1 /* Subroutines shared by all languages that are variants of C.
2 Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
3 2001, 2002, 2003, 2004, 2005 Free Software Foundation, Inc.
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify it under
8 the terms of the GNU General Public License as published by the Free
9 Software Foundation; either version 2, or (at your option) any later
12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING. If not, write to the Free
19 Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
24 #include "coretypes.h"
36 #include "diagnostic.h"
41 #include "langhooks.h"
42 #include "tree-inline.h"
45 #include "tree-iterator.h"
47 #include "tree-mudflap.h"
52 cpp_reader *parse_in; /* Declared in c-pragma.h. */
54 /* We let tm.h override the types used here, to handle trivial differences
55 such as the choice of unsigned int or long unsigned int for size_t.
56 When machines start needing nontrivial differences in the size type,
57 it would be best to do something here to figure out automatically
58 from other information what type to use. */
61 #define SIZE_TYPE "long unsigned int"
65 #define PID_TYPE "int"
69 #define WCHAR_TYPE "int"
72 /* WCHAR_TYPE gets overridden by -fshort-wchar. */
73 #define MODIFIED_WCHAR_TYPE \
74 (flag_short_wchar ? "short unsigned int" : WCHAR_TYPE)
77 #define PTRDIFF_TYPE "long int"
81 #define WINT_TYPE "unsigned int"
85 #define INTMAX_TYPE ((INT_TYPE_SIZE == LONG_LONG_TYPE_SIZE) \
87 : ((LONG_TYPE_SIZE == LONG_LONG_TYPE_SIZE) \
93 #define UINTMAX_TYPE ((INT_TYPE_SIZE == LONG_LONG_TYPE_SIZE) \
95 : ((LONG_TYPE_SIZE == LONG_LONG_TYPE_SIZE) \
96 ? "long unsigned int" \
97 : "long long unsigned int"))
100 /* The following symbols are subsumed in the c_global_trees array, and
101 listed here individually for documentation purposes.
103 INTEGER_TYPE and REAL_TYPE nodes for the standard data types.
105 tree short_integer_type_node;
106 tree long_integer_type_node;
107 tree long_long_integer_type_node;
109 tree short_unsigned_type_node;
110 tree long_unsigned_type_node;
111 tree long_long_unsigned_type_node;
113 tree truthvalue_type_node;
114 tree truthvalue_false_node;
115 tree truthvalue_true_node;
117 tree ptrdiff_type_node;
119 tree unsigned_char_type_node;
120 tree signed_char_type_node;
121 tree wchar_type_node;
122 tree signed_wchar_type_node;
123 tree unsigned_wchar_type_node;
125 tree float_type_node;
126 tree double_type_node;
127 tree long_double_type_node;
129 tree complex_integer_type_node;
130 tree complex_float_type_node;
131 tree complex_double_type_node;
132 tree complex_long_double_type_node;
134 tree dfloat32_type_node;
135 tree dfloat64_type_node;
136 tree_dfloat128_type_node;
138 tree intQI_type_node;
139 tree intHI_type_node;
140 tree intSI_type_node;
141 tree intDI_type_node;
142 tree intTI_type_node;
144 tree unsigned_intQI_type_node;
145 tree unsigned_intHI_type_node;
146 tree unsigned_intSI_type_node;
147 tree unsigned_intDI_type_node;
148 tree unsigned_intTI_type_node;
150 tree widest_integer_literal_type_node;
151 tree widest_unsigned_literal_type_node;
153 Nodes for types `void *' and `const void *'.
155 tree ptr_type_node, const_ptr_type_node;
157 Nodes for types `char *' and `const char *'.
159 tree string_type_node, const_string_type_node;
161 Type `char[SOMENUMBER]'.
162 Used when an array of char is needed and the size is irrelevant.
164 tree char_array_type_node;
166 Type `int[SOMENUMBER]' or something like it.
167 Used when an array of int needed and the size is irrelevant.
169 tree int_array_type_node;
171 Type `wchar_t[SOMENUMBER]' or something like it.
172 Used when a wide string literal is created.
174 tree wchar_array_type_node;
176 Type `int ()' -- used for implicit declaration of functions.
178 tree default_function_type;
180 A VOID_TYPE node, packaged in a TREE_LIST.
184 The lazily created VAR_DECLs for __FUNCTION__, __PRETTY_FUNCTION__,
185 and __func__. (C doesn't generate __FUNCTION__ and__PRETTY_FUNCTION__
186 VAR_DECLS, but C++ does.)
188 tree function_name_decl_node;
189 tree pretty_function_name_decl_node;
190 tree c99_function_name_decl_node;
192 Stack of nested function name VAR_DECLs.
194 tree saved_function_name_decls;
198 tree c_global_trees[CTI_MAX];
200 /* Switches common to the C front ends. */
202 /* Nonzero if prepreprocessing only. */
204 int flag_preprocess_only;
206 /* Nonzero means don't output line number information. */
208 char flag_no_line_commands;
210 /* Nonzero causes -E output not to be done, but directives such as
211 #define that have side effects are still obeyed. */
215 /* Nonzero means dump macros in some fashion. */
217 char flag_dump_macros;
219 /* Nonzero means pass #include lines through to the output. */
221 char flag_dump_includes;
223 /* Nonzero means process PCH files while preprocessing. */
225 bool flag_pch_preprocess;
227 /* The file name to which we should write a precompiled header, or
228 NULL if no header will be written in this compile. */
230 const char *pch_file;
232 /* Nonzero if an ISO standard was selected. It rejects macros in the
236 /* Nonzero if -undef was given. It suppresses target built-in macros
240 /* Nonzero means don't recognize the non-ANSI builtin functions. */
244 /* Nonzero means don't recognize the non-ANSI builtin functions.
247 int flag_no_nonansi_builtin;
249 /* Nonzero means give `double' the same size as `float'. */
251 int flag_short_double;
253 /* Nonzero means give `wchar_t' the same size as `short'. */
255 int flag_short_wchar;
257 /* Nonzero means allow implicit conversions between vectors with
258 differing numbers of subparts and/or differing element types. */
259 int flag_lax_vector_conversions;
261 /* Nonzero means allow Microsoft extensions without warnings or errors. */
262 int flag_ms_extensions;
264 /* Nonzero means don't recognize the keyword `asm'. */
268 /* Nonzero means to treat bitfields as signed unless they say `unsigned'. */
270 int flag_signed_bitfields = 1;
272 /* Warn about #pragma directives that are not recognized. */
274 int warn_unknown_pragmas; /* Tri state variable. */
276 /* Warn about format/argument anomalies in calls to formatted I/O functions
277 (*printf, *scanf, strftime, strfmon, etc.). */
281 /* Warn about using __null (as NULL in C++) as sentinel. For code compiled
282 with GCC this doesn't matter as __null is guaranteed to have the right
285 int warn_strict_null_sentinel;
287 /* Zero means that faster, ...NonNil variants of objc_msgSend...
288 calls will be used in ObjC; passing nil receivers to such calls
289 will most likely result in crashes. */
290 int flag_nil_receivers = 1;
292 /* Nonzero means that code generation will be altered to support
293 "zero-link" execution. This currently affects ObjC only, but may
294 affect other languages in the future. */
295 int flag_zero_link = 0;
297 /* Nonzero means emit an '__OBJC, __image_info' for the current translation
298 unit. It will inform the ObjC runtime that class definition(s) herein
299 contained are to replace one(s) previously loaded. */
300 int flag_replace_objc_classes = 0;
302 /* C/ObjC language option variables. */
305 /* Nonzero means allow type mismatches in conditional expressions;
306 just make their values `void'. */
308 int flag_cond_mismatch;
310 /* Nonzero means enable C89 Amendment 1 features. */
314 /* Nonzero means use the ISO C99 dialect of C. */
318 /* Nonzero means that we have builtin functions, and main is an int. */
322 /* Warn if main is suspicious. */
327 /* ObjC language option variables. */
330 /* Open and close the file for outputting class declarations, if
333 int flag_gen_declaration;
335 /* Tells the compiler that this is a special run. Do not perform any
336 compiling, instead we are to test some platform dependent features
337 and output a C header file with appropriate definitions. */
339 int print_struct_values;
341 /* Tells the compiler what is the constant string class for Objc. */
343 const char *constant_string_class_name;
346 /* C++ language option variables. */
349 /* Nonzero means don't recognize any extension keywords. */
351 int flag_no_gnu_keywords;
353 /* Nonzero means do emit exported implementations of functions even if
354 they can be inlined. */
356 int flag_implement_inlines = 1;
358 /* Nonzero means that implicit instantiations will be emitted if needed. */
360 int flag_implicit_templates = 1;
362 /* Nonzero means that implicit instantiations of inline templates will be
363 emitted if needed, even if instantiations of non-inline templates
366 int flag_implicit_inline_templates = 1;
368 /* Nonzero means generate separate instantiation control files and
369 juggle them at link time. */
371 int flag_use_repository;
373 /* Nonzero if we want to issue diagnostics that the standard says are not
376 int flag_optional_diags = 1;
378 /* Nonzero means we should attempt to elide constructors when possible. */
380 int flag_elide_constructors = 1;
382 /* Nonzero means that member functions defined in class scope are
383 inline by default. */
385 int flag_default_inline = 1;
387 /* Controls whether compiler generates 'type descriptor' that give
388 run-time type information. */
392 /* Nonzero if we want to conserve space in the .o files. We do this
393 by putting uninitialized data and runtime initialized data into
394 .common instead of .data at the expense of not flagging multiple
397 int flag_conserve_space;
399 /* Nonzero if we want to obey access control semantics. */
401 int flag_access_control = 1;
403 /* Nonzero if we want to check the return value of new and avoid calling
404 constructors if it is a null pointer. */
408 /* Nonzero if we want the new ISO rules for pushing a new scope for `for'
409 initialization variables.
410 0: Old rules, set by -fno-for-scope.
411 2: New ISO rules, set by -ffor-scope.
412 1: Try to implement new ISO rules, but with backup compatibility
413 (and warnings). This is the default, for now. */
415 int flag_new_for_scope = 1;
417 /* Nonzero if we want to emit defined symbols with common-like linkage as
418 weak symbols where possible, in order to conform to C++ semantics.
419 Otherwise, emit them as local symbols. */
423 /* 0 means we want the preprocessor to not emit line directives for
424 the current working directory. 1 means we want it to do it. -1
425 means we should decide depending on whether debugging information
426 is being emitted or not. */
428 int flag_working_directory = -1;
430 /* Nonzero to use __cxa_atexit, rather than atexit, to register
431 destructors for local statics and global objects. '2' means it has been
432 set nonzero as a default, not by a command-line flag. */
434 int flag_use_cxa_atexit = DEFAULT_USE_CXA_ATEXIT;
436 /* Nonzero to use __cxa_get_exception_ptr in C++ exception-handling
437 code. '2' means it has not been set explicitly on the command line. */
439 int flag_use_cxa_get_exception_ptr = 2;
441 /* Nonzero means make the default pedwarns warnings instead of errors.
442 The value of this flag is ignored if -pedantic is specified. */
446 /* Nonzero means to implement standard semantics for exception
447 specifications, calling unexpected if an exception is thrown that
448 doesn't match the specification. Zero means to treat them as
449 assertions and optimize accordingly, but not check them. */
451 int flag_enforce_eh_specs = 1;
453 /* Nonzero means to generate thread-safe code for initializing local
456 int flag_threadsafe_statics = 1;
458 /* Nonzero means warn about implicit declarations. */
460 int warn_implicit = 1;
462 /* Maximum template instantiation depth. This limit is rather
463 arbitrary, but it exists to limit the time it takes to notice
464 infinite template instantiations. */
466 int max_tinst_depth = 500;
470 /* The elements of `ridpointers' are identifier nodes for the reserved
471 type names and storage classes. It is indexed by a RID_... value. */
474 tree (*make_fname_decl) (tree, int);
476 /* Nonzero means the expression being parsed will never be evaluated.
477 This is a count, since unevaluated expressions can nest. */
480 /* Information about how a function name is generated. */
483 tree *const decl; /* pointer to the VAR_DECL. */
484 const unsigned rid; /* RID number for the identifier. */
485 const int pretty; /* How pretty is it? */
488 /* The three ways of getting then name of the current function. */
490 const struct fname_var_t fname_vars[] =
492 /* C99 compliant __func__, must be first. */
493 {&c99_function_name_decl_node, RID_C99_FUNCTION_NAME, 0},
494 /* GCC __FUNCTION__ compliant. */
495 {&function_name_decl_node, RID_FUNCTION_NAME, 0},
496 /* GCC __PRETTY_FUNCTION__ compliant. */
497 {&pretty_function_name_decl_node, RID_PRETTY_FUNCTION_NAME, 1},
501 static int constant_fits_type_p (tree, tree);
502 static tree check_case_value (tree);
503 static bool check_case_bounds (tree, tree, tree *, tree *);
505 static tree handle_packed_attribute (tree *, tree, tree, int, bool *);
506 static tree handle_nocommon_attribute (tree *, tree, tree, int, bool *);
507 static tree handle_common_attribute (tree *, tree, tree, int, bool *);
508 static tree handle_noreturn_attribute (tree *, tree, tree, int, bool *);
509 static tree handle_noinline_attribute (tree *, tree, tree, int, bool *);
510 static tree handle_always_inline_attribute (tree *, tree, tree, int,
512 static tree handle_gnu_inline_attribute (tree *, tree, tree, int,
514 static tree handle_flatten_attribute (tree *, tree, tree, int, bool *);
515 static tree handle_used_attribute (tree *, tree, tree, int, bool *);
516 static tree handle_unused_attribute (tree *, tree, tree, int, bool *);
517 static tree handle_externally_visible_attribute (tree *, tree, tree, int,
519 static tree handle_const_attribute (tree *, tree, tree, int, bool *);
520 static tree handle_transparent_union_attribute (tree *, tree, tree,
522 static tree handle_constructor_attribute (tree *, tree, tree, int, bool *);
523 static tree handle_destructor_attribute (tree *, tree, tree, int, bool *);
524 static tree handle_mode_attribute (tree *, tree, tree, int, bool *);
525 static tree handle_section_attribute (tree *, tree, tree, int, bool *);
526 static tree handle_aligned_attribute (tree *, tree, tree, int, bool *);
527 static tree handle_weak_attribute (tree *, tree, tree, int, bool *) ;
528 static tree handle_alias_attribute (tree *, tree, tree, int, bool *);
529 static tree handle_weakref_attribute (tree *, tree, tree, int, bool *) ;
530 static tree handle_visibility_attribute (tree *, tree, tree, int,
532 static tree handle_tls_model_attribute (tree *, tree, tree, int,
534 static tree handle_no_instrument_function_attribute (tree *, tree,
536 static tree handle_malloc_attribute (tree *, tree, tree, int, bool *);
537 static tree handle_returns_twice_attribute (tree *, tree, tree, int, bool *);
538 static tree handle_no_limit_stack_attribute (tree *, tree, tree, int,
540 static tree handle_pure_attribute (tree *, tree, tree, int, bool *);
541 static tree handle_novops_attribute (tree *, tree, tree, int, bool *);
542 static tree handle_deprecated_attribute (tree *, tree, tree, int,
544 /* APPLE LOCAL begin "unavailable" attribute (Radar 2809697) --ilr */
545 static tree handle_unavailable_attribute (tree *, tree, tree, int, bool *);
546 /* APPLE LOCAL end "unavailable" attribute --ilr */
547 static tree handle_vector_size_attribute (tree *, tree, tree, int,
549 static tree handle_nonnull_attribute (tree *, tree, tree, int, bool *);
550 static tree handle_nothrow_attribute (tree *, tree, tree, int, bool *);
551 static tree handle_cleanup_attribute (tree *, tree, tree, int, bool *);
552 static tree handle_warn_unused_result_attribute (tree *, tree, tree, int,
554 static tree handle_sentinel_attribute (tree *, tree, tree, int, bool *);
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 { "gnu_inline", 0, 0, true, false, false,
586 handle_gnu_inline_attribute },
587 { "flatten", 0, 0, true, false, false,
588 handle_flatten_attribute },
589 { "used", 0, 0, true, false, false,
590 handle_used_attribute },
591 { "unused", 0, 0, false, false, false,
592 handle_unused_attribute },
593 { "externally_visible", 0, 0, true, false, false,
594 handle_externally_visible_attribute },
595 /* The same comments as for noreturn attributes apply to const ones. */
596 { "const", 0, 0, true, false, false,
597 handle_const_attribute },
598 { "transparent_union", 0, 0, false, false, false,
599 handle_transparent_union_attribute },
600 { "constructor", 0, 0, true, false, false,
601 handle_constructor_attribute },
602 { "destructor", 0, 0, true, false, false,
603 handle_destructor_attribute },
604 { "mode", 1, 1, false, true, false,
605 handle_mode_attribute },
606 { "section", 1, 1, true, false, false,
607 handle_section_attribute },
608 { "aligned", 0, 1, false, false, false,
609 handle_aligned_attribute },
610 { "weak", 0, 0, true, false, false,
611 handle_weak_attribute },
612 { "alias", 1, 1, true, false, false,
613 handle_alias_attribute },
614 { "weakref", 0, 1, true, false, false,
615 handle_weakref_attribute },
616 { "no_instrument_function", 0, 0, true, false, false,
617 handle_no_instrument_function_attribute },
618 { "malloc", 0, 0, true, false, false,
619 handle_malloc_attribute },
620 { "returns_twice", 0, 0, true, false, false,
621 handle_returns_twice_attribute },
622 { "no_stack_limit", 0, 0, true, false, false,
623 handle_no_limit_stack_attribute },
624 { "pure", 0, 0, true, false, false,
625 handle_pure_attribute },
626 /* For internal use (marking of builtins) only. The name contains space
627 to prevent its usage in source code. */
628 { "no vops", 0, 0, true, false, false,
629 handle_novops_attribute },
630 { "deprecated", 0, 0, false, false, false,
631 handle_deprecated_attribute },
632 /* APPLE LOCAL begin "unavailable" attribute (Radar 2809697) --ilr */
633 { "unavailable", 0, 0, false, false, false,
634 handle_unavailable_attribute },
635 /* APPLE LOCAL end "unavailable" attribute --ilr */
636 { "vector_size", 1, 1, false, true, false,
637 handle_vector_size_attribute },
638 { "visibility", 1, 1, false, false, false,
639 handle_visibility_attribute },
640 { "tls_model", 1, 1, true, false, false,
641 handle_tls_model_attribute },
642 { "nonnull", 0, -1, false, true, true,
643 handle_nonnull_attribute },
644 { "nothrow", 0, 0, true, false, false,
645 handle_nothrow_attribute },
646 { "may_alias", 0, 0, false, true, false, NULL },
647 { "cleanup", 1, 1, true, false, false,
648 handle_cleanup_attribute },
649 { "warn_unused_result", 0, 0, false, true, true,
650 handle_warn_unused_result_attribute },
651 { "sentinel", 0, 1, false, true, true,
652 handle_sentinel_attribute },
653 { NULL, 0, 0, false, false, false, NULL }
656 /* Give the specifications for the format attributes, used by C and all
659 const struct attribute_spec c_common_format_attribute_table[] =
661 /* { name, min_len, max_len, decl_req, type_req, fn_type_req, handler } */
662 { "format", 3, 3, false, true, true,
663 handle_format_attribute },
664 { "format_arg", 1, 1, false, true, true,
665 handle_format_arg_attribute },
666 { NULL, 0, 0, false, false, false, NULL }
669 /* Push current bindings for the function name VAR_DECLS. */
672 start_fname_decls (void)
675 tree saved = NULL_TREE;
677 for (ix = 0; fname_vars[ix].decl; ix++)
679 tree decl = *fname_vars[ix].decl;
683 saved = tree_cons (decl, build_int_cst (NULL_TREE, ix), saved);
684 *fname_vars[ix].decl = NULL_TREE;
687 if (saved || saved_function_name_decls)
688 /* Normally they'll have been NULL, so only push if we've got a
689 stack, or they are non-NULL. */
690 saved_function_name_decls = tree_cons (saved, NULL_TREE,
691 saved_function_name_decls);
694 /* Finish up the current bindings, adding them into the current function's
695 statement tree. This must be done _before_ finish_stmt_tree is called.
696 If there is no current function, we must be at file scope and no statements
697 are involved. Pop the previous bindings. */
700 finish_fname_decls (void)
703 tree stmts = NULL_TREE;
704 tree stack = saved_function_name_decls;
706 for (; stack && TREE_VALUE (stack); stack = TREE_CHAIN (stack))
707 append_to_statement_list (TREE_VALUE (stack), &stmts);
711 tree *bodyp = &DECL_SAVED_TREE (current_function_decl);
713 if (TREE_CODE (*bodyp) == BIND_EXPR)
714 bodyp = &BIND_EXPR_BODY (*bodyp);
716 append_to_statement_list_force (*bodyp, &stmts);
720 for (ix = 0; fname_vars[ix].decl; ix++)
721 *fname_vars[ix].decl = NULL_TREE;
725 /* We had saved values, restore them. */
728 for (saved = TREE_PURPOSE (stack); saved; saved = TREE_CHAIN (saved))
730 tree decl = TREE_PURPOSE (saved);
731 unsigned ix = TREE_INT_CST_LOW (TREE_VALUE (saved));
733 *fname_vars[ix].decl = decl;
735 stack = TREE_CHAIN (stack);
737 saved_function_name_decls = stack;
740 /* Return the text name of the current function, suitably prettified
741 by PRETTY_P. Return string must be freed by caller. */
744 fname_as_string (int pretty_p)
746 const char *name = "top level";
756 if (current_function_decl)
757 name = lang_hooks.decl_printable_name (current_function_decl, vrb);
759 if (c_lex_string_translate)
761 int len = strlen (name) + 3; /* Two for '"'s. One for NULL. */
762 cpp_string cstr = { 0, 0 }, strname;
764 namep = XNEWVEC (char, len);
765 snprintf (namep, len, "\"%s\"", name);
766 strname.text = (unsigned char *) namep;
767 strname.len = len - 1;
769 if (cpp_interpret_string (parse_in, &strname, 1, &cstr, false))
772 return (char *) cstr.text;
776 namep = xstrdup (name);
781 /* Expand DECL if it declares an entity not handled by the
785 c_expand_decl (tree decl)
787 if (TREE_CODE (decl) == VAR_DECL && !TREE_STATIC (decl))
789 /* Let the back-end know about this variable. */
790 if (!anon_aggr_type_p (TREE_TYPE (decl)))
791 emit_local_var (decl);
793 expand_anon_union_decl (decl, NULL_TREE,
794 DECL_ANON_UNION_ELEMS (decl));
803 /* Return the VAR_DECL for a const char array naming the current
804 function. If the VAR_DECL has not yet been created, create it
805 now. RID indicates how it should be formatted and IDENTIFIER_NODE
806 ID is its name (unfortunately C and C++ hold the RID values of
807 keywords in different places, so we can't derive RID from ID in
808 this language independent code. */
811 fname_decl (unsigned int rid, tree id)
814 tree decl = NULL_TREE;
816 for (ix = 0; fname_vars[ix].decl; ix++)
817 if (fname_vars[ix].rid == rid)
820 decl = *fname_vars[ix].decl;
823 /* If a tree is built here, it would normally have the lineno of
824 the current statement. Later this tree will be moved to the
825 beginning of the function and this line number will be wrong.
826 To avoid this problem set the lineno to 0 here; that prevents
827 it from appearing in the RTL. */
829 location_t saved_location = input_location;
830 #ifdef USE_MAPPED_LOCATION
831 input_location = UNKNOWN_LOCATION;
836 stmts = push_stmt_list ();
837 decl = (*make_fname_decl) (id, fname_vars[ix].pretty);
838 stmts = pop_stmt_list (stmts);
839 if (!IS_EMPTY_STMT (stmts))
840 saved_function_name_decls
841 = tree_cons (decl, stmts, saved_function_name_decls);
842 *fname_vars[ix].decl = decl;
843 input_location = saved_location;
845 if (!ix && !current_function_decl)
846 pedwarn ("%qD is not defined outside of function scope", decl);
851 /* Given a STRING_CST, give it a suitable array-of-chars data type. */
854 fix_string_type (tree value)
856 const int wchar_bytes = TYPE_PRECISION (wchar_type_node) / BITS_PER_UNIT;
857 const int wide_flag = TREE_TYPE (value) == wchar_array_type_node;
858 int length = TREE_STRING_LENGTH (value);
860 tree e_type, i_type, a_type;
862 /* Compute the number of elements, for the array type. */
863 nchars = wide_flag ? length / wchar_bytes : length;
865 /* C89 2.2.4.1, C99 5.2.4.1 (Translation limits). The analogous
866 limit in C++98 Annex B is very large (65536) and is not normative,
867 so we do not diagnose it (warn_overlength_strings is forced off
868 in c_common_post_options). */
869 if (warn_overlength_strings)
871 const int nchars_max = flag_isoc99 ? 4095 : 509;
872 const int relevant_std = flag_isoc99 ? 99 : 90;
873 if (nchars - 1 > nchars_max)
874 /* Translators: The %d after 'ISO C' will be 90 or 99. Do not
875 separate the %d from the 'C'. 'ISO' should not be
876 translated, but it may be moved after 'C%d' in languages
877 where modifiers follow nouns. */
878 pedwarn ("string length %qd is greater than the length %qd "
879 "ISO C%d compilers are required to support",
880 nchars - 1, nchars_max, relevant_std);
883 /* Create the array type for the string constant. The ISO C++
884 standard says that a string literal has type `const char[N]' or
885 `const wchar_t[N]'. We use the same logic when invoked as a C
886 front-end with -Wwrite-strings.
887 ??? We should change the type of an expression depending on the
888 state of a warning flag. We should just be warning -- see how
889 this is handled in the C++ front-end for the deprecated implicit
890 conversion from string literals to `char*' or `wchar_t*'.
892 The C++ front end relies on TYPE_MAIN_VARIANT of a cv-qualified
893 array type being the unqualified version of that type.
894 Therefore, if we are constructing an array of const char, we must
895 construct the matching unqualified array type first. The C front
896 end does not require this, but it does no harm, so we do it
898 e_type = wide_flag ? wchar_type_node : char_type_node;
899 i_type = build_index_type (build_int_cst (NULL_TREE, nchars - 1));
900 a_type = build_array_type (e_type, i_type);
901 if (c_dialect_cxx() || warn_write_strings)
902 a_type = c_build_qualified_type (a_type, TYPE_QUAL_CONST);
904 TREE_TYPE (value) = a_type;
905 TREE_CONSTANT (value) = 1;
906 TREE_INVARIANT (value) = 1;
907 TREE_READONLY (value) = 1;
908 TREE_STATIC (value) = 1;
912 /* Print a warning if a constant expression had overflow in folding.
913 Invoke this function on every expression that the language
914 requires to be a constant expression.
915 Note the ANSI C standard says it is erroneous for a
916 constant expression to overflow. */
919 constant_expression_warning (tree value)
921 if ((TREE_CODE (value) == INTEGER_CST || TREE_CODE (value) == REAL_CST
922 || TREE_CODE (value) == VECTOR_CST
923 || TREE_CODE (value) == COMPLEX_CST)
924 && TREE_CONSTANT_OVERFLOW (value)
927 pedwarn ("overflow in constant expression");
930 /* Print a warning if an expression had overflow in folding and its
933 Invoke this function on every expression that
934 (1) appears in the source code, and
935 (2) is a constant expression that overflowed, and
936 (3) is not already checked by convert_and_check;
937 however, do not invoke this function on operands of explicit casts
938 or when the expression is the result of an operator and any operand
939 already overflowed. */
942 overflow_warning (tree value)
944 if (skip_evaluation) return;
946 switch (TREE_CODE (value))
949 warning (OPT_Woverflow, "integer overflow in expression");
953 warning (OPT_Woverflow, "floating point overflow in expression");
957 warning (OPT_Woverflow, "vector overflow in expression");
961 if (TREE_CODE (TREE_REALPART (value)) == INTEGER_CST)
962 warning (OPT_Woverflow, "complex integer overflow in expression");
963 else if (TREE_CODE (TREE_REALPART (value)) == REAL_CST)
964 warning (OPT_Woverflow, "complex floating point overflow in expression");
972 /* Print a warning if a large constant is truncated to unsigned,
973 or if -Wconversion is used and a constant < 0 is converted to unsigned.
974 Invoke this function on every expression that might be implicitly
975 converted to an unsigned type. */
978 unsigned_conversion_warning (tree result, tree operand)
980 tree type = TREE_TYPE (result);
982 if (TREE_CODE (operand) == INTEGER_CST
983 && TREE_CODE (type) == INTEGER_TYPE
984 && TYPE_UNSIGNED (type)
985 && skip_evaluation == 0
986 && !int_fits_type_p (operand, type))
988 if (!int_fits_type_p (operand, c_common_signed_type (type)))
989 /* This detects cases like converting -129 or 256 to unsigned char. */
990 warning (OPT_Woverflow,
991 "large integer implicitly truncated to unsigned type");
993 warning (OPT_Wconversion,
994 "negative integer implicitly converted to unsigned type");
998 /* Print a warning about casts that might indicate violation
999 of strict aliasing rules if -Wstrict-aliasing is used and
1000 strict aliasing mode is in effect. OTYPE is the original
1001 TREE_TYPE of EXPR, and TYPE the type we're casting to. */
1004 strict_aliasing_warning (tree otype, tree type, tree expr)
1006 if (!(flag_strict_aliasing && POINTER_TYPE_P (type)
1007 && POINTER_TYPE_P (otype) && !VOID_TYPE_P (TREE_TYPE (type))))
1010 if ((warn_strict_aliasing > 1) && TREE_CODE (expr) == ADDR_EXPR
1011 && (DECL_P (TREE_OPERAND (expr, 0))
1012 || handled_component_p (TREE_OPERAND (expr, 0))))
1014 /* Casting the address of an object to non void pointer. Warn
1015 if the cast breaks type based aliasing. */
1016 if (!COMPLETE_TYPE_P (TREE_TYPE (type)) && warn_strict_aliasing == 2)
1018 warning (OPT_Wstrict_aliasing, "type-punning to incomplete type "
1019 "might break strict-aliasing rules");
1024 /* warn_strict_aliasing >= 3. This includes the default (3).
1025 Only warn if the cast is dereferenced immediately. */
1026 HOST_WIDE_INT set1 =
1027 get_alias_set (TREE_TYPE (TREE_OPERAND (expr, 0)));
1028 HOST_WIDE_INT set2 = get_alias_set (TREE_TYPE (type));
1030 if (!alias_sets_conflict_p (set1, set2))
1032 warning (OPT_Wstrict_aliasing, "dereferencing type-punned "
1033 "pointer will break strict-aliasing rules");
1036 else if (warn_strict_aliasing == 2
1037 && !alias_sets_might_conflict_p (set1, set2))
1039 warning (OPT_Wstrict_aliasing, "dereferencing type-punned "
1040 "pointer might break strict-aliasing rules");
1046 if ((warn_strict_aliasing == 1) && !VOID_TYPE_P (TREE_TYPE (otype)))
1048 /* At this level, warn for any conversions, even if an address is
1049 not taken in the same statement. This will likely produce many
1050 false positives, but could be useful to pinpoint problems that
1051 are not revealed at higher levels. */
1052 HOST_WIDE_INT set1 = get_alias_set (TREE_TYPE (otype));
1053 HOST_WIDE_INT set2 = get_alias_set (TREE_TYPE (type));
1054 if (!COMPLETE_TYPE_P(type)
1055 || !alias_sets_might_conflict_p (set1, set2))
1057 warning (OPT_Wstrict_aliasing, "dereferencing type-punned "
1058 "pointer might break strict-aliasing rules");
1067 /* Print a warning about if (); or if () .. else; constructs
1068 via the special empty statement node that we create. INNER_THEN
1069 and INNER_ELSE are the statement lists of the if and the else
1073 empty_body_warning (tree inner_then, tree inner_else)
1077 if (TREE_CODE (inner_then) == STATEMENT_LIST
1078 && STATEMENT_LIST_TAIL (inner_then))
1079 inner_then = STATEMENT_LIST_TAIL (inner_then)->stmt;
1081 if (inner_else && TREE_CODE (inner_else) == STATEMENT_LIST
1082 && STATEMENT_LIST_TAIL (inner_else))
1083 inner_else = STATEMENT_LIST_TAIL (inner_else)->stmt;
1085 if (IS_EMPTY_STMT (inner_then) && !inner_else)
1086 warning (OPT_Wextra, "%Hempty body in an if-statement",
1087 EXPR_LOCUS (inner_then));
1089 if (inner_else && IS_EMPTY_STMT (inner_else))
1090 warning (OPT_Wextra, "%Hempty body in an else-statement",
1091 EXPR_LOCUS (inner_else));
1096 /* Nonzero if constant C has a value that is permissible
1097 for type TYPE (an INTEGER_TYPE). */
1100 constant_fits_type_p (tree c, tree type)
1102 if (TREE_CODE (c) == INTEGER_CST)
1103 return int_fits_type_p (c, type);
1105 c = convert (type, c);
1106 return !TREE_OVERFLOW (c);
1110 /* True if vector types T1 and T2 can be converted to each other
1111 without an explicit cast. If EMIT_LAX_NOTE is true, and T1 and T2
1112 can only be converted with -flax-vector-conversions yet that is not
1113 in effect, emit a note telling the user about that option if such
1114 a note has not previously been emitted. */
1116 vector_types_convertible_p (tree t1, tree t2, bool emit_lax_note)
1118 static bool emitted_lax_note = false;
1119 bool convertible_lax;
1121 if ((targetm.vector_opaque_p (t1) || targetm.vector_opaque_p (t2))
1122 && tree_int_cst_equal (TYPE_SIZE (t1), TYPE_SIZE (t2)))
1126 (tree_int_cst_equal (TYPE_SIZE (t1), TYPE_SIZE (t2))
1127 && (TREE_CODE (TREE_TYPE (t1)) != REAL_TYPE ||
1128 TYPE_PRECISION (t1) == TYPE_PRECISION (t2))
1129 && (INTEGRAL_TYPE_P (TREE_TYPE (t1))
1130 == INTEGRAL_TYPE_P (TREE_TYPE (t2))));
1132 if (!convertible_lax || flag_lax_vector_conversions)
1133 return convertible_lax;
1135 if (TYPE_VECTOR_SUBPARTS (t1) == TYPE_VECTOR_SUBPARTS (t2)
1136 && comptypes (TREE_TYPE (t1), TREE_TYPE (t2)))
1139 if (emit_lax_note && !emitted_lax_note)
1141 emitted_lax_note = true;
1142 inform ("use -flax-vector-conversions to permit "
1143 "conversions between vectors with differing "
1144 "element types or numbers of subparts");
1150 /* Convert EXPR to TYPE, warning about conversion problems with constants.
1151 Invoke this function on every expression that is converted implicitly,
1152 i.e. because of language rules and not because of an explicit cast. */
1155 convert_and_check (tree type, tree expr)
1157 tree t = convert (type, expr);
1158 if (TREE_CODE (t) == INTEGER_CST)
1160 if (TREE_OVERFLOW (t))
1162 TREE_OVERFLOW (t) = 0;
1164 /* Do not diagnose overflow in a constant expression merely
1165 because a conversion overflowed. */
1166 TREE_CONSTANT_OVERFLOW (t) = CONSTANT_CLASS_P (expr)
1167 && TREE_CONSTANT_OVERFLOW (expr);
1169 /* No warning for converting 0x80000000 to int. */
1170 if (!(TYPE_UNSIGNED (type) < TYPE_UNSIGNED (TREE_TYPE (expr))
1171 && TREE_CODE (TREE_TYPE (expr)) == INTEGER_TYPE
1172 && TYPE_PRECISION (type) == TYPE_PRECISION (TREE_TYPE (expr))))
1173 /* If EXPR fits in the unsigned version of TYPE,
1174 don't warn unless pedantic. */
1176 || TYPE_UNSIGNED (type)
1177 || !constant_fits_type_p (expr,
1178 c_common_unsigned_type (type)))
1179 && skip_evaluation == 0)
1180 warning (OPT_Woverflow,
1181 "overflow in implicit constant conversion");
1184 unsigned_conversion_warning (t, expr);
1189 /* A node in a list that describes references to variables (EXPR), which are
1190 either read accesses if WRITER is zero, or write accesses, in which case
1191 WRITER is the parent of EXPR. */
1198 /* Used to implement a cache the results of a call to verify_tree. We only
1199 use this for SAVE_EXPRs. */
1202 struct tlist_cache *next;
1203 struct tlist *cache_before_sp;
1204 struct tlist *cache_after_sp;
1208 /* Obstack to use when allocating tlist structures, and corresponding
1210 static struct obstack tlist_obstack;
1211 static char *tlist_firstobj = 0;
1213 /* Keep track of the identifiers we've warned about, so we can avoid duplicate
1215 static struct tlist *warned_ids;
1216 /* SAVE_EXPRs need special treatment. We process them only once and then
1217 cache the results. */
1218 static struct tlist_cache *save_expr_cache;
1220 static void add_tlist (struct tlist **, struct tlist *, tree, int);
1221 static void merge_tlist (struct tlist **, struct tlist *, int);
1222 static void verify_tree (tree, struct tlist **, struct tlist **, tree);
1223 static int warning_candidate_p (tree);
1224 static void warn_for_collisions (struct tlist *);
1225 static void warn_for_collisions_1 (tree, tree, struct tlist *, int);
1226 static struct tlist *new_tlist (struct tlist *, tree, tree);
1228 /* Create a new struct tlist and fill in its fields. */
1229 static struct tlist *
1230 new_tlist (struct tlist *next, tree t, tree writer)
1233 l = XOBNEW (&tlist_obstack, struct tlist);
1240 /* Add duplicates of the nodes found in ADD to the list *TO. If EXCLUDE_WRITER
1241 is nonnull, we ignore any node we find which has a writer equal to it. */
1244 add_tlist (struct tlist **to, struct tlist *add, tree exclude_writer, int copy)
1248 struct tlist *next = add->next;
1251 if (!exclude_writer || add->writer != exclude_writer)
1252 *to = copy ? new_tlist (*to, add->expr, add->writer) : add;
1257 /* Merge the nodes of ADD into TO. This merging process is done so that for
1258 each variable that already exists in TO, no new node is added; however if
1259 there is a write access recorded in ADD, and an occurrence on TO is only
1260 a read access, then the occurrence in TO will be modified to record the
1264 merge_tlist (struct tlist **to, struct tlist *add, int copy)
1266 struct tlist **end = to;
1269 end = &(*end)->next;
1275 struct tlist *next = add->next;
1277 for (tmp2 = *to; tmp2; tmp2 = tmp2->next)
1278 if (tmp2->expr == add->expr)
1282 tmp2->writer = add->writer;
1286 *end = copy ? add : new_tlist (NULL, add->expr, add->writer);
1287 end = &(*end)->next;
1294 /* WRITTEN is a variable, WRITER is its parent. Warn if any of the variable
1295 references in list LIST conflict with it, excluding reads if ONLY writers
1299 warn_for_collisions_1 (tree written, tree writer, struct tlist *list,
1304 /* Avoid duplicate warnings. */
1305 for (tmp = warned_ids; tmp; tmp = tmp->next)
1306 if (tmp->expr == written)
1311 if (list->expr == written
1312 && list->writer != writer
1313 && (!only_writes || list->writer)
1314 && DECL_NAME (list->expr))
1316 warned_ids = new_tlist (warned_ids, written, NULL_TREE);
1317 warning (0, "operation on %qE may be undefined", list->expr);
1323 /* Given a list LIST of references to variables, find whether any of these
1324 can cause conflicts due to missing sequence points. */
1327 warn_for_collisions (struct tlist *list)
1331 for (tmp = list; tmp; tmp = tmp->next)
1334 warn_for_collisions_1 (tmp->expr, tmp->writer, list, 0);
1338 /* Return nonzero if X is a tree that can be verified by the sequence point
1341 warning_candidate_p (tree x)
1343 return TREE_CODE (x) == VAR_DECL || TREE_CODE (x) == PARM_DECL;
1346 /* Walk the tree X, and record accesses to variables. If X is written by the
1347 parent tree, WRITER is the parent.
1348 We store accesses in one of the two lists: PBEFORE_SP, and PNO_SP. If this
1349 expression or its only operand forces a sequence point, then everything up
1350 to the sequence point is stored in PBEFORE_SP. Everything else gets stored
1352 Once we return, we will have emitted warnings if any subexpression before
1353 such a sequence point could be undefined. On a higher level, however, the
1354 sequence point may not be relevant, and we'll merge the two lists.
1356 Example: (b++, a) + b;
1357 The call that processes the COMPOUND_EXPR will store the increment of B
1358 in PBEFORE_SP, and the use of A in PNO_SP. The higher-level call that
1359 processes the PLUS_EXPR will need to merge the two lists so that
1360 eventually, all accesses end up on the same list (and we'll warn about the
1361 unordered subexpressions b++ and b.
1363 A note on merging. If we modify the former example so that our expression
1366 care must be taken not simply to add all three expressions into the final
1367 PNO_SP list. The function merge_tlist takes care of that by merging the
1368 before-SP list of the COMPOUND_EXPR into its after-SP list in a special
1369 way, so that no more than one access to B is recorded. */
1372 verify_tree (tree x, struct tlist **pbefore_sp, struct tlist **pno_sp,
1375 struct tlist *tmp_before, *tmp_nosp, *tmp_list2, *tmp_list3;
1376 enum tree_code code;
1377 enum tree_code_class cl;
1379 /* X may be NULL if it is the operand of an empty statement expression
1385 code = TREE_CODE (x);
1386 cl = TREE_CODE_CLASS (code);
1388 if (warning_candidate_p (x))
1390 *pno_sp = new_tlist (*pno_sp, x, writer);
1400 case TRUTH_ANDIF_EXPR:
1401 case TRUTH_ORIF_EXPR:
1402 tmp_before = tmp_nosp = tmp_list3 = 0;
1403 verify_tree (TREE_OPERAND (x, 0), &tmp_before, &tmp_nosp, NULL_TREE);
1404 warn_for_collisions (tmp_nosp);
1405 merge_tlist (pbefore_sp, tmp_before, 0);
1406 merge_tlist (pbefore_sp, tmp_nosp, 0);
1407 verify_tree (TREE_OPERAND (x, 1), &tmp_list3, pno_sp, NULL_TREE);
1408 merge_tlist (pbefore_sp, tmp_list3, 0);
1412 tmp_before = tmp_list2 = 0;
1413 verify_tree (TREE_OPERAND (x, 0), &tmp_before, &tmp_list2, NULL_TREE);
1414 warn_for_collisions (tmp_list2);
1415 merge_tlist (pbefore_sp, tmp_before, 0);
1416 merge_tlist (pbefore_sp, tmp_list2, 1);
1418 tmp_list3 = tmp_nosp = 0;
1419 verify_tree (TREE_OPERAND (x, 1), &tmp_list3, &tmp_nosp, NULL_TREE);
1420 warn_for_collisions (tmp_nosp);
1421 merge_tlist (pbefore_sp, tmp_list3, 0);
1423 tmp_list3 = tmp_list2 = 0;
1424 verify_tree (TREE_OPERAND (x, 2), &tmp_list3, &tmp_list2, NULL_TREE);
1425 warn_for_collisions (tmp_list2);
1426 merge_tlist (pbefore_sp, tmp_list3, 0);
1427 /* Rather than add both tmp_nosp and tmp_list2, we have to merge the
1428 two first, to avoid warning for (a ? b++ : b++). */
1429 merge_tlist (&tmp_nosp, tmp_list2, 0);
1430 add_tlist (pno_sp, tmp_nosp, NULL_TREE, 0);
1433 case PREDECREMENT_EXPR:
1434 case PREINCREMENT_EXPR:
1435 case POSTDECREMENT_EXPR:
1436 case POSTINCREMENT_EXPR:
1437 verify_tree (TREE_OPERAND (x, 0), pno_sp, pno_sp, x);
1441 tmp_before = tmp_nosp = tmp_list3 = 0;
1442 verify_tree (TREE_OPERAND (x, 1), &tmp_before, &tmp_nosp, NULL_TREE);
1443 verify_tree (TREE_OPERAND (x, 0), &tmp_list3, &tmp_list3, x);
1444 /* Expressions inside the LHS are not ordered wrt. the sequence points
1445 in the RHS. Example:
1447 Despite the fact that the modification of "a" is in the before_sp
1448 list (tmp_before), it conflicts with the use of "a" in the LHS.
1449 We can handle this by adding the contents of tmp_list3
1450 to those of tmp_before, and redoing the collision warnings for that
1452 add_tlist (&tmp_before, tmp_list3, x, 1);
1453 warn_for_collisions (tmp_before);
1454 /* Exclude the LHS itself here; we first have to merge it into the
1455 tmp_nosp list. This is done to avoid warning for "a = a"; if we
1456 didn't exclude the LHS, we'd get it twice, once as a read and once
1458 add_tlist (pno_sp, tmp_list3, x, 0);
1459 warn_for_collisions_1 (TREE_OPERAND (x, 0), x, tmp_nosp, 1);
1461 merge_tlist (pbefore_sp, tmp_before, 0);
1462 if (warning_candidate_p (TREE_OPERAND (x, 0)))
1463 merge_tlist (&tmp_nosp, new_tlist (NULL, TREE_OPERAND (x, 0), x), 0);
1464 add_tlist (pno_sp, tmp_nosp, NULL_TREE, 1);
1468 /* We need to warn about conflicts among arguments and conflicts between
1469 args and the function address. Side effects of the function address,
1470 however, are not ordered by the sequence point of the call. */
1471 tmp_before = tmp_nosp = tmp_list2 = tmp_list3 = 0;
1472 verify_tree (TREE_OPERAND (x, 0), &tmp_before, &tmp_nosp, NULL_TREE);
1473 if (TREE_OPERAND (x, 1))
1474 verify_tree (TREE_OPERAND (x, 1), &tmp_list2, &tmp_list3, NULL_TREE);
1475 merge_tlist (&tmp_list3, tmp_list2, 0);
1476 add_tlist (&tmp_before, tmp_list3, NULL_TREE, 0);
1477 add_tlist (&tmp_before, tmp_nosp, NULL_TREE, 0);
1478 warn_for_collisions (tmp_before);
1479 add_tlist (pbefore_sp, tmp_before, NULL_TREE, 0);
1483 /* Scan all the list, e.g. indices of multi dimensional array. */
1486 tmp_before = tmp_nosp = 0;
1487 verify_tree (TREE_VALUE (x), &tmp_before, &tmp_nosp, NULL_TREE);
1488 merge_tlist (&tmp_nosp, tmp_before, 0);
1489 add_tlist (pno_sp, tmp_nosp, NULL_TREE, 0);
1496 struct tlist_cache *t;
1497 for (t = save_expr_cache; t; t = t->next)
1503 t = XOBNEW (&tlist_obstack, struct tlist_cache);
1504 t->next = save_expr_cache;
1506 save_expr_cache = t;
1508 tmp_before = tmp_nosp = 0;
1509 verify_tree (TREE_OPERAND (x, 0), &tmp_before, &tmp_nosp, NULL_TREE);
1510 warn_for_collisions (tmp_nosp);
1515 struct tlist *t = tmp_nosp;
1517 merge_tlist (&tmp_list3, t, 0);
1519 t->cache_before_sp = tmp_before;
1520 t->cache_after_sp = tmp_list3;
1522 merge_tlist (pbefore_sp, t->cache_before_sp, 1);
1523 add_tlist (pno_sp, t->cache_after_sp, NULL_TREE, 1);
1528 /* For other expressions, simply recurse on their operands.
1529 Manual tail recursion for unary expressions.
1530 Other non-expressions need not be processed. */
1531 if (cl == tcc_unary)
1533 x = TREE_OPERAND (x, 0);
1537 else if (IS_EXPR_CODE_CLASS (cl))
1540 int max = TREE_CODE_LENGTH (TREE_CODE (x));
1541 for (lp = 0; lp < max; lp++)
1543 tmp_before = tmp_nosp = 0;
1544 verify_tree (TREE_OPERAND (x, lp), &tmp_before, &tmp_nosp, 0);
1545 merge_tlist (&tmp_nosp, tmp_before, 0);
1546 add_tlist (pno_sp, tmp_nosp, NULL_TREE, 0);
1553 /* Try to warn for undefined behavior in EXPR due to missing sequence
1557 verify_sequence_points (tree expr)
1559 struct tlist *before_sp = 0, *after_sp = 0;
1562 save_expr_cache = 0;
1563 if (tlist_firstobj == 0)
1565 gcc_obstack_init (&tlist_obstack);
1566 tlist_firstobj = (char *) obstack_alloc (&tlist_obstack, 0);
1569 verify_tree (expr, &before_sp, &after_sp, 0);
1570 warn_for_collisions (after_sp);
1571 obstack_free (&tlist_obstack, tlist_firstobj);
1574 /* Validate the expression after `case' and apply default promotions. */
1577 check_case_value (tree value)
1579 if (value == NULL_TREE)
1582 /* ??? Can we ever get nops here for a valid case value? We
1584 STRIP_TYPE_NOPS (value);
1585 /* In C++, the following is allowed:
1588 switch (...) { case i: ... }
1590 So, we try to reduce the VALUE to a constant that way. */
1591 if (c_dialect_cxx ())
1593 value = decl_constant_value (value);
1594 STRIP_TYPE_NOPS (value);
1595 value = fold (value);
1598 if (TREE_CODE (value) == INTEGER_CST)
1599 /* Promote char or short to int. */
1600 value = perform_integral_promotions (value);
1601 else if (value != error_mark_node)
1603 error ("case label does not reduce to an integer constant");
1604 value = error_mark_node;
1607 constant_expression_warning (value);
1612 /* See if the case values LOW and HIGH are in the range of the original
1613 type (i.e. before the default conversion to int) of the switch testing
1615 TYPE is the promoted type of the testing expression, and ORIG_TYPE is
1616 the type before promoting it. CASE_LOW_P is a pointer to the lower
1617 bound of the case label, and CASE_HIGH_P is the upper bound or NULL
1618 if the case is not a case range.
1619 The caller has to make sure that we are not called with NULL for
1620 CASE_LOW_P (i.e. the default case).
1621 Returns true if the case label is in range of ORIG_TYPE (saturated or
1622 untouched) or false if the label is out of range. */
1625 check_case_bounds (tree type, tree orig_type,
1626 tree *case_low_p, tree *case_high_p)
1628 tree min_value, max_value;
1629 tree case_low = *case_low_p;
1630 tree case_high = case_high_p ? *case_high_p : case_low;
1632 /* If there was a problem with the original type, do nothing. */
1633 if (orig_type == error_mark_node)
1636 min_value = TYPE_MIN_VALUE (orig_type);
1637 max_value = TYPE_MAX_VALUE (orig_type);
1639 /* Case label is less than minimum for type. */
1640 if (tree_int_cst_compare (case_low, min_value) < 0
1641 && tree_int_cst_compare (case_high, min_value) < 0)
1643 warning (0, "case label value is less than minimum value for type");
1647 /* Case value is greater than maximum for type. */
1648 if (tree_int_cst_compare (case_low, max_value) > 0
1649 && tree_int_cst_compare (case_high, max_value) > 0)
1651 warning (0, "case label value exceeds maximum value for type");
1655 /* Saturate lower case label value to minimum. */
1656 if (tree_int_cst_compare (case_high, min_value) >= 0
1657 && tree_int_cst_compare (case_low, min_value) < 0)
1659 warning (0, "lower value in case label range"
1660 " less than minimum value for type");
1661 case_low = min_value;
1664 /* Saturate upper case label value to maximum. */
1665 if (tree_int_cst_compare (case_low, max_value) <= 0
1666 && tree_int_cst_compare (case_high, max_value) > 0)
1668 warning (0, "upper value in case label range"
1669 " exceeds maximum value for type");
1670 case_high = max_value;
1673 if (*case_low_p != case_low)
1674 *case_low_p = convert (type, case_low);
1675 if (case_high_p && *case_high_p != case_high)
1676 *case_high_p = convert (type, case_high);
1681 /* Return an integer type with BITS bits of precision,
1682 that is unsigned if UNSIGNEDP is nonzero, otherwise signed. */
1685 c_common_type_for_size (unsigned int bits, int unsignedp)
1687 if (bits == TYPE_PRECISION (integer_type_node))
1688 return unsignedp ? unsigned_type_node : integer_type_node;
1690 if (bits == TYPE_PRECISION (signed_char_type_node))
1691 return unsignedp ? unsigned_char_type_node : signed_char_type_node;
1693 if (bits == TYPE_PRECISION (short_integer_type_node))
1694 return unsignedp ? short_unsigned_type_node : short_integer_type_node;
1696 if (bits == TYPE_PRECISION (long_integer_type_node))
1697 return unsignedp ? long_unsigned_type_node : long_integer_type_node;
1699 if (bits == TYPE_PRECISION (long_long_integer_type_node))
1700 return (unsignedp ? long_long_unsigned_type_node
1701 : long_long_integer_type_node);
1703 if (bits == TYPE_PRECISION (widest_integer_literal_type_node))
1704 return (unsignedp ? widest_unsigned_literal_type_node
1705 : widest_integer_literal_type_node);
1707 if (bits <= TYPE_PRECISION (intQI_type_node))
1708 return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
1710 if (bits <= TYPE_PRECISION (intHI_type_node))
1711 return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
1713 if (bits <= TYPE_PRECISION (intSI_type_node))
1714 return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
1716 if (bits <= TYPE_PRECISION (intDI_type_node))
1717 return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
1722 /* Used for communication between c_common_type_for_mode and
1723 c_register_builtin_type. */
1724 static GTY(()) tree registered_builtin_types;
1726 /* Return a data type that has machine mode MODE.
1727 If the mode is an integer,
1728 then UNSIGNEDP selects between signed and unsigned types. */
1731 c_common_type_for_mode (enum machine_mode mode, int unsignedp)
1735 if (mode == TYPE_MODE (integer_type_node))
1736 return unsignedp ? unsigned_type_node : integer_type_node;
1738 if (mode == TYPE_MODE (signed_char_type_node))
1739 return unsignedp ? unsigned_char_type_node : signed_char_type_node;
1741 if (mode == TYPE_MODE (short_integer_type_node))
1742 return unsignedp ? short_unsigned_type_node : short_integer_type_node;
1744 if (mode == TYPE_MODE (long_integer_type_node))
1745 return unsignedp ? long_unsigned_type_node : long_integer_type_node;
1747 if (mode == TYPE_MODE (long_long_integer_type_node))
1748 return unsignedp ? long_long_unsigned_type_node : long_long_integer_type_node;
1750 if (mode == TYPE_MODE (widest_integer_literal_type_node))
1751 return unsignedp ? widest_unsigned_literal_type_node
1752 : widest_integer_literal_type_node;
1755 return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
1758 return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
1761 return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
1764 return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
1766 #if HOST_BITS_PER_WIDE_INT >= 64
1767 if (mode == TYPE_MODE (intTI_type_node))
1768 return unsignedp ? unsigned_intTI_type_node : intTI_type_node;
1771 if (mode == TYPE_MODE (float_type_node))
1772 return float_type_node;
1774 if (mode == TYPE_MODE (double_type_node))
1775 return double_type_node;
1777 if (mode == TYPE_MODE (long_double_type_node))
1778 return long_double_type_node;
1780 if (mode == TYPE_MODE (void_type_node))
1781 return void_type_node;
1783 if (mode == TYPE_MODE (build_pointer_type (char_type_node)))
1785 ? make_unsigned_type (GET_MODE_PRECISION (mode))
1786 : make_signed_type (GET_MODE_PRECISION (mode)));
1788 if (mode == TYPE_MODE (build_pointer_type (integer_type_node)))
1790 ? make_unsigned_type (GET_MODE_PRECISION (mode))
1791 : make_signed_type (GET_MODE_PRECISION (mode)));
1793 if (COMPLEX_MODE_P (mode))
1795 enum machine_mode inner_mode;
1798 if (mode == TYPE_MODE (complex_float_type_node))
1799 return complex_float_type_node;
1800 if (mode == TYPE_MODE (complex_double_type_node))
1801 return complex_double_type_node;
1802 if (mode == TYPE_MODE (complex_long_double_type_node))
1803 return complex_long_double_type_node;
1805 if (mode == TYPE_MODE (complex_integer_type_node) && !unsignedp)
1806 return complex_integer_type_node;
1808 inner_mode = GET_MODE_INNER (mode);
1809 inner_type = c_common_type_for_mode (inner_mode, unsignedp);
1810 if (inner_type != NULL_TREE)
1811 return build_complex_type (inner_type);
1813 else if (VECTOR_MODE_P (mode))
1815 enum machine_mode inner_mode = GET_MODE_INNER (mode);
1816 tree inner_type = c_common_type_for_mode (inner_mode, unsignedp);
1817 if (inner_type != NULL_TREE)
1818 return build_vector_type_for_mode (inner_type, mode);
1821 if (mode == TYPE_MODE (dfloat32_type_node))
1822 return dfloat32_type_node;
1823 if (mode == TYPE_MODE (dfloat64_type_node))
1824 return dfloat64_type_node;
1825 if (mode == TYPE_MODE (dfloat128_type_node))
1826 return dfloat128_type_node;
1828 for (t = registered_builtin_types; t; t = TREE_CHAIN (t))
1829 if (TYPE_MODE (TREE_VALUE (t)) == mode)
1830 return TREE_VALUE (t);
1835 /* Return an unsigned type the same as TYPE in other respects. */
1837 c_common_unsigned_type (tree type)
1839 tree type1 = TYPE_MAIN_VARIANT (type);
1840 if (type1 == signed_char_type_node || type1 == char_type_node)
1841 return unsigned_char_type_node;
1842 if (type1 == integer_type_node)
1843 return unsigned_type_node;
1844 if (type1 == short_integer_type_node)
1845 return short_unsigned_type_node;
1846 if (type1 == long_integer_type_node)
1847 return long_unsigned_type_node;
1848 if (type1 == long_long_integer_type_node)
1849 return long_long_unsigned_type_node;
1850 if (type1 == widest_integer_literal_type_node)
1851 return widest_unsigned_literal_type_node;
1852 #if HOST_BITS_PER_WIDE_INT >= 64
1853 if (type1 == intTI_type_node)
1854 return unsigned_intTI_type_node;
1856 if (type1 == intDI_type_node)
1857 return unsigned_intDI_type_node;
1858 if (type1 == intSI_type_node)
1859 return unsigned_intSI_type_node;
1860 if (type1 == intHI_type_node)
1861 return unsigned_intHI_type_node;
1862 if (type1 == intQI_type_node)
1863 return unsigned_intQI_type_node;
1865 return c_common_signed_or_unsigned_type (1, type);
1868 /* Return a signed type the same as TYPE in other respects. */
1871 c_common_signed_type (tree type)
1873 tree type1 = TYPE_MAIN_VARIANT (type);
1874 if (type1 == unsigned_char_type_node || type1 == char_type_node)
1875 return signed_char_type_node;
1876 if (type1 == unsigned_type_node)
1877 return integer_type_node;
1878 if (type1 == short_unsigned_type_node)
1879 return short_integer_type_node;
1880 if (type1 == long_unsigned_type_node)
1881 return long_integer_type_node;
1882 if (type1 == long_long_unsigned_type_node)
1883 return long_long_integer_type_node;
1884 if (type1 == widest_unsigned_literal_type_node)
1885 return widest_integer_literal_type_node;
1886 #if HOST_BITS_PER_WIDE_INT >= 64
1887 if (type1 == unsigned_intTI_type_node)
1888 return intTI_type_node;
1890 if (type1 == unsigned_intDI_type_node)
1891 return intDI_type_node;
1892 if (type1 == unsigned_intSI_type_node)
1893 return intSI_type_node;
1894 if (type1 == unsigned_intHI_type_node)
1895 return intHI_type_node;
1896 if (type1 == unsigned_intQI_type_node)
1897 return intQI_type_node;
1899 return c_common_signed_or_unsigned_type (0, type);
1902 /* Return a type the same as TYPE except unsigned or
1903 signed according to UNSIGNEDP. */
1906 c_common_signed_or_unsigned_type (int unsignedp, tree type)
1908 if (!INTEGRAL_TYPE_P (type)
1909 || TYPE_UNSIGNED (type) == unsignedp)
1912 /* For ENUMERAL_TYPEs in C++, must check the mode of the types, not
1913 the precision; they have precision set to match their range, but
1914 may use a wider mode to match an ABI. If we change modes, we may
1915 wind up with bad conversions. For INTEGER_TYPEs in C, must check
1916 the precision as well, so as to yield correct results for
1917 bit-field types. C++ does not have these separate bit-field
1918 types, and producing a signed or unsigned variant of an
1919 ENUMERAL_TYPE may cause other problems as well. */
1921 #define TYPE_OK(node) \
1922 (TYPE_MODE (type) == TYPE_MODE (node) \
1923 && (c_dialect_cxx () || TYPE_PRECISION (type) == TYPE_PRECISION (node)))
1924 if (TYPE_OK (signed_char_type_node))
1925 return unsignedp ? unsigned_char_type_node : signed_char_type_node;
1926 if (TYPE_OK (integer_type_node))
1927 return unsignedp ? unsigned_type_node : integer_type_node;
1928 if (TYPE_OK (short_integer_type_node))
1929 return unsignedp ? short_unsigned_type_node : short_integer_type_node;
1930 if (TYPE_OK (long_integer_type_node))
1931 return unsignedp ? long_unsigned_type_node : long_integer_type_node;
1932 if (TYPE_OK (long_long_integer_type_node))
1933 return (unsignedp ? long_long_unsigned_type_node
1934 : long_long_integer_type_node);
1935 if (TYPE_OK (widest_integer_literal_type_node))
1936 return (unsignedp ? widest_unsigned_literal_type_node
1937 : widest_integer_literal_type_node);
1939 #if HOST_BITS_PER_WIDE_INT >= 64
1940 if (TYPE_OK (intTI_type_node))
1941 return unsignedp ? unsigned_intTI_type_node : intTI_type_node;
1943 if (TYPE_OK (intDI_type_node))
1944 return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
1945 if (TYPE_OK (intSI_type_node))
1946 return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
1947 if (TYPE_OK (intHI_type_node))
1948 return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
1949 if (TYPE_OK (intQI_type_node))
1950 return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
1953 if (c_dialect_cxx ())
1956 return build_nonstandard_integer_type (TYPE_PRECISION (type), unsignedp);
1959 /* Build a bit-field integer type for the given WIDTH and UNSIGNEDP. */
1962 c_build_bitfield_integer_type (unsigned HOST_WIDE_INT width, int unsignedp)
1964 /* Extended integer types of the same width as a standard type have
1965 lesser rank, so those of the same width as int promote to int or
1966 unsigned int and are valid for printf formats expecting int or
1967 unsigned int. To avoid such special cases, avoid creating
1968 extended integer types for bit-fields if a standard integer type
1970 if (width == TYPE_PRECISION (integer_type_node))
1971 return unsignedp ? unsigned_type_node : integer_type_node;
1972 if (width == TYPE_PRECISION (signed_char_type_node))
1973 return unsignedp ? unsigned_char_type_node : signed_char_type_node;
1974 if (width == TYPE_PRECISION (short_integer_type_node))
1975 return unsignedp ? short_unsigned_type_node : short_integer_type_node;
1976 if (width == TYPE_PRECISION (long_integer_type_node))
1977 return unsignedp ? long_unsigned_type_node : long_integer_type_node;
1978 if (width == TYPE_PRECISION (long_long_integer_type_node))
1979 return (unsignedp ? long_long_unsigned_type_node
1980 : long_long_integer_type_node);
1981 return build_nonstandard_integer_type (width, unsignedp);
1984 /* The C version of the register_builtin_type langhook. */
1987 c_register_builtin_type (tree type, const char* name)
1991 decl = build_decl (TYPE_DECL, get_identifier (name), type);
1992 DECL_ARTIFICIAL (decl) = 1;
1993 if (!TYPE_NAME (type))
1994 TYPE_NAME (type) = decl;
1997 registered_builtin_types = tree_cons (0, type, registered_builtin_types);
2001 /* Return the minimum number of bits needed to represent VALUE in a
2002 signed or unsigned type, UNSIGNEDP says which. */
2005 min_precision (tree value, int unsignedp)
2009 /* If the value is negative, compute its negative minus 1. The latter
2010 adjustment is because the absolute value of the largest negative value
2011 is one larger than the largest positive value. This is equivalent to
2012 a bit-wise negation, so use that operation instead. */
2014 if (tree_int_cst_sgn (value) < 0)
2015 value = fold_build1 (BIT_NOT_EXPR, TREE_TYPE (value), value);
2017 /* Return the number of bits needed, taking into account the fact
2018 that we need one more bit for a signed than unsigned type. */
2020 if (integer_zerop (value))
2023 log = tree_floor_log2 (value);
2025 return log + 1 + !unsignedp;
2028 /* Print an error message for invalid operands to arith operation
2029 CODE with TYPE0 for operand 0, and TYPE1 for operand 1. */
2032 binary_op_error (enum tree_code code, tree type0, tree type1)
2039 opname = "+"; break;
2041 opname = "-"; break;
2043 opname = "*"; break;
2045 opname = "max"; break;
2047 opname = "min"; break;
2049 opname = "=="; break;
2051 opname = "!="; break;
2053 opname = "<="; break;
2055 opname = ">="; break;
2057 opname = "<"; break;
2059 opname = ">"; break;
2061 opname = "<<"; break;
2063 opname = ">>"; break;
2064 case TRUNC_MOD_EXPR:
2065 case FLOOR_MOD_EXPR:
2066 opname = "%"; break;
2067 case TRUNC_DIV_EXPR:
2068 case FLOOR_DIV_EXPR:
2069 opname = "/"; break;
2071 opname = "&"; break;
2073 opname = "|"; break;
2074 case TRUTH_ANDIF_EXPR:
2075 opname = "&&"; break;
2076 case TRUTH_ORIF_EXPR:
2077 opname = "||"; break;
2079 opname = "^"; break;
2083 error ("invalid operands to binary %s (have %qT and %qT)", opname,
2087 /* Subroutine of build_binary_op, used for comparison operations.
2088 See if the operands have both been converted from subword integer types
2089 and, if so, perhaps change them both back to their original type.
2090 This function is also responsible for converting the two operands
2091 to the proper common type for comparison.
2093 The arguments of this function are all pointers to local variables
2094 of build_binary_op: OP0_PTR is &OP0, OP1_PTR is &OP1,
2095 RESTYPE_PTR is &RESULT_TYPE and RESCODE_PTR is &RESULTCODE.
2097 If this function returns nonzero, it means that the comparison has
2098 a constant value. What this function returns is an expression for
2102 shorten_compare (tree *op0_ptr, tree *op1_ptr, tree *restype_ptr,
2103 enum tree_code *rescode_ptr)
2106 tree op0 = *op0_ptr;
2107 tree op1 = *op1_ptr;
2108 int unsignedp0, unsignedp1;
2110 tree primop0, primop1;
2111 enum tree_code code = *rescode_ptr;
2113 /* Throw away any conversions to wider types
2114 already present in the operands. */
2116 primop0 = get_narrower (op0, &unsignedp0);
2117 primop1 = get_narrower (op1, &unsignedp1);
2119 /* Handle the case that OP0 does not *contain* a conversion
2120 but it *requires* conversion to FINAL_TYPE. */
2122 if (op0 == primop0 && TREE_TYPE (op0) != *restype_ptr)
2123 unsignedp0 = TYPE_UNSIGNED (TREE_TYPE (op0));
2124 if (op1 == primop1 && TREE_TYPE (op1) != *restype_ptr)
2125 unsignedp1 = TYPE_UNSIGNED (TREE_TYPE (op1));
2127 /* If one of the operands must be floated, we cannot optimize. */
2128 real1 = TREE_CODE (TREE_TYPE (primop0)) == REAL_TYPE;
2129 real2 = TREE_CODE (TREE_TYPE (primop1)) == REAL_TYPE;
2131 /* If first arg is constant, swap the args (changing operation
2132 so value is preserved), for canonicalization. Don't do this if
2133 the second arg is 0. */
2135 if (TREE_CONSTANT (primop0)
2136 && !integer_zerop (primop1) && !real_zerop (primop1))
2139 int temi = unsignedp0;
2147 unsignedp0 = unsignedp1;
2170 *rescode_ptr = code;
2173 /* If comparing an integer against a constant more bits wide,
2174 maybe we can deduce a value of 1 or 0 independent of the data.
2175 Or else truncate the constant now
2176 rather than extend the variable at run time.
2178 This is only interesting if the constant is the wider arg.
2179 Also, it is not safe if the constant is unsigned and the
2180 variable arg is signed, since in this case the variable
2181 would be sign-extended and then regarded as unsigned.
2182 Our technique fails in this case because the lowest/highest
2183 possible unsigned results don't follow naturally from the
2184 lowest/highest possible values of the variable operand.
2185 For just EQ_EXPR and NE_EXPR there is another technique that
2186 could be used: see if the constant can be faithfully represented
2187 in the other operand's type, by truncating it and reextending it
2188 and see if that preserves the constant's value. */
2190 if (!real1 && !real2
2191 && TREE_CODE (primop1) == INTEGER_CST
2192 && TYPE_PRECISION (TREE_TYPE (primop0)) < TYPE_PRECISION (*restype_ptr))
2194 int min_gt, max_gt, min_lt, max_lt;
2195 tree maxval, minval;
2196 /* 1 if comparison is nominally unsigned. */
2197 int unsignedp = TYPE_UNSIGNED (*restype_ptr);
2200 type = c_common_signed_or_unsigned_type (unsignedp0,
2201 TREE_TYPE (primop0));
2203 maxval = TYPE_MAX_VALUE (type);
2204 minval = TYPE_MIN_VALUE (type);
2206 if (unsignedp && !unsignedp0)
2207 *restype_ptr = c_common_signed_type (*restype_ptr);
2209 if (TREE_TYPE (primop1) != *restype_ptr)
2211 /* Convert primop1 to target type, but do not introduce
2212 additional overflow. We know primop1 is an int_cst. */
2213 tree tmp = build_int_cst_wide (*restype_ptr,
2214 TREE_INT_CST_LOW (primop1),
2215 TREE_INT_CST_HIGH (primop1));
2217 primop1 = force_fit_type (tmp, 0, TREE_OVERFLOW (primop1),
2218 TREE_CONSTANT_OVERFLOW (primop1));
2220 if (type != *restype_ptr)
2222 minval = convert (*restype_ptr, minval);
2223 maxval = convert (*restype_ptr, maxval);
2226 if (unsignedp && unsignedp0)
2228 min_gt = INT_CST_LT_UNSIGNED (primop1, minval);
2229 max_gt = INT_CST_LT_UNSIGNED (primop1, maxval);
2230 min_lt = INT_CST_LT_UNSIGNED (minval, primop1);
2231 max_lt = INT_CST_LT_UNSIGNED (maxval, primop1);
2235 min_gt = INT_CST_LT (primop1, minval);
2236 max_gt = INT_CST_LT (primop1, maxval);
2237 min_lt = INT_CST_LT (minval, primop1);
2238 max_lt = INT_CST_LT (maxval, primop1);
2242 /* This used to be a switch, but Genix compiler can't handle that. */
2243 if (code == NE_EXPR)
2245 if (max_lt || min_gt)
2246 val = truthvalue_true_node;
2248 else if (code == EQ_EXPR)
2250 if (max_lt || min_gt)
2251 val = truthvalue_false_node;
2253 else if (code == LT_EXPR)
2256 val = truthvalue_true_node;
2258 val = truthvalue_false_node;
2260 else if (code == GT_EXPR)
2263 val = truthvalue_true_node;
2265 val = truthvalue_false_node;
2267 else if (code == LE_EXPR)
2270 val = truthvalue_true_node;
2272 val = truthvalue_false_node;
2274 else if (code == GE_EXPR)
2277 val = truthvalue_true_node;
2279 val = truthvalue_false_node;
2282 /* If primop0 was sign-extended and unsigned comparison specd,
2283 we did a signed comparison above using the signed type bounds.
2284 But the comparison we output must be unsigned.
2286 Also, for inequalities, VAL is no good; but if the signed
2287 comparison had *any* fixed result, it follows that the
2288 unsigned comparison just tests the sign in reverse
2289 (positive values are LE, negative ones GE).
2290 So we can generate an unsigned comparison
2291 against an extreme value of the signed type. */
2293 if (unsignedp && !unsignedp0)
2300 primop1 = TYPE_MIN_VALUE (type);
2306 primop1 = TYPE_MAX_VALUE (type);
2313 type = c_common_unsigned_type (type);
2316 if (TREE_CODE (primop0) != INTEGER_CST)
2318 if (val == truthvalue_false_node)
2319 warning (0, "comparison is always false due to limited range of data type");
2320 if (val == truthvalue_true_node)
2321 warning (0, "comparison is always true due to limited range of data type");
2326 /* Don't forget to evaluate PRIMOP0 if it has side effects. */
2327 if (TREE_SIDE_EFFECTS (primop0))
2328 return build2 (COMPOUND_EXPR, TREE_TYPE (val), primop0, val);
2332 /* Value is not predetermined, but do the comparison
2333 in the type of the operand that is not constant.
2334 TYPE is already properly set. */
2337 /* If either arg is decimal float and the other is float, find the
2338 proper common type to use for comparison. */
2339 else if (real1 && real2
2340 && (DECIMAL_FLOAT_MODE_P (TYPE_MODE (TREE_TYPE (primop0)))
2341 || DECIMAL_FLOAT_MODE_P (TYPE_MODE (TREE_TYPE (primop1)))))
2342 type = common_type (TREE_TYPE (primop0), TREE_TYPE (primop1));
2344 else if (real1 && real2
2345 && (TYPE_PRECISION (TREE_TYPE (primop0))
2346 == TYPE_PRECISION (TREE_TYPE (primop1))))
2347 type = TREE_TYPE (primop0);
2349 /* If args' natural types are both narrower than nominal type
2350 and both extend in the same manner, compare them
2351 in the type of the wider arg.
2352 Otherwise must actually extend both to the nominal
2353 common type lest different ways of extending
2355 (eg, (short)-1 == (unsigned short)-1 should be 0.) */
2357 else if (unsignedp0 == unsignedp1 && real1 == real2
2358 && TYPE_PRECISION (TREE_TYPE (primop0)) < TYPE_PRECISION (*restype_ptr)
2359 && TYPE_PRECISION (TREE_TYPE (primop1)) < TYPE_PRECISION (*restype_ptr))
2361 type = common_type (TREE_TYPE (primop0), TREE_TYPE (primop1));
2362 type = c_common_signed_or_unsigned_type (unsignedp0
2363 || TYPE_UNSIGNED (*restype_ptr),
2365 /* Make sure shorter operand is extended the right way
2366 to match the longer operand. */
2368 = convert (c_common_signed_or_unsigned_type (unsignedp0,
2369 TREE_TYPE (primop0)),
2372 = convert (c_common_signed_or_unsigned_type (unsignedp1,
2373 TREE_TYPE (primop1)),
2378 /* Here we must do the comparison on the nominal type
2379 using the args exactly as we received them. */
2380 type = *restype_ptr;
2384 if (!real1 && !real2 && integer_zerop (primop1)
2385 && TYPE_UNSIGNED (*restype_ptr))
2391 /* All unsigned values are >= 0, so we warn if extra warnings
2392 are requested. However, if OP0 is a constant that is
2393 >= 0, the signedness of the comparison isn't an issue,
2394 so suppress the warning. */
2395 if (extra_warnings && !in_system_header
2396 && !(TREE_CODE (primop0) == INTEGER_CST
2397 && !TREE_OVERFLOW (convert (c_common_signed_type (type),
2399 warning (0, "comparison of unsigned expression >= 0 is always true");
2400 value = truthvalue_true_node;
2404 if (extra_warnings && !in_system_header
2405 && !(TREE_CODE (primop0) == INTEGER_CST
2406 && !TREE_OVERFLOW (convert (c_common_signed_type (type),
2408 warning (0, "comparison of unsigned expression < 0 is always false");
2409 value = truthvalue_false_node;
2418 /* Don't forget to evaluate PRIMOP0 if it has side effects. */
2419 if (TREE_SIDE_EFFECTS (primop0))
2420 return build2 (COMPOUND_EXPR, TREE_TYPE (value),
2427 *op0_ptr = convert (type, primop0);
2428 *op1_ptr = convert (type, primop1);
2430 *restype_ptr = truthvalue_type_node;
2435 /* Return a tree for the sum or difference (RESULTCODE says which)
2436 of pointer PTROP and integer INTOP. */
2439 pointer_int_sum (enum tree_code resultcode, tree ptrop, tree intop)
2443 /* The result is a pointer of the same type that is being added. */
2445 tree result_type = TREE_TYPE (ptrop);
2447 if (TREE_CODE (TREE_TYPE (result_type)) == VOID_TYPE)
2449 if (pedantic || warn_pointer_arith)
2450 pedwarn ("pointer of type %<void *%> used in arithmetic");
2451 size_exp = integer_one_node;
2453 else if (TREE_CODE (TREE_TYPE (result_type)) == FUNCTION_TYPE)
2455 if (pedantic || warn_pointer_arith)
2456 pedwarn ("pointer to a function used in arithmetic");
2457 size_exp = integer_one_node;
2459 else if (TREE_CODE (TREE_TYPE (result_type)) == METHOD_TYPE)
2461 if (pedantic || warn_pointer_arith)
2462 pedwarn ("pointer to member function used in arithmetic");
2463 size_exp = integer_one_node;
2466 size_exp = size_in_bytes (TREE_TYPE (result_type));
2468 /* We are manipulating pointer values, so we don't need to warn
2469 about relying on undefined signed overflow. We disable the
2470 warning here because we use integer types so fold won't know that
2471 they are really pointers. */
2472 fold_defer_overflow_warnings ();
2474 /* If what we are about to multiply by the size of the elements
2475 contains a constant term, apply distributive law
2476 and multiply that constant term separately.
2477 This helps produce common subexpressions. */
2479 if ((TREE_CODE (intop) == PLUS_EXPR || TREE_CODE (intop) == MINUS_EXPR)
2480 && !TREE_CONSTANT (intop)
2481 && TREE_CONSTANT (TREE_OPERAND (intop, 1))
2482 && TREE_CONSTANT (size_exp)
2483 /* If the constant comes from pointer subtraction,
2484 skip this optimization--it would cause an error. */
2485 && TREE_CODE (TREE_TYPE (TREE_OPERAND (intop, 0))) == INTEGER_TYPE
2486 /* If the constant is unsigned, and smaller than the pointer size,
2487 then we must skip this optimization. This is because it could cause
2488 an overflow error if the constant is negative but INTOP is not. */
2489 && (!TYPE_UNSIGNED (TREE_TYPE (intop))
2490 || (TYPE_PRECISION (TREE_TYPE (intop))
2491 == TYPE_PRECISION (TREE_TYPE (ptrop)))))
2493 enum tree_code subcode = resultcode;
2494 tree int_type = TREE_TYPE (intop);
2495 if (TREE_CODE (intop) == MINUS_EXPR)
2496 subcode = (subcode == PLUS_EXPR ? MINUS_EXPR : PLUS_EXPR);
2497 /* Convert both subexpression types to the type of intop,
2498 because weird cases involving pointer arithmetic
2499 can result in a sum or difference with different type args. */
2500 ptrop = build_binary_op (subcode, ptrop,
2501 convert (int_type, TREE_OPERAND (intop, 1)), 1);
2502 intop = convert (int_type, TREE_OPERAND (intop, 0));
2505 /* Convert the integer argument to a type the same size as sizetype
2506 so the multiply won't overflow spuriously. */
2508 if (TYPE_PRECISION (TREE_TYPE (intop)) != TYPE_PRECISION (sizetype)
2509 || TYPE_UNSIGNED (TREE_TYPE (intop)) != TYPE_UNSIGNED (sizetype))
2510 intop = convert (c_common_type_for_size (TYPE_PRECISION (sizetype),
2511 TYPE_UNSIGNED (sizetype)), intop);
2513 /* Replace the integer argument with a suitable product by the object size.
2514 Do this multiplication as signed, then convert to the appropriate
2515 pointer type (actually unsigned integral). */
2517 intop = convert (result_type,
2518 build_binary_op (MULT_EXPR, intop,
2519 convert (TREE_TYPE (intop), size_exp), 1));
2521 /* Create the sum or difference. */
2522 ret = fold_build2 (resultcode, result_type, ptrop, intop);
2524 fold_undefer_and_ignore_overflow_warnings ();
2529 /* Prepare expr to be an argument of a TRUTH_NOT_EXPR,
2530 or for an `if' or `while' statement or ?..: exp. It should already
2531 have been validated to be of suitable type; otherwise, a bad
2532 diagnostic may result.
2534 This preparation consists of taking the ordinary
2535 representation of an expression expr and producing a valid tree
2536 boolean expression describing whether expr is nonzero. We could
2537 simply always do build_binary_op (NE_EXPR, expr, truthvalue_false_node, 1),
2538 but we optimize comparisons, &&, ||, and !.
2540 The resulting type should always be `truthvalue_type_node'. */
2543 c_common_truthvalue_conversion (tree expr)
2545 switch (TREE_CODE (expr))
2547 case EQ_EXPR: case NE_EXPR: case UNEQ_EXPR: case LTGT_EXPR:
2548 case LE_EXPR: case GE_EXPR: case LT_EXPR: case GT_EXPR:
2549 case UNLE_EXPR: case UNGE_EXPR: case UNLT_EXPR: case UNGT_EXPR:
2550 case ORDERED_EXPR: case UNORDERED_EXPR:
2551 if (TREE_TYPE (expr) == truthvalue_type_node)
2553 return build2 (TREE_CODE (expr), truthvalue_type_node,
2554 TREE_OPERAND (expr, 0), TREE_OPERAND (expr, 1));
2556 case TRUTH_ANDIF_EXPR:
2557 case TRUTH_ORIF_EXPR:
2558 case TRUTH_AND_EXPR:
2560 case TRUTH_XOR_EXPR:
2561 if (TREE_TYPE (expr) == truthvalue_type_node)
2563 return build2 (TREE_CODE (expr), truthvalue_type_node,
2564 c_common_truthvalue_conversion (TREE_OPERAND (expr, 0)),
2565 c_common_truthvalue_conversion (TREE_OPERAND (expr, 1)));
2567 case TRUTH_NOT_EXPR:
2568 if (TREE_TYPE (expr) == truthvalue_type_node)
2570 return build1 (TREE_CODE (expr), truthvalue_type_node,
2571 c_common_truthvalue_conversion (TREE_OPERAND (expr, 0)));
2577 /* Avoid integer_zerop to ignore TREE_CONSTANT_OVERFLOW. */
2578 return (TREE_INT_CST_LOW (expr) != 0 || TREE_INT_CST_HIGH (expr) != 0)
2579 ? truthvalue_true_node
2580 : truthvalue_false_node;
2583 return real_compare (NE_EXPR, &TREE_REAL_CST (expr), &dconst0)
2584 ? truthvalue_true_node
2585 : truthvalue_false_node;
2588 expr = build_unary_op (ADDR_EXPR, expr, 0);
2593 tree inner = TREE_OPERAND (expr, 0);
2595 && (TREE_CODE (inner) == PARM_DECL
2596 || TREE_CODE (inner) == LABEL_DECL
2597 || !DECL_WEAK (inner)))
2599 /* Common Ada/Pascal programmer's mistake. We always warn
2600 about this since it is so bad. */
2601 warning (OPT_Waddress,
2602 "the address of %qD will always evaluate as %<true%>",
2604 return truthvalue_true_node;
2607 /* If we are taking the address of an external decl, it might be
2608 zero if it is weak, so we cannot optimize. */
2610 && DECL_EXTERNAL (inner))
2613 if (TREE_SIDE_EFFECTS (inner))
2614 return build2 (COMPOUND_EXPR, truthvalue_type_node,
2615 inner, truthvalue_true_node);
2617 return truthvalue_true_node;
2621 return build_binary_op ((TREE_SIDE_EFFECTS (TREE_OPERAND (expr, 1))
2622 ? TRUTH_OR_EXPR : TRUTH_ORIF_EXPR),
2623 c_common_truthvalue_conversion (TREE_OPERAND (expr, 0)),
2624 c_common_truthvalue_conversion (TREE_OPERAND (expr, 1)),
2630 /* These don't change whether an object is nonzero or zero. */
2631 return c_common_truthvalue_conversion (TREE_OPERAND (expr, 0));
2635 /* These don't change whether an object is zero or nonzero, but
2636 we can't ignore them if their second arg has side-effects. */
2637 if (TREE_SIDE_EFFECTS (TREE_OPERAND (expr, 1)))
2638 return build2 (COMPOUND_EXPR, truthvalue_type_node,
2639 TREE_OPERAND (expr, 1),
2640 c_common_truthvalue_conversion (TREE_OPERAND (expr, 0)));
2642 return c_common_truthvalue_conversion (TREE_OPERAND (expr, 0));
2645 /* Distribute the conversion into the arms of a COND_EXPR. */
2646 return fold_build3 (COND_EXPR, truthvalue_type_node,
2647 TREE_OPERAND (expr, 0),
2648 c_common_truthvalue_conversion (TREE_OPERAND (expr, 1)),
2649 c_common_truthvalue_conversion (TREE_OPERAND (expr, 2)));
2653 /* Don't cancel the effect of a CONVERT_EXPR from a REFERENCE_TYPE,
2654 since that affects how `default_conversion' will behave. */
2655 if (TREE_CODE (TREE_TYPE (expr)) == REFERENCE_TYPE
2656 || TREE_CODE (TREE_TYPE (TREE_OPERAND (expr, 0))) == REFERENCE_TYPE)
2658 /* If this is widening the argument, we can ignore it. */
2659 if (TYPE_PRECISION (TREE_TYPE (expr))
2660 >= TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (expr, 0))))
2661 return c_common_truthvalue_conversion (TREE_OPERAND (expr, 0));
2665 if (!TREE_NO_WARNING (expr)
2666 && warn_parentheses)
2668 warning (OPT_Wparentheses,
2669 "suggest parentheses around assignment used as truth value");
2670 TREE_NO_WARNING (expr) = 1;
2678 if (TREE_CODE (TREE_TYPE (expr)) == COMPLEX_TYPE)
2680 tree t = save_expr (expr);
2681 return (build_binary_op
2682 ((TREE_SIDE_EFFECTS (expr)
2683 ? TRUTH_OR_EXPR : TRUTH_ORIF_EXPR),
2684 c_common_truthvalue_conversion (build_unary_op (REALPART_EXPR, t, 0)),
2685 c_common_truthvalue_conversion (build_unary_op (IMAGPART_EXPR, t, 0)),
2689 return build_binary_op (NE_EXPR, expr, integer_zero_node, 1);
2692 static void def_builtin_1 (enum built_in_function fncode,
2694 enum built_in_class fnclass,
2695 tree fntype, tree libtype,
2696 bool both_p, bool fallback_p, bool nonansi_p,
2697 tree fnattrs, bool implicit_p);
2699 /* Make a variant type in the proper way for C/C++, propagating qualifiers
2700 down to the element type of an array. */
2703 c_build_qualified_type (tree type, int type_quals)
2705 if (type == error_mark_node)
2708 if (TREE_CODE (type) == ARRAY_TYPE)
2711 tree element_type = c_build_qualified_type (TREE_TYPE (type),
2714 /* See if we already have an identically qualified type. */
2715 for (t = TYPE_MAIN_VARIANT (type); t; t = TYPE_NEXT_VARIANT (t))
2717 if (TYPE_QUALS (strip_array_types (t)) == type_quals
2718 && TYPE_NAME (t) == TYPE_NAME (type)
2719 && TYPE_CONTEXT (t) == TYPE_CONTEXT (type)
2720 && attribute_list_equal (TYPE_ATTRIBUTES (t),
2721 TYPE_ATTRIBUTES (type)))
2726 t = build_variant_type_copy (type);
2727 TREE_TYPE (t) = element_type;
2732 /* A restrict-qualified pointer type must be a pointer to object or
2733 incomplete type. Note that the use of POINTER_TYPE_P also allows
2734 REFERENCE_TYPEs, which is appropriate for C++. */
2735 if ((type_quals & TYPE_QUAL_RESTRICT)
2736 && (!POINTER_TYPE_P (type)
2737 || !C_TYPE_OBJECT_OR_INCOMPLETE_P (TREE_TYPE (type))))
2739 error ("invalid use of %<restrict%>");
2740 type_quals &= ~TYPE_QUAL_RESTRICT;
2743 return build_qualified_type (type, type_quals);
2746 /* Apply the TYPE_QUALS to the new DECL. */
2749 c_apply_type_quals_to_decl (int type_quals, tree decl)
2751 tree type = TREE_TYPE (decl);
2753 if (type == error_mark_node)
2756 if (((type_quals & TYPE_QUAL_CONST)
2757 || (type && TREE_CODE (type) == REFERENCE_TYPE))
2758 /* An object declared 'const' is only readonly after it is
2759 initialized. We don't have any way of expressing this currently,
2760 so we need to be conservative and unset TREE_READONLY for types
2761 with constructors. Otherwise aliasing code will ignore stores in
2762 an inline constructor. */
2763 && !(type && TYPE_NEEDS_CONSTRUCTING (type)))
2764 TREE_READONLY (decl) = 1;
2765 if (type_quals & TYPE_QUAL_VOLATILE)
2767 TREE_SIDE_EFFECTS (decl) = 1;
2768 TREE_THIS_VOLATILE (decl) = 1;
2770 if (type_quals & TYPE_QUAL_RESTRICT)
2772 while (type && TREE_CODE (type) == ARRAY_TYPE)
2773 /* Allow 'restrict' on arrays of pointers.
2774 FIXME currently we just ignore it. */
2775 type = TREE_TYPE (type);
2777 || !POINTER_TYPE_P (type)
2778 || !C_TYPE_OBJECT_OR_INCOMPLETE_P (TREE_TYPE (type)))
2779 error ("invalid use of %<restrict%>");
2780 else if (flag_strict_aliasing && type == TREE_TYPE (decl))
2781 /* Indicate we need to make a unique alias set for this pointer.
2782 We can't do it here because it might be pointing to an
2784 DECL_POINTER_ALIAS_SET (decl) = -2;
2788 /* Hash function for the problem of multiple type definitions in
2789 different files. This must hash all types that will compare
2790 equal via comptypes to the same value. In practice it hashes
2791 on some of the simple stuff and leaves the details to comptypes. */
2794 c_type_hash (const void *p)
2800 switch (TREE_CODE (t))
2802 /* For pointers, hash on pointee type plus some swizzling. */
2804 return c_type_hash (TREE_TYPE (t)) ^ 0x3003003;
2805 /* Hash on number of elements and total size. */
2808 t2 = TYPE_VALUES (t);
2812 t2 = TYPE_FIELDS (t);
2814 case QUAL_UNION_TYPE:
2816 t2 = TYPE_FIELDS (t);
2820 t2 = TYPE_FIELDS (t);
2825 for (; t2; t2 = TREE_CHAIN (t2))
2827 size = TREE_INT_CST_LOW (TYPE_SIZE (t));
2828 return ((size << 24) | (i << shift));
2831 static GTY((param_is (union tree_node))) htab_t type_hash_table;
2833 /* Return the typed-based alias set for T, which may be an expression
2834 or a type. Return -1 if we don't do anything special. */
2837 c_common_get_alias_set (tree t)
2842 /* Permit type-punning when accessing a union, provided the access
2843 is directly through the union. For example, this code does not
2844 permit taking the address of a union member and then storing
2845 through it. Even the type-punning allowed here is a GCC
2846 extension, albeit a common and useful one; the C standard says
2847 that such accesses have implementation-defined behavior. */
2849 TREE_CODE (u) == COMPONENT_REF || TREE_CODE (u) == ARRAY_REF;
2850 u = TREE_OPERAND (u, 0))
2851 if (TREE_CODE (u) == COMPONENT_REF
2852 && TREE_CODE (TREE_TYPE (TREE_OPERAND (u, 0))) == UNION_TYPE)
2855 /* That's all the expressions we handle specially. */
2859 /* The C standard guarantees that any object may be accessed via an
2860 lvalue that has character type. */
2861 if (t == char_type_node
2862 || t == signed_char_type_node
2863 || t == unsigned_char_type_node)
2866 /* If it has the may_alias attribute, it can alias anything. */
2867 if (lookup_attribute ("may_alias", TYPE_ATTRIBUTES (t)))
2870 /* The C standard specifically allows aliasing between signed and
2871 unsigned variants of the same type. We treat the signed
2872 variant as canonical. */
2873 if (TREE_CODE (t) == INTEGER_TYPE && TYPE_UNSIGNED (t))
2875 tree t1 = c_common_signed_type (t);
2877 /* t1 == t can happen for boolean nodes which are always unsigned. */
2879 return get_alias_set (t1);
2881 else if (POINTER_TYPE_P (t))
2885 /* Unfortunately, there is no canonical form of a pointer type.
2886 In particular, if we have `typedef int I', then `int *', and
2887 `I *' are different types. So, we have to pick a canonical
2888 representative. We do this below.
2890 Technically, this approach is actually more conservative that
2891 it needs to be. In particular, `const int *' and `int *'
2892 should be in different alias sets, according to the C and C++
2893 standard, since their types are not the same, and so,
2894 technically, an `int **' and `const int **' cannot point at
2897 But, the standard is wrong. In particular, this code is
2902 const int* const* cipp = ipp;
2904 And, it doesn't make sense for that to be legal unless you
2905 can dereference IPP and CIPP. So, we ignore cv-qualifiers on
2906 the pointed-to types. This issue has been reported to the
2908 t1 = build_type_no_quals (t);
2910 return get_alias_set (t1);
2913 /* Handle the case of multiple type nodes referring to "the same" type,
2914 which occurs with IMA. These share an alias set. FIXME: Currently only
2915 C90 is handled. (In C99 type compatibility is not transitive, which
2916 complicates things mightily. The alias set splay trees can theoretically
2917 represent this, but insertion is tricky when you consider all the
2918 different orders things might arrive in.) */
2920 if (c_language != clk_c || flag_isoc99)
2923 /* Save time if there's only one input file. */
2924 if (num_in_fnames == 1)
2927 /* Pointers need special handling if they point to any type that
2928 needs special handling (below). */
2929 if (TREE_CODE (t) == POINTER_TYPE)
2932 /* Find bottom type under any nested POINTERs. */
2933 for (t2 = TREE_TYPE (t);
2934 TREE_CODE (t2) == POINTER_TYPE;
2935 t2 = TREE_TYPE (t2))
2937 if (TREE_CODE (t2) != RECORD_TYPE
2938 && TREE_CODE (t2) != ENUMERAL_TYPE
2939 && TREE_CODE (t2) != QUAL_UNION_TYPE
2940 && TREE_CODE (t2) != UNION_TYPE)
2942 if (TYPE_SIZE (t2) == 0)
2945 /* These are the only cases that need special handling. */
2946 if (TREE_CODE (t) != RECORD_TYPE
2947 && TREE_CODE (t) != ENUMERAL_TYPE
2948 && TREE_CODE (t) != QUAL_UNION_TYPE
2949 && TREE_CODE (t) != UNION_TYPE
2950 && TREE_CODE (t) != POINTER_TYPE)
2953 if (TYPE_SIZE (t) == 0)
2956 /* Look up t in hash table. Only one of the compatible types within each
2957 alias set is recorded in the table. */
2958 if (!type_hash_table)
2959 type_hash_table = htab_create_ggc (1021, c_type_hash,
2960 (htab_eq) lang_hooks.types_compatible_p,
2962 slot = htab_find_slot (type_hash_table, t, INSERT);
2965 TYPE_ALIAS_SET (t) = TYPE_ALIAS_SET ((tree)*slot);
2966 return TYPE_ALIAS_SET ((tree)*slot);
2969 /* Our caller will assign and record (in t) a new alias set; all we need
2970 to do is remember t in the hash table. */
2976 /* Compute the value of 'sizeof (TYPE)' or '__alignof__ (TYPE)', where the
2977 second parameter indicates which OPERATOR is being applied. The COMPLAIN
2978 flag controls whether we should diagnose possibly ill-formed
2979 constructs or not. */
2982 c_sizeof_or_alignof_type (tree type, bool is_sizeof, int complain)
2984 const char *op_name;
2986 enum tree_code type_code = TREE_CODE (type);
2988 op_name = is_sizeof ? "sizeof" : "__alignof__";
2990 if (type_code == FUNCTION_TYPE)
2994 if (complain && (pedantic || warn_pointer_arith))
2995 pedwarn ("invalid application of %<sizeof%> to a function type");
2996 value = size_one_node;
2999 value = size_int (FUNCTION_BOUNDARY / BITS_PER_UNIT);
3001 else if (type_code == VOID_TYPE || type_code == ERROR_MARK)
3003 if (type_code == VOID_TYPE
3004 && complain && (pedantic || warn_pointer_arith))
3005 pedwarn ("invalid application of %qs to a void type", op_name);
3006 value = size_one_node;
3008 else if (!COMPLETE_TYPE_P (type))
3011 error ("invalid application of %qs to incomplete type %qT ",
3013 value = size_zero_node;
3018 /* Convert in case a char is more than one unit. */
3019 value = size_binop (CEIL_DIV_EXPR, TYPE_SIZE_UNIT (type),
3020 size_int (TYPE_PRECISION (char_type_node)
3023 value = size_int (TYPE_ALIGN_UNIT (type));
3026 /* VALUE will have an integer type with TYPE_IS_SIZETYPE set.
3027 TYPE_IS_SIZETYPE means that certain things (like overflow) will
3028 never happen. However, this node should really have type
3029 `size_t', which is just a typedef for an ordinary integer type. */
3030 value = fold_convert (size_type_node, value);
3031 gcc_assert (!TYPE_IS_SIZETYPE (TREE_TYPE (value)));
3036 /* Implement the __alignof keyword: Return the minimum required
3037 alignment of EXPR, measured in bytes. For VAR_DECLs,
3038 FUNCTION_DECLs and FIELD_DECLs return DECL_ALIGN (which can be set
3039 from an "aligned" __attribute__ specification). */
3042 c_alignof_expr (tree expr)
3046 if (VAR_OR_FUNCTION_DECL_P (expr))
3047 t = size_int (DECL_ALIGN_UNIT (expr));
3049 else if (TREE_CODE (expr) == COMPONENT_REF
3050 && DECL_C_BIT_FIELD (TREE_OPERAND (expr, 1)))
3052 error ("%<__alignof%> applied to a bit-field");
3055 else if (TREE_CODE (expr) == COMPONENT_REF
3056 && TREE_CODE (TREE_OPERAND (expr, 1)) == FIELD_DECL)
3057 t = size_int (DECL_ALIGN_UNIT (TREE_OPERAND (expr, 1)));
3059 else if (TREE_CODE (expr) == INDIRECT_REF)
3061 tree t = TREE_OPERAND (expr, 0);
3063 int bestalign = TYPE_ALIGN (TREE_TYPE (TREE_TYPE (t)));
3065 while ((TREE_CODE (t) == NOP_EXPR || TREE_CODE (t) == CONVERT_EXPR)
3066 && TREE_CODE (TREE_TYPE (TREE_OPERAND (t, 0))) == POINTER_TYPE)
3070 t = TREE_OPERAND (t, 0);
3071 thisalign = TYPE_ALIGN (TREE_TYPE (TREE_TYPE (t)));
3072 if (thisalign > bestalign)
3073 best = t, bestalign = thisalign;
3075 return c_alignof (TREE_TYPE (TREE_TYPE (best)));
3078 return c_alignof (TREE_TYPE (expr));
3080 return fold_convert (size_type_node, t);
3083 /* Handle C and C++ default attributes. */
3085 enum built_in_attribute
3087 #define DEF_ATTR_NULL_TREE(ENUM) ENUM,
3088 #define DEF_ATTR_INT(ENUM, VALUE) ENUM,
3089 #define DEF_ATTR_IDENT(ENUM, STRING) ENUM,
3090 #define DEF_ATTR_TREE_LIST(ENUM, PURPOSE, VALUE, CHAIN) ENUM,
3091 #include "builtin-attrs.def"
3092 #undef DEF_ATTR_NULL_TREE
3094 #undef DEF_ATTR_IDENT
3095 #undef DEF_ATTR_TREE_LIST
3099 static GTY(()) tree built_in_attributes[(int) ATTR_LAST];
3101 static void c_init_attributes (void);
3105 #define DEF_PRIMITIVE_TYPE(NAME, VALUE) NAME,
3106 #define DEF_FUNCTION_TYPE_0(NAME, RETURN) NAME,
3107 #define DEF_FUNCTION_TYPE_1(NAME, RETURN, ARG1) NAME,
3108 #define DEF_FUNCTION_TYPE_2(NAME, RETURN, ARG1, ARG2) NAME,
3109 #define DEF_FUNCTION_TYPE_3(NAME, RETURN, ARG1, ARG2, ARG3) NAME,
3110 #define DEF_FUNCTION_TYPE_4(NAME, RETURN, ARG1, ARG2, ARG3, ARG4) NAME,
3111 #define DEF_FUNCTION_TYPE_5(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5) NAME,
3112 #define DEF_FUNCTION_TYPE_6(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6) NAME,
3113 #define DEF_FUNCTION_TYPE_7(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6, ARG7) NAME,
3114 #define DEF_FUNCTION_TYPE_VAR_0(NAME, RETURN) NAME,
3115 #define DEF_FUNCTION_TYPE_VAR_1(NAME, RETURN, ARG1) NAME,
3116 #define DEF_FUNCTION_TYPE_VAR_2(NAME, RETURN, ARG1, ARG2) NAME,
3117 #define DEF_FUNCTION_TYPE_VAR_3(NAME, RETURN, ARG1, ARG2, ARG3) NAME,
3118 #define DEF_FUNCTION_TYPE_VAR_4(NAME, RETURN, ARG1, ARG2, ARG3, ARG4) NAME,
3119 #define DEF_FUNCTION_TYPE_VAR_5(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG6) \
3121 #define DEF_POINTER_TYPE(NAME, TYPE) NAME,
3122 #include "builtin-types.def"
3123 #undef DEF_PRIMITIVE_TYPE
3124 #undef DEF_FUNCTION_TYPE_0
3125 #undef DEF_FUNCTION_TYPE_1
3126 #undef DEF_FUNCTION_TYPE_2
3127 #undef DEF_FUNCTION_TYPE_3
3128 #undef DEF_FUNCTION_TYPE_4
3129 #undef DEF_FUNCTION_TYPE_5
3130 #undef DEF_FUNCTION_TYPE_6
3131 #undef DEF_FUNCTION_TYPE_7
3132 #undef DEF_FUNCTION_TYPE_VAR_0
3133 #undef DEF_FUNCTION_TYPE_VAR_1
3134 #undef DEF_FUNCTION_TYPE_VAR_2
3135 #undef DEF_FUNCTION_TYPE_VAR_3
3136 #undef DEF_FUNCTION_TYPE_VAR_4
3137 #undef DEF_FUNCTION_TYPE_VAR_5
3138 #undef DEF_POINTER_TYPE
3142 typedef enum c_builtin_type builtin_type;
3144 /* A temporary array for c_common_nodes_and_builtins. Used in
3145 communication with def_fn_type. */
3146 static tree builtin_types[(int) BT_LAST + 1];
3148 /* A helper function for c_common_nodes_and_builtins. Build function type
3149 for DEF with return type RET and N arguments. If VAR is true, then the
3150 function should be variadic after those N arguments.
3152 Takes special care not to ICE if any of the types involved are
3153 error_mark_node, which indicates that said type is not in fact available
3154 (see builtin_type_for_size). In which case the function type as a whole
3155 should be error_mark_node. */
3158 def_fn_type (builtin_type def, builtin_type ret, bool var, int n, ...)
3160 tree args = NULL, t;
3165 for (i = 0; i < n; ++i)
3167 builtin_type a = va_arg (list, builtin_type);
3168 t = builtin_types[a];
3169 if (t == error_mark_node)
3171 args = tree_cons (NULL_TREE, t, args);
3175 args = nreverse (args);
3177 args = chainon (args, void_list_node);
3179 t = builtin_types[ret];
3180 if (t == error_mark_node)
3182 t = build_function_type (t, args);
3185 builtin_types[def] = t;
3188 /* Build builtin functions common to both C and C++ language
3192 c_define_builtins (tree va_list_ref_type_node, tree va_list_arg_type_node)
3194 #define DEF_PRIMITIVE_TYPE(ENUM, VALUE) \
3195 builtin_types[ENUM] = VALUE;
3196 #define DEF_FUNCTION_TYPE_0(ENUM, RETURN) \
3197 def_fn_type (ENUM, RETURN, 0, 0);
3198 #define DEF_FUNCTION_TYPE_1(ENUM, RETURN, ARG1) \
3199 def_fn_type (ENUM, RETURN, 0, 1, ARG1);
3200 #define DEF_FUNCTION_TYPE_2(ENUM, RETURN, ARG1, ARG2) \
3201 def_fn_type (ENUM, RETURN, 0, 2, ARG1, ARG2);
3202 #define DEF_FUNCTION_TYPE_3(ENUM, RETURN, ARG1, ARG2, ARG3) \
3203 def_fn_type (ENUM, RETURN, 0, 3, ARG1, ARG2, ARG3);
3204 #define DEF_FUNCTION_TYPE_4(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4) \
3205 def_fn_type (ENUM, RETURN, 0, 4, ARG1, ARG2, ARG3, ARG4);
3206 #define DEF_FUNCTION_TYPE_5(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5) \
3207 def_fn_type (ENUM, RETURN, 0, 5, ARG1, ARG2, ARG3, ARG4, ARG5);
3208 #define DEF_FUNCTION_TYPE_6(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
3210 def_fn_type (ENUM, RETURN, 0, 6, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6);
3211 #define DEF_FUNCTION_TYPE_7(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
3213 def_fn_type (ENUM, RETURN, 0, 7, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6, ARG7);
3214 #define DEF_FUNCTION_TYPE_VAR_0(ENUM, RETURN) \
3215 def_fn_type (ENUM, RETURN, 1, 0);
3216 #define DEF_FUNCTION_TYPE_VAR_1(ENUM, RETURN, ARG1) \
3217 def_fn_type (ENUM, RETURN, 1, 1, ARG1);
3218 #define DEF_FUNCTION_TYPE_VAR_2(ENUM, RETURN, ARG1, ARG2) \
3219 def_fn_type (ENUM, RETURN, 1, 2, ARG1, ARG2);
3220 #define DEF_FUNCTION_TYPE_VAR_3(ENUM, RETURN, ARG1, ARG2, ARG3) \
3221 def_fn_type (ENUM, RETURN, 1, 3, ARG1, ARG2, ARG3);
3222 #define DEF_FUNCTION_TYPE_VAR_4(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4) \
3223 def_fn_type (ENUM, RETURN, 1, 4, ARG1, ARG2, ARG3, ARG4);
3224 #define DEF_FUNCTION_TYPE_VAR_5(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5) \
3225 def_fn_type (ENUM, RETURN, 1, 5, ARG1, ARG2, ARG3, ARG4, ARG5);
3226 #define DEF_POINTER_TYPE(ENUM, TYPE) \
3227 builtin_types[(int) ENUM] = build_pointer_type (builtin_types[(int) TYPE]);
3229 #include "builtin-types.def"
3231 #undef DEF_PRIMITIVE_TYPE
3232 #undef DEF_FUNCTION_TYPE_1
3233 #undef DEF_FUNCTION_TYPE_2
3234 #undef DEF_FUNCTION_TYPE_3
3235 #undef DEF_FUNCTION_TYPE_4
3236 #undef DEF_FUNCTION_TYPE_5
3237 #undef DEF_FUNCTION_TYPE_6
3238 #undef DEF_FUNCTION_TYPE_VAR_0
3239 #undef DEF_FUNCTION_TYPE_VAR_1
3240 #undef DEF_FUNCTION_TYPE_VAR_2
3241 #undef DEF_FUNCTION_TYPE_VAR_3
3242 #undef DEF_FUNCTION_TYPE_VAR_4
3243 #undef DEF_FUNCTION_TYPE_VAR_5
3244 #undef DEF_POINTER_TYPE
3245 builtin_types[(int) BT_LAST] = NULL_TREE;
3247 c_init_attributes ();
3249 #define DEF_BUILTIN(ENUM, NAME, CLASS, TYPE, LIBTYPE, BOTH_P, FALLBACK_P, \
3250 NONANSI_P, ATTRS, IMPLICIT, COND) \
3252 def_builtin_1 (ENUM, NAME, CLASS, \
3253 builtin_types[(int) TYPE], \
3254 builtin_types[(int) LIBTYPE], \
3255 BOTH_P, FALLBACK_P, NONANSI_P, \
3256 built_in_attributes[(int) ATTRS], IMPLICIT);
3257 #include "builtins.def"
3260 build_common_builtin_nodes ();
3262 targetm.init_builtins ();
3267 /* Build tree nodes and builtin functions common to both C and C++ language
3271 c_common_nodes_and_builtins (void)
3273 int wchar_type_size;
3274 tree array_domain_type;
3275 tree va_list_ref_type_node;
3276 tree va_list_arg_type_node;
3278 /* Define `int' and `char' first so that dbx will output them first. */
3279 record_builtin_type (RID_INT, NULL, integer_type_node);
3280 record_builtin_type (RID_CHAR, "char", char_type_node);
3282 /* `signed' is the same as `int'. FIXME: the declarations of "signed",
3283 "unsigned long", "long long unsigned" and "unsigned short" were in C++
3284 but not C. Are the conditionals here needed? */
3285 if (c_dialect_cxx ())
3286 record_builtin_type (RID_SIGNED, NULL, integer_type_node);
3287 record_builtin_type (RID_LONG, "long int", long_integer_type_node);
3288 record_builtin_type (RID_UNSIGNED, "unsigned int", unsigned_type_node);
3289 record_builtin_type (RID_MAX, "long unsigned int",
3290 long_unsigned_type_node);
3291 if (c_dialect_cxx ())
3292 record_builtin_type (RID_MAX, "unsigned long", long_unsigned_type_node);
3293 record_builtin_type (RID_MAX, "long long int",
3294 long_long_integer_type_node);
3295 record_builtin_type (RID_MAX, "long long unsigned int",
3296 long_long_unsigned_type_node);
3297 if (c_dialect_cxx ())
3298 record_builtin_type (RID_MAX, "long long unsigned",
3299 long_long_unsigned_type_node);
3300 record_builtin_type (RID_SHORT, "short int", short_integer_type_node);
3301 record_builtin_type (RID_MAX, "short unsigned int",
3302 short_unsigned_type_node);
3303 if (c_dialect_cxx ())
3304 record_builtin_type (RID_MAX, "unsigned short",
3305 short_unsigned_type_node);
3307 /* Define both `signed char' and `unsigned char'. */
3308 record_builtin_type (RID_MAX, "signed char", signed_char_type_node);
3309 record_builtin_type (RID_MAX, "unsigned char", unsigned_char_type_node);
3311 /* These are types that c_common_type_for_size and
3312 c_common_type_for_mode use. */
3313 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
3315 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
3317 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
3319 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
3321 #if HOST_BITS_PER_WIDE_INT >= 64
3322 if (targetm.scalar_mode_supported_p (TImode))
3323 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL,
3324 get_identifier ("__int128_t"),
3327 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
3328 unsigned_intQI_type_node));
3329 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
3330 unsigned_intHI_type_node));
3331 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
3332 unsigned_intSI_type_node));
3333 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
3334 unsigned_intDI_type_node));
3335 #if HOST_BITS_PER_WIDE_INT >= 64
3336 if (targetm.scalar_mode_supported_p (TImode))
3337 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL,
3338 get_identifier ("__uint128_t"),
3339 unsigned_intTI_type_node));
3342 /* Create the widest literal types. */
3343 widest_integer_literal_type_node
3344 = make_signed_type (HOST_BITS_PER_WIDE_INT * 2);
3345 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
3346 widest_integer_literal_type_node));
3348 widest_unsigned_literal_type_node
3349 = make_unsigned_type (HOST_BITS_PER_WIDE_INT * 2);
3350 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
3351 widest_unsigned_literal_type_node));
3353 /* `unsigned long' is the standard type for sizeof.
3354 Note that stddef.h uses `unsigned long',
3355 and this must agree, even if long and int are the same size. */
3357 TREE_TYPE (identifier_global_value (get_identifier (SIZE_TYPE)));
3358 signed_size_type_node = c_common_signed_type (size_type_node);
3359 set_sizetype (size_type_node);
3362 TREE_TYPE (identifier_global_value (get_identifier (PID_TYPE)));
3364 build_common_tree_nodes_2 (flag_short_double);
3366 record_builtin_type (RID_FLOAT, NULL, float_type_node);
3367 record_builtin_type (RID_DOUBLE, NULL, double_type_node);
3368 record_builtin_type (RID_MAX, "long double", long_double_type_node);
3370 /* Only supported decimal floating point extension if the target
3371 actually supports underlying modes. */
3372 if (targetm.scalar_mode_supported_p (SDmode)
3373 && targetm.scalar_mode_supported_p (DDmode)
3374 && targetm.scalar_mode_supported_p (TDmode))
3376 record_builtin_type (RID_DFLOAT32, NULL, dfloat32_type_node);
3377 record_builtin_type (RID_DFLOAT64, NULL, dfloat64_type_node);
3378 record_builtin_type (RID_DFLOAT128, NULL, dfloat128_type_node);
3381 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL,
3382 get_identifier ("complex int"),
3383 complex_integer_type_node));
3384 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL,
3385 get_identifier ("complex float"),
3386 complex_float_type_node));
3387 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL,
3388 get_identifier ("complex double"),
3389 complex_double_type_node));
3390 lang_hooks.decls.pushdecl
3391 (build_decl (TYPE_DECL, get_identifier ("complex long double"),
3392 complex_long_double_type_node));
3394 if (c_dialect_cxx ())
3395 /* For C++, make fileptr_type_node a distinct void * type until
3396 FILE type is defined. */
3397 fileptr_type_node = build_variant_type_copy (ptr_type_node);
3399 record_builtin_type (RID_VOID, NULL, void_type_node);
3401 /* This node must not be shared. */
3402 void_zero_node = make_node (INTEGER_CST);
3403 TREE_TYPE (void_zero_node) = void_type_node;
3405 void_list_node = build_void_list_node ();
3407 /* Make a type to be the domain of a few array types
3408 whose domains don't really matter.
3409 200 is small enough that it always fits in size_t
3410 and large enough that it can hold most function names for the
3411 initializations of __FUNCTION__ and __PRETTY_FUNCTION__. */
3412 array_domain_type = build_index_type (size_int (200));
3414 /* Make a type for arrays of characters.
3415 With luck nothing will ever really depend on the length of this
3417 char_array_type_node
3418 = build_array_type (char_type_node, array_domain_type);
3420 /* Likewise for arrays of ints. */
3422 = build_array_type (integer_type_node, array_domain_type);
3424 string_type_node = build_pointer_type (char_type_node);
3425 const_string_type_node
3426 = build_pointer_type (build_qualified_type
3427 (char_type_node, TYPE_QUAL_CONST));
3429 /* This is special for C++ so functions can be overloaded. */
3430 wchar_type_node = get_identifier (MODIFIED_WCHAR_TYPE);
3431 wchar_type_node = TREE_TYPE (identifier_global_value (wchar_type_node));
3432 wchar_type_size = TYPE_PRECISION (wchar_type_node);
3433 if (c_dialect_cxx ())
3435 if (TYPE_UNSIGNED (wchar_type_node))
3436 wchar_type_node = make_unsigned_type (wchar_type_size);
3438 wchar_type_node = make_signed_type (wchar_type_size);
3439 record_builtin_type (RID_WCHAR, "wchar_t", wchar_type_node);
3443 signed_wchar_type_node = c_common_signed_type (wchar_type_node);
3444 unsigned_wchar_type_node = c_common_unsigned_type (wchar_type_node);
3447 /* This is for wide string constants. */
3448 wchar_array_type_node
3449 = build_array_type (wchar_type_node, array_domain_type);
3452 TREE_TYPE (identifier_global_value (get_identifier (WINT_TYPE)));
3455 TREE_TYPE (identifier_global_value (get_identifier (INTMAX_TYPE)));
3457 TREE_TYPE (identifier_global_value (get_identifier (UINTMAX_TYPE)));
3459 default_function_type = build_function_type (integer_type_node, NULL_TREE);
3461 = TREE_TYPE (identifier_global_value (get_identifier (PTRDIFF_TYPE)));
3462 unsigned_ptrdiff_type_node = c_common_unsigned_type (ptrdiff_type_node);
3464 lang_hooks.decls.pushdecl
3465 (build_decl (TYPE_DECL, get_identifier ("__builtin_va_list"),
3466 va_list_type_node));
3468 if (TREE_CODE (va_list_type_node) == ARRAY_TYPE)
3470 va_list_arg_type_node = va_list_ref_type_node =
3471 build_pointer_type (TREE_TYPE (va_list_type_node));
3475 va_list_arg_type_node = va_list_type_node;
3476 va_list_ref_type_node = build_reference_type (va_list_type_node);
3479 if (!flag_preprocess_only)
3480 c_define_builtins (va_list_ref_type_node, va_list_arg_type_node);
3482 main_identifier_node = get_identifier ("main");
3484 /* Create the built-in __null node. It is important that this is
3486 null_node = make_node (INTEGER_CST);
3487 TREE_TYPE (null_node) = c_common_type_for_size (POINTER_SIZE, 0);
3489 /* Since builtin_types isn't gc'ed, don't export these nodes. */
3490 memset (builtin_types, 0, sizeof (builtin_types));
3493 /* Look up the function in built_in_decls that corresponds to DECL
3494 and set ASMSPEC as its user assembler name. DECL must be a
3495 function decl that declares a builtin. */
3498 set_builtin_user_assembler_name (tree decl, const char *asmspec)
3501 gcc_assert (TREE_CODE (decl) == FUNCTION_DECL
3502 && DECL_BUILT_IN_CLASS (decl) == BUILT_IN_NORMAL
3505 builtin = built_in_decls [DECL_FUNCTION_CODE (decl)];
3506 set_user_assembler_name (builtin, asmspec);
3507 if (DECL_FUNCTION_CODE (decl) == BUILT_IN_MEMCPY)
3508 init_block_move_fn (asmspec);
3509 else if (DECL_FUNCTION_CODE (decl) == BUILT_IN_MEMSET)
3510 init_block_clear_fn (asmspec);
3513 /* The number of named compound-literals generated thus far. */
3514 static GTY(()) int compound_literal_number;
3516 /* Set DECL_NAME for DECL, a VAR_DECL for a compound-literal. */
3519 set_compound_literal_name (tree decl)
3522 ASM_FORMAT_PRIVATE_NAME (name, "__compound_literal",
3523 compound_literal_number);
3524 compound_literal_number++;
3525 DECL_NAME (decl) = get_identifier (name);
3529 build_va_arg (tree expr, tree type)
3531 return build1 (VA_ARG_EXPR, type, expr);
3535 /* Linked list of disabled built-in functions. */
3537 typedef struct disabled_builtin
3540 struct disabled_builtin *next;
3542 static disabled_builtin *disabled_builtins = NULL;
3544 static bool builtin_function_disabled_p (const char *);
3546 /* Disable a built-in function specified by -fno-builtin-NAME. If NAME
3547 begins with "__builtin_", give an error. */
3550 disable_builtin_function (const char *name)
3552 if (strncmp (name, "__builtin_", strlen ("__builtin_")) == 0)
3553 error ("cannot disable built-in function %qs", name);
3556 disabled_builtin *new_disabled_builtin = XNEW (disabled_builtin);
3557 new_disabled_builtin->name = name;
3558 new_disabled_builtin->next = disabled_builtins;
3559 disabled_builtins = new_disabled_builtin;
3564 /* Return true if the built-in function NAME has been disabled, false
3568 builtin_function_disabled_p (const char *name)
3570 disabled_builtin *p;
3571 for (p = disabled_builtins; p != NULL; p = p->next)
3573 if (strcmp (name, p->name) == 0)
3580 /* Worker for DEF_BUILTIN.
3581 Possibly define a builtin function with one or two names.
3582 Does not declare a non-__builtin_ function if flag_no_builtin, or if
3583 nonansi_p and flag_no_nonansi_builtin. */
3586 def_builtin_1 (enum built_in_function fncode,
3588 enum built_in_class fnclass,
3589 tree fntype, tree libtype,
3590 bool both_p, bool fallback_p, bool nonansi_p,
3591 tree fnattrs, bool implicit_p)
3594 const char *libname;
3596 if (fntype == error_mark_node)
3599 gcc_assert ((!both_p && !fallback_p)
3600 || !strncmp (name, "__builtin_",
3601 strlen ("__builtin_")));
3603 libname = name + strlen ("__builtin_");
3604 decl = lang_hooks.builtin_function (name, fntype, fncode, fnclass,
3605 (fallback_p ? libname : NULL),
3608 && !flag_no_builtin && !builtin_function_disabled_p (libname)
3609 && !(nonansi_p && flag_no_nonansi_builtin))
3610 lang_hooks.builtin_function (libname, libtype, fncode, fnclass,
3613 built_in_decls[(int) fncode] = decl;
3615 implicit_built_in_decls[(int) fncode] = decl;
3618 /* Nonzero if the type T promotes to int. This is (nearly) the
3619 integral promotions defined in ISO C99 6.3.1.1/2. */
3622 c_promoting_integer_type_p (tree t)
3624 switch (TREE_CODE (t))
3627 return (TYPE_MAIN_VARIANT (t) == char_type_node
3628 || TYPE_MAIN_VARIANT (t) == signed_char_type_node
3629 || TYPE_MAIN_VARIANT (t) == unsigned_char_type_node
3630 || TYPE_MAIN_VARIANT (t) == short_integer_type_node
3631 || TYPE_MAIN_VARIANT (t) == short_unsigned_type_node
3632 || TYPE_PRECISION (t) < TYPE_PRECISION (integer_type_node));
3635 /* ??? Technically all enumerations not larger than an int
3636 promote to an int. But this is used along code paths
3637 that only want to notice a size change. */
3638 return TYPE_PRECISION (t) < TYPE_PRECISION (integer_type_node);
3648 /* Return 1 if PARMS specifies a fixed number of parameters
3649 and none of their types is affected by default promotions. */
3652 self_promoting_args_p (tree parms)
3655 for (t = parms; t; t = TREE_CHAIN (t))
3657 tree type = TREE_VALUE (t);
3659 if (type == error_mark_node)
3662 if (TREE_CHAIN (t) == 0 && type != void_type_node)
3668 if (TYPE_MAIN_VARIANT (type) == float_type_node)
3671 if (c_promoting_integer_type_p (type))
3677 /* Recursively examines the array elements of TYPE, until a non-array
3678 element type is found. */
3681 strip_array_types (tree type)
3683 while (TREE_CODE (type) == ARRAY_TYPE)
3684 type = TREE_TYPE (type);
3689 /* Recursively remove any '*' or '&' operator from TYPE. */
3691 strip_pointer_operator (tree t)
3693 while (POINTER_TYPE_P (t))
3698 /* Used to compare case labels. K1 and K2 are actually tree nodes
3699 representing case labels, or NULL_TREE for a `default' label.
3700 Returns -1 if K1 is ordered before K2, -1 if K1 is ordered after
3701 K2, and 0 if K1 and K2 are equal. */
3704 case_compare (splay_tree_key k1, splay_tree_key k2)
3706 /* Consider a NULL key (such as arises with a `default' label) to be
3707 smaller than anything else. */
3713 return tree_int_cst_compare ((tree) k1, (tree) k2);
3716 /* Process a case label for the range LOW_VALUE ... HIGH_VALUE. If
3717 LOW_VALUE and HIGH_VALUE are both NULL_TREE then this case label is
3718 actually a `default' label. If only HIGH_VALUE is NULL_TREE, then
3719 case label was declared using the usual C/C++ syntax, rather than
3720 the GNU case range extension. CASES is a tree containing all the
3721 case ranges processed so far; COND is the condition for the
3722 switch-statement itself. Returns the CASE_LABEL_EXPR created, or
3723 ERROR_MARK_NODE if no CASE_LABEL_EXPR is created. */
3726 c_add_case_label (splay_tree cases, tree cond, tree orig_type,
3727 tree low_value, tree high_value)
3732 splay_tree_node node;
3734 /* Create the LABEL_DECL itself. */
3735 label = create_artificial_label ();
3737 /* If there was an error processing the switch condition, bail now
3738 before we get more confused. */
3739 if (!cond || cond == error_mark_node)
3742 if ((low_value && TREE_TYPE (low_value)
3743 && POINTER_TYPE_P (TREE_TYPE (low_value)))
3744 || (high_value && TREE_TYPE (high_value)
3745 && POINTER_TYPE_P (TREE_TYPE (high_value))))
3747 error ("pointers are not permitted as case values");
3751 /* Case ranges are a GNU extension. */
3752 if (high_value && pedantic)
3753 pedwarn ("range expressions in switch statements are non-standard");
3755 type = TREE_TYPE (cond);
3758 low_value = check_case_value (low_value);
3759 low_value = convert_and_check (type, low_value);
3760 if (low_value == error_mark_node)
3765 high_value = check_case_value (high_value);
3766 high_value = convert_and_check (type, high_value);
3767 if (high_value == error_mark_node)
3771 if (low_value && high_value)
3773 /* If the LOW_VALUE and HIGH_VALUE are the same, then this isn't
3774 really a case range, even though it was written that way.
3775 Remove the HIGH_VALUE to simplify later processing. */
3776 if (tree_int_cst_equal (low_value, high_value))
3777 high_value = NULL_TREE;
3778 else if (!tree_int_cst_lt (low_value, high_value))
3779 warning (0, "empty range specified");
3782 /* See if the case is in range of the type of the original testing
3783 expression. If both low_value and high_value are out of range,
3784 don't insert the case label and return NULL_TREE. */
3786 && !check_case_bounds (type, orig_type,
3787 &low_value, high_value ? &high_value : NULL))
3790 /* Look up the LOW_VALUE in the table of case labels we already
3792 node = splay_tree_lookup (cases, (splay_tree_key) low_value);
3793 /* If there was not an exact match, check for overlapping ranges.
3794 There's no need to do this if there's no LOW_VALUE or HIGH_VALUE;
3795 that's a `default' label and the only overlap is an exact match. */
3796 if (!node && (low_value || high_value))
3798 splay_tree_node low_bound;
3799 splay_tree_node high_bound;
3801 /* Even though there wasn't an exact match, there might be an
3802 overlap between this case range and another case range.
3803 Since we've (inductively) not allowed any overlapping case
3804 ranges, we simply need to find the greatest low case label
3805 that is smaller that LOW_VALUE, and the smallest low case
3806 label that is greater than LOW_VALUE. If there is an overlap
3807 it will occur in one of these two ranges. */
3808 low_bound = splay_tree_predecessor (cases,
3809 (splay_tree_key) low_value);
3810 high_bound = splay_tree_successor (cases,
3811 (splay_tree_key) low_value);
3813 /* Check to see if the LOW_BOUND overlaps. It is smaller than
3814 the LOW_VALUE, so there is no need to check unless the
3815 LOW_BOUND is in fact itself a case range. */
3817 && CASE_HIGH ((tree) low_bound->value)
3818 && tree_int_cst_compare (CASE_HIGH ((tree) low_bound->value),
3821 /* Check to see if the HIGH_BOUND overlaps. The low end of that
3822 range is bigger than the low end of the current range, so we
3823 are only interested if the current range is a real range, and
3824 not an ordinary case label. */
3827 && (tree_int_cst_compare ((tree) high_bound->key,
3832 /* If there was an overlap, issue an error. */
3835 tree duplicate = CASE_LABEL ((tree) node->value);
3839 error ("duplicate (or overlapping) case value");
3840 error ("%Jthis is the first entry overlapping that value", duplicate);
3844 error ("duplicate case value") ;
3845 error ("%Jpreviously used here", duplicate);
3849 error ("multiple default labels in one switch");
3850 error ("%Jthis is the first default label", duplicate);
3855 /* Add a CASE_LABEL to the statement-tree. */
3856 case_label = add_stmt (build_case_label (low_value, high_value, label));
3857 /* Register this case label in the splay tree. */
3858 splay_tree_insert (cases,
3859 (splay_tree_key) low_value,
3860 (splay_tree_value) case_label);
3865 /* Add a label so that the back-end doesn't think that the beginning of
3866 the switch is unreachable. Note that we do not add a case label, as
3867 that just leads to duplicates and thence to failure later on. */
3870 tree t = create_artificial_label ();
3871 add_stmt (build_stmt (LABEL_EXPR, t));
3873 return error_mark_node;
3876 /* Subroutines of c_do_switch_warnings, called via splay_tree_foreach.
3877 Used to verify that case values match up with enumerator values. */
3880 match_case_to_enum_1 (tree key, tree type, tree label)
3882 char buf[2 + 2*HOST_BITS_PER_WIDE_INT/4 + 1];
3884 /* ??? Not working too hard to print the double-word value.
3885 Should perhaps be done with %lwd in the diagnostic routines? */
3886 if (TREE_INT_CST_HIGH (key) == 0)
3887 snprintf (buf, sizeof (buf), HOST_WIDE_INT_PRINT_UNSIGNED,
3888 TREE_INT_CST_LOW (key));
3889 else if (!TYPE_UNSIGNED (type)
3890 && TREE_INT_CST_HIGH (key) == -1
3891 && TREE_INT_CST_LOW (key) != 0)
3892 snprintf (buf, sizeof (buf), "-" HOST_WIDE_INT_PRINT_UNSIGNED,
3893 -TREE_INT_CST_LOW (key));
3895 snprintf (buf, sizeof (buf), HOST_WIDE_INT_PRINT_DOUBLE_HEX,
3896 TREE_INT_CST_HIGH (key), TREE_INT_CST_LOW (key));
3898 if (TYPE_NAME (type) == 0)
3899 warning (0, "%Jcase value %qs not in enumerated type",
3900 CASE_LABEL (label), buf);
3902 warning (0, "%Jcase value %qs not in enumerated type %qT",
3903 CASE_LABEL (label), buf, type);
3906 /* Subroutine of c_do_switch_warnings, called via splay_tree_foreach.
3907 Used to verify that case values match up with enumerator values. */
3910 match_case_to_enum (splay_tree_node node, void *data)
3912 tree label = (tree) node->value;
3913 tree type = (tree) data;
3915 /* Skip default case. */
3916 if (!CASE_LOW (label))
3919 /* If CASE_LOW_SEEN is not set, that means CASE_LOW did not appear
3920 when we did our enum->case scan. Reset our scratch bit after. */
3921 if (!CASE_LOW_SEEN (label))
3922 match_case_to_enum_1 (CASE_LOW (label), type, label);
3924 CASE_LOW_SEEN (label) = 0;
3926 /* If CASE_HIGH is non-null, we have a range. If CASE_HIGH_SEEN is
3927 not set, that means that CASE_HIGH did not appear when we did our
3928 enum->case scan. Reset our scratch bit after. */
3929 if (CASE_HIGH (label))
3931 if (!CASE_HIGH_SEEN (label))
3932 match_case_to_enum_1 (CASE_HIGH (label), type, label);
3934 CASE_HIGH_SEEN (label) = 0;
3940 /* Handle -Wswitch*. Called from the front end after parsing the
3941 switch construct. */
3942 /* ??? Should probably be somewhere generic, since other languages
3943 besides C and C++ would want this. At the moment, however, C/C++
3944 are the only tree-ssa languages that support enumerations at all,
3945 so the point is moot. */
3948 c_do_switch_warnings (splay_tree cases, location_t switch_location,
3949 tree type, tree cond)
3951 splay_tree_node default_node;
3952 splay_tree_node node;
3955 if (!warn_switch && !warn_switch_enum && !warn_switch_default)
3958 default_node = splay_tree_lookup (cases, (splay_tree_key) NULL);
3960 warning (OPT_Wswitch_default, "%Hswitch missing default case",
3963 /* From here on, we only care about about enumerated types. */
3964 if (!type || TREE_CODE (type) != ENUMERAL_TYPE)
3967 /* If the switch expression was an enumerated type, check that
3968 exactly all enumeration literals are covered by the cases.
3969 The check is made when -Wswitch was specified and there is no
3970 default case, or when -Wswitch-enum was specified. */
3972 if (!warn_switch_enum
3973 && !(warn_switch && !default_node))
3976 /* Clearing COND if it is not an integer constant simplifies
3977 the tests inside the loop below. */
3978 if (TREE_CODE (cond) != INTEGER_CST)
3981 /* The time complexity here is O(N*lg(N)) worst case, but for the
3982 common case of monotonically increasing enumerators, it is
3983 O(N), since the nature of the splay tree will keep the next
3984 element adjacent to the root at all times. */
3986 for (chain = TYPE_VALUES (type); chain; chain = TREE_CHAIN (chain))
3988 tree value = TREE_VALUE (chain);
3989 node = splay_tree_lookup (cases, (splay_tree_key) value);
3992 /* Mark the CASE_LOW part of the case entry as seen. */
3993 tree label = (tree) node->value;
3994 CASE_LOW_SEEN (label) = 1;
3998 /* Even though there wasn't an exact match, there might be a
3999 case range which includes the enumator's value. */
4000 node = splay_tree_predecessor (cases, (splay_tree_key) value);
4001 if (node && CASE_HIGH ((tree) node->value))
4003 tree label = (tree) node->value;
4004 int cmp = tree_int_cst_compare (CASE_HIGH (label), value);
4007 /* If we match the upper bound exactly, mark the CASE_HIGH
4008 part of the case entry as seen. */
4010 CASE_HIGH_SEEN (label) = 1;
4015 /* We've now determined that this enumerated literal isn't
4016 handled by the case labels of the switch statement. */
4018 /* If the switch expression is a constant, we only really care
4019 about whether that constant is handled by the switch. */
4020 if (cond && tree_int_cst_compare (cond, value))
4023 warning (0, "%Henumeration value %qE not handled in switch",
4024 &switch_location, TREE_PURPOSE (chain));
4027 /* Warn if there are case expressions that don't correspond to
4028 enumerators. This can occur since C and C++ don't enforce
4029 type-checking of assignments to enumeration variables.
4031 The time complexity here is now always O(N) worst case, since
4032 we should have marked both the lower bound and upper bound of
4033 every disjoint case label, with CASE_LOW_SEEN and CASE_HIGH_SEEN
4034 above. This scan also resets those fields. */
4035 splay_tree_foreach (cases, match_case_to_enum, type);
4038 /* Finish an expression taking the address of LABEL (an
4039 IDENTIFIER_NODE). Returns an expression for the address. */
4042 finish_label_address_expr (tree label)
4047 pedwarn ("taking the address of a label is non-standard");
4049 if (label == error_mark_node)
4050 return error_mark_node;
4052 label = lookup_label (label);
4053 if (label == NULL_TREE)
4054 result = null_pointer_node;
4057 TREE_USED (label) = 1;
4058 result = build1 (ADDR_EXPR, ptr_type_node, label);
4059 /* The current function in not necessarily uninlinable.
4060 Computed gotos are incompatible with inlining, but the value
4061 here could be used only in a diagnostic, for example. */
4067 /* Hook used by expand_expr to expand language-specific tree codes. */
4068 /* The only things that should go here are bits needed to expand
4069 constant initializers. Everything else should be handled by the
4070 gimplification routines. */
4073 c_expand_expr (tree exp, rtx target, enum machine_mode tmode,
4074 int modifier /* Actually enum_modifier. */,
4077 switch (TREE_CODE (exp))
4079 case COMPOUND_LITERAL_EXPR:
4081 /* Initialize the anonymous variable declared in the compound
4082 literal, then return the variable. */
4083 tree decl = COMPOUND_LITERAL_EXPR_DECL (exp);
4084 emit_local_var (decl);
4085 return expand_expr_real (decl, target, tmode, modifier, alt_rtl);
4093 /* Hook used by staticp to handle language-specific tree codes. */
4096 c_staticp (tree exp)
4098 return (TREE_CODE (exp) == COMPOUND_LITERAL_EXPR
4099 && TREE_STATIC (COMPOUND_LITERAL_EXPR_DECL (exp))
4104 /* Given a boolean expression ARG, return a tree representing an increment
4105 or decrement (as indicated by CODE) of ARG. The front end must check for
4106 invalid cases (e.g., decrement in C++). */
4108 boolean_increment (enum tree_code code, tree arg)
4111 tree true_res = boolean_true_node;
4113 arg = stabilize_reference (arg);
4116 case PREINCREMENT_EXPR:
4117 val = build2 (MODIFY_EXPR, TREE_TYPE (arg), arg, true_res);
4119 case POSTINCREMENT_EXPR:
4120 val = build2 (MODIFY_EXPR, TREE_TYPE (arg), arg, true_res);
4121 arg = save_expr (arg);
4122 val = build2 (COMPOUND_EXPR, TREE_TYPE (arg), val, arg);
4123 val = build2 (COMPOUND_EXPR, TREE_TYPE (arg), arg, val);
4125 case PREDECREMENT_EXPR:
4126 val = build2 (MODIFY_EXPR, TREE_TYPE (arg), arg,
4127 invert_truthvalue (arg));
4129 case POSTDECREMENT_EXPR:
4130 val = build2 (MODIFY_EXPR, TREE_TYPE (arg), arg,
4131 invert_truthvalue (arg));
4132 arg = save_expr (arg);
4133 val = build2 (COMPOUND_EXPR, TREE_TYPE (arg), val, arg);
4134 val = build2 (COMPOUND_EXPR, TREE_TYPE (arg), arg, val);
4139 TREE_SIDE_EFFECTS (val) = 1;
4143 /* Built-in macros for stddef.h, that require macros defined in this
4146 c_stddef_cpp_builtins(void)
4148 builtin_define_with_value ("__SIZE_TYPE__", SIZE_TYPE, 0);
4149 builtin_define_with_value ("__PTRDIFF_TYPE__", PTRDIFF_TYPE, 0);
4150 builtin_define_with_value ("__WCHAR_TYPE__", MODIFIED_WCHAR_TYPE, 0);
4151 builtin_define_with_value ("__WINT_TYPE__", WINT_TYPE, 0);
4152 builtin_define_with_value ("__INTMAX_TYPE__", INTMAX_TYPE, 0);
4153 builtin_define_with_value ("__UINTMAX_TYPE__", UINTMAX_TYPE, 0);
4157 c_init_attributes (void)
4159 /* Fill in the built_in_attributes array. */
4160 #define DEF_ATTR_NULL_TREE(ENUM) \
4161 built_in_attributes[(int) ENUM] = NULL_TREE;
4162 #define DEF_ATTR_INT(ENUM, VALUE) \
4163 built_in_attributes[(int) ENUM] = build_int_cst (NULL_TREE, VALUE);
4164 #define DEF_ATTR_IDENT(ENUM, STRING) \
4165 built_in_attributes[(int) ENUM] = get_identifier (STRING);
4166 #define DEF_ATTR_TREE_LIST(ENUM, PURPOSE, VALUE, CHAIN) \
4167 built_in_attributes[(int) ENUM] \
4168 = tree_cons (built_in_attributes[(int) PURPOSE], \
4169 built_in_attributes[(int) VALUE], \
4170 built_in_attributes[(int) CHAIN]);
4171 #include "builtin-attrs.def"
4172 #undef DEF_ATTR_NULL_TREE
4174 #undef DEF_ATTR_IDENT
4175 #undef DEF_ATTR_TREE_LIST
4178 /* Attribute handlers common to C front ends. */
4180 /* Handle a "packed" attribute; arguments as in
4181 struct attribute_spec.handler. */
4184 handle_packed_attribute (tree *node, tree name, tree ARG_UNUSED (args),
4185 int flags, bool *no_add_attrs)
4189 if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
4190 *node = build_variant_type_copy (*node);
4191 TYPE_PACKED (*node) = 1;
4193 else if (TREE_CODE (*node) == FIELD_DECL)
4195 if (TYPE_ALIGN (TREE_TYPE (*node)) <= BITS_PER_UNIT)
4196 warning (OPT_Wattributes,
4197 "%qE attribute ignored for field of type %qT",
4198 name, TREE_TYPE (*node));
4200 DECL_PACKED (*node) = 1;
4202 /* We can't set DECL_PACKED for a VAR_DECL, because the bit is
4203 used for DECL_REGISTER. It wouldn't mean anything anyway.
4204 We can't set DECL_PACKED on the type of a TYPE_DECL, because
4205 that changes what the typedef is typing. */
4208 warning (OPT_Wattributes, "%qE attribute ignored", name);
4209 *no_add_attrs = true;
4215 /* Handle a "nocommon" attribute; arguments as in
4216 struct attribute_spec.handler. */
4219 handle_nocommon_attribute (tree *node, tree name,
4220 tree ARG_UNUSED (args),
4221 int ARG_UNUSED (flags), bool *no_add_attrs)
4223 if (TREE_CODE (*node) == VAR_DECL)
4224 DECL_COMMON (*node) = 0;
4227 warning (OPT_Wattributes, "%qE attribute ignored", name);
4228 *no_add_attrs = true;
4234 /* Handle a "common" attribute; arguments as in
4235 struct attribute_spec.handler. */
4238 handle_common_attribute (tree *node, tree name, tree ARG_UNUSED (args),
4239 int ARG_UNUSED (flags), bool *no_add_attrs)
4241 if (TREE_CODE (*node) == VAR_DECL)
4242 DECL_COMMON (*node) = 1;
4245 warning (OPT_Wattributes, "%qE attribute ignored", name);
4246 *no_add_attrs = true;
4252 /* Handle a "noreturn" attribute; arguments as in
4253 struct attribute_spec.handler. */
4256 handle_noreturn_attribute (tree *node, tree name, tree ARG_UNUSED (args),
4257 int ARG_UNUSED (flags), bool *no_add_attrs)
4259 tree type = TREE_TYPE (*node);
4261 /* See FIXME comment in c_common_attribute_table. */
4262 if (TREE_CODE (*node) == FUNCTION_DECL)
4263 TREE_THIS_VOLATILE (*node) = 1;
4264 else if (TREE_CODE (type) == POINTER_TYPE
4265 && TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE)
4267 = build_pointer_type
4268 (build_type_variant (TREE_TYPE (type),
4269 TYPE_READONLY (TREE_TYPE (type)), 1));
4272 warning (OPT_Wattributes, "%qE attribute ignored", name);
4273 *no_add_attrs = true;
4279 /* Handle a "noinline" attribute; arguments as in
4280 struct attribute_spec.handler. */
4283 handle_noinline_attribute (tree *node, tree name,
4284 tree ARG_UNUSED (args),
4285 int ARG_UNUSED (flags), bool *no_add_attrs)
4287 if (TREE_CODE (*node) == FUNCTION_DECL)
4288 DECL_UNINLINABLE (*node) = 1;
4291 warning (OPT_Wattributes, "%qE attribute ignored", name);
4292 *no_add_attrs = true;
4298 /* Handle a "always_inline" attribute; arguments as in
4299 struct attribute_spec.handler. */
4302 handle_always_inline_attribute (tree *node, tree name,
4303 tree ARG_UNUSED (args),
4304 int ARG_UNUSED (flags),
4307 if (TREE_CODE (*node) == FUNCTION_DECL)
4309 /* Do nothing else, just set the attribute. We'll get at
4310 it later with lookup_attribute. */
4314 warning (OPT_Wattributes, "%qE attribute ignored", name);
4315 *no_add_attrs = true;
4321 /* Handle a "gnu_inline" attribute; arguments as in
4322 struct attribute_spec.handler. */
4325 handle_gnu_inline_attribute (tree *node, tree name,
4326 tree ARG_UNUSED (args),
4327 int ARG_UNUSED (flags),
4330 if (TREE_CODE (*node) == FUNCTION_DECL && DECL_DECLARED_INLINE_P (*node))
4332 /* Do nothing else, just set the attribute. We'll get at
4333 it later with lookup_attribute. */
4337 warning (OPT_Wattributes, "%qE attribute ignored", name);
4338 *no_add_attrs = true;
4344 /* Handle a "flatten" attribute; arguments as in
4345 struct attribute_spec.handler. */
4348 handle_flatten_attribute (tree *node, tree name,
4349 tree args ATTRIBUTE_UNUSED,
4350 int flags ATTRIBUTE_UNUSED, bool *no_add_attrs)
4352 if (TREE_CODE (*node) == FUNCTION_DECL)
4353 /* Do nothing else, just set the attribute. We'll get at
4354 it later with lookup_attribute. */
4358 warning (OPT_Wattributes, "%qE attribute ignored", name);
4359 *no_add_attrs = true;
4366 /* Handle a "used" attribute; arguments as in
4367 struct attribute_spec.handler. */
4370 handle_used_attribute (tree *pnode, tree name, tree ARG_UNUSED (args),
4371 int ARG_UNUSED (flags), bool *no_add_attrs)
4375 if (TREE_CODE (node) == FUNCTION_DECL
4376 || (TREE_CODE (node) == VAR_DECL && TREE_STATIC (node)))
4378 TREE_USED (node) = 1;
4379 DECL_PRESERVE_P (node) = 1;
4383 warning (OPT_Wattributes, "%qE attribute ignored", name);
4384 *no_add_attrs = true;
4390 /* Handle a "unused" attribute; arguments as in
4391 struct attribute_spec.handler. */
4394 handle_unused_attribute (tree *node, tree name, tree ARG_UNUSED (args),
4395 int flags, bool *no_add_attrs)
4401 if (TREE_CODE (decl) == PARM_DECL
4402 || TREE_CODE (decl) == VAR_DECL
4403 || TREE_CODE (decl) == FUNCTION_DECL
4404 /* APPLE LOCAL begin for-fsf-4_4 3274130 5295549 */ \
4405 || (TREE_CODE (decl) == LABEL_DECL
4406 && ! DECL_ARTIFICIAL (decl))
4407 /* APPLE LOCAL end for-fsf-4_4 3274130 5295549 */ \
4408 || TREE_CODE (decl) == TYPE_DECL)
4409 TREE_USED (decl) = 1;
4412 warning (OPT_Wattributes, "%qE attribute ignored", name);
4413 *no_add_attrs = true;
4418 if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
4419 *node = build_variant_type_copy (*node);
4420 TREE_USED (*node) = 1;
4426 /* Handle a "externally_visible" attribute; arguments as in
4427 struct attribute_spec.handler. */
4430 handle_externally_visible_attribute (tree *pnode, tree name,
4431 tree ARG_UNUSED (args),
4432 int ARG_UNUSED (flags),
4437 if (TREE_CODE (node) == FUNCTION_DECL || TREE_CODE (node) == VAR_DECL)
4439 if ((!TREE_STATIC (node) && TREE_CODE (node) != FUNCTION_DECL
4440 && !DECL_EXTERNAL (node)) || !TREE_PUBLIC (node))
4442 warning (OPT_Wattributes,
4443 "%qE attribute have effect only on public objects", name);
4444 *no_add_attrs = true;
4449 warning (OPT_Wattributes, "%qE attribute ignored", name);
4450 *no_add_attrs = true;
4456 /* Handle a "const" attribute; arguments as in
4457 struct attribute_spec.handler. */
4460 handle_const_attribute (tree *node, tree name, tree ARG_UNUSED (args),
4461 int ARG_UNUSED (flags), bool *no_add_attrs)
4463 tree type = TREE_TYPE (*node);
4465 /* See FIXME comment on noreturn in c_common_attribute_table. */
4466 if (TREE_CODE (*node) == FUNCTION_DECL)
4467 TREE_READONLY (*node) = 1;
4468 else if (TREE_CODE (type) == POINTER_TYPE
4469 && TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE)
4471 = build_pointer_type
4472 (build_type_variant (TREE_TYPE (type), 1,
4473 TREE_THIS_VOLATILE (TREE_TYPE (type))));
4476 warning (OPT_Wattributes, "%qE attribute ignored", name);
4477 *no_add_attrs = true;
4483 /* Handle a "transparent_union" attribute; arguments as in
4484 struct attribute_spec.handler. */
4487 handle_transparent_union_attribute (tree *node, tree name,
4488 tree ARG_UNUSED (args), int flags,
4493 *no_add_attrs = true;
4497 if (TREE_CODE (*node) != TYPE_DECL)
4499 node = &TREE_TYPE (*node);
4502 else if (TYPE_P (*node))
4507 if (TREE_CODE (type) == UNION_TYPE)
4509 /* When IN_PLACE is set, leave the check for FIELDS and MODE to
4510 the code in finish_struct. */
4511 if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
4513 if (TYPE_FIELDS (type) == NULL_TREE
4514 || TYPE_MODE (type) != DECL_MODE (TYPE_FIELDS (type)))
4517 /* A type variant isn't good enough, since we don't a cast
4518 to such a type removed as a no-op. */
4519 *node = type = build_duplicate_type (type);
4522 TYPE_TRANSPARENT_UNION (type) = 1;
4527 warning (OPT_Wattributes, "%qE attribute ignored", name);
4531 /* Handle a "constructor" attribute; arguments as in
4532 struct attribute_spec.handler. */
4535 handle_constructor_attribute (tree *node, tree name,
4536 tree ARG_UNUSED (args),
4537 int ARG_UNUSED (flags),
4541 tree type = TREE_TYPE (decl);
4543 if (TREE_CODE (decl) == FUNCTION_DECL
4544 && TREE_CODE (type) == FUNCTION_TYPE
4545 && decl_function_context (decl) == 0)
4547 DECL_STATIC_CONSTRUCTOR (decl) = 1;
4548 TREE_USED (decl) = 1;
4552 warning (OPT_Wattributes, "%qE attribute ignored", name);
4553 *no_add_attrs = true;
4559 /* Handle a "destructor" attribute; arguments as in
4560 struct attribute_spec.handler. */
4563 handle_destructor_attribute (tree *node, tree name,
4564 tree ARG_UNUSED (args),
4565 int ARG_UNUSED (flags),
4569 tree type = TREE_TYPE (decl);
4571 if (TREE_CODE (decl) == FUNCTION_DECL
4572 && TREE_CODE (type) == FUNCTION_TYPE
4573 && decl_function_context (decl) == 0)
4575 DECL_STATIC_DESTRUCTOR (decl) = 1;
4576 TREE_USED (decl) = 1;
4580 warning (OPT_Wattributes, "%qE attribute ignored", name);
4581 *no_add_attrs = true;
4587 /* Handle a "mode" attribute; arguments as in
4588 struct attribute_spec.handler. */
4591 handle_mode_attribute (tree *node, tree name, tree args,
4592 int ARG_UNUSED (flags), bool *no_add_attrs)
4596 *no_add_attrs = true;
4598 if (TREE_CODE (TREE_VALUE (args)) != IDENTIFIER_NODE)
4599 warning (OPT_Wattributes, "%qE attribute ignored", name);
4603 const char *p = IDENTIFIER_POINTER (TREE_VALUE (args));
4604 int len = strlen (p);
4605 enum machine_mode mode = VOIDmode;
4609 if (len > 4 && p[0] == '_' && p[1] == '_'
4610 && p[len - 1] == '_' && p[len - 2] == '_')
4612 char *newp = (char *) alloca (len - 1);
4614 strcpy (newp, &p[2]);
4615 newp[len - 4] = '\0';
4619 /* Change this type to have a type with the specified mode.
4620 First check for the special modes. */
4621 if (!strcmp (p, "byte"))
4623 else if (!strcmp (p, "word"))
4625 else if (!strcmp (p, "pointer"))
4628 for (j = 0; j < NUM_MACHINE_MODES; j++)
4629 if (!strcmp (p, GET_MODE_NAME (j)))
4631 mode = (enum machine_mode) j;
4635 if (mode == VOIDmode)
4637 error ("unknown machine mode %qs", p);
4642 switch (GET_MODE_CLASS (mode))
4645 case MODE_PARTIAL_INT:
4647 case MODE_DECIMAL_FLOAT:
4648 valid_mode = targetm.scalar_mode_supported_p (mode);
4651 case MODE_COMPLEX_INT:
4652 case MODE_COMPLEX_FLOAT:
4653 valid_mode = targetm.scalar_mode_supported_p (GET_MODE_INNER (mode));
4656 case MODE_VECTOR_INT:
4657 case MODE_VECTOR_FLOAT:
4658 warning (OPT_Wattributes, "specifying vector types with "
4659 "__attribute__ ((mode)) is deprecated");
4660 warning (OPT_Wattributes,
4661 "use __attribute__ ((vector_size)) instead");
4662 valid_mode = vector_mode_valid_p (mode);
4670 error ("unable to emulate %qs", p);
4674 if (POINTER_TYPE_P (type))
4676 tree (*fn)(tree, enum machine_mode, bool);
4678 if (!targetm.valid_pointer_mode (mode))
4680 error ("invalid pointer mode %qs", p);
4684 if (TREE_CODE (type) == POINTER_TYPE)
4685 fn = build_pointer_type_for_mode;
4687 fn = build_reference_type_for_mode;
4688 typefm = fn (TREE_TYPE (type), mode, false);
4691 typefm = lang_hooks.types.type_for_mode (mode, TYPE_UNSIGNED (type));
4693 if (typefm == NULL_TREE)
4695 error ("no data type for mode %qs", p);
4698 else if (TREE_CODE (type) == ENUMERAL_TYPE)
4700 /* For enumeral types, copy the precision from the integer
4701 type returned above. If not an INTEGER_TYPE, we can't use
4702 this mode for this type. */
4703 if (TREE_CODE (typefm) != INTEGER_TYPE)
4705 error ("cannot use mode %qs for enumeral types", p);
4709 if (flags & ATTR_FLAG_TYPE_IN_PLACE)
4711 TYPE_PRECISION (type) = TYPE_PRECISION (typefm);
4716 /* We cannot build a type variant, as there's code that assumes
4717 that TYPE_MAIN_VARIANT has the same mode. This includes the
4718 debug generators. Instead, create a subrange type. This
4719 results in all of the enumeral values being emitted only once
4720 in the original, and the subtype gets them by reference. */
4721 if (TYPE_UNSIGNED (type))
4722 typefm = make_unsigned_type (TYPE_PRECISION (typefm));
4724 typefm = make_signed_type (TYPE_PRECISION (typefm));
4725 TREE_TYPE (typefm) = type;
4728 else if (VECTOR_MODE_P (mode)
4729 ? TREE_CODE (type) != TREE_CODE (TREE_TYPE (typefm))
4730 : TREE_CODE (type) != TREE_CODE (typefm))
4732 error ("mode %qs applied to inappropriate type", p);
4742 /* Handle a "section" attribute; arguments as in
4743 struct attribute_spec.handler. */
4746 handle_section_attribute (tree *node, tree ARG_UNUSED (name), tree args,
4747 int ARG_UNUSED (flags), bool *no_add_attrs)
4751 if (targetm.have_named_sections)
4753 user_defined_section_attribute = true;
4755 if ((TREE_CODE (decl) == FUNCTION_DECL
4756 || TREE_CODE (decl) == VAR_DECL)
4757 && TREE_CODE (TREE_VALUE (args)) == STRING_CST)
4759 if (TREE_CODE (decl) == VAR_DECL
4760 && current_function_decl != NULL_TREE
4761 && !TREE_STATIC (decl))
4763 error ("%Jsection attribute cannot be specified for "
4764 "local variables", decl);
4765 *no_add_attrs = true;
4768 /* The decl may have already been given a section attribute
4769 from a previous declaration. Ensure they match. */
4770 else if (DECL_SECTION_NAME (decl) != NULL_TREE
4771 && strcmp (TREE_STRING_POINTER (DECL_SECTION_NAME (decl)),
4772 TREE_STRING_POINTER (TREE_VALUE (args))) != 0)
4774 error ("section of %q+D conflicts with previous declaration",
4776 *no_add_attrs = true;
4779 DECL_SECTION_NAME (decl) = TREE_VALUE (args);
4783 error ("section attribute not allowed for %q+D", *node);
4784 *no_add_attrs = true;
4789 error ("%Jsection attributes are not supported for this target", *node);
4790 *no_add_attrs = true;
4796 /* Handle a "aligned" attribute; arguments as in
4797 struct attribute_spec.handler. */
4800 handle_aligned_attribute (tree *node, tree ARG_UNUSED (name), tree args,
4801 int flags, bool *no_add_attrs)
4803 tree decl = NULL_TREE;
4806 tree align_expr = (args ? TREE_VALUE (args)
4807 : size_int (BIGGEST_ALIGNMENT / BITS_PER_UNIT));
4813 type = &TREE_TYPE (decl);
4814 is_type = TREE_CODE (*node) == TYPE_DECL;
4816 else if (TYPE_P (*node))
4817 type = node, is_type = 1;
4819 if (TREE_CODE (align_expr) != INTEGER_CST)
4821 error ("requested alignment is not a constant");
4822 *no_add_attrs = true;
4824 else if ((i = tree_log2 (align_expr)) == -1)
4826 error ("requested alignment is not a power of 2");
4827 *no_add_attrs = true;
4829 else if (i > HOST_BITS_PER_INT - 2)
4831 error ("requested alignment is too large");
4832 *no_add_attrs = true;
4836 /* If we have a TYPE_DECL, then copy the type, so that we
4837 don't accidentally modify a builtin type. See pushdecl. */
4838 if (decl && TREE_TYPE (decl) != error_mark_node
4839 && DECL_ORIGINAL_TYPE (decl) == NULL_TREE)
4841 tree tt = TREE_TYPE (decl);
4842 *type = build_variant_type_copy (*type);
4843 DECL_ORIGINAL_TYPE (decl) = tt;
4844 TYPE_NAME (*type) = decl;
4845 TREE_USED (*type) = TREE_USED (decl);
4846 TREE_TYPE (decl) = *type;
4848 else if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
4849 *type = build_variant_type_copy (*type);
4851 TYPE_ALIGN (*type) = (1 << i) * BITS_PER_UNIT;
4852 TYPE_USER_ALIGN (*type) = 1;
4854 else if (! VAR_OR_FUNCTION_DECL_P (decl)
4855 /* APPLE LOCAL begin for-fsf-4_4 3274130 5295549 */ \
4856 && TREE_CODE (decl) != FIELD_DECL
4857 && TREE_CODE (decl) != LABEL_DECL)
4858 /* APPLE LOCAL end for-fsf-4_4 3274130 5295549 */ \
4860 error ("alignment may not be specified for %q+D", decl);
4861 *no_add_attrs = true;
4863 else if (TREE_CODE (decl) == FUNCTION_DECL
4864 && DECL_ALIGN (decl) > (1 << i) * BITS_PER_UNIT)
4866 if (DECL_USER_ALIGN (decl))
4867 error ("alignment for %q+D was previously specified as %d "
4868 "and may not be decreased", decl,
4869 DECL_ALIGN (decl) / BITS_PER_UNIT);
4871 error ("alignment for %q+D must be at least %d", decl,
4872 DECL_ALIGN (decl) / BITS_PER_UNIT);
4873 *no_add_attrs = true;
4877 DECL_ALIGN (decl) = (1 << i) * BITS_PER_UNIT;
4878 DECL_USER_ALIGN (decl) = 1;
4884 /* Handle a "weak" attribute; arguments as in
4885 struct attribute_spec.handler. */
4888 handle_weak_attribute (tree *node, tree name,
4889 tree ARG_UNUSED (args),
4890 int ARG_UNUSED (flags),
4891 bool * ARG_UNUSED (no_add_attrs))
4893 if (TREE_CODE (*node) == FUNCTION_DECL
4894 || TREE_CODE (*node) == VAR_DECL)
4895 declare_weak (*node);
4897 warning (OPT_Wattributes, "%qE attribute ignored", name);
4903 /* Handle an "alias" attribute; arguments as in
4904 struct attribute_spec.handler. */
4907 handle_alias_attribute (tree *node, tree name, tree args,
4908 int ARG_UNUSED (flags), bool *no_add_attrs)
4912 if ((TREE_CODE (decl) == FUNCTION_DECL && DECL_INITIAL (decl))
4913 || (TREE_CODE (decl) != FUNCTION_DECL
4914 && TREE_PUBLIC (decl) && !DECL_EXTERNAL (decl))
4915 /* A static variable declaration is always a tentative definition,
4916 but the alias is a non-tentative definition which overrides. */
4917 || (TREE_CODE (decl) != FUNCTION_DECL
4918 && ! TREE_PUBLIC (decl) && DECL_INITIAL (decl)))
4920 error ("%q+D defined both normally and as an alias", decl);
4921 *no_add_attrs = true;
4924 /* Note that the very first time we process a nested declaration,
4925 decl_function_context will not be set. Indeed, *would* never
4926 be set except for the DECL_INITIAL/DECL_EXTERNAL frobbery that
4927 we do below. After such frobbery, pushdecl would set the context.
4928 In any case, this is never what we want. */
4929 else if (decl_function_context (decl) == 0 && current_function_decl == NULL)
4933 id = TREE_VALUE (args);
4934 if (TREE_CODE (id) != STRING_CST)
4936 error ("alias argument not a string");
4937 *no_add_attrs = true;
4940 id = get_identifier (TREE_STRING_POINTER (id));
4941 /* This counts as a use of the object pointed to. */
4944 if (TREE_CODE (decl) == FUNCTION_DECL)
4945 DECL_INITIAL (decl) = error_mark_node;
4948 if (lookup_attribute ("weakref", DECL_ATTRIBUTES (decl)))
4949 DECL_EXTERNAL (decl) = 1;
4951 DECL_EXTERNAL (decl) = 0;
4952 TREE_STATIC (decl) = 1;
4957 warning (OPT_Wattributes, "%qE attribute ignored", name);
4958 *no_add_attrs = true;
4964 /* Handle a "weakref" attribute; arguments as in struct
4965 attribute_spec.handler. */
4968 handle_weakref_attribute (tree *node, tree ARG_UNUSED (name), tree args,
4969 int flags, bool *no_add_attrs)
4971 tree attr = NULL_TREE;
4973 /* We must ignore the attribute when it is associated with
4974 local-scoped decls, since attribute alias is ignored and many
4975 such symbols do not even have a DECL_WEAK field. */
4976 if (decl_function_context (*node) || current_function_decl)
4978 warning (OPT_Wattributes, "%qE attribute ignored", name);
4979 *no_add_attrs = true;
4983 /* The idea here is that `weakref("name")' mutates into `weakref,
4984 alias("name")', and weakref without arguments, in turn,
4985 implicitly adds weak. */
4989 attr = tree_cons (get_identifier ("alias"), args, attr);
4990 attr = tree_cons (get_identifier ("weakref"), NULL_TREE, attr);
4992 *no_add_attrs = true;
4994 decl_attributes (node, attr, flags);
4998 if (lookup_attribute ("alias", DECL_ATTRIBUTES (*node)))
4999 error ("%Jweakref attribute must appear before alias attribute",
5002 /* Can't call declare_weak because it wants this to be TREE_PUBLIC,
5003 and that isn't supported; and because it wants to add it to
5004 the list of weak decls, which isn't helpful. */
5005 DECL_WEAK (*node) = 1;
5011 /* Handle an "visibility" attribute; arguments as in
5012 struct attribute_spec.handler. */
5015 handle_visibility_attribute (tree *node, tree name, tree args,
5016 int ARG_UNUSED (flags),
5017 bool *ARG_UNUSED (no_add_attrs))
5020 tree id = TREE_VALUE (args);
5021 enum symbol_visibility vis;
5025 if (TREE_CODE (*node) == ENUMERAL_TYPE)
5027 else if (TREE_CODE (*node) != RECORD_TYPE && TREE_CODE (*node) != UNION_TYPE)
5029 warning (OPT_Wattributes, "%qE attribute ignored on non-class types",
5033 else if (TYPE_FIELDS (*node))
5035 error ("%qE attribute ignored because %qT is already defined",
5040 else if (decl_function_context (decl) != 0 || !TREE_PUBLIC (decl))
5042 warning (OPT_Wattributes, "%qE attribute ignored", name);
5046 if (TREE_CODE (id) != STRING_CST)
5048 error ("visibility argument not a string");
5052 /* If this is a type, set the visibility on the type decl. */
5055 decl = TYPE_NAME (decl);
5058 if (TREE_CODE (decl) == IDENTIFIER_NODE)
5060 warning (OPT_Wattributes, "%qE attribute ignored on types",
5066 if (strcmp (TREE_STRING_POINTER (id), "default") == 0)
5067 vis = VISIBILITY_DEFAULT;
5068 else if (strcmp (TREE_STRING_POINTER (id), "internal") == 0)
5069 vis = VISIBILITY_INTERNAL;
5070 else if (strcmp (TREE_STRING_POINTER (id), "hidden") == 0)
5071 vis = VISIBILITY_HIDDEN;
5072 else if (strcmp (TREE_STRING_POINTER (id), "protected") == 0)
5073 vis = VISIBILITY_PROTECTED;
5076 error ("visibility argument must be one of \"default\", \"hidden\", \"protected\" or \"internal\"");
5077 vis = VISIBILITY_DEFAULT;
5080 if (DECL_VISIBILITY_SPECIFIED (decl)
5081 && vis != DECL_VISIBILITY (decl)
5082 && lookup_attribute ("visibility", (TYPE_P (*node)
5083 ? TYPE_ATTRIBUTES (*node)
5084 : DECL_ATTRIBUTES (decl))))
5085 error ("%qD redeclared with different visibility", decl);
5087 DECL_VISIBILITY (decl) = vis;
5088 DECL_VISIBILITY_SPECIFIED (decl) = 1;
5090 /* Go ahead and attach the attribute to the node as well. This is needed
5091 so we can determine whether we have VISIBILITY_DEFAULT because the
5092 visibility was not specified, or because it was explicitly overridden
5093 from the containing scope. */
5098 /* Determine the ELF symbol visibility for DECL, which is either a
5099 variable or a function. It is an error to use this function if a
5100 definition of DECL is not available in this translation unit.
5101 Returns true if the final visibility has been determined by this
5102 function; false if the caller is free to make additional
5106 c_determine_visibility (tree decl)
5108 gcc_assert (TREE_CODE (decl) == VAR_DECL
5109 || TREE_CODE (decl) == FUNCTION_DECL);
5111 /* If the user explicitly specified the visibility with an
5112 attribute, honor that. DECL_VISIBILITY will have been set during
5113 the processing of the attribute. We check for an explicit
5114 attribute, rather than just checking DECL_VISIBILITY_SPECIFIED,
5115 to distinguish the use of an attribute from the use of a "#pragma
5116 GCC visibility push(...)"; in the latter case we still want other
5117 considerations to be able to overrule the #pragma. */
5118 if (lookup_attribute ("visibility", DECL_ATTRIBUTES (decl)))
5121 /* Anything that is exported must have default visibility. */
5122 if (TARGET_DLLIMPORT_DECL_ATTRIBUTES
5123 && lookup_attribute ("dllexport", DECL_ATTRIBUTES (decl)))
5125 DECL_VISIBILITY (decl) = VISIBILITY_DEFAULT;
5126 DECL_VISIBILITY_SPECIFIED (decl) = 1;
5130 /* Set default visibility to whatever the user supplied with
5131 visibility_specified depending on #pragma GCC visibility. */
5132 if (!DECL_VISIBILITY_SPECIFIED (decl))
5134 DECL_VISIBILITY (decl) = default_visibility;
5135 DECL_VISIBILITY_SPECIFIED (decl) = visibility_options.inpragma;
5140 /* Handle an "tls_model" attribute; arguments as in
5141 struct attribute_spec.handler. */
5144 handle_tls_model_attribute (tree *node, tree name, tree args,
5145 int ARG_UNUSED (flags), bool *no_add_attrs)
5149 enum tls_model kind;
5151 *no_add_attrs = true;
5153 if (!DECL_THREAD_LOCAL_P (decl))
5155 warning (OPT_Wattributes, "%qE attribute ignored", name);
5159 kind = DECL_TLS_MODEL (decl);
5160 id = TREE_VALUE (args);
5161 if (TREE_CODE (id) != STRING_CST)
5163 error ("tls_model argument not a string");
5167 if (!strcmp (TREE_STRING_POINTER (id), "local-exec"))
5168 kind = TLS_MODEL_LOCAL_EXEC;
5169 else if (!strcmp (TREE_STRING_POINTER (id), "initial-exec"))
5170 kind = TLS_MODEL_INITIAL_EXEC;
5171 else if (!strcmp (TREE_STRING_POINTER (id), "local-dynamic"))
5172 kind = optimize ? TLS_MODEL_LOCAL_DYNAMIC : TLS_MODEL_GLOBAL_DYNAMIC;
5173 else if (!strcmp (TREE_STRING_POINTER (id), "global-dynamic"))
5174 kind = TLS_MODEL_GLOBAL_DYNAMIC;
5176 error ("tls_model argument must be one of \"local-exec\", \"initial-exec\", \"local-dynamic\" or \"global-dynamic\"");
5178 DECL_TLS_MODEL (decl) = kind;
5182 /* Handle a "no_instrument_function" attribute; arguments as in
5183 struct attribute_spec.handler. */
5186 handle_no_instrument_function_attribute (tree *node, tree name,
5187 tree ARG_UNUSED (args),
5188 int ARG_UNUSED (flags),
5193 if (TREE_CODE (decl) != FUNCTION_DECL)
5195 error ("%J%qE attribute applies only to functions", decl, name);
5196 *no_add_attrs = true;
5198 else if (DECL_INITIAL (decl))
5200 error ("%Jcan%'t set %qE attribute after definition", decl, name);
5201 *no_add_attrs = true;
5204 DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (decl) = 1;
5209 /* Handle a "malloc" attribute; arguments as in
5210 struct attribute_spec.handler. */
5213 handle_malloc_attribute (tree *node, tree name, tree ARG_UNUSED (args),
5214 int ARG_UNUSED (flags), bool *no_add_attrs)
5216 if (TREE_CODE (*node) == FUNCTION_DECL
5217 && POINTER_TYPE_P (TREE_TYPE (TREE_TYPE (*node))))
5218 DECL_IS_MALLOC (*node) = 1;
5221 warning (OPT_Wattributes, "%qE attribute ignored", name);
5222 *no_add_attrs = true;
5228 /* Handle a "returns_twice" attribute; arguments as in
5229 struct attribute_spec.handler. */
5232 handle_returns_twice_attribute (tree *node, tree name, tree ARG_UNUSED (args),
5233 int ARG_UNUSED (flags), bool *no_add_attrs)
5235 if (TREE_CODE (*node) == FUNCTION_DECL)
5236 DECL_IS_RETURNS_TWICE (*node) = 1;
5239 warning (OPT_Wattributes, "%qE attribute ignored", name);
5240 *no_add_attrs = true;
5246 /* Handle a "no_limit_stack" attribute; arguments as in
5247 struct attribute_spec.handler. */
5250 handle_no_limit_stack_attribute (tree *node, tree name,
5251 tree ARG_UNUSED (args),
5252 int ARG_UNUSED (flags),
5257 if (TREE_CODE (decl) != FUNCTION_DECL)
5259 error ("%J%qE attribute applies only to functions", decl, name);
5260 *no_add_attrs = true;
5262 else if (DECL_INITIAL (decl))
5264 error ("%Jcan%'t set %qE attribute after definition", decl, name);
5265 *no_add_attrs = true;
5268 DECL_NO_LIMIT_STACK (decl) = 1;
5273 /* Handle a "pure" attribute; arguments as in
5274 struct attribute_spec.handler. */
5277 handle_pure_attribute (tree *node, tree name, tree ARG_UNUSED (args),
5278 int ARG_UNUSED (flags), bool *no_add_attrs)
5280 if (TREE_CODE (*node) == FUNCTION_DECL)
5281 DECL_IS_PURE (*node) = 1;
5282 /* ??? TODO: Support types. */
5285 warning (OPT_Wattributes, "%qE attribute ignored", name);
5286 *no_add_attrs = true;
5292 /* Handle a "no vops" attribute; arguments as in
5293 struct attribute_spec.handler. */
5296 handle_novops_attribute (tree *node, tree ARG_UNUSED (name),
5297 tree ARG_UNUSED (args), int ARG_UNUSED (flags),
5298 bool *ARG_UNUSED (no_add_attrs))
5300 gcc_assert (TREE_CODE (*node) == FUNCTION_DECL);
5301 DECL_IS_NOVOPS (*node) = 1;
5305 /* Handle a "deprecated" attribute; arguments as in
5306 struct attribute_spec.handler. */
5309 handle_deprecated_attribute (tree *node, tree name,
5310 tree ARG_UNUSED (args), int flags,
5313 tree type = NULL_TREE;
5315 tree what = NULL_TREE;
5320 type = TREE_TYPE (decl);
5322 if (TREE_CODE (decl) == TYPE_DECL
5323 || TREE_CODE (decl) == PARM_DECL
5324 || TREE_CODE (decl) == VAR_DECL
5325 || TREE_CODE (decl) == FUNCTION_DECL
5326 || TREE_CODE (decl) == FIELD_DECL)
5327 TREE_DEPRECATED (decl) = 1;
5331 else if (TYPE_P (*node))
5333 if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
5334 *node = build_variant_type_copy (*node);
5335 TREE_DEPRECATED (*node) = 1;
5343 *no_add_attrs = true;
5344 if (type && TYPE_NAME (type))
5346 if (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE)
5347 what = TYPE_NAME (*node);
5348 else if (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
5349 && DECL_NAME (TYPE_NAME (type)))
5350 what = DECL_NAME (TYPE_NAME (type));
5353 warning (OPT_Wattributes, "%qE attribute ignored for %qE", name, what);
5355 warning (OPT_Wattributes, "%qE attribute ignored", name);
5361 /* APPLE LOCAL begin "unavailable" attribute (Radar 2809697) --ilr */
5362 /* Handle a "unavailable" attribute; arguments as in
5363 struct attribute_spec.handler. */
5366 handle_unavailable_attribute (tree *node, tree name,
5367 tree args ATTRIBUTE_UNUSED,
5368 int flags ATTRIBUTE_UNUSED,
5371 tree type = NULL_TREE;
5373 const char *what = NULL;
5378 type = TREE_TYPE (decl);
5380 if (TREE_CODE (decl) == TYPE_DECL
5381 || TREE_CODE (decl) == PARM_DECL
5382 || TREE_CODE (decl) == VAR_DECL
5383 || TREE_CODE (decl) == FUNCTION_DECL
5384 || TREE_CODE (decl) == FIELD_DECL)
5385 /* Removed radar 3803157 - objc attribute */
5387 TREE_UNAVAILABLE (decl) = 1;
5392 else if (TYPE_P (*node))
5394 if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
5395 *node = build_variant_type_copy (*node);
5396 TREE_UNAVAILABLE (*node) = 1;
5404 *no_add_attrs = true;
5405 if (type && TYPE_NAME (type))
5407 if (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE)
5408 what = IDENTIFIER_POINTER (TYPE_NAME (*node));
5409 else if (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
5410 && DECL_NAME (TYPE_NAME (type)))
5411 what = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type)));
5414 warning (0, "`%s' attribute ignored for `%s'",
5415 IDENTIFIER_POINTER (name), what);
5417 warning (0, "`%s' attribute ignored", IDENTIFIER_POINTER (name));
5422 /* APPLE LOCAL end "unavailable" attribute --ilr */
5424 /* Handle a "vector_size" attribute; arguments as in
5425 struct attribute_spec.handler. */
5428 handle_vector_size_attribute (tree *node, tree name, tree args,
5429 int ARG_UNUSED (flags),
5432 unsigned HOST_WIDE_INT vecsize, nunits;
5433 enum machine_mode orig_mode;
5434 tree type = *node, new_type, size;
5436 *no_add_attrs = true;
5438 size = TREE_VALUE (args);
5440 if (!host_integerp (size, 1))
5442 warning (OPT_Wattributes, "%qE attribute ignored", name);
5446 /* Get the vector size (in bytes). */
5447 vecsize = tree_low_cst (size, 1);
5449 /* We need to provide for vector pointers, vector arrays, and
5450 functions returning vectors. For example:
5452 __attribute__((vector_size(16))) short *foo;
5454 In this case, the mode is SI, but the type being modified is
5455 HI, so we need to look further. */
5457 while (POINTER_TYPE_P (type)
5458 || TREE_CODE (type) == FUNCTION_TYPE
5459 || TREE_CODE (type) == METHOD_TYPE
5460 || TREE_CODE (type) == ARRAY_TYPE)
5461 type = TREE_TYPE (type);
5463 /* Get the mode of the type being modified. */
5464 orig_mode = TYPE_MODE (type);
5466 if (TREE_CODE (type) == RECORD_TYPE
5467 || TREE_CODE (type) == UNION_TYPE
5468 || TREE_CODE (type) == VECTOR_TYPE
5469 || (!SCALAR_FLOAT_MODE_P (orig_mode)
5470 && GET_MODE_CLASS (orig_mode) != MODE_INT)
5471 || !host_integerp (TYPE_SIZE_UNIT (type), 1))
5473 error ("invalid vector type for attribute %qE", name);
5477 if (vecsize % tree_low_cst (TYPE_SIZE_UNIT (type), 1))
5479 error ("vector size not an integral multiple of component size");
5485 error ("zero vector size");
5489 /* Calculate how many units fit in the vector. */
5490 nunits = vecsize / tree_low_cst (TYPE_SIZE_UNIT (type), 1);
5491 if (nunits & (nunits - 1))
5493 error ("number of components of the vector not a power of two");
5497 new_type = build_vector_type (type, nunits);
5499 /* Build back pointers if needed. */
5500 *node = reconstruct_complex_type (*node, new_type);
5505 /* Handle the "nonnull" attribute. */
5507 handle_nonnull_attribute (tree *node, tree ARG_UNUSED (name),
5508 tree args, int ARG_UNUSED (flags),
5512 unsigned HOST_WIDE_INT attr_arg_num;
5514 /* If no arguments are specified, all pointer arguments should be
5515 non-null. Verify a full prototype is given so that the arguments
5516 will have the correct types when we actually check them later. */
5519 if (!TYPE_ARG_TYPES (type))
5521 error ("nonnull attribute without arguments on a non-prototype");
5522 *no_add_attrs = true;
5527 /* Argument list specified. Verify that each argument number references
5528 a pointer argument. */
5529 for (attr_arg_num = 1; args; args = TREE_CHAIN (args))
5532 unsigned HOST_WIDE_INT arg_num = 0, ck_num;
5534 if (!get_nonnull_operand (TREE_VALUE (args), &arg_num))
5536 error ("nonnull argument has invalid operand number (argument %lu)",
5537 (unsigned long) attr_arg_num);
5538 *no_add_attrs = true;
5542 argument = TYPE_ARG_TYPES (type);
5545 for (ck_num = 1; ; ck_num++)
5547 if (!argument || ck_num == arg_num)
5549 argument = TREE_CHAIN (argument);
5553 || TREE_CODE (TREE_VALUE (argument)) == VOID_TYPE)
5555 error ("nonnull argument with out-of-range operand number (argument %lu, operand %lu)",
5556 (unsigned long) attr_arg_num, (unsigned long) arg_num);
5557 *no_add_attrs = true;
5561 if (TREE_CODE (TREE_VALUE (argument)) != POINTER_TYPE)
5563 error ("nonnull argument references non-pointer operand (argument %lu, operand %lu)",
5564 (unsigned long) attr_arg_num, (unsigned long) arg_num);
5565 *no_add_attrs = true;
5574 /* Check the argument list of a function call for null in argument slots
5575 that are marked as requiring a non-null pointer argument. */
5578 check_function_nonnull (tree attrs, tree params)
5580 tree a, args, param;
5583 for (a = attrs; a; a = TREE_CHAIN (a))
5585 if (is_attribute_p ("nonnull", TREE_PURPOSE (a)))
5587 args = TREE_VALUE (a);
5589 /* Walk the argument list. If we encounter an argument number we
5590 should check for non-null, do it. If the attribute has no args,
5591 then every pointer argument is checked (in which case the check
5592 for pointer type is done in check_nonnull_arg). */
5593 for (param = params, param_num = 1; ;
5594 param_num++, param = TREE_CHAIN (param))
5598 if (!args || nonnull_check_p (args, param_num))
5599 check_function_arguments_recurse (check_nonnull_arg, NULL,
5607 /* Check that the Nth argument of a function call (counting backwards
5608 from the end) is a (pointer)0. */
5611 check_function_sentinel (tree attrs, tree params, tree typelist)
5613 tree attr = lookup_attribute ("sentinel", attrs);
5617 /* Skip over the named arguments. */
5618 while (typelist && params)
5620 typelist = TREE_CHAIN (typelist);
5621 params = TREE_CHAIN (params);
5624 if (typelist || !params)
5625 warning (OPT_Wformat,
5626 "not enough variable arguments to fit a sentinel");
5632 if (TREE_VALUE (attr))
5634 tree p = TREE_VALUE (TREE_VALUE (attr));
5635 pos = TREE_INT_CST_LOW (p);
5638 sentinel = end = params;
5640 /* Advance `end' ahead of `sentinel' by `pos' positions. */
5641 while (pos > 0 && TREE_CHAIN (end))
5644 end = TREE_CHAIN (end);
5648 warning (OPT_Wformat,
5649 "not enough variable arguments to fit a sentinel");
5653 /* Now advance both until we find the last parameter. */
5654 while (TREE_CHAIN (end))
5656 end = TREE_CHAIN (end);
5657 sentinel = TREE_CHAIN (sentinel);
5660 /* Validate the sentinel. */
5661 if ((!POINTER_TYPE_P (TREE_TYPE (TREE_VALUE (sentinel)))
5662 || !integer_zerop (TREE_VALUE (sentinel)))
5663 /* Although __null (in C++) is only an integer we allow it
5664 nevertheless, as we are guaranteed that it's exactly
5665 as wide as a pointer, and we don't want to force
5666 users to cast the NULL they have written there.
5667 We warn with -Wstrict-null-sentinel, though. */
5668 && (warn_strict_null_sentinel
5669 || null_node != TREE_VALUE (sentinel)))
5670 warning (OPT_Wformat, "missing sentinel in function call");
5675 /* Helper for check_function_nonnull; given a list of operands which
5676 must be non-null in ARGS, determine if operand PARAM_NUM should be
5680 nonnull_check_p (tree args, unsigned HOST_WIDE_INT param_num)
5682 unsigned HOST_WIDE_INT arg_num = 0;
5684 for (; args; args = TREE_CHAIN (args))
5686 bool found = get_nonnull_operand (TREE_VALUE (args), &arg_num);
5690 if (arg_num == param_num)
5696 /* Check that the function argument PARAM (which is operand number
5697 PARAM_NUM) is non-null. This is called by check_function_nonnull
5698 via check_function_arguments_recurse. */
5701 check_nonnull_arg (void * ARG_UNUSED (ctx), tree param,
5702 unsigned HOST_WIDE_INT param_num)
5704 /* Just skip checking the argument if it's not a pointer. This can
5705 happen if the "nonnull" attribute was given without an operand
5706 list (which means to check every pointer argument). */
5708 if (TREE_CODE (TREE_TYPE (param)) != POINTER_TYPE)
5711 if (integer_zerop (param))
5712 warning (OPT_Wnonnull, "null argument where non-null required "
5713 "(argument %lu)", (unsigned long) param_num);
5716 /* Helper for nonnull attribute handling; fetch the operand number
5717 from the attribute argument list. */
5720 get_nonnull_operand (tree arg_num_expr, unsigned HOST_WIDE_INT *valp)
5722 /* Verify the arg number is a constant. */
5723 if (TREE_CODE (arg_num_expr) != INTEGER_CST
5724 || TREE_INT_CST_HIGH (arg_num_expr) != 0)
5727 *valp = TREE_INT_CST_LOW (arg_num_expr);
5731 /* Handle a "nothrow" attribute; arguments as in
5732 struct attribute_spec.handler. */
5735 handle_nothrow_attribute (tree *node, tree name, tree ARG_UNUSED (args),
5736 int ARG_UNUSED (flags), bool *no_add_attrs)
5738 if (TREE_CODE (*node) == FUNCTION_DECL)
5739 TREE_NOTHROW (*node) = 1;
5740 /* ??? TODO: Support types. */
5743 warning (OPT_Wattributes, "%qE attribute ignored", name);
5744 *no_add_attrs = true;
5750 /* Handle a "cleanup" attribute; arguments as in
5751 struct attribute_spec.handler. */
5754 handle_cleanup_attribute (tree *node, tree name, tree args,
5755 int ARG_UNUSED (flags), bool *no_add_attrs)
5758 tree cleanup_id, cleanup_decl;
5760 /* ??? Could perhaps support cleanups on TREE_STATIC, much like we do
5761 for global destructors in C++. This requires infrastructure that
5762 we don't have generically at the moment. It's also not a feature
5763 we'd be missing too much, since we do have attribute constructor. */
5764 if (TREE_CODE (decl) != VAR_DECL || TREE_STATIC (decl))
5766 warning (OPT_Wattributes, "%qE attribute ignored", name);
5767 *no_add_attrs = true;
5771 /* Verify that the argument is a function in scope. */
5772 /* ??? We could support pointers to functions here as well, if
5773 that was considered desirable. */
5774 cleanup_id = TREE_VALUE (args);
5775 if (TREE_CODE (cleanup_id) != IDENTIFIER_NODE)
5777 error ("cleanup argument not an identifier");
5778 *no_add_attrs = true;
5781 cleanup_decl = lookup_name (cleanup_id);
5782 if (!cleanup_decl || TREE_CODE (cleanup_decl) != FUNCTION_DECL)
5784 error ("cleanup argument not a function");
5785 *no_add_attrs = true;
5789 /* That the function has proper type is checked with the
5790 eventual call to build_function_call. */
5795 /* Handle a "warn_unused_result" attribute. No special handling. */
5798 handle_warn_unused_result_attribute (tree *node, tree name,
5799 tree ARG_UNUSED (args),
5800 int ARG_UNUSED (flags), bool *no_add_attrs)
5802 /* Ignore the attribute for functions not returning any value. */
5803 if (VOID_TYPE_P (TREE_TYPE (*node)))
5805 warning (OPT_Wattributes, "%qE attribute ignored", name);
5806 *no_add_attrs = true;
5812 /* Handle a "sentinel" attribute. */
5815 handle_sentinel_attribute (tree *node, tree name, tree args,
5816 int ARG_UNUSED (flags), bool *no_add_attrs)
5818 tree params = TYPE_ARG_TYPES (*node);
5822 warning (OPT_Wattributes,
5823 "%qE attribute requires prototypes with named arguments", name);
5824 *no_add_attrs = true;
5828 while (TREE_CHAIN (params))
5829 params = TREE_CHAIN (params);
5831 if (VOID_TYPE_P (TREE_VALUE (params)))
5833 warning (OPT_Wattributes,
5834 "%qE attribute only applies to variadic functions", name);
5835 *no_add_attrs = true;
5841 tree position = TREE_VALUE (args);
5843 if (TREE_CODE (position) != INTEGER_CST)
5845 warning (0, "requested position is not an integer constant");
5846 *no_add_attrs = true;
5850 if (tree_int_cst_lt (position, integer_zero_node))
5852 warning (0, "requested position is less than zero");
5853 *no_add_attrs = true;
5861 /* Check for valid arguments being passed to a function. */
5863 check_function_arguments (tree attrs, tree params, tree typelist)
5865 /* Check for null being passed in a pointer argument that must be
5866 non-null. We also need to do this if format checking is enabled. */
5869 check_function_nonnull (attrs, params);
5871 /* Check for errors in format strings. */
5873 if (warn_format || warn_missing_format_attribute)
5874 check_function_format (attrs, params);
5877 check_function_sentinel (attrs, params, typelist);
5880 /* Generic argument checking recursion routine. PARAM is the argument to
5881 be checked. PARAM_NUM is the number of the argument. CALLBACK is invoked
5882 once the argument is resolved. CTX is context for the callback. */
5884 check_function_arguments_recurse (void (*callback)
5885 (void *, tree, unsigned HOST_WIDE_INT),
5886 void *ctx, tree param,
5887 unsigned HOST_WIDE_INT param_num)
5889 if ((TREE_CODE (param) == NOP_EXPR || TREE_CODE (param) == CONVERT_EXPR)
5890 && (TYPE_PRECISION (TREE_TYPE (param))
5891 == TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (param, 0)))))
5893 /* Strip coercion. */
5894 check_function_arguments_recurse (callback, ctx,
5895 TREE_OPERAND (param, 0), param_num);
5899 if (TREE_CODE (param) == CALL_EXPR)
5901 tree type = TREE_TYPE (TREE_TYPE (TREE_OPERAND (param, 0)));
5903 bool found_format_arg = false;
5905 /* See if this is a call to a known internationalization function
5906 that modifies a format arg. Such a function may have multiple
5907 format_arg attributes (for example, ngettext). */
5909 for (attrs = TYPE_ATTRIBUTES (type);
5911 attrs = TREE_CHAIN (attrs))
5912 if (is_attribute_p ("format_arg", TREE_PURPOSE (attrs)))
5915 tree format_num_expr;
5919 /* Extract the argument number, which was previously checked
5921 format_num_expr = TREE_VALUE (TREE_VALUE (attrs));
5923 gcc_assert (TREE_CODE (format_num_expr) == INTEGER_CST
5924 && !TREE_INT_CST_HIGH (format_num_expr));
5926 format_num = TREE_INT_CST_LOW (format_num_expr);
5928 for (inner_args = TREE_OPERAND (param, 1), i = 1;
5930 inner_args = TREE_CHAIN (inner_args), i++)
5931 if (i == format_num)
5933 check_function_arguments_recurse (callback, ctx,
5934 TREE_VALUE (inner_args),
5936 found_format_arg = true;
5941 /* If we found a format_arg attribute and did a recursive check,
5942 we are done with checking this argument. Otherwise, we continue
5943 and this will be considered a non-literal. */
5944 if (found_format_arg)
5948 if (TREE_CODE (param) == COND_EXPR)
5950 /* Check both halves of the conditional expression. */
5951 check_function_arguments_recurse (callback, ctx,
5952 TREE_OPERAND (param, 1), param_num);
5953 check_function_arguments_recurse (callback, ctx,
5954 TREE_OPERAND (param, 2), param_num);
5958 (*callback) (ctx, param, param_num);
5961 /* Function to help qsort sort FIELD_DECLs by name order. */
5964 field_decl_cmp (const void *x_p, const void *y_p)
5966 const tree *const x = (const tree *const) x_p;
5967 const tree *const y = (const tree *const) y_p;
5969 if (DECL_NAME (*x) == DECL_NAME (*y))
5970 /* A nontype is "greater" than a type. */
5971 return (TREE_CODE (*y) == TYPE_DECL) - (TREE_CODE (*x) == TYPE_DECL);
5972 if (DECL_NAME (*x) == NULL_TREE)
5974 if (DECL_NAME (*y) == NULL_TREE)
5976 if (DECL_NAME (*x) < DECL_NAME (*y))
5982 gt_pointer_operator new_value;
5986 /* This routine compares two fields like field_decl_cmp but using the
5987 pointer operator in resort_data. */
5990 resort_field_decl_cmp (const void *x_p, const void *y_p)
5992 const tree *const x = (const tree *const) x_p;
5993 const tree *const y = (const tree *const) y_p;
5995 if (DECL_NAME (*x) == DECL_NAME (*y))
5996 /* A nontype is "greater" than a type. */
5997 return (TREE_CODE (*y) == TYPE_DECL) - (TREE_CODE (*x) == TYPE_DECL);
5998 if (DECL_NAME (*x) == NULL_TREE)
6000 if (DECL_NAME (*y) == NULL_TREE)
6003 tree d1 = DECL_NAME (*x);
6004 tree d2 = DECL_NAME (*y);
6005 resort_data.new_value (&d1, resort_data.cookie);
6006 resort_data.new_value (&d2, resort_data.cookie);
6013 /* Resort DECL_SORTED_FIELDS because pointers have been reordered. */
6016 resort_sorted_fields (void *obj,
6017 void * ARG_UNUSED (orig_obj),
6018 gt_pointer_operator new_value,
6021 struct sorted_fields_type *sf = (struct sorted_fields_type *) obj;
6022 resort_data.new_value = new_value;
6023 resort_data.cookie = cookie;
6024 qsort (&sf->elts[0], sf->len, sizeof (tree),
6025 resort_field_decl_cmp);
6028 /* Subroutine of c_parse_error.
6029 Return the result of concatenating LHS and RHS. RHS is really
6030 a string literal, its first character is indicated by RHS_START and
6031 RHS_SIZE is its length (including the terminating NUL character).
6033 The caller is responsible for deleting the returned pointer. */
6036 catenate_strings (const char *lhs, const char *rhs_start, int rhs_size)
6038 const int lhs_size = strlen (lhs);
6039 char *result = XNEWVEC (char, lhs_size + rhs_size);
6040 strncpy (result, lhs, lhs_size);
6041 strncpy (result + lhs_size, rhs_start, rhs_size);
6045 /* Issue the error given by GMSGID, indicating that it occurred before
6046 TOKEN, which had the associated VALUE. */
6049 c_parse_error (const char *gmsgid, enum cpp_ttype token, tree value)
6051 #define catenate_messages(M1, M2) catenate_strings ((M1), (M2), sizeof (M2))
6053 char *message = NULL;
6055 if (token == CPP_EOF)
6056 message = catenate_messages (gmsgid, " at end of input");
6057 else if (token == CPP_CHAR || token == CPP_WCHAR)
6059 unsigned int val = TREE_INT_CST_LOW (value);
6060 const char *const ell = (token == CPP_CHAR) ? "" : "L";
6061 if (val <= UCHAR_MAX && ISGRAPH (val))
6062 message = catenate_messages (gmsgid, " before %s'%c'");
6064 message = catenate_messages (gmsgid, " before %s'\\x%x'");
6066 error (message, ell, val);
6070 else if (token == CPP_STRING || token == CPP_WSTRING)
6071 message = catenate_messages (gmsgid, " before string constant");
6072 else if (token == CPP_NUMBER)
6073 message = catenate_messages (gmsgid, " before numeric constant");
6074 else if (token == CPP_NAME)
6076 message = catenate_messages (gmsgid, " before %qE");
6077 error (message, value);
6081 else if (token == CPP_PRAGMA)
6082 message = catenate_messages (gmsgid, " before %<#pragma%>");
6083 else if (token == CPP_PRAGMA_EOL)
6084 message = catenate_messages (gmsgid, " before end of line");
6085 else if (token < N_TTYPES)
6087 message = catenate_messages (gmsgid, " before %qs token");
6088 error (message, cpp_type2name (token));
6097 error (message, "");
6100 #undef catenate_messages
6103 /* Walk a gimplified function and warn for functions whose return value is
6104 ignored and attribute((warn_unused_result)) is set. This is done before
6105 inlining, so we don't have to worry about that. */
6108 c_warn_unused_result (tree *top_p)
6111 tree_stmt_iterator i;
6114 switch (TREE_CODE (t))
6116 case STATEMENT_LIST:
6117 for (i = tsi_start (*top_p); !tsi_end_p (i); tsi_next (&i))
6118 c_warn_unused_result (tsi_stmt_ptr (i));
6122 c_warn_unused_result (&COND_EXPR_THEN (t));
6123 c_warn_unused_result (&COND_EXPR_ELSE (t));
6126 c_warn_unused_result (&BIND_EXPR_BODY (t));
6128 case TRY_FINALLY_EXPR:
6129 case TRY_CATCH_EXPR:
6130 c_warn_unused_result (&TREE_OPERAND (t, 0));
6131 c_warn_unused_result (&TREE_OPERAND (t, 1));
6134 c_warn_unused_result (&CATCH_BODY (t));
6136 case EH_FILTER_EXPR:
6137 c_warn_unused_result (&EH_FILTER_FAILURE (t));
6144 /* This is a naked call, as opposed to a CALL_EXPR nested inside
6145 a MODIFY_EXPR. All calls whose value is ignored should be
6146 represented like this. Look for the attribute. */
6147 fdecl = get_callee_fndecl (t);
6149 ftype = TREE_TYPE (fdecl);
6152 ftype = TREE_TYPE (TREE_OPERAND (t, 0));
6153 /* Look past pointer-to-function to the function type itself. */
6154 ftype = TREE_TYPE (ftype);
6157 if (lookup_attribute ("warn_unused_result", TYPE_ATTRIBUTES (ftype)))
6160 warning (0, "%Hignoring return value of %qD, "
6161 "declared with attribute warn_unused_result",
6162 EXPR_LOCUS (t), fdecl);
6164 warning (0, "%Hignoring return value of function "
6165 "declared with attribute warn_unused_result",
6171 /* Not a container, not a call, or a call whose value is used. */
6176 /* Convert a character from the host to the target execution character
6177 set. cpplib handles this, mostly. */
6180 c_common_to_target_charset (HOST_WIDE_INT c)
6182 /* Character constants in GCC proper are sign-extended under -fsigned-char,
6183 zero-extended under -fno-signed-char. cpplib insists that characters
6184 and character constants are always unsigned. Hence we must convert
6186 cppchar_t uc = ((cppchar_t)c) & ((((cppchar_t)1) << CHAR_BIT)-1);
6188 uc = cpp_host_to_exec_charset (parse_in, uc);
6190 if (flag_signed_char)
6191 return ((HOST_WIDE_INT)uc) << (HOST_BITS_PER_WIDE_INT - CHAR_TYPE_SIZE)
6192 >> (HOST_BITS_PER_WIDE_INT - CHAR_TYPE_SIZE);
6197 /* Build the result of __builtin_offsetof. EXPR is a nested sequence of
6198 component references, with STOP_REF, or alternatively an INDIRECT_REF of
6199 NULL, at the bottom; much like the traditional rendering of offsetof as a
6200 macro. Returns the folded and properly cast result. */
6203 fold_offsetof_1 (tree expr, tree stop_ref)
6205 enum tree_code code = PLUS_EXPR;
6208 if (expr == stop_ref && TREE_CODE (expr) != ERROR_MARK)
6209 return size_zero_node;
6211 switch (TREE_CODE (expr))
6217 error ("cannot apply %<offsetof%> to static data member %qD", expr);
6218 return error_mark_node;
6221 error ("cannot apply %<offsetof%> when %<operator[]%> is overloaded");
6222 return error_mark_node;
6225 gcc_assert (integer_zerop (expr));
6226 return size_zero_node;
6230 base = fold_offsetof_1 (TREE_OPERAND (expr, 0), stop_ref);
6231 gcc_assert (base == error_mark_node || base == size_zero_node);
6235 base = fold_offsetof_1 (TREE_OPERAND (expr, 0), stop_ref);
6236 if (base == error_mark_node)
6239 t = TREE_OPERAND (expr, 1);
6240 if (DECL_C_BIT_FIELD (t))
6242 error ("attempt to take address of bit-field structure "
6244 return error_mark_node;
6246 off = size_binop (PLUS_EXPR, DECL_FIELD_OFFSET (t),
6247 size_int (tree_low_cst (DECL_FIELD_BIT_OFFSET (t), 1)
6252 base = fold_offsetof_1 (TREE_OPERAND (expr, 0), stop_ref);
6253 if (base == error_mark_node)
6256 t = TREE_OPERAND (expr, 1);
6257 if (TREE_CODE (t) == INTEGER_CST && tree_int_cst_sgn (t) < 0)
6260 t = fold_build1 (NEGATE_EXPR, TREE_TYPE (t), t);
6262 t = convert (sizetype, t);
6263 off = size_binop (MULT_EXPR, TYPE_SIZE_UNIT (TREE_TYPE (expr)), t);
6267 /* Handle static members of volatile structs. */
6268 t = TREE_OPERAND (expr, 1);
6269 gcc_assert (TREE_CODE (t) == VAR_DECL);
6270 return fold_offsetof_1 (t, stop_ref);
6276 return size_binop (code, base, off);
6280 fold_offsetof (tree expr, tree stop_ref)
6282 /* Convert back from the internal sizetype to size_t. */
6283 return convert (size_type_node, fold_offsetof_1 (expr, stop_ref));
6286 /* Print an error message for an invalid lvalue. USE says
6287 how the lvalue is being used and so selects the error message. */
6290 lvalue_error (enum lvalue_use use)
6295 error ("lvalue required as left operand of assignment");
6298 error ("lvalue required as increment operand");
6301 error ("lvalue required as decrement operand");
6304 error ("lvalue required as unary %<&%> operand");
6307 error ("lvalue required in asm statement");
6314 /* *PTYPE is an incomplete array. Complete it with a domain based on
6315 INITIAL_VALUE. If INITIAL_VALUE is not present, use 1 if DO_DEFAULT
6316 is true. Return 0 if successful, 1 if INITIAL_VALUE can't be deciphered,
6317 2 if INITIAL_VALUE was NULL, and 3 if INITIAL_VALUE was empty. */
6320 complete_array_type (tree *ptype, tree initial_value, bool do_default)
6322 tree maxindex, type, main_type, elt, unqual_elt;
6323 int failure = 0, quals;
6325 maxindex = size_zero_node;
6328 if (TREE_CODE (initial_value) == STRING_CST)
6331 = int_size_in_bytes (TREE_TYPE (TREE_TYPE (initial_value)));
6332 maxindex = size_int (TREE_STRING_LENGTH (initial_value)/eltsize - 1);
6334 else if (TREE_CODE (initial_value) == CONSTRUCTOR)
6336 VEC(constructor_elt,gc) *v = CONSTRUCTOR_ELTS (initial_value);
6338 if (VEC_empty (constructor_elt, v))
6342 maxindex = integer_minus_one_node;
6347 unsigned HOST_WIDE_INT cnt;
6348 constructor_elt *ce;
6350 if (VEC_index (constructor_elt, v, 0)->index)
6351 maxindex = fold_convert (sizetype,
6352 VEC_index (constructor_elt,
6354 curindex = maxindex;
6357 VEC_iterate (constructor_elt, v, cnt, ce);
6361 curindex = fold_convert (sizetype, ce->index);
6363 curindex = size_binop (PLUS_EXPR, curindex, size_one_node);
6365 if (tree_int_cst_lt (maxindex, curindex))
6366 maxindex = curindex;
6372 /* Make an error message unless that happened already. */
6373 if (initial_value != error_mark_node)
6385 elt = TREE_TYPE (type);
6386 quals = TYPE_QUALS (strip_array_types (elt));
6390 unqual_elt = c_build_qualified_type (elt, TYPE_UNQUALIFIED);
6392 /* Using build_distinct_type_copy and modifying things afterward instead
6393 of using build_array_type to create a new type preserves all of the
6394 TYPE_LANG_FLAG_? bits that the front end may have set. */
6395 main_type = build_distinct_type_copy (TYPE_MAIN_VARIANT (type));
6396 TREE_TYPE (main_type) = unqual_elt;
6397 TYPE_DOMAIN (main_type) = build_index_type (maxindex);
6398 layout_type (main_type);
6403 type = c_build_qualified_type (main_type, quals);
6410 /* Used to help initialize the builtin-types.def table. When a type of
6411 the correct size doesn't exist, use error_mark_node instead of NULL.
6412 The later results in segfaults even when a decl using the type doesn't
6416 builtin_type_for_size (int size, bool unsignedp)
6418 tree type = lang_hooks.types.type_for_size (size, unsignedp);
6419 return type ? type : error_mark_node;
6422 /* A helper function for resolve_overloaded_builtin in resolving the
6423 overloaded __sync_ builtins. Returns a positive power of 2 if the
6424 first operand of PARAMS is a pointer to a supported data type.
6425 Returns 0 if an error is encountered. */
6428 sync_resolve_size (tree function, tree params)
6435 error ("too few arguments to function %qE", function);
6439 type = TREE_TYPE (TREE_VALUE (params));
6440 if (TREE_CODE (type) != POINTER_TYPE)
6443 type = TREE_TYPE (type);
6444 if (!INTEGRAL_TYPE_P (type) && !POINTER_TYPE_P (type))
6447 size = tree_low_cst (TYPE_SIZE_UNIT (type), 1);
6448 if (size == 1 || size == 2 || size == 4 || size == 8 || size == 16)
6452 error ("incompatible type for argument %d of %qE", 1, function);
6456 /* A helper function for resolve_overloaded_builtin. Adds casts to
6457 PARAMS to make arguments match up with those of FUNCTION. Drops
6458 the variadic arguments at the end. Returns false if some error
6459 was encountered; true on success. */
6462 sync_resolve_params (tree orig_function, tree function, tree params)
6464 tree arg_types = TYPE_ARG_TYPES (TREE_TYPE (function));
6468 /* We've declared the implementation functions to use "volatile void *"
6469 as the pointer parameter, so we shouldn't get any complaints from the
6470 call to check_function_arguments what ever type the user used. */
6471 arg_types = TREE_CHAIN (arg_types);
6472 ptype = TREE_TYPE (TREE_TYPE (TREE_VALUE (params)));
6475 /* For the rest of the values, we need to cast these to FTYPE, so that we
6476 don't get warnings for passing pointer types, etc. */
6477 while (arg_types != void_list_node)
6481 params = TREE_CHAIN (params);
6484 error ("too few arguments to function %qE", orig_function);
6488 /* ??? Ideally for the first conversion we'd use convert_for_assignment
6489 so that we get warnings for anything that doesn't match the pointer
6490 type. This isn't portable across the C and C++ front ends atm. */
6491 val = TREE_VALUE (params);
6492 val = convert (ptype, val);
6493 val = convert (TREE_VALUE (arg_types), val);
6494 TREE_VALUE (params) = val;
6496 arg_types = TREE_CHAIN (arg_types);
6500 /* The definition of these primitives is variadic, with the remaining
6501 being "an optional list of variables protected by the memory barrier".
6502 No clue what that's supposed to mean, precisely, but we consider all
6503 call-clobbered variables to be protected so we're safe. */
6504 TREE_CHAIN (params) = NULL;
6509 /* A helper function for resolve_overloaded_builtin. Adds a cast to
6510 RESULT to make it match the type of the first pointer argument in
6514 sync_resolve_return (tree params, tree result)
6516 tree ptype = TREE_TYPE (TREE_TYPE (TREE_VALUE (params)));
6517 ptype = TYPE_MAIN_VARIANT (ptype);
6518 return convert (ptype, result);
6521 /* Some builtin functions are placeholders for other expressions. This
6522 function should be called immediately after parsing the call expression
6523 before surrounding code has committed to the type of the expression.
6525 FUNCTION is the DECL that has been invoked; it is known to be a builtin.
6526 PARAMS is the argument list for the call. The return value is non-null
6527 when expansion is complete, and null if normal processing should
6531 resolve_overloaded_builtin (tree function, tree params)
6533 enum built_in_function orig_code = DECL_FUNCTION_CODE (function);
6534 switch (DECL_BUILT_IN_CLASS (function))
6536 case BUILT_IN_NORMAL:
6539 if (targetm.resolve_overloaded_builtin)
6540 return targetm.resolve_overloaded_builtin (function, params);
6547 /* Handle BUILT_IN_NORMAL here. */
6550 case BUILT_IN_FETCH_AND_ADD_N:
6551 case BUILT_IN_FETCH_AND_SUB_N:
6552 case BUILT_IN_FETCH_AND_OR_N:
6553 case BUILT_IN_FETCH_AND_AND_N:
6554 case BUILT_IN_FETCH_AND_XOR_N:
6555 case BUILT_IN_FETCH_AND_NAND_N:
6556 case BUILT_IN_ADD_AND_FETCH_N:
6557 case BUILT_IN_SUB_AND_FETCH_N:
6558 case BUILT_IN_OR_AND_FETCH_N:
6559 case BUILT_IN_AND_AND_FETCH_N:
6560 case BUILT_IN_XOR_AND_FETCH_N:
6561 case BUILT_IN_NAND_AND_FETCH_N:
6562 case BUILT_IN_BOOL_COMPARE_AND_SWAP_N:
6563 case BUILT_IN_VAL_COMPARE_AND_SWAP_N:
6564 case BUILT_IN_LOCK_TEST_AND_SET_N:
6565 case BUILT_IN_LOCK_RELEASE_N:
6567 int n = sync_resolve_size (function, params);
6568 tree new_function, result;
6571 return error_mark_node;
6573 new_function = built_in_decls[orig_code + exact_log2 (n) + 1];
6574 if (!sync_resolve_params (function, new_function, params))
6575 return error_mark_node;
6577 result = build_function_call (new_function, params);
6578 if (orig_code != BUILT_IN_BOOL_COMPARE_AND_SWAP_N
6579 && orig_code != BUILT_IN_LOCK_RELEASE_N)
6580 result = sync_resolve_return (params, result);
6590 /* Ignoring their sign, return true if two scalar types are the same. */
6592 same_scalar_type_ignoring_signedness (tree t1, tree t2)
6594 enum tree_code c1 = TREE_CODE (t1), c2 = TREE_CODE (t2);
6596 gcc_assert ((c1 == INTEGER_TYPE || c1 == REAL_TYPE)
6597 && (c2 == INTEGER_TYPE || c2 == REAL_TYPE));
6599 /* Equality works here because c_common_signed_type uses
6600 TYPE_MAIN_VARIANT. */
6601 return lang_hooks.types.signed_type (t1)
6602 == lang_hooks.types.signed_type (t2);
6605 /* Check for missing format attributes on function pointers. LTYPE is
6606 the new type or left-hand side type. RTYPE is the old type or
6607 right-hand side type. Returns TRUE if LTYPE is missing the desired
6611 check_missing_format_attribute (tree ltype, tree rtype)
6613 tree const ttr = TREE_TYPE (rtype), ttl = TREE_TYPE (ltype);
6616 for (ra = TYPE_ATTRIBUTES (ttr); ra; ra = TREE_CHAIN (ra))
6617 if (is_attribute_p ("format", TREE_PURPOSE (ra)))
6622 for (la = TYPE_ATTRIBUTES (ttl); la; la = TREE_CHAIN (la))
6623 if (is_attribute_p ("format", TREE_PURPOSE (la)))
6631 /* Subscripting with type char is likely to lose on a machine where
6632 chars are signed. So warn on any machine, but optionally. Don't
6633 warn for unsigned char since that type is safe. Don't warn for
6634 signed char because anyone who uses that must have done so
6635 deliberately. Furthermore, we reduce the false positive load by
6636 warning only for non-constant value of type char. */
6639 warn_array_subscript_with_type_char (tree index)
6641 if (TYPE_MAIN_VARIANT (TREE_TYPE (index)) == char_type_node
6642 && TREE_CODE (index) != INTEGER_CST)
6643 warning (OPT_Wchar_subscripts, "array subscript has type %<char%>");
6646 /* Implement -Wparentheses for the unexpected C precedence rules, to
6647 cover cases like x + y << z which readers are likely to
6648 misinterpret. We have seen an expression in which CODE is a binary
6649 operator used to combine expressions headed by CODE_LEFT and
6650 CODE_RIGHT. CODE_LEFT and CODE_RIGHT may be ERROR_MARK, which
6651 means that that side of the expression was not formed using a
6652 binary operator, or it was enclosed in parentheses. */
6655 warn_about_parentheses (enum tree_code code, enum tree_code code_left,
6656 enum tree_code code_right)
6658 if (!warn_parentheses)
6661 if (code == LSHIFT_EXPR || code == RSHIFT_EXPR)
6663 if (code_left == PLUS_EXPR || code_left == MINUS_EXPR
6664 || code_right == PLUS_EXPR || code_right == MINUS_EXPR)
6665 warning (OPT_Wparentheses,
6666 "suggest parentheses around + or - inside shift");
6669 if (code == TRUTH_ORIF_EXPR)
6671 if (code_left == TRUTH_ANDIF_EXPR
6672 || code_right == TRUTH_ANDIF_EXPR)
6673 warning (OPT_Wparentheses,
6674 "suggest parentheses around && within ||");
6677 if (code == BIT_IOR_EXPR)
6679 if (code_left == BIT_AND_EXPR || code_left == BIT_XOR_EXPR
6680 || code_left == PLUS_EXPR || code_left == MINUS_EXPR
6681 || code_right == BIT_AND_EXPR || code_right == BIT_XOR_EXPR
6682 || code_right == PLUS_EXPR || code_right == MINUS_EXPR)
6683 warning (OPT_Wparentheses,
6684 "suggest parentheses around arithmetic in operand of |");
6685 /* Check cases like x|y==z */
6686 if (TREE_CODE_CLASS (code_left) == tcc_comparison
6687 || TREE_CODE_CLASS (code_right) == tcc_comparison)
6688 warning (OPT_Wparentheses,
6689 "suggest parentheses around comparison in operand of |");
6692 if (code == BIT_XOR_EXPR)
6694 if (code_left == BIT_AND_EXPR
6695 || code_left == PLUS_EXPR || code_left == MINUS_EXPR
6696 || code_right == BIT_AND_EXPR
6697 || code_right == PLUS_EXPR || code_right == MINUS_EXPR)
6698 warning (OPT_Wparentheses,
6699 "suggest parentheses around arithmetic in operand of ^");
6700 /* Check cases like x^y==z */
6701 if (TREE_CODE_CLASS (code_left) == tcc_comparison
6702 || TREE_CODE_CLASS (code_right) == tcc_comparison)
6703 warning (OPT_Wparentheses,
6704 "suggest parentheses around comparison in operand of ^");
6707 if (code == BIT_AND_EXPR)
6709 if (code_left == PLUS_EXPR || code_left == MINUS_EXPR
6710 || code_right == PLUS_EXPR || code_right == MINUS_EXPR)
6711 warning (OPT_Wparentheses,
6712 "suggest parentheses around + or - in operand of &");
6713 /* Check cases like x&y==z */
6714 if (TREE_CODE_CLASS (code_left) == tcc_comparison
6715 || TREE_CODE_CLASS (code_right) == tcc_comparison)
6716 warning (OPT_Wparentheses,
6717 "suggest parentheses around comparison in operand of &");
6720 /* Similarly, check for cases like 1<=i<=10 that are probably errors. */
6721 if (TREE_CODE_CLASS (code) == tcc_comparison
6722 && (TREE_CODE_CLASS (code_left) == tcc_comparison
6723 || TREE_CODE_CLASS (code_right) == tcc_comparison))
6724 warning (OPT_Wparentheses, "comparisons like X<=Y<=Z do not "
6725 "have their mathematical meaning");
6729 #include "gt-c-common.h"