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 *);
555 /* APPLE LOCAL radar 5932809 - copyable byref blocks */
556 static tree handle_blocks_attribute (tree *, tree, tree, int, bool *);
558 static void check_function_nonnull (tree, tree);
559 static void check_nonnull_arg (void *, tree, unsigned HOST_WIDE_INT);
560 static bool nonnull_check_p (tree, unsigned HOST_WIDE_INT);
561 static bool get_nonnull_operand (tree, unsigned HOST_WIDE_INT *);
562 static int resort_field_decl_cmp (const void *, const void *);
564 /* Table of machine-independent attributes common to all C-like languages. */
565 const struct attribute_spec c_common_attribute_table[] =
567 /* { name, min_len, max_len, decl_req, type_req, fn_type_req, handler } */
568 { "packed", 0, 0, false, false, false,
569 handle_packed_attribute },
570 { "nocommon", 0, 0, true, false, false,
571 handle_nocommon_attribute },
572 { "common", 0, 0, true, false, false,
573 handle_common_attribute },
574 /* FIXME: logically, noreturn attributes should be listed as
575 "false, true, true" and apply to function types. But implementing this
576 would require all the places in the compiler that use TREE_THIS_VOLATILE
577 on a decl to identify non-returning functions to be located and fixed
578 to check the function type instead. */
579 { "noreturn", 0, 0, true, false, false,
580 handle_noreturn_attribute },
581 { "volatile", 0, 0, true, false, false,
582 handle_noreturn_attribute },
583 { "noinline", 0, 0, true, false, false,
584 handle_noinline_attribute },
585 { "always_inline", 0, 0, true, false, false,
586 handle_always_inline_attribute },
587 { "gnu_inline", 0, 0, true, false, false,
588 handle_gnu_inline_attribute },
589 { "flatten", 0, 0, true, false, false,
590 handle_flatten_attribute },
591 { "used", 0, 0, true, false, false,
592 handle_used_attribute },
593 { "unused", 0, 0, false, false, false,
594 handle_unused_attribute },
595 { "externally_visible", 0, 0, true, false, false,
596 handle_externally_visible_attribute },
597 /* The same comments as for noreturn attributes apply to const ones. */
598 { "const", 0, 0, true, false, false,
599 handle_const_attribute },
600 { "transparent_union", 0, 0, false, false, false,
601 handle_transparent_union_attribute },
602 { "constructor", 0, 0, true, false, false,
603 handle_constructor_attribute },
604 { "destructor", 0, 0, true, false, false,
605 handle_destructor_attribute },
606 { "mode", 1, 1, false, true, false,
607 handle_mode_attribute },
608 { "section", 1, 1, true, false, false,
609 handle_section_attribute },
610 { "aligned", 0, 1, false, false, false,
611 handle_aligned_attribute },
612 /* APPLE LOCAL weak types 5954418 */
613 { "weak", 0, 0, false, false, false,
614 handle_weak_attribute },
615 { "alias", 1, 1, true, false, false,
616 handle_alias_attribute },
617 { "weakref", 0, 1, true, false, false,
618 handle_weakref_attribute },
619 { "no_instrument_function", 0, 0, true, false, false,
620 handle_no_instrument_function_attribute },
621 { "malloc", 0, 0, true, false, false,
622 handle_malloc_attribute },
623 { "returns_twice", 0, 0, true, false, false,
624 handle_returns_twice_attribute },
625 { "no_stack_limit", 0, 0, true, false, false,
626 handle_no_limit_stack_attribute },
627 { "pure", 0, 0, true, false, false,
628 handle_pure_attribute },
629 /* For internal use (marking of builtins) only. The name contains space
630 to prevent its usage in source code. */
631 { "no vops", 0, 0, true, false, false,
632 handle_novops_attribute },
633 { "deprecated", 0, 0, false, false, false,
634 handle_deprecated_attribute },
635 /* APPLE LOCAL begin "unavailable" attribute (Radar 2809697) --ilr */
636 { "unavailable", 0, 0, false, false, false,
637 handle_unavailable_attribute },
638 /* APPLE LOCAL end "unavailable" attribute --ilr */
639 { "vector_size", 1, 1, false, true, false,
640 handle_vector_size_attribute },
641 { "visibility", 1, 1, false, false, false,
642 handle_visibility_attribute },
643 { "tls_model", 1, 1, true, false, false,
644 handle_tls_model_attribute },
645 { "nonnull", 0, -1, false, true, true,
646 handle_nonnull_attribute },
647 { "nothrow", 0, 0, true, false, false,
648 handle_nothrow_attribute },
649 { "may_alias", 0, 0, false, true, false, NULL },
650 { "cleanup", 1, 1, true, false, false,
651 handle_cleanup_attribute },
652 { "warn_unused_result", 0, 0, false, true, true,
653 handle_warn_unused_result_attribute },
654 { "sentinel", 0, 1, false, true, true,
655 handle_sentinel_attribute },
656 /* APPLE LOCAL radar 5932809 - copyable byref blocks */
657 { "blocks", 1, 1, true, false, false, handle_blocks_attribute },
658 { NULL, 0, 0, false, false, false, NULL }
661 /* Give the specifications for the format attributes, used by C and all
664 const struct attribute_spec c_common_format_attribute_table[] =
666 /* { name, min_len, max_len, decl_req, type_req, fn_type_req, handler } */
667 { "format", 3, 3, false, true, true,
668 handle_format_attribute },
669 { "format_arg", 1, 1, false, true, true,
670 handle_format_arg_attribute },
671 { NULL, 0, 0, false, false, false, NULL }
674 /* Push current bindings for the function name VAR_DECLS. */
677 start_fname_decls (void)
680 tree saved = NULL_TREE;
682 for (ix = 0; fname_vars[ix].decl; ix++)
684 tree decl = *fname_vars[ix].decl;
688 saved = tree_cons (decl, build_int_cst (NULL_TREE, ix), saved);
689 *fname_vars[ix].decl = NULL_TREE;
692 if (saved || saved_function_name_decls)
693 /* Normally they'll have been NULL, so only push if we've got a
694 stack, or they are non-NULL. */
695 saved_function_name_decls = tree_cons (saved, NULL_TREE,
696 saved_function_name_decls);
699 /* Finish up the current bindings, adding them into the current function's
700 statement tree. This must be done _before_ finish_stmt_tree is called.
701 If there is no current function, we must be at file scope and no statements
702 are involved. Pop the previous bindings. */
705 finish_fname_decls (void)
708 tree stmts = NULL_TREE;
709 tree stack = saved_function_name_decls;
711 for (; stack && TREE_VALUE (stack); stack = TREE_CHAIN (stack))
712 append_to_statement_list (TREE_VALUE (stack), &stmts);
716 tree *bodyp = &DECL_SAVED_TREE (current_function_decl);
718 if (TREE_CODE (*bodyp) == BIND_EXPR)
719 bodyp = &BIND_EXPR_BODY (*bodyp);
721 append_to_statement_list_force (*bodyp, &stmts);
725 for (ix = 0; fname_vars[ix].decl; ix++)
726 *fname_vars[ix].decl = NULL_TREE;
730 /* We had saved values, restore them. */
733 for (saved = TREE_PURPOSE (stack); saved; saved = TREE_CHAIN (saved))
735 tree decl = TREE_PURPOSE (saved);
736 unsigned ix = TREE_INT_CST_LOW (TREE_VALUE (saved));
738 *fname_vars[ix].decl = decl;
740 stack = TREE_CHAIN (stack);
742 saved_function_name_decls = stack;
745 /* Return the text name of the current function, suitably prettified
746 by PRETTY_P. Return string must be freed by caller. */
749 fname_as_string (int pretty_p)
751 const char *name = "top level";
761 if (current_function_decl)
762 name = lang_hooks.decl_printable_name (current_function_decl, vrb);
764 if (c_lex_string_translate)
766 int len = strlen (name) + 3; /* Two for '"'s. One for NULL. */
767 cpp_string cstr = { 0, 0 }, strname;
769 namep = XNEWVEC (char, len);
770 snprintf (namep, len, "\"%s\"", name);
771 strname.text = (unsigned char *) namep;
772 strname.len = len - 1;
774 if (cpp_interpret_string (parse_in, &strname, 1, &cstr, false))
777 return (char *) cstr.text;
781 namep = xstrdup (name);
786 /* Expand DECL if it declares an entity not handled by the
790 c_expand_decl (tree decl)
792 if (TREE_CODE (decl) == VAR_DECL && !TREE_STATIC (decl))
794 /* Let the back-end know about this variable. */
795 if (!anon_aggr_type_p (TREE_TYPE (decl)))
796 emit_local_var (decl);
798 expand_anon_union_decl (decl, NULL_TREE,
799 DECL_ANON_UNION_ELEMS (decl));
808 /* Return the VAR_DECL for a const char array naming the current
809 function. If the VAR_DECL has not yet been created, create it
810 now. RID indicates how it should be formatted and IDENTIFIER_NODE
811 ID is its name (unfortunately C and C++ hold the RID values of
812 keywords in different places, so we can't derive RID from ID in
813 this language independent code. */
816 fname_decl (unsigned int rid, tree id)
819 tree decl = NULL_TREE;
821 for (ix = 0; fname_vars[ix].decl; ix++)
822 if (fname_vars[ix].rid == rid)
825 decl = *fname_vars[ix].decl;
828 /* If a tree is built here, it would normally have the lineno of
829 the current statement. Later this tree will be moved to the
830 beginning of the function and this line number will be wrong.
831 To avoid this problem set the lineno to 0 here; that prevents
832 it from appearing in the RTL. */
834 location_t saved_location = input_location;
835 #ifdef USE_MAPPED_LOCATION
836 input_location = UNKNOWN_LOCATION;
841 stmts = push_stmt_list ();
842 decl = (*make_fname_decl) (id, fname_vars[ix].pretty);
843 stmts = pop_stmt_list (stmts);
844 if (!IS_EMPTY_STMT (stmts))
845 saved_function_name_decls
846 = tree_cons (decl, stmts, saved_function_name_decls);
847 *fname_vars[ix].decl = decl;
848 input_location = saved_location;
850 if (!ix && !current_function_decl)
851 pedwarn ("%qD is not defined outside of function scope", decl);
856 /* Given a STRING_CST, give it a suitable array-of-chars data type. */
859 fix_string_type (tree value)
861 const int wchar_bytes = TYPE_PRECISION (wchar_type_node) / BITS_PER_UNIT;
862 const int wide_flag = TREE_TYPE (value) == wchar_array_type_node;
863 int length = TREE_STRING_LENGTH (value);
865 tree e_type, i_type, a_type;
867 /* Compute the number of elements, for the array type. */
868 nchars = wide_flag ? length / wchar_bytes : length;
870 /* C89 2.2.4.1, C99 5.2.4.1 (Translation limits). The analogous
871 limit in C++98 Annex B is very large (65536) and is not normative,
872 so we do not diagnose it (warn_overlength_strings is forced off
873 in c_common_post_options). */
874 if (warn_overlength_strings)
876 const int nchars_max = flag_isoc99 ? 4095 : 509;
877 const int relevant_std = flag_isoc99 ? 99 : 90;
878 if (nchars - 1 > nchars_max)
879 /* Translators: The %d after 'ISO C' will be 90 or 99. Do not
880 separate the %d from the 'C'. 'ISO' should not be
881 translated, but it may be moved after 'C%d' in languages
882 where modifiers follow nouns. */
883 pedwarn ("string length %qd is greater than the length %qd "
884 "ISO C%d compilers are required to support",
885 nchars - 1, nchars_max, relevant_std);
888 /* Create the array type for the string constant. The ISO C++
889 standard says that a string literal has type `const char[N]' or
890 `const wchar_t[N]'. We use the same logic when invoked as a C
891 front-end with -Wwrite-strings.
892 ??? We should change the type of an expression depending on the
893 state of a warning flag. We should just be warning -- see how
894 this is handled in the C++ front-end for the deprecated implicit
895 conversion from string literals to `char*' or `wchar_t*'.
897 The C++ front end relies on TYPE_MAIN_VARIANT of a cv-qualified
898 array type being the unqualified version of that type.
899 Therefore, if we are constructing an array of const char, we must
900 construct the matching unqualified array type first. The C front
901 end does not require this, but it does no harm, so we do it
903 e_type = wide_flag ? wchar_type_node : char_type_node;
904 i_type = build_index_type (build_int_cst (NULL_TREE, nchars - 1));
905 a_type = build_array_type (e_type, i_type);
906 if (c_dialect_cxx() || warn_write_strings)
907 a_type = c_build_qualified_type (a_type, TYPE_QUAL_CONST);
909 TREE_TYPE (value) = a_type;
910 TREE_CONSTANT (value) = 1;
911 TREE_INVARIANT (value) = 1;
912 TREE_READONLY (value) = 1;
913 TREE_STATIC (value) = 1;
917 /* Print a warning if a constant expression had overflow in folding.
918 Invoke this function on every expression that the language
919 requires to be a constant expression.
920 Note the ANSI C standard says it is erroneous for a
921 constant expression to overflow. */
924 constant_expression_warning (tree value)
926 if ((TREE_CODE (value) == INTEGER_CST || TREE_CODE (value) == REAL_CST
927 || TREE_CODE (value) == VECTOR_CST
928 || TREE_CODE (value) == COMPLEX_CST)
929 && TREE_CONSTANT_OVERFLOW (value)
932 pedwarn ("overflow in constant expression");
935 /* Print a warning if an expression had overflow in folding and its
938 Invoke this function on every expression that
939 (1) appears in the source code, and
940 (2) is a constant expression that overflowed, and
941 (3) is not already checked by convert_and_check;
942 however, do not invoke this function on operands of explicit casts
943 or when the expression is the result of an operator and any operand
944 already overflowed. */
947 overflow_warning (tree value)
949 if (skip_evaluation) return;
951 switch (TREE_CODE (value))
954 warning (OPT_Woverflow, "integer overflow in expression");
958 warning (OPT_Woverflow, "floating point overflow in expression");
962 warning (OPT_Woverflow, "vector overflow in expression");
966 if (TREE_CODE (TREE_REALPART (value)) == INTEGER_CST)
967 warning (OPT_Woverflow, "complex integer overflow in expression");
968 else if (TREE_CODE (TREE_REALPART (value)) == REAL_CST)
969 warning (OPT_Woverflow, "complex floating point overflow in expression");
977 /* Print a warning if a large constant is truncated to unsigned,
978 or if -Wconversion is used and a constant < 0 is converted to unsigned.
979 Invoke this function on every expression that might be implicitly
980 converted to an unsigned type. */
983 unsigned_conversion_warning (tree result, tree operand)
985 tree type = TREE_TYPE (result);
987 if (TREE_CODE (operand) == INTEGER_CST
988 && TREE_CODE (type) == INTEGER_TYPE
989 && TYPE_UNSIGNED (type)
990 && skip_evaluation == 0
991 && !int_fits_type_p (operand, type))
993 if (!int_fits_type_p (operand, c_common_signed_type (type)))
994 /* This detects cases like converting -129 or 256 to unsigned char. */
995 warning (OPT_Woverflow,
996 "large integer implicitly truncated to unsigned type");
998 warning (OPT_Wconversion,
999 "negative integer implicitly converted to unsigned type");
1003 /* Print a warning about casts that might indicate violation
1004 of strict aliasing rules if -Wstrict-aliasing is used and
1005 strict aliasing mode is in effect. OTYPE is the original
1006 TREE_TYPE of EXPR, and TYPE the type we're casting to. */
1009 strict_aliasing_warning (tree otype, tree type, tree expr)
1011 if (!(flag_strict_aliasing && POINTER_TYPE_P (type)
1012 && POINTER_TYPE_P (otype) && !VOID_TYPE_P (TREE_TYPE (type))))
1015 if ((warn_strict_aliasing > 1) && TREE_CODE (expr) == ADDR_EXPR
1016 && (DECL_P (TREE_OPERAND (expr, 0))
1017 || handled_component_p (TREE_OPERAND (expr, 0))))
1019 /* Casting the address of an object to non void pointer. Warn
1020 if the cast breaks type based aliasing. */
1021 if (!COMPLETE_TYPE_P (TREE_TYPE (type)) && warn_strict_aliasing == 2)
1023 warning (OPT_Wstrict_aliasing, "type-punning to incomplete type "
1024 "might break strict-aliasing rules");
1029 /* warn_strict_aliasing >= 3. This includes the default (3).
1030 Only warn if the cast is dereferenced immediately. */
1031 HOST_WIDE_INT set1 =
1032 get_alias_set (TREE_TYPE (TREE_OPERAND (expr, 0)));
1033 HOST_WIDE_INT set2 = get_alias_set (TREE_TYPE (type));
1035 if (!alias_sets_conflict_p (set1, set2))
1037 warning (OPT_Wstrict_aliasing, "dereferencing type-punned "
1038 "pointer will break strict-aliasing rules");
1041 else if (warn_strict_aliasing == 2
1042 && !alias_sets_might_conflict_p (set1, set2))
1044 warning (OPT_Wstrict_aliasing, "dereferencing type-punned "
1045 "pointer might break strict-aliasing rules");
1051 if ((warn_strict_aliasing == 1) && !VOID_TYPE_P (TREE_TYPE (otype)))
1053 /* At this level, warn for any conversions, even if an address is
1054 not taken in the same statement. This will likely produce many
1055 false positives, but could be useful to pinpoint problems that
1056 are not revealed at higher levels. */
1057 HOST_WIDE_INT set1 = get_alias_set (TREE_TYPE (otype));
1058 HOST_WIDE_INT set2 = get_alias_set (TREE_TYPE (type));
1059 if (!COMPLETE_TYPE_P(type)
1060 || !alias_sets_might_conflict_p (set1, set2))
1062 warning (OPT_Wstrict_aliasing, "dereferencing type-punned "
1063 "pointer might break strict-aliasing rules");
1072 /* Print a warning about if (); or if () .. else; constructs
1073 via the special empty statement node that we create. INNER_THEN
1074 and INNER_ELSE are the statement lists of the if and the else
1078 empty_body_warning (tree inner_then, tree inner_else)
1082 if (TREE_CODE (inner_then) == STATEMENT_LIST
1083 && STATEMENT_LIST_TAIL (inner_then))
1084 inner_then = STATEMENT_LIST_TAIL (inner_then)->stmt;
1086 if (inner_else && TREE_CODE (inner_else) == STATEMENT_LIST
1087 && STATEMENT_LIST_TAIL (inner_else))
1088 inner_else = STATEMENT_LIST_TAIL (inner_else)->stmt;
1090 if (IS_EMPTY_STMT (inner_then) && !inner_else)
1091 warning (OPT_Wextra, "%Hempty body in an if-statement",
1092 EXPR_LOCUS (inner_then));
1094 if (inner_else && IS_EMPTY_STMT (inner_else))
1095 warning (OPT_Wextra, "%Hempty body in an else-statement",
1096 EXPR_LOCUS (inner_else));
1101 /* Nonzero if constant C has a value that is permissible
1102 for type TYPE (an INTEGER_TYPE). */
1105 constant_fits_type_p (tree c, tree type)
1107 if (TREE_CODE (c) == INTEGER_CST)
1108 return int_fits_type_p (c, type);
1110 c = convert (type, c);
1111 return !TREE_OVERFLOW (c);
1115 /* True if vector types T1 and T2 can be converted to each other
1116 without an explicit cast. If EMIT_LAX_NOTE is true, and T1 and T2
1117 can only be converted with -flax-vector-conversions yet that is not
1118 in effect, emit a note telling the user about that option if such
1119 a note has not previously been emitted. */
1121 vector_types_convertible_p (tree t1, tree t2, bool emit_lax_note)
1123 static bool emitted_lax_note = false;
1124 bool convertible_lax;
1126 if ((targetm.vector_opaque_p (t1) || targetm.vector_opaque_p (t2))
1127 && tree_int_cst_equal (TYPE_SIZE (t1), TYPE_SIZE (t2)))
1131 (tree_int_cst_equal (TYPE_SIZE (t1), TYPE_SIZE (t2))
1132 && (TREE_CODE (TREE_TYPE (t1)) != REAL_TYPE ||
1133 TYPE_PRECISION (t1) == TYPE_PRECISION (t2))
1134 && (INTEGRAL_TYPE_P (TREE_TYPE (t1))
1135 == INTEGRAL_TYPE_P (TREE_TYPE (t2))));
1137 if (!convertible_lax || flag_lax_vector_conversions)
1138 return convertible_lax;
1140 if (TYPE_VECTOR_SUBPARTS (t1) == TYPE_VECTOR_SUBPARTS (t2)
1141 && comptypes (TREE_TYPE (t1), TREE_TYPE (t2)))
1144 if (emit_lax_note && !emitted_lax_note)
1146 emitted_lax_note = true;
1147 inform ("use -flax-vector-conversions to permit "
1148 "conversions between vectors with differing "
1149 "element types or numbers of subparts");
1155 /* Convert EXPR to TYPE, warning about conversion problems with constants.
1156 Invoke this function on every expression that is converted implicitly,
1157 i.e. because of language rules and not because of an explicit cast. */
1160 convert_and_check (tree type, tree expr)
1162 tree t = convert (type, expr);
1163 if (TREE_CODE (t) == INTEGER_CST)
1165 if (TREE_OVERFLOW (t))
1167 TREE_OVERFLOW (t) = 0;
1169 /* Do not diagnose overflow in a constant expression merely
1170 because a conversion overflowed. */
1171 TREE_CONSTANT_OVERFLOW (t) = CONSTANT_CLASS_P (expr)
1172 && TREE_CONSTANT_OVERFLOW (expr);
1174 /* No warning for converting 0x80000000 to int. */
1175 if (!(TYPE_UNSIGNED (type) < TYPE_UNSIGNED (TREE_TYPE (expr))
1176 && TREE_CODE (TREE_TYPE (expr)) == INTEGER_TYPE
1177 && TYPE_PRECISION (type) == TYPE_PRECISION (TREE_TYPE (expr))))
1178 /* If EXPR fits in the unsigned version of TYPE,
1179 don't warn unless pedantic. */
1181 || TYPE_UNSIGNED (type)
1182 || !constant_fits_type_p (expr,
1183 c_common_unsigned_type (type)))
1184 && skip_evaluation == 0)
1185 warning (OPT_Woverflow,
1186 "overflow in implicit constant conversion");
1189 unsigned_conversion_warning (t, expr);
1194 /* A node in a list that describes references to variables (EXPR), which are
1195 either read accesses if WRITER is zero, or write accesses, in which case
1196 WRITER is the parent of EXPR. */
1203 /* Used to implement a cache the results of a call to verify_tree. We only
1204 use this for SAVE_EXPRs. */
1207 struct tlist_cache *next;
1208 struct tlist *cache_before_sp;
1209 struct tlist *cache_after_sp;
1213 /* Obstack to use when allocating tlist structures, and corresponding
1215 static struct obstack tlist_obstack;
1216 static char *tlist_firstobj = 0;
1218 /* Keep track of the identifiers we've warned about, so we can avoid duplicate
1220 static struct tlist *warned_ids;
1221 /* SAVE_EXPRs need special treatment. We process them only once and then
1222 cache the results. */
1223 static struct tlist_cache *save_expr_cache;
1225 static void add_tlist (struct tlist **, struct tlist *, tree, int);
1226 static void merge_tlist (struct tlist **, struct tlist *, int);
1227 static void verify_tree (tree, struct tlist **, struct tlist **, tree);
1228 static int warning_candidate_p (tree);
1229 static void warn_for_collisions (struct tlist *);
1230 static void warn_for_collisions_1 (tree, tree, struct tlist *, int);
1231 static struct tlist *new_tlist (struct tlist *, tree, tree);
1233 /* Create a new struct tlist and fill in its fields. */
1234 static struct tlist *
1235 new_tlist (struct tlist *next, tree t, tree writer)
1238 l = XOBNEW (&tlist_obstack, struct tlist);
1245 /* Add duplicates of the nodes found in ADD to the list *TO. If EXCLUDE_WRITER
1246 is nonnull, we ignore any node we find which has a writer equal to it. */
1249 add_tlist (struct tlist **to, struct tlist *add, tree exclude_writer, int copy)
1253 struct tlist *next = add->next;
1256 if (!exclude_writer || add->writer != exclude_writer)
1257 *to = copy ? new_tlist (*to, add->expr, add->writer) : add;
1262 /* Merge the nodes of ADD into TO. This merging process is done so that for
1263 each variable that already exists in TO, no new node is added; however if
1264 there is a write access recorded in ADD, and an occurrence on TO is only
1265 a read access, then the occurrence in TO will be modified to record the
1269 merge_tlist (struct tlist **to, struct tlist *add, int copy)
1271 struct tlist **end = to;
1274 end = &(*end)->next;
1280 struct tlist *next = add->next;
1282 for (tmp2 = *to; tmp2; tmp2 = tmp2->next)
1283 if (tmp2->expr == add->expr)
1287 tmp2->writer = add->writer;
1291 *end = copy ? add : new_tlist (NULL, add->expr, add->writer);
1292 end = &(*end)->next;
1299 /* WRITTEN is a variable, WRITER is its parent. Warn if any of the variable
1300 references in list LIST conflict with it, excluding reads if ONLY writers
1304 warn_for_collisions_1 (tree written, tree writer, struct tlist *list,
1309 /* Avoid duplicate warnings. */
1310 for (tmp = warned_ids; tmp; tmp = tmp->next)
1311 if (tmp->expr == written)
1316 if (list->expr == written
1317 && list->writer != writer
1318 && (!only_writes || list->writer)
1319 && DECL_NAME (list->expr))
1321 warned_ids = new_tlist (warned_ids, written, NULL_TREE);
1322 warning (0, "operation on %qE may be undefined", list->expr);
1328 /* Given a list LIST of references to variables, find whether any of these
1329 can cause conflicts due to missing sequence points. */
1332 warn_for_collisions (struct tlist *list)
1336 for (tmp = list; tmp; tmp = tmp->next)
1339 warn_for_collisions_1 (tmp->expr, tmp->writer, list, 0);
1343 /* Return nonzero if X is a tree that can be verified by the sequence point
1346 warning_candidate_p (tree x)
1348 return TREE_CODE (x) == VAR_DECL || TREE_CODE (x) == PARM_DECL;
1351 /* Walk the tree X, and record accesses to variables. If X is written by the
1352 parent tree, WRITER is the parent.
1353 We store accesses in one of the two lists: PBEFORE_SP, and PNO_SP. If this
1354 expression or its only operand forces a sequence point, then everything up
1355 to the sequence point is stored in PBEFORE_SP. Everything else gets stored
1357 Once we return, we will have emitted warnings if any subexpression before
1358 such a sequence point could be undefined. On a higher level, however, the
1359 sequence point may not be relevant, and we'll merge the two lists.
1361 Example: (b++, a) + b;
1362 The call that processes the COMPOUND_EXPR will store the increment of B
1363 in PBEFORE_SP, and the use of A in PNO_SP. The higher-level call that
1364 processes the PLUS_EXPR will need to merge the two lists so that
1365 eventually, all accesses end up on the same list (and we'll warn about the
1366 unordered subexpressions b++ and b.
1368 A note on merging. If we modify the former example so that our expression
1371 care must be taken not simply to add all three expressions into the final
1372 PNO_SP list. The function merge_tlist takes care of that by merging the
1373 before-SP list of the COMPOUND_EXPR into its after-SP list in a special
1374 way, so that no more than one access to B is recorded. */
1377 verify_tree (tree x, struct tlist **pbefore_sp, struct tlist **pno_sp,
1380 struct tlist *tmp_before, *tmp_nosp, *tmp_list2, *tmp_list3;
1381 enum tree_code code;
1382 enum tree_code_class cl;
1384 /* X may be NULL if it is the operand of an empty statement expression
1390 code = TREE_CODE (x);
1391 cl = TREE_CODE_CLASS (code);
1393 if (warning_candidate_p (x))
1395 *pno_sp = new_tlist (*pno_sp, x, writer);
1405 case TRUTH_ANDIF_EXPR:
1406 case TRUTH_ORIF_EXPR:
1407 tmp_before = tmp_nosp = tmp_list3 = 0;
1408 verify_tree (TREE_OPERAND (x, 0), &tmp_before, &tmp_nosp, NULL_TREE);
1409 warn_for_collisions (tmp_nosp);
1410 merge_tlist (pbefore_sp, tmp_before, 0);
1411 merge_tlist (pbefore_sp, tmp_nosp, 0);
1412 verify_tree (TREE_OPERAND (x, 1), &tmp_list3, pno_sp, NULL_TREE);
1413 merge_tlist (pbefore_sp, tmp_list3, 0);
1417 tmp_before = tmp_list2 = 0;
1418 verify_tree (TREE_OPERAND (x, 0), &tmp_before, &tmp_list2, NULL_TREE);
1419 warn_for_collisions (tmp_list2);
1420 merge_tlist (pbefore_sp, tmp_before, 0);
1421 merge_tlist (pbefore_sp, tmp_list2, 1);
1423 tmp_list3 = tmp_nosp = 0;
1424 verify_tree (TREE_OPERAND (x, 1), &tmp_list3, &tmp_nosp, NULL_TREE);
1425 warn_for_collisions (tmp_nosp);
1426 merge_tlist (pbefore_sp, tmp_list3, 0);
1428 tmp_list3 = tmp_list2 = 0;
1429 verify_tree (TREE_OPERAND (x, 2), &tmp_list3, &tmp_list2, NULL_TREE);
1430 warn_for_collisions (tmp_list2);
1431 merge_tlist (pbefore_sp, tmp_list3, 0);
1432 /* Rather than add both tmp_nosp and tmp_list2, we have to merge the
1433 two first, to avoid warning for (a ? b++ : b++). */
1434 merge_tlist (&tmp_nosp, tmp_list2, 0);
1435 add_tlist (pno_sp, tmp_nosp, NULL_TREE, 0);
1438 case PREDECREMENT_EXPR:
1439 case PREINCREMENT_EXPR:
1440 case POSTDECREMENT_EXPR:
1441 case POSTINCREMENT_EXPR:
1442 verify_tree (TREE_OPERAND (x, 0), pno_sp, pno_sp, x);
1446 tmp_before = tmp_nosp = tmp_list3 = 0;
1447 verify_tree (TREE_OPERAND (x, 1), &tmp_before, &tmp_nosp, NULL_TREE);
1448 verify_tree (TREE_OPERAND (x, 0), &tmp_list3, &tmp_list3, x);
1449 /* Expressions inside the LHS are not ordered wrt. the sequence points
1450 in the RHS. Example:
1452 Despite the fact that the modification of "a" is in the before_sp
1453 list (tmp_before), it conflicts with the use of "a" in the LHS.
1454 We can handle this by adding the contents of tmp_list3
1455 to those of tmp_before, and redoing the collision warnings for that
1457 add_tlist (&tmp_before, tmp_list3, x, 1);
1458 warn_for_collisions (tmp_before);
1459 /* Exclude the LHS itself here; we first have to merge it into the
1460 tmp_nosp list. This is done to avoid warning for "a = a"; if we
1461 didn't exclude the LHS, we'd get it twice, once as a read and once
1463 add_tlist (pno_sp, tmp_list3, x, 0);
1464 warn_for_collisions_1 (TREE_OPERAND (x, 0), x, tmp_nosp, 1);
1466 merge_tlist (pbefore_sp, tmp_before, 0);
1467 if (warning_candidate_p (TREE_OPERAND (x, 0)))
1468 merge_tlist (&tmp_nosp, new_tlist (NULL, TREE_OPERAND (x, 0), x), 0);
1469 add_tlist (pno_sp, tmp_nosp, NULL_TREE, 1);
1473 /* We need to warn about conflicts among arguments and conflicts between
1474 args and the function address. Side effects of the function address,
1475 however, are not ordered by the sequence point of the call. */
1476 tmp_before = tmp_nosp = tmp_list2 = tmp_list3 = 0;
1477 verify_tree (TREE_OPERAND (x, 0), &tmp_before, &tmp_nosp, NULL_TREE);
1478 if (TREE_OPERAND (x, 1))
1479 verify_tree (TREE_OPERAND (x, 1), &tmp_list2, &tmp_list3, NULL_TREE);
1480 merge_tlist (&tmp_list3, tmp_list2, 0);
1481 add_tlist (&tmp_before, tmp_list3, NULL_TREE, 0);
1482 add_tlist (&tmp_before, tmp_nosp, NULL_TREE, 0);
1483 warn_for_collisions (tmp_before);
1484 add_tlist (pbefore_sp, tmp_before, NULL_TREE, 0);
1488 /* Scan all the list, e.g. indices of multi dimensional array. */
1491 tmp_before = tmp_nosp = 0;
1492 verify_tree (TREE_VALUE (x), &tmp_before, &tmp_nosp, NULL_TREE);
1493 merge_tlist (&tmp_nosp, tmp_before, 0);
1494 add_tlist (pno_sp, tmp_nosp, NULL_TREE, 0);
1501 struct tlist_cache *t;
1502 for (t = save_expr_cache; t; t = t->next)
1508 t = XOBNEW (&tlist_obstack, struct tlist_cache);
1509 t->next = save_expr_cache;
1511 save_expr_cache = t;
1513 tmp_before = tmp_nosp = 0;
1514 verify_tree (TREE_OPERAND (x, 0), &tmp_before, &tmp_nosp, NULL_TREE);
1515 warn_for_collisions (tmp_nosp);
1520 struct tlist *t = tmp_nosp;
1522 merge_tlist (&tmp_list3, t, 0);
1524 t->cache_before_sp = tmp_before;
1525 t->cache_after_sp = tmp_list3;
1527 merge_tlist (pbefore_sp, t->cache_before_sp, 1);
1528 add_tlist (pno_sp, t->cache_after_sp, NULL_TREE, 1);
1533 /* For other expressions, simply recurse on their operands.
1534 Manual tail recursion for unary expressions.
1535 Other non-expressions need not be processed. */
1536 if (cl == tcc_unary)
1538 x = TREE_OPERAND (x, 0);
1542 else if (IS_EXPR_CODE_CLASS (cl))
1545 int max = TREE_CODE_LENGTH (TREE_CODE (x));
1546 for (lp = 0; lp < max; lp++)
1548 tmp_before = tmp_nosp = 0;
1549 verify_tree (TREE_OPERAND (x, lp), &tmp_before, &tmp_nosp, 0);
1550 merge_tlist (&tmp_nosp, tmp_before, 0);
1551 add_tlist (pno_sp, tmp_nosp, NULL_TREE, 0);
1558 /* Try to warn for undefined behavior in EXPR due to missing sequence
1562 verify_sequence_points (tree expr)
1564 struct tlist *before_sp = 0, *after_sp = 0;
1567 save_expr_cache = 0;
1568 if (tlist_firstobj == 0)
1570 gcc_obstack_init (&tlist_obstack);
1571 tlist_firstobj = (char *) obstack_alloc (&tlist_obstack, 0);
1574 verify_tree (expr, &before_sp, &after_sp, 0);
1575 warn_for_collisions (after_sp);
1576 obstack_free (&tlist_obstack, tlist_firstobj);
1579 /* Validate the expression after `case' and apply default promotions. */
1582 check_case_value (tree value)
1584 if (value == NULL_TREE)
1587 /* ??? Can we ever get nops here for a valid case value? We
1589 STRIP_TYPE_NOPS (value);
1590 /* In C++, the following is allowed:
1593 switch (...) { case i: ... }
1595 So, we try to reduce the VALUE to a constant that way. */
1596 if (c_dialect_cxx ())
1598 value = decl_constant_value (value);
1599 STRIP_TYPE_NOPS (value);
1600 value = fold (value);
1603 if (TREE_CODE (value) == INTEGER_CST)
1604 /* Promote char or short to int. */
1605 value = perform_integral_promotions (value);
1606 else if (value != error_mark_node)
1608 error ("case label does not reduce to an integer constant");
1609 value = error_mark_node;
1612 constant_expression_warning (value);
1617 /* See if the case values LOW and HIGH are in the range of the original
1618 type (i.e. before the default conversion to int) of the switch testing
1620 TYPE is the promoted type of the testing expression, and ORIG_TYPE is
1621 the type before promoting it. CASE_LOW_P is a pointer to the lower
1622 bound of the case label, and CASE_HIGH_P is the upper bound or NULL
1623 if the case is not a case range.
1624 The caller has to make sure that we are not called with NULL for
1625 CASE_LOW_P (i.e. the default case).
1626 Returns true if the case label is in range of ORIG_TYPE (saturated or
1627 untouched) or false if the label is out of range. */
1630 check_case_bounds (tree type, tree orig_type,
1631 tree *case_low_p, tree *case_high_p)
1633 tree min_value, max_value;
1634 tree case_low = *case_low_p;
1635 tree case_high = case_high_p ? *case_high_p : case_low;
1637 /* If there was a problem with the original type, do nothing. */
1638 if (orig_type == error_mark_node)
1641 min_value = TYPE_MIN_VALUE (orig_type);
1642 max_value = TYPE_MAX_VALUE (orig_type);
1644 /* Case label is less than minimum for type. */
1645 if (tree_int_cst_compare (case_low, min_value) < 0
1646 && tree_int_cst_compare (case_high, min_value) < 0)
1648 warning (0, "case label value is less than minimum value for type");
1652 /* Case value is greater than maximum for type. */
1653 if (tree_int_cst_compare (case_low, max_value) > 0
1654 && tree_int_cst_compare (case_high, max_value) > 0)
1656 warning (0, "case label value exceeds maximum value for type");
1660 /* Saturate lower case label value to minimum. */
1661 if (tree_int_cst_compare (case_high, min_value) >= 0
1662 && tree_int_cst_compare (case_low, min_value) < 0)
1664 warning (0, "lower value in case label range"
1665 " less than minimum value for type");
1666 case_low = min_value;
1669 /* Saturate upper case label value to maximum. */
1670 if (tree_int_cst_compare (case_low, max_value) <= 0
1671 && tree_int_cst_compare (case_high, max_value) > 0)
1673 warning (0, "upper value in case label range"
1674 " exceeds maximum value for type");
1675 case_high = max_value;
1678 if (*case_low_p != case_low)
1679 *case_low_p = convert (type, case_low);
1680 if (case_high_p && *case_high_p != case_high)
1681 *case_high_p = convert (type, case_high);
1686 /* Return an integer type with BITS bits of precision,
1687 that is unsigned if UNSIGNEDP is nonzero, otherwise signed. */
1690 c_common_type_for_size (unsigned int bits, int unsignedp)
1692 if (bits == TYPE_PRECISION (integer_type_node))
1693 return unsignedp ? unsigned_type_node : integer_type_node;
1695 if (bits == TYPE_PRECISION (signed_char_type_node))
1696 return unsignedp ? unsigned_char_type_node : signed_char_type_node;
1698 if (bits == TYPE_PRECISION (short_integer_type_node))
1699 return unsignedp ? short_unsigned_type_node : short_integer_type_node;
1701 if (bits == TYPE_PRECISION (long_integer_type_node))
1702 return unsignedp ? long_unsigned_type_node : long_integer_type_node;
1704 if (bits == TYPE_PRECISION (long_long_integer_type_node))
1705 return (unsignedp ? long_long_unsigned_type_node
1706 : long_long_integer_type_node);
1708 if (bits == TYPE_PRECISION (widest_integer_literal_type_node))
1709 return (unsignedp ? widest_unsigned_literal_type_node
1710 : widest_integer_literal_type_node);
1712 if (bits <= TYPE_PRECISION (intQI_type_node))
1713 return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
1715 if (bits <= TYPE_PRECISION (intHI_type_node))
1716 return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
1718 if (bits <= TYPE_PRECISION (intSI_type_node))
1719 return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
1721 if (bits <= TYPE_PRECISION (intDI_type_node))
1722 return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
1727 /* Used for communication between c_common_type_for_mode and
1728 c_register_builtin_type. */
1729 static GTY(()) tree registered_builtin_types;
1731 /* Return a data type that has machine mode MODE.
1732 If the mode is an integer,
1733 then UNSIGNEDP selects between signed and unsigned types. */
1736 c_common_type_for_mode (enum machine_mode mode, int unsignedp)
1740 if (mode == TYPE_MODE (integer_type_node))
1741 return unsignedp ? unsigned_type_node : integer_type_node;
1743 if (mode == TYPE_MODE (signed_char_type_node))
1744 return unsignedp ? unsigned_char_type_node : signed_char_type_node;
1746 if (mode == TYPE_MODE (short_integer_type_node))
1747 return unsignedp ? short_unsigned_type_node : short_integer_type_node;
1749 if (mode == TYPE_MODE (long_integer_type_node))
1750 return unsignedp ? long_unsigned_type_node : long_integer_type_node;
1752 if (mode == TYPE_MODE (long_long_integer_type_node))
1753 return unsignedp ? long_long_unsigned_type_node : long_long_integer_type_node;
1755 if (mode == TYPE_MODE (widest_integer_literal_type_node))
1756 return unsignedp ? widest_unsigned_literal_type_node
1757 : widest_integer_literal_type_node;
1760 return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
1763 return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
1766 return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
1769 return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
1771 #if HOST_BITS_PER_WIDE_INT >= 64
1772 if (mode == TYPE_MODE (intTI_type_node))
1773 return unsignedp ? unsigned_intTI_type_node : intTI_type_node;
1776 if (mode == TYPE_MODE (float_type_node))
1777 return float_type_node;
1779 if (mode == TYPE_MODE (double_type_node))
1780 return double_type_node;
1782 if (mode == TYPE_MODE (long_double_type_node))
1783 return long_double_type_node;
1785 if (mode == TYPE_MODE (void_type_node))
1786 return void_type_node;
1788 if (mode == TYPE_MODE (build_pointer_type (char_type_node)))
1790 ? make_unsigned_type (GET_MODE_PRECISION (mode))
1791 : make_signed_type (GET_MODE_PRECISION (mode)));
1793 if (mode == TYPE_MODE (build_pointer_type (integer_type_node)))
1795 ? make_unsigned_type (GET_MODE_PRECISION (mode))
1796 : make_signed_type (GET_MODE_PRECISION (mode)));
1798 if (COMPLEX_MODE_P (mode))
1800 enum machine_mode inner_mode;
1803 if (mode == TYPE_MODE (complex_float_type_node))
1804 return complex_float_type_node;
1805 if (mode == TYPE_MODE (complex_double_type_node))
1806 return complex_double_type_node;
1807 if (mode == TYPE_MODE (complex_long_double_type_node))
1808 return complex_long_double_type_node;
1810 if (mode == TYPE_MODE (complex_integer_type_node) && !unsignedp)
1811 return complex_integer_type_node;
1813 inner_mode = GET_MODE_INNER (mode);
1814 inner_type = c_common_type_for_mode (inner_mode, unsignedp);
1815 if (inner_type != NULL_TREE)
1816 return build_complex_type (inner_type);
1818 else if (VECTOR_MODE_P (mode))
1820 enum machine_mode inner_mode = GET_MODE_INNER (mode);
1821 tree inner_type = c_common_type_for_mode (inner_mode, unsignedp);
1822 if (inner_type != NULL_TREE)
1823 return build_vector_type_for_mode (inner_type, mode);
1826 if (mode == TYPE_MODE (dfloat32_type_node))
1827 return dfloat32_type_node;
1828 if (mode == TYPE_MODE (dfloat64_type_node))
1829 return dfloat64_type_node;
1830 if (mode == TYPE_MODE (dfloat128_type_node))
1831 return dfloat128_type_node;
1833 for (t = registered_builtin_types; t; t = TREE_CHAIN (t))
1834 if (TYPE_MODE (TREE_VALUE (t)) == mode)
1835 return TREE_VALUE (t);
1840 /* Return an unsigned type the same as TYPE in other respects. */
1842 c_common_unsigned_type (tree type)
1844 tree type1 = TYPE_MAIN_VARIANT (type);
1845 if (type1 == signed_char_type_node || type1 == char_type_node)
1846 return unsigned_char_type_node;
1847 if (type1 == integer_type_node)
1848 return unsigned_type_node;
1849 if (type1 == short_integer_type_node)
1850 return short_unsigned_type_node;
1851 if (type1 == long_integer_type_node)
1852 return long_unsigned_type_node;
1853 if (type1 == long_long_integer_type_node)
1854 return long_long_unsigned_type_node;
1855 if (type1 == widest_integer_literal_type_node)
1856 return widest_unsigned_literal_type_node;
1857 #if HOST_BITS_PER_WIDE_INT >= 64
1858 if (type1 == intTI_type_node)
1859 return unsigned_intTI_type_node;
1861 if (type1 == intDI_type_node)
1862 return unsigned_intDI_type_node;
1863 if (type1 == intSI_type_node)
1864 return unsigned_intSI_type_node;
1865 if (type1 == intHI_type_node)
1866 return unsigned_intHI_type_node;
1867 if (type1 == intQI_type_node)
1868 return unsigned_intQI_type_node;
1870 return c_common_signed_or_unsigned_type (1, type);
1873 /* Return a signed type the same as TYPE in other respects. */
1876 c_common_signed_type (tree type)
1878 tree type1 = TYPE_MAIN_VARIANT (type);
1879 if (type1 == unsigned_char_type_node || type1 == char_type_node)
1880 return signed_char_type_node;
1881 if (type1 == unsigned_type_node)
1882 return integer_type_node;
1883 if (type1 == short_unsigned_type_node)
1884 return short_integer_type_node;
1885 if (type1 == long_unsigned_type_node)
1886 return long_integer_type_node;
1887 if (type1 == long_long_unsigned_type_node)
1888 return long_long_integer_type_node;
1889 if (type1 == widest_unsigned_literal_type_node)
1890 return widest_integer_literal_type_node;
1891 #if HOST_BITS_PER_WIDE_INT >= 64
1892 if (type1 == unsigned_intTI_type_node)
1893 return intTI_type_node;
1895 if (type1 == unsigned_intDI_type_node)
1896 return intDI_type_node;
1897 if (type1 == unsigned_intSI_type_node)
1898 return intSI_type_node;
1899 if (type1 == unsigned_intHI_type_node)
1900 return intHI_type_node;
1901 if (type1 == unsigned_intQI_type_node)
1902 return intQI_type_node;
1904 return c_common_signed_or_unsigned_type (0, type);
1907 /* Return a type the same as TYPE except unsigned or
1908 signed according to UNSIGNEDP. */
1911 c_common_signed_or_unsigned_type (int unsignedp, tree type)
1913 if (!INTEGRAL_TYPE_P (type)
1914 || TYPE_UNSIGNED (type) == unsignedp)
1917 /* For ENUMERAL_TYPEs in C++, must check the mode of the types, not
1918 the precision; they have precision set to match their range, but
1919 may use a wider mode to match an ABI. If we change modes, we may
1920 wind up with bad conversions. For INTEGER_TYPEs in C, must check
1921 the precision as well, so as to yield correct results for
1922 bit-field types. C++ does not have these separate bit-field
1923 types, and producing a signed or unsigned variant of an
1924 ENUMERAL_TYPE may cause other problems as well. */
1926 #define TYPE_OK(node) \
1927 (TYPE_MODE (type) == TYPE_MODE (node) \
1928 && (c_dialect_cxx () || TYPE_PRECISION (type) == TYPE_PRECISION (node)))
1929 if (TYPE_OK (signed_char_type_node))
1930 return unsignedp ? unsigned_char_type_node : signed_char_type_node;
1931 if (TYPE_OK (integer_type_node))
1932 return unsignedp ? unsigned_type_node : integer_type_node;
1933 if (TYPE_OK (short_integer_type_node))
1934 return unsignedp ? short_unsigned_type_node : short_integer_type_node;
1935 if (TYPE_OK (long_integer_type_node))
1936 return unsignedp ? long_unsigned_type_node : long_integer_type_node;
1937 if (TYPE_OK (long_long_integer_type_node))
1938 return (unsignedp ? long_long_unsigned_type_node
1939 : long_long_integer_type_node);
1940 if (TYPE_OK (widest_integer_literal_type_node))
1941 return (unsignedp ? widest_unsigned_literal_type_node
1942 : widest_integer_literal_type_node);
1944 #if HOST_BITS_PER_WIDE_INT >= 64
1945 if (TYPE_OK (intTI_type_node))
1946 return unsignedp ? unsigned_intTI_type_node : intTI_type_node;
1948 if (TYPE_OK (intDI_type_node))
1949 return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
1950 if (TYPE_OK (intSI_type_node))
1951 return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
1952 if (TYPE_OK (intHI_type_node))
1953 return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
1954 if (TYPE_OK (intQI_type_node))
1955 return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
1958 if (c_dialect_cxx ())
1961 return build_nonstandard_integer_type (TYPE_PRECISION (type), unsignedp);
1964 /* Build a bit-field integer type for the given WIDTH and UNSIGNEDP. */
1967 c_build_bitfield_integer_type (unsigned HOST_WIDE_INT width, int unsignedp)
1969 /* Extended integer types of the same width as a standard type have
1970 lesser rank, so those of the same width as int promote to int or
1971 unsigned int and are valid for printf formats expecting int or
1972 unsigned int. To avoid such special cases, avoid creating
1973 extended integer types for bit-fields if a standard integer type
1975 if (width == TYPE_PRECISION (integer_type_node))
1976 return unsignedp ? unsigned_type_node : integer_type_node;
1977 if (width == TYPE_PRECISION (signed_char_type_node))
1978 return unsignedp ? unsigned_char_type_node : signed_char_type_node;
1979 if (width == TYPE_PRECISION (short_integer_type_node))
1980 return unsignedp ? short_unsigned_type_node : short_integer_type_node;
1981 if (width == TYPE_PRECISION (long_integer_type_node))
1982 return unsignedp ? long_unsigned_type_node : long_integer_type_node;
1983 if (width == TYPE_PRECISION (long_long_integer_type_node))
1984 return (unsignedp ? long_long_unsigned_type_node
1985 : long_long_integer_type_node);
1986 return build_nonstandard_integer_type (width, unsignedp);
1989 /* The C version of the register_builtin_type langhook. */
1992 c_register_builtin_type (tree type, const char* name)
1996 decl = build_decl (TYPE_DECL, get_identifier (name), type);
1997 DECL_ARTIFICIAL (decl) = 1;
1998 if (!TYPE_NAME (type))
1999 TYPE_NAME (type) = decl;
2002 registered_builtin_types = tree_cons (0, type, registered_builtin_types);
2006 /* Return the minimum number of bits needed to represent VALUE in a
2007 signed or unsigned type, UNSIGNEDP says which. */
2010 min_precision (tree value, int unsignedp)
2014 /* If the value is negative, compute its negative minus 1. The latter
2015 adjustment is because the absolute value of the largest negative value
2016 is one larger than the largest positive value. This is equivalent to
2017 a bit-wise negation, so use that operation instead. */
2019 if (tree_int_cst_sgn (value) < 0)
2020 value = fold_build1 (BIT_NOT_EXPR, TREE_TYPE (value), value);
2022 /* Return the number of bits needed, taking into account the fact
2023 that we need one more bit for a signed than unsigned type. */
2025 if (integer_zerop (value))
2028 log = tree_floor_log2 (value);
2030 return log + 1 + !unsignedp;
2033 /* Print an error message for invalid operands to arith operation
2034 CODE with TYPE0 for operand 0, and TYPE1 for operand 1. */
2037 binary_op_error (enum tree_code code, tree type0, tree type1)
2044 opname = "+"; break;
2046 opname = "-"; break;
2048 opname = "*"; break;
2050 opname = "max"; break;
2052 opname = "min"; break;
2054 opname = "=="; break;
2056 opname = "!="; break;
2058 opname = "<="; break;
2060 opname = ">="; break;
2062 opname = "<"; break;
2064 opname = ">"; break;
2066 opname = "<<"; break;
2068 opname = ">>"; break;
2069 case TRUNC_MOD_EXPR:
2070 case FLOOR_MOD_EXPR:
2071 opname = "%"; break;
2072 case TRUNC_DIV_EXPR:
2073 case FLOOR_DIV_EXPR:
2074 opname = "/"; break;
2076 opname = "&"; break;
2078 opname = "|"; break;
2079 case TRUTH_ANDIF_EXPR:
2080 opname = "&&"; break;
2081 case TRUTH_ORIF_EXPR:
2082 opname = "||"; break;
2084 opname = "^"; break;
2088 error ("invalid operands to binary %s (have %qT and %qT)", opname,
2092 /* Subroutine of build_binary_op, used for comparison operations.
2093 See if the operands have both been converted from subword integer types
2094 and, if so, perhaps change them both back to their original type.
2095 This function is also responsible for converting the two operands
2096 to the proper common type for comparison.
2098 The arguments of this function are all pointers to local variables
2099 of build_binary_op: OP0_PTR is &OP0, OP1_PTR is &OP1,
2100 RESTYPE_PTR is &RESULT_TYPE and RESCODE_PTR is &RESULTCODE.
2102 If this function returns nonzero, it means that the comparison has
2103 a constant value. What this function returns is an expression for
2107 shorten_compare (tree *op0_ptr, tree *op1_ptr, tree *restype_ptr,
2108 enum tree_code *rescode_ptr)
2111 tree op0 = *op0_ptr;
2112 tree op1 = *op1_ptr;
2113 int unsignedp0, unsignedp1;
2115 tree primop0, primop1;
2116 enum tree_code code = *rescode_ptr;
2118 /* Throw away any conversions to wider types
2119 already present in the operands. */
2121 primop0 = get_narrower (op0, &unsignedp0);
2122 primop1 = get_narrower (op1, &unsignedp1);
2124 /* Handle the case that OP0 does not *contain* a conversion
2125 but it *requires* conversion to FINAL_TYPE. */
2127 if (op0 == primop0 && TREE_TYPE (op0) != *restype_ptr)
2128 unsignedp0 = TYPE_UNSIGNED (TREE_TYPE (op0));
2129 if (op1 == primop1 && TREE_TYPE (op1) != *restype_ptr)
2130 unsignedp1 = TYPE_UNSIGNED (TREE_TYPE (op1));
2132 /* If one of the operands must be floated, we cannot optimize. */
2133 real1 = TREE_CODE (TREE_TYPE (primop0)) == REAL_TYPE;
2134 real2 = TREE_CODE (TREE_TYPE (primop1)) == REAL_TYPE;
2136 /* If first arg is constant, swap the args (changing operation
2137 so value is preserved), for canonicalization. Don't do this if
2138 the second arg is 0. */
2140 if (TREE_CONSTANT (primop0)
2141 && !integer_zerop (primop1) && !real_zerop (primop1))
2144 int temi = unsignedp0;
2152 unsignedp0 = unsignedp1;
2175 *rescode_ptr = code;
2178 /* If comparing an integer against a constant more bits wide,
2179 maybe we can deduce a value of 1 or 0 independent of the data.
2180 Or else truncate the constant now
2181 rather than extend the variable at run time.
2183 This is only interesting if the constant is the wider arg.
2184 Also, it is not safe if the constant is unsigned and the
2185 variable arg is signed, since in this case the variable
2186 would be sign-extended and then regarded as unsigned.
2187 Our technique fails in this case because the lowest/highest
2188 possible unsigned results don't follow naturally from the
2189 lowest/highest possible values of the variable operand.
2190 For just EQ_EXPR and NE_EXPR there is another technique that
2191 could be used: see if the constant can be faithfully represented
2192 in the other operand's type, by truncating it and reextending it
2193 and see if that preserves the constant's value. */
2195 if (!real1 && !real2
2196 && TREE_CODE (primop1) == INTEGER_CST
2197 && TYPE_PRECISION (TREE_TYPE (primop0)) < TYPE_PRECISION (*restype_ptr))
2199 int min_gt, max_gt, min_lt, max_lt;
2200 tree maxval, minval;
2201 /* 1 if comparison is nominally unsigned. */
2202 int unsignedp = TYPE_UNSIGNED (*restype_ptr);
2205 type = c_common_signed_or_unsigned_type (unsignedp0,
2206 TREE_TYPE (primop0));
2208 maxval = TYPE_MAX_VALUE (type);
2209 minval = TYPE_MIN_VALUE (type);
2211 if (unsignedp && !unsignedp0)
2212 *restype_ptr = c_common_signed_type (*restype_ptr);
2214 if (TREE_TYPE (primop1) != *restype_ptr)
2216 /* Convert primop1 to target type, but do not introduce
2217 additional overflow. We know primop1 is an int_cst. */
2218 tree tmp = build_int_cst_wide (*restype_ptr,
2219 TREE_INT_CST_LOW (primop1),
2220 TREE_INT_CST_HIGH (primop1));
2222 primop1 = force_fit_type (tmp, 0, TREE_OVERFLOW (primop1),
2223 TREE_CONSTANT_OVERFLOW (primop1));
2225 if (type != *restype_ptr)
2227 minval = convert (*restype_ptr, minval);
2228 maxval = convert (*restype_ptr, maxval);
2231 if (unsignedp && unsignedp0)
2233 min_gt = INT_CST_LT_UNSIGNED (primop1, minval);
2234 max_gt = INT_CST_LT_UNSIGNED (primop1, maxval);
2235 min_lt = INT_CST_LT_UNSIGNED (minval, primop1);
2236 max_lt = INT_CST_LT_UNSIGNED (maxval, primop1);
2240 min_gt = INT_CST_LT (primop1, minval);
2241 max_gt = INT_CST_LT (primop1, maxval);
2242 min_lt = INT_CST_LT (minval, primop1);
2243 max_lt = INT_CST_LT (maxval, primop1);
2247 /* This used to be a switch, but Genix compiler can't handle that. */
2248 if (code == NE_EXPR)
2250 if (max_lt || min_gt)
2251 val = truthvalue_true_node;
2253 else if (code == EQ_EXPR)
2255 if (max_lt || min_gt)
2256 val = truthvalue_false_node;
2258 else if (code == LT_EXPR)
2261 val = truthvalue_true_node;
2263 val = truthvalue_false_node;
2265 else if (code == GT_EXPR)
2268 val = truthvalue_true_node;
2270 val = truthvalue_false_node;
2272 else if (code == LE_EXPR)
2275 val = truthvalue_true_node;
2277 val = truthvalue_false_node;
2279 else if (code == GE_EXPR)
2282 val = truthvalue_true_node;
2284 val = truthvalue_false_node;
2287 /* If primop0 was sign-extended and unsigned comparison specd,
2288 we did a signed comparison above using the signed type bounds.
2289 But the comparison we output must be unsigned.
2291 Also, for inequalities, VAL is no good; but if the signed
2292 comparison had *any* fixed result, it follows that the
2293 unsigned comparison just tests the sign in reverse
2294 (positive values are LE, negative ones GE).
2295 So we can generate an unsigned comparison
2296 against an extreme value of the signed type. */
2298 if (unsignedp && !unsignedp0)
2305 primop1 = TYPE_MIN_VALUE (type);
2311 primop1 = TYPE_MAX_VALUE (type);
2318 type = c_common_unsigned_type (type);
2321 if (TREE_CODE (primop0) != INTEGER_CST)
2323 if (val == truthvalue_false_node)
2324 warning (0, "comparison is always false due to limited range of data type");
2325 if (val == truthvalue_true_node)
2326 warning (0, "comparison is always true due to limited range of data type");
2331 /* Don't forget to evaluate PRIMOP0 if it has side effects. */
2332 if (TREE_SIDE_EFFECTS (primop0))
2333 return build2 (COMPOUND_EXPR, TREE_TYPE (val), primop0, val);
2337 /* Value is not predetermined, but do the comparison
2338 in the type of the operand that is not constant.
2339 TYPE is already properly set. */
2342 /* If either arg is decimal float and the other is float, find the
2343 proper common type to use for comparison. */
2344 else if (real1 && real2
2345 && (DECIMAL_FLOAT_MODE_P (TYPE_MODE (TREE_TYPE (primop0)))
2346 || DECIMAL_FLOAT_MODE_P (TYPE_MODE (TREE_TYPE (primop1)))))
2347 type = common_type (TREE_TYPE (primop0), TREE_TYPE (primop1));
2349 else if (real1 && real2
2350 && (TYPE_PRECISION (TREE_TYPE (primop0))
2351 == TYPE_PRECISION (TREE_TYPE (primop1))))
2352 type = TREE_TYPE (primop0);
2354 /* If args' natural types are both narrower than nominal type
2355 and both extend in the same manner, compare them
2356 in the type of the wider arg.
2357 Otherwise must actually extend both to the nominal
2358 common type lest different ways of extending
2360 (eg, (short)-1 == (unsigned short)-1 should be 0.) */
2362 else if (unsignedp0 == unsignedp1 && real1 == real2
2363 && TYPE_PRECISION (TREE_TYPE (primop0)) < TYPE_PRECISION (*restype_ptr)
2364 && TYPE_PRECISION (TREE_TYPE (primop1)) < TYPE_PRECISION (*restype_ptr))
2366 type = common_type (TREE_TYPE (primop0), TREE_TYPE (primop1));
2367 type = c_common_signed_or_unsigned_type (unsignedp0
2368 || TYPE_UNSIGNED (*restype_ptr),
2370 /* Make sure shorter operand is extended the right way
2371 to match the longer operand. */
2373 = convert (c_common_signed_or_unsigned_type (unsignedp0,
2374 TREE_TYPE (primop0)),
2377 = convert (c_common_signed_or_unsigned_type (unsignedp1,
2378 TREE_TYPE (primop1)),
2383 /* Here we must do the comparison on the nominal type
2384 using the args exactly as we received them. */
2385 type = *restype_ptr;
2389 if (!real1 && !real2 && integer_zerop (primop1)
2390 && TYPE_UNSIGNED (*restype_ptr))
2396 /* All unsigned values are >= 0, so we warn if extra warnings
2397 are requested. However, if OP0 is a constant that is
2398 >= 0, the signedness of the comparison isn't an issue,
2399 so suppress the warning. */
2400 if (extra_warnings && !in_system_header
2401 && !(TREE_CODE (primop0) == INTEGER_CST
2402 && !TREE_OVERFLOW (convert (c_common_signed_type (type),
2404 warning (0, "comparison of unsigned expression >= 0 is always true");
2405 value = truthvalue_true_node;
2409 if (extra_warnings && !in_system_header
2410 && !(TREE_CODE (primop0) == INTEGER_CST
2411 && !TREE_OVERFLOW (convert (c_common_signed_type (type),
2413 warning (0, "comparison of unsigned expression < 0 is always false");
2414 value = truthvalue_false_node;
2423 /* Don't forget to evaluate PRIMOP0 if it has side effects. */
2424 if (TREE_SIDE_EFFECTS (primop0))
2425 return build2 (COMPOUND_EXPR, TREE_TYPE (value),
2432 *op0_ptr = convert (type, primop0);
2433 *op1_ptr = convert (type, primop1);
2435 *restype_ptr = truthvalue_type_node;
2440 /* Return a tree for the sum or difference (RESULTCODE says which)
2441 of pointer PTROP and integer INTOP. */
2444 pointer_int_sum (enum tree_code resultcode, tree ptrop, tree intop)
2448 /* The result is a pointer of the same type that is being added. */
2450 tree result_type = TREE_TYPE (ptrop);
2452 if (TREE_CODE (TREE_TYPE (result_type)) == VOID_TYPE)
2454 if (pedantic || warn_pointer_arith)
2455 pedwarn ("pointer of type %<void *%> used in arithmetic");
2456 size_exp = integer_one_node;
2458 else if (TREE_CODE (TREE_TYPE (result_type)) == FUNCTION_TYPE)
2460 if (pedantic || warn_pointer_arith)
2461 pedwarn ("pointer to a function used in arithmetic");
2462 size_exp = integer_one_node;
2464 else if (TREE_CODE (TREE_TYPE (result_type)) == METHOD_TYPE)
2466 if (pedantic || warn_pointer_arith)
2467 pedwarn ("pointer to member function used in arithmetic");
2468 size_exp = integer_one_node;
2471 size_exp = size_in_bytes (TREE_TYPE (result_type));
2473 /* We are manipulating pointer values, so we don't need to warn
2474 about relying on undefined signed overflow. We disable the
2475 warning here because we use integer types so fold won't know that
2476 they are really pointers. */
2477 fold_defer_overflow_warnings ();
2479 /* If what we are about to multiply by the size of the elements
2480 contains a constant term, apply distributive law
2481 and multiply that constant term separately.
2482 This helps produce common subexpressions. */
2484 if ((TREE_CODE (intop) == PLUS_EXPR || TREE_CODE (intop) == MINUS_EXPR)
2485 && !TREE_CONSTANT (intop)
2486 && TREE_CONSTANT (TREE_OPERAND (intop, 1))
2487 && TREE_CONSTANT (size_exp)
2488 /* If the constant comes from pointer subtraction,
2489 skip this optimization--it would cause an error. */
2490 && TREE_CODE (TREE_TYPE (TREE_OPERAND (intop, 0))) == INTEGER_TYPE
2491 /* If the constant is unsigned, and smaller than the pointer size,
2492 then we must skip this optimization. This is because it could cause
2493 an overflow error if the constant is negative but INTOP is not. */
2494 && (!TYPE_UNSIGNED (TREE_TYPE (intop))
2495 || (TYPE_PRECISION (TREE_TYPE (intop))
2496 == TYPE_PRECISION (TREE_TYPE (ptrop)))))
2498 enum tree_code subcode = resultcode;
2499 tree int_type = TREE_TYPE (intop);
2500 if (TREE_CODE (intop) == MINUS_EXPR)
2501 subcode = (subcode == PLUS_EXPR ? MINUS_EXPR : PLUS_EXPR);
2502 /* Convert both subexpression types to the type of intop,
2503 because weird cases involving pointer arithmetic
2504 can result in a sum or difference with different type args. */
2505 ptrop = build_binary_op (subcode, ptrop,
2506 convert (int_type, TREE_OPERAND (intop, 1)), 1);
2507 intop = convert (int_type, TREE_OPERAND (intop, 0));
2510 /* Convert the integer argument to a type the same size as sizetype
2511 so the multiply won't overflow spuriously. */
2513 if (TYPE_PRECISION (TREE_TYPE (intop)) != TYPE_PRECISION (sizetype)
2514 || TYPE_UNSIGNED (TREE_TYPE (intop)) != TYPE_UNSIGNED (sizetype))
2515 intop = convert (c_common_type_for_size (TYPE_PRECISION (sizetype),
2516 TYPE_UNSIGNED (sizetype)), intop);
2518 /* Replace the integer argument with a suitable product by the object size.
2519 Do this multiplication as signed, then convert to the appropriate
2520 pointer type (actually unsigned integral). */
2522 intop = convert (result_type,
2523 build_binary_op (MULT_EXPR, intop,
2524 convert (TREE_TYPE (intop), size_exp), 1));
2526 /* Create the sum or difference. */
2527 ret = fold_build2 (resultcode, result_type, ptrop, intop);
2529 fold_undefer_and_ignore_overflow_warnings ();
2534 /* Prepare expr to be an argument of a TRUTH_NOT_EXPR,
2535 or for an `if' or `while' statement or ?..: exp. It should already
2536 have been validated to be of suitable type; otherwise, a bad
2537 diagnostic may result.
2539 This preparation consists of taking the ordinary
2540 representation of an expression expr and producing a valid tree
2541 boolean expression describing whether expr is nonzero. We could
2542 simply always do build_binary_op (NE_EXPR, expr, truthvalue_false_node, 1),
2543 but we optimize comparisons, &&, ||, and !.
2545 The resulting type should always be `truthvalue_type_node'. */
2548 c_common_truthvalue_conversion (tree expr)
2550 switch (TREE_CODE (expr))
2552 case EQ_EXPR: case NE_EXPR: case UNEQ_EXPR: case LTGT_EXPR:
2553 case LE_EXPR: case GE_EXPR: case LT_EXPR: case GT_EXPR:
2554 case UNLE_EXPR: case UNGE_EXPR: case UNLT_EXPR: case UNGT_EXPR:
2555 case ORDERED_EXPR: case UNORDERED_EXPR:
2556 if (TREE_TYPE (expr) == truthvalue_type_node)
2558 return build2 (TREE_CODE (expr), truthvalue_type_node,
2559 TREE_OPERAND (expr, 0), TREE_OPERAND (expr, 1));
2561 case TRUTH_ANDIF_EXPR:
2562 case TRUTH_ORIF_EXPR:
2563 case TRUTH_AND_EXPR:
2565 case TRUTH_XOR_EXPR:
2566 if (TREE_TYPE (expr) == truthvalue_type_node)
2568 return build2 (TREE_CODE (expr), truthvalue_type_node,
2569 c_common_truthvalue_conversion (TREE_OPERAND (expr, 0)),
2570 c_common_truthvalue_conversion (TREE_OPERAND (expr, 1)));
2572 case TRUTH_NOT_EXPR:
2573 if (TREE_TYPE (expr) == truthvalue_type_node)
2575 return build1 (TREE_CODE (expr), truthvalue_type_node,
2576 c_common_truthvalue_conversion (TREE_OPERAND (expr, 0)));
2582 /* Avoid integer_zerop to ignore TREE_CONSTANT_OVERFLOW. */
2583 return (TREE_INT_CST_LOW (expr) != 0 || TREE_INT_CST_HIGH (expr) != 0)
2584 ? truthvalue_true_node
2585 : truthvalue_false_node;
2588 return real_compare (NE_EXPR, &TREE_REAL_CST (expr), &dconst0)
2589 ? truthvalue_true_node
2590 : truthvalue_false_node;
2593 expr = build_unary_op (ADDR_EXPR, expr, 0);
2598 tree inner = TREE_OPERAND (expr, 0);
2600 && (TREE_CODE (inner) == PARM_DECL
2601 || TREE_CODE (inner) == LABEL_DECL
2602 || !DECL_WEAK (inner)))
2604 /* Common Ada/Pascal programmer's mistake. We always warn
2605 about this since it is so bad. */
2606 warning (OPT_Waddress,
2607 "the address of %qD will always evaluate as %<true%>",
2609 return truthvalue_true_node;
2612 /* If we are taking the address of an external decl, it might be
2613 zero if it is weak, so we cannot optimize. */
2615 && DECL_EXTERNAL (inner))
2618 if (TREE_SIDE_EFFECTS (inner))
2619 return build2 (COMPOUND_EXPR, truthvalue_type_node,
2620 inner, truthvalue_true_node);
2622 return truthvalue_true_node;
2626 return build_binary_op ((TREE_SIDE_EFFECTS (TREE_OPERAND (expr, 1))
2627 ? TRUTH_OR_EXPR : TRUTH_ORIF_EXPR),
2628 c_common_truthvalue_conversion (TREE_OPERAND (expr, 0)),
2629 c_common_truthvalue_conversion (TREE_OPERAND (expr, 1)),
2635 /* These don't change whether an object is nonzero or zero. */
2636 return c_common_truthvalue_conversion (TREE_OPERAND (expr, 0));
2640 /* These don't change whether an object is zero or nonzero, but
2641 we can't ignore them if their second arg has side-effects. */
2642 if (TREE_SIDE_EFFECTS (TREE_OPERAND (expr, 1)))
2643 return build2 (COMPOUND_EXPR, truthvalue_type_node,
2644 TREE_OPERAND (expr, 1),
2645 c_common_truthvalue_conversion (TREE_OPERAND (expr, 0)));
2647 return c_common_truthvalue_conversion (TREE_OPERAND (expr, 0));
2650 /* Distribute the conversion into the arms of a COND_EXPR. */
2651 return fold_build3 (COND_EXPR, truthvalue_type_node,
2652 TREE_OPERAND (expr, 0),
2653 c_common_truthvalue_conversion (TREE_OPERAND (expr, 1)),
2654 c_common_truthvalue_conversion (TREE_OPERAND (expr, 2)));
2658 /* Don't cancel the effect of a CONVERT_EXPR from a REFERENCE_TYPE,
2659 since that affects how `default_conversion' will behave. */
2660 if (TREE_CODE (TREE_TYPE (expr)) == REFERENCE_TYPE
2661 || TREE_CODE (TREE_TYPE (TREE_OPERAND (expr, 0))) == REFERENCE_TYPE)
2663 /* If this is widening the argument, we can ignore it. */
2664 if (TYPE_PRECISION (TREE_TYPE (expr))
2665 >= TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (expr, 0))))
2666 return c_common_truthvalue_conversion (TREE_OPERAND (expr, 0));
2670 if (!TREE_NO_WARNING (expr)
2671 && warn_parentheses)
2673 warning (OPT_Wparentheses,
2674 "suggest parentheses around assignment used as truth value");
2675 TREE_NO_WARNING (expr) = 1;
2683 if (TREE_CODE (TREE_TYPE (expr)) == COMPLEX_TYPE)
2685 tree t = save_expr (expr);
2686 return (build_binary_op
2687 ((TREE_SIDE_EFFECTS (expr)
2688 ? TRUTH_OR_EXPR : TRUTH_ORIF_EXPR),
2689 c_common_truthvalue_conversion (build_unary_op (REALPART_EXPR, t, 0)),
2690 c_common_truthvalue_conversion (build_unary_op (IMAGPART_EXPR, t, 0)),
2694 return build_binary_op (NE_EXPR, expr, integer_zero_node, 1);
2697 static void def_builtin_1 (enum built_in_function fncode,
2699 enum built_in_class fnclass,
2700 tree fntype, tree libtype,
2701 bool both_p, bool fallback_p, bool nonansi_p,
2702 tree fnattrs, bool implicit_p);
2704 /* Make a variant type in the proper way for C/C++, propagating qualifiers
2705 down to the element type of an array. */
2708 c_build_qualified_type (tree type, int type_quals)
2710 if (type == error_mark_node)
2713 if (TREE_CODE (type) == ARRAY_TYPE)
2716 tree element_type = c_build_qualified_type (TREE_TYPE (type),
2719 /* See if we already have an identically qualified type. */
2720 for (t = TYPE_MAIN_VARIANT (type); t; t = TYPE_NEXT_VARIANT (t))
2722 if (TYPE_QUALS (strip_array_types (t)) == type_quals
2723 && TYPE_NAME (t) == TYPE_NAME (type)
2724 && TYPE_CONTEXT (t) == TYPE_CONTEXT (type)
2725 && attribute_list_equal (TYPE_ATTRIBUTES (t),
2726 TYPE_ATTRIBUTES (type)))
2731 t = build_variant_type_copy (type);
2732 TREE_TYPE (t) = element_type;
2737 /* A restrict-qualified pointer type must be a pointer to object or
2738 incomplete type. Note that the use of POINTER_TYPE_P also allows
2739 REFERENCE_TYPEs, which is appropriate for C++. */
2740 if ((type_quals & TYPE_QUAL_RESTRICT)
2741 && (!POINTER_TYPE_P (type)
2742 || !C_TYPE_OBJECT_OR_INCOMPLETE_P (TREE_TYPE (type))))
2744 error ("invalid use of %<restrict%>");
2745 type_quals &= ~TYPE_QUAL_RESTRICT;
2748 return build_qualified_type (type, type_quals);
2751 /* Apply the TYPE_QUALS to the new DECL. */
2754 c_apply_type_quals_to_decl (int type_quals, tree decl)
2756 tree type = TREE_TYPE (decl);
2758 if (type == error_mark_node)
2761 if (((type_quals & TYPE_QUAL_CONST)
2762 || (type && TREE_CODE (type) == REFERENCE_TYPE))
2763 /* An object declared 'const' is only readonly after it is
2764 initialized. We don't have any way of expressing this currently,
2765 so we need to be conservative and unset TREE_READONLY for types
2766 with constructors. Otherwise aliasing code will ignore stores in
2767 an inline constructor. */
2768 && !(type && TYPE_NEEDS_CONSTRUCTING (type)))
2769 TREE_READONLY (decl) = 1;
2770 if (type_quals & TYPE_QUAL_VOLATILE)
2772 TREE_SIDE_EFFECTS (decl) = 1;
2773 TREE_THIS_VOLATILE (decl) = 1;
2775 if (type_quals & TYPE_QUAL_RESTRICT)
2777 while (type && TREE_CODE (type) == ARRAY_TYPE)
2778 /* Allow 'restrict' on arrays of pointers.
2779 FIXME currently we just ignore it. */
2780 type = TREE_TYPE (type);
2782 || !POINTER_TYPE_P (type)
2783 || !C_TYPE_OBJECT_OR_INCOMPLETE_P (TREE_TYPE (type)))
2784 error ("invalid use of %<restrict%>");
2785 else if (flag_strict_aliasing && type == TREE_TYPE (decl))
2786 /* Indicate we need to make a unique alias set for this pointer.
2787 We can't do it here because it might be pointing to an
2789 DECL_POINTER_ALIAS_SET (decl) = -2;
2793 /* Hash function for the problem of multiple type definitions in
2794 different files. This must hash all types that will compare
2795 equal via comptypes to the same value. In practice it hashes
2796 on some of the simple stuff and leaves the details to comptypes. */
2799 c_type_hash (const void *p)
2805 switch (TREE_CODE (t))
2807 /* For pointers, hash on pointee type plus some swizzling. */
2809 return c_type_hash (TREE_TYPE (t)) ^ 0x3003003;
2810 /* Hash on number of elements and total size. */
2813 t2 = TYPE_VALUES (t);
2817 t2 = TYPE_FIELDS (t);
2819 case QUAL_UNION_TYPE:
2821 t2 = TYPE_FIELDS (t);
2825 t2 = TYPE_FIELDS (t);
2830 for (; t2; t2 = TREE_CHAIN (t2))
2832 size = TREE_INT_CST_LOW (TYPE_SIZE (t));
2833 return ((size << 24) | (i << shift));
2836 static GTY((param_is (union tree_node))) htab_t type_hash_table;
2838 /* Return the typed-based alias set for T, which may be an expression
2839 or a type. Return -1 if we don't do anything special. */
2842 c_common_get_alias_set (tree t)
2847 /* Permit type-punning when accessing a union, provided the access
2848 is directly through the union. For example, this code does not
2849 permit taking the address of a union member and then storing
2850 through it. Even the type-punning allowed here is a GCC
2851 extension, albeit a common and useful one; the C standard says
2852 that such accesses have implementation-defined behavior. */
2854 TREE_CODE (u) == COMPONENT_REF || TREE_CODE (u) == ARRAY_REF;
2855 u = TREE_OPERAND (u, 0))
2856 if (TREE_CODE (u) == COMPONENT_REF
2857 && TREE_CODE (TREE_TYPE (TREE_OPERAND (u, 0))) == UNION_TYPE)
2860 /* That's all the expressions we handle specially. */
2864 /* The C standard guarantees that any object may be accessed via an
2865 lvalue that has character type. */
2866 if (t == char_type_node
2867 || t == signed_char_type_node
2868 || t == unsigned_char_type_node)
2871 /* If it has the may_alias attribute, it can alias anything. */
2872 if (lookup_attribute ("may_alias", TYPE_ATTRIBUTES (t)))
2875 /* The C standard specifically allows aliasing between signed and
2876 unsigned variants of the same type. We treat the signed
2877 variant as canonical. */
2878 if (TREE_CODE (t) == INTEGER_TYPE && TYPE_UNSIGNED (t))
2880 tree t1 = c_common_signed_type (t);
2882 /* t1 == t can happen for boolean nodes which are always unsigned. */
2884 return get_alias_set (t1);
2886 else if (POINTER_TYPE_P (t))
2890 /* Unfortunately, there is no canonical form of a pointer type.
2891 In particular, if we have `typedef int I', then `int *', and
2892 `I *' are different types. So, we have to pick a canonical
2893 representative. We do this below.
2895 Technically, this approach is actually more conservative that
2896 it needs to be. In particular, `const int *' and `int *'
2897 should be in different alias sets, according to the C and C++
2898 standard, since their types are not the same, and so,
2899 technically, an `int **' and `const int **' cannot point at
2902 But, the standard is wrong. In particular, this code is
2907 const int* const* cipp = ipp;
2909 And, it doesn't make sense for that to be legal unless you
2910 can dereference IPP and CIPP. So, we ignore cv-qualifiers on
2911 the pointed-to types. This issue has been reported to the
2913 t1 = build_type_no_quals (t);
2915 return get_alias_set (t1);
2918 /* Handle the case of multiple type nodes referring to "the same" type,
2919 which occurs with IMA. These share an alias set. FIXME: Currently only
2920 C90 is handled. (In C99 type compatibility is not transitive, which
2921 complicates things mightily. The alias set splay trees can theoretically
2922 represent this, but insertion is tricky when you consider all the
2923 different orders things might arrive in.) */
2925 if (c_language != clk_c || flag_isoc99)
2928 /* Save time if there's only one input file. */
2929 if (num_in_fnames == 1)
2932 /* Pointers need special handling if they point to any type that
2933 needs special handling (below). */
2934 if (TREE_CODE (t) == POINTER_TYPE)
2937 /* Find bottom type under any nested POINTERs. */
2938 for (t2 = TREE_TYPE (t);
2939 TREE_CODE (t2) == POINTER_TYPE;
2940 t2 = TREE_TYPE (t2))
2942 if (TREE_CODE (t2) != RECORD_TYPE
2943 && TREE_CODE (t2) != ENUMERAL_TYPE
2944 && TREE_CODE (t2) != QUAL_UNION_TYPE
2945 && TREE_CODE (t2) != UNION_TYPE)
2947 if (TYPE_SIZE (t2) == 0)
2950 /* These are the only cases that need special handling. */
2951 if (TREE_CODE (t) != RECORD_TYPE
2952 && TREE_CODE (t) != ENUMERAL_TYPE
2953 && TREE_CODE (t) != QUAL_UNION_TYPE
2954 && TREE_CODE (t) != UNION_TYPE
2955 && TREE_CODE (t) != POINTER_TYPE)
2958 if (TYPE_SIZE (t) == 0)
2961 /* Look up t in hash table. Only one of the compatible types within each
2962 alias set is recorded in the table. */
2963 if (!type_hash_table)
2964 type_hash_table = htab_create_ggc (1021, c_type_hash,
2965 (htab_eq) lang_hooks.types_compatible_p,
2967 slot = htab_find_slot (type_hash_table, t, INSERT);
2970 TYPE_ALIAS_SET (t) = TYPE_ALIAS_SET ((tree)*slot);
2971 return TYPE_ALIAS_SET ((tree)*slot);
2974 /* Our caller will assign and record (in t) a new alias set; all we need
2975 to do is remember t in the hash table. */
2981 /* Compute the value of 'sizeof (TYPE)' or '__alignof__ (TYPE)', where the
2982 second parameter indicates which OPERATOR is being applied. The COMPLAIN
2983 flag controls whether we should diagnose possibly ill-formed
2984 constructs or not. */
2987 c_sizeof_or_alignof_type (tree type, bool is_sizeof, int complain)
2989 const char *op_name;
2991 enum tree_code type_code = TREE_CODE (type);
2993 op_name = is_sizeof ? "sizeof" : "__alignof__";
2995 if (type_code == FUNCTION_TYPE)
2999 if (complain && (pedantic || warn_pointer_arith))
3000 pedwarn ("invalid application of %<sizeof%> to a function type");
3001 value = size_one_node;
3004 value = size_int (FUNCTION_BOUNDARY / BITS_PER_UNIT);
3006 else if (type_code == VOID_TYPE || type_code == ERROR_MARK)
3008 if (type_code == VOID_TYPE
3009 && complain && (pedantic || warn_pointer_arith))
3010 pedwarn ("invalid application of %qs to a void type", op_name);
3011 value = size_one_node;
3013 else if (!COMPLETE_TYPE_P (type))
3016 error ("invalid application of %qs to incomplete type %qT ",
3018 value = size_zero_node;
3023 /* Convert in case a char is more than one unit. */
3024 value = size_binop (CEIL_DIV_EXPR, TYPE_SIZE_UNIT (type),
3025 size_int (TYPE_PRECISION (char_type_node)
3028 value = size_int (TYPE_ALIGN_UNIT (type));
3031 /* VALUE will have an integer type with TYPE_IS_SIZETYPE set.
3032 TYPE_IS_SIZETYPE means that certain things (like overflow) will
3033 never happen. However, this node should really have type
3034 `size_t', which is just a typedef for an ordinary integer type. */
3035 value = fold_convert (size_type_node, value);
3036 gcc_assert (!TYPE_IS_SIZETYPE (TREE_TYPE (value)));
3041 /* Implement the __alignof keyword: Return the minimum required
3042 alignment of EXPR, measured in bytes. For VAR_DECLs,
3043 FUNCTION_DECLs and FIELD_DECLs return DECL_ALIGN (which can be set
3044 from an "aligned" __attribute__ specification). */
3047 c_alignof_expr (tree expr)
3051 if (VAR_OR_FUNCTION_DECL_P (expr))
3052 t = size_int (DECL_ALIGN_UNIT (expr));
3054 else if (TREE_CODE (expr) == COMPONENT_REF
3055 && DECL_C_BIT_FIELD (TREE_OPERAND (expr, 1)))
3057 error ("%<__alignof%> applied to a bit-field");
3060 else if (TREE_CODE (expr) == COMPONENT_REF
3061 && TREE_CODE (TREE_OPERAND (expr, 1)) == FIELD_DECL)
3062 t = size_int (DECL_ALIGN_UNIT (TREE_OPERAND (expr, 1)));
3064 else if (TREE_CODE (expr) == INDIRECT_REF)
3066 tree t = TREE_OPERAND (expr, 0);
3068 int bestalign = TYPE_ALIGN (TREE_TYPE (TREE_TYPE (t)));
3070 while ((TREE_CODE (t) == NOP_EXPR || TREE_CODE (t) == CONVERT_EXPR)
3071 && TREE_CODE (TREE_TYPE (TREE_OPERAND (t, 0))) == POINTER_TYPE)
3075 t = TREE_OPERAND (t, 0);
3076 thisalign = TYPE_ALIGN (TREE_TYPE (TREE_TYPE (t)));
3077 if (thisalign > bestalign)
3078 best = t, bestalign = thisalign;
3080 return c_alignof (TREE_TYPE (TREE_TYPE (best)));
3083 return c_alignof (TREE_TYPE (expr));
3085 return fold_convert (size_type_node, t);
3088 /* Handle C and C++ default attributes. */
3090 enum built_in_attribute
3092 #define DEF_ATTR_NULL_TREE(ENUM) ENUM,
3093 #define DEF_ATTR_INT(ENUM, VALUE) ENUM,
3094 #define DEF_ATTR_IDENT(ENUM, STRING) ENUM,
3095 #define DEF_ATTR_TREE_LIST(ENUM, PURPOSE, VALUE, CHAIN) ENUM,
3096 #include "builtin-attrs.def"
3097 #undef DEF_ATTR_NULL_TREE
3099 #undef DEF_ATTR_IDENT
3100 #undef DEF_ATTR_TREE_LIST
3104 static GTY(()) tree built_in_attributes[(int) ATTR_LAST];
3106 static void c_init_attributes (void);
3110 #define DEF_PRIMITIVE_TYPE(NAME, VALUE) NAME,
3111 #define DEF_FUNCTION_TYPE_0(NAME, RETURN) NAME,
3112 #define DEF_FUNCTION_TYPE_1(NAME, RETURN, ARG1) NAME,
3113 #define DEF_FUNCTION_TYPE_2(NAME, RETURN, ARG1, ARG2) NAME,
3114 #define DEF_FUNCTION_TYPE_3(NAME, RETURN, ARG1, ARG2, ARG3) NAME,
3115 #define DEF_FUNCTION_TYPE_4(NAME, RETURN, ARG1, ARG2, ARG3, ARG4) NAME,
3116 #define DEF_FUNCTION_TYPE_5(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5) NAME,
3117 #define DEF_FUNCTION_TYPE_6(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6) NAME,
3118 #define DEF_FUNCTION_TYPE_7(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6, ARG7) NAME,
3119 #define DEF_FUNCTION_TYPE_VAR_0(NAME, RETURN) NAME,
3120 #define DEF_FUNCTION_TYPE_VAR_1(NAME, RETURN, ARG1) NAME,
3121 #define DEF_FUNCTION_TYPE_VAR_2(NAME, RETURN, ARG1, ARG2) NAME,
3122 #define DEF_FUNCTION_TYPE_VAR_3(NAME, RETURN, ARG1, ARG2, ARG3) NAME,
3123 #define DEF_FUNCTION_TYPE_VAR_4(NAME, RETURN, ARG1, ARG2, ARG3, ARG4) NAME,
3124 #define DEF_FUNCTION_TYPE_VAR_5(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG6) \
3126 #define DEF_POINTER_TYPE(NAME, TYPE) NAME,
3127 #include "builtin-types.def"
3128 #undef DEF_PRIMITIVE_TYPE
3129 #undef DEF_FUNCTION_TYPE_0
3130 #undef DEF_FUNCTION_TYPE_1
3131 #undef DEF_FUNCTION_TYPE_2
3132 #undef DEF_FUNCTION_TYPE_3
3133 #undef DEF_FUNCTION_TYPE_4
3134 #undef DEF_FUNCTION_TYPE_5
3135 #undef DEF_FUNCTION_TYPE_6
3136 #undef DEF_FUNCTION_TYPE_7
3137 #undef DEF_FUNCTION_TYPE_VAR_0
3138 #undef DEF_FUNCTION_TYPE_VAR_1
3139 #undef DEF_FUNCTION_TYPE_VAR_2
3140 #undef DEF_FUNCTION_TYPE_VAR_3
3141 #undef DEF_FUNCTION_TYPE_VAR_4
3142 #undef DEF_FUNCTION_TYPE_VAR_5
3143 #undef DEF_POINTER_TYPE
3147 typedef enum c_builtin_type builtin_type;
3149 /* A temporary array for c_common_nodes_and_builtins. Used in
3150 communication with def_fn_type. */
3151 static tree builtin_types[(int) BT_LAST + 1];
3153 /* A helper function for c_common_nodes_and_builtins. Build function type
3154 for DEF with return type RET and N arguments. If VAR is true, then the
3155 function should be variadic after those N arguments.
3157 Takes special care not to ICE if any of the types involved are
3158 error_mark_node, which indicates that said type is not in fact available
3159 (see builtin_type_for_size). In which case the function type as a whole
3160 should be error_mark_node. */
3163 def_fn_type (builtin_type def, builtin_type ret, bool var, int n, ...)
3165 tree args = NULL, t;
3170 for (i = 0; i < n; ++i)
3172 builtin_type a = va_arg (list, builtin_type);
3173 t = builtin_types[a];
3174 if (t == error_mark_node)
3176 args = tree_cons (NULL_TREE, t, args);
3180 args = nreverse (args);
3182 args = chainon (args, void_list_node);
3184 t = builtin_types[ret];
3185 if (t == error_mark_node)
3187 t = build_function_type (t, args);
3190 builtin_types[def] = t;
3193 /* Build builtin functions common to both C and C++ language
3197 c_define_builtins (tree va_list_ref_type_node, tree va_list_arg_type_node)
3199 #define DEF_PRIMITIVE_TYPE(ENUM, VALUE) \
3200 builtin_types[ENUM] = VALUE;
3201 #define DEF_FUNCTION_TYPE_0(ENUM, RETURN) \
3202 def_fn_type (ENUM, RETURN, 0, 0);
3203 #define DEF_FUNCTION_TYPE_1(ENUM, RETURN, ARG1) \
3204 def_fn_type (ENUM, RETURN, 0, 1, ARG1);
3205 #define DEF_FUNCTION_TYPE_2(ENUM, RETURN, ARG1, ARG2) \
3206 def_fn_type (ENUM, RETURN, 0, 2, ARG1, ARG2);
3207 #define DEF_FUNCTION_TYPE_3(ENUM, RETURN, ARG1, ARG2, ARG3) \
3208 def_fn_type (ENUM, RETURN, 0, 3, ARG1, ARG2, ARG3);
3209 #define DEF_FUNCTION_TYPE_4(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4) \
3210 def_fn_type (ENUM, RETURN, 0, 4, ARG1, ARG2, ARG3, ARG4);
3211 #define DEF_FUNCTION_TYPE_5(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5) \
3212 def_fn_type (ENUM, RETURN, 0, 5, ARG1, ARG2, ARG3, ARG4, ARG5);
3213 #define DEF_FUNCTION_TYPE_6(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
3215 def_fn_type (ENUM, RETURN, 0, 6, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6);
3216 #define DEF_FUNCTION_TYPE_7(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
3218 def_fn_type (ENUM, RETURN, 0, 7, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6, ARG7);
3219 #define DEF_FUNCTION_TYPE_VAR_0(ENUM, RETURN) \
3220 def_fn_type (ENUM, RETURN, 1, 0);
3221 #define DEF_FUNCTION_TYPE_VAR_1(ENUM, RETURN, ARG1) \
3222 def_fn_type (ENUM, RETURN, 1, 1, ARG1);
3223 #define DEF_FUNCTION_TYPE_VAR_2(ENUM, RETURN, ARG1, ARG2) \
3224 def_fn_type (ENUM, RETURN, 1, 2, ARG1, ARG2);
3225 #define DEF_FUNCTION_TYPE_VAR_3(ENUM, RETURN, ARG1, ARG2, ARG3) \
3226 def_fn_type (ENUM, RETURN, 1, 3, ARG1, ARG2, ARG3);
3227 #define DEF_FUNCTION_TYPE_VAR_4(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4) \
3228 def_fn_type (ENUM, RETURN, 1, 4, ARG1, ARG2, ARG3, ARG4);
3229 #define DEF_FUNCTION_TYPE_VAR_5(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5) \
3230 def_fn_type (ENUM, RETURN, 1, 5, ARG1, ARG2, ARG3, ARG4, ARG5);
3231 #define DEF_POINTER_TYPE(ENUM, TYPE) \
3232 builtin_types[(int) ENUM] = build_pointer_type (builtin_types[(int) TYPE]);
3234 #include "builtin-types.def"
3236 #undef DEF_PRIMITIVE_TYPE
3237 #undef DEF_FUNCTION_TYPE_1
3238 #undef DEF_FUNCTION_TYPE_2
3239 #undef DEF_FUNCTION_TYPE_3
3240 #undef DEF_FUNCTION_TYPE_4
3241 #undef DEF_FUNCTION_TYPE_5
3242 #undef DEF_FUNCTION_TYPE_6
3243 #undef DEF_FUNCTION_TYPE_VAR_0
3244 #undef DEF_FUNCTION_TYPE_VAR_1
3245 #undef DEF_FUNCTION_TYPE_VAR_2
3246 #undef DEF_FUNCTION_TYPE_VAR_3
3247 #undef DEF_FUNCTION_TYPE_VAR_4
3248 #undef DEF_FUNCTION_TYPE_VAR_5
3249 #undef DEF_POINTER_TYPE
3250 builtin_types[(int) BT_LAST] = NULL_TREE;
3252 c_init_attributes ();
3254 #define DEF_BUILTIN(ENUM, NAME, CLASS, TYPE, LIBTYPE, BOTH_P, FALLBACK_P, \
3255 NONANSI_P, ATTRS, IMPLICIT, COND) \
3257 def_builtin_1 (ENUM, NAME, CLASS, \
3258 builtin_types[(int) TYPE], \
3259 builtin_types[(int) LIBTYPE], \
3260 BOTH_P, FALLBACK_P, NONANSI_P, \
3261 built_in_attributes[(int) ATTRS], IMPLICIT);
3262 #include "builtins.def"
3265 build_common_builtin_nodes ();
3267 targetm.init_builtins ();
3272 /* Build tree nodes and builtin functions common to both C and C++ language
3276 c_common_nodes_and_builtins (void)
3278 int wchar_type_size;
3279 tree array_domain_type;
3280 tree va_list_ref_type_node;
3281 tree va_list_arg_type_node;
3283 /* Define `int' and `char' first so that dbx will output them first. */
3284 record_builtin_type (RID_INT, NULL, integer_type_node);
3285 record_builtin_type (RID_CHAR, "char", char_type_node);
3287 /* `signed' is the same as `int'. FIXME: the declarations of "signed",
3288 "unsigned long", "long long unsigned" and "unsigned short" were in C++
3289 but not C. Are the conditionals here needed? */
3290 if (c_dialect_cxx ())
3291 record_builtin_type (RID_SIGNED, NULL, integer_type_node);
3292 record_builtin_type (RID_LONG, "long int", long_integer_type_node);
3293 record_builtin_type (RID_UNSIGNED, "unsigned int", unsigned_type_node);
3294 record_builtin_type (RID_MAX, "long unsigned int",
3295 long_unsigned_type_node);
3296 if (c_dialect_cxx ())
3297 record_builtin_type (RID_MAX, "unsigned long", long_unsigned_type_node);
3298 record_builtin_type (RID_MAX, "long long int",
3299 long_long_integer_type_node);
3300 record_builtin_type (RID_MAX, "long long unsigned int",
3301 long_long_unsigned_type_node);
3302 if (c_dialect_cxx ())
3303 record_builtin_type (RID_MAX, "long long unsigned",
3304 long_long_unsigned_type_node);
3305 record_builtin_type (RID_SHORT, "short int", short_integer_type_node);
3306 record_builtin_type (RID_MAX, "short unsigned int",
3307 short_unsigned_type_node);
3308 if (c_dialect_cxx ())
3309 record_builtin_type (RID_MAX, "unsigned short",
3310 short_unsigned_type_node);
3312 /* Define both `signed char' and `unsigned char'. */
3313 record_builtin_type (RID_MAX, "signed char", signed_char_type_node);
3314 record_builtin_type (RID_MAX, "unsigned char", unsigned_char_type_node);
3316 /* These are types that c_common_type_for_size and
3317 c_common_type_for_mode use. */
3318 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
3320 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
3322 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
3324 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
3326 #if HOST_BITS_PER_WIDE_INT >= 64
3327 if (targetm.scalar_mode_supported_p (TImode))
3328 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL,
3329 get_identifier ("__int128_t"),
3332 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
3333 unsigned_intQI_type_node));
3334 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
3335 unsigned_intHI_type_node));
3336 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
3337 unsigned_intSI_type_node));
3338 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
3339 unsigned_intDI_type_node));
3340 #if HOST_BITS_PER_WIDE_INT >= 64
3341 if (targetm.scalar_mode_supported_p (TImode))
3342 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL,
3343 get_identifier ("__uint128_t"),
3344 unsigned_intTI_type_node));
3347 /* Create the widest literal types. */
3348 widest_integer_literal_type_node
3349 = make_signed_type (HOST_BITS_PER_WIDE_INT * 2);
3350 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
3351 widest_integer_literal_type_node));
3353 widest_unsigned_literal_type_node
3354 = make_unsigned_type (HOST_BITS_PER_WIDE_INT * 2);
3355 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
3356 widest_unsigned_literal_type_node));
3358 /* `unsigned long' is the standard type for sizeof.
3359 Note that stddef.h uses `unsigned long',
3360 and this must agree, even if long and int are the same size. */
3362 TREE_TYPE (identifier_global_value (get_identifier (SIZE_TYPE)));
3363 signed_size_type_node = c_common_signed_type (size_type_node);
3364 set_sizetype (size_type_node);
3367 TREE_TYPE (identifier_global_value (get_identifier (PID_TYPE)));
3369 build_common_tree_nodes_2 (flag_short_double);
3371 record_builtin_type (RID_FLOAT, NULL, float_type_node);
3372 record_builtin_type (RID_DOUBLE, NULL, double_type_node);
3373 record_builtin_type (RID_MAX, "long double", long_double_type_node);
3375 /* Only supported decimal floating point extension if the target
3376 actually supports underlying modes. */
3377 if (targetm.scalar_mode_supported_p (SDmode)
3378 && targetm.scalar_mode_supported_p (DDmode)
3379 && targetm.scalar_mode_supported_p (TDmode))
3381 record_builtin_type (RID_DFLOAT32, NULL, dfloat32_type_node);
3382 record_builtin_type (RID_DFLOAT64, NULL, dfloat64_type_node);
3383 record_builtin_type (RID_DFLOAT128, NULL, dfloat128_type_node);
3386 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL,
3387 get_identifier ("complex int"),
3388 complex_integer_type_node));
3389 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL,
3390 get_identifier ("complex float"),
3391 complex_float_type_node));
3392 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL,
3393 get_identifier ("complex double"),
3394 complex_double_type_node));
3395 lang_hooks.decls.pushdecl
3396 (build_decl (TYPE_DECL, get_identifier ("complex long double"),
3397 complex_long_double_type_node));
3399 if (c_dialect_cxx ())
3400 /* For C++, make fileptr_type_node a distinct void * type until
3401 FILE type is defined. */
3402 fileptr_type_node = build_variant_type_copy (ptr_type_node);
3404 record_builtin_type (RID_VOID, NULL, void_type_node);
3406 /* This node must not be shared. */
3407 void_zero_node = make_node (INTEGER_CST);
3408 TREE_TYPE (void_zero_node) = void_type_node;
3410 void_list_node = build_void_list_node ();
3412 /* Make a type to be the domain of a few array types
3413 whose domains don't really matter.
3414 200 is small enough that it always fits in size_t
3415 and large enough that it can hold most function names for the
3416 initializations of __FUNCTION__ and __PRETTY_FUNCTION__. */
3417 array_domain_type = build_index_type (size_int (200));
3419 /* Make a type for arrays of characters.
3420 With luck nothing will ever really depend on the length of this
3422 char_array_type_node
3423 = build_array_type (char_type_node, array_domain_type);
3425 /* Likewise for arrays of ints. */
3427 = build_array_type (integer_type_node, array_domain_type);
3429 string_type_node = build_pointer_type (char_type_node);
3430 const_string_type_node
3431 = build_pointer_type (build_qualified_type
3432 (char_type_node, TYPE_QUAL_CONST));
3434 /* This is special for C++ so functions can be overloaded. */
3435 wchar_type_node = get_identifier (MODIFIED_WCHAR_TYPE);
3436 wchar_type_node = TREE_TYPE (identifier_global_value (wchar_type_node));
3437 wchar_type_size = TYPE_PRECISION (wchar_type_node);
3438 if (c_dialect_cxx ())
3440 if (TYPE_UNSIGNED (wchar_type_node))
3441 wchar_type_node = make_unsigned_type (wchar_type_size);
3443 wchar_type_node = make_signed_type (wchar_type_size);
3444 record_builtin_type (RID_WCHAR, "wchar_t", wchar_type_node);
3448 signed_wchar_type_node = c_common_signed_type (wchar_type_node);
3449 unsigned_wchar_type_node = c_common_unsigned_type (wchar_type_node);
3452 /* This is for wide string constants. */
3453 wchar_array_type_node
3454 = build_array_type (wchar_type_node, array_domain_type);
3457 TREE_TYPE (identifier_global_value (get_identifier (WINT_TYPE)));
3460 TREE_TYPE (identifier_global_value (get_identifier (INTMAX_TYPE)));
3462 TREE_TYPE (identifier_global_value (get_identifier (UINTMAX_TYPE)));
3464 default_function_type = build_function_type (integer_type_node, NULL_TREE);
3466 = TREE_TYPE (identifier_global_value (get_identifier (PTRDIFF_TYPE)));
3467 unsigned_ptrdiff_type_node = c_common_unsigned_type (ptrdiff_type_node);
3469 lang_hooks.decls.pushdecl
3470 (build_decl (TYPE_DECL, get_identifier ("__builtin_va_list"),
3471 va_list_type_node));
3473 if (TREE_CODE (va_list_type_node) == ARRAY_TYPE)
3475 va_list_arg_type_node = va_list_ref_type_node =
3476 build_pointer_type (TREE_TYPE (va_list_type_node));
3480 va_list_arg_type_node = va_list_type_node;
3481 va_list_ref_type_node = build_reference_type (va_list_type_node);
3484 if (!flag_preprocess_only)
3485 c_define_builtins (va_list_ref_type_node, va_list_arg_type_node);
3487 main_identifier_node = get_identifier ("main");
3489 /* Create the built-in __null node. It is important that this is
3491 null_node = make_node (INTEGER_CST);
3492 TREE_TYPE (null_node) = c_common_type_for_size (POINTER_SIZE, 0);
3494 /* Since builtin_types isn't gc'ed, don't export these nodes. */
3495 memset (builtin_types, 0, sizeof (builtin_types));
3498 /* Look up the function in built_in_decls that corresponds to DECL
3499 and set ASMSPEC as its user assembler name. DECL must be a
3500 function decl that declares a builtin. */
3503 set_builtin_user_assembler_name (tree decl, const char *asmspec)
3506 gcc_assert (TREE_CODE (decl) == FUNCTION_DECL
3507 && DECL_BUILT_IN_CLASS (decl) == BUILT_IN_NORMAL
3510 builtin = built_in_decls [DECL_FUNCTION_CODE (decl)];
3511 set_user_assembler_name (builtin, asmspec);
3512 if (DECL_FUNCTION_CODE (decl) == BUILT_IN_MEMCPY)
3513 init_block_move_fn (asmspec);
3514 else if (DECL_FUNCTION_CODE (decl) == BUILT_IN_MEMSET)
3515 init_block_clear_fn (asmspec);
3518 /* The number of named compound-literals generated thus far. */
3519 static GTY(()) int compound_literal_number;
3521 /* Set DECL_NAME for DECL, a VAR_DECL for a compound-literal. */
3524 set_compound_literal_name (tree decl)
3527 ASM_FORMAT_PRIVATE_NAME (name, "__compound_literal",
3528 compound_literal_number);
3529 compound_literal_number++;
3530 DECL_NAME (decl) = get_identifier (name);
3534 build_va_arg (tree expr, tree type)
3536 return build1 (VA_ARG_EXPR, type, expr);
3540 /* Linked list of disabled built-in functions. */
3542 typedef struct disabled_builtin
3545 struct disabled_builtin *next;
3547 static disabled_builtin *disabled_builtins = NULL;
3549 static bool builtin_function_disabled_p (const char *);
3551 /* Disable a built-in function specified by -fno-builtin-NAME. If NAME
3552 begins with "__builtin_", give an error. */
3555 disable_builtin_function (const char *name)
3557 if (strncmp (name, "__builtin_", strlen ("__builtin_")) == 0)
3558 error ("cannot disable built-in function %qs", name);
3561 disabled_builtin *new_disabled_builtin = XNEW (disabled_builtin);
3562 new_disabled_builtin->name = name;
3563 new_disabled_builtin->next = disabled_builtins;
3564 disabled_builtins = new_disabled_builtin;
3569 /* Return true if the built-in function NAME has been disabled, false
3573 builtin_function_disabled_p (const char *name)
3575 disabled_builtin *p;
3576 for (p = disabled_builtins; p != NULL; p = p->next)
3578 if (strcmp (name, p->name) == 0)
3585 /* Worker for DEF_BUILTIN.
3586 Possibly define a builtin function with one or two names.
3587 Does not declare a non-__builtin_ function if flag_no_builtin, or if
3588 nonansi_p and flag_no_nonansi_builtin. */
3591 def_builtin_1 (enum built_in_function fncode,
3593 enum built_in_class fnclass,
3594 tree fntype, tree libtype,
3595 bool both_p, bool fallback_p, bool nonansi_p,
3596 tree fnattrs, bool implicit_p)
3599 const char *libname;
3601 if (fntype == error_mark_node)
3604 gcc_assert ((!both_p && !fallback_p)
3605 || !strncmp (name, "__builtin_",
3606 strlen ("__builtin_")));
3608 libname = name + strlen ("__builtin_");
3609 decl = lang_hooks.builtin_function (name, fntype, fncode, fnclass,
3610 (fallback_p ? libname : NULL),
3613 && !flag_no_builtin && !builtin_function_disabled_p (libname)
3614 && !(nonansi_p && flag_no_nonansi_builtin))
3615 lang_hooks.builtin_function (libname, libtype, fncode, fnclass,
3618 built_in_decls[(int) fncode] = decl;
3620 implicit_built_in_decls[(int) fncode] = decl;
3623 /* Nonzero if the type T promotes to int. This is (nearly) the
3624 integral promotions defined in ISO C99 6.3.1.1/2. */
3627 c_promoting_integer_type_p (tree t)
3629 switch (TREE_CODE (t))
3632 return (TYPE_MAIN_VARIANT (t) == char_type_node
3633 || TYPE_MAIN_VARIANT (t) == signed_char_type_node
3634 || TYPE_MAIN_VARIANT (t) == unsigned_char_type_node
3635 || TYPE_MAIN_VARIANT (t) == short_integer_type_node
3636 || TYPE_MAIN_VARIANT (t) == short_unsigned_type_node
3637 || TYPE_PRECISION (t) < TYPE_PRECISION (integer_type_node));
3640 /* ??? Technically all enumerations not larger than an int
3641 promote to an int. But this is used along code paths
3642 that only want to notice a size change. */
3643 return TYPE_PRECISION (t) < TYPE_PRECISION (integer_type_node);
3653 /* Return 1 if PARMS specifies a fixed number of parameters
3654 and none of their types is affected by default promotions. */
3657 self_promoting_args_p (tree parms)
3660 for (t = parms; t; t = TREE_CHAIN (t))
3662 tree type = TREE_VALUE (t);
3664 if (type == error_mark_node)
3667 if (TREE_CHAIN (t) == 0 && type != void_type_node)
3673 if (TYPE_MAIN_VARIANT (type) == float_type_node)
3676 if (c_promoting_integer_type_p (type))
3682 /* Recursively examines the array elements of TYPE, until a non-array
3683 element type is found. */
3686 strip_array_types (tree type)
3688 while (TREE_CODE (type) == ARRAY_TYPE)
3689 type = TREE_TYPE (type);
3694 /* Recursively remove any '*' or '&' operator from TYPE. */
3696 strip_pointer_operator (tree t)
3698 while (POINTER_TYPE_P (t))
3703 /* Used to compare case labels. K1 and K2 are actually tree nodes
3704 representing case labels, or NULL_TREE for a `default' label.
3705 Returns -1 if K1 is ordered before K2, -1 if K1 is ordered after
3706 K2, and 0 if K1 and K2 are equal. */
3709 case_compare (splay_tree_key k1, splay_tree_key k2)
3711 /* Consider a NULL key (such as arises with a `default' label) to be
3712 smaller than anything else. */
3718 return tree_int_cst_compare ((tree) k1, (tree) k2);
3721 /* Process a case label for the range LOW_VALUE ... HIGH_VALUE. If
3722 LOW_VALUE and HIGH_VALUE are both NULL_TREE then this case label is
3723 actually a `default' label. If only HIGH_VALUE is NULL_TREE, then
3724 case label was declared using the usual C/C++ syntax, rather than
3725 the GNU case range extension. CASES is a tree containing all the
3726 case ranges processed so far; COND is the condition for the
3727 switch-statement itself. Returns the CASE_LABEL_EXPR created, or
3728 ERROR_MARK_NODE if no CASE_LABEL_EXPR is created. */
3731 c_add_case_label (splay_tree cases, tree cond, tree orig_type,
3732 tree low_value, tree high_value)
3737 splay_tree_node node;
3739 /* Create the LABEL_DECL itself. */
3740 label = create_artificial_label ();
3742 /* If there was an error processing the switch condition, bail now
3743 before we get more confused. */
3744 if (!cond || cond == error_mark_node)
3747 if ((low_value && TREE_TYPE (low_value)
3748 && POINTER_TYPE_P (TREE_TYPE (low_value)))
3749 || (high_value && TREE_TYPE (high_value)
3750 && POINTER_TYPE_P (TREE_TYPE (high_value))))
3752 error ("pointers are not permitted as case values");
3756 /* Case ranges are a GNU extension. */
3757 if (high_value && pedantic)
3758 pedwarn ("range expressions in switch statements are non-standard");
3760 type = TREE_TYPE (cond);
3763 low_value = check_case_value (low_value);
3764 low_value = convert_and_check (type, low_value);
3765 if (low_value == error_mark_node)
3770 high_value = check_case_value (high_value);
3771 high_value = convert_and_check (type, high_value);
3772 if (high_value == error_mark_node)
3776 if (low_value && high_value)
3778 /* If the LOW_VALUE and HIGH_VALUE are the same, then this isn't
3779 really a case range, even though it was written that way.
3780 Remove the HIGH_VALUE to simplify later processing. */
3781 if (tree_int_cst_equal (low_value, high_value))
3782 high_value = NULL_TREE;
3783 else if (!tree_int_cst_lt (low_value, high_value))
3784 warning (0, "empty range specified");
3787 /* See if the case is in range of the type of the original testing
3788 expression. If both low_value and high_value are out of range,
3789 don't insert the case label and return NULL_TREE. */
3791 && !check_case_bounds (type, orig_type,
3792 &low_value, high_value ? &high_value : NULL))
3795 /* Look up the LOW_VALUE in the table of case labels we already
3797 node = splay_tree_lookup (cases, (splay_tree_key) low_value);
3798 /* If there was not an exact match, check for overlapping ranges.
3799 There's no need to do this if there's no LOW_VALUE or HIGH_VALUE;
3800 that's a `default' label and the only overlap is an exact match. */
3801 if (!node && (low_value || high_value))
3803 splay_tree_node low_bound;
3804 splay_tree_node high_bound;
3806 /* Even though there wasn't an exact match, there might be an
3807 overlap between this case range and another case range.
3808 Since we've (inductively) not allowed any overlapping case
3809 ranges, we simply need to find the greatest low case label
3810 that is smaller that LOW_VALUE, and the smallest low case
3811 label that is greater than LOW_VALUE. If there is an overlap
3812 it will occur in one of these two ranges. */
3813 low_bound = splay_tree_predecessor (cases,
3814 (splay_tree_key) low_value);
3815 high_bound = splay_tree_successor (cases,
3816 (splay_tree_key) low_value);
3818 /* Check to see if the LOW_BOUND overlaps. It is smaller than
3819 the LOW_VALUE, so there is no need to check unless the
3820 LOW_BOUND is in fact itself a case range. */
3822 && CASE_HIGH ((tree) low_bound->value)
3823 && tree_int_cst_compare (CASE_HIGH ((tree) low_bound->value),
3826 /* Check to see if the HIGH_BOUND overlaps. The low end of that
3827 range is bigger than the low end of the current range, so we
3828 are only interested if the current range is a real range, and
3829 not an ordinary case label. */
3832 && (tree_int_cst_compare ((tree) high_bound->key,
3837 /* If there was an overlap, issue an error. */
3840 tree duplicate = CASE_LABEL ((tree) node->value);
3844 error ("duplicate (or overlapping) case value");
3845 error ("%Jthis is the first entry overlapping that value", duplicate);
3849 error ("duplicate case value") ;
3850 error ("%Jpreviously used here", duplicate);
3854 error ("multiple default labels in one switch");
3855 error ("%Jthis is the first default label", duplicate);
3860 /* Add a CASE_LABEL to the statement-tree. */
3861 case_label = add_stmt (build_case_label (low_value, high_value, label));
3862 /* Register this case label in the splay tree. */
3863 splay_tree_insert (cases,
3864 (splay_tree_key) low_value,
3865 (splay_tree_value) case_label);
3870 /* Add a label so that the back-end doesn't think that the beginning of
3871 the switch is unreachable. Note that we do not add a case label, as
3872 that just leads to duplicates and thence to failure later on. */
3875 tree t = create_artificial_label ();
3876 add_stmt (build_stmt (LABEL_EXPR, t));
3878 return error_mark_node;
3881 /* Subroutines of c_do_switch_warnings, called via splay_tree_foreach.
3882 Used to verify that case values match up with enumerator values. */
3885 match_case_to_enum_1 (tree key, tree type, tree label)
3887 char buf[2 + 2*HOST_BITS_PER_WIDE_INT/4 + 1];
3889 /* ??? Not working too hard to print the double-word value.
3890 Should perhaps be done with %lwd in the diagnostic routines? */
3891 if (TREE_INT_CST_HIGH (key) == 0)
3892 snprintf (buf, sizeof (buf), HOST_WIDE_INT_PRINT_UNSIGNED,
3893 TREE_INT_CST_LOW (key));
3894 else if (!TYPE_UNSIGNED (type)
3895 && TREE_INT_CST_HIGH (key) == -1
3896 && TREE_INT_CST_LOW (key) != 0)
3897 snprintf (buf, sizeof (buf), "-" HOST_WIDE_INT_PRINT_UNSIGNED,
3898 -TREE_INT_CST_LOW (key));
3900 snprintf (buf, sizeof (buf), HOST_WIDE_INT_PRINT_DOUBLE_HEX,
3901 TREE_INT_CST_HIGH (key), TREE_INT_CST_LOW (key));
3903 if (TYPE_NAME (type) == 0)
3904 warning (0, "%Jcase value %qs not in enumerated type",
3905 CASE_LABEL (label), buf);
3907 warning (0, "%Jcase value %qs not in enumerated type %qT",
3908 CASE_LABEL (label), buf, type);
3911 /* Subroutine of c_do_switch_warnings, called via splay_tree_foreach.
3912 Used to verify that case values match up with enumerator values. */
3915 match_case_to_enum (splay_tree_node node, void *data)
3917 tree label = (tree) node->value;
3918 tree type = (tree) data;
3920 /* Skip default case. */
3921 if (!CASE_LOW (label))
3924 /* If CASE_LOW_SEEN is not set, that means CASE_LOW did not appear
3925 when we did our enum->case scan. Reset our scratch bit after. */
3926 if (!CASE_LOW_SEEN (label))
3927 match_case_to_enum_1 (CASE_LOW (label), type, label);
3929 CASE_LOW_SEEN (label) = 0;
3931 /* If CASE_HIGH is non-null, we have a range. If CASE_HIGH_SEEN is
3932 not set, that means that CASE_HIGH did not appear when we did our
3933 enum->case scan. Reset our scratch bit after. */
3934 if (CASE_HIGH (label))
3936 if (!CASE_HIGH_SEEN (label))
3937 match_case_to_enum_1 (CASE_HIGH (label), type, label);
3939 CASE_HIGH_SEEN (label) = 0;
3945 /* Handle -Wswitch*. Called from the front end after parsing the
3946 switch construct. */
3947 /* ??? Should probably be somewhere generic, since other languages
3948 besides C and C++ would want this. At the moment, however, C/C++
3949 are the only tree-ssa languages that support enumerations at all,
3950 so the point is moot. */
3953 c_do_switch_warnings (splay_tree cases, location_t switch_location,
3954 tree type, tree cond)
3956 splay_tree_node default_node;
3957 splay_tree_node node;
3960 if (!warn_switch && !warn_switch_enum && !warn_switch_default)
3963 default_node = splay_tree_lookup (cases, (splay_tree_key) NULL);
3965 warning (OPT_Wswitch_default, "%Hswitch missing default case",
3968 /* From here on, we only care about about enumerated types. */
3969 if (!type || TREE_CODE (type) != ENUMERAL_TYPE)
3972 /* If the switch expression was an enumerated type, check that
3973 exactly all enumeration literals are covered by the cases.
3974 The check is made when -Wswitch was specified and there is no
3975 default case, or when -Wswitch-enum was specified. */
3977 if (!warn_switch_enum
3978 && !(warn_switch && !default_node))
3981 /* Clearing COND if it is not an integer constant simplifies
3982 the tests inside the loop below. */
3983 if (TREE_CODE (cond) != INTEGER_CST)
3986 /* The time complexity here is O(N*lg(N)) worst case, but for the
3987 common case of monotonically increasing enumerators, it is
3988 O(N), since the nature of the splay tree will keep the next
3989 element adjacent to the root at all times. */
3991 for (chain = TYPE_VALUES (type); chain; chain = TREE_CHAIN (chain))
3993 tree value = TREE_VALUE (chain);
3994 node = splay_tree_lookup (cases, (splay_tree_key) value);
3997 /* Mark the CASE_LOW part of the case entry as seen. */
3998 tree label = (tree) node->value;
3999 CASE_LOW_SEEN (label) = 1;
4003 /* Even though there wasn't an exact match, there might be a
4004 case range which includes the enumator's value. */
4005 node = splay_tree_predecessor (cases, (splay_tree_key) value);
4006 if (node && CASE_HIGH ((tree) node->value))
4008 tree label = (tree) node->value;
4009 int cmp = tree_int_cst_compare (CASE_HIGH (label), value);
4012 /* If we match the upper bound exactly, mark the CASE_HIGH
4013 part of the case entry as seen. */
4015 CASE_HIGH_SEEN (label) = 1;
4020 /* We've now determined that this enumerated literal isn't
4021 handled by the case labels of the switch statement. */
4023 /* If the switch expression is a constant, we only really care
4024 about whether that constant is handled by the switch. */
4025 if (cond && tree_int_cst_compare (cond, value))
4028 warning (0, "%Henumeration value %qE not handled in switch",
4029 &switch_location, TREE_PURPOSE (chain));
4032 /* Warn if there are case expressions that don't correspond to
4033 enumerators. This can occur since C and C++ don't enforce
4034 type-checking of assignments to enumeration variables.
4036 The time complexity here is now always O(N) worst case, since
4037 we should have marked both the lower bound and upper bound of
4038 every disjoint case label, with CASE_LOW_SEEN and CASE_HIGH_SEEN
4039 above. This scan also resets those fields. */
4040 splay_tree_foreach (cases, match_case_to_enum, type);
4043 /* Finish an expression taking the address of LABEL (an
4044 IDENTIFIER_NODE). Returns an expression for the address. */
4047 finish_label_address_expr (tree label)
4052 pedwarn ("taking the address of a label is non-standard");
4054 if (label == error_mark_node)
4055 return error_mark_node;
4057 label = lookup_label (label);
4058 if (label == NULL_TREE)
4059 result = null_pointer_node;
4062 TREE_USED (label) = 1;
4063 result = build1 (ADDR_EXPR, ptr_type_node, label);
4064 /* The current function in not necessarily uninlinable.
4065 Computed gotos are incompatible with inlining, but the value
4066 here could be used only in a diagnostic, for example. */
4072 /* Hook used by expand_expr to expand language-specific tree codes. */
4073 /* The only things that should go here are bits needed to expand
4074 constant initializers. Everything else should be handled by the
4075 gimplification routines. */
4078 c_expand_expr (tree exp, rtx target, enum machine_mode tmode,
4079 int modifier /* Actually enum_modifier. */,
4082 switch (TREE_CODE (exp))
4084 case COMPOUND_LITERAL_EXPR:
4086 /* Initialize the anonymous variable declared in the compound
4087 literal, then return the variable. */
4088 tree decl = COMPOUND_LITERAL_EXPR_DECL (exp);
4089 emit_local_var (decl);
4090 return expand_expr_real (decl, target, tmode, modifier, alt_rtl);
4098 /* Hook used by staticp to handle language-specific tree codes. */
4101 c_staticp (tree exp)
4103 return (TREE_CODE (exp) == COMPOUND_LITERAL_EXPR
4104 && TREE_STATIC (COMPOUND_LITERAL_EXPR_DECL (exp))
4109 /* Given a boolean expression ARG, return a tree representing an increment
4110 or decrement (as indicated by CODE) of ARG. The front end must check for
4111 invalid cases (e.g., decrement in C++). */
4113 boolean_increment (enum tree_code code, tree arg)
4116 tree true_res = boolean_true_node;
4118 arg = stabilize_reference (arg);
4121 case PREINCREMENT_EXPR:
4122 val = build2 (MODIFY_EXPR, TREE_TYPE (arg), arg, true_res);
4124 case POSTINCREMENT_EXPR:
4125 val = build2 (MODIFY_EXPR, TREE_TYPE (arg), arg, true_res);
4126 arg = save_expr (arg);
4127 val = build2 (COMPOUND_EXPR, TREE_TYPE (arg), val, arg);
4128 val = build2 (COMPOUND_EXPR, TREE_TYPE (arg), arg, val);
4130 case PREDECREMENT_EXPR:
4131 val = build2 (MODIFY_EXPR, TREE_TYPE (arg), arg,
4132 invert_truthvalue (arg));
4134 case POSTDECREMENT_EXPR:
4135 val = build2 (MODIFY_EXPR, TREE_TYPE (arg), arg,
4136 invert_truthvalue (arg));
4137 arg = save_expr (arg);
4138 val = build2 (COMPOUND_EXPR, TREE_TYPE (arg), val, arg);
4139 val = build2 (COMPOUND_EXPR, TREE_TYPE (arg), arg, val);
4144 TREE_SIDE_EFFECTS (val) = 1;
4148 /* Built-in macros for stddef.h, that require macros defined in this
4151 c_stddef_cpp_builtins(void)
4153 builtin_define_with_value ("__SIZE_TYPE__", SIZE_TYPE, 0);
4154 builtin_define_with_value ("__PTRDIFF_TYPE__", PTRDIFF_TYPE, 0);
4155 builtin_define_with_value ("__WCHAR_TYPE__", MODIFIED_WCHAR_TYPE, 0);
4156 builtin_define_with_value ("__WINT_TYPE__", WINT_TYPE, 0);
4157 builtin_define_with_value ("__INTMAX_TYPE__", INTMAX_TYPE, 0);
4158 builtin_define_with_value ("__UINTMAX_TYPE__", UINTMAX_TYPE, 0);
4162 c_init_attributes (void)
4164 /* Fill in the built_in_attributes array. */
4165 #define DEF_ATTR_NULL_TREE(ENUM) \
4166 built_in_attributes[(int) ENUM] = NULL_TREE;
4167 #define DEF_ATTR_INT(ENUM, VALUE) \
4168 built_in_attributes[(int) ENUM] = build_int_cst (NULL_TREE, VALUE);
4169 #define DEF_ATTR_IDENT(ENUM, STRING) \
4170 built_in_attributes[(int) ENUM] = get_identifier (STRING);
4171 #define DEF_ATTR_TREE_LIST(ENUM, PURPOSE, VALUE, CHAIN) \
4172 built_in_attributes[(int) ENUM] \
4173 = tree_cons (built_in_attributes[(int) PURPOSE], \
4174 built_in_attributes[(int) VALUE], \
4175 built_in_attributes[(int) CHAIN]);
4176 #include "builtin-attrs.def"
4177 #undef DEF_ATTR_NULL_TREE
4179 #undef DEF_ATTR_IDENT
4180 #undef DEF_ATTR_TREE_LIST
4183 /* Attribute handlers common to C front ends. */
4185 /* Handle a "packed" attribute; arguments as in
4186 struct attribute_spec.handler. */
4189 handle_packed_attribute (tree *node, tree name, tree ARG_UNUSED (args),
4190 int flags, bool *no_add_attrs)
4194 if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
4195 *node = build_variant_type_copy (*node);
4196 TYPE_PACKED (*node) = 1;
4198 else if (TREE_CODE (*node) == FIELD_DECL)
4200 if (TYPE_ALIGN (TREE_TYPE (*node)) <= BITS_PER_UNIT)
4201 warning (OPT_Wattributes,
4202 "%qE attribute ignored for field of type %qT",
4203 name, TREE_TYPE (*node));
4205 DECL_PACKED (*node) = 1;
4207 /* We can't set DECL_PACKED for a VAR_DECL, because the bit is
4208 used for DECL_REGISTER. It wouldn't mean anything anyway.
4209 We can't set DECL_PACKED on the type of a TYPE_DECL, because
4210 that changes what the typedef is typing. */
4213 warning (OPT_Wattributes, "%qE attribute ignored", name);
4214 *no_add_attrs = true;
4220 /* Handle a "nocommon" attribute; arguments as in
4221 struct attribute_spec.handler. */
4224 handle_nocommon_attribute (tree *node, tree name,
4225 tree ARG_UNUSED (args),
4226 int ARG_UNUSED (flags), bool *no_add_attrs)
4228 if (TREE_CODE (*node) == VAR_DECL)
4229 DECL_COMMON (*node) = 0;
4232 warning (OPT_Wattributes, "%qE attribute ignored", name);
4233 *no_add_attrs = true;
4239 /* Handle a "common" attribute; arguments as in
4240 struct attribute_spec.handler. */
4243 handle_common_attribute (tree *node, tree name, tree ARG_UNUSED (args),
4244 int ARG_UNUSED (flags), bool *no_add_attrs)
4246 if (TREE_CODE (*node) == VAR_DECL)
4247 DECL_COMMON (*node) = 1;
4250 warning (OPT_Wattributes, "%qE attribute ignored", name);
4251 *no_add_attrs = true;
4257 /* Handle a "noreturn" attribute; arguments as in
4258 struct attribute_spec.handler. */
4261 handle_noreturn_attribute (tree *node, tree name, tree ARG_UNUSED (args),
4262 int ARG_UNUSED (flags), bool *no_add_attrs)
4264 tree type = TREE_TYPE (*node);
4266 /* See FIXME comment in c_common_attribute_table. */
4267 /* APPLE LOCAL begin radar 4727659 */
4268 if (TREE_CODE (*node) == FUNCTION_DECL
4269 || objc_method_decl (TREE_CODE (*node)))
4270 /* APPLE LOCAL end radar 4727659 */
4271 TREE_THIS_VOLATILE (*node) = 1;
4272 else if (TREE_CODE (type) == POINTER_TYPE
4273 && TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE)
4275 = build_pointer_type
4276 (build_type_variant (TREE_TYPE (type),
4277 TYPE_READONLY (TREE_TYPE (type)), 1));
4278 /* APPLE LOCAL begin radar 6237713 */
4279 else if (TREE_CODE (type) == BLOCK_POINTER_TYPE
4280 && TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE)
4282 = build_block_pointer_type
4283 (build_type_variant (TREE_TYPE (type),
4284 TYPE_READONLY (TREE_TYPE (type)), 1));
4285 /* APPLE LOCAL end radar 6237713 */
4288 warning (OPT_Wattributes, "%qE attribute ignored", name);
4289 *no_add_attrs = true;
4295 /* Handle a "noinline" attribute; arguments as in
4296 struct attribute_spec.handler. */
4299 handle_noinline_attribute (tree *node, tree name,
4300 tree ARG_UNUSED (args),
4301 int ARG_UNUSED (flags), bool *no_add_attrs)
4303 if (TREE_CODE (*node) == FUNCTION_DECL)
4304 DECL_UNINLINABLE (*node) = 1;
4307 warning (OPT_Wattributes, "%qE attribute ignored", name);
4308 *no_add_attrs = true;
4314 /* Handle a "always_inline" attribute; arguments as in
4315 struct attribute_spec.handler. */
4318 handle_always_inline_attribute (tree *node, tree name,
4319 tree ARG_UNUSED (args),
4320 int ARG_UNUSED (flags),
4323 if (TREE_CODE (*node) == FUNCTION_DECL)
4325 /* Do nothing else, just set the attribute. We'll get at
4326 it later with lookup_attribute. */
4330 warning (OPT_Wattributes, "%qE attribute ignored", name);
4331 *no_add_attrs = true;
4337 /* Handle a "gnu_inline" attribute; arguments as in
4338 struct attribute_spec.handler. */
4341 handle_gnu_inline_attribute (tree *node, tree name,
4342 tree ARG_UNUSED (args),
4343 int ARG_UNUSED (flags),
4346 if (TREE_CODE (*node) == FUNCTION_DECL && DECL_DECLARED_INLINE_P (*node))
4348 /* Do nothing else, just set the attribute. We'll get at
4349 it later with lookup_attribute. */
4353 warning (OPT_Wattributes, "%qE attribute ignored", name);
4354 *no_add_attrs = true;
4360 /* Handle a "flatten" attribute; arguments as in
4361 struct attribute_spec.handler. */
4364 handle_flatten_attribute (tree *node, tree name,
4365 tree args ATTRIBUTE_UNUSED,
4366 int flags ATTRIBUTE_UNUSED, bool *no_add_attrs)
4368 if (TREE_CODE (*node) == FUNCTION_DECL)
4369 /* Do nothing else, just set the attribute. We'll get at
4370 it later with lookup_attribute. */
4374 warning (OPT_Wattributes, "%qE attribute ignored", name);
4375 *no_add_attrs = true;
4382 /* Handle a "used" attribute; arguments as in
4383 struct attribute_spec.handler. */
4386 handle_used_attribute (tree *pnode, tree name, tree ARG_UNUSED (args),
4387 int ARG_UNUSED (flags), bool *no_add_attrs)
4391 if (TREE_CODE (node) == FUNCTION_DECL
4392 || (TREE_CODE (node) == VAR_DECL && TREE_STATIC (node)))
4394 TREE_USED (node) = 1;
4395 DECL_PRESERVE_P (node) = 1;
4399 warning (OPT_Wattributes, "%qE attribute ignored", name);
4400 *no_add_attrs = true;
4406 /* Handle a "unused" attribute; arguments as in
4407 struct attribute_spec.handler. */
4410 handle_unused_attribute (tree *node, tree name, tree ARG_UNUSED (args),
4411 int flags, bool *no_add_attrs)
4417 if (TREE_CODE (decl) == PARM_DECL
4418 || TREE_CODE (decl) == VAR_DECL
4419 || TREE_CODE (decl) == FUNCTION_DECL
4420 /* APPLE LOCAL begin for-fsf-4_4 3274130 5295549 */ \
4421 || (TREE_CODE (decl) == LABEL_DECL
4422 && ! DECL_ARTIFICIAL (decl))
4423 /* APPLE LOCAL end for-fsf-4_4 3274130 5295549 */ \
4424 || TREE_CODE (decl) == TYPE_DECL)
4425 TREE_USED (decl) = 1;
4428 warning (OPT_Wattributes, "%qE attribute ignored", name);
4429 *no_add_attrs = true;
4434 if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
4435 *node = build_variant_type_copy (*node);
4436 TREE_USED (*node) = 1;
4442 /* Handle a "externally_visible" attribute; arguments as in
4443 struct attribute_spec.handler. */
4446 handle_externally_visible_attribute (tree *pnode, tree name,
4447 tree ARG_UNUSED (args),
4448 int ARG_UNUSED (flags),
4453 if (TREE_CODE (node) == FUNCTION_DECL || TREE_CODE (node) == VAR_DECL)
4455 if ((!TREE_STATIC (node) && TREE_CODE (node) != FUNCTION_DECL
4456 && !DECL_EXTERNAL (node)) || !TREE_PUBLIC (node))
4458 warning (OPT_Wattributes,
4459 "%qE attribute have effect only on public objects", name);
4460 *no_add_attrs = true;
4465 warning (OPT_Wattributes, "%qE attribute ignored", name);
4466 *no_add_attrs = true;
4472 /* Handle a "const" attribute; arguments as in
4473 struct attribute_spec.handler. */
4476 handle_const_attribute (tree *node, tree name, tree ARG_UNUSED (args),
4477 int ARG_UNUSED (flags), bool *no_add_attrs)
4479 tree type = TREE_TYPE (*node);
4481 /* See FIXME comment on noreturn in c_common_attribute_table. */
4482 if (TREE_CODE (*node) == FUNCTION_DECL)
4483 TREE_READONLY (*node) = 1;
4484 else if (TREE_CODE (type) == POINTER_TYPE
4485 && TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE)
4487 = build_pointer_type
4488 (build_type_variant (TREE_TYPE (type), 1,
4489 TREE_THIS_VOLATILE (TREE_TYPE (type))));
4492 warning (OPT_Wattributes, "%qE attribute ignored", name);
4493 *no_add_attrs = true;
4499 /* Handle a "transparent_union" attribute; arguments as in
4500 struct attribute_spec.handler. */
4503 handle_transparent_union_attribute (tree *node, tree name,
4504 tree ARG_UNUSED (args), int flags,
4509 *no_add_attrs = true;
4513 if (TREE_CODE (*node) != TYPE_DECL)
4515 node = &TREE_TYPE (*node);
4518 else if (TYPE_P (*node))
4523 if (TREE_CODE (type) == UNION_TYPE)
4525 /* When IN_PLACE is set, leave the check for FIELDS and MODE to
4526 the code in finish_struct. */
4527 if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
4529 if (TYPE_FIELDS (type) == NULL_TREE
4530 || TYPE_MODE (type) != DECL_MODE (TYPE_FIELDS (type)))
4533 /* A type variant isn't good enough, since we don't a cast
4534 to such a type removed as a no-op. */
4535 *node = type = build_duplicate_type (type);
4538 TYPE_TRANSPARENT_UNION (type) = 1;
4543 warning (OPT_Wattributes, "%qE attribute ignored", name);
4547 /* Handle a "constructor" attribute; arguments as in
4548 struct attribute_spec.handler. */
4551 handle_constructor_attribute (tree *node, tree name,
4552 tree ARG_UNUSED (args),
4553 int ARG_UNUSED (flags),
4557 tree type = TREE_TYPE (decl);
4559 if (TREE_CODE (decl) == FUNCTION_DECL
4560 && TREE_CODE (type) == FUNCTION_TYPE
4561 && decl_function_context (decl) == 0)
4563 DECL_STATIC_CONSTRUCTOR (decl) = 1;
4564 TREE_USED (decl) = 1;
4568 warning (OPT_Wattributes, "%qE attribute ignored", name);
4569 *no_add_attrs = true;
4575 /* Handle a "destructor" attribute; arguments as in
4576 struct attribute_spec.handler. */
4579 handle_destructor_attribute (tree *node, tree name,
4580 tree ARG_UNUSED (args),
4581 int ARG_UNUSED (flags),
4585 tree type = TREE_TYPE (decl);
4587 if (TREE_CODE (decl) == FUNCTION_DECL
4588 && TREE_CODE (type) == FUNCTION_TYPE
4589 && decl_function_context (decl) == 0)
4591 DECL_STATIC_DESTRUCTOR (decl) = 1;
4592 TREE_USED (decl) = 1;
4596 warning (OPT_Wattributes, "%qE attribute ignored", name);
4597 *no_add_attrs = true;
4603 /* Handle a "mode" attribute; arguments as in
4604 struct attribute_spec.handler. */
4607 handle_mode_attribute (tree *node, tree name, tree args,
4608 int ARG_UNUSED (flags), bool *no_add_attrs)
4612 *no_add_attrs = true;
4614 if (TREE_CODE (TREE_VALUE (args)) != IDENTIFIER_NODE)
4615 warning (OPT_Wattributes, "%qE attribute ignored", name);
4619 const char *p = IDENTIFIER_POINTER (TREE_VALUE (args));
4620 int len = strlen (p);
4621 enum machine_mode mode = VOIDmode;
4625 if (len > 4 && p[0] == '_' && p[1] == '_'
4626 && p[len - 1] == '_' && p[len - 2] == '_')
4628 char *newp = (char *) alloca (len - 1);
4630 strcpy (newp, &p[2]);
4631 newp[len - 4] = '\0';
4635 /* Change this type to have a type with the specified mode.
4636 First check for the special modes. */
4637 if (!strcmp (p, "byte"))
4639 else if (!strcmp (p, "word"))
4641 else if (!strcmp (p, "pointer"))
4644 for (j = 0; j < NUM_MACHINE_MODES; j++)
4645 if (!strcmp (p, GET_MODE_NAME (j)))
4647 mode = (enum machine_mode) j;
4651 if (mode == VOIDmode)
4653 error ("unknown machine mode %qs", p);
4658 switch (GET_MODE_CLASS (mode))
4661 case MODE_PARTIAL_INT:
4663 case MODE_DECIMAL_FLOAT:
4664 valid_mode = targetm.scalar_mode_supported_p (mode);
4667 case MODE_COMPLEX_INT:
4668 case MODE_COMPLEX_FLOAT:
4669 valid_mode = targetm.scalar_mode_supported_p (GET_MODE_INNER (mode));
4672 case MODE_VECTOR_INT:
4673 case MODE_VECTOR_FLOAT:
4674 warning (OPT_Wattributes, "specifying vector types with "
4675 "__attribute__ ((mode)) is deprecated");
4676 warning (OPT_Wattributes,
4677 "use __attribute__ ((vector_size)) instead");
4678 valid_mode = vector_mode_valid_p (mode);
4686 error ("unable to emulate %qs", p);
4690 if (POINTER_TYPE_P (type))
4692 tree (*fn)(tree, enum machine_mode, bool);
4694 if (!targetm.valid_pointer_mode (mode))
4696 error ("invalid pointer mode %qs", p);
4700 if (TREE_CODE (type) == POINTER_TYPE)
4701 fn = build_pointer_type_for_mode;
4703 fn = build_reference_type_for_mode;
4704 typefm = fn (TREE_TYPE (type), mode, false);
4707 typefm = lang_hooks.types.type_for_mode (mode, TYPE_UNSIGNED (type));
4709 if (typefm == NULL_TREE)
4711 error ("no data type for mode %qs", p);
4714 else if (TREE_CODE (type) == ENUMERAL_TYPE)
4716 /* For enumeral types, copy the precision from the integer
4717 type returned above. If not an INTEGER_TYPE, we can't use
4718 this mode for this type. */
4719 if (TREE_CODE (typefm) != INTEGER_TYPE)
4721 error ("cannot use mode %qs for enumeral types", p);
4725 if (flags & ATTR_FLAG_TYPE_IN_PLACE)
4727 TYPE_PRECISION (type) = TYPE_PRECISION (typefm);
4732 /* We cannot build a type variant, as there's code that assumes
4733 that TYPE_MAIN_VARIANT has the same mode. This includes the
4734 debug generators. Instead, create a subrange type. This
4735 results in all of the enumeral values being emitted only once
4736 in the original, and the subtype gets them by reference. */
4737 if (TYPE_UNSIGNED (type))
4738 typefm = make_unsigned_type (TYPE_PRECISION (typefm));
4740 typefm = make_signed_type (TYPE_PRECISION (typefm));
4741 TREE_TYPE (typefm) = type;
4744 else if (VECTOR_MODE_P (mode)
4745 ? TREE_CODE (type) != TREE_CODE (TREE_TYPE (typefm))
4746 : TREE_CODE (type) != TREE_CODE (typefm))
4748 error ("mode %qs applied to inappropriate type", p);
4758 /* Handle a "section" attribute; arguments as in
4759 struct attribute_spec.handler. */
4762 handle_section_attribute (tree *node, tree ARG_UNUSED (name), tree args,
4763 int ARG_UNUSED (flags), bool *no_add_attrs)
4767 if (targetm.have_named_sections)
4769 user_defined_section_attribute = true;
4771 if ((TREE_CODE (decl) == FUNCTION_DECL
4772 || TREE_CODE (decl) == VAR_DECL)
4773 && TREE_CODE (TREE_VALUE (args)) == STRING_CST)
4775 if (TREE_CODE (decl) == VAR_DECL
4776 && current_function_decl != NULL_TREE
4777 && !TREE_STATIC (decl))
4779 error ("%Jsection attribute cannot be specified for "
4780 "local variables", decl);
4781 *no_add_attrs = true;
4784 /* The decl may have already been given a section attribute
4785 from a previous declaration. Ensure they match. */
4786 else if (DECL_SECTION_NAME (decl) != NULL_TREE
4787 && strcmp (TREE_STRING_POINTER (DECL_SECTION_NAME (decl)),
4788 TREE_STRING_POINTER (TREE_VALUE (args))) != 0)
4790 error ("section of %q+D conflicts with previous declaration",
4792 *no_add_attrs = true;
4795 DECL_SECTION_NAME (decl) = TREE_VALUE (args);
4799 error ("section attribute not allowed for %q+D", *node);
4800 *no_add_attrs = true;
4805 error ("%Jsection attributes are not supported for this target", *node);
4806 *no_add_attrs = true;
4812 /* Handle a "aligned" attribute; arguments as in
4813 struct attribute_spec.handler. */
4816 handle_aligned_attribute (tree *node, tree ARG_UNUSED (name), tree args,
4817 int flags, bool *no_add_attrs)
4819 tree decl = NULL_TREE;
4822 tree align_expr = (args ? TREE_VALUE (args)
4823 : size_int (BIGGEST_ALIGNMENT / BITS_PER_UNIT));
4829 type = &TREE_TYPE (decl);
4830 is_type = TREE_CODE (*node) == TYPE_DECL;
4832 else if (TYPE_P (*node))
4833 type = node, is_type = 1;
4835 if (TREE_CODE (align_expr) != INTEGER_CST)
4837 error ("requested alignment is not a constant");
4838 *no_add_attrs = true;
4840 else if ((i = tree_log2 (align_expr)) == -1)
4842 error ("requested alignment is not a power of 2");
4843 *no_add_attrs = true;
4845 else if (i > HOST_BITS_PER_INT - 2)
4847 error ("requested alignment is too large");
4848 *no_add_attrs = true;
4852 /* If we have a TYPE_DECL, then copy the type, so that we
4853 don't accidentally modify a builtin type. See pushdecl. */
4854 if (decl && TREE_TYPE (decl) != error_mark_node
4855 && DECL_ORIGINAL_TYPE (decl) == NULL_TREE)
4857 tree tt = TREE_TYPE (decl);
4858 *type = build_variant_type_copy (*type);
4859 DECL_ORIGINAL_TYPE (decl) = tt;
4860 TYPE_NAME (*type) = decl;
4861 TREE_USED (*type) = TREE_USED (decl);
4862 TREE_TYPE (decl) = *type;
4864 else if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
4865 *type = build_variant_type_copy (*type);
4867 TYPE_ALIGN (*type) = (1 << i) * BITS_PER_UNIT;
4868 TYPE_USER_ALIGN (*type) = 1;
4870 else if (! VAR_OR_FUNCTION_DECL_P (decl)
4871 /* APPLE LOCAL begin for-fsf-4_4 3274130 5295549 */ \
4872 && TREE_CODE (decl) != FIELD_DECL
4873 && TREE_CODE (decl) != LABEL_DECL)
4874 /* APPLE LOCAL end for-fsf-4_4 3274130 5295549 */ \
4876 error ("alignment may not be specified for %q+D", decl);
4877 *no_add_attrs = true;
4879 else if (TREE_CODE (decl) == FUNCTION_DECL
4880 && DECL_ALIGN (decl) > (1 << i) * BITS_PER_UNIT)
4882 if (DECL_USER_ALIGN (decl))
4883 error ("alignment for %q+D was previously specified as %d "
4884 "and may not be decreased", decl,
4885 DECL_ALIGN (decl) / BITS_PER_UNIT);
4887 error ("alignment for %q+D must be at least %d", decl,
4888 DECL_ALIGN (decl) / BITS_PER_UNIT);
4889 *no_add_attrs = true;
4893 DECL_ALIGN (decl) = (1 << i) * BITS_PER_UNIT;
4894 DECL_USER_ALIGN (decl) = 1;
4900 /* Handle a "weak" attribute; arguments as in
4901 struct attribute_spec.handler. */
4904 handle_weak_attribute (tree *node, tree name,
4905 tree ARG_UNUSED (args),
4906 int ARG_UNUSED (flags),
4907 bool * ARG_UNUSED (no_add_attrs))
4909 if (TREE_CODE (*node) == FUNCTION_DECL
4910 || TREE_CODE (*node) == VAR_DECL)
4911 declare_weak (*node);
4912 /* APPLE LOCAL begin weak types 5954418 */
4913 else if (!DECL_P (*node)
4914 /* If the weak flag can be associated with something else,
4916 && (flags & (ATTR_FLAG_FUNCTION_NEXT
4917 |ATTR_FLAG_DECL_NEXT
4918 |ATTR_FLAG_ARRAY_NEXT)))
4920 *no_add_attrs = true;
4921 return tree_cons (name, args, NULL_TREE);
4923 else if (! targetm.cxx.class_data_always_comdat ()
4924 && TREE_CODE (*node) == RECORD_TYPE)
4926 /* Leave on the type for the C++ front end */
4928 /* APPLE LOCAL end weak types 5954418 */
4930 warning (OPT_Wattributes, "%qE attribute ignored", name);
4936 /* Handle an "alias" attribute; arguments as in
4937 struct attribute_spec.handler. */
4940 handle_alias_attribute (tree *node, tree name, tree args,
4941 int ARG_UNUSED (flags), bool *no_add_attrs)
4945 if ((TREE_CODE (decl) == FUNCTION_DECL && DECL_INITIAL (decl))
4946 || (TREE_CODE (decl) != FUNCTION_DECL
4947 && TREE_PUBLIC (decl) && !DECL_EXTERNAL (decl))
4948 /* A static variable declaration is always a tentative definition,
4949 but the alias is a non-tentative definition which overrides. */
4950 || (TREE_CODE (decl) != FUNCTION_DECL
4951 && ! TREE_PUBLIC (decl) && DECL_INITIAL (decl)))
4953 error ("%q+D defined both normally and as an alias", decl);
4954 *no_add_attrs = true;
4957 /* Note that the very first time we process a nested declaration,
4958 decl_function_context will not be set. Indeed, *would* never
4959 be set except for the DECL_INITIAL/DECL_EXTERNAL frobbery that
4960 we do below. After such frobbery, pushdecl would set the context.
4961 In any case, this is never what we want. */
4962 else if (decl_function_context (decl) == 0 && current_function_decl == NULL)
4966 id = TREE_VALUE (args);
4967 if (TREE_CODE (id) != STRING_CST)
4969 error ("alias argument not a string");
4970 *no_add_attrs = true;
4973 id = get_identifier (TREE_STRING_POINTER (id));
4974 /* This counts as a use of the object pointed to. */
4977 if (TREE_CODE (decl) == FUNCTION_DECL)
4978 DECL_INITIAL (decl) = error_mark_node;
4981 if (lookup_attribute ("weakref", DECL_ATTRIBUTES (decl)))
4982 DECL_EXTERNAL (decl) = 1;
4984 DECL_EXTERNAL (decl) = 0;
4985 TREE_STATIC (decl) = 1;
4990 warning (OPT_Wattributes, "%qE attribute ignored", name);
4991 *no_add_attrs = true;
4997 /* Handle a "weakref" attribute; arguments as in struct
4998 attribute_spec.handler. */
5001 handle_weakref_attribute (tree *node, tree ARG_UNUSED (name), tree args,
5002 int flags, bool *no_add_attrs)
5004 tree attr = NULL_TREE;
5006 /* We must ignore the attribute when it is associated with
5007 local-scoped decls, since attribute alias is ignored and many
5008 such symbols do not even have a DECL_WEAK field. */
5009 if (decl_function_context (*node) || current_function_decl)
5011 warning (OPT_Wattributes, "%qE attribute ignored", name);
5012 *no_add_attrs = true;
5016 /* The idea here is that `weakref("name")' mutates into `weakref,
5017 alias("name")', and weakref without arguments, in turn,
5018 implicitly adds weak. */
5022 attr = tree_cons (get_identifier ("alias"), args, attr);
5023 attr = tree_cons (get_identifier ("weakref"), NULL_TREE, attr);
5025 *no_add_attrs = true;
5027 decl_attributes (node, attr, flags);
5031 if (lookup_attribute ("alias", DECL_ATTRIBUTES (*node)))
5032 error ("%Jweakref attribute must appear before alias attribute",
5035 /* Can't call declare_weak because it wants this to be TREE_PUBLIC,
5036 and that isn't supported; and because it wants to add it to
5037 the list of weak decls, which isn't helpful. */
5038 DECL_WEAK (*node) = 1;
5044 /* Handle an "visibility" attribute; arguments as in
5045 struct attribute_spec.handler. */
5048 handle_visibility_attribute (tree *node, tree name, tree args,
5049 int ARG_UNUSED (flags),
5050 bool *ARG_UNUSED (no_add_attrs))
5053 tree id = TREE_VALUE (args);
5054 enum symbol_visibility vis;
5058 if (TREE_CODE (*node) == ENUMERAL_TYPE)
5060 else if (TREE_CODE (*node) != RECORD_TYPE && TREE_CODE (*node) != UNION_TYPE)
5062 warning (OPT_Wattributes, "%qE attribute ignored on non-class types",
5066 else if (TYPE_FIELDS (*node))
5068 error ("%qE attribute ignored because %qT is already defined",
5073 else if (decl_function_context (decl) != 0 || !TREE_PUBLIC (decl))
5075 warning (OPT_Wattributes, "%qE attribute ignored", name);
5079 if (TREE_CODE (id) != STRING_CST)
5081 error ("visibility argument not a string");
5085 /* If this is a type, set the visibility on the type decl. */
5088 decl = TYPE_NAME (decl);
5091 if (TREE_CODE (decl) == IDENTIFIER_NODE)
5093 warning (OPT_Wattributes, "%qE attribute ignored on types",
5099 if (strcmp (TREE_STRING_POINTER (id), "default") == 0)
5100 vis = VISIBILITY_DEFAULT;
5101 else if (strcmp (TREE_STRING_POINTER (id), "internal") == 0)
5102 vis = VISIBILITY_INTERNAL;
5103 else if (strcmp (TREE_STRING_POINTER (id), "hidden") == 0)
5104 vis = VISIBILITY_HIDDEN;
5105 else if (strcmp (TREE_STRING_POINTER (id), "protected") == 0)
5106 vis = VISIBILITY_PROTECTED;
5109 error ("visibility argument must be one of \"default\", \"hidden\", \"protected\" or \"internal\"");
5110 vis = VISIBILITY_DEFAULT;
5113 if (DECL_VISIBILITY_SPECIFIED (decl)
5114 && vis != DECL_VISIBILITY (decl)
5115 && lookup_attribute ("visibility", (TYPE_P (*node)
5116 ? TYPE_ATTRIBUTES (*node)
5117 : DECL_ATTRIBUTES (decl))))
5118 error ("%qD redeclared with different visibility", decl);
5120 DECL_VISIBILITY (decl) = vis;
5121 DECL_VISIBILITY_SPECIFIED (decl) = 1;
5123 /* Go ahead and attach the attribute to the node as well. This is needed
5124 so we can determine whether we have VISIBILITY_DEFAULT because the
5125 visibility was not specified, or because it was explicitly overridden
5126 from the containing scope. */
5131 /* Determine the ELF symbol visibility for DECL, which is either a
5132 variable or a function. It is an error to use this function if a
5133 definition of DECL is not available in this translation unit.
5134 Returns true if the final visibility has been determined by this
5135 function; false if the caller is free to make additional
5139 c_determine_visibility (tree decl)
5141 gcc_assert (TREE_CODE (decl) == VAR_DECL
5142 || TREE_CODE (decl) == FUNCTION_DECL);
5144 /* If the user explicitly specified the visibility with an
5145 attribute, honor that. DECL_VISIBILITY will have been set during
5146 the processing of the attribute. We check for an explicit
5147 attribute, rather than just checking DECL_VISIBILITY_SPECIFIED,
5148 to distinguish the use of an attribute from the use of a "#pragma
5149 GCC visibility push(...)"; in the latter case we still want other
5150 considerations to be able to overrule the #pragma. */
5151 if (lookup_attribute ("visibility", DECL_ATTRIBUTES (decl)))
5154 /* Anything that is exported must have default visibility. */
5155 if (TARGET_DLLIMPORT_DECL_ATTRIBUTES
5156 && lookup_attribute ("dllexport", DECL_ATTRIBUTES (decl)))
5158 DECL_VISIBILITY (decl) = VISIBILITY_DEFAULT;
5159 DECL_VISIBILITY_SPECIFIED (decl) = 1;
5163 /* Set default visibility to whatever the user supplied with
5164 visibility_specified depending on #pragma GCC visibility. */
5165 if (!DECL_VISIBILITY_SPECIFIED (decl))
5167 DECL_VISIBILITY (decl) = default_visibility;
5168 DECL_VISIBILITY_SPECIFIED (decl) = visibility_options.inpragma;
5173 /* Handle an "tls_model" attribute; arguments as in
5174 struct attribute_spec.handler. */
5177 handle_tls_model_attribute (tree *node, tree name, tree args,
5178 int ARG_UNUSED (flags), bool *no_add_attrs)
5182 enum tls_model kind;
5184 *no_add_attrs = true;
5186 if (!DECL_THREAD_LOCAL_P (decl))
5188 warning (OPT_Wattributes, "%qE attribute ignored", name);
5192 kind = DECL_TLS_MODEL (decl);
5193 id = TREE_VALUE (args);
5194 if (TREE_CODE (id) != STRING_CST)
5196 error ("tls_model argument not a string");
5200 if (!strcmp (TREE_STRING_POINTER (id), "local-exec"))
5201 kind = TLS_MODEL_LOCAL_EXEC;
5202 else if (!strcmp (TREE_STRING_POINTER (id), "initial-exec"))
5203 kind = TLS_MODEL_INITIAL_EXEC;
5204 else if (!strcmp (TREE_STRING_POINTER (id), "local-dynamic"))
5205 kind = optimize ? TLS_MODEL_LOCAL_DYNAMIC : TLS_MODEL_GLOBAL_DYNAMIC;
5206 else if (!strcmp (TREE_STRING_POINTER (id), "global-dynamic"))
5207 kind = TLS_MODEL_GLOBAL_DYNAMIC;
5209 error ("tls_model argument must be one of \"local-exec\", \"initial-exec\", \"local-dynamic\" or \"global-dynamic\"");
5211 DECL_TLS_MODEL (decl) = kind;
5215 /* Handle a "no_instrument_function" attribute; arguments as in
5216 struct attribute_spec.handler. */
5219 handle_no_instrument_function_attribute (tree *node, tree name,
5220 tree ARG_UNUSED (args),
5221 int ARG_UNUSED (flags),
5226 if (TREE_CODE (decl) != FUNCTION_DECL)
5228 error ("%J%qE attribute applies only to functions", decl, name);
5229 *no_add_attrs = true;
5231 else if (DECL_INITIAL (decl))
5233 error ("%Jcan%'t set %qE attribute after definition", decl, name);
5234 *no_add_attrs = true;
5237 DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (decl) = 1;
5242 /* Handle a "malloc" attribute; arguments as in
5243 struct attribute_spec.handler. */
5246 handle_malloc_attribute (tree *node, tree name, tree ARG_UNUSED (args),
5247 int ARG_UNUSED (flags), bool *no_add_attrs)
5249 if (TREE_CODE (*node) == FUNCTION_DECL
5250 && POINTER_TYPE_P (TREE_TYPE (TREE_TYPE (*node))))
5251 DECL_IS_MALLOC (*node) = 1;
5254 warning (OPT_Wattributes, "%qE attribute ignored", name);
5255 *no_add_attrs = true;
5261 /* Handle a "returns_twice" attribute; arguments as in
5262 struct attribute_spec.handler. */
5265 handle_returns_twice_attribute (tree *node, tree name, tree ARG_UNUSED (args),
5266 int ARG_UNUSED (flags), bool *no_add_attrs)
5268 if (TREE_CODE (*node) == FUNCTION_DECL)
5269 DECL_IS_RETURNS_TWICE (*node) = 1;
5272 warning (OPT_Wattributes, "%qE attribute ignored", name);
5273 *no_add_attrs = true;
5279 /* Handle a "no_limit_stack" attribute; arguments as in
5280 struct attribute_spec.handler. */
5283 handle_no_limit_stack_attribute (tree *node, tree name,
5284 tree ARG_UNUSED (args),
5285 int ARG_UNUSED (flags),
5290 if (TREE_CODE (decl) != FUNCTION_DECL)
5292 error ("%J%qE attribute applies only to functions", decl, name);
5293 *no_add_attrs = true;
5295 else if (DECL_INITIAL (decl))
5297 error ("%Jcan%'t set %qE attribute after definition", decl, name);
5298 *no_add_attrs = true;
5301 DECL_NO_LIMIT_STACK (decl) = 1;
5306 /* Handle a "pure" attribute; arguments as in
5307 struct attribute_spec.handler. */
5310 handle_pure_attribute (tree *node, tree name, tree ARG_UNUSED (args),
5311 int ARG_UNUSED (flags), bool *no_add_attrs)
5313 if (TREE_CODE (*node) == FUNCTION_DECL)
5314 DECL_IS_PURE (*node) = 1;
5315 /* ??? TODO: Support types. */
5318 warning (OPT_Wattributes, "%qE attribute ignored", name);
5319 *no_add_attrs = true;
5325 /* Handle a "no vops" attribute; arguments as in
5326 struct attribute_spec.handler. */
5329 handle_novops_attribute (tree *node, tree ARG_UNUSED (name),
5330 tree ARG_UNUSED (args), int ARG_UNUSED (flags),
5331 bool *ARG_UNUSED (no_add_attrs))
5333 gcc_assert (TREE_CODE (*node) == FUNCTION_DECL);
5334 DECL_IS_NOVOPS (*node) = 1;
5338 /* Handle a "deprecated" attribute; arguments as in
5339 struct attribute_spec.handler. */
5342 handle_deprecated_attribute (tree *node, tree name,
5343 tree ARG_UNUSED (args), int flags,
5346 tree type = NULL_TREE;
5348 tree what = NULL_TREE;
5353 type = TREE_TYPE (decl);
5355 if (TREE_CODE (decl) == TYPE_DECL
5356 || TREE_CODE (decl) == PARM_DECL
5357 || TREE_CODE (decl) == VAR_DECL
5358 || TREE_CODE (decl) == FUNCTION_DECL
5359 || TREE_CODE (decl) == FIELD_DECL)
5360 TREE_DEPRECATED (decl) = 1;
5364 else if (TYPE_P (*node))
5366 if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
5367 *node = build_variant_type_copy (*node);
5368 TREE_DEPRECATED (*node) = 1;
5376 *no_add_attrs = true;
5377 if (type && TYPE_NAME (type))
5379 if (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE)
5380 what = TYPE_NAME (*node);
5381 else if (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
5382 && DECL_NAME (TYPE_NAME (type)))
5383 what = DECL_NAME (TYPE_NAME (type));
5386 warning (OPT_Wattributes, "%qE attribute ignored for %qE", name, what);
5388 warning (OPT_Wattributes, "%qE attribute ignored", name);
5394 /* APPLE LOCAL begin "unavailable" attribute (Radar 2809697) --ilr */
5395 /* Handle a "unavailable" attribute; arguments as in
5396 struct attribute_spec.handler. */
5399 handle_unavailable_attribute (tree *node, tree name,
5400 tree args ATTRIBUTE_UNUSED,
5401 int flags ATTRIBUTE_UNUSED,
5404 tree type = NULL_TREE;
5406 const char *what = NULL;
5411 type = TREE_TYPE (decl);
5413 if (TREE_CODE (decl) == TYPE_DECL
5414 || TREE_CODE (decl) == PARM_DECL
5415 || TREE_CODE (decl) == VAR_DECL
5416 || TREE_CODE (decl) == FUNCTION_DECL
5417 /* APPLE LOCAL begin radar 3803157 - objc attribute */
5418 || TREE_CODE (decl) == FIELD_DECL
5419 || objc_method_decl (TREE_CODE (decl)))
5420 /* APPLE LOCAL end radar 3803157 - objc attribute */
5422 TREE_UNAVAILABLE (decl) = 1;
5427 else if (TYPE_P (*node))
5429 if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
5430 *node = build_variant_type_copy (*node);
5431 TREE_UNAVAILABLE (*node) = 1;
5439 *no_add_attrs = true;
5440 if (type && TYPE_NAME (type))
5442 if (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE)
5443 what = IDENTIFIER_POINTER (TYPE_NAME (*node));
5444 else if (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
5445 && DECL_NAME (TYPE_NAME (type)))
5446 what = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type)));
5449 warning (0, "`%s' attribute ignored for `%s'",
5450 IDENTIFIER_POINTER (name), what);
5452 warning (0, "`%s' attribute ignored", IDENTIFIER_POINTER (name));
5457 /* APPLE LOCAL end "unavailable" attribute --ilr */
5459 /* Handle a "vector_size" attribute; arguments as in
5460 struct attribute_spec.handler. */
5463 handle_vector_size_attribute (tree *node, tree name, tree args,
5464 int ARG_UNUSED (flags),
5467 unsigned HOST_WIDE_INT vecsize, nunits;
5468 enum machine_mode orig_mode;
5469 tree type = *node, new_type, size;
5471 *no_add_attrs = true;
5473 size = TREE_VALUE (args);
5475 if (!host_integerp (size, 1))
5477 warning (OPT_Wattributes, "%qE attribute ignored", name);
5481 /* Get the vector size (in bytes). */
5482 vecsize = tree_low_cst (size, 1);
5484 /* We need to provide for vector pointers, vector arrays, and
5485 functions returning vectors. For example:
5487 __attribute__((vector_size(16))) short *foo;
5489 In this case, the mode is SI, but the type being modified is
5490 HI, so we need to look further. */
5492 while (POINTER_TYPE_P (type)
5493 || TREE_CODE (type) == FUNCTION_TYPE
5494 || TREE_CODE (type) == METHOD_TYPE
5495 || TREE_CODE (type) == ARRAY_TYPE)
5496 type = TREE_TYPE (type);
5498 /* Get the mode of the type being modified. */
5499 orig_mode = TYPE_MODE (type);
5501 if (TREE_CODE (type) == RECORD_TYPE
5502 || TREE_CODE (type) == UNION_TYPE
5503 || TREE_CODE (type) == VECTOR_TYPE
5504 || (!SCALAR_FLOAT_MODE_P (orig_mode)
5505 && GET_MODE_CLASS (orig_mode) != MODE_INT)
5506 || !host_integerp (TYPE_SIZE_UNIT (type), 1))
5508 error ("invalid vector type for attribute %qE", name);
5512 if (vecsize % tree_low_cst (TYPE_SIZE_UNIT (type), 1))
5514 error ("vector size not an integral multiple of component size");
5520 error ("zero vector size");
5524 /* Calculate how many units fit in the vector. */
5525 nunits = vecsize / tree_low_cst (TYPE_SIZE_UNIT (type), 1);
5526 if (nunits & (nunits - 1))
5528 error ("number of components of the vector not a power of two");
5532 new_type = build_vector_type (type, nunits);
5534 /* Build back pointers if needed. */
5535 *node = reconstruct_complex_type (*node, new_type);
5540 /* Handle the "nonnull" attribute. */
5542 handle_nonnull_attribute (tree *node, tree ARG_UNUSED (name),
5543 tree args, int ARG_UNUSED (flags),
5547 unsigned HOST_WIDE_INT attr_arg_num;
5549 /* If no arguments are specified, all pointer arguments should be
5550 non-null. Verify a full prototype is given so that the arguments
5551 will have the correct types when we actually check them later. */
5554 if (!TYPE_ARG_TYPES (type))
5556 error ("nonnull attribute without arguments on a non-prototype");
5557 *no_add_attrs = true;
5562 /* Argument list specified. Verify that each argument number references
5563 a pointer argument. */
5564 for (attr_arg_num = 1; args; args = TREE_CHAIN (args))
5567 unsigned HOST_WIDE_INT arg_num = 0, ck_num;
5569 if (!get_nonnull_operand (TREE_VALUE (args), &arg_num))
5571 error ("nonnull argument has invalid operand number (argument %lu)",
5572 (unsigned long) attr_arg_num);
5573 *no_add_attrs = true;
5577 argument = TYPE_ARG_TYPES (type);
5580 for (ck_num = 1; ; ck_num++)
5582 if (!argument || ck_num == arg_num)
5584 argument = TREE_CHAIN (argument);
5588 || TREE_CODE (TREE_VALUE (argument)) == VOID_TYPE)
5590 error ("nonnull argument with out-of-range operand number (argument %lu, operand %lu)",
5591 (unsigned long) attr_arg_num, (unsigned long) arg_num);
5592 *no_add_attrs = true;
5596 /* APPLE LOCAL begin blocks 5925781 */
5597 if (TREE_CODE (TREE_VALUE (argument)) != POINTER_TYPE &&
5598 TREE_CODE (TREE_VALUE (argument)) != BLOCK_POINTER_TYPE)
5599 /* APPLE LOCAL end blocks 5925781 */
5601 error ("nonnull argument references non-pointer operand (argument %lu, operand %lu)",
5602 (unsigned long) attr_arg_num, (unsigned long) arg_num);
5603 *no_add_attrs = true;
5612 /* Check the argument list of a function call for null in argument slots
5613 that are marked as requiring a non-null pointer argument. */
5616 check_function_nonnull (tree attrs, tree params)
5618 tree a, args, param;
5621 for (a = attrs; a; a = TREE_CHAIN (a))
5623 if (is_attribute_p ("nonnull", TREE_PURPOSE (a)))
5625 args = TREE_VALUE (a);
5627 /* Walk the argument list. If we encounter an argument number we
5628 should check for non-null, do it. If the attribute has no args,
5629 then every pointer argument is checked (in which case the check
5630 for pointer type is done in check_nonnull_arg). */
5631 for (param = params, param_num = 1; ;
5632 param_num++, param = TREE_CHAIN (param))
5636 if (!args || nonnull_check_p (args, param_num))
5637 check_function_arguments_recurse (check_nonnull_arg, NULL,
5645 /* Check that the Nth argument of a function call (counting backwards
5646 from the end) is a (pointer)0. */
5649 check_function_sentinel (tree attrs, tree params, tree typelist)
5651 tree attr = lookup_attribute ("sentinel", attrs);
5655 /* Skip over the named arguments. */
5656 while (typelist && params)
5658 typelist = TREE_CHAIN (typelist);
5659 params = TREE_CHAIN (params);
5662 if (typelist || !params)
5663 warning (OPT_Wformat,
5664 "not enough variable arguments to fit a sentinel");
5670 if (TREE_VALUE (attr))
5672 tree p = TREE_VALUE (TREE_VALUE (attr));
5673 pos = TREE_INT_CST_LOW (p);
5676 sentinel = end = params;
5678 /* Advance `end' ahead of `sentinel' by `pos' positions. */
5679 while (pos > 0 && TREE_CHAIN (end))
5682 end = TREE_CHAIN (end);
5686 warning (OPT_Wformat,
5687 "not enough variable arguments to fit a sentinel");
5691 /* Now advance both until we find the last parameter. */
5692 while (TREE_CHAIN (end))
5694 end = TREE_CHAIN (end);
5695 sentinel = TREE_CHAIN (sentinel);
5698 /* Validate the sentinel. */
5699 if ((!POINTER_TYPE_P (TREE_TYPE (TREE_VALUE (sentinel)))
5700 || !integer_zerop (TREE_VALUE (sentinel)))
5701 /* Although __null (in C++) is only an integer we allow it
5702 nevertheless, as we are guaranteed that it's exactly
5703 as wide as a pointer, and we don't want to force
5704 users to cast the NULL they have written there.
5705 We warn with -Wstrict-null-sentinel, though. */
5706 && (warn_strict_null_sentinel
5707 || null_node != TREE_VALUE (sentinel)))
5708 warning (OPT_Wformat, "missing sentinel in function call");
5713 /* Helper for check_function_nonnull; given a list of operands which
5714 must be non-null in ARGS, determine if operand PARAM_NUM should be
5718 nonnull_check_p (tree args, unsigned HOST_WIDE_INT param_num)
5720 unsigned HOST_WIDE_INT arg_num = 0;
5722 for (; args; args = TREE_CHAIN (args))
5724 bool found = get_nonnull_operand (TREE_VALUE (args), &arg_num);
5728 if (arg_num == param_num)
5734 /* Check that the function argument PARAM (which is operand number
5735 PARAM_NUM) is non-null. This is called by check_function_nonnull
5736 via check_function_arguments_recurse. */
5739 check_nonnull_arg (void * ARG_UNUSED (ctx), tree param,
5740 unsigned HOST_WIDE_INT param_num)
5742 /* Just skip checking the argument if it's not a pointer. This can
5743 happen if the "nonnull" attribute was given without an operand
5744 list (which means to check every pointer argument). */
5746 /* APPLE LOCAL begin blocks 5925781 */
5747 if (TREE_CODE (TREE_TYPE (param)) != POINTER_TYPE &&
5748 TREE_CODE (TREE_TYPE (param)) != BLOCK_POINTER_TYPE)
5749 /* APPLE LOCAL end blocks 5925781 */
5752 if (integer_zerop (param))
5753 warning (OPT_Wnonnull, "null argument where non-null required "
5754 "(argument %lu)", (unsigned long) param_num);
5757 /* Helper for nonnull attribute handling; fetch the operand number
5758 from the attribute argument list. */
5761 get_nonnull_operand (tree arg_num_expr, unsigned HOST_WIDE_INT *valp)
5763 /* Verify the arg number is a constant. */
5764 if (TREE_CODE (arg_num_expr) != INTEGER_CST
5765 || TREE_INT_CST_HIGH (arg_num_expr) != 0)
5768 *valp = TREE_INT_CST_LOW (arg_num_expr);
5772 /* Handle a "nothrow" attribute; arguments as in
5773 struct attribute_spec.handler. */
5776 handle_nothrow_attribute (tree *node, tree name, tree ARG_UNUSED (args),
5777 int ARG_UNUSED (flags), bool *no_add_attrs)
5779 if (TREE_CODE (*node) == FUNCTION_DECL)
5780 TREE_NOTHROW (*node) = 1;
5781 /* ??? TODO: Support types. */
5784 warning (OPT_Wattributes, "%qE attribute ignored", name);
5785 *no_add_attrs = true;
5791 /* Handle a "cleanup" attribute; arguments as in
5792 struct attribute_spec.handler. */
5795 handle_cleanup_attribute (tree *node, tree name, tree args,
5796 int ARG_UNUSED (flags), bool *no_add_attrs)
5799 tree cleanup_id, cleanup_decl;
5801 /* ??? Could perhaps support cleanups on TREE_STATIC, much like we do
5802 for global destructors in C++. This requires infrastructure that
5803 we don't have generically at the moment. It's also not a feature
5804 we'd be missing too much, since we do have attribute constructor. */
5805 if (TREE_CODE (decl) != VAR_DECL || TREE_STATIC (decl))
5807 warning (OPT_Wattributes, "%qE attribute ignored", name);
5808 *no_add_attrs = true;
5812 /* Verify that the argument is a function in scope. */
5813 /* ??? We could support pointers to functions here as well, if
5814 that was considered desirable. */
5815 cleanup_id = TREE_VALUE (args);
5816 if (TREE_CODE (cleanup_id) != IDENTIFIER_NODE)
5818 error ("cleanup argument not an identifier");
5819 *no_add_attrs = true;
5822 cleanup_decl = lookup_name (cleanup_id);
5823 if (!cleanup_decl || TREE_CODE (cleanup_decl) != FUNCTION_DECL)
5825 error ("cleanup argument not a function");
5826 *no_add_attrs = true;
5830 /* That the function has proper type is checked with the
5831 eventual call to build_function_call. */
5836 /* Handle a "warn_unused_result" attribute. No special handling. */
5839 handle_warn_unused_result_attribute (tree *node, tree name,
5840 tree ARG_UNUSED (args),
5841 int ARG_UNUSED (flags), bool *no_add_attrs)
5843 /* Ignore the attribute for functions not returning any value. */
5844 if (VOID_TYPE_P (TREE_TYPE (*node)))
5846 warning (OPT_Wattributes, "%qE attribute ignored", name);
5847 *no_add_attrs = true;
5853 /* APPLE LOCAL begin radar 5932809 - copyable byref blocks */
5854 /* Handle "blocks" attribute. */
5856 handle_blocks_attribute (tree *node, tree name,
5858 int ARG_UNUSED (flags), bool *no_add_attrs)
5861 /* APPLE LOCAL radar 6217257 */
5863 *no_add_attrs = true;
5864 if (!(*node) || TREE_CODE (*node) != VAR_DECL)
5866 error ("__block attribute can be specified on variables only");
5869 arg_ident = TREE_VALUE (args);
5870 gcc_assert (TREE_CODE (arg_ident) == IDENTIFIER_NODE);
5871 /* APPLE LOCAL radar 6096219 */
5872 if (strcmp (IDENTIFIER_POINTER (arg_ident), "byref"))
5874 /* APPLE LOCAL radar 6096219 */
5875 warning (OPT_Wattributes, "Only \"byref\" is allowed - %qE attribute ignored",
5879 /* APPLE LOCAL begin radar 6217257 */
5880 type = TREE_TYPE (*node);
5881 if (TREE_CODE (type) == ERROR_MARK)
5883 if (TREE_CODE (type) == ARRAY_TYPE)
5885 if (!TYPE_SIZE (type) || TREE_CODE (TYPE_SIZE (type)) != INTEGER_CST)
5887 error ("__block not allowed on a variable length array declaration");
5891 /* APPLE LOCAL end radar 6217257 */
5892 COPYABLE_BYREF_LOCAL_VAR (*node) = 1;
5893 COPYABLE_BYREF_LOCAL_NONPOD (*node) = block_requires_copying (*node);
5896 /* APPLE LOCAL end radar 5932809 - copyable byref blocks */
5898 /* APPLE LOCAL begin blocks 6040305 */
5900 /* This routine builds:
5901 *(void **)(EXP+20) expression which references the object pointer.
5904 build_indirect_object_id_exp (tree exp)
5907 int int_size = int_cst_value (TYPE_SIZE_UNIT (unsigned_type_node));
5909 /* dst->object In thid case 'object' is the field
5910 of the object passed offset by: void * + void* + int + int + void* + void *
5911 This must match definition of Block_byref structs. */
5912 /* APPLE LOCAL radar 6244520 */
5913 offset = GET_MODE_SIZE (Pmode) + GET_MODE_SIZE (Pmode)
5914 + int_size + int_size + GET_MODE_SIZE (Pmode) +
5915 GET_MODE_SIZE (Pmode);
5916 dst_obj = build2 (PLUS_EXPR, ptr_type_node, exp,
5917 build_int_cst (NULL_TREE, offset));
5918 /* APPLE LOCAL begin radar 6180456 */
5919 /* Type case to: 'void **' */
5920 dst_obj = build_c_cast (build_pointer_type (ptr_type_node), dst_obj);
5921 dst_obj = build_indirect_ref (dst_obj, "unary *");
5922 /* APPLE LOCAL end radar 6180456 */
5926 /* This routine builds call to:
5927 _Block_object_dispose(VAR_DECL.__forwarding, BLOCK_FIELD_IS_BYREF);
5928 and adds it to the statement list.
5931 build_block_byref_release_exp (tree var_decl)
5933 tree exp = var_decl, call_exp;
5934 tree type = TREE_TYPE (var_decl);
5935 /* __block variables imported into Blocks are not _Block_object_dispose()
5936 from within the Block statement itself; otherwise, each envokation of
5937 the block causes a release. Make sure to release __block variables declared
5938 and used locally in the block though. */
5940 && (BLOCK_DECL_COPIED (var_decl) || BLOCK_DECL_BYREF (var_decl)))
5942 if (BLOCK_DECL_BYREF (var_decl)) {
5943 /* This is a "struct Block_byref_X *" type. Get its pointee. */
5944 gcc_assert (POINTER_TYPE_P (type));
5945 type = TREE_TYPE (type);
5946 exp = build_indirect_ref (exp, "unary *");
5948 TREE_USED (var_decl) = 1;
5950 /* Declare: _Block_object_dispose(void*, BLOCK_FIELD_IS_BYREF) if not done already. */
5951 exp = build_component_ref (exp, get_identifier ("__forwarding"));
5952 call_exp = build_block_object_dispose_call_exp (exp, BLOCK_FIELD_IS_BYREF);
5955 /* APPLE LOCAL end blocks 6040305 */
5956 /* APPLE LOCAL begin radar 5803600 */
5957 /** add_block_global_byref_list - Adds global variable decl to the list of
5958 byref global declarations in the current block.
5960 void add_block_global_byref_list (tree decl)
5962 cur_block->block_byref_global_decl_list =
5963 tree_cons (NULL_TREE, decl, cur_block->block_byref_global_decl_list);
5966 /** in_block_global_byref_list - returns TRUE if global variable is
5967 in the list of 'byref' declarations.
5969 bool in_block_global_byref_list (tree decl)
5972 if (TREE_STATIC (decl)) {
5973 for (chain = cur_block->block_byref_global_decl_list; chain;
5974 chain = TREE_CHAIN (chain))
5975 if (TREE_VALUE (chain) == decl)
5980 /* APPLE LOCAL end radar 5803600 */
5982 /* APPLE LOCAL begin radar 6160536 */
5984 build_block_helper_name (int unique_count)
5987 if (!current_function_decl)
5989 /* APPLE LOCAL begin radar 6411649 */
5990 static int global_count;
5991 buf = (char *)alloca (32);
5992 sprintf (buf, "__block_global_%d", ++global_count);
5993 /* APPLE LOCAL end radar 6411649 */
5997 tree outer_decl = current_function_decl;
5998 /* APPLE LOCAL begin radar 6169580 */
5999 while (outer_decl &&
6000 DECL_CONTEXT (outer_decl) && TREE_CODE (DECL_CONTEXT (outer_decl)) == FUNCTION_DECL)
6001 /* APPLE LOCAL end radar 6169580 */
6002 outer_decl = DECL_CONTEXT (outer_decl);
6003 /* APPLE LOCAL begin radar 6411649 */
6005 unique_count = ++DECL_STRUCT_FUNCTION(outer_decl)->unqiue_block_number;
6006 /* APPLE LOCAL end radar 6411649 */
6007 buf = (char *)alloca (IDENTIFIER_LENGTH (DECL_NAME (outer_decl)) + 32);
6008 sprintf (buf, "__%s_block_invoke_%d",
6009 IDENTIFIER_POINTER (DECL_NAME (outer_decl)), unique_count);
6011 return get_identifier (buf);
6013 /* APPLE LOCAL end radar 6160536 */
6015 /* Handle a "sentinel" attribute. */
6018 handle_sentinel_attribute (tree *node, tree name, tree args,
6019 int ARG_UNUSED (flags), bool *no_add_attrs)
6021 tree params = TYPE_ARG_TYPES (*node);
6025 warning (OPT_Wattributes,
6026 "%qE attribute requires prototypes with named arguments", name);
6027 *no_add_attrs = true;
6031 while (TREE_CHAIN (params))
6032 params = TREE_CHAIN (params);
6034 if (VOID_TYPE_P (TREE_VALUE (params)))
6036 warning (OPT_Wattributes,
6037 "%qE attribute only applies to variadic functions", name);
6038 *no_add_attrs = true;
6044 tree position = TREE_VALUE (args);
6046 if (TREE_CODE (position) != INTEGER_CST)
6048 warning (0, "requested position is not an integer constant");
6049 *no_add_attrs = true;
6053 if (tree_int_cst_lt (position, integer_zero_node))
6055 warning (0, "requested position is less than zero");
6056 *no_add_attrs = true;
6064 /* Check for valid arguments being passed to a function. */
6066 check_function_arguments (tree attrs, tree params, tree typelist)
6068 /* Check for null being passed in a pointer argument that must be
6069 non-null. We also need to do this if format checking is enabled. */
6072 check_function_nonnull (attrs, params);
6074 /* Check for errors in format strings. */
6076 if (warn_format || warn_missing_format_attribute)
6077 check_function_format (attrs, params);
6080 check_function_sentinel (attrs, params, typelist);
6083 /* Generic argument checking recursion routine. PARAM is the argument to
6084 be checked. PARAM_NUM is the number of the argument. CALLBACK is invoked
6085 once the argument is resolved. CTX is context for the callback. */
6087 check_function_arguments_recurse (void (*callback)
6088 (void *, tree, unsigned HOST_WIDE_INT),
6089 void *ctx, tree param,
6090 unsigned HOST_WIDE_INT param_num)
6092 if ((TREE_CODE (param) == NOP_EXPR || TREE_CODE (param) == CONVERT_EXPR)
6093 && (TYPE_PRECISION (TREE_TYPE (param))
6094 == TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (param, 0)))))
6096 /* Strip coercion. */
6097 check_function_arguments_recurse (callback, ctx,
6098 TREE_OPERAND (param, 0), param_num);
6102 if (TREE_CODE (param) == CALL_EXPR)
6104 tree type = TREE_TYPE (TREE_TYPE (TREE_OPERAND (param, 0)));
6106 bool found_format_arg = false;
6108 /* See if this is a call to a known internationalization function
6109 that modifies a format arg. Such a function may have multiple
6110 format_arg attributes (for example, ngettext). */
6112 for (attrs = TYPE_ATTRIBUTES (type);
6114 attrs = TREE_CHAIN (attrs))
6115 if (is_attribute_p ("format_arg", TREE_PURPOSE (attrs)))
6118 tree format_num_expr;
6122 /* Extract the argument number, which was previously checked
6124 format_num_expr = TREE_VALUE (TREE_VALUE (attrs));
6126 gcc_assert (TREE_CODE (format_num_expr) == INTEGER_CST
6127 && !TREE_INT_CST_HIGH (format_num_expr));
6129 format_num = TREE_INT_CST_LOW (format_num_expr);
6131 for (inner_args = TREE_OPERAND (param, 1), i = 1;
6133 inner_args = TREE_CHAIN (inner_args), i++)
6134 if (i == format_num)
6136 check_function_arguments_recurse (callback, ctx,
6137 TREE_VALUE (inner_args),
6139 found_format_arg = true;
6144 /* If we found a format_arg attribute and did a recursive check,
6145 we are done with checking this argument. Otherwise, we continue
6146 and this will be considered a non-literal. */
6147 if (found_format_arg)
6151 if (TREE_CODE (param) == COND_EXPR)
6153 /* Check both halves of the conditional expression. */
6154 check_function_arguments_recurse (callback, ctx,
6155 TREE_OPERAND (param, 1), param_num);
6156 check_function_arguments_recurse (callback, ctx,
6157 TREE_OPERAND (param, 2), param_num);
6161 (*callback) (ctx, param, param_num);
6164 /* Function to help qsort sort FIELD_DECLs by name order. */
6167 field_decl_cmp (const void *x_p, const void *y_p)
6169 const tree *const x = (const tree *const) x_p;
6170 const tree *const y = (const tree *const) y_p;
6172 if (DECL_NAME (*x) == DECL_NAME (*y))
6173 /* A nontype is "greater" than a type. */
6174 return (TREE_CODE (*y) == TYPE_DECL) - (TREE_CODE (*x) == TYPE_DECL);
6175 if (DECL_NAME (*x) == NULL_TREE)
6177 if (DECL_NAME (*y) == NULL_TREE)
6179 if (DECL_NAME (*x) < DECL_NAME (*y))
6185 gt_pointer_operator new_value;
6189 /* This routine compares two fields like field_decl_cmp but using the
6190 pointer operator in resort_data. */
6193 resort_field_decl_cmp (const void *x_p, const void *y_p)
6195 const tree *const x = (const tree *const) x_p;
6196 const tree *const y = (const tree *const) y_p;
6198 if (DECL_NAME (*x) == DECL_NAME (*y))
6199 /* A nontype is "greater" than a type. */
6200 return (TREE_CODE (*y) == TYPE_DECL) - (TREE_CODE (*x) == TYPE_DECL);
6201 if (DECL_NAME (*x) == NULL_TREE)
6203 if (DECL_NAME (*y) == NULL_TREE)
6206 tree d1 = DECL_NAME (*x);
6207 tree d2 = DECL_NAME (*y);
6208 resort_data.new_value (&d1, resort_data.cookie);
6209 resort_data.new_value (&d2, resort_data.cookie);
6216 /* Resort DECL_SORTED_FIELDS because pointers have been reordered. */
6219 resort_sorted_fields (void *obj,
6220 void * ARG_UNUSED (orig_obj),
6221 gt_pointer_operator new_value,
6224 struct sorted_fields_type *sf = (struct sorted_fields_type *) obj;
6225 resort_data.new_value = new_value;
6226 resort_data.cookie = cookie;
6227 qsort (&sf->elts[0], sf->len, sizeof (tree),
6228 resort_field_decl_cmp);
6231 /* Subroutine of c_parse_error.
6232 Return the result of concatenating LHS and RHS. RHS is really
6233 a string literal, its first character is indicated by RHS_START and
6234 RHS_SIZE is its length (including the terminating NUL character).
6236 The caller is responsible for deleting the returned pointer. */
6239 catenate_strings (const char *lhs, const char *rhs_start, int rhs_size)
6241 const int lhs_size = strlen (lhs);
6242 char *result = XNEWVEC (char, lhs_size + rhs_size);
6243 strncpy (result, lhs, lhs_size);
6244 strncpy (result + lhs_size, rhs_start, rhs_size);
6248 /* Issue the error given by GMSGID, indicating that it occurred before
6249 TOKEN, which had the associated VALUE. */
6252 c_parse_error (const char *gmsgid, enum cpp_ttype token, tree value)
6254 #define catenate_messages(M1, M2) catenate_strings ((M1), (M2), sizeof (M2))
6256 char *message = NULL;
6258 if (token == CPP_EOF)
6259 message = catenate_messages (gmsgid, " at end of input");
6260 else if (token == CPP_CHAR || token == CPP_WCHAR)
6262 unsigned int val = TREE_INT_CST_LOW (value);
6263 const char *const ell = (token == CPP_CHAR) ? "" : "L";
6264 if (val <= UCHAR_MAX && ISGRAPH (val))
6265 message = catenate_messages (gmsgid, " before %s'%c'");
6267 message = catenate_messages (gmsgid, " before %s'\\x%x'");
6269 error (message, ell, val);
6273 else if (token == CPP_STRING || token == CPP_WSTRING)
6274 message = catenate_messages (gmsgid, " before string constant");
6275 else if (token == CPP_NUMBER)
6276 message = catenate_messages (gmsgid, " before numeric constant");
6277 else if (token == CPP_NAME)
6279 message = catenate_messages (gmsgid, " before %qE");
6280 error (message, value);
6284 else if (token == CPP_PRAGMA)
6285 message = catenate_messages (gmsgid, " before %<#pragma%>");
6286 else if (token == CPP_PRAGMA_EOL)
6287 message = catenate_messages (gmsgid, " before end of line");
6288 else if (token < N_TTYPES)
6290 message = catenate_messages (gmsgid, " before %qs token");
6291 error (message, cpp_type2name (token));
6300 error (message, "");
6303 #undef catenate_messages
6306 /* Walk a gimplified function and warn for functions whose return value is
6307 ignored and attribute((warn_unused_result)) is set. This is done before
6308 inlining, so we don't have to worry about that. */
6311 c_warn_unused_result (tree *top_p)
6314 tree_stmt_iterator i;
6317 switch (TREE_CODE (t))
6319 case STATEMENT_LIST:
6320 for (i = tsi_start (*top_p); !tsi_end_p (i); tsi_next (&i))
6321 c_warn_unused_result (tsi_stmt_ptr (i));
6325 c_warn_unused_result (&COND_EXPR_THEN (t));
6326 c_warn_unused_result (&COND_EXPR_ELSE (t));
6329 c_warn_unused_result (&BIND_EXPR_BODY (t));
6331 case TRY_FINALLY_EXPR:
6332 case TRY_CATCH_EXPR:
6333 c_warn_unused_result (&TREE_OPERAND (t, 0));
6334 c_warn_unused_result (&TREE_OPERAND (t, 1));
6337 c_warn_unused_result (&CATCH_BODY (t));
6339 case EH_FILTER_EXPR:
6340 c_warn_unused_result (&EH_FILTER_FAILURE (t));
6347 /* This is a naked call, as opposed to a CALL_EXPR nested inside
6348 a MODIFY_EXPR. All calls whose value is ignored should be
6349 represented like this. Look for the attribute. */
6350 fdecl = get_callee_fndecl (t);
6352 ftype = TREE_TYPE (fdecl);
6355 ftype = TREE_TYPE (TREE_OPERAND (t, 0));
6356 /* Look past pointer-to-function to the function type itself. */
6357 ftype = TREE_TYPE (ftype);
6360 if (lookup_attribute ("warn_unused_result", TYPE_ATTRIBUTES (ftype)))
6363 warning (0, "%Hignoring return value of %qD, "
6364 "declared with attribute warn_unused_result",
6365 EXPR_LOCUS (t), fdecl);
6367 warning (0, "%Hignoring return value of function "
6368 "declared with attribute warn_unused_result",
6374 /* Not a container, not a call, or a call whose value is used. */
6379 /* Convert a character from the host to the target execution character
6380 set. cpplib handles this, mostly. */
6383 c_common_to_target_charset (HOST_WIDE_INT c)
6385 /* Character constants in GCC proper are sign-extended under -fsigned-char,
6386 zero-extended under -fno-signed-char. cpplib insists that characters
6387 and character constants are always unsigned. Hence we must convert
6389 cppchar_t uc = ((cppchar_t)c) & ((((cppchar_t)1) << CHAR_BIT)-1);
6391 uc = cpp_host_to_exec_charset (parse_in, uc);
6393 if (flag_signed_char)
6394 return ((HOST_WIDE_INT)uc) << (HOST_BITS_PER_WIDE_INT - CHAR_TYPE_SIZE)
6395 >> (HOST_BITS_PER_WIDE_INT - CHAR_TYPE_SIZE);
6400 /* Build the result of __builtin_offsetof. EXPR is a nested sequence of
6401 component references, with STOP_REF, or alternatively an INDIRECT_REF of
6402 NULL, at the bottom; much like the traditional rendering of offsetof as a
6403 macro. Returns the folded and properly cast result. */
6406 fold_offsetof_1 (tree expr, tree stop_ref)
6408 enum tree_code code = PLUS_EXPR;
6411 if (expr == stop_ref && TREE_CODE (expr) != ERROR_MARK)
6412 return size_zero_node;
6414 switch (TREE_CODE (expr))
6420 error ("cannot apply %<offsetof%> to static data member %qD", expr);
6421 return error_mark_node;
6424 error ("cannot apply %<offsetof%> when %<operator[]%> is overloaded");
6425 return error_mark_node;
6428 gcc_assert (integer_zerop (expr));
6429 return size_zero_node;
6433 base = fold_offsetof_1 (TREE_OPERAND (expr, 0), stop_ref);
6434 gcc_assert (base == error_mark_node || base == size_zero_node);
6438 base = fold_offsetof_1 (TREE_OPERAND (expr, 0), stop_ref);
6439 if (base == error_mark_node)
6442 t = TREE_OPERAND (expr, 1);
6443 if (DECL_C_BIT_FIELD (t))
6445 error ("attempt to take address of bit-field structure "
6447 return error_mark_node;
6449 off = size_binop (PLUS_EXPR, DECL_FIELD_OFFSET (t),
6450 size_int (tree_low_cst (DECL_FIELD_BIT_OFFSET (t), 1)
6455 base = fold_offsetof_1 (TREE_OPERAND (expr, 0), stop_ref);
6456 if (base == error_mark_node)
6459 t = TREE_OPERAND (expr, 1);
6460 if (TREE_CODE (t) == INTEGER_CST && tree_int_cst_sgn (t) < 0)
6463 t = fold_build1 (NEGATE_EXPR, TREE_TYPE (t), t);
6465 t = convert (sizetype, t);
6466 off = size_binop (MULT_EXPR, TYPE_SIZE_UNIT (TREE_TYPE (expr)), t);
6470 /* Handle static members of volatile structs. */
6471 t = TREE_OPERAND (expr, 1);
6472 gcc_assert (TREE_CODE (t) == VAR_DECL);
6473 return fold_offsetof_1 (t, stop_ref);
6479 return size_binop (code, base, off);
6483 fold_offsetof (tree expr, tree stop_ref)
6485 /* Convert back from the internal sizetype to size_t. */
6486 return convert (size_type_node, fold_offsetof_1 (expr, stop_ref));
6489 /* Print an error message for an invalid lvalue. USE says
6490 how the lvalue is being used and so selects the error message. */
6493 lvalue_error (enum lvalue_use use)
6498 error ("lvalue required as left operand of assignment");
6501 error ("lvalue required as increment operand");
6504 error ("lvalue required as decrement operand");
6507 error ("lvalue required as unary %<&%> operand");
6510 error ("lvalue required in asm statement");
6517 /* *PTYPE is an incomplete array. Complete it with a domain based on
6518 INITIAL_VALUE. If INITIAL_VALUE is not present, use 1 if DO_DEFAULT
6519 is true. Return 0 if successful, 1 if INITIAL_VALUE can't be deciphered,
6520 2 if INITIAL_VALUE was NULL, and 3 if INITIAL_VALUE was empty. */
6523 complete_array_type (tree *ptype, tree initial_value, bool do_default)
6525 tree maxindex, type, main_type, elt, unqual_elt;
6526 int failure = 0, quals;
6528 maxindex = size_zero_node;
6531 if (TREE_CODE (initial_value) == STRING_CST)
6534 = int_size_in_bytes (TREE_TYPE (TREE_TYPE (initial_value)));
6535 maxindex = size_int (TREE_STRING_LENGTH (initial_value)/eltsize - 1);
6537 else if (TREE_CODE (initial_value) == CONSTRUCTOR)
6539 VEC(constructor_elt,gc) *v = CONSTRUCTOR_ELTS (initial_value);
6541 if (VEC_empty (constructor_elt, v))
6545 maxindex = integer_minus_one_node;
6550 unsigned HOST_WIDE_INT cnt;
6551 constructor_elt *ce;
6553 if (VEC_index (constructor_elt, v, 0)->index)
6554 maxindex = fold_convert (sizetype,
6555 VEC_index (constructor_elt,
6557 curindex = maxindex;
6560 VEC_iterate (constructor_elt, v, cnt, ce);
6564 curindex = fold_convert (sizetype, ce->index);
6566 curindex = size_binop (PLUS_EXPR, curindex, size_one_node);
6568 if (tree_int_cst_lt (maxindex, curindex))
6569 maxindex = curindex;
6575 /* Make an error message unless that happened already. */
6576 if (initial_value != error_mark_node)
6588 elt = TREE_TYPE (type);
6589 quals = TYPE_QUALS (strip_array_types (elt));
6593 unqual_elt = c_build_qualified_type (elt, TYPE_UNQUALIFIED);
6595 /* Using build_distinct_type_copy and modifying things afterward instead
6596 of using build_array_type to create a new type preserves all of the
6597 TYPE_LANG_FLAG_? bits that the front end may have set. */
6598 main_type = build_distinct_type_copy (TYPE_MAIN_VARIANT (type));
6599 TREE_TYPE (main_type) = unqual_elt;
6600 TYPE_DOMAIN (main_type) = build_index_type (maxindex);
6601 layout_type (main_type);
6606 type = c_build_qualified_type (main_type, quals);
6613 /* Used to help initialize the builtin-types.def table. When a type of
6614 the correct size doesn't exist, use error_mark_node instead of NULL.
6615 The later results in segfaults even when a decl using the type doesn't
6619 builtin_type_for_size (int size, bool unsignedp)
6621 tree type = lang_hooks.types.type_for_size (size, unsignedp);
6622 return type ? type : error_mark_node;
6625 /* A helper function for resolve_overloaded_builtin in resolving the
6626 overloaded __sync_ builtins. Returns a positive power of 2 if the
6627 first operand of PARAMS is a pointer to a supported data type.
6628 Returns 0 if an error is encountered. */
6631 sync_resolve_size (tree function, tree params)
6638 error ("too few arguments to function %qE", function);
6642 type = TREE_TYPE (TREE_VALUE (params));
6643 if (TREE_CODE (type) != POINTER_TYPE)
6646 type = TREE_TYPE (type);
6647 if (!INTEGRAL_TYPE_P (type) && !POINTER_TYPE_P (type))
6650 size = tree_low_cst (TYPE_SIZE_UNIT (type), 1);
6651 if (size == 1 || size == 2 || size == 4 || size == 8 || size == 16)
6655 error ("incompatible type for argument %d of %qE", 1, function);
6659 /* A helper function for resolve_overloaded_builtin. Adds casts to
6660 PARAMS to make arguments match up with those of FUNCTION. Drops
6661 the variadic arguments at the end. Returns false if some error
6662 was encountered; true on success. */
6665 sync_resolve_params (tree orig_function, tree function, tree params)
6667 tree arg_types = TYPE_ARG_TYPES (TREE_TYPE (function));
6671 /* We've declared the implementation functions to use "volatile void *"
6672 as the pointer parameter, so we shouldn't get any complaints from the
6673 call to check_function_arguments what ever type the user used. */
6674 arg_types = TREE_CHAIN (arg_types);
6675 ptype = TREE_TYPE (TREE_TYPE (TREE_VALUE (params)));
6678 /* For the rest of the values, we need to cast these to FTYPE, so that we
6679 don't get warnings for passing pointer types, etc. */
6680 while (arg_types != void_list_node)
6684 params = TREE_CHAIN (params);
6687 error ("too few arguments to function %qE", orig_function);
6691 /* ??? Ideally for the first conversion we'd use convert_for_assignment
6692 so that we get warnings for anything that doesn't match the pointer
6693 type. This isn't portable across the C and C++ front ends atm. */
6694 val = TREE_VALUE (params);
6695 val = convert (ptype, val);
6696 val = convert (TREE_VALUE (arg_types), val);
6697 TREE_VALUE (params) = val;
6699 arg_types = TREE_CHAIN (arg_types);
6703 /* The definition of these primitives is variadic, with the remaining
6704 being "an optional list of variables protected by the memory barrier".
6705 No clue what that's supposed to mean, precisely, but we consider all
6706 call-clobbered variables to be protected so we're safe. */
6707 TREE_CHAIN (params) = NULL;
6712 /* A helper function for resolve_overloaded_builtin. Adds a cast to
6713 RESULT to make it match the type of the first pointer argument in
6717 sync_resolve_return (tree params, tree result)
6719 tree ptype = TREE_TYPE (TREE_TYPE (TREE_VALUE (params)));
6720 ptype = TYPE_MAIN_VARIANT (ptype);
6721 return convert (ptype, result);
6724 /* Some builtin functions are placeholders for other expressions. This
6725 function should be called immediately after parsing the call expression
6726 before surrounding code has committed to the type of the expression.
6728 FUNCTION is the DECL that has been invoked; it is known to be a builtin.
6729 PARAMS is the argument list for the call. The return value is non-null
6730 when expansion is complete, and null if normal processing should
6734 resolve_overloaded_builtin (tree function, tree params)
6736 enum built_in_function orig_code = DECL_FUNCTION_CODE (function);
6737 switch (DECL_BUILT_IN_CLASS (function))
6739 case BUILT_IN_NORMAL:
6742 if (targetm.resolve_overloaded_builtin)
6743 return targetm.resolve_overloaded_builtin (function, params);
6750 /* Handle BUILT_IN_NORMAL here. */
6753 case BUILT_IN_FETCH_AND_ADD_N:
6754 case BUILT_IN_FETCH_AND_SUB_N:
6755 case BUILT_IN_FETCH_AND_OR_N:
6756 case BUILT_IN_FETCH_AND_AND_N:
6757 case BUILT_IN_FETCH_AND_XOR_N:
6758 case BUILT_IN_FETCH_AND_NAND_N:
6759 case BUILT_IN_ADD_AND_FETCH_N:
6760 case BUILT_IN_SUB_AND_FETCH_N:
6761 case BUILT_IN_OR_AND_FETCH_N:
6762 case BUILT_IN_AND_AND_FETCH_N:
6763 case BUILT_IN_XOR_AND_FETCH_N:
6764 case BUILT_IN_NAND_AND_FETCH_N:
6765 case BUILT_IN_BOOL_COMPARE_AND_SWAP_N:
6766 case BUILT_IN_VAL_COMPARE_AND_SWAP_N:
6767 case BUILT_IN_LOCK_TEST_AND_SET_N:
6768 case BUILT_IN_LOCK_RELEASE_N:
6770 int n = sync_resolve_size (function, params);
6771 tree new_function, result;
6774 return error_mark_node;
6776 new_function = built_in_decls[orig_code + exact_log2 (n) + 1];
6777 if (!sync_resolve_params (function, new_function, params))
6778 return error_mark_node;
6780 result = build_function_call (new_function, params);
6781 if (orig_code != BUILT_IN_BOOL_COMPARE_AND_SWAP_N
6782 && orig_code != BUILT_IN_LOCK_RELEASE_N)
6783 result = sync_resolve_return (params, result);
6793 /* Ignoring their sign, return true if two scalar types are the same. */
6795 same_scalar_type_ignoring_signedness (tree t1, tree t2)
6797 enum tree_code c1 = TREE_CODE (t1), c2 = TREE_CODE (t2);
6799 gcc_assert ((c1 == INTEGER_TYPE || c1 == REAL_TYPE)
6800 && (c2 == INTEGER_TYPE || c2 == REAL_TYPE));
6802 /* Equality works here because c_common_signed_type uses
6803 TYPE_MAIN_VARIANT. */
6804 return lang_hooks.types.signed_type (t1)
6805 == lang_hooks.types.signed_type (t2);
6808 /* Check for missing format attributes on function pointers. LTYPE is
6809 the new type or left-hand side type. RTYPE is the old type or
6810 right-hand side type. Returns TRUE if LTYPE is missing the desired
6814 check_missing_format_attribute (tree ltype, tree rtype)
6816 tree const ttr = TREE_TYPE (rtype), ttl = TREE_TYPE (ltype);
6819 for (ra = TYPE_ATTRIBUTES (ttr); ra; ra = TREE_CHAIN (ra))
6820 if (is_attribute_p ("format", TREE_PURPOSE (ra)))
6825 for (la = TYPE_ATTRIBUTES (ttl); la; la = TREE_CHAIN (la))
6826 if (is_attribute_p ("format", TREE_PURPOSE (la)))
6834 /* Subscripting with type char is likely to lose on a machine where
6835 chars are signed. So warn on any machine, but optionally. Don't
6836 warn for unsigned char since that type is safe. Don't warn for
6837 signed char because anyone who uses that must have done so
6838 deliberately. Furthermore, we reduce the false positive load by
6839 warning only for non-constant value of type char. */
6842 warn_array_subscript_with_type_char (tree index)
6844 if (TYPE_MAIN_VARIANT (TREE_TYPE (index)) == char_type_node
6845 && TREE_CODE (index) != INTEGER_CST)
6846 warning (OPT_Wchar_subscripts, "array subscript has type %<char%>");
6849 /* Implement -Wparentheses for the unexpected C precedence rules, to
6850 cover cases like x + y << z which readers are likely to
6851 misinterpret. We have seen an expression in which CODE is a binary
6852 operator used to combine expressions headed by CODE_LEFT and
6853 CODE_RIGHT. CODE_LEFT and CODE_RIGHT may be ERROR_MARK, which
6854 means that that side of the expression was not formed using a
6855 binary operator, or it was enclosed in parentheses. */
6858 warn_about_parentheses (enum tree_code code, enum tree_code code_left,
6859 enum tree_code code_right)
6861 if (!warn_parentheses)
6864 if (code == LSHIFT_EXPR || code == RSHIFT_EXPR)
6866 if (code_left == PLUS_EXPR || code_left == MINUS_EXPR
6867 || code_right == PLUS_EXPR || code_right == MINUS_EXPR)
6868 warning (OPT_Wparentheses,
6869 "suggest parentheses around + or - inside shift");
6872 if (code == TRUTH_ORIF_EXPR)
6874 if (code_left == TRUTH_ANDIF_EXPR
6875 || code_right == TRUTH_ANDIF_EXPR)
6876 warning (OPT_Wparentheses,
6877 "suggest parentheses around && within ||");
6880 if (code == BIT_IOR_EXPR)
6882 if (code_left == BIT_AND_EXPR || code_left == BIT_XOR_EXPR
6883 || code_left == PLUS_EXPR || code_left == MINUS_EXPR
6884 || code_right == BIT_AND_EXPR || code_right == BIT_XOR_EXPR
6885 || code_right == PLUS_EXPR || code_right == MINUS_EXPR)
6886 warning (OPT_Wparentheses,
6887 "suggest parentheses around arithmetic in operand of |");
6888 /* Check cases like x|y==z */
6889 if (TREE_CODE_CLASS (code_left) == tcc_comparison
6890 || TREE_CODE_CLASS (code_right) == tcc_comparison)
6891 warning (OPT_Wparentheses,
6892 "suggest parentheses around comparison in operand of |");
6895 if (code == BIT_XOR_EXPR)
6897 if (code_left == BIT_AND_EXPR
6898 || code_left == PLUS_EXPR || code_left == MINUS_EXPR
6899 || code_right == BIT_AND_EXPR
6900 || code_right == PLUS_EXPR || code_right == MINUS_EXPR)
6901 warning (OPT_Wparentheses,
6902 "suggest parentheses around arithmetic in operand of ^");
6903 /* Check cases like x^y==z */
6904 if (TREE_CODE_CLASS (code_left) == tcc_comparison
6905 || TREE_CODE_CLASS (code_right) == tcc_comparison)
6906 warning (OPT_Wparentheses,
6907 "suggest parentheses around comparison in operand of ^");
6910 if (code == BIT_AND_EXPR)
6912 if (code_left == PLUS_EXPR || code_left == MINUS_EXPR
6913 || code_right == PLUS_EXPR || code_right == MINUS_EXPR)
6914 warning (OPT_Wparentheses,
6915 "suggest parentheses around + or - in operand of &");
6916 /* Check cases like x&y==z */
6917 if (TREE_CODE_CLASS (code_left) == tcc_comparison
6918 || TREE_CODE_CLASS (code_right) == tcc_comparison)
6919 warning (OPT_Wparentheses,
6920 "suggest parentheses around comparison in operand of &");
6923 /* Similarly, check for cases like 1<=i<=10 that are probably errors. */
6924 if (TREE_CODE_CLASS (code) == tcc_comparison
6925 && (TREE_CODE_CLASS (code_left) == tcc_comparison
6926 || TREE_CODE_CLASS (code_right) == tcc_comparison))
6927 warning (OPT_Wparentheses, "comparisons like X<=Y<=Z do not "
6928 "have their mathematical meaning");
6931 /* APPLE LOCAL begin radar 6246527 */
6932 /* This routine is called for a "format" attribute. It adds the number of
6933 hidden argument ('1') to the format's 2nd and 3rd argument to compensate
6934 for these two arguments. This is to make rest of the "format" attribute
6935 processing done in the middle-end to work seemlessly. */
6938 block_delta_format_args (tree format)
6940 tree format_num_expr, first_arg_num_expr;
6942 tree args = TREE_VALUE (format);
6943 gcc_assert (TREE_CHAIN (args) && TREE_CHAIN (TREE_CHAIN (args)));
6944 format_num_expr = TREE_VALUE (TREE_CHAIN (args));
6945 first_arg_num_expr = TREE_VALUE (TREE_CHAIN (TREE_CHAIN (args)));
6946 if (format_num_expr && TREE_CODE (format_num_expr) == INTEGER_CST)
6948 val = TREE_INT_CST_LOW (format_num_expr);
6949 TREE_VALUE (TREE_CHAIN (args)) = build_int_cst (NULL_TREE, val+1);
6951 if (first_arg_num_expr && TREE_CODE (first_arg_num_expr) == INTEGER_CST)
6953 val = TREE_INT_CST_LOW (first_arg_num_expr);
6955 TREE_VALUE (TREE_CHAIN (TREE_CHAIN (args))) =
6956 build_int_cst (NULL_TREE, val+1);
6960 /* This routine recognizes legal block attributes. In case of block's "format"
6961 attribute, it calls block_delta_format_args to compensate for hidden
6962 argument _self getting passed to block's helper function. */
6964 any_recognized_block_attribute (tree attributes)
6968 for (chain = attributes; chain; chain = TREE_CHAIN (chain))
6970 if (is_attribute_p ("format", TREE_PURPOSE (chain)))
6972 block_delta_format_args (chain);
6975 else if (is_attribute_p ("sentinel", TREE_PURPOSE (chain)))
6980 /* APPLE LOCAL end radar 6246527 */
6981 /* APPLE LOCAL begin radar 5847976 */
6982 static GTY(()) tree block_object_assign_decl;
6983 static GTY(()) tree block_object_dispose_func_decl;
6984 /* This routine declares:
6985 void _Block_object_assign (void *, void *, int) or uses an
6989 build_block_object_assign_decl (void)
6992 if (block_object_assign_decl)
6993 return block_object_assign_decl;
6994 block_object_assign_decl = lookup_name (get_identifier ("_Block_object_assign"));
6995 if (block_object_assign_decl)
6996 return block_object_assign_decl;
6998 build_function_type (void_type_node,
6999 tree_cons (NULL_TREE, ptr_type_node,
7000 tree_cons (NULL_TREE, ptr_type_node,
7001 tree_cons (NULL_TREE, integer_type_node, void_list_node))));
7003 block_object_assign_decl = builtin_function ("_Block_object_assign", func_type,
7004 0, NOT_BUILT_IN, 0, NULL_TREE);
7005 TREE_NOTHROW (block_object_assign_decl) = 0;
7006 return block_object_assign_decl;
7009 /* This routine builds:
7010 _Block_object_assign(dest, src, flag)
7012 tree build_block_object_assign_call_exp (tree dst, tree src, int flag)
7014 tree func_params = tree_cons (NULL_TREE, dst,
7015 tree_cons (NULL_TREE, src,
7016 tree_cons (NULL_TREE,
7017 build_int_cst (integer_type_node, flag),
7019 return build_function_call (build_block_object_assign_decl (), func_params);
7022 /* This routine declares:
7023 void _Block_object_dispose (void *, int) or uses an
7027 build_block_object_dispose_decl (void)
7030 if (block_object_dispose_func_decl)
7031 return block_object_dispose_func_decl;
7032 block_object_dispose_func_decl = lookup_name (get_identifier ("_Block_object_dispose"));
7033 if (block_object_dispose_func_decl)
7034 return block_object_dispose_func_decl;
7036 build_function_type (void_type_node,
7037 tree_cons (NULL_TREE, ptr_type_node,
7038 tree_cons (NULL_TREE, integer_type_node, void_list_node)));
7040 block_object_dispose_func_decl = builtin_function ("_Block_object_dispose", func_type,
7041 0, NOT_BUILT_IN, 0, NULL_TREE);
7042 TREE_NOTHROW (block_object_dispose_func_decl) = 0;
7043 return block_object_dispose_func_decl;
7046 /* This routine builds the call tree:
7047 _Block_object_dispose(src, flag)
7049 tree build_block_object_dispose_call_exp (tree src, int flag)
7051 tree func_params = tree_cons (NULL_TREE, src,
7052 tree_cons (NULL_TREE,
7053 build_int_cst (integer_type_node, flag),
7055 return build_function_call (build_block_object_dispose_decl (), func_params);
7057 /* APPLE LOCAL end radar 5847976 */
7058 /* APPLE LOCAL begin radar 7760213 */
7059 int HasByrefArray(tree byrefType)
7062 /* Check for possibility of an error condition. */
7063 if (TREE_CODE(byrefType) != RECORD_TYPE)
7066 for (s1 = TYPE_FIELDS (byrefType); s1; s1 = TREE_CHAIN (s1))
7068 if (TREE_CODE(TREE_TYPE(s1)) == ARRAY_TYPE)
7073 /* APPLE LOCAL end radar 7760213 */
7074 #include "gt-c-common.h"