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"
47 #include "tree-mudflap.h"
50 cpp_reader *parse_in; /* Declared in c-pragma.h. */
52 /* We let tm.h override the types used here, to handle trivial differences
53 such as the choice of unsigned int or long unsigned int for size_t.
54 When machines start needing nontrivial differences in the size type,
55 it would be best to do something here to figure out automatically
56 from other information what type to use. */
59 #define SIZE_TYPE "long unsigned int"
63 #define PID_TYPE "int"
67 #define WCHAR_TYPE "int"
70 /* WCHAR_TYPE gets overridden by -fshort-wchar. */
71 #define MODIFIED_WCHAR_TYPE \
72 (flag_short_wchar ? "short unsigned int" : WCHAR_TYPE)
75 #define PTRDIFF_TYPE "long int"
79 #define WINT_TYPE "unsigned int"
83 #define INTMAX_TYPE ((INT_TYPE_SIZE == LONG_LONG_TYPE_SIZE) \
85 : ((LONG_TYPE_SIZE == LONG_LONG_TYPE_SIZE) \
91 #define UINTMAX_TYPE ((INT_TYPE_SIZE == LONG_LONG_TYPE_SIZE) \
93 : ((LONG_TYPE_SIZE == LONG_LONG_TYPE_SIZE) \
94 ? "long unsigned int" \
95 : "long long unsigned int"))
98 /* The following symbols are subsumed in the c_global_trees array, and
99 listed here individually for documentation purposes.
101 INTEGER_TYPE and REAL_TYPE nodes for the standard data types.
103 tree short_integer_type_node;
104 tree long_integer_type_node;
105 tree long_long_integer_type_node;
107 tree short_unsigned_type_node;
108 tree long_unsigned_type_node;
109 tree long_long_unsigned_type_node;
111 tree truthvalue_type_node;
112 tree truthvalue_false_node;
113 tree truthvalue_true_node;
115 tree ptrdiff_type_node;
117 tree unsigned_char_type_node;
118 tree signed_char_type_node;
119 tree wchar_type_node;
120 tree signed_wchar_type_node;
121 tree unsigned_wchar_type_node;
123 tree float_type_node;
124 tree double_type_node;
125 tree long_double_type_node;
127 tree complex_integer_type_node;
128 tree complex_float_type_node;
129 tree complex_double_type_node;
130 tree complex_long_double_type_node;
132 tree intQI_type_node;
133 tree intHI_type_node;
134 tree intSI_type_node;
135 tree intDI_type_node;
136 tree intTI_type_node;
138 tree unsigned_intQI_type_node;
139 tree unsigned_intHI_type_node;
140 tree unsigned_intSI_type_node;
141 tree unsigned_intDI_type_node;
142 tree unsigned_intTI_type_node;
144 tree widest_integer_literal_type_node;
145 tree widest_unsigned_literal_type_node;
147 Nodes for types `void *' and `const void *'.
149 tree ptr_type_node, const_ptr_type_node;
151 Nodes for types `char *' and `const char *'.
153 tree string_type_node, const_string_type_node;
155 Type `char[SOMENUMBER]'.
156 Used when an array of char is needed and the size is irrelevant.
158 tree char_array_type_node;
160 Type `int[SOMENUMBER]' or something like it.
161 Used when an array of int needed and the size is irrelevant.
163 tree int_array_type_node;
165 Type `wchar_t[SOMENUMBER]' or something like it.
166 Used when a wide string literal is created.
168 tree wchar_array_type_node;
170 Type `int ()' -- used for implicit declaration of functions.
172 tree default_function_type;
174 A VOID_TYPE node, packaged in a TREE_LIST.
178 The lazily created VAR_DECLs for __FUNCTION__, __PRETTY_FUNCTION__,
179 and __func__. (C doesn't generate __FUNCTION__ and__PRETTY_FUNCTION__
180 VAR_DECLS, but C++ does.)
182 tree function_name_decl_node;
183 tree pretty_function_name_decl_node;
184 tree c99_function_name_decl_node;
186 Stack of nested function name VAR_DECLs.
188 tree saved_function_name_decls;
192 tree c_global_trees[CTI_MAX];
194 /* TRUE if a code represents a statement. The front end init
195 langhook should take care of initialization of this array. */
197 bool statement_code_p[MAX_TREE_CODES];
199 /* Switches common to the C front ends. */
201 /* Nonzero if prepreprocessing only. */
203 int flag_preprocess_only;
205 /* Nonzero means don't output line number information. */
207 char flag_no_line_commands;
209 /* Nonzero causes -E output not to be done, but directives such as
210 #define that have side effects are still obeyed. */
214 /* Nonzero means dump macros in some fashion. */
216 char flag_dump_macros;
218 /* Nonzero means pass #include lines through to the output. */
220 char flag_dump_includes;
222 /* Nonzero means process PCH files while preprocessing. */
224 bool flag_pch_preprocess;
226 /* The file name to which we should write a precompiled header, or
227 NULL if no header will be written in this compile. */
229 const char *pch_file;
231 /* Nonzero if an ISO standard was selected. It rejects macros in the
235 /* Nonzero if -undef was given. It suppresses target built-in macros
239 /* Nonzero means don't recognize the non-ANSI builtin functions. */
243 /* Nonzero means don't recognize the non-ANSI builtin functions.
246 int flag_no_nonansi_builtin;
248 /* Nonzero means give `double' the same size as `float'. */
250 int flag_short_double;
252 /* Nonzero means give `wchar_t' the same size as `short'. */
254 int flag_short_wchar;
256 /* Nonzero means allow Microsoft extensions without warnings or errors. */
257 int flag_ms_extensions;
259 /* Nonzero means don't recognize the keyword `asm'. */
263 /* Nonzero means give string constants the type `const char *', as mandated
266 int flag_const_strings;
268 /* Nonzero means to treat bitfields as signed unless they say `unsigned'. */
270 int flag_signed_bitfields = 1;
271 int explicit_flag_signed_bitfields;
273 /* Nonzero means warn about deprecated conversion from string constant to
276 int warn_write_strings;
278 /* Warn about #pragma directives that are not recognized. */
280 int warn_unknown_pragmas; /* Tri state variable. */
282 /* Warn about format/argument anomalies in calls to formatted I/O functions
283 (*printf, *scanf, strftime, strfmon, etc.). */
287 /* Zero means that faster, ...NonNil variants of objc_msgSend...
288 calls will be used in ObjC; passing nil receivers to such calls
289 will most likely result in crashes. */
290 int flag_nil_receivers = 1;
292 /* Nonzero means that we will allow new ObjC exception syntax (@throw,
293 @try, etc.) in source code. */
294 int flag_objc_exceptions = 0;
296 /* Nonzero means that we generate NeXT setjmp based exceptions. */
297 int flag_objc_sjlj_exceptions = -1;
299 /* Nonzero means that code generation will be altered to support
300 "zero-link" execution. This currently affects ObjC only, but may
301 affect other languages in the future. */
302 int flag_zero_link = 0;
304 /* Nonzero means emit an '__OBJC, __image_info' for the current translation
305 unit. It will inform the ObjC runtime that class definition(s) herein
306 contained are to replace one(s) previously loaded. */
307 int flag_replace_objc_classes = 0;
309 /* C/ObjC language option variables. */
312 /* Nonzero means allow type mismatches in conditional expressions;
313 just make their values `void'. */
315 int flag_cond_mismatch;
317 /* Nonzero means enable C89 Amendment 1 features. */
321 /* Nonzero means use the ISO C99 dialect of C. */
325 /* Nonzero means that we have builtin functions, and main is an int. */
329 /* Warn if main is suspicious. */
334 /* ObjC language option variables. */
337 /* Open and close the file for outputting class declarations, if
340 int flag_gen_declaration;
342 /* Generate code for GNU or NeXT runtime environment. */
344 #ifdef NEXT_OBJC_RUNTIME
345 int flag_next_runtime = 1;
347 int flag_next_runtime = 0;
350 /* Tells the compiler that this is a special run. Do not perform any
351 compiling, instead we are to test some platform dependent features
352 and output a C header file with appropriate definitions. */
354 int print_struct_values;
356 /* ???. Undocumented. */
358 const char *constant_string_class_name;
361 /* C++ language option variables. */
364 /* Nonzero means don't recognize any extension keywords. */
366 int flag_no_gnu_keywords;
368 /* Nonzero means do emit exported implementations of functions even if
369 they can be inlined. */
371 int flag_implement_inlines = 1;
373 /* Nonzero means that implicit instantiations will be emitted if needed. */
375 int flag_implicit_templates = 1;
377 /* Nonzero means that implicit instantiations of inline templates will be
378 emitted if needed, even if instantiations of non-inline templates
381 int flag_implicit_inline_templates = 1;
383 /* Nonzero means generate separate instantiation control files and
384 juggle them at link time. */
386 int flag_use_repository;
388 /* Nonzero if we want to issue diagnostics that the standard says are not
391 int flag_optional_diags = 1;
393 /* Nonzero means we should attempt to elide constructors when possible. */
395 int flag_elide_constructors = 1;
397 /* Nonzero means that member functions defined in class scope are
398 inline by default. */
400 int flag_default_inline = 1;
402 /* Controls whether compiler generates 'type descriptor' that give
403 run-time type information. */
407 /* Nonzero if we want to conserve space in the .o files. We do this
408 by putting uninitialized data and runtime initialized data into
409 .common instead of .data at the expense of not flagging multiple
412 int flag_conserve_space;
414 /* Nonzero if we want to obey access control semantics. */
416 int flag_access_control = 1;
418 /* Nonzero if we want to check the return value of new and avoid calling
419 constructors if it is a null pointer. */
423 /* Nonzero if we want the new ISO rules for pushing a new scope for `for'
424 initialization variables.
425 0: Old rules, set by -fno-for-scope.
426 2: New ISO rules, set by -ffor-scope.
427 1: Try to implement new ISO rules, but with backup compatibility
428 (and warnings). This is the default, for now. */
430 int flag_new_for_scope = 1;
432 /* Nonzero if we want to emit defined symbols with common-like linkage as
433 weak symbols where possible, in order to conform to C++ semantics.
434 Otherwise, emit them as local symbols. */
438 /* 0 means we want the preprocessor to not emit line directives for
439 the current working directory. 1 means we want it to do it. -1
440 means we should decide depending on whether debugging information
441 is being emitted or not. */
443 int flag_working_directory = -1;
445 /* Nonzero to use __cxa_atexit, rather than atexit, to register
446 destructors for local statics and global objects. */
448 int flag_use_cxa_atexit = DEFAULT_USE_CXA_ATEXIT;
450 /* Nonzero means make the default pedwarns warnings instead of errors.
451 The value of this flag is ignored if -pedantic is specified. */
455 /* Nonzero means to implement standard semantics for exception
456 specifications, calling unexpected if an exception is thrown that
457 doesn't match the specification. Zero means to treat them as
458 assertions and optimize accordingly, but not check them. */
460 int flag_enforce_eh_specs = 1;
462 /* Nonzero means warn about implicit declarations. */
464 int warn_implicit = 1;
466 /* Maximum template instantiation depth. This limit is rather
467 arbitrary, but it exists to limit the time it takes to notice
468 infinite template instantiations. */
470 int max_tinst_depth = 500;
474 /* The elements of `ridpointers' are identifier nodes for the reserved
475 type names and storage classes. It is indexed by a RID_... value. */
478 tree (*make_fname_decl) (tree, int);
480 /* If non-NULL, the address of a language-specific function that
481 returns 1 for language-specific statement codes. */
482 int (*lang_statement_code_p) (enum tree_code);
484 /* If non-NULL, the address of a language-specific function that takes
485 any action required right before expand_function_end is called. */
486 void (*lang_expand_function_end) (void);
488 /* Nonzero means the expression being parsed will never be evaluated.
489 This is a count, since unevaluated expressions can nest. */
492 /* Information about how a function name is generated. */
495 tree *const decl; /* pointer to the VAR_DECL. */
496 const unsigned rid; /* RID number for the identifier. */
497 const int pretty; /* How pretty is it? */
500 /* The three ways of getting then name of the current function. */
502 const struct fname_var_t fname_vars[] =
504 /* C99 compliant __func__, must be first. */
505 {&c99_function_name_decl_node, RID_C99_FUNCTION_NAME, 0},
506 /* GCC __FUNCTION__ compliant. */
507 {&function_name_decl_node, RID_FUNCTION_NAME, 0},
508 /* GCC __PRETTY_FUNCTION__ compliant. */
509 {&pretty_function_name_decl_node, RID_PRETTY_FUNCTION_NAME, 1},
513 static int constant_fits_type_p (tree, tree);
514 static tree check_case_value (tree);
515 static bool check_case_bounds (tree, tree, tree *, tree *);
517 static tree handle_packed_attribute (tree *, tree, tree, int, bool *);
518 static tree handle_nocommon_attribute (tree *, tree, tree, int, bool *);
519 static tree handle_common_attribute (tree *, tree, tree, int, bool *);
520 static tree handle_noreturn_attribute (tree *, tree, tree, int, bool *);
521 static tree handle_noinline_attribute (tree *, tree, tree, int, bool *);
522 static tree handle_always_inline_attribute (tree *, tree, tree, int,
524 static tree handle_used_attribute (tree *, tree, tree, int, bool *);
525 static tree handle_unused_attribute (tree *, tree, tree, int, bool *);
526 static tree handle_const_attribute (tree *, tree, tree, int, bool *);
527 static tree handle_transparent_union_attribute (tree *, tree, tree,
529 static tree handle_constructor_attribute (tree *, tree, tree, int, bool *);
530 static tree handle_destructor_attribute (tree *, tree, tree, int, bool *);
531 static tree handle_mode_attribute (tree *, tree, tree, int, bool *);
532 static tree handle_section_attribute (tree *, tree, tree, int, bool *);
533 static tree handle_aligned_attribute (tree *, tree, tree, int, bool *);
534 static tree handle_weak_attribute (tree *, tree, tree, int, bool *) ;
535 static tree handle_alias_attribute (tree *, tree, tree, int, bool *);
536 static tree handle_visibility_attribute (tree *, tree, tree, int,
538 static tree handle_tls_model_attribute (tree *, tree, tree, int,
540 static tree handle_no_instrument_function_attribute (tree *, tree,
542 static tree handle_malloc_attribute (tree *, tree, tree, int, bool *);
543 static tree handle_no_limit_stack_attribute (tree *, tree, tree, int,
545 static tree handle_pure_attribute (tree *, tree, tree, int, bool *);
546 static tree handle_deprecated_attribute (tree *, tree, tree, int,
548 static tree handle_vector_size_attribute (tree *, tree, tree, int,
550 static tree handle_nonnull_attribute (tree *, tree, tree, int, bool *);
551 static tree handle_nothrow_attribute (tree *, tree, tree, int, bool *);
552 static tree handle_cleanup_attribute (tree *, tree, tree, int, bool *);
553 static tree handle_warn_unused_result_attribute (tree *, tree, tree, int,
556 static void check_function_nonnull (tree, tree);
557 static void check_nonnull_arg (void *, tree, unsigned HOST_WIDE_INT);
558 static bool nonnull_check_p (tree, unsigned HOST_WIDE_INT);
559 static bool get_nonnull_operand (tree, unsigned HOST_WIDE_INT *);
560 static int resort_field_decl_cmp (const void *, const void *);
562 /* Table of machine-independent attributes common to all C-like languages. */
563 const struct attribute_spec c_common_attribute_table[] =
565 /* { name, min_len, max_len, decl_req, type_req, fn_type_req, handler } */
566 { "packed", 0, 0, false, false, false,
567 handle_packed_attribute },
568 { "nocommon", 0, 0, true, false, false,
569 handle_nocommon_attribute },
570 { "common", 0, 0, true, false, false,
571 handle_common_attribute },
572 /* FIXME: logically, noreturn attributes should be listed as
573 "false, true, true" and apply to function types. But implementing this
574 would require all the places in the compiler that use TREE_THIS_VOLATILE
575 on a decl to identify non-returning functions to be located and fixed
576 to check the function type instead. */
577 { "noreturn", 0, 0, true, false, false,
578 handle_noreturn_attribute },
579 { "volatile", 0, 0, true, false, false,
580 handle_noreturn_attribute },
581 { "noinline", 0, 0, true, false, false,
582 handle_noinline_attribute },
583 { "always_inline", 0, 0, true, false, false,
584 handle_always_inline_attribute },
585 { "used", 0, 0, true, false, false,
586 handle_used_attribute },
587 { "unused", 0, 0, false, false, false,
588 handle_unused_attribute },
589 /* The same comments as for noreturn attributes apply to const ones. */
590 { "const", 0, 0, true, false, false,
591 handle_const_attribute },
592 { "transparent_union", 0, 0, false, false, false,
593 handle_transparent_union_attribute },
594 { "constructor", 0, 0, true, false, false,
595 handle_constructor_attribute },
596 { "destructor", 0, 0, true, false, false,
597 handle_destructor_attribute },
598 { "mode", 1, 1, false, true, false,
599 handle_mode_attribute },
600 { "section", 1, 1, true, false, false,
601 handle_section_attribute },
602 { "aligned", 0, 1, false, false, false,
603 handle_aligned_attribute },
604 { "weak", 0, 0, true, false, false,
605 handle_weak_attribute },
606 { "alias", 1, 1, true, false, false,
607 handle_alias_attribute },
608 { "no_instrument_function", 0, 0, true, false, false,
609 handle_no_instrument_function_attribute },
610 { "malloc", 0, 0, true, false, false,
611 handle_malloc_attribute },
612 { "no_stack_limit", 0, 0, true, false, false,
613 handle_no_limit_stack_attribute },
614 { "pure", 0, 0, true, false, false,
615 handle_pure_attribute },
616 { "deprecated", 0, 0, false, false, false,
617 handle_deprecated_attribute },
618 { "vector_size", 1, 1, false, true, false,
619 handle_vector_size_attribute },
620 { "visibility", 1, 1, false, false, false,
621 handle_visibility_attribute },
622 { "tls_model", 1, 1, true, false, false,
623 handle_tls_model_attribute },
624 { "nonnull", 0, -1, false, true, true,
625 handle_nonnull_attribute },
626 { "nothrow", 0, 0, true, false, false,
627 handle_nothrow_attribute },
628 { "may_alias", 0, 0, false, true, false, NULL },
629 { "cleanup", 1, 1, true, false, false,
630 handle_cleanup_attribute },
631 { "warn_unused_result", 0, 0, false, true, true,
632 handle_warn_unused_result_attribute },
633 { NULL, 0, 0, false, false, false, NULL }
636 /* Give the specifications for the format attributes, used by C and all
639 const struct attribute_spec c_common_format_attribute_table[] =
641 /* { name, min_len, max_len, decl_req, type_req, fn_type_req, handler } */
642 { "format", 3, 3, false, true, true,
643 handle_format_attribute },
644 { "format_arg", 1, 1, false, true, true,
645 handle_format_arg_attribute },
646 { NULL, 0, 0, false, false, false, NULL }
649 /* Push current bindings for the function name VAR_DECLS. */
652 start_fname_decls (void)
655 tree saved = NULL_TREE;
657 for (ix = 0; fname_vars[ix].decl; ix++)
659 tree decl = *fname_vars[ix].decl;
663 saved = tree_cons (decl, build_int_2 (ix, 0), saved);
664 *fname_vars[ix].decl = NULL_TREE;
667 if (saved || saved_function_name_decls)
668 /* Normally they'll have been NULL, so only push if we've got a
669 stack, or they are non-NULL. */
670 saved_function_name_decls = tree_cons (saved, NULL_TREE,
671 saved_function_name_decls);
674 /* Finish up the current bindings, adding them into the current function's
675 statement tree. This must be done _before_ finish_stmt_tree is called.
676 If there is no current function, we must be at file scope and no statements
677 are involved. Pop the previous bindings. */
680 finish_fname_decls (void)
683 tree stmts = NULL_TREE;
684 tree stack = saved_function_name_decls;
686 for (; stack && TREE_VALUE (stack); stack = TREE_CHAIN (stack))
687 append_to_statement_list (TREE_VALUE (stack), &stmts);
691 tree *bodyp = &DECL_SAVED_TREE (current_function_decl);
693 if (TREE_CODE (*bodyp) == BIND_EXPR)
694 bodyp = &BIND_EXPR_BODY (*bodyp);
696 append_to_statement_list (*bodyp, &stmts);
700 for (ix = 0; fname_vars[ix].decl; ix++)
701 *fname_vars[ix].decl = NULL_TREE;
705 /* We had saved values, restore them. */
708 for (saved = TREE_PURPOSE (stack); saved; saved = TREE_CHAIN (saved))
710 tree decl = TREE_PURPOSE (saved);
711 unsigned ix = TREE_INT_CST_LOW (TREE_VALUE (saved));
713 *fname_vars[ix].decl = decl;
715 stack = TREE_CHAIN (stack);
717 saved_function_name_decls = stack;
720 /* Return the text name of the current function, suitably prettified
721 by PRETTY_P. Return string must be freed by caller. */
724 fname_as_string (int pretty_p)
726 const char *name = "top level";
736 if (current_function_decl)
737 name = lang_hooks.decl_printable_name (current_function_decl, vrb);
739 if (c_lex_string_translate)
741 int len = strlen (name) + 3; /* Two for '"'s. One for NULL. */
742 cpp_string cstr = { 0, 0 }, strname;
744 namep = XNEWVEC (char, len);
745 snprintf (namep, len, "\"%s\"", name);
746 strname.text = (unsigned char *) namep;
747 strname.len = len - 1;
749 if (cpp_interpret_string (parse_in, &strname, 1, &cstr, false))
750 return (char *) cstr.text;
753 namep = xstrdup (name);
758 /* Expand DECL if it declares an entity not handled by the
762 c_expand_decl (tree decl)
764 if (TREE_CODE (decl) == VAR_DECL && !TREE_STATIC (decl))
766 /* Let the back-end know about this variable. */
767 if (!anon_aggr_type_p (TREE_TYPE (decl)))
768 emit_local_var (decl);
770 expand_anon_union_decl (decl, NULL_TREE,
771 DECL_ANON_UNION_ELEMS (decl));
773 else if (TREE_CODE (decl) == VAR_DECL && TREE_STATIC (decl))
774 make_rtl_for_local_static (decl);
782 /* Return the VAR_DECL for a const char array naming the current
783 function. If the VAR_DECL has not yet been created, create it
784 now. RID indicates how it should be formatted and IDENTIFIER_NODE
785 ID is its name (unfortunately C and C++ hold the RID values of
786 keywords in different places, so we can't derive RID from ID in
787 this language independent code. */
790 fname_decl (unsigned int rid, tree id)
793 tree decl = NULL_TREE;
795 for (ix = 0; fname_vars[ix].decl; ix++)
796 if (fname_vars[ix].rid == rid)
799 decl = *fname_vars[ix].decl;
802 /* If a tree is built here, it would normally have the lineno of
803 the current statement. Later this tree will be moved to the
804 beginning of the function and this line number will be wrong.
805 To avoid this problem set the lineno to 0 here; that prevents
806 it from appearing in the RTL. */
808 location_t saved_location = input_location;
809 #ifdef USE_MAPPED_LOCATION
810 input_location = UNKNOWN_LOCATION;
815 stmts = push_stmt_list ();
816 decl = (*make_fname_decl) (id, fname_vars[ix].pretty);
817 stmts = pop_stmt_list (stmts);
818 if (!IS_EMPTY_STMT (stmts))
819 saved_function_name_decls
820 = tree_cons (decl, stmts, saved_function_name_decls);
821 *fname_vars[ix].decl = decl;
822 input_location = saved_location;
824 if (!ix && !current_function_decl)
825 pedwarn ("%J'%D' is not defined outside of function scope", decl, decl);
830 /* Given a STRING_CST, give it a suitable array-of-chars data type. */
833 fix_string_type (tree value)
835 const int wchar_bytes = TYPE_PRECISION (wchar_type_node) / BITS_PER_UNIT;
836 const int wide_flag = TREE_TYPE (value) == wchar_array_type_node;
837 const int nchars_max = flag_isoc99 ? 4095 : 509;
838 int length = TREE_STRING_LENGTH (value);
841 /* Compute the number of elements, for the array type. */
842 nchars = wide_flag ? length / wchar_bytes : length;
844 if (pedantic && nchars - 1 > nchars_max && !c_dialect_cxx ())
845 pedwarn ("string length `%d' is greater than the length `%d' ISO C%d compilers are required to support",
846 nchars - 1, nchars_max, flag_isoc99 ? 99 : 89);
848 /* Create the array type for the string constant.
849 -Wwrite-strings says make the string constant an array of const char
850 so that copying it to a non-const pointer will get a warning.
851 For C++, this is the standard behavior. */
852 if (flag_const_strings)
855 = build_type_variant (wide_flag ? wchar_type_node : char_type_node,
858 = build_array_type (elements,
859 build_index_type (build_int_2 (nchars - 1, 0)));
863 = build_array_type (wide_flag ? wchar_type_node : char_type_node,
864 build_index_type (build_int_2 (nchars - 1, 0)));
866 TREE_CONSTANT (value) = 1;
867 TREE_INVARIANT (value) = 1;
868 TREE_READONLY (value) = 1;
869 TREE_STATIC (value) = 1;
873 /* Print a warning if a constant expression had overflow in folding.
874 Invoke this function on every expression that the language
875 requires to be a constant expression.
876 Note the ANSI C standard says it is erroneous for a
877 constant expression to overflow. */
880 constant_expression_warning (tree value)
882 if ((TREE_CODE (value) == INTEGER_CST || TREE_CODE (value) == REAL_CST
883 || TREE_CODE (value) == VECTOR_CST
884 || TREE_CODE (value) == COMPLEX_CST)
885 && TREE_CONSTANT_OVERFLOW (value) && pedantic)
886 pedwarn ("overflow in constant expression");
889 /* Print a warning if an expression had overflow in folding.
890 Invoke this function on every expression that
891 (1) appears in the source code, and
892 (2) might be a constant expression that overflowed, and
893 (3) is not already checked by convert_and_check;
894 however, do not invoke this function on operands of explicit casts. */
897 overflow_warning (tree value)
899 if ((TREE_CODE (value) == INTEGER_CST
900 || (TREE_CODE (value) == COMPLEX_CST
901 && TREE_CODE (TREE_REALPART (value)) == INTEGER_CST))
902 && TREE_OVERFLOW (value))
904 TREE_OVERFLOW (value) = 0;
905 if (skip_evaluation == 0)
906 warning ("integer overflow in expression");
908 else if ((TREE_CODE (value) == REAL_CST
909 || (TREE_CODE (value) == COMPLEX_CST
910 && TREE_CODE (TREE_REALPART (value)) == REAL_CST))
911 && TREE_OVERFLOW (value))
913 TREE_OVERFLOW (value) = 0;
914 if (skip_evaluation == 0)
915 warning ("floating point overflow in expression");
917 else if (TREE_CODE (value) == VECTOR_CST && TREE_OVERFLOW (value))
919 TREE_OVERFLOW (value) = 0;
920 if (skip_evaluation == 0)
921 warning ("vector overflow in expression");
925 /* Print a warning if a large constant is truncated to unsigned,
926 or if -Wconversion is used and a constant < 0 is converted to unsigned.
927 Invoke this function on every expression that might be implicitly
928 converted to an unsigned type. */
931 unsigned_conversion_warning (tree result, tree operand)
933 tree type = TREE_TYPE (result);
935 if (TREE_CODE (operand) == INTEGER_CST
936 && TREE_CODE (type) == INTEGER_TYPE
937 && TYPE_UNSIGNED (type)
938 && skip_evaluation == 0
939 && !int_fits_type_p (operand, type))
941 if (!int_fits_type_p (operand, c_common_signed_type (type)))
942 /* This detects cases like converting -129 or 256 to unsigned char. */
943 warning ("large integer implicitly truncated to unsigned type");
944 else if (warn_conversion)
945 warning ("negative integer implicitly converted to unsigned type");
949 /* Nonzero if constant C has a value that is permissible
950 for type TYPE (an INTEGER_TYPE). */
953 constant_fits_type_p (tree c, tree type)
955 if (TREE_CODE (c) == INTEGER_CST)
956 return int_fits_type_p (c, type);
958 c = convert (type, c);
959 return !TREE_OVERFLOW (c);
962 /* Nonzero if vector types T1 and T2 can be converted to each other
963 without an explicit cast. */
965 vector_types_convertible_p (tree t1, tree t2)
967 return targetm.vector_opaque_p (t1)
968 || targetm.vector_opaque_p (t2)
969 || (tree_int_cst_equal (TYPE_SIZE (t1), TYPE_SIZE (t2))
970 && INTEGRAL_TYPE_P (TREE_TYPE (t1))
971 == INTEGRAL_TYPE_P (TREE_TYPE (t2)));
974 /* Convert EXPR to TYPE, warning about conversion problems with constants.
975 Invoke this function on every expression that is converted implicitly,
976 i.e. because of language rules and not because of an explicit cast. */
979 convert_and_check (tree type, tree expr)
981 tree t = convert (type, expr);
982 if (TREE_CODE (t) == INTEGER_CST)
984 if (TREE_OVERFLOW (t))
986 TREE_OVERFLOW (t) = 0;
988 /* Do not diagnose overflow in a constant expression merely
989 because a conversion overflowed. */
990 TREE_CONSTANT_OVERFLOW (t) = TREE_CONSTANT_OVERFLOW (expr);
992 /* No warning for converting 0x80000000 to int. */
993 if (!(TYPE_UNSIGNED (type) < TYPE_UNSIGNED (TREE_TYPE (expr))
994 && TREE_CODE (TREE_TYPE (expr)) == INTEGER_TYPE
995 && TYPE_PRECISION (type) == TYPE_PRECISION (TREE_TYPE (expr))))
996 /* If EXPR fits in the unsigned version of TYPE,
997 don't warn unless pedantic. */
999 || TYPE_UNSIGNED (type)
1000 || ! constant_fits_type_p (expr,
1001 c_common_unsigned_type (type)))
1002 && skip_evaluation == 0)
1003 warning ("overflow in implicit constant conversion");
1006 unsigned_conversion_warning (t, expr);
1011 /* A node in a list that describes references to variables (EXPR), which are
1012 either read accesses if WRITER is zero, or write accesses, in which case
1013 WRITER is the parent of EXPR. */
1020 /* Used to implement a cache the results of a call to verify_tree. We only
1021 use this for SAVE_EXPRs. */
1024 struct tlist_cache *next;
1025 struct tlist *cache_before_sp;
1026 struct tlist *cache_after_sp;
1030 /* Obstack to use when allocating tlist structures, and corresponding
1032 static struct obstack tlist_obstack;
1033 static char *tlist_firstobj = 0;
1035 /* Keep track of the identifiers we've warned about, so we can avoid duplicate
1037 static struct tlist *warned_ids;
1038 /* SAVE_EXPRs need special treatment. We process them only once and then
1039 cache the results. */
1040 static struct tlist_cache *save_expr_cache;
1042 static void add_tlist (struct tlist **, struct tlist *, tree, int);
1043 static void merge_tlist (struct tlist **, struct tlist *, int);
1044 static void verify_tree (tree, struct tlist **, struct tlist **, tree);
1045 static int warning_candidate_p (tree);
1046 static void warn_for_collisions (struct tlist *);
1047 static void warn_for_collisions_1 (tree, tree, struct tlist *, int);
1048 static struct tlist *new_tlist (struct tlist *, tree, tree);
1050 /* Create a new struct tlist and fill in its fields. */
1051 static struct tlist *
1052 new_tlist (struct tlist *next, tree t, tree writer)
1055 l = XOBNEW (&tlist_obstack, struct tlist);
1062 /* Add duplicates of the nodes found in ADD to the list *TO. If EXCLUDE_WRITER
1063 is nonnull, we ignore any node we find which has a writer equal to it. */
1066 add_tlist (struct tlist **to, struct tlist *add, tree exclude_writer, int copy)
1070 struct tlist *next = add->next;
1073 if (! exclude_writer || add->writer != exclude_writer)
1074 *to = copy ? new_tlist (*to, add->expr, add->writer) : add;
1079 /* Merge the nodes of ADD into TO. This merging process is done so that for
1080 each variable that already exists in TO, no new node is added; however if
1081 there is a write access recorded in ADD, and an occurrence on TO is only
1082 a read access, then the occurrence in TO will be modified to record the
1086 merge_tlist (struct tlist **to, struct tlist *add, int copy)
1088 struct tlist **end = to;
1091 end = &(*end)->next;
1097 struct tlist *next = add->next;
1099 for (tmp2 = *to; tmp2; tmp2 = tmp2->next)
1100 if (tmp2->expr == add->expr)
1104 tmp2->writer = add->writer;
1108 *end = copy ? add : new_tlist (NULL, add->expr, add->writer);
1109 end = &(*end)->next;
1116 /* WRITTEN is a variable, WRITER is its parent. Warn if any of the variable
1117 references in list LIST conflict with it, excluding reads if ONLY writers
1121 warn_for_collisions_1 (tree written, tree writer, struct tlist *list,
1126 /* Avoid duplicate warnings. */
1127 for (tmp = warned_ids; tmp; tmp = tmp->next)
1128 if (tmp->expr == written)
1133 if (list->expr == written
1134 && list->writer != writer
1135 && (! only_writes || list->writer)
1136 && DECL_NAME (list->expr))
1138 warned_ids = new_tlist (warned_ids, written, NULL_TREE);
1139 warning ("operation on `%s' may be undefined",
1140 IDENTIFIER_POINTER (DECL_NAME (list->expr)));
1146 /* Given a list LIST of references to variables, find whether any of these
1147 can cause conflicts due to missing sequence points. */
1150 warn_for_collisions (struct tlist *list)
1154 for (tmp = list; tmp; tmp = tmp->next)
1157 warn_for_collisions_1 (tmp->expr, tmp->writer, list, 0);
1161 /* Return nonzero if X is a tree that can be verified by the sequence point
1164 warning_candidate_p (tree x)
1166 return TREE_CODE (x) == VAR_DECL || TREE_CODE (x) == PARM_DECL;
1169 /* Walk the tree X, and record accesses to variables. If X is written by the
1170 parent tree, WRITER is the parent.
1171 We store accesses in one of the two lists: PBEFORE_SP, and PNO_SP. If this
1172 expression or its only operand forces a sequence point, then everything up
1173 to the sequence point is stored in PBEFORE_SP. Everything else gets stored
1175 Once we return, we will have emitted warnings if any subexpression before
1176 such a sequence point could be undefined. On a higher level, however, the
1177 sequence point may not be relevant, and we'll merge the two lists.
1179 Example: (b++, a) + b;
1180 The call that processes the COMPOUND_EXPR will store the increment of B
1181 in PBEFORE_SP, and the use of A in PNO_SP. The higher-level call that
1182 processes the PLUS_EXPR will need to merge the two lists so that
1183 eventually, all accesses end up on the same list (and we'll warn about the
1184 unordered subexpressions b++ and b.
1186 A note on merging. If we modify the former example so that our expression
1189 care must be taken not simply to add all three expressions into the final
1190 PNO_SP list. The function merge_tlist takes care of that by merging the
1191 before-SP list of the COMPOUND_EXPR into its after-SP list in a special
1192 way, so that no more than one access to B is recorded. */
1195 verify_tree (tree x, struct tlist **pbefore_sp, struct tlist **pno_sp,
1198 struct tlist *tmp_before, *tmp_nosp, *tmp_list2, *tmp_list3;
1199 enum tree_code code;
1202 /* X may be NULL if it is the operand of an empty statement expression
1208 code = TREE_CODE (x);
1209 cl = TREE_CODE_CLASS (code);
1211 if (warning_candidate_p (x))
1213 *pno_sp = new_tlist (*pno_sp, x, writer);
1223 case TRUTH_ANDIF_EXPR:
1224 case TRUTH_ORIF_EXPR:
1225 tmp_before = tmp_nosp = tmp_list3 = 0;
1226 verify_tree (TREE_OPERAND (x, 0), &tmp_before, &tmp_nosp, NULL_TREE);
1227 warn_for_collisions (tmp_nosp);
1228 merge_tlist (pbefore_sp, tmp_before, 0);
1229 merge_tlist (pbefore_sp, tmp_nosp, 0);
1230 verify_tree (TREE_OPERAND (x, 1), &tmp_list3, pno_sp, NULL_TREE);
1231 merge_tlist (pbefore_sp, tmp_list3, 0);
1235 tmp_before = tmp_list2 = 0;
1236 verify_tree (TREE_OPERAND (x, 0), &tmp_before, &tmp_list2, NULL_TREE);
1237 warn_for_collisions (tmp_list2);
1238 merge_tlist (pbefore_sp, tmp_before, 0);
1239 merge_tlist (pbefore_sp, tmp_list2, 1);
1241 tmp_list3 = tmp_nosp = 0;
1242 verify_tree (TREE_OPERAND (x, 1), &tmp_list3, &tmp_nosp, NULL_TREE);
1243 warn_for_collisions (tmp_nosp);
1244 merge_tlist (pbefore_sp, tmp_list3, 0);
1246 tmp_list3 = tmp_list2 = 0;
1247 verify_tree (TREE_OPERAND (x, 2), &tmp_list3, &tmp_list2, NULL_TREE);
1248 warn_for_collisions (tmp_list2);
1249 merge_tlist (pbefore_sp, tmp_list3, 0);
1250 /* Rather than add both tmp_nosp and tmp_list2, we have to merge the
1251 two first, to avoid warning for (a ? b++ : b++). */
1252 merge_tlist (&tmp_nosp, tmp_list2, 0);
1253 add_tlist (pno_sp, tmp_nosp, NULL_TREE, 0);
1256 case PREDECREMENT_EXPR:
1257 case PREINCREMENT_EXPR:
1258 case POSTDECREMENT_EXPR:
1259 case POSTINCREMENT_EXPR:
1260 verify_tree (TREE_OPERAND (x, 0), pno_sp, pno_sp, x);
1264 tmp_before = tmp_nosp = tmp_list3 = 0;
1265 verify_tree (TREE_OPERAND (x, 1), &tmp_before, &tmp_nosp, NULL_TREE);
1266 verify_tree (TREE_OPERAND (x, 0), &tmp_list3, &tmp_list3, x);
1267 /* Expressions inside the LHS are not ordered wrt. the sequence points
1268 in the RHS. Example:
1270 Despite the fact that the modification of "a" is in the before_sp
1271 list (tmp_before), it conflicts with the use of "a" in the LHS.
1272 We can handle this by adding the contents of tmp_list3
1273 to those of tmp_before, and redoing the collision warnings for that
1275 add_tlist (&tmp_before, tmp_list3, x, 1);
1276 warn_for_collisions (tmp_before);
1277 /* Exclude the LHS itself here; we first have to merge it into the
1278 tmp_nosp list. This is done to avoid warning for "a = a"; if we
1279 didn't exclude the LHS, we'd get it twice, once as a read and once
1281 add_tlist (pno_sp, tmp_list3, x, 0);
1282 warn_for_collisions_1 (TREE_OPERAND (x, 0), x, tmp_nosp, 1);
1284 merge_tlist (pbefore_sp, tmp_before, 0);
1285 if (warning_candidate_p (TREE_OPERAND (x, 0)))
1286 merge_tlist (&tmp_nosp, new_tlist (NULL, TREE_OPERAND (x, 0), x), 0);
1287 add_tlist (pno_sp, tmp_nosp, NULL_TREE, 1);
1291 /* We need to warn about conflicts among arguments and conflicts between
1292 args and the function address. Side effects of the function address,
1293 however, are not ordered by the sequence point of the call. */
1294 tmp_before = tmp_nosp = tmp_list2 = tmp_list3 = 0;
1295 verify_tree (TREE_OPERAND (x, 0), &tmp_before, &tmp_nosp, NULL_TREE);
1296 if (TREE_OPERAND (x, 1))
1297 verify_tree (TREE_OPERAND (x, 1), &tmp_list2, &tmp_list3, NULL_TREE);
1298 merge_tlist (&tmp_list3, tmp_list2, 0);
1299 add_tlist (&tmp_before, tmp_list3, NULL_TREE, 0);
1300 add_tlist (&tmp_before, tmp_nosp, NULL_TREE, 0);
1301 warn_for_collisions (tmp_before);
1302 add_tlist (pbefore_sp, tmp_before, NULL_TREE, 0);
1306 /* Scan all the list, e.g. indices of multi dimensional array. */
1309 tmp_before = tmp_nosp = 0;
1310 verify_tree (TREE_VALUE (x), &tmp_before, &tmp_nosp, NULL_TREE);
1311 merge_tlist (&tmp_nosp, tmp_before, 0);
1312 add_tlist (pno_sp, tmp_nosp, NULL_TREE, 0);
1319 struct tlist_cache *t;
1320 for (t = save_expr_cache; t; t = t->next)
1326 t = XOBNEW (&tlist_obstack, struct tlist_cache);
1327 t->next = save_expr_cache;
1329 save_expr_cache = t;
1331 tmp_before = tmp_nosp = 0;
1332 verify_tree (TREE_OPERAND (x, 0), &tmp_before, &tmp_nosp, NULL_TREE);
1333 warn_for_collisions (tmp_nosp);
1338 struct tlist *t = tmp_nosp;
1340 merge_tlist (&tmp_list3, t, 0);
1342 t->cache_before_sp = tmp_before;
1343 t->cache_after_sp = tmp_list3;
1345 merge_tlist (pbefore_sp, t->cache_before_sp, 1);
1346 add_tlist (pno_sp, t->cache_after_sp, NULL_TREE, 1);
1355 if (first_rtl_op (code) == 0)
1357 x = TREE_OPERAND (x, 0);
1372 int max = first_rtl_op (TREE_CODE (x));
1373 for (lp = 0; lp < max; lp++)
1375 tmp_before = tmp_nosp = 0;
1376 verify_tree (TREE_OPERAND (x, lp), &tmp_before, &tmp_nosp, NULL_TREE);
1377 merge_tlist (&tmp_nosp, tmp_before, 0);
1378 add_tlist (pno_sp, tmp_nosp, NULL_TREE, 0);
1385 /* Try to warn for undefined behavior in EXPR due to missing sequence
1389 verify_sequence_points (tree expr)
1391 struct tlist *before_sp = 0, *after_sp = 0;
1394 save_expr_cache = 0;
1395 if (tlist_firstobj == 0)
1397 gcc_obstack_init (&tlist_obstack);
1398 tlist_firstobj = (char *) obstack_alloc (&tlist_obstack, 0);
1401 verify_tree (expr, &before_sp, &after_sp, 0);
1402 warn_for_collisions (after_sp);
1403 obstack_free (&tlist_obstack, tlist_firstobj);
1406 /* Validate the expression after `case' and apply default promotions. */
1409 check_case_value (tree value)
1411 if (value == NULL_TREE)
1414 /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue. */
1415 STRIP_TYPE_NOPS (value);
1416 /* In C++, the following is allowed:
1419 switch (...) { case i: ... }
1421 So, we try to reduce the VALUE to a constant that way. */
1422 if (c_dialect_cxx ())
1424 value = decl_constant_value (value);
1425 STRIP_TYPE_NOPS (value);
1426 value = fold (value);
1429 if (TREE_CODE (value) != INTEGER_CST
1430 && value != error_mark_node)
1432 error ("case label does not reduce to an integer constant");
1433 value = error_mark_node;
1436 /* Promote char or short to int. */
1437 value = default_conversion (value);
1439 constant_expression_warning (value);
1444 /* See if the case values LOW and HIGH are in the range of the original
1445 type (ie. before the default conversion to int) of the switch testing
1447 TYPE is the promoted type of the testing expression, and ORIG_TYPE is
1448 the type before promiting it. CASE_LOW_P is a pointer to the lower
1449 bound of the case label, and CASE_HIGH_P is the upper bound or NULL
1450 if the case is not a case range.
1451 The caller has to make sure that we are not called with NULL for
1452 CASE_LOW_P (ie. the defualt case).
1453 Returns true if the case label is in range of ORIG_TYPE (satured or
1454 untouched) or false if the label is out of range. */
1457 check_case_bounds (tree type, tree orig_type,
1458 tree *case_low_p, tree *case_high_p)
1460 tree min_value, max_value;
1461 tree case_low = *case_low_p;
1462 tree case_high = case_high_p ? *case_high_p : case_low;
1464 /* If there was a problem with the original type, do nothing. */
1465 if (orig_type == error_mark_node)
1468 min_value = TYPE_MIN_VALUE (orig_type);
1469 max_value = TYPE_MAX_VALUE (orig_type);
1471 /* Case label is less than minimum for type. */
1472 if (tree_int_cst_compare (case_low, min_value) < 0
1473 && tree_int_cst_compare (case_high, min_value) < 0)
1475 warning ("case label value is less than minimum value for type");
1479 /* Case value is greater than maximum for type. */
1480 if (tree_int_cst_compare (case_low, max_value) > 0
1481 && tree_int_cst_compare (case_high, max_value) > 0)
1483 warning ("case label value exceeds maximum value for type");
1487 /* Saturate lower case label value to minimum. */
1488 if (tree_int_cst_compare (case_high, min_value) >= 0
1489 && tree_int_cst_compare (case_low, min_value) < 0)
1491 warning ("lower value in case label range"
1492 " less than minimum value for type");
1493 case_low = min_value;
1496 /* Saturate upper case label value to maximum. */
1497 if (tree_int_cst_compare (case_low, max_value) <= 0
1498 && tree_int_cst_compare (case_high, max_value) > 0)
1500 warning ("upper value in case label range"
1501 " exceeds maximum value for type");
1502 case_high = max_value;
1505 if (*case_low_p != case_low)
1506 *case_low_p = convert (type, case_low);
1507 if (case_high_p && *case_high_p != case_high)
1508 *case_high_p = convert (type, case_high);
1513 /* Return an integer type with BITS bits of precision,
1514 that is unsigned if UNSIGNEDP is nonzero, otherwise signed. */
1517 c_common_type_for_size (unsigned int bits, int unsignedp)
1519 if (bits == TYPE_PRECISION (integer_type_node))
1520 return unsignedp ? unsigned_type_node : integer_type_node;
1522 if (bits == TYPE_PRECISION (signed_char_type_node))
1523 return unsignedp ? unsigned_char_type_node : signed_char_type_node;
1525 if (bits == TYPE_PRECISION (short_integer_type_node))
1526 return unsignedp ? short_unsigned_type_node : short_integer_type_node;
1528 if (bits == TYPE_PRECISION (long_integer_type_node))
1529 return unsignedp ? long_unsigned_type_node : long_integer_type_node;
1531 if (bits == TYPE_PRECISION (long_long_integer_type_node))
1532 return (unsignedp ? long_long_unsigned_type_node
1533 : long_long_integer_type_node);
1535 if (bits == TYPE_PRECISION (widest_integer_literal_type_node))
1536 return (unsignedp ? widest_unsigned_literal_type_node
1537 : widest_integer_literal_type_node);
1539 if (bits <= TYPE_PRECISION (intQI_type_node))
1540 return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
1542 if (bits <= TYPE_PRECISION (intHI_type_node))
1543 return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
1545 if (bits <= TYPE_PRECISION (intSI_type_node))
1546 return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
1548 if (bits <= TYPE_PRECISION (intDI_type_node))
1549 return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
1554 /* Used for communication between c_common_type_for_mode and
1555 c_register_builtin_type. */
1556 static GTY(()) tree registered_builtin_types;
1558 /* Return a data type that has machine mode MODE.
1559 If the mode is an integer,
1560 then UNSIGNEDP selects between signed and unsigned types. */
1563 c_common_type_for_mode (enum machine_mode mode, int unsignedp)
1567 if (mode == TYPE_MODE (integer_type_node))
1568 return unsignedp ? unsigned_type_node : integer_type_node;
1570 if (mode == TYPE_MODE (signed_char_type_node))
1571 return unsignedp ? unsigned_char_type_node : signed_char_type_node;
1573 if (mode == TYPE_MODE (short_integer_type_node))
1574 return unsignedp ? short_unsigned_type_node : short_integer_type_node;
1576 if (mode == TYPE_MODE (long_integer_type_node))
1577 return unsignedp ? long_unsigned_type_node : long_integer_type_node;
1579 if (mode == TYPE_MODE (long_long_integer_type_node))
1580 return unsignedp ? long_long_unsigned_type_node : long_long_integer_type_node;
1582 if (mode == TYPE_MODE (widest_integer_literal_type_node))
1583 return unsignedp ? widest_unsigned_literal_type_node
1584 : widest_integer_literal_type_node;
1587 return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
1590 return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
1593 return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
1596 return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
1598 #if HOST_BITS_PER_WIDE_INT >= 64
1599 if (mode == TYPE_MODE (intTI_type_node))
1600 return unsignedp ? unsigned_intTI_type_node : intTI_type_node;
1603 if (mode == TYPE_MODE (float_type_node))
1604 return float_type_node;
1606 if (mode == TYPE_MODE (double_type_node))
1607 return double_type_node;
1609 if (mode == TYPE_MODE (long_double_type_node))
1610 return long_double_type_node;
1612 if (mode == TYPE_MODE (void_type_node))
1613 return void_type_node;
1615 if (mode == TYPE_MODE (build_pointer_type (char_type_node)))
1616 return unsignedp ? make_unsigned_type (mode) : make_signed_type (mode);
1618 if (mode == TYPE_MODE (build_pointer_type (integer_type_node)))
1619 return unsignedp ? make_unsigned_type (mode) : make_signed_type (mode);
1621 if (VECTOR_MODE_P (mode))
1623 enum machine_mode inner_mode = GET_MODE_INNER (mode);
1624 tree inner_type = c_common_type_for_mode (inner_mode, unsignedp);
1625 if (inner_type != NULL_TREE)
1626 return build_vector_type_for_mode (inner_type, mode);
1629 for (t = registered_builtin_types; t; t = TREE_CHAIN (t))
1630 if (TYPE_MODE (TREE_VALUE (t)) == mode)
1631 return TREE_VALUE (t);
1636 /* Return an unsigned type the same as TYPE in other respects. */
1638 c_common_unsigned_type (tree type)
1640 tree type1 = TYPE_MAIN_VARIANT (type);
1641 if (type1 == signed_char_type_node || type1 == char_type_node)
1642 return unsigned_char_type_node;
1643 if (type1 == integer_type_node)
1644 return unsigned_type_node;
1645 if (type1 == short_integer_type_node)
1646 return short_unsigned_type_node;
1647 if (type1 == long_integer_type_node)
1648 return long_unsigned_type_node;
1649 if (type1 == long_long_integer_type_node)
1650 return long_long_unsigned_type_node;
1651 if (type1 == widest_integer_literal_type_node)
1652 return widest_unsigned_literal_type_node;
1653 #if HOST_BITS_PER_WIDE_INT >= 64
1654 if (type1 == intTI_type_node)
1655 return unsigned_intTI_type_node;
1657 if (type1 == intDI_type_node)
1658 return unsigned_intDI_type_node;
1659 if (type1 == intSI_type_node)
1660 return unsigned_intSI_type_node;
1661 if (type1 == intHI_type_node)
1662 return unsigned_intHI_type_node;
1663 if (type1 == intQI_type_node)
1664 return unsigned_intQI_type_node;
1666 return c_common_signed_or_unsigned_type (1, type);
1669 /* Return a signed type the same as TYPE in other respects. */
1672 c_common_signed_type (tree type)
1674 tree type1 = TYPE_MAIN_VARIANT (type);
1675 if (type1 == unsigned_char_type_node || type1 == char_type_node)
1676 return signed_char_type_node;
1677 if (type1 == unsigned_type_node)
1678 return integer_type_node;
1679 if (type1 == short_unsigned_type_node)
1680 return short_integer_type_node;
1681 if (type1 == long_unsigned_type_node)
1682 return long_integer_type_node;
1683 if (type1 == long_long_unsigned_type_node)
1684 return long_long_integer_type_node;
1685 if (type1 == widest_unsigned_literal_type_node)
1686 return widest_integer_literal_type_node;
1687 #if HOST_BITS_PER_WIDE_INT >= 64
1688 if (type1 == unsigned_intTI_type_node)
1689 return intTI_type_node;
1691 if (type1 == unsigned_intDI_type_node)
1692 return intDI_type_node;
1693 if (type1 == unsigned_intSI_type_node)
1694 return intSI_type_node;
1695 if (type1 == unsigned_intHI_type_node)
1696 return intHI_type_node;
1697 if (type1 == unsigned_intQI_type_node)
1698 return intQI_type_node;
1700 return c_common_signed_or_unsigned_type (0, type);
1703 /* Return a type the same as TYPE except unsigned or
1704 signed according to UNSIGNEDP. */
1707 c_common_signed_or_unsigned_type (int unsignedp, tree type)
1709 if (! INTEGRAL_TYPE_P (type)
1710 || TYPE_UNSIGNED (type) == unsignedp)
1713 /* For ENUMERAL_TYPEs in C++, must check the mode of the types, not
1714 the precision; they have precision set to match their range, but
1715 may use a wider mode to match an ABI. If we change modes, we may
1716 wind up with bad conversions. For INTEGER_TYPEs in C, must check
1717 the precision as well, so as to yield correct results for
1718 bit-field types. C++ does not have these separate bit-field
1719 types, and producing a signed or unsigned variant of an
1720 ENUMERAL_TYPE may cause other problems as well. */
1722 #define TYPE_OK(node) \
1723 (TYPE_MODE (type) == TYPE_MODE (node) \
1724 && (c_dialect_cxx () || TYPE_PRECISION (type) == TYPE_PRECISION (node)))
1725 if (TYPE_OK (signed_char_type_node))
1726 return unsignedp ? unsigned_char_type_node : signed_char_type_node;
1727 if (TYPE_OK (integer_type_node))
1728 return unsignedp ? unsigned_type_node : integer_type_node;
1729 if (TYPE_OK (short_integer_type_node))
1730 return unsignedp ? short_unsigned_type_node : short_integer_type_node;
1731 if (TYPE_OK (long_integer_type_node))
1732 return unsignedp ? long_unsigned_type_node : long_integer_type_node;
1733 if (TYPE_OK (long_long_integer_type_node))
1734 return (unsignedp ? long_long_unsigned_type_node
1735 : long_long_integer_type_node);
1736 if (TYPE_OK (widest_integer_literal_type_node))
1737 return (unsignedp ? widest_unsigned_literal_type_node
1738 : widest_integer_literal_type_node);
1740 #if HOST_BITS_PER_WIDE_INT >= 64
1741 if (TYPE_OK (intTI_type_node))
1742 return unsignedp ? unsigned_intTI_type_node : intTI_type_node;
1744 if (TYPE_OK (intDI_type_node))
1745 return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
1746 if (TYPE_OK (intSI_type_node))
1747 return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
1748 if (TYPE_OK (intHI_type_node))
1749 return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
1750 if (TYPE_OK (intQI_type_node))
1751 return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
1754 if (c_dialect_cxx ())
1757 return build_nonstandard_integer_type (TYPE_PRECISION (type), unsignedp);
1760 /* The C version of the register_builtin_type langhook. */
1763 c_register_builtin_type (tree type, const char* name)
1767 decl = build_decl (TYPE_DECL, get_identifier (name), type);
1768 DECL_ARTIFICIAL (decl) = 1;
1769 if (!TYPE_NAME (type))
1770 TYPE_NAME (type) = decl;
1773 registered_builtin_types = tree_cons (0, type, registered_builtin_types);
1777 /* Return the minimum number of bits needed to represent VALUE in a
1778 signed or unsigned type, UNSIGNEDP says which. */
1781 min_precision (tree value, int unsignedp)
1785 /* If the value is negative, compute its negative minus 1. The latter
1786 adjustment is because the absolute value of the largest negative value
1787 is one larger than the largest positive value. This is equivalent to
1788 a bit-wise negation, so use that operation instead. */
1790 if (tree_int_cst_sgn (value) < 0)
1791 value = fold (build1 (BIT_NOT_EXPR, TREE_TYPE (value), value));
1793 /* Return the number of bits needed, taking into account the fact
1794 that we need one more bit for a signed than unsigned type. */
1796 if (integer_zerop (value))
1799 log = tree_floor_log2 (value);
1801 return log + 1 + ! unsignedp;
1804 /* Print an error message for invalid operands to arith operation
1805 CODE. NOP_EXPR is used as a special case (see
1806 c_common_truthvalue_conversion). */
1809 binary_op_error (enum tree_code code)
1816 error ("invalid truth-value expression");
1820 opname = "+"; break;
1822 opname = "-"; break;
1824 opname = "*"; break;
1826 opname = "max"; break;
1828 opname = "min"; break;
1830 opname = "=="; break;
1832 opname = "!="; break;
1834 opname = "<="; break;
1836 opname = ">="; break;
1838 opname = "<"; break;
1840 opname = ">"; break;
1842 opname = "<<"; break;
1844 opname = ">>"; break;
1845 case TRUNC_MOD_EXPR:
1846 case FLOOR_MOD_EXPR:
1847 opname = "%"; break;
1848 case TRUNC_DIV_EXPR:
1849 case FLOOR_DIV_EXPR:
1850 opname = "/"; break;
1852 opname = "&"; break;
1854 opname = "|"; break;
1855 case TRUTH_ANDIF_EXPR:
1856 opname = "&&"; break;
1857 case TRUTH_ORIF_EXPR:
1858 opname = "||"; break;
1860 opname = "^"; break;
1863 opname = "rotate"; break;
1865 opname = "unknown"; break;
1867 error ("invalid operands to binary %s", opname);
1870 /* Subroutine of build_binary_op, used for comparison operations.
1871 See if the operands have both been converted from subword integer types
1872 and, if so, perhaps change them both back to their original type.
1873 This function is also responsible for converting the two operands
1874 to the proper common type for comparison.
1876 The arguments of this function are all pointers to local variables
1877 of build_binary_op: OP0_PTR is &OP0, OP1_PTR is &OP1,
1878 RESTYPE_PTR is &RESULT_TYPE and RESCODE_PTR is &RESULTCODE.
1880 If this function returns nonzero, it means that the comparison has
1881 a constant value. What this function returns is an expression for
1885 shorten_compare (tree *op0_ptr, tree *op1_ptr, tree *restype_ptr,
1886 enum tree_code *rescode_ptr)
1889 tree op0 = *op0_ptr;
1890 tree op1 = *op1_ptr;
1891 int unsignedp0, unsignedp1;
1893 tree primop0, primop1;
1894 enum tree_code code = *rescode_ptr;
1896 /* Throw away any conversions to wider types
1897 already present in the operands. */
1899 primop0 = get_narrower (op0, &unsignedp0);
1900 primop1 = get_narrower (op1, &unsignedp1);
1902 /* Handle the case that OP0 does not *contain* a conversion
1903 but it *requires* conversion to FINAL_TYPE. */
1905 if (op0 == primop0 && TREE_TYPE (op0) != *restype_ptr)
1906 unsignedp0 = TYPE_UNSIGNED (TREE_TYPE (op0));
1907 if (op1 == primop1 && TREE_TYPE (op1) != *restype_ptr)
1908 unsignedp1 = TYPE_UNSIGNED (TREE_TYPE (op1));
1910 /* If one of the operands must be floated, we cannot optimize. */
1911 real1 = TREE_CODE (TREE_TYPE (primop0)) == REAL_TYPE;
1912 real2 = TREE_CODE (TREE_TYPE (primop1)) == REAL_TYPE;
1914 /* If first arg is constant, swap the args (changing operation
1915 so value is preserved), for canonicalization. Don't do this if
1916 the second arg is 0. */
1918 if (TREE_CONSTANT (primop0)
1919 && ! integer_zerop (primop1) && ! real_zerop (primop1))
1922 int temi = unsignedp0;
1930 unsignedp0 = unsignedp1;
1953 *rescode_ptr = code;
1956 /* If comparing an integer against a constant more bits wide,
1957 maybe we can deduce a value of 1 or 0 independent of the data.
1958 Or else truncate the constant now
1959 rather than extend the variable at run time.
1961 This is only interesting if the constant is the wider arg.
1962 Also, it is not safe if the constant is unsigned and the
1963 variable arg is signed, since in this case the variable
1964 would be sign-extended and then regarded as unsigned.
1965 Our technique fails in this case because the lowest/highest
1966 possible unsigned results don't follow naturally from the
1967 lowest/highest possible values of the variable operand.
1968 For just EQ_EXPR and NE_EXPR there is another technique that
1969 could be used: see if the constant can be faithfully represented
1970 in the other operand's type, by truncating it and reextending it
1971 and see if that preserves the constant's value. */
1973 if (!real1 && !real2
1974 && TREE_CODE (primop1) == INTEGER_CST
1975 && TYPE_PRECISION (TREE_TYPE (primop0)) < TYPE_PRECISION (*restype_ptr))
1977 int min_gt, max_gt, min_lt, max_lt;
1978 tree maxval, minval;
1979 /* 1 if comparison is nominally unsigned. */
1980 int unsignedp = TYPE_UNSIGNED (*restype_ptr);
1983 type = c_common_signed_or_unsigned_type (unsignedp0,
1984 TREE_TYPE (primop0));
1986 /* In C, if TYPE is an enumeration, then we need to get its
1987 min/max values from its underlying integral type, not the
1988 enumerated type itself. In C++, TYPE_MAX_VALUE and
1989 TYPE_MIN_VALUE have already been set correctly on the
1990 enumeration type. */
1991 if (!c_dialect_cxx() && TREE_CODE (type) == ENUMERAL_TYPE)
1992 type = c_common_type_for_size (TYPE_PRECISION (type), unsignedp0);
1994 maxval = TYPE_MAX_VALUE (type);
1995 minval = TYPE_MIN_VALUE (type);
1997 if (unsignedp && !unsignedp0)
1998 *restype_ptr = c_common_signed_type (*restype_ptr);
2000 if (TREE_TYPE (primop1) != *restype_ptr)
2002 tree tmp = convert (*restype_ptr, primop1);
2003 TREE_OVERFLOW (tmp) = TREE_OVERFLOW (primop1);
2004 TREE_CONSTANT_OVERFLOW (tmp) = TREE_CONSTANT_OVERFLOW (primop1);
2007 if (type != *restype_ptr)
2009 minval = convert (*restype_ptr, minval);
2010 maxval = convert (*restype_ptr, maxval);
2013 if (unsignedp && unsignedp0)
2015 min_gt = INT_CST_LT_UNSIGNED (primop1, minval);
2016 max_gt = INT_CST_LT_UNSIGNED (primop1, maxval);
2017 min_lt = INT_CST_LT_UNSIGNED (minval, primop1);
2018 max_lt = INT_CST_LT_UNSIGNED (maxval, primop1);
2022 min_gt = INT_CST_LT (primop1, minval);
2023 max_gt = INT_CST_LT (primop1, maxval);
2024 min_lt = INT_CST_LT (minval, primop1);
2025 max_lt = INT_CST_LT (maxval, primop1);
2029 /* This used to be a switch, but Genix compiler can't handle that. */
2030 if (code == NE_EXPR)
2032 if (max_lt || min_gt)
2033 val = truthvalue_true_node;
2035 else if (code == EQ_EXPR)
2037 if (max_lt || min_gt)
2038 val = truthvalue_false_node;
2040 else if (code == LT_EXPR)
2043 val = truthvalue_true_node;
2045 val = truthvalue_false_node;
2047 else if (code == GT_EXPR)
2050 val = truthvalue_true_node;
2052 val = truthvalue_false_node;
2054 else if (code == LE_EXPR)
2057 val = truthvalue_true_node;
2059 val = truthvalue_false_node;
2061 else if (code == GE_EXPR)
2064 val = truthvalue_true_node;
2066 val = truthvalue_false_node;
2069 /* If primop0 was sign-extended and unsigned comparison specd,
2070 we did a signed comparison above using the signed type bounds.
2071 But the comparison we output must be unsigned.
2073 Also, for inequalities, VAL is no good; but if the signed
2074 comparison had *any* fixed result, it follows that the
2075 unsigned comparison just tests the sign in reverse
2076 (positive values are LE, negative ones GE).
2077 So we can generate an unsigned comparison
2078 against an extreme value of the signed type. */
2080 if (unsignedp && !unsignedp0)
2087 primop1 = TYPE_MIN_VALUE (type);
2093 primop1 = TYPE_MAX_VALUE (type);
2100 type = c_common_unsigned_type (type);
2103 if (TREE_CODE (primop0) != INTEGER_CST)
2105 if (val == truthvalue_false_node)
2106 warning ("comparison is always false due to limited range of data type");
2107 if (val == truthvalue_true_node)
2108 warning ("comparison is always true due to limited range of data type");
2113 /* Don't forget to evaluate PRIMOP0 if it has side effects. */
2114 if (TREE_SIDE_EFFECTS (primop0))
2115 return build (COMPOUND_EXPR, TREE_TYPE (val), primop0, val);
2119 /* Value is not predetermined, but do the comparison
2120 in the type of the operand that is not constant.
2121 TYPE is already properly set. */
2123 else if (real1 && real2
2124 && (TYPE_PRECISION (TREE_TYPE (primop0))
2125 == TYPE_PRECISION (TREE_TYPE (primop1))))
2126 type = TREE_TYPE (primop0);
2128 /* If args' natural types are both narrower than nominal type
2129 and both extend in the same manner, compare them
2130 in the type of the wider arg.
2131 Otherwise must actually extend both to the nominal
2132 common type lest different ways of extending
2134 (eg, (short)-1 == (unsigned short)-1 should be 0.) */
2136 else if (unsignedp0 == unsignedp1 && real1 == real2
2137 && TYPE_PRECISION (TREE_TYPE (primop0)) < TYPE_PRECISION (*restype_ptr)
2138 && TYPE_PRECISION (TREE_TYPE (primop1)) < TYPE_PRECISION (*restype_ptr))
2140 type = common_type (TREE_TYPE (primop0), TREE_TYPE (primop1));
2141 type = c_common_signed_or_unsigned_type (unsignedp0
2142 || TYPE_UNSIGNED (*restype_ptr),
2144 /* Make sure shorter operand is extended the right way
2145 to match the longer operand. */
2147 = convert (c_common_signed_or_unsigned_type (unsignedp0,
2148 TREE_TYPE (primop0)),
2151 = convert (c_common_signed_or_unsigned_type (unsignedp1,
2152 TREE_TYPE (primop1)),
2157 /* Here we must do the comparison on the nominal type
2158 using the args exactly as we received them. */
2159 type = *restype_ptr;
2163 if (!real1 && !real2 && integer_zerop (primop1)
2164 && TYPE_UNSIGNED (*restype_ptr))
2170 /* All unsigned values are >= 0, so we warn if extra warnings
2171 are requested. However, if OP0 is a constant that is
2172 >= 0, the signedness of the comparison isn't an issue,
2173 so suppress the warning. */
2174 if (extra_warnings && !in_system_header
2175 && ! (TREE_CODE (primop0) == INTEGER_CST
2176 && ! TREE_OVERFLOW (convert (c_common_signed_type (type),
2178 warning ("comparison of unsigned expression >= 0 is always true");
2179 value = truthvalue_true_node;
2183 if (extra_warnings && !in_system_header
2184 && ! (TREE_CODE (primop0) == INTEGER_CST
2185 && ! TREE_OVERFLOW (convert (c_common_signed_type (type),
2187 warning ("comparison of unsigned expression < 0 is always false");
2188 value = truthvalue_false_node;
2197 /* Don't forget to evaluate PRIMOP0 if it has side effects. */
2198 if (TREE_SIDE_EFFECTS (primop0))
2199 return build (COMPOUND_EXPR, TREE_TYPE (value),
2206 *op0_ptr = convert (type, primop0);
2207 *op1_ptr = convert (type, primop1);
2209 *restype_ptr = truthvalue_type_node;
2214 /* Return a tree for the sum or difference (RESULTCODE says which)
2215 of pointer PTROP and integer INTOP. */
2218 pointer_int_sum (enum tree_code resultcode, tree ptrop, tree intop)
2222 /* The result is a pointer of the same type that is being added. */
2224 tree result_type = TREE_TYPE (ptrop);
2226 if (TREE_CODE (TREE_TYPE (result_type)) == VOID_TYPE)
2228 if (pedantic || warn_pointer_arith)
2229 pedwarn ("pointer of type `void *' used in arithmetic");
2230 size_exp = integer_one_node;
2232 else if (TREE_CODE (TREE_TYPE (result_type)) == FUNCTION_TYPE)
2234 if (pedantic || warn_pointer_arith)
2235 pedwarn ("pointer to a function used in arithmetic");
2236 size_exp = integer_one_node;
2238 else if (TREE_CODE (TREE_TYPE (result_type)) == METHOD_TYPE)
2240 if (pedantic || warn_pointer_arith)
2241 pedwarn ("pointer to member function used in arithmetic");
2242 size_exp = integer_one_node;
2245 size_exp = size_in_bytes (TREE_TYPE (result_type));
2247 /* If what we are about to multiply by the size of the elements
2248 contains a constant term, apply distributive law
2249 and multiply that constant term separately.
2250 This helps produce common subexpressions. */
2252 if ((TREE_CODE (intop) == PLUS_EXPR || TREE_CODE (intop) == MINUS_EXPR)
2253 && ! TREE_CONSTANT (intop)
2254 && TREE_CONSTANT (TREE_OPERAND (intop, 1))
2255 && TREE_CONSTANT (size_exp)
2256 /* If the constant comes from pointer subtraction,
2257 skip this optimization--it would cause an error. */
2258 && TREE_CODE (TREE_TYPE (TREE_OPERAND (intop, 0))) == INTEGER_TYPE
2259 /* If the constant is unsigned, and smaller than the pointer size,
2260 then we must skip this optimization. This is because it could cause
2261 an overflow error if the constant is negative but INTOP is not. */
2262 && (! TYPE_UNSIGNED (TREE_TYPE (intop))
2263 || (TYPE_PRECISION (TREE_TYPE (intop))
2264 == TYPE_PRECISION (TREE_TYPE (ptrop)))))
2266 enum tree_code subcode = resultcode;
2267 tree int_type = TREE_TYPE (intop);
2268 if (TREE_CODE (intop) == MINUS_EXPR)
2269 subcode = (subcode == PLUS_EXPR ? MINUS_EXPR : PLUS_EXPR);
2270 /* Convert both subexpression types to the type of intop,
2271 because weird cases involving pointer arithmetic
2272 can result in a sum or difference with different type args. */
2273 ptrop = build_binary_op (subcode, ptrop,
2274 convert (int_type, TREE_OPERAND (intop, 1)), 1);
2275 intop = convert (int_type, TREE_OPERAND (intop, 0));
2278 /* Convert the integer argument to a type the same size as sizetype
2279 so the multiply won't overflow spuriously. */
2281 if (TYPE_PRECISION (TREE_TYPE (intop)) != TYPE_PRECISION (sizetype)
2282 || TYPE_UNSIGNED (TREE_TYPE (intop)) != TYPE_UNSIGNED (sizetype))
2283 intop = convert (c_common_type_for_size (TYPE_PRECISION (sizetype),
2284 TYPE_UNSIGNED (sizetype)), intop);
2286 /* Replace the integer argument with a suitable product by the object size.
2287 Do this multiplication as signed, then convert to the appropriate
2288 pointer type (actually unsigned integral). */
2290 intop = convert (result_type,
2291 build_binary_op (MULT_EXPR, intop,
2292 convert (TREE_TYPE (intop), size_exp), 1));
2294 /* Create the sum or difference. */
2295 return fold (build (resultcode, result_type, ptrop, intop));
2298 /* Prepare expr to be an argument of a TRUTH_NOT_EXPR,
2299 or validate its data type for an `if' or `while' statement or ?..: exp.
2301 This preparation consists of taking the ordinary
2302 representation of an expression expr and producing a valid tree
2303 boolean expression describing whether expr is nonzero. We could
2304 simply always do build_binary_op (NE_EXPR, expr, truthvalue_false_node, 1),
2305 but we optimize comparisons, &&, ||, and !.
2307 The resulting type should always be `truthvalue_type_node'. */
2310 c_common_truthvalue_conversion (tree expr)
2312 if (TREE_CODE (expr) == ERROR_MARK)
2315 if (TREE_CODE (expr) == FUNCTION_DECL)
2316 expr = build_unary_op (ADDR_EXPR, expr, 0);
2318 switch (TREE_CODE (expr))
2320 case EQ_EXPR: case NE_EXPR: case UNEQ_EXPR: case LTGT_EXPR:
2321 case LE_EXPR: case GE_EXPR: case LT_EXPR: case GT_EXPR:
2322 case UNLE_EXPR: case UNGE_EXPR: case UNLT_EXPR: case UNGT_EXPR:
2323 case ORDERED_EXPR: case UNORDERED_EXPR:
2324 case TRUTH_ANDIF_EXPR:
2325 case TRUTH_ORIF_EXPR:
2326 case TRUTH_AND_EXPR:
2328 case TRUTH_XOR_EXPR:
2329 case TRUTH_NOT_EXPR:
2330 TREE_TYPE (expr) = truthvalue_type_node;
2337 return integer_zerop (expr) ? truthvalue_false_node : truthvalue_true_node;
2340 return real_zerop (expr) ? truthvalue_false_node : truthvalue_true_node;
2344 if (TREE_CODE (TREE_OPERAND (expr, 0)) == FUNCTION_DECL
2345 && ! DECL_WEAK (TREE_OPERAND (expr, 0)))
2347 /* Common Ada/Pascal programmer's mistake. We always warn
2348 about this since it is so bad. */
2349 warning ("the address of `%D', will always evaluate as `true'",
2350 TREE_OPERAND (expr, 0));
2351 return truthvalue_true_node;
2354 /* If we are taking the address of an external decl, it might be
2355 zero if it is weak, so we cannot optimize. */
2356 if (DECL_P (TREE_OPERAND (expr, 0))
2357 && DECL_EXTERNAL (TREE_OPERAND (expr, 0)))
2360 if (TREE_SIDE_EFFECTS (TREE_OPERAND (expr, 0)))
2361 return build (COMPOUND_EXPR, truthvalue_type_node,
2362 TREE_OPERAND (expr, 0), truthvalue_true_node);
2364 return truthvalue_true_node;
2368 return build_binary_op ((TREE_SIDE_EFFECTS (TREE_OPERAND (expr, 1))
2369 ? TRUTH_OR_EXPR : TRUTH_ORIF_EXPR),
2370 lang_hooks.truthvalue_conversion (TREE_OPERAND (expr, 0)),
2371 lang_hooks.truthvalue_conversion (TREE_OPERAND (expr, 1)),
2377 /* These don't change whether an object is nonzero or zero. */
2378 return lang_hooks.truthvalue_conversion (TREE_OPERAND (expr, 0));
2382 /* These don't change whether an object is zero or nonzero, but
2383 we can't ignore them if their second arg has side-effects. */
2384 if (TREE_SIDE_EFFECTS (TREE_OPERAND (expr, 1)))
2385 return build (COMPOUND_EXPR, truthvalue_type_node, TREE_OPERAND (expr, 1),
2386 lang_hooks.truthvalue_conversion (TREE_OPERAND (expr, 0)));
2388 return lang_hooks.truthvalue_conversion (TREE_OPERAND (expr, 0));
2391 /* Distribute the conversion into the arms of a COND_EXPR. */
2392 return fold (build (COND_EXPR, truthvalue_type_node, TREE_OPERAND (expr, 0),
2393 lang_hooks.truthvalue_conversion (TREE_OPERAND (expr, 1)),
2394 lang_hooks.truthvalue_conversion (TREE_OPERAND (expr, 2))));
2397 /* Don't cancel the effect of a CONVERT_EXPR from a REFERENCE_TYPE,
2398 since that affects how `default_conversion' will behave. */
2399 if (TREE_CODE (TREE_TYPE (expr)) == REFERENCE_TYPE
2400 || TREE_CODE (TREE_TYPE (TREE_OPERAND (expr, 0))) == REFERENCE_TYPE)
2402 /* Fall through.... */
2404 /* If this is widening the argument, we can ignore it. */
2405 if (TYPE_PRECISION (TREE_TYPE (expr))
2406 >= TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (expr, 0))))
2407 return lang_hooks.truthvalue_conversion (TREE_OPERAND (expr, 0));
2411 /* Perhaps reduce (x - y) != 0 to (x != y). The expressions
2412 aren't guaranteed to the be same for modes that can represent
2413 infinity, since if x and y are both +infinity, or both
2414 -infinity, then x - y is not a number.
2416 Note that this transformation is safe when x or y is NaN.
2417 (x - y) is then NaN, and both (x - y) != 0 and x != y will
2419 if (HONOR_INFINITIES (TYPE_MODE (TREE_TYPE (TREE_OPERAND (expr, 0)))))
2421 /* Fall through.... */
2423 /* This and MINUS_EXPR can be changed into a comparison of the
2425 if (TREE_TYPE (TREE_OPERAND (expr, 0))
2426 == TREE_TYPE (TREE_OPERAND (expr, 1)))
2427 return build_binary_op (NE_EXPR, TREE_OPERAND (expr, 0),
2428 TREE_OPERAND (expr, 1), 1);
2429 return build_binary_op (NE_EXPR, TREE_OPERAND (expr, 0),
2430 fold (build1 (NOP_EXPR,
2431 TREE_TYPE (TREE_OPERAND (expr, 0)),
2432 TREE_OPERAND (expr, 1))), 1);
2435 if (integer_onep (TREE_OPERAND (expr, 1))
2436 && TREE_TYPE (expr) != truthvalue_type_node)
2437 /* Using convert here would cause infinite recursion. */
2438 return build1 (NOP_EXPR, truthvalue_type_node, expr);
2442 if (warn_parentheses && !TREE_NO_WARNING (expr))
2443 warning ("suggest parentheses around assignment used as truth value");
2450 if (TREE_CODE (TREE_TYPE (expr)) == COMPLEX_TYPE)
2452 tree t = save_expr (expr);
2453 return (build_binary_op
2454 ((TREE_SIDE_EFFECTS (expr)
2455 ? TRUTH_OR_EXPR : TRUTH_ORIF_EXPR),
2456 lang_hooks.truthvalue_conversion (build_unary_op (REALPART_EXPR, t, 0)),
2457 lang_hooks.truthvalue_conversion (build_unary_op (IMAGPART_EXPR, t, 0)),
2461 return build_binary_op (NE_EXPR, expr, integer_zero_node, 1);
2464 static tree builtin_function_2 (const char *builtin_name, const char *name,
2465 tree builtin_type, tree type,
2466 enum built_in_function function_code,
2467 enum built_in_class cl, int library_name_p,
2471 /* Make a variant type in the proper way for C/C++, propagating qualifiers
2472 down to the element type of an array. */
2475 c_build_qualified_type (tree type, int type_quals)
2477 if (type == error_mark_node)
2480 if (TREE_CODE (type) == ARRAY_TYPE)
2481 return build_array_type (c_build_qualified_type (TREE_TYPE (type),
2483 TYPE_DOMAIN (type));
2485 /* A restrict-qualified pointer type must be a pointer to object or
2486 incomplete type. Note that the use of POINTER_TYPE_P also allows
2487 REFERENCE_TYPEs, which is appropriate for C++. */
2488 if ((type_quals & TYPE_QUAL_RESTRICT)
2489 && (!POINTER_TYPE_P (type)
2490 || !C_TYPE_OBJECT_OR_INCOMPLETE_P (TREE_TYPE (type))))
2492 error ("invalid use of `restrict'");
2493 type_quals &= ~TYPE_QUAL_RESTRICT;
2496 return build_qualified_type (type, type_quals);
2499 /* Apply the TYPE_QUALS to the new DECL. */
2502 c_apply_type_quals_to_decl (int type_quals, tree decl)
2504 tree type = TREE_TYPE (decl);
2506 if (type == error_mark_node)
2509 if (((type_quals & TYPE_QUAL_CONST)
2510 || (type && TREE_CODE (type) == REFERENCE_TYPE))
2511 /* An object declared 'const' is only readonly after it is
2512 initialized. We don't have any way of expressing this currently,
2513 so we need to be conservative and unset TREE_READONLY for types
2514 with constructors. Otherwise aliasing code will ignore stores in
2515 an inline constructor. */
2516 && !(type && TYPE_NEEDS_CONSTRUCTING (type)))
2517 TREE_READONLY (decl) = 1;
2518 if (type_quals & TYPE_QUAL_VOLATILE)
2520 TREE_SIDE_EFFECTS (decl) = 1;
2521 TREE_THIS_VOLATILE (decl) = 1;
2523 if (type_quals & TYPE_QUAL_RESTRICT)
2525 while (type && TREE_CODE (type) == ARRAY_TYPE)
2526 /* Allow 'restrict' on arrays of pointers.
2527 FIXME currently we just ignore it. */
2528 type = TREE_TYPE (type);
2530 || !POINTER_TYPE_P (type)
2531 || !C_TYPE_OBJECT_OR_INCOMPLETE_P (TREE_TYPE (type)))
2532 error ("invalid use of `restrict'");
2533 else if (flag_strict_aliasing && type == TREE_TYPE (decl))
2534 /* Indicate we need to make a unique alias set for this pointer.
2535 We can't do it here because it might be pointing to an
2537 DECL_POINTER_ALIAS_SET (decl) = -2;
2541 /* Hash function for the problem of multiple type definitions in
2542 different files. This must hash all types that will compare
2543 equal via comptypes to the same value. In practice it hashes
2544 on some of the simple stuff and leaves the details to comptypes. */
2547 c_type_hash (const void *p)
2553 switch (TREE_CODE (t))
2555 /* For pointers, hash on pointee type plus some swizzling. */
2557 return c_type_hash (TREE_TYPE (t)) ^ 0x3003003;
2558 /* Hash on number of elements and total size. */
2561 t2 = TYPE_VALUES (t);
2565 t2 = TYPE_FIELDS (t);
2567 case QUAL_UNION_TYPE:
2569 t2 = TYPE_FIELDS (t);
2573 t2 = TYPE_FIELDS (t);
2578 for (; t2; t2 = TREE_CHAIN (t2))
2580 size = TREE_INT_CST_LOW (TYPE_SIZE (t));
2581 return ((size << 24) | (i << shift));
2584 /* Return the typed-based alias set for T, which may be an expression
2585 or a type. Return -1 if we don't do anything special. */
2588 c_common_get_alias_set (tree t)
2592 static htab_t type_hash_table;
2594 /* Permit type-punning when accessing a union, provided the access
2595 is directly through the union. For example, this code does not
2596 permit taking the address of a union member and then storing
2597 through it. Even the type-punning allowed here is a GCC
2598 extension, albeit a common and useful one; the C standard says
2599 that such accesses have implementation-defined behavior. */
2601 TREE_CODE (u) == COMPONENT_REF || TREE_CODE (u) == ARRAY_REF;
2602 u = TREE_OPERAND (u, 0))
2603 if (TREE_CODE (u) == COMPONENT_REF
2604 && TREE_CODE (TREE_TYPE (TREE_OPERAND (u, 0))) == UNION_TYPE)
2607 /* That's all the expressions we handle specially. */
2611 /* The C standard guarantees that any object may be accessed via an
2612 lvalue that has character type. */
2613 if (t == char_type_node
2614 || t == signed_char_type_node
2615 || t == unsigned_char_type_node)
2618 /* If it has the may_alias attribute, it can alias anything. */
2619 if (lookup_attribute ("may_alias", TYPE_ATTRIBUTES (t)))
2622 /* The C standard specifically allows aliasing between signed and
2623 unsigned variants of the same type. We treat the signed
2624 variant as canonical. */
2625 if (TREE_CODE (t) == INTEGER_TYPE && TYPE_UNSIGNED (t))
2627 tree t1 = c_common_signed_type (t);
2629 /* t1 == t can happen for boolean nodes which are always unsigned. */
2631 return get_alias_set (t1);
2633 else if (POINTER_TYPE_P (t))
2637 /* Unfortunately, there is no canonical form of a pointer type.
2638 In particular, if we have `typedef int I', then `int *', and
2639 `I *' are different types. So, we have to pick a canonical
2640 representative. We do this below.
2642 Technically, this approach is actually more conservative that
2643 it needs to be. In particular, `const int *' and `int *'
2644 should be in different alias sets, according to the C and C++
2645 standard, since their types are not the same, and so,
2646 technically, an `int **' and `const int **' cannot point at
2649 But, the standard is wrong. In particular, this code is
2654 const int* const* cipp = ipp;
2656 And, it doesn't make sense for that to be legal unless you
2657 can dereference IPP and CIPP. So, we ignore cv-qualifiers on
2658 the pointed-to types. This issue has been reported to the
2660 t1 = build_type_no_quals (t);
2662 return get_alias_set (t1);
2665 /* Handle the case of multiple type nodes referring to "the same" type,
2666 which occurs with IMA. These share an alias set. FIXME: Currently only
2667 C90 is handled. (In C99 type compatibility is not transitive, which
2668 complicates things mightily. The alias set splay trees can theoretically
2669 represent this, but insertion is tricky when you consider all the
2670 different orders things might arrive in.) */
2672 if (c_language != clk_c || flag_isoc99)
2675 /* Save time if there's only one input file. */
2676 if (num_in_fnames == 1)
2679 /* Pointers need special handling if they point to any type that
2680 needs special handling (below). */
2681 if (TREE_CODE (t) == POINTER_TYPE)
2684 /* Find bottom type under any nested POINTERs. */
2685 for (t2 = TREE_TYPE (t);
2686 TREE_CODE (t2) == POINTER_TYPE;
2687 t2 = TREE_TYPE (t2))
2689 if (TREE_CODE (t2) != RECORD_TYPE
2690 && TREE_CODE (t2) != ENUMERAL_TYPE
2691 && TREE_CODE (t2) != QUAL_UNION_TYPE
2692 && TREE_CODE (t2) != UNION_TYPE)
2694 if (TYPE_SIZE (t2) == 0)
2697 /* These are the only cases that need special handling. */
2698 if (TREE_CODE (t) != RECORD_TYPE
2699 && TREE_CODE (t) != ENUMERAL_TYPE
2700 && TREE_CODE (t) != QUAL_UNION_TYPE
2701 && TREE_CODE (t) != UNION_TYPE
2702 && TREE_CODE (t) != POINTER_TYPE)
2705 if (TYPE_SIZE (t) == 0)
2708 /* Look up t in hash table. Only one of the compatible types within each
2709 alias set is recorded in the table. */
2710 if (!type_hash_table)
2711 type_hash_table = htab_create (1021, c_type_hash,
2712 (htab_eq) lang_hooks.types_compatible_p,
2714 slot = htab_find_slot (type_hash_table, t, INSERT);
2716 return TYPE_ALIAS_SET ((tree)*slot);
2718 /* Our caller will assign and record (in t) a new alias set; all we need
2719 to do is remember t in the hash table. */
2725 /* Compute the value of 'sizeof (TYPE)' or '__alignof__ (TYPE)', where the
2726 second parameter indicates which OPERATOR is being applied. The COMPLAIN
2727 flag controls whether we should diagnose possibly ill-formed
2728 constructs or not. */
2730 c_sizeof_or_alignof_type (tree type, enum tree_code op, int complain)
2732 const char *op_name;
2734 enum tree_code type_code = TREE_CODE (type);
2736 my_friendly_assert (op == SIZEOF_EXPR || op == ALIGNOF_EXPR, 20020720);
2737 op_name = op == SIZEOF_EXPR ? "sizeof" : "__alignof__";
2739 if (type_code == FUNCTION_TYPE)
2741 if (op == SIZEOF_EXPR)
2743 if (complain && (pedantic || warn_pointer_arith))
2744 pedwarn ("invalid application of `sizeof' to a function type");
2745 value = size_one_node;
2748 value = size_int (FUNCTION_BOUNDARY / BITS_PER_UNIT);
2750 else if (type_code == VOID_TYPE || type_code == ERROR_MARK)
2752 if (type_code == VOID_TYPE
2753 && complain && (pedantic || warn_pointer_arith))
2754 pedwarn ("invalid application of `%s' to a void type", op_name);
2755 value = size_one_node;
2757 else if (!COMPLETE_TYPE_P (type))
2760 error ("invalid application of `%s' to incomplete type `%T' ",
2762 value = size_zero_node;
2766 if (op == (enum tree_code) SIZEOF_EXPR)
2767 /* Convert in case a char is more than one unit. */
2768 value = size_binop (CEIL_DIV_EXPR, TYPE_SIZE_UNIT (type),
2769 size_int (TYPE_PRECISION (char_type_node)
2772 value = size_int (TYPE_ALIGN (type) / BITS_PER_UNIT);
2775 /* VALUE will have an integer type with TYPE_IS_SIZETYPE set.
2776 TYPE_IS_SIZETYPE means that certain things (like overflow) will
2777 never happen. However, this node should really have type
2778 `size_t', which is just a typedef for an ordinary integer type. */
2779 value = fold (build1 (NOP_EXPR, size_type_node, value));
2780 my_friendly_assert (!TYPE_IS_SIZETYPE (TREE_TYPE (value)), 20001021);
2785 /* Implement the __alignof keyword: Return the minimum required
2786 alignment of EXPR, measured in bytes. For VAR_DECL's and
2787 FIELD_DECL's return DECL_ALIGN (which can be set from an
2788 "aligned" __attribute__ specification). */
2791 c_alignof_expr (tree expr)
2795 if (TREE_CODE (expr) == VAR_DECL)
2796 t = size_int (DECL_ALIGN (expr) / BITS_PER_UNIT);
2798 else if (TREE_CODE (expr) == COMPONENT_REF
2799 && DECL_C_BIT_FIELD (TREE_OPERAND (expr, 1)))
2801 error ("`__alignof' applied to a bit-field");
2804 else if (TREE_CODE (expr) == COMPONENT_REF
2805 && TREE_CODE (TREE_OPERAND (expr, 1)) == FIELD_DECL)
2806 t = size_int (DECL_ALIGN (TREE_OPERAND (expr, 1)) / BITS_PER_UNIT);
2808 else if (TREE_CODE (expr) == INDIRECT_REF)
2810 tree t = TREE_OPERAND (expr, 0);
2812 int bestalign = TYPE_ALIGN (TREE_TYPE (TREE_TYPE (t)));
2814 while (TREE_CODE (t) == NOP_EXPR
2815 && TREE_CODE (TREE_TYPE (TREE_OPERAND (t, 0))) == POINTER_TYPE)
2819 t = TREE_OPERAND (t, 0);
2820 thisalign = TYPE_ALIGN (TREE_TYPE (TREE_TYPE (t)));
2821 if (thisalign > bestalign)
2822 best = t, bestalign = thisalign;
2824 return c_alignof (TREE_TYPE (TREE_TYPE (best)));
2827 return c_alignof (TREE_TYPE (expr));
2829 return fold (build1 (NOP_EXPR, size_type_node, t));
2832 /* Handle C and C++ default attributes. */
2834 enum built_in_attribute
2836 #define DEF_ATTR_NULL_TREE(ENUM) ENUM,
2837 #define DEF_ATTR_INT(ENUM, VALUE) ENUM,
2838 #define DEF_ATTR_IDENT(ENUM, STRING) ENUM,
2839 #define DEF_ATTR_TREE_LIST(ENUM, PURPOSE, VALUE, CHAIN) ENUM,
2840 #include "builtin-attrs.def"
2841 #undef DEF_ATTR_NULL_TREE
2843 #undef DEF_ATTR_IDENT
2844 #undef DEF_ATTR_TREE_LIST
2848 static GTY(()) tree built_in_attributes[(int) ATTR_LAST];
2850 static void c_init_attributes (void);
2852 /* Build tree nodes and builtin functions common to both C and C++ language
2856 c_common_nodes_and_builtins (void)
2860 #define DEF_PRIMITIVE_TYPE(NAME, VALUE) NAME,
2861 #define DEF_FUNCTION_TYPE_0(NAME, RETURN) NAME,
2862 #define DEF_FUNCTION_TYPE_1(NAME, RETURN, ARG1) NAME,
2863 #define DEF_FUNCTION_TYPE_2(NAME, RETURN, ARG1, ARG2) NAME,
2864 #define DEF_FUNCTION_TYPE_3(NAME, RETURN, ARG1, ARG2, ARG3) NAME,
2865 #define DEF_FUNCTION_TYPE_4(NAME, RETURN, ARG1, ARG2, ARG3, ARG4) NAME,
2866 #define DEF_FUNCTION_TYPE_VAR_0(NAME, RETURN) NAME,
2867 #define DEF_FUNCTION_TYPE_VAR_1(NAME, RETURN, ARG1) NAME,
2868 #define DEF_FUNCTION_TYPE_VAR_2(NAME, RETURN, ARG1, ARG2) NAME,
2869 #define DEF_FUNCTION_TYPE_VAR_3(NAME, RETURN, ARG1, ARG2, ARG3) NAME,
2870 #define DEF_POINTER_TYPE(NAME, TYPE) NAME,
2871 #include "builtin-types.def"
2872 #undef DEF_PRIMITIVE_TYPE
2873 #undef DEF_FUNCTION_TYPE_0
2874 #undef DEF_FUNCTION_TYPE_1
2875 #undef DEF_FUNCTION_TYPE_2
2876 #undef DEF_FUNCTION_TYPE_3
2877 #undef DEF_FUNCTION_TYPE_4
2878 #undef DEF_FUNCTION_TYPE_VAR_0
2879 #undef DEF_FUNCTION_TYPE_VAR_1
2880 #undef DEF_FUNCTION_TYPE_VAR_2
2881 #undef DEF_FUNCTION_TYPE_VAR_3
2882 #undef DEF_POINTER_TYPE
2886 typedef enum builtin_type builtin_type;
2888 tree builtin_types[(int) BT_LAST];
2889 int wchar_type_size;
2890 tree array_domain_type;
2891 tree va_list_ref_type_node;
2892 tree va_list_arg_type_node;
2894 /* Define `int' and `char' first so that dbx will output them first. */
2895 record_builtin_type (RID_INT, NULL, integer_type_node);
2896 record_builtin_type (RID_CHAR, "char", char_type_node);
2898 /* `signed' is the same as `int'. FIXME: the declarations of "signed",
2899 "unsigned long", "long long unsigned" and "unsigned short" were in C++
2900 but not C. Are the conditionals here needed? */
2901 if (c_dialect_cxx ())
2902 record_builtin_type (RID_SIGNED, NULL, integer_type_node);
2903 record_builtin_type (RID_LONG, "long int", long_integer_type_node);
2904 record_builtin_type (RID_UNSIGNED, "unsigned int", unsigned_type_node);
2905 record_builtin_type (RID_MAX, "long unsigned int",
2906 long_unsigned_type_node);
2907 if (c_dialect_cxx ())
2908 record_builtin_type (RID_MAX, "unsigned long", long_unsigned_type_node);
2909 record_builtin_type (RID_MAX, "long long int",
2910 long_long_integer_type_node);
2911 record_builtin_type (RID_MAX, "long long unsigned int",
2912 long_long_unsigned_type_node);
2913 if (c_dialect_cxx ())
2914 record_builtin_type (RID_MAX, "long long unsigned",
2915 long_long_unsigned_type_node);
2916 record_builtin_type (RID_SHORT, "short int", short_integer_type_node);
2917 record_builtin_type (RID_MAX, "short unsigned int",
2918 short_unsigned_type_node);
2919 if (c_dialect_cxx ())
2920 record_builtin_type (RID_MAX, "unsigned short",
2921 short_unsigned_type_node);
2923 /* Define both `signed char' and `unsigned char'. */
2924 record_builtin_type (RID_MAX, "signed char", signed_char_type_node);
2925 record_builtin_type (RID_MAX, "unsigned char", unsigned_char_type_node);
2927 /* These are types that c_common_type_for_size and
2928 c_common_type_for_mode use. */
2929 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
2931 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
2933 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
2935 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
2937 #if HOST_BITS_PER_WIDE_INT >= 64
2938 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL,
2939 get_identifier ("__int128_t"),
2942 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
2943 unsigned_intQI_type_node));
2944 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
2945 unsigned_intHI_type_node));
2946 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
2947 unsigned_intSI_type_node));
2948 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
2949 unsigned_intDI_type_node));
2950 #if HOST_BITS_PER_WIDE_INT >= 64
2951 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL,
2952 get_identifier ("__uint128_t"),
2953 unsigned_intTI_type_node));
2956 /* Create the widest literal types. */
2957 widest_integer_literal_type_node
2958 = make_signed_type (HOST_BITS_PER_WIDE_INT * 2);
2959 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
2960 widest_integer_literal_type_node));
2962 widest_unsigned_literal_type_node
2963 = make_unsigned_type (HOST_BITS_PER_WIDE_INT * 2);
2964 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
2965 widest_unsigned_literal_type_node));
2967 /* `unsigned long' is the standard type for sizeof.
2968 Note that stddef.h uses `unsigned long',
2969 and this must agree, even if long and int are the same size. */
2971 TREE_TYPE (identifier_global_value (get_identifier (SIZE_TYPE)));
2972 signed_size_type_node = c_common_signed_type (size_type_node);
2973 set_sizetype (size_type_node);
2976 TREE_TYPE (identifier_global_value (get_identifier (PID_TYPE)));
2978 build_common_tree_nodes_2 (flag_short_double);
2980 record_builtin_type (RID_FLOAT, NULL, float_type_node);
2981 record_builtin_type (RID_DOUBLE, NULL, double_type_node);
2982 record_builtin_type (RID_MAX, "long double", long_double_type_node);
2984 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL,
2985 get_identifier ("complex int"),
2986 complex_integer_type_node));
2987 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL,
2988 get_identifier ("complex float"),
2989 complex_float_type_node));
2990 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL,
2991 get_identifier ("complex double"),
2992 complex_double_type_node));
2993 lang_hooks.decls.pushdecl
2994 (build_decl (TYPE_DECL, get_identifier ("complex long double"),
2995 complex_long_double_type_node));
2997 if (c_dialect_cxx ())
2998 /* For C++, make fileptr_type_node a distinct void * type until
2999 FILE type is defined. */
3000 fileptr_type_node = build_type_copy (ptr_type_node);
3002 record_builtin_type (RID_VOID, NULL, void_type_node);
3004 void_zero_node = build_int_2 (0, 0);
3005 TREE_TYPE (void_zero_node) = void_type_node;
3007 void_list_node = build_void_list_node ();
3009 /* Make a type to be the domain of a few array types
3010 whose domains don't really matter.
3011 200 is small enough that it always fits in size_t
3012 and large enough that it can hold most function names for the
3013 initializations of __FUNCTION__ and __PRETTY_FUNCTION__. */
3014 array_domain_type = build_index_type (size_int (200));
3016 /* Make a type for arrays of characters.
3017 With luck nothing will ever really depend on the length of this
3019 char_array_type_node
3020 = build_array_type (char_type_node, array_domain_type);
3022 /* Likewise for arrays of ints. */
3024 = build_array_type (integer_type_node, array_domain_type);
3026 string_type_node = build_pointer_type (char_type_node);
3027 const_string_type_node
3028 = build_pointer_type (build_qualified_type
3029 (char_type_node, TYPE_QUAL_CONST));
3031 /* This is special for C++ so functions can be overloaded. */
3032 wchar_type_node = get_identifier (MODIFIED_WCHAR_TYPE);
3033 wchar_type_node = TREE_TYPE (identifier_global_value (wchar_type_node));
3034 wchar_type_size = TYPE_PRECISION (wchar_type_node);
3035 if (c_dialect_cxx ())
3037 if (TYPE_UNSIGNED (wchar_type_node))
3038 wchar_type_node = make_unsigned_type (wchar_type_size);
3040 wchar_type_node = make_signed_type (wchar_type_size);
3041 record_builtin_type (RID_WCHAR, "wchar_t", wchar_type_node);
3045 signed_wchar_type_node = c_common_signed_type (wchar_type_node);
3046 unsigned_wchar_type_node = c_common_unsigned_type (wchar_type_node);
3049 /* This is for wide string constants. */
3050 wchar_array_type_node
3051 = build_array_type (wchar_type_node, array_domain_type);
3054 TREE_TYPE (identifier_global_value (get_identifier (WINT_TYPE)));
3057 TREE_TYPE (identifier_global_value (get_identifier (INTMAX_TYPE)));
3059 TREE_TYPE (identifier_global_value (get_identifier (UINTMAX_TYPE)));
3061 default_function_type = build_function_type (integer_type_node, NULL_TREE);
3063 = TREE_TYPE (identifier_global_value (get_identifier (PTRDIFF_TYPE)));
3064 unsigned_ptrdiff_type_node = c_common_unsigned_type (ptrdiff_type_node);
3066 lang_hooks.decls.pushdecl
3067 (build_decl (TYPE_DECL, get_identifier ("__builtin_va_list"),
3068 va_list_type_node));
3070 if (TREE_CODE (va_list_type_node) == ARRAY_TYPE)
3072 va_list_arg_type_node = va_list_ref_type_node =
3073 build_pointer_type (TREE_TYPE (va_list_type_node));
3077 va_list_arg_type_node = va_list_type_node;
3078 va_list_ref_type_node = build_reference_type (va_list_type_node);
3081 #define DEF_PRIMITIVE_TYPE(ENUM, VALUE) \
3082 builtin_types[(int) ENUM] = VALUE;
3083 #define DEF_FUNCTION_TYPE_0(ENUM, RETURN) \
3084 builtin_types[(int) ENUM] \
3085 = build_function_type (builtin_types[(int) RETURN], \
3087 #define DEF_FUNCTION_TYPE_1(ENUM, RETURN, ARG1) \
3088 builtin_types[(int) ENUM] \
3089 = build_function_type (builtin_types[(int) RETURN], \
3090 tree_cons (NULL_TREE, \
3091 builtin_types[(int) ARG1], \
3093 #define DEF_FUNCTION_TYPE_2(ENUM, RETURN, ARG1, ARG2) \
3094 builtin_types[(int) ENUM] \
3095 = build_function_type \
3096 (builtin_types[(int) RETURN], \
3097 tree_cons (NULL_TREE, \
3098 builtin_types[(int) ARG1], \
3099 tree_cons (NULL_TREE, \
3100 builtin_types[(int) ARG2], \
3102 #define DEF_FUNCTION_TYPE_3(ENUM, RETURN, ARG1, ARG2, ARG3) \
3103 builtin_types[(int) ENUM] \
3104 = build_function_type \
3105 (builtin_types[(int) RETURN], \
3106 tree_cons (NULL_TREE, \
3107 builtin_types[(int) ARG1], \
3108 tree_cons (NULL_TREE, \
3109 builtin_types[(int) ARG2], \
3110 tree_cons (NULL_TREE, \
3111 builtin_types[(int) ARG3], \
3113 #define DEF_FUNCTION_TYPE_4(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4) \
3114 builtin_types[(int) ENUM] \
3115 = build_function_type \
3116 (builtin_types[(int) RETURN], \
3117 tree_cons (NULL_TREE, \
3118 builtin_types[(int) ARG1], \
3119 tree_cons (NULL_TREE, \
3120 builtin_types[(int) ARG2], \
3123 builtin_types[(int) ARG3], \
3124 tree_cons (NULL_TREE, \
3125 builtin_types[(int) ARG4], \
3126 void_list_node)))));
3127 #define DEF_FUNCTION_TYPE_VAR_0(ENUM, RETURN) \
3128 builtin_types[(int) ENUM] \
3129 = build_function_type (builtin_types[(int) RETURN], NULL_TREE);
3130 #define DEF_FUNCTION_TYPE_VAR_1(ENUM, RETURN, ARG1) \
3131 builtin_types[(int) ENUM] \
3132 = build_function_type (builtin_types[(int) RETURN], \
3133 tree_cons (NULL_TREE, \
3134 builtin_types[(int) ARG1], \
3137 #define DEF_FUNCTION_TYPE_VAR_2(ENUM, RETURN, ARG1, ARG2) \
3138 builtin_types[(int) ENUM] \
3139 = build_function_type \
3140 (builtin_types[(int) RETURN], \
3141 tree_cons (NULL_TREE, \
3142 builtin_types[(int) ARG1], \
3143 tree_cons (NULL_TREE, \
3144 builtin_types[(int) ARG2], \
3147 #define DEF_FUNCTION_TYPE_VAR_3(ENUM, RETURN, ARG1, ARG2, ARG3) \
3148 builtin_types[(int) ENUM] \
3149 = build_function_type \
3150 (builtin_types[(int) RETURN], \
3151 tree_cons (NULL_TREE, \
3152 builtin_types[(int) ARG1], \
3153 tree_cons (NULL_TREE, \
3154 builtin_types[(int) ARG2], \
3155 tree_cons (NULL_TREE, \
3156 builtin_types[(int) ARG3], \
3159 #define DEF_POINTER_TYPE(ENUM, TYPE) \
3160 builtin_types[(int) ENUM] \
3161 = build_pointer_type (builtin_types[(int) TYPE]);
3162 #include "builtin-types.def"
3163 #undef DEF_PRIMITIVE_TYPE
3164 #undef DEF_FUNCTION_TYPE_1
3165 #undef DEF_FUNCTION_TYPE_2
3166 #undef DEF_FUNCTION_TYPE_3
3167 #undef DEF_FUNCTION_TYPE_4
3168 #undef DEF_FUNCTION_TYPE_VAR_0
3169 #undef DEF_FUNCTION_TYPE_VAR_1
3170 #undef DEF_FUNCTION_TYPE_VAR_2
3171 #undef DEF_FUNCTION_TYPE_VAR_3
3172 #undef DEF_POINTER_TYPE
3174 c_init_attributes ();
3176 #define DEF_BUILTIN(ENUM, NAME, CLASS, TYPE, LIBTYPE, \
3177 BOTH_P, FALLBACK_P, NONANSI_P, ATTRS, IMPLICIT) \
3182 if (strncmp (NAME, "__builtin_", strlen ("__builtin_")) != 0) \
3186 decl = lang_hooks.builtin_function (NAME, builtin_types[TYPE], \
3190 ? (NAME + strlen ("__builtin_")) \
3192 built_in_attributes[(int) ATTRS]); \
3194 decl = builtin_function_2 (NAME, \
3195 NAME + strlen ("__builtin_"), \
3196 builtin_types[TYPE], \
3197 builtin_types[LIBTYPE], \
3202 built_in_attributes[(int) ATTRS]); \
3204 built_in_decls[(int) ENUM] = decl; \
3206 implicit_built_in_decls[(int) ENUM] = decl; \
3208 #include "builtins.def"
3211 targetm.init_builtins ();
3215 main_identifier_node = get_identifier ("main");
3219 build_va_arg (tree expr, tree type)
3221 return build1 (VA_ARG_EXPR, type, expr);
3225 /* Linked list of disabled built-in functions. */
3227 typedef struct disabled_builtin
3230 struct disabled_builtin *next;
3232 static disabled_builtin *disabled_builtins = NULL;
3234 static bool builtin_function_disabled_p (const char *);
3236 /* Disable a built-in function specified by -fno-builtin-NAME. If NAME
3237 begins with "__builtin_", give an error. */
3240 disable_builtin_function (const char *name)
3242 if (strncmp (name, "__builtin_", strlen ("__builtin_")) == 0)
3243 error ("cannot disable built-in function `%s'", name);
3246 disabled_builtin *new_disabled_builtin = XNEW (disabled_builtin);
3247 new_disabled_builtin->name = name;
3248 new_disabled_builtin->next = disabled_builtins;
3249 disabled_builtins = new_disabled_builtin;
3254 /* Return true if the built-in function NAME has been disabled, false
3258 builtin_function_disabled_p (const char *name)
3260 disabled_builtin *p;
3261 for (p = disabled_builtins; p != NULL; p = p->next)
3263 if (strcmp (name, p->name) == 0)
3270 /* Possibly define a builtin function with one or two names. BUILTIN_NAME
3271 is an __builtin_-prefixed name; NAME is the ordinary name; one or both
3272 of these may be NULL (though both being NULL is useless).
3273 BUILTIN_TYPE is the type of the __builtin_-prefixed function;
3274 TYPE is the type of the function with the ordinary name. These
3275 may differ if the ordinary name is declared with a looser type to avoid
3276 conflicts with headers. FUNCTION_CODE and CL are as for
3277 builtin_function. If LIBRARY_NAME_P is nonzero, NAME is passed as
3278 the LIBRARY_NAME parameter to builtin_function when declaring BUILTIN_NAME.
3279 If NONANSI_P is true, the name NAME is treated as a non-ANSI name;
3280 ATTRS is the tree list representing the builtin's function attributes.
3281 Returns the declaration of BUILTIN_NAME, if any, otherwise
3282 the declaration of NAME. Does not declare NAME if flag_no_builtin,
3283 or if NONANSI_P and flag_no_nonansi_builtin. */
3286 builtin_function_2 (const char *builtin_name, const char *name,
3287 tree builtin_type, tree type,
3288 enum built_in_function function_code,
3289 enum built_in_class cl, int library_name_p,
3290 bool nonansi_p, tree attrs)
3292 tree bdecl = NULL_TREE;
3293 tree decl = NULL_TREE;
3295 if (builtin_name != 0)
3296 bdecl = lang_hooks.builtin_function (builtin_name, builtin_type,
3298 library_name_p ? name : NULL, attrs);
3300 if (name != 0 && !flag_no_builtin && !builtin_function_disabled_p (name)
3301 && !(nonansi_p && flag_no_nonansi_builtin))
3302 decl = lang_hooks.builtin_function (name, type, function_code, cl,
3305 return (bdecl != 0 ? bdecl : decl);
3308 /* Nonzero if the type T promotes to int. This is (nearly) the
3309 integral promotions defined in ISO C99 6.3.1.1/2. */
3312 c_promoting_integer_type_p (tree t)
3314 switch (TREE_CODE (t))
3317 return (TYPE_MAIN_VARIANT (t) == char_type_node
3318 || TYPE_MAIN_VARIANT (t) == signed_char_type_node
3319 || TYPE_MAIN_VARIANT (t) == unsigned_char_type_node
3320 || TYPE_MAIN_VARIANT (t) == short_integer_type_node
3321 || TYPE_MAIN_VARIANT (t) == short_unsigned_type_node
3322 || TYPE_PRECISION (t) < TYPE_PRECISION (integer_type_node));
3325 /* ??? Technically all enumerations not larger than an int
3326 promote to an int. But this is used along code paths
3327 that only want to notice a size change. */
3328 return TYPE_PRECISION (t) < TYPE_PRECISION (integer_type_node);
3338 /* Return 1 if PARMS specifies a fixed number of parameters
3339 and none of their types is affected by default promotions. */
3342 self_promoting_args_p (tree parms)
3345 for (t = parms; t; t = TREE_CHAIN (t))
3347 tree type = TREE_VALUE (t);
3349 if (TREE_CHAIN (t) == 0 && type != void_type_node)
3355 if (TYPE_MAIN_VARIANT (type) == float_type_node)
3358 if (c_promoting_integer_type_p (type))
3364 /* Recursively examines the array elements of TYPE, until a non-array
3365 element type is found. */
3368 strip_array_types (tree type)
3370 while (TREE_CODE (type) == ARRAY_TYPE)
3371 type = TREE_TYPE (type);
3376 /* Recursively remove any '*' or '&' operator from TYPE. */
3378 strip_pointer_operator (tree t)
3380 while (POINTER_TYPE_P (t))
3385 /* Walk the statement tree, rooted at *tp. Apply FUNC to all the
3386 sub-trees of *TP in a pre-order traversal. FUNC is called with the
3387 DATA and the address of each sub-tree. If FUNC returns a non-NULL
3388 value, the traversal is aborted, and the value returned by FUNC is
3389 returned. If FUNC sets WALK_SUBTREES to zero, then the subtrees of
3390 the node being visited are not walked.
3392 We don't need a without_duplicates variant of this one because the
3393 statement tree is a tree, not a graph. */
3396 walk_stmt_tree (tree *tp, walk_tree_fn func, void *data)
3398 enum tree_code code;
3403 #define WALK_SUBTREE(NODE) \
3406 result = walk_stmt_tree (&(NODE), func, data); \
3412 /* Skip empty subtrees. */
3416 /* Skip subtrees below non-statement nodes. */
3417 if (!STATEMENT_CODE_P (TREE_CODE (*tp)))
3420 /* Call the function. */
3422 result = (*func) (tp, &walk_subtrees, data);
3424 /* If we found something, return it. */
3428 /* FUNC may have modified the tree, recheck that we're looking at a
3430 code = TREE_CODE (*tp);
3431 if (!STATEMENT_CODE_P (code))
3434 /* Visit the subtrees unless FUNC decided that there was nothing
3435 interesting below this point in the tree. */
3438 /* Walk over all the sub-trees of this operand. Statement nodes
3439 never contain RTL, and we needn't worry about TARGET_EXPRs. */
3440 len = TREE_CODE_LENGTH (code);
3442 /* Go through the subtrees. We need to do this in forward order so
3443 that the scope of a FOR_EXPR is handled properly. */
3444 for (i = 0; i < len; ++i)
3445 WALK_SUBTREE (TREE_OPERAND (*tp, i));
3448 /* Finally visit the chain. This can be tail-recursion optimized if
3449 we write it this way. */
3450 return walk_stmt_tree (&TREE_CHAIN (*tp), func, data);
3455 /* Used to compare case labels. K1 and K2 are actually tree nodes
3456 representing case labels, or NULL_TREE for a `default' label.
3457 Returns -1 if K1 is ordered before K2, -1 if K1 is ordered after
3458 K2, and 0 if K1 and K2 are equal. */
3461 case_compare (splay_tree_key k1, splay_tree_key k2)
3463 /* Consider a NULL key (such as arises with a `default' label) to be
3464 smaller than anything else. */
3470 return tree_int_cst_compare ((tree) k1, (tree) k2);
3473 /* Process a case label for the range LOW_VALUE ... HIGH_VALUE. If
3474 LOW_VALUE and HIGH_VALUE are both NULL_TREE then this case label is
3475 actually a `default' label. If only HIGH_VALUE is NULL_TREE, then
3476 case label was declared using the usual C/C++ syntax, rather than
3477 the GNU case range extension. CASES is a tree containing all the
3478 case ranges processed so far; COND is the condition for the
3479 switch-statement itself. Returns the CASE_LABEL_EXPR created, or
3480 ERROR_MARK_NODE if no CASE_LABEL_EXPR is created. */
3483 c_add_case_label (splay_tree cases, tree cond, tree orig_type,
3484 tree low_value, tree high_value)
3489 splay_tree_node node;
3491 /* Create the LABEL_DECL itself. */
3492 label = create_artificial_label ();
3494 /* If there was an error processing the switch condition, bail now
3495 before we get more confused. */
3496 if (!cond || cond == error_mark_node)
3499 if ((low_value && TREE_TYPE (low_value)
3500 && POINTER_TYPE_P (TREE_TYPE (low_value)))
3501 || (high_value && TREE_TYPE (high_value)
3502 && POINTER_TYPE_P (TREE_TYPE (high_value))))
3503 error ("pointers are not permitted as case values");
3505 /* Case ranges are a GNU extension. */
3506 if (high_value && pedantic)
3507 pedwarn ("range expressions in switch statements are non-standard");
3509 type = TREE_TYPE (cond);
3512 low_value = check_case_value (low_value);
3513 low_value = convert_and_check (type, low_value);
3517 high_value = check_case_value (high_value);
3518 high_value = convert_and_check (type, high_value);
3521 /* If an error has occurred, bail out now. */
3522 if (low_value == error_mark_node || high_value == error_mark_node)
3525 /* If the LOW_VALUE and HIGH_VALUE are the same, then this isn't
3526 really a case range, even though it was written that way. Remove
3527 the HIGH_VALUE to simplify later processing. */
3528 if (tree_int_cst_equal (low_value, high_value))
3529 high_value = NULL_TREE;
3530 if (low_value && high_value
3531 && !tree_int_cst_lt (low_value, high_value))
3532 warning ("empty range specified");
3534 /* See if the case is in range of the type of the original testing
3535 expression. If both low_value and high_value are out of range,
3536 don't insert the case label and return NULL_TREE. */
3538 && ! check_case_bounds (type, orig_type,
3539 &low_value, high_value ? &high_value : NULL))
3542 /* Look up the LOW_VALUE in the table of case labels we already
3544 node = splay_tree_lookup (cases, (splay_tree_key) low_value);
3545 /* If there was not an exact match, check for overlapping ranges.
3546 There's no need to do this if there's no LOW_VALUE or HIGH_VALUE;
3547 that's a `default' label and the only overlap is an exact match. */
3548 if (!node && (low_value || high_value))
3550 splay_tree_node low_bound;
3551 splay_tree_node high_bound;
3553 /* Even though there wasn't an exact match, there might be an
3554 overlap between this case range and another case range.
3555 Since we've (inductively) not allowed any overlapping case
3556 ranges, we simply need to find the greatest low case label
3557 that is smaller that LOW_VALUE, and the smallest low case
3558 label that is greater than LOW_VALUE. If there is an overlap
3559 it will occur in one of these two ranges. */
3560 low_bound = splay_tree_predecessor (cases,
3561 (splay_tree_key) low_value);
3562 high_bound = splay_tree_successor (cases,
3563 (splay_tree_key) low_value);
3565 /* Check to see if the LOW_BOUND overlaps. It is smaller than
3566 the LOW_VALUE, so there is no need to check unless the
3567 LOW_BOUND is in fact itself a case range. */
3569 && CASE_HIGH ((tree) low_bound->value)
3570 && tree_int_cst_compare (CASE_HIGH ((tree) low_bound->value),
3573 /* Check to see if the HIGH_BOUND overlaps. The low end of that
3574 range is bigger than the low end of the current range, so we
3575 are only interested if the current range is a real range, and
3576 not an ordinary case label. */
3579 && (tree_int_cst_compare ((tree) high_bound->key,
3584 /* If there was an overlap, issue an error. */
3587 tree duplicate = CASE_LABEL ((tree) node->value);
3591 error ("duplicate (or overlapping) case value");
3592 error ("%Jthis is the first entry overlapping that value", duplicate);
3596 error ("duplicate case value") ;
3597 error ("%Jpreviously used here", duplicate);
3601 error ("multiple default labels in one switch");
3602 error ("%Jthis is the first default label", duplicate);
3607 /* Add a CASE_LABEL to the statement-tree. */
3608 case_label = add_stmt (build_case_label (low_value, high_value, label));
3609 /* Register this case label in the splay tree. */
3610 splay_tree_insert (cases,
3611 (splay_tree_key) low_value,
3612 (splay_tree_value) case_label);
3617 /* Add a label so that the back-end doesn't think that the beginning of
3618 the switch is unreachable. Note that we do not add a case label, as
3619 that just leads to duplicates and thence to aborts later on. */
3622 tree t = create_artificial_label ();
3623 add_stmt (build_stmt (LABEL_EXPR, t));
3625 return error_mark_node;
3628 /* Subroutines of c_do_switch_warnings, called via splay_tree_foreach.
3629 Used to verify that case values match up with enumerator values. */
3632 match_case_to_enum_1 (tree key, tree type, tree label)
3634 char buf[2 + 2*HOST_BITS_PER_WIDE_INT/4 + 1];
3636 /* ??? Not working too hard to print the double-word value.
3637 Should perhaps be done with %lwd in the diagnostic routines? */
3638 if (TREE_INT_CST_HIGH (key) == 0)
3639 snprintf (buf, sizeof (buf), HOST_WIDE_INT_PRINT_UNSIGNED,
3640 TREE_INT_CST_LOW (key));
3641 else if (!TYPE_UNSIGNED (type)
3642 && TREE_INT_CST_HIGH (key) == -1
3643 && TREE_INT_CST_LOW (key) != 0)
3644 snprintf (buf, sizeof (buf), "-" HOST_WIDE_INT_PRINT_UNSIGNED,
3645 -TREE_INT_CST_LOW (key));
3647 snprintf (buf, sizeof (buf), HOST_WIDE_INT_PRINT_DOUBLE_HEX,
3648 TREE_INT_CST_HIGH (key), TREE_INT_CST_LOW (key));
3650 if (TYPE_NAME (type) == 0)
3651 warning ("%Jcase value `%s' not in enumerated type",
3652 CASE_LABEL (label), buf);
3654 warning ("%Jcase value `%s' not in enumerated type `%T'",
3655 CASE_LABEL (label), buf, type);
3659 match_case_to_enum (splay_tree_node node, void *data)
3661 tree label = (tree) node->value;
3662 tree type = (tree) data;
3664 /* Skip default case. */
3665 if (!CASE_LOW (label))
3668 /* If TREE_ADDRESSABLE is not set, that means CASE_LOW did not appear
3669 when we did our enum->case scan. Reset our scratch bit after. */
3670 if (!TREE_ADDRESSABLE (label))
3671 match_case_to_enum_1 (CASE_LOW (label), type, label);
3673 TREE_ADDRESSABLE (label) = 0;
3675 /* If CASE_HIGH is non-null, we have a range. Here we must search.
3676 Note that the old code in stmt.c did not check for the values in
3677 the range either, just the endpoints. */
3678 if (CASE_HIGH (label))
3680 tree chain, key = CASE_HIGH (label);
3682 for (chain = TYPE_VALUES (type);
3683 chain && !tree_int_cst_equal (key, TREE_VALUE (chain));
3684 chain = TREE_CHAIN (chain))
3687 match_case_to_enum_1 (key, type, label);
3693 /* Handle -Wswitch*. Called from the front end after parsing the switch
3695 /* ??? Should probably be somewhere generic, since other languages besides
3696 C and C++ would want this. We'd want to agree on the datastructure,
3697 however, which is a problem. Alternately, we operate on gimplified
3698 switch_exprs, which I don't especially like. At the moment, however,
3699 C/C++ are the only tree-ssa languages that support enumerations at all,
3700 so the point is moot. */
3703 c_do_switch_warnings (splay_tree cases, tree switch_stmt)
3705 splay_tree_node default_node;
3706 location_t switch_location;
3709 if (!warn_switch && !warn_switch_enum && !warn_switch_default)
3712 if (EXPR_HAS_LOCATION (switch_stmt))
3713 switch_location = EXPR_LOCATION (switch_stmt);
3715 switch_location = input_location;
3717 type = SWITCH_TYPE (switch_stmt);
3719 default_node = splay_tree_lookup (cases, (splay_tree_key) NULL);
3720 if (warn_switch_default && !default_node)
3721 warning ("%Hswitch missing default case", &switch_location);
3723 /* If the switch expression was an enumerated type, check that
3724 exactly all enumeration literals are covered by the cases.
3725 The check is made when -Wswitch was specified and there is no
3726 default case, or when -Wswitch-enum was specified. */
3727 if (((warn_switch && !default_node) || warn_switch_enum)
3728 && type && TREE_CODE (type) == ENUMERAL_TYPE
3729 && TREE_CODE (SWITCH_COND (switch_stmt)) != INTEGER_CST)
3733 /* The time complexity here is O(N*lg(N)) worst case, but for the
3734 common case of monotonically increasing enumerators, it is
3735 O(N), since the nature of the splay tree will keep the next
3736 element adjacent to the root at all times. */
3738 for (chain = TYPE_VALUES (type); chain; chain = TREE_CHAIN (chain))
3740 splay_tree_node node
3741 = splay_tree_lookup (cases, (splay_tree_key) TREE_VALUE (chain));
3745 /* Mark the CASE_LOW part of the case entry as seen, so
3746 that we save time later. Choose TREE_ADDRESSABLE
3747 randomly as a bit that won't have been set to-date. */
3748 tree label = (tree) node->value;
3749 TREE_ADDRESSABLE (label) = 1;
3753 /* Warn if there are enumerators that don't correspond to
3754 case expressions. */
3755 warning ("%Henumeration value `%E' not handled in switch",
3756 &switch_location, TREE_PURPOSE (chain));
3760 /* Warn if there are case expressions that don't correspond to
3761 enumerators. This can occur since C and C++ don't enforce
3762 type-checking of assignments to enumeration variables.
3764 The time complexity here is O(N**2) worst case, since we've
3765 not sorted the enumeration values. However, in the absence
3766 of case ranges this is O(N), since all single cases that
3767 corresponded to enumerations have been marked above. */
3769 splay_tree_foreach (cases, match_case_to_enum, type);
3773 /* Finish an expression taking the address of LABEL (an
3774 IDENTIFIER_NODE). Returns an expression for the address. */
3777 finish_label_address_expr (tree label)
3782 pedwarn ("taking the address of a label is non-standard");
3784 if (label == error_mark_node)
3785 return error_mark_node;
3787 label = lookup_label (label);
3788 if (label == NULL_TREE)
3789 result = null_pointer_node;
3792 TREE_USED (label) = 1;
3793 result = build1 (ADDR_EXPR, ptr_type_node, label);
3794 /* The current function in not necessarily uninlinable.
3795 Computed gotos are incompatible with inlining, but the value
3796 here could be used only in a diagnostic, for example. */
3802 /* Hook used by expand_expr to expand language-specific tree codes. */
3803 /* The only things that should go here are bits needed to expand
3804 constant initializers. Everything else should be handled by the
3805 gimplification routines. */
3808 c_expand_expr (tree exp, rtx target, enum machine_mode tmode,
3809 int modifier /* Actually enum_modifier. */,
3812 switch (TREE_CODE (exp))
3814 case COMPOUND_LITERAL_EXPR:
3816 /* Initialize the anonymous variable declared in the compound
3817 literal, then return the variable. */
3818 tree decl = COMPOUND_LITERAL_EXPR_DECL (exp);
3819 emit_local_var (decl);
3820 return expand_expr_real (decl, target, tmode, modifier, alt_rtl);
3828 /* Hook used by staticp to handle language-specific tree codes. */
3831 c_staticp (tree exp)
3833 if (TREE_CODE (exp) == COMPOUND_LITERAL_EXPR
3834 && TREE_STATIC (COMPOUND_LITERAL_EXPR_DECL (exp)))
3840 /* Given a boolean expression ARG, return a tree representing an increment
3841 or decrement (as indicated by CODE) of ARG. The front end must check for
3842 invalid cases (e.g., decrement in C++). */
3844 boolean_increment (enum tree_code code, tree arg)
3847 tree true_res = boolean_true_node;
3849 arg = stabilize_reference (arg);
3852 case PREINCREMENT_EXPR:
3853 val = build (MODIFY_EXPR, TREE_TYPE (arg), arg, true_res);
3855 case POSTINCREMENT_EXPR:
3856 val = build (MODIFY_EXPR, TREE_TYPE (arg), arg, true_res);
3857 arg = save_expr (arg);
3858 val = build (COMPOUND_EXPR, TREE_TYPE (arg), val, arg);
3859 val = build (COMPOUND_EXPR, TREE_TYPE (arg), arg, val);
3861 case PREDECREMENT_EXPR:
3862 val = build (MODIFY_EXPR, TREE_TYPE (arg), arg, invert_truthvalue (arg));
3864 case POSTDECREMENT_EXPR:
3865 val = build (MODIFY_EXPR, TREE_TYPE (arg), arg, invert_truthvalue (arg));
3866 arg = save_expr (arg);
3867 val = build (COMPOUND_EXPR, TREE_TYPE (arg), val, arg);
3868 val = build (COMPOUND_EXPR, TREE_TYPE (arg), arg, val);
3873 TREE_SIDE_EFFECTS (val) = 1;
3877 /* Built-in macros for stddef.h, that require macros defined in this
3880 c_stddef_cpp_builtins(void)
3882 builtin_define_with_value ("__SIZE_TYPE__", SIZE_TYPE, 0);
3883 builtin_define_with_value ("__PTRDIFF_TYPE__", PTRDIFF_TYPE, 0);
3884 builtin_define_with_value ("__WCHAR_TYPE__", MODIFIED_WCHAR_TYPE, 0);
3885 builtin_define_with_value ("__WINT_TYPE__", WINT_TYPE, 0);
3889 c_init_attributes (void)
3891 /* Fill in the built_in_attributes array. */
3892 #define DEF_ATTR_NULL_TREE(ENUM) \
3893 built_in_attributes[(int) ENUM] = NULL_TREE;
3894 #define DEF_ATTR_INT(ENUM, VALUE) \
3895 built_in_attributes[(int) ENUM] = build_int_2 (VALUE, VALUE < 0 ? -1 : 0);
3896 #define DEF_ATTR_IDENT(ENUM, STRING) \
3897 built_in_attributes[(int) ENUM] = get_identifier (STRING);
3898 #define DEF_ATTR_TREE_LIST(ENUM, PURPOSE, VALUE, CHAIN) \
3899 built_in_attributes[(int) ENUM] \
3900 = tree_cons (built_in_attributes[(int) PURPOSE], \
3901 built_in_attributes[(int) VALUE], \
3902 built_in_attributes[(int) CHAIN]);
3903 #include "builtin-attrs.def"
3904 #undef DEF_ATTR_NULL_TREE
3906 #undef DEF_ATTR_IDENT
3907 #undef DEF_ATTR_TREE_LIST
3910 /* Attribute handlers common to C front ends. */
3912 /* Handle a "packed" attribute; arguments as in
3913 struct attribute_spec.handler. */
3916 handle_packed_attribute (tree *node, tree name, tree ARG_UNUSED (args),
3917 int flags, bool *no_add_attrs)
3921 if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
3922 *node = build_type_copy (*node);
3923 TYPE_PACKED (*node) = 1;
3924 if (TYPE_MAIN_VARIANT (*node) == *node)
3926 /* If it is the main variant, then pack the other variants
3927 too. This happens in,
3930 struct Foo const *ptr; // creates a variant w/o packed flag
3931 } __ attribute__((packed)); // packs it now.
3935 for (probe = *node; probe; probe = TYPE_NEXT_VARIANT (probe))
3936 TYPE_PACKED (probe) = 1;
3940 else if (TREE_CODE (*node) == FIELD_DECL)
3941 DECL_PACKED (*node) = 1;
3942 /* We can't set DECL_PACKED for a VAR_DECL, because the bit is
3943 used for DECL_REGISTER. It wouldn't mean anything anyway.
3944 We can't set DECL_PACKED on the type of a TYPE_DECL, because
3945 that changes what the typedef is typing. */
3948 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
3949 *no_add_attrs = true;
3955 /* Handle a "nocommon" attribute; arguments as in
3956 struct attribute_spec.handler. */
3959 handle_nocommon_attribute (tree *node, tree name,
3960 tree ARG_UNUSED (args),
3961 int ARG_UNUSED (flags), bool *no_add_attrs)
3963 if (TREE_CODE (*node) == VAR_DECL)
3964 DECL_COMMON (*node) = 0;
3967 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
3968 *no_add_attrs = true;
3974 /* Handle a "common" attribute; arguments as in
3975 struct attribute_spec.handler. */
3978 handle_common_attribute (tree *node, tree name, tree ARG_UNUSED (args),
3979 int ARG_UNUSED (flags), bool *no_add_attrs)
3981 if (TREE_CODE (*node) == VAR_DECL)
3982 DECL_COMMON (*node) = 1;
3985 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
3986 *no_add_attrs = true;
3992 /* Handle a "noreturn" attribute; arguments as in
3993 struct attribute_spec.handler. */
3996 handle_noreturn_attribute (tree *node, tree name, tree ARG_UNUSED (args),
3997 int ARG_UNUSED (flags), bool *no_add_attrs)
3999 tree type = TREE_TYPE (*node);
4001 /* See FIXME comment in c_common_attribute_table. */
4002 if (TREE_CODE (*node) == FUNCTION_DECL)
4003 TREE_THIS_VOLATILE (*node) = 1;
4004 else if (TREE_CODE (type) == POINTER_TYPE
4005 && TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE)
4007 = build_pointer_type
4008 (build_type_variant (TREE_TYPE (type),
4009 TYPE_READONLY (TREE_TYPE (type)), 1));
4012 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
4013 *no_add_attrs = true;
4019 /* Handle a "noinline" attribute; arguments as in
4020 struct attribute_spec.handler. */
4023 handle_noinline_attribute (tree *node, tree name,
4024 tree ARG_UNUSED (args),
4025 int ARG_UNUSED (flags), bool *no_add_attrs)
4027 if (TREE_CODE (*node) == FUNCTION_DECL)
4028 DECL_UNINLINABLE (*node) = 1;
4031 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
4032 *no_add_attrs = true;
4038 /* Handle a "always_inline" attribute; arguments as in
4039 struct attribute_spec.handler. */
4042 handle_always_inline_attribute (tree *node, tree name,
4043 tree ARG_UNUSED (args),
4044 int ARG_UNUSED (flags),
4047 if (TREE_CODE (*node) == FUNCTION_DECL)
4049 /* Do nothing else, just set the attribute. We'll get at
4050 it later with lookup_attribute. */
4054 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
4055 *no_add_attrs = true;
4061 /* Handle a "used" attribute; arguments as in
4062 struct attribute_spec.handler. */
4065 handle_used_attribute (tree *pnode, tree name, tree ARG_UNUSED (args),
4066 int ARG_UNUSED (flags), bool *no_add_attrs)
4070 if (TREE_CODE (node) == FUNCTION_DECL
4071 || (TREE_CODE (node) == VAR_DECL && TREE_STATIC (node)))
4073 TREE_USED (node) = 1;
4077 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
4078 *no_add_attrs = true;
4084 /* Handle a "unused" attribute; arguments as in
4085 struct attribute_spec.handler. */
4088 handle_unused_attribute (tree *node, tree name, tree ARG_UNUSED (args),
4089 int flags, bool *no_add_attrs)
4095 if (TREE_CODE (decl) == PARM_DECL
4096 || TREE_CODE (decl) == VAR_DECL
4097 || TREE_CODE (decl) == FUNCTION_DECL
4098 || TREE_CODE (decl) == LABEL_DECL
4099 || TREE_CODE (decl) == TYPE_DECL)
4100 TREE_USED (decl) = 1;
4103 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
4104 *no_add_attrs = true;
4109 if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
4110 *node = build_type_copy (*node);
4111 TREE_USED (*node) = 1;
4117 /* Handle a "const" attribute; arguments as in
4118 struct attribute_spec.handler. */
4121 handle_const_attribute (tree *node, tree name, tree ARG_UNUSED (args),
4122 int ARG_UNUSED (flags), bool *no_add_attrs)
4124 tree type = TREE_TYPE (*node);
4126 /* See FIXME comment on noreturn in c_common_attribute_table. */
4127 if (TREE_CODE (*node) == FUNCTION_DECL)
4128 TREE_READONLY (*node) = 1;
4129 else if (TREE_CODE (type) == POINTER_TYPE
4130 && TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE)
4132 = build_pointer_type
4133 (build_type_variant (TREE_TYPE (type), 1,
4134 TREE_THIS_VOLATILE (TREE_TYPE (type))));
4137 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
4138 *no_add_attrs = true;
4144 /* Handle a "transparent_union" attribute; arguments as in
4145 struct attribute_spec.handler. */
4148 handle_transparent_union_attribute (tree *node, tree name,
4149 tree ARG_UNUSED (args), int flags,
4152 tree decl = NULL_TREE;
4159 type = &TREE_TYPE (decl);
4160 is_type = TREE_CODE (*node) == TYPE_DECL;
4162 else if (TYPE_P (*node))
4163 type = node, is_type = 1;
4166 && TREE_CODE (*type) == UNION_TYPE
4168 || (TYPE_FIELDS (*type) != 0
4169 && TYPE_MODE (*type) == DECL_MODE (TYPE_FIELDS (*type)))))
4171 if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
4172 *type = build_type_copy (*type);
4173 TYPE_TRANSPARENT_UNION (*type) = 1;
4175 else if (decl != 0 && TREE_CODE (decl) == PARM_DECL
4176 && TREE_CODE (*type) == UNION_TYPE
4177 && TYPE_MODE (*type) == DECL_MODE (TYPE_FIELDS (*type)))
4178 DECL_TRANSPARENT_UNION (decl) = 1;
4181 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
4182 *no_add_attrs = true;
4188 /* Handle a "constructor" attribute; arguments as in
4189 struct attribute_spec.handler. */
4192 handle_constructor_attribute (tree *node, tree name,
4193 tree ARG_UNUSED (args),
4194 int ARG_UNUSED (flags),
4198 tree type = TREE_TYPE (decl);
4200 if (TREE_CODE (decl) == FUNCTION_DECL
4201 && TREE_CODE (type) == FUNCTION_TYPE
4202 && decl_function_context (decl) == 0)
4204 DECL_STATIC_CONSTRUCTOR (decl) = 1;
4205 TREE_USED (decl) = 1;
4209 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
4210 *no_add_attrs = true;
4216 /* Handle a "destructor" attribute; arguments as in
4217 struct attribute_spec.handler. */
4220 handle_destructor_attribute (tree *node, tree name,
4221 tree ARG_UNUSED (args),
4222 int ARG_UNUSED (flags),
4226 tree type = TREE_TYPE (decl);
4228 if (TREE_CODE (decl) == FUNCTION_DECL
4229 && TREE_CODE (type) == FUNCTION_TYPE
4230 && decl_function_context (decl) == 0)
4232 DECL_STATIC_DESTRUCTOR (decl) = 1;
4233 TREE_USED (decl) = 1;
4237 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
4238 *no_add_attrs = true;
4244 /* Handle a "mode" attribute; arguments as in
4245 struct attribute_spec.handler. */
4248 handle_mode_attribute (tree *node, tree name, tree args,
4249 int ARG_UNUSED (flags), bool *no_add_attrs)
4253 *no_add_attrs = true;
4255 if (TREE_CODE (TREE_VALUE (args)) != IDENTIFIER_NODE)
4256 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
4260 const char *p = IDENTIFIER_POINTER (TREE_VALUE (args));
4261 int len = strlen (p);
4262 enum machine_mode mode = VOIDmode;
4266 if (len > 4 && p[0] == '_' && p[1] == '_'
4267 && p[len - 1] == '_' && p[len - 2] == '_')
4269 char *newp = (char *) alloca (len - 1);
4271 strcpy (newp, &p[2]);
4272 newp[len - 4] = '\0';
4276 /* Change this type to have a type with the specified mode.
4277 First check for the special modes. */
4278 if (! strcmp (p, "byte"))
4280 else if (!strcmp (p, "word"))
4282 else if (! strcmp (p, "pointer"))
4285 for (j = 0; j < NUM_MACHINE_MODES; j++)
4286 if (!strcmp (p, GET_MODE_NAME (j)))
4287 mode = (enum machine_mode) j;
4289 if (mode == VOIDmode)
4291 error ("unknown machine mode `%s'", p);
4295 if (VECTOR_MODE_P (mode))
4297 warning ("specifying vector types with __attribute__ ((mode)) "
4299 warning ("use __attribute__ ((vector_size)) instead");
4302 typefm = lang_hooks.types.type_for_mode (mode, TYPE_UNSIGNED (type));
4303 if (typefm == NULL_TREE)
4304 error ("no data type for mode `%s'", p);
4306 else if ((TREE_CODE (type) == POINTER_TYPE
4307 || TREE_CODE (type) == REFERENCE_TYPE)
4308 && !targetm.valid_pointer_mode (mode))
4309 error ("invalid pointer mode `%s'", p);
4312 /* If this is a vector, make sure we either have hardware
4313 support, or we can emulate it. */
4314 if (VECTOR_MODE_P (mode) && !vector_mode_valid_p (mode))
4316 error ("unable to emulate '%s'", GET_MODE_NAME (mode));
4320 if (TREE_CODE (type) == POINTER_TYPE)
4322 ptr_type = build_pointer_type_for_mode (TREE_TYPE (type),
4326 else if (TREE_CODE (type) == REFERENCE_TYPE)
4328 ptr_type = build_reference_type_for_mode (TREE_TYPE (type),
4334 /* No need to layout the type here. The caller should do this. */
4341 /* Handle a "section" attribute; arguments as in
4342 struct attribute_spec.handler. */
4345 handle_section_attribute (tree *node, tree ARG_UNUSED (name), tree args,
4346 int ARG_UNUSED (flags), bool *no_add_attrs)
4350 if (targetm.have_named_sections)
4352 if ((TREE_CODE (decl) == FUNCTION_DECL
4353 || TREE_CODE (decl) == VAR_DECL)
4354 && TREE_CODE (TREE_VALUE (args)) == STRING_CST)
4356 if (TREE_CODE (decl) == VAR_DECL
4357 && current_function_decl != NULL_TREE
4358 && ! TREE_STATIC (decl))
4360 error ("%Jsection attribute cannot be specified for "
4361 "local variables", decl);
4362 *no_add_attrs = true;
4365 /* The decl may have already been given a section attribute
4366 from a previous declaration. Ensure they match. */
4367 else if (DECL_SECTION_NAME (decl) != NULL_TREE
4368 && strcmp (TREE_STRING_POINTER (DECL_SECTION_NAME (decl)),
4369 TREE_STRING_POINTER (TREE_VALUE (args))) != 0)
4371 error ("%Jsection of '%D' conflicts with previous declaration",
4373 *no_add_attrs = true;
4376 DECL_SECTION_NAME (decl) = TREE_VALUE (args);
4380 error ("%Jsection attribute not allowed for '%D'", *node, *node);
4381 *no_add_attrs = true;
4386 error ("%Jsection attributes are not supported for this target", *node);
4387 *no_add_attrs = true;
4393 /* Handle a "aligned" attribute; arguments as in
4394 struct attribute_spec.handler. */
4397 handle_aligned_attribute (tree *node, tree ARG_UNUSED (name), tree args,
4398 int flags, bool *no_add_attrs)
4400 tree decl = NULL_TREE;
4403 tree align_expr = (args ? TREE_VALUE (args)
4404 : size_int (BIGGEST_ALIGNMENT / BITS_PER_UNIT));
4410 type = &TREE_TYPE (decl);
4411 is_type = TREE_CODE (*node) == TYPE_DECL;
4413 else if (TYPE_P (*node))
4414 type = node, is_type = 1;
4416 /* Strip any NOPs of any kind. */
4417 while (TREE_CODE (align_expr) == NOP_EXPR
4418 || TREE_CODE (align_expr) == CONVERT_EXPR
4419 || TREE_CODE (align_expr) == NON_LVALUE_EXPR)
4420 align_expr = TREE_OPERAND (align_expr, 0);
4422 if (TREE_CODE (align_expr) != INTEGER_CST)
4424 error ("requested alignment is not a constant");
4425 *no_add_attrs = true;
4427 else if ((i = tree_log2 (align_expr)) == -1)
4429 error ("requested alignment is not a power of 2");
4430 *no_add_attrs = true;
4432 else if (i > HOST_BITS_PER_INT - 2)
4434 error ("requested alignment is too large");
4435 *no_add_attrs = true;
4439 /* If we have a TYPE_DECL, then copy the type, so that we
4440 don't accidentally modify a builtin type. See pushdecl. */
4441 if (decl && TREE_TYPE (decl) != error_mark_node
4442 && DECL_ORIGINAL_TYPE (decl) == NULL_TREE)
4444 tree tt = TREE_TYPE (decl);
4445 *type = build_type_copy (*type);
4446 DECL_ORIGINAL_TYPE (decl) = tt;
4447 TYPE_NAME (*type) = decl;
4448 TREE_USED (*type) = TREE_USED (decl);
4449 TREE_TYPE (decl) = *type;
4451 else if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
4452 *type = build_type_copy (*type);
4454 TYPE_ALIGN (*type) = (1 << i) * BITS_PER_UNIT;
4455 TYPE_USER_ALIGN (*type) = 1;
4457 else if (TREE_CODE (decl) != VAR_DECL
4458 && TREE_CODE (decl) != FIELD_DECL)
4460 error ("%Jalignment may not be specified for '%D'", decl, decl);
4461 *no_add_attrs = true;
4465 DECL_ALIGN (decl) = (1 << i) * BITS_PER_UNIT;
4466 DECL_USER_ALIGN (decl) = 1;
4472 /* Handle a "weak" attribute; arguments as in
4473 struct attribute_spec.handler. */
4476 handle_weak_attribute (tree *node, tree ARG_UNUSED (name),
4477 tree ARG_UNUSED (args),
4478 int ARG_UNUSED (flags),
4479 bool * ARG_UNUSED (no_add_attrs))
4481 declare_weak (*node);
4486 /* Handle an "alias" attribute; arguments as in
4487 struct attribute_spec.handler. */
4490 handle_alias_attribute (tree *node, tree name, tree args,
4491 int ARG_UNUSED (flags), bool *no_add_attrs)
4495 if ((TREE_CODE (decl) == FUNCTION_DECL && DECL_INITIAL (decl))
4496 || (TREE_CODE (decl) != FUNCTION_DECL && ! DECL_EXTERNAL (decl)))
4498 error ("%J'%D' defined both normally and as an alias", decl, decl);
4499 *no_add_attrs = true;
4502 /* Note that the very first time we process a nested declaration,
4503 decl_function_context will not be set. Indeed, *would* never
4504 be set except for the DECL_INITIAL/DECL_EXTERNAL frobbery that
4505 we do below. After such frobbery, pushdecl would set the context.
4506 In any case, this is never what we want. */
4507 else if (decl_function_context (decl) == 0 && current_function_decl == NULL)
4511 id = TREE_VALUE (args);
4512 if (TREE_CODE (id) != STRING_CST)
4514 error ("alias arg not a string");
4515 *no_add_attrs = true;
4518 id = get_identifier (TREE_STRING_POINTER (id));
4519 /* This counts as a use of the object pointed to. */
4522 if (TREE_CODE (decl) == FUNCTION_DECL)
4523 DECL_INITIAL (decl) = error_mark_node;
4526 DECL_EXTERNAL (decl) = 0;
4527 TREE_STATIC (decl) = 1;
4532 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
4533 *no_add_attrs = true;
4539 /* Handle an "visibility" attribute; arguments as in
4540 struct attribute_spec.handler. */
4543 handle_visibility_attribute (tree *node, tree name, tree args,
4544 int ARG_UNUSED (flags),
4548 tree id = TREE_VALUE (args);
4550 *no_add_attrs = true;
4554 if (TREE_CODE (*node) != RECORD_TYPE && TREE_CODE (*node) != UNION_TYPE)
4556 warning ("`%s' attribute ignored on non-class types",
4557 IDENTIFIER_POINTER (name));
4561 else if (decl_function_context (decl) != 0 || ! TREE_PUBLIC (decl))
4563 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
4567 if (TREE_CODE (id) != STRING_CST)
4569 error ("visibility arg not a string");
4573 /* If this is a type, set the visibility on the type decl. */
4576 decl = TYPE_NAME (decl);
4581 if (strcmp (TREE_STRING_POINTER (id), "default") == 0)
4582 DECL_VISIBILITY (decl) = VISIBILITY_DEFAULT;
4583 else if (strcmp (TREE_STRING_POINTER (id), "internal") == 0)
4584 DECL_VISIBILITY (decl) = VISIBILITY_INTERNAL;
4585 else if (strcmp (TREE_STRING_POINTER (id), "hidden") == 0)
4586 DECL_VISIBILITY (decl) = VISIBILITY_HIDDEN;
4587 else if (strcmp (TREE_STRING_POINTER (id), "protected") == 0)
4588 DECL_VISIBILITY (decl) = VISIBILITY_PROTECTED;
4590 error ("visibility arg must be one of \"default\", \"hidden\", \"protected\" or \"internal\"");
4591 DECL_VISIBILITY_SPECIFIED (decl) = 1;
4593 /* For decls only, go ahead and attach the attribute to the node as well.
4594 This is needed so we can determine whether we have VISIBILITY_DEFAULT
4595 because the visibility was not specified, or because it was explicitly
4596 overridden from the class visibility. */
4598 *no_add_attrs = false;
4603 /* Handle an "tls_model" attribute; arguments as in
4604 struct attribute_spec.handler. */
4607 handle_tls_model_attribute (tree *node, tree name, tree args,
4608 int ARG_UNUSED (flags), bool *no_add_attrs)
4612 if (! DECL_THREAD_LOCAL (decl))
4614 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
4615 *no_add_attrs = true;
4621 id = TREE_VALUE (args);
4622 if (TREE_CODE (id) != STRING_CST)
4624 error ("tls_model arg not a string");
4625 *no_add_attrs = true;
4628 if (strcmp (TREE_STRING_POINTER (id), "local-exec")
4629 && strcmp (TREE_STRING_POINTER (id), "initial-exec")
4630 && strcmp (TREE_STRING_POINTER (id), "local-dynamic")
4631 && strcmp (TREE_STRING_POINTER (id), "global-dynamic"))
4633 error ("tls_model arg must be one of \"local-exec\", \"initial-exec\", \"local-dynamic\" or \"global-dynamic\"");
4634 *no_add_attrs = true;
4642 /* Handle a "no_instrument_function" attribute; arguments as in
4643 struct attribute_spec.handler. */
4646 handle_no_instrument_function_attribute (tree *node, tree name,
4647 tree ARG_UNUSED (args),
4648 int ARG_UNUSED (flags),
4653 if (TREE_CODE (decl) != FUNCTION_DECL)
4655 error ("%J'%E' attribute applies only to functions", decl, name);
4656 *no_add_attrs = true;
4658 else if (DECL_INITIAL (decl))
4660 error ("%Jcan't set '%E' attribute after definition", decl, name);
4661 *no_add_attrs = true;
4664 DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (decl) = 1;
4669 /* Handle a "malloc" attribute; arguments as in
4670 struct attribute_spec.handler. */
4673 handle_malloc_attribute (tree *node, tree name, tree ARG_UNUSED (args),
4674 int ARG_UNUSED (flags), bool *no_add_attrs)
4676 if (TREE_CODE (*node) == FUNCTION_DECL)
4677 DECL_IS_MALLOC (*node) = 1;
4678 /* ??? TODO: Support types. */
4681 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
4682 *no_add_attrs = true;
4688 /* Handle a "no_limit_stack" attribute; arguments as in
4689 struct attribute_spec.handler. */
4692 handle_no_limit_stack_attribute (tree *node, tree name,
4693 tree ARG_UNUSED (args),
4694 int ARG_UNUSED (flags),
4699 if (TREE_CODE (decl) != FUNCTION_DECL)
4701 error ("%J'%E' attribute applies only to functions", decl, name);
4702 *no_add_attrs = true;
4704 else if (DECL_INITIAL (decl))
4706 error ("%Jcan't set '%E' attribute after definition", decl, name);
4707 *no_add_attrs = true;
4710 DECL_NO_LIMIT_STACK (decl) = 1;
4715 /* Handle a "pure" attribute; arguments as in
4716 struct attribute_spec.handler. */
4719 handle_pure_attribute (tree *node, tree name, tree ARG_UNUSED (args),
4720 int ARG_UNUSED (flags), bool *no_add_attrs)
4722 if (TREE_CODE (*node) == FUNCTION_DECL)
4723 DECL_IS_PURE (*node) = 1;
4724 /* ??? TODO: Support types. */
4727 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
4728 *no_add_attrs = true;
4734 /* Handle a "deprecated" attribute; arguments as in
4735 struct attribute_spec.handler. */
4738 handle_deprecated_attribute (tree *node, tree name,
4739 tree ARG_UNUSED (args), int flags,
4742 tree type = NULL_TREE;
4744 const char *what = NULL;
4749 type = TREE_TYPE (decl);
4751 if (TREE_CODE (decl) == TYPE_DECL
4752 || TREE_CODE (decl) == PARM_DECL
4753 || TREE_CODE (decl) == VAR_DECL
4754 || TREE_CODE (decl) == FUNCTION_DECL
4755 || TREE_CODE (decl) == FIELD_DECL)
4756 TREE_DEPRECATED (decl) = 1;
4760 else if (TYPE_P (*node))
4762 if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
4763 *node = build_type_copy (*node);
4764 TREE_DEPRECATED (*node) = 1;
4772 *no_add_attrs = true;
4773 if (type && TYPE_NAME (type))
4775 if (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE)
4776 what = IDENTIFIER_POINTER (TYPE_NAME (*node));
4777 else if (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
4778 && DECL_NAME (TYPE_NAME (type)))
4779 what = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type)));
4782 warning ("`%s' attribute ignored for `%s'",
4783 IDENTIFIER_POINTER (name), what);
4785 warning ("`%s' attribute ignored",
4786 IDENTIFIER_POINTER (name));
4792 /* Handle a "vector_size" attribute; arguments as in
4793 struct attribute_spec.handler. */
4796 handle_vector_size_attribute (tree *node, tree name, tree args,
4797 int ARG_UNUSED (flags),
4800 unsigned HOST_WIDE_INT vecsize, nunits;
4801 enum machine_mode orig_mode;
4802 tree type = *node, new_type, size;
4804 *no_add_attrs = true;
4806 /* Stripping NON_LVALUE_EXPR allows declarations such as
4807 typedef short v4si __attribute__((vector_size (4 * sizeof(short)))). */
4808 size = TREE_VALUE (args);
4809 if (TREE_CODE (size) == NON_LVALUE_EXPR)
4810 size = TREE_OPERAND (size, 0);
4812 if (! host_integerp (size, 1))
4814 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
4818 /* Get the vector size (in bytes). */
4819 vecsize = tree_low_cst (size, 1);
4821 /* We need to provide for vector pointers, vector arrays, and
4822 functions returning vectors. For example:
4824 __attribute__((vector_size(16))) short *foo;
4826 In this case, the mode is SI, but the type being modified is
4827 HI, so we need to look further. */
4829 while (POINTER_TYPE_P (type)
4830 || TREE_CODE (type) == FUNCTION_TYPE
4831 || TREE_CODE (type) == METHOD_TYPE
4832 || TREE_CODE (type) == ARRAY_TYPE)
4833 type = TREE_TYPE (type);
4835 /* Get the mode of the type being modified. */
4836 orig_mode = TYPE_MODE (type);
4838 if (TREE_CODE (type) == RECORD_TYPE
4839 || (GET_MODE_CLASS (orig_mode) != MODE_FLOAT
4840 && GET_MODE_CLASS (orig_mode) != MODE_INT)
4841 || ! host_integerp (TYPE_SIZE_UNIT (type), 1))
4843 error ("invalid vector type for attribute `%s'",
4844 IDENTIFIER_POINTER (name));
4848 /* Calculate how many units fit in the vector. */
4849 nunits = vecsize / tree_low_cst (TYPE_SIZE_UNIT (type), 1);
4850 if (nunits & (nunits - 1))
4852 error ("number of components of the vector not a power of two");
4856 new_type = build_vector_type (type, nunits);
4858 /* Build back pointers if needed. */
4859 *node = reconstruct_complex_type (*node, new_type);
4864 /* Handle the "nonnull" attribute. */
4866 handle_nonnull_attribute (tree *node, tree ARG_UNUSED (name),
4867 tree args, int ARG_UNUSED (flags),
4871 unsigned HOST_WIDE_INT attr_arg_num;
4873 /* If no arguments are specified, all pointer arguments should be
4874 non-null. Verify a full prototype is given so that the arguments
4875 will have the correct types when we actually check them later. */
4878 if (! TYPE_ARG_TYPES (type))
4880 error ("nonnull attribute without arguments on a non-prototype");
4881 *no_add_attrs = true;
4886 /* Argument list specified. Verify that each argument number references
4887 a pointer argument. */
4888 for (attr_arg_num = 1; args; args = TREE_CHAIN (args))
4891 unsigned HOST_WIDE_INT arg_num = 0, ck_num;
4893 if (! get_nonnull_operand (TREE_VALUE (args), &arg_num))
4895 error ("nonnull argument has invalid operand number (arg %lu)",
4896 (unsigned long) attr_arg_num);
4897 *no_add_attrs = true;
4901 argument = TYPE_ARG_TYPES (type);
4904 for (ck_num = 1; ; ck_num++)
4906 if (! argument || ck_num == arg_num)
4908 argument = TREE_CHAIN (argument);
4912 || TREE_CODE (TREE_VALUE (argument)) == VOID_TYPE)
4914 error ("nonnull argument with out-of-range operand number (arg %lu, operand %lu)",
4915 (unsigned long) attr_arg_num, (unsigned long) arg_num);
4916 *no_add_attrs = true;
4920 if (TREE_CODE (TREE_VALUE (argument)) != POINTER_TYPE)
4922 error ("nonnull argument references non-pointer operand (arg %lu, operand %lu)",
4923 (unsigned long) attr_arg_num, (unsigned long) arg_num);
4924 *no_add_attrs = true;
4933 /* Check the argument list of a function call for null in argument slots
4934 that are marked as requiring a non-null pointer argument. */
4937 check_function_nonnull (tree attrs, tree params)
4939 tree a, args, param;
4942 for (a = attrs; a; a = TREE_CHAIN (a))
4944 if (is_attribute_p ("nonnull", TREE_PURPOSE (a)))
4946 args = TREE_VALUE (a);
4948 /* Walk the argument list. If we encounter an argument number we
4949 should check for non-null, do it. If the attribute has no args,
4950 then every pointer argument is checked (in which case the check
4951 for pointer type is done in check_nonnull_arg). */
4952 for (param = params, param_num = 1; ;
4953 param_num++, param = TREE_CHAIN (param))
4957 if (! args || nonnull_check_p (args, param_num))
4958 check_function_arguments_recurse (check_nonnull_arg, NULL,
4966 /* Helper for check_function_nonnull; given a list of operands which
4967 must be non-null in ARGS, determine if operand PARAM_NUM should be
4971 nonnull_check_p (tree args, unsigned HOST_WIDE_INT param_num)
4973 unsigned HOST_WIDE_INT arg_num = 0;
4975 for (; args; args = TREE_CHAIN (args))
4977 if (! get_nonnull_operand (TREE_VALUE (args), &arg_num))
4980 if (arg_num == param_num)
4986 /* Check that the function argument PARAM (which is operand number
4987 PARAM_NUM) is non-null. This is called by check_function_nonnull
4988 via check_function_arguments_recurse. */
4991 check_nonnull_arg (void * ARG_UNUSED (ctx), tree param,
4992 unsigned HOST_WIDE_INT param_num)
4994 /* Just skip checking the argument if it's not a pointer. This can
4995 happen if the "nonnull" attribute was given without an operand
4996 list (which means to check every pointer argument). */
4998 if (TREE_CODE (TREE_TYPE (param)) != POINTER_TYPE)
5001 if (integer_zerop (param))
5002 warning ("null argument where non-null required (arg %lu)",
5003 (unsigned long) param_num);
5006 /* Helper for nonnull attribute handling; fetch the operand number
5007 from the attribute argument list. */
5010 get_nonnull_operand (tree arg_num_expr, unsigned HOST_WIDE_INT *valp)
5012 /* Strip any conversions from the arg number and verify they
5014 while (TREE_CODE (arg_num_expr) == NOP_EXPR
5015 || TREE_CODE (arg_num_expr) == CONVERT_EXPR
5016 || TREE_CODE (arg_num_expr) == NON_LVALUE_EXPR)
5017 arg_num_expr = TREE_OPERAND (arg_num_expr, 0);
5019 if (TREE_CODE (arg_num_expr) != INTEGER_CST
5020 || TREE_INT_CST_HIGH (arg_num_expr) != 0)
5023 *valp = TREE_INT_CST_LOW (arg_num_expr);
5027 /* Handle a "nothrow" attribute; arguments as in
5028 struct attribute_spec.handler. */
5031 handle_nothrow_attribute (tree *node, tree name, tree ARG_UNUSED (args),
5032 int ARG_UNUSED (flags), bool *no_add_attrs)
5034 if (TREE_CODE (*node) == FUNCTION_DECL)
5035 TREE_NOTHROW (*node) = 1;
5036 /* ??? TODO: Support types. */
5039 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
5040 *no_add_attrs = true;
5046 /* Handle a "cleanup" attribute; arguments as in
5047 struct attribute_spec.handler. */
5050 handle_cleanup_attribute (tree *node, tree name, tree args,
5051 int ARG_UNUSED (flags), bool *no_add_attrs)
5054 tree cleanup_id, cleanup_decl;
5056 /* ??? Could perhaps support cleanups on TREE_STATIC, much like we do
5057 for global destructors in C++. This requires infrastructure that
5058 we don't have generically at the moment. It's also not a feature
5059 we'd be missing too much, since we do have attribute constructor. */
5060 if (TREE_CODE (decl) != VAR_DECL || TREE_STATIC (decl))
5062 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
5063 *no_add_attrs = true;
5067 /* Verify that the argument is a function in scope. */
5068 /* ??? We could support pointers to functions here as well, if
5069 that was considered desirable. */
5070 cleanup_id = TREE_VALUE (args);
5071 if (TREE_CODE (cleanup_id) != IDENTIFIER_NODE)
5073 error ("cleanup arg not an identifier");
5074 *no_add_attrs = true;
5077 cleanup_decl = lookup_name (cleanup_id);
5078 if (!cleanup_decl || TREE_CODE (cleanup_decl) != FUNCTION_DECL)
5080 error ("cleanup arg not a function");
5081 *no_add_attrs = true;
5085 /* That the function has proper type is checked with the
5086 eventual call to build_function_call. */
5091 /* Handle a "warn_unused_result" attribute. No special handling. */
5094 handle_warn_unused_result_attribute (tree *node, tree name,
5095 tree ARG_UNUSED (args),
5096 int ARG_UNUSED (flags), bool *no_add_attrs)
5098 /* Ignore the attribute for functions not returning any value. */
5099 if (VOID_TYPE_P (TREE_TYPE (*node)))
5101 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
5102 *no_add_attrs = true;
5108 /* Check for valid arguments being passed to a function. */
5110 check_function_arguments (tree attrs, tree params)
5112 /* Check for null being passed in a pointer argument that must be
5113 non-null. We also need to do this if format checking is enabled. */
5116 check_function_nonnull (attrs, params);
5118 /* Check for errors in format strings. */
5121 check_function_format (attrs, params);
5124 /* Generic argument checking recursion routine. PARAM is the argument to
5125 be checked. PARAM_NUM is the number of the argument. CALLBACK is invoked
5126 once the argument is resolved. CTX is context for the callback. */
5128 check_function_arguments_recurse (void (*callback)
5129 (void *, tree, unsigned HOST_WIDE_INT),
5130 void *ctx, tree param,
5131 unsigned HOST_WIDE_INT param_num)
5133 if (TREE_CODE (param) == NOP_EXPR)
5135 /* Strip coercion. */
5136 check_function_arguments_recurse (callback, ctx,
5137 TREE_OPERAND (param, 0), param_num);
5141 if (TREE_CODE (param) == CALL_EXPR)
5143 tree type = TREE_TYPE (TREE_TYPE (TREE_OPERAND (param, 0)));
5145 bool found_format_arg = false;
5147 /* See if this is a call to a known internationalization function
5148 that modifies a format arg. Such a function may have multiple
5149 format_arg attributes (for example, ngettext). */
5151 for (attrs = TYPE_ATTRIBUTES (type);
5153 attrs = TREE_CHAIN (attrs))
5154 if (is_attribute_p ("format_arg", TREE_PURPOSE (attrs)))
5157 tree format_num_expr;
5161 /* Extract the argument number, which was previously checked
5163 format_num_expr = TREE_VALUE (TREE_VALUE (attrs));
5164 while (TREE_CODE (format_num_expr) == NOP_EXPR
5165 || TREE_CODE (format_num_expr) == CONVERT_EXPR
5166 || TREE_CODE (format_num_expr) == NON_LVALUE_EXPR)
5167 format_num_expr = TREE_OPERAND (format_num_expr, 0);
5169 if (TREE_CODE (format_num_expr) != INTEGER_CST
5170 || TREE_INT_CST_HIGH (format_num_expr) != 0)
5173 format_num = TREE_INT_CST_LOW (format_num_expr);
5175 for (inner_args = TREE_OPERAND (param, 1), i = 1;
5177 inner_args = TREE_CHAIN (inner_args), i++)
5178 if (i == format_num)
5180 check_function_arguments_recurse (callback, ctx,
5181 TREE_VALUE (inner_args),
5183 found_format_arg = true;
5188 /* If we found a format_arg attribute and did a recursive check,
5189 we are done with checking this argument. Otherwise, we continue
5190 and this will be considered a non-literal. */
5191 if (found_format_arg)
5195 if (TREE_CODE (param) == COND_EXPR)
5197 /* Check both halves of the conditional expression. */
5198 check_function_arguments_recurse (callback, ctx,
5199 TREE_OPERAND (param, 1), param_num);
5200 check_function_arguments_recurse (callback, ctx,
5201 TREE_OPERAND (param, 2), param_num);
5205 (*callback) (ctx, param, param_num);
5208 /* Function to help qsort sort FIELD_DECLs by name order. */
5211 field_decl_cmp (const void *x_p, const void *y_p)
5213 const tree *const x = (const tree *const) x_p;
5214 const tree *const y = (const tree *const) y_p;
5216 if (DECL_NAME (*x) == DECL_NAME (*y))
5217 /* A nontype is "greater" than a type. */
5218 return (TREE_CODE (*y) == TYPE_DECL) - (TREE_CODE (*x) == TYPE_DECL);
5219 if (DECL_NAME (*x) == NULL_TREE)
5221 if (DECL_NAME (*y) == NULL_TREE)
5223 if (DECL_NAME (*x) < DECL_NAME (*y))
5229 gt_pointer_operator new_value;
5233 /* This routine compares two fields like field_decl_cmp but using the
5234 pointer operator in resort_data. */
5237 resort_field_decl_cmp (const void *x_p, const void *y_p)
5239 const tree *const x = (const tree *const) x_p;
5240 const tree *const y = (const tree *const) y_p;
5242 if (DECL_NAME (*x) == DECL_NAME (*y))
5243 /* A nontype is "greater" than a type. */
5244 return (TREE_CODE (*y) == TYPE_DECL) - (TREE_CODE (*x) == TYPE_DECL);
5245 if (DECL_NAME (*x) == NULL_TREE)
5247 if (DECL_NAME (*y) == NULL_TREE)
5250 tree d1 = DECL_NAME (*x);
5251 tree d2 = DECL_NAME (*y);
5252 resort_data.new_value (&d1, resort_data.cookie);
5253 resort_data.new_value (&d2, resort_data.cookie);
5260 /* Resort DECL_SORTED_FIELDS because pointers have been reordered. */
5263 resort_sorted_fields (void *obj,
5264 void * ARG_UNUSED (orig_obj),
5265 gt_pointer_operator new_value,
5268 struct sorted_fields_type *sf = (struct sorted_fields_type *) obj;
5269 resort_data.new_value = new_value;
5270 resort_data.cookie = cookie;
5271 qsort (&sf->elts[0], sf->len, sizeof (tree),
5272 resort_field_decl_cmp);
5275 /* Issue the error given by MSGID, indicating that it occurred before
5276 TOKEN, which had the associated VALUE. */
5279 c_parse_error (const char *msgid, enum cpp_ttype token, tree value)
5281 const char *string = _(msgid);
5283 if (token == CPP_EOF)
5284 error ("%s at end of input", string);
5285 else if (token == CPP_CHAR || token == CPP_WCHAR)
5287 unsigned int val = TREE_INT_CST_LOW (value);
5288 const char *const ell = (token == CPP_CHAR) ? "" : "L";
5289 if (val <= UCHAR_MAX && ISGRAPH (val))
5290 error ("%s before %s'%c'", string, ell, val);
5292 error ("%s before %s'\\x%x'", string, ell, val);
5294 else if (token == CPP_STRING
5295 || token == CPP_WSTRING)
5296 error ("%s before string constant", string);
5297 else if (token == CPP_NUMBER)
5298 error ("%s before numeric constant", string);
5299 else if (token == CPP_NAME)
5300 error ("%s before \"%s\"", string, IDENTIFIER_POINTER (value));
5301 else if (token < N_TTYPES)
5302 error ("%s before '%s' token", string, cpp_type2name (token));
5304 error ("%s", string);
5307 /* Walk a gimplified function and warn for functions whose return value is
5308 ignored and attribute((warn_unused_result)) is set. This is done before
5309 inlining, so we don't have to worry about that. */
5312 c_warn_unused_result (tree *top_p)
5315 tree_stmt_iterator i;
5318 switch (TREE_CODE (t))
5320 case STATEMENT_LIST:
5321 for (i = tsi_start (*top_p); !tsi_end_p (i); tsi_next (&i))
5322 c_warn_unused_result (tsi_stmt_ptr (i));
5326 c_warn_unused_result (&COND_EXPR_THEN (t));
5327 c_warn_unused_result (&COND_EXPR_ELSE (t));
5330 c_warn_unused_result (&BIND_EXPR_BODY (t));
5332 case TRY_FINALLY_EXPR:
5333 case TRY_CATCH_EXPR:
5334 c_warn_unused_result (&TREE_OPERAND (t, 0));
5335 c_warn_unused_result (&TREE_OPERAND (t, 1));
5338 c_warn_unused_result (&CATCH_BODY (t));
5340 case EH_FILTER_EXPR:
5341 c_warn_unused_result (&EH_FILTER_FAILURE (t));
5345 /* This is a naked call, as opposed to a CALL_EXPR nested inside
5346 a MODIFY_EXPR. All calls whose value is ignored should be
5347 represented like this. Look for the attribute. */
5348 fdecl = get_callee_fndecl (t);
5350 ftype = TREE_TYPE (fdecl);
5353 ftype = TREE_TYPE (TREE_OPERAND (t, 0));
5354 /* Look past pointer-to-function to the function type itself. */
5355 ftype = TREE_TYPE (ftype);
5358 if (lookup_attribute ("warn_unused_result", TYPE_ATTRIBUTES (ftype)))
5361 warning ("%Hignoring return value of `%D', "
5362 "declared with attribute warn_unused_result",
5363 EXPR_LOCUS (t), fdecl);
5365 warning ("%Hignoring return value of function "
5366 "declared with attribute warn_unused_result",
5372 /* Not a container, not a call, or a call whose value is used. */
5377 #include "gt-c-common.h"