No OneTemporary
Actions

Size

4 MB

Referenced Files

None

Subscribers

None

View Options

This file is larger than 256 KB, so syntax highlighting was skipped.

	diff --git a/contrib/gcc/ChangeLog.apple b/contrib/gcc/ChangeLog.apple
	new file mode 100644
	index 000000000000..b2004ee16569
	--- /dev/null
	+++ b/contrib/gcc/ChangeLog.apple
	@@ -0,0 +1,51 @@
	+006-02-15 Fariborz Jahanian <fjahanian@apple.com>
	+
	+ Radar 4445586
	+ * c-common.def (DO_STMT): Takes an extra argument.
	+
	+/* APPLE LOCAL merge marger */
	+/* Stuff under is in fsf mainline, but not in the 4.2 branch */
	+
	+2007-08-02 Geoffrey Keating <geoffk@apple.com>
	+
	+ Radar 3274130, 5295549
	+ * c-parser.c (c_parser_while_statement): Handle attributes.
	+ (c_parser_do_statement): Handle attributes.
	+ (c_parser_for_statement): Handle attributes.
	+ * c-common.c (handle_unused_attribute): Warn if a statement
	+ is marked as unused.
	+ * c-tree.h (c_finish_loop): Add extra parameter.
	+ * c-typeck.c (c_finish_loop): Handle attributes.
	+ * doc/extend.texi (Attribute Syntax): Document statement attributes.
	+ (Label Attributes): Explain how they apply to statements.
	+ * tree-cfg.c (cleanup_dead_labels): Preserve labels with
	+ user-specified alignment or attributes.
	+ * stmt.c (expand_label): Update and correct documentation.
	+
	+ * c-common.c (handle_aligned_attribute): Handle LABEL_DECL.
	+ * rtl.def (CODE_LABEL): Add 8th operand.
	+ * rtl.h (LABEL_ALIGN_LOG): New.
	+ (LABEL_MAX_SKIP): New.
	+ (SET_LABEL_ALIGN): New.
	+ * emit-rtl.c (gen_label_rtx): Adjust.
	+ * print-rtl.c (print_rtx): Print LABEL_ALIGN_LOG.
	+ * stmt.c (label_rtx): Set CODE_LABEL's alignment from DECL_ALIGN.
	+ (expand_label): Update documentation.
	+ * final.c (struct label_alignment): Delete.
	+ (label_align): Delete.
	+ (min_labelno): Delete.
	+ (max_labelno): Delete.
	+ (LABEL_TO_ALIGNMENT): Delete.
	+ (LABEL_TO_MAX_SKIP): Delete.
	+ (label_to_alignment): Adjust for LABEL_ALIGN_LOG.
	+ (align_fuzz): Likewise.
	+ (compute_alignments): Likewise.
	+ (shorten_branches): Remove code to set up label_align.
	+ Adjust for LABEL_ALIGN_LOG.
	+ (final_scan_insn): Adjust for LABEL_ALIGN_LOG.
	+ * doc/extend.texi (C Extensions): Add 'Label Attributes' to menu.
	+ (Attribute Syntax): Move label content to Label Attributes.
	+ (Function Attributes): Mention label attributes.
	+ (Variable Attributes): Mention label attributes.
	+ (Type Attributes): Mention label attributes.
	+ (Label Attributes): New.
	diff --git a/contrib/gcc/c-common.c b/contrib/gcc/c-common.c
	index b1fa91dd80ab..4b47ef422b9b 100644
	--- a/contrib/gcc/c-common.c
	+++ b/contrib/gcc/c-common.c
	@@ -1,6653 +1,6727 @@
	/* Subroutines shared by all languages that are variants of C.
	Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
	2001, 2002, 2003, 2004, 2005 Free Software Foundation, Inc.

	This file is part of GCC.

	GCC is free software; you can redistribute it and/or modify it under
	the terms of the GNU General Public License as published by the Free
	Software Foundation; either version 2, or (at your option) any later
	version.

	GCC is distributed in the hope that it will be useful, but WITHOUT ANY
	WARRANTY; without even the implied warranty of MERCHANTABILITY or
	FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	for more details.

	You should have received a copy of the GNU General Public License
	along with GCC; see the file COPYING. If not, write to the Free
	Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
	02110-1301, USA. */

	#include "config.h"
	#include "system.h"
	#include "coretypes.h"
	#include "tm.h"
	#include "intl.h"
	#include "tree.h"
	#include "flags.h"
	#include "output.h"
	#include "c-pragma.h"
	#include "rtl.h"
	#include "ggc.h"
	#include "varray.h"
	#include "expr.h"
	#include "c-common.h"
	#include "diagnostic.h"
	#include "tm_p.h"
	#include "obstack.h"
	#include "cpplib.h"
	#include "target.h"
	#include "langhooks.h"
	#include "tree-inline.h"
	#include "c-tree.h"
	#include "toplev.h"
	#include "tree-iterator.h"
	#include "hashtab.h"
	#include "tree-mudflap.h"
	#include "opts.h"
	#include "real.h"
	#include "cgraph.h"

	cpp_reader parse_in; / Declared in c-pragma.h. */

	/* We let tm.h override the types used here, to handle trivial differences
	such as the choice of unsigned int or long unsigned int for size_t.
	When machines start needing nontrivial differences in the size type,
	it would be best to do something here to figure out automatically
	from other information what type to use. */

	#ifndef SIZE_TYPE
	#define SIZE_TYPE "long unsigned int"
	#endif

	#ifndef PID_TYPE
	#define PID_TYPE "int"
	#endif

	#ifndef WCHAR_TYPE
	#define WCHAR_TYPE "int"
	#endif

	/* WCHAR_TYPE gets overridden by -fshort-wchar. */
	#define MODIFIED_WCHAR_TYPE \
	(flag_short_wchar ? "short unsigned int" : WCHAR_TYPE)

	#ifndef PTRDIFF_TYPE
	#define PTRDIFF_TYPE "long int"
	#endif

	#ifndef WINT_TYPE
	#define WINT_TYPE "unsigned int"
	#endif

	#ifndef INTMAX_TYPE
	#define INTMAX_TYPE ((INT_TYPE_SIZE == LONG_LONG_TYPE_SIZE) \
	? "int" \
	: ((LONG_TYPE_SIZE == LONG_LONG_TYPE_SIZE) \
	? "long int" \
	: "long long int"))
	#endif

	#ifndef UINTMAX_TYPE
	#define UINTMAX_TYPE ((INT_TYPE_SIZE == LONG_LONG_TYPE_SIZE) \
	? "unsigned int" \
	: ((LONG_TYPE_SIZE == LONG_LONG_TYPE_SIZE) \
	? "long unsigned int" \
	: "long long unsigned int"))
	#endif

	/* The following symbols are subsumed in the c_global_trees array, and
	listed here individually for documentation purposes.

	INTEGER_TYPE and REAL_TYPE nodes for the standard data types.

	tree short_integer_type_node;
	tree long_integer_type_node;
	tree long_long_integer_type_node;

	tree short_unsigned_type_node;
	tree long_unsigned_type_node;
	tree long_long_unsigned_type_node;

	tree truthvalue_type_node;
	tree truthvalue_false_node;
	tree truthvalue_true_node;

	tree ptrdiff_type_node;

	tree unsigned_char_type_node;
	tree signed_char_type_node;
	tree wchar_type_node;
	tree signed_wchar_type_node;
	tree unsigned_wchar_type_node;

	tree float_type_node;
	tree double_type_node;
	tree long_double_type_node;

	tree complex_integer_type_node;
	tree complex_float_type_node;
	tree complex_double_type_node;
	tree complex_long_double_type_node;

	tree dfloat32_type_node;
	tree dfloat64_type_node;
	tree_dfloat128_type_node;

	tree intQI_type_node;
	tree intHI_type_node;
	tree intSI_type_node;
	tree intDI_type_node;
	tree intTI_type_node;

	tree unsigned_intQI_type_node;
	tree unsigned_intHI_type_node;
	tree unsigned_intSI_type_node;
	tree unsigned_intDI_type_node;
	tree unsigned_intTI_type_node;

	tree widest_integer_literal_type_node;
	tree widest_unsigned_literal_type_node;

	Nodes for types `void ' and `const void '.

	tree ptr_type_node, const_ptr_type_node;

	Nodes for types `char ' and `const char '.

	tree string_type_node, const_string_type_node;

	Type `char[SOMENUMBER]'.
	Used when an array of char is needed and the size is irrelevant.

	tree char_array_type_node;

	Type `int[SOMENUMBER]' or something like it.
	Used when an array of int needed and the size is irrelevant.

	tree int_array_type_node;

	Type `wchar_t[SOMENUMBER]' or something like it.
	Used when a wide string literal is created.

	tree wchar_array_type_node;

	Type `int ()' -- used for implicit declaration of functions.

	tree default_function_type;

	A VOID_TYPE node, packaged in a TREE_LIST.

	tree void_list_node;

	The lazily created VAR_DECLs for __FUNCTION__, __PRETTY_FUNCTION__,
	and __func__. (C doesn't generate __FUNCTION__ and__PRETTY_FUNCTION__
	VAR_DECLS, but C++ does.)

	tree function_name_decl_node;
	tree pretty_function_name_decl_node;
	tree c99_function_name_decl_node;

	Stack of nested function name VAR_DECLs.

	tree saved_function_name_decls;

	*/

	tree c_global_trees[CTI_MAX];

	/* Switches common to the C front ends. */

	/* Nonzero if prepreprocessing only. */

	int flag_preprocess_only;

	/* Nonzero means don't output line number information. */

	char flag_no_line_commands;

	/* Nonzero causes -E output not to be done, but directives such as
	#define that have side effects are still obeyed. */

	char flag_no_output;

	/* Nonzero means dump macros in some fashion. */

	char flag_dump_macros;

	/* Nonzero means pass #include lines through to the output. */

	char flag_dump_includes;

	/* Nonzero means process PCH files while preprocessing. */

	bool flag_pch_preprocess;

	/* The file name to which we should write a precompiled header, or
	NULL if no header will be written in this compile. */

	const char *pch_file;

	/* Nonzero if an ISO standard was selected. It rejects macros in the
	user's namespace. */
	int flag_iso;

	/* Nonzero if -undef was given. It suppresses target built-in macros
	and assertions. */
	int flag_undef;

	/* Nonzero means don't recognize the non-ANSI builtin functions. */

	int flag_no_builtin;

	/* Nonzero means don't recognize the non-ANSI builtin functions.
	-ansi sets this. */

	int flag_no_nonansi_builtin;

	/* Nonzero means give `double' the same size as `float'. */

	int flag_short_double;

	/* Nonzero means give `wchar_t' the same size as `short'. */

	int flag_short_wchar;

	/* Nonzero means allow implicit conversions between vectors with
	differing numbers of subparts and/or differing element types. */
	int flag_lax_vector_conversions;

	/* Nonzero means allow Microsoft extensions without warnings or errors. */
	int flag_ms_extensions;

	/* Nonzero means don't recognize the keyword `asm'. */

	int flag_no_asm;

	/* Nonzero means to treat bitfields as signed unless they say `unsigned'. */

	int flag_signed_bitfields = 1;

	/* Warn about #pragma directives that are not recognized. */

	int warn_unknown_pragmas; /* Tri state variable. */

	/* Warn about format/argument anomalies in calls to formatted I/O functions
	(printf, scanf, strftime, strfmon, etc.). */

	int warn_format;

	/* Warn about using __null (as NULL in C++) as sentinel. For code compiled
	with GCC this doesn't matter as __null is guaranteed to have the right
	size. */

	int warn_strict_null_sentinel;

	/* Zero means that faster, ...NonNil variants of objc_msgSend...
	calls will be used in ObjC; passing nil receivers to such calls
	will most likely result in crashes. */
	int flag_nil_receivers = 1;

	/* Nonzero means that code generation will be altered to support
	"zero-link" execution. This currently affects ObjC only, but may
	affect other languages in the future. */
	int flag_zero_link = 0;

	/* Nonzero means emit an '__OBJC, __image_info' for the current translation
	unit. It will inform the ObjC runtime that class definition(s) herein
	contained are to replace one(s) previously loaded. */
	int flag_replace_objc_classes = 0;

	/* C/ObjC language option variables. */


	/* Nonzero means allow type mismatches in conditional expressions;
	just make their values `void'. */

	int flag_cond_mismatch;

	/* Nonzero means enable C89 Amendment 1 features. */

	int flag_isoc94;

	/* Nonzero means use the ISO C99 dialect of C. */

	int flag_isoc99;

	/* Nonzero means that we have builtin functions, and main is an int. */

	int flag_hosted = 1;

	/* Warn if main is suspicious. */

	int warn_main;


	/* ObjC language option variables. */


	/* Open and close the file for outputting class declarations, if
	requested (ObjC). */

	int flag_gen_declaration;

	/* Tells the compiler that this is a special run. Do not perform any
	compiling, instead we are to test some platform dependent features
	and output a C header file with appropriate definitions. */

	int print_struct_values;

	/* Tells the compiler what is the constant string class for Objc. */

	const char *constant_string_class_name;


	/* C++ language option variables. */


	/* Nonzero means don't recognize any extension keywords. */

	int flag_no_gnu_keywords;

	/* Nonzero means do emit exported implementations of functions even if
	they can be inlined. */

	int flag_implement_inlines = 1;

	/* Nonzero means that implicit instantiations will be emitted if needed. */

	int flag_implicit_templates = 1;

	/* Nonzero means that implicit instantiations of inline templates will be
	emitted if needed, even if instantiations of non-inline templates
	aren't. */

	int flag_implicit_inline_templates = 1;

	/* Nonzero means generate separate instantiation control files and
	juggle them at link time. */

	int flag_use_repository;

	/* Nonzero if we want to issue diagnostics that the standard says are not
	required. */

	int flag_optional_diags = 1;

	/* Nonzero means we should attempt to elide constructors when possible. */

	int flag_elide_constructors = 1;

	/* Nonzero means that member functions defined in class scope are
	inline by default. */

	int flag_default_inline = 1;

	/* Controls whether compiler generates 'type descriptor' that give
	run-time type information. */

	int flag_rtti = 1;

	/* Nonzero if we want to conserve space in the .o files. We do this
	by putting uninitialized data and runtime initialized data into
	.common instead of .data at the expense of not flagging multiple
	definitions. */

	int flag_conserve_space;

	/* Nonzero if we want to obey access control semantics. */

	int flag_access_control = 1;

	/* Nonzero if we want to check the return value of new and avoid calling
	constructors if it is a null pointer. */

	int flag_check_new;

	/* Nonzero if we want the new ISO rules for pushing a new scope for `for'
	initialization variables.
	0: Old rules, set by -fno-for-scope.
	2: New ISO rules, set by -ffor-scope.
	1: Try to implement new ISO rules, but with backup compatibility
	(and warnings). This is the default, for now. */

	int flag_new_for_scope = 1;

	/* Nonzero if we want to emit defined symbols with common-like linkage as
	weak symbols where possible, in order to conform to C++ semantics.
	Otherwise, emit them as local symbols. */

	int flag_weak = 1;

	/* 0 means we want the preprocessor to not emit line directives for
	the current working directory. 1 means we want it to do it. -1
	means we should decide depending on whether debugging information
	is being emitted or not. */

	int flag_working_directory = -1;

	/* Nonzero to use __cxa_atexit, rather than atexit, to register
	destructors for local statics and global objects. '2' means it has been
	set nonzero as a default, not by a command-line flag. */

	int flag_use_cxa_atexit = DEFAULT_USE_CXA_ATEXIT;

	/* Nonzero to use __cxa_get_exception_ptr in C++ exception-handling
	code. '2' means it has not been set explicitly on the command line. */

	int flag_use_cxa_get_exception_ptr = 2;

	/* Nonzero means make the default pedwarns warnings instead of errors.
	The value of this flag is ignored if -pedantic is specified. */

	int flag_permissive;

	/* Nonzero means to implement standard semantics for exception
	specifications, calling unexpected if an exception is thrown that
	doesn't match the specification. Zero means to treat them as
	assertions and optimize accordingly, but not check them. */

	int flag_enforce_eh_specs = 1;

	/* Nonzero means to generate thread-safe code for initializing local
	statics. */

	int flag_threadsafe_statics = 1;

	/* Nonzero means warn about implicit declarations. */

	int warn_implicit = 1;

	/* Maximum template instantiation depth. This limit is rather
	arbitrary, but it exists to limit the time it takes to notice
	infinite template instantiations. */

	int max_tinst_depth = 500;



	/* The elements of `ridpointers' are identifier nodes for the reserved
	type names and storage classes. It is indexed by a RID_... value. */
	tree *ridpointers;

	tree (*make_fname_decl) (tree, int);

	/* Nonzero means the expression being parsed will never be evaluated.
	This is a count, since unevaluated expressions can nest. */
	int skip_evaluation;

	/* Information about how a function name is generated. */
	struct fname_var_t
	{
	tree const decl; / pointer to the VAR_DECL. */
	const unsigned rid; /* RID number for the identifier. */
	const int pretty; /* How pretty is it? */
	};

	/* The three ways of getting then name of the current function. */

	const struct fname_var_t fname_vars[] =
	{
	/* C99 compliant __func__, must be first. */
	{&c99_function_name_decl_node, RID_C99_FUNCTION_NAME, 0},
	/* GCC __FUNCTION__ compliant. */
	{&function_name_decl_node, RID_FUNCTION_NAME, 0},
	/* GCC __PRETTY_FUNCTION__ compliant. */
	{&pretty_function_name_decl_node, RID_PRETTY_FUNCTION_NAME, 1},
	{NULL, 0, 0},
	};

	static int constant_fits_type_p (tree, tree);
	static tree check_case_value (tree);
	static bool check_case_bounds (tree, tree, tree , tree );

	static tree handle_packed_attribute (tree , tree, tree, int, bool );
	static tree handle_nocommon_attribute (tree , tree, tree, int, bool );
	static tree handle_common_attribute (tree , tree, tree, int, bool );
	static tree handle_noreturn_attribute (tree , tree, tree, int, bool );
	static tree handle_noinline_attribute (tree , tree, tree, int, bool );
	static tree handle_always_inline_attribute (tree *, tree, tree, int,
	bool *);
	static tree handle_gnu_inline_attribute (tree *, tree, tree, int,
	bool *);
	static tree handle_flatten_attribute (tree , tree, tree, int, bool );
	static tree handle_used_attribute (tree , tree, tree, int, bool );
	static tree handle_unused_attribute (tree , tree, tree, int, bool );
	static tree handle_externally_visible_attribute (tree *, tree, tree, int,
	bool *);
	static tree handle_const_attribute (tree , tree, tree, int, bool );
	static tree handle_transparent_union_attribute (tree *, tree, tree,
	int, bool *);
	static tree handle_constructor_attribute (tree , tree, tree, int, bool );
	static tree handle_destructor_attribute (tree , tree, tree, int, bool );
	static tree handle_mode_attribute (tree , tree, tree, int, bool );
	static tree handle_section_attribute (tree , tree, tree, int, bool );
	static tree handle_aligned_attribute (tree , tree, tree, int, bool );
	static tree handle_weak_attribute (tree , tree, tree, int, bool ) ;
	static tree handle_alias_attribute (tree , tree, tree, int, bool );
	static tree handle_weakref_attribute (tree , tree, tree, int, bool ) ;
	static tree handle_visibility_attribute (tree *, tree, tree, int,
	bool *);
	static tree handle_tls_model_attribute (tree *, tree, tree, int,
	bool *);
	static tree handle_no_instrument_function_attribute (tree *, tree,
	tree, int, bool *);
	static tree handle_malloc_attribute (tree , tree, tree, int, bool );
	static tree handle_returns_twice_attribute (tree , tree, tree, int, bool );
	static tree handle_no_limit_stack_attribute (tree *, tree, tree, int,
	bool *);
	static tree handle_pure_attribute (tree , tree, tree, int, bool );
	static tree handle_novops_attribute (tree , tree, tree, int, bool );
	static tree handle_deprecated_attribute (tree *, tree, tree, int,
	bool *);
	+/* APPLE LOCAL begin "unavailable" attribute (Radar 2809697) --ilr */
	+static tree handle_unavailable_attribute (tree , tree, tree, int, bool );
	+/* APPLE LOCAL end "unavailable" attribute --ilr */
	static tree handle_vector_size_attribute (tree *, tree, tree, int,
	bool *);
	static tree handle_nonnull_attribute (tree , tree, tree, int, bool );
	static tree handle_nothrow_attribute (tree , tree, tree, int, bool );
	static tree handle_cleanup_attribute (tree , tree, tree, int, bool );
	static tree handle_warn_unused_result_attribute (tree *, tree, tree, int,
	bool *);
	static tree handle_sentinel_attribute (tree , tree, tree, int, bool );

	static void check_function_nonnull (tree, tree);
	static void check_nonnull_arg (void *, tree, unsigned HOST_WIDE_INT);
	static bool nonnull_check_p (tree, unsigned HOST_WIDE_INT);
	static bool get_nonnull_operand (tree, unsigned HOST_WIDE_INT *);
	static int resort_field_decl_cmp (const void , const void );

	/* Table of machine-independent attributes common to all C-like languages. */
	const struct attribute_spec c_common_attribute_table[] =
	{
	/* { name, min_len, max_len, decl_req, type_req, fn_type_req, handler } */
	{ "packed", 0, 0, false, false, false,
	handle_packed_attribute },
	{ "nocommon", 0, 0, true, false, false,
	handle_nocommon_attribute },
	{ "common", 0, 0, true, false, false,
	handle_common_attribute },
	/* FIXME: logically, noreturn attributes should be listed as
	"false, true, true" and apply to function types. But implementing this
	would require all the places in the compiler that use TREE_THIS_VOLATILE
	on a decl to identify non-returning functions to be located and fixed
	to check the function type instead. */
	{ "noreturn", 0, 0, true, false, false,
	handle_noreturn_attribute },
	{ "volatile", 0, 0, true, false, false,
	handle_noreturn_attribute },
	{ "noinline", 0, 0, true, false, false,
	handle_noinline_attribute },
	{ "always_inline", 0, 0, true, false, false,
	handle_always_inline_attribute },
	{ "gnu_inline", 0, 0, true, false, false,
	handle_gnu_inline_attribute },
	{ "flatten", 0, 0, true, false, false,
	handle_flatten_attribute },
	{ "used", 0, 0, true, false, false,
	handle_used_attribute },
	{ "unused", 0, 0, false, false, false,
	handle_unused_attribute },
	{ "externally_visible", 0, 0, true, false, false,
	handle_externally_visible_attribute },
	/* The same comments as for noreturn attributes apply to const ones. */
	{ "const", 0, 0, true, false, false,
	handle_const_attribute },
	{ "transparent_union", 0, 0, false, false, false,
	handle_transparent_union_attribute },
	{ "constructor", 0, 0, true, false, false,
	handle_constructor_attribute },
	{ "destructor", 0, 0, true, false, false,
	handle_destructor_attribute },
	{ "mode", 1, 1, false, true, false,
	handle_mode_attribute },
	{ "section", 1, 1, true, false, false,
	handle_section_attribute },
	{ "aligned", 0, 1, false, false, false,
	handle_aligned_attribute },
	{ "weak", 0, 0, true, false, false,
	handle_weak_attribute },
	{ "alias", 1, 1, true, false, false,
	handle_alias_attribute },
	{ "weakref", 0, 1, true, false, false,
	handle_weakref_attribute },
	{ "no_instrument_function", 0, 0, true, false, false,
	handle_no_instrument_function_attribute },
	{ "malloc", 0, 0, true, false, false,
	handle_malloc_attribute },
	{ "returns_twice", 0, 0, true, false, false,
	handle_returns_twice_attribute },
	{ "no_stack_limit", 0, 0, true, false, false,
	handle_no_limit_stack_attribute },
	{ "pure", 0, 0, true, false, false,
	handle_pure_attribute },
	/* For internal use (marking of builtins) only. The name contains space
	to prevent its usage in source code. */
	{ "no vops", 0, 0, true, false, false,
	handle_novops_attribute },
	{ "deprecated", 0, 0, false, false, false,
	handle_deprecated_attribute },
	+ /* APPLE LOCAL begin "unavailable" attribute (Radar 2809697) --ilr */
	+ { "unavailable", 0, 0, false, false, false,
	+ handle_unavailable_attribute },
	+ /* APPLE LOCAL end "unavailable" attribute --ilr */
	{ "vector_size", 1, 1, false, true, false,
	handle_vector_size_attribute },
	{ "visibility", 1, 1, false, false, false,
	handle_visibility_attribute },
	{ "tls_model", 1, 1, true, false, false,
	handle_tls_model_attribute },
	{ "nonnull", 0, -1, false, true, true,
	handle_nonnull_attribute },
	{ "nothrow", 0, 0, true, false, false,
	handle_nothrow_attribute },
	{ "may_alias", 0, 0, false, true, false, NULL },
	{ "cleanup", 1, 1, true, false, false,
	handle_cleanup_attribute },
	{ "warn_unused_result", 0, 0, false, true, true,
	handle_warn_unused_result_attribute },
	{ "sentinel", 0, 1, false, true, true,
	handle_sentinel_attribute },
	{ NULL, 0, 0, false, false, false, NULL }
	};

	/* Give the specifications for the format attributes, used by C and all
	descendants. */

	const struct attribute_spec c_common_format_attribute_table[] =
	{
	/* { name, min_len, max_len, decl_req, type_req, fn_type_req, handler } */
	{ "format", 3, 3, false, true, true,
	handle_format_attribute },
	{ "format_arg", 1, 1, false, true, true,
	handle_format_arg_attribute },
	{ NULL, 0, 0, false, false, false, NULL }
	};

	/* Push current bindings for the function name VAR_DECLS. */

	void
	start_fname_decls (void)
	{
	unsigned ix;
	tree saved = NULL_TREE;

	for (ix = 0; fname_vars[ix].decl; ix++)
	{
	tree decl = *fname_vars[ix].decl;

	if (decl)
	{
	saved = tree_cons (decl, build_int_cst (NULL_TREE, ix), saved);
	*fname_vars[ix].decl = NULL_TREE;
	}
	}
	if (saved \|\| saved_function_name_decls)
	/* Normally they'll have been NULL, so only push if we've got a
	stack, or they are non-NULL. */
	saved_function_name_decls = tree_cons (saved, NULL_TREE,
	saved_function_name_decls);
	}

	/* Finish up the current bindings, adding them into the current function's
	statement tree. This must be done _before_ finish_stmt_tree is called.
	If there is no current function, we must be at file scope and no statements
	are involved. Pop the previous bindings. */

	void
	finish_fname_decls (void)
	{
	unsigned ix;
	tree stmts = NULL_TREE;
	tree stack = saved_function_name_decls;

	for (; stack && TREE_VALUE (stack); stack = TREE_CHAIN (stack))
	append_to_statement_list (TREE_VALUE (stack), &stmts);

	if (stmts)
	{
	tree *bodyp = &DECL_SAVED_TREE (current_function_decl);

	if (TREE_CODE (*bodyp) == BIND_EXPR)
	bodyp = &BIND_EXPR_BODY (*bodyp);

	append_to_statement_list_force (*bodyp, &stmts);
	*bodyp = stmts;
	}

	for (ix = 0; fname_vars[ix].decl; ix++)
	*fname_vars[ix].decl = NULL_TREE;

	if (stack)
	{
	/* We had saved values, restore them. */
	tree saved;

	for (saved = TREE_PURPOSE (stack); saved; saved = TREE_CHAIN (saved))
	{
	tree decl = TREE_PURPOSE (saved);
	unsigned ix = TREE_INT_CST_LOW (TREE_VALUE (saved));

	*fname_vars[ix].decl = decl;
	}
	stack = TREE_CHAIN (stack);
	}
	saved_function_name_decls = stack;
	}

	/* Return the text name of the current function, suitably prettified
	by PRETTY_P. Return string must be freed by caller. */

	const char *
	fname_as_string (int pretty_p)
	{
	const char *name = "top level";
	char *namep;
	int vrb = 2;

	if (!pretty_p)
	{
	name = "";
	vrb = 0;
	}

	if (current_function_decl)
	name = lang_hooks.decl_printable_name (current_function_decl, vrb);

	if (c_lex_string_translate)
	{
	int len = strlen (name) + 3; /* Two for '"'s. One for NULL. */
	cpp_string cstr = { 0, 0 }, strname;

	namep = XNEWVEC (char, len);
	snprintf (namep, len, "\"%s\"", name);
	strname.text = (unsigned char *) namep;
	strname.len = len - 1;

	if (cpp_interpret_string (parse_in, &strname, 1, &cstr, false))
	{
	XDELETEVEC (namep);
	return (char *) cstr.text;
	}
	}
	else
	namep = xstrdup (name);

	return namep;
	}

	/* Expand DECL if it declares an entity not handled by the
	common code. */

	int
	c_expand_decl (tree decl)
	{
	if (TREE_CODE (decl) == VAR_DECL && !TREE_STATIC (decl))
	{
	/* Let the back-end know about this variable. */
	if (!anon_aggr_type_p (TREE_TYPE (decl)))
	emit_local_var (decl);
	else
	expand_anon_union_decl (decl, NULL_TREE,
	DECL_ANON_UNION_ELEMS (decl));
	}
	else
	return 0;

	return 1;
	}


	/* Return the VAR_DECL for a const char array naming the current
	function. If the VAR_DECL has not yet been created, create it
	now. RID indicates how it should be formatted and IDENTIFIER_NODE
	ID is its name (unfortunately C and C++ hold the RID values of
	keywords in different places, so we can't derive RID from ID in
	this language independent code. */

	tree
	fname_decl (unsigned int rid, tree id)
	{
	unsigned ix;
	tree decl = NULL_TREE;

	for (ix = 0; fname_vars[ix].decl; ix++)
	if (fname_vars[ix].rid == rid)
	break;

	decl = *fname_vars[ix].decl;
	if (!decl)
	{
	/* If a tree is built here, it would normally have the lineno of
	the current statement. Later this tree will be moved to the
	beginning of the function and this line number will be wrong.
	To avoid this problem set the lineno to 0 here; that prevents
	it from appearing in the RTL. */
	tree stmts;
	location_t saved_location = input_location;
	#ifdef USE_MAPPED_LOCATION
	input_location = UNKNOWN_LOCATION;
	#else
	input_line = 0;
	#endif

	stmts = push_stmt_list ();
	decl = (*make_fname_decl) (id, fname_vars[ix].pretty);
	stmts = pop_stmt_list (stmts);
	if (!IS_EMPTY_STMT (stmts))
	saved_function_name_decls
	= tree_cons (decl, stmts, saved_function_name_decls);
	*fname_vars[ix].decl = decl;
	input_location = saved_location;
	}
	if (!ix && !current_function_decl)
	pedwarn ("%qD is not defined outside of function scope", decl);

	return decl;
	}

	/* Given a STRING_CST, give it a suitable array-of-chars data type. */

	tree
	fix_string_type (tree value)
	{
	const int wchar_bytes = TYPE_PRECISION (wchar_type_node) / BITS_PER_UNIT;
	const int wide_flag = TREE_TYPE (value) == wchar_array_type_node;
	int length = TREE_STRING_LENGTH (value);
	int nchars;
	tree e_type, i_type, a_type;

	/* Compute the number of elements, for the array type. */
	nchars = wide_flag ? length / wchar_bytes : length;

	/* C89 2.2.4.1, C99 5.2.4.1 (Translation limits). The analogous
	limit in C++98 Annex B is very large (65536) and is not normative,
	so we do not diagnose it (warn_overlength_strings is forced off
	in c_common_post_options). */
	if (warn_overlength_strings)
	{
	const int nchars_max = flag_isoc99 ? 4095 : 509;
	const int relevant_std = flag_isoc99 ? 99 : 90;
	if (nchars - 1 > nchars_max)
	/* Translators: The %d after 'ISO C' will be 90 or 99. Do not
	separate the %d from the 'C'. 'ISO' should not be
	translated, but it may be moved after 'C%d' in languages
	where modifiers follow nouns. */
	pedwarn ("string length %qd is greater than the length %qd "
	"ISO C%d compilers are required to support",
	nchars - 1, nchars_max, relevant_std);
	}

	/* Create the array type for the string constant. The ISO C++
	standard says that a string literal has type `const char[N]' or
	`const wchar_t[N]'. We use the same logic when invoked as a C
	front-end with -Wwrite-strings.
	??? We should change the type of an expression depending on the
	state of a warning flag. We should just be warning -- see how
	this is handled in the C++ front-end for the deprecated implicit
	conversion from string literals to `char' or `wchar_t'.

	The C++ front end relies on TYPE_MAIN_VARIANT of a cv-qualified
	array type being the unqualified version of that type.
	Therefore, if we are constructing an array of const char, we must
	construct the matching unqualified array type first. The C front
	end does not require this, but it does no harm, so we do it
	unconditionally. */
	e_type = wide_flag ? wchar_type_node : char_type_node;
	i_type = build_index_type (build_int_cst (NULL_TREE, nchars - 1));
	a_type = build_array_type (e_type, i_type);
	if (c_dialect_cxx() \|\| warn_write_strings)
	a_type = c_build_qualified_type (a_type, TYPE_QUAL_CONST);

	TREE_TYPE (value) = a_type;
	TREE_CONSTANT (value) = 1;
	TREE_INVARIANT (value) = 1;
	TREE_READONLY (value) = 1;
	TREE_STATIC (value) = 1;
	return value;
	}

	/* Print a warning if a constant expression had overflow in folding.
	Invoke this function on every expression that the language
	requires to be a constant expression.
	Note the ANSI C standard says it is erroneous for a
	constant expression to overflow. */

	void
	constant_expression_warning (tree value)
	{
	if ((TREE_CODE (value) == INTEGER_CST \|\| TREE_CODE (value) == REAL_CST
	\|\| TREE_CODE (value) == VECTOR_CST
	\|\| TREE_CODE (value) == COMPLEX_CST)
	&& TREE_CONSTANT_OVERFLOW (value)
	&& warn_overflow
	&& pedantic)
	pedwarn ("overflow in constant expression");
	}

	/* Print a warning if an expression had overflow in folding and its
	operands hadn't.

	Invoke this function on every expression that
	(1) appears in the source code, and
	(2) is a constant expression that overflowed, and
	(3) is not already checked by convert_and_check;
	however, do not invoke this function on operands of explicit casts
	or when the expression is the result of an operator and any operand
	already overflowed. */

	void
	overflow_warning (tree value)
	{
	if (skip_evaluation) return;

	switch (TREE_CODE (value))
	{
	case INTEGER_CST:
	warning (OPT_Woverflow, "integer overflow in expression");
	break;

	case REAL_CST:
	warning (OPT_Woverflow, "floating point overflow in expression");
	break;

	case VECTOR_CST:
	warning (OPT_Woverflow, "vector overflow in expression");
	break;

	case COMPLEX_CST:
	if (TREE_CODE (TREE_REALPART (value)) == INTEGER_CST)
	warning (OPT_Woverflow, "complex integer overflow in expression");
	else if (TREE_CODE (TREE_REALPART (value)) == REAL_CST)
	warning (OPT_Woverflow, "complex floating point overflow in expression");
	break;

	default:
	break;
	}
	}

	/* Print a warning if a large constant is truncated to unsigned,
	or if -Wconversion is used and a constant < 0 is converted to unsigned.
	Invoke this function on every expression that might be implicitly
	converted to an unsigned type. */

	static void
	unsigned_conversion_warning (tree result, tree operand)
	{
	tree type = TREE_TYPE (result);

	if (TREE_CODE (operand) == INTEGER_CST
	&& TREE_CODE (type) == INTEGER_TYPE
	&& TYPE_UNSIGNED (type)
	&& skip_evaluation == 0
	&& !int_fits_type_p (operand, type))
	{
	if (!int_fits_type_p (operand, c_common_signed_type (type)))
	/* This detects cases like converting -129 or 256 to unsigned char. */
	warning (OPT_Woverflow,
	"large integer implicitly truncated to unsigned type");
	else
	warning (OPT_Wconversion,
	"negative integer implicitly converted to unsigned type");
	}
	}

	/* Print a warning about casts that might indicate violation
	of strict aliasing rules if -Wstrict-aliasing is used and
	strict aliasing mode is in effect. OTYPE is the original
	TREE_TYPE of EXPR, and TYPE the type we're casting to. */

	bool
	strict_aliasing_warning (tree otype, tree type, tree expr)
	{
	if (!(flag_strict_aliasing && POINTER_TYPE_P (type)
	&& POINTER_TYPE_P (otype) && !VOID_TYPE_P (TREE_TYPE (type))))
	return false;

	if ((warn_strict_aliasing > 1) && TREE_CODE (expr) == ADDR_EXPR
	&& (DECL_P (TREE_OPERAND (expr, 0))
	\|\| handled_component_p (TREE_OPERAND (expr, 0))))
	{
	/* Casting the address of an object to non void pointer. Warn
	if the cast breaks type based aliasing. */
	if (!COMPLETE_TYPE_P (TREE_TYPE (type)) && warn_strict_aliasing == 2)
	{
	warning (OPT_Wstrict_aliasing, "type-punning to incomplete type "
	"might break strict-aliasing rules");
	return true;
	}
	else
	{
	/* warn_strict_aliasing >= 3. This includes the default (3).
	Only warn if the cast is dereferenced immediately. */
	HOST_WIDE_INT set1 =
	get_alias_set (TREE_TYPE (TREE_OPERAND (expr, 0)));
	HOST_WIDE_INT set2 = get_alias_set (TREE_TYPE (type));

	if (!alias_sets_conflict_p (set1, set2))
	{
	warning (OPT_Wstrict_aliasing, "dereferencing type-punned "
	"pointer will break strict-aliasing rules");
	return true;
	}
	else if (warn_strict_aliasing == 2
	&& !alias_sets_might_conflict_p (set1, set2))
	{
	warning (OPT_Wstrict_aliasing, "dereferencing type-punned "
	"pointer might break strict-aliasing rules");
	return true;
	}
	}
	}
	else
	if ((warn_strict_aliasing == 1) && !VOID_TYPE_P (TREE_TYPE (otype)))
	{
	/* At this level, warn for any conversions, even if an address is
	not taken in the same statement. This will likely produce many
	false positives, but could be useful to pinpoint problems that
	are not revealed at higher levels. */
	HOST_WIDE_INT set1 = get_alias_set (TREE_TYPE (otype));
	HOST_WIDE_INT set2 = get_alias_set (TREE_TYPE (type));
	if (!COMPLETE_TYPE_P(type)
	\|\| !alias_sets_might_conflict_p (set1, set2))
	{
	warning (OPT_Wstrict_aliasing, "dereferencing type-punned "
	"pointer might break strict-aliasing rules");
	return true;
	}
	}

	return false;
	}


	/* Print a warning about if (); or if () .. else; constructs
	via the special empty statement node that we create. INNER_THEN
	and INNER_ELSE are the statement lists of the if and the else
	block. */

	void
	empty_body_warning (tree inner_then, tree inner_else)
	{
	if (extra_warnings)
	{
	if (TREE_CODE (inner_then) == STATEMENT_LIST
	&& STATEMENT_LIST_TAIL (inner_then))
	inner_then = STATEMENT_LIST_TAIL (inner_then)->stmt;

	if (inner_else && TREE_CODE (inner_else) == STATEMENT_LIST
	&& STATEMENT_LIST_TAIL (inner_else))
	inner_else = STATEMENT_LIST_TAIL (inner_else)->stmt;

	if (IS_EMPTY_STMT (inner_then) && !inner_else)
	warning (OPT_Wextra, "%Hempty body in an if-statement",
	EXPR_LOCUS (inner_then));

	if (inner_else && IS_EMPTY_STMT (inner_else))
	warning (OPT_Wextra, "%Hempty body in an else-statement",
	EXPR_LOCUS (inner_else));
	}
	}


	/* Nonzero if constant C has a value that is permissible
	for type TYPE (an INTEGER_TYPE). */

	static int
	constant_fits_type_p (tree c, tree type)
	{
	if (TREE_CODE (c) == INTEGER_CST)
	return int_fits_type_p (c, type);

	c = convert (type, c);
	return !TREE_OVERFLOW (c);
	}


	/* True if vector types T1 and T2 can be converted to each other
	without an explicit cast. If EMIT_LAX_NOTE is true, and T1 and T2
	can only be converted with -flax-vector-conversions yet that is not
	in effect, emit a note telling the user about that option if such
	a note has not previously been emitted. */
	bool
	vector_types_convertible_p (tree t1, tree t2, bool emit_lax_note)
	{
	static bool emitted_lax_note = false;
	bool convertible_lax;

	if ((targetm.vector_opaque_p (t1) \|\| targetm.vector_opaque_p (t2))
	&& tree_int_cst_equal (TYPE_SIZE (t1), TYPE_SIZE (t2)))
	return true;

	convertible_lax =
	(tree_int_cst_equal (TYPE_SIZE (t1), TYPE_SIZE (t2))
	&& (TREE_CODE (TREE_TYPE (t1)) != REAL_TYPE \|\|
	TYPE_PRECISION (t1) == TYPE_PRECISION (t2))
	&& (INTEGRAL_TYPE_P (TREE_TYPE (t1))
	== INTEGRAL_TYPE_P (TREE_TYPE (t2))));

	if (!convertible_lax \|\| flag_lax_vector_conversions)
	return convertible_lax;

	if (TYPE_VECTOR_SUBPARTS (t1) == TYPE_VECTOR_SUBPARTS (t2)
	&& comptypes (TREE_TYPE (t1), TREE_TYPE (t2)))
	return true;

	if (emit_lax_note && !emitted_lax_note)
	{
	emitted_lax_note = true;
	inform ("use -flax-vector-conversions to permit "
	"conversions between vectors with differing "
	"element types or numbers of subparts");
	}

	return false;
	}

	/* Convert EXPR to TYPE, warning about conversion problems with constants.
	Invoke this function on every expression that is converted implicitly,
	i.e. because of language rules and not because of an explicit cast. */

	tree
	convert_and_check (tree type, tree expr)
	{
	tree t = convert (type, expr);
	if (TREE_CODE (t) == INTEGER_CST)
	{
	if (TREE_OVERFLOW (t))
	{
	TREE_OVERFLOW (t) = 0;

	/* Do not diagnose overflow in a constant expression merely
	because a conversion overflowed. */
	TREE_CONSTANT_OVERFLOW (t) = CONSTANT_CLASS_P (expr)
	&& TREE_CONSTANT_OVERFLOW (expr);

	/* No warning for converting 0x80000000 to int. */
	if (!(TYPE_UNSIGNED (type) < TYPE_UNSIGNED (TREE_TYPE (expr))
	&& TREE_CODE (TREE_TYPE (expr)) == INTEGER_TYPE
	&& TYPE_PRECISION (type) == TYPE_PRECISION (TREE_TYPE (expr))))
	/* If EXPR fits in the unsigned version of TYPE,
	don't warn unless pedantic. */
	if ((pedantic
	\|\| TYPE_UNSIGNED (type)
	\|\| !constant_fits_type_p (expr,
	c_common_unsigned_type (type)))
	&& skip_evaluation == 0)
	warning (OPT_Woverflow,
	"overflow in implicit constant conversion");
	}
	else
	unsigned_conversion_warning (t, expr);
	}
	return t;
	}

	/* A node in a list that describes references to variables (EXPR), which are
	either read accesses if WRITER is zero, or write accesses, in which case
	WRITER is the parent of EXPR. */
	struct tlist
	{
	struct tlist *next;
	tree expr, writer;
	};

	/* Used to implement a cache the results of a call to verify_tree. We only
	use this for SAVE_EXPRs. */
	struct tlist_cache
	{
	struct tlist_cache *next;
	struct tlist *cache_before_sp;
	struct tlist *cache_after_sp;
	tree expr;
	};

	/* Obstack to use when allocating tlist structures, and corresponding
	firstobj. */
	static struct obstack tlist_obstack;
	static char *tlist_firstobj = 0;

	/* Keep track of the identifiers we've warned about, so we can avoid duplicate
	warnings. */
	static struct tlist *warned_ids;
	/* SAVE_EXPRs need special treatment. We process them only once and then
	cache the results. */
	static struct tlist_cache *save_expr_cache;

	static void add_tlist (struct tlist *, struct tlist , tree, int);
	static void merge_tlist (struct tlist *, struct tlist , int);
	static void verify_tree (tree, struct tlist , struct tlist , tree);
	static int warning_candidate_p (tree);
	static void warn_for_collisions (struct tlist *);
	static void warn_for_collisions_1 (tree, tree, struct tlist *, int);
	static struct tlist new_tlist (struct tlist , tree, tree);

	/* Create a new struct tlist and fill in its fields. */
	static struct tlist *
	new_tlist (struct tlist *next, tree t, tree writer)
	{
	struct tlist *l;
	l = XOBNEW (&tlist_obstack, struct tlist);
	l->next = next;
	l->expr = t;
	l->writer = writer;
	return l;
	}

	/* Add duplicates of the nodes found in ADD to the list *TO. If EXCLUDE_WRITER
	is nonnull, we ignore any node we find which has a writer equal to it. */

	static void
	add_tlist (struct tlist *to, struct tlist add, tree exclude_writer, int copy)
	{
	while (add)
	{
	struct tlist *next = add->next;
	if (!copy)
	add->next = *to;
	if (!exclude_writer \|\| add->writer != exclude_writer)
	to = copy ? new_tlist (to, add->expr, add->writer) : add;
	add = next;
	}
	}

	/* Merge the nodes of ADD into TO. This merging process is done so that for
	each variable that already exists in TO, no new node is added; however if
	there is a write access recorded in ADD, and an occurrence on TO is only
	a read access, then the occurrence in TO will be modified to record the
	write. */

	static void
	merge_tlist (struct tlist *to, struct tlist add, int copy)
	{
	struct tlist **end = to;

	while (*end)
	end = &(*end)->next;

	while (add)
	{
	int found = 0;
	struct tlist *tmp2;
	struct tlist *next = add->next;

	for (tmp2 = *to; tmp2; tmp2 = tmp2->next)
	if (tmp2->expr == add->expr)
	{
	found = 1;
	if (!tmp2->writer)
	tmp2->writer = add->writer;
	}
	if (!found)
	{
	*end = copy ? add : new_tlist (NULL, add->expr, add->writer);
	end = &(*end)->next;
	*end = 0;
	}
	add = next;
	}
	}

	/* WRITTEN is a variable, WRITER is its parent. Warn if any of the variable
	references in list LIST conflict with it, excluding reads if ONLY writers
	is nonzero. */

	static void
	warn_for_collisions_1 (tree written, tree writer, struct tlist *list,
	int only_writes)
	{
	struct tlist *tmp;

	/* Avoid duplicate warnings. */
	for (tmp = warned_ids; tmp; tmp = tmp->next)
	if (tmp->expr == written)
	return;

	while (list)
	{
	if (list->expr == written
	&& list->writer != writer
	&& (!only_writes \|\| list->writer)
	&& DECL_NAME (list->expr))
	{
	warned_ids = new_tlist (warned_ids, written, NULL_TREE);
	warning (0, "operation on %qE may be undefined", list->expr);
	}
	list = list->next;
	}
	}

	/* Given a list LIST of references to variables, find whether any of these
	can cause conflicts due to missing sequence points. */

	static void
	warn_for_collisions (struct tlist *list)
	{
	struct tlist *tmp;

	for (tmp = list; tmp; tmp = tmp->next)
	{
	if (tmp->writer)
	warn_for_collisions_1 (tmp->expr, tmp->writer, list, 0);
	}
	}

	/* Return nonzero if X is a tree that can be verified by the sequence point
	warnings. */
	static int
	warning_candidate_p (tree x)
	{
	return TREE_CODE (x) == VAR_DECL \|\| TREE_CODE (x) == PARM_DECL;
	}

	/* Walk the tree X, and record accesses to variables. If X is written by the
	parent tree, WRITER is the parent.
	We store accesses in one of the two lists: PBEFORE_SP, and PNO_SP. If this
	expression or its only operand forces a sequence point, then everything up
	to the sequence point is stored in PBEFORE_SP. Everything else gets stored
	in PNO_SP.
	Once we return, we will have emitted warnings if any subexpression before
	such a sequence point could be undefined. On a higher level, however, the
	sequence point may not be relevant, and we'll merge the two lists.

	Example: (b++, a) + b;
	The call that processes the COMPOUND_EXPR will store the increment of B
	in PBEFORE_SP, and the use of A in PNO_SP. The higher-level call that
	processes the PLUS_EXPR will need to merge the two lists so that
	eventually, all accesses end up on the same list (and we'll warn about the
	unordered subexpressions b++ and b.

	A note on merging. If we modify the former example so that our expression
	becomes
	(b++, b) + a
	care must be taken not simply to add all three expressions into the final
	PNO_SP list. The function merge_tlist takes care of that by merging the
	before-SP list of the COMPOUND_EXPR into its after-SP list in a special
	way, so that no more than one access to B is recorded. */

	static void
	verify_tree (tree x, struct tlist pbefore_sp, struct tlist pno_sp,
	tree writer)
	{
	struct tlist tmp_before, tmp_nosp, tmp_list2, tmp_list3;
	enum tree_code code;
	enum tree_code_class cl;

	/* X may be NULL if it is the operand of an empty statement expression
	({ }). */
	if (x == NULL)
	return;

	restart:
	code = TREE_CODE (x);
	cl = TREE_CODE_CLASS (code);

	if (warning_candidate_p (x))
	{
	pno_sp = new_tlist (pno_sp, x, writer);
	return;
	}

	switch (code)
	{
	case CONSTRUCTOR:
	return;

	case COMPOUND_EXPR:
	case TRUTH_ANDIF_EXPR:
	case TRUTH_ORIF_EXPR:
	tmp_before = tmp_nosp = tmp_list3 = 0;
	verify_tree (TREE_OPERAND (x, 0), &tmp_before, &tmp_nosp, NULL_TREE);
	warn_for_collisions (tmp_nosp);
	merge_tlist (pbefore_sp, tmp_before, 0);
	merge_tlist (pbefore_sp, tmp_nosp, 0);
	verify_tree (TREE_OPERAND (x, 1), &tmp_list3, pno_sp, NULL_TREE);
	merge_tlist (pbefore_sp, tmp_list3, 0);
	return;

	case COND_EXPR:
	tmp_before = tmp_list2 = 0;
	verify_tree (TREE_OPERAND (x, 0), &tmp_before, &tmp_list2, NULL_TREE);
	warn_for_collisions (tmp_list2);
	merge_tlist (pbefore_sp, tmp_before, 0);
	merge_tlist (pbefore_sp, tmp_list2, 1);

	tmp_list3 = tmp_nosp = 0;
	verify_tree (TREE_OPERAND (x, 1), &tmp_list3, &tmp_nosp, NULL_TREE);
	warn_for_collisions (tmp_nosp);
	merge_tlist (pbefore_sp, tmp_list3, 0);

	tmp_list3 = tmp_list2 = 0;
	verify_tree (TREE_OPERAND (x, 2), &tmp_list3, &tmp_list2, NULL_TREE);
	warn_for_collisions (tmp_list2);
	merge_tlist (pbefore_sp, tmp_list3, 0);
	/* Rather than add both tmp_nosp and tmp_list2, we have to merge the
	two first, to avoid warning for (a ? b++ : b++). */
	merge_tlist (&tmp_nosp, tmp_list2, 0);
	add_tlist (pno_sp, tmp_nosp, NULL_TREE, 0);
	return;

	case PREDECREMENT_EXPR:
	case PREINCREMENT_EXPR:
	case POSTDECREMENT_EXPR:
	case POSTINCREMENT_EXPR:
	verify_tree (TREE_OPERAND (x, 0), pno_sp, pno_sp, x);
	return;

	case MODIFY_EXPR:
	tmp_before = tmp_nosp = tmp_list3 = 0;
	verify_tree (TREE_OPERAND (x, 1), &tmp_before, &tmp_nosp, NULL_TREE);
	verify_tree (TREE_OPERAND (x, 0), &tmp_list3, &tmp_list3, x);
	/* Expressions inside the LHS are not ordered wrt. the sequence points
	in the RHS. Example:
	*a = (a++, 2)
	Despite the fact that the modification of "a" is in the before_sp
	list (tmp_before), it conflicts with the use of "a" in the LHS.
	We can handle this by adding the contents of tmp_list3
	to those of tmp_before, and redoing the collision warnings for that
	list. */
	add_tlist (&tmp_before, tmp_list3, x, 1);
	warn_for_collisions (tmp_before);
	/* Exclude the LHS itself here; we first have to merge it into the
	tmp_nosp list. This is done to avoid warning for "a = a"; if we
	didn't exclude the LHS, we'd get it twice, once as a read and once
	as a write. */
	add_tlist (pno_sp, tmp_list3, x, 0);
	warn_for_collisions_1 (TREE_OPERAND (x, 0), x, tmp_nosp, 1);

	merge_tlist (pbefore_sp, tmp_before, 0);
	if (warning_candidate_p (TREE_OPERAND (x, 0)))
	merge_tlist (&tmp_nosp, new_tlist (NULL, TREE_OPERAND (x, 0), x), 0);
	add_tlist (pno_sp, tmp_nosp, NULL_TREE, 1);
	return;

	case CALL_EXPR:
	/* We need to warn about conflicts among arguments and conflicts between
	args and the function address. Side effects of the function address,
	however, are not ordered by the sequence point of the call. */
	tmp_before = tmp_nosp = tmp_list2 = tmp_list3 = 0;
	verify_tree (TREE_OPERAND (x, 0), &tmp_before, &tmp_nosp, NULL_TREE);
	if (TREE_OPERAND (x, 1))
	verify_tree (TREE_OPERAND (x, 1), &tmp_list2, &tmp_list3, NULL_TREE);
	merge_tlist (&tmp_list3, tmp_list2, 0);
	add_tlist (&tmp_before, tmp_list3, NULL_TREE, 0);
	add_tlist (&tmp_before, tmp_nosp, NULL_TREE, 0);
	warn_for_collisions (tmp_before);
	add_tlist (pbefore_sp, tmp_before, NULL_TREE, 0);
	return;

	case TREE_LIST:
	/* Scan all the list, e.g. indices of multi dimensional array. */
	while (x)
	{
	tmp_before = tmp_nosp = 0;
	verify_tree (TREE_VALUE (x), &tmp_before, &tmp_nosp, NULL_TREE);
	merge_tlist (&tmp_nosp, tmp_before, 0);
	add_tlist (pno_sp, tmp_nosp, NULL_TREE, 0);
	x = TREE_CHAIN (x);
	}
	return;

	case SAVE_EXPR:
	{
	struct tlist_cache *t;
	for (t = save_expr_cache; t; t = t->next)
	if (t->expr == x)
	break;

	if (!t)
	{
	t = XOBNEW (&tlist_obstack, struct tlist_cache);
	t->next = save_expr_cache;
	t->expr = x;
	save_expr_cache = t;

	tmp_before = tmp_nosp = 0;
	verify_tree (TREE_OPERAND (x, 0), &tmp_before, &tmp_nosp, NULL_TREE);
	warn_for_collisions (tmp_nosp);

	tmp_list3 = 0;
	while (tmp_nosp)
	{
	struct tlist *t = tmp_nosp;
	tmp_nosp = t->next;
	merge_tlist (&tmp_list3, t, 0);
	}
	t->cache_before_sp = tmp_before;
	t->cache_after_sp = tmp_list3;
	}
	merge_tlist (pbefore_sp, t->cache_before_sp, 1);
	add_tlist (pno_sp, t->cache_after_sp, NULL_TREE, 1);
	return;
	}

	default:
	/* For other expressions, simply recurse on their operands.
	Manual tail recursion for unary expressions.
	Other non-expressions need not be processed. */
	if (cl == tcc_unary)
	{
	x = TREE_OPERAND (x, 0);
	writer = 0;
	goto restart;
	}
	else if (IS_EXPR_CODE_CLASS (cl))
	{
	int lp;
	int max = TREE_CODE_LENGTH (TREE_CODE (x));
	for (lp = 0; lp < max; lp++)
	{
	tmp_before = tmp_nosp = 0;
	verify_tree (TREE_OPERAND (x, lp), &tmp_before, &tmp_nosp, 0);
	merge_tlist (&tmp_nosp, tmp_before, 0);
	add_tlist (pno_sp, tmp_nosp, NULL_TREE, 0);
	}
	}
	return;
	}
	}

	/* Try to warn for undefined behavior in EXPR due to missing sequence
	points. */

	void
	verify_sequence_points (tree expr)
	{
	struct tlist before_sp = 0, after_sp = 0;

	warned_ids = 0;
	save_expr_cache = 0;
	if (tlist_firstobj == 0)
	{
	gcc_obstack_init (&tlist_obstack);
	tlist_firstobj = (char *) obstack_alloc (&tlist_obstack, 0);
	}

	verify_tree (expr, &before_sp, &after_sp, 0);
	warn_for_collisions (after_sp);
	obstack_free (&tlist_obstack, tlist_firstobj);
	}

	/* Validate the expression after `case' and apply default promotions. */

	static tree
	check_case_value (tree value)
	{
	if (value == NULL_TREE)
	return value;

	/* ??? Can we ever get nops here for a valid case value? We
	shouldn't for C. */
	STRIP_TYPE_NOPS (value);
	/* In C++, the following is allowed:

	const int i = 3;
	switch (...) { case i: ... }

	So, we try to reduce the VALUE to a constant that way. */
	if (c_dialect_cxx ())
	{
	value = decl_constant_value (value);
	STRIP_TYPE_NOPS (value);
	value = fold (value);
	}

	if (TREE_CODE (value) == INTEGER_CST)
	/* Promote char or short to int. */
	value = perform_integral_promotions (value);
	else if (value != error_mark_node)
	{
	error ("case label does not reduce to an integer constant");
	value = error_mark_node;
	}

	constant_expression_warning (value);

	return value;
	}

	/* See if the case values LOW and HIGH are in the range of the original
	type (i.e. before the default conversion to int) of the switch testing
	expression.
	TYPE is the promoted type of the testing expression, and ORIG_TYPE is
	the type before promoting it. CASE_LOW_P is a pointer to the lower
	bound of the case label, and CASE_HIGH_P is the upper bound or NULL
	if the case is not a case range.
	The caller has to make sure that we are not called with NULL for
	CASE_LOW_P (i.e. the default case).
	Returns true if the case label is in range of ORIG_TYPE (saturated or
	untouched) or false if the label is out of range. */

	static bool
	check_case_bounds (tree type, tree orig_type,
	tree case_low_p, tree case_high_p)
	{
	tree min_value, max_value;
	tree case_low = *case_low_p;
	tree case_high = case_high_p ? *case_high_p : case_low;

	/* If there was a problem with the original type, do nothing. */
	if (orig_type == error_mark_node)
	return true;

	min_value = TYPE_MIN_VALUE (orig_type);
	max_value = TYPE_MAX_VALUE (orig_type);

	/* Case label is less than minimum for type. */
	if (tree_int_cst_compare (case_low, min_value) < 0
	&& tree_int_cst_compare (case_high, min_value) < 0)
	{
	warning (0, "case label value is less than minimum value for type");
	return false;
	}

	/* Case value is greater than maximum for type. */
	if (tree_int_cst_compare (case_low, max_value) > 0
	&& tree_int_cst_compare (case_high, max_value) > 0)
	{
	warning (0, "case label value exceeds maximum value for type");
	return false;
	}

	/* Saturate lower case label value to minimum. */
	if (tree_int_cst_compare (case_high, min_value) >= 0
	&& tree_int_cst_compare (case_low, min_value) < 0)
	{
	warning (0, "lower value in case label range"
	" less than minimum value for type");
	case_low = min_value;
	}

	/* Saturate upper case label value to maximum. */
	if (tree_int_cst_compare (case_low, max_value) <= 0
	&& tree_int_cst_compare (case_high, max_value) > 0)
	{
	warning (0, "upper value in case label range"
	" exceeds maximum value for type");
	case_high = max_value;
	}

	if (*case_low_p != case_low)
	*case_low_p = convert (type, case_low);
	if (case_high_p && *case_high_p != case_high)
	*case_high_p = convert (type, case_high);

	return true;
	}

	/* Return an integer type with BITS bits of precision,
	that is unsigned if UNSIGNEDP is nonzero, otherwise signed. */

	tree
	c_common_type_for_size (unsigned int bits, int unsignedp)
	{
	if (bits == TYPE_PRECISION (integer_type_node))
	return unsignedp ? unsigned_type_node : integer_type_node;

	if (bits == TYPE_PRECISION (signed_char_type_node))
	return unsignedp ? unsigned_char_type_node : signed_char_type_node;

	if (bits == TYPE_PRECISION (short_integer_type_node))
	return unsignedp ? short_unsigned_type_node : short_integer_type_node;

	if (bits == TYPE_PRECISION (long_integer_type_node))
	return unsignedp ? long_unsigned_type_node : long_integer_type_node;

	if (bits == TYPE_PRECISION (long_long_integer_type_node))
	return (unsignedp ? long_long_unsigned_type_node
	: long_long_integer_type_node);

	if (bits == TYPE_PRECISION (widest_integer_literal_type_node))
	return (unsignedp ? widest_unsigned_literal_type_node
	: widest_integer_literal_type_node);

	if (bits <= TYPE_PRECISION (intQI_type_node))
	return unsignedp ? unsigned_intQI_type_node : intQI_type_node;

	if (bits <= TYPE_PRECISION (intHI_type_node))
	return unsignedp ? unsigned_intHI_type_node : intHI_type_node;

	if (bits <= TYPE_PRECISION (intSI_type_node))
	return unsignedp ? unsigned_intSI_type_node : intSI_type_node;

	if (bits <= TYPE_PRECISION (intDI_type_node))
	return unsignedp ? unsigned_intDI_type_node : intDI_type_node;

	return 0;
	}

	/* Used for communication between c_common_type_for_mode and
	c_register_builtin_type. */
	static GTY(()) tree registered_builtin_types;

	/* Return a data type that has machine mode MODE.
	If the mode is an integer,
	then UNSIGNEDP selects between signed and unsigned types. */

	tree
	c_common_type_for_mode (enum machine_mode mode, int unsignedp)
	{
	tree t;

	if (mode == TYPE_MODE (integer_type_node))
	return unsignedp ? unsigned_type_node : integer_type_node;

	if (mode == TYPE_MODE (signed_char_type_node))
	return unsignedp ? unsigned_char_type_node : signed_char_type_node;

	if (mode == TYPE_MODE (short_integer_type_node))
	return unsignedp ? short_unsigned_type_node : short_integer_type_node;

	if (mode == TYPE_MODE (long_integer_type_node))
	return unsignedp ? long_unsigned_type_node : long_integer_type_node;

	if (mode == TYPE_MODE (long_long_integer_type_node))
	return unsignedp ? long_long_unsigned_type_node : long_long_integer_type_node;

	if (mode == TYPE_MODE (widest_integer_literal_type_node))
	return unsignedp ? widest_unsigned_literal_type_node
	: widest_integer_literal_type_node;

	if (mode == QImode)
	return unsignedp ? unsigned_intQI_type_node : intQI_type_node;

	if (mode == HImode)
	return unsignedp ? unsigned_intHI_type_node : intHI_type_node;

	if (mode == SImode)
	return unsignedp ? unsigned_intSI_type_node : intSI_type_node;

	if (mode == DImode)
	return unsignedp ? unsigned_intDI_type_node : intDI_type_node;

	#if HOST_BITS_PER_WIDE_INT >= 64
	if (mode == TYPE_MODE (intTI_type_node))
	return unsignedp ? unsigned_intTI_type_node : intTI_type_node;
	#endif

	if (mode == TYPE_MODE (float_type_node))
	return float_type_node;

	if (mode == TYPE_MODE (double_type_node))
	return double_type_node;

	if (mode == TYPE_MODE (long_double_type_node))
	return long_double_type_node;

	if (mode == TYPE_MODE (void_type_node))
	return void_type_node;

	if (mode == TYPE_MODE (build_pointer_type (char_type_node)))
	return (unsignedp
	? make_unsigned_type (GET_MODE_PRECISION (mode))
	: make_signed_type (GET_MODE_PRECISION (mode)));

	if (mode == TYPE_MODE (build_pointer_type (integer_type_node)))
	return (unsignedp
	? make_unsigned_type (GET_MODE_PRECISION (mode))
	: make_signed_type (GET_MODE_PRECISION (mode)));

	if (COMPLEX_MODE_P (mode))
	{
	enum machine_mode inner_mode;
	tree inner_type;

	if (mode == TYPE_MODE (complex_float_type_node))
	return complex_float_type_node;
	if (mode == TYPE_MODE (complex_double_type_node))
	return complex_double_type_node;
	if (mode == TYPE_MODE (complex_long_double_type_node))
	return complex_long_double_type_node;

	if (mode == TYPE_MODE (complex_integer_type_node) && !unsignedp)
	return complex_integer_type_node;

	inner_mode = GET_MODE_INNER (mode);
	inner_type = c_common_type_for_mode (inner_mode, unsignedp);
	if (inner_type != NULL_TREE)
	return build_complex_type (inner_type);
	}
	else if (VECTOR_MODE_P (mode))
	{
	enum machine_mode inner_mode = GET_MODE_INNER (mode);
	tree inner_type = c_common_type_for_mode (inner_mode, unsignedp);
	if (inner_type != NULL_TREE)
	return build_vector_type_for_mode (inner_type, mode);
	}

	if (mode == TYPE_MODE (dfloat32_type_node))
	return dfloat32_type_node;
	if (mode == TYPE_MODE (dfloat64_type_node))
	return dfloat64_type_node;
	if (mode == TYPE_MODE (dfloat128_type_node))
	return dfloat128_type_node;

	for (t = registered_builtin_types; t; t = TREE_CHAIN (t))
	if (TYPE_MODE (TREE_VALUE (t)) == mode)
	return TREE_VALUE (t);

	return 0;
	}

	/* Return an unsigned type the same as TYPE in other respects. */
	tree
	c_common_unsigned_type (tree type)
	{
	tree type1 = TYPE_MAIN_VARIANT (type);
	if (type1 == signed_char_type_node \|\| type1 == char_type_node)
	return unsigned_char_type_node;
	if (type1 == integer_type_node)
	return unsigned_type_node;
	if (type1 == short_integer_type_node)
	return short_unsigned_type_node;
	if (type1 == long_integer_type_node)
	return long_unsigned_type_node;
	if (type1 == long_long_integer_type_node)
	return long_long_unsigned_type_node;
	if (type1 == widest_integer_literal_type_node)
	return widest_unsigned_literal_type_node;
	#if HOST_BITS_PER_WIDE_INT >= 64
	if (type1 == intTI_type_node)
	return unsigned_intTI_type_node;
	#endif
	if (type1 == intDI_type_node)
	return unsigned_intDI_type_node;
	if (type1 == intSI_type_node)
	return unsigned_intSI_type_node;
	if (type1 == intHI_type_node)
	return unsigned_intHI_type_node;
	if (type1 == intQI_type_node)
	return unsigned_intQI_type_node;

	return c_common_signed_or_unsigned_type (1, type);
	}

	/* Return a signed type the same as TYPE in other respects. */

	tree
	c_common_signed_type (tree type)
	{
	tree type1 = TYPE_MAIN_VARIANT (type);
	if (type1 == unsigned_char_type_node \|\| type1 == char_type_node)
	return signed_char_type_node;
	if (type1 == unsigned_type_node)
	return integer_type_node;
	if (type1 == short_unsigned_type_node)
	return short_integer_type_node;
	if (type1 == long_unsigned_type_node)
	return long_integer_type_node;
	if (type1 == long_long_unsigned_type_node)
	return long_long_integer_type_node;
	if (type1 == widest_unsigned_literal_type_node)
	return widest_integer_literal_type_node;
	#if HOST_BITS_PER_WIDE_INT >= 64
	if (type1 == unsigned_intTI_type_node)
	return intTI_type_node;
	#endif
	if (type1 == unsigned_intDI_type_node)
	return intDI_type_node;
	if (type1 == unsigned_intSI_type_node)
	return intSI_type_node;
	if (type1 == unsigned_intHI_type_node)
	return intHI_type_node;
	if (type1 == unsigned_intQI_type_node)
	return intQI_type_node;

	return c_common_signed_or_unsigned_type (0, type);
	}

	/* Return a type the same as TYPE except unsigned or
	signed according to UNSIGNEDP. */

	tree
	c_common_signed_or_unsigned_type (int unsignedp, tree type)
	{
	if (!INTEGRAL_TYPE_P (type)
	\|\| TYPE_UNSIGNED (type) == unsignedp)
	return type;

	/* For ENUMERAL_TYPEs in C++, must check the mode of the types, not
	the precision; they have precision set to match their range, but
	may use a wider mode to match an ABI. If we change modes, we may
	wind up with bad conversions. For INTEGER_TYPEs in C, must check
	the precision as well, so as to yield correct results for
	bit-field types. C++ does not have these separate bit-field
	types, and producing a signed or unsigned variant of an
	ENUMERAL_TYPE may cause other problems as well. */

	#define TYPE_OK(node) \
	(TYPE_MODE (type) == TYPE_MODE (node) \
	&& (c_dialect_cxx () \|\| TYPE_PRECISION (type) == TYPE_PRECISION (node)))
	if (TYPE_OK (signed_char_type_node))
	return unsignedp ? unsigned_char_type_node : signed_char_type_node;
	if (TYPE_OK (integer_type_node))
	return unsignedp ? unsigned_type_node : integer_type_node;
	if (TYPE_OK (short_integer_type_node))
	return unsignedp ? short_unsigned_type_node : short_integer_type_node;
	if (TYPE_OK (long_integer_type_node))
	return unsignedp ? long_unsigned_type_node : long_integer_type_node;
	if (TYPE_OK (long_long_integer_type_node))
	return (unsignedp ? long_long_unsigned_type_node
	: long_long_integer_type_node);
	if (TYPE_OK (widest_integer_literal_type_node))
	return (unsignedp ? widest_unsigned_literal_type_node
	: widest_integer_literal_type_node);

	#if HOST_BITS_PER_WIDE_INT >= 64
	if (TYPE_OK (intTI_type_node))
	return unsignedp ? unsigned_intTI_type_node : intTI_type_node;
	#endif
	if (TYPE_OK (intDI_type_node))
	return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
	if (TYPE_OK (intSI_type_node))
	return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
	if (TYPE_OK (intHI_type_node))
	return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
	if (TYPE_OK (intQI_type_node))
	return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
	#undef TYPE_OK

	if (c_dialect_cxx ())
	return type;
	else
	return build_nonstandard_integer_type (TYPE_PRECISION (type), unsignedp);
	}

	/* Build a bit-field integer type for the given WIDTH and UNSIGNEDP. */

	tree
	c_build_bitfield_integer_type (unsigned HOST_WIDE_INT width, int unsignedp)
	{
	/* Extended integer types of the same width as a standard type have
	lesser rank, so those of the same width as int promote to int or
	unsigned int and are valid for printf formats expecting int or
	unsigned int. To avoid such special cases, avoid creating
	extended integer types for bit-fields if a standard integer type
	is available. */
	if (width == TYPE_PRECISION (integer_type_node))
	return unsignedp ? unsigned_type_node : integer_type_node;
	if (width == TYPE_PRECISION (signed_char_type_node))
	return unsignedp ? unsigned_char_type_node : signed_char_type_node;
	if (width == TYPE_PRECISION (short_integer_type_node))
	return unsignedp ? short_unsigned_type_node : short_integer_type_node;
	if (width == TYPE_PRECISION (long_integer_type_node))
	return unsignedp ? long_unsigned_type_node : long_integer_type_node;
	if (width == TYPE_PRECISION (long_long_integer_type_node))
	return (unsignedp ? long_long_unsigned_type_node
	: long_long_integer_type_node);
	return build_nonstandard_integer_type (width, unsignedp);
	}

	/* The C version of the register_builtin_type langhook. */

	void
	c_register_builtin_type (tree type, const char* name)
	{
	tree decl;

	decl = build_decl (TYPE_DECL, get_identifier (name), type);
	DECL_ARTIFICIAL (decl) = 1;
	if (!TYPE_NAME (type))
	TYPE_NAME (type) = decl;
	pushdecl (decl);

	registered_builtin_types = tree_cons (0, type, registered_builtin_types);
	}


	/* Return the minimum number of bits needed to represent VALUE in a
	signed or unsigned type, UNSIGNEDP says which. */

	unsigned int
	min_precision (tree value, int unsignedp)
	{
	int log;

	/* If the value is negative, compute its negative minus 1. The latter
	adjustment is because the absolute value of the largest negative value
	is one larger than the largest positive value. This is equivalent to
	a bit-wise negation, so use that operation instead. */

	if (tree_int_cst_sgn (value) < 0)
	value = fold_build1 (BIT_NOT_EXPR, TREE_TYPE (value), value);

	/* Return the number of bits needed, taking into account the fact
	that we need one more bit for a signed than unsigned type. */

	if (integer_zerop (value))
	log = 0;
	else
	log = tree_floor_log2 (value);

	return log + 1 + !unsignedp;
	}

	/* Print an error message for invalid operands to arith operation
	CODE with TYPE0 for operand 0, and TYPE1 for operand 1. */

	void
	binary_op_error (enum tree_code code, tree type0, tree type1)
	{
	const char *opname;

	switch (code)
	{
	case PLUS_EXPR:
	opname = "+"; break;
	case MINUS_EXPR:
	opname = "-"; break;
	case MULT_EXPR:
	opname = "*"; break;
	case MAX_EXPR:
	opname = "max"; break;
	case MIN_EXPR:
	opname = "min"; break;
	case EQ_EXPR:
	opname = "=="; break;
	case NE_EXPR:
	opname = "!="; break;
	case LE_EXPR:
	opname = "<="; break;
	case GE_EXPR:
	opname = ">="; break;
	case LT_EXPR:
	opname = "<"; break;
	case GT_EXPR:
	opname = ">"; break;
	case LSHIFT_EXPR:
	opname = "<<"; break;
	case RSHIFT_EXPR:
	opname = ">>"; break;
	case TRUNC_MOD_EXPR:
	case FLOOR_MOD_EXPR:
	opname = "%"; break;
	case TRUNC_DIV_EXPR:
	case FLOOR_DIV_EXPR:
	opname = "/"; break;
	case BIT_AND_EXPR:
	opname = "&"; break;
	case BIT_IOR_EXPR:
	opname = "\|"; break;
	case TRUTH_ANDIF_EXPR:
	opname = "&&"; break;
	case TRUTH_ORIF_EXPR:
	opname = "\|\|"; break;
	case BIT_XOR_EXPR:
	opname = "^"; break;
	default:
	gcc_unreachable ();
	}
	error ("invalid operands to binary %s (have %qT and %qT)", opname,
	type0, type1);
	}

	/* Subroutine of build_binary_op, used for comparison operations.
	See if the operands have both been converted from subword integer types
	and, if so, perhaps change them both back to their original type.
	This function is also responsible for converting the two operands
	to the proper common type for comparison.

	The arguments of this function are all pointers to local variables
	of build_binary_op: OP0_PTR is &OP0, OP1_PTR is &OP1,
	RESTYPE_PTR is &RESULT_TYPE and RESCODE_PTR is &RESULTCODE.

	If this function returns nonzero, it means that the comparison has
	a constant value. What this function returns is an expression for
	that value. */

	tree
	shorten_compare (tree op0_ptr, tree op1_ptr, tree *restype_ptr,
	enum tree_code *rescode_ptr)
	{
	tree type;
	tree op0 = *op0_ptr;
	tree op1 = *op1_ptr;
	int unsignedp0, unsignedp1;
	int real1, real2;
	tree primop0, primop1;
	enum tree_code code = *rescode_ptr;

	/* Throw away any conversions to wider types
	already present in the operands. */

	primop0 = get_narrower (op0, &unsignedp0);
	primop1 = get_narrower (op1, &unsignedp1);

	/* Handle the case that OP0 does not contain a conversion
	but it requires conversion to FINAL_TYPE. */

	if (op0 == primop0 && TREE_TYPE (op0) != *restype_ptr)
	unsignedp0 = TYPE_UNSIGNED (TREE_TYPE (op0));
	if (op1 == primop1 && TREE_TYPE (op1) != *restype_ptr)
	unsignedp1 = TYPE_UNSIGNED (TREE_TYPE (op1));

	/* If one of the operands must be floated, we cannot optimize. */
	real1 = TREE_CODE (TREE_TYPE (primop0)) == REAL_TYPE;
	real2 = TREE_CODE (TREE_TYPE (primop1)) == REAL_TYPE;

	/* If first arg is constant, swap the args (changing operation
	so value is preserved), for canonicalization. Don't do this if
	the second arg is 0. */

	if (TREE_CONSTANT (primop0)
	&& !integer_zerop (primop1) && !real_zerop (primop1))
	{
	tree tem = primop0;
	int temi = unsignedp0;
	primop0 = primop1;
	primop1 = tem;
	tem = op0;
	op0 = op1;
	op1 = tem;
	*op0_ptr = op0;
	*op1_ptr = op1;
	unsignedp0 = unsignedp1;
	unsignedp1 = temi;
	temi = real1;
	real1 = real2;
	real2 = temi;

	switch (code)
	{
	case LT_EXPR:
	code = GT_EXPR;
	break;
	case GT_EXPR:
	code = LT_EXPR;
	break;
	case LE_EXPR:
	code = GE_EXPR;
	break;
	case GE_EXPR:
	code = LE_EXPR;
	break;
	default:
	break;
	}
	*rescode_ptr = code;
	}

	/* If comparing an integer against a constant more bits wide,
	maybe we can deduce a value of 1 or 0 independent of the data.
	Or else truncate the constant now
	rather than extend the variable at run time.

	This is only interesting if the constant is the wider arg.
	Also, it is not safe if the constant is unsigned and the
	variable arg is signed, since in this case the variable
	would be sign-extended and then regarded as unsigned.
	Our technique fails in this case because the lowest/highest
	possible unsigned results don't follow naturally from the
	lowest/highest possible values of the variable operand.
	For just EQ_EXPR and NE_EXPR there is another technique that
	could be used: see if the constant can be faithfully represented
	in the other operand's type, by truncating it and reextending it
	and see if that preserves the constant's value. */

	if (!real1 && !real2
	&& TREE_CODE (primop1) == INTEGER_CST
	&& TYPE_PRECISION (TREE_TYPE (primop0)) < TYPE_PRECISION (*restype_ptr))
	{
	int min_gt, max_gt, min_lt, max_lt;
	tree maxval, minval;
	/* 1 if comparison is nominally unsigned. */
	int unsignedp = TYPE_UNSIGNED (*restype_ptr);
	tree val;

	type = c_common_signed_or_unsigned_type (unsignedp0,
	TREE_TYPE (primop0));

	maxval = TYPE_MAX_VALUE (type);
	minval = TYPE_MIN_VALUE (type);

	if (unsignedp && !unsignedp0)
	restype_ptr = c_common_signed_type (restype_ptr);

	if (TREE_TYPE (primop1) != *restype_ptr)
	{
	/* Convert primop1 to target type, but do not introduce
	additional overflow. We know primop1 is an int_cst. */
	tree tmp = build_int_cst_wide (*restype_ptr,
	TREE_INT_CST_LOW (primop1),
	TREE_INT_CST_HIGH (primop1));

	primop1 = force_fit_type (tmp, 0, TREE_OVERFLOW (primop1),
	TREE_CONSTANT_OVERFLOW (primop1));
	}
	if (type != *restype_ptr)
	{
	minval = convert (*restype_ptr, minval);
	maxval = convert (*restype_ptr, maxval);
	}

	if (unsignedp && unsignedp0)
	{
	min_gt = INT_CST_LT_UNSIGNED (primop1, minval);
	max_gt = INT_CST_LT_UNSIGNED (primop1, maxval);
	min_lt = INT_CST_LT_UNSIGNED (minval, primop1);
	max_lt = INT_CST_LT_UNSIGNED (maxval, primop1);
	}
	else
	{
	min_gt = INT_CST_LT (primop1, minval);
	max_gt = INT_CST_LT (primop1, maxval);
	min_lt = INT_CST_LT (minval, primop1);
	max_lt = INT_CST_LT (maxval, primop1);
	}

	val = 0;
	/* This used to be a switch, but Genix compiler can't handle that. */
	if (code == NE_EXPR)
	{
	if (max_lt \|\| min_gt)
	val = truthvalue_true_node;
	}
	else if (code == EQ_EXPR)
	{
	if (max_lt \|\| min_gt)
	val = truthvalue_false_node;
	}
	else if (code == LT_EXPR)
	{
	if (max_lt)
	val = truthvalue_true_node;
	if (!min_lt)
	val = truthvalue_false_node;
	}
	else if (code == GT_EXPR)
	{
	if (min_gt)
	val = truthvalue_true_node;
	if (!max_gt)
	val = truthvalue_false_node;
	}
	else if (code == LE_EXPR)
	{
	if (!max_gt)
	val = truthvalue_true_node;
	if (min_gt)
	val = truthvalue_false_node;
	}
	else if (code == GE_EXPR)
	{
	if (!min_lt)
	val = truthvalue_true_node;
	if (max_lt)
	val = truthvalue_false_node;
	}

	/* If primop0 was sign-extended and unsigned comparison specd,
	we did a signed comparison above using the signed type bounds.
	But the comparison we output must be unsigned.

	Also, for inequalities, VAL is no good; but if the signed
	comparison had any fixed result, it follows that the
	unsigned comparison just tests the sign in reverse
	(positive values are LE, negative ones GE).
	So we can generate an unsigned comparison
	against an extreme value of the signed type. */

	if (unsignedp && !unsignedp0)
	{
	if (val != 0)
	switch (code)
	{
	case LT_EXPR:
	case GE_EXPR:
	primop1 = TYPE_MIN_VALUE (type);
	val = 0;
	break;

	case LE_EXPR:
	case GT_EXPR:
	primop1 = TYPE_MAX_VALUE (type);
	val = 0;
	break;

	default:
	break;
	}
	type = c_common_unsigned_type (type);
	}

	if (TREE_CODE (primop0) != INTEGER_CST)
	{
	if (val == truthvalue_false_node)
	warning (0, "comparison is always false due to limited range of data type");
	if (val == truthvalue_true_node)
	warning (0, "comparison is always true due to limited range of data type");
	}

	if (val != 0)
	{
	/* Don't forget to evaluate PRIMOP0 if it has side effects. */
	if (TREE_SIDE_EFFECTS (primop0))
	return build2 (COMPOUND_EXPR, TREE_TYPE (val), primop0, val);
	return val;
	}

	/* Value is not predetermined, but do the comparison
	in the type of the operand that is not constant.
	TYPE is already properly set. */
	}

	/* If either arg is decimal float and the other is float, find the
	proper common type to use for comparison. */
	else if (real1 && real2
	&& (DECIMAL_FLOAT_MODE_P (TYPE_MODE (TREE_TYPE (primop0)))
	\|\| DECIMAL_FLOAT_MODE_P (TYPE_MODE (TREE_TYPE (primop1)))))
	type = common_type (TREE_TYPE (primop0), TREE_TYPE (primop1));

	else if (real1 && real2
	&& (TYPE_PRECISION (TREE_TYPE (primop0))
	== TYPE_PRECISION (TREE_TYPE (primop1))))
	type = TREE_TYPE (primop0);

	/* If args' natural types are both narrower than nominal type
	and both extend in the same manner, compare them
	in the type of the wider arg.
	Otherwise must actually extend both to the nominal
	common type lest different ways of extending
	alter the result.
	(eg, (short)-1 == (unsigned short)-1 should be 0.) */

	else if (unsignedp0 == unsignedp1 && real1 == real2
	&& TYPE_PRECISION (TREE_TYPE (primop0)) < TYPE_PRECISION (*restype_ptr)
	&& TYPE_PRECISION (TREE_TYPE (primop1)) < TYPE_PRECISION (*restype_ptr))
	{
	type = common_type (TREE_TYPE (primop0), TREE_TYPE (primop1));
	type = c_common_signed_or_unsigned_type (unsignedp0
	\|\| TYPE_UNSIGNED (*restype_ptr),
	type);
	/* Make sure shorter operand is extended the right way
	to match the longer operand. */
	primop0
	= convert (c_common_signed_or_unsigned_type (unsignedp0,
	TREE_TYPE (primop0)),
	primop0);
	primop1
	= convert (c_common_signed_or_unsigned_type (unsignedp1,
	TREE_TYPE (primop1)),
	primop1);
	}
	else
	{
	/* Here we must do the comparison on the nominal type
	using the args exactly as we received them. */
	type = *restype_ptr;
	primop0 = op0;
	primop1 = op1;

	if (!real1 && !real2 && integer_zerop (primop1)
	&& TYPE_UNSIGNED (*restype_ptr))
	{
	tree value = 0;
	switch (code)
	{
	case GE_EXPR:
	/* All unsigned values are >= 0, so we warn if extra warnings
	are requested. However, if OP0 is a constant that is
	>= 0, the signedness of the comparison isn't an issue,
	so suppress the warning. */
	if (extra_warnings && !in_system_header
	&& !(TREE_CODE (primop0) == INTEGER_CST
	&& !TREE_OVERFLOW (convert (c_common_signed_type (type),
	primop0))))
	warning (0, "comparison of unsigned expression >= 0 is always true");
	value = truthvalue_true_node;
	break;

	case LT_EXPR:
	if (extra_warnings && !in_system_header
	&& !(TREE_CODE (primop0) == INTEGER_CST
	&& !TREE_OVERFLOW (convert (c_common_signed_type (type),
	primop0))))
	warning (0, "comparison of unsigned expression < 0 is always false");
	value = truthvalue_false_node;
	break;

	default:
	break;
	}

	if (value != 0)
	{
	/* Don't forget to evaluate PRIMOP0 if it has side effects. */
	if (TREE_SIDE_EFFECTS (primop0))
	return build2 (COMPOUND_EXPR, TREE_TYPE (value),
	primop0, value);
	return value;
	}
	}
	}

	*op0_ptr = convert (type, primop0);
	*op1_ptr = convert (type, primop1);

	*restype_ptr = truthvalue_type_node;

	return 0;
	}

	/* Return a tree for the sum or difference (RESULTCODE says which)
	of pointer PTROP and integer INTOP. */

	tree
	pointer_int_sum (enum tree_code resultcode, tree ptrop, tree intop)
	{
	tree size_exp, ret;

	/* The result is a pointer of the same type that is being added. */

	tree result_type = TREE_TYPE (ptrop);

	if (TREE_CODE (TREE_TYPE (result_type)) == VOID_TYPE)
	{
	if (pedantic \|\| warn_pointer_arith)
	pedwarn ("pointer of type %<void *%> used in arithmetic");
	size_exp = integer_one_node;
	}
	else if (TREE_CODE (TREE_TYPE (result_type)) == FUNCTION_TYPE)
	{
	if (pedantic \|\| warn_pointer_arith)
	pedwarn ("pointer to a function used in arithmetic");
	size_exp = integer_one_node;
	}
	else if (TREE_CODE (TREE_TYPE (result_type)) == METHOD_TYPE)
	{
	if (pedantic \|\| warn_pointer_arith)
	pedwarn ("pointer to member function used in arithmetic");
	size_exp = integer_one_node;
	}
	else
	size_exp = size_in_bytes (TREE_TYPE (result_type));

	/* We are manipulating pointer values, so we don't need to warn
	about relying on undefined signed overflow. We disable the
	warning here because we use integer types so fold won't know that
	they are really pointers. */
	fold_defer_overflow_warnings ();

	/* If what we are about to multiply by the size of the elements
	contains a constant term, apply distributive law
	and multiply that constant term separately.
	This helps produce common subexpressions. */

	if ((TREE_CODE (intop) == PLUS_EXPR \|\| TREE_CODE (intop) == MINUS_EXPR)
	&& !TREE_CONSTANT (intop)
	&& TREE_CONSTANT (TREE_OPERAND (intop, 1))
	&& TREE_CONSTANT (size_exp)
	/* If the constant comes from pointer subtraction,
	skip this optimization--it would cause an error. */
	&& TREE_CODE (TREE_TYPE (TREE_OPERAND (intop, 0))) == INTEGER_TYPE
	/* If the constant is unsigned, and smaller than the pointer size,
	then we must skip this optimization. This is because it could cause
	an overflow error if the constant is negative but INTOP is not. */
	&& (!TYPE_UNSIGNED (TREE_TYPE (intop))
	\|\| (TYPE_PRECISION (TREE_TYPE (intop))
	== TYPE_PRECISION (TREE_TYPE (ptrop)))))
	{
	enum tree_code subcode = resultcode;
	tree int_type = TREE_TYPE (intop);
	if (TREE_CODE (intop) == MINUS_EXPR)
	subcode = (subcode == PLUS_EXPR ? MINUS_EXPR : PLUS_EXPR);
	/* Convert both subexpression types to the type of intop,
	because weird cases involving pointer arithmetic
	can result in a sum or difference with different type args. */
	ptrop = build_binary_op (subcode, ptrop,
	convert (int_type, TREE_OPERAND (intop, 1)), 1);
	intop = convert (int_type, TREE_OPERAND (intop, 0));
	}

	/* Convert the integer argument to a type the same size as sizetype
	so the multiply won't overflow spuriously. */

	if (TYPE_PRECISION (TREE_TYPE (intop)) != TYPE_PRECISION (sizetype)
	\|\| TYPE_UNSIGNED (TREE_TYPE (intop)) != TYPE_UNSIGNED (sizetype))
	intop = convert (c_common_type_for_size (TYPE_PRECISION (sizetype),
	TYPE_UNSIGNED (sizetype)), intop);

	/* Replace the integer argument with a suitable product by the object size.
	Do this multiplication as signed, then convert to the appropriate
	pointer type (actually unsigned integral). */

	intop = convert (result_type,
	build_binary_op (MULT_EXPR, intop,
	convert (TREE_TYPE (intop), size_exp), 1));

	/* Create the sum or difference. */
	ret = fold_build2 (resultcode, result_type, ptrop, intop);

	fold_undefer_and_ignore_overflow_warnings ();

	return ret;
	}

	/* Prepare expr to be an argument of a TRUTH_NOT_EXPR,
	or for an `if' or `while' statement or ?..: exp. It should already
	have been validated to be of suitable type; otherwise, a bad
	diagnostic may result.

	This preparation consists of taking the ordinary
	representation of an expression expr and producing a valid tree
	boolean expression describing whether expr is nonzero. We could
	simply always do build_binary_op (NE_EXPR, expr, truthvalue_false_node, 1),
	but we optimize comparisons, &&, \|\|, and !.

	The resulting type should always be `truthvalue_type_node'. */

	tree
	c_common_truthvalue_conversion (tree expr)
	{
	switch (TREE_CODE (expr))
	{
	case EQ_EXPR: case NE_EXPR: case UNEQ_EXPR: case LTGT_EXPR:
	case LE_EXPR: case GE_EXPR: case LT_EXPR: case GT_EXPR:
	case UNLE_EXPR: case UNGE_EXPR: case UNLT_EXPR: case UNGT_EXPR:
	case ORDERED_EXPR: case UNORDERED_EXPR:
	if (TREE_TYPE (expr) == truthvalue_type_node)
	return expr;
	return build2 (TREE_CODE (expr), truthvalue_type_node,
	TREE_OPERAND (expr, 0), TREE_OPERAND (expr, 1));

	case TRUTH_ANDIF_EXPR:
	case TRUTH_ORIF_EXPR:
	case TRUTH_AND_EXPR:
	case TRUTH_OR_EXPR:
	case TRUTH_XOR_EXPR:
	if (TREE_TYPE (expr) == truthvalue_type_node)
	return expr;
	return build2 (TREE_CODE (expr), truthvalue_type_node,
	c_common_truthvalue_conversion (TREE_OPERAND (expr, 0)),
	c_common_truthvalue_conversion (TREE_OPERAND (expr, 1)));

	case TRUTH_NOT_EXPR:
	if (TREE_TYPE (expr) == truthvalue_type_node)
	return expr;
	return build1 (TREE_CODE (expr), truthvalue_type_node,
	c_common_truthvalue_conversion (TREE_OPERAND (expr, 0)));

	case ERROR_MARK:
	return expr;

	case INTEGER_CST:
	/* Avoid integer_zerop to ignore TREE_CONSTANT_OVERFLOW. */
	return (TREE_INT_CST_LOW (expr) != 0 \|\| TREE_INT_CST_HIGH (expr) != 0)
	? truthvalue_true_node
	: truthvalue_false_node;

	case REAL_CST:
	return real_compare (NE_EXPR, &TREE_REAL_CST (expr), &dconst0)
	? truthvalue_true_node
	: truthvalue_false_node;

	case FUNCTION_DECL:
	expr = build_unary_op (ADDR_EXPR, expr, 0);
	/* Fall through. */

	case ADDR_EXPR:
	{
	tree inner = TREE_OPERAND (expr, 0);
	if (DECL_P (inner)
	&& (TREE_CODE (inner) == PARM_DECL
	\|\| TREE_CODE (inner) == LABEL_DECL
	\|\| !DECL_WEAK (inner)))
	{
	/* Common Ada/Pascal programmer's mistake. We always warn
	about this since it is so bad. */
	warning (OPT_Waddress,
	"the address of %qD will always evaluate as %<true%>",
	inner);
	return truthvalue_true_node;
	}

	/* If we are taking the address of an external decl, it might be
	zero if it is weak, so we cannot optimize. */
	if (DECL_P (inner)
	&& DECL_EXTERNAL (inner))
	break;

	if (TREE_SIDE_EFFECTS (inner))
	return build2 (COMPOUND_EXPR, truthvalue_type_node,
	inner, truthvalue_true_node);
	else
	return truthvalue_true_node;
	}

	case COMPLEX_EXPR:
	return build_binary_op ((TREE_SIDE_EFFECTS (TREE_OPERAND (expr, 1))
	? TRUTH_OR_EXPR : TRUTH_ORIF_EXPR),
	c_common_truthvalue_conversion (TREE_OPERAND (expr, 0)),
	c_common_truthvalue_conversion (TREE_OPERAND (expr, 1)),
	0);

	case NEGATE_EXPR:
	case ABS_EXPR:
	case FLOAT_EXPR:
	/* These don't change whether an object is nonzero or zero. */
	return c_common_truthvalue_conversion (TREE_OPERAND (expr, 0));

	case LROTATE_EXPR:
	case RROTATE_EXPR:
	/* These don't change whether an object is zero or nonzero, but
	we can't ignore them if their second arg has side-effects. */
	if (TREE_SIDE_EFFECTS (TREE_OPERAND (expr, 1)))
	return build2 (COMPOUND_EXPR, truthvalue_type_node,
	TREE_OPERAND (expr, 1),
	c_common_truthvalue_conversion (TREE_OPERAND (expr, 0)));
	else
	return c_common_truthvalue_conversion (TREE_OPERAND (expr, 0));

	case COND_EXPR:
	/* Distribute the conversion into the arms of a COND_EXPR. */
	return fold_build3 (COND_EXPR, truthvalue_type_node,
	TREE_OPERAND (expr, 0),
	c_common_truthvalue_conversion (TREE_OPERAND (expr, 1)),
	c_common_truthvalue_conversion (TREE_OPERAND (expr, 2)));

	case CONVERT_EXPR:
	case NOP_EXPR:
	/* Don't cancel the effect of a CONVERT_EXPR from a REFERENCE_TYPE,
	since that affects how `default_conversion' will behave. */
	if (TREE_CODE (TREE_TYPE (expr)) == REFERENCE_TYPE
	\|\| TREE_CODE (TREE_TYPE (TREE_OPERAND (expr, 0))) == REFERENCE_TYPE)
	break;
	/* If this is widening the argument, we can ignore it. */
	if (TYPE_PRECISION (TREE_TYPE (expr))
	>= TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (expr, 0))))
	return c_common_truthvalue_conversion (TREE_OPERAND (expr, 0));
	break;

	case MODIFY_EXPR:
	if (!TREE_NO_WARNING (expr)
	&& warn_parentheses)
	{
	warning (OPT_Wparentheses,
	"suggest parentheses around assignment used as truth value");
	TREE_NO_WARNING (expr) = 1;
	}
	break;

	default:
	break;
	}

	if (TREE_CODE (TREE_TYPE (expr)) == COMPLEX_TYPE)
	{
	tree t = save_expr (expr);
	return (build_binary_op
	((TREE_SIDE_EFFECTS (expr)
	? TRUTH_OR_EXPR : TRUTH_ORIF_EXPR),
	c_common_truthvalue_conversion (build_unary_op (REALPART_EXPR, t, 0)),
	c_common_truthvalue_conversion (build_unary_op (IMAGPART_EXPR, t, 0)),
	0));
	}

	return build_binary_op (NE_EXPR, expr, integer_zero_node, 1);
	}

	static void def_builtin_1 (enum built_in_function fncode,
	const char *name,
	enum built_in_class fnclass,
	tree fntype, tree libtype,
	bool both_p, bool fallback_p, bool nonansi_p,
	tree fnattrs, bool implicit_p);

	/* Make a variant type in the proper way for C/C++, propagating qualifiers
	down to the element type of an array. */

	tree
	c_build_qualified_type (tree type, int type_quals)
	{
	if (type == error_mark_node)
	return type;

	if (TREE_CODE (type) == ARRAY_TYPE)
	{
	tree t;
	tree element_type = c_build_qualified_type (TREE_TYPE (type),
	type_quals);

	/* See if we already have an identically qualified type. */
	for (t = TYPE_MAIN_VARIANT (type); t; t = TYPE_NEXT_VARIANT (t))
	{
	if (TYPE_QUALS (strip_array_types (t)) == type_quals
	&& TYPE_NAME (t) == TYPE_NAME (type)
	&& TYPE_CONTEXT (t) == TYPE_CONTEXT (type)
	&& attribute_list_equal (TYPE_ATTRIBUTES (t),
	TYPE_ATTRIBUTES (type)))
	break;
	}
	if (!t)
	{
	t = build_variant_type_copy (type);
	TREE_TYPE (t) = element_type;
	}
	return t;
	}

	/* A restrict-qualified pointer type must be a pointer to object or
	incomplete type. Note that the use of POINTER_TYPE_P also allows
	REFERENCE_TYPEs, which is appropriate for C++. */
	if ((type_quals & TYPE_QUAL_RESTRICT)
	&& (!POINTER_TYPE_P (type)
	\|\| !C_TYPE_OBJECT_OR_INCOMPLETE_P (TREE_TYPE (type))))
	{
	error ("invalid use of %<restrict%>");
	type_quals &= ~TYPE_QUAL_RESTRICT;
	}

	return build_qualified_type (type, type_quals);
	}

	/* Apply the TYPE_QUALS to the new DECL. */

	void
	c_apply_type_quals_to_decl (int type_quals, tree decl)
	{
	tree type = TREE_TYPE (decl);

	if (type == error_mark_node)
	return;

	if (((type_quals & TYPE_QUAL_CONST)
	\|\| (type && TREE_CODE (type) == REFERENCE_TYPE))
	/* An object declared 'const' is only readonly after it is
	initialized. We don't have any way of expressing this currently,
	so we need to be conservative and unset TREE_READONLY for types
	with constructors. Otherwise aliasing code will ignore stores in
	an inline constructor. */
	&& !(type && TYPE_NEEDS_CONSTRUCTING (type)))
	TREE_READONLY (decl) = 1;
	if (type_quals & TYPE_QUAL_VOLATILE)
	{
	TREE_SIDE_EFFECTS (decl) = 1;
	TREE_THIS_VOLATILE (decl) = 1;
	}
	if (type_quals & TYPE_QUAL_RESTRICT)
	{
	while (type && TREE_CODE (type) == ARRAY_TYPE)
	/* Allow 'restrict' on arrays of pointers.
	FIXME currently we just ignore it. */
	type = TREE_TYPE (type);
	if (!type
	\|\| !POINTER_TYPE_P (type)
	\|\| !C_TYPE_OBJECT_OR_INCOMPLETE_P (TREE_TYPE (type)))
	error ("invalid use of %<restrict%>");
	else if (flag_strict_aliasing && type == TREE_TYPE (decl))
	/* Indicate we need to make a unique alias set for this pointer.
	We can't do it here because it might be pointing to an
	incomplete type. */
	DECL_POINTER_ALIAS_SET (decl) = -2;
	}
	}

	/* Hash function for the problem of multiple type definitions in
	different files. This must hash all types that will compare
	equal via comptypes to the same value. In practice it hashes
	on some of the simple stuff and leaves the details to comptypes. */

	static hashval_t
	c_type_hash (const void *p)
	{
	int i = 0;
	int shift, size;
	tree t = (tree) p;
	tree t2;
	switch (TREE_CODE (t))
	{
	/* For pointers, hash on pointee type plus some swizzling. */
	case POINTER_TYPE:
	return c_type_hash (TREE_TYPE (t)) ^ 0x3003003;
	/* Hash on number of elements and total size. */
	case ENUMERAL_TYPE:
	shift = 3;
	t2 = TYPE_VALUES (t);
	break;
	case RECORD_TYPE:
	shift = 0;
	t2 = TYPE_FIELDS (t);
	break;
	case QUAL_UNION_TYPE:
	shift = 1;
	t2 = TYPE_FIELDS (t);
	break;
	case UNION_TYPE:
	shift = 2;
	t2 = TYPE_FIELDS (t);
	break;
	default:
	gcc_unreachable ();
	}
	for (; t2; t2 = TREE_CHAIN (t2))
	i++;
	size = TREE_INT_CST_LOW (TYPE_SIZE (t));
	return ((size << 24) \| (i << shift));
	}

	static GTY((param_is (union tree_node))) htab_t type_hash_table;

	/* Return the typed-based alias set for T, which may be an expression
	or a type. Return -1 if we don't do anything special. */

	HOST_WIDE_INT
	c_common_get_alias_set (tree t)
	{
	tree u;
	PTR *slot;

	/* Permit type-punning when accessing a union, provided the access
	is directly through the union. For example, this code does not
	permit taking the address of a union member and then storing
	through it. Even the type-punning allowed here is a GCC
	extension, albeit a common and useful one; the C standard says
	that such accesses have implementation-defined behavior. */
	for (u = t;
	TREE_CODE (u) == COMPONENT_REF \|\| TREE_CODE (u) == ARRAY_REF;
	u = TREE_OPERAND (u, 0))
	if (TREE_CODE (u) == COMPONENT_REF
	&& TREE_CODE (TREE_TYPE (TREE_OPERAND (u, 0))) == UNION_TYPE)
	return 0;

	/* That's all the expressions we handle specially. */
	if (!TYPE_P (t))
	return -1;

	/* The C standard guarantees that any object may be accessed via an
	lvalue that has character type. */
	if (t == char_type_node
	\|\| t == signed_char_type_node
	\|\| t == unsigned_char_type_node)
	return 0;

	/* If it has the may_alias attribute, it can alias anything. */
	if (lookup_attribute ("may_alias", TYPE_ATTRIBUTES (t)))
	return 0;

	/* The C standard specifically allows aliasing between signed and
	unsigned variants of the same type. We treat the signed
	variant as canonical. */
	if (TREE_CODE (t) == INTEGER_TYPE && TYPE_UNSIGNED (t))
	{
	tree t1 = c_common_signed_type (t);

	/* t1 == t can happen for boolean nodes which are always unsigned. */
	if (t1 != t)
	return get_alias_set (t1);
	}
	else if (POINTER_TYPE_P (t))
	{
	tree t1;

	/* Unfortunately, there is no canonical form of a pointer type.
	In particular, if we have `typedef int I', then `int *', and
	`I *' are different types. So, we have to pick a canonical
	representative. We do this below.

	Technically, this approach is actually more conservative that
	it needs to be. In particular, `const int ' and `int '
	should be in different alias sets, according to the C and C++
	standard, since their types are not the same, and so,
	technically, an `int ' and `const int ' cannot point at
	the same thing.

	But, the standard is wrong. In particular, this code is
	legal C++:

	int *ip;
	int **ipp = &ip;
	const int* const* cipp = ipp;

	And, it doesn't make sense for that to be legal unless you
	can dereference IPP and CIPP. So, we ignore cv-qualifiers on
	the pointed-to types. This issue has been reported to the
	C++ committee. */
	t1 = build_type_no_quals (t);
	if (t1 != t)
	return get_alias_set (t1);
	}

	/* Handle the case of multiple type nodes referring to "the same" type,
	which occurs with IMA. These share an alias set. FIXME: Currently only
	C90 is handled. (In C99 type compatibility is not transitive, which
	complicates things mightily. The alias set splay trees can theoretically
	represent this, but insertion is tricky when you consider all the
	different orders things might arrive in.) */

	if (c_language != clk_c \|\| flag_isoc99)
	return -1;

	/* Save time if there's only one input file. */
	if (num_in_fnames == 1)
	return -1;

	/* Pointers need special handling if they point to any type that
	needs special handling (below). */
	if (TREE_CODE (t) == POINTER_TYPE)
	{
	tree t2;
	/* Find bottom type under any nested POINTERs. */
	for (t2 = TREE_TYPE (t);
	TREE_CODE (t2) == POINTER_TYPE;
	t2 = TREE_TYPE (t2))
	;
	if (TREE_CODE (t2) != RECORD_TYPE
	&& TREE_CODE (t2) != ENUMERAL_TYPE
	&& TREE_CODE (t2) != QUAL_UNION_TYPE
	&& TREE_CODE (t2) != UNION_TYPE)
	return -1;
	if (TYPE_SIZE (t2) == 0)
	return -1;
	}
	/* These are the only cases that need special handling. */
	if (TREE_CODE (t) != RECORD_TYPE
	&& TREE_CODE (t) != ENUMERAL_TYPE
	&& TREE_CODE (t) != QUAL_UNION_TYPE
	&& TREE_CODE (t) != UNION_TYPE
	&& TREE_CODE (t) != POINTER_TYPE)
	return -1;
	/* Undefined? */
	if (TYPE_SIZE (t) == 0)
	return -1;

	/* Look up t in hash table. Only one of the compatible types within each
	alias set is recorded in the table. */
	if (!type_hash_table)
	type_hash_table = htab_create_ggc (1021, c_type_hash,
	(htab_eq) lang_hooks.types_compatible_p,
	NULL);
	slot = htab_find_slot (type_hash_table, t, INSERT);
	if (*slot != NULL)
	{
	TYPE_ALIAS_SET (t) = TYPE_ALIAS_SET ((tree)*slot);
	return TYPE_ALIAS_SET ((tree)*slot);
	}
	else
	/* Our caller will assign and record (in t) a new alias set; all we need
	to do is remember t in the hash table. */
	*slot = t;

	return -1;
	}

	/* Compute the value of 'sizeof (TYPE)' or '__alignof__ (TYPE)', where the
	second parameter indicates which OPERATOR is being applied. The COMPLAIN
	flag controls whether we should diagnose possibly ill-formed
	constructs or not. */

	tree
	c_sizeof_or_alignof_type (tree type, bool is_sizeof, int complain)
	{
	const char *op_name;
	tree value = NULL;
	enum tree_code type_code = TREE_CODE (type);

	op_name = is_sizeof ? "sizeof" : "__alignof__";

	if (type_code == FUNCTION_TYPE)
	{
	if (is_sizeof)
	{
	if (complain && (pedantic \|\| warn_pointer_arith))
	pedwarn ("invalid application of %<sizeof%> to a function type");
	value = size_one_node;
	}
	else
	value = size_int (FUNCTION_BOUNDARY / BITS_PER_UNIT);
	}
	else if (type_code == VOID_TYPE \|\| type_code == ERROR_MARK)
	{
	if (type_code == VOID_TYPE
	&& complain && (pedantic \|\| warn_pointer_arith))
	pedwarn ("invalid application of %qs to a void type", op_name);
	value = size_one_node;
	}
	else if (!COMPLETE_TYPE_P (type))
	{
	if (complain)
	error ("invalid application of %qs to incomplete type %qT ",
	op_name, type);
	value = size_zero_node;
	}
	else
	{
	if (is_sizeof)
	/* Convert in case a char is more than one unit. */
	value = size_binop (CEIL_DIV_EXPR, TYPE_SIZE_UNIT (type),
	size_int (TYPE_PRECISION (char_type_node)
	/ BITS_PER_UNIT));
	else
	value = size_int (TYPE_ALIGN_UNIT (type));
	}

	/* VALUE will have an integer type with TYPE_IS_SIZETYPE set.
	TYPE_IS_SIZETYPE means that certain things (like overflow) will
	never happen. However, this node should really have type
	`size_t', which is just a typedef for an ordinary integer type. */
	value = fold_convert (size_type_node, value);
	gcc_assert (!TYPE_IS_SIZETYPE (TREE_TYPE (value)));

	return value;
	}

	/* Implement the __alignof keyword: Return the minimum required
	alignment of EXPR, measured in bytes. For VAR_DECLs,
	FUNCTION_DECLs and FIELD_DECLs return DECL_ALIGN (which can be set
	from an "aligned" __attribute__ specification). */

	tree
	c_alignof_expr (tree expr)
	{
	tree t;

	if (VAR_OR_FUNCTION_DECL_P (expr))
	t = size_int (DECL_ALIGN_UNIT (expr));

	else if (TREE_CODE (expr) == COMPONENT_REF
	&& DECL_C_BIT_FIELD (TREE_OPERAND (expr, 1)))
	{
	error ("%<__alignof%> applied to a bit-field");
	t = size_one_node;
	}
	else if (TREE_CODE (expr) == COMPONENT_REF
	&& TREE_CODE (TREE_OPERAND (expr, 1)) == FIELD_DECL)
	t = size_int (DECL_ALIGN_UNIT (TREE_OPERAND (expr, 1)));

	else if (TREE_CODE (expr) == INDIRECT_REF)
	{
	tree t = TREE_OPERAND (expr, 0);
	tree best = t;
	int bestalign = TYPE_ALIGN (TREE_TYPE (TREE_TYPE (t)));

	while ((TREE_CODE (t) == NOP_EXPR \|\| TREE_CODE (t) == CONVERT_EXPR)
	&& TREE_CODE (TREE_TYPE (TREE_OPERAND (t, 0))) == POINTER_TYPE)
	{
	int thisalign;

	t = TREE_OPERAND (t, 0);
	thisalign = TYPE_ALIGN (TREE_TYPE (TREE_TYPE (t)));
	if (thisalign > bestalign)
	best = t, bestalign = thisalign;
	}
	return c_alignof (TREE_TYPE (TREE_TYPE (best)));
	}
	else
	return c_alignof (TREE_TYPE (expr));

	return fold_convert (size_type_node, t);
	}

	/* Handle C and C++ default attributes. */

	enum built_in_attribute
	{
	#define DEF_ATTR_NULL_TREE(ENUM) ENUM,
	#define DEF_ATTR_INT(ENUM, VALUE) ENUM,
	#define DEF_ATTR_IDENT(ENUM, STRING) ENUM,
	#define DEF_ATTR_TREE_LIST(ENUM, PURPOSE, VALUE, CHAIN) ENUM,
	#include "builtin-attrs.def"
	#undef DEF_ATTR_NULL_TREE
	#undef DEF_ATTR_INT
	#undef DEF_ATTR_IDENT
	#undef DEF_ATTR_TREE_LIST
	ATTR_LAST
	};

	static GTY(()) tree built_in_attributes[(int) ATTR_LAST];

	static void c_init_attributes (void);

	enum c_builtin_type
	{
	#define DEF_PRIMITIVE_TYPE(NAME, VALUE) NAME,
	#define DEF_FUNCTION_TYPE_0(NAME, RETURN) NAME,
	#define DEF_FUNCTION_TYPE_1(NAME, RETURN, ARG1) NAME,
	#define DEF_FUNCTION_TYPE_2(NAME, RETURN, ARG1, ARG2) NAME,
	#define DEF_FUNCTION_TYPE_3(NAME, RETURN, ARG1, ARG2, ARG3) NAME,
	#define DEF_FUNCTION_TYPE_4(NAME, RETURN, ARG1, ARG2, ARG3, ARG4) NAME,
	#define DEF_FUNCTION_TYPE_5(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5) NAME,
	#define DEF_FUNCTION_TYPE_6(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6) NAME,
	#define DEF_FUNCTION_TYPE_7(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6, ARG7) NAME,
	#define DEF_FUNCTION_TYPE_VAR_0(NAME, RETURN) NAME,
	#define DEF_FUNCTION_TYPE_VAR_1(NAME, RETURN, ARG1) NAME,
	#define DEF_FUNCTION_TYPE_VAR_2(NAME, RETURN, ARG1, ARG2) NAME,
	#define DEF_FUNCTION_TYPE_VAR_3(NAME, RETURN, ARG1, ARG2, ARG3) NAME,
	#define DEF_FUNCTION_TYPE_VAR_4(NAME, RETURN, ARG1, ARG2, ARG3, ARG4) NAME,
	#define DEF_FUNCTION_TYPE_VAR_5(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG6) \
	NAME,
	#define DEF_POINTER_TYPE(NAME, TYPE) NAME,
	#include "builtin-types.def"
	#undef DEF_PRIMITIVE_TYPE
	#undef DEF_FUNCTION_TYPE_0
	#undef DEF_FUNCTION_TYPE_1
	#undef DEF_FUNCTION_TYPE_2
	#undef DEF_FUNCTION_TYPE_3
	#undef DEF_FUNCTION_TYPE_4
	#undef DEF_FUNCTION_TYPE_5
	#undef DEF_FUNCTION_TYPE_6
	#undef DEF_FUNCTION_TYPE_7
	#undef DEF_FUNCTION_TYPE_VAR_0
	#undef DEF_FUNCTION_TYPE_VAR_1
	#undef DEF_FUNCTION_TYPE_VAR_2
	#undef DEF_FUNCTION_TYPE_VAR_3
	#undef DEF_FUNCTION_TYPE_VAR_4
	#undef DEF_FUNCTION_TYPE_VAR_5
	#undef DEF_POINTER_TYPE
	BT_LAST
	};

	typedef enum c_builtin_type builtin_type;

	/* A temporary array for c_common_nodes_and_builtins. Used in
	communication with def_fn_type. */
	static tree builtin_types[(int) BT_LAST + 1];

	/* A helper function for c_common_nodes_and_builtins. Build function type
	for DEF with return type RET and N arguments. If VAR is true, then the
	function should be variadic after those N arguments.

	Takes special care not to ICE if any of the types involved are
	error_mark_node, which indicates that said type is not in fact available
	(see builtin_type_for_size). In which case the function type as a whole
	should be error_mark_node. */

	static void
	def_fn_type (builtin_type def, builtin_type ret, bool var, int n, ...)
	{
	tree args = NULL, t;
	va_list list;
	int i;

	va_start (list, n);
	for (i = 0; i < n; ++i)
	{
	builtin_type a = va_arg (list, builtin_type);
	t = builtin_types[a];
	if (t == error_mark_node)
	goto egress;
	args = tree_cons (NULL_TREE, t, args);
	}
	va_end (list);

	args = nreverse (args);
	if (!var)
	args = chainon (args, void_list_node);

	t = builtin_types[ret];
	if (t == error_mark_node)
	goto egress;
	t = build_function_type (t, args);

	egress:
	builtin_types[def] = t;
	}

	/* Build builtin functions common to both C and C++ language
	frontends. */

	static void
	c_define_builtins (tree va_list_ref_type_node, tree va_list_arg_type_node)
	{
	#define DEF_PRIMITIVE_TYPE(ENUM, VALUE) \
	builtin_types[ENUM] = VALUE;
	#define DEF_FUNCTION_TYPE_0(ENUM, RETURN) \
	def_fn_type (ENUM, RETURN, 0, 0);
	#define DEF_FUNCTION_TYPE_1(ENUM, RETURN, ARG1) \
	def_fn_type (ENUM, RETURN, 0, 1, ARG1);
	#define DEF_FUNCTION_TYPE_2(ENUM, RETURN, ARG1, ARG2) \
	def_fn_type (ENUM, RETURN, 0, 2, ARG1, ARG2);
	#define DEF_FUNCTION_TYPE_3(ENUM, RETURN, ARG1, ARG2, ARG3) \
	def_fn_type (ENUM, RETURN, 0, 3, ARG1, ARG2, ARG3);
	#define DEF_FUNCTION_TYPE_4(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4) \
	def_fn_type (ENUM, RETURN, 0, 4, ARG1, ARG2, ARG3, ARG4);
	#define DEF_FUNCTION_TYPE_5(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5) \
	def_fn_type (ENUM, RETURN, 0, 5, ARG1, ARG2, ARG3, ARG4, ARG5);
	#define DEF_FUNCTION_TYPE_6(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
	ARG6) \
	def_fn_type (ENUM, RETURN, 0, 6, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6);
	#define DEF_FUNCTION_TYPE_7(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
	ARG6, ARG7) \
	def_fn_type (ENUM, RETURN, 0, 7, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6, ARG7);
	#define DEF_FUNCTION_TYPE_VAR_0(ENUM, RETURN) \
	def_fn_type (ENUM, RETURN, 1, 0);
	#define DEF_FUNCTION_TYPE_VAR_1(ENUM, RETURN, ARG1) \
	def_fn_type (ENUM, RETURN, 1, 1, ARG1);
	#define DEF_FUNCTION_TYPE_VAR_2(ENUM, RETURN, ARG1, ARG2) \
	def_fn_type (ENUM, RETURN, 1, 2, ARG1, ARG2);
	#define DEF_FUNCTION_TYPE_VAR_3(ENUM, RETURN, ARG1, ARG2, ARG3) \
	def_fn_type (ENUM, RETURN, 1, 3, ARG1, ARG2, ARG3);
	#define DEF_FUNCTION_TYPE_VAR_4(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4) \
	def_fn_type (ENUM, RETURN, 1, 4, ARG1, ARG2, ARG3, ARG4);
	#define DEF_FUNCTION_TYPE_VAR_5(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5) \
	def_fn_type (ENUM, RETURN, 1, 5, ARG1, ARG2, ARG3, ARG4, ARG5);
	#define DEF_POINTER_TYPE(ENUM, TYPE) \
	builtin_types[(int) ENUM] = build_pointer_type (builtin_types[(int) TYPE]);

	#include "builtin-types.def"

	#undef DEF_PRIMITIVE_TYPE
	#undef DEF_FUNCTION_TYPE_1
	#undef DEF_FUNCTION_TYPE_2
	#undef DEF_FUNCTION_TYPE_3
	#undef DEF_FUNCTION_TYPE_4
	#undef DEF_FUNCTION_TYPE_5
	#undef DEF_FUNCTION_TYPE_6
	#undef DEF_FUNCTION_TYPE_VAR_0
	#undef DEF_FUNCTION_TYPE_VAR_1
	#undef DEF_FUNCTION_TYPE_VAR_2
	#undef DEF_FUNCTION_TYPE_VAR_3
	#undef DEF_FUNCTION_TYPE_VAR_4
	#undef DEF_FUNCTION_TYPE_VAR_5
	#undef DEF_POINTER_TYPE
	builtin_types[(int) BT_LAST] = NULL_TREE;

	c_init_attributes ();

	#define DEF_BUILTIN(ENUM, NAME, CLASS, TYPE, LIBTYPE, BOTH_P, FALLBACK_P, \
	NONANSI_P, ATTRS, IMPLICIT, COND) \
	if (NAME && COND) \
	def_builtin_1 (ENUM, NAME, CLASS, \
	builtin_types[(int) TYPE], \
	builtin_types[(int) LIBTYPE], \
	BOTH_P, FALLBACK_P, NONANSI_P, \
	built_in_attributes[(int) ATTRS], IMPLICIT);
	#include "builtins.def"
	#undef DEF_BUILTIN

	build_common_builtin_nodes ();

	targetm.init_builtins ();
	if (flag_mudflap)
	mudflap_init ();
	}

	/* Build tree nodes and builtin functions common to both C and C++ language
	frontends. */

	void
	c_common_nodes_and_builtins (void)
	{
	int wchar_type_size;
	tree array_domain_type;
	tree va_list_ref_type_node;
	tree va_list_arg_type_node;

	/* Define `int' and `char' first so that dbx will output them first. */
	record_builtin_type (RID_INT, NULL, integer_type_node);
	record_builtin_type (RID_CHAR, "char", char_type_node);

	/* `signed' is the same as `int'. FIXME: the declarations of "signed",
	"unsigned long", "long long unsigned" and "unsigned short" were in C++
	but not C. Are the conditionals here needed? */
	if (c_dialect_cxx ())
	record_builtin_type (RID_SIGNED, NULL, integer_type_node);
	record_builtin_type (RID_LONG, "long int", long_integer_type_node);
	record_builtin_type (RID_UNSIGNED, "unsigned int", unsigned_type_node);
	record_builtin_type (RID_MAX, "long unsigned int",
	long_unsigned_type_node);
	if (c_dialect_cxx ())
	record_builtin_type (RID_MAX, "unsigned long", long_unsigned_type_node);
	record_builtin_type (RID_MAX, "long long int",
	long_long_integer_type_node);
	record_builtin_type (RID_MAX, "long long unsigned int",
	long_long_unsigned_type_node);
	if (c_dialect_cxx ())
	record_builtin_type (RID_MAX, "long long unsigned",
	long_long_unsigned_type_node);
	record_builtin_type (RID_SHORT, "short int", short_integer_type_node);
	record_builtin_type (RID_MAX, "short unsigned int",
	short_unsigned_type_node);
	if (c_dialect_cxx ())
	record_builtin_type (RID_MAX, "unsigned short",
	short_unsigned_type_node);

	/* Define both `signed char' and `unsigned char'. */
	record_builtin_type (RID_MAX, "signed char", signed_char_type_node);
	record_builtin_type (RID_MAX, "unsigned char", unsigned_char_type_node);

	/* These are types that c_common_type_for_size and
	c_common_type_for_mode use. */
	lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
	intQI_type_node));
	lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
	intHI_type_node));
	lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
	intSI_type_node));
	lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
	intDI_type_node));
	#if HOST_BITS_PER_WIDE_INT >= 64
	if (targetm.scalar_mode_supported_p (TImode))
	lang_hooks.decls.pushdecl (build_decl (TYPE_DECL,
	get_identifier ("__int128_t"),
	intTI_type_node));
	#endif
	lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
	unsigned_intQI_type_node));
	lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
	unsigned_intHI_type_node));
	lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
	unsigned_intSI_type_node));
	lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
	unsigned_intDI_type_node));
	#if HOST_BITS_PER_WIDE_INT >= 64
	if (targetm.scalar_mode_supported_p (TImode))
	lang_hooks.decls.pushdecl (build_decl (TYPE_DECL,
	get_identifier ("__uint128_t"),
	unsigned_intTI_type_node));
	#endif

	/* Create the widest literal types. */
	widest_integer_literal_type_node
	= make_signed_type (HOST_BITS_PER_WIDE_INT * 2);
	lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
	widest_integer_literal_type_node));

	widest_unsigned_literal_type_node
	= make_unsigned_type (HOST_BITS_PER_WIDE_INT * 2);
	lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
	widest_unsigned_literal_type_node));

	/* `unsigned long' is the standard type for sizeof.
	Note that stddef.h uses `unsigned long',
	and this must agree, even if long and int are the same size. */
	size_type_node =
	TREE_TYPE (identifier_global_value (get_identifier (SIZE_TYPE)));
	signed_size_type_node = c_common_signed_type (size_type_node);
	set_sizetype (size_type_node);

	pid_type_node =
	TREE_TYPE (identifier_global_value (get_identifier (PID_TYPE)));

	build_common_tree_nodes_2 (flag_short_double);

	record_builtin_type (RID_FLOAT, NULL, float_type_node);
	record_builtin_type (RID_DOUBLE, NULL, double_type_node);
	record_builtin_type (RID_MAX, "long double", long_double_type_node);

	/* Only supported decimal floating point extension if the target
	actually supports underlying modes. */
	if (targetm.scalar_mode_supported_p (SDmode)
	&& targetm.scalar_mode_supported_p (DDmode)
	&& targetm.scalar_mode_supported_p (TDmode))
	{
	record_builtin_type (RID_DFLOAT32, NULL, dfloat32_type_node);
	record_builtin_type (RID_DFLOAT64, NULL, dfloat64_type_node);
	record_builtin_type (RID_DFLOAT128, NULL, dfloat128_type_node);
	}

	lang_hooks.decls.pushdecl (build_decl (TYPE_DECL,
	get_identifier ("complex int"),
	complex_integer_type_node));
	lang_hooks.decls.pushdecl (build_decl (TYPE_DECL,
	get_identifier ("complex float"),
	complex_float_type_node));
	lang_hooks.decls.pushdecl (build_decl (TYPE_DECL,
	get_identifier ("complex double"),
	complex_double_type_node));
	lang_hooks.decls.pushdecl
	(build_decl (TYPE_DECL, get_identifier ("complex long double"),
	complex_long_double_type_node));

	if (c_dialect_cxx ())
	/* For C++, make fileptr_type_node a distinct void * type until
	FILE type is defined. */
	fileptr_type_node = build_variant_type_copy (ptr_type_node);

	record_builtin_type (RID_VOID, NULL, void_type_node);

	/* This node must not be shared. */
	void_zero_node = make_node (INTEGER_CST);
	TREE_TYPE (void_zero_node) = void_type_node;

	void_list_node = build_void_list_node ();

	/* Make a type to be the domain of a few array types
	whose domains don't really matter.
	200 is small enough that it always fits in size_t
	and large enough that it can hold most function names for the
	initializations of __FUNCTION__ and __PRETTY_FUNCTION__. */
	array_domain_type = build_index_type (size_int (200));

	/* Make a type for arrays of characters.
	With luck nothing will ever really depend on the length of this
	array type. */
	char_array_type_node
	= build_array_type (char_type_node, array_domain_type);

	/* Likewise for arrays of ints. */
	int_array_type_node
	= build_array_type (integer_type_node, array_domain_type);

	string_type_node = build_pointer_type (char_type_node);
	const_string_type_node
	= build_pointer_type (build_qualified_type
	(char_type_node, TYPE_QUAL_CONST));

	/* This is special for C++ so functions can be overloaded. */
	wchar_type_node = get_identifier (MODIFIED_WCHAR_TYPE);
	wchar_type_node = TREE_TYPE (identifier_global_value (wchar_type_node));
	wchar_type_size = TYPE_PRECISION (wchar_type_node);
	if (c_dialect_cxx ())
	{
	if (TYPE_UNSIGNED (wchar_type_node))
	wchar_type_node = make_unsigned_type (wchar_type_size);
	else
	wchar_type_node = make_signed_type (wchar_type_size);
	record_builtin_type (RID_WCHAR, "wchar_t", wchar_type_node);
	}
	else
	{
	signed_wchar_type_node = c_common_signed_type (wchar_type_node);
	unsigned_wchar_type_node = c_common_unsigned_type (wchar_type_node);
	}

	/* This is for wide string constants. */
	wchar_array_type_node
	= build_array_type (wchar_type_node, array_domain_type);

	wint_type_node =
	TREE_TYPE (identifier_global_value (get_identifier (WINT_TYPE)));

	intmax_type_node =
	TREE_TYPE (identifier_global_value (get_identifier (INTMAX_TYPE)));
	uintmax_type_node =
	TREE_TYPE (identifier_global_value (get_identifier (UINTMAX_TYPE)));

	default_function_type = build_function_type (integer_type_node, NULL_TREE);
	ptrdiff_type_node
	= TREE_TYPE (identifier_global_value (get_identifier (PTRDIFF_TYPE)));
	unsigned_ptrdiff_type_node = c_common_unsigned_type (ptrdiff_type_node);

	lang_hooks.decls.pushdecl
	(build_decl (TYPE_DECL, get_identifier ("__builtin_va_list"),
	va_list_type_node));

	if (TREE_CODE (va_list_type_node) == ARRAY_TYPE)
	{
	va_list_arg_type_node = va_list_ref_type_node =
	build_pointer_type (TREE_TYPE (va_list_type_node));
	}
	else
	{
	va_list_arg_type_node = va_list_type_node;
	va_list_ref_type_node = build_reference_type (va_list_type_node);
	}

	if (!flag_preprocess_only)
	c_define_builtins (va_list_ref_type_node, va_list_arg_type_node);

	main_identifier_node = get_identifier ("main");

	/* Create the built-in __null node. It is important that this is
	not shared. */
	null_node = make_node (INTEGER_CST);
	TREE_TYPE (null_node) = c_common_type_for_size (POINTER_SIZE, 0);

	/* Since builtin_types isn't gc'ed, don't export these nodes. */
	memset (builtin_types, 0, sizeof (builtin_types));
	}

	/* Look up the function in built_in_decls that corresponds to DECL
	and set ASMSPEC as its user assembler name. DECL must be a
	function decl that declares a builtin. */

	void
	set_builtin_user_assembler_name (tree decl, const char *asmspec)
	{
	tree builtin;
	gcc_assert (TREE_CODE (decl) == FUNCTION_DECL
	&& DECL_BUILT_IN_CLASS (decl) == BUILT_IN_NORMAL
	&& asmspec != 0);

	builtin = built_in_decls [DECL_FUNCTION_CODE (decl)];
	set_user_assembler_name (builtin, asmspec);
	if (DECL_FUNCTION_CODE (decl) == BUILT_IN_MEMCPY)
	init_block_move_fn (asmspec);
	else if (DECL_FUNCTION_CODE (decl) == BUILT_IN_MEMSET)
	init_block_clear_fn (asmspec);
	}

	/* The number of named compound-literals generated thus far. */
	static GTY(()) int compound_literal_number;

	/* Set DECL_NAME for DECL, a VAR_DECL for a compound-literal. */

	void
	set_compound_literal_name (tree decl)
	{
	char *name;
	ASM_FORMAT_PRIVATE_NAME (name, "__compound_literal",
	compound_literal_number);
	compound_literal_number++;
	DECL_NAME (decl) = get_identifier (name);
	}

	tree
	build_va_arg (tree expr, tree type)
	{
	return build1 (VA_ARG_EXPR, type, expr);
	}


	/* Linked list of disabled built-in functions. */

	typedef struct disabled_builtin
	{
	const char *name;
	struct disabled_builtin *next;
	} disabled_builtin;
	static disabled_builtin *disabled_builtins = NULL;

	static bool builtin_function_disabled_p (const char *);

	/* Disable a built-in function specified by -fno-builtin-NAME. If NAME
	begins with "__builtin_", give an error. */

	void
	disable_builtin_function (const char *name)
	{
	if (strncmp (name, "__builtin_", strlen ("__builtin_")) == 0)
	error ("cannot disable built-in function %qs", name);
	else
	{
	disabled_builtin *new_disabled_builtin = XNEW (disabled_builtin);
	new_disabled_builtin->name = name;
	new_disabled_builtin->next = disabled_builtins;
	disabled_builtins = new_disabled_builtin;
	}
	}


	/* Return true if the built-in function NAME has been disabled, false
	otherwise. */

	static bool
	builtin_function_disabled_p (const char *name)
	{
	disabled_builtin *p;
	for (p = disabled_builtins; p != NULL; p = p->next)
	{
	if (strcmp (name, p->name) == 0)
	return true;
	}
	return false;
	}


	/* Worker for DEF_BUILTIN.
	Possibly define a builtin function with one or two names.
	Does not declare a non-__builtin_ function if flag_no_builtin, or if
	nonansi_p and flag_no_nonansi_builtin. */

	static void
	def_builtin_1 (enum built_in_function fncode,
	const char *name,
	enum built_in_class fnclass,
	tree fntype, tree libtype,
	bool both_p, bool fallback_p, bool nonansi_p,
	tree fnattrs, bool implicit_p)
	{
	tree decl;
	const char *libname;

	if (fntype == error_mark_node)
	return;

	gcc_assert ((!both_p && !fallback_p)
	\|\| !strncmp (name, "__builtin_",
	strlen ("__builtin_")));

	libname = name + strlen ("__builtin_");
	decl = lang_hooks.builtin_function (name, fntype, fncode, fnclass,
	(fallback_p ? libname : NULL),
	fnattrs);
	if (both_p
	&& !flag_no_builtin && !builtin_function_disabled_p (libname)
	&& !(nonansi_p && flag_no_nonansi_builtin))
	lang_hooks.builtin_function (libname, libtype, fncode, fnclass,
	NULL, fnattrs);

	built_in_decls[(int) fncode] = decl;
	if (implicit_p)
	implicit_built_in_decls[(int) fncode] = decl;
	}

	/* Nonzero if the type T promotes to int. This is (nearly) the
	integral promotions defined in ISO C99 6.3.1.1/2. */

	bool
	c_promoting_integer_type_p (tree t)
	{
	switch (TREE_CODE (t))
	{
	case INTEGER_TYPE:
	return (TYPE_MAIN_VARIANT (t) == char_type_node
	\|\| TYPE_MAIN_VARIANT (t) == signed_char_type_node
	\|\| TYPE_MAIN_VARIANT (t) == unsigned_char_type_node
	\|\| TYPE_MAIN_VARIANT (t) == short_integer_type_node
	\|\| TYPE_MAIN_VARIANT (t) == short_unsigned_type_node
	\|\| TYPE_PRECISION (t) < TYPE_PRECISION (integer_type_node));

	case ENUMERAL_TYPE:
	/* ??? Technically all enumerations not larger than an int
	promote to an int. But this is used along code paths
	that only want to notice a size change. */
	return TYPE_PRECISION (t) < TYPE_PRECISION (integer_type_node);

	case BOOLEAN_TYPE:
	return 1;

	default:
	return 0;
	}
	}

	/* Return 1 if PARMS specifies a fixed number of parameters
	and none of their types is affected by default promotions. */

	int
	self_promoting_args_p (tree parms)
	{
	tree t;
	for (t = parms; t; t = TREE_CHAIN (t))
	{
	tree type = TREE_VALUE (t);

	if (type == error_mark_node)
	continue;

	if (TREE_CHAIN (t) == 0 && type != void_type_node)
	return 0;

	if (type == 0)
	return 0;

	if (TYPE_MAIN_VARIANT (type) == float_type_node)
	return 0;

	if (c_promoting_integer_type_p (type))
	return 0;
	}
	return 1;
	}

	/* Recursively examines the array elements of TYPE, until a non-array
	element type is found. */

	tree
	strip_array_types (tree type)
	{
	while (TREE_CODE (type) == ARRAY_TYPE)
	type = TREE_TYPE (type);

	return type;
	}

	/* Recursively remove any '' or '&' operator from TYPE. /
	tree
	strip_pointer_operator (tree t)
	{
	while (POINTER_TYPE_P (t))
	t = TREE_TYPE (t);
	return t;
	}

	/* Used to compare case labels. K1 and K2 are actually tree nodes
	representing case labels, or NULL_TREE for a `default' label.
	Returns -1 if K1 is ordered before K2, -1 if K1 is ordered after
	K2, and 0 if K1 and K2 are equal. */

	int
	case_compare (splay_tree_key k1, splay_tree_key k2)
	{
	/* Consider a NULL key (such as arises with a `default' label) to be
	smaller than anything else. */
	if (!k1)
	return k2 ? -1 : 0;
	else if (!k2)
	return k1 ? 1 : 0;

	return tree_int_cst_compare ((tree) k1, (tree) k2);
	}

	/* Process a case label for the range LOW_VALUE ... HIGH_VALUE. If
	LOW_VALUE and HIGH_VALUE are both NULL_TREE then this case label is
	actually a `default' label. If only HIGH_VALUE is NULL_TREE, then
	case label was declared using the usual C/C++ syntax, rather than
	the GNU case range extension. CASES is a tree containing all the
	case ranges processed so far; COND is the condition for the
	switch-statement itself. Returns the CASE_LABEL_EXPR created, or
	ERROR_MARK_NODE if no CASE_LABEL_EXPR is created. */

	tree
	c_add_case_label (splay_tree cases, tree cond, tree orig_type,
	tree low_value, tree high_value)
	{
	tree type;
	tree label;
	tree case_label;
	splay_tree_node node;

	/* Create the LABEL_DECL itself. */
	label = create_artificial_label ();

	/* If there was an error processing the switch condition, bail now
	before we get more confused. */
	if (!cond \|\| cond == error_mark_node)
	goto error_out;

	if ((low_value && TREE_TYPE (low_value)
	&& POINTER_TYPE_P (TREE_TYPE (low_value)))
	\|\| (high_value && TREE_TYPE (high_value)
	&& POINTER_TYPE_P (TREE_TYPE (high_value))))
	{
	error ("pointers are not permitted as case values");
	goto error_out;
	}

	/* Case ranges are a GNU extension. */
	if (high_value && pedantic)
	pedwarn ("range expressions in switch statements are non-standard");

	type = TREE_TYPE (cond);
	if (low_value)
	{
	low_value = check_case_value (low_value);
	low_value = convert_and_check (type, low_value);
	if (low_value == error_mark_node)
	goto error_out;
	}
	if (high_value)
	{
	high_value = check_case_value (high_value);
	high_value = convert_and_check (type, high_value);
	if (high_value == error_mark_node)
	goto error_out;
	}

	if (low_value && high_value)
	{
	/* If the LOW_VALUE and HIGH_VALUE are the same, then this isn't
	really a case range, even though it was written that way.
	Remove the HIGH_VALUE to simplify later processing. */
	if (tree_int_cst_equal (low_value, high_value))
	high_value = NULL_TREE;
	else if (!tree_int_cst_lt (low_value, high_value))
	warning (0, "empty range specified");
	}

	/* See if the case is in range of the type of the original testing
	expression. If both low_value and high_value are out of range,
	don't insert the case label and return NULL_TREE. */
	if (low_value
	&& !check_case_bounds (type, orig_type,
	&low_value, high_value ? &high_value : NULL))
	return NULL_TREE;

	/* Look up the LOW_VALUE in the table of case labels we already
	have. */
	node = splay_tree_lookup (cases, (splay_tree_key) low_value);
	/* If there was not an exact match, check for overlapping ranges.
	There's no need to do this if there's no LOW_VALUE or HIGH_VALUE;
	that's a `default' label and the only overlap is an exact match. */
	if (!node && (low_value \|\| high_value))
	{
	splay_tree_node low_bound;
	splay_tree_node high_bound;

	/* Even though there wasn't an exact match, there might be an
	overlap between this case range and another case range.
	Since we've (inductively) not allowed any overlapping case
	ranges, we simply need to find the greatest low case label
	that is smaller that LOW_VALUE, and the smallest low case
	label that is greater than LOW_VALUE. If there is an overlap
	it will occur in one of these two ranges. */
	low_bound = splay_tree_predecessor (cases,
	(splay_tree_key) low_value);
	high_bound = splay_tree_successor (cases,
	(splay_tree_key) low_value);

	/* Check to see if the LOW_BOUND overlaps. It is smaller than
	the LOW_VALUE, so there is no need to check unless the
	LOW_BOUND is in fact itself a case range. */
	if (low_bound
	&& CASE_HIGH ((tree) low_bound->value)
	&& tree_int_cst_compare (CASE_HIGH ((tree) low_bound->value),
	low_value) >= 0)
	node = low_bound;
	/* Check to see if the HIGH_BOUND overlaps. The low end of that
	range is bigger than the low end of the current range, so we
	are only interested if the current range is a real range, and
	not an ordinary case label. */
	else if (high_bound
	&& high_value
	&& (tree_int_cst_compare ((tree) high_bound->key,
	high_value)
	<= 0))
	node = high_bound;
	}
	/* If there was an overlap, issue an error. */
	if (node)
	{
	tree duplicate = CASE_LABEL ((tree) node->value);

	if (high_value)
	{
	error ("duplicate (or overlapping) case value");
	error ("%Jthis is the first entry overlapping that value", duplicate);
	}
	else if (low_value)
	{
	error ("duplicate case value") ;
	error ("%Jpreviously used here", duplicate);
	}
	else
	{
	error ("multiple default labels in one switch");
	error ("%Jthis is the first default label", duplicate);
	}
	goto error_out;
	}

	/* Add a CASE_LABEL to the statement-tree. */
	case_label = add_stmt (build_case_label (low_value, high_value, label));
	/* Register this case label in the splay tree. */
	splay_tree_insert (cases,
	(splay_tree_key) low_value,
	(splay_tree_value) case_label);

	return case_label;

	error_out:
	/* Add a label so that the back-end doesn't think that the beginning of
	the switch is unreachable. Note that we do not add a case label, as
	that just leads to duplicates and thence to failure later on. */
	if (!cases->root)
	{
	tree t = create_artificial_label ();
	add_stmt (build_stmt (LABEL_EXPR, t));
	}
	return error_mark_node;
	}

	/* Subroutines of c_do_switch_warnings, called via splay_tree_foreach.
	Used to verify that case values match up with enumerator values. */

	static void
	match_case_to_enum_1 (tree key, tree type, tree label)
	{
	char buf[2 + 2*HOST_BITS_PER_WIDE_INT/4 + 1];

	/* ??? Not working too hard to print the double-word value.
	Should perhaps be done with %lwd in the diagnostic routines? */
	if (TREE_INT_CST_HIGH (key) == 0)
	snprintf (buf, sizeof (buf), HOST_WIDE_INT_PRINT_UNSIGNED,
	TREE_INT_CST_LOW (key));
	else if (!TYPE_UNSIGNED (type)
	&& TREE_INT_CST_HIGH (key) == -1
	&& TREE_INT_CST_LOW (key) != 0)
	snprintf (buf, sizeof (buf), "-" HOST_WIDE_INT_PRINT_UNSIGNED,
	-TREE_INT_CST_LOW (key));
	else
	snprintf (buf, sizeof (buf), HOST_WIDE_INT_PRINT_DOUBLE_HEX,
	TREE_INT_CST_HIGH (key), TREE_INT_CST_LOW (key));

	if (TYPE_NAME (type) == 0)
	warning (0, "%Jcase value %qs not in enumerated type",
	CASE_LABEL (label), buf);
	else
	warning (0, "%Jcase value %qs not in enumerated type %qT",
	CASE_LABEL (label), buf, type);
	}

	/* Subroutine of c_do_switch_warnings, called via splay_tree_foreach.
	Used to verify that case values match up with enumerator values. */

	static int
	match_case_to_enum (splay_tree_node node, void *data)
	{
	tree label = (tree) node->value;
	tree type = (tree) data;

	/* Skip default case. */
	if (!CASE_LOW (label))
	return 0;

	/* If CASE_LOW_SEEN is not set, that means CASE_LOW did not appear
	when we did our enum->case scan. Reset our scratch bit after. */
	if (!CASE_LOW_SEEN (label))
	match_case_to_enum_1 (CASE_LOW (label), type, label);
	else
	CASE_LOW_SEEN (label) = 0;

	/* If CASE_HIGH is non-null, we have a range. If CASE_HIGH_SEEN is
	not set, that means that CASE_HIGH did not appear when we did our
	enum->case scan. Reset our scratch bit after. */
	if (CASE_HIGH (label))
	{
	if (!CASE_HIGH_SEEN (label))
	match_case_to_enum_1 (CASE_HIGH (label), type, label);
	else
	CASE_HIGH_SEEN (label) = 0;
	}

	return 0;
	}

	/* Handle -Wswitch*. Called from the front end after parsing the
	switch construct. */
	/* ??? Should probably be somewhere generic, since other languages
	besides C and C++ would want this. At the moment, however, C/C++
	are the only tree-ssa languages that support enumerations at all,
	so the point is moot. */

	void
	c_do_switch_warnings (splay_tree cases, location_t switch_location,
	tree type, tree cond)
	{
	splay_tree_node default_node;
	splay_tree_node node;
	tree chain;

	if (!warn_switch && !warn_switch_enum && !warn_switch_default)
	return;

	default_node = splay_tree_lookup (cases, (splay_tree_key) NULL);
	if (!default_node)
	warning (OPT_Wswitch_default, "%Hswitch missing default case",
	&switch_location);

	/* From here on, we only care about about enumerated types. */
	if (!type \|\| TREE_CODE (type) != ENUMERAL_TYPE)
	return;

	/* If the switch expression was an enumerated type, check that
	exactly all enumeration literals are covered by the cases.
	The check is made when -Wswitch was specified and there is no
	default case, or when -Wswitch-enum was specified. */

	if (!warn_switch_enum
	&& !(warn_switch && !default_node))
	return;

	/* Clearing COND if it is not an integer constant simplifies
	the tests inside the loop below. */
	if (TREE_CODE (cond) != INTEGER_CST)
	cond = NULL_TREE;

	/* The time complexity here is O(N*lg(N)) worst case, but for the
	common case of monotonically increasing enumerators, it is
	O(N), since the nature of the splay tree will keep the next
	element adjacent to the root at all times. */

	for (chain = TYPE_VALUES (type); chain; chain = TREE_CHAIN (chain))
	{
	tree value = TREE_VALUE (chain);
	node = splay_tree_lookup (cases, (splay_tree_key) value);
	if (node)
	{
	/* Mark the CASE_LOW part of the case entry as seen. */
	tree label = (tree) node->value;
	CASE_LOW_SEEN (label) = 1;
	continue;
	}

	/* Even though there wasn't an exact match, there might be a
	case range which includes the enumator's value. */
	node = splay_tree_predecessor (cases, (splay_tree_key) value);
	if (node && CASE_HIGH ((tree) node->value))
	{
	tree label = (tree) node->value;
	int cmp = tree_int_cst_compare (CASE_HIGH (label), value);
	if (cmp >= 0)
	{
	/* If we match the upper bound exactly, mark the CASE_HIGH
	part of the case entry as seen. */
	if (cmp == 0)
	CASE_HIGH_SEEN (label) = 1;
	continue;
	}
	}

	/* We've now determined that this enumerated literal isn't
	handled by the case labels of the switch statement. */

	/* If the switch expression is a constant, we only really care
	about whether that constant is handled by the switch. */
	if (cond && tree_int_cst_compare (cond, value))
	continue;

	warning (0, "%Henumeration value %qE not handled in switch",
	&switch_location, TREE_PURPOSE (chain));
	}

	/* Warn if there are case expressions that don't correspond to
	enumerators. This can occur since C and C++ don't enforce
	type-checking of assignments to enumeration variables.

	The time complexity here is now always O(N) worst case, since
	we should have marked both the lower bound and upper bound of
	every disjoint case label, with CASE_LOW_SEEN and CASE_HIGH_SEEN
	above. This scan also resets those fields. */
	splay_tree_foreach (cases, match_case_to_enum, type);
	}

	/* Finish an expression taking the address of LABEL (an
	IDENTIFIER_NODE). Returns an expression for the address. */

	tree
	finish_label_address_expr (tree label)
	{
	tree result;

	if (pedantic)
	pedwarn ("taking the address of a label is non-standard");

	if (label == error_mark_node)
	return error_mark_node;

	label = lookup_label (label);
	if (label == NULL_TREE)
	result = null_pointer_node;
	else
	{
	TREE_USED (label) = 1;
	result = build1 (ADDR_EXPR, ptr_type_node, label);
	/* The current function in not necessarily uninlinable.
	Computed gotos are incompatible with inlining, but the value
	here could be used only in a diagnostic, for example. */
	}

	return result;
	}

	/* Hook used by expand_expr to expand language-specific tree codes. */
	/* The only things that should go here are bits needed to expand
	constant initializers. Everything else should be handled by the
	gimplification routines. */

	rtx
	c_expand_expr (tree exp, rtx target, enum machine_mode tmode,
	int modifier /* Actually enum_modifier. */,
	rtx *alt_rtl)
	{
	switch (TREE_CODE (exp))
	{
	case COMPOUND_LITERAL_EXPR:
	{
	/* Initialize the anonymous variable declared in the compound
	literal, then return the variable. */
	tree decl = COMPOUND_LITERAL_EXPR_DECL (exp);
	emit_local_var (decl);
	return expand_expr_real (decl, target, tmode, modifier, alt_rtl);
	}

	default:
	gcc_unreachable ();
	}
	}

	/* Hook used by staticp to handle language-specific tree codes. */

	tree
	c_staticp (tree exp)
	{
	return (TREE_CODE (exp) == COMPOUND_LITERAL_EXPR
	&& TREE_STATIC (COMPOUND_LITERAL_EXPR_DECL (exp))
	? exp : NULL);
	}


	/* Given a boolean expression ARG, return a tree representing an increment
	or decrement (as indicated by CODE) of ARG. The front end must check for
	invalid cases (e.g., decrement in C++). */
	tree
	boolean_increment (enum tree_code code, tree arg)
	{
	tree val;
	tree true_res = boolean_true_node;

	arg = stabilize_reference (arg);
	switch (code)
	{
	case PREINCREMENT_EXPR:
	val = build2 (MODIFY_EXPR, TREE_TYPE (arg), arg, true_res);
	break;
	case POSTINCREMENT_EXPR:
	val = build2 (MODIFY_EXPR, TREE_TYPE (arg), arg, true_res);
	arg = save_expr (arg);
	val = build2 (COMPOUND_EXPR, TREE_TYPE (arg), val, arg);
	val = build2 (COMPOUND_EXPR, TREE_TYPE (arg), arg, val);
	break;
	case PREDECREMENT_EXPR:
	val = build2 (MODIFY_EXPR, TREE_TYPE (arg), arg,
	invert_truthvalue (arg));
	break;
	case POSTDECREMENT_EXPR:
	val = build2 (MODIFY_EXPR, TREE_TYPE (arg), arg,
	invert_truthvalue (arg));
	arg = save_expr (arg);
	val = build2 (COMPOUND_EXPR, TREE_TYPE (arg), val, arg);
	val = build2 (COMPOUND_EXPR, TREE_TYPE (arg), arg, val);
	break;
	default:
	gcc_unreachable ();
	}
	TREE_SIDE_EFFECTS (val) = 1;
	return val;
	}

	/* Built-in macros for stddef.h, that require macros defined in this
	file. */
	void
	c_stddef_cpp_builtins(void)
	{
	builtin_define_with_value ("__SIZE_TYPE__", SIZE_TYPE, 0);
	builtin_define_with_value ("__PTRDIFF_TYPE__", PTRDIFF_TYPE, 0);
	builtin_define_with_value ("__WCHAR_TYPE__", MODIFIED_WCHAR_TYPE, 0);
	builtin_define_with_value ("__WINT_TYPE__", WINT_TYPE, 0);
	builtin_define_with_value ("__INTMAX_TYPE__", INTMAX_TYPE, 0);
	builtin_define_with_value ("__UINTMAX_TYPE__", UINTMAX_TYPE, 0);
	}

	static void
	c_init_attributes (void)
	{
	/* Fill in the built_in_attributes array. */
	#define DEF_ATTR_NULL_TREE(ENUM) \
	built_in_attributes[(int) ENUM] = NULL_TREE;
	#define DEF_ATTR_INT(ENUM, VALUE) \
	built_in_attributes[(int) ENUM] = build_int_cst (NULL_TREE, VALUE);
	#define DEF_ATTR_IDENT(ENUM, STRING) \
	built_in_attributes[(int) ENUM] = get_identifier (STRING);
	#define DEF_ATTR_TREE_LIST(ENUM, PURPOSE, VALUE, CHAIN) \
	built_in_attributes[(int) ENUM] \
	= tree_cons (built_in_attributes[(int) PURPOSE], \
	built_in_attributes[(int) VALUE], \
	built_in_attributes[(int) CHAIN]);
	#include "builtin-attrs.def"
	#undef DEF_ATTR_NULL_TREE
	#undef DEF_ATTR_INT
	#undef DEF_ATTR_IDENT
	#undef DEF_ATTR_TREE_LIST
	}

	/* Attribute handlers common to C front ends. */

	/* Handle a "packed" attribute; arguments as in
	struct attribute_spec.handler. */

	static tree
	handle_packed_attribute (tree *node, tree name, tree ARG_UNUSED (args),
	int flags, bool *no_add_attrs)
	{
	if (TYPE_P (*node))
	{
	if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
	node = build_variant_type_copy (node);
	TYPE_PACKED (*node) = 1;
	}
	else if (TREE_CODE (*node) == FIELD_DECL)
	{
	if (TYPE_ALIGN (TREE_TYPE (*node)) <= BITS_PER_UNIT)
	warning (OPT_Wattributes,
	"%qE attribute ignored for field of type %qT",
	name, TREE_TYPE (*node));
	else
	DECL_PACKED (*node) = 1;
	}
	/* We can't set DECL_PACKED for a VAR_DECL, because the bit is
	used for DECL_REGISTER. It wouldn't mean anything anyway.
	We can't set DECL_PACKED on the type of a TYPE_DECL, because
	that changes what the typedef is typing. */
	else
	{
	warning (OPT_Wattributes, "%qE attribute ignored", name);
	*no_add_attrs = true;
	}

	return NULL_TREE;
	}

	/* Handle a "nocommon" attribute; arguments as in
	struct attribute_spec.handler. */

	static tree
	handle_nocommon_attribute (tree *node, tree name,
	tree ARG_UNUSED (args),
	int ARG_UNUSED (flags), bool *no_add_attrs)
	{
	if (TREE_CODE (*node) == VAR_DECL)
	DECL_COMMON (*node) = 0;
	else
	{
	warning (OPT_Wattributes, "%qE attribute ignored", name);
	*no_add_attrs = true;
	}

	return NULL_TREE;
	}

	/* Handle a "common" attribute; arguments as in
	struct attribute_spec.handler. */

	static tree
	handle_common_attribute (tree *node, tree name, tree ARG_UNUSED (args),
	int ARG_UNUSED (flags), bool *no_add_attrs)
	{
	if (TREE_CODE (*node) == VAR_DECL)
	DECL_COMMON (*node) = 1;
	else
	{
	warning (OPT_Wattributes, "%qE attribute ignored", name);
	*no_add_attrs = true;
	}

	return NULL_TREE;
	}

	/* Handle a "noreturn" attribute; arguments as in
	struct attribute_spec.handler. */

	static tree
	handle_noreturn_attribute (tree *node, tree name, tree ARG_UNUSED (args),
	int ARG_UNUSED (flags), bool *no_add_attrs)
	{
	tree type = TREE_TYPE (*node);

	/* See FIXME comment in c_common_attribute_table. */
	if (TREE_CODE (*node) == FUNCTION_DECL)
	TREE_THIS_VOLATILE (*node) = 1;
	else if (TREE_CODE (type) == POINTER_TYPE
	&& TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE)
	TREE_TYPE (*node)
	= build_pointer_type
	(build_type_variant (TREE_TYPE (type),
	TYPE_READONLY (TREE_TYPE (type)), 1));
	else
	{
	warning (OPT_Wattributes, "%qE attribute ignored", name);
	*no_add_attrs = true;
	}

	return NULL_TREE;
	}

	/* Handle a "noinline" attribute; arguments as in
	struct attribute_spec.handler. */

	static tree
	handle_noinline_attribute (tree *node, tree name,
	tree ARG_UNUSED (args),
	int ARG_UNUSED (flags), bool *no_add_attrs)
	{
	if (TREE_CODE (*node) == FUNCTION_DECL)
	DECL_UNINLINABLE (*node) = 1;
	else
	{
	warning (OPT_Wattributes, "%qE attribute ignored", name);
	*no_add_attrs = true;
	}

	return NULL_TREE;
	}

	/* Handle a "always_inline" attribute; arguments as in
	struct attribute_spec.handler. */

	static tree
	handle_always_inline_attribute (tree *node, tree name,
	tree ARG_UNUSED (args),
	int ARG_UNUSED (flags),
	bool *no_add_attrs)
	{
	if (TREE_CODE (*node) == FUNCTION_DECL)
	{
	/* Do nothing else, just set the attribute. We'll get at
	it later with lookup_attribute. */
	}
	else
	{
	warning (OPT_Wattributes, "%qE attribute ignored", name);
	*no_add_attrs = true;
	}

	return NULL_TREE;
	}

	/* Handle a "gnu_inline" attribute; arguments as in
	struct attribute_spec.handler. */

	static tree
	handle_gnu_inline_attribute (tree *node, tree name,
	tree ARG_UNUSED (args),
	int ARG_UNUSED (flags),
	bool *no_add_attrs)
	{
	if (TREE_CODE (node) == FUNCTION_DECL && DECL_DECLARED_INLINE_P (node))
	{
	/* Do nothing else, just set the attribute. We'll get at
	it later with lookup_attribute. */
	}
	else
	{
	warning (OPT_Wattributes, "%qE attribute ignored", name);
	*no_add_attrs = true;
	}

	return NULL_TREE;
	}

	/* Handle a "flatten" attribute; arguments as in
	struct attribute_spec.handler. */

	static tree
	handle_flatten_attribute (tree *node, tree name,
	tree args ATTRIBUTE_UNUSED,
	int flags ATTRIBUTE_UNUSED, bool *no_add_attrs)
	{
	if (TREE_CODE (*node) == FUNCTION_DECL)
	/* Do nothing else, just set the attribute. We'll get at
	it later with lookup_attribute. */
	;
	else
	{
	warning (OPT_Wattributes, "%qE attribute ignored", name);
	*no_add_attrs = true;
	}

	return NULL_TREE;
	}


	/* Handle a "used" attribute; arguments as in
	struct attribute_spec.handler. */

	static tree
	handle_used_attribute (tree *pnode, tree name, tree ARG_UNUSED (args),
	int ARG_UNUSED (flags), bool *no_add_attrs)
	{
	tree node = *pnode;

	if (TREE_CODE (node) == FUNCTION_DECL
	\|\| (TREE_CODE (node) == VAR_DECL && TREE_STATIC (node)))
	{
	TREE_USED (node) = 1;
	DECL_PRESERVE_P (node) = 1;
	}
	else
	{
	warning (OPT_Wattributes, "%qE attribute ignored", name);
	*no_add_attrs = true;
	}

	return NULL_TREE;
	}

	/* Handle a "unused" attribute; arguments as in
	struct attribute_spec.handler. */

	static tree
	handle_unused_attribute (tree *node, tree name, tree ARG_UNUSED (args),
	int flags, bool *no_add_attrs)
	{
	if (DECL_P (*node))
	{
	tree decl = *node;

	if (TREE_CODE (decl) == PARM_DECL
	\|\| TREE_CODE (decl) == VAR_DECL
	\|\| TREE_CODE (decl) == FUNCTION_DECL
	- \|\| TREE_CODE (decl) == LABEL_DECL
	+/* APPLE LOCAL begin for-fsf-4_4 3274130 5295549 */ \
	+ \|\| (TREE_CODE (decl) == LABEL_DECL
	+ && ! DECL_ARTIFICIAL (decl))
	+/* APPLE LOCAL end for-fsf-4_4 3274130 5295549 */ \
	\|\| TREE_CODE (decl) == TYPE_DECL)
	TREE_USED (decl) = 1;
	else
	{
	warning (OPT_Wattributes, "%qE attribute ignored", name);
	*no_add_attrs = true;
	}
	}
	else
	{
	if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
	node = build_variant_type_copy (node);
	TREE_USED (*node) = 1;
	}

	return NULL_TREE;
	}

	/* Handle a "externally_visible" attribute; arguments as in
	struct attribute_spec.handler. */

	static tree
	handle_externally_visible_attribute (tree *pnode, tree name,
	tree ARG_UNUSED (args),
	int ARG_UNUSED (flags),
	bool *no_add_attrs)
	{
	tree node = *pnode;

	if (TREE_CODE (node) == FUNCTION_DECL \|\| TREE_CODE (node) == VAR_DECL)
	{
	if ((!TREE_STATIC (node) && TREE_CODE (node) != FUNCTION_DECL
	&& !DECL_EXTERNAL (node)) \|\| !TREE_PUBLIC (node))
	{
	warning (OPT_Wattributes,
	"%qE attribute have effect only on public objects", name);
	*no_add_attrs = true;
	}
	}
	else
	{
	warning (OPT_Wattributes, "%qE attribute ignored", name);
	*no_add_attrs = true;
	}

	return NULL_TREE;
	}

	/* Handle a "const" attribute; arguments as in
	struct attribute_spec.handler. */

	static tree
	handle_const_attribute (tree *node, tree name, tree ARG_UNUSED (args),
	int ARG_UNUSED (flags), bool *no_add_attrs)
	{
	tree type = TREE_TYPE (*node);

	/* See FIXME comment on noreturn in c_common_attribute_table. */
	if (TREE_CODE (*node) == FUNCTION_DECL)
	TREE_READONLY (*node) = 1;
	else if (TREE_CODE (type) == POINTER_TYPE
	&& TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE)
	TREE_TYPE (*node)
	= build_pointer_type
	(build_type_variant (TREE_TYPE (type), 1,
	TREE_THIS_VOLATILE (TREE_TYPE (type))));
	else
	{
	warning (OPT_Wattributes, "%qE attribute ignored", name);
	*no_add_attrs = true;
	}

	return NULL_TREE;
	}

	/* Handle a "transparent_union" attribute; arguments as in
	struct attribute_spec.handler. */

	static tree
	handle_transparent_union_attribute (tree *node, tree name,
	tree ARG_UNUSED (args), int flags,
	bool *no_add_attrs)
	{
	tree type = NULL;

	*no_add_attrs = true;

	if (DECL_P (*node))
	{
	if (TREE_CODE (*node) != TYPE_DECL)
	goto ignored;
	node = &TREE_TYPE (*node);
	type = *node;
	}
	else if (TYPE_P (*node))
	type = *node;
	else
	goto ignored;

	if (TREE_CODE (type) == UNION_TYPE)
	{
	/* When IN_PLACE is set, leave the check for FIELDS and MODE to
	the code in finish_struct. */
	if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
	{
	if (TYPE_FIELDS (type) == NULL_TREE
	\|\| TYPE_MODE (type) != DECL_MODE (TYPE_FIELDS (type)))
	goto ignored;

	/* A type variant isn't good enough, since we don't a cast
	to such a type removed as a no-op. */
	*node = type = build_duplicate_type (type);
	}

	TYPE_TRANSPARENT_UNION (type) = 1;
	return NULL_TREE;
	}

	ignored:
	warning (OPT_Wattributes, "%qE attribute ignored", name);
	return NULL_TREE;
	}

	/* Handle a "constructor" attribute; arguments as in
	struct attribute_spec.handler. */

	static tree
	handle_constructor_attribute (tree *node, tree name,
	tree ARG_UNUSED (args),
	int ARG_UNUSED (flags),
	bool *no_add_attrs)
	{
	tree decl = *node;
	tree type = TREE_TYPE (decl);

	if (TREE_CODE (decl) == FUNCTION_DECL
	&& TREE_CODE (type) == FUNCTION_TYPE
	&& decl_function_context (decl) == 0)
	{
	DECL_STATIC_CONSTRUCTOR (decl) = 1;
	TREE_USED (decl) = 1;
	}
	else
	{
	warning (OPT_Wattributes, "%qE attribute ignored", name);
	*no_add_attrs = true;
	}

	return NULL_TREE;
	}

	/* Handle a "destructor" attribute; arguments as in
	struct attribute_spec.handler. */

	static tree
	handle_destructor_attribute (tree *node, tree name,
	tree ARG_UNUSED (args),
	int ARG_UNUSED (flags),
	bool *no_add_attrs)
	{
	tree decl = *node;
	tree type = TREE_TYPE (decl);

	if (TREE_CODE (decl) == FUNCTION_DECL
	&& TREE_CODE (type) == FUNCTION_TYPE
	&& decl_function_context (decl) == 0)
	{
	DECL_STATIC_DESTRUCTOR (decl) = 1;
	TREE_USED (decl) = 1;
	}
	else
	{
	warning (OPT_Wattributes, "%qE attribute ignored", name);
	*no_add_attrs = true;
	}

	return NULL_TREE;
	}

	/* Handle a "mode" attribute; arguments as in
	struct attribute_spec.handler. */

	static tree
	handle_mode_attribute (tree *node, tree name, tree args,
	int ARG_UNUSED (flags), bool *no_add_attrs)
	{
	tree type = *node;

	*no_add_attrs = true;

	if (TREE_CODE (TREE_VALUE (args)) != IDENTIFIER_NODE)
	warning (OPT_Wattributes, "%qE attribute ignored", name);
	else
	{
	int j;
	const char *p = IDENTIFIER_POINTER (TREE_VALUE (args));
	int len = strlen (p);
	enum machine_mode mode = VOIDmode;
	tree typefm;
	bool valid_mode;

	if (len > 4 && p[0] == '_' && p[1] == '_'
	&& p[len - 1] == '_' && p[len - 2] == '_')
	{
	char newp = (char ) alloca (len - 1);

	strcpy (newp, &p[2]);
	newp[len - 4] = '\0';
	p = newp;
	}

	/* Change this type to have a type with the specified mode.
	First check for the special modes. */
	if (!strcmp (p, "byte"))
	mode = byte_mode;
	else if (!strcmp (p, "word"))
	mode = word_mode;
	else if (!strcmp (p, "pointer"))
	mode = ptr_mode;
	else
	for (j = 0; j < NUM_MACHINE_MODES; j++)
	if (!strcmp (p, GET_MODE_NAME (j)))
	{
	mode = (enum machine_mode) j;
	break;
	}

	if (mode == VOIDmode)
	{
	error ("unknown machine mode %qs", p);
	return NULL_TREE;
	}

	valid_mode = false;
	switch (GET_MODE_CLASS (mode))
	{
	case MODE_INT:
	case MODE_PARTIAL_INT:
	case MODE_FLOAT:
	case MODE_DECIMAL_FLOAT:
	valid_mode = targetm.scalar_mode_supported_p (mode);
	break;

	case MODE_COMPLEX_INT:
	case MODE_COMPLEX_FLOAT:
	valid_mode = targetm.scalar_mode_supported_p (GET_MODE_INNER (mode));
	break;

	case MODE_VECTOR_INT:
	case MODE_VECTOR_FLOAT:
	warning (OPT_Wattributes, "specifying vector types with "
	"__attribute__ ((mode)) is deprecated");
	warning (OPT_Wattributes,
	"use __attribute__ ((vector_size)) instead");
	valid_mode = vector_mode_valid_p (mode);
	break;

	default:
	break;
	}
	if (!valid_mode)
	{
	error ("unable to emulate %qs", p);
	return NULL_TREE;
	}

	if (POINTER_TYPE_P (type))
	{
	tree (*fn)(tree, enum machine_mode, bool);

	if (!targetm.valid_pointer_mode (mode))
	{
	error ("invalid pointer mode %qs", p);
	return NULL_TREE;
	}

	if (TREE_CODE (type) == POINTER_TYPE)
	fn = build_pointer_type_for_mode;
	else
	fn = build_reference_type_for_mode;
	typefm = fn (TREE_TYPE (type), mode, false);
	}
	else
	typefm = lang_hooks.types.type_for_mode (mode, TYPE_UNSIGNED (type));

	if (typefm == NULL_TREE)
	{
	error ("no data type for mode %qs", p);
	return NULL_TREE;
	}
	else if (TREE_CODE (type) == ENUMERAL_TYPE)
	{
	/* For enumeral types, copy the precision from the integer
	type returned above. If not an INTEGER_TYPE, we can't use
	this mode for this type. */
	if (TREE_CODE (typefm) != INTEGER_TYPE)
	{
	error ("cannot use mode %qs for enumeral types", p);
	return NULL_TREE;
	}

	if (flags & ATTR_FLAG_TYPE_IN_PLACE)
	{
	TYPE_PRECISION (type) = TYPE_PRECISION (typefm);
	typefm = type;
	}
	else
	{
	/* We cannot build a type variant, as there's code that assumes
	that TYPE_MAIN_VARIANT has the same mode. This includes the
	debug generators. Instead, create a subrange type. This
	results in all of the enumeral values being emitted only once
	in the original, and the subtype gets them by reference. */
	if (TYPE_UNSIGNED (type))
	typefm = make_unsigned_type (TYPE_PRECISION (typefm));
	else
	typefm = make_signed_type (TYPE_PRECISION (typefm));
	TREE_TYPE (typefm) = type;
	}
	}
	else if (VECTOR_MODE_P (mode)
	? TREE_CODE (type) != TREE_CODE (TREE_TYPE (typefm))
	: TREE_CODE (type) != TREE_CODE (typefm))
	{
	error ("mode %qs applied to inappropriate type", p);
	return NULL_TREE;
	}

	*node = typefm;
	}

	return NULL_TREE;
	}

	/* Handle a "section" attribute; arguments as in
	struct attribute_spec.handler. */

	static tree
	handle_section_attribute (tree *node, tree ARG_UNUSED (name), tree args,
	int ARG_UNUSED (flags), bool *no_add_attrs)
	{
	tree decl = *node;

	if (targetm.have_named_sections)
	{
	user_defined_section_attribute = true;

	if ((TREE_CODE (decl) == FUNCTION_DECL
	\|\| TREE_CODE (decl) == VAR_DECL)
	&& TREE_CODE (TREE_VALUE (args)) == STRING_CST)
	{
	if (TREE_CODE (decl) == VAR_DECL
	&& current_function_decl != NULL_TREE
	&& !TREE_STATIC (decl))
	{
	error ("%Jsection attribute cannot be specified for "
	"local variables", decl);
	*no_add_attrs = true;
	}

	/* The decl may have already been given a section attribute
	from a previous declaration. Ensure they match. */
	else if (DECL_SECTION_NAME (decl) != NULL_TREE
	&& strcmp (TREE_STRING_POINTER (DECL_SECTION_NAME (decl)),
	TREE_STRING_POINTER (TREE_VALUE (args))) != 0)
	{
	error ("section of %q+D conflicts with previous declaration",
	*node);
	*no_add_attrs = true;
	}
	else
	DECL_SECTION_NAME (decl) = TREE_VALUE (args);
	}
	else
	{
	error ("section attribute not allowed for %q+D", *node);
	*no_add_attrs = true;
	}
	}
	else
	{
	error ("%Jsection attributes are not supported for this target", *node);
	*no_add_attrs = true;
	}

	return NULL_TREE;
	}

	/* Handle a "aligned" attribute; arguments as in
	struct attribute_spec.handler. */

	static tree
	handle_aligned_attribute (tree *node, tree ARG_UNUSED (name), tree args,
	int flags, bool *no_add_attrs)
	{
	tree decl = NULL_TREE;
	tree *type = NULL;
	int is_type = 0;
	tree align_expr = (args ? TREE_VALUE (args)
	: size_int (BIGGEST_ALIGNMENT / BITS_PER_UNIT));
	int i;

	if (DECL_P (*node))
	{
	decl = *node;
	type = &TREE_TYPE (decl);
	is_type = TREE_CODE (*node) == TYPE_DECL;
	}
	else if (TYPE_P (*node))
	type = node, is_type = 1;

	if (TREE_CODE (align_expr) != INTEGER_CST)
	{
	error ("requested alignment is not a constant");
	*no_add_attrs = true;
	}
	else if ((i = tree_log2 (align_expr)) == -1)
	{
	error ("requested alignment is not a power of 2");
	*no_add_attrs = true;
	}
	else if (i > HOST_BITS_PER_INT - 2)
	{
	error ("requested alignment is too large");
	*no_add_attrs = true;
	}
	else if (is_type)
	{
	/* If we have a TYPE_DECL, then copy the type, so that we
	don't accidentally modify a builtin type. See pushdecl. */
	if (decl && TREE_TYPE (decl) != error_mark_node
	&& DECL_ORIGINAL_TYPE (decl) == NULL_TREE)
	{
	tree tt = TREE_TYPE (decl);
	type = build_variant_type_copy (type);
	DECL_ORIGINAL_TYPE (decl) = tt;
	TYPE_NAME (*type) = decl;
	TREE_USED (*type) = TREE_USED (decl);
	TREE_TYPE (decl) = *type;
	}
	else if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
	type = build_variant_type_copy (type);

	TYPE_ALIGN (type) = (1 << i) BITS_PER_UNIT;
	TYPE_USER_ALIGN (*type) = 1;
	}
	else if (! VAR_OR_FUNCTION_DECL_P (decl)
	- && TREE_CODE (decl) != FIELD_DECL)
	+/* APPLE LOCAL begin for-fsf-4_4 3274130 5295549 */ \
	+ && TREE_CODE (decl) != FIELD_DECL
	+ && TREE_CODE (decl) != LABEL_DECL)
	+/* APPLE LOCAL end for-fsf-4_4 3274130 5295549 */ \
	{
	error ("alignment may not be specified for %q+D", decl);
	*no_add_attrs = true;
	}
	else if (TREE_CODE (decl) == FUNCTION_DECL
	&& DECL_ALIGN (decl) > (1 << i) * BITS_PER_UNIT)
	{
	if (DECL_USER_ALIGN (decl))
	error ("alignment for %q+D was previously specified as %d "
	"and may not be decreased", decl,
	DECL_ALIGN (decl) / BITS_PER_UNIT);
	else
	error ("alignment for %q+D must be at least %d", decl,
	DECL_ALIGN (decl) / BITS_PER_UNIT);
	*no_add_attrs = true;
	}
	else
	{
	DECL_ALIGN (decl) = (1 << i) * BITS_PER_UNIT;
	DECL_USER_ALIGN (decl) = 1;
	}

	return NULL_TREE;
	}

	/* Handle a "weak" attribute; arguments as in
	struct attribute_spec.handler. */

	static tree
	handle_weak_attribute (tree *node, tree name,
	tree ARG_UNUSED (args),
	int ARG_UNUSED (flags),
	bool * ARG_UNUSED (no_add_attrs))
	{
	if (TREE_CODE (*node) == FUNCTION_DECL
	\|\| TREE_CODE (*node) == VAR_DECL)
	declare_weak (*node);
	else
	warning (OPT_Wattributes, "%qE attribute ignored", name);


	return NULL_TREE;
	}

	/* Handle an "alias" attribute; arguments as in
	struct attribute_spec.handler. */

	static tree
	handle_alias_attribute (tree *node, tree name, tree args,
	int ARG_UNUSED (flags), bool *no_add_attrs)
	{
	tree decl = *node;

	if ((TREE_CODE (decl) == FUNCTION_DECL && DECL_INITIAL (decl))
	\|\| (TREE_CODE (decl) != FUNCTION_DECL
	&& TREE_PUBLIC (decl) && !DECL_EXTERNAL (decl))
	/* A static variable declaration is always a tentative definition,
	but the alias is a non-tentative definition which overrides. */
	\|\| (TREE_CODE (decl) != FUNCTION_DECL
	&& ! TREE_PUBLIC (decl) && DECL_INITIAL (decl)))
	{
	error ("%q+D defined both normally and as an alias", decl);
	*no_add_attrs = true;
	}

	/* Note that the very first time we process a nested declaration,
	decl_function_context will not be set. Indeed, would never
	be set except for the DECL_INITIAL/DECL_EXTERNAL frobbery that
	we do below. After such frobbery, pushdecl would set the context.
	In any case, this is never what we want. */
	else if (decl_function_context (decl) == 0 && current_function_decl == NULL)
	{
	tree id;

	id = TREE_VALUE (args);
	if (TREE_CODE (id) != STRING_CST)
	{
	error ("alias argument not a string");
	*no_add_attrs = true;
	return NULL_TREE;
	}
	id = get_identifier (TREE_STRING_POINTER (id));
	/* This counts as a use of the object pointed to. */
	TREE_USED (id) = 1;

	if (TREE_CODE (decl) == FUNCTION_DECL)
	DECL_INITIAL (decl) = error_mark_node;
	else
	{
	if (lookup_attribute ("weakref", DECL_ATTRIBUTES (decl)))
	DECL_EXTERNAL (decl) = 1;
	else
	DECL_EXTERNAL (decl) = 0;
	TREE_STATIC (decl) = 1;
	}
	}
	else
	{
	warning (OPT_Wattributes, "%qE attribute ignored", name);
	*no_add_attrs = true;
	}

	return NULL_TREE;
	}

	/* Handle a "weakref" attribute; arguments as in struct
	attribute_spec.handler. */

	static tree
	handle_weakref_attribute (tree *node, tree ARG_UNUSED (name), tree args,
	int flags, bool *no_add_attrs)
	{
	tree attr = NULL_TREE;

	/* We must ignore the attribute when it is associated with
	local-scoped decls, since attribute alias is ignored and many
	such symbols do not even have a DECL_WEAK field. */
	if (decl_function_context (*node) \|\| current_function_decl)
	{
	warning (OPT_Wattributes, "%qE attribute ignored", name);
	*no_add_attrs = true;
	return NULL_TREE;
	}

	/* The idea here is that `weakref("name")' mutates into `weakref,
	alias("name")', and weakref without arguments, in turn,
	implicitly adds weak. */

	if (args)
	{
	attr = tree_cons (get_identifier ("alias"), args, attr);
	attr = tree_cons (get_identifier ("weakref"), NULL_TREE, attr);

	*no_add_attrs = true;

	decl_attributes (node, attr, flags);
	}
	else
	{
	if (lookup_attribute ("alias", DECL_ATTRIBUTES (*node)))
	error ("%Jweakref attribute must appear before alias attribute",
	*node);

	/* Can't call declare_weak because it wants this to be TREE_PUBLIC,
	and that isn't supported; and because it wants to add it to
	the list of weak decls, which isn't helpful. */
	DECL_WEAK (*node) = 1;
	}

	return NULL_TREE;
	}

	/* Handle an "visibility" attribute; arguments as in
	struct attribute_spec.handler. */

	static tree
	handle_visibility_attribute (tree *node, tree name, tree args,
	int ARG_UNUSED (flags),
	bool *ARG_UNUSED (no_add_attrs))
	{
	tree decl = *node;
	tree id = TREE_VALUE (args);
	enum symbol_visibility vis;

	if (TYPE_P (*node))
	{
	if (TREE_CODE (*node) == ENUMERAL_TYPE)
	/* OK */;
	else if (TREE_CODE (node) != RECORD_TYPE && TREE_CODE (node) != UNION_TYPE)
	{
	warning (OPT_Wattributes, "%qE attribute ignored on non-class types",
	name);
	return NULL_TREE;
	}
	else if (TYPE_FIELDS (*node))
	{
	error ("%qE attribute ignored because %qT is already defined",
	name, *node);
	return NULL_TREE;
	}
	}
	else if (decl_function_context (decl) != 0 \|\| !TREE_PUBLIC (decl))
	{
	warning (OPT_Wattributes, "%qE attribute ignored", name);
	return NULL_TREE;
	}

	if (TREE_CODE (id) != STRING_CST)
	{
	error ("visibility argument not a string");
	return NULL_TREE;
	}

	/* If this is a type, set the visibility on the type decl. */
	if (TYPE_P (decl))
	{
	decl = TYPE_NAME (decl);
	if (!decl)
	return NULL_TREE;
	if (TREE_CODE (decl) == IDENTIFIER_NODE)
	{
	warning (OPT_Wattributes, "%qE attribute ignored on types",
	name);
	return NULL_TREE;
	}
	}

	if (strcmp (TREE_STRING_POINTER (id), "default") == 0)
	vis = VISIBILITY_DEFAULT;
	else if (strcmp (TREE_STRING_POINTER (id), "internal") == 0)
	vis = VISIBILITY_INTERNAL;
	else if (strcmp (TREE_STRING_POINTER (id), "hidden") == 0)
	vis = VISIBILITY_HIDDEN;
	else if (strcmp (TREE_STRING_POINTER (id), "protected") == 0)
	vis = VISIBILITY_PROTECTED;
	else
	{
	error ("visibility argument must be one of \"default\", \"hidden\", \"protected\" or \"internal\"");
	vis = VISIBILITY_DEFAULT;
	}

	if (DECL_VISIBILITY_SPECIFIED (decl)
	&& vis != DECL_VISIBILITY (decl)
	&& lookup_attribute ("visibility", (TYPE_P (*node)
	? TYPE_ATTRIBUTES (*node)
	: DECL_ATTRIBUTES (decl))))
	error ("%qD redeclared with different visibility", decl);

	DECL_VISIBILITY (decl) = vis;
	DECL_VISIBILITY_SPECIFIED (decl) = 1;

	/* Go ahead and attach the attribute to the node as well. This is needed
	so we can determine whether we have VISIBILITY_DEFAULT because the
	visibility was not specified, or because it was explicitly overridden
	from the containing scope. */

	return NULL_TREE;
	}

	/* Determine the ELF symbol visibility for DECL, which is either a
	variable or a function. It is an error to use this function if a
	definition of DECL is not available in this translation unit.
	Returns true if the final visibility has been determined by this
	function; false if the caller is free to make additional
	modifications. */

	bool
	c_determine_visibility (tree decl)
	{
	gcc_assert (TREE_CODE (decl) == VAR_DECL
	\|\| TREE_CODE (decl) == FUNCTION_DECL);

	/* If the user explicitly specified the visibility with an
	attribute, honor that. DECL_VISIBILITY will have been set during
	the processing of the attribute. We check for an explicit
	attribute, rather than just checking DECL_VISIBILITY_SPECIFIED,
	to distinguish the use of an attribute from the use of a "#pragma
	GCC visibility push(...)"; in the latter case we still want other
	considerations to be able to overrule the #pragma. */
	if (lookup_attribute ("visibility", DECL_ATTRIBUTES (decl)))
	return true;

	/* Anything that is exported must have default visibility. */
	if (TARGET_DLLIMPORT_DECL_ATTRIBUTES
	&& lookup_attribute ("dllexport", DECL_ATTRIBUTES (decl)))
	{
	DECL_VISIBILITY (decl) = VISIBILITY_DEFAULT;
	DECL_VISIBILITY_SPECIFIED (decl) = 1;
	return true;
	}

	/* Set default visibility to whatever the user supplied with
	visibility_specified depending on #pragma GCC visibility. */
	if (!DECL_VISIBILITY_SPECIFIED (decl))
	{
	DECL_VISIBILITY (decl) = default_visibility;
	DECL_VISIBILITY_SPECIFIED (decl) = visibility_options.inpragma;
	}
	return false;
	}

	/* Handle an "tls_model" attribute; arguments as in
	struct attribute_spec.handler. */

	static tree
	handle_tls_model_attribute (tree *node, tree name, tree args,
	int ARG_UNUSED (flags), bool *no_add_attrs)
	{
	tree id;
	tree decl = *node;
	enum tls_model kind;

	*no_add_attrs = true;

	if (!DECL_THREAD_LOCAL_P (decl))
	{
	warning (OPT_Wattributes, "%qE attribute ignored", name);
	return NULL_TREE;
	}

	kind = DECL_TLS_MODEL (decl);
	id = TREE_VALUE (args);
	if (TREE_CODE (id) != STRING_CST)
	{
	error ("tls_model argument not a string");
	return NULL_TREE;
	}

	if (!strcmp (TREE_STRING_POINTER (id), "local-exec"))
	kind = TLS_MODEL_LOCAL_EXEC;
	else if (!strcmp (TREE_STRING_POINTER (id), "initial-exec"))
	kind = TLS_MODEL_INITIAL_EXEC;
	else if (!strcmp (TREE_STRING_POINTER (id), "local-dynamic"))
	kind = optimize ? TLS_MODEL_LOCAL_DYNAMIC : TLS_MODEL_GLOBAL_DYNAMIC;
	else if (!strcmp (TREE_STRING_POINTER (id), "global-dynamic"))
	kind = TLS_MODEL_GLOBAL_DYNAMIC;
	else
	error ("tls_model argument must be one of \"local-exec\", \"initial-exec\", \"local-dynamic\" or \"global-dynamic\"");

	DECL_TLS_MODEL (decl) = kind;
	return NULL_TREE;
	}

	/* Handle a "no_instrument_function" attribute; arguments as in
	struct attribute_spec.handler. */

	static tree
	handle_no_instrument_function_attribute (tree *node, tree name,
	tree ARG_UNUSED (args),
	int ARG_UNUSED (flags),
	bool *no_add_attrs)
	{
	tree decl = *node;

	if (TREE_CODE (decl) != FUNCTION_DECL)
	{
	error ("%J%qE attribute applies only to functions", decl, name);
	*no_add_attrs = true;
	}
	else if (DECL_INITIAL (decl))
	{
	error ("%Jcan%'t set %qE attribute after definition", decl, name);
	*no_add_attrs = true;
	}
	else
	DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (decl) = 1;

	return NULL_TREE;
	}

	/* Handle a "malloc" attribute; arguments as in
	struct attribute_spec.handler. */

	static tree
	handle_malloc_attribute (tree *node, tree name, tree ARG_UNUSED (args),
	int ARG_UNUSED (flags), bool *no_add_attrs)
	{
	if (TREE_CODE (*node) == FUNCTION_DECL
	&& POINTER_TYPE_P (TREE_TYPE (TREE_TYPE (*node))))
	DECL_IS_MALLOC (*node) = 1;
	else
	{
	warning (OPT_Wattributes, "%qE attribute ignored", name);
	*no_add_attrs = true;
	}

	return NULL_TREE;
	}

	/* Handle a "returns_twice" attribute; arguments as in
	struct attribute_spec.handler. */

	static tree
	handle_returns_twice_attribute (tree *node, tree name, tree ARG_UNUSED (args),
	int ARG_UNUSED (flags), bool *no_add_attrs)
	{
	if (TREE_CODE (*node) == FUNCTION_DECL)
	DECL_IS_RETURNS_TWICE (*node) = 1;
	else
	{
	warning (OPT_Wattributes, "%qE attribute ignored", name);
	*no_add_attrs = true;
	}

	return NULL_TREE;
	}

	/* Handle a "no_limit_stack" attribute; arguments as in
	struct attribute_spec.handler. */

	static tree
	handle_no_limit_stack_attribute (tree *node, tree name,
	tree ARG_UNUSED (args),
	int ARG_UNUSED (flags),
	bool *no_add_attrs)
	{
	tree decl = *node;

	if (TREE_CODE (decl) != FUNCTION_DECL)
	{
	error ("%J%qE attribute applies only to functions", decl, name);
	*no_add_attrs = true;
	}
	else if (DECL_INITIAL (decl))
	{
	error ("%Jcan%'t set %qE attribute after definition", decl, name);
	*no_add_attrs = true;
	}
	else
	DECL_NO_LIMIT_STACK (decl) = 1;

	return NULL_TREE;
	}

	/* Handle a "pure" attribute; arguments as in
	struct attribute_spec.handler. */

	static tree
	handle_pure_attribute (tree *node, tree name, tree ARG_UNUSED (args),
	int ARG_UNUSED (flags), bool *no_add_attrs)
	{
	if (TREE_CODE (*node) == FUNCTION_DECL)
	DECL_IS_PURE (*node) = 1;
	/* ??? TODO: Support types. */
	else
	{
	warning (OPT_Wattributes, "%qE attribute ignored", name);
	*no_add_attrs = true;
	}

	return NULL_TREE;
	}

	/* Handle a "no vops" attribute; arguments as in
	struct attribute_spec.handler. */

	static tree
	handle_novops_attribute (tree *node, tree ARG_UNUSED (name),
	tree ARG_UNUSED (args), int ARG_UNUSED (flags),
	bool *ARG_UNUSED (no_add_attrs))
	{
	gcc_assert (TREE_CODE (*node) == FUNCTION_DECL);
	DECL_IS_NOVOPS (*node) = 1;
	return NULL_TREE;
	}

	/* Handle a "deprecated" attribute; arguments as in
	struct attribute_spec.handler. */

	static tree
	handle_deprecated_attribute (tree *node, tree name,
	tree ARG_UNUSED (args), int flags,
	bool *no_add_attrs)
	{
	tree type = NULL_TREE;
	int warn = 0;
	tree what = NULL_TREE;

	if (DECL_P (*node))
	{
	tree decl = *node;
	type = TREE_TYPE (decl);

	if (TREE_CODE (decl) == TYPE_DECL
	\|\| TREE_CODE (decl) == PARM_DECL
	\|\| TREE_CODE (decl) == VAR_DECL
	\|\| TREE_CODE (decl) == FUNCTION_DECL
	\|\| TREE_CODE (decl) == FIELD_DECL)
	TREE_DEPRECATED (decl) = 1;
	else
	warn = 1;
	}
	else if (TYPE_P (*node))
	{
	if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
	node = build_variant_type_copy (node);
	TREE_DEPRECATED (*node) = 1;
	type = *node;
	}
	else
	warn = 1;

	if (warn)
	{
	*no_add_attrs = true;
	if (type && TYPE_NAME (type))
	{
	if (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE)
	what = TYPE_NAME (*node);
	else if (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
	&& DECL_NAME (TYPE_NAME (type)))
	what = DECL_NAME (TYPE_NAME (type));
	}
	if (what)
	warning (OPT_Wattributes, "%qE attribute ignored for %qE", name, what);
	else
	warning (OPT_Wattributes, "%qE attribute ignored", name);
	}

	return NULL_TREE;
	}

	+/* APPLE LOCAL begin "unavailable" attribute (Radar 2809697) --ilr */
	+/* Handle a "unavailable" attribute; arguments as in
	+ struct attribute_spec.handler. */
	+
	+static tree
	+handle_unavailable_attribute (tree *node, tree name,
	+ tree args ATTRIBUTE_UNUSED,
	+ int flags ATTRIBUTE_UNUSED,
	+ bool *no_add_attrs)
	+{
	+ tree type = NULL_TREE;
	+ int warn = 0;
	+ const char *what = NULL;
	+
	+ if (DECL_P (*node))
	+ {
	+ tree decl = *node;
	+ type = TREE_TYPE (decl);
	+
	+ if (TREE_CODE (decl) == TYPE_DECL
	+ \|\| TREE_CODE (decl) == PARM_DECL
	+ \|\| TREE_CODE (decl) == VAR_DECL
	+ \|\| TREE_CODE (decl) == FUNCTION_DECL)
	+ {
	+ TREE_UNAVAILABLE (decl) = 1;
	+ }
	+ else
	+ warn = 1;
	+ }
	+ else if (TYPE_P (*node))
	+ {
	+ if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
	+ node = build_variant_type_copy (node);
	+ TREE_UNAVAILABLE (*node) = 1;
	+ type = *node;
	+ }
	+ else
	+ warn = 1;
	+
	+ if (warn)
	+ {
	+ *no_add_attrs = true;
	+ if (type && TYPE_NAME (type))
	+ {
	+ if (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE)
	+ what = IDENTIFIER_POINTER (TYPE_NAME (*node));
	+ else if (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
	+ && DECL_NAME (TYPE_NAME (type)))
	+ what = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type)));
	+ }
	+ if (what)
	+ warning (0, "`%s' attribute ignored for `%s'",
	+ IDENTIFIER_POINTER (name), what);
	+ else
	+ warning (0, "`%s' attribute ignored", IDENTIFIER_POINTER (name));
	+ }
	+
	+ return NULL_TREE;
	+}
	+/* APPLE LOCAL end "unavailable" attribute --ilr */
	+
	/* Handle a "vector_size" attribute; arguments as in
	struct attribute_spec.handler. */

	static tree
	handle_vector_size_attribute (tree *node, tree name, tree args,
	int ARG_UNUSED (flags),
	bool *no_add_attrs)
	{
	unsigned HOST_WIDE_INT vecsize, nunits;
	enum machine_mode orig_mode;
	tree type = *node, new_type, size;

	*no_add_attrs = true;

	size = TREE_VALUE (args);

	if (!host_integerp (size, 1))
	{
	warning (OPT_Wattributes, "%qE attribute ignored", name);
	return NULL_TREE;
	}

	/* Get the vector size (in bytes). */
	vecsize = tree_low_cst (size, 1);

	/* We need to provide for vector pointers, vector arrays, and
	functions returning vectors. For example:

	__attribute__((vector_size(16))) short *foo;

	In this case, the mode is SI, but the type being modified is
	HI, so we need to look further. */

	while (POINTER_TYPE_P (type)
	\|\| TREE_CODE (type) == FUNCTION_TYPE
	\|\| TREE_CODE (type) == METHOD_TYPE
	\|\| TREE_CODE (type) == ARRAY_TYPE)
	type = TREE_TYPE (type);

	/* Get the mode of the type being modified. */
	orig_mode = TYPE_MODE (type);

	if (TREE_CODE (type) == RECORD_TYPE
	\|\| TREE_CODE (type) == UNION_TYPE
	\|\| TREE_CODE (type) == VECTOR_TYPE
	\|\| (!SCALAR_FLOAT_MODE_P (orig_mode)
	&& GET_MODE_CLASS (orig_mode) != MODE_INT)
	\|\| !host_integerp (TYPE_SIZE_UNIT (type), 1))
	{
	error ("invalid vector type for attribute %qE", name);
	return NULL_TREE;
	}

	if (vecsize % tree_low_cst (TYPE_SIZE_UNIT (type), 1))
	{
	error ("vector size not an integral multiple of component size");
	return NULL;
	}

	if (vecsize == 0)
	{
	error ("zero vector size");
	return NULL;
	}

	/* Calculate how many units fit in the vector. */
	nunits = vecsize / tree_low_cst (TYPE_SIZE_UNIT (type), 1);
	if (nunits & (nunits - 1))
	{
	error ("number of components of the vector not a power of two");
	return NULL_TREE;
	}

	new_type = build_vector_type (type, nunits);

	/* Build back pointers if needed. */
	node = reconstruct_complex_type (node, new_type);

	return NULL_TREE;
	}

	/* Handle the "nonnull" attribute. */
	static tree
	handle_nonnull_attribute (tree *node, tree ARG_UNUSED (name),
	tree args, int ARG_UNUSED (flags),
	bool *no_add_attrs)
	{
	tree type = *node;
	unsigned HOST_WIDE_INT attr_arg_num;

	/* If no arguments are specified, all pointer arguments should be
	non-null. Verify a full prototype is given so that the arguments
	will have the correct types when we actually check them later. */
	if (!args)
	{
	if (!TYPE_ARG_TYPES (type))
	{
	error ("nonnull attribute without arguments on a non-prototype");
	*no_add_attrs = true;
	}
	return NULL_TREE;
	}

	/* Argument list specified. Verify that each argument number references
	a pointer argument. */
	for (attr_arg_num = 1; args; args = TREE_CHAIN (args))
	{
	tree argument;
	unsigned HOST_WIDE_INT arg_num = 0, ck_num;

	if (!get_nonnull_operand (TREE_VALUE (args), &arg_num))
	{
	error ("nonnull argument has invalid operand number (argument %lu)",
	(unsigned long) attr_arg_num);
	*no_add_attrs = true;
	return NULL_TREE;
	}

	argument = TYPE_ARG_TYPES (type);
	if (argument)
	{
	for (ck_num = 1; ; ck_num++)
	{
	if (!argument \|\| ck_num == arg_num)
	break;
	argument = TREE_CHAIN (argument);
	}

	if (!argument
	\|\| TREE_CODE (TREE_VALUE (argument)) == VOID_TYPE)
	{
	error ("nonnull argument with out-of-range operand number (argument %lu, operand %lu)",
	(unsigned long) attr_arg_num, (unsigned long) arg_num);
	*no_add_attrs = true;
	return NULL_TREE;
	}

	if (TREE_CODE (TREE_VALUE (argument)) != POINTER_TYPE)
	{
	error ("nonnull argument references non-pointer operand (argument %lu, operand %lu)",
	(unsigned long) attr_arg_num, (unsigned long) arg_num);
	*no_add_attrs = true;
	return NULL_TREE;
	}
	}
	}

	return NULL_TREE;
	}

	/* Check the argument list of a function call for null in argument slots
	that are marked as requiring a non-null pointer argument. */

	static void
	check_function_nonnull (tree attrs, tree params)
	{
	tree a, args, param;
	int param_num;

	for (a = attrs; a; a = TREE_CHAIN (a))
	{
	if (is_attribute_p ("nonnull", TREE_PURPOSE (a)))
	{
	args = TREE_VALUE (a);

	/* Walk the argument list. If we encounter an argument number we
	should check for non-null, do it. If the attribute has no args,
	then every pointer argument is checked (in which case the check
	for pointer type is done in check_nonnull_arg). */
	for (param = params, param_num = 1; ;
	param_num++, param = TREE_CHAIN (param))
	{
	if (!param)
	break;
	if (!args \|\| nonnull_check_p (args, param_num))
	check_function_arguments_recurse (check_nonnull_arg, NULL,
	TREE_VALUE (param),
	param_num);
	}
	}
	}
	}

	/* Check that the Nth argument of a function call (counting backwards
	from the end) is a (pointer)0. */

	static void
	check_function_sentinel (tree attrs, tree params, tree typelist)
	{
	tree attr = lookup_attribute ("sentinel", attrs);

	if (attr)
	{
	/* Skip over the named arguments. */
	while (typelist && params)
	{
	typelist = TREE_CHAIN (typelist);
	params = TREE_CHAIN (params);
	}

	if (typelist \|\| !params)
	warning (OPT_Wformat,
	"not enough variable arguments to fit a sentinel");
	else
	{
	tree sentinel, end;
	unsigned pos = 0;

	if (TREE_VALUE (attr))
	{
	tree p = TREE_VALUE (TREE_VALUE (attr));
	pos = TREE_INT_CST_LOW (p);
	}

	sentinel = end = params;

	/* Advance `end' ahead of `sentinel' by `pos' positions. */
	while (pos > 0 && TREE_CHAIN (end))
	{
	pos--;
	end = TREE_CHAIN (end);
	}
	if (pos > 0)
	{
	warning (OPT_Wformat,
	"not enough variable arguments to fit a sentinel");
	return;
	}

	/* Now advance both until we find the last parameter. */
	while (TREE_CHAIN (end))
	{
	end = TREE_CHAIN (end);
	sentinel = TREE_CHAIN (sentinel);
	}

	/* Validate the sentinel. */
	if ((!POINTER_TYPE_P (TREE_TYPE (TREE_VALUE (sentinel)))
	\|\| !integer_zerop (TREE_VALUE (sentinel)))
	/* Although __null (in C++) is only an integer we allow it
	nevertheless, as we are guaranteed that it's exactly
	as wide as a pointer, and we don't want to force
	users to cast the NULL they have written there.
	We warn with -Wstrict-null-sentinel, though. */
	&& (warn_strict_null_sentinel
	\|\| null_node != TREE_VALUE (sentinel)))
	warning (OPT_Wformat, "missing sentinel in function call");
	}
	}
	}

	/* Helper for check_function_nonnull; given a list of operands which
	must be non-null in ARGS, determine if operand PARAM_NUM should be
	checked. */

	static bool
	nonnull_check_p (tree args, unsigned HOST_WIDE_INT param_num)
	{
	unsigned HOST_WIDE_INT arg_num = 0;

	for (; args; args = TREE_CHAIN (args))
	{
	bool found = get_nonnull_operand (TREE_VALUE (args), &arg_num);

	gcc_assert (found);

	if (arg_num == param_num)
	return true;
	}
	return false;
	}

	/* Check that the function argument PARAM (which is operand number
	PARAM_NUM) is non-null. This is called by check_function_nonnull
	via check_function_arguments_recurse. */

	static void
	check_nonnull_arg (void * ARG_UNUSED (ctx), tree param,
	unsigned HOST_WIDE_INT param_num)
	{
	/* Just skip checking the argument if it's not a pointer. This can
	happen if the "nonnull" attribute was given without an operand
	list (which means to check every pointer argument). */

	if (TREE_CODE (TREE_TYPE (param)) != POINTER_TYPE)
	return;

	if (integer_zerop (param))
	warning (OPT_Wnonnull, "null argument where non-null required "
	"(argument %lu)", (unsigned long) param_num);
	}

	/* Helper for nonnull attribute handling; fetch the operand number
	from the attribute argument list. */

	static bool
	get_nonnull_operand (tree arg_num_expr, unsigned HOST_WIDE_INT *valp)
	{
	/* Verify the arg number is a constant. */
	if (TREE_CODE (arg_num_expr) != INTEGER_CST
	\|\| TREE_INT_CST_HIGH (arg_num_expr) != 0)
	return false;

	*valp = TREE_INT_CST_LOW (arg_num_expr);
	return true;
	}

	/* Handle a "nothrow" attribute; arguments as in
	struct attribute_spec.handler. */

	static tree
	handle_nothrow_attribute (tree *node, tree name, tree ARG_UNUSED (args),
	int ARG_UNUSED (flags), bool *no_add_attrs)
	{
	if (TREE_CODE (*node) == FUNCTION_DECL)
	TREE_NOTHROW (*node) = 1;
	/* ??? TODO: Support types. */
	else
	{
	warning (OPT_Wattributes, "%qE attribute ignored", name);
	*no_add_attrs = true;
	}

	return NULL_TREE;
	}

	/* Handle a "cleanup" attribute; arguments as in
	struct attribute_spec.handler. */

	static tree
	handle_cleanup_attribute (tree *node, tree name, tree args,
	int ARG_UNUSED (flags), bool *no_add_attrs)
	{
	tree decl = *node;
	tree cleanup_id, cleanup_decl;

	/* ??? Could perhaps support cleanups on TREE_STATIC, much like we do
	for global destructors in C++. This requires infrastructure that
	we don't have generically at the moment. It's also not a feature
	we'd be missing too much, since we do have attribute constructor. */
	if (TREE_CODE (decl) != VAR_DECL \|\| TREE_STATIC (decl))
	{
	warning (OPT_Wattributes, "%qE attribute ignored", name);
	*no_add_attrs = true;
	return NULL_TREE;
	}

	/* Verify that the argument is a function in scope. */
	/* ??? We could support pointers to functions here as well, if
	that was considered desirable. */
	cleanup_id = TREE_VALUE (args);
	if (TREE_CODE (cleanup_id) != IDENTIFIER_NODE)
	{
	error ("cleanup argument not an identifier");
	*no_add_attrs = true;
	return NULL_TREE;
	}
	cleanup_decl = lookup_name (cleanup_id);
	if (!cleanup_decl \|\| TREE_CODE (cleanup_decl) != FUNCTION_DECL)
	{
	error ("cleanup argument not a function");
	*no_add_attrs = true;
	return NULL_TREE;
	}

	/* That the function has proper type is checked with the
	eventual call to build_function_call. */

	return NULL_TREE;
	}

	/* Handle a "warn_unused_result" attribute. No special handling. */

	static tree
	handle_warn_unused_result_attribute (tree *node, tree name,
	tree ARG_UNUSED (args),
	int ARG_UNUSED (flags), bool *no_add_attrs)
	{
	/* Ignore the attribute for functions not returning any value. */
	if (VOID_TYPE_P (TREE_TYPE (*node)))
	{
	warning (OPT_Wattributes, "%qE attribute ignored", name);
	*no_add_attrs = true;
	}

	return NULL_TREE;
	}

	/* Handle a "sentinel" attribute. */

	static tree
	handle_sentinel_attribute (tree *node, tree name, tree args,
	int ARG_UNUSED (flags), bool *no_add_attrs)
	{
	tree params = TYPE_ARG_TYPES (*node);

	if (!params)
	{
	warning (OPT_Wattributes,
	"%qE attribute requires prototypes with named arguments", name);
	*no_add_attrs = true;
	}
	else
	{
	while (TREE_CHAIN (params))
	params = TREE_CHAIN (params);

	if (VOID_TYPE_P (TREE_VALUE (params)))
	{
	warning (OPT_Wattributes,
	"%qE attribute only applies to variadic functions", name);
	*no_add_attrs = true;
	}
	}

	if (args)
	{
	tree position = TREE_VALUE (args);

	if (TREE_CODE (position) != INTEGER_CST)
	{
	warning (0, "requested position is not an integer constant");
	*no_add_attrs = true;
	}
	else
	{
	if (tree_int_cst_lt (position, integer_zero_node))
	{
	warning (0, "requested position is less than zero");
	*no_add_attrs = true;
	}
	}
	}

	return NULL_TREE;
	}

	/* Check for valid arguments being passed to a function. */
	void
	check_function_arguments (tree attrs, tree params, tree typelist)
	{
	/* Check for null being passed in a pointer argument that must be
	non-null. We also need to do this if format checking is enabled. */

	if (warn_nonnull)
	check_function_nonnull (attrs, params);

	/* Check for errors in format strings. */

	if (warn_format \|\| warn_missing_format_attribute)
	check_function_format (attrs, params);

	if (warn_format)
	check_function_sentinel (attrs, params, typelist);
	}

	/* Generic argument checking recursion routine. PARAM is the argument to
	be checked. PARAM_NUM is the number of the argument. CALLBACK is invoked
	once the argument is resolved. CTX is context for the callback. */
	void
	check_function_arguments_recurse (void (*callback)
	(void *, tree, unsigned HOST_WIDE_INT),
	void *ctx, tree param,
	unsigned HOST_WIDE_INT param_num)
	{
	if ((TREE_CODE (param) == NOP_EXPR \|\| TREE_CODE (param) == CONVERT_EXPR)
	&& (TYPE_PRECISION (TREE_TYPE (param))
	== TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (param, 0)))))
	{
	/* Strip coercion. */
	check_function_arguments_recurse (callback, ctx,
	TREE_OPERAND (param, 0), param_num);
	return;
	}

	if (TREE_CODE (param) == CALL_EXPR)
	{
	tree type = TREE_TYPE (TREE_TYPE (TREE_OPERAND (param, 0)));
	tree attrs;
	bool found_format_arg = false;

	/* See if this is a call to a known internationalization function
	that modifies a format arg. Such a function may have multiple
	format_arg attributes (for example, ngettext). */

	for (attrs = TYPE_ATTRIBUTES (type);
	attrs;
	attrs = TREE_CHAIN (attrs))
	if (is_attribute_p ("format_arg", TREE_PURPOSE (attrs)))
	{
	tree inner_args;
	tree format_num_expr;
	int format_num;
	int i;

	/* Extract the argument number, which was previously checked
	to be valid. */
	format_num_expr = TREE_VALUE (TREE_VALUE (attrs));

	gcc_assert (TREE_CODE (format_num_expr) == INTEGER_CST
	&& !TREE_INT_CST_HIGH (format_num_expr));

	format_num = TREE_INT_CST_LOW (format_num_expr);

	for (inner_args = TREE_OPERAND (param, 1), i = 1;
	inner_args != 0;
	inner_args = TREE_CHAIN (inner_args), i++)
	if (i == format_num)
	{
	check_function_arguments_recurse (callback, ctx,
	TREE_VALUE (inner_args),
	param_num);
	found_format_arg = true;
	break;
	}
	}

	/* If we found a format_arg attribute and did a recursive check,
	we are done with checking this argument. Otherwise, we continue
	and this will be considered a non-literal. */
	if (found_format_arg)
	return;
	}

	if (TREE_CODE (param) == COND_EXPR)
	{
	/* Check both halves of the conditional expression. */
	check_function_arguments_recurse (callback, ctx,
	TREE_OPERAND (param, 1), param_num);
	check_function_arguments_recurse (callback, ctx,
	TREE_OPERAND (param, 2), param_num);
	return;
	}

	(*callback) (ctx, param, param_num);
	}

	/* Function to help qsort sort FIELD_DECLs by name order. */

	int
	field_decl_cmp (const void x_p, const void y_p)
	{
	const tree const x = (const tree const) x_p;
	const tree const y = (const tree const) y_p;

	if (DECL_NAME (x) == DECL_NAME (y))
	/* A nontype is "greater" than a type. */
	return (TREE_CODE (y) == TYPE_DECL) - (TREE_CODE (x) == TYPE_DECL);
	if (DECL_NAME (*x) == NULL_TREE)
	return -1;
	if (DECL_NAME (*y) == NULL_TREE)
	return 1;
	if (DECL_NAME (x) < DECL_NAME (y))
	return -1;
	return 1;
	}

	static struct {
	gt_pointer_operator new_value;
	void *cookie;
	} resort_data;

	/* This routine compares two fields like field_decl_cmp but using the
	pointer operator in resort_data. */

	static int
	resort_field_decl_cmp (const void x_p, const void y_p)
	{
	const tree const x = (const tree const) x_p;
	const tree const y = (const tree const) y_p;

	if (DECL_NAME (x) == DECL_NAME (y))
	/* A nontype is "greater" than a type. */
	return (TREE_CODE (y) == TYPE_DECL) - (TREE_CODE (x) == TYPE_DECL);
	if (DECL_NAME (*x) == NULL_TREE)
	return -1;
	if (DECL_NAME (*y) == NULL_TREE)
	return 1;
	{
	tree d1 = DECL_NAME (*x);
	tree d2 = DECL_NAME (*y);
	resort_data.new_value (&d1, resort_data.cookie);
	resort_data.new_value (&d2, resort_data.cookie);
	if (d1 < d2)
	return -1;
	}
	return 1;
	}

	/* Resort DECL_SORTED_FIELDS because pointers have been reordered. */

	void
	resort_sorted_fields (void *obj,
	void * ARG_UNUSED (orig_obj),
	gt_pointer_operator new_value,
	void *cookie)
	{
	struct sorted_fields_type sf = (struct sorted_fields_type ) obj;
	resort_data.new_value = new_value;
	resort_data.cookie = cookie;
	qsort (&sf->elts[0], sf->len, sizeof (tree),
	resort_field_decl_cmp);
	}

	/* Subroutine of c_parse_error.
	Return the result of concatenating LHS and RHS. RHS is really
	a string literal, its first character is indicated by RHS_START and
	RHS_SIZE is its length (including the terminating NUL character).

	The caller is responsible for deleting the returned pointer. */

	static char *
	catenate_strings (const char lhs, const char rhs_start, int rhs_size)
	{
	const int lhs_size = strlen (lhs);
	char *result = XNEWVEC (char, lhs_size + rhs_size);
	strncpy (result, lhs, lhs_size);
	strncpy (result + lhs_size, rhs_start, rhs_size);
	return result;
	}

	/* Issue the error given by GMSGID, indicating that it occurred before
	TOKEN, which had the associated VALUE. */

	void
	c_parse_error (const char *gmsgid, enum cpp_ttype token, tree value)
	{
	#define catenate_messages(M1, M2) catenate_strings ((M1), (M2), sizeof (M2))

	char *message = NULL;

	if (token == CPP_EOF)
	message = catenate_messages (gmsgid, " at end of input");
	else if (token == CPP_CHAR \|\| token == CPP_WCHAR)
	{
	unsigned int val = TREE_INT_CST_LOW (value);
	const char *const ell = (token == CPP_CHAR) ? "" : "L";
	if (val <= UCHAR_MAX && ISGRAPH (val))
	message = catenate_messages (gmsgid, " before %s'%c'");
	else
	message = catenate_messages (gmsgid, " before %s'\\x%x'");

	error (message, ell, val);
	free (message);
	message = NULL;
	}
	else if (token == CPP_STRING \|\| token == CPP_WSTRING)
	message = catenate_messages (gmsgid, " before string constant");
	else if (token == CPP_NUMBER)
	message = catenate_messages (gmsgid, " before numeric constant");
	else if (token == CPP_NAME)
	{
	message = catenate_messages (gmsgid, " before %qE");
	error (message, value);
	free (message);
	message = NULL;
	}
	else if (token == CPP_PRAGMA)
	message = catenate_messages (gmsgid, " before %<#pragma%>");
	else if (token == CPP_PRAGMA_EOL)
	message = catenate_messages (gmsgid, " before end of line");
	else if (token < N_TTYPES)
	{
	message = catenate_messages (gmsgid, " before %qs token");
	error (message, cpp_type2name (token));
	free (message);
	message = NULL;
	}
	else
	error (gmsgid, "");

	if (message)
	{
	error (message, "");
	free (message);
	}
	#undef catenate_messages
	}

	/* Walk a gimplified function and warn for functions whose return value is
	ignored and attribute((warn_unused_result)) is set. This is done before
	inlining, so we don't have to worry about that. */

	void
	c_warn_unused_result (tree *top_p)
	{
	tree t = *top_p;
	tree_stmt_iterator i;
	tree fdecl, ftype;

	switch (TREE_CODE (t))
	{
	case STATEMENT_LIST:
	for (i = tsi_start (*top_p); !tsi_end_p (i); tsi_next (&i))
	c_warn_unused_result (tsi_stmt_ptr (i));
	break;

	case COND_EXPR:
	c_warn_unused_result (&COND_EXPR_THEN (t));
	c_warn_unused_result (&COND_EXPR_ELSE (t));
	break;
	case BIND_EXPR:
	c_warn_unused_result (&BIND_EXPR_BODY (t));
	break;
	case TRY_FINALLY_EXPR:
	case TRY_CATCH_EXPR:
	c_warn_unused_result (&TREE_OPERAND (t, 0));
	c_warn_unused_result (&TREE_OPERAND (t, 1));
	break;
	case CATCH_EXPR:
	c_warn_unused_result (&CATCH_BODY (t));
	break;
	case EH_FILTER_EXPR:
	c_warn_unused_result (&EH_FILTER_FAILURE (t));
	break;

	case CALL_EXPR:
	if (TREE_USED (t))
	break;

	/* This is a naked call, as opposed to a CALL_EXPR nested inside
	a MODIFY_EXPR. All calls whose value is ignored should be
	represented like this. Look for the attribute. */
	fdecl = get_callee_fndecl (t);
	if (fdecl)
	ftype = TREE_TYPE (fdecl);
	else
	{
	ftype = TREE_TYPE (TREE_OPERAND (t, 0));
	/* Look past pointer-to-function to the function type itself. */
	ftype = TREE_TYPE (ftype);
	}

	if (lookup_attribute ("warn_unused_result", TYPE_ATTRIBUTES (ftype)))
	{
	if (fdecl)
	warning (0, "%Hignoring return value of %qD, "
	"declared with attribute warn_unused_result",
	EXPR_LOCUS (t), fdecl);
	else
	warning (0, "%Hignoring return value of function "
	"declared with attribute warn_unused_result",
	EXPR_LOCUS (t));
	}
	break;

	default:
	/* Not a container, not a call, or a call whose value is used. */
	break;
	}
	}

	/* Convert a character from the host to the target execution character
	set. cpplib handles this, mostly. */

	HOST_WIDE_INT
	c_common_to_target_charset (HOST_WIDE_INT c)
	{
	/* Character constants in GCC proper are sign-extended under -fsigned-char,
	zero-extended under -fno-signed-char. cpplib insists that characters
	and character constants are always unsigned. Hence we must convert
	back and forth. */
	cppchar_t uc = ((cppchar_t)c) & ((((cppchar_t)1) << CHAR_BIT)-1);

	uc = cpp_host_to_exec_charset (parse_in, uc);

	if (flag_signed_char)
	return ((HOST_WIDE_INT)uc) << (HOST_BITS_PER_WIDE_INT - CHAR_TYPE_SIZE)
	>> (HOST_BITS_PER_WIDE_INT - CHAR_TYPE_SIZE);
	else
	return uc;
	}

	/* Build the result of __builtin_offsetof. EXPR is a nested sequence of
	component references, with STOP_REF, or alternatively an INDIRECT_REF of
	NULL, at the bottom; much like the traditional rendering of offsetof as a
	macro. Returns the folded and properly cast result. */

	static tree
	fold_offsetof_1 (tree expr, tree stop_ref)
	{
	enum tree_code code = PLUS_EXPR;
	tree base, off, t;

	if (expr == stop_ref && TREE_CODE (expr) != ERROR_MARK)
	return size_zero_node;

	switch (TREE_CODE (expr))
	{
	case ERROR_MARK:
	return expr;

	case VAR_DECL:
	error ("cannot apply %<offsetof%> to static data member %qD", expr);
	return error_mark_node;

	case CALL_EXPR:
	error ("cannot apply %<offsetof%> when %<operator[]%> is overloaded");
	return error_mark_node;

	case INTEGER_CST:
	gcc_assert (integer_zerop (expr));
	return size_zero_node;

	case NOP_EXPR:
	case INDIRECT_REF:
	base = fold_offsetof_1 (TREE_OPERAND (expr, 0), stop_ref);
	gcc_assert (base == error_mark_node \|\| base == size_zero_node);
	return base;

	case COMPONENT_REF:
	base = fold_offsetof_1 (TREE_OPERAND (expr, 0), stop_ref);
	if (base == error_mark_node)
	return base;

	t = TREE_OPERAND (expr, 1);
	if (DECL_C_BIT_FIELD (t))
	{
	error ("attempt to take address of bit-field structure "
	"member %qD", t);
	return error_mark_node;
	}
	off = size_binop (PLUS_EXPR, DECL_FIELD_OFFSET (t),
	size_int (tree_low_cst (DECL_FIELD_BIT_OFFSET (t), 1)
	/ BITS_PER_UNIT));
	break;

	case ARRAY_REF:
	base = fold_offsetof_1 (TREE_OPERAND (expr, 0), stop_ref);
	if (base == error_mark_node)
	return base;

	t = TREE_OPERAND (expr, 1);
	if (TREE_CODE (t) == INTEGER_CST && tree_int_cst_sgn (t) < 0)
	{
	code = MINUS_EXPR;
	t = fold_build1 (NEGATE_EXPR, TREE_TYPE (t), t);
	}
	t = convert (sizetype, t);
	off = size_binop (MULT_EXPR, TYPE_SIZE_UNIT (TREE_TYPE (expr)), t);
	break;

	case COMPOUND_EXPR:
	/* Handle static members of volatile structs. */
	t = TREE_OPERAND (expr, 1);
	gcc_assert (TREE_CODE (t) == VAR_DECL);
	return fold_offsetof_1 (t, stop_ref);

	default:
	gcc_unreachable ();
	}

	return size_binop (code, base, off);
	}

	tree
	fold_offsetof (tree expr, tree stop_ref)
	{
	/* Convert back from the internal sizetype to size_t. */
	return convert (size_type_node, fold_offsetof_1 (expr, stop_ref));
	}

	/* Print an error message for an invalid lvalue. USE says
	how the lvalue is being used and so selects the error message. */

	void
	lvalue_error (enum lvalue_use use)
	{
	switch (use)
	{
	case lv_assign:
	error ("lvalue required as left operand of assignment");
	break;
	case lv_increment:
	error ("lvalue required as increment operand");
	break;
	case lv_decrement:
	error ("lvalue required as decrement operand");
	break;
	case lv_addressof:
	error ("lvalue required as unary %<&%> operand");
	break;
	case lv_asm:
	error ("lvalue required in asm statement");
	break;
	default:
	gcc_unreachable ();
	}
	}

	/* *PTYPE is an incomplete array. Complete it with a domain based on
	INITIAL_VALUE. If INITIAL_VALUE is not present, use 1 if DO_DEFAULT
	is true. Return 0 if successful, 1 if INITIAL_VALUE can't be deciphered,
	2 if INITIAL_VALUE was NULL, and 3 if INITIAL_VALUE was empty. */

	int
	complete_array_type (tree *ptype, tree initial_value, bool do_default)
	{
	tree maxindex, type, main_type, elt, unqual_elt;
	int failure = 0, quals;

	maxindex = size_zero_node;
	if (initial_value)
	{
	if (TREE_CODE (initial_value) == STRING_CST)
	{
	int eltsize
	= int_size_in_bytes (TREE_TYPE (TREE_TYPE (initial_value)));
	maxindex = size_int (TREE_STRING_LENGTH (initial_value)/eltsize - 1);
	}
	else if (TREE_CODE (initial_value) == CONSTRUCTOR)
	{
	VEC(constructor_elt,gc) *v = CONSTRUCTOR_ELTS (initial_value);

	if (VEC_empty (constructor_elt, v))
	{
	if (pedantic)
	failure = 3;
	maxindex = integer_minus_one_node;
	}
	else
	{
	tree curindex;
	unsigned HOST_WIDE_INT cnt;
	constructor_elt *ce;

	if (VEC_index (constructor_elt, v, 0)->index)
	maxindex = fold_convert (sizetype,
	VEC_index (constructor_elt,
	v, 0)->index);
	curindex = maxindex;

	for (cnt = 1;
	VEC_iterate (constructor_elt, v, cnt, ce);
	cnt++)
	{
	if (ce->index)
	curindex = fold_convert (sizetype, ce->index);
	else
	curindex = size_binop (PLUS_EXPR, curindex, size_one_node);

	if (tree_int_cst_lt (maxindex, curindex))
	maxindex = curindex;
	}
	}
	}
	else
	{
	/* Make an error message unless that happened already. */
	if (initial_value != error_mark_node)
	failure = 1;
	}
	}
	else
	{
	failure = 2;
	if (!do_default)
	return failure;
	}

	type = *ptype;
	elt = TREE_TYPE (type);
	quals = TYPE_QUALS (strip_array_types (elt));
	if (quals == 0)
	unqual_elt = elt;
	else
	unqual_elt = c_build_qualified_type (elt, TYPE_UNQUALIFIED);

	/* Using build_distinct_type_copy and modifying things afterward instead
	of using build_array_type to create a new type preserves all of the
	TYPE_LANG_FLAG_? bits that the front end may have set. */
	main_type = build_distinct_type_copy (TYPE_MAIN_VARIANT (type));
	TREE_TYPE (main_type) = unqual_elt;
	TYPE_DOMAIN (main_type) = build_index_type (maxindex);
	layout_type (main_type);

	if (quals == 0)
	type = main_type;
	else
	type = c_build_qualified_type (main_type, quals);

	*ptype = type;
	return failure;
	}


	/* Used to help initialize the builtin-types.def table. When a type of
	the correct size doesn't exist, use error_mark_node instead of NULL.
	The later results in segfaults even when a decl using the type doesn't
	get invoked. */

	tree
	builtin_type_for_size (int size, bool unsignedp)
	{
	tree type = lang_hooks.types.type_for_size (size, unsignedp);
	return type ? type : error_mark_node;
	}

	/* A helper function for resolve_overloaded_builtin in resolving the
	overloaded __sync_ builtins. Returns a positive power of 2 if the
	first operand of PARAMS is a pointer to a supported data type.
	Returns 0 if an error is encountered. */

	static int
	sync_resolve_size (tree function, tree params)
	{
	tree type;
	int size;

	if (params == NULL)
	{
	error ("too few arguments to function %qE", function);
	return 0;
	}

	type = TREE_TYPE (TREE_VALUE (params));
	if (TREE_CODE (type) != POINTER_TYPE)
	goto incompatible;

	type = TREE_TYPE (type);
	if (!INTEGRAL_TYPE_P (type) && !POINTER_TYPE_P (type))
	goto incompatible;

	size = tree_low_cst (TYPE_SIZE_UNIT (type), 1);
	if (size == 1 \|\| size == 2 \|\| size == 4 \|\| size == 8 \|\| size == 16)
	return size;

	incompatible:
	error ("incompatible type for argument %d of %qE", 1, function);
	return 0;
	}

	/* A helper function for resolve_overloaded_builtin. Adds casts to
	PARAMS to make arguments match up with those of FUNCTION. Drops
	the variadic arguments at the end. Returns false if some error
	was encountered; true on success. */

	static bool
	sync_resolve_params (tree orig_function, tree function, tree params)
	{
	tree arg_types = TYPE_ARG_TYPES (TREE_TYPE (function));
	tree ptype;
	int number;

	/* We've declared the implementation functions to use "volatile void *"
	as the pointer parameter, so we shouldn't get any complaints from the
	call to check_function_arguments what ever type the user used. */
	arg_types = TREE_CHAIN (arg_types);
	ptype = TREE_TYPE (TREE_TYPE (TREE_VALUE (params)));
	number = 2;

	/* For the rest of the values, we need to cast these to FTYPE, so that we
	don't get warnings for passing pointer types, etc. */
	while (arg_types != void_list_node)
	{
	tree val;

	params = TREE_CHAIN (params);
	if (params == NULL)
	{
	error ("too few arguments to function %qE", orig_function);
	return false;
	}

	/* ??? Ideally for the first conversion we'd use convert_for_assignment
	so that we get warnings for anything that doesn't match the pointer
	type. This isn't portable across the C and C++ front ends atm. */
	val = TREE_VALUE (params);
	val = convert (ptype, val);
	val = convert (TREE_VALUE (arg_types), val);
	TREE_VALUE (params) = val;

	arg_types = TREE_CHAIN (arg_types);
	number++;
	}

	/* The definition of these primitives is variadic, with the remaining
	being "an optional list of variables protected by the memory barrier".
	No clue what that's supposed to mean, precisely, but we consider all
	call-clobbered variables to be protected so we're safe. */
	TREE_CHAIN (params) = NULL;

	return true;
	}

	/* A helper function for resolve_overloaded_builtin. Adds a cast to
	RESULT to make it match the type of the first pointer argument in
	PARAMS. */

	static tree
	sync_resolve_return (tree params, tree result)
	{
	tree ptype = TREE_TYPE (TREE_TYPE (TREE_VALUE (params)));
	ptype = TYPE_MAIN_VARIANT (ptype);
	return convert (ptype, result);
	}

	/* Some builtin functions are placeholders for other expressions. This
	function should be called immediately after parsing the call expression
	before surrounding code has committed to the type of the expression.

	FUNCTION is the DECL that has been invoked; it is known to be a builtin.
	PARAMS is the argument list for the call. The return value is non-null
	when expansion is complete, and null if normal processing should
	continue. */

	tree
	resolve_overloaded_builtin (tree function, tree params)
	{
	enum built_in_function orig_code = DECL_FUNCTION_CODE (function);
	switch (DECL_BUILT_IN_CLASS (function))
	{
	case BUILT_IN_NORMAL:
	break;
	case BUILT_IN_MD:
	if (targetm.resolve_overloaded_builtin)
	return targetm.resolve_overloaded_builtin (function, params);
	else
	return NULL_TREE;
	default:
	return NULL_TREE;
	}

	/* Handle BUILT_IN_NORMAL here. */
	switch (orig_code)
	{
	case BUILT_IN_FETCH_AND_ADD_N:
	case BUILT_IN_FETCH_AND_SUB_N:
	case BUILT_IN_FETCH_AND_OR_N:
	case BUILT_IN_FETCH_AND_AND_N:
	case BUILT_IN_FETCH_AND_XOR_N:
	case BUILT_IN_FETCH_AND_NAND_N:
	case BUILT_IN_ADD_AND_FETCH_N:
	case BUILT_IN_SUB_AND_FETCH_N:
	case BUILT_IN_OR_AND_FETCH_N:
	case BUILT_IN_AND_AND_FETCH_N:
	case BUILT_IN_XOR_AND_FETCH_N:
	case BUILT_IN_NAND_AND_FETCH_N:
	case BUILT_IN_BOOL_COMPARE_AND_SWAP_N:
	case BUILT_IN_VAL_COMPARE_AND_SWAP_N:
	case BUILT_IN_LOCK_TEST_AND_SET_N:
	case BUILT_IN_LOCK_RELEASE_N:
	{
	int n = sync_resolve_size (function, params);
	tree new_function, result;

	if (n == 0)
	return error_mark_node;

	new_function = built_in_decls[orig_code + exact_log2 (n) + 1];
	if (!sync_resolve_params (function, new_function, params))
	return error_mark_node;

	result = build_function_call (new_function, params);
	if (orig_code != BUILT_IN_BOOL_COMPARE_AND_SWAP_N
	&& orig_code != BUILT_IN_LOCK_RELEASE_N)
	result = sync_resolve_return (params, result);

	return result;
	}

	default:
	return NULL_TREE;
	}
	}

	/* Ignoring their sign, return true if two scalar types are the same. */
	bool
	same_scalar_type_ignoring_signedness (tree t1, tree t2)
	{
	enum tree_code c1 = TREE_CODE (t1), c2 = TREE_CODE (t2);

	gcc_assert ((c1 == INTEGER_TYPE \|\| c1 == REAL_TYPE)
	&& (c2 == INTEGER_TYPE \|\| c2 == REAL_TYPE));

	/* Equality works here because c_common_signed_type uses
	TYPE_MAIN_VARIANT. */
	return lang_hooks.types.signed_type (t1)
	== lang_hooks.types.signed_type (t2);
	}

	/* Check for missing format attributes on function pointers. LTYPE is
	the new type or left-hand side type. RTYPE is the old type or
	right-hand side type. Returns TRUE if LTYPE is missing the desired
	attribute. */

	bool
	check_missing_format_attribute (tree ltype, tree rtype)
	{
	tree const ttr = TREE_TYPE (rtype), ttl = TREE_TYPE (ltype);
	tree ra;

	for (ra = TYPE_ATTRIBUTES (ttr); ra; ra = TREE_CHAIN (ra))
	if (is_attribute_p ("format", TREE_PURPOSE (ra)))
	break;
	if (ra)
	{
	tree la;
	for (la = TYPE_ATTRIBUTES (ttl); la; la = TREE_CHAIN (la))
	if (is_attribute_p ("format", TREE_PURPOSE (la)))
	break;
	return !la;
	}
	else
	return false;
	}

	/* Subscripting with type char is likely to lose on a machine where
	chars are signed. So warn on any machine, but optionally. Don't
	warn for unsigned char since that type is safe. Don't warn for
	signed char because anyone who uses that must have done so
	deliberately. Furthermore, we reduce the false positive load by
	warning only for non-constant value of type char. */

	void
	warn_array_subscript_with_type_char (tree index)
	{
	if (TYPE_MAIN_VARIANT (TREE_TYPE (index)) == char_type_node
	&& TREE_CODE (index) != INTEGER_CST)
	warning (OPT_Wchar_subscripts, "array subscript has type %<char%>");
	}

	/* Implement -Wparentheses for the unexpected C precedence rules, to
	cover cases like x + y << z which readers are likely to
	misinterpret. We have seen an expression in which CODE is a binary
	operator used to combine expressions headed by CODE_LEFT and
	CODE_RIGHT. CODE_LEFT and CODE_RIGHT may be ERROR_MARK, which
	means that that side of the expression was not formed using a
	binary operator, or it was enclosed in parentheses. */

	void
	warn_about_parentheses (enum tree_code code, enum tree_code code_left,
	enum tree_code code_right)
	{
	if (!warn_parentheses)
	return;

	if (code == LSHIFT_EXPR \|\| code == RSHIFT_EXPR)
	{
	if (code_left == PLUS_EXPR \|\| code_left == MINUS_EXPR
	\|\| code_right == PLUS_EXPR \|\| code_right == MINUS_EXPR)
	warning (OPT_Wparentheses,
	"suggest parentheses around + or - inside shift");
	}

	if (code == TRUTH_ORIF_EXPR)
	{
	if (code_left == TRUTH_ANDIF_EXPR
	\|\| code_right == TRUTH_ANDIF_EXPR)
	warning (OPT_Wparentheses,
	"suggest parentheses around && within \|\|");
	}

	if (code == BIT_IOR_EXPR)
	{
	if (code_left == BIT_AND_EXPR \|\| code_left == BIT_XOR_EXPR
	\|\| code_left == PLUS_EXPR \|\| code_left == MINUS_EXPR
	\|\| code_right == BIT_AND_EXPR \|\| code_right == BIT_XOR_EXPR
	\|\| code_right == PLUS_EXPR \|\| code_right == MINUS_EXPR)
	warning (OPT_Wparentheses,
	"suggest parentheses around arithmetic in operand of \|");
	/* Check cases like x\|y==z */
	if (TREE_CODE_CLASS (code_left) == tcc_comparison
	\|\| TREE_CODE_CLASS (code_right) == tcc_comparison)
	warning (OPT_Wparentheses,
	"suggest parentheses around comparison in operand of \|");
	}

	if (code == BIT_XOR_EXPR)
	{
	if (code_left == BIT_AND_EXPR
	\|\| code_left == PLUS_EXPR \|\| code_left == MINUS_EXPR
	\|\| code_right == BIT_AND_EXPR
	\|\| code_right == PLUS_EXPR \|\| code_right == MINUS_EXPR)
	warning (OPT_Wparentheses,
	"suggest parentheses around arithmetic in operand of ^");
	/* Check cases like x^y==z */
	if (TREE_CODE_CLASS (code_left) == tcc_comparison
	\|\| TREE_CODE_CLASS (code_right) == tcc_comparison)
	warning (OPT_Wparentheses,
	"suggest parentheses around comparison in operand of ^");
	}

	if (code == BIT_AND_EXPR)
	{
	if (code_left == PLUS_EXPR \|\| code_left == MINUS_EXPR
	\|\| code_right == PLUS_EXPR \|\| code_right == MINUS_EXPR)
	warning (OPT_Wparentheses,
	"suggest parentheses around + or - in operand of &");
	/* Check cases like x&y==z */
	if (TREE_CODE_CLASS (code_left) == tcc_comparison
	\|\| TREE_CODE_CLASS (code_right) == tcc_comparison)
	warning (OPT_Wparentheses,
	"suggest parentheses around comparison in operand of &");
	}

	/* Similarly, check for cases like 1<=i<=10 that are probably errors. */
	if (TREE_CODE_CLASS (code) == tcc_comparison
	&& (TREE_CODE_CLASS (code_left) == tcc_comparison
	\|\| TREE_CODE_CLASS (code_right) == tcc_comparison))
	warning (OPT_Wparentheses, "comparisons like X<=Y<=Z do not "
	"have their mathematical meaning");
	}


	#include "gt-c-common.h"
	diff --git a/contrib/gcc/c-decl.c b/contrib/gcc/c-decl.c
	index 3cdd69b3d2a1..7b3833c384aa 100644
	--- a/contrib/gcc/c-decl.c
	+++ b/contrib/gcc/c-decl.c
	@@ -1,8081 +1,8134 @@
	/* Process declarations and variables for C compiler.
	Copyright (C) 1988, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
	2001, 2002, 2003, 2004, 2005, 2006, 2007 Free Software Foundation, Inc.

	This file is part of GCC.

	GCC is free software; you can redistribute it and/or modify it under
	the terms of the GNU General Public License as published by the Free
	Software Foundation; either version 2, or (at your option) any later
	version.

	GCC is distributed in the hope that it will be useful, but WITHOUT ANY
	WARRANTY; without even the implied warranty of MERCHANTABILITY or
	FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	for more details.

	You should have received a copy of the GNU General Public License
	along with GCC; see the file COPYING. If not, write to the Free
	Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
	02110-1301, USA. */

	/* $FreeBSD$ */
	/* Merged C99 inline changes from gcc trunk 122565 2007-03-05 */
	/* Fixed problems with compiling inline-25.c and inline-26.c */
	/* XXX still fails inline-29.c, inline-31.c, and inline-32.c */

	/* Process declarations and symbol lookup for C front end.
	Also constructs types; the standard scalar types at initialization,
	and structure, union, array and enum types when they are declared. */

	/* ??? not all decl nodes are given the most useful possible
	line numbers. For example, the CONST_DECLs for enum values. */

	#include "config.h"
	#include "system.h"
	#include "coretypes.h"
	#include "input.h"
	#include "tm.h"
	#include "intl.h"
	#include "tree.h"
	#include "tree-inline.h"
	#include "rtl.h"
	#include "flags.h"
	#include "function.h"
	#include "output.h"
	#include "expr.h"
	#include "c-tree.h"
	#include "toplev.h"
	#include "ggc.h"
	#include "tm_p.h"
	#include "cpplib.h"
	#include "target.h"
	#include "debug.h"
	#include "opts.h"
	#include "timevar.h"
	#include "c-common.h"
	#include "c-pragma.h"
	#include "langhooks.h"
	#include "tree-mudflap.h"
	#include "tree-gimple.h"
	#include "diagnostic.h"
	#include "tree-dump.h"
	#include "cgraph.h"
	#include "hashtab.h"
	#include "libfuncs.h"
	#include "except.h"
	#include "langhooks-def.h"
	#include "pointer-set.h"

	/* In grokdeclarator, distinguish syntactic contexts of declarators. */
	enum decl_context
	{ NORMAL, /* Ordinary declaration */
	FUNCDEF, /* Function definition */
	PARM, /* Declaration of parm before function body */
	FIELD, /* Declaration inside struct or union */
	TYPENAME}; /* Typename (inside cast or sizeof) */


	/* Nonzero if we have seen an invalid cross reference
	to a struct, union, or enum, but not yet printed the message. */
	tree pending_invalid_xref;

	/* File and line to appear in the eventual error message. */
	location_t pending_invalid_xref_location;

	/* True means we've initialized exception handling. */
	bool c_eh_initialized_p;

	/* While defining an enum type, this is 1 plus the last enumerator
	constant value. Note that will do not have to save this or `enum_overflow'
	around nested function definition since such a definition could only
	occur in an enum value expression and we don't use these variables in
	that case. */

	static tree enum_next_value;

	/* Nonzero means that there was overflow computing enum_next_value. */

	static int enum_overflow;

	/* The file and line that the prototype came from if this is an
	old-style definition; used for diagnostics in
	store_parm_decls_oldstyle. */

	static location_t current_function_prototype_locus;

	/* Whether this prototype was built-in. */

	static bool current_function_prototype_built_in;

	/* The argument type information of this prototype. */

	static tree current_function_prototype_arg_types;

	/* The argument information structure for the function currently being
	defined. */

	static struct c_arg_info *current_function_arg_info;

	/* The obstack on which parser and related data structures, which are
	not live beyond their top-level declaration or definition, are
	allocated. */
	struct obstack parser_obstack;

	/* The current statement tree. */

	static GTY(()) struct stmt_tree_s c_stmt_tree;

	/* State saving variables. */
	tree c_break_label;
	tree c_cont_label;

	/* Linked list of TRANSLATION_UNIT_DECLS for the translation units
	included in this invocation. Note that the current translation
	unit is not included in this list. */

	static GTY(()) tree all_translation_units;

	/* A list of decls to be made automatically visible in each file scope. */
	static GTY(()) tree visible_builtins;

	/* Set to 0 at beginning of a function definition, set to 1 if
	a return statement that specifies a return value is seen. */

	int current_function_returns_value;

	/* Set to 0 at beginning of a function definition, set to 1 if
	a return statement with no argument is seen. */

	int current_function_returns_null;

	/* Set to 0 at beginning of a function definition, set to 1 if
	a call to a noreturn function is seen. */

	int current_function_returns_abnormally;

	/* Set to nonzero by `grokdeclarator' for a function
	whose return type is defaulted, if warnings for this are desired. */

	static int warn_about_return_type;

	/* Nonzero when the current toplevel function contains a declaration
	of a nested function which is never defined. */

	static bool undef_nested_function;

	/* True means global_bindings_p should return false even if the scope stack
	says we are in file scope. */
	bool c_override_global_bindings_to_false;


	/* Each c_binding structure describes one binding of an identifier to
	a decl. All the decls in a scope - irrespective of namespace - are
	chained together by the ->prev field, which (as the name implies)
	runs in reverse order. All the decls in a given namespace bound to
	a given identifier are chained by the ->shadowed field, which runs
	from inner to outer scopes.

	The ->decl field usually points to a DECL node, but there are two
	exceptions. In the namespace of type tags, the bound entity is a
	RECORD_TYPE, UNION_TYPE, or ENUMERAL_TYPE node. If an undeclared
	identifier is encountered, it is bound to error_mark_node to
	suppress further errors about that identifier in the current
	function.

	The ->type field stores the type of the declaration in this scope;
	if NULL, the type is the type of the ->decl field. This is only of
	relevance for objects with external or internal linkage which may
	be redeclared in inner scopes, forming composite types that only
	persist for the duration of those scopes. In the external scope,
	this stores the composite of all the types declared for this
	object, visible or not. The ->inner_comp field (used only at file
	scope) stores whether an incomplete array type at file scope was
	completed at an inner scope to an array size other than 1.

	The depth field is copied from the scope structure that holds this
	decl. It is used to preserve the proper ordering of the ->shadowed
	field (see bind()) and also for a handful of special-case checks.
	Finally, the invisible bit is true for a decl which should be
	ignored for purposes of normal name lookup, and the nested bit is
	true for a decl that's been bound a second time in an inner scope;
	in all such cases, the binding in the outer scope will have its
	invisible bit true. */

	struct c_binding GTY((chain_next ("%h.prev")))
	{
	tree decl; /* the decl bound */
	tree type; /* the type in this scope */
	tree id; /* the identifier it's bound to */
	struct c_binding prev; / the previous decl in this scope */
	struct c_binding shadowed; / the innermost decl shadowed by this one */
	unsigned int depth : 28; /* depth of this scope */
	BOOL_BITFIELD invisible : 1; /* normal lookup should ignore this binding */
	BOOL_BITFIELD nested : 1; /* do not set DECL_CONTEXT when popping */
	BOOL_BITFIELD inner_comp : 1; /* incomplete array completed in inner scope */
	/* one free bit */
	};
	#define B_IN_SCOPE(b1, b2) ((b1)->depth == (b2)->depth)
	#define B_IN_CURRENT_SCOPE(b) ((b)->depth == current_scope->depth)
	#define B_IN_FILE_SCOPE(b) ((b)->depth == 1 /file_scope->depth/)
	#define B_IN_EXTERNAL_SCOPE(b) ((b)->depth == 0 /external_scope->depth/)

	#define I_SYMBOL_BINDING(node) \
	(((struct lang_identifier *) IDENTIFIER_NODE_CHECK(node))->symbol_binding)
	#define I_SYMBOL_DECL(node) \
	(I_SYMBOL_BINDING(node) ? I_SYMBOL_BINDING(node)->decl : 0)

	#define I_TAG_BINDING(node) \
	(((struct lang_identifier *) IDENTIFIER_NODE_CHECK(node))->tag_binding)
	#define I_TAG_DECL(node) \
	(I_TAG_BINDING(node) ? I_TAG_BINDING(node)->decl : 0)

	#define I_LABEL_BINDING(node) \
	(((struct lang_identifier *) IDENTIFIER_NODE_CHECK(node))->label_binding)
	#define I_LABEL_DECL(node) \
	(I_LABEL_BINDING(node) ? I_LABEL_BINDING(node)->decl : 0)

	/* Each C symbol points to three linked lists of c_binding structures.
	These describe the values of the identifier in the three different
	namespaces defined by the language. */

	struct lang_identifier GTY(())
	{
	struct c_common_identifier common_id;
	struct c_binding symbol_binding; / vars, funcs, constants, typedefs */
	struct c_binding tag_binding; / struct/union/enum tags */
	struct c_binding label_binding; / labels */
	};

	/* Validate c-lang.c's assumptions. */
	extern char C_SIZEOF_STRUCT_LANG_IDENTIFIER_isnt_accurate
	[(sizeof(struct lang_identifier) == C_SIZEOF_STRUCT_LANG_IDENTIFIER) ? 1 : -1];

	/* The resulting tree type. */

	union lang_tree_node
	GTY((desc ("TREE_CODE (&%h.generic) == IDENTIFIER_NODE"),
	chain_next ("TREE_CODE (&%h.generic) == INTEGER_TYPE ? (union lang_tree_node ) TYPE_NEXT_VARIANT (&%h.generic) : (union lang_tree_node ) TREE_CHAIN (&%h.generic)")))
	{
	union tree_node GTY ((tag ("0"),
	desc ("tree_node_structure (&%h)")))
	generic;
	struct lang_identifier GTY ((tag ("1"))) identifier;
	};

	/* Each c_scope structure describes the complete contents of one
	scope. Four scopes are distinguished specially: the innermost or
	current scope, the innermost function scope, the file scope (always
	the second to outermost) and the outermost or external scope.

	Most declarations are recorded in the current scope.

	All normal label declarations are recorded in the innermost
	function scope, as are bindings of undeclared identifiers to
	error_mark_node. (GCC permits nested functions as an extension,
	hence the 'innermost' qualifier.) Explicitly declared labels
	(using the __label__ extension) appear in the current scope.

	Being in the file scope (current_scope == file_scope) causes
	special behavior in several places below. Also, under some
	conditions the Objective-C front end records declarations in the
	file scope even though that isn't the current scope.

	All declarations with external linkage are recorded in the external
	scope, even if they aren't visible there; this models the fact that
	such declarations are visible to the entire program, and (with a
	bit of cleverness, see pushdecl) allows diagnosis of some violations
	of C99 6.2.2p7 and 6.2.7p2:

	If, within the same translation unit, the same identifier appears
	with both internal and external linkage, the behavior is
	undefined.

	All declarations that refer to the same object or function shall
	have compatible type; otherwise, the behavior is undefined.

	Initially only the built-in declarations, which describe compiler
	intrinsic functions plus a subset of the standard library, are in
	this scope.

	The order of the blocks list matters, and it is frequently appended
	to. To avoid having to walk all the way to the end of the list on
	each insertion, or reverse the list later, we maintain a pointer to
	the last list entry. (FIXME: It should be feasible to use a reversed
	list here.)

	The bindings list is strictly in reverse order of declarations;
	pop_scope relies on this. */


	struct c_scope GTY((chain_next ("%h.outer")))
	{
	/* The scope containing this one. */
	struct c_scope *outer;

	/* The next outermost function scope. */
	struct c_scope *outer_function;

	/* All bindings in this scope. */
	struct c_binding *bindings;

	/* For each scope (except the global one), a chain of BLOCK nodes
	for all the scopes that were entered and exited one level down. */
	tree blocks;
	tree blocks_last;

	/* The depth of this scope. Used to keep the ->shadowed chain of
	bindings sorted innermost to outermost. */
	unsigned int depth : 28;

	/* True if we are currently filling this scope with parameter
	declarations. */
	BOOL_BITFIELD parm_flag : 1;

	/* True if we saw [*] in this scope. Used to give an error messages
	if these appears in a function definition. */
	BOOL_BITFIELD had_vla_unspec : 1;

	/* True if we already complained about forward parameter decls
	in this scope. This prevents double warnings on
	foo (int a; int b; ...) */
	BOOL_BITFIELD warned_forward_parm_decls : 1;

	/* True if this is the outermost block scope of a function body.
	This scope contains the parameters, the local variables declared
	in the outermost block, and all the labels (except those in
	nested functions, or declared at block scope with __label__). */
	BOOL_BITFIELD function_body : 1;

	/* True means make a BLOCK for this scope no matter what. */
	BOOL_BITFIELD keep : 1;
	};

	/* The scope currently in effect. */

	static GTY(()) struct c_scope *current_scope;

	/* The innermost function scope. Ordinary (not explicitly declared)
	labels, bindings to error_mark_node, and the lazily-created
	bindings of __func__ and its friends get this scope. */

	static GTY(()) struct c_scope *current_function_scope;

	/* The C file scope. This is reset for each input translation unit. */

	static GTY(()) struct c_scope *file_scope;

	/* The outermost scope. This is used for all declarations with
	external linkage, and only these, hence the name. */

	static GTY(()) struct c_scope *external_scope;

	/* A chain of c_scope structures awaiting reuse. */

	static GTY((deletable)) struct c_scope *scope_freelist;

	/* A chain of c_binding structures awaiting reuse. */

	static GTY((deletable)) struct c_binding *binding_freelist;

	/* Append VAR to LIST in scope SCOPE. */
	#define SCOPE_LIST_APPEND(scope, list, decl) do { \
	struct c_scope *s_ = (scope); \
	tree d_ = (decl); \
	if (s_->list##_last) \
	TREE_CHAIN (s_->list##_last) = d_; \
	else \
	s_->list = d_; \
	s_->list##_last = d_; \
	} while (0)

	/* Concatenate FROM in scope FSCOPE onto TO in scope TSCOPE. */
	#define SCOPE_LIST_CONCAT(tscope, to, fscope, from) do { \
	struct c_scope *t_ = (tscope); \
	struct c_scope *f_ = (fscope); \
	if (t_->to##_last) \
	TREE_CHAIN (t_->to##_last) = f_->from; \
	else \
	t_->to = f_->from; \
	t_->to##_last = f_->from##_last; \
	} while (0)

	/* True means unconditionally make a BLOCK for the next scope pushed. */

	static bool keep_next_level_flag;

	/* True means the next call to push_scope will be the outermost scope
	of a function body, so do not push a new scope, merely cease
	expecting parameter decls. */

	static bool next_is_function_body;

	/* Functions called automatically at the beginning and end of execution. */

	static GTY(()) tree static_ctors;
	static GTY(()) tree static_dtors;

	/* Forward declarations. */
	static tree lookup_name_in_scope (tree, struct c_scope *);
	static tree c_make_fname_decl (tree, int);
	static tree grokdeclarator (const struct c_declarator *,
	struct c_declspecs *,
	enum decl_context, bool, tree *);
	static tree grokparms (struct c_arg_info *, bool);
	static void layout_array_type (tree);

	/* T is a statement. Add it to the statement-tree. This is the
	C/ObjC version--C++ has a slightly different version of this
	function. */

	tree
	add_stmt (tree t)
	{
	enum tree_code code = TREE_CODE (t);

	if (EXPR_P (t) && code != LABEL_EXPR)
	{
	if (!EXPR_HAS_LOCATION (t))
	SET_EXPR_LOCATION (t, input_location);
	}

	if (code == LABEL_EXPR \|\| code == CASE_LABEL_EXPR)
	STATEMENT_LIST_HAS_LABEL (cur_stmt_list) = 1;

	/* Add T to the statement-tree. Non-side-effect statements need to be
	recorded during statement expressions. */
	append_to_statement_list_force (t, &cur_stmt_list);

	return t;
	}

	/* States indicating how grokdeclarator() should handle declspecs marked
	with __attribute__((deprecated)). An object declared as
	__attribute__((deprecated)) suppresses warnings of uses of other
	deprecated items. */
	+/* APPLE LOCAL begin "unavailable" attribute (radar 2809697) */
	+/* Also add an __attribute__((unavailable)). An object declared as
	+ __attribute__((unavailable)) suppresses any reports of being
	+ declared with unavailable or deprecated items. */
	+/* APPLE LOCAL end "unavailable" attribute (radar 2809697) */

	enum deprecated_states {
	DEPRECATED_NORMAL,
	DEPRECATED_SUPPRESS
	+ /* APPLE LOCAL "unavailable" attribute (radar 2809697) */
	+ , DEPRECATED_UNAVAILABLE_SUPPRESS
	};

	static enum deprecated_states deprecated_state = DEPRECATED_NORMAL;

	void
	c_print_identifier (FILE *file, tree node, int indent)
	{
	print_node (file, "symbol", I_SYMBOL_DECL (node), indent + 4);
	print_node (file, "tag", I_TAG_DECL (node), indent + 4);
	print_node (file, "label", I_LABEL_DECL (node), indent + 4);
	if (C_IS_RESERVED_WORD (node))
	{
	tree rid = ridpointers[C_RID_CODE (node)];
	indent_to (file, indent + 4);
	fprintf (file, "rid %p \"%s\"",
	(void *) rid, IDENTIFIER_POINTER (rid));
	}
	}

	/* Establish a binding between NAME, an IDENTIFIER_NODE, and DECL,
	which may be any of several kinds of DECL or TYPE or error_mark_node,
	in the scope SCOPE. */
	static void
	bind (tree name, tree decl, struct c_scope *scope, bool invisible, bool nested)
	{
	struct c_binding b, *here;

	if (binding_freelist)
	{
	b = binding_freelist;
	binding_freelist = b->prev;
	}
	else
	b = GGC_NEW (struct c_binding);

	b->shadowed = 0;
	b->decl = decl;
	b->id = name;
	b->depth = scope->depth;
	b->invisible = invisible;
	b->nested = nested;
	b->inner_comp = 0;

	b->type = 0;

	b->prev = scope->bindings;
	scope->bindings = b;

	if (!name)
	return;

	switch (TREE_CODE (decl))
	{
	case LABEL_DECL: here = &I_LABEL_BINDING (name); break;
	case ENUMERAL_TYPE:
	case UNION_TYPE:
	case RECORD_TYPE: here = &I_TAG_BINDING (name); break;
	case VAR_DECL:
	case FUNCTION_DECL:
	case TYPE_DECL:
	case CONST_DECL:
	case PARM_DECL:
	case ERROR_MARK: here = &I_SYMBOL_BINDING (name); break;

	default:
	gcc_unreachable ();
	}

	/* Locate the appropriate place in the chain of shadowed decls
	to insert this binding. Normally, scope == current_scope and
	this does nothing. */
	while (here && (here)->depth > scope->depth)
	here = &(*here)->shadowed;

	b->shadowed = *here;
	*here = b;
	}

	/* Clear the binding structure B, stick it on the binding_freelist,
	and return the former value of b->prev. This is used by pop_scope
	and get_parm_info to iterate destructively over all the bindings
	from a given scope. */
	static struct c_binding *
	free_binding_and_advance (struct c_binding *b)
	{
	struct c_binding *prev = b->prev;

	memset (b, 0, sizeof (struct c_binding));
	b->prev = binding_freelist;
	binding_freelist = b;

	return prev;
	}


	/* Hook called at end of compilation to assume 1 elt
	for a file-scope tentative array defn that wasn't complete before. */

	void
	c_finish_incomplete_decl (tree decl)
	{
	if (TREE_CODE (decl) == VAR_DECL)
	{
	tree type = TREE_TYPE (decl);
	if (type != error_mark_node
	&& TREE_CODE (type) == ARRAY_TYPE
	&& !DECL_EXTERNAL (decl)
	&& TYPE_DOMAIN (type) == 0)
	{
	warning (0, "array %q+D assumed to have one element", decl);

	complete_array_type (&TREE_TYPE (decl), NULL_TREE, true);

	layout_decl (decl, 0);
	}
	}
	}

	/* The Objective-C front-end often needs to determine the current scope. */

	void *
	objc_get_current_scope (void)
	{
	return current_scope;
	}

	/* The following function is used only by Objective-C. It needs to live here
	because it accesses the innards of c_scope. */

	void
	objc_mark_locals_volatile (void *enclosing_blk)
	{
	struct c_scope *scope;
	struct c_binding *b;

	for (scope = current_scope;
	scope && scope != enclosing_blk;
	scope = scope->outer)
	{
	for (b = scope->bindings; b; b = b->prev)
	objc_volatilize_decl (b->decl);

	/* Do not climb up past the current function. */
	if (scope->function_body)
	break;
	}
	}

	/* Nonzero if we are currently in file scope. */

	int
	global_bindings_p (void)
	{
	return current_scope == file_scope && !c_override_global_bindings_to_false;
	}

	void
	keep_next_level (void)
	{
	keep_next_level_flag = true;
	}

	/* Identify this scope as currently being filled with parameters. */

	void
	declare_parm_level (void)
	{
	current_scope->parm_flag = true;
	}

	void
	push_scope (void)
	{
	if (next_is_function_body)
	{
	/* This is the transition from the parameters to the top level
	of the function body. These are the same scope
	(C99 6.2.1p4,6) so we do not push another scope structure.
	next_is_function_body is set only by store_parm_decls, which
	in turn is called when and only when we are about to
	encounter the opening curly brace for the function body.

	The outermost block of a function always gets a BLOCK node,
	because the debugging output routines expect that each
	function has at least one BLOCK. */
	current_scope->parm_flag = false;
	current_scope->function_body = true;
	current_scope->keep = true;
	current_scope->outer_function = current_function_scope;
	current_function_scope = current_scope;

	keep_next_level_flag = false;
	next_is_function_body = false;
	}
	else
	{
	struct c_scope *scope;
	if (scope_freelist)
	{
	scope = scope_freelist;
	scope_freelist = scope->outer;
	}
	else
	scope = GGC_CNEW (struct c_scope);

	scope->keep = keep_next_level_flag;
	scope->outer = current_scope;
	scope->depth = current_scope ? (current_scope->depth + 1) : 0;

	/* Check for scope depth overflow. Unlikely (2^28 == 268,435,456) but
	possible. */
	if (current_scope && scope->depth == 0)
	{
	scope->depth--;
	sorry ("GCC supports only %u nested scopes", scope->depth);
	}

	current_scope = scope;
	keep_next_level_flag = false;
	}
	}

	/* Set the TYPE_CONTEXT of all of TYPE's variants to CONTEXT. */

	static void
	set_type_context (tree type, tree context)
	{
	for (type = TYPE_MAIN_VARIANT (type); type;
	type = TYPE_NEXT_VARIANT (type))
	TYPE_CONTEXT (type) = context;
	}

	/* Exit a scope. Restore the state of the identifier-decl mappings
	that were in effect when this scope was entered. Return a BLOCK
	node containing all the DECLs in this scope that are of interest
	to debug info generation. */

	tree
	pop_scope (void)
	{
	struct c_scope *scope = current_scope;
	tree block, context, p;
	struct c_binding *b;

	bool functionbody = scope->function_body;
	bool keep = functionbody \|\| scope->keep \|\| scope->bindings;

	c_end_vm_scope (scope->depth);

	/* If appropriate, create a BLOCK to record the decls for the life
	of this function. */
	block = 0;
	if (keep)
	{
	block = make_node (BLOCK);
	BLOCK_SUBBLOCKS (block) = scope->blocks;
	TREE_USED (block) = 1;

	/* In each subblock, record that this is its superior. */
	for (p = scope->blocks; p; p = TREE_CHAIN (p))
	BLOCK_SUPERCONTEXT (p) = block;

	BLOCK_VARS (block) = 0;
	}

	/* The TYPE_CONTEXTs for all of the tagged types belonging to this
	scope must be set so that they point to the appropriate
	construct, i.e. either to the current FUNCTION_DECL node, or
	else to the BLOCK node we just constructed.

	Note that for tagged types whose scope is just the formal
	parameter list for some function type specification, we can't
	properly set their TYPE_CONTEXTs here, because we don't have a
	pointer to the appropriate FUNCTION_TYPE node readily available
	to us. For those cases, the TYPE_CONTEXTs of the relevant tagged
	type nodes get set in `grokdeclarator' as soon as we have created
	the FUNCTION_TYPE node which will represent the "scope" for these
	"parameter list local" tagged types. */
	if (scope->function_body)
	context = current_function_decl;
	else if (scope == file_scope)
	{
	tree file_decl = build_decl (TRANSLATION_UNIT_DECL, 0, 0);
	TREE_CHAIN (file_decl) = all_translation_units;
	all_translation_units = file_decl;
	context = file_decl;
	}
	else
	context = block;

	/* Clear all bindings in this scope. */
	for (b = scope->bindings; b; b = free_binding_and_advance (b))
	{
	p = b->decl;
	switch (TREE_CODE (p))
	{
	case LABEL_DECL:
	/* Warnings for unused labels, errors for undefined labels. */
	if (TREE_USED (p) && !DECL_INITIAL (p))
	{
	error ("label %q+D used but not defined", p);
	DECL_INITIAL (p) = error_mark_node;
	}
	else if (!TREE_USED (p) && warn_unused_label)
	{
	if (DECL_INITIAL (p))
	warning (0, "label %q+D defined but not used", p);
	else
	warning (0, "label %q+D declared but not defined", p);
	}
	/* Labels go in BLOCK_VARS. */
	TREE_CHAIN (p) = BLOCK_VARS (block);
	BLOCK_VARS (block) = p;
	gcc_assert (I_LABEL_BINDING (b->id) == b);
	I_LABEL_BINDING (b->id) = b->shadowed;
	break;

	case ENUMERAL_TYPE:
	case UNION_TYPE:
	case RECORD_TYPE:
	set_type_context (p, context);

	/* Types may not have tag-names, in which case the type
	appears in the bindings list with b->id NULL. */
	if (b->id)
	{
	gcc_assert (I_TAG_BINDING (b->id) == b);
	I_TAG_BINDING (b->id) = b->shadowed;
	}
	break;

	case FUNCTION_DECL:
	/* Propagate TREE_ADDRESSABLE from nested functions to their
	containing functions. */
	if (!TREE_ASM_WRITTEN (p)
	&& DECL_INITIAL (p) != 0
	&& TREE_ADDRESSABLE (p)
	&& DECL_ABSTRACT_ORIGIN (p) != 0
	&& DECL_ABSTRACT_ORIGIN (p) != p)
	TREE_ADDRESSABLE (DECL_ABSTRACT_ORIGIN (p)) = 1;
	if (!DECL_EXTERNAL (p)
	&& DECL_INITIAL (p) == 0
	&& scope != file_scope
	&& scope != external_scope)
	{
	error ("nested function %q+D declared but never defined", p);
	undef_nested_function = true;
	}
	/* C99 6.7.4p6: "a function with external linkage... declared
	with an inline function specifier ... shall also be defined in the
	same translation unit." */
	else if (DECL_DECLARED_INLINE_P (p)
	&& TREE_PUBLIC (p)
	&& !DECL_INITIAL (p)
	&& !flag_gnu89_inline)
	pedwarn ("inline function %q+D declared but never defined", p);

	goto common_symbol;

	case VAR_DECL:
	/* Warnings for unused variables. */
	if (!TREE_USED (p)
	&& !TREE_NO_WARNING (p)
	&& !DECL_IN_SYSTEM_HEADER (p)
	&& DECL_NAME (p)
	&& !DECL_ARTIFICIAL (p)
	&& scope != file_scope
	&& scope != external_scope)
	warning (OPT_Wunused_variable, "unused variable %q+D", p);

	if (b->inner_comp)
	{
	error ("type of array %q+D completed incompatibly with"
	" implicit initialization", p);
	}

	/* Fall through. */
	case TYPE_DECL:
	case CONST_DECL:
	common_symbol:
	/* All of these go in BLOCK_VARS, but only if this is the
	binding in the home scope. */
	if (!b->nested)
	{
	TREE_CHAIN (p) = BLOCK_VARS (block);
	BLOCK_VARS (block) = p;
	}
	/* If this is the file scope, and we are processing more
	than one translation unit in this compilation, set
	DECL_CONTEXT of each decl to the TRANSLATION_UNIT_DECL.
	This makes same_translation_unit_p work, and causes
	static declarations to be given disambiguating suffixes. */
	if (scope == file_scope && num_in_fnames > 1)
	{
	DECL_CONTEXT (p) = context;
	if (TREE_CODE (p) == TYPE_DECL)
	set_type_context (TREE_TYPE (p), context);
	}

	/* Fall through. */
	/* Parameters go in DECL_ARGUMENTS, not BLOCK_VARS, and have
	already been put there by store_parm_decls. Unused-
	parameter warnings are handled by function.c.
	error_mark_node obviously does not go in BLOCK_VARS and
	does not get unused-variable warnings. */
	case PARM_DECL:
	case ERROR_MARK:
	/* It is possible for a decl not to have a name. We get
	here with b->id NULL in this case. */
	if (b->id)
	{
	gcc_assert (I_SYMBOL_BINDING (b->id) == b);
	I_SYMBOL_BINDING (b->id) = b->shadowed;
	if (b->shadowed && b->shadowed->type)
	TREE_TYPE (b->shadowed->decl) = b->shadowed->type;
	}
	break;

	default:
	gcc_unreachable ();
	}
	}


	/* Dispose of the block that we just made inside some higher level. */
	if ((scope->function_body \|\| scope == file_scope) && context)
	{
	DECL_INITIAL (context) = block;
	BLOCK_SUPERCONTEXT (block) = context;
	}
	else if (scope->outer)
	{
	if (block)
	SCOPE_LIST_APPEND (scope->outer, blocks, block);
	/* If we did not make a block for the scope just exited, any
	blocks made for inner scopes must be carried forward so they
	will later become subblocks of something else. */
	else if (scope->blocks)
	SCOPE_LIST_CONCAT (scope->outer, blocks, scope, blocks);
	}

	/* Pop the current scope, and free the structure for reuse. */
	current_scope = scope->outer;
	if (scope->function_body)
	current_function_scope = scope->outer_function;

	memset (scope, 0, sizeof (struct c_scope));
	scope->outer = scope_freelist;
	scope_freelist = scope;

	return block;
	}

	void
	push_file_scope (void)
	{
	tree decl;

	if (file_scope)
	return;

	push_scope ();
	file_scope = current_scope;

	start_fname_decls ();

	for (decl = visible_builtins; decl; decl = TREE_CHAIN (decl))
	bind (DECL_NAME (decl), decl, file_scope,
	/invisible=/false, /nested=/true);
	}

	void
	pop_file_scope (void)
	{
	/* In case there were missing closebraces, get us back to the global
	binding level. */
	while (current_scope != file_scope)
	pop_scope ();

	/* __FUNCTION__ is defined at file scope (""). This
	call may not be necessary as my tests indicate it
	still works without it. */
	finish_fname_decls ();

	/* This is the point to write out a PCH if we're doing that.
	In that case we do not want to do anything else. */
	if (pch_file)
	{
	c_common_write_pch ();
	return;
	}

	/* Pop off the file scope and close this translation unit. */
	pop_scope ();
	file_scope = 0;

	maybe_apply_pending_pragma_weaks ();
	cgraph_finalize_compilation_unit ();
	}

	/* Insert BLOCK at the end of the list of subblocks of the current
	scope. This is used when a BIND_EXPR is expanded, to handle the
	BLOCK node inside the BIND_EXPR. */

	void
	insert_block (tree block)
	{
	TREE_USED (block) = 1;
	SCOPE_LIST_APPEND (current_scope, blocks, block);
	}

	/* Push a definition or a declaration of struct, union or enum tag "name".
	"type" should be the type node.
	We assume that the tag "name" is not already defined.

	Note that the definition may really be just a forward reference.
	In that case, the TYPE_SIZE will be zero. */

	static void
	pushtag (tree name, tree type)
	{
	/* Record the identifier as the type's name if it has none. */
	if (name && !TYPE_NAME (type))
	TYPE_NAME (type) = name;
	bind (name, type, current_scope, /invisible=/false, /nested=/false);

	/* Create a fake NULL-named TYPE_DECL node whose TREE_TYPE will be the
	tagged type we just added to the current scope. This fake
	NULL-named TYPE_DECL node helps dwarfout.c to know when it needs
	to output a representation of a tagged type, and it also gives
	us a convenient place to record the "scope start" address for the
	tagged type. */

	TYPE_STUB_DECL (type) = pushdecl (build_decl (TYPE_DECL, NULL_TREE, type));

	/* An approximation for now, so we can tell this is a function-scope tag.
	This will be updated in pop_scope. */
	TYPE_CONTEXT (type) = DECL_CONTEXT (TYPE_STUB_DECL (type));
	}

	/* Subroutine of compare_decls. Allow harmless mismatches in return
	and argument types provided that the type modes match. This function
	return a unified type given a suitable match, and 0 otherwise. */

	static tree
	match_builtin_function_types (tree newtype, tree oldtype)
	{
	tree newrettype, oldrettype;
	tree newargs, oldargs;
	tree trytype, tryargs;

	/* Accept the return type of the new declaration if same modes. */
	oldrettype = TREE_TYPE (oldtype);
	newrettype = TREE_TYPE (newtype);

	if (TYPE_MODE (oldrettype) != TYPE_MODE (newrettype))
	return 0;

	oldargs = TYPE_ARG_TYPES (oldtype);
	newargs = TYPE_ARG_TYPES (newtype);
	tryargs = newargs;

	while (oldargs \|\| newargs)
	{
	if (!oldargs
	\|\| !newargs
	\|\| !TREE_VALUE (oldargs)
	\|\| !TREE_VALUE (newargs)
	\|\| TYPE_MODE (TREE_VALUE (oldargs))
	!= TYPE_MODE (TREE_VALUE (newargs)))
	return 0;

	oldargs = TREE_CHAIN (oldargs);
	newargs = TREE_CHAIN (newargs);
	}

	trytype = build_function_type (newrettype, tryargs);
	return build_type_attribute_variant (trytype, TYPE_ATTRIBUTES (oldtype));
	}

	/* Subroutine of diagnose_mismatched_decls. Check for function type
	mismatch involving an empty arglist vs a nonempty one and give clearer
	diagnostics. */
	static void
	diagnose_arglist_conflict (tree newdecl, tree olddecl,
	tree newtype, tree oldtype)
	{
	tree t;

	if (TREE_CODE (olddecl) != FUNCTION_DECL
	\|\| !comptypes (TREE_TYPE (oldtype), TREE_TYPE (newtype))
	\|\| !((TYPE_ARG_TYPES (oldtype) == 0 && DECL_INITIAL (olddecl) == 0)
	\|\|
	(TYPE_ARG_TYPES (newtype) == 0 && DECL_INITIAL (newdecl) == 0)))
	return;

	t = TYPE_ARG_TYPES (oldtype);
	if (t == 0)
	t = TYPE_ARG_TYPES (newtype);
	for (; t; t = TREE_CHAIN (t))
	{
	tree type = TREE_VALUE (t);

	if (TREE_CHAIN (t) == 0
	&& TYPE_MAIN_VARIANT (type) != void_type_node)
	{
	inform ("a parameter list with an ellipsis can%'t match "
	"an empty parameter name list declaration");
	break;
	}

	if (c_type_promotes_to (type) != type)
	{
	inform ("an argument type that has a default promotion can%'t match "
	"an empty parameter name list declaration");
	break;
	}
	}
	}

	/* Another subroutine of diagnose_mismatched_decls. OLDDECL is an
	old-style function definition, NEWDECL is a prototype declaration.
	Diagnose inconsistencies in the argument list. Returns TRUE if
	the prototype is compatible, FALSE if not. */
	static bool
	validate_proto_after_old_defn (tree newdecl, tree newtype, tree oldtype)
	{
	tree newargs, oldargs;
	int i;

	#define END_OF_ARGLIST(t) ((t) == void_type_node)

	oldargs = TYPE_ACTUAL_ARG_TYPES (oldtype);
	newargs = TYPE_ARG_TYPES (newtype);
	i = 1;

	for (;;)
	{
	tree oldargtype = TREE_VALUE (oldargs);
	tree newargtype = TREE_VALUE (newargs);

	if (oldargtype == error_mark_node \|\| newargtype == error_mark_node)
	return false;

	oldargtype = TYPE_MAIN_VARIANT (oldargtype);
	newargtype = TYPE_MAIN_VARIANT (newargtype);

	if (END_OF_ARGLIST (oldargtype) && END_OF_ARGLIST (newargtype))
	break;

	/* Reaching the end of just one list means the two decls don't
	agree on the number of arguments. */
	if (END_OF_ARGLIST (oldargtype))
	{
	error ("prototype for %q+D declares more arguments "
	"than previous old-style definition", newdecl);
	return false;
	}
	else if (END_OF_ARGLIST (newargtype))
	{
	error ("prototype for %q+D declares fewer arguments "
	"than previous old-style definition", newdecl);
	return false;
	}

	/* Type for passing arg must be consistent with that declared
	for the arg. */
	else if (!comptypes (oldargtype, newargtype))
	{
	error ("prototype for %q+D declares argument %d"
	" with incompatible type",
	newdecl, i);
	return false;
	}

	oldargs = TREE_CHAIN (oldargs);
	newargs = TREE_CHAIN (newargs);
	i++;
	}

	/* If we get here, no errors were found, but do issue a warning
	for this poor-style construct. */
	warning (0, "prototype for %q+D follows non-prototype definition",
	newdecl);
	return true;
	#undef END_OF_ARGLIST
	}

	/* Subroutine of diagnose_mismatched_decls. Report the location of DECL,
	first in a pair of mismatched declarations, using the diagnostic
	function DIAG. */
	static void
	locate_old_decl (tree decl, void (diag)(const char , ...) ATTRIBUTE_GCC_CDIAG(1,2))
	{
	if (TREE_CODE (decl) == FUNCTION_DECL && DECL_BUILT_IN (decl))
	;
	else if (DECL_INITIAL (decl))
	diag (G_("previous definition of %q+D was here"), decl);
	else if (C_DECL_IMPLICIT (decl))
	diag (G_("previous implicit declaration of %q+D was here"), decl);
	else
	diag (G_("previous declaration of %q+D was here"), decl);
	}

	/* Subroutine of duplicate_decls. Compare NEWDECL to OLDDECL.
	Returns true if the caller should proceed to merge the two, false
	if OLDDECL should simply be discarded. As a side effect, issues
	all necessary diagnostics for invalid or poor-style combinations.
	If it returns true, writes the types of NEWDECL and OLDDECL to
	NEWTYPEP and OLDTYPEP - these may have been adjusted from
	TREE_TYPE (NEWDECL, OLDDECL) respectively. */

	static bool
	diagnose_mismatched_decls (tree newdecl, tree olddecl,
	tree newtypep, tree oldtypep)
	{
	tree newtype, oldtype;
	bool pedwarned = false;
	bool warned = false;
	bool retval = true;

	#define DECL_EXTERN_INLINE(DECL) (DECL_DECLARED_INLINE_P (DECL) \
	&& DECL_EXTERNAL (DECL))

	/* If we have error_mark_node for either decl or type, just discard
	the previous decl - we're in an error cascade already. */
	if (olddecl == error_mark_node \|\| newdecl == error_mark_node)
	return false;
	*oldtypep = oldtype = TREE_TYPE (olddecl);
	*newtypep = newtype = TREE_TYPE (newdecl);
	if (oldtype == error_mark_node \|\| newtype == error_mark_node)
	return false;

	/* Two different categories of symbol altogether. This is an error
	unless OLDDECL is a builtin. OLDDECL will be discarded in any case. */
	if (TREE_CODE (olddecl) != TREE_CODE (newdecl))
	{
	if (!(TREE_CODE (olddecl) == FUNCTION_DECL
	&& DECL_BUILT_IN (olddecl)
	&& !C_DECL_DECLARED_BUILTIN (olddecl)))
	{
	error ("%q+D redeclared as different kind of symbol", newdecl);
	locate_old_decl (olddecl, error);
	}
	else if (TREE_PUBLIC (newdecl))
	warning (0, "built-in function %q+D declared as non-function",
	newdecl);
	else
	warning (OPT_Wshadow, "declaration of %q+D shadows "
	"a built-in function", newdecl);
	return false;
	}

	/* Enumerators have no linkage, so may only be declared once in a
	given scope. */
	if (TREE_CODE (olddecl) == CONST_DECL)
	{
	error ("redeclaration of enumerator %q+D", newdecl);
	locate_old_decl (olddecl, error);
	return false;
	}

	if (!comptypes (oldtype, newtype))
	{
	if (TREE_CODE (olddecl) == FUNCTION_DECL
	&& DECL_BUILT_IN (olddecl) && !C_DECL_DECLARED_BUILTIN (olddecl))
	{
	/* Accept harmless mismatch in function types.
	This is for the ffs and fprintf builtins. */
	tree trytype = match_builtin_function_types (newtype, oldtype);

	if (trytype && comptypes (newtype, trytype))
	*oldtypep = oldtype = trytype;
	else
	{
	/* If types don't match for a built-in, throw away the
	built-in. No point in calling locate_old_decl here, it
	won't print anything. */
	warning (0, "conflicting types for built-in function %q+D",
	newdecl);
	return false;
	}
	}
	else if (TREE_CODE (olddecl) == FUNCTION_DECL
	&& DECL_IS_BUILTIN (olddecl))
	{
	/* A conflicting function declaration for a predeclared
	function that isn't actually built in. Objective C uses
	these. The new declaration silently overrides everything
	but the volatility (i.e. noreturn) indication. See also
	below. FIXME: Make Objective C use normal builtins. */
	TREE_THIS_VOLATILE (newdecl) \|= TREE_THIS_VOLATILE (olddecl);
	return false;
	}
	/* Permit void foo (...) to match int foo (...) if the latter is
	the definition and implicit int was used. See
	c-torture/compile/920625-2.c. */
	else if (TREE_CODE (newdecl) == FUNCTION_DECL && DECL_INITIAL (newdecl)
	&& TYPE_MAIN_VARIANT (TREE_TYPE (oldtype)) == void_type_node
	&& TYPE_MAIN_VARIANT (TREE_TYPE (newtype)) == integer_type_node
	&& C_FUNCTION_IMPLICIT_INT (newdecl) && !DECL_INITIAL (olddecl))
	{
	pedwarn ("conflicting types for %q+D", newdecl);
	/* Make sure we keep void as the return type. */
	TREE_TYPE (newdecl) = *newtypep = newtype = oldtype;
	C_FUNCTION_IMPLICIT_INT (newdecl) = 0;
	pedwarned = true;
	}
	/* Permit void foo (...) to match an earlier call to foo (...) with
	no declared type (thus, implicitly int). */
	else if (TREE_CODE (newdecl) == FUNCTION_DECL
	&& TYPE_MAIN_VARIANT (TREE_TYPE (newtype)) == void_type_node
	&& TYPE_MAIN_VARIANT (TREE_TYPE (oldtype)) == integer_type_node
	&& C_DECL_IMPLICIT (olddecl) && !DECL_INITIAL (olddecl))
	{
	pedwarn ("conflicting types for %q+D", newdecl);
	/* Make sure we keep void as the return type. */
	TREE_TYPE (olddecl) = *oldtypep = oldtype = newtype;
	pedwarned = true;
	}
	else
	{
	if (TYPE_QUALS (newtype) != TYPE_QUALS (oldtype))
	error ("conflicting type qualifiers for %q+D", newdecl);
	else
	error ("conflicting types for %q+D", newdecl);
	diagnose_arglist_conflict (newdecl, olddecl, newtype, oldtype);
	locate_old_decl (olddecl, error);
	return false;
	}
	}

	/* Redeclaration of a type is a constraint violation (6.7.2.3p1),
	but silently ignore the redeclaration if either is in a system
	header. (Conflicting redeclarations were handled above.) */
	if (TREE_CODE (newdecl) == TYPE_DECL)
	{
	if (DECL_IN_SYSTEM_HEADER (newdecl) \|\| DECL_IN_SYSTEM_HEADER (olddecl))
	return true; /* Allow OLDDECL to continue in use. */

	error ("redefinition of typedef %q+D", newdecl);
	locate_old_decl (olddecl, error);
	return false;
	}

	/* Function declarations can either be 'static' or 'extern' (no
	qualifier is equivalent to 'extern' - C99 6.2.2p5) and therefore
	can never conflict with each other on account of linkage
	(6.2.2p4). Multiple definitions are not allowed (6.9p3,5) but
	gnu89 mode permits two definitions if one is 'extern inline' and
	one is not. The non- extern-inline definition supersedes the
	extern-inline definition. */

	else if (TREE_CODE (newdecl) == FUNCTION_DECL)
	{
	/* If you declare a built-in function name as static, or
	define the built-in with an old-style definition (so we
	can't validate the argument list) the built-in definition is
	overridden, but optionally warn this was a bad choice of name. */
	if (DECL_BUILT_IN (olddecl)
	&& !C_DECL_DECLARED_BUILTIN (olddecl)
	&& (!TREE_PUBLIC (newdecl)
	\|\| (DECL_INITIAL (newdecl)
	&& !TYPE_ARG_TYPES (TREE_TYPE (newdecl)))))
	{
	warning (OPT_Wshadow, "declaration of %q+D shadows "
	"a built-in function", newdecl);
	/* Discard the old built-in function. */
	return false;
	}

	if (DECL_INITIAL (newdecl))
	{
	if (DECL_INITIAL (olddecl))
	{
	/* If both decls are in the same TU and the new declaration
	isn't overriding an extern inline reject the new decl.
	In c99, no overriding is allowed in the same translation
	unit. */
	if ((!DECL_EXTERN_INLINE (olddecl)
	\|\| DECL_EXTERN_INLINE (newdecl)
	\|\| (!flag_gnu89_inline
	&& (!DECL_DECLARED_INLINE_P (olddecl)
	\|\| !lookup_attribute ("gnu_inline",
	DECL_ATTRIBUTES (olddecl)))
	&& (!DECL_DECLARED_INLINE_P (newdecl)
	\|\| !lookup_attribute ("gnu_inline",
	DECL_ATTRIBUTES (newdecl))))
	)
	&& same_translation_unit_p (newdecl, olddecl))
	{
	error ("redefinition of %q+D", newdecl);
	locate_old_decl (olddecl, error);
	return false;
	}
	}
	}
	/* If we have a prototype after an old-style function definition,
	the argument types must be checked specially. */
	else if (DECL_INITIAL (olddecl)
	&& !TYPE_ARG_TYPES (oldtype) && TYPE_ARG_TYPES (newtype)
	&& TYPE_ACTUAL_ARG_TYPES (oldtype)
	&& !validate_proto_after_old_defn (newdecl, newtype, oldtype))
	{
	locate_old_decl (olddecl, error);
	return false;
	}
	/* A non-static declaration (even an "extern") followed by a
	static declaration is undefined behavior per C99 6.2.2p3-5,7.
	The same is true for a static forward declaration at block
	scope followed by a non-static declaration/definition at file
	scope. Static followed by non-static at the same scope is
	not undefined behavior, and is the most convenient way to get
	some effects (see e.g. what unwind-dw2-fde-glibc.c does to
	the definition of _Unwind_Find_FDE in unwind-dw2-fde.c), but
	we do diagnose it if -Wtraditional. */
	if (TREE_PUBLIC (olddecl) && !TREE_PUBLIC (newdecl))
	{
	/* Two exceptions to the rule. If olddecl is an extern
	inline, or a predeclared function that isn't actually
	built in, newdecl silently overrides olddecl. The latter
	occur only in Objective C; see also above. (FIXME: Make
	Objective C use normal builtins.) */
	if (!DECL_IS_BUILTIN (olddecl)
	&& !DECL_EXTERN_INLINE (olddecl))
	{
	error ("static declaration of %q+D follows "
	"non-static declaration", newdecl);
	locate_old_decl (olddecl, error);
	}
	return false;
	}
	else if (TREE_PUBLIC (newdecl) && !TREE_PUBLIC (olddecl))
	{
	if (DECL_CONTEXT (olddecl))
	{
	error ("non-static declaration of %q+D follows "
	"static declaration", newdecl);
	locate_old_decl (olddecl, error);
	return false;
	}
	else if (warn_traditional)
	{
	warning (OPT_Wtraditional, "non-static declaration of %q+D "
	"follows static declaration", newdecl);
	warned = true;
	}
	}

	/* Make sure gnu_inline attribute is either not present, or
	present on all inline decls. */
	if (DECL_DECLARED_INLINE_P (olddecl)
	&& DECL_DECLARED_INLINE_P (newdecl))
	{
	bool newa = lookup_attribute ("gnu_inline",
	DECL_ATTRIBUTES (newdecl)) != NULL;
	bool olda = lookup_attribute ("gnu_inline",
	DECL_ATTRIBUTES (olddecl)) != NULL;
	if (newa != olda)
	{
	error ("%<gnu_inline%> attribute present on %q+D",
	newa ? newdecl : olddecl);
	error ("%Jbut not here", newa ? olddecl : newdecl);
	}
	}
	}
	else if (TREE_CODE (newdecl) == VAR_DECL)
	{
	/* Only variables can be thread-local, and all declarations must
	agree on this property. */
	if (C_DECL_THREADPRIVATE_P (olddecl) && !DECL_THREAD_LOCAL_P (newdecl))
	{
	/* Nothing to check. Since OLDDECL is marked threadprivate
	and NEWDECL does not have a thread-local attribute, we
	will merge the threadprivate attribute into NEWDECL. */
	;
	}
	else if (DECL_THREAD_LOCAL_P (newdecl) != DECL_THREAD_LOCAL_P (olddecl))
	{
	if (DECL_THREAD_LOCAL_P (newdecl))
	error ("thread-local declaration of %q+D follows "
	"non-thread-local declaration", newdecl);
	else
	error ("non-thread-local declaration of %q+D follows "
	"thread-local declaration", newdecl);

	locate_old_decl (olddecl, error);
	return false;
	}

	/* Multiple initialized definitions are not allowed (6.9p3,5). */
	if (DECL_INITIAL (newdecl) && DECL_INITIAL (olddecl))
	{
	error ("redefinition of %q+D", newdecl);
	locate_old_decl (olddecl, error);
	return false;
	}

	/* Objects declared at file scope: if the first declaration had
	external linkage (even if it was an external reference) the
	second must have external linkage as well, or the behavior is
	undefined. If the first declaration had internal linkage, then
	the second must too, or else be an external reference (in which
	case the composite declaration still has internal linkage).
	As for function declarations, we warn about the static-then-
	extern case only for -Wtraditional. See generally 6.2.2p3-5,7. */
	if (DECL_FILE_SCOPE_P (newdecl)
	&& TREE_PUBLIC (newdecl) != TREE_PUBLIC (olddecl))
	{
	if (DECL_EXTERNAL (newdecl))
	{
	if (!DECL_FILE_SCOPE_P (olddecl))
	{
	error ("extern declaration of %q+D follows "
	"declaration with no linkage", newdecl);
	locate_old_decl (olddecl, error);
	return false;
	}
	else if (warn_traditional)
	{
	warning (OPT_Wtraditional, "non-static declaration of %q+D "
	"follows static declaration", newdecl);
	warned = true;
	}
	}
	else
	{
	if (TREE_PUBLIC (newdecl))
	error ("non-static declaration of %q+D follows "
	"static declaration", newdecl);
	else
	error ("static declaration of %q+D follows "
	"non-static declaration", newdecl);

	locate_old_decl (olddecl, error);
	return false;
	}
	}
	/* Two objects with the same name declared at the same block
	scope must both be external references (6.7p3). */
	else if (!DECL_FILE_SCOPE_P (newdecl))
	{
	if (DECL_EXTERNAL (newdecl))
	{
	/* Extern with initializer at block scope, which will
	already have received an error. */
	}
	else if (DECL_EXTERNAL (olddecl))
	{
	error ("declaration of %q+D with no linkage follows "
	"extern declaration", newdecl);
	locate_old_decl (olddecl, error);
	}
	else
	{
	error ("redeclaration of %q+D with no linkage", newdecl);
	locate_old_decl (olddecl, error);
	}

	return false;
	}
	}

	/* warnings */
	/* All decls must agree on a visibility. */
	if (CODE_CONTAINS_STRUCT (TREE_CODE (newdecl), TS_DECL_WITH_VIS)
	&& DECL_VISIBILITY_SPECIFIED (newdecl) && DECL_VISIBILITY_SPECIFIED (olddecl)
	&& DECL_VISIBILITY (newdecl) != DECL_VISIBILITY (olddecl))
	{
	warning (0, "redeclaration of %q+D with different visibility "
	"(old visibility preserved)", newdecl);
	warned = true;
	}

	if (TREE_CODE (newdecl) == FUNCTION_DECL)
	{
	/* Diagnose inline __attribute__ ((noinline)) which is silly. */
	if (DECL_DECLARED_INLINE_P (newdecl)
	&& lookup_attribute ("noinline", DECL_ATTRIBUTES (olddecl)))
	{
	warning (OPT_Wattributes, "inline declaration of %qD follows "
	"declaration with attribute noinline", newdecl);
	warned = true;
	}
	else if (DECL_DECLARED_INLINE_P (olddecl)
	&& lookup_attribute ("noinline", DECL_ATTRIBUTES (newdecl)))
	{
	warning (OPT_Wattributes, "declaration of %q+D with attribute "
	"noinline follows inline declaration ", newdecl);
	warned = true;
	}

	/* Inline declaration after use or definition.
	??? Should we still warn about this now we have unit-at-a-time
	mode and can get it right?
	Definitely don't complain if the decls are in different translation
	units.
	C99 permits this, so don't warn in that case. (The function
	may not be inlined everywhere in function-at-a-time mode, but
	we still shouldn't warn.) */
	if (DECL_DECLARED_INLINE_P (newdecl) && !DECL_DECLARED_INLINE_P (olddecl)
	&& same_translation_unit_p (olddecl, newdecl)
	&& flag_gnu89_inline)
	{
	if (TREE_USED (olddecl))
	{
	warning (0, "%q+D declared inline after being called", olddecl);
	warned = true;
	}
	else if (DECL_INITIAL (olddecl))
	{
	warning (0, "%q+D declared inline after its definition", olddecl);
	warned = true;
	}
	}
	}
	else /* PARM_DECL, VAR_DECL */
	{
	/* Redeclaration of a parameter is a constraint violation (this is
	not explicitly stated, but follows from C99 6.7p3 [no more than
	one declaration of the same identifier with no linkage in the
	same scope, except type tags] and 6.2.2p6 [parameters have no
	linkage]). We must check for a forward parameter declaration,
	indicated by TREE_ASM_WRITTEN on the old declaration - this is
	an extension, the mandatory diagnostic for which is handled by
	mark_forward_parm_decls. */

	if (TREE_CODE (newdecl) == PARM_DECL
	&& (!TREE_ASM_WRITTEN (olddecl) \|\| TREE_ASM_WRITTEN (newdecl)))
	{
	error ("redefinition of parameter %q+D", newdecl);
	locate_old_decl (olddecl, error);
	return false;
	}
	}

	/* Optional warning for completely redundant decls. */
	if (!warned && !pedwarned
	&& warn_redundant_decls
	/* Don't warn about a function declaration followed by a
	definition. */
	&& !(TREE_CODE (newdecl) == FUNCTION_DECL
	&& DECL_INITIAL (newdecl) && !DECL_INITIAL (olddecl))
	/* Don't warn about redundant redeclarations of builtins. */
	&& !(TREE_CODE (newdecl) == FUNCTION_DECL
	&& !DECL_BUILT_IN (newdecl)
	&& DECL_BUILT_IN (olddecl)
	&& !C_DECL_DECLARED_BUILTIN (olddecl))
	/* Don't warn about an extern followed by a definition. */
	&& !(DECL_EXTERNAL (olddecl) && !DECL_EXTERNAL (newdecl))
	/* Don't warn about forward parameter decls. */
	&& !(TREE_CODE (newdecl) == PARM_DECL
	&& TREE_ASM_WRITTEN (olddecl) && !TREE_ASM_WRITTEN (newdecl))
	/* Don't warn about a variable definition following a declaration. */
	&& !(TREE_CODE (newdecl) == VAR_DECL
	&& DECL_INITIAL (newdecl) && !DECL_INITIAL (olddecl)))
	{
	warning (OPT_Wredundant_decls, "redundant redeclaration of %q+D",
	newdecl);
	warned = true;
	}

	/* Report location of previous decl/defn in a consistent manner. */
	if (warned \|\| pedwarned)
	locate_old_decl (olddecl, pedwarned ? pedwarn : warning0);

	#undef DECL_EXTERN_INLINE

	return retval;
	}

	/* Subroutine of duplicate_decls. NEWDECL has been found to be
	consistent with OLDDECL, but carries new information. Merge the
	new information into OLDDECL. This function issues no
	diagnostics. */

	static void
	merge_decls (tree newdecl, tree olddecl, tree newtype, tree oldtype)
	{
	bool new_is_definition = (TREE_CODE (newdecl) == FUNCTION_DECL
	&& DECL_INITIAL (newdecl) != 0);
	bool new_is_prototype = (TREE_CODE (newdecl) == FUNCTION_DECL
	&& TYPE_ARG_TYPES (TREE_TYPE (newdecl)) != 0);
	bool old_is_prototype = (TREE_CODE (olddecl) == FUNCTION_DECL
	&& TYPE_ARG_TYPES (TREE_TYPE (olddecl)) != 0);
	bool extern_changed = false;

	/* For real parm decl following a forward decl, rechain the old decl
	in its new location and clear TREE_ASM_WRITTEN (it's not a
	forward decl anymore). */
	if (TREE_CODE (newdecl) == PARM_DECL
	&& TREE_ASM_WRITTEN (olddecl) && !TREE_ASM_WRITTEN (newdecl))
	{
	struct c_binding b, *here;

	for (here = &current_scope->bindings; here; here = &(here)->prev)
	if ((*here)->decl == olddecl)
	goto found;
	gcc_unreachable ();

	found:
	b = *here;
	*here = b->prev;
	b->prev = current_scope->bindings;
	current_scope->bindings = b;

	TREE_ASM_WRITTEN (olddecl) = 0;
	}

	DECL_ATTRIBUTES (newdecl)
	= targetm.merge_decl_attributes (olddecl, newdecl);

	/* Merge the data types specified in the two decls. */
	TREE_TYPE (newdecl)
	= TREE_TYPE (olddecl)
	= composite_type (newtype, oldtype);

	/* Lay the type out, unless already done. */
	if (!comptypes (oldtype, TREE_TYPE (newdecl)))
	{
	if (TREE_TYPE (newdecl) != error_mark_node)
	layout_type (TREE_TYPE (newdecl));
	if (TREE_CODE (newdecl) != FUNCTION_DECL
	&& TREE_CODE (newdecl) != TYPE_DECL
	&& TREE_CODE (newdecl) != CONST_DECL)
	layout_decl (newdecl, 0);
	}
	else
	{
	/* Since the type is OLDDECL's, make OLDDECL's size go with. */
	DECL_SIZE (newdecl) = DECL_SIZE (olddecl);
	DECL_SIZE_UNIT (newdecl) = DECL_SIZE_UNIT (olddecl);
	DECL_MODE (newdecl) = DECL_MODE (olddecl);
	if (DECL_ALIGN (olddecl) > DECL_ALIGN (newdecl))
	{
	DECL_ALIGN (newdecl) = DECL_ALIGN (olddecl);
	DECL_USER_ALIGN (newdecl) \|= DECL_ALIGN (olddecl);
	}
	}


	/* Merge the type qualifiers. */
	if (TREE_READONLY (newdecl))
	TREE_READONLY (olddecl) = 1;

	if (TREE_THIS_VOLATILE (newdecl))
	TREE_THIS_VOLATILE (olddecl) = 1;

	/* Merge deprecatedness. */
	if (TREE_DEPRECATED (newdecl))
	TREE_DEPRECATED (olddecl) = 1;

	+ /* APPLE LOCAL begin "unavailable" attribute (radar 2809697) */
	+ /* Merge unavailableness. */
	+ if (TREE_UNAVAILABLE (newdecl))
	+ TREE_UNAVAILABLE (olddecl) = 1;
	+ /* APPLE LOCAL end "unavailable" attribute (radar 2809697) */
	+
	/* Keep source location of definition rather than declaration and of
	prototype rather than non-prototype unless that prototype is
	built-in. */
	if ((DECL_INITIAL (newdecl) == 0 && DECL_INITIAL (olddecl) != 0)
	\|\| (old_is_prototype && !new_is_prototype
	&& !C_DECL_BUILTIN_PROTOTYPE (olddecl)))
	DECL_SOURCE_LOCATION (newdecl) = DECL_SOURCE_LOCATION (olddecl);

	/* Merge the initialization information. */
	if (DECL_INITIAL (newdecl) == 0)
	DECL_INITIAL (newdecl) = DECL_INITIAL (olddecl);

	/* Merge the threadprivate attribute. */
	if (TREE_CODE (olddecl) == VAR_DECL && C_DECL_THREADPRIVATE_P (olddecl))
	{
	DECL_TLS_MODEL (newdecl) = DECL_TLS_MODEL (olddecl);
	C_DECL_THREADPRIVATE_P (newdecl) = 1;
	}

	if (CODE_CONTAINS_STRUCT (TREE_CODE (olddecl), TS_DECL_WITH_VIS))
	{
	/* Merge the unused-warning information. */
	if (DECL_IN_SYSTEM_HEADER (olddecl))
	DECL_IN_SYSTEM_HEADER (newdecl) = 1;
	else if (DECL_IN_SYSTEM_HEADER (newdecl))
	DECL_IN_SYSTEM_HEADER (olddecl) = 1;

	/* Merge the section attribute.
	We want to issue an error if the sections conflict but that
	must be done later in decl_attributes since we are called
	before attributes are assigned. */
	if (DECL_SECTION_NAME (newdecl) == NULL_TREE)
	DECL_SECTION_NAME (newdecl) = DECL_SECTION_NAME (olddecl);

	/* Copy the assembler name.
	Currently, it can only be defined in the prototype. */
	COPY_DECL_ASSEMBLER_NAME (olddecl, newdecl);

	/* Use visibility of whichever declaration had it specified */
	if (DECL_VISIBILITY_SPECIFIED (olddecl))
	{
	DECL_VISIBILITY (newdecl) = DECL_VISIBILITY (olddecl);
	DECL_VISIBILITY_SPECIFIED (newdecl) = 1;
	}

	if (TREE_CODE (newdecl) == FUNCTION_DECL)
	{
	DECL_STATIC_CONSTRUCTOR(newdecl) \|= DECL_STATIC_CONSTRUCTOR(olddecl);
	DECL_STATIC_DESTRUCTOR (newdecl) \|= DECL_STATIC_DESTRUCTOR (olddecl);
	DECL_NO_LIMIT_STACK (newdecl) \|= DECL_NO_LIMIT_STACK (olddecl);
	DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (newdecl)
	\|= DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (olddecl);
	TREE_THIS_VOLATILE (newdecl) \|= TREE_THIS_VOLATILE (olddecl);
	TREE_READONLY (newdecl) \|= TREE_READONLY (olddecl);
	DECL_IS_MALLOC (newdecl) \|= DECL_IS_MALLOC (olddecl);
	DECL_IS_PURE (newdecl) \|= DECL_IS_PURE (olddecl);
	DECL_IS_NOVOPS (newdecl) \|= DECL_IS_NOVOPS (olddecl);
	}

	/* Merge the storage class information. */
	merge_weak (newdecl, olddecl);

	/* For functions, static overrides non-static. */
	if (TREE_CODE (newdecl) == FUNCTION_DECL)
	{
	TREE_PUBLIC (newdecl) &= TREE_PUBLIC (olddecl);
	/* This is since we don't automatically
	copy the attributes of NEWDECL into OLDDECL. */
	TREE_PUBLIC (olddecl) = TREE_PUBLIC (newdecl);
	/* If this clears `static', clear it in the identifier too. */
	if (!TREE_PUBLIC (olddecl))
	TREE_PUBLIC (DECL_NAME (olddecl)) = 0;
	}
	}

	/* In c99, 'extern' declaration before (or after) 'inline' means this
	function is not DECL_EXTERNAL, unless 'gnu_inline' attribute
	is present. */
	if (TREE_CODE (newdecl) == FUNCTION_DECL
	&& !flag_gnu89_inline
	&& (DECL_DECLARED_INLINE_P (newdecl)
	\|\| DECL_DECLARED_INLINE_P (olddecl))
	&& (!DECL_DECLARED_INLINE_P (newdecl)
	\|\| !DECL_DECLARED_INLINE_P (olddecl)
	\|\| !DECL_EXTERNAL (olddecl))
	&& DECL_EXTERNAL (newdecl)
	&& !lookup_attribute ("gnu_inline", DECL_ATTRIBUTES (newdecl)))
	DECL_EXTERNAL (newdecl) = 0;

	if (DECL_EXTERNAL (newdecl))
	{
	TREE_STATIC (newdecl) = TREE_STATIC (olddecl);
	DECL_EXTERNAL (newdecl) = DECL_EXTERNAL (olddecl);

	/* An extern decl does not override previous storage class. */
	TREE_PUBLIC (newdecl) = TREE_PUBLIC (olddecl);
	if (!DECL_EXTERNAL (newdecl))
	{
	DECL_CONTEXT (newdecl) = DECL_CONTEXT (olddecl);
	DECL_COMMON (newdecl) = DECL_COMMON (olddecl);
	}
	}
	else
	{
	TREE_STATIC (olddecl) = TREE_STATIC (newdecl);
	TREE_PUBLIC (olddecl) = TREE_PUBLIC (newdecl);
	}

	if (TREE_CODE (newdecl) == FUNCTION_DECL)
	{
	/* If we're redefining a function previously defined as extern
	inline, make sure we emit debug info for the inline before we
	throw it away, in case it was inlined into a function that
	hasn't been written out yet. */
	if (new_is_definition && DECL_INITIAL (olddecl))
	{
	if (TREE_USED (olddecl)
	/* In unit-at-a-time mode we never inline re-defined extern
	inline functions. */
	&& !flag_unit_at_a_time
	&& cgraph_function_possibly_inlined_p (olddecl))
	(*debug_hooks->outlining_inline_function) (olddecl);

	/* The new defn must not be inline. */
	DECL_INLINE (newdecl) = 0;
	DECL_UNINLINABLE (newdecl) = 1;
	}
	else
	{
	/* If either decl says `inline', this fn is inline, unless
	its definition was passed already. */
	if (DECL_DECLARED_INLINE_P (newdecl)
	\|\| DECL_DECLARED_INLINE_P (olddecl))
	DECL_DECLARED_INLINE_P (newdecl) = 1;

	DECL_UNINLINABLE (newdecl) = DECL_UNINLINABLE (olddecl)
	= (DECL_UNINLINABLE (newdecl) \|\| DECL_UNINLINABLE (olddecl));
	}

	if (DECL_BUILT_IN (olddecl))
	{
	/* If redeclaring a builtin function, it stays built in.
	But it gets tagged as having been declared. */
	DECL_BUILT_IN_CLASS (newdecl) = DECL_BUILT_IN_CLASS (olddecl);
	DECL_FUNCTION_CODE (newdecl) = DECL_FUNCTION_CODE (olddecl);
	C_DECL_DECLARED_BUILTIN (newdecl) = 1;
	if (new_is_prototype)
	C_DECL_BUILTIN_PROTOTYPE (newdecl) = 0;
	else
	C_DECL_BUILTIN_PROTOTYPE (newdecl)
	= C_DECL_BUILTIN_PROTOTYPE (olddecl);
	}

	/* Also preserve various other info from the definition. */
	if (!new_is_definition)
	{
	DECL_RESULT (newdecl) = DECL_RESULT (olddecl);
	DECL_INITIAL (newdecl) = DECL_INITIAL (olddecl);
	DECL_STRUCT_FUNCTION (newdecl) = DECL_STRUCT_FUNCTION (olddecl);
	DECL_SAVED_TREE (newdecl) = DECL_SAVED_TREE (olddecl);
	DECL_ARGUMENTS (newdecl) = DECL_ARGUMENTS (olddecl);

	/* Set DECL_INLINE on the declaration if we've got a body
	from which to instantiate. */
	if (DECL_INLINE (olddecl) && !DECL_UNINLINABLE (newdecl))
	{
	DECL_INLINE (newdecl) = 1;
	DECL_ABSTRACT_ORIGIN (newdecl)
	= DECL_ABSTRACT_ORIGIN (olddecl);
	}
	}
	else
	{
	/* If a previous declaration said inline, mark the
	definition as inlinable. */
	if (DECL_DECLARED_INLINE_P (newdecl)
	&& !DECL_UNINLINABLE (newdecl))
	DECL_INLINE (newdecl) = 1;
	}
	}

	extern_changed = DECL_EXTERNAL (olddecl) && !DECL_EXTERNAL (newdecl);

	/* Copy most of the decl-specific fields of NEWDECL into OLDDECL.
	But preserve OLDDECL's DECL_UID and DECL_CONTEXT. */
	{
	unsigned olddecl_uid = DECL_UID (olddecl);
	tree olddecl_context = DECL_CONTEXT (olddecl);

	memcpy ((char *) olddecl + sizeof (struct tree_common),
	(char *) newdecl + sizeof (struct tree_common),
	sizeof (struct tree_decl_common) - sizeof (struct tree_common));
	switch (TREE_CODE (olddecl))
	{
	case FIELD_DECL:
	case VAR_DECL:
	case PARM_DECL:
	case LABEL_DECL:
	case RESULT_DECL:
	case CONST_DECL:
	case TYPE_DECL:
	case FUNCTION_DECL:
	memcpy ((char *) olddecl + sizeof (struct tree_decl_common),
	(char *) newdecl + sizeof (struct tree_decl_common),
	tree_code_size (TREE_CODE (olddecl)) - sizeof (struct tree_decl_common));
	break;

	default:

	memcpy ((char *) olddecl + sizeof (struct tree_decl_common),
	(char *) newdecl + sizeof (struct tree_decl_common),
	sizeof (struct tree_decl_non_common) - sizeof (struct tree_decl_common));
	}
	DECL_UID (olddecl) = olddecl_uid;
	DECL_CONTEXT (olddecl) = olddecl_context;
	}

	/* If OLDDECL had its DECL_RTL instantiated, re-invoke make_decl_rtl
	so that encode_section_info has a chance to look at the new decl
	flags and attributes. */
	if (DECL_RTL_SET_P (olddecl)
	&& (TREE_CODE (olddecl) == FUNCTION_DECL
	\|\| (TREE_CODE (olddecl) == VAR_DECL
	&& TREE_STATIC (olddecl))))
	make_decl_rtl (olddecl);

	/* If we changed a function from DECL_EXTERNAL to !DECL_EXTERNAL,
	and the definition is coming from the old version, cgraph needs
	to be called again. */
	if (extern_changed && !new_is_definition
	&& TREE_CODE (olddecl) == FUNCTION_DECL && DECL_INITIAL (olddecl))
	cgraph_finalize_function (olddecl, false);
	}

	/* Handle when a new declaration NEWDECL has the same name as an old
	one OLDDECL in the same binding contour. Prints an error message
	if appropriate.

	If safely possible, alter OLDDECL to look like NEWDECL, and return
	true. Otherwise, return false. */

	static bool
	duplicate_decls (tree newdecl, tree olddecl)
	{
	tree newtype = NULL, oldtype = NULL;

	if (!diagnose_mismatched_decls (newdecl, olddecl, &newtype, &oldtype))
	{
	/* Avoid `unused variable' and other warnings warnings for OLDDECL. */
	TREE_NO_WARNING (olddecl) = 1;
	return false;
	}

	merge_decls (newdecl, olddecl, newtype, oldtype);
	return true;
	}


	/* Check whether decl-node NEW_DECL shadows an existing declaration. */
	static void
	warn_if_shadowing (tree new_decl)
	{
	struct c_binding *b;

	/* Shadow warnings wanted? */
	if (!warn_shadow
	/* No shadow warnings for internally generated vars. */
	\|\| DECL_IS_BUILTIN (new_decl)
	/* No shadow warnings for vars made for inlining. */
	\|\| DECL_FROM_INLINE (new_decl))
	return;

	/* Is anything being shadowed? Invisible decls do not count. */
	for (b = I_SYMBOL_BINDING (DECL_NAME (new_decl)); b; b = b->shadowed)
	if (b->decl && b->decl != new_decl && !b->invisible)
	{
	tree old_decl = b->decl;

	if (old_decl == error_mark_node)
	{
	warning (OPT_Wshadow, "declaration of %q+D shadows previous "
	"non-variable", new_decl);
	break;
	}
	else if (TREE_CODE (old_decl) == PARM_DECL)
	warning (OPT_Wshadow, "declaration of %q+D shadows a parameter",
	new_decl);
	else if (DECL_FILE_SCOPE_P (old_decl))
	warning (OPT_Wshadow, "declaration of %q+D shadows a global "
	"declaration", new_decl);
	else if (TREE_CODE (old_decl) == FUNCTION_DECL
	&& DECL_BUILT_IN (old_decl))
	{
	warning (OPT_Wshadow, "declaration of %q+D shadows "
	"a built-in function", new_decl);
	break;
	}
	else
	warning (OPT_Wshadow, "declaration of %q+D shadows a previous local",
	new_decl);

	warning (OPT_Wshadow, "%Jshadowed declaration is here", old_decl);

	break;
	}
	}


	/* Subroutine of pushdecl.

	X is a TYPE_DECL for a typedef statement. Create a brand new
	..._TYPE node (which will be just a variant of the existing
	..._TYPE node with identical properties) and then install X
	as the TYPE_NAME of this brand new (duplicate) ..._TYPE node.

	The whole point here is to end up with a situation where each
	and every ..._TYPE node the compiler creates will be uniquely
	associated with AT MOST one node representing a typedef name.
	This way, even though the compiler substitutes corresponding
	..._TYPE nodes for TYPE_DECL (i.e. "typedef name") nodes very
	early on, later parts of the compiler can always do the reverse
	translation and get back the corresponding typedef name. For
	example, given:

	typedef struct S MY_TYPE;
	MY_TYPE object;

	Later parts of the compiler might only know that `object' was of
	type `struct S' if it were not for code just below. With this
	code however, later parts of the compiler see something like:

	struct S' == struct S
	typedef struct S' MY_TYPE;
	struct S' object;

	And they can then deduce (from the node for type struct S') that
	the original object declaration was:

	MY_TYPE object;

	Being able to do this is important for proper support of protoize,
	and also for generating precise symbolic debugging information
	which takes full account of the programmer's (typedef) vocabulary.

	Obviously, we don't want to generate a duplicate ..._TYPE node if
	the TYPE_DECL node that we are now processing really represents a
	standard built-in type.

	Since all standard types are effectively declared at line zero
	in the source file, we can easily check to see if we are working
	on a standard type by checking the current value of lineno. */

	static void
	clone_underlying_type (tree x)
	{
	if (DECL_IS_BUILTIN (x))
	{
	if (TYPE_NAME (TREE_TYPE (x)) == 0)
	TYPE_NAME (TREE_TYPE (x)) = x;
	}
	else if (TREE_TYPE (x) != error_mark_node
	&& DECL_ORIGINAL_TYPE (x) == NULL_TREE)
	{
	tree tt = TREE_TYPE (x);
	DECL_ORIGINAL_TYPE (x) = tt;
	tt = build_variant_type_copy (tt);
	TYPE_NAME (tt) = x;
	TREE_USED (tt) = TREE_USED (x);
	TREE_TYPE (x) = tt;
	}
	}

	/* Record a decl-node X as belonging to the current lexical scope.
	Check for errors (such as an incompatible declaration for the same
	name already seen in the same scope).

	Returns either X or an old decl for the same name.
	If an old decl is returned, it may have been smashed
	to agree with what X says. */

	tree
	pushdecl (tree x)
	{
	tree name = DECL_NAME (x);
	struct c_scope *scope = current_scope;
	struct c_binding *b;
	bool nested = false;

	/* Functions need the lang_decl data. */
	if (TREE_CODE (x) == FUNCTION_DECL && !DECL_LANG_SPECIFIC (x))
	DECL_LANG_SPECIFIC (x) = GGC_CNEW (struct lang_decl);

	/* Must set DECL_CONTEXT for everything not at file scope or
	DECL_FILE_SCOPE_P won't work. Local externs don't count
	unless they have initializers (which generate code). */
	if (current_function_decl
	&& ((TREE_CODE (x) != FUNCTION_DECL && TREE_CODE (x) != VAR_DECL)
	\|\| DECL_INITIAL (x) \|\| !DECL_EXTERNAL (x)))
	DECL_CONTEXT (x) = current_function_decl;

	/* If this is of variably modified type, prevent jumping into its
	scope. */
	if ((TREE_CODE (x) == VAR_DECL \|\| TREE_CODE (x) == TYPE_DECL)
	&& variably_modified_type_p (TREE_TYPE (x), NULL_TREE))
	c_begin_vm_scope (scope->depth);

	/* Anonymous decls are just inserted in the scope. */
	if (!name)
	{
	bind (name, x, scope, /invisible=/false, /nested=/false);
	return x;
	}

	/* First, see if there is another declaration with the same name in
	the current scope. If there is, duplicate_decls may do all the
	work for us. If duplicate_decls returns false, that indicates
	two incompatible decls in the same scope; we are to silently
	replace the old one (duplicate_decls has issued all appropriate
	diagnostics). In particular, we should not consider possible
	duplicates in the external scope, or shadowing. */
	b = I_SYMBOL_BINDING (name);
	if (b && B_IN_SCOPE (b, scope))
	{
	struct c_binding b_ext, b_use;
	tree type = TREE_TYPE (x);
	tree visdecl = b->decl;
	tree vistype = TREE_TYPE (visdecl);
	if (TREE_CODE (TREE_TYPE (x)) == ARRAY_TYPE
	&& COMPLETE_TYPE_P (TREE_TYPE (x)))
	b->inner_comp = false;
	b_use = b;
	b_ext = b;
	/* If this is an external linkage declaration, we should check
	for compatibility with the type in the external scope before
	setting the type at this scope based on the visible
	information only. */
	if (TREE_PUBLIC (x) && TREE_PUBLIC (visdecl))
	{
	while (b_ext && !B_IN_EXTERNAL_SCOPE (b_ext))
	b_ext = b_ext->shadowed;
	if (b_ext)
	{
	b_use = b_ext;
	if (b_use->type)
	TREE_TYPE (b_use->decl) = b_use->type;
	}
	}
	if (duplicate_decls (x, b_use->decl))
	{
	if (b_use != b)
	{
	/* Save the updated type in the external scope and
	restore the proper type for this scope. */
	tree thistype;
	if (comptypes (vistype, type))
	thistype = composite_type (vistype, type);
	else
	thistype = TREE_TYPE (b_use->decl);
	b_use->type = TREE_TYPE (b_use->decl);
	if (TREE_CODE (b_use->decl) == FUNCTION_DECL
	&& DECL_BUILT_IN (b_use->decl))
	thistype
	= build_type_attribute_variant (thistype,
	TYPE_ATTRIBUTES
	(b_use->type));
	TREE_TYPE (b_use->decl) = thistype;
	}
	return b_use->decl;
	}
	else
	goto skip_external_and_shadow_checks;
	}

	/* All declarations with external linkage, and all external
	references, go in the external scope, no matter what scope is
	current. However, the binding in that scope is ignored for
	purposes of normal name lookup. A separate binding structure is
	created in the requested scope; this governs the normal
	visibility of the symbol.

	The binding in the externals scope is used exclusively for
	detecting duplicate declarations of the same object, no matter
	what scope they are in; this is what we do here. (C99 6.2.7p2:
	All declarations that refer to the same object or function shall
	have compatible type; otherwise, the behavior is undefined.) */
	if (DECL_EXTERNAL (x) \|\| scope == file_scope)
	{
	tree type = TREE_TYPE (x);
	tree vistype = 0;
	tree visdecl = 0;
	bool type_saved = false;
	if (b && !B_IN_EXTERNAL_SCOPE (b)
	&& (TREE_CODE (b->decl) == FUNCTION_DECL
	\|\| TREE_CODE (b->decl) == VAR_DECL)
	&& DECL_FILE_SCOPE_P (b->decl))
	{
	visdecl = b->decl;
	vistype = TREE_TYPE (visdecl);
	}
	if (scope != file_scope
	&& !DECL_IN_SYSTEM_HEADER (x))
	warning (OPT_Wnested_externs, "nested extern declaration of %qD", x);

	while (b && !B_IN_EXTERNAL_SCOPE (b))
	{
	/* If this decl might be modified, save its type. This is
	done here rather than when the decl is first bound
	because the type may change after first binding, through
	being completed or through attributes being added. If we
	encounter multiple such decls, only the first should have
	its type saved; the others will already have had their
	proper types saved and the types will not have changed as
	their scopes will not have been re-entered. */
	if (DECL_P (b->decl) && DECL_FILE_SCOPE_P (b->decl) && !type_saved)
	{
	b->type = TREE_TYPE (b->decl);
	type_saved = true;
	}
	if (B_IN_FILE_SCOPE (b)
	&& TREE_CODE (b->decl) == VAR_DECL
	&& TREE_STATIC (b->decl)
	&& TREE_CODE (TREE_TYPE (b->decl)) == ARRAY_TYPE
	&& !TYPE_DOMAIN (TREE_TYPE (b->decl))
	&& TREE_CODE (type) == ARRAY_TYPE
	&& TYPE_DOMAIN (type)
	&& TYPE_MAX_VALUE (TYPE_DOMAIN (type))
	&& !integer_zerop (TYPE_MAX_VALUE (TYPE_DOMAIN (type))))
	{
	/* Array type completed in inner scope, which should be
	diagnosed if the completion does not have size 1 and
	it does not get completed in the file scope. */
	b->inner_comp = true;
	}
	b = b->shadowed;
	}

	/* If a matching external declaration has been found, set its
	type to the composite of all the types of that declaration.
	After the consistency checks, it will be reset to the
	composite of the visible types only. */
	if (b && (TREE_PUBLIC (x) \|\| same_translation_unit_p (x, b->decl))
	&& b->type)
	TREE_TYPE (b->decl) = b->type;

	/* The point of the same_translation_unit_p check here is,
	we want to detect a duplicate decl for a construct like
	foo() { extern bar(); } ... static bar(); but not if
	they are in different translation units. In any case,
	the static does not go in the externals scope. */
	if (b
	&& (TREE_PUBLIC (x) \|\| same_translation_unit_p (x, b->decl))
	&& duplicate_decls (x, b->decl))
	{
	tree thistype;
	if (vistype)
	{
	if (comptypes (vistype, type))
	thistype = composite_type (vistype, type);
	else
	thistype = TREE_TYPE (b->decl);
	}
	else
	thistype = type;
	b->type = TREE_TYPE (b->decl);
	if (TREE_CODE (b->decl) == FUNCTION_DECL && DECL_BUILT_IN (b->decl))
	thistype
	= build_type_attribute_variant (thistype,
	TYPE_ATTRIBUTES (b->type));
	TREE_TYPE (b->decl) = thistype;
	bind (name, b->decl, scope, /invisible=/false, /nested=/true);
	return b->decl;
	}
	else if (TREE_PUBLIC (x))
	{
	if (visdecl && !b && duplicate_decls (x, visdecl))
	{
	/* An external declaration at block scope referring to a
	visible entity with internal linkage. The composite
	type will already be correct for this scope, so we
	just need to fall through to make the declaration in
	this scope. */
	nested = true;
	x = visdecl;
	}
	else
	{
	bind (name, x, external_scope, /invisible=/true,
	/nested=/false);
	nested = true;
	}
	}
	}

	if (TREE_CODE (x) != PARM_DECL)
	warn_if_shadowing (x);

	skip_external_and_shadow_checks:
	if (TREE_CODE (x) == TYPE_DECL)
	clone_underlying_type (x);

	bind (name, x, scope, /invisible=/false, nested);

	/* If x's type is incomplete because it's based on a
	structure or union which has not yet been fully declared,
	attach it to that structure or union type, so we can go
	back and complete the variable declaration later, if the
	structure or union gets fully declared.

	If the input is erroneous, we can have error_mark in the type
	slot (e.g. "f(void a, ...)") - that doesn't count as an
	incomplete type. */
	if (TREE_TYPE (x) != error_mark_node
	&& !COMPLETE_TYPE_P (TREE_TYPE (x)))
	{
	tree element = TREE_TYPE (x);

	while (TREE_CODE (element) == ARRAY_TYPE)
	element = TREE_TYPE (element);
	element = TYPE_MAIN_VARIANT (element);

	if ((TREE_CODE (element) == RECORD_TYPE
	\|\| TREE_CODE (element) == UNION_TYPE)
	&& (TREE_CODE (x) != TYPE_DECL
	\|\| TREE_CODE (TREE_TYPE (x)) == ARRAY_TYPE)
	&& !COMPLETE_TYPE_P (element))
	C_TYPE_INCOMPLETE_VARS (element)
	= tree_cons (NULL_TREE, x, C_TYPE_INCOMPLETE_VARS (element));
	}
	return x;
	}

	/* Record X as belonging to file scope.
	This is used only internally by the Objective-C front end,
	and is limited to its needs. duplicate_decls is not called;
	if there is any preexisting decl for this identifier, it is an ICE. */

	tree
	pushdecl_top_level (tree x)
	{
	tree name;
	bool nested = false;
	gcc_assert (TREE_CODE (x) == VAR_DECL \|\| TREE_CODE (x) == CONST_DECL);

	name = DECL_NAME (x);

	gcc_assert (TREE_CODE (x) == CONST_DECL \|\| !I_SYMBOL_BINDING (name));

	if (TREE_PUBLIC (x))
	{
	bind (name, x, external_scope, /invisible=/true, /nested=/false);
	nested = true;
	}
	if (file_scope)
	bind (name, x, file_scope, /invisible=/false, nested);

	return x;
	}

	static void
	implicit_decl_warning (tree id, tree olddecl)
	{
	void (diag) (const char , ...) ATTRIBUTE_GCC_CDIAG(1,2);
	switch (mesg_implicit_function_declaration)
	{
	case 0: return;
	case 1: diag = warning0; break;
	case 2: diag = error; break;
	default: gcc_unreachable ();
	}

	diag (G_("implicit declaration of function %qE"), id);
	if (olddecl)
	locate_old_decl (olddecl, diag);
	}

	/* Generate an implicit declaration for identifier FUNCTIONID as a
	function of type int (). */

	tree
	implicitly_declare (tree functionid)
	{
	struct c_binding *b;
	tree decl = 0;
	tree asmspec_tree;

	for (b = I_SYMBOL_BINDING (functionid); b; b = b->shadowed)
	{
	if (B_IN_SCOPE (b, external_scope))
	{
	decl = b->decl;
	break;
	}
	}

	if (decl)
	{
	if (decl == error_mark_node)
	return decl;

	/* FIXME: Objective-C has weird not-really-builtin functions
	which are supposed to be visible automatically. They wind up
	in the external scope because they're pushed before the file
	scope gets created. Catch this here and rebind them into the
	file scope. */
	if (!DECL_BUILT_IN (decl) && DECL_IS_BUILTIN (decl))
	{
	bind (functionid, decl, file_scope,
	/invisible=/false, /nested=/true);
	return decl;
	}
	else
	{
	tree newtype = default_function_type;
	if (b->type)
	TREE_TYPE (decl) = b->type;
	/* Implicit declaration of a function already declared
	(somehow) in a different scope, or as a built-in.
	If this is the first time this has happened, warn;
	then recycle the old declaration but with the new type. */
	if (!C_DECL_IMPLICIT (decl))
	{
	implicit_decl_warning (functionid, decl);
	C_DECL_IMPLICIT (decl) = 1;
	}
	if (DECL_BUILT_IN (decl))
	{
	newtype = build_type_attribute_variant (newtype,
	TYPE_ATTRIBUTES
	(TREE_TYPE (decl)));
	if (!comptypes (newtype, TREE_TYPE (decl)))
	{
	warning (0, "incompatible implicit declaration of built-in"
	" function %qD", decl);
	newtype = TREE_TYPE (decl);
	}
	}
	else
	{
	if (!comptypes (newtype, TREE_TYPE (decl)))
	{
	error ("incompatible implicit declaration of function %qD",
	decl);
	locate_old_decl (decl, error);
	}
	}
	b->type = TREE_TYPE (decl);
	TREE_TYPE (decl) = newtype;
	bind (functionid, decl, current_scope,
	/invisible=/false, /nested=/true);
	return decl;
	}
	}

	/* Not seen before. */
	decl = build_decl (FUNCTION_DECL, functionid, default_function_type);
	DECL_EXTERNAL (decl) = 1;
	TREE_PUBLIC (decl) = 1;
	C_DECL_IMPLICIT (decl) = 1;
	implicit_decl_warning (functionid, 0);
	asmspec_tree = maybe_apply_renaming_pragma (decl, /asmname=/NULL);
	if (asmspec_tree)
	set_user_assembler_name (decl, TREE_STRING_POINTER (asmspec_tree));

	/* C89 says implicit declarations are in the innermost block.
	So we record the decl in the standard fashion. */
	decl = pushdecl (decl);

	/* No need to call objc_check_decl here - it's a function type. */
	rest_of_decl_compilation (decl, 0, 0);

	/* Write a record describing this implicit function declaration
	to the prototypes file (if requested). */
	gen_aux_info_record (decl, 0, 1, 0);

	/* Possibly apply some default attributes to this implicit declaration. */
	decl_attributes (&decl, NULL_TREE, 0);

	return decl;
	}

	/* Issue an error message for a reference to an undeclared variable
	ID, including a reference to a builtin outside of function-call
	context. Establish a binding of the identifier to error_mark_node
	in an appropriate scope, which will suppress further errors for the
	same identifier. The error message should be given location LOC. */
	void
	undeclared_variable (tree id, location_t loc)
	{
	static bool already = false;
	struct c_scope *scope;

	if (current_function_decl == 0)
	{
	error ("%H%qE undeclared here (not in a function)", &loc, id);
	scope = current_scope;
	}
	else
	{
	error ("%H%qE undeclared (first use in this function)", &loc, id);

	if (!already)
	{
	error ("%H(Each undeclared identifier is reported only once", &loc);
	error ("%Hfor each function it appears in.)", &loc);
	already = true;
	}

	/* If we are parsing old-style parameter decls, current_function_decl
	will be nonnull but current_function_scope will be null. */
	scope = current_function_scope ? current_function_scope : current_scope;
	}
	bind (id, error_mark_node, scope, /invisible=/false, /nested=/false);
	}

	/* Subroutine of lookup_label, declare_label, define_label: construct a
	LABEL_DECL with all the proper frills. */

	static tree
	make_label (tree name, location_t location)
	{
	tree label = build_decl (LABEL_DECL, name, void_type_node);

	DECL_CONTEXT (label) = current_function_decl;
	DECL_MODE (label) = VOIDmode;
	DECL_SOURCE_LOCATION (label) = location;

	return label;
	}

	/* Get the LABEL_DECL corresponding to identifier NAME as a label.
	Create one if none exists so far for the current function.
	This is called when a label is used in a goto expression or
	has its address taken. */

	tree
	lookup_label (tree name)
	{
	tree label;

	if (current_function_decl == 0)
	{
	error ("label %qE referenced outside of any function", name);
	return 0;
	}

	/* Use a label already defined or ref'd with this name, but not if
	it is inherited from a containing function and wasn't declared
	using __label__. */
	label = I_LABEL_DECL (name);
	if (label && (DECL_CONTEXT (label) == current_function_decl
	\|\| C_DECLARED_LABEL_FLAG (label)))
	{
	/* If the label has only been declared, update its apparent
	location to point here, for better diagnostics if it
	turns out not to have been defined. */
	if (!TREE_USED (label))
	DECL_SOURCE_LOCATION (label) = input_location;
	return label;
	}

	/* No label binding for that identifier; make one. */
	label = make_label (name, input_location);

	/* Ordinary labels go in the current function scope. */
	bind (name, label, current_function_scope,
	/invisible=/false, /nested=/false);
	return label;
	}

	/* Make a label named NAME in the current function, shadowing silently
	any that may be inherited from containing functions or containing
	scopes. This is called for __label__ declarations. */

	tree
	declare_label (tree name)
	{
	struct c_binding *b = I_LABEL_BINDING (name);
	tree label;

	/* Check to make sure that the label hasn't already been declared
	at this scope */
	if (b && B_IN_CURRENT_SCOPE (b))
	{
	error ("duplicate label declaration %qE", name);
	locate_old_decl (b->decl, error);

	/* Just use the previous declaration. */
	return b->decl;
	}

	label = make_label (name, input_location);
	C_DECLARED_LABEL_FLAG (label) = 1;

	/* Declared labels go in the current scope. */
	bind (name, label, current_scope,
	/invisible=/false, /nested=/false);
	return label;
	}

	/* Define a label, specifying the location in the source file.
	Return the LABEL_DECL node for the label, if the definition is valid.
	Otherwise return 0. */

	tree
	define_label (location_t location, tree name)
	{
	/* Find any preexisting label with this name. It is an error
	if that label has already been defined in this function, or
	if there is a containing function with a declared label with
	the same name. */
	tree label = I_LABEL_DECL (name);
	struct c_label_list nlist_se, nlist_vm;

	if (label
	&& ((DECL_CONTEXT (label) == current_function_decl
	&& DECL_INITIAL (label) != 0)
	\|\| (DECL_CONTEXT (label) != current_function_decl
	&& C_DECLARED_LABEL_FLAG (label))))
	{
	error ("%Hduplicate label %qD", &location, label);
	locate_old_decl (label, error);
	return 0;
	}
	else if (label && DECL_CONTEXT (label) == current_function_decl)
	{
	/* The label has been used or declared already in this function,
	but not defined. Update its location to point to this
	definition. */
	if (C_DECL_UNDEFINABLE_STMT_EXPR (label))
	error ("%Jjump into statement expression", label);
	if (C_DECL_UNDEFINABLE_VM (label))
	error ("%Jjump into scope of identifier with variably modified type",
	label);
	DECL_SOURCE_LOCATION (label) = location;
	}
	else
	{
	/* No label binding for that identifier; make one. */
	label = make_label (name, location);

	/* Ordinary labels go in the current function scope. */
	bind (name, label, current_function_scope,
	/invisible=/false, /nested=/false);
	}

	if (!in_system_header && lookup_name (name))
	warning (OPT_Wtraditional, "%Htraditional C lacks a separate namespace "
	"for labels, identifier %qE conflicts", &location, name);

	nlist_se = XOBNEW (&parser_obstack, struct c_label_list);
	nlist_se->next = label_context_stack_se->labels_def;
	nlist_se->label = label;
	label_context_stack_se->labels_def = nlist_se;

	nlist_vm = XOBNEW (&parser_obstack, struct c_label_list);
	nlist_vm->next = label_context_stack_vm->labels_def;
	nlist_vm->label = label;
	label_context_stack_vm->labels_def = nlist_vm;

	/* Mark label as having been defined. */
	DECL_INITIAL (label) = error_mark_node;
	return label;
	}

	/* Given NAME, an IDENTIFIER_NODE,
	return the structure (or union or enum) definition for that name.
	If THISLEVEL_ONLY is nonzero, searches only the current_scope.
	CODE says which kind of type the caller wants;
	it is RECORD_TYPE or UNION_TYPE or ENUMERAL_TYPE.
	If the wrong kind of type is found, an error is reported. */

	static tree
	lookup_tag (enum tree_code code, tree name, int thislevel_only)
	{
	struct c_binding *b = I_TAG_BINDING (name);
	int thislevel = 0;

	if (!b \|\| !b->decl)
	return 0;

	/* We only care about whether it's in this level if
	thislevel_only was set or it might be a type clash. */
	if (thislevel_only \|\| TREE_CODE (b->decl) != code)
	{
	/* For our purposes, a tag in the external scope is the same as
	a tag in the file scope. (Primarily relevant to Objective-C
	and its builtin structure tags, which get pushed before the
	file scope is created.) */
	if (B_IN_CURRENT_SCOPE (b)
	\|\| (current_scope == file_scope && B_IN_EXTERNAL_SCOPE (b)))
	thislevel = 1;
	}

	if (thislevel_only && !thislevel)
	return 0;

	if (TREE_CODE (b->decl) != code)
	{
	/* Definition isn't the kind we were looking for. */
	pending_invalid_xref = name;
	pending_invalid_xref_location = input_location;

	/* If in the same binding level as a declaration as a tag
	of a different type, this must not be allowed to
	shadow that tag, so give the error immediately.
	(For example, "struct foo; union foo;" is invalid.) */
	if (thislevel)
	pending_xref_error ();
	}
	return b->decl;
	}

	/* Print an error message now
	for a recent invalid struct, union or enum cross reference.
	We don't print them immediately because they are not invalid
	when used in the `struct foo;' construct for shadowing. */

	void
	pending_xref_error (void)
	{
	if (pending_invalid_xref != 0)
	error ("%H%qE defined as wrong kind of tag",
	&pending_invalid_xref_location, pending_invalid_xref);
	pending_invalid_xref = 0;
	}


	/* Look up NAME in the current scope and its superiors
	in the namespace of variables, functions and typedefs.
	Return a ..._DECL node of some kind representing its definition,
	or return 0 if it is undefined. */

	tree
	lookup_name (tree name)
	{
	struct c_binding *b = I_SYMBOL_BINDING (name);
	if (b && !b->invisible)
	return b->decl;
	return 0;
	}

	/* Similar to `lookup_name' but look only at the indicated scope. */

	static tree
	lookup_name_in_scope (tree name, struct c_scope *scope)
	{
	struct c_binding *b;

	for (b = I_SYMBOL_BINDING (name); b; b = b->shadowed)
	if (B_IN_SCOPE (b, scope))
	return b->decl;
	return 0;
	}

	/* Create the predefined scalar types of C,
	and some nodes representing standard constants (0, 1, (void *) 0).
	Initialize the global scope.
	Make definitions for built-in primitive functions. */

	void
	c_init_decl_processing (void)
	{
	location_t save_loc = input_location;

	/* Initialize reserved words for parser. */
	c_parse_init ();

	current_function_decl = 0;

	gcc_obstack_init (&parser_obstack);

	/* Make the externals scope. */
	push_scope ();
	external_scope = current_scope;

	/* Declarations from c_common_nodes_and_builtins must not be associated
	with this input file, lest we get differences between using and not
	using preprocessed headers. */
	#ifdef USE_MAPPED_LOCATION
	input_location = BUILTINS_LOCATION;
	#else
	input_location.file = "<built-in>";
	input_location.line = 0;
	#endif

	build_common_tree_nodes (flag_signed_char, false);

	c_common_nodes_and_builtins ();

	/* In C, comparisons and TRUTH_* expressions have type int. */
	truthvalue_type_node = integer_type_node;
	truthvalue_true_node = integer_one_node;
	truthvalue_false_node = integer_zero_node;

	/* Even in C99, which has a real boolean type. */
	pushdecl (build_decl (TYPE_DECL, get_identifier ("_Bool"),
	boolean_type_node));

	input_location = save_loc;

	pedantic_lvalues = true;

	make_fname_decl = c_make_fname_decl;
	start_fname_decls ();
	}

	/* Create the VAR_DECL for __FUNCTION__ etc. ID is the name to give the
	decl, NAME is the initialization string and TYPE_DEP indicates whether
	NAME depended on the type of the function. As we don't yet implement
	delayed emission of static data, we mark the decl as emitted
	so it is not placed in the output. Anything using it must therefore pull
	out the STRING_CST initializer directly. FIXME. */

	static tree
	c_make_fname_decl (tree id, int type_dep)
	{
	const char *name = fname_as_string (type_dep);
	tree decl, type, init;
	size_t length = strlen (name);

	type = build_array_type (char_type_node,
	build_index_type (size_int (length)));
	type = c_build_qualified_type (type, TYPE_QUAL_CONST);

	decl = build_decl (VAR_DECL, id, type);

	TREE_STATIC (decl) = 1;
	TREE_READONLY (decl) = 1;
	DECL_ARTIFICIAL (decl) = 1;

	init = build_string (length + 1, name);
	free ((char *) name);
	TREE_TYPE (init) = type;
	DECL_INITIAL (decl) = init;

	TREE_USED (decl) = 1;

	if (current_function_decl
	/* For invalid programs like this:

	void foo()
	const char* p = __FUNCTION__;

	the __FUNCTION__ is believed to appear in K&R style function
	parameter declarator. In that case we still don't have
	function_scope. */
	&& (!errorcount \|\| current_function_scope))
	{
	DECL_CONTEXT (decl) = current_function_decl;
	bind (id, decl, current_function_scope,
	/invisible=/false, /nested=/false);
	}

	finish_decl (decl, init, NULL_TREE);

	return decl;
	}

	/* Return a definition for a builtin function named NAME and whose data type
	is TYPE. TYPE should be a function type with argument types.
	FUNCTION_CODE tells later passes how to compile calls to this function.
	See tree.h for its possible values.

	If LIBRARY_NAME is nonzero, use that for DECL_ASSEMBLER_NAME,
	the name to be called if we can't opencode the function. If
	ATTRS is nonzero, use that for the function's attribute list. */

	tree
	builtin_function (const char *name, tree type, int function_code,
	enum built_in_class cl, const char *library_name,
	tree attrs)
	{
	tree id = get_identifier (name);
	tree decl = build_decl (FUNCTION_DECL, id, type);
	TREE_PUBLIC (decl) = 1;
	DECL_EXTERNAL (decl) = 1;
	DECL_LANG_SPECIFIC (decl) = GGC_CNEW (struct lang_decl);
	DECL_BUILT_IN_CLASS (decl) = cl;
	DECL_FUNCTION_CODE (decl) = function_code;
	C_DECL_BUILTIN_PROTOTYPE (decl) = (TYPE_ARG_TYPES (type) != 0);
	if (library_name)
	SET_DECL_ASSEMBLER_NAME (decl, get_identifier (library_name));

	/* Should never be called on a symbol with a preexisting meaning. */
	gcc_assert (!I_SYMBOL_BINDING (id));

	bind (id, decl, external_scope, /invisible=/true, /nested=/false);

	/* Builtins in the implementation namespace are made visible without
	needing to be explicitly declared. See push_file_scope. */
	if (name[0] == '_' && (name[1] == '_' \|\| ISUPPER (name[1])))
	{
	TREE_CHAIN (decl) = visible_builtins;
	visible_builtins = decl;
	}

	/* Possibly apply some default attributes to this built-in function. */
	if (attrs)
	decl_attributes (&decl, attrs, ATTR_FLAG_BUILT_IN);
	else
	decl_attributes (&decl, NULL_TREE, 0);

	return decl;
	}

	/* Called when a declaration is seen that contains no names to declare.
	If its type is a reference to a structure, union or enum inherited
	from a containing scope, shadow that tag name for the current scope
	with a forward reference.
	If its type defines a new named structure or union
	or defines an enum, it is valid but we need not do anything here.
	Otherwise, it is an error. */

	void
	shadow_tag (const struct c_declspecs *declspecs)
	{
	shadow_tag_warned (declspecs, 0);
	}

	/* WARNED is 1 if we have done a pedwarn, 2 if we have done a warning,
	but no pedwarn. */
	void
	shadow_tag_warned (const struct c_declspecs *declspecs, int warned)
	{
	bool found_tag = false;

	if (declspecs->type && !declspecs->default_int_p && !declspecs->typedef_p)
	{
	tree value = declspecs->type;
	enum tree_code code = TREE_CODE (value);

	if (code == RECORD_TYPE \|\| code == UNION_TYPE \|\| code == ENUMERAL_TYPE)
	/* Used to test also that TYPE_SIZE (value) != 0.
	That caused warning for `struct foo;' at top level in the file. */
	{
	tree name = TYPE_NAME (value);
	tree t;

	found_tag = true;

	if (name == 0)
	{
	if (warned != 1 && code != ENUMERAL_TYPE)
	/* Empty unnamed enum OK */
	{
	pedwarn ("unnamed struct/union that defines no instances");
	warned = 1;
	}
	}
	else if (!declspecs->tag_defined_p
	&& declspecs->storage_class != csc_none)
	{
	if (warned != 1)
	pedwarn ("empty declaration with storage class specifier "
	"does not redeclare tag");
	warned = 1;
	pending_xref_error ();
	}
	else if (!declspecs->tag_defined_p
	&& (declspecs->const_p
	\|\| declspecs->volatile_p
	\|\| declspecs->restrict_p))
	{
	if (warned != 1)
	pedwarn ("empty declaration with type qualifier "
	"does not redeclare tag");
	warned = 1;
	pending_xref_error ();
	}
	else
	{
	pending_invalid_xref = 0;
	t = lookup_tag (code, name, 1);

	if (t == 0)
	{
	t = make_node (code);
	pushtag (name, t);
	}
	}
	}
	else
	{
	if (warned != 1 && !in_system_header)
	{
	pedwarn ("useless type name in empty declaration");
	warned = 1;
	}
	}
	}
	else if (warned != 1 && !in_system_header && declspecs->typedef_p)
	{
	pedwarn ("useless type name in empty declaration");
	warned = 1;
	}

	pending_invalid_xref = 0;

	if (declspecs->inline_p)
	{
	error ("%<inline%> in empty declaration");
	warned = 1;
	}

	if (current_scope == file_scope && declspecs->storage_class == csc_auto)
	{
	error ("%<auto%> in file-scope empty declaration");
	warned = 1;
	}

	if (current_scope == file_scope && declspecs->storage_class == csc_register)
	{
	error ("%<register%> in file-scope empty declaration");
	warned = 1;
	}

	if (!warned && !in_system_header && declspecs->storage_class != csc_none)
	{
	warning (0, "useless storage class specifier in empty declaration");
	warned = 2;
	}

	if (!warned && !in_system_header && declspecs->thread_p)
	{
	warning (0, "useless %<__thread%> in empty declaration");
	warned = 2;
	}

	if (!warned && !in_system_header && (declspecs->const_p
	\|\| declspecs->volatile_p
	\|\| declspecs->restrict_p))
	{
	warning (0, "useless type qualifier in empty declaration");
	warned = 2;
	}

	if (warned != 1)
	{
	if (!found_tag)
	pedwarn ("empty declaration");
	}
	}


	/* Return the qualifiers from SPECS as a bitwise OR of TYPE_QUAL_*
	bits. SPECS represents declaration specifiers that the grammar
	only permits to contain type qualifiers and attributes. */

	int
	quals_from_declspecs (const struct c_declspecs *specs)
	{
	int quals = ((specs->const_p ? TYPE_QUAL_CONST : 0)
	\| (specs->volatile_p ? TYPE_QUAL_VOLATILE : 0)
	\| (specs->restrict_p ? TYPE_QUAL_RESTRICT : 0));
	gcc_assert (!specs->type
	&& !specs->decl_attr
	&& specs->typespec_word == cts_none
	&& specs->storage_class == csc_none
	&& !specs->typedef_p
	&& !specs->explicit_signed_p
	&& !specs->deprecated_p
	&& !specs->long_p
	&& !specs->long_long_p
	&& !specs->short_p
	&& !specs->signed_p
	&& !specs->unsigned_p
	&& !specs->complex_p
	&& !specs->inline_p
	&& !specs->thread_p);
	return quals;
	}

	/* Construct an array declarator. EXPR is the expression inside [],
	or NULL_TREE. QUALS are the type qualifiers inside the [] (to be
	applied to the pointer to which a parameter array is converted).
	STATIC_P is true if "static" is inside the [], false otherwise.
	VLA_UNSPEC_P is true if the array is [*], a VLA of unspecified
	length which is nevertheless a complete type, false otherwise. The
	field for the contained declarator is left to be filled in by
	set_array_declarator_inner. */

	struct c_declarator *
	build_array_declarator (tree expr, struct c_declspecs *quals, bool static_p,
	bool vla_unspec_p)
	{
	struct c_declarator *declarator = XOBNEW (&parser_obstack,
	struct c_declarator);
	declarator->kind = cdk_array;
	declarator->declarator = 0;
	declarator->u.array.dimen = expr;
	if (quals)
	{
	declarator->u.array.attrs = quals->attrs;
	declarator->u.array.quals = quals_from_declspecs (quals);
	}
	else
	{
	declarator->u.array.attrs = NULL_TREE;
	declarator->u.array.quals = 0;
	}
	declarator->u.array.static_p = static_p;
	declarator->u.array.vla_unspec_p = vla_unspec_p;
	if (pedantic && !flag_isoc99)
	{
	if (static_p \|\| quals != NULL)
	pedwarn ("ISO C90 does not support %<static%> or type "
	"qualifiers in parameter array declarators");
	if (vla_unspec_p)
	pedwarn ("ISO C90 does not support %<[*]%> array declarators");
	}
	if (vla_unspec_p)
	{
	if (!current_scope->parm_flag)
	{
	/* C99 6.7.5.2p4 */
	error ("%<[*]%> not allowed in other than function prototype scope");
	declarator->u.array.vla_unspec_p = false;
	return NULL;
	}
	current_scope->had_vla_unspec = true;
	}
	return declarator;
	}

	/* Set the contained declarator of an array declarator. DECL is the
	declarator, as constructed by build_array_declarator; INNER is what
	appears on the left of the []. ABSTRACT_P is true if it is an
	abstract declarator, false otherwise; this is used to reject static
	and type qualifiers in abstract declarators, where they are not in
	the C99 grammar (subject to possible change in DR#289). */

	struct c_declarator *
	set_array_declarator_inner (struct c_declarator *decl,
	struct c_declarator *inner, bool abstract_p)
	{
	decl->declarator = inner;
	if (abstract_p && (decl->u.array.quals != TYPE_UNQUALIFIED
	\|\| decl->u.array.attrs != NULL_TREE
	\|\| decl->u.array.static_p))
	error ("static or type qualifiers in abstract declarator");
	return decl;
	}

	/* INIT is a constructor that forms DECL's initializer. If the final
	element initializes a flexible array field, add the size of that
	initializer to DECL's size. */

	static void
	add_flexible_array_elts_to_size (tree decl, tree init)
	{
	tree elt, type;

	if (VEC_empty (constructor_elt, CONSTRUCTOR_ELTS (init)))
	return;

	elt = VEC_last (constructor_elt, CONSTRUCTOR_ELTS (init))->value;
	type = TREE_TYPE (elt);
	if (TREE_CODE (type) == ARRAY_TYPE
	&& TYPE_SIZE (type) == NULL_TREE
	&& TYPE_DOMAIN (type) != NULL_TREE
	&& TYPE_MAX_VALUE (TYPE_DOMAIN (type)) == NULL_TREE)
	{
	complete_array_type (&type, elt, false);
	DECL_SIZE (decl)
	= size_binop (PLUS_EXPR, DECL_SIZE (decl), TYPE_SIZE (type));
	DECL_SIZE_UNIT (decl)
	= size_binop (PLUS_EXPR, DECL_SIZE_UNIT (decl), TYPE_SIZE_UNIT (type));
	}
	}

	/* Decode a "typename", such as "int *", returning a ..._TYPE node. /

	tree
	groktypename (struct c_type_name *type_name)
	{
	tree type;
	tree attrs = type_name->specs->attrs;

	type_name->specs->attrs = NULL_TREE;

	type = grokdeclarator (type_name->declarator, type_name->specs, TYPENAME,
	false, NULL);

	/* Apply attributes. */
	decl_attributes (&type, attrs, 0);

	return type;
	}

	/* Decode a declarator in an ordinary declaration or data definition.
	This is called as soon as the type information and variable name
	have been parsed, before parsing the initializer if any.
	Here we create the ..._DECL node, fill in its type,
	and put it on the list of decls for the current context.
	The ..._DECL node is returned as the value.

	Exception: for arrays where the length is not specified,
	the type is left null, to be filled in by `finish_decl'.

	Function definitions do not come here; they go to start_function
	instead. However, external and forward declarations of functions
	do go through here. Structure field declarations are done by
	grokfield and not through here. */

	tree
	start_decl (struct c_declarator declarator, struct c_declspecs declspecs,
	bool initialized, tree attributes)
	{
	tree decl;
	tree tem;

	/* An object declared as __attribute__((deprecated)) suppresses
	warnings of uses of other deprecated items. */
	+ /* APPLE LOCAL begin "unavailable" attribute (radar 2809697) */
	+ /* An object declared as __attribute__((unavailable)) suppresses
	+ any reports of being declared with unavailable or deprecated
	+ items. An object declared as __attribute__((deprecated))
	+ suppresses warnings of uses of other deprecated items. */
	+#ifdef A_LESS_INEFFICENT_WAY /* which I really don't want to do! */
	if (lookup_attribute ("deprecated", attributes))
	deprecated_state = DEPRECATED_SUPPRESS;
	+ else if (lookup_attribute ("unavailable", attributes))
	+ deprecated_state = DEPRECATED_UNAVAILABLE_SUPPRESS;
	+#else /* a more efficient way doing what lookup_attribute would do */
	+ tree a;
	+
	+ for (a = attributes; a; a = TREE_CHAIN (a))
	+ {
	+ tree name = TREE_PURPOSE (a);
	+ if (TREE_CODE (name) == IDENTIFIER_NODE)
	+ if (is_attribute_p ("deprecated", name))
	+ {
	+ deprecated_state = DEPRECATED_SUPPRESS;
	+ break;
	+ }
	+ if (is_attribute_p ("unavailable", name))
	+ {
	+ deprecated_state = DEPRECATED_UNAVAILABLE_SUPPRESS;
	+ break;
	+ }
	+ }
	+#endif
	+ /* APPLE LOCAL end "unavailable" attribute (radar 2809697) */

	decl = grokdeclarator (declarator, declspecs,
	NORMAL, initialized, NULL);
	if (!decl)
	return 0;

	deprecated_state = DEPRECATED_NORMAL;

	if (warn_main > 0 && TREE_CODE (decl) != FUNCTION_DECL
	&& MAIN_NAME_P (DECL_NAME (decl)))
	warning (OPT_Wmain, "%q+D is usually a function", decl);

	if (initialized)
	/* Is it valid for this decl to have an initializer at all?
	If not, set INITIALIZED to zero, which will indirectly
	tell 'finish_decl' to ignore the initializer once it is parsed. */
	switch (TREE_CODE (decl))
	{
	case TYPE_DECL:
	error ("typedef %qD is initialized (use __typeof__ instead)", decl);
	initialized = 0;
	break;

	case FUNCTION_DECL:
	error ("function %qD is initialized like a variable", decl);
	initialized = 0;
	break;

	case PARM_DECL:
	/* DECL_INITIAL in a PARM_DECL is really DECL_ARG_TYPE. */
	error ("parameter %qD is initialized", decl);
	initialized = 0;
	break;

	default:
	/* Don't allow initializations for incomplete types except for
	arrays which might be completed by the initialization. */

	/* This can happen if the array size is an undefined macro.
	We already gave a warning, so we don't need another one. */
	if (TREE_TYPE (decl) == error_mark_node)
	initialized = 0;
	else if (COMPLETE_TYPE_P (TREE_TYPE (decl)))
	{
	/* A complete type is ok if size is fixed. */

	if (TREE_CODE (TYPE_SIZE (TREE_TYPE (decl))) != INTEGER_CST
	\|\| C_DECL_VARIABLE_SIZE (decl))
	{
	error ("variable-sized object may not be initialized");
	initialized = 0;
	}
	}
	else if (TREE_CODE (TREE_TYPE (decl)) != ARRAY_TYPE)
	{
	error ("variable %qD has initializer but incomplete type", decl);
	initialized = 0;
	}
	else if (C_DECL_VARIABLE_SIZE (decl))
	{
	/* Although C99 is unclear about whether incomplete arrays
	of VLAs themselves count as VLAs, it does not make
	sense to permit them to be initialized given that
	ordinary VLAs may not be initialized. */
	error ("variable-sized object may not be initialized");
	initialized = 0;
	}
	}

	if (initialized)
	{
	if (current_scope == file_scope)
	TREE_STATIC (decl) = 1;

	/* Tell 'pushdecl' this is an initialized decl
	even though we don't yet have the initializer expression.
	Also tell 'finish_decl' it may store the real initializer. */
	DECL_INITIAL (decl) = error_mark_node;
	}

	/* If this is a function declaration, write a record describing it to the
	prototypes file (if requested). */

	if (TREE_CODE (decl) == FUNCTION_DECL)
	gen_aux_info_record (decl, 0, 0, TYPE_ARG_TYPES (TREE_TYPE (decl)) != 0);

	/* ANSI specifies that a tentative definition which is not merged with
	a non-tentative definition behaves exactly like a definition with an
	initializer equal to zero. (Section 3.7.2)

	-fno-common gives strict ANSI behavior, though this tends to break
	a large body of code that grew up without this rule.

	Thread-local variables are never common, since there's no entrenched
	body of code to break, and it allows more efficient variable references
	in the presence of dynamic linking. */

	if (TREE_CODE (decl) == VAR_DECL
	&& !initialized
	&& TREE_PUBLIC (decl)
	&& !DECL_THREAD_LOCAL_P (decl)
	&& !flag_no_common)
	DECL_COMMON (decl) = 1;

	/* Set attributes here so if duplicate decl, will have proper attributes. */
	decl_attributes (&decl, attributes, 0);

	/* Handle gnu_inline attribute. */
	if (declspecs->inline_p
	&& !flag_gnu89_inline
	&& TREE_CODE (decl) == FUNCTION_DECL
	&& lookup_attribute ("gnu_inline", DECL_ATTRIBUTES (decl)))
	{
	if (declspecs->storage_class == csc_auto && current_scope != file_scope)
	;
	else if (declspecs->storage_class != csc_static)
	DECL_EXTERNAL (decl) = !DECL_EXTERNAL (decl);
	}

	if (TREE_CODE (decl) == FUNCTION_DECL
	&& targetm.calls.promote_prototypes (TREE_TYPE (decl)))
	{
	struct c_declarator *ce = declarator;

	if (ce->kind == cdk_pointer)
	ce = declarator->declarator;
	if (ce->kind == cdk_function)
	{
	tree args = ce->u.arg_info->parms;
	for (; args; args = TREE_CHAIN (args))
	{
	tree type = TREE_TYPE (args);
	if (type && INTEGRAL_TYPE_P (type)
	&& TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node))
	DECL_ARG_TYPE (args) = integer_type_node;
	}
	}
	}

	if (TREE_CODE (decl) == FUNCTION_DECL
	&& DECL_DECLARED_INLINE_P (decl)
	&& DECL_UNINLINABLE (decl)
	&& lookup_attribute ("noinline", DECL_ATTRIBUTES (decl)))
	warning (OPT_Wattributes, "inline function %q+D given attribute noinline",
	decl);

	/* C99 6.7.4p3: An inline definition of a function with external
	linkage shall not contain a definition of a modifiable object
	with static storage duration... */
	if (TREE_CODE (decl) == VAR_DECL
	&& current_scope != file_scope
	&& TREE_STATIC (decl)
	&& !TREE_READONLY (decl)
	&& DECL_DECLARED_INLINE_P (current_function_decl)
	&& DECL_EXTERNAL (current_function_decl))
	pedwarn ("%q+D is static but declared in inline function %qD "
	"which is not static", decl, current_function_decl);

	/* Add this decl to the current scope.
	TEM may equal DECL or it may be a previous decl of the same name. */
	tem = pushdecl (decl);

	if (initialized && DECL_EXTERNAL (tem))
	{
	DECL_EXTERNAL (tem) = 0;
	TREE_STATIC (tem) = 1;
	}

	return tem;
	}

	/* Initialize EH if not initialized yet and exceptions are enabled. */

	void
	c_maybe_initialize_eh (void)
	{
	if (!flag_exceptions \|\| c_eh_initialized_p)
	return;

	c_eh_initialized_p = true;
	eh_personality_libfunc
	= init_one_libfunc (USING_SJLJ_EXCEPTIONS
	? "__gcc_personality_sj0"
	: "__gcc_personality_v0");
	default_init_unwind_resume_libfunc ();
	using_eh_for_cleanups ();
	}

	/* Finish processing of a declaration;
	install its initial value.
	If the length of an array type is not known before,
	it must be determined now, from the initial value, or it is an error. */

	void
	finish_decl (tree decl, tree init, tree asmspec_tree)
	{
	tree type;
	int was_incomplete = (DECL_SIZE (decl) == 0);
	const char *asmspec = 0;

	/* If a name was specified, get the string. */
	if ((TREE_CODE (decl) == FUNCTION_DECL \|\| TREE_CODE (decl) == VAR_DECL)
	&& DECL_FILE_SCOPE_P (decl))
	asmspec_tree = maybe_apply_renaming_pragma (decl, asmspec_tree);
	if (asmspec_tree)
	asmspec = TREE_STRING_POINTER (asmspec_tree);

	/* If `start_decl' didn't like having an initialization, ignore it now. */
	if (init != 0 && DECL_INITIAL (decl) == 0)
	init = 0;

	/* Don't crash if parm is initialized. */
	if (TREE_CODE (decl) == PARM_DECL)
	init = 0;

	if (init)
	store_init_value (decl, init);

	if (c_dialect_objc () && (TREE_CODE (decl) == VAR_DECL
	\|\| TREE_CODE (decl) == FUNCTION_DECL
	\|\| TREE_CODE (decl) == FIELD_DECL))
	objc_check_decl (decl);

	type = TREE_TYPE (decl);

	/* Deduce size of array from initialization, if not already known. */
	if (TREE_CODE (type) == ARRAY_TYPE
	&& TYPE_DOMAIN (type) == 0
	&& TREE_CODE (decl) != TYPE_DECL)
	{
	bool do_default
	= (TREE_STATIC (decl)
	/* Even if pedantic, an external linkage array
	may have incomplete type at first. */
	? pedantic && !TREE_PUBLIC (decl)
	: !DECL_EXTERNAL (decl));
	int failure
	= complete_array_type (&TREE_TYPE (decl), DECL_INITIAL (decl),
	do_default);

	/* Get the completed type made by complete_array_type. */
	type = TREE_TYPE (decl);

	switch (failure)
	{
	case 1:
	error ("initializer fails to determine size of %q+D", decl);
	break;

	case 2:
	if (do_default)
	error ("array size missing in %q+D", decl);
	/* If a `static' var's size isn't known,
	make it extern as well as static, so it does not get
	allocated.
	If it is not `static', then do not mark extern;
	finish_incomplete_decl will give it a default size
	and it will get allocated. */
	else if (!pedantic && TREE_STATIC (decl) && !TREE_PUBLIC (decl))
	DECL_EXTERNAL (decl) = 1;
	break;

	case 3:
	error ("zero or negative size array %q+D", decl);
	break;

	case 0:
	/* For global variables, update the copy of the type that
	exists in the binding. */
	if (TREE_PUBLIC (decl))
	{
	struct c_binding *b_ext = I_SYMBOL_BINDING (DECL_NAME (decl));
	while (b_ext && !B_IN_EXTERNAL_SCOPE (b_ext))
	b_ext = b_ext->shadowed;
	if (b_ext)
	{
	if (b_ext->type)
	b_ext->type = composite_type (b_ext->type, type);
	else
	b_ext->type = type;
	}
	}
	break;

	default:
	gcc_unreachable ();
	}

	if (DECL_INITIAL (decl))
	TREE_TYPE (DECL_INITIAL (decl)) = type;

	layout_decl (decl, 0);
	}

	if (TREE_CODE (decl) == VAR_DECL)
	{
	if (init && TREE_CODE (init) == CONSTRUCTOR)
	add_flexible_array_elts_to_size (decl, init);

	if (DECL_SIZE (decl) == 0 && TREE_TYPE (decl) != error_mark_node
	&& COMPLETE_TYPE_P (TREE_TYPE (decl)))
	layout_decl (decl, 0);

	if (DECL_SIZE (decl) == 0
	/* Don't give an error if we already gave one earlier. */
	&& TREE_TYPE (decl) != error_mark_node
	&& (TREE_STATIC (decl)
	/* A static variable with an incomplete type
	is an error if it is initialized.
	Also if it is not file scope.
	Otherwise, let it through, but if it is not `extern'
	then it may cause an error message later. */
	? (DECL_INITIAL (decl) != 0
	\|\| !DECL_FILE_SCOPE_P (decl))
	/* An automatic variable with an incomplete type
	is an error. */
	: !DECL_EXTERNAL (decl)))
	{
	error ("storage size of %q+D isn%'t known", decl);
	TREE_TYPE (decl) = error_mark_node;
	}

	if ((DECL_EXTERNAL (decl) \|\| TREE_STATIC (decl))
	&& DECL_SIZE (decl) != 0)
	{
	if (TREE_CODE (DECL_SIZE (decl)) == INTEGER_CST)
	constant_expression_warning (DECL_SIZE (decl));
	else
	error ("storage size of %q+D isn%'t constant", decl);
	}

	if (TREE_USED (type))
	TREE_USED (decl) = 1;
	}

	/* If this is a function and an assembler name is specified, reset DECL_RTL
	so we can give it its new name. Also, update built_in_decls if it
	was a normal built-in. */
	if (TREE_CODE (decl) == FUNCTION_DECL && asmspec)
	{
	if (DECL_BUILT_IN_CLASS (decl) == BUILT_IN_NORMAL)
	set_builtin_user_assembler_name (decl, asmspec);
	set_user_assembler_name (decl, asmspec);
	}

	/* If #pragma weak was used, mark the decl weak now. */
	maybe_apply_pragma_weak (decl);

	/* Output the assembler code and/or RTL code for variables and functions,
	unless the type is an undefined structure or union.
	If not, it will get done when the type is completed. */

	if (TREE_CODE (decl) == VAR_DECL \|\| TREE_CODE (decl) == FUNCTION_DECL)
	{
	/* Determine the ELF visibility. */
	if (TREE_PUBLIC (decl))
	c_determine_visibility (decl);

	/* This is a no-op in c-lang.c or something real in objc-act.c. */
	if (c_dialect_objc ())
	objc_check_decl (decl);

	if (asmspec)
	{
	/* If this is not a static variable, issue a warning.
	It doesn't make any sense to give an ASMSPEC for an
	ordinary, non-register local variable. Historically,
	GCC has accepted -- but ignored -- the ASMSPEC in
	this case. */
	if (!DECL_FILE_SCOPE_P (decl)
	&& TREE_CODE (decl) == VAR_DECL
	&& !C_DECL_REGISTER (decl)
	&& !TREE_STATIC (decl))
	warning (0, "ignoring asm-specifier for non-static local "
	"variable %q+D", decl);
	else
	set_user_assembler_name (decl, asmspec);
	}

	if (DECL_FILE_SCOPE_P (decl))
	{
	if (DECL_INITIAL (decl) == NULL_TREE
	\|\| DECL_INITIAL (decl) == error_mark_node)
	/* Don't output anything
	when a tentative file-scope definition is seen.
	But at end of compilation, do output code for them. */
	DECL_DEFER_OUTPUT (decl) = 1;
	rest_of_decl_compilation (decl, true, 0);
	}
	else
	{
	/* In conjunction with an ASMSPEC, the `register'
	keyword indicates that we should place the variable
	in a particular register. */
	if (asmspec && C_DECL_REGISTER (decl))
	{
	DECL_HARD_REGISTER (decl) = 1;
	/* This cannot be done for a structure with volatile
	fields, on which DECL_REGISTER will have been
	reset. */
	if (!DECL_REGISTER (decl))
	error ("cannot put object with volatile field into register");
	}

	if (TREE_CODE (decl) != FUNCTION_DECL)
	{
	/* If we're building a variable sized type, and we might be
	reachable other than via the top of the current binding
	level, then create a new BIND_EXPR so that we deallocate
	the object at the right time. */
	/* Note that DECL_SIZE can be null due to errors. */
	if (DECL_SIZE (decl)
	&& !TREE_CONSTANT (DECL_SIZE (decl))
	&& STATEMENT_LIST_HAS_LABEL (cur_stmt_list))
	{
	tree bind;
	bind = build3 (BIND_EXPR, void_type_node, NULL, NULL, NULL);
	TREE_SIDE_EFFECTS (bind) = 1;
	add_stmt (bind);
	BIND_EXPR_BODY (bind) = push_stmt_list ();
	}
	add_stmt (build_stmt (DECL_EXPR, decl));
	}
	}


	if (!DECL_FILE_SCOPE_P (decl))
	{
	/* Recompute the RTL of a local array now
	if it used to be an incomplete type. */
	if (was_incomplete
	&& !TREE_STATIC (decl) && !DECL_EXTERNAL (decl))
	{
	/* If we used it already as memory, it must stay in memory. */
	TREE_ADDRESSABLE (decl) = TREE_USED (decl);
	/* If it's still incomplete now, no init will save it. */
	if (DECL_SIZE (decl) == 0)
	DECL_INITIAL (decl) = 0;
	}
	}
	}

	/* If this was marked 'used', be sure it will be output. */
	if (!flag_unit_at_a_time && lookup_attribute ("used", DECL_ATTRIBUTES (decl)))
	mark_decl_referenced (decl);

	if (TREE_CODE (decl) == TYPE_DECL)
	{
	if (!DECL_FILE_SCOPE_P (decl)
	&& variably_modified_type_p (TREE_TYPE (decl), NULL_TREE))
	add_stmt (build_stmt (DECL_EXPR, decl));

	rest_of_decl_compilation (decl, DECL_FILE_SCOPE_P (decl), 0);
	}

	/* At the end of a declaration, throw away any variable type sizes
	of types defined inside that declaration. There is no use
	computing them in the following function definition. */
	if (current_scope == file_scope)
	get_pending_sizes ();

	/* Install a cleanup (aka destructor) if one was given. */
	if (TREE_CODE (decl) == VAR_DECL && !TREE_STATIC (decl))
	{
	tree attr = lookup_attribute ("cleanup", DECL_ATTRIBUTES (decl));
	if (attr)
	{
	tree cleanup_id = TREE_VALUE (TREE_VALUE (attr));
	tree cleanup_decl = lookup_name (cleanup_id);
	tree cleanup;

	/* Build "cleanup(&decl)" for the destructor. */
	cleanup = build_unary_op (ADDR_EXPR, decl, 0);
	cleanup = build_tree_list (NULL_TREE, cleanup);
	cleanup = build_function_call (cleanup_decl, cleanup);

	/* Don't warn about decl unused; the cleanup uses it. */
	TREE_USED (decl) = 1;
	TREE_USED (cleanup_decl) = 1;

	/* Initialize EH, if we've been told to do so. */
	c_maybe_initialize_eh ();

	push_cleanup (decl, cleanup, false);
	}
	}
	}

	/* Given a parsed parameter declaration, decode it into a PARM_DECL. */

	tree
	grokparm (const struct c_parm *parm)
	{
	tree decl = grokdeclarator (parm->declarator, parm->specs, PARM, false,
	NULL);

	decl_attributes (&decl, parm->attrs, 0);

	return decl;
	}

	/* Given a parsed parameter declaration, decode it into a PARM_DECL
	and push that on the current scope. */

	void
	push_parm_decl (const struct c_parm *parm)
	{
	tree decl;

	decl = grokdeclarator (parm->declarator, parm->specs, PARM, false, NULL);
	decl_attributes (&decl, parm->attrs, 0);

	decl = pushdecl (decl);

	finish_decl (decl, NULL_TREE, NULL_TREE);
	}

	/* Mark all the parameter declarations to date as forward decls.
	Also diagnose use of this extension. */

	void
	mark_forward_parm_decls (void)
	{
	struct c_binding *b;

	if (pedantic && !current_scope->warned_forward_parm_decls)
	{
	pedwarn ("ISO C forbids forward parameter declarations");
	current_scope->warned_forward_parm_decls = true;
	}

	for (b = current_scope->bindings; b; b = b->prev)
	if (TREE_CODE (b->decl) == PARM_DECL)
	TREE_ASM_WRITTEN (b->decl) = 1;
	}

	/* Build a COMPOUND_LITERAL_EXPR. TYPE is the type given in the compound
	literal, which may be an incomplete array type completed by the
	initializer; INIT is a CONSTRUCTOR that initializes the compound
	literal. */

	tree
	build_compound_literal (tree type, tree init)
	{
	/* We do not use start_decl here because we have a type, not a declarator;
	and do not use finish_decl because the decl should be stored inside
	the COMPOUND_LITERAL_EXPR rather than added elsewhere as a DECL_EXPR. */
	tree decl;
	tree complit;
	tree stmt;

	if (type == error_mark_node)
	return error_mark_node;

	decl = build_decl (VAR_DECL, NULL_TREE, type);
	DECL_EXTERNAL (decl) = 0;
	TREE_PUBLIC (decl) = 0;
	TREE_STATIC (decl) = (current_scope == file_scope);
	DECL_CONTEXT (decl) = current_function_decl;
	TREE_USED (decl) = 1;
	TREE_TYPE (decl) = type;
	TREE_READONLY (decl) = TYPE_READONLY (type);
	store_init_value (decl, init);

	if (TREE_CODE (type) == ARRAY_TYPE && !COMPLETE_TYPE_P (type))
	{
	int failure = complete_array_type (&TREE_TYPE (decl),
	DECL_INITIAL (decl), true);
	gcc_assert (!failure);

	type = TREE_TYPE (decl);
	TREE_TYPE (DECL_INITIAL (decl)) = type;
	}

	if (type == error_mark_node \|\| !COMPLETE_TYPE_P (type))
	return error_mark_node;

	stmt = build_stmt (DECL_EXPR, decl);
	complit = build1 (COMPOUND_LITERAL_EXPR, type, stmt);
	TREE_SIDE_EFFECTS (complit) = 1;

	layout_decl (decl, 0);

	if (TREE_STATIC (decl))
	{
	/* This decl needs a name for the assembler output. */
	set_compound_literal_name (decl);
	DECL_DEFER_OUTPUT (decl) = 1;
	DECL_COMDAT (decl) = 1;
	DECL_ARTIFICIAL (decl) = 1;
	DECL_IGNORED_P (decl) = 1;
	pushdecl (decl);
	rest_of_decl_compilation (decl, 1, 0);
	}

	return complit;
	}

	/* Determine whether TYPE is a structure with a flexible array member,
	or a union containing such a structure (possibly recursively). */

	static bool
	flexible_array_type_p (tree type)
	{
	tree x;
	switch (TREE_CODE (type))
	{
	case RECORD_TYPE:
	x = TYPE_FIELDS (type);
	if (x == NULL_TREE)
	return false;
	while (TREE_CHAIN (x) != NULL_TREE)
	x = TREE_CHAIN (x);
	if (TREE_CODE (TREE_TYPE (x)) == ARRAY_TYPE
	&& TYPE_SIZE (TREE_TYPE (x)) == NULL_TREE
	&& TYPE_DOMAIN (TREE_TYPE (x)) != NULL_TREE
	&& TYPE_MAX_VALUE (TYPE_DOMAIN (TREE_TYPE (x))) == NULL_TREE)
	return true;
	return false;
	case UNION_TYPE:
	for (x = TYPE_FIELDS (type); x != NULL_TREE; x = TREE_CHAIN (x))
	{
	if (flexible_array_type_p (TREE_TYPE (x)))
	return true;
	}
	return false;
	default:
	return false;
	}
	}

	/* Performs sanity checks on the TYPE and WIDTH of the bit-field NAME,
	replacing with appropriate values if they are invalid. */
	static void
	check_bitfield_type_and_width (tree type, tree width, const char *orig_name)
	{
	tree type_mv;
	unsigned int max_width;
	unsigned HOST_WIDE_INT w;
	const char *name = orig_name ? orig_name: _("<anonymous>");

	/* Detect and ignore out of range field width and process valid
	field widths. */
	if (!INTEGRAL_TYPE_P (TREE_TYPE (*width))
	\|\| TREE_CODE (*width) != INTEGER_CST)
	{
	error ("bit-field %qs width not an integer constant", name);
	*width = integer_one_node;
	}
	else
	{
	constant_expression_warning (*width);
	if (tree_int_cst_sgn (*width) < 0)
	{
	error ("negative width in bit-field %qs", name);
	*width = integer_one_node;
	}
	else if (integer_zerop (*width) && orig_name)
	{
	error ("zero width for bit-field %qs", name);
	*width = integer_one_node;
	}
	}

	/* Detect invalid bit-field type. */
	if (TREE_CODE (*type) != INTEGER_TYPE
	&& TREE_CODE (*type) != BOOLEAN_TYPE
	&& TREE_CODE (*type) != ENUMERAL_TYPE)
	{
	error ("bit-field %qs has invalid type", name);
	*type = unsigned_type_node;
	}

	type_mv = TYPE_MAIN_VARIANT (*type);
	if (pedantic
	&& !in_system_header
	&& type_mv != integer_type_node
	&& type_mv != unsigned_type_node
	&& type_mv != boolean_type_node)
	pedwarn ("type of bit-field %qs is a GCC extension", name);

	if (type_mv == boolean_type_node)
	max_width = CHAR_TYPE_SIZE;
	else
	max_width = TYPE_PRECISION (*type);

	if (0 < compare_tree_int (*width, max_width))
	{
	error ("width of %qs exceeds its type", name);
	w = max_width;
	*width = build_int_cst (NULL_TREE, w);
	}
	else
	w = tree_low_cst (*width, 1);

	if (TREE_CODE (*type) == ENUMERAL_TYPE)
	{
	struct lang_type lt = TYPE_LANG_SPECIFIC (type);
	if (!lt
	\|\| w < min_precision (lt->enum_min, TYPE_UNSIGNED (*type))
	\|\| w < min_precision (lt->enum_max, TYPE_UNSIGNED (*type)))
	warning (0, "%qs is narrower than values of its type", name);
	}
	}



	/* Print warning about variable length array if necessary. */

	static void
	warn_variable_length_array (const char *name, tree size)
	{
	int ped = !flag_isoc99 && pedantic && warn_vla != 0;
	int const_size = TREE_CONSTANT (size);

	if (ped)
	{
	if (const_size)
	{
	if (name)
	pedwarn ("ISO C90 forbids array %qs whose size "
	"can%'t be evaluated",
	name);
	else
	pedwarn ("ISO C90 forbids array whose size "
	"can%'t be evaluated");
	}
	else
	{
	if (name)
	pedwarn ("ISO C90 forbids variable length array %qs",
	name);
	else
	pedwarn ("ISO C90 forbids variable length array");
	}
	}
	else if (warn_vla > 0)
	{
	if (const_size)
	{
	if (name)
	warning (OPT_Wvla,
	"the size of array %qs can"
	"%'t be evaluated", name);
	else
	warning (OPT_Wvla,
	"the size of array can %'t be evaluated");
	}
	else
	{
	if (name)
	warning (OPT_Wvla,
	"variable length array %qs is used",
	name);
	else
	warning (OPT_Wvla,
	"variable length array is used");
	}
	}
	}

	/* Given declspecs and a declarator,
	determine the name and type of the object declared
	and construct a ..._DECL node for it.
	(In one case we can return a ..._TYPE node instead.
	For invalid input we sometimes return 0.)

	DECLSPECS is a c_declspecs structure for the declaration specifiers.

	DECL_CONTEXT says which syntactic context this declaration is in:
	NORMAL for most contexts. Make a VAR_DECL or FUNCTION_DECL or TYPE_DECL.
	FUNCDEF for a function definition. Like NORMAL but a few different
	error messages in each case. Return value may be zero meaning
	this definition is too screwy to try to parse.
	PARM for a parameter declaration (either within a function prototype
	or before a function body). Make a PARM_DECL, or return void_type_node.
	TYPENAME if for a typename (in a cast or sizeof).
	Don't make a DECL node; just return the ..._TYPE node.
	FIELD for a struct or union field; make a FIELD_DECL.
	INITIALIZED is true if the decl has an initializer.
	WIDTH is non-NULL for bit-fields, and is a pointer to an INTEGER_CST node
	representing the width of the bit-field.

	In the TYPENAME case, DECLARATOR is really an absolute declarator.
	It may also be so in the PARM case, for a prototype where the
	argument type is specified but not the name.

	This function is where the complicated C meanings of `static'
	and `extern' are interpreted. */

	static tree
	grokdeclarator (const struct c_declarator *declarator,
	struct c_declspecs *declspecs,
	enum decl_context decl_context, bool initialized, tree *width)
	{
	tree type = declspecs->type;
	bool threadp = declspecs->thread_p;
	enum c_storage_class storage_class = declspecs->storage_class;
	int constp;
	int restrictp;
	int volatilep;
	int type_quals = TYPE_UNQUALIFIED;
	const char name, orig_name;
	tree typedef_type = 0;
	bool funcdef_flag = false;
	bool funcdef_syntax = false;
	int size_varies = 0;
	tree decl_attr = declspecs->decl_attr;
	int array_ptr_quals = TYPE_UNQUALIFIED;
	tree array_ptr_attrs = NULL_TREE;
	int array_parm_static = 0;
	bool array_parm_vla_unspec_p = false;
	tree returned_attrs = NULL_TREE;
	bool bitfield = width != NULL;
	tree element_type;
	struct c_arg_info *arg_info = 0;

	if (decl_context == FUNCDEF)
	funcdef_flag = true, decl_context = NORMAL;

	/* Look inside a declarator for the name being declared
	and get it as a string, for an error message. */
	{
	const struct c_declarator *decl = declarator;
	name = 0;

	while (decl)
	switch (decl->kind)
	{
	case cdk_function:
	case cdk_array:
	case cdk_pointer:
	funcdef_syntax = (decl->kind == cdk_function);
	decl = decl->declarator;
	break;

	case cdk_attrs:
	decl = decl->declarator;
	break;

	case cdk_id:
	if (decl->u.id)
	name = IDENTIFIER_POINTER (decl->u.id);
	decl = 0;
	break;

	default:
	gcc_unreachable ();
	}
	orig_name = name;
	if (name == 0)
	name = "type name";
	}

	/* A function definition's declarator must have the form of
	a function declarator. */

	if (funcdef_flag && !funcdef_syntax)
	return 0;

	/* If this looks like a function definition, make it one,
	even if it occurs where parms are expected.
	Then store_parm_decls will reject it and not use it as a parm. */
	+ /* APPLE LOCAL begin "unavailable" attribute (radar 2809697) */
	+ if (declspecs->unavailable_p)
	+ error_unavailable_use (declspecs->type);
	+ else
	+ /* APPLE LOCAL end "unavailable" attribute (radar 2809697) */
	if (decl_context == NORMAL && !funcdef_flag && current_scope->parm_flag)
	decl_context = PARM;

	if (declspecs->deprecated_p && deprecated_state != DEPRECATED_SUPPRESS)
	warn_deprecated_use (declspecs->type);

	if ((decl_context == NORMAL \|\| decl_context == FIELD)
	&& current_scope == file_scope
	&& variably_modified_type_p (type, NULL_TREE))
	{
	error ("variably modified %qs at file scope", name);
	type = integer_type_node;
	}

	typedef_type = type;
	size_varies = C_TYPE_VARIABLE_SIZE (type);

	/* Diagnose defaulting to "int". */

	if (declspecs->default_int_p && !in_system_header)
	{
	/* Issue a warning if this is an ISO C 99 program or if
	-Wreturn-type and this is a function, or if -Wimplicit;
	prefer the former warning since it is more explicit. */
	if ((warn_implicit_int \|\| warn_return_type \|\| flag_isoc99)
	&& funcdef_flag)
	warn_about_return_type = 1;
	else if (warn_implicit_int \|\| flag_isoc99)
	pedwarn_c99 ("type defaults to %<int%> in declaration of %qs", name);
	}

	/* Adjust the type if a bit-field is being declared,
	-funsigned-bitfields applied and the type is not explicitly
	"signed". */
	if (bitfield && !flag_signed_bitfields && !declspecs->explicit_signed_p
	&& TREE_CODE (type) == INTEGER_TYPE)
	type = c_common_unsigned_type (type);

	/* Figure out the type qualifiers for the declaration. There are
	two ways a declaration can become qualified. One is something
	like `const int i' where the `const' is explicit. Another is
	something like `typedef const int CI; CI i' where the type of the
	declaration contains the `const'. A third possibility is that
	there is a type qualifier on the element type of a typedefed
	array type, in which case we should extract that qualifier so
	that c_apply_type_quals_to_decls receives the full list of
	qualifiers to work with (C90 is not entirely clear about whether
	duplicate qualifiers should be diagnosed in this case, but it
	seems most appropriate to do so). */
	element_type = strip_array_types (type);
	constp = declspecs->const_p + TYPE_READONLY (element_type);
	restrictp = declspecs->restrict_p + TYPE_RESTRICT (element_type);
	volatilep = declspecs->volatile_p + TYPE_VOLATILE (element_type);
	if (pedantic && !flag_isoc99)
	{
	if (constp > 1)
	pedwarn ("duplicate %<const%>");
	if (restrictp > 1)
	pedwarn ("duplicate %<restrict%>");
	if (volatilep > 1)
	pedwarn ("duplicate %<volatile%>");
	}
	if (!flag_gen_aux_info && (TYPE_QUALS (element_type)))
	type = TYPE_MAIN_VARIANT (type);
	type_quals = ((constp ? TYPE_QUAL_CONST : 0)
	\| (restrictp ? TYPE_QUAL_RESTRICT : 0)
	\| (volatilep ? TYPE_QUAL_VOLATILE : 0));

	/* Warn about storage classes that are invalid for certain
	kinds of declarations (parameters, typenames, etc.). */

	if (funcdef_flag
	&& (threadp
	\|\| storage_class == csc_auto
	\|\| storage_class == csc_register
	\|\| storage_class == csc_typedef))
	{
	if (storage_class == csc_auto
	&& (pedantic \|\| current_scope == file_scope))
	pedwarn ("function definition declared %<auto%>");
	if (storage_class == csc_register)
	error ("function definition declared %<register%>");
	if (storage_class == csc_typedef)
	error ("function definition declared %<typedef%>");
	if (threadp)
	error ("function definition declared %<__thread%>");
	threadp = false;
	if (storage_class == csc_auto
	\|\| storage_class == csc_register
	\|\| storage_class == csc_typedef)
	storage_class = csc_none;
	}
	else if (decl_context != NORMAL && (storage_class != csc_none \|\| threadp))
	{
	if (decl_context == PARM && storage_class == csc_register)
	;
	else
	{
	switch (decl_context)
	{
	case FIELD:
	error ("storage class specified for structure field %qs",
	name);
	break;
	case PARM:
	error ("storage class specified for parameter %qs", name);
	break;
	default:
	error ("storage class specified for typename");
	break;
	}
	storage_class = csc_none;
	threadp = false;
	}
	}
	else if (storage_class == csc_extern
	&& initialized
	&& !funcdef_flag)
	{
	/* 'extern' with initialization is invalid if not at file scope. */
	if (current_scope == file_scope)
	{
	/* It is fine to have 'extern const' when compiling at C
	and C++ intersection. */
	if (!(warn_cxx_compat && constp))
	warning (0, "%qs initialized and declared %<extern%>", name);
	}
	else
	error ("%qs has both %<extern%> and initializer", name);
	}
	else if (current_scope == file_scope)
	{
	if (storage_class == csc_auto)
	error ("file-scope declaration of %qs specifies %<auto%>", name);
	if (pedantic && storage_class == csc_register)
	pedwarn ("file-scope declaration of %qs specifies %<register%>", name);
	}
	else
	{
	if (storage_class == csc_extern && funcdef_flag)
	error ("nested function %qs declared %<extern%>", name);
	else if (threadp && storage_class == csc_none)
	{
	error ("function-scope %qs implicitly auto and declared "
	"%<__thread%>",
	name);
	threadp = false;
	}
	}

	/* Now figure out the structure of the declarator proper.
	Descend through it, creating more complex types, until we reach
	the declared identifier (or NULL_TREE, in an absolute declarator).
	At each stage we maintain an unqualified version of the type
	together with any qualifiers that should be applied to it with
	c_build_qualified_type; this way, array types including
	multidimensional array types are first built up in unqualified
	form and then the qualified form is created with
	TYPE_MAIN_VARIANT pointing to the unqualified form. */

	while (declarator && declarator->kind != cdk_id)
	{
	if (type == error_mark_node)
	{
	declarator = declarator->declarator;
	continue;
	}

	/* Each level of DECLARATOR is either a cdk_array (for ...[..]),
	a cdk_pointer (for *...),
	a cdk_function (for ...(...)),
	a cdk_attrs (for nested attributes),
	or a cdk_id (for the name being declared
	or the place in an absolute declarator
	where the name was omitted).
	For the last case, we have just exited the loop.

	At this point, TYPE is the type of elements of an array,
	or for a function to return, or for a pointer to point to.
	After this sequence of ifs, TYPE is the type of the
	array or function or pointer, and DECLARATOR has had its
	outermost layer removed. */

	if (array_ptr_quals != TYPE_UNQUALIFIED
	\|\| array_ptr_attrs != NULL_TREE
	\|\| array_parm_static)
	{
	/* Only the innermost declarator (making a parameter be of
	array type which is converted to pointer type)
	may have static or type qualifiers. */
	error ("static or type qualifiers in non-parameter array declarator");
	array_ptr_quals = TYPE_UNQUALIFIED;
	array_ptr_attrs = NULL_TREE;
	array_parm_static = 0;
	}

	switch (declarator->kind)
	{
	case cdk_attrs:
	{
	/* A declarator with embedded attributes. */
	tree attrs = declarator->u.attrs;
	const struct c_declarator *inner_decl;
	int attr_flags = 0;
	declarator = declarator->declarator;
	inner_decl = declarator;
	while (inner_decl->kind == cdk_attrs)
	inner_decl = inner_decl->declarator;
	if (inner_decl->kind == cdk_id)
	attr_flags \|= (int) ATTR_FLAG_DECL_NEXT;
	else if (inner_decl->kind == cdk_function)
	attr_flags \|= (int) ATTR_FLAG_FUNCTION_NEXT;
	else if (inner_decl->kind == cdk_array)
	attr_flags \|= (int) ATTR_FLAG_ARRAY_NEXT;
	returned_attrs = decl_attributes (&type,
	chainon (returned_attrs, attrs),
	attr_flags);
	break;
	}
	case cdk_array:
	{
	tree itype = NULL_TREE;
	tree size = declarator->u.array.dimen;
	/* The index is a signed object `sizetype' bits wide. */
	tree index_type = c_common_signed_type (sizetype);

	array_ptr_quals = declarator->u.array.quals;
	array_ptr_attrs = declarator->u.array.attrs;
	array_parm_static = declarator->u.array.static_p;
	array_parm_vla_unspec_p = declarator->u.array.vla_unspec_p;

	declarator = declarator->declarator;

	/* Check for some types that there cannot be arrays of. */

	if (VOID_TYPE_P (type))
	{
	error ("declaration of %qs as array of voids", name);
	type = error_mark_node;
	}

	if (TREE_CODE (type) == FUNCTION_TYPE)
	{
	error ("declaration of %qs as array of functions", name);
	type = error_mark_node;
	}

	if (pedantic && !in_system_header && flexible_array_type_p (type))
	pedwarn ("invalid use of structure with flexible array member");

	if (size == error_mark_node)
	type = error_mark_node;

	if (type == error_mark_node)
	continue;

	/* If size was specified, set ITYPE to a range-type for
	that size. Otherwise, ITYPE remains null. finish_decl
	may figure it out from an initial value. */

	if (size)
	{
	/* Strip NON_LVALUE_EXPRs since we aren't using as an
	lvalue. */
	STRIP_TYPE_NOPS (size);

	if (!INTEGRAL_TYPE_P (TREE_TYPE (size)))
	{
	error ("size of array %qs has non-integer type", name);
	size = integer_one_node;
	}

	if (pedantic && integer_zerop (size))
	pedwarn ("ISO C forbids zero-size array %qs", name);

	if (TREE_CODE (size) == INTEGER_CST)
	{
	constant_expression_warning (size);
	if (tree_int_cst_sgn (size) < 0)
	{
	error ("size of array %qs is negative", name);
	size = integer_one_node;
	}
	}
	else if ((decl_context == NORMAL \|\| decl_context == FIELD)
	&& current_scope == file_scope)
	{
	error ("variably modified %qs at file scope", name);
	size = integer_one_node;
	}
	else
	{
	/* Make sure the array size remains visibly
	nonconstant even if it is (eg) a const variable
	with known value. */
	size_varies = 1;
	warn_variable_length_array (orig_name, size);
	if (warn_variable_decl)
	warning (0, "variable-sized array %qs", name);
	}

	if (integer_zerop (size))
	{
	/* A zero-length array cannot be represented with
	an unsigned index type, which is what we'll
	get with build_index_type. Create an
	open-ended range instead. */
	itype = build_range_type (sizetype, size, NULL_TREE);
	}
	else
	{
	/* Arrange for the SAVE_EXPR on the inside of the
	MINUS_EXPR, which allows the -1 to get folded
	with the +1 that happens when building TYPE_SIZE. */
	if (size_varies)
	size = variable_size (size);

	/* Compute the maximum valid index, that is, size
	- 1. Do the calculation in index_type, so that
	if it is a variable the computations will be
	done in the proper mode. */
	itype = fold_build2 (MINUS_EXPR, index_type,
	convert (index_type, size),
	convert (index_type,
	size_one_node));

	/* If that overflowed, the array is too big. ???
	While a size of INT_MAX+1 technically shouldn't
	cause an overflow (because we subtract 1), the
	overflow is recorded during the conversion to
	index_type, before the subtraction. Handling
	this case seems like an unnecessary
	complication. */
	if (TREE_CODE (itype) == INTEGER_CST
	&& TREE_OVERFLOW (itype))
	{
	error ("size of array %qs is too large", name);
	type = error_mark_node;
	continue;
	}

	itype = build_index_type (itype);
	}
	}
	else if (decl_context == FIELD)
	{
	if (pedantic && !flag_isoc99 && !in_system_header)
	pedwarn ("ISO C90 does not support flexible array members");

	/* ISO C99 Flexible array members are effectively
	identical to GCC's zero-length array extension. */
	itype = build_range_type (sizetype, size_zero_node, NULL_TREE);
	}
	else if (decl_context == PARM)
	{
	if (array_parm_vla_unspec_p)
	{
	if (! orig_name)
	{
	/* C99 6.7.5.2p4 */
	error ("%<[*]%> not allowed in other than a declaration");
	}

	itype = build_range_type (sizetype, size_zero_node, NULL_TREE);
	size_varies = 1;
	}
	}
	else if (decl_context == TYPENAME)
	{
	if (array_parm_vla_unspec_p)
	{
	/* The error is printed elsewhere. We use this to
	avoid messing up with incomplete array types of
	the same type, that would otherwise be modified
	below. */
	itype = build_range_type (sizetype, size_zero_node,
	NULL_TREE);
	}
	}

	/* Complain about arrays of incomplete types. */
	if (!COMPLETE_TYPE_P (type))
	{
	error ("array type has incomplete element type");
	type = error_mark_node;
	}
	else
	/* When itype is NULL, a shared incomplete array type is
	returned for all array of a given type. Elsewhere we
	make sure we don't complete that type before copying
	it, but here we want to make sure we don't ever
	modify the shared type, so we gcc_assert (itype)
	below. */
	type = build_array_type (type, itype);

	if (type != error_mark_node)
	{
	if (size_varies)
	{
	/* It is ok to modify type here even if itype is
	NULL: if size_varies, we're in a
	multi-dimensional array and the inner type has
	variable size, so the enclosing shared array type
	must too. */
	if (size && TREE_CODE (size) == INTEGER_CST)
	type
	= build_distinct_type_copy (TYPE_MAIN_VARIANT (type));
	C_TYPE_VARIABLE_SIZE (type) = 1;
	}

	/* The GCC extension for zero-length arrays differs from
	ISO flexible array members in that sizeof yields
	zero. */
	if (size && integer_zerop (size))
	{
	gcc_assert (itype);
	TYPE_SIZE (type) = bitsize_zero_node;
	TYPE_SIZE_UNIT (type) = size_zero_node;
	}
	if (array_parm_vla_unspec_p)
	{
	gcc_assert (itype);
	/* The type is complete. C99 6.7.5.2p4 */
	TYPE_SIZE (type) = bitsize_zero_node;
	TYPE_SIZE_UNIT (type) = size_zero_node;
	}
	}

	if (decl_context != PARM
	&& (array_ptr_quals != TYPE_UNQUALIFIED
	\|\| array_ptr_attrs != NULL_TREE
	\|\| array_parm_static))
	{
	error ("static or type qualifiers in non-parameter array declarator");
	array_ptr_quals = TYPE_UNQUALIFIED;
	array_ptr_attrs = NULL_TREE;
	array_parm_static = 0;
	}
	break;
	}
	case cdk_function:
	{
	/* Say it's a definition only for the declarator closest
	to the identifier, apart possibly from some
	attributes. */
	bool really_funcdef = false;
	tree arg_types;
	if (funcdef_flag)
	{
	const struct c_declarator *t = declarator->declarator;
	while (t->kind == cdk_attrs)
	t = t->declarator;
	really_funcdef = (t->kind == cdk_id);
	}

	/* Declaring a function type. Make sure we have a valid
	type for the function to return. */
	if (type == error_mark_node)
	continue;

	size_varies = 0;

	/* Warn about some types functions can't return. */
	if (TREE_CODE (type) == FUNCTION_TYPE)
	{
	error ("%qs declared as function returning a function", name);
	type = integer_type_node;
	}
	if (TREE_CODE (type) == ARRAY_TYPE)
	{
	error ("%qs declared as function returning an array", name);
	type = integer_type_node;
	}

	/* Construct the function type and go to the next
	inner layer of declarator. */
	arg_info = declarator->u.arg_info;
	arg_types = grokparms (arg_info, really_funcdef);
	if (really_funcdef)
	put_pending_sizes (arg_info->pending_sizes);

	/* Type qualifiers before the return type of the function
	qualify the return type, not the function type. */
	if (type_quals)
	{
	/* Type qualifiers on a function return type are
	normally permitted by the standard but have no
	effect, so give a warning at -Wreturn-type.
	Qualifiers on a void return type are banned on
	function definitions in ISO C; GCC used to used
	them for noreturn functions. */
	if (VOID_TYPE_P (type) && really_funcdef)
	pedwarn ("function definition has qualified void return type");
	else
	warning (OPT_Wreturn_type,
	"type qualifiers ignored on function return type");

	type = c_build_qualified_type (type, type_quals);
	}
	type_quals = TYPE_UNQUALIFIED;

	type = build_function_type (type, arg_types);
	declarator = declarator->declarator;

	/* Set the TYPE_CONTEXTs for each tagged type which is local to
	the formal parameter list of this FUNCTION_TYPE to point to
	the FUNCTION_TYPE node itself. */
	{
	tree link;

	for (link = arg_info->tags;
	link;
	link = TREE_CHAIN (link))
	TYPE_CONTEXT (TREE_VALUE (link)) = type;
	}
	break;
	}
	case cdk_pointer:
	{
	/* Merge any constancy or volatility into the target type
	for the pointer. */

	if (pedantic && TREE_CODE (type) == FUNCTION_TYPE
	&& type_quals)
	pedwarn ("ISO C forbids qualified function types");
	if (type_quals)
	type = c_build_qualified_type (type, type_quals);
	size_varies = 0;

	/* When the pointed-to type involves components of variable size,
	care must be taken to ensure that the size evaluation code is
	emitted early enough to dominate all the possible later uses
	and late enough for the variables on which it depends to have
	been assigned.

	This is expected to happen automatically when the pointed-to
	type has a name/declaration of it's own, but special attention
	is required if the type is anonymous.

	We handle the NORMAL and FIELD contexts here by attaching an
	artificial TYPE_DECL to such pointed-to type. This forces the
	sizes evaluation at a safe point and ensures it is not deferred
	until e.g. within a deeper conditional context.

	We expect nothing to be needed here for PARM or TYPENAME.
	Pushing a TYPE_DECL at this point for TYPENAME would actually
	be incorrect, as we might be in the middle of an expression
	with side effects on the pointed-to type size "arguments" prior
	to the pointer declaration point and the fake TYPE_DECL in the
	enclosing context would force the size evaluation prior to the
	side effects. */

	if (!TYPE_NAME (type)
	&& (decl_context == NORMAL \|\| decl_context == FIELD)
	&& variably_modified_type_p (type, NULL_TREE))
	{
	tree decl = build_decl (TYPE_DECL, NULL_TREE, type);
	DECL_ARTIFICIAL (decl) = 1;
	pushdecl (decl);
	finish_decl (decl, NULL_TREE, NULL_TREE);
	TYPE_NAME (type) = decl;
	}

	type = build_pointer_type (type);

	/* Process type qualifiers (such as const or volatile)
	that were given inside the `'. /
	type_quals = declarator->u.pointer_quals;

	declarator = declarator->declarator;
	break;
	}
	default:
	gcc_unreachable ();
	}
	}

	/* Now TYPE has the actual type, apart from any qualifiers in
	TYPE_QUALS. */

	/* Check the type and width of a bit-field. */
	if (bitfield)
	check_bitfield_type_and_width (&type, width, orig_name);

	/* Did array size calculations overflow? */

	if (TREE_CODE (type) == ARRAY_TYPE
	&& COMPLETE_TYPE_P (type)
	&& TREE_CODE (TYPE_SIZE_UNIT (type)) == INTEGER_CST
	&& TREE_OVERFLOW (TYPE_SIZE_UNIT (type)))
	{
	error ("size of array %qs is too large", name);
	/* If we proceed with the array type as it is, we'll eventually
	crash in tree_low_cst(). */
	type = error_mark_node;
	}

	/* If this is declaring a typedef name, return a TYPE_DECL. */

	if (storage_class == csc_typedef)
	{
	tree decl;
	if (pedantic && TREE_CODE (type) == FUNCTION_TYPE
	&& type_quals)
	pedwarn ("ISO C forbids qualified function types");
	if (type_quals)
	type = c_build_qualified_type (type, type_quals);
	decl = build_decl (TYPE_DECL, declarator->u.id, type);
	if (declspecs->explicit_signed_p)
	C_TYPEDEF_EXPLICITLY_SIGNED (decl) = 1;
	decl_attributes (&decl, returned_attrs, 0);
	if (declspecs->inline_p)
	pedwarn ("typedef %q+D declared %<inline%>", decl);
	return decl;
	}

	/* If this is a type name (such as, in a cast or sizeof),
	compute the type and return it now. */

	if (decl_context == TYPENAME)
	{
	/* Note that the grammar rejects storage classes in typenames
	and fields. */
	gcc_assert (storage_class == csc_none && !threadp
	&& !declspecs->inline_p);
	if (pedantic && TREE_CODE (type) == FUNCTION_TYPE
	&& type_quals)
	pedwarn ("ISO C forbids const or volatile function types");
	if (type_quals)
	type = c_build_qualified_type (type, type_quals);
	decl_attributes (&type, returned_attrs, 0);
	return type;
	}

	if (pedantic && decl_context == FIELD
	&& variably_modified_type_p (type, NULL_TREE))
	{
	/* C99 6.7.2.1p8 */
	pedwarn ("a member of a structure or union cannot have a variably modified type");
	}

	/* Aside from typedefs and type names (handle above),
	`void' at top level (not within pointer)
	is allowed only in public variables.
	We don't complain about parms either, but that is because
	a better error message can be made later. */

	if (VOID_TYPE_P (type) && decl_context != PARM
	&& !((decl_context != FIELD && TREE_CODE (type) != FUNCTION_TYPE)
	&& (storage_class == csc_extern
	\|\| (current_scope == file_scope
	&& !(storage_class == csc_static
	\|\| storage_class == csc_register)))))
	{
	error ("variable or field %qs declared void", name);
	type = integer_type_node;
	}

	/* Now create the decl, which may be a VAR_DECL, a PARM_DECL
	or a FUNCTION_DECL, depending on DECL_CONTEXT and TYPE. */

	{
	tree decl;

	if (decl_context == PARM)
	{
	tree type_as_written;
	tree promoted_type;

	/* A parameter declared as an array of T is really a pointer to T.
	One declared as a function is really a pointer to a function. */

	if (TREE_CODE (type) == ARRAY_TYPE)
	{
	/* Transfer const-ness of array into that of type pointed to. */
	type = TREE_TYPE (type);
	if (type_quals)
	type = c_build_qualified_type (type, type_quals);
	type = build_pointer_type (type);
	type_quals = array_ptr_quals;

	/* We don't yet implement attributes in this context. */
	if (array_ptr_attrs != NULL_TREE)
	warning (OPT_Wattributes,
	"attributes in parameter array declarator ignored");

	size_varies = 0;
	}
	else if (TREE_CODE (type) == FUNCTION_TYPE)
	{
	if (pedantic && type_quals)
	pedwarn ("ISO C forbids qualified function types");
	if (type_quals)
	type = c_build_qualified_type (type, type_quals);
	type = build_pointer_type (type);
	type_quals = TYPE_UNQUALIFIED;
	}
	else if (type_quals)
	type = c_build_qualified_type (type, type_quals);

	type_as_written = type;

	decl = build_decl (PARM_DECL, declarator->u.id, type);
	if (size_varies)
	C_DECL_VARIABLE_SIZE (decl) = 1;

	/* Compute the type actually passed in the parmlist,
	for the case where there is no prototype.
	(For example, shorts and chars are passed as ints.)
	When there is a prototype, this is overridden later. */

	if (type == error_mark_node)
	promoted_type = type;
	else
	promoted_type = c_type_promotes_to (type);

	DECL_ARG_TYPE (decl) = promoted_type;
	if (declspecs->inline_p)
	pedwarn ("parameter %q+D declared %<inline%>", decl);
	}
	else if (decl_context == FIELD)
	{
	/* Note that the grammar rejects storage classes in typenames
	and fields. */
	gcc_assert (storage_class == csc_none && !threadp
	&& !declspecs->inline_p);

	/* Structure field. It may not be a function. */

	if (TREE_CODE (type) == FUNCTION_TYPE)
	{
	error ("field %qs declared as a function", name);
	type = build_pointer_type (type);
	}
	else if (TREE_CODE (type) != ERROR_MARK
	&& !COMPLETE_OR_UNBOUND_ARRAY_TYPE_P (type))
	{
	error ("field %qs has incomplete type", name);
	type = error_mark_node;
	}
	type = c_build_qualified_type (type, type_quals);
	decl = build_decl (FIELD_DECL, declarator->u.id, type);
	DECL_NONADDRESSABLE_P (decl) = bitfield;

	if (size_varies)
	C_DECL_VARIABLE_SIZE (decl) = 1;
	}
	else if (TREE_CODE (type) == FUNCTION_TYPE)
	{
	if (storage_class == csc_register \|\| threadp)
	{
	error ("invalid storage class for function %qs", name);
	}
	else if (current_scope != file_scope)
	{
	/* Function declaration not at file scope. Storage
	classes other than `extern' are not allowed, C99
	6.7.1p5, and `extern' makes no difference. However,
	GCC allows 'auto', perhaps with 'inline', to support
	nested functions. */
	if (storage_class == csc_auto)
	{
	if (pedantic)
	pedwarn ("invalid storage class for function %qs", name);
	}
	else if (storage_class == csc_static)
	{
	error ("invalid storage class for function %qs", name);
	if (funcdef_flag)
	storage_class = declspecs->storage_class = csc_none;
	else
	return 0;
	}
	}

	decl = build_decl (FUNCTION_DECL, declarator->u.id, type);
	decl = build_decl_attribute_variant (decl, decl_attr);

	DECL_LANG_SPECIFIC (decl) = GGC_CNEW (struct lang_decl);

	if (pedantic && type_quals && !DECL_IN_SYSTEM_HEADER (decl))
	pedwarn ("ISO C forbids qualified function types");

	/* GNU C interprets a volatile-qualified function type to indicate
	that the function does not return. */
	if ((type_quals & TYPE_QUAL_VOLATILE)
	&& !VOID_TYPE_P (TREE_TYPE (TREE_TYPE (decl))))
	warning (0, "%<noreturn%> function returns non-void value");

	/* Every function declaration is an external reference
	(DECL_EXTERNAL) except for those which are not at file
	scope and are explicitly declared "auto". This is
	forbidden by standard C (C99 6.7.1p5) and is interpreted by
	GCC to signify a forward declaration of a nested function. */
	if (storage_class == csc_auto && current_scope != file_scope)
	DECL_EXTERNAL (decl) = 0;
	/* In C99, a function which is declared 'inline' with 'extern'
	is not an external reference (which is confusing). It
	means that the later definition of the function must be output
	in this file, C99 6.7.4p6. In GNU C89, a function declared
	'extern inline' is an external reference. */
	else if (declspecs->inline_p && storage_class != csc_static)
	DECL_EXTERNAL (decl) = ((storage_class == csc_extern)
	== flag_gnu89_inline);
	else
	DECL_EXTERNAL (decl) = !initialized;

	/* Record absence of global scope for `static' or `auto'. */
	TREE_PUBLIC (decl)
	= !(storage_class == csc_static \|\| storage_class == csc_auto);

	/* For a function definition, record the argument information
	block where store_parm_decls will look for it. */
	if (funcdef_flag)
	current_function_arg_info = arg_info;

	if (declspecs->default_int_p)
	C_FUNCTION_IMPLICIT_INT (decl) = 1;

	/* Record presence of `inline', if it is reasonable. */
	if (flag_hosted && MAIN_NAME_P (declarator->u.id))
	{
	if (declspecs->inline_p)
	pedwarn ("cannot inline function %<main%>");
	}
	else if (declspecs->inline_p)
	{
	/* Record that the function is declared `inline'. */
	DECL_DECLARED_INLINE_P (decl) = 1;

	/* Do not mark bare declarations as DECL_INLINE. Doing so
	in the presence of multiple declarations can result in
	the abstract origin pointing between the declarations,
	which will confuse dwarf2out. */
	if (initialized)
	DECL_INLINE (decl) = 1;
	}
	/* If -finline-functions, assume it can be inlined. This does
	two things: let the function be deferred until it is actually
	needed, and let dwarf2 know that the function is inlinable. */
	else if (flag_inline_trees == 2 && initialized)
	DECL_INLINE (decl) = 1;
	}
	else
	{
	/* It's a variable. */
	/* An uninitialized decl with `extern' is a reference. */
	int extern_ref = !initialized && storage_class == csc_extern;

	type = c_build_qualified_type (type, type_quals);

	/* C99 6.2.2p7: It is invalid (compile-time undefined
	behavior) to create an 'extern' declaration for a
	variable if there is a global declaration that is
	'static' and the global declaration is not visible.
	(If the static declaration _is_ currently visible,
	the 'extern' declaration is taken to refer to that decl.) */
	if (extern_ref && current_scope != file_scope)
	{
	tree global_decl = identifier_global_value (declarator->u.id);
	tree visible_decl = lookup_name (declarator->u.id);

	if (global_decl
	&& global_decl != visible_decl
	&& TREE_CODE (global_decl) == VAR_DECL
	&& !TREE_PUBLIC (global_decl))
	error ("variable previously declared %<static%> redeclared "
	"%<extern%>");
	}

	decl = build_decl (VAR_DECL, declarator->u.id, type);
	DECL_SOURCE_LOCATION (decl) = declarator->id_loc;
	if (size_varies)
	C_DECL_VARIABLE_SIZE (decl) = 1;

	if (declspecs->inline_p)
	pedwarn ("variable %q+D declared %<inline%>", decl);

	/* At file scope, an initialized extern declaration may follow
	a static declaration. In that case, DECL_EXTERNAL will be
	reset later in start_decl. */
	DECL_EXTERNAL (decl) = (storage_class == csc_extern);

	/* At file scope, the presence of a `static' or `register' storage
	class specifier, or the absence of all storage class specifiers
	makes this declaration a definition (perhaps tentative). Also,
	the absence of `static' makes it public. */
	if (current_scope == file_scope)
	{
	TREE_PUBLIC (decl) = storage_class != csc_static;
	TREE_STATIC (decl) = !extern_ref;
	}
	/* Not at file scope, only `static' makes a static definition. */
	else
	{
	TREE_STATIC (decl) = (storage_class == csc_static);
	TREE_PUBLIC (decl) = extern_ref;
	}

	if (threadp)
	{
	if (targetm.have_tls)
	DECL_TLS_MODEL (decl) = decl_default_tls_model (decl);
	else
	/* A mere warning is sure to result in improper semantics
	at runtime. Don't bother to allow this to compile. */
	error ("thread-local storage not supported for this target");
	}
	}

	if (storage_class == csc_extern
	&& variably_modified_type_p (type, NULL_TREE))
	{
	/* C99 6.7.5.2p2 */
	error ("object with variably modified type must have no linkage");
	}

	/* Record `register' declaration for warnings on &
	and in case doing stupid register allocation. */

	if (storage_class == csc_register)
	{
	C_DECL_REGISTER (decl) = 1;
	DECL_REGISTER (decl) = 1;
	}

	/* Record constancy and volatility. */
	c_apply_type_quals_to_decl (type_quals, decl);

	/* If a type has volatile components, it should be stored in memory.
	Otherwise, the fact that those components are volatile
	will be ignored, and would even crash the compiler.
	Of course, this only makes sense on VAR,PARM, and RESULT decl's. */
	if (C_TYPE_FIELDS_VOLATILE (TREE_TYPE (decl))
	&& (TREE_CODE (decl) == VAR_DECL \|\| TREE_CODE (decl) == PARM_DECL
	\|\| TREE_CODE (decl) == RESULT_DECL))
	{
	/* It is not an error for a structure with volatile fields to
	be declared register, but reset DECL_REGISTER since it
	cannot actually go in a register. */
	int was_reg = C_DECL_REGISTER (decl);
	C_DECL_REGISTER (decl) = 0;
	DECL_REGISTER (decl) = 0;
	c_mark_addressable (decl);
	C_DECL_REGISTER (decl) = was_reg;
	}

	/* This is the earliest point at which we might know the assembler
	name of a variable. Thus, if it's known before this, die horribly. */
	gcc_assert (!DECL_ASSEMBLER_NAME_SET_P (decl));

	decl_attributes (&decl, returned_attrs, 0);

	return decl;
	}
	}

	/* Decode the parameter-list info for a function type or function definition.
	The argument is the value returned by `get_parm_info' (or made in c-parse.c
	if there is an identifier list instead of a parameter decl list).
	These two functions are separate because when a function returns
	or receives functions then each is called multiple times but the order
	of calls is different. The last call to `grokparms' is always the one
	that contains the formal parameter names of a function definition.

	Return a list of arg types to use in the FUNCTION_TYPE for this function.

	FUNCDEF_FLAG is true for a function definition, false for
	a mere declaration. A nonempty identifier-list gets an error message
	when FUNCDEF_FLAG is false. */

	static tree
	grokparms (struct c_arg_info *arg_info, bool funcdef_flag)
	{
	tree arg_types = arg_info->types;

	if (funcdef_flag && arg_info->had_vla_unspec)
	{
	/* A function definition isn't function prototype scope C99 6.2.1p4. */
	/* C99 6.7.5.2p4 */
	error ("%<[*]%> not allowed in other than function prototype scope");
	}

	if (arg_types == 0 && !funcdef_flag && !in_system_header)
	warning (OPT_Wstrict_prototypes,
	"function declaration isn%'t a prototype");

	if (arg_types == error_mark_node)
	return 0; /* don't set TYPE_ARG_TYPES in this case */

	else if (arg_types && TREE_CODE (TREE_VALUE (arg_types)) == IDENTIFIER_NODE)
	{
	if (!funcdef_flag)
	pedwarn ("parameter names (without types) in function declaration");

	arg_info->parms = arg_info->types;
	arg_info->types = 0;
	return 0;
	}
	else
	{
	tree parm, type, typelt;
	unsigned int parmno;

	/* If there is a parameter of incomplete type in a definition,
	this is an error. In a declaration this is valid, and a
	struct or union type may be completed later, before any calls
	or definition of the function. In the case where the tag was
	first declared within the parameter list, a warning has
	already been given. If a parameter has void type, then
	however the function cannot be defined or called, so
	warn. */

	for (parm = arg_info->parms, typelt = arg_types, parmno = 1;
	parm;
	parm = TREE_CHAIN (parm), typelt = TREE_CHAIN (typelt), parmno++)
	{
	type = TREE_VALUE (typelt);
	if (type == error_mark_node)
	continue;

	if (!COMPLETE_TYPE_P (type))
	{
	if (funcdef_flag)
	{
	if (DECL_NAME (parm))
	error ("parameter %u (%q+D) has incomplete type",
	parmno, parm);
	else
	error ("%Jparameter %u has incomplete type",
	parm, parmno);

	TREE_VALUE (typelt) = error_mark_node;
	TREE_TYPE (parm) = error_mark_node;
	}
	else if (VOID_TYPE_P (type))
	{
	if (DECL_NAME (parm))
	warning (0, "parameter %u (%q+D) has void type",
	parmno, parm);
	else
	warning (0, "%Jparameter %u has void type",
	parm, parmno);
	}
	}

	if (DECL_NAME (parm) && TREE_USED (parm))
	warn_if_shadowing (parm);
	}
	return arg_types;
	}
	}

	/* Take apart the current scope and return a c_arg_info structure with
	info on a parameter list just parsed.

	This structure is later fed to 'grokparms' and 'store_parm_decls'.

	ELLIPSIS being true means the argument list ended in '...' so don't
	append a sentinel (void_list_node) to the end of the type-list. */

	struct c_arg_info *
	get_parm_info (bool ellipsis)
	{
	struct c_binding *b = current_scope->bindings;
	struct c_arg_info *arg_info = XOBNEW (&parser_obstack,
	struct c_arg_info);
	tree parms = 0;
	tree tags = 0;
	tree types = 0;
	tree others = 0;

	static bool explained_incomplete_types = false;
	bool gave_void_only_once_err = false;

	arg_info->parms = 0;
	arg_info->tags = 0;
	arg_info->types = 0;
	arg_info->others = 0;
	arg_info->pending_sizes = 0;
	arg_info->had_vla_unspec = current_scope->had_vla_unspec;

	/* The bindings in this scope must not get put into a block.
	We will take care of deleting the binding nodes. */
	current_scope->bindings = 0;

	/* This function is only called if there was something on the
	parameter list. */
	gcc_assert (b);

	/* A parameter list consisting solely of 'void' indicates that the
	function takes no arguments. But if the 'void' is qualified
	(by 'const' or 'volatile'), or has a storage class specifier
	('register'), then the behavior is undefined; issue an error.
	Typedefs for 'void' are OK (see DR#157). */
	if (b->prev == 0 /* one binding */
	&& TREE_CODE (b->decl) == PARM_DECL /* which is a parameter */
	&& !DECL_NAME (b->decl) /* anonymous */
	&& VOID_TYPE_P (TREE_TYPE (b->decl))) /* of void type */
	{
	if (TREE_THIS_VOLATILE (b->decl)
	\|\| TREE_READONLY (b->decl)
	\|\| C_DECL_REGISTER (b->decl))
	error ("%<void%> as only parameter may not be qualified");

	/* There cannot be an ellipsis. */
	if (ellipsis)
	error ("%<void%> must be the only parameter");

	arg_info->types = void_list_node;
	return arg_info;
	}

	if (!ellipsis)
	types = void_list_node;

	/* Break up the bindings list into parms, tags, types, and others;
	apply sanity checks; purge the name-to-decl bindings. */
	while (b)
	{
	tree decl = b->decl;
	tree type = TREE_TYPE (decl);
	const char *keyword;

	switch (TREE_CODE (decl))
	{
	case PARM_DECL:
	if (b->id)
	{
	gcc_assert (I_SYMBOL_BINDING (b->id) == b);
	I_SYMBOL_BINDING (b->id) = b->shadowed;
	}

	/* Check for forward decls that never got their actual decl. */
	if (TREE_ASM_WRITTEN (decl))
	error ("parameter %q+D has just a forward declaration", decl);
	/* Check for (..., void, ...) and issue an error. */
	else if (VOID_TYPE_P (type) && !DECL_NAME (decl))
	{
	if (!gave_void_only_once_err)
	{
	error ("%<void%> must be the only parameter");
	gave_void_only_once_err = true;
	}
	}
	else
	{
	/* Valid parameter, add it to the list. */
	TREE_CHAIN (decl) = parms;
	parms = decl;

	/* Since there is a prototype, args are passed in their
	declared types. The back end may override this later. */
	DECL_ARG_TYPE (decl) = type;
	types = tree_cons (0, type, types);
	}
	break;

	case ENUMERAL_TYPE: keyword = "enum"; goto tag;
	case UNION_TYPE: keyword = "union"; goto tag;
	case RECORD_TYPE: keyword = "struct"; goto tag;
	tag:
	/* Types may not have tag-names, in which case the type
	appears in the bindings list with b->id NULL. */
	if (b->id)
	{
	gcc_assert (I_TAG_BINDING (b->id) == b);
	I_TAG_BINDING (b->id) = b->shadowed;
	}

	/* Warn about any struct, union or enum tags defined in a
	parameter list. The scope of such types is limited to
	the parameter list, which is rarely if ever desirable
	(it's impossible to call such a function with type-
	correct arguments). An anonymous union parm type is
	meaningful as a GNU extension, so don't warn for that. */
	if (TREE_CODE (decl) != UNION_TYPE \|\| b->id != 0)
	{
	if (b->id)
	/* The %s will be one of 'struct', 'union', or 'enum'. */
	warning (0, "%<%s %E%> declared inside parameter list",
	keyword, b->id);
	else
	/* The %s will be one of 'struct', 'union', or 'enum'. */
	warning (0, "anonymous %s declared inside parameter list",
	keyword);

	if (!explained_incomplete_types)
	{
	warning (0, "its scope is only this definition or declaration,"
	" which is probably not what you want");
	explained_incomplete_types = true;
	}
	}

	tags = tree_cons (b->id, decl, tags);
	break;

	case CONST_DECL:
	case TYPE_DECL:
	case FUNCTION_DECL:
	/* CONST_DECLs appear here when we have an embedded enum,
	and TYPE_DECLs appear here when we have an embedded struct
	or union. No warnings for this - we already warned about the
	type itself. FUNCTION_DECLs appear when there is an implicit
	function declaration in the parameter list. */

	TREE_CHAIN (decl) = others;
	others = decl;
	/* fall through */

	case ERROR_MARK:
	/* error_mark_node appears here when we have an undeclared
	variable. Just throw it away. */
	if (b->id)
	{
	gcc_assert (I_SYMBOL_BINDING (b->id) == b);
	I_SYMBOL_BINDING (b->id) = b->shadowed;
	}
	break;

	/* Other things that might be encountered. */
	case LABEL_DECL:
	case VAR_DECL:
	default:
	gcc_unreachable ();
	}

	b = free_binding_and_advance (b);
	}

	arg_info->parms = parms;
	arg_info->tags = tags;
	arg_info->types = types;
	arg_info->others = others;
	arg_info->pending_sizes = get_pending_sizes ();
	return arg_info;
	}

	/* Get the struct, enum or union (CODE says which) with tag NAME.
	Define the tag as a forward-reference if it is not defined.
	Return a c_typespec structure for the type specifier. */

	struct c_typespec
	parser_xref_tag (enum tree_code code, tree name)
	{
	struct c_typespec ret;
	/* If a cross reference is requested, look up the type
	already defined for this tag and return it. */

	tree ref = lookup_tag (code, name, 0);
	/* If this is the right type of tag, return what we found.
	(This reference will be shadowed by shadow_tag later if appropriate.)
	If this is the wrong type of tag, do not return it. If it was the
	wrong type in the same scope, we will have had an error
	message already; if in a different scope and declaring
	a name, pending_xref_error will give an error message; but if in a
	different scope and not declaring a name, this tag should
	shadow the previous declaration of a different type of tag, and
	this would not work properly if we return the reference found.
	(For example, with "struct foo" in an outer scope, "union foo;"
	must shadow that tag with a new one of union type.) */
	ret.kind = (ref ? ctsk_tagref : ctsk_tagfirstref);
	if (ref && TREE_CODE (ref) == code)
	{
	ret.spec = ref;
	return ret;
	}

	/* If no such tag is yet defined, create a forward-reference node
	and record it as the "definition".
	When a real declaration of this type is found,
	the forward-reference will be altered into a real type. */

	ref = make_node (code);
	if (code == ENUMERAL_TYPE)
	{
	/* Give the type a default layout like unsigned int
	to avoid crashing if it does not get defined. */
	TYPE_MODE (ref) = TYPE_MODE (unsigned_type_node);
	TYPE_ALIGN (ref) = TYPE_ALIGN (unsigned_type_node);
	TYPE_USER_ALIGN (ref) = 0;
	TYPE_UNSIGNED (ref) = 1;
	TYPE_PRECISION (ref) = TYPE_PRECISION (unsigned_type_node);
	TYPE_MIN_VALUE (ref) = TYPE_MIN_VALUE (unsigned_type_node);
	TYPE_MAX_VALUE (ref) = TYPE_MAX_VALUE (unsigned_type_node);
	}

	pushtag (name, ref);

	ret.spec = ref;
	return ret;
	}

	/* Get the struct, enum or union (CODE says which) with tag NAME.
	Define the tag as a forward-reference if it is not defined.
	Return a tree for the type. */

	tree
	xref_tag (enum tree_code code, tree name)
	{
	return parser_xref_tag (code, name).spec;
	}

	/* Make sure that the tag NAME is defined in the current scope
	at least as a forward reference.
	CODE says which kind of tag NAME ought to be. */

	tree
	start_struct (enum tree_code code, tree name)
	{
	/* If there is already a tag defined at this scope
	(as a forward reference), just return it. */

	tree ref = 0;

	if (name != 0)
	ref = lookup_tag (code, name, 1);
	if (ref && TREE_CODE (ref) == code)
	{
	if (TYPE_SIZE (ref))
	{
	if (code == UNION_TYPE)
	error ("redefinition of %<union %E%>", name);
	else
	error ("redefinition of %<struct %E%>", name);
	}
	else if (C_TYPE_BEING_DEFINED (ref))
	{
	if (code == UNION_TYPE)
	error ("nested redefinition of %<union %E%>", name);
	else
	error ("nested redefinition of %<struct %E%>", name);
	/* Don't create structures that contain themselves. */
	ref = NULL_TREE;
	}
	}

	/* Otherwise create a forward-reference just so the tag is in scope. */

	if (ref == NULL_TREE \|\| TREE_CODE (ref) != code)
	{
	ref = make_node (code);
	pushtag (name, ref);
	}

	C_TYPE_BEING_DEFINED (ref) = 1;
	TYPE_PACKED (ref) = flag_pack_struct;
	return ref;
	}

	/* Process the specs, declarator and width (NULL if omitted)
	of a structure component, returning a FIELD_DECL node.
	WIDTH is non-NULL for bit-fields only, and is an INTEGER_CST node.

	This is done during the parsing of the struct declaration.
	The FIELD_DECL nodes are chained together and the lot of them
	are ultimately passed to `build_struct' to make the RECORD_TYPE node. */

	tree
	grokfield (struct c_declarator declarator, struct c_declspecs declspecs,
	tree width)
	{
	tree value;

	if (declarator->kind == cdk_id && declarator->u.id == NULL_TREE
	&& width == NULL_TREE)
	{
	/* This is an unnamed decl.

	If we have something of the form "union { list } ;" then this
	is the anonymous union extension. Similarly for struct.

	If this is something of the form "struct foo;", then
	If MS extensions are enabled, this is handled as an
	anonymous struct.
	Otherwise this is a forward declaration of a structure tag.

	If this is something of the form "foo;" and foo is a TYPE_DECL, then
	If MS extensions are enabled and foo names a structure, then
	again this is an anonymous struct.
	Otherwise this is an error.

	Oh what a horrid tangled web we weave. I wonder if MS consciously
	took this from Plan 9 or if it was an accident of implementation
	that took root before someone noticed the bug... */

	tree type = declspecs->type;
	bool type_ok = (TREE_CODE (type) == RECORD_TYPE
	\|\| TREE_CODE (type) == UNION_TYPE);
	bool ok = false;

	if (type_ok
	&& (flag_ms_extensions \|\| !declspecs->typedef_p))
	{
	if (flag_ms_extensions)
	ok = true;
	else if (flag_iso)
	ok = false;
	else if (TYPE_NAME (type) == NULL)
	ok = true;
	else
	ok = false;
	}
	if (!ok)
	{
	pedwarn ("declaration does not declare anything");
	return NULL_TREE;
	}
	if (pedantic)
	pedwarn ("ISO C doesn%'t support unnamed structs/unions");
	}

	value = grokdeclarator (declarator, declspecs, FIELD, false,
	width ? &width : NULL);

	finish_decl (value, NULL_TREE, NULL_TREE);
	DECL_INITIAL (value) = width;

	return value;
	}

	/* Generate an error for any duplicate field names in FIELDLIST. Munge
	the list such that this does not present a problem later. */

	static void
	detect_field_duplicates (tree fieldlist)
	{
	tree x, y;
	int timeout = 10;

	/* First, see if there are more than "a few" fields.
	This is trivially true if there are zero or one fields. */
	if (!fieldlist)
	return;
	x = TREE_CHAIN (fieldlist);
	if (!x)
	return;
	do {
	timeout--;
	x = TREE_CHAIN (x);
	} while (timeout > 0 && x);

	/* If there were "few" fields, avoid the overhead of allocating
	a hash table. Instead just do the nested traversal thing. */
	if (timeout > 0)
	{
	for (x = TREE_CHAIN (fieldlist); x ; x = TREE_CHAIN (x))
	if (DECL_NAME (x))
	{
	for (y = fieldlist; y != x; y = TREE_CHAIN (y))
	if (DECL_NAME (y) == DECL_NAME (x))
	{
	error ("duplicate member %q+D", x);
	DECL_NAME (x) = NULL_TREE;
	}
	}
	}
	else
	{
	htab_t htab = htab_create (37, htab_hash_pointer, htab_eq_pointer, NULL);
	void **slot;

	for (x = fieldlist; x ; x = TREE_CHAIN (x))
	if ((y = DECL_NAME (x)) != 0)
	{
	slot = htab_find_slot (htab, y, INSERT);
	if (*slot)
	{
	error ("duplicate member %q+D", x);
	DECL_NAME (x) = NULL_TREE;
	}
	*slot = y;
	}

	htab_delete (htab);
	}
	}

	/* Fill in the fields of a RECORD_TYPE or UNION_TYPE node, T.
	FIELDLIST is a chain of FIELD_DECL nodes for the fields.
	ATTRIBUTES are attributes to be applied to the structure. */

	tree
	finish_struct (tree t, tree fieldlist, tree attributes)
	{
	tree x;
	bool toplevel = file_scope == current_scope;
	int saw_named_field;

	/* If this type was previously laid out as a forward reference,
	make sure we lay it out again. */

	TYPE_SIZE (t) = 0;

	decl_attributes (&t, attributes, (int) ATTR_FLAG_TYPE_IN_PLACE);

	if (pedantic)
	{
	for (x = fieldlist; x; x = TREE_CHAIN (x))
	if (DECL_NAME (x) != 0)
	break;

	if (x == 0)
	{
	if (TREE_CODE (t) == UNION_TYPE)
	{
	if (fieldlist)
	pedwarn ("union has no named members");
	else
	pedwarn ("union has no members");
	}
	else
	{
	if (fieldlist)
	pedwarn ("struct has no named members");
	else
	pedwarn ("struct has no members");
	}
	}
	}

	/* Install struct as DECL_CONTEXT of each field decl.
	Also process specified field sizes, found in the DECL_INITIAL,
	storing 0 there after the type has been changed to precision equal
	to its width, rather than the precision of the specified standard
	type. (Correct layout requires the original type to have been preserved
	until now.) */

	saw_named_field = 0;
	for (x = fieldlist; x; x = TREE_CHAIN (x))
	{
	if (TREE_TYPE (x) == error_mark_node)
	continue;

	DECL_CONTEXT (x) = t;

	if (TYPE_PACKED (t) && TYPE_ALIGN (TREE_TYPE (x)) > BITS_PER_UNIT)
	DECL_PACKED (x) = 1;

	/* If any field is const, the structure type is pseudo-const. */
	if (TREE_READONLY (x))
	C_TYPE_FIELDS_READONLY (t) = 1;
	else
	{
	/* A field that is pseudo-const makes the structure likewise. */
	tree t1 = TREE_TYPE (x);
	while (TREE_CODE (t1) == ARRAY_TYPE)
	t1 = TREE_TYPE (t1);
	if ((TREE_CODE (t1) == RECORD_TYPE \|\| TREE_CODE (t1) == UNION_TYPE)
	&& C_TYPE_FIELDS_READONLY (t1))
	C_TYPE_FIELDS_READONLY (t) = 1;
	}

	/* Any field that is volatile means variables of this type must be
	treated in some ways as volatile. */
	if (TREE_THIS_VOLATILE (x))
	C_TYPE_FIELDS_VOLATILE (t) = 1;

	/* Any field of nominal variable size implies structure is too. */
	if (C_DECL_VARIABLE_SIZE (x))
	C_TYPE_VARIABLE_SIZE (t) = 1;

	if (DECL_INITIAL (x))
	{
	unsigned HOST_WIDE_INT width = tree_low_cst (DECL_INITIAL (x), 1);
	DECL_SIZE (x) = bitsize_int (width);
	DECL_BIT_FIELD (x) = 1;
	SET_DECL_C_BIT_FIELD (x);
	}

	/* Detect flexible array member in an invalid context. */
	if (TREE_CODE (TREE_TYPE (x)) == ARRAY_TYPE
	&& TYPE_SIZE (TREE_TYPE (x)) == NULL_TREE
	&& TYPE_DOMAIN (TREE_TYPE (x)) != NULL_TREE
	&& TYPE_MAX_VALUE (TYPE_DOMAIN (TREE_TYPE (x))) == NULL_TREE)
	{
	if (TREE_CODE (t) == UNION_TYPE)
	{
	error ("%Jflexible array member in union", x);
	TREE_TYPE (x) = error_mark_node;
	}
	else if (TREE_CHAIN (x) != NULL_TREE)
	{
	error ("%Jflexible array member not at end of struct", x);
	TREE_TYPE (x) = error_mark_node;
	}
	else if (!saw_named_field)
	{
	error ("%Jflexible array member in otherwise empty struct", x);
	TREE_TYPE (x) = error_mark_node;
	}
	}

	if (pedantic && !in_system_header && TREE_CODE (t) == RECORD_TYPE
	&& flexible_array_type_p (TREE_TYPE (x)))
	pedwarn ("%Jinvalid use of structure with flexible array member", x);

	if (DECL_NAME (x))
	saw_named_field = 1;
	}

	detect_field_duplicates (fieldlist);

	/* Now we have the nearly final fieldlist. Record it,
	then lay out the structure or union (including the fields). */

	TYPE_FIELDS (t) = fieldlist;

	layout_type (t);

	/* Give bit-fields their proper types. */
	{
	tree *fieldlistp = &fieldlist;
	while (*fieldlistp)
	if (TREE_CODE (fieldlistp) == FIELD_DECL && DECL_INITIAL (fieldlistp)
	&& TREE_TYPE (*fieldlistp) != error_mark_node)
	{
	unsigned HOST_WIDE_INT width
	= tree_low_cst (DECL_INITIAL (*fieldlistp), 1);
	tree type = TREE_TYPE (*fieldlistp);
	if (width != TYPE_PRECISION (type))
	{
	TREE_TYPE (*fieldlistp)
	= c_build_bitfield_integer_type (width, TYPE_UNSIGNED (type));
	DECL_MODE (fieldlistp) = TYPE_MODE (TREE_TYPE (fieldlistp));
	}
	DECL_INITIAL (*fieldlistp) = 0;
	}
	else
	fieldlistp = &TREE_CHAIN (*fieldlistp);
	}

	/* Now we have the truly final field list.
	Store it in this type and in the variants. */

	TYPE_FIELDS (t) = fieldlist;

	/* If there are lots of fields, sort so we can look through them fast.
	We arbitrarily consider 16 or more elts to be "a lot". */

	{
	int len = 0;

	for (x = fieldlist; x; x = TREE_CHAIN (x))
	{
	if (len > 15 \|\| DECL_NAME (x) == NULL)
	break;
	len += 1;
	}

	if (len > 15)
	{
	tree *field_array;
	struct lang_type *space;
	struct sorted_fields_type *space2;

	len += list_length (x);

	/* Use the same allocation policy here that make_node uses, to
	ensure that this lives as long as the rest of the struct decl.
	All decls in an inline function need to be saved. */

	space = GGC_CNEW (struct lang_type);
	space2 = GGC_NEWVAR (struct sorted_fields_type,
	sizeof (struct sorted_fields_type) + len * sizeof (tree));

	len = 0;
	space->s = space2;
	field_array = &space2->elts[0];
	for (x = fieldlist; x; x = TREE_CHAIN (x))
	{
	field_array[len++] = x;

	/* If there is anonymous struct or union, break out of the loop. */
	if (DECL_NAME (x) == NULL)
	break;
	}
	/* Found no anonymous struct/union. Add the TYPE_LANG_SPECIFIC. */
	if (x == NULL)
	{
	TYPE_LANG_SPECIFIC (t) = space;
	TYPE_LANG_SPECIFIC (t)->s->len = len;
	field_array = TYPE_LANG_SPECIFIC (t)->s->elts;
	qsort (field_array, len, sizeof (tree), field_decl_cmp);
	}
	}
	}

	for (x = TYPE_MAIN_VARIANT (t); x; x = TYPE_NEXT_VARIANT (x))
	{
	TYPE_FIELDS (x) = TYPE_FIELDS (t);
	TYPE_LANG_SPECIFIC (x) = TYPE_LANG_SPECIFIC (t);
	C_TYPE_FIELDS_READONLY (x) = C_TYPE_FIELDS_READONLY (t);
	C_TYPE_FIELDS_VOLATILE (x) = C_TYPE_FIELDS_VOLATILE (t);
	C_TYPE_VARIABLE_SIZE (x) = C_TYPE_VARIABLE_SIZE (t);
	}

	/* If this was supposed to be a transparent union, but we can't
	make it one, warn and turn off the flag. */
	if (TREE_CODE (t) == UNION_TYPE
	&& TYPE_TRANSPARENT_UNION (t)
	&& (!TYPE_FIELDS (t) \|\| TYPE_MODE (t) != DECL_MODE (TYPE_FIELDS (t))))
	{
	TYPE_TRANSPARENT_UNION (t) = 0;
	warning (0, "union cannot be made transparent");
	}

	/* If this structure or union completes the type of any previous
	variable declaration, lay it out and output its rtl. */
	for (x = C_TYPE_INCOMPLETE_VARS (TYPE_MAIN_VARIANT (t));
	x;
	x = TREE_CHAIN (x))
	{
	tree decl = TREE_VALUE (x);
	if (TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE)
	layout_array_type (TREE_TYPE (decl));
	if (TREE_CODE (decl) != TYPE_DECL)
	{
	layout_decl (decl, 0);
	if (c_dialect_objc ())
	objc_check_decl (decl);
	rest_of_decl_compilation (decl, toplevel, 0);
	if (!toplevel)
	expand_decl (decl);
	}
	}
	C_TYPE_INCOMPLETE_VARS (TYPE_MAIN_VARIANT (t)) = 0;

	/* Finish debugging output for this type. */
	rest_of_type_compilation (t, toplevel);

	/* If we're inside a function proper, i.e. not file-scope and not still
	parsing parameters, then arrange for the size of a variable sized type
	to be bound now. */
	if (cur_stmt_list && variably_modified_type_p (t, NULL_TREE))
	add_stmt (build_stmt (DECL_EXPR, build_decl (TYPE_DECL, NULL, t)));

	return t;
	}

	/* Lay out the type T, and its element type, and so on. */

	static void
	layout_array_type (tree t)
	{
	if (TREE_CODE (TREE_TYPE (t)) == ARRAY_TYPE)
	layout_array_type (TREE_TYPE (t));
	layout_type (t);
	}

	/* Begin compiling the definition of an enumeration type.
	NAME is its name (or null if anonymous).
	Returns the type object, as yet incomplete.
	Also records info about it so that build_enumerator
	may be used to declare the individual values as they are read. */

	tree
	start_enum (tree name)
	{
	tree enumtype = 0;

	/* If this is the real definition for a previous forward reference,
	fill in the contents in the same object that used to be the
	forward reference. */

	if (name != 0)
	enumtype = lookup_tag (ENUMERAL_TYPE, name, 1);

	if (enumtype == 0 \|\| TREE_CODE (enumtype) != ENUMERAL_TYPE)
	{
	enumtype = make_node (ENUMERAL_TYPE);
	pushtag (name, enumtype);
	}

	if (C_TYPE_BEING_DEFINED (enumtype))
	error ("nested redefinition of %<enum %E%>", name);

	C_TYPE_BEING_DEFINED (enumtype) = 1;

	if (TYPE_VALUES (enumtype) != 0)
	{
	/* This enum is a named one that has been declared already. */
	error ("redeclaration of %<enum %E%>", name);

	/* Completely replace its old definition.
	The old enumerators remain defined, however. */
	TYPE_VALUES (enumtype) = 0;
	}

	enum_next_value = integer_zero_node;
	enum_overflow = 0;

	if (flag_short_enums)
	TYPE_PACKED (enumtype) = 1;

	return enumtype;
	}

	/* After processing and defining all the values of an enumeration type,
	install their decls in the enumeration type and finish it off.
	ENUMTYPE is the type object, VALUES a list of decl-value pairs,
	and ATTRIBUTES are the specified attributes.
	Returns ENUMTYPE. */

	tree
	finish_enum (tree enumtype, tree values, tree attributes)
	{
	tree pair, tem;
	tree minnode = 0, maxnode = 0;
	int precision, unsign;
	bool toplevel = (file_scope == current_scope);
	struct lang_type *lt;

	decl_attributes (&enumtype, attributes, (int) ATTR_FLAG_TYPE_IN_PLACE);

	/* Calculate the maximum value of any enumerator in this type. */

	if (values == error_mark_node)
	minnode = maxnode = integer_zero_node;
	else
	{
	minnode = maxnode = TREE_VALUE (values);
	for (pair = TREE_CHAIN (values); pair; pair = TREE_CHAIN (pair))
	{
	tree value = TREE_VALUE (pair);
	if (tree_int_cst_lt (maxnode, value))
	maxnode = value;
	if (tree_int_cst_lt (value, minnode))
	minnode = value;
	}
	}

	/* Construct the final type of this enumeration. It is the same
	as one of the integral types - the narrowest one that fits, except
	that normally we only go as narrow as int - and signed iff any of
	the values are negative. */
	unsign = (tree_int_cst_sgn (minnode) >= 0);
	precision = MAX (min_precision (minnode, unsign),
	min_precision (maxnode, unsign));

	if (TYPE_PACKED (enumtype) \|\| precision > TYPE_PRECISION (integer_type_node))
	{
	tem = c_common_type_for_size (precision, unsign);
	if (tem == NULL)
	{
	warning (0, "enumeration values exceed range of largest integer");
	tem = long_long_integer_type_node;
	}
	}
	else
	tem = unsign ? unsigned_type_node : integer_type_node;

	TYPE_MIN_VALUE (enumtype) = TYPE_MIN_VALUE (tem);
	TYPE_MAX_VALUE (enumtype) = TYPE_MAX_VALUE (tem);
	TYPE_UNSIGNED (enumtype) = TYPE_UNSIGNED (tem);
	TYPE_SIZE (enumtype) = 0;

	/* If the precision of the type was specific with an attribute and it
	was too small, give an error. Otherwise, use it. */
	if (TYPE_PRECISION (enumtype))
	{
	if (precision > TYPE_PRECISION (enumtype))
	error ("specified mode too small for enumeral values");
	}
	else
	TYPE_PRECISION (enumtype) = TYPE_PRECISION (tem);

	layout_type (enumtype);

	if (values != error_mark_node)
	{
	/* Change the type of the enumerators to be the enum type. We
	need to do this irrespective of the size of the enum, for
	proper type checking. Replace the DECL_INITIALs of the
	enumerators, and the value slots of the list, with copies
	that have the enum type; they cannot be modified in place
	because they may be shared (e.g. integer_zero_node) Finally,
	change the purpose slots to point to the names of the decls. */
	for (pair = values; pair; pair = TREE_CHAIN (pair))
	{
	tree enu = TREE_PURPOSE (pair);
	tree ini = DECL_INITIAL (enu);

	TREE_TYPE (enu) = enumtype;

	/* The ISO C Standard mandates enumerators to have type int,
	even though the underlying type of an enum type is
	unspecified. Here we convert any enumerators that fit in
	an int to type int, to avoid promotions to unsigned types
	when comparing integers with enumerators that fit in the
	int range. When -pedantic is given, build_enumerator()
	would have already taken care of those that don't fit. */
	if (int_fits_type_p (ini, integer_type_node))
	tem = integer_type_node;
	else
	tem = enumtype;
	ini = convert (tem, ini);

	DECL_INITIAL (enu) = ini;
	TREE_PURPOSE (pair) = DECL_NAME (enu);
	TREE_VALUE (pair) = ini;
	}

	TYPE_VALUES (enumtype) = values;
	}

	/* Record the min/max values so that we can warn about bit-field
	enumerations that are too small for the values. */
	lt = GGC_CNEW (struct lang_type);
	lt->enum_min = minnode;
	lt->enum_max = maxnode;
	TYPE_LANG_SPECIFIC (enumtype) = lt;

	/* Fix up all variant types of this enum type. */
	for (tem = TYPE_MAIN_VARIANT (enumtype); tem; tem = TYPE_NEXT_VARIANT (tem))
	{
	if (tem == enumtype)
	continue;
	TYPE_VALUES (tem) = TYPE_VALUES (enumtype);
	TYPE_MIN_VALUE (tem) = TYPE_MIN_VALUE (enumtype);
	TYPE_MAX_VALUE (tem) = TYPE_MAX_VALUE (enumtype);
	TYPE_SIZE (tem) = TYPE_SIZE (enumtype);
	TYPE_SIZE_UNIT (tem) = TYPE_SIZE_UNIT (enumtype);
	TYPE_MODE (tem) = TYPE_MODE (enumtype);
	TYPE_PRECISION (tem) = TYPE_PRECISION (enumtype);
	TYPE_ALIGN (tem) = TYPE_ALIGN (enumtype);
	TYPE_USER_ALIGN (tem) = TYPE_USER_ALIGN (enumtype);
	TYPE_UNSIGNED (tem) = TYPE_UNSIGNED (enumtype);
	TYPE_LANG_SPECIFIC (tem) = TYPE_LANG_SPECIFIC (enumtype);
	}

	/* Finish debugging output for this type. */
	rest_of_type_compilation (enumtype, toplevel);

	return enumtype;
	}

	/* Build and install a CONST_DECL for one value of the
	current enumeration type (one that was begun with start_enum).
	Return a tree-list containing the CONST_DECL and its value.
	Assignment of sequential values by default is handled here. */

	tree
	build_enumerator (tree name, tree value)
	{
	tree decl, type;

	/* Validate and default VALUE. */

	if (value != 0)
	{
	/* Don't issue more errors for error_mark_node (i.e. an
	undeclared identifier) - just ignore the value expression. */
	if (value == error_mark_node)
	value = 0;
	else if (!INTEGRAL_TYPE_P (TREE_TYPE (value))
	\|\| TREE_CODE (value) != INTEGER_CST)
	{
	error ("enumerator value for %qE is not an integer constant", name);
	value = 0;
	}
	else
	{
	value = default_conversion (value);
	constant_expression_warning (value);
	}
	}

	/* Default based on previous value. */
	/* It should no longer be possible to have NON_LVALUE_EXPR
	in the default. */
	if (value == 0)
	{
	value = enum_next_value;
	if (enum_overflow)
	error ("overflow in enumeration values");
	}

	if (pedantic && !int_fits_type_p (value, integer_type_node))
	{
	pedwarn ("ISO C restricts enumerator values to range of %<int%>");
	/* XXX This causes -pedantic to change the meaning of the program.
	Remove? -zw 2004-03-15 */
	value = convert (integer_type_node, value);
	}

	/* Set basis for default for next value. */
	enum_next_value = build_binary_op (PLUS_EXPR, value, integer_one_node, 0);
	enum_overflow = tree_int_cst_lt (enum_next_value, value);

	/* Now create a declaration for the enum value name. */

	type = TREE_TYPE (value);
	type = c_common_type_for_size (MAX (TYPE_PRECISION (type),
	TYPE_PRECISION (integer_type_node)),
	(TYPE_PRECISION (type)
	>= TYPE_PRECISION (integer_type_node)
	&& TYPE_UNSIGNED (type)));

	decl = build_decl (CONST_DECL, name, type);
	DECL_INITIAL (decl) = convert (type, value);
	pushdecl (decl);

	return tree_cons (decl, value, NULL_TREE);
	}


	/* Create the FUNCTION_DECL for a function definition.
	DECLSPECS, DECLARATOR and ATTRIBUTES are the parts of
	the declaration; they describe the function's name and the type it returns,
	but twisted together in a fashion that parallels the syntax of C.

	This function creates a binding context for the function body
	as well as setting up the FUNCTION_DECL in current_function_decl.

	Returns 1 on success. If the DECLARATOR is not suitable for a function
	(it defines a datum instead), we return 0, which tells
	yyparse to report a parse error. */

	int
	start_function (struct c_declspecs declspecs, struct c_declarator declarator,
	tree attributes)
	{
	tree decl1, old_decl;
	tree restype, resdecl;
	struct c_label_context_se *nstack_se;
	struct c_label_context_vm *nstack_vm;

	current_function_returns_value = 0; /* Assume, until we see it does. */
	current_function_returns_null = 0;
	current_function_returns_abnormally = 0;
	warn_about_return_type = 0;
	c_switch_stack = NULL;

	nstack_se = XOBNEW (&parser_obstack, struct c_label_context_se);
	nstack_se->labels_def = NULL;
	nstack_se->labels_used = NULL;
	nstack_se->next = label_context_stack_se;
	label_context_stack_se = nstack_se;

	nstack_vm = XOBNEW (&parser_obstack, struct c_label_context_vm);
	nstack_vm->labels_def = NULL;
	nstack_vm->labels_used = NULL;
	nstack_vm->scope = 0;
	nstack_vm->next = label_context_stack_vm;
	label_context_stack_vm = nstack_vm;

	/* Indicate no valid break/continue context by setting these variables
	to some non-null, non-label value. We'll notice and emit the proper
	error message in c_finish_bc_stmt. */
	c_break_label = c_cont_label = size_zero_node;

	decl1 = grokdeclarator (declarator, declspecs, FUNCDEF, true, NULL);

	/* If the declarator is not suitable for a function definition,
	cause a syntax error. */
	if (decl1 == 0)
	{
	label_context_stack_se = label_context_stack_se->next;
	label_context_stack_vm = label_context_stack_vm->next;
	return 0;
	}

	decl_attributes (&decl1, attributes, 0);

	if (DECL_DECLARED_INLINE_P (decl1)
	&& DECL_UNINLINABLE (decl1)
	&& lookup_attribute ("noinline", DECL_ATTRIBUTES (decl1)))
	warning (OPT_Wattributes, "inline function %q+D given attribute noinline",
	decl1);

	/* Handle gnu_inline attribute. */
	if (declspecs->inline_p
	&& !flag_gnu89_inline
	&& TREE_CODE (decl1) == FUNCTION_DECL
	&& lookup_attribute ("gnu_inline", DECL_ATTRIBUTES (decl1)))
	{
	if (declspecs->storage_class != csc_static)
	DECL_EXTERNAL (decl1) = !DECL_EXTERNAL (decl1);
	}

	announce_function (decl1);

	if (!COMPLETE_OR_VOID_TYPE_P (TREE_TYPE (TREE_TYPE (decl1))))
	{
	error ("return type is an incomplete type");
	/* Make it return void instead. */
	TREE_TYPE (decl1)
	= build_function_type (void_type_node,
	TYPE_ARG_TYPES (TREE_TYPE (decl1)));
	}

	if (warn_about_return_type)
	pedwarn_c99 ("return type defaults to %<int%>");

	/* Make the init_value nonzero so pushdecl knows this is not tentative.
	error_mark_node is replaced below (in pop_scope) with the BLOCK. */
	DECL_INITIAL (decl1) = error_mark_node;

	/* If this definition isn't a prototype and we had a prototype declaration
	before, copy the arg type info from that prototype. */
	old_decl = lookup_name_in_scope (DECL_NAME (decl1), current_scope);
	if (old_decl && TREE_CODE (old_decl) != FUNCTION_DECL)
	old_decl = 0;
	current_function_prototype_locus = UNKNOWN_LOCATION;
	current_function_prototype_built_in = false;
	current_function_prototype_arg_types = NULL_TREE;
	if (TYPE_ARG_TYPES (TREE_TYPE (decl1)) == 0)
	{
	if (old_decl != 0 && TREE_CODE (TREE_TYPE (old_decl)) == FUNCTION_TYPE
	&& comptypes (TREE_TYPE (TREE_TYPE (decl1)),
	TREE_TYPE (TREE_TYPE (old_decl))))
	{
	TREE_TYPE (decl1) = composite_type (TREE_TYPE (old_decl),
	TREE_TYPE (decl1));
	current_function_prototype_locus = DECL_SOURCE_LOCATION (old_decl);
	current_function_prototype_built_in
	= C_DECL_BUILTIN_PROTOTYPE (old_decl);
	current_function_prototype_arg_types
	= TYPE_ARG_TYPES (TREE_TYPE (decl1));
	}
	if (TREE_PUBLIC (decl1))
	{
	/* If there is an external prototype declaration of this
	function, record its location but do not copy information
	to this decl. This may be an invisible declaration
	(built-in or in a scope which has finished) or simply
	have more refined argument types than any declaration
	found above. */
	struct c_binding *b;
	for (b = I_SYMBOL_BINDING (DECL_NAME (decl1)); b; b = b->shadowed)
	if (B_IN_SCOPE (b, external_scope))
	break;
	if (b)
	{
	tree ext_decl, ext_type;
	ext_decl = b->decl;
	ext_type = b->type ? b->type : TREE_TYPE (ext_decl);
	if (TREE_CODE (ext_type) == FUNCTION_TYPE
	&& comptypes (TREE_TYPE (TREE_TYPE (decl1)),
	TREE_TYPE (ext_type)))
	{
	current_function_prototype_locus
	= DECL_SOURCE_LOCATION (ext_decl);
	current_function_prototype_built_in
	= C_DECL_BUILTIN_PROTOTYPE (ext_decl);
	current_function_prototype_arg_types
	= TYPE_ARG_TYPES (ext_type);
	}
	}
	}
	}

	/* Optionally warn of old-fashioned def with no previous prototype. */
	if (warn_strict_prototypes
	&& old_decl != error_mark_node
	&& TYPE_ARG_TYPES (TREE_TYPE (decl1)) == 0
	&& C_DECL_ISNT_PROTOTYPE (old_decl))
	warning (OPT_Wstrict_prototypes,
	"function declaration isn%'t a prototype");
	/* Optionally warn of any global def with no previous prototype. */
	else if (warn_missing_prototypes
	&& old_decl != error_mark_node
	&& TREE_PUBLIC (decl1)
	&& !MAIN_NAME_P (DECL_NAME (decl1))
	&& C_DECL_ISNT_PROTOTYPE (old_decl))
	warning (OPT_Wmissing_prototypes, "no previous prototype for %q+D", decl1);
	/* Optionally warn of any def with no previous prototype
	if the function has already been used. */
	else if (warn_missing_prototypes
	&& old_decl != 0
	&& old_decl != error_mark_node
	&& TREE_USED (old_decl)
	&& TYPE_ARG_TYPES (TREE_TYPE (old_decl)) == 0)
	warning (OPT_Wmissing_prototypes,
	"%q+D was used with no prototype before its definition", decl1);
	/* Optionally warn of any global def with no previous declaration. */
	else if (warn_missing_declarations
	&& TREE_PUBLIC (decl1)
	&& old_decl == 0
	&& !MAIN_NAME_P (DECL_NAME (decl1)))
	warning (OPT_Wmissing_declarations, "no previous declaration for %q+D",
	decl1);
	/* Optionally warn of any def with no previous declaration
	if the function has already been used. */
	else if (warn_missing_declarations
	&& old_decl != 0
	&& old_decl != error_mark_node
	&& TREE_USED (old_decl)
	&& C_DECL_IMPLICIT (old_decl))
	warning (OPT_Wmissing_declarations,
	"%q+D was used with no declaration before its definition", decl1);

	/* This function exists in static storage.
	(This does not mean `static' in the C sense!) */
	TREE_STATIC (decl1) = 1;

	/* A nested function is not global. */
	if (current_function_decl != 0)
	TREE_PUBLIC (decl1) = 0;

	/* This is the earliest point at which we might know the assembler
	name of the function. Thus, if it's set before this, die horribly. */
	gcc_assert (!DECL_ASSEMBLER_NAME_SET_P (decl1));

	/* If #pragma weak was used, mark the decl weak now. */
	if (current_scope == file_scope)
	maybe_apply_pragma_weak (decl1);

	/* Warn for unlikely, improbable, or stupid declarations of `main'. */
	if (warn_main > 0 && MAIN_NAME_P (DECL_NAME (decl1)))
	{
	tree args;
	int argct = 0;

	if (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (decl1)))
	!= integer_type_node)
	pedwarn ("return type of %q+D is not %<int%>", decl1);

	for (args = TYPE_ARG_TYPES (TREE_TYPE (decl1)); args;
	args = TREE_CHAIN (args))
	{
	tree type = args ? TREE_VALUE (args) : 0;

	if (type == void_type_node)
	break;

	++argct;
	switch (argct)
	{
	case 1:
	if (TYPE_MAIN_VARIANT (type) != integer_type_node)
	pedwarn ("first argument of %q+D should be %<int%>", decl1);
	break;

	case 2:
	if (TREE_CODE (type) != POINTER_TYPE
	\|\| TREE_CODE (TREE_TYPE (type)) != POINTER_TYPE
	\|\| (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (type)))
	!= char_type_node))
	pedwarn ("second argument of %q+D should be %<char **%>",
	decl1);
	break;

	case 3:
	if (TREE_CODE (type) != POINTER_TYPE
	\|\| TREE_CODE (TREE_TYPE (type)) != POINTER_TYPE
	\|\| (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (type)))
	!= char_type_node))
	pedwarn ("third argument of %q+D should probably be "
	"%<char **%>", decl1);
	break;
	}
	}

	/* It is intentional that this message does not mention the third
	argument because it's only mentioned in an appendix of the
	standard. */
	if (argct > 0 && (argct < 2 \|\| argct > 3))
	pedwarn ("%q+D takes only zero or two arguments", decl1);

	if (!TREE_PUBLIC (decl1))
	pedwarn ("%q+D is normally a non-static function", decl1);
	}

	/* Record the decl so that the function name is defined.
	If we already have a decl for this name, and it is a FUNCTION_DECL,
	use the old decl. */

	current_function_decl = pushdecl (decl1);

	push_scope ();
	declare_parm_level ();

	restype = TREE_TYPE (TREE_TYPE (current_function_decl));
	/* Promote the value to int before returning it. */
	if (c_promoting_integer_type_p (restype))
	{
	/* It retains unsignedness if not really getting wider. */
	if (TYPE_UNSIGNED (restype)
	&& (TYPE_PRECISION (restype)
	== TYPE_PRECISION (integer_type_node)))
	restype = unsigned_type_node;
	else
	restype = integer_type_node;
	}

	resdecl = build_decl (RESULT_DECL, NULL_TREE, restype);
	DECL_ARTIFICIAL (resdecl) = 1;
	DECL_IGNORED_P (resdecl) = 1;
	DECL_RESULT (current_function_decl) = resdecl;

	start_fname_decls ();

	return 1;
	}

	/* Subroutine of store_parm_decls which handles new-style function
	definitions (prototype format). The parms already have decls, so we
	need only record them as in effect and complain if any redundant
	old-style parm decls were written. */
	static void
	store_parm_decls_newstyle (tree fndecl, const struct c_arg_info *arg_info)
	{
	tree decl;

	if (current_scope->bindings)
	{
	error ("%Jold-style parameter declarations in prototyped "
	"function definition", fndecl);

	/* Get rid of the old-style declarations. */
	pop_scope ();
	push_scope ();
	}
	/* Don't issue this warning for nested functions, and don't issue this
	warning if we got here because ARG_INFO_TYPES was error_mark_node
	(this happens when a function definition has just an ellipsis in
	its parameter list). */
	else if (!in_system_header && !current_function_scope
	&& arg_info->types != error_mark_node)
	warning (OPT_Wtraditional,
	"%Jtraditional C rejects ISO C style function definitions",
	fndecl);

	/* Now make all the parameter declarations visible in the function body.
	We can bypass most of the grunt work of pushdecl. */
	for (decl = arg_info->parms; decl; decl = TREE_CHAIN (decl))
	{
	DECL_CONTEXT (decl) = current_function_decl;
	if (DECL_NAME (decl))
	{
	bind (DECL_NAME (decl), decl, current_scope,
	/invisible=/false, /nested=/false);
	if (!TREE_USED (decl))
	warn_if_shadowing (decl);
	}
	else
	error ("%Jparameter name omitted", decl);
	}

	/* Record the parameter list in the function declaration. */
	DECL_ARGUMENTS (fndecl) = arg_info->parms;

	/* Now make all the ancillary declarations visible, likewise. */
	for (decl = arg_info->others; decl; decl = TREE_CHAIN (decl))
	{
	DECL_CONTEXT (decl) = current_function_decl;
	if (DECL_NAME (decl))
	bind (DECL_NAME (decl), decl, current_scope,
	/invisible=/false, /nested=/false);
	}

	/* And all the tag declarations. */
	for (decl = arg_info->tags; decl; decl = TREE_CHAIN (decl))
	if (TREE_PURPOSE (decl))
	bind (TREE_PURPOSE (decl), TREE_VALUE (decl), current_scope,
	/invisible=/false, /nested=/false);
	}

	/* Subroutine of store_parm_decls which handles old-style function
	definitions (separate parameter list and declarations). */

	static void
	store_parm_decls_oldstyle (tree fndecl, const struct c_arg_info *arg_info)
	{
	struct c_binding *b;
	tree parm, decl, last;
	tree parmids = arg_info->parms;
	struct pointer_set_t *seen_args = pointer_set_create ();

	if (!in_system_header)
	warning (OPT_Wold_style_definition, "%Jold-style function definition",
	fndecl);

	/* Match each formal parameter name with its declaration. Save each
	decl in the appropriate TREE_PURPOSE slot of the parmids chain. */
	for (parm = parmids; parm; parm = TREE_CHAIN (parm))
	{
	if (TREE_VALUE (parm) == 0)
	{
	error ("%Jparameter name missing from parameter list", fndecl);
	TREE_PURPOSE (parm) = 0;
	continue;
	}

	b = I_SYMBOL_BINDING (TREE_VALUE (parm));
	if (b && B_IN_CURRENT_SCOPE (b))
	{
	decl = b->decl;
	/* If we got something other than a PARM_DECL it is an error. */
	if (TREE_CODE (decl) != PARM_DECL)
	error ("%q+D declared as a non-parameter", decl);
	/* If the declaration is already marked, we have a duplicate
	name. Complain and ignore the duplicate. */
	else if (pointer_set_contains (seen_args, decl))
	{
	error ("multiple parameters named %q+D", decl);
	TREE_PURPOSE (parm) = 0;
	continue;
	}
	/* If the declaration says "void", complain and turn it into
	an int. */
	else if (VOID_TYPE_P (TREE_TYPE (decl)))
	{
	error ("parameter %q+D declared with void type", decl);
	TREE_TYPE (decl) = integer_type_node;
	DECL_ARG_TYPE (decl) = integer_type_node;
	layout_decl (decl, 0);
	}
	warn_if_shadowing (decl);
	}
	/* If no declaration found, default to int. */
	else
	{
	decl = build_decl (PARM_DECL, TREE_VALUE (parm), integer_type_node);
	DECL_ARG_TYPE (decl) = TREE_TYPE (decl);
	DECL_SOURCE_LOCATION (decl) = DECL_SOURCE_LOCATION (fndecl);
	pushdecl (decl);
	warn_if_shadowing (decl);

	if (flag_isoc99)
	pedwarn ("type of %q+D defaults to %<int%>", decl);
	else if (extra_warnings)
	warning (OPT_Wextra, "type of %q+D defaults to %<int%>", decl);
	}

	TREE_PURPOSE (parm) = decl;
	pointer_set_insert (seen_args, decl);
	}

	/* Now examine the parms chain for incomplete declarations
	and declarations with no corresponding names. */

	for (b = current_scope->bindings; b; b = b->prev)
	{
	parm = b->decl;
	if (TREE_CODE (parm) != PARM_DECL)
	continue;

	if (TREE_TYPE (parm) != error_mark_node
	&& !COMPLETE_TYPE_P (TREE_TYPE (parm)))
	{
	error ("parameter %q+D has incomplete type", parm);
	TREE_TYPE (parm) = error_mark_node;
	}

	if (!pointer_set_contains (seen_args, parm))
	{
	error ("declaration for parameter %q+D but no such parameter", parm);

	/* Pretend the parameter was not missing.
	This gets us to a standard state and minimizes
	further error messages. */
	parmids = chainon (parmids, tree_cons (parm, 0, 0));
	}
	}

	/* Chain the declarations together in the order of the list of
	names. Store that chain in the function decl, replacing the
	list of names. Update the current scope to match. */
	DECL_ARGUMENTS (fndecl) = 0;

	for (parm = parmids; parm; parm = TREE_CHAIN (parm))
	if (TREE_PURPOSE (parm))
	break;
	if (parm && TREE_PURPOSE (parm))
	{
	last = TREE_PURPOSE (parm);
	DECL_ARGUMENTS (fndecl) = last;

	for (parm = TREE_CHAIN (parm); parm; parm = TREE_CHAIN (parm))
	if (TREE_PURPOSE (parm))
	{
	TREE_CHAIN (last) = TREE_PURPOSE (parm);
	last = TREE_PURPOSE (parm);
	}
	TREE_CHAIN (last) = 0;
	}

	pointer_set_destroy (seen_args);

	/* If there was a previous prototype,
	set the DECL_ARG_TYPE of each argument according to
	the type previously specified, and report any mismatches. */

	if (current_function_prototype_arg_types)
	{
	tree type;
	for (parm = DECL_ARGUMENTS (fndecl),
	type = current_function_prototype_arg_types;
	parm \|\| (type && (TYPE_MAIN_VARIANT (TREE_VALUE (type))
	!= void_type_node));
	parm = TREE_CHAIN (parm), type = TREE_CHAIN (type))
	{
	if (parm == 0 \|\| type == 0
	\|\| TYPE_MAIN_VARIANT (TREE_VALUE (type)) == void_type_node)
	{
	if (current_function_prototype_built_in)
	warning (0, "number of arguments doesn%'t match "
	"built-in prototype");
	else
	{
	error ("number of arguments doesn%'t match prototype");
	error ("%Hprototype declaration",
	&current_function_prototype_locus);
	}
	break;
	}
	/* Type for passing arg must be consistent with that
	declared for the arg. ISO C says we take the unqualified
	type for parameters declared with qualified type. */
	if (!comptypes (TYPE_MAIN_VARIANT (DECL_ARG_TYPE (parm)),
	TYPE_MAIN_VARIANT (TREE_VALUE (type))))
	{
	if (TYPE_MAIN_VARIANT (TREE_TYPE (parm))
	== TYPE_MAIN_VARIANT (TREE_VALUE (type)))
	{
	/* Adjust argument to match prototype. E.g. a previous
	`int foo(float);' prototype causes
	`int foo(x) float x; {...}' to be treated like
	`int foo(float x) {...}'. This is particularly
	useful for argument types like uid_t. */
	DECL_ARG_TYPE (parm) = TREE_TYPE (parm);

	if (targetm.calls.promote_prototypes (TREE_TYPE (current_function_decl))
	&& INTEGRAL_TYPE_P (TREE_TYPE (parm))
	&& TYPE_PRECISION (TREE_TYPE (parm))
	< TYPE_PRECISION (integer_type_node))
	DECL_ARG_TYPE (parm) = integer_type_node;

	if (pedantic)
	{
	/* ??? Is it possible to get here with a
	built-in prototype or will it always have
	been diagnosed as conflicting with an
	old-style definition and discarded? */
	if (current_function_prototype_built_in)
	warning (0, "promoted argument %qD "
	"doesn%'t match built-in prototype", parm);
	else
	{
	pedwarn ("promoted argument %qD "
	"doesn%'t match prototype", parm);
	pedwarn ("%Hprototype declaration",
	&current_function_prototype_locus);
	}
	}
	}
	else
	{
	if (current_function_prototype_built_in)
	warning (0, "argument %qD doesn%'t match "
	"built-in prototype", parm);
	else
	{
	error ("argument %qD doesn%'t match prototype", parm);
	error ("%Hprototype declaration",
	&current_function_prototype_locus);
	}
	}
	}
	}
	TYPE_ACTUAL_ARG_TYPES (TREE_TYPE (fndecl)) = 0;
	}

	/* Otherwise, create a prototype that would match. */

	else
	{
	tree actual = 0, last = 0, type;

	for (parm = DECL_ARGUMENTS (fndecl); parm; parm = TREE_CHAIN (parm))
	{
	type = tree_cons (NULL_TREE, DECL_ARG_TYPE (parm), NULL_TREE);
	if (last)
	TREE_CHAIN (last) = type;
	else
	actual = type;
	last = type;
	}
	type = tree_cons (NULL_TREE, void_type_node, NULL_TREE);
	if (last)
	TREE_CHAIN (last) = type;
	else
	actual = type;

	/* We are going to assign a new value for the TYPE_ACTUAL_ARG_TYPES
	of the type of this function, but we need to avoid having this
	affect the types of other similarly-typed functions, so we must
	first force the generation of an identical (but separate) type
	node for the relevant function type. The new node we create
	will be a variant of the main variant of the original function
	type. */

	TREE_TYPE (fndecl) = build_variant_type_copy (TREE_TYPE (fndecl));

	TYPE_ACTUAL_ARG_TYPES (TREE_TYPE (fndecl)) = actual;
	}
	}

	/* Store parameter declarations passed in ARG_INFO into the current
	function declaration. */

	void
	store_parm_decls_from (struct c_arg_info *arg_info)
	{
	current_function_arg_info = arg_info;
	store_parm_decls ();
	}

	/* Store the parameter declarations into the current function declaration.
	This is called after parsing the parameter declarations, before
	digesting the body of the function.

	For an old-style definition, construct a prototype out of the old-style
	parameter declarations and inject it into the function's type. */

	void
	store_parm_decls (void)
	{
	tree fndecl = current_function_decl;
	bool proto;

	/* The argument information block for FNDECL. */
	struct c_arg_info *arg_info = current_function_arg_info;
	current_function_arg_info = 0;

	/* True if this definition is written with a prototype. Note:
	despite C99 6.7.5.3p14, we can not treat an empty argument
	list in a function definition as equivalent to (void) -- an
	empty argument list specifies the function has no parameters,
	but only (void) sets up a prototype for future calls. */
	proto = arg_info->types != 0;

	if (proto)
	store_parm_decls_newstyle (fndecl, arg_info);
	else
	store_parm_decls_oldstyle (fndecl, arg_info);

	/* The next call to push_scope will be a function body. */

	next_is_function_body = true;

	/* Write a record describing this function definition to the prototypes
	file (if requested). */

	gen_aux_info_record (fndecl, 1, 0, proto);

	/* Initialize the RTL code for the function. */
	allocate_struct_function (fndecl);

	/* Begin the statement tree for this function. */
	DECL_SAVED_TREE (fndecl) = push_stmt_list ();

	/* ??? Insert the contents of the pending sizes list into the function
	to be evaluated. The only reason left to have this is
	void foo(int n, int array[n++])
	because we throw away the array type in favor of a pointer type, and
	thus won't naturally see the SAVE_EXPR containing the increment. All
	other pending sizes would be handled by gimplify_parameters. */
	{
	tree t;
	for (t = nreverse (get_pending_sizes ()); t ; t = TREE_CHAIN (t))
	add_stmt (TREE_VALUE (t));
	}

	/* Even though we're inside a function body, we still don't want to
	call expand_expr to calculate the size of a variable-sized array.
	We haven't necessarily assigned RTL to all variables yet, so it's
	not safe to try to expand expressions involving them. */
	cfun->x_dont_save_pending_sizes_p = 1;
	}

	/* Emit diagnostics that require gimple input for detection. Operate on
	FNDECL and all its nested functions. */

	static void
	c_gimple_diagnostics_recursively (tree fndecl)
	{
	struct cgraph_node *cgn;

	/* Handle attribute((warn_unused_result)). Relies on gimple input. */
	c_warn_unused_result (&DECL_SAVED_TREE (fndecl));

	/* Notice when OpenMP structured block constraints are violated. */
	if (flag_openmp)
	diagnose_omp_structured_block_errors (fndecl);

	/* Finalize all nested functions now. */
	cgn = cgraph_node (fndecl);
	for (cgn = cgn->nested; cgn ; cgn = cgn->next_nested)
	c_gimple_diagnostics_recursively (cgn->decl);
	}

	/* Finish up a function declaration and compile that function
	all the way to assembler language output. The free the storage
	for the function definition.

	This is called after parsing the body of the function definition. */

	void
	finish_function (void)
	{
	tree fndecl = current_function_decl;

	label_context_stack_se = label_context_stack_se->next;
	label_context_stack_vm = label_context_stack_vm->next;

	if (TREE_CODE (fndecl) == FUNCTION_DECL
	&& targetm.calls.promote_prototypes (TREE_TYPE (fndecl)))
	{
	tree args = DECL_ARGUMENTS (fndecl);
	for (; args; args = TREE_CHAIN (args))
	{
	tree type = TREE_TYPE (args);
	if (INTEGRAL_TYPE_P (type)
	&& TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node))
	DECL_ARG_TYPE (args) = integer_type_node;
	}
	}

	if (DECL_INITIAL (fndecl) && DECL_INITIAL (fndecl) != error_mark_node)
	BLOCK_SUPERCONTEXT (DECL_INITIAL (fndecl)) = fndecl;

	/* Must mark the RESULT_DECL as being in this function. */

	if (DECL_RESULT (fndecl) && DECL_RESULT (fndecl) != error_mark_node)
	DECL_CONTEXT (DECL_RESULT (fndecl)) = fndecl;

	if (MAIN_NAME_P (DECL_NAME (fndecl)) && flag_hosted)
	{
	if (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (fndecl)))
	!= integer_type_node)
	{
	/* If warn_main is 1 (-Wmain) or 2 (-Wall), we have already warned.
	If warn_main is -1 (-Wno-main) we don't want to be warned. */
	if (!warn_main)
	pedwarn ("return type of %q+D is not %<int%>", fndecl);
	}
	else
	{
	if (flag_isoc99)
	{
	tree stmt = c_finish_return (integer_zero_node);
	#ifdef USE_MAPPED_LOCATION
	/* Hack. We don't want the middle-end to warn that this return
	is unreachable, so we mark its location as special. Using
	UNKNOWN_LOCATION has the problem that it gets clobbered in
	annotate_one_with_locus. A cleaner solution might be to
	ensure ! should_carry_locus_p (stmt), but that needs a flag.
	*/
	SET_EXPR_LOCATION (stmt, BUILTINS_LOCATION);
	#else
	/* Hack. We don't want the middle-end to warn that this
	return is unreachable, so put the statement on the
	special line 0. */
	annotate_with_file_line (stmt, input_filename, 0);
	#endif
	}
	}
	}

	/* Tie off the statement tree for this function. */
	DECL_SAVED_TREE (fndecl) = pop_stmt_list (DECL_SAVED_TREE (fndecl));

	finish_fname_decls ();

	/* Complain if there's just no return statement. */
	if (warn_return_type
	&& TREE_CODE (TREE_TYPE (TREE_TYPE (fndecl))) != VOID_TYPE
	&& !current_function_returns_value && !current_function_returns_null
	/* Don't complain if we are no-return. */
	&& !current_function_returns_abnormally
	/* Don't warn for main(). */
	&& !MAIN_NAME_P (DECL_NAME (fndecl))
	/* Or if they didn't actually specify a return type. */
	&& !C_FUNCTION_IMPLICIT_INT (fndecl)
	/* Normally, with -Wreturn-type, flow will complain. Unless we're an
	inline function, as we might never be compiled separately. */
	&& DECL_INLINE (fndecl))
	{
	warning (OPT_Wreturn_type,
	"no return statement in function returning non-void");
	TREE_NO_WARNING (fndecl) = 1;
	}

	/* With just -Wextra, complain only if function returns both with
	and without a value. */
	if (extra_warnings
	&& current_function_returns_value
	&& current_function_returns_null)
	warning (OPT_Wextra, "this function may return with or without a value");

	/* Store the end of the function, so that we get good line number
	info for the epilogue. */
	cfun->function_end_locus = input_location;

	/* If we don't have ctors/dtors sections, and this is a static
	constructor or destructor, it must be recorded now. */
	if (DECL_STATIC_CONSTRUCTOR (fndecl)
	&& !targetm.have_ctors_dtors)
	static_ctors = tree_cons (NULL_TREE, fndecl, static_ctors);
	if (DECL_STATIC_DESTRUCTOR (fndecl)
	&& !targetm.have_ctors_dtors)
	static_dtors = tree_cons (NULL_TREE, fndecl, static_dtors);

	/* Finalize the ELF visibility for the function. */
	c_determine_visibility (fndecl);

	/* Genericize before inlining. Delay genericizing nested functions
	until their parent function is genericized. Since finalizing
	requires GENERIC, delay that as well. */

	if (DECL_INITIAL (fndecl) && DECL_INITIAL (fndecl) != error_mark_node
	&& !undef_nested_function)
	{
	if (!decl_function_context (fndecl))
	{
	c_genericize (fndecl);
	c_gimple_diagnostics_recursively (fndecl);

	/* ??? Objc emits functions after finalizing the compilation unit.
	This should be cleaned up later and this conditional removed. */
	if (cgraph_global_info_ready)
	{
	c_expand_body (fndecl);
	return;
	}

	cgraph_finalize_function (fndecl, false);
	}
	else
	{
	/* Register this function with cgraph just far enough to get it
	added to our parent's nested function list. Handy, since the
	C front end doesn't have such a list. */
	(void) cgraph_node (fndecl);
	}
	}

	if (!decl_function_context (fndecl))
	undef_nested_function = false;

	/* We're leaving the context of this function, so zap cfun.
	It's still in DECL_STRUCT_FUNCTION, and we'll restore it in
	tree_rest_of_compilation. */
	cfun = NULL;
	current_function_decl = NULL;
	}

	/* Generate the RTL for the body of FNDECL. */

	void
	c_expand_body (tree fndecl)
	{

	if (!DECL_INITIAL (fndecl)
	\|\| DECL_INITIAL (fndecl) == error_mark_node)
	return;

	tree_rest_of_compilation (fndecl);

	if (DECL_STATIC_CONSTRUCTOR (fndecl)
	&& targetm.have_ctors_dtors)
	targetm.asm_out.constructor (XEXP (DECL_RTL (fndecl), 0),
	DEFAULT_INIT_PRIORITY);
	if (DECL_STATIC_DESTRUCTOR (fndecl)
	&& targetm.have_ctors_dtors)
	targetm.asm_out.destructor (XEXP (DECL_RTL (fndecl), 0),
	DEFAULT_INIT_PRIORITY);
	}

	/* Check the declarations given in a for-loop for satisfying the C99
	constraints. If exactly one such decl is found, return it. */

	tree
	check_for_loop_decls (void)
	{
	struct c_binding *b;
	tree one_decl = NULL_TREE;
	int n_decls = 0;


	if (!flag_isoc99)
	{
	/* If we get here, declarations have been used in a for loop without
	the C99 for loop scope. This doesn't make much sense, so don't
	allow it. */
	error ("%<for%> loop initial declaration used outside C99 mode");
	return NULL_TREE;
	}
	/* C99 subclause 6.8.5 paragraph 3:

	[#3] The declaration part of a for statement shall only
	declare identifiers for objects having storage class auto or
	register.

	It isn't clear whether, in this sentence, "identifiers" binds to
	"shall only declare" or to "objects" - that is, whether all identifiers
	declared must be identifiers for objects, or whether the restriction
	only applies to those that are. (A question on this in comp.std.c
	in November 2000 received no answer.) We implement the strictest
	interpretation, to avoid creating an extension which later causes
	problems. */

	for (b = current_scope->bindings; b; b = b->prev)
	{
	tree id = b->id;
	tree decl = b->decl;

	if (!id)
	continue;

	switch (TREE_CODE (decl))
	{
	case VAR_DECL:
	if (TREE_STATIC (decl))
	error ("declaration of static variable %q+D in %<for%> loop "
	"initial declaration", decl);
	else if (DECL_EXTERNAL (decl))
	error ("declaration of %<extern%> variable %q+D in %<for%> loop "
	"initial declaration", decl);
	break;

	case RECORD_TYPE:
	error ("%<struct %E%> declared in %<for%> loop initial declaration",
	id);
	break;
	case UNION_TYPE:
	error ("%<union %E%> declared in %<for%> loop initial declaration",
	id);
	break;
	case ENUMERAL_TYPE:
	error ("%<enum %E%> declared in %<for%> loop initial declaration",
	id);
	break;
	default:
	error ("declaration of non-variable %q+D in %<for%> loop "
	"initial declaration", decl);
	}

	n_decls++;
	one_decl = decl;
	}

	return n_decls == 1 ? one_decl : NULL_TREE;
	}

	/* Save and reinitialize the variables
	used during compilation of a C function. */

	void
	c_push_function_context (struct function *f)
	{
	struct language_function *p;
	p = GGC_NEW (struct language_function);
	f->language = p;

	p->base.x_stmt_tree = c_stmt_tree;
	p->x_break_label = c_break_label;
	p->x_cont_label = c_cont_label;
	p->x_switch_stack = c_switch_stack;
	p->arg_info = current_function_arg_info;
	p->returns_value = current_function_returns_value;
	p->returns_null = current_function_returns_null;
	p->returns_abnormally = current_function_returns_abnormally;
	p->warn_about_return_type = warn_about_return_type;
	}

	/* Restore the variables used during compilation of a C function. */

	void
	c_pop_function_context (struct function *f)
	{
	struct language_function *p = f->language;

	if (DECL_STRUCT_FUNCTION (current_function_decl) == 0
	&& DECL_SAVED_TREE (current_function_decl) == NULL_TREE)
	{
	/* Stop pointing to the local nodes about to be freed. */
	/* But DECL_INITIAL must remain nonzero so we know this
	was an actual function definition. */
	DECL_INITIAL (current_function_decl) = error_mark_node;
	DECL_ARGUMENTS (current_function_decl) = 0;
	}

	c_stmt_tree = p->base.x_stmt_tree;
	c_break_label = p->x_break_label;
	c_cont_label = p->x_cont_label;
	c_switch_stack = p->x_switch_stack;
	current_function_arg_info = p->arg_info;
	current_function_returns_value = p->returns_value;
	current_function_returns_null = p->returns_null;
	current_function_returns_abnormally = p->returns_abnormally;
	warn_about_return_type = p->warn_about_return_type;

	f->language = NULL;
	}

	/* Copy the DECL_LANG_SPECIFIC data associated with DECL. */

	void
	c_dup_lang_specific_decl (tree decl)
	{
	struct lang_decl *ld;

	if (!DECL_LANG_SPECIFIC (decl))
	return;

	ld = GGC_NEW (struct lang_decl);
	memcpy (ld, DECL_LANG_SPECIFIC (decl), sizeof (struct lang_decl));
	DECL_LANG_SPECIFIC (decl) = ld;
	}

	/* The functions below are required for functionality of doing
	function at once processing in the C front end. Currently these
	functions are not called from anywhere in the C front end, but as
	these changes continue, that will change. */

	/* Returns the stmt_tree (if any) to which statements are currently
	being added. If there is no active statement-tree, NULL is
	returned. */

	stmt_tree
	current_stmt_tree (void)
	{
	return &c_stmt_tree;
	}

	/* Nonzero if TYPE is an anonymous union or struct type. Always 0 in
	C. */

	int
	anon_aggr_type_p (tree ARG_UNUSED (node))
	{
	return 0;
	}

	/* Return the global value of T as a symbol. */

	tree
	identifier_global_value (tree t)
	{
	struct c_binding *b;

	for (b = I_SYMBOL_BINDING (t); b; b = b->shadowed)
	if (B_IN_FILE_SCOPE (b) \|\| B_IN_EXTERNAL_SCOPE (b))
	return b->decl;

	return 0;
	}

	/* Record a builtin type for C. If NAME is non-NULL, it is the name used;
	otherwise the name is found in ridpointers from RID_INDEX. */

	void
	record_builtin_type (enum rid rid_index, const char *name, tree type)
	{
	tree id, decl;
	if (name == 0)
	id = ridpointers[(int) rid_index];
	else
	id = get_identifier (name);
	decl = build_decl (TYPE_DECL, id, type);
	pushdecl (decl);
	if (debug_hooks->type_decl)
	debug_hooks->type_decl (decl, false);
	}

	/* Build the void_list_node (void_type_node having been created). */
	tree
	build_void_list_node (void)
	{
	tree t = build_tree_list (NULL_TREE, void_type_node);
	return t;
	}

	/* Return a c_parm structure with the given SPECS, ATTRS and DECLARATOR. */

	struct c_parm *
	build_c_parm (struct c_declspecs *specs, tree attrs,
	struct c_declarator *declarator)
	{
	struct c_parm *ret = XOBNEW (&parser_obstack, struct c_parm);
	ret->specs = specs;
	ret->attrs = attrs;
	ret->declarator = declarator;
	return ret;
	}

	/* Return a declarator with nested attributes. TARGET is the inner
	declarator to which these attributes apply. ATTRS are the
	attributes. */

	struct c_declarator *
	build_attrs_declarator (tree attrs, struct c_declarator *target)
	{
	struct c_declarator *ret = XOBNEW (&parser_obstack, struct c_declarator);
	ret->kind = cdk_attrs;
	ret->declarator = target;
	ret->u.attrs = attrs;
	return ret;
	}

	/* Return a declarator for a function with arguments specified by ARGS
	and return type specified by TARGET. */

	struct c_declarator *
	build_function_declarator (struct c_arg_info *args,
	struct c_declarator *target)
	{
	struct c_declarator *ret = XOBNEW (&parser_obstack, struct c_declarator);
	ret->kind = cdk_function;
	ret->declarator = target;
	ret->u.arg_info = args;
	return ret;
	}

	/* Return a declarator for the identifier IDENT (which may be
	NULL_TREE for an abstract declarator). */

	struct c_declarator *
	build_id_declarator (tree ident)
	{
	struct c_declarator *ret = XOBNEW (&parser_obstack, struct c_declarator);
	ret->kind = cdk_id;
	ret->declarator = 0;
	ret->u.id = ident;
	/* Default value - may get reset to a more precise location. */
	ret->id_loc = input_location;
	return ret;
	}

	/* Return something to represent absolute declarators containing a *.
	TARGET is the absolute declarator that the * contains.
	TYPE_QUALS_ATTRS is a structure for type qualifiers and attributes
	to apply to the pointer type. */

	struct c_declarator *
	make_pointer_declarator (struct c_declspecs *type_quals_attrs,
	struct c_declarator *target)
	{
	tree attrs;
	int quals = 0;
	struct c_declarator *itarget = target;
	struct c_declarator *ret = XOBNEW (&parser_obstack, struct c_declarator);
	if (type_quals_attrs)
	{
	attrs = type_quals_attrs->attrs;
	quals = quals_from_declspecs (type_quals_attrs);
	if (attrs != NULL_TREE)
	itarget = build_attrs_declarator (attrs, target);
	}
	ret->kind = cdk_pointer;
	ret->declarator = itarget;
	ret->u.pointer_quals = quals;
	return ret;
	}

	/* Return a pointer to a structure for an empty list of declaration
	specifiers. */

	struct c_declspecs *
	build_null_declspecs (void)
	{
	struct c_declspecs *ret = XOBNEW (&parser_obstack, struct c_declspecs);
	ret->type = 0;
	ret->decl_attr = 0;
	ret->attrs = 0;
	ret->typespec_word = cts_none;
	ret->storage_class = csc_none;
	ret->declspecs_seen_p = false;
	ret->type_seen_p = false;
	ret->non_sc_seen_p = false;
	ret->typedef_p = false;
	ret->tag_defined_p = false;
	ret->explicit_signed_p = false;
	ret->deprecated_p = false;
	+ /* APPLE LOCAL "unavailable" attribute (radar 2809697) */
	+ ret->unavailable_p = false;
	ret->default_int_p = false;
	ret->long_p = false;
	ret->long_long_p = false;
	ret->short_p = false;
	ret->signed_p = false;
	ret->unsigned_p = false;
	ret->complex_p = false;
	ret->inline_p = false;
	ret->thread_p = false;
	ret->const_p = false;
	ret->volatile_p = false;
	ret->restrict_p = false;
	return ret;
	}

	/* Add the type qualifier QUAL to the declaration specifiers SPECS,
	returning SPECS. */

	struct c_declspecs *
	declspecs_add_qual (struct c_declspecs *specs, tree qual)
	{
	enum rid i;
	bool dupe = false;
	specs->non_sc_seen_p = true;
	specs->declspecs_seen_p = true;
	gcc_assert (TREE_CODE (qual) == IDENTIFIER_NODE
	&& C_IS_RESERVED_WORD (qual));
	i = C_RID_CODE (qual);
	switch (i)
	{
	case RID_CONST:
	dupe = specs->const_p;
	specs->const_p = true;
	break;
	case RID_VOLATILE:
	dupe = specs->volatile_p;
	specs->volatile_p = true;
	break;
	case RID_RESTRICT:
	dupe = specs->restrict_p;
	specs->restrict_p = true;
	break;
	default:
	gcc_unreachable ();
	}
	if (dupe && pedantic && !flag_isoc99)
	pedwarn ("duplicate %qE", qual);
	return specs;
	}

	/* Add the type specifier TYPE to the declaration specifiers SPECS,
	returning SPECS. */

	struct c_declspecs *
	declspecs_add_type (struct c_declspecs *specs, struct c_typespec spec)
	{
	tree type = spec.spec;
	specs->non_sc_seen_p = true;
	specs->declspecs_seen_p = true;
	specs->type_seen_p = true;
	if (TREE_DEPRECATED (type))
	specs->deprecated_p = true;

	+ /* APPLE LOCAL begin "unavailable" attribute (radar 2809697) */
	+ if (TREE_UNAVAILABLE (type))
	+ specs->unavailable_p = true;
	+ /* APPLE LOCAL end "unavailable" attribute (radar 2809697) */
	+
	/* Handle type specifier keywords. */
	if (TREE_CODE (type) == IDENTIFIER_NODE && C_IS_RESERVED_WORD (type))
	{
	enum rid i = C_RID_CODE (type);
	if (specs->type)
	{
	error ("two or more data types in declaration specifiers");
	return specs;
	}
	if ((int) i <= (int) RID_LAST_MODIFIER)
	{
	/* "long", "short", "signed", "unsigned" or "_Complex". */
	bool dupe = false;
	switch (i)
	{
	case RID_LONG:
	if (specs->long_long_p)
	{
	error ("%<long long long%> is too long for GCC");
	break;
	}
	if (specs->long_p)
	{
	if (specs->typespec_word == cts_double)
	{
	error ("both %<long long%> and %<double%> in "
	"declaration specifiers");
	break;
	}
	if (pedantic && !flag_isoc99 && !in_system_header
	&& warn_long_long)
	pedwarn ("ISO C90 does not support %<long long%>");
	specs->long_long_p = 1;
	break;
	}
	if (specs->short_p)
	error ("both %<long%> and %<short%> in "
	"declaration specifiers");
	else if (specs->typespec_word == cts_void)
	error ("both %<long%> and %<void%> in "
	"declaration specifiers");
	else if (specs->typespec_word == cts_bool)
	error ("both %<long%> and %<_Bool%> in "
	"declaration specifiers");
	else if (specs->typespec_word == cts_char)
	error ("both %<long%> and %<char%> in "
	"declaration specifiers");
	else if (specs->typespec_word == cts_float)
	error ("both %<long%> and %<float%> in "
	"declaration specifiers");
	else if (specs->typespec_word == cts_dfloat32)
	error ("both %<long%> and %<_Decimal32%> in "
	"declaration specifiers");
	else if (specs->typespec_word == cts_dfloat64)
	error ("both %<long%> and %<_Decimal64%> in "
	"declaration specifiers");
	else if (specs->typespec_word == cts_dfloat128)
	error ("both %<long%> and %<_Decimal128%> in "
	"declaration specifiers");
	else
	specs->long_p = true;
	break;
	case RID_SHORT:
	dupe = specs->short_p;
	if (specs->long_p)
	error ("both %<long%> and %<short%> in "
	"declaration specifiers");
	else if (specs->typespec_word == cts_void)
	error ("both %<short%> and %<void%> in "
	"declaration specifiers");
	else if (specs->typespec_word == cts_bool)
	error ("both %<short%> and %<_Bool%> in "
	"declaration specifiers");
	else if (specs->typespec_word == cts_char)
	error ("both %<short%> and %<char%> in "
	"declaration specifiers");
	else if (specs->typespec_word == cts_float)
	error ("both %<short%> and %<float%> in "
	"declaration specifiers");
	else if (specs->typespec_word == cts_double)
	error ("both %<short%> and %<double%> in "
	"declaration specifiers");
	else if (specs->typespec_word == cts_dfloat32)
	error ("both %<short%> and %<_Decimal32%> in "
	"declaration specifiers");
	else if (specs->typespec_word == cts_dfloat64)
	error ("both %<short%> and %<_Decimal64%> in "
	"declaration specifiers");
	else if (specs->typespec_word == cts_dfloat128)
	error ("both %<short%> and %<_Decimal128%> in "
	"declaration specifiers");
	else
	specs->short_p = true;
	break;
	case RID_SIGNED:
	dupe = specs->signed_p;
	if (specs->unsigned_p)
	error ("both %<signed%> and %<unsigned%> in "
	"declaration specifiers");
	else if (specs->typespec_word == cts_void)
	error ("both %<signed%> and %<void%> in "
	"declaration specifiers");
	else if (specs->typespec_word == cts_bool)
	error ("both %<signed%> and %<_Bool%> in "
	"declaration specifiers");
	else if (specs->typespec_word == cts_float)
	error ("both %<signed%> and %<float%> in "
	"declaration specifiers");
	else if (specs->typespec_word == cts_double)
	error ("both %<signed%> and %<double%> in "
	"declaration specifiers");
	else if (specs->typespec_word == cts_dfloat32)
	error ("both %<signed%> and %<_Decimal32%> in "
	"declaration specifiers");
	else if (specs->typespec_word == cts_dfloat64)
	error ("both %<signed%> and %<_Decimal64%> in "
	"declaration specifiers");
	else if (specs->typespec_word == cts_dfloat128)
	error ("both %<signed%> and %<_Decimal128%> in "
	"declaration specifiers");
	else
	specs->signed_p = true;
	break;
	case RID_UNSIGNED:
	dupe = specs->unsigned_p;
	if (specs->signed_p)
	error ("both %<signed%> and %<unsigned%> in "
	"declaration specifiers");
	else if (specs->typespec_word == cts_void)
	error ("both %<unsigned%> and %<void%> in "
	"declaration specifiers");
	else if (specs->typespec_word == cts_bool)
	error ("both %<unsigned%> and %<_Bool%> in "
	"declaration specifiers");
	else if (specs->typespec_word == cts_float)
	error ("both %<unsigned%> and %<float%> in "
	"declaration specifiers");
	else if (specs->typespec_word == cts_double)
	error ("both %<unsigned%> and %<double%> in "
	"declaration specifiers");
	else if (specs->typespec_word == cts_dfloat32)
	error ("both %<unsigned%> and %<_Decimal32%> in "
	"declaration specifiers");
	else if (specs->typespec_word == cts_dfloat64)
	error ("both %<unsigned%> and %<_Decimal64%> in "
	"declaration specifiers");
	else if (specs->typespec_word == cts_dfloat128)
	error ("both %<unsigned%> and %<_Decimal128%> in "
	"declaration specifiers");
	else
	specs->unsigned_p = true;
	break;
	case RID_COMPLEX:
	dupe = specs->complex_p;
	if (pedantic && !flag_isoc99 && !in_system_header)
	pedwarn ("ISO C90 does not support complex types");
	if (specs->typespec_word == cts_void)
	error ("both %<complex%> and %<void%> in "
	"declaration specifiers");
	else if (specs->typespec_word == cts_bool)
	error ("both %<complex%> and %<_Bool%> in "
	"declaration specifiers");
	else if (specs->typespec_word == cts_dfloat32)
	error ("both %<complex%> and %<_Decimal32%> in "
	"declaration specifiers");
	else if (specs->typespec_word == cts_dfloat64)
	error ("both %<complex%> and %<_Decimal64%> in "
	"declaration specifiers");
	else if (specs->typespec_word == cts_dfloat128)
	error ("both %<complex%> and %<_Decimal128%> in "
	"declaration specifiers");
	else
	specs->complex_p = true;
	break;
	default:
	gcc_unreachable ();
	}

	if (dupe)
	error ("duplicate %qE", type);

	return specs;
	}
	else
	{
	/* "void", "_Bool", "char", "int", "float" or "double". */
	if (specs->typespec_word != cts_none)
	{
	error ("two or more data types in declaration specifiers");
	return specs;
	}
	switch (i)
	{
	case RID_VOID:
	if (specs->long_p)
	error ("both %<long%> and %<void%> in "
	"declaration specifiers");
	else if (specs->short_p)
	error ("both %<short%> and %<void%> in "
	"declaration specifiers");
	else if (specs->signed_p)
	error ("both %<signed%> and %<void%> in "
	"declaration specifiers");
	else if (specs->unsigned_p)
	error ("both %<unsigned%> and %<void%> in "
	"declaration specifiers");
	else if (specs->complex_p)
	error ("both %<complex%> and %<void%> in "
	"declaration specifiers");
	else
	specs->typespec_word = cts_void;
	return specs;
	case RID_BOOL:
	if (specs->long_p)
	error ("both %<long%> and %<_Bool%> in "
	"declaration specifiers");
	else if (specs->short_p)
	error ("both %<short%> and %<_Bool%> in "
	"declaration specifiers");
	else if (specs->signed_p)
	error ("both %<signed%> and %<_Bool%> in "
	"declaration specifiers");
	else if (specs->unsigned_p)
	error ("both %<unsigned%> and %<_Bool%> in "
	"declaration specifiers");
	else if (specs->complex_p)
	error ("both %<complex%> and %<_Bool%> in "
	"declaration specifiers");
	else
	specs->typespec_word = cts_bool;
	return specs;
	case RID_CHAR:
	if (specs->long_p)
	error ("both %<long%> and %<char%> in "
	"declaration specifiers");
	else if (specs->short_p)
	error ("both %<short%> and %<char%> in "
	"declaration specifiers");
	else
	specs->typespec_word = cts_char;
	return specs;
	case RID_INT:
	specs->typespec_word = cts_int;
	return specs;
	case RID_FLOAT:
	if (specs->long_p)
	error ("both %<long%> and %<float%> in "
	"declaration specifiers");
	else if (specs->short_p)
	error ("both %<short%> and %<float%> in "
	"declaration specifiers");
	else if (specs->signed_p)
	error ("both %<signed%> and %<float%> in "
	"declaration specifiers");
	else if (specs->unsigned_p)
	error ("both %<unsigned%> and %<float%> in "
	"declaration specifiers");
	else
	specs->typespec_word = cts_float;
	return specs;
	case RID_DOUBLE:
	if (specs->long_long_p)
	error ("both %<long long%> and %<double%> in "
	"declaration specifiers");
	else if (specs->short_p)
	error ("both %<short%> and %<double%> in "
	"declaration specifiers");
	else if (specs->signed_p)
	error ("both %<signed%> and %<double%> in "
	"declaration specifiers");
	else if (specs->unsigned_p)
	error ("both %<unsigned%> and %<double%> in "
	"declaration specifiers");
	else
	specs->typespec_word = cts_double;
	return specs;
	case RID_DFLOAT32:
	case RID_DFLOAT64:
	case RID_DFLOAT128:
	{
	const char *str;
	if (i == RID_DFLOAT32)
	str = "_Decimal32";
	else if (i == RID_DFLOAT64)
	str = "_Decimal64";
	else
	str = "_Decimal128";
	if (specs->long_long_p)
	error ("both %<long long%> and %<%s%> in "
	"declaration specifiers", str);
	if (specs->long_p)
	error ("both %<long%> and %<%s%> in "
	"declaration specifiers", str);
	else if (specs->short_p)
	error ("both %<short%> and %<%s%> in "
	"declaration specifiers", str);
	else if (specs->signed_p)
	error ("both %<signed%> and %<%s%> in "
	"declaration specifiers", str);
	else if (specs->unsigned_p)
	error ("both %<unsigned%> and %<%s%> in "
	"declaration specifiers", str);
	else if (specs->complex_p)
	error ("both %<complex%> and %<%s%> in "
	"declaration specifiers", str);
	else if (i == RID_DFLOAT32)
	specs->typespec_word = cts_dfloat32;
	else if (i == RID_DFLOAT64)
	specs->typespec_word = cts_dfloat64;
	else
	specs->typespec_word = cts_dfloat128;
	}
	if (!targetm.decimal_float_supported_p ())
	error ("decimal floating point not supported for this target");
	if (pedantic)
	pedwarn ("ISO C does not support decimal floating point");
	return specs;
	default:
	/* ObjC reserved word "id", handled below. */
	break;
	}
	}
	}

	/* Now we have a typedef (a TYPE_DECL node), an identifier (some
	form of ObjC type, cases such as "int" and "long" being handled
	above), a TYPE (struct, union, enum and typeof specifiers) or an
	ERROR_MARK. In none of these cases may there have previously
	been any type specifiers. */
	if (specs->type \|\| specs->typespec_word != cts_none
	\|\| specs->long_p \|\| specs->short_p \|\| specs->signed_p
	\|\| specs->unsigned_p \|\| specs->complex_p)
	error ("two or more data types in declaration specifiers");
	else if (TREE_CODE (type) == TYPE_DECL)
	{
	if (TREE_TYPE (type) == error_mark_node)
	; /* Allow the type to default to int to avoid cascading errors. */
	else
	{
	specs->type = TREE_TYPE (type);
	specs->decl_attr = DECL_ATTRIBUTES (type);
	specs->typedef_p = true;
	specs->explicit_signed_p = C_TYPEDEF_EXPLICITLY_SIGNED (type);
	}
	}
	else if (TREE_CODE (type) == IDENTIFIER_NODE)
	{
	tree t = lookup_name (type);
	if (!t \|\| TREE_CODE (t) != TYPE_DECL)
	error ("%qE fails to be a typedef or built in type", type);
	else if (TREE_TYPE (t) == error_mark_node)
	;
	else
	specs->type = TREE_TYPE (t);
	}
	else if (TREE_CODE (type) != ERROR_MARK)
	{
	if (spec.kind == ctsk_tagdef \|\| spec.kind == ctsk_tagfirstref)
	specs->tag_defined_p = true;
	if (spec.kind == ctsk_typeof)
	specs->typedef_p = true;
	specs->type = type;
	}

	return specs;
	}

	/* Add the storage class specifier or function specifier SCSPEC to the
	declaration specifiers SPECS, returning SPECS. */

	struct c_declspecs *
	declspecs_add_scspec (struct c_declspecs *specs, tree scspec)
	{
	enum rid i;
	enum c_storage_class n = csc_none;
	bool dupe = false;
	specs->declspecs_seen_p = true;
	gcc_assert (TREE_CODE (scspec) == IDENTIFIER_NODE
	&& C_IS_RESERVED_WORD (scspec));
	i = C_RID_CODE (scspec);
	if (extra_warnings && specs->non_sc_seen_p)
	warning (OPT_Wextra, "%qE is not at beginning of declaration", scspec);
	switch (i)
	{
	case RID_INLINE:
	/* C99 permits duplicate inline. Although of doubtful utility,
	it seems simplest to permit it in gnu89 mode as well, as
	there is also little utility in maintaining this as a
	difference between gnu89 and C99 inline. */
	dupe = false;
	specs->inline_p = true;
	break;
	case RID_THREAD:
	dupe = specs->thread_p;
	if (specs->storage_class == csc_auto)
	error ("%<__thread%> used with %<auto%>");
	else if (specs->storage_class == csc_register)
	error ("%<__thread%> used with %<register%>");
	else if (specs->storage_class == csc_typedef)
	error ("%<__thread%> used with %<typedef%>");
	else
	specs->thread_p = true;
	break;
	case RID_AUTO:
	n = csc_auto;
	break;
	case RID_EXTERN:
	n = csc_extern;
	/* Diagnose "__thread extern". */
	if (specs->thread_p)
	error ("%<__thread%> before %<extern%>");
	break;
	case RID_REGISTER:
	n = csc_register;
	break;
	case RID_STATIC:
	n = csc_static;
	/* Diagnose "__thread static". */
	if (specs->thread_p)
	error ("%<__thread%> before %<static%>");
	break;
	case RID_TYPEDEF:
	n = csc_typedef;
	break;
	default:
	gcc_unreachable ();
	}
	if (n != csc_none && n == specs->storage_class)
	dupe = true;
	if (dupe)
	error ("duplicate %qE", scspec);
	if (n != csc_none)
	{
	if (specs->storage_class != csc_none && n != specs->storage_class)
	{
	error ("multiple storage classes in declaration specifiers");
	}
	else
	{
	specs->storage_class = n;
	if (n != csc_extern && n != csc_static && specs->thread_p)
	{
	error ("%<__thread%> used with %qE", scspec);
	specs->thread_p = false;
	}
	}
	}
	return specs;
	}

	/* Add the attributes ATTRS to the declaration specifiers SPECS,
	returning SPECS. */

	struct c_declspecs *
	declspecs_add_attrs (struct c_declspecs *specs, tree attrs)
	{
	specs->attrs = chainon (attrs, specs->attrs);
	specs->declspecs_seen_p = true;
	return specs;
	}

	/* Combine "long", "short", "signed", "unsigned" and "_Complex" type
	specifiers with any other type specifier to determine the resulting
	type. This is where ISO C checks on complex types are made, since
	"_Complex long" is a prefix of the valid ISO C type "_Complex long
	double". */

	struct c_declspecs *
	finish_declspecs (struct c_declspecs *specs)
	{
	/* If a type was specified as a whole, we have no modifiers and are
	done. */
	if (specs->type != NULL_TREE)
	{
	gcc_assert (!specs->long_p && !specs->long_long_p && !specs->short_p
	&& !specs->signed_p && !specs->unsigned_p
	&& !specs->complex_p);
	return specs;
	}

	/* If none of "void", "_Bool", "char", "int", "float" or "double"
	has been specified, treat it as "int" unless "_Complex" is
	present and there are no other specifiers. If we just have
	"_Complex", it is equivalent to "_Complex double", but e.g.
	"_Complex short" is equivalent to "_Complex short int". */
	if (specs->typespec_word == cts_none)
	{
	if (specs->long_p \|\| specs->short_p
	\|\| specs->signed_p \|\| specs->unsigned_p)
	{
	specs->typespec_word = cts_int;
	}
	else if (specs->complex_p)
	{
	specs->typespec_word = cts_double;
	if (pedantic)
	pedwarn ("ISO C does not support plain %<complex%> meaning "
	"%<double complex%>");
	}
	else
	{
	specs->typespec_word = cts_int;
	specs->default_int_p = true;
	/* We don't diagnose this here because grokdeclarator will
	give more specific diagnostics according to whether it is
	a function definition. */
	}
	}

	/* If "signed" was specified, record this to distinguish "int" and
	"signed int" in the case of a bit-field with
	-funsigned-bitfields. */
	specs->explicit_signed_p = specs->signed_p;

	/* Now compute the actual type. */
	switch (specs->typespec_word)
	{
	case cts_void:
	gcc_assert (!specs->long_p && !specs->short_p
	&& !specs->signed_p && !specs->unsigned_p
	&& !specs->complex_p);
	specs->type = void_type_node;
	break;
	case cts_bool:
	gcc_assert (!specs->long_p && !specs->short_p
	&& !specs->signed_p && !specs->unsigned_p
	&& !specs->complex_p);
	specs->type = boolean_type_node;
	break;
	case cts_char:
	gcc_assert (!specs->long_p && !specs->short_p);
	gcc_assert (!(specs->signed_p && specs->unsigned_p));
	if (specs->signed_p)
	specs->type = signed_char_type_node;
	else if (specs->unsigned_p)
	specs->type = unsigned_char_type_node;
	else
	specs->type = char_type_node;
	if (specs->complex_p)
	{
	if (pedantic)
	pedwarn ("ISO C does not support complex integer types");
	specs->type = build_complex_type (specs->type);
	}
	break;
	case cts_int:
	gcc_assert (!(specs->long_p && specs->short_p));
	gcc_assert (!(specs->signed_p && specs->unsigned_p));
	if (specs->long_long_p)
	specs->type = (specs->unsigned_p
	? long_long_unsigned_type_node
	: long_long_integer_type_node);
	else if (specs->long_p)
	specs->type = (specs->unsigned_p
	? long_unsigned_type_node
	: long_integer_type_node);
	else if (specs->short_p)
	specs->type = (specs->unsigned_p
	? short_unsigned_type_node
	: short_integer_type_node);
	else
	specs->type = (specs->unsigned_p
	? unsigned_type_node
	: integer_type_node);
	if (specs->complex_p)
	{
	if (pedantic)
	pedwarn ("ISO C does not support complex integer types");
	specs->type = build_complex_type (specs->type);
	}
	break;
	case cts_float:
	gcc_assert (!specs->long_p && !specs->short_p
	&& !specs->signed_p && !specs->unsigned_p);
	specs->type = (specs->complex_p
	? complex_float_type_node
	: float_type_node);
	break;
	case cts_double:
	gcc_assert (!specs->long_long_p && !specs->short_p
	&& !specs->signed_p && !specs->unsigned_p);
	if (specs->long_p)
	{
	specs->type = (specs->complex_p
	? complex_long_double_type_node
	: long_double_type_node);
	}
	else
	{
	specs->type = (specs->complex_p
	? complex_double_type_node
	: double_type_node);
	}
	break;
	case cts_dfloat32:
	case cts_dfloat64:
	case cts_dfloat128:
	gcc_assert (!specs->long_p && !specs->long_long_p && !specs->short_p
	&& !specs->signed_p && !specs->unsigned_p && !specs->complex_p);
	if (specs->typespec_word == cts_dfloat32)
	specs->type = dfloat32_type_node;
	else if (specs->typespec_word == cts_dfloat64)
	specs->type = dfloat64_type_node;
	else
	specs->type = dfloat128_type_node;
	break;
	default:
	gcc_unreachable ();
	}

	return specs;
	}

	/* Synthesize a function which calls all the global ctors or global
	dtors in this file. This is only used for targets which do not
	support .ctors/.dtors sections. FIXME: Migrate into cgraph. */
	static void
	build_cdtor (int method_type, tree cdtors)
	{
	tree body = 0;

	if (!cdtors)
	return;

	for (; cdtors; cdtors = TREE_CHAIN (cdtors))
	append_to_statement_list (build_function_call (TREE_VALUE (cdtors), 0),
	&body);

	cgraph_build_static_cdtor (method_type, body, DEFAULT_INIT_PRIORITY);
	}

	/* A subroutine of c_write_global_declarations. Perform final processing
	on one file scope's declarations (or the external scope's declarations),
	GLOBALS. */

	static void
	c_write_global_declarations_1 (tree globals)
	{
	tree decl;
	bool reconsider;

	/* Process the decls in the order they were written. */
	for (decl = globals; decl; decl = TREE_CHAIN (decl))
	{
	/* Check for used but undefined static functions using the C
	standard's definition of "used", and set TREE_NO_WARNING so
	that check_global_declarations doesn't repeat the check. */
	if (TREE_CODE (decl) == FUNCTION_DECL
	&& DECL_INITIAL (decl) == 0
	&& DECL_EXTERNAL (decl)
	&& !TREE_PUBLIC (decl)
	&& C_DECL_USED (decl))
	{
	pedwarn ("%q+F used but never defined", decl);
	TREE_NO_WARNING (decl) = 1;
	}

	wrapup_global_declaration_1 (decl);
	}

	do
	{
	reconsider = false;
	for (decl = globals; decl; decl = TREE_CHAIN (decl))
	reconsider \|= wrapup_global_declaration_2 (decl);
	}
	while (reconsider);

	for (decl = globals; decl; decl = TREE_CHAIN (decl))
	check_global_declaration_1 (decl);
	}

	/* A subroutine of c_write_global_declarations Emit debug information for each
	of the declarations in GLOBALS. */

	static void
	c_write_global_declarations_2 (tree globals)
	{
	tree decl;

	for (decl = globals; decl ; decl = TREE_CHAIN (decl))
	debug_hooks->global_decl (decl);
	}

	/* Preserve the external declarations scope across a garbage collect. */
	static GTY(()) tree ext_block;

	void
	c_write_global_declarations (void)
	{
	tree t;

	/* We don't want to do this if generating a PCH. */
	if (pch_file)
	return;

	/* Don't waste time on further processing if -fsyntax-only or we've
	encountered errors. */
	if (flag_syntax_only \|\| errorcount \|\| sorrycount \|\| cpp_errors (parse_in))
	return;

	/* Close the external scope. */
	ext_block = pop_scope ();
	external_scope = 0;
	gcc_assert (!current_scope);

	if (ext_block)
	{
	tree tmp = BLOCK_VARS (ext_block);
	int flags;
	FILE * stream = dump_begin (TDI_tu, &flags);
	if (stream && tmp)
	{
	dump_node (tmp, flags & ~TDF_SLIM, stream);
	dump_end (TDI_tu, stream);
	}
	}

	/* Process all file scopes in this compilation, and the external_scope,
	through wrapup_global_declarations and check_global_declarations. */
	for (t = all_translation_units; t; t = TREE_CHAIN (t))
	c_write_global_declarations_1 (BLOCK_VARS (DECL_INITIAL (t)));
	c_write_global_declarations_1 (BLOCK_VARS (ext_block));

	/* Generate functions to call static constructors and destructors
	for targets that do not support .ctors/.dtors sections. These
	functions have magic names which are detected by collect2. */
	build_cdtor ('I', static_ctors); static_ctors = 0;
	build_cdtor ('D', static_dtors); static_dtors = 0;

	/* We're done parsing; proceed to optimize and emit assembly.
	FIXME: shouldn't be the front end's responsibility to call this. */
	cgraph_optimize ();

	/* After cgraph has had a chance to emit everything that's going to
	be emitted, output debug information for globals. */
	if (errorcount == 0 && sorrycount == 0)
	{
	timevar_push (TV_SYMOUT);
	for (t = all_translation_units; t; t = TREE_CHAIN (t))
	c_write_global_declarations_2 (BLOCK_VARS (DECL_INITIAL (t)));
	c_write_global_declarations_2 (BLOCK_VARS (ext_block));
	timevar_pop (TV_SYMOUT);
	}

	ext_block = NULL;
	}

	#include "gt-c-decl.h"
	diff --git a/contrib/gcc/c-parser.c b/contrib/gcc/c-parser.c
	index c6be63918f66..a8c8a1ecb93d 100644
	--- a/contrib/gcc/c-parser.c
	+++ b/contrib/gcc/c-parser.c
	@@ -1,7868 +1,7905 @@
	/* Parser for C and Objective-C.
	Copyright (C) 1987, 1988, 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
	1999, 2000, 2001, 2002, 2003, 2004, 2005 Free Software Foundation, Inc.

	Parser actions based on the old Bison parser; structure somewhat
	influenced by and fragments based on the C++ parser.

	This file is part of GCC.

	GCC is free software; you can redistribute it and/or modify it under
	the terms of the GNU General Public License as published by the Free
	Software Foundation; either version 2, or (at your option) any later
	version.

	GCC is distributed in the hope that it will be useful, but WITHOUT ANY
	WARRANTY; without even the implied warranty of MERCHANTABILITY or
	FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	for more details.

	You should have received a copy of the GNU General Public License
	along with GCC; see the file COPYING. If not, write to the Free
	Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
	02110-1301, USA. */

	/* TODO:

	Make sure all relevant comments, and all relevant code from all
	actions, brought over from old parser. Verify exact correspondence
	of syntax accepted.

	Add testcases covering every input symbol in every state in old and
	new parsers.

	Include full syntax for GNU C, including erroneous cases accepted
	with error messages, in syntax productions in comments.

	Make more diagnostics in the front end generally take an explicit
	location rather than implicitly using input_location. */

	#include "config.h"
	#include "system.h"
	#include "coretypes.h"
	#include "tm.h"
	#include "tree.h"
	#include "rtl.h"
	#include "langhooks.h"
	#include "input.h"
	#include "cpplib.h"
	#include "timevar.h"
	#include "c-pragma.h"
	#include "c-tree.h"
	#include "flags.h"
	#include "output.h"
	#include "toplev.h"
	#include "ggc.h"
	#include "c-common.h"
	#include "vec.h"
	#include "target.h"
	#include "cgraph.h"


	/* Miscellaneous data and functions needed for the parser. */

	int yydebug;

	/* Objective-C specific parser/lexer information. */

	static int objc_pq_context = 0;

	/* The following flag is needed to contextualize Objective-C lexical
	analysis. In some cases (e.g., 'int NSObject;'), it is undesirable
	to bind an identifier to an Objective-C class, even if a class with
	that name exists. */
	static int objc_need_raw_identifier = 0;
	#define OBJC_NEED_RAW_IDENTIFIER(VAL) \
	do { \
	if (c_dialect_objc ()) \
	objc_need_raw_identifier = VAL; \
	} while (0)

	/* The reserved keyword table. */
	struct resword
	{
	const char *word;
	ENUM_BITFIELD(rid) rid : 16;
	unsigned int disable : 16;
	};

	/* Disable mask. Keywords are disabled if (reswords[i].disable &
	mask) is _true_. */
	#define D_C89 0x01 /* not in C89 */
	#define D_EXT 0x02 /* GCC extension */
	#define D_EXT89 0x04 /* GCC extension incorporated in C99 */
	#define D_OBJC 0x08 /* Objective C only */

	static const struct resword reswords[] =
	{
	{ "_Bool", RID_BOOL, 0 },
	{ "_Complex", RID_COMPLEX, 0 },
	{ "_Decimal32", RID_DFLOAT32, D_EXT },
	{ "_Decimal64", RID_DFLOAT64, D_EXT },
	{ "_Decimal128", RID_DFLOAT128, D_EXT },
	{ "__FUNCTION__", RID_FUNCTION_NAME, 0 },
	{ "__PRETTY_FUNCTION__", RID_PRETTY_FUNCTION_NAME, 0 },
	{ "__alignof", RID_ALIGNOF, 0 },
	{ "__alignof__", RID_ALIGNOF, 0 },
	{ "__asm", RID_ASM, 0 },
	{ "__asm__", RID_ASM, 0 },
	{ "__attribute", RID_ATTRIBUTE, 0 },
	{ "__attribute__", RID_ATTRIBUTE, 0 },
	{ "__builtin_choose_expr", RID_CHOOSE_EXPR, 0 },
	{ "__builtin_offsetof", RID_OFFSETOF, 0 },
	{ "__builtin_types_compatible_p", RID_TYPES_COMPATIBLE_P, 0 },
	{ "__builtin_va_arg", RID_VA_ARG, 0 },
	{ "__complex", RID_COMPLEX, 0 },
	{ "__complex__", RID_COMPLEX, 0 },
	{ "__const", RID_CONST, 0 },
	{ "__const__", RID_CONST, 0 },
	{ "__extension__", RID_EXTENSION, 0 },
	{ "__func__", RID_C99_FUNCTION_NAME, 0 },
	{ "__imag", RID_IMAGPART, 0 },
	{ "__imag__", RID_IMAGPART, 0 },
	{ "__inline", RID_INLINE, 0 },
	{ "__inline__", RID_INLINE, 0 },
	{ "__label__", RID_LABEL, 0 },
	{ "__real", RID_REALPART, 0 },
	{ "__real__", RID_REALPART, 0 },
	{ "__restrict", RID_RESTRICT, 0 },
	{ "__restrict__", RID_RESTRICT, 0 },
	{ "__signed", RID_SIGNED, 0 },
	{ "__signed__", RID_SIGNED, 0 },
	{ "__thread", RID_THREAD, 0 },
	{ "__typeof", RID_TYPEOF, 0 },
	{ "__typeof__", RID_TYPEOF, 0 },
	{ "__volatile", RID_VOLATILE, 0 },
	{ "__volatile__", RID_VOLATILE, 0 },
	{ "asm", RID_ASM, D_EXT },
	{ "auto", RID_AUTO, 0 },
	{ "break", RID_BREAK, 0 },
	{ "case", RID_CASE, 0 },
	{ "char", RID_CHAR, 0 },
	{ "const", RID_CONST, 0 },
	{ "continue", RID_CONTINUE, 0 },
	{ "default", RID_DEFAULT, 0 },
	{ "do", RID_DO, 0 },
	{ "double", RID_DOUBLE, 0 },
	{ "else", RID_ELSE, 0 },
	{ "enum", RID_ENUM, 0 },
	{ "extern", RID_EXTERN, 0 },
	{ "float", RID_FLOAT, 0 },
	{ "for", RID_FOR, 0 },
	{ "goto", RID_GOTO, 0 },
	{ "if", RID_IF, 0 },
	{ "inline", RID_INLINE, D_EXT89 },
	{ "int", RID_INT, 0 },
	{ "long", RID_LONG, 0 },
	{ "register", RID_REGISTER, 0 },
	{ "restrict", RID_RESTRICT, D_C89 },
	{ "return", RID_RETURN, 0 },
	{ "short", RID_SHORT, 0 },
	{ "signed", RID_SIGNED, 0 },
	{ "sizeof", RID_SIZEOF, 0 },
	{ "static", RID_STATIC, 0 },
	{ "struct", RID_STRUCT, 0 },
	{ "switch", RID_SWITCH, 0 },
	{ "typedef", RID_TYPEDEF, 0 },
	{ "typeof", RID_TYPEOF, D_EXT },
	{ "union", RID_UNION, 0 },
	{ "unsigned", RID_UNSIGNED, 0 },
	{ "void", RID_VOID, 0 },
	{ "volatile", RID_VOLATILE, 0 },
	{ "while", RID_WHILE, 0 },
	/* These Objective-C keywords are recognized only immediately after
	an '@'. */
	{ "class", RID_AT_CLASS, D_OBJC },
	{ "compatibility_alias", RID_AT_ALIAS, D_OBJC },
	{ "defs", RID_AT_DEFS, D_OBJC },
	{ "encode", RID_AT_ENCODE, D_OBJC },
	{ "end", RID_AT_END, D_OBJC },
	{ "implementation", RID_AT_IMPLEMENTATION, D_OBJC },
	{ "interface", RID_AT_INTERFACE, D_OBJC },
	{ "private", RID_AT_PRIVATE, D_OBJC },
	{ "protected", RID_AT_PROTECTED, D_OBJC },
	{ "protocol", RID_AT_PROTOCOL, D_OBJC },
	{ "public", RID_AT_PUBLIC, D_OBJC },
	{ "selector", RID_AT_SELECTOR, D_OBJC },
	{ "throw", RID_AT_THROW, D_OBJC },
	{ "try", RID_AT_TRY, D_OBJC },
	{ "catch", RID_AT_CATCH, D_OBJC },
	{ "finally", RID_AT_FINALLY, D_OBJC },
	{ "synchronized", RID_AT_SYNCHRONIZED, D_OBJC },
	/* These are recognized only in protocol-qualifier context
	(see above) */
	{ "bycopy", RID_BYCOPY, D_OBJC },
	{ "byref", RID_BYREF, D_OBJC },
	{ "in", RID_IN, D_OBJC },
	{ "inout", RID_INOUT, D_OBJC },
	{ "oneway", RID_ONEWAY, D_OBJC },
	{ "out", RID_OUT, D_OBJC },
	};
	#define N_reswords (sizeof reswords / sizeof (struct resword))

	/* All OpenMP clauses. OpenMP 2.5. */
	typedef enum pragma_omp_clause {
	PRAGMA_OMP_CLAUSE_NONE = 0,

	PRAGMA_OMP_CLAUSE_COPYIN,
	PRAGMA_OMP_CLAUSE_COPYPRIVATE,
	PRAGMA_OMP_CLAUSE_DEFAULT,
	PRAGMA_OMP_CLAUSE_FIRSTPRIVATE,
	PRAGMA_OMP_CLAUSE_IF,
	PRAGMA_OMP_CLAUSE_LASTPRIVATE,
	PRAGMA_OMP_CLAUSE_NOWAIT,
	PRAGMA_OMP_CLAUSE_NUM_THREADS,
	PRAGMA_OMP_CLAUSE_ORDERED,
	PRAGMA_OMP_CLAUSE_PRIVATE,
	PRAGMA_OMP_CLAUSE_REDUCTION,
	PRAGMA_OMP_CLAUSE_SCHEDULE,
	PRAGMA_OMP_CLAUSE_SHARED
	} pragma_omp_clause;


	/* Initialization routine for this file. */

	void
	c_parse_init (void)
	{
	/* The only initialization required is of the reserved word
	identifiers. */
	unsigned int i;
	tree id;
	int mask = (flag_isoc99 ? 0 : D_C89)
	\| (flag_no_asm ? (flag_isoc99 ? D_EXT : D_EXT\|D_EXT89) : 0);

	if (!c_dialect_objc ())
	mask \|= D_OBJC;

	ridpointers = GGC_CNEWVEC (tree, (int) RID_MAX);
	for (i = 0; i < N_reswords; i++)
	{
	/* If a keyword is disabled, do not enter it into the table
	and so create a canonical spelling that isn't a keyword. */
	if (reswords[i].disable & mask)
	continue;

	id = get_identifier (reswords[i].word);
	C_RID_CODE (id) = reswords[i].rid;
	C_IS_RESERVED_WORD (id) = 1;
	ridpointers [(int) reswords[i].rid] = id;
	}
	}

	/* The C lexer intermediates between the lexer in cpplib and c-lex.c
	and the C parser. Unlike the C++ lexer, the parser structure
	stores the lexer information instead of using a separate structure.
	Identifiers are separated into ordinary identifiers, type names,
	keywords and some other Objective-C types of identifiers, and some
	look-ahead is maintained.

	??? It might be a good idea to lex the whole file up front (as for
	C++). It would then be possible to share more of the C and C++
	lexer code, if desired. */

	/* The following local token type is used. */

	/* A keyword. */
	#define CPP_KEYWORD ((enum cpp_ttype) (N_TTYPES + 1))

	/* More information about the type of a CPP_NAME token. */
	typedef enum c_id_kind {
	/* An ordinary identifier. */
	C_ID_ID,
	/* An identifier declared as a typedef name. */
	C_ID_TYPENAME,
	/* An identifier declared as an Objective-C class name. */
	C_ID_CLASSNAME,
	/* Not an identifier. */
	C_ID_NONE
	} c_id_kind;

	/* A single C token after string literal concatenation and conversion
	of preprocessing tokens to tokens. */
	typedef struct c_token GTY (())
	{
	/* The kind of token. */
	ENUM_BITFIELD (cpp_ttype) type : 8;
	/* If this token is a CPP_NAME, this value indicates whether also
	declared as some kind of type. Otherwise, it is C_ID_NONE. */
	ENUM_BITFIELD (c_id_kind) id_kind : 8;
	/* If this token is a keyword, this value indicates which keyword.
	Otherwise, this value is RID_MAX. */
	ENUM_BITFIELD (rid) keyword : 8;
	/* If this token is a CPP_PRAGMA, this indicates the pragma that
	was seen. Otherwise it is PRAGMA_NONE. */
	ENUM_BITFIELD (pragma_kind) pragma_kind : 7;
	/* True if this token is from a system header. */
	BOOL_BITFIELD in_system_header : 1;
	/* The value associated with this token, if any. */
	tree value;
	/* The location at which this token was found. */
	location_t location;
	} c_token;

	/* A parser structure recording information about the state and
	context of parsing. Includes lexer information with up to two
	tokens of look-ahead; more are not needed for C. */
	typedef struct c_parser GTY(())
	{
	/* The look-ahead tokens. */
	c_token tokens[2];
	/* How many look-ahead tokens are available (0, 1 or 2). */
	short tokens_avail;
	/* True if a syntax error is being recovered from; false otherwise.
	c_parser_error sets this flag. It should clear this flag when
	enough tokens have been consumed to recover from the error. */
	BOOL_BITFIELD error : 1;
	/* True if we're processing a pragma, and shouldn't automatically
	consume CPP_PRAGMA_EOL. */
	BOOL_BITFIELD in_pragma : 1;
	} c_parser;


	/* The actual parser and external interface. ??? Does this need to be
	garbage-collected? */

	static GTY (()) c_parser *the_parser;


	/* Read in and lex a single token, storing it in TOKEN. /

	static void
	c_lex_one_token (c_token *token)
	{
	timevar_push (TV_LEX);

	token->type = c_lex_with_flags (&token->value, &token->location, NULL);
	token->id_kind = C_ID_NONE;
	token->keyword = RID_MAX;
	token->pragma_kind = PRAGMA_NONE;
	token->in_system_header = in_system_header;

	switch (token->type)
	{
	case CPP_NAME:
	{
	tree decl;

	int objc_force_identifier = objc_need_raw_identifier;
	OBJC_NEED_RAW_IDENTIFIER (0);

	if (C_IS_RESERVED_WORD (token->value))
	{
	enum rid rid_code = C_RID_CODE (token->value);

	if (c_dialect_objc ())
	{
	if (!OBJC_IS_AT_KEYWORD (rid_code)
	&& (!OBJC_IS_PQ_KEYWORD (rid_code) \|\| objc_pq_context))
	{
	/* Return the canonical spelling for this keyword. */
	token->value = ridpointers[(int) rid_code];
	token->type = CPP_KEYWORD;
	token->keyword = rid_code;
	break;
	}
	}
	else
	{
	/* Return the canonical spelling for this keyword. */
	token->value = ridpointers[(int) rid_code];
	token->type = CPP_KEYWORD;
	token->keyword = rid_code;
	break;
	}
	}

	decl = lookup_name (token->value);
	if (decl)
	{
	if (TREE_CODE (decl) == TYPE_DECL)
	{
	token->id_kind = C_ID_TYPENAME;
	break;
	}
	}
	else if (c_dialect_objc ())
	{
	tree objc_interface_decl = objc_is_class_name (token->value);
	/* Objective-C class names are in the same namespace as
	variables and typedefs, and hence are shadowed by local
	declarations. */
	if (objc_interface_decl
	&& (global_bindings_p ()
	\|\| (!objc_force_identifier && !decl)))
	{
	token->value = objc_interface_decl;
	token->id_kind = C_ID_CLASSNAME;
	break;
	}
	}
	token->id_kind = C_ID_ID;
	}
	break;
	case CPP_AT_NAME:
	/* This only happens in Objective-C; it must be a keyword. */
	token->type = CPP_KEYWORD;
	token->keyword = C_RID_CODE (token->value);
	break;
	case CPP_COLON:
	case CPP_COMMA:
	case CPP_CLOSE_PAREN:
	case CPP_SEMICOLON:
	/* These tokens may affect the interpretation of any identifiers
	following, if doing Objective-C. */
	OBJC_NEED_RAW_IDENTIFIER (0);
	break;
	case CPP_PRAGMA:
	/* We smuggled the cpp_token->u.pragma value in an INTEGER_CST. */
	token->pragma_kind = TREE_INT_CST_LOW (token->value);
	token->value = NULL;
	break;
	default:
	break;
	}
	timevar_pop (TV_LEX);
	}

	/* Return a pointer to the next token from PARSER, reading it in if
	necessary. */

	static inline c_token *
	c_parser_peek_token (c_parser *parser)
	{
	if (parser->tokens_avail == 0)
	{
	c_lex_one_token (&parser->tokens[0]);
	parser->tokens_avail = 1;
	}
	return &parser->tokens[0];
	}

	/* Return true if the next token from PARSER has the indicated
	TYPE. */

	static inline bool
	c_parser_next_token_is (c_parser *parser, enum cpp_ttype type)
	{
	return c_parser_peek_token (parser)->type == type;
	}

	/* Return true if the next token from PARSER does not have the
	indicated TYPE. */

	static inline bool
	c_parser_next_token_is_not (c_parser *parser, enum cpp_ttype type)
	{
	return !c_parser_next_token_is (parser, type);
	}

	/* Return true if the next token from PARSER is the indicated
	KEYWORD. */

	static inline bool
	c_parser_next_token_is_keyword (c_parser *parser, enum rid keyword)
	{
	c_token *token;

	/* Peek at the next token. */
	token = c_parser_peek_token (parser);
	/* Check to see if it is the indicated keyword. */
	return token->keyword == keyword;
	}

	/* Return true if TOKEN can start a type name,
	false otherwise. */
	static bool
	c_token_starts_typename (c_token *token)
	{
	switch (token->type)
	{
	case CPP_NAME:
	switch (token->id_kind)
	{
	case C_ID_ID:
	return false;
	case C_ID_TYPENAME:
	return true;
	case C_ID_CLASSNAME:
	gcc_assert (c_dialect_objc ());
	return true;
	default:
	gcc_unreachable ();
	}
	case CPP_KEYWORD:
	switch (token->keyword)
	{
	case RID_UNSIGNED:
	case RID_LONG:
	case RID_SHORT:
	case RID_SIGNED:
	case RID_COMPLEX:
	case RID_INT:
	case RID_CHAR:
	case RID_FLOAT:
	case RID_DOUBLE:
	case RID_VOID:
	case RID_DFLOAT32:
	case RID_DFLOAT64:
	case RID_DFLOAT128:
	case RID_BOOL:
	case RID_ENUM:
	case RID_STRUCT:
	case RID_UNION:
	case RID_TYPEOF:
	case RID_CONST:
	case RID_VOLATILE:
	case RID_RESTRICT:
	case RID_ATTRIBUTE:
	return true;
	default:
	return false;
	}
	case CPP_LESS:
	if (c_dialect_objc ())
	return true;
	return false;
	default:
	return false;
	}
	}

	/* Return true if the next token from PARSER can start a type name,
	false otherwise. */
	static inline bool
	c_parser_next_token_starts_typename (c_parser *parser)
	{
	c_token *token = c_parser_peek_token (parser);
	return c_token_starts_typename (token);
	}

	/* Return true if TOKEN can start declaration specifiers, false
	otherwise. */
	static bool
	c_token_starts_declspecs (c_token *token)
	{
	switch (token->type)
	{
	case CPP_NAME:
	switch (token->id_kind)
	{
	case C_ID_ID:
	return false;
	case C_ID_TYPENAME:
	return true;
	case C_ID_CLASSNAME:
	gcc_assert (c_dialect_objc ());
	return true;
	default:
	gcc_unreachable ();
	}
	case CPP_KEYWORD:
	switch (token->keyword)
	{
	case RID_STATIC:
	case RID_EXTERN:
	case RID_REGISTER:
	case RID_TYPEDEF:
	case RID_INLINE:
	case RID_AUTO:
	case RID_THREAD:
	case RID_UNSIGNED:
	case RID_LONG:
	case RID_SHORT:
	case RID_SIGNED:
	case RID_COMPLEX:
	case RID_INT:
	case RID_CHAR:
	case RID_FLOAT:
	case RID_DOUBLE:
	case RID_VOID:
	case RID_DFLOAT32:
	case RID_DFLOAT64:
	case RID_DFLOAT128:
	case RID_BOOL:
	case RID_ENUM:
	case RID_STRUCT:
	case RID_UNION:
	case RID_TYPEOF:
	case RID_CONST:
	case RID_VOLATILE:
	case RID_RESTRICT:
	case RID_ATTRIBUTE:
	return true;
	default:
	return false;
	}
	case CPP_LESS:
	if (c_dialect_objc ())
	return true;
	return false;
	default:
	return false;
	}
	}

	/* Return true if the next token from PARSER can start declaration
	specifiers, false otherwise. */
	static inline bool
	c_parser_next_token_starts_declspecs (c_parser *parser)
	{
	c_token *token = c_parser_peek_token (parser);
	return c_token_starts_declspecs (token);
	}

	/* Return a pointer to the next-but-one token from PARSER, reading it
	in if necessary. The next token is already read in. */

	static c_token *
	c_parser_peek_2nd_token (c_parser *parser)
	{
	if (parser->tokens_avail >= 2)
	return &parser->tokens[1];
	gcc_assert (parser->tokens_avail == 1);
	gcc_assert (parser->tokens[0].type != CPP_EOF);
	gcc_assert (parser->tokens[0].type != CPP_PRAGMA_EOL);
	c_lex_one_token (&parser->tokens[1]);
	parser->tokens_avail = 2;
	return &parser->tokens[1];
	}

	/* Consume the next token from PARSER. */

	static void
	c_parser_consume_token (c_parser *parser)
	{
	gcc_assert (parser->tokens_avail >= 1);
	gcc_assert (parser->tokens[0].type != CPP_EOF);
	gcc_assert (!parser->in_pragma \|\| parser->tokens[0].type != CPP_PRAGMA_EOL);
	gcc_assert (parser->error \|\| parser->tokens[0].type != CPP_PRAGMA);
	if (parser->tokens_avail == 2)
	parser->tokens[0] = parser->tokens[1];
	parser->tokens_avail--;
	}

	/* Expect the current token to be a #pragma. Consume it and remember
	that we've begun parsing a pragma. */

	static void
	c_parser_consume_pragma (c_parser *parser)
	{
	gcc_assert (!parser->in_pragma);
	gcc_assert (parser->tokens_avail >= 1);
	gcc_assert (parser->tokens[0].type == CPP_PRAGMA);
	if (parser->tokens_avail == 2)
	parser->tokens[0] = parser->tokens[1];
	parser->tokens_avail--;
	parser->in_pragma = true;
	}

	/* Update the globals input_location and in_system_header from
	TOKEN. */
	static inline void
	c_parser_set_source_position_from_token (c_token *token)
	{
	if (token->type != CPP_EOF)
	{
	input_location = token->location;
	in_system_header = token->in_system_header;
	}
	}

	/* Issue a diagnostic of the form
	FILE:LINE: MESSAGE before TOKEN
	where TOKEN is the next token in the input stream of PARSER.
	MESSAGE (specified by the caller) is usually of the form "expected
	OTHER-TOKEN".

	Do not issue a diagnostic if still recovering from an error.

	??? This is taken from the C++ parser, but building up messages in
	this way is not i18n-friendly and some other approach should be
	used. */

	static void
	c_parser_error (c_parser parser, const char gmsgid)
	{
	c_token *token = c_parser_peek_token (parser);
	if (parser->error)
	return;
	parser->error = true;
	if (!gmsgid)
	return;
	/* This diagnostic makes more sense if it is tagged to the line of
	the token we just peeked at. */
	c_parser_set_source_position_from_token (token);
	c_parse_error (gmsgid,
	/* Because c_parse_error does not understand
	CPP_KEYWORD, keywords are treated like
	identifiers. */
	(token->type == CPP_KEYWORD ? CPP_NAME : token->type),
	token->value);
	}

	/* If the next token is of the indicated TYPE, consume it. Otherwise,
	issue the error MSGID. If MSGID is NULL then a message has already
	been produced and no message will be produced this time. Returns
	true if found, false otherwise. */

	static bool
	c_parser_require (c_parser *parser,
	enum cpp_ttype type,
	const char *msgid)
	{
	if (c_parser_next_token_is (parser, type))
	{
	c_parser_consume_token (parser);
	return true;
	}
	else
	{
	c_parser_error (parser, msgid);
	return false;
	}
	}

	/* If the next token is the indicated keyword, consume it. Otherwise,
	issue the error MSGID. Returns true if found, false otherwise. */

	static bool
	c_parser_require_keyword (c_parser *parser,
	enum rid keyword,
	const char *msgid)
	{
	if (c_parser_next_token_is_keyword (parser, keyword))
	{
	c_parser_consume_token (parser);
	return true;
	}
	else
	{
	c_parser_error (parser, msgid);
	return false;
	}
	}

	/* Like c_parser_require, except that tokens will be skipped until the
	desired token is found. An error message is still produced if the
	next token is not as expected. If MSGID is NULL then a message has
	already been produced and no message will be produced this
	time. */

	static void
	c_parser_skip_until_found (c_parser *parser,
	enum cpp_ttype type,
	const char *msgid)
	{
	unsigned nesting_depth = 0;

	if (c_parser_require (parser, type, msgid))
	return;

	/* Skip tokens until the desired token is found. */
	while (true)
	{
	/* Peek at the next token. */
	c_token *token = c_parser_peek_token (parser);
	/* If we've reached the token we want, consume it and stop. */
	if (token->type == type && !nesting_depth)
	{
	c_parser_consume_token (parser);
	break;
	}

	/* If we've run out of tokens, stop. */
	if (token->type == CPP_EOF)
	return;
	if (token->type == CPP_PRAGMA_EOL && parser->in_pragma)
	return;
	if (token->type == CPP_OPEN_BRACE
	\|\| token->type == CPP_OPEN_PAREN
	\|\| token->type == CPP_OPEN_SQUARE)
	++nesting_depth;
	else if (token->type == CPP_CLOSE_BRACE
	\|\| token->type == CPP_CLOSE_PAREN
	\|\| token->type == CPP_CLOSE_SQUARE)
	{
	if (nesting_depth-- == 0)
	break;
	}
	/* Consume this token. */
	c_parser_consume_token (parser);
	}
	parser->error = false;
	}

	/* Skip tokens until the end of a parameter is found, but do not
	consume the comma, semicolon or closing delimiter. */

	static void
	c_parser_skip_to_end_of_parameter (c_parser *parser)
	{
	unsigned nesting_depth = 0;

	while (true)
	{
	c_token *token = c_parser_peek_token (parser);
	if ((token->type == CPP_COMMA \|\| token->type == CPP_SEMICOLON)
	&& !nesting_depth)
	break;
	/* If we've run out of tokens, stop. */
	if (token->type == CPP_EOF)
	return;
	if (token->type == CPP_PRAGMA_EOL && parser->in_pragma)
	return;
	if (token->type == CPP_OPEN_BRACE
	\|\| token->type == CPP_OPEN_PAREN
	\|\| token->type == CPP_OPEN_SQUARE)
	++nesting_depth;
	else if (token->type == CPP_CLOSE_BRACE
	\|\| token->type == CPP_CLOSE_PAREN
	\|\| token->type == CPP_CLOSE_SQUARE)
	{
	if (nesting_depth-- == 0)
	break;
	}
	/* Consume this token. */
	c_parser_consume_token (parser);
	}
	parser->error = false;
	}

	/* Expect to be at the end of the pragma directive and consume an
	end of line marker. */

	static void
	c_parser_skip_to_pragma_eol (c_parser *parser)
	{
	gcc_assert (parser->in_pragma);
	parser->in_pragma = false;

	if (!c_parser_require (parser, CPP_PRAGMA_EOL, "expected end of line"))
	while (true)
	{
	c_token *token = c_parser_peek_token (parser);
	if (token->type == CPP_EOF)
	break;
	if (token->type == CPP_PRAGMA_EOL)
	{
	c_parser_consume_token (parser);
	break;
	}
	c_parser_consume_token (parser);
	}

	parser->error = false;
	}

	/* Skip tokens until we have consumed an entire block, or until we
	have consumed a non-nested ';'. */

	static void
	c_parser_skip_to_end_of_block_or_statement (c_parser *parser)
	{
	unsigned nesting_depth = 0;
	bool save_error = parser->error;

	while (true)
	{
	c_token *token;

	/* Peek at the next token. */
	token = c_parser_peek_token (parser);

	switch (token->type)
	{
	case CPP_EOF:
	return;

	case CPP_PRAGMA_EOL:
	if (parser->in_pragma)
	return;
	break;

	case CPP_SEMICOLON:
	/* If the next token is a ';', we have reached the
	end of the statement. */
	if (!nesting_depth)
	{
	/* Consume the ';'. */
	c_parser_consume_token (parser);
	goto finished;
	}
	break;

	case CPP_CLOSE_BRACE:
	/* If the next token is a non-nested '}', then we have
	reached the end of the current block. */
	if (nesting_depth == 0 \|\| --nesting_depth == 0)
	{
	c_parser_consume_token (parser);
	goto finished;
	}
	break;

	case CPP_OPEN_BRACE:
	/* If it the next token is a '{', then we are entering a new
	block. Consume the entire block. */
	++nesting_depth;
	break;

	case CPP_PRAGMA:
	/* If we see a pragma, consume the whole thing at once. We
	have some safeguards against consuming pragmas willy-nilly.
	Normally, we'd expect to be here with parser->error set,
	which disables these safeguards. But it's possible to get
	here for secondary error recovery, after parser->error has
	been cleared. */
	c_parser_consume_pragma (parser);
	c_parser_skip_to_pragma_eol (parser);
	parser->error = save_error;
	continue;

	default:
	break;
	}

	c_parser_consume_token (parser);
	}

	finished:
	parser->error = false;
	}

	/* Save the warning flags which are controlled by __extension__. */

	static inline int
	disable_extension_diagnostics (void)
	{
	int ret = (pedantic
	\| (warn_pointer_arith << 1)
	\| (warn_traditional << 2)
	\| (flag_iso << 3));
	pedantic = 0;
	warn_pointer_arith = 0;
	warn_traditional = 0;
	flag_iso = 0;
	return ret;
	}

	/* Restore the warning flags which are controlled by __extension__.
	FLAGS is the return value from disable_extension_diagnostics. */

	static inline void
	restore_extension_diagnostics (int flags)
	{
	pedantic = flags & 1;
	warn_pointer_arith = (flags >> 1) & 1;
	warn_traditional = (flags >> 2) & 1;
	flag_iso = (flags >> 3) & 1;
	}

	/* Possibly kinds of declarator to parse. */
	typedef enum c_dtr_syn {
	/* A normal declarator with an identifier. */
	C_DTR_NORMAL,
	/* An abstract declarator (maybe empty). */
	C_DTR_ABSTRACT,
	/* A parameter declarator: may be either, but after a type name does
	not redeclare a typedef name as an identifier if it can
	alternatively be interpreted as a typedef name; see DR#009,
	applied in C90 TC1, omitted from C99 and reapplied in C99 TC2
	following DR#249. For example, given a typedef T, "int T" and
	"int *T" are valid parameter declarations redeclaring T, while
	"int (T)" and "int * (T)" and "int (T[])" and "int (T (int))" are
	abstract declarators rather than involving redundant parentheses;
	the same applies with attributes inside the parentheses before
	"T". */
	C_DTR_PARM
	} c_dtr_syn;

	static void c_parser_external_declaration (c_parser *);
	static void c_parser_asm_definition (c_parser *);
	static void c_parser_declaration_or_fndef (c_parser *, bool, bool, bool, bool);
	static void c_parser_declspecs (c_parser , struct c_declspecs , bool, bool,
	bool);
	static struct c_typespec c_parser_enum_specifier (c_parser *);
	static struct c_typespec c_parser_struct_or_union_specifier (c_parser *);
	static tree c_parser_struct_declaration (c_parser *);
	static struct c_typespec c_parser_typeof_specifier (c_parser *);
	static struct c_declarator c_parser_declarator (c_parser , bool, c_dtr_syn,
	bool *);
	static struct c_declarator c_parser_direct_declarator (c_parser , bool,
	c_dtr_syn, bool *);
	static struct c_declarator c_parser_direct_declarator_inner (c_parser ,
	bool,
	struct c_declarator *);
	static struct c_arg_info c_parser_parms_declarator (c_parser , bool, tree);
	static struct c_arg_info c_parser_parms_list_declarator (c_parser , tree);
	static struct c_parm c_parser_parameter_declaration (c_parser , tree);
	static tree c_parser_simple_asm_expr (c_parser *);
	static tree c_parser_attributes (c_parser *);
	static struct c_type_name c_parser_type_name (c_parser );
	static struct c_expr c_parser_initializer (c_parser *);
	static struct c_expr c_parser_braced_init (c_parser *, tree, bool);
	static void c_parser_initelt (c_parser *);
	static void c_parser_initval (c_parser , struct c_expr );
	static tree c_parser_compound_statement (c_parser *);
	static void c_parser_compound_statement_nostart (c_parser *);
	static void c_parser_label (c_parser *);
	static void c_parser_statement (c_parser *);
	static void c_parser_statement_after_labels (c_parser *);
	static void c_parser_if_statement (c_parser *);
	static void c_parser_switch_statement (c_parser *);
	static void c_parser_while_statement (c_parser *);
	static void c_parser_do_statement (c_parser *);
	static void c_parser_for_statement (c_parser *);
	static tree c_parser_asm_statement (c_parser *);
	static tree c_parser_asm_operands (c_parser *, bool);
	static tree c_parser_asm_clobbers (c_parser *);
	static struct c_expr c_parser_expr_no_commas (c_parser , struct c_expr );
	static struct c_expr c_parser_conditional_expression (c_parser *,
	struct c_expr *);
	static struct c_expr c_parser_binary_expression (c_parser , struct c_expr );
	static struct c_expr c_parser_cast_expression (c_parser , struct c_expr );
	static struct c_expr c_parser_unary_expression (c_parser *);
	static struct c_expr c_parser_sizeof_expression (c_parser *);
	static struct c_expr c_parser_alignof_expression (c_parser *);
	static struct c_expr c_parser_postfix_expression (c_parser *);
	static struct c_expr c_parser_postfix_expression_after_paren_type (c_parser *,
	struct c_type_name *);
	static struct c_expr c_parser_postfix_expression_after_primary (c_parser *,
	struct c_expr);
	static struct c_expr c_parser_expression (c_parser *);
	static struct c_expr c_parser_expression_conv (c_parser *);
	static tree c_parser_expr_list (c_parser *, bool);
	static void c_parser_omp_construct (c_parser *);
	static void c_parser_omp_threadprivate (c_parser *);
	static void c_parser_omp_barrier (c_parser *);
	static void c_parser_omp_flush (c_parser *);

	enum pragma_context { pragma_external, pragma_stmt, pragma_compound };
	static bool c_parser_pragma (c_parser *, enum pragma_context);

	/* These Objective-C parser functions are only ever called when
	compiling Objective-C. */
	static void c_parser_objc_class_definition (c_parser *);
	static void c_parser_objc_class_instance_variables (c_parser *);
	static void c_parser_objc_class_declaration (c_parser *);
	static void c_parser_objc_alias_declaration (c_parser *);
	static void c_parser_objc_protocol_definition (c_parser *);
	static enum tree_code c_parser_objc_method_type (c_parser *);
	static void c_parser_objc_method_definition (c_parser *);
	static void c_parser_objc_methodprotolist (c_parser *);
	static void c_parser_objc_methodproto (c_parser *);
	static tree c_parser_objc_method_decl (c_parser *);
	static tree c_parser_objc_type_name (c_parser *);
	static tree c_parser_objc_protocol_refs (c_parser *);
	static void c_parser_objc_try_catch_statement (c_parser *);
	static void c_parser_objc_synchronized_statement (c_parser *);
	static tree c_parser_objc_selector (c_parser *);
	static tree c_parser_objc_selector_arg (c_parser *);
	static tree c_parser_objc_receiver (c_parser *);
	static tree c_parser_objc_message_args (c_parser *);
	static tree c_parser_objc_keywordexpr (c_parser *);

	/* Parse a translation unit (C90 6.7, C99 6.9).

	translation-unit:
	external-declarations

	external-declarations:
	external-declaration
	external-declarations external-declaration

	GNU extensions:

	translation-unit:
	empty
	*/

	static void
	c_parser_translation_unit (c_parser *parser)
	{
	if (c_parser_next_token_is (parser, CPP_EOF))
	{
	if (pedantic)
	pedwarn ("ISO C forbids an empty source file");
	}
	else
	{
	void *obstack_position = obstack_alloc (&parser_obstack, 0);
	do
	{
	ggc_collect ();
	c_parser_external_declaration (parser);
	obstack_free (&parser_obstack, obstack_position);
	}
	while (c_parser_next_token_is_not (parser, CPP_EOF));
	}
	}

	/* Parse an external declaration (C90 6.7, C99 6.9).

	external-declaration:
	function-definition
	declaration

	GNU extensions:

	external-declaration:
	asm-definition
	;
	__extension__ external-declaration

	Objective-C:

	external-declaration:
	objc-class-definition
	objc-class-declaration
	objc-alias-declaration
	objc-protocol-definition
	objc-method-definition
	@end
	*/

	static void
	c_parser_external_declaration (c_parser *parser)
	{
	int ext;
	switch (c_parser_peek_token (parser)->type)
	{
	case CPP_KEYWORD:
	switch (c_parser_peek_token (parser)->keyword)
	{
	case RID_EXTENSION:
	ext = disable_extension_diagnostics ();
	c_parser_consume_token (parser);
	c_parser_external_declaration (parser);
	restore_extension_diagnostics (ext);
	break;
	case RID_ASM:
	c_parser_asm_definition (parser);
	break;
	case RID_AT_INTERFACE:
	case RID_AT_IMPLEMENTATION:
	gcc_assert (c_dialect_objc ());
	c_parser_objc_class_definition (parser);
	break;
	case RID_AT_CLASS:
	gcc_assert (c_dialect_objc ());
	c_parser_objc_class_declaration (parser);
	break;
	case RID_AT_ALIAS:
	gcc_assert (c_dialect_objc ());
	c_parser_objc_alias_declaration (parser);
	break;
	case RID_AT_PROTOCOL:
	gcc_assert (c_dialect_objc ());
	c_parser_objc_protocol_definition (parser);
	break;
	case RID_AT_END:
	gcc_assert (c_dialect_objc ());
	c_parser_consume_token (parser);
	objc_finish_implementation ();
	break;
	default:
	goto decl_or_fndef;
	}
	break;
	case CPP_SEMICOLON:
	if (pedantic)
	pedwarn ("ISO C does not allow extra %<;%> outside of a function");
	c_parser_consume_token (parser);
	break;
	case CPP_PRAGMA:
	c_parser_pragma (parser, pragma_external);
	break;
	case CPP_PLUS:
	case CPP_MINUS:
	if (c_dialect_objc ())
	{
	c_parser_objc_method_definition (parser);
	break;
	}
	/* Else fall through, and yield a syntax error trying to parse
	as a declaration or function definition. */
	default:
	decl_or_fndef:
	/* A declaration or a function definition. We can only tell
	which after parsing the declaration specifiers, if any, and
	the first declarator. */
	c_parser_declaration_or_fndef (parser, true, true, false, true);
	break;
	}
	}


	/* Parse a declaration or function definition (C90 6.5, 6.7.1, C99
	6.7, 6.9.1). If FNDEF_OK is true, a function definition is
	accepted; otherwise (old-style parameter declarations) only other
	declarations are accepted. If NESTED is true, we are inside a
	function or parsing old-style parameter declarations; any functions
	encountered are nested functions and declaration specifiers are
	required; otherwise we are at top level and functions are normal
	functions and declaration specifiers may be optional. If EMPTY_OK
	is true, empty declarations are OK (subject to all other
	constraints); otherwise (old-style parameter declarations) they are
	diagnosed. If START_ATTR_OK is true, the declaration specifiers
	may start with attributes; otherwise they may not.

	declaration:
	declaration-specifiers init-declarator-list[opt] ;

	function-definition:
	declaration-specifiers[opt] declarator declaration-list[opt]
	compound-statement

	declaration-list:
	declaration
	declaration-list declaration

	init-declarator-list:
	init-declarator
	init-declarator-list , init-declarator

	init-declarator:
	declarator simple-asm-expr[opt] attributes[opt]
	declarator simple-asm-expr[opt] attributes[opt] = initializer

	GNU extensions:

	nested-function-definition:
	declaration-specifiers declarator declaration-list[opt]
	compound-statement

	The simple-asm-expr and attributes are GNU extensions.

	This function does not handle __extension__; that is handled in its
	callers. ??? Following the old parser, __extension__ may start
	external declarations, declarations in functions and declarations
	at the start of "for" loops, but not old-style parameter
	declarations.

	C99 requires declaration specifiers in a function definition; the
	absence is diagnosed through the diagnosis of implicit int. In GNU
	C we also allow but diagnose declarations without declaration
	specifiers, but only at top level (elsewhere they conflict with
	other syntax).

	OpenMP:

	declaration:
	threadprivate-directive */

	static void
	c_parser_declaration_or_fndef (c_parser *parser, bool fndef_ok, bool empty_ok,
	bool nested, bool start_attr_ok)
	{
	struct c_declspecs *specs;
	tree prefix_attrs;
	tree all_prefix_attrs;
	bool diagnosed_no_specs = false;

	specs = build_null_declspecs ();
	c_parser_declspecs (parser, specs, true, true, start_attr_ok);
	if (parser->error)
	{
	c_parser_skip_to_end_of_block_or_statement (parser);
	return;
	}
	if (nested && !specs->declspecs_seen_p)
	{
	c_parser_error (parser, "expected declaration specifiers");
	c_parser_skip_to_end_of_block_or_statement (parser);
	return;
	}
	finish_declspecs (specs);
	if (c_parser_next_token_is (parser, CPP_SEMICOLON))
	{
	if (empty_ok)
	shadow_tag (specs);
	else
	{
	shadow_tag_warned (specs, 1);
	pedwarn ("empty declaration");
	}
	c_parser_consume_token (parser);
	return;
	}
	pending_xref_error ();
	prefix_attrs = specs->attrs;
	all_prefix_attrs = prefix_attrs;
	specs->attrs = NULL_TREE;
	while (true)
	{
	struct c_declarator *declarator;
	bool dummy = false;
	tree fnbody;
	/* Declaring either one or more declarators (in which case we
	should diagnose if there were no declaration specifiers) or a
	function definition (in which case the diagnostic for
	implicit int suffices). */
	declarator = c_parser_declarator (parser, specs->type_seen_p,
	C_DTR_NORMAL, &dummy);
	if (declarator == NULL)
	{
	c_parser_skip_to_end_of_block_or_statement (parser);
	return;
	}
	if (c_parser_next_token_is (parser, CPP_EQ)
	\|\| c_parser_next_token_is (parser, CPP_COMMA)
	\|\| c_parser_next_token_is (parser, CPP_SEMICOLON)
	\|\| c_parser_next_token_is_keyword (parser, RID_ASM)
	\|\| c_parser_next_token_is_keyword (parser, RID_ATTRIBUTE))
	{
	tree asm_name = NULL_TREE;
	tree postfix_attrs = NULL_TREE;
	if (!diagnosed_no_specs && !specs->declspecs_seen_p)
	{
	diagnosed_no_specs = true;
	pedwarn ("data definition has no type or storage class");
	}
	/* Having seen a data definition, there cannot now be a
	function definition. */
	fndef_ok = false;
	if (c_parser_next_token_is_keyword (parser, RID_ASM))
	asm_name = c_parser_simple_asm_expr (parser);
	if (c_parser_next_token_is_keyword (parser, RID_ATTRIBUTE))
	postfix_attrs = c_parser_attributes (parser);
	if (c_parser_next_token_is (parser, CPP_EQ))
	{
	tree d;
	struct c_expr init;
	c_parser_consume_token (parser);
	/* The declaration of the variable is in effect while
	its initializer is parsed. */
	d = start_decl (declarator, specs, true,
	chainon (postfix_attrs, all_prefix_attrs));
	if (!d)
	d = error_mark_node;
	start_init (d, asm_name, global_bindings_p ());
	init = c_parser_initializer (parser);
	finish_init ();
	if (d != error_mark_node)
	{
	maybe_warn_string_init (TREE_TYPE (d), init);
	finish_decl (d, init.value, asm_name);
	}
	}
	else
	{
	tree d = start_decl (declarator, specs, false,
	chainon (postfix_attrs,
	all_prefix_attrs));
	if (d)
	finish_decl (d, NULL_TREE, asm_name);
	}
	if (c_parser_next_token_is (parser, CPP_COMMA))
	{
	c_parser_consume_token (parser);
	if (c_parser_next_token_is_keyword (parser, RID_ATTRIBUTE))
	all_prefix_attrs = chainon (c_parser_attributes (parser),
	prefix_attrs);
	else
	all_prefix_attrs = prefix_attrs;
	continue;
	}
	else if (c_parser_next_token_is (parser, CPP_SEMICOLON))
	{
	c_parser_consume_token (parser);
	return;
	}
	else
	{
	c_parser_error (parser, "expected %<,%> or %<;%>");
	c_parser_skip_to_end_of_block_or_statement (parser);
	return;
	}
	}
	else if (!fndef_ok)
	{
	c_parser_error (parser, "expected %<=%>, %<,%>, %<;%>, "
	"%<asm%> or %<__attribute__%>");
	c_parser_skip_to_end_of_block_or_statement (parser);
	return;
	}
	/* Function definition (nested or otherwise). */
	if (nested)
	{
	if (pedantic)
	pedwarn ("ISO C forbids nested functions");
	push_function_context ();
	}
	if (!start_function (specs, declarator, all_prefix_attrs))
	{
	/* This can appear in many cases looking nothing like a
	function definition, so we don't give a more specific
	error suggesting there was one. */
	c_parser_error (parser, "expected %<=%>, %<,%>, %<;%>, %<asm%> "
	"or %<__attribute__%>");
	if (nested)
	pop_function_context ();
	break;
	}
	/* Parse old-style parameter declarations. ??? Attributes are
	not allowed to start declaration specifiers here because of a
	syntax conflict between a function declaration with attribute
	suffix and a function definition with an attribute prefix on
	first old-style parameter declaration. Following the old
	parser, they are not accepted on subsequent old-style
	parameter declarations either. However, there is no
	ambiguity after the first declaration, nor indeed on the
	first as long as we don't allow postfix attributes after a
	declarator with a nonempty identifier list in a definition;
	and postfix attributes have never been accepted here in
	function definitions either. */
	while (c_parser_next_token_is_not (parser, CPP_EOF)
	&& c_parser_next_token_is_not (parser, CPP_OPEN_BRACE))
	c_parser_declaration_or_fndef (parser, false, false, true, false);
	DECL_SOURCE_LOCATION (current_function_decl)
	= c_parser_peek_token (parser)->location;
	store_parm_decls ();
	fnbody = c_parser_compound_statement (parser);
	if (nested)
	{
	tree decl = current_function_decl;
	add_stmt (fnbody);
	finish_function ();
	pop_function_context ();
	add_stmt (build_stmt (DECL_EXPR, decl));
	}
	else
	{
	add_stmt (fnbody);
	finish_function ();
	}
	break;
	}
	}

	/* Parse an asm-definition (asm() outside a function body). This is a
	GNU extension.

	asm-definition:
	simple-asm-expr ;
	*/

	static void
	c_parser_asm_definition (c_parser *parser)
	{
	tree asm_str = c_parser_simple_asm_expr (parser);
	if (asm_str)
	cgraph_add_asm_node (asm_str);
	c_parser_skip_until_found (parser, CPP_SEMICOLON, "expected %<;%>");
	}

	/* Parse some declaration specifiers (possibly none) (C90 6.5, C99
	6.7), adding them to SPECS (which may already include some).
	Storage class specifiers are accepted iff SCSPEC_OK; type
	specifiers are accepted iff TYPESPEC_OK; attributes are accepted at
	the start iff START_ATTR_OK.

	declaration-specifiers:
	storage-class-specifier declaration-specifiers[opt]
	type-specifier declaration-specifiers[opt]
	type-qualifier declaration-specifiers[opt]
	function-specifier declaration-specifiers[opt]

	Function specifiers (inline) are from C99, and are currently
	handled as storage class specifiers, as is __thread.

	C90 6.5.1, C99 6.7.1:
	storage-class-specifier:
	typedef
	extern
	static
	auto
	register

	C99 6.7.4:
	function-specifier:
	inline

	C90 6.5.2, C99 6.7.2:
	type-specifier:
	void
	char
	short
	int
	long
	float
	double
	signed
	unsigned
	_Bool
	_Complex
	[_Imaginary removed in C99 TC2]
	struct-or-union-specifier
	enum-specifier
	typedef-name

	(_Bool and _Complex are new in C99.)

	C90 6.5.3, C99 6.7.3:

	type-qualifier:
	const
	restrict
	volatile

	(restrict is new in C99.)

	GNU extensions:

	declaration-specifiers:
	attributes declaration-specifiers[opt]

	storage-class-specifier:
	__thread

	type-specifier:
	typeof-specifier
	_Decimal32
	_Decimal64
	_Decimal128

	Objective-C:

	type-specifier:
	class-name objc-protocol-refs[opt]
	typedef-name objc-protocol-refs
	objc-protocol-refs
	*/

	static void
	c_parser_declspecs (c_parser parser, struct c_declspecs specs,
	bool scspec_ok, bool typespec_ok, bool start_attr_ok)
	{
	bool attrs_ok = start_attr_ok;
	bool seen_type = specs->type_seen_p;
	while (c_parser_next_token_is (parser, CPP_NAME)
	\|\| c_parser_next_token_is (parser, CPP_KEYWORD)
	\|\| (c_dialect_objc () && c_parser_next_token_is (parser, CPP_LESS)))
	{
	struct c_typespec t;
	tree attrs;
	if (c_parser_next_token_is (parser, CPP_NAME))
	{
	tree value = c_parser_peek_token (parser)->value;
	c_id_kind kind = c_parser_peek_token (parser)->id_kind;
	/* This finishes the specifiers unless a type name is OK, it
	is declared as a type name and a type name hasn't yet
	been seen. */
	if (!typespec_ok \|\| seen_type
	\|\| (kind != C_ID_TYPENAME && kind != C_ID_CLASSNAME))
	break;
	c_parser_consume_token (parser);
	seen_type = true;
	attrs_ok = true;
	if (kind == C_ID_TYPENAME
	&& (!c_dialect_objc ()
	\|\| c_parser_next_token_is_not (parser, CPP_LESS)))
	{
	t.kind = ctsk_typedef;
	/* For a typedef name, record the meaning, not the name.
	In case of 'foo foo, bar;'. */
	t.spec = lookup_name (value);
	}
	else
	{
	tree proto = NULL_TREE;
	gcc_assert (c_dialect_objc ());
	t.kind = ctsk_objc;
	if (c_parser_next_token_is (parser, CPP_LESS))
	proto = c_parser_objc_protocol_refs (parser);
	t.spec = objc_get_protocol_qualified_type (value, proto);
	}
	declspecs_add_type (specs, t);
	continue;
	}
	if (c_parser_next_token_is (parser, CPP_LESS))
	{
	/* Make "<SomeProtocol>" equivalent to "id <SomeProtocol>" -
	nisse@lysator.liu.se. */
	tree proto;
	gcc_assert (c_dialect_objc ());
	if (!typespec_ok \|\| seen_type)
	break;
	proto = c_parser_objc_protocol_refs (parser);
	t.kind = ctsk_objc;
	t.spec = objc_get_protocol_qualified_type (NULL_TREE, proto);
	declspecs_add_type (specs, t);
	continue;
	}
	gcc_assert (c_parser_next_token_is (parser, CPP_KEYWORD));
	switch (c_parser_peek_token (parser)->keyword)
	{
	case RID_STATIC:
	case RID_EXTERN:
	case RID_REGISTER:
	case RID_TYPEDEF:
	case RID_INLINE:
	case RID_AUTO:
	case RID_THREAD:
	if (!scspec_ok)
	goto out;
	attrs_ok = true;
	/* TODO: Distinguish between function specifiers (inline)
	and storage class specifiers, either here or in
	declspecs_add_scspec. */
	declspecs_add_scspec (specs, c_parser_peek_token (parser)->value);
	c_parser_consume_token (parser);
	break;
	case RID_UNSIGNED:
	case RID_LONG:
	case RID_SHORT:
	case RID_SIGNED:
	case RID_COMPLEX:
	case RID_INT:
	case RID_CHAR:
	case RID_FLOAT:
	case RID_DOUBLE:
	case RID_VOID:
	case RID_DFLOAT32:
	case RID_DFLOAT64:
	case RID_DFLOAT128:
	case RID_BOOL:
	if (!typespec_ok)
	goto out;
	attrs_ok = true;
	seen_type = true;
	OBJC_NEED_RAW_IDENTIFIER (1);
	t.kind = ctsk_resword;
	t.spec = c_parser_peek_token (parser)->value;
	declspecs_add_type (specs, t);
	c_parser_consume_token (parser);
	break;
	case RID_ENUM:
	if (!typespec_ok)
	goto out;
	attrs_ok = true;
	seen_type = true;
	t = c_parser_enum_specifier (parser);
	declspecs_add_type (specs, t);
	break;
	case RID_STRUCT:
	case RID_UNION:
	if (!typespec_ok)
	goto out;
	attrs_ok = true;
	seen_type = true;
	t = c_parser_struct_or_union_specifier (parser);
	declspecs_add_type (specs, t);
	break;
	case RID_TYPEOF:
	/* ??? The old parser rejected typeof after other type
	specifiers, but is a syntax error the best way of
	handling this? */
	if (!typespec_ok \|\| seen_type)
	goto out;
	attrs_ok = true;
	seen_type = true;
	t = c_parser_typeof_specifier (parser);
	declspecs_add_type (specs, t);
	break;
	case RID_CONST:
	case RID_VOLATILE:
	case RID_RESTRICT:
	attrs_ok = true;
	declspecs_add_qual (specs, c_parser_peek_token (parser)->value);
	c_parser_consume_token (parser);
	break;
	case RID_ATTRIBUTE:
	if (!attrs_ok)
	goto out;
	attrs = c_parser_attributes (parser);
	declspecs_add_attrs (specs, attrs);
	break;
	default:
	goto out;
	}
	}
	out: ;
	}

	/* Parse an enum specifier (C90 6.5.2.2, C99 6.7.2.2).

	enum-specifier:
	enum attributes[opt] identifier[opt] { enumerator-list } attributes[opt]
	enum attributes[opt] identifier[opt] { enumerator-list , } attributes[opt]
	enum attributes[opt] identifier

	The form with trailing comma is new in C99. The forms with
	attributes are GNU extensions. In GNU C, we accept any expression
	without commas in the syntax (assignment expressions, not just
	conditional expressions); assignment expressions will be diagnosed
	as non-constant.

	enumerator-list:
	enumerator
	enumerator-list , enumerator

	enumerator:
	enumeration-constant
	enumeration-constant = constant-expression
	*/

	static struct c_typespec
	c_parser_enum_specifier (c_parser *parser)
	{
	struct c_typespec ret;
	tree attrs;
	tree ident = NULL_TREE;
	gcc_assert (c_parser_next_token_is_keyword (parser, RID_ENUM));
	c_parser_consume_token (parser);
	attrs = c_parser_attributes (parser);
	if (c_parser_next_token_is (parser, CPP_NAME))
	{
	ident = c_parser_peek_token (parser)->value;
	c_parser_consume_token (parser);
	}
	if (c_parser_next_token_is (parser, CPP_OPEN_BRACE))
	{
	/* Parse an enum definition. */
	tree type = start_enum (ident);
	tree postfix_attrs;
	/* We chain the enumerators in reverse order, then put them in
	forward order at the end. */
	tree values = NULL_TREE;
	c_parser_consume_token (parser);
	while (true)
	{
	tree enum_id;
	tree enum_value;
	tree enum_decl;
	bool seen_comma;
	if (c_parser_next_token_is_not (parser, CPP_NAME))
	{
	c_parser_error (parser, "expected identifier");
	c_parser_skip_until_found (parser, CPP_CLOSE_BRACE, NULL);
	values = error_mark_node;
	break;
	}
	enum_id = c_parser_peek_token (parser)->value;
	c_parser_consume_token (parser);
	if (c_parser_next_token_is (parser, CPP_EQ))
	{
	c_parser_consume_token (parser);
	enum_value = c_parser_expr_no_commas (parser, NULL).value;
	}
	else
	enum_value = NULL_TREE;
	enum_decl = build_enumerator (enum_id, enum_value);
	TREE_CHAIN (enum_decl) = values;
	values = enum_decl;
	seen_comma = false;
	if (c_parser_next_token_is (parser, CPP_COMMA))
	{
	seen_comma = true;
	c_parser_consume_token (parser);
	}
	if (c_parser_next_token_is (parser, CPP_CLOSE_BRACE))
	{
	if (seen_comma && pedantic && !flag_isoc99)
	pedwarn ("comma at end of enumerator list");
	c_parser_consume_token (parser);
	break;
	}
	if (!seen_comma)
	{
	c_parser_error (parser, "expected %<,%> or %<}%>");
	c_parser_skip_until_found (parser, CPP_CLOSE_BRACE, NULL);
	values = error_mark_node;
	break;
	}
	}
	postfix_attrs = c_parser_attributes (parser);
	ret.spec = finish_enum (type, nreverse (values),
	chainon (attrs, postfix_attrs));
	ret.kind = ctsk_tagdef;
	return ret;
	}
	else if (!ident)
	{
	c_parser_error (parser, "expected %<{%>");
	ret.spec = error_mark_node;
	ret.kind = ctsk_tagref;
	return ret;
	}
	ret = parser_xref_tag (ENUMERAL_TYPE, ident);
	/* In ISO C, enumerated types can be referred to only if already
	defined. */
	if (pedantic && !COMPLETE_TYPE_P (ret.spec))
	pedwarn ("ISO C forbids forward references to %<enum%> types");
	return ret;
	}

	/* Parse a struct or union specifier (C90 6.5.2.1, C99 6.7.2.1).

	struct-or-union-specifier:
	struct-or-union attributes[opt] identifier[opt]
	{ struct-contents } attributes[opt]
	struct-or-union attributes[opt] identifier

	struct-contents:
	struct-declaration-list

	struct-declaration-list:
	struct-declaration ;
	struct-declaration-list struct-declaration ;

	GNU extensions:

	struct-contents:
	empty
	struct-declaration
	struct-declaration-list struct-declaration

	struct-declaration-list:
	struct-declaration-list ;
	;

	(Note that in the syntax here, unlike that in ISO C, the semicolons
	are included here rather than in struct-declaration, in order to
	describe the syntax with extra semicolons and missing semicolon at
	end.)

	Objective-C:

	struct-declaration-list:
	@defs ( class-name )

	(Note this does not include a trailing semicolon, but can be
	followed by further declarations, and gets a pedwarn-if-pedantic
	when followed by a semicolon.) */

	static struct c_typespec
	c_parser_struct_or_union_specifier (c_parser *parser)
	{
	struct c_typespec ret;
	tree attrs;
	tree ident = NULL_TREE;
	enum tree_code code;
	switch (c_parser_peek_token (parser)->keyword)
	{
	case RID_STRUCT:
	code = RECORD_TYPE;
	break;
	case RID_UNION:
	code = UNION_TYPE;
	break;
	default:
	gcc_unreachable ();
	}
	c_parser_consume_token (parser);
	attrs = c_parser_attributes (parser);
	if (c_parser_next_token_is (parser, CPP_NAME))
	{
	ident = c_parser_peek_token (parser)->value;
	c_parser_consume_token (parser);
	}
	if (c_parser_next_token_is (parser, CPP_OPEN_BRACE))
	{
	/* Parse a struct or union definition. Start the scope of the
	tag before parsing components. */
	tree type = start_struct (code, ident);
	tree postfix_attrs;
	/* We chain the components in reverse order, then put them in
	forward order at the end. Each struct-declaration may
	declare multiple components (comma-separated), so we must use
	chainon to join them, although when parsing each
	struct-declaration we can use TREE_CHAIN directly.

	The theory behind all this is that there will be more
	semicolon separated fields than comma separated fields, and
	so we'll be minimizing the number of node traversals required
	by chainon. */
	tree contents = NULL_TREE;
	c_parser_consume_token (parser);
	/* Handle the Objective-C @defs construct,
	e.g. foo(sizeof(struct{ @defs(ClassName) }));. */
	if (c_parser_next_token_is_keyword (parser, RID_AT_DEFS))
	{
	tree name;
	gcc_assert (c_dialect_objc ());
	c_parser_consume_token (parser);
	if (!c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>"))
	goto end_at_defs;
	if (c_parser_next_token_is (parser, CPP_NAME)
	&& c_parser_peek_token (parser)->id_kind == C_ID_CLASSNAME)
	{
	name = c_parser_peek_token (parser)->value;
	c_parser_consume_token (parser);
	}
	else
	{
	c_parser_error (parser, "expected class name");
	c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, NULL);
	goto end_at_defs;
	}
	c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
	"expected %<)%>");
	contents = nreverse (objc_get_class_ivars (name));
	}
	end_at_defs:
	/* Parse the struct-declarations and semicolons. Problems with
	semicolons are diagnosed here; empty structures are diagnosed
	elsewhere. */
	while (true)
	{
	tree decls;
	/* Parse any stray semicolon. */
	if (c_parser_next_token_is (parser, CPP_SEMICOLON))
	{
	if (pedantic)
	pedwarn ("extra semicolon in struct or union specified");
	c_parser_consume_token (parser);
	continue;
	}
	/* Stop if at the end of the struct or union contents. */
	if (c_parser_next_token_is (parser, CPP_CLOSE_BRACE))
	{
	c_parser_consume_token (parser);
	break;
	}
	/* Accept #pragmas at struct scope. */
	if (c_parser_next_token_is (parser, CPP_PRAGMA))
	{
	c_parser_pragma (parser, pragma_external);
	continue;
	}
	/* Parse some comma-separated declarations, but not the
	trailing semicolon if any. */
	decls = c_parser_struct_declaration (parser);
	contents = chainon (decls, contents);
	/* If no semicolon follows, either we have a parse error or
	are at the end of the struct or union and should
	pedwarn. */
	if (c_parser_next_token_is (parser, CPP_SEMICOLON))
	c_parser_consume_token (parser);
	else
	{
	if (c_parser_next_token_is (parser, CPP_CLOSE_BRACE))
	pedwarn ("no semicolon at end of struct or union");
	else
	{
	c_parser_error (parser, "expected %<;%>");
	c_parser_skip_until_found (parser, CPP_CLOSE_BRACE, NULL);
	break;
	}
	}
	}
	postfix_attrs = c_parser_attributes (parser);
	ret.spec = finish_struct (type, nreverse (contents),
	chainon (attrs, postfix_attrs));
	ret.kind = ctsk_tagdef;
	return ret;
	}
	else if (!ident)
	{
	c_parser_error (parser, "expected %<{%>");
	ret.spec = error_mark_node;
	ret.kind = ctsk_tagref;
	return ret;
	}
	ret = parser_xref_tag (code, ident);
	return ret;
	}

	/* Parse a struct-declaration (C90 6.5.2.1, C99 6.7.2.1), without
	the trailing semicolon.

	struct-declaration:
	specifier-qualifier-list struct-declarator-list

	specifier-qualifier-list:
	type-specifier specifier-qualifier-list[opt]
	type-qualifier specifier-qualifier-list[opt]
	attributes specifier-qualifier-list[opt]

	struct-declarator-list:
	struct-declarator
	struct-declarator-list , attributes[opt] struct-declarator

	struct-declarator:
	declarator attributes[opt]
	declarator[opt] : constant-expression attributes[opt]

	GNU extensions:

	struct-declaration:
	__extension__ struct-declaration
	specifier-qualifier-list

	Unlike the ISO C syntax, semicolons are handled elsewhere. The use
	of attributes where shown is a GNU extension. In GNU C, we accept
	any expression without commas in the syntax (assignment
	expressions, not just conditional expressions); assignment
	expressions will be diagnosed as non-constant. */

	static tree
	c_parser_struct_declaration (c_parser *parser)
	{
	struct c_declspecs *specs;
	tree prefix_attrs;
	tree all_prefix_attrs;
	tree decls;
	if (c_parser_next_token_is_keyword (parser, RID_EXTENSION))
	{
	int ext;
	tree decl;
	ext = disable_extension_diagnostics ();
	c_parser_consume_token (parser);
	decl = c_parser_struct_declaration (parser);
	restore_extension_diagnostics (ext);
	return decl;
	}
	specs = build_null_declspecs ();
	c_parser_declspecs (parser, specs, false, true, true);
	if (parser->error)
	return NULL_TREE;
	if (!specs->declspecs_seen_p)
	{
	c_parser_error (parser, "expected specifier-qualifier-list");
	return NULL_TREE;
	}
	finish_declspecs (specs);
	if (c_parser_next_token_is (parser, CPP_SEMICOLON))
	{
	tree ret;
	if (!specs->type_seen_p)
	{
	if (pedantic)
	pedwarn ("ISO C forbids member declarations with no members");
	shadow_tag_warned (specs, pedantic);
	ret = NULL_TREE;
	}
	else
	{
	/* Support for unnamed structs or unions as members of
	structs or unions (which is [a] useful and [b] supports
	MS P-SDK). */
	ret = grokfield (build_id_declarator (NULL_TREE), specs, NULL_TREE);
	}
	return ret;
	}
	pending_xref_error ();
	prefix_attrs = specs->attrs;
	all_prefix_attrs = prefix_attrs;
	specs->attrs = NULL_TREE;
	decls = NULL_TREE;
	while (true)
	{
	/* Declaring one or more declarators or un-named bit-fields. */
	struct c_declarator *declarator;
	bool dummy = false;
	if (c_parser_next_token_is (parser, CPP_COLON))
	declarator = build_id_declarator (NULL_TREE);
	else
	declarator = c_parser_declarator (parser, specs->type_seen_p,
	C_DTR_NORMAL, &dummy);
	if (declarator == NULL)
	{
	c_parser_skip_to_end_of_block_or_statement (parser);
	break;
	}
	if (c_parser_next_token_is (parser, CPP_COLON)
	\|\| c_parser_next_token_is (parser, CPP_COMMA)
	\|\| c_parser_next_token_is (parser, CPP_SEMICOLON)
	\|\| c_parser_next_token_is (parser, CPP_CLOSE_BRACE)
	\|\| c_parser_next_token_is_keyword (parser, RID_ATTRIBUTE))
	{
	tree postfix_attrs = NULL_TREE;
	tree width = NULL_TREE;
	tree d;
	if (c_parser_next_token_is (parser, CPP_COLON))
	{
	c_parser_consume_token (parser);
	width = c_parser_expr_no_commas (parser, NULL).value;
	}
	if (c_parser_next_token_is_keyword (parser, RID_ATTRIBUTE))
	postfix_attrs = c_parser_attributes (parser);
	d = grokfield (declarator, specs, width);
	decl_attributes (&d, chainon (postfix_attrs,
	all_prefix_attrs), 0);
	TREE_CHAIN (d) = decls;
	decls = d;
	if (c_parser_next_token_is_keyword (parser, RID_ATTRIBUTE))
	all_prefix_attrs = chainon (c_parser_attributes (parser),
	prefix_attrs);
	else
	all_prefix_attrs = prefix_attrs;
	if (c_parser_next_token_is (parser, CPP_COMMA))
	c_parser_consume_token (parser);
	else if (c_parser_next_token_is (parser, CPP_SEMICOLON)
	\|\| c_parser_next_token_is (parser, CPP_CLOSE_BRACE))
	{
	/* Semicolon consumed in caller. */
	break;
	}
	else
	{
	c_parser_error (parser, "expected %<,%>, %<;%> or %<}%>");
	break;
	}
	}
	else
	{
	c_parser_error (parser,
	"expected %<:%>, %<,%>, %<;%>, %<}%> or "
	"%<__attribute__%>");
	break;
	}
	}
	return decls;
	}

	/* Parse a typeof specifier (a GNU extension).

	typeof-specifier:
	typeof ( expression )
	typeof ( type-name )
	*/

	static struct c_typespec
	c_parser_typeof_specifier (c_parser *parser)
	{
	struct c_typespec ret;
	ret.kind = ctsk_typeof;
	ret.spec = error_mark_node;
	gcc_assert (c_parser_next_token_is_keyword (parser, RID_TYPEOF));
	c_parser_consume_token (parser);
	skip_evaluation++;
	in_typeof++;
	if (!c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>"))
	{
	skip_evaluation--;
	in_typeof--;
	return ret;
	}
	if (c_parser_next_token_starts_typename (parser))
	{
	struct c_type_name *type = c_parser_type_name (parser);
	skip_evaluation--;
	in_typeof--;
	if (type != NULL)
	{
	ret.spec = groktypename (type);
	pop_maybe_used (variably_modified_type_p (ret.spec, NULL_TREE));
	}
	}
	else
	{
	bool was_vm;
	struct c_expr expr = c_parser_expression (parser);
	skip_evaluation--;
	in_typeof--;
	if (TREE_CODE (expr.value) == COMPONENT_REF
	&& DECL_C_BIT_FIELD (TREE_OPERAND (expr.value, 1)))
	error ("%<typeof%> applied to a bit-field");
	ret.spec = TREE_TYPE (expr.value);
	was_vm = variably_modified_type_p (ret.spec, NULL_TREE);
	/* This should be returned with the type so that when the type
	is evaluated, this can be evaluated. For now, we avoid
	evaluation when the context might. */
	if (!skip_evaluation && was_vm)
	{
	tree e = expr.value;

	/* If the expression is not of a type to which we cannot assign a line
	number, wrap the thing in a no-op NOP_EXPR. */
	if (DECL_P (e) \|\| CONSTANT_CLASS_P (e))
	e = build1 (NOP_EXPR, void_type_node, e);

	if (EXPR_P (e))
	SET_EXPR_LOCATION (e, input_location);

	add_stmt (e);
	}
	pop_maybe_used (was_vm);
	}
	c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, "expected %<)%>");
	return ret;
	}

	/* Parse a declarator, possibly an abstract declarator (C90 6.5.4,
	6.5.5, C99 6.7.5, 6.7.6). If TYPE_SEEN_P then a typedef name may
	be redeclared; otherwise it may not. KIND indicates which kind of
	declarator is wanted. Returns a valid declarator except in the
	case of a syntax error in which case NULL is returned. *SEEN_ID is
	set to true if an identifier being declared is seen; this is used
	to diagnose bad forms of abstract array declarators and to
	determine whether an identifier list is syntactically permitted.

	declarator:
	pointer[opt] direct-declarator

	direct-declarator:
	identifier
	( attributes[opt] declarator )
	direct-declarator array-declarator
	direct-declarator ( parameter-type-list )
	direct-declarator ( identifier-list[opt] )

	pointer:
	* type-qualifier-list[opt]
	* type-qualifier-list[opt] pointer

	type-qualifier-list:
	type-qualifier
	attributes
	type-qualifier-list type-qualifier
	type-qualifier-list attributes

	parameter-type-list:
	parameter-list
	parameter-list , ...

	parameter-list:
	parameter-declaration
	parameter-list , parameter-declaration

	parameter-declaration:
	declaration-specifiers declarator attributes[opt]
	declaration-specifiers abstract-declarator[opt] attributes[opt]

	identifier-list:
	identifier
	identifier-list , identifier

	abstract-declarator:
	pointer
	pointer[opt] direct-abstract-declarator

	direct-abstract-declarator:
	( attributes[opt] abstract-declarator )
	direct-abstract-declarator[opt] array-declarator
	direct-abstract-declarator[opt] ( parameter-type-list[opt] )

	GNU extensions:

	direct-declarator:
	direct-declarator ( parameter-forward-declarations
	parameter-type-list[opt] )

	direct-abstract-declarator:
	direct-abstract-declarator[opt] ( parameter-forward-declarations
	parameter-type-list[opt] )

	parameter-forward-declarations:
	parameter-list ;
	parameter-forward-declarations parameter-list ;

	The uses of attributes shown above are GNU extensions.

	Some forms of array declarator are not included in C99 in the
	syntax for abstract declarators; these are disallowed elsewhere.
	This may be a defect (DR#289).

	This function also accepts an omitted abstract declarator as being
	an abstract declarator, although not part of the formal syntax. */

	static struct c_declarator *
	c_parser_declarator (c_parser *parser, bool type_seen_p, c_dtr_syn kind,
	bool *seen_id)
	{
	/* Parse any initial pointer part. */
	if (c_parser_next_token_is (parser, CPP_MULT))
	{
	struct c_declspecs *quals_attrs = build_null_declspecs ();
	struct c_declarator *inner;
	c_parser_consume_token (parser);
	c_parser_declspecs (parser, quals_attrs, false, false, true);
	inner = c_parser_declarator (parser, type_seen_p, kind, seen_id);
	if (inner == NULL)
	return NULL;
	else
	return make_pointer_declarator (quals_attrs, inner);
	}
	/* Now we have a direct declarator, direct abstract declarator or
	nothing (which counts as a direct abstract declarator here). */
	return c_parser_direct_declarator (parser, type_seen_p, kind, seen_id);
	}

	/* Parse a direct declarator or direct abstract declarator; arguments
	as c_parser_declarator. */

	static struct c_declarator *
	c_parser_direct_declarator (c_parser *parser, bool type_seen_p, c_dtr_syn kind,
	bool *seen_id)
	{
	/* The direct declarator must start with an identifier (possibly
	omitted) or a parenthesized declarator (possibly abstract). In
	an ordinary declarator, initial parentheses must start a
	parenthesized declarator. In an abstract declarator or parameter
	declarator, they could start a parenthesized declarator or a
	parameter list. To tell which, the open parenthesis and any
	following attributes must be read. If a declaration specifier
	follows, then it is a parameter list; if the specifier is a
	typedef name, there might be an ambiguity about redeclaring it,
	which is resolved in the direction of treating it as a typedef
	name. If a close parenthesis follows, it is also an empty
	parameter list, as the syntax does not permit empty abstract
	declarators. Otherwise, it is a parenthesized declarator (in
	which case the analysis may be repeated inside it, recursively).

	??? There is an ambiguity in a parameter declaration "int
	(__attribute__((foo)) x)", where x is not a typedef name: it
	could be an abstract declarator for a function, or declare x with
	parentheses. The proper resolution of this ambiguity needs
	documenting. At present we follow an accident of the old
	parser's implementation, whereby the first parameter must have
	some declaration specifiers other than just attributes. Thus as
	a parameter declaration it is treated as a parenthesized
	parameter named x, and as an abstract declarator it is
	rejected.

	??? Also following the old parser, attributes inside an empty
	parameter list are ignored, making it a list not yielding a
	prototype, rather than giving an error or making it have one
	parameter with implicit type int.

	??? Also following the old parser, typedef names may be
	redeclared in declarators, but not Objective-C class names. */

	if (kind != C_DTR_ABSTRACT
	&& c_parser_next_token_is (parser, CPP_NAME)
	&& ((type_seen_p
	&& c_parser_peek_token (parser)->id_kind == C_ID_TYPENAME)
	\|\| c_parser_peek_token (parser)->id_kind == C_ID_ID))
	{
	struct c_declarator *inner
	= build_id_declarator (c_parser_peek_token (parser)->value);
	*seen_id = true;
	inner->id_loc = c_parser_peek_token (parser)->location;
	c_parser_consume_token (parser);
	return c_parser_direct_declarator_inner (parser, *seen_id, inner);
	}

	if (kind != C_DTR_NORMAL
	&& c_parser_next_token_is (parser, CPP_OPEN_SQUARE))
	{
	struct c_declarator *inner = build_id_declarator (NULL_TREE);
	return c_parser_direct_declarator_inner (parser, *seen_id, inner);
	}

	/* Either we are at the end of an abstract declarator, or we have
	parentheses. */

	if (c_parser_next_token_is (parser, CPP_OPEN_PAREN))
	{
	tree attrs;
	struct c_declarator *inner;
	c_parser_consume_token (parser);
	attrs = c_parser_attributes (parser);
	if (kind != C_DTR_NORMAL
	&& (c_parser_next_token_starts_declspecs (parser)
	\|\| c_parser_next_token_is (parser, CPP_CLOSE_PAREN)))
	{
	struct c_arg_info *args
	= c_parser_parms_declarator (parser, kind == C_DTR_NORMAL,
	attrs);
	if (args == NULL)
	return NULL;
	else
	{
	inner
	= build_function_declarator (args,
	build_id_declarator (NULL_TREE));
	return c_parser_direct_declarator_inner (parser, *seen_id,
	inner);
	}
	}
	/* A parenthesized declarator. */
	inner = c_parser_declarator (parser, type_seen_p, kind, seen_id);
	if (inner != NULL && attrs != NULL)
	inner = build_attrs_declarator (attrs, inner);
	if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN))
	{
	c_parser_consume_token (parser);
	if (inner == NULL)
	return NULL;
	else
	return c_parser_direct_declarator_inner (parser, *seen_id, inner);
	}
	else
	{
	c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
	"expected %<)%>");
	return NULL;
	}
	}
	else
	{
	if (kind == C_DTR_NORMAL)
	{
	c_parser_error (parser, "expected identifier or %<(%>");
	return NULL;
	}
	else
	return build_id_declarator (NULL_TREE);
	}
	}

	/* Parse part of a direct declarator or direct abstract declarator,
	given that some (in INNER) has already been parsed; ID_PRESENT is
	true if an identifier is present, false for an abstract
	declarator. */

	static struct c_declarator *
	c_parser_direct_declarator_inner (c_parser *parser, bool id_present,
	struct c_declarator *inner)
	{
	/* Parse a sequence of array declarators and parameter lists. */
	if (c_parser_next_token_is (parser, CPP_OPEN_SQUARE))
	{
	struct c_declarator *declarator;
	struct c_declspecs *quals_attrs = build_null_declspecs ();
	bool static_seen;
	bool star_seen;
	tree dimen;
	c_parser_consume_token (parser);
	c_parser_declspecs (parser, quals_attrs, false, false, true);
	static_seen = c_parser_next_token_is_keyword (parser, RID_STATIC);
	if (static_seen)
	c_parser_consume_token (parser);
	if (static_seen && !quals_attrs->declspecs_seen_p)
	c_parser_declspecs (parser, quals_attrs, false, false, true);
	if (!quals_attrs->declspecs_seen_p)
	quals_attrs = NULL;
	/* If "static" is present, there must be an array dimension.
	Otherwise, there may be a dimension, "*", or no
	dimension. */
	if (static_seen)
	{
	star_seen = false;
	dimen = c_parser_expr_no_commas (parser, NULL).value;
	}
	else
	{
	if (c_parser_next_token_is (parser, CPP_CLOSE_SQUARE))
	{
	dimen = NULL_TREE;
	star_seen = false;
	}
	else if (c_parser_next_token_is (parser, CPP_MULT))
	{
	if (c_parser_peek_2nd_token (parser)->type == CPP_CLOSE_SQUARE)
	{
	dimen = NULL_TREE;
	star_seen = true;
	c_parser_consume_token (parser);
	}
	else
	{
	star_seen = false;
	dimen = c_parser_expr_no_commas (parser, NULL).value;
	}
	}
	else
	{
	star_seen = false;
	dimen = c_parser_expr_no_commas (parser, NULL).value;
	}
	}
	if (c_parser_next_token_is (parser, CPP_CLOSE_SQUARE))
	c_parser_consume_token (parser);
	else
	{
	c_parser_skip_until_found (parser, CPP_CLOSE_SQUARE,
	"expected %<]%>");
	return NULL;
	}
	declarator = build_array_declarator (dimen, quals_attrs, static_seen,
	star_seen);
	if (declarator == NULL)
	return NULL;
	inner = set_array_declarator_inner (declarator, inner, !id_present);
	return c_parser_direct_declarator_inner (parser, id_present, inner);
	}
	else if (c_parser_next_token_is (parser, CPP_OPEN_PAREN))
	{
	tree attrs;
	struct c_arg_info *args;
	c_parser_consume_token (parser);
	attrs = c_parser_attributes (parser);
	args = c_parser_parms_declarator (parser, id_present, attrs);
	if (args == NULL)
	return NULL;
	else
	{
	inner = build_function_declarator (args, inner);
	return c_parser_direct_declarator_inner (parser, id_present, inner);
	}
	}
	return inner;
	}

	/* Parse a parameter list or identifier list, including the closing
	parenthesis but not the opening one. ATTRS are the attributes at
	the start of the list. ID_LIST_OK is true if an identifier list is
	acceptable; such a list must not have attributes at the start. */

	static struct c_arg_info *
	c_parser_parms_declarator (c_parser *parser, bool id_list_ok, tree attrs)
	{
	push_scope ();
	declare_parm_level ();
	/* If the list starts with an identifier, it is an identifier list.
	Otherwise, it is either a prototype list or an empty list. */
	if (id_list_ok
	&& !attrs
	&& c_parser_next_token_is (parser, CPP_NAME)
	&& c_parser_peek_token (parser)->id_kind == C_ID_ID)
	{
	tree list = NULL_TREE, *nextp = &list;
	while (c_parser_next_token_is (parser, CPP_NAME)
	&& c_parser_peek_token (parser)->id_kind == C_ID_ID)
	{
	*nextp = build_tree_list (NULL_TREE,
	c_parser_peek_token (parser)->value);
	nextp = & TREE_CHAIN (*nextp);
	c_parser_consume_token (parser);
	if (c_parser_next_token_is_not (parser, CPP_COMMA))
	break;
	c_parser_consume_token (parser);
	if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN))
	{
	c_parser_error (parser, "expected identifier");
	break;
	}
	}
	if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN))
	{
	struct c_arg_info *ret = XOBNEW (&parser_obstack, struct c_arg_info);
	ret->parms = 0;
	ret->tags = 0;
	ret->types = list;
	ret->others = 0;
	ret->pending_sizes = 0;
	ret->had_vla_unspec = 0;
	c_parser_consume_token (parser);
	pop_scope ();
	return ret;
	}
	else
	{
	c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
	"expected %<)%>");
	pop_scope ();
	return NULL;
	}
	}
	else
	{
	struct c_arg_info *ret = c_parser_parms_list_declarator (parser, attrs);
	pop_scope ();
	return ret;
	}
	}

	/* Parse a parameter list (possibly empty), including the closing
	parenthesis but not the opening one. ATTRS are the attributes at
	the start of the list. */

	static struct c_arg_info *
	c_parser_parms_list_declarator (c_parser *parser, tree attrs)
	{
	bool good_parm = false;
	/* ??? Following the old parser, forward parameter declarations may
	use abstract declarators, and if no real parameter declarations
	follow the forward declarations then this is not diagnosed. Also
	note as above that attributes are ignored as the only contents of
	the parentheses, or as the only contents after forward
	declarations. */
	if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN))
	{
	struct c_arg_info *ret = XOBNEW (&parser_obstack, struct c_arg_info);
	ret->parms = 0;
	ret->tags = 0;
	ret->types = 0;
	ret->others = 0;
	ret->pending_sizes = 0;
	ret->had_vla_unspec = 0;
	c_parser_consume_token (parser);
	return ret;
	}
	if (c_parser_next_token_is (parser, CPP_ELLIPSIS))
	{
	struct c_arg_info *ret = XOBNEW (&parser_obstack, struct c_arg_info);
	ret->parms = 0;
	ret->tags = 0;
	ret->others = 0;
	ret->pending_sizes = 0;
	ret->had_vla_unspec = 0;
	/* Suppress -Wold-style-definition for this case. */
	ret->types = error_mark_node;
	error ("ISO C requires a named argument before %<...%>");
	c_parser_consume_token (parser);
	if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN))
	{
	c_parser_consume_token (parser);
	return ret;
	}
	else
	{
	c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
	"expected %<)%>");
	return NULL;
	}
	}
	/* Nonempty list of parameters, either terminated with semicolon
	(forward declarations; recurse) or with close parenthesis (normal
	function) or with ", ... )" (variadic function). */
	while (true)
	{
	/* Parse a parameter. */
	struct c_parm *parm = c_parser_parameter_declaration (parser, attrs);
	attrs = NULL_TREE;
	if (parm != NULL)
	{
	good_parm = true;
	push_parm_decl (parm);
	}
	if (c_parser_next_token_is (parser, CPP_SEMICOLON))
	{
	tree new_attrs;
	c_parser_consume_token (parser);
	mark_forward_parm_decls ();
	new_attrs = c_parser_attributes (parser);
	return c_parser_parms_list_declarator (parser, new_attrs);
	}
	if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN))
	{
	c_parser_consume_token (parser);
	if (good_parm)
	return get_parm_info (false);
	else
	{
	struct c_arg_info *ret
	= XOBNEW (&parser_obstack, struct c_arg_info);
	ret->parms = 0;
	ret->tags = 0;
	ret->types = 0;
	ret->others = 0;
	ret->pending_sizes = 0;
	ret->had_vla_unspec = 0;
	return ret;
	}
	}
	if (!c_parser_require (parser, CPP_COMMA,
	"expected %<;%>, %<,%> or %<)%>"))
	{
	c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, NULL);
	return NULL;
	}
	if (c_parser_next_token_is (parser, CPP_ELLIPSIS))
	{
	c_parser_consume_token (parser);
	if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN))
	{
	c_parser_consume_token (parser);
	if (good_parm)
	return get_parm_info (true);
	else
	{
	struct c_arg_info *ret
	= XOBNEW (&parser_obstack, struct c_arg_info);
	ret->parms = 0;
	ret->tags = 0;
	ret->types = 0;
	ret->others = 0;
	ret->pending_sizes = 0;
	ret->had_vla_unspec = 0;
	return ret;
	}
	}
	else
	{
	c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
	"expected %<)%>");
	return NULL;
	}
	}
	}
	}

	/* Parse a parameter declaration. ATTRS are the attributes at the
	start of the declaration if it is the first parameter. */

	static struct c_parm *
	c_parser_parameter_declaration (c_parser *parser, tree attrs)
	{
	struct c_declspecs *specs;
	struct c_declarator *declarator;
	tree prefix_attrs;
	tree postfix_attrs = NULL_TREE;
	bool dummy = false;
	if (!c_parser_next_token_starts_declspecs (parser))
	{
	/* ??? In some Objective-C cases '...' isn't applicable so there
	should be a different message. */
	c_parser_error (parser,
	"expected declaration specifiers or %<...%>");
	c_parser_skip_to_end_of_parameter (parser);
	return NULL;
	}
	specs = build_null_declspecs ();
	if (attrs)
	{
	declspecs_add_attrs (specs, attrs);
	attrs = NULL_TREE;
	}
	c_parser_declspecs (parser, specs, true, true, true);
	finish_declspecs (specs);
	pending_xref_error ();
	prefix_attrs = specs->attrs;
	specs->attrs = NULL_TREE;
	declarator = c_parser_declarator (parser, specs->type_seen_p,
	C_DTR_PARM, &dummy);
	if (declarator == NULL)
	{
	c_parser_skip_until_found (parser, CPP_COMMA, NULL);
	return NULL;
	}
	if (c_parser_next_token_is_keyword (parser, RID_ATTRIBUTE))
	postfix_attrs = c_parser_attributes (parser);
	return build_c_parm (specs, chainon (postfix_attrs, prefix_attrs),
	declarator);
	}

	/* Parse a string literal in an asm expression. It should not be
	translated, and wide string literals are an error although
	permitted by the syntax. This is a GNU extension.

	asm-string-literal:
	string-literal

	??? At present, following the old parser, the caller needs to have
	set c_lex_string_translate to 0. It would be better to follow the
	C++ parser rather than using the c_lex_string_translate kludge. */

	static tree
	c_parser_asm_string_literal (c_parser *parser)
	{
	tree str;
	if (c_parser_next_token_is (parser, CPP_STRING))
	{
	str = c_parser_peek_token (parser)->value;
	c_parser_consume_token (parser);
	}
	else if (c_parser_next_token_is (parser, CPP_WSTRING))
	{
	error ("wide string literal in %<asm%>");
	str = build_string (1, "");
	c_parser_consume_token (parser);
	}
	else
	{
	c_parser_error (parser, "expected string literal");
	str = NULL_TREE;
	}
	return str;
	}

	/* Parse a simple asm expression. This is used in restricted
	contexts, where a full expression with inputs and outputs does not
	make sense. This is a GNU extension.

	simple-asm-expr:
	asm ( asm-string-literal )
	*/

	static tree
	c_parser_simple_asm_expr (c_parser *parser)
	{
	tree str;
	gcc_assert (c_parser_next_token_is_keyword (parser, RID_ASM));
	/* ??? Follow the C++ parser rather than using the
	c_lex_string_translate kludge. */
	c_lex_string_translate = 0;
	c_parser_consume_token (parser);
	if (!c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>"))
	{
	c_lex_string_translate = 1;
	return NULL_TREE;
	}
	str = c_parser_asm_string_literal (parser);
	c_lex_string_translate = 1;
	if (!c_parser_require (parser, CPP_CLOSE_PAREN, "expected %<)%>"))
	{
	c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, NULL);
	return NULL_TREE;
	}
	return str;
	}

	/* Parse (possibly empty) attributes. This is a GNU extension.

	attributes:
	empty
	attributes attribute

	attribute:
	__attribute__ ( ( attribute-list ) )

	attribute-list:
	attrib
	attribute_list , attrib

	attrib:
	empty
	any-word
	any-word ( identifier )
	any-word ( identifier , nonempty-expr-list )
	any-word ( expr-list )

	where the "identifier" must not be declared as a type, and
	"any-word" may be any identifier (including one declared as a
	type), a reserved word storage class specifier, type specifier or
	type qualifier. ??? This still leaves out most reserved keywords
	(following the old parser), shouldn't we include them, and why not
	allow identifiers declared as types to start the arguments? */

	static tree
	c_parser_attributes (c_parser *parser)
	{
	tree attrs = NULL_TREE;
	while (c_parser_next_token_is_keyword (parser, RID_ATTRIBUTE))
	{
	/* ??? Follow the C++ parser rather than using the
	c_lex_string_translate kludge. */
	c_lex_string_translate = 0;
	c_parser_consume_token (parser);
	if (!c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>"))
	{
	c_lex_string_translate = 1;
	return attrs;
	}
	if (!c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>"))
	{
	c_lex_string_translate = 1;
	c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, NULL);
	return attrs;
	}
	/* Parse the attribute list. */
	while (c_parser_next_token_is (parser, CPP_COMMA)
	\|\| c_parser_next_token_is (parser, CPP_NAME)
	\|\| c_parser_next_token_is (parser, CPP_KEYWORD))
	{
	tree attr, attr_name, attr_args;
	if (c_parser_next_token_is (parser, CPP_COMMA))
	{
	c_parser_consume_token (parser);
	continue;
	}
	if (c_parser_next_token_is (parser, CPP_KEYWORD))
	{
	/* ??? See comment above about what keywords are
	accepted here. */
	bool ok;
	switch (c_parser_peek_token (parser)->keyword)
	{
	case RID_STATIC:
	case RID_UNSIGNED:
	case RID_LONG:
	case RID_CONST:
	case RID_EXTERN:
	case RID_REGISTER:
	case RID_TYPEDEF:
	case RID_SHORT:
	case RID_INLINE:
	case RID_VOLATILE:
	case RID_SIGNED:
	case RID_AUTO:
	case RID_RESTRICT:
	case RID_COMPLEX:
	case RID_THREAD:
	case RID_INT:
	case RID_CHAR:
	case RID_FLOAT:
	case RID_DOUBLE:
	case RID_VOID:
	case RID_DFLOAT32:
	case RID_DFLOAT64:
	case RID_DFLOAT128:
	case RID_BOOL:
	ok = true;
	break;
	default:
	ok = false;
	break;
	}
	if (!ok)
	break;
	}
	attr_name = c_parser_peek_token (parser)->value;
	c_parser_consume_token (parser);
	if (c_parser_next_token_is_not (parser, CPP_OPEN_PAREN))
	{
	attr = build_tree_list (attr_name, NULL_TREE);
	attrs = chainon (attrs, attr);
	continue;
	}
	c_parser_consume_token (parser);
	/* Parse the attribute contents. If they start with an
	identifier which is followed by a comma or close
	parenthesis, then the arguments start with that
	identifier; otherwise they are an expression list. */
	if (c_parser_next_token_is (parser, CPP_NAME)
	&& c_parser_peek_token (parser)->id_kind == C_ID_ID
	&& ((c_parser_peek_2nd_token (parser)->type == CPP_COMMA)
	\|\| (c_parser_peek_2nd_token (parser)->type
	== CPP_CLOSE_PAREN)))
	{
	tree arg1 = c_parser_peek_token (parser)->value;
	c_parser_consume_token (parser);
	if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN))
	attr_args = build_tree_list (NULL_TREE, arg1);
	else
	{
	c_parser_consume_token (parser);
	attr_args = tree_cons (NULL_TREE, arg1,
	c_parser_expr_list (parser, false));
	}
	}
	else
	{
	if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN))
	attr_args = NULL_TREE;
	else
	attr_args = c_parser_expr_list (parser, false);
	}
	attr = build_tree_list (attr_name, attr_args);
	if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN))
	c_parser_consume_token (parser);
	else
	{
	c_lex_string_translate = 1;
	c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
	"expected %<)%>");
	return attrs;
	}
	attrs = chainon (attrs, attr);
	}
	if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN))
	c_parser_consume_token (parser);
	else
	{
	c_lex_string_translate = 1;
	c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
	"expected %<)%>");
	return attrs;
	}
	if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN))
	c_parser_consume_token (parser);
	else
	{
	c_lex_string_translate = 1;
	c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
	"expected %<)%>");
	return attrs;
	}
	c_lex_string_translate = 1;
	}
	return attrs;
	}

	/* Parse a type name (C90 6.5.5, C99 6.7.6).

	type-name:
	specifier-qualifier-list abstract-declarator[opt]
	*/

	static struct c_type_name *
	c_parser_type_name (c_parser *parser)
	{
	struct c_declspecs *specs = build_null_declspecs ();
	struct c_declarator *declarator;
	struct c_type_name *ret;
	bool dummy = false;
	c_parser_declspecs (parser, specs, false, true, true);
	if (!specs->declspecs_seen_p)
	{
	c_parser_error (parser, "expected specifier-qualifier-list");
	return NULL;
	}
	pending_xref_error ();
	finish_declspecs (specs);
	declarator = c_parser_declarator (parser, specs->type_seen_p,
	C_DTR_ABSTRACT, &dummy);
	if (declarator == NULL)
	return NULL;
	ret = XOBNEW (&parser_obstack, struct c_type_name);
	ret->specs = specs;
	ret->declarator = declarator;
	return ret;
	}

	/* Parse an initializer (C90 6.5.7, C99 6.7.8).

	initializer:
	assignment-expression
	{ initializer-list }
	{ initializer-list , }

	initializer-list:
	designation[opt] initializer
	initializer-list , designation[opt] initializer

	designation:
	designator-list =

	designator-list:
	designator
	designator-list designator

	designator:
	array-designator
	. identifier

	array-designator:
	[ constant-expression ]

	GNU extensions:

	initializer:
	{ }

	designation:
	array-designator
	identifier :

	array-designator:
	[ constant-expression ... constant-expression ]

	Any expression without commas is accepted in the syntax for the
	constant-expressions, with non-constant expressions rejected later.

	This function is only used for top-level initializers; for nested
	ones, see c_parser_initval. */

	static struct c_expr
	c_parser_initializer (c_parser *parser)
	{
	if (c_parser_next_token_is (parser, CPP_OPEN_BRACE))
	return c_parser_braced_init (parser, NULL_TREE, false);
	else
	{
	struct c_expr ret;
	ret = c_parser_expr_no_commas (parser, NULL);
	if (TREE_CODE (ret.value) != STRING_CST
	&& TREE_CODE (ret.value) != COMPOUND_LITERAL_EXPR)
	ret = default_function_array_conversion (ret);
	return ret;
	}
	}

	/* Parse a braced initializer list. TYPE is the type specified for a
	compound literal, and NULL_TREE for other initializers and for
	nested braced lists. NESTED_P is true for nested braced lists,
	false for the list of a compound literal or the list that is the
	top-level initializer in a declaration. */

	static struct c_expr
	c_parser_braced_init (c_parser *parser, tree type, bool nested_p)
	{
	gcc_assert (c_parser_next_token_is (parser, CPP_OPEN_BRACE));
	c_parser_consume_token (parser);
	if (nested_p)
	push_init_level (0);
	else
	really_start_incremental_init (type);
	if (c_parser_next_token_is (parser, CPP_CLOSE_BRACE))
	{
	if (pedantic)
	pedwarn ("ISO C forbids empty initializer braces");
	}
	else
	{
	/* Parse a non-empty initializer list, possibly with a trailing
	comma. */
	while (true)
	{
	c_parser_initelt (parser);
	if (parser->error)
	break;
	if (c_parser_next_token_is (parser, CPP_COMMA))
	c_parser_consume_token (parser);
	else
	break;
	if (c_parser_next_token_is (parser, CPP_CLOSE_BRACE))
	break;
	}
	}
	if (c_parser_next_token_is_not (parser, CPP_CLOSE_BRACE))
	{
	struct c_expr ret;
	ret.value = error_mark_node;
	ret.original_code = ERROR_MARK;
	c_parser_skip_until_found (parser, CPP_CLOSE_BRACE, "expected %<}%>");
	return ret;
	}
	c_parser_consume_token (parser);
	return pop_init_level (0);
	}

	/* Parse a nested initializer, including designators. */

	static void
	c_parser_initelt (c_parser *parser)
	{
	/* Parse any designator or designator list. A single array
	designator may have the subsequent "=" omitted in GNU C, but a
	longer list or a structure member designator may not. */
	if (c_parser_next_token_is (parser, CPP_NAME)
	&& c_parser_peek_2nd_token (parser)->type == CPP_COLON)
	{
	/* Old-style structure member designator. */
	set_init_label (c_parser_peek_token (parser)->value);
	if (pedantic)
	pedwarn ("obsolete use of designated initializer with %<:%>");
	c_parser_consume_token (parser);
	c_parser_consume_token (parser);
	}
	else
	{
	/* des_seen is 0 if there have been no designators, 1 if there
	has been a single array designator and 2 otherwise. */
	int des_seen = 0;
	while (c_parser_next_token_is (parser, CPP_OPEN_SQUARE)
	\|\| c_parser_next_token_is (parser, CPP_DOT))
	{
	int des_prev = des_seen;
	if (des_seen < 2)
	des_seen++;
	if (c_parser_next_token_is (parser, CPP_DOT))
	{
	des_seen = 2;
	c_parser_consume_token (parser);
	if (c_parser_next_token_is (parser, CPP_NAME))
	{
	set_init_label (c_parser_peek_token (parser)->value);
	c_parser_consume_token (parser);
	}
	else
	{
	struct c_expr init;
	init.value = error_mark_node;
	init.original_code = ERROR_MARK;
	c_parser_error (parser, "expected identifier");
	c_parser_skip_until_found (parser, CPP_COMMA, NULL);
	process_init_element (init);
	return;
	}
	}
	else
	{
	tree first, second;
	/* ??? Following the old parser, [ objc-receiver
	objc-message-args ] is accepted as an initializer,
	being distinguished from a designator by what follows
	the first assignment expression inside the square
	brackets, but after a first array designator a
	subsequent square bracket is for Objective-C taken to
	start an expression, using the obsolete form of
	designated initializer without '=', rather than
	possibly being a second level of designation: in LALR
	terms, the '[' is shifted rather than reducing
	designator to designator-list. */
	if (des_prev == 1 && c_dialect_objc ())
	{
	des_seen = des_prev;
	break;
	}
	if (des_prev == 0 && c_dialect_objc ())
	{
	/* This might be an array designator or an
	Objective-C message expression. If the former,
	continue parsing here; if the latter, parse the
	remainder of the initializer given the starting
	primary-expression. ??? It might make sense to
	distinguish when des_prev == 1 as well; see
	previous comment. */
	tree rec, args;
	struct c_expr mexpr;
	c_parser_consume_token (parser);
	if (c_parser_peek_token (parser)->type == CPP_NAME
	&& ((c_parser_peek_token (parser)->id_kind
	== C_ID_TYPENAME)
	\|\| (c_parser_peek_token (parser)->id_kind
	== C_ID_CLASSNAME)))
	{
	/* Type name receiver. */
	tree id = c_parser_peek_token (parser)->value;
	c_parser_consume_token (parser);
	rec = objc_get_class_reference (id);
	goto parse_message_args;
	}
	first = c_parser_expr_no_commas (parser, NULL).value;
	if (c_parser_next_token_is (parser, CPP_ELLIPSIS)
	\|\| c_parser_next_token_is (parser, CPP_CLOSE_SQUARE))
	goto array_desig_after_first;
	/* Expression receiver. So far only one part
	without commas has been parsed; there might be
	more of the expression. */
	rec = first;
	while (c_parser_next_token_is (parser, CPP_COMMA))
	{
	struct c_expr next;
	c_parser_consume_token (parser);
	next = c_parser_expr_no_commas (parser, NULL);
	next = default_function_array_conversion (next);
	rec = build_compound_expr (rec, next.value);
	}
	parse_message_args:
	/* Now parse the objc-message-args. */
	args = c_parser_objc_message_args (parser);
	c_parser_skip_until_found (parser, CPP_CLOSE_SQUARE,
	"expected %<]%>");
	mexpr.value
	= objc_build_message_expr (build_tree_list (rec, args));
	mexpr.original_code = ERROR_MARK;
	/* Now parse and process the remainder of the
	initializer, starting with this message
	expression as a primary-expression. */
	c_parser_initval (parser, &mexpr);
	return;
	}
	c_parser_consume_token (parser);
	first = c_parser_expr_no_commas (parser, NULL).value;
	array_desig_after_first:
	if (c_parser_next_token_is (parser, CPP_ELLIPSIS))
	{
	c_parser_consume_token (parser);
	second = c_parser_expr_no_commas (parser, NULL).value;
	}
	else
	second = NULL_TREE;
	if (c_parser_next_token_is (parser, CPP_CLOSE_SQUARE))
	{
	c_parser_consume_token (parser);
	set_init_index (first, second);
	if (pedantic && second)
	pedwarn ("ISO C forbids specifying range of "
	"elements to initialize");
	}
	else
	c_parser_skip_until_found (parser, CPP_CLOSE_SQUARE,
	"expected %<]%>");
	}
	}
	if (des_seen >= 1)
	{
	if (c_parser_next_token_is (parser, CPP_EQ))
	{
	if (pedantic && !flag_isoc99)
	pedwarn ("ISO C90 forbids specifying subobject to initialize");
	c_parser_consume_token (parser);
	}
	else
	{
	if (des_seen == 1)
	{
	if (pedantic)
	pedwarn ("obsolete use of designated initializer "
	"without %<=%>");
	}
	else
	{
	struct c_expr init;
	init.value = error_mark_node;
	init.original_code = ERROR_MARK;
	c_parser_error (parser, "expected %<=%>");
	c_parser_skip_until_found (parser, CPP_COMMA, NULL);
	process_init_element (init);
	return;
	}
	}
	}
	}
	c_parser_initval (parser, NULL);
	}

	/* Parse a nested initializer; as c_parser_initializer but parses
	initializers within braced lists, after any designators have been
	applied. If AFTER is not NULL then it is an Objective-C message
	expression which is the primary-expression starting the
	initializer. */

	static void
	c_parser_initval (c_parser parser, struct c_expr after)
	{
	struct c_expr init;
	gcc_assert (!after \|\| c_dialect_objc ());
	if (c_parser_next_token_is (parser, CPP_OPEN_BRACE) && !after)
	init = c_parser_braced_init (parser, NULL_TREE, true);
	else
	{
	init = c_parser_expr_no_commas (parser, after);
	if (init.value != NULL_TREE
	&& TREE_CODE (init.value) != STRING_CST
	&& TREE_CODE (init.value) != COMPOUND_LITERAL_EXPR)
	init = default_function_array_conversion (init);
	}
	process_init_element (init);
	}

	/* Parse a compound statement (possibly a function body) (C90 6.6.2,
	C99 6.8.2).

	compound-statement:
	{ block-item-list[opt] }
	{ label-declarations block-item-list }

	block-item-list:
	block-item
	block-item-list block-item

	block-item:
	nested-declaration
	statement

	nested-declaration:
	declaration

	GNU extensions:

	compound-statement:
	{ label-declarations block-item-list }

	nested-declaration:
	__extension__ nested-declaration
	nested-function-definition

	label-declarations:
	label-declaration
	label-declarations label-declaration

	label-declaration:
	__label__ identifier-list ;

	Allowing the mixing of declarations and code is new in C99. The
	GNU syntax also permits (not shown above) labels at the end of
	compound statements, which yield an error. We don't allow labels
	on declarations; this might seem like a natural extension, but
	there would be a conflict between attributes on the label and
	prefix attributes on the declaration. ??? The syntax follows the
	old parser in requiring something after label declarations.
	Although they are erroneous if the labels declared aren't defined,
	is it useful for the syntax to be this way?

	OpenMP:

	block-item:
	openmp-directive

	openmp-directive:
	barrier-directive
	flush-directive */

	static tree
	c_parser_compound_statement (c_parser *parser)
	{
	tree stmt;
	if (!c_parser_require (parser, CPP_OPEN_BRACE, "expected %<{%>"))
	return error_mark_node;
	stmt = c_begin_compound_stmt (true);
	c_parser_compound_statement_nostart (parser);
	return c_end_compound_stmt (stmt, true);
	}

	/* Parse a compound statement except for the opening brace. This is
	used for parsing both compound statements and statement expressions
	(which follow different paths to handling the opening). */

	static void
	c_parser_compound_statement_nostart (c_parser *parser)
	{
	bool last_stmt = false;
	bool last_label = false;
	if (c_parser_next_token_is (parser, CPP_CLOSE_BRACE))
	{
	c_parser_consume_token (parser);
	return;
	}
	if (c_parser_next_token_is_keyword (parser, RID_LABEL))
	{
	/* Read zero or more forward-declarations for labels that nested
	functions can jump to. */
	while (c_parser_next_token_is_keyword (parser, RID_LABEL))
	{
	c_parser_consume_token (parser);
	/* Any identifiers, including those declared as type names,
	are OK here. */
	while (true)
	{
	tree label;
	if (c_parser_next_token_is_not (parser, CPP_NAME))
	{
	c_parser_error (parser, "expected identifier");
	break;
	}
	label
	= declare_label (c_parser_peek_token (parser)->value);
	C_DECLARED_LABEL_FLAG (label) = 1;
	add_stmt (build_stmt (DECL_EXPR, label));
	c_parser_consume_token (parser);
	if (c_parser_next_token_is (parser, CPP_COMMA))
	c_parser_consume_token (parser);
	else
	break;
	}
	c_parser_skip_until_found (parser, CPP_SEMICOLON, "expected %<;%>");
	}
	/* ??? Locating this diagnostic on the token after the
	declarations end follows the old parser, but it might be
	better to locate it where the declarations start instead. */
	if (pedantic)
	pedwarn ("ISO C forbids label declarations");
	}
	/* We must now have at least one statement, label or declaration. */
	if (c_parser_next_token_is (parser, CPP_CLOSE_BRACE))
	{
	c_parser_error (parser, "expected declaration or statement");
	c_parser_consume_token (parser);
	return;
	}
	while (c_parser_next_token_is_not (parser, CPP_CLOSE_BRACE))
	{
	location_t loc = c_parser_peek_token (parser)->location;
	if (c_parser_next_token_is_keyword (parser, RID_CASE)
	\|\| c_parser_next_token_is_keyword (parser, RID_DEFAULT)
	\|\| (c_parser_next_token_is (parser, CPP_NAME)
	&& c_parser_peek_2nd_token (parser)->type == CPP_COLON))
	{
	last_label = true;
	last_stmt = false;
	c_parser_label (parser);
	}
	else if (!last_label
	&& c_parser_next_token_starts_declspecs (parser))
	{
	last_label = false;
	c_parser_declaration_or_fndef (parser, true, true, true, true);
	if (last_stmt
	&& ((pedantic && !flag_isoc99)
	\|\| warn_declaration_after_statement))
	pedwarn_c90 ("%HISO C90 forbids mixed declarations and code",
	&loc);
	last_stmt = false;
	}
	else if (!last_label
	&& c_parser_next_token_is_keyword (parser, RID_EXTENSION))
	{
	/* __extension__ can start a declaration, but is also an
	unary operator that can start an expression. Consume all
	but the last of a possible series of __extension__ to
	determine which. */
	while (c_parser_peek_2nd_token (parser)->type == CPP_KEYWORD
	&& (c_parser_peek_2nd_token (parser)->keyword
	== RID_EXTENSION))
	c_parser_consume_token (parser);
	if (c_token_starts_declspecs (c_parser_peek_2nd_token (parser)))
	{
	int ext;
	ext = disable_extension_diagnostics ();
	c_parser_consume_token (parser);
	last_label = false;
	c_parser_declaration_or_fndef (parser, true, true, true, true);
	/* Following the old parser, __extension__ does not
	disable this diagnostic. */
	restore_extension_diagnostics (ext);
	if (last_stmt
	&& ((pedantic && !flag_isoc99)
	\|\| warn_declaration_after_statement))
	pedwarn_c90 ("%HISO C90 forbids mixed declarations and code",
	&loc);
	last_stmt = false;
	}
	else
	goto statement;
	}
	else if (c_parser_next_token_is (parser, CPP_PRAGMA))
	{
	/* External pragmas, and some omp pragmas, are not associated
	with regular c code, and so are not to be considered statements
	syntactically. This ensures that the user doesn't put them
	places that would turn into syntax errors if the directive
	were ignored. */
	if (c_parser_pragma (parser, pragma_compound))
	last_label = false, last_stmt = true;
	}
	else if (c_parser_next_token_is (parser, CPP_EOF))
	{
	c_parser_error (parser, "expected declaration or statement");
	return;
	}
	else
	{
	statement:
	last_label = false;
	last_stmt = true;
	c_parser_statement_after_labels (parser);
	}

	parser->error = false;
	}
	if (last_label)
	error ("label at end of compound statement");
	c_parser_consume_token (parser);
	}

	/* Parse a label (C90 6.6.1, C99 6.8.1).

	label:
	identifier : attributes[opt]
	case constant-expression :
	default :

	GNU extensions:

	label:
	case constant-expression ... constant-expression :

	The use of attributes on labels is a GNU extension. The syntax in
	GNU C accepts any expressions without commas, non-constant
	expressions being rejected later. */

	static void
	c_parser_label (c_parser *parser)
	{
	location_t loc1 = c_parser_peek_token (parser)->location;
	tree label = NULL_TREE;
	if (c_parser_next_token_is_keyword (parser, RID_CASE))
	{
	tree exp1, exp2;
	c_parser_consume_token (parser);
	exp1 = c_parser_expr_no_commas (parser, NULL).value;
	if (c_parser_next_token_is (parser, CPP_COLON))
	{
	c_parser_consume_token (parser);
	label = do_case (exp1, NULL_TREE);
	}
	else if (c_parser_next_token_is (parser, CPP_ELLIPSIS))
	{
	c_parser_consume_token (parser);
	exp2 = c_parser_expr_no_commas (parser, NULL).value;
	if (c_parser_require (parser, CPP_COLON, "expected %<:%>"))
	label = do_case (exp1, exp2);
	}
	else
	c_parser_error (parser, "expected %<:%> or %<...%>");
	}
	else if (c_parser_next_token_is_keyword (parser, RID_DEFAULT))
	{
	c_parser_consume_token (parser);
	if (c_parser_require (parser, CPP_COLON, "expected %<:%>"))
	label = do_case (NULL_TREE, NULL_TREE);
	}
	else
	{
	tree name = c_parser_peek_token (parser)->value;
	tree tlab;
	location_t loc2;
	tree attrs;
	gcc_assert (c_parser_next_token_is (parser, CPP_NAME));
	c_parser_consume_token (parser);
	gcc_assert (c_parser_next_token_is (parser, CPP_COLON));
	loc2 = c_parser_peek_token (parser)->location;
	c_parser_consume_token (parser);
	attrs = c_parser_attributes (parser);
	tlab = define_label (loc2, name);
	if (tlab)
	{
	decl_attributes (&tlab, attrs, 0);
	label = add_stmt (build_stmt (LABEL_EXPR, tlab));
	}
	}
	if (label)
	SET_EXPR_LOCATION (label, loc1);
	}

	/* Parse a statement (C90 6.6, C99 6.8).

	statement:
	labeled-statement
	compound-statement
	expression-statement
	selection-statement
	iteration-statement
	jump-statement

	labeled-statement:
	label statement

	expression-statement:
	expression[opt] ;

	selection-statement:
	if-statement
	switch-statement

	iteration-statement:
	while-statement
	do-statement
	for-statement

	jump-statement:
	goto identifier ;
	continue ;
	break ;
	return expression[opt] ;

	GNU extensions:

	statement:
	asm-statement

	jump-statement:
	goto * expression ;

	Objective-C:

	statement:
	objc-throw-statement
	objc-try-catch-statement
	objc-synchronized-statement

	objc-throw-statement:
	@throw expression ;
	@throw ;

	OpenMP:

	statement:
	openmp-construct

	openmp-construct:
	parallel-construct
	for-construct
	sections-construct
	single-construct
	parallel-for-construct
	parallel-sections-construct
	master-construct
	critical-construct
	atomic-construct
	ordered-construct

	parallel-construct:
	parallel-directive structured-block

	for-construct:
	for-directive iteration-statement

	sections-construct:
	sections-directive section-scope

	single-construct:
	single-directive structured-block

	parallel-for-construct:
	parallel-for-directive iteration-statement

	parallel-sections-construct:
	parallel-sections-directive section-scope

	master-construct:
	master-directive structured-block

	critical-construct:
	critical-directive structured-block

	atomic-construct:
	atomic-directive expression-statement

	ordered-construct:
	ordered-directive structured-block */

	static void
	c_parser_statement (c_parser *parser)
	{
	while (c_parser_next_token_is_keyword (parser, RID_CASE)
	\|\| c_parser_next_token_is_keyword (parser, RID_DEFAULT)
	\|\| (c_parser_next_token_is (parser, CPP_NAME)
	&& c_parser_peek_2nd_token (parser)->type == CPP_COLON))
	c_parser_label (parser);
	c_parser_statement_after_labels (parser);
	}

	/* Parse a statement, other than a labeled statement. */

	static void
	c_parser_statement_after_labels (c_parser *parser)
	{
	location_t loc = c_parser_peek_token (parser)->location;
	tree stmt = NULL_TREE;
	switch (c_parser_peek_token (parser)->type)
	{
	case CPP_OPEN_BRACE:
	add_stmt (c_parser_compound_statement (parser));
	break;
	case CPP_KEYWORD:
	switch (c_parser_peek_token (parser)->keyword)
	{
	case RID_IF:
	c_parser_if_statement (parser);
	break;
	case RID_SWITCH:
	c_parser_switch_statement (parser);
	break;
	case RID_WHILE:
	c_parser_while_statement (parser);
	break;
	case RID_DO:
	c_parser_do_statement (parser);
	break;
	case RID_FOR:
	c_parser_for_statement (parser);
	break;
	case RID_GOTO:
	c_parser_consume_token (parser);
	if (c_parser_next_token_is (parser, CPP_NAME))
	{
	stmt = c_finish_goto_label (c_parser_peek_token (parser)->value);
	c_parser_consume_token (parser);
	}
	else if (c_parser_next_token_is (parser, CPP_MULT))
	{
	c_parser_consume_token (parser);
	stmt = c_finish_goto_ptr (c_parser_expression (parser).value);
	}
	else
	c_parser_error (parser, "expected identifier or %<*%>");
	goto expect_semicolon;
	case RID_CONTINUE:
	c_parser_consume_token (parser);
	stmt = c_finish_bc_stmt (&c_cont_label, false);
	goto expect_semicolon;
	case RID_BREAK:
	c_parser_consume_token (parser);
	stmt = c_finish_bc_stmt (&c_break_label, true);
	goto expect_semicolon;
	case RID_RETURN:
	c_parser_consume_token (parser);
	if (c_parser_next_token_is (parser, CPP_SEMICOLON))
	{
	stmt = c_finish_return (NULL_TREE);
	c_parser_consume_token (parser);
	}
	else
	{
	stmt = c_finish_return (c_parser_expression_conv (parser).value);
	goto expect_semicolon;
	}
	break;
	case RID_ASM:
	stmt = c_parser_asm_statement (parser);
	break;
	case RID_AT_THROW:
	gcc_assert (c_dialect_objc ());
	c_parser_consume_token (parser);
	if (c_parser_next_token_is (parser, CPP_SEMICOLON))
	{
	stmt = objc_build_throw_stmt (NULL_TREE);
	c_parser_consume_token (parser);
	}
	else
	{
	stmt
	= objc_build_throw_stmt (c_parser_expression (parser).value);
	goto expect_semicolon;
	}
	break;
	case RID_AT_TRY:
	gcc_assert (c_dialect_objc ());
	c_parser_objc_try_catch_statement (parser);
	break;
	case RID_AT_SYNCHRONIZED:
	gcc_assert (c_dialect_objc ());
	c_parser_objc_synchronized_statement (parser);
	break;
	default:
	goto expr_stmt;
	}
	break;
	case CPP_SEMICOLON:
	c_parser_consume_token (parser);
	break;
	case CPP_CLOSE_PAREN:
	case CPP_CLOSE_SQUARE:
	/* Avoid infinite loop in error recovery:
	c_parser_skip_until_found stops at a closing nesting
	delimiter without consuming it, but here we need to consume
	it to proceed further. */
	c_parser_error (parser, "expected statement");
	c_parser_consume_token (parser);
	break;
	case CPP_PRAGMA:
	c_parser_pragma (parser, pragma_stmt);
	break;
	default:
	expr_stmt:
	stmt = c_finish_expr_stmt (c_parser_expression_conv (parser).value);
	expect_semicolon:
	c_parser_skip_until_found (parser, CPP_SEMICOLON, "expected %<;%>");
	break;
	}
	/* Two cases cannot and do not have line numbers associated: If stmt
	is degenerate, such as "2;", then stmt is an INTEGER_CST, which
	cannot hold line numbers. But that's OK because the statement
	will either be changed to a MODIFY_EXPR during gimplification of
	the statement expr, or discarded. If stmt was compound, but
	without new variables, we will have skipped the creation of a
	BIND and will have a bare STATEMENT_LIST. But that's OK because
	(recursively) all of the component statements should already have
	line numbers assigned. ??? Can we discard no-op statements
	earlier? */
	if (stmt && EXPR_P (stmt))
	SET_EXPR_LOCATION (stmt, loc);
	}

	/* Parse a parenthesized condition from an if, do or while statement.

	condition:
	( expression )
	*/
	static tree
	c_parser_paren_condition (c_parser *parser)
	{
	location_t loc;
	tree cond;
	if (!c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>"))
	return error_mark_node;
	loc = c_parser_peek_token (parser)->location;
	cond = c_objc_common_truthvalue_conversion
	(c_parser_expression_conv (parser).value);
	if (EXPR_P (cond))
	SET_EXPR_LOCATION (cond, loc);
	c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, "expected %<)%>");
	return cond;
	}

	/* Parse a statement which is a block in C99. */

	static tree
	c_parser_c99_block_statement (c_parser *parser)
	{
	tree block = c_begin_compound_stmt (flag_isoc99);
	c_parser_statement (parser);
	return c_end_compound_stmt (block, flag_isoc99);
	}

	/* Parse the body of an if statement or the else half thereof. This
	is just parsing a statement but (a) it is a block in C99, (b) we
	track whether the body is an if statement for the sake of
	-Wparentheses warnings, (c) we handle an empty body specially for
	the sake of -Wextra warnings. */

	static tree
	c_parser_if_body (c_parser parser, bool if_p)
	{
	tree block = c_begin_compound_stmt (flag_isoc99);
	while (c_parser_next_token_is_keyword (parser, RID_CASE)
	\|\| c_parser_next_token_is_keyword (parser, RID_DEFAULT)
	\|\| (c_parser_next_token_is (parser, CPP_NAME)
	&& c_parser_peek_2nd_token (parser)->type == CPP_COLON))
	c_parser_label (parser);
	*if_p = c_parser_next_token_is_keyword (parser, RID_IF);
	if (extra_warnings && c_parser_next_token_is (parser, CPP_SEMICOLON))
	add_stmt (build_empty_stmt ());
	c_parser_statement_after_labels (parser);
	return c_end_compound_stmt (block, flag_isoc99);
	}

	/* Parse an if statement (C90 6.6.4, C99 6.8.4).

	if-statement:
	if ( expression ) statement
	if ( expression ) statement else statement
	*/

	static void
	c_parser_if_statement (c_parser *parser)
	{
	tree block;
	location_t loc;
	tree cond;
	bool first_if = false, second_if = false;
	tree first_body, second_body;
	gcc_assert (c_parser_next_token_is_keyword (parser, RID_IF));
	c_parser_consume_token (parser);
	block = c_begin_compound_stmt (flag_isoc99);
	loc = c_parser_peek_token (parser)->location;
	cond = c_parser_paren_condition (parser);
	first_body = c_parser_if_body (parser, &first_if);
	if (c_parser_next_token_is_keyword (parser, RID_ELSE))
	{
	c_parser_consume_token (parser);
	second_body = c_parser_if_body (parser, &second_if);
	}
	else
	second_body = NULL_TREE;
	c_finish_if_stmt (loc, cond, first_body, second_body, first_if);
	add_stmt (c_end_compound_stmt (block, flag_isoc99));
	}

	/* Parse a switch statement (C90 6.6.4, C99 6.8.4).

	switch-statement:
	switch (expression) statement
	*/

	static void
	c_parser_switch_statement (c_parser *parser)
	{
	tree block, expr, body, save_break;
	gcc_assert (c_parser_next_token_is_keyword (parser, RID_SWITCH));
	c_parser_consume_token (parser);
	block = c_begin_compound_stmt (flag_isoc99);
	if (c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>"))
	{
	expr = c_parser_expression (parser).value;
	c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, "expected %<)%>");
	}
	else
	expr = error_mark_node;
	c_start_case (expr);
	save_break = c_break_label;
	c_break_label = NULL_TREE;
	body = c_parser_c99_block_statement (parser);
	c_finish_case (body);
	if (c_break_label)
	add_stmt (build1 (LABEL_EXPR, void_type_node, c_break_label));
	c_break_label = save_break;
	add_stmt (c_end_compound_stmt (block, flag_isoc99));
	}

	/* Parse a while statement (C90 6.6.5, C99 6.8.5).

	while-statement:
	- while (expression) statement
	+ APPLE LOCAL begin for-fsf-4_4 3274130 5295549
	+ while attributes (expression) statement
	+
	+ The use of attributes is a GNU extension.
	+ APPLE LOCAL end for-fsf-4_4 3274130 5295549
	*/

	static void
	c_parser_while_statement (c_parser *parser)
	{
	- tree block, cond, body, save_break, save_cont;
	+/* APPLE LOCAL begin for-fsf-4_4 3274130 5295549 */ \
	+ tree block, cond, body, save_break, save_cont, attrs;
	+/* APPLE LOCAL end for-fsf-4_4 3274130 5295549 */ \
	location_t loc;
	gcc_assert (c_parser_next_token_is_keyword (parser, RID_WHILE));
	c_parser_consume_token (parser);
	+/* APPLE LOCAL begin for-fsf-4_4 3274130 5295549 */ \
	+ attrs = c_parser_attributes (parser);
	+/* APPLE LOCAL end for-fsf-4_4 3274130 5295549 */ \
	block = c_begin_compound_stmt (flag_isoc99);
	loc = c_parser_peek_token (parser)->location;
	cond = c_parser_paren_condition (parser);
	save_break = c_break_label;
	c_break_label = NULL_TREE;
	save_cont = c_cont_label;
	c_cont_label = NULL_TREE;
	body = c_parser_c99_block_statement (parser);
	- c_finish_loop (loc, cond, NULL, body, c_break_label, c_cont_label, true);
	+/* APPLE LOCAL begin for-fsf-4_4 3274130 5295549 */ \
	+ c_finish_loop (loc, cond, NULL, body, c_break_label, c_cont_label, attrs,
	+ true);
	+/* APPLE LOCAL end for-fsf-4_4 3274130 5295549 */ \
	add_stmt (c_end_compound_stmt (block, flag_isoc99));
	c_break_label = save_break;
	c_cont_label = save_cont;
	}

	/* Parse a do statement (C90 6.6.5, C99 6.8.5).

	do-statement:
	- do statement while ( expression ) ;
	+ APPLE LOCAL begin for-fsf-4_4 3274130 5295549
	+ do attributes statement while ( expression ) ;
	+
	+ The use of attributes is a GNU extension.
	+ APPLE LOCAL end for-fsf-4_4 3274130 5295549
	*/

	static void
	c_parser_do_statement (c_parser *parser)
	{
	- tree block, cond, body, save_break, save_cont, new_break, new_cont;
	+/* APPLE LOCAL begin for-fsf-4_4 3274130 5295549 */ \
	+ tree block, cond, body, save_break, save_cont, new_break, new_cont, attrs;
	+/* APPLE LOCAL end for-fsf-4_4 3274130 5295549 */ \
	location_t loc;
	gcc_assert (c_parser_next_token_is_keyword (parser, RID_DO));
	c_parser_consume_token (parser);
	+/* APPLE LOCAL begin for-fsf-4_4 3274130 5295549 */ \
	+ attrs = c_parser_attributes (parser);
	+/* APPLE LOCAL end for-fsf-4_4 3274130 5295549 */ \
	block = c_begin_compound_stmt (flag_isoc99);
	loc = c_parser_peek_token (parser)->location;
	save_break = c_break_label;
	c_break_label = NULL_TREE;
	save_cont = c_cont_label;
	c_cont_label = NULL_TREE;
	body = c_parser_c99_block_statement (parser);
	c_parser_require_keyword (parser, RID_WHILE, "expected %<while%>");
	new_break = c_break_label;
	c_break_label = save_break;
	new_cont = c_cont_label;
	c_cont_label = save_cont;
	cond = c_parser_paren_condition (parser);
	if (!c_parser_require (parser, CPP_SEMICOLON, "expected %<;%>"))
	c_parser_skip_to_end_of_block_or_statement (parser);
	- c_finish_loop (loc, cond, NULL, body, new_break, new_cont, false);
	+/* APPLE LOCAL begin for-fsf-4_4 3274130 5295549 */ \
	+ c_finish_loop (loc, cond, NULL, body, new_break, new_cont, attrs, false);
	+/* APPLE LOCAL end for-fsf-4_4 3274130 5295549 */ \
	add_stmt (c_end_compound_stmt (block, flag_isoc99));
	}

	/* Parse a for statement (C90 6.6.5, C99 6.8.5).

	for-statement:
	- for ( expression[opt] ; expression[opt] ; expression[opt] ) statement
	- for ( nested-declaration expression[opt] ; expression[opt] ) statement
	+ APPLE LOCAL begin for-fsf-4_4 3274130 5295549
	+ for attributes ( expression[opt] ; expression[opt] ; expression[opt] ) \
	+ statement
	+ for attributes ( nested-declaration expression[opt] ; expression[opt] ) \
	+ statement

	The form with a declaration is new in C99.

	+ The use of attributes is a GNU extension.
	+
	+ APPLE LOCAL end for-fsf-4_4 3274130 5295549
	??? In accordance with the old parser, the declaration may be a
	nested function, which is then rejected in check_for_loop_decls,
	but does it make any sense for this to be included in the grammar?
	Note in particular that the nested function does not include a
	trailing ';', whereas the "declaration" production includes one.
	Also, can we reject bad declarations earlier and cheaper than
	check_for_loop_decls? */

	static void
	c_parser_for_statement (c_parser *parser)
	{
	- tree block, cond, incr, save_break, save_cont, body;
	+/* APPLE LOCAL begin for-fsf-4_4 3274130 5295549 */ \
	+ tree block, cond, incr, save_break, save_cont, body, attrs;
	+/* APPLE LOCAL end for-fsf-4_4 3274130 5295549 */ \
	location_t loc;
	gcc_assert (c_parser_next_token_is_keyword (parser, RID_FOR));
	loc = c_parser_peek_token (parser)->location;
	c_parser_consume_token (parser);
	+/* APPLE LOCAL begin for-fsf-4_4 3274130 5295549 */ \
	+ attrs = c_parser_attributes (parser);
	+/* APPLE LOCAL end for-fsf-4_4 3274130 5295549 */ \
	block = c_begin_compound_stmt (flag_isoc99);
	if (c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>"))
	{
	/* Parse the initialization declaration or expression. */
	if (c_parser_next_token_is (parser, CPP_SEMICOLON))
	{
	c_parser_consume_token (parser);
	c_finish_expr_stmt (NULL_TREE);
	}
	else if (c_parser_next_token_starts_declspecs (parser))
	{
	c_parser_declaration_or_fndef (parser, true, true, true, true);
	check_for_loop_decls ();
	}
	else if (c_parser_next_token_is_keyword (parser, RID_EXTENSION))
	{
	/* __extension__ can start a declaration, but is also an
	unary operator that can start an expression. Consume all
	but the last of a possible series of __extension__ to
	determine which. */
	while (c_parser_peek_2nd_token (parser)->type == CPP_KEYWORD
	&& (c_parser_peek_2nd_token (parser)->keyword
	== RID_EXTENSION))
	c_parser_consume_token (parser);
	if (c_token_starts_declspecs (c_parser_peek_2nd_token (parser)))
	{
	int ext;
	ext = disable_extension_diagnostics ();
	c_parser_consume_token (parser);
	c_parser_declaration_or_fndef (parser, true, true, true, true);
	restore_extension_diagnostics (ext);
	check_for_loop_decls ();
	}
	else
	goto init_expr;
	}
	else
	{
	init_expr:
	c_finish_expr_stmt (c_parser_expression (parser).value);
	c_parser_skip_until_found (parser, CPP_SEMICOLON, "expected %<;%>");
	}
	/* Parse the loop condition. */
	loc = c_parser_peek_token (parser)->location;
	if (c_parser_next_token_is (parser, CPP_SEMICOLON))
	{
	c_parser_consume_token (parser);
	cond = NULL_TREE;
	}
	else
	{
	tree ocond = c_parser_expression_conv (parser).value;
	cond = c_objc_common_truthvalue_conversion (ocond);
	if (EXPR_P (cond))
	SET_EXPR_LOCATION (cond, loc);
	c_parser_skip_until_found (parser, CPP_SEMICOLON, "expected %<;%>");
	}
	/* Parse the increment expression. */
	if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN))
	incr = c_process_expr_stmt (NULL_TREE);
	else
	incr = c_process_expr_stmt (c_parser_expression (parser).value);
	c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, "expected %<)%>");
	}
	else
	{
	cond = error_mark_node;
	incr = error_mark_node;
	}
	save_break = c_break_label;
	c_break_label = NULL_TREE;
	save_cont = c_cont_label;
	c_cont_label = NULL_TREE;
	body = c_parser_c99_block_statement (parser);
	- c_finish_loop (loc, cond, incr, body, c_break_label, c_cont_label, true);
	+/* APPLE LOCAL begin for-fsf-4_4 3274130 5295549 */ \
	+ c_finish_loop (loc, cond, incr, body, c_break_label, c_cont_label, attrs,
	+ true);
	+/* APPLE LOCAL end for-fsf-4_4 3274130 5295549 */ \
	add_stmt (c_end_compound_stmt (block, flag_isoc99));
	c_break_label = save_break;
	c_cont_label = save_cont;
	}

	/* Parse an asm statement, a GNU extension. This is a full-blown asm
	statement with inputs, outputs, clobbers, and volatile tag
	allowed.

	asm-statement:
	asm type-qualifier[opt] ( asm-argument ) ;

	asm-argument:
	asm-string-literal
	asm-string-literal : asm-operands[opt]
	asm-string-literal : asm-operands[opt] : asm-operands[opt]
	asm-string-literal : asm-operands[opt] : asm-operands[opt] : asm-clobbers

	Qualifiers other than volatile are accepted in the syntax but
	warned for. */

	static tree
	c_parser_asm_statement (c_parser *parser)
	{
	tree quals, str, outputs, inputs, clobbers, ret;
	bool simple;
	gcc_assert (c_parser_next_token_is_keyword (parser, RID_ASM));
	c_parser_consume_token (parser);
	if (c_parser_next_token_is_keyword (parser, RID_VOLATILE))
	{
	quals = c_parser_peek_token (parser)->value;
	c_parser_consume_token (parser);
	}
	else if (c_parser_next_token_is_keyword (parser, RID_CONST)
	\|\| c_parser_next_token_is_keyword (parser, RID_RESTRICT))
	{
	warning (0, "%E qualifier ignored on asm",
	c_parser_peek_token (parser)->value);
	quals = NULL_TREE;
	c_parser_consume_token (parser);
	}
	else
	quals = NULL_TREE;
	/* ??? Follow the C++ parser rather than using the
	c_lex_string_translate kludge. */
	c_lex_string_translate = 0;
	if (!c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>"))
	{
	c_lex_string_translate = 1;
	return NULL_TREE;
	}
	str = c_parser_asm_string_literal (parser);
	if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN))
	{
	simple = true;
	outputs = NULL_TREE;
	inputs = NULL_TREE;
	clobbers = NULL_TREE;
	goto done_asm;
	}
	if (!c_parser_require (parser, CPP_COLON, "expected %<:%> or %<)%>"))
	{
	c_lex_string_translate = 1;
	c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, NULL);
	return NULL_TREE;
	}
	simple = false;
	/* Parse outputs. */
	if (c_parser_next_token_is (parser, CPP_COLON)
	\|\| c_parser_next_token_is (parser, CPP_CLOSE_PAREN))
	outputs = NULL_TREE;
	else
	outputs = c_parser_asm_operands (parser, false);
	if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN))
	{
	inputs = NULL_TREE;
	clobbers = NULL_TREE;
	goto done_asm;
	}
	if (!c_parser_require (parser, CPP_COLON, "expected %<:%> or %<)%>"))
	{
	c_lex_string_translate = 1;
	c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, NULL);
	return NULL_TREE;
	}
	/* Parse inputs. */
	if (c_parser_next_token_is (parser, CPP_COLON)
	\|\| c_parser_next_token_is (parser, CPP_CLOSE_PAREN))
	inputs = NULL_TREE;
	else
	inputs = c_parser_asm_operands (parser, true);
	if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN))
	{
	clobbers = NULL_TREE;
	goto done_asm;
	}
	if (!c_parser_require (parser, CPP_COLON, "expected %<:%> or %<)%>"))
	{
	c_lex_string_translate = 1;
	c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, NULL);
	return NULL_TREE;
	}
	/* Parse clobbers. */
	clobbers = c_parser_asm_clobbers (parser);
	done_asm:
	c_lex_string_translate = 1;
	if (!c_parser_require (parser, CPP_CLOSE_PAREN, "expected %<)%>"))
	{
	c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, NULL);
	return NULL_TREE;
	}
	if (!c_parser_require (parser, CPP_SEMICOLON, "expected %<;%>"))
	c_parser_skip_to_end_of_block_or_statement (parser);
	ret = build_asm_stmt (quals, build_asm_expr (str, outputs, inputs,
	clobbers, simple));
	return ret;
	}

	/* Parse asm operands, a GNU extension. If CONVERT_P (for inputs but
	not outputs), apply the default conversion of functions and arrays
	to pointers.

	asm-operands:
	asm-operand
	asm-operands , asm-operand

	asm-operand:
	asm-string-literal ( expression )
	[ identifier ] asm-string-literal ( expression )
	*/

	static tree
	c_parser_asm_operands (c_parser *parser, bool convert_p)
	{
	tree list = NULL_TREE;
	while (true)
	{
	tree name, str;
	struct c_expr expr;
	if (c_parser_next_token_is (parser, CPP_OPEN_SQUARE))
	{
	c_parser_consume_token (parser);
	if (c_parser_next_token_is (parser, CPP_NAME))
	{
	tree id = c_parser_peek_token (parser)->value;
	c_parser_consume_token (parser);
	name = build_string (IDENTIFIER_LENGTH (id),
	IDENTIFIER_POINTER (id));
	}
	else
	{
	c_parser_error (parser, "expected identifier");
	c_parser_skip_until_found (parser, CPP_CLOSE_SQUARE, NULL);
	return NULL_TREE;
	}
	c_parser_skip_until_found (parser, CPP_CLOSE_SQUARE,
	"expected %<]%>");
	}
	else
	name = NULL_TREE;
	str = c_parser_asm_string_literal (parser);
	if (str == NULL_TREE)
	return NULL_TREE;
	c_lex_string_translate = 1;
	if (!c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>"))
	{
	c_lex_string_translate = 0;
	return NULL_TREE;
	}
	expr = c_parser_expression (parser);
	if (convert_p)
	expr = default_function_array_conversion (expr);
	c_lex_string_translate = 0;
	if (!c_parser_require (parser, CPP_CLOSE_PAREN, "expected %<)%>"))
	{
	c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, NULL);
	return NULL_TREE;
	}
	list = chainon (list, build_tree_list (build_tree_list (name, str),
	expr.value));
	if (c_parser_next_token_is (parser, CPP_COMMA))
	c_parser_consume_token (parser);
	else
	break;
	}
	return list;
	}

	/* Parse asm clobbers, a GNU extension.

	asm-clobbers:
	asm-string-literal
	asm-clobbers , asm-string-literal
	*/

	static tree
	c_parser_asm_clobbers (c_parser *parser)
	{
	tree list = NULL_TREE;
	while (true)
	{
	tree str = c_parser_asm_string_literal (parser);
	if (str)
	list = tree_cons (NULL_TREE, str, list);
	else
	return NULL_TREE;
	if (c_parser_next_token_is (parser, CPP_COMMA))
	c_parser_consume_token (parser);
	else
	break;
	}
	return list;
	}

	/* Parse an expression other than a compound expression; that is, an
	assignment expression (C90 6.3.16, C99 6.5.16). If AFTER is not
	NULL then it is an Objective-C message expression which is the
	primary-expression starting the expression as an initializer.

	assignment-expression:
	conditional-expression
	unary-expression assignment-operator assignment-expression

	assignment-operator: one of
	= *= /= %= += -= <<= >>= &= ^= \|=

	In GNU C we accept any conditional expression on the LHS and
	diagnose the invalid lvalue rather than producing a syntax
	error. */

	static struct c_expr
	c_parser_expr_no_commas (c_parser parser, struct c_expr after)
	{
	struct c_expr lhs, rhs, ret;
	enum tree_code code;
	gcc_assert (!after \|\| c_dialect_objc ());
	lhs = c_parser_conditional_expression (parser, after);
	switch (c_parser_peek_token (parser)->type)
	{
	case CPP_EQ:
	code = NOP_EXPR;
	break;
	case CPP_MULT_EQ:
	code = MULT_EXPR;
	break;
	case CPP_DIV_EQ:
	code = TRUNC_DIV_EXPR;
	break;
	case CPP_MOD_EQ:
	code = TRUNC_MOD_EXPR;
	break;
	case CPP_PLUS_EQ:
	code = PLUS_EXPR;
	break;
	case CPP_MINUS_EQ:
	code = MINUS_EXPR;
	break;
	case CPP_LSHIFT_EQ:
	code = LSHIFT_EXPR;
	break;
	case CPP_RSHIFT_EQ:
	code = RSHIFT_EXPR;
	break;
	case CPP_AND_EQ:
	code = BIT_AND_EXPR;
	break;
	case CPP_XOR_EQ:
	code = BIT_XOR_EXPR;
	break;
	case CPP_OR_EQ:
	code = BIT_IOR_EXPR;
	break;
	default:
	return lhs;
	}
	c_parser_consume_token (parser);
	rhs = c_parser_expr_no_commas (parser, NULL);
	rhs = default_function_array_conversion (rhs);
	ret.value = build_modify_expr (lhs.value, code, rhs.value);
	if (code == NOP_EXPR)
	ret.original_code = MODIFY_EXPR;
	else
	{
	TREE_NO_WARNING (ret.value) = 1;
	ret.original_code = ERROR_MARK;
	}
	return ret;
	}

	/* Parse a conditional expression (C90 6.3.15, C99 6.5.15). If AFTER
	is not NULL then it is an Objective-C message expression which is
	the primary-expression starting the expression as an initializer.

	conditional-expression:
	logical-OR-expression
	logical-OR-expression ? expression : conditional-expression

	GNU extensions:

	conditional-expression:
	logical-OR-expression ? : conditional-expression
	*/

	static struct c_expr
	c_parser_conditional_expression (c_parser parser, struct c_expr after)
	{
	struct c_expr cond, exp1, exp2, ret;
	gcc_assert (!after \|\| c_dialect_objc ());
	cond = c_parser_binary_expression (parser, after);
	if (c_parser_next_token_is_not (parser, CPP_QUERY))
	return cond;
	cond = default_function_array_conversion (cond);
	c_parser_consume_token (parser);
	if (c_parser_next_token_is (parser, CPP_COLON))
	{
	if (pedantic)
	pedwarn ("ISO C forbids omitting the middle term of a ?: expression");
	/* Make sure first operand is calculated only once. */
	exp1.value = save_expr (default_conversion (cond.value));
	cond.value = c_objc_common_truthvalue_conversion (exp1.value);
	skip_evaluation += cond.value == truthvalue_true_node;
	}
	else
	{
	cond.value
	= c_objc_common_truthvalue_conversion
	(default_conversion (cond.value));
	skip_evaluation += cond.value == truthvalue_false_node;
	exp1 = c_parser_expression_conv (parser);
	skip_evaluation += ((cond.value == truthvalue_true_node)
	- (cond.value == truthvalue_false_node));
	}
	if (!c_parser_require (parser, CPP_COLON, "expected %<:%>"))
	{
	skip_evaluation -= cond.value == truthvalue_true_node;
	ret.value = error_mark_node;
	ret.original_code = ERROR_MARK;
	return ret;
	}
	exp2 = c_parser_conditional_expression (parser, NULL);
	exp2 = default_function_array_conversion (exp2);
	skip_evaluation -= cond.value == truthvalue_true_node;
	ret.value = build_conditional_expr (cond.value, exp1.value, exp2.value);
	ret.original_code = ERROR_MARK;
	return ret;
	}

	/* Parse a binary expression; that is, a logical-OR-expression (C90
	6.3.5-6.3.14, C99 6.5.5-6.5.14). If AFTER is not NULL then it is
	an Objective-C message expression which is the primary-expression
	starting the expression as an initializer.

	multiplicative-expression:
	cast-expression
	multiplicative-expression * cast-expression
	multiplicative-expression / cast-expression
	multiplicative-expression % cast-expression

	additive-expression:
	multiplicative-expression
	additive-expression + multiplicative-expression
	additive-expression - multiplicative-expression

	shift-expression:
	additive-expression
	shift-expression << additive-expression
	shift-expression >> additive-expression

	relational-expression:
	shift-expression
	relational-expression < shift-expression
	relational-expression > shift-expression
	relational-expression <= shift-expression
	relational-expression >= shift-expression

	equality-expression:
	relational-expression
	equality-expression == relational-expression
	equality-expression != relational-expression

	AND-expression:
	equality-expression
	AND-expression & equality-expression

	exclusive-OR-expression:
	AND-expression
	exclusive-OR-expression ^ AND-expression

	inclusive-OR-expression:
	exclusive-OR-expression
	inclusive-OR-expression \| exclusive-OR-expression

	logical-AND-expression:
	inclusive-OR-expression
	logical-AND-expression && inclusive-OR-expression

	logical-OR-expression:
	logical-AND-expression
	logical-OR-expression \|\| logical-AND-expression
	*/

	static struct c_expr
	c_parser_binary_expression (c_parser parser, struct c_expr after)
	{
	/* A binary expression is parsed using operator-precedence parsing,
	with the operands being cast expressions. All the binary
	operators are left-associative. Thus a binary expression is of
	form:

	E0 op1 E1 op2 E2 ...

	which we represent on a stack. On the stack, the precedence
	levels are strictly increasing. When a new operator is
	encountered of higher precedence than that at the top of the
	stack, it is pushed; its LHS is the top expression, and its RHS
	is everything parsed until it is popped. When a new operator is
	encountered with precedence less than or equal to that at the top
	of the stack, triples E[i-1] op[i] E[i] are popped and replaced
	by the result of the operation until the operator at the top of
	the stack has lower precedence than the new operator or there is
	only one element on the stack; then the top expression is the LHS
	of the new operator. In the case of logical AND and OR
	expressions, we also need to adjust skip_evaluation as
	appropriate when the operators are pushed and popped. */

	/* The precedence levels, where 0 is a dummy lowest level used for
	the bottom of the stack. */
	enum prec {
	PREC_NONE,
	PREC_LOGOR,
	PREC_LOGAND,
	PREC_BITOR,
	PREC_BITXOR,
	PREC_BITAND,
	PREC_EQ,
	PREC_REL,
	PREC_SHIFT,
	PREC_ADD,
	PREC_MULT,
	NUM_PRECS
	};
	struct {
	/* The expression at this stack level. */
	struct c_expr expr;
	/* The precedence of the operator on its left, PREC_NONE at the
	bottom of the stack. */
	enum prec prec;
	/* The operation on its left. */
	enum tree_code op;
	} stack[NUM_PRECS];
	int sp;
	#define POP \
	do { \
	switch (stack[sp].op) \
	{ \
	case TRUTH_ANDIF_EXPR: \
	skip_evaluation -= stack[sp - 1].expr.value == truthvalue_false_node; \
	break; \
	case TRUTH_ORIF_EXPR: \
	skip_evaluation -= stack[sp - 1].expr.value == truthvalue_true_node; \
	break; \
	default: \
	break; \
	} \
	stack[sp - 1].expr \
	= default_function_array_conversion (stack[sp - 1].expr); \
	stack[sp].expr \
	= default_function_array_conversion (stack[sp].expr); \
	stack[sp - 1].expr = parser_build_binary_op (stack[sp].op, \
	stack[sp - 1].expr, \
	stack[sp].expr); \
	sp--; \
	} while (0)
	gcc_assert (!after \|\| c_dialect_objc ());
	stack[0].expr = c_parser_cast_expression (parser, after);
	stack[0].prec = PREC_NONE;
	sp = 0;
	while (true)
	{
	enum prec oprec;
	enum tree_code ocode;
	if (parser->error)
	goto out;
	switch (c_parser_peek_token (parser)->type)
	{
	case CPP_MULT:
	oprec = PREC_MULT;
	ocode = MULT_EXPR;
	break;
	case CPP_DIV:
	oprec = PREC_MULT;
	ocode = TRUNC_DIV_EXPR;
	break;
	case CPP_MOD:
	oprec = PREC_MULT;
	ocode = TRUNC_MOD_EXPR;
	break;
	case CPP_PLUS:
	oprec = PREC_ADD;
	ocode = PLUS_EXPR;
	break;
	case CPP_MINUS:
	oprec = PREC_ADD;
	ocode = MINUS_EXPR;
	break;
	case CPP_LSHIFT:
	oprec = PREC_SHIFT;
	ocode = LSHIFT_EXPR;
	break;
	case CPP_RSHIFT:
	oprec = PREC_SHIFT;
	ocode = RSHIFT_EXPR;
	break;
	case CPP_LESS:
	oprec = PREC_REL;
	ocode = LT_EXPR;
	break;
	case CPP_GREATER:
	oprec = PREC_REL;
	ocode = GT_EXPR;
	break;
	case CPP_LESS_EQ:
	oprec = PREC_REL;
	ocode = LE_EXPR;
	break;
	case CPP_GREATER_EQ:
	oprec = PREC_REL;
	ocode = GE_EXPR;
	break;
	case CPP_EQ_EQ:
	oprec = PREC_EQ;
	ocode = EQ_EXPR;
	break;
	case CPP_NOT_EQ:
	oprec = PREC_EQ;
	ocode = NE_EXPR;
	break;
	case CPP_AND:
	oprec = PREC_BITAND;
	ocode = BIT_AND_EXPR;
	break;
	case CPP_XOR:
	oprec = PREC_BITXOR;
	ocode = BIT_XOR_EXPR;
	break;
	case CPP_OR:
	oprec = PREC_BITOR;
	ocode = BIT_IOR_EXPR;
	break;
	case CPP_AND_AND:
	oprec = PREC_LOGAND;
	ocode = TRUTH_ANDIF_EXPR;
	break;
	case CPP_OR_OR:
	oprec = PREC_LOGOR;
	ocode = TRUTH_ORIF_EXPR;
	break;
	default:
	/* Not a binary operator, so end of the binary
	expression. */
	goto out;
	}
	c_parser_consume_token (parser);
	while (oprec <= stack[sp].prec)
	POP;
	switch (ocode)
	{
	case TRUTH_ANDIF_EXPR:
	stack[sp].expr
	= default_function_array_conversion (stack[sp].expr);
	stack[sp].expr.value = c_objc_common_truthvalue_conversion
	(default_conversion (stack[sp].expr.value));
	skip_evaluation += stack[sp].expr.value == truthvalue_false_node;
	break;
	case TRUTH_ORIF_EXPR:
	stack[sp].expr
	= default_function_array_conversion (stack[sp].expr);
	stack[sp].expr.value = c_objc_common_truthvalue_conversion
	(default_conversion (stack[sp].expr.value));
	skip_evaluation += stack[sp].expr.value == truthvalue_true_node;
	break;
	default:
	break;
	}
	sp++;
	stack[sp].expr = c_parser_cast_expression (parser, NULL);
	stack[sp].prec = oprec;
	stack[sp].op = ocode;
	}
	out:
	while (sp > 0)
	POP;
	return stack[0].expr;
	#undef POP
	}

	/* Parse a cast expression (C90 6.3.4, C99 6.5.4). If AFTER is not
	NULL then it is an Objective-C message expression which is the
	primary-expression starting the expression as an initializer.

	cast-expression:
	unary-expression
	( type-name ) unary-expression
	*/

	static struct c_expr
	c_parser_cast_expression (c_parser parser, struct c_expr after)
	{
	gcc_assert (!after \|\| c_dialect_objc ());
	if (after)
	return c_parser_postfix_expression_after_primary (parser, *after);
	/* If the expression begins with a parenthesized type name, it may
	be either a cast or a compound literal; we need to see whether
	the next character is '{' to tell the difference. If not, it is
	an unary expression. */
	if (c_parser_next_token_is (parser, CPP_OPEN_PAREN)
	&& c_token_starts_typename (c_parser_peek_2nd_token (parser)))
	{
	struct c_type_name *type_name;
	struct c_expr ret;
	struct c_expr expr;
	c_parser_consume_token (parser);
	type_name = c_parser_type_name (parser);
	c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, "expected %<)%>");
	if (type_name == NULL)
	{
	ret.value = error_mark_node;
	ret.original_code = ERROR_MARK;
	return ret;
	}

	/* Save casted types in the function's used types hash table. */
	used_types_insert (type_name->specs->type);

	if (c_parser_next_token_is (parser, CPP_OPEN_BRACE))
	return c_parser_postfix_expression_after_paren_type (parser,
	type_name);
	expr = c_parser_cast_expression (parser, NULL);
	expr = default_function_array_conversion (expr);
	ret.value = c_cast_expr (type_name, expr.value);
	ret.original_code = ERROR_MARK;
	return ret;
	}
	else
	return c_parser_unary_expression (parser);
	}

	/* Parse an unary expression (C90 6.3.3, C99 6.5.3).

	unary-expression:
	postfix-expression
	++ unary-expression
	-- unary-expression
	unary-operator cast-expression
	sizeof unary-expression
	sizeof ( type-name )

	unary-operator: one of
	& * + - ~ !

	GNU extensions:

	unary-expression:
	__alignof__ unary-expression
	__alignof__ ( type-name )
	&& identifier

	unary-operator: one of
	__extension__ __real__ __imag__

	In addition, the GNU syntax treats ++ and -- as unary operators, so
	they may be applied to cast expressions with errors for non-lvalues
	given later. */

	static struct c_expr
	c_parser_unary_expression (c_parser *parser)
	{
	int ext;
	struct c_expr ret, op;
	switch (c_parser_peek_token (parser)->type)
	{
	case CPP_PLUS_PLUS:
	c_parser_consume_token (parser);
	op = c_parser_cast_expression (parser, NULL);
	op = default_function_array_conversion (op);
	return parser_build_unary_op (PREINCREMENT_EXPR, op);
	case CPP_MINUS_MINUS:
	c_parser_consume_token (parser);
	op = c_parser_cast_expression (parser, NULL);
	op = default_function_array_conversion (op);
	return parser_build_unary_op (PREDECREMENT_EXPR, op);
	case CPP_AND:
	c_parser_consume_token (parser);
	return parser_build_unary_op (ADDR_EXPR,
	c_parser_cast_expression (parser, NULL));
	case CPP_MULT:
	c_parser_consume_token (parser);
	op = c_parser_cast_expression (parser, NULL);
	op = default_function_array_conversion (op);
	ret.value = build_indirect_ref (op.value, "unary *");
	ret.original_code = ERROR_MARK;
	return ret;
	case CPP_PLUS:
	c_parser_consume_token (parser);
	if (!c_dialect_objc () && !in_system_header)
	warning (OPT_Wtraditional,
	"traditional C rejects the unary plus operator");
	op = c_parser_cast_expression (parser, NULL);
	op = default_function_array_conversion (op);
	return parser_build_unary_op (CONVERT_EXPR, op);
	case CPP_MINUS:
	c_parser_consume_token (parser);
	op = c_parser_cast_expression (parser, NULL);
	op = default_function_array_conversion (op);
	return parser_build_unary_op (NEGATE_EXPR, op);
	case CPP_COMPL:
	c_parser_consume_token (parser);
	op = c_parser_cast_expression (parser, NULL);
	op = default_function_array_conversion (op);
	return parser_build_unary_op (BIT_NOT_EXPR, op);
	case CPP_NOT:
	c_parser_consume_token (parser);
	op = c_parser_cast_expression (parser, NULL);
	op = default_function_array_conversion (op);
	return parser_build_unary_op (TRUTH_NOT_EXPR, op);
	case CPP_AND_AND:
	/* Refer to the address of a label as a pointer. */
	c_parser_consume_token (parser);
	if (c_parser_next_token_is (parser, CPP_NAME))
	{
	ret.value = finish_label_address_expr
	(c_parser_peek_token (parser)->value);
	c_parser_consume_token (parser);
	}
	else
	{
	c_parser_error (parser, "expected identifier");
	ret.value = error_mark_node;
	}
	ret.original_code = ERROR_MARK;
	return ret;
	case CPP_KEYWORD:
	switch (c_parser_peek_token (parser)->keyword)
	{
	case RID_SIZEOF:
	return c_parser_sizeof_expression (parser);
	case RID_ALIGNOF:
	return c_parser_alignof_expression (parser);
	case RID_EXTENSION:
	c_parser_consume_token (parser);
	ext = disable_extension_diagnostics ();
	ret = c_parser_cast_expression (parser, NULL);
	restore_extension_diagnostics (ext);
	return ret;
	case RID_REALPART:
	c_parser_consume_token (parser);
	op = c_parser_cast_expression (parser, NULL);
	op = default_function_array_conversion (op);
	return parser_build_unary_op (REALPART_EXPR, op);
	case RID_IMAGPART:
	c_parser_consume_token (parser);
	op = c_parser_cast_expression (parser, NULL);
	op = default_function_array_conversion (op);
	return parser_build_unary_op (IMAGPART_EXPR, op);
	default:
	return c_parser_postfix_expression (parser);
	}
	default:
	return c_parser_postfix_expression (parser);
	}
	}

	/* Parse a sizeof expression. */

	static struct c_expr
	c_parser_sizeof_expression (c_parser *parser)
	{
	struct c_expr expr;
	gcc_assert (c_parser_next_token_is_keyword (parser, RID_SIZEOF));
	c_parser_consume_token (parser);
	skip_evaluation++;
	in_sizeof++;
	if (c_parser_next_token_is (parser, CPP_OPEN_PAREN)
	&& c_token_starts_typename (c_parser_peek_2nd_token (parser)))
	{
	/* Either sizeof ( type-name ) or sizeof unary-expression
	starting with a compound literal. */
	struct c_type_name *type_name;
	c_parser_consume_token (parser);
	type_name = c_parser_type_name (parser);
	c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, "expected %<)%>");
	if (type_name == NULL)
	{
	struct c_expr ret;
	skip_evaluation--;
	in_sizeof--;
	ret.value = error_mark_node;
	ret.original_code = ERROR_MARK;
	return ret;
	}
	if (c_parser_next_token_is (parser, CPP_OPEN_BRACE))
	{
	expr = c_parser_postfix_expression_after_paren_type (parser,
	type_name);
	goto sizeof_expr;
	}
	/* sizeof ( type-name ). */
	skip_evaluation--;
	in_sizeof--;
	if (type_name->declarator->kind == cdk_array
	&& type_name->declarator->u.array.vla_unspec_p)
	{
	/* C99 6.7.5.2p4 */
	error ("%<[*]%> not allowed in other than a declaration");
	}
	return c_expr_sizeof_type (type_name);
	}
	else
	{
	expr = c_parser_unary_expression (parser);
	sizeof_expr:
	skip_evaluation--;
	in_sizeof--;
	if (TREE_CODE (expr.value) == COMPONENT_REF
	&& DECL_C_BIT_FIELD (TREE_OPERAND (expr.value, 1)))
	error ("%<sizeof%> applied to a bit-field");
	return c_expr_sizeof_expr (expr);
	}
	}

	/* Parse an alignof expression. */

	static struct c_expr
	c_parser_alignof_expression (c_parser *parser)
	{
	struct c_expr expr;
	gcc_assert (c_parser_next_token_is_keyword (parser, RID_ALIGNOF));
	c_parser_consume_token (parser);
	skip_evaluation++;
	in_alignof++;
	if (c_parser_next_token_is (parser, CPP_OPEN_PAREN)
	&& c_token_starts_typename (c_parser_peek_2nd_token (parser)))
	{
	/* Either __alignof__ ( type-name ) or __alignof__
	unary-expression starting with a compound literal. */
	struct c_type_name *type_name;
	struct c_expr ret;
	c_parser_consume_token (parser);
	type_name = c_parser_type_name (parser);
	c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, "expected %<)%>");
	if (type_name == NULL)
	{
	struct c_expr ret;
	skip_evaluation--;
	in_alignof--;
	ret.value = error_mark_node;
	ret.original_code = ERROR_MARK;
	return ret;
	}
	if (c_parser_next_token_is (parser, CPP_OPEN_BRACE))
	{
	expr = c_parser_postfix_expression_after_paren_type (parser,
	type_name);
	goto alignof_expr;
	}
	/* alignof ( type-name ). */
	skip_evaluation--;
	in_alignof--;
	ret.value = c_alignof (groktypename (type_name));
	ret.original_code = ERROR_MARK;
	return ret;
	}
	else
	{
	struct c_expr ret;
	expr = c_parser_unary_expression (parser);
	alignof_expr:
	skip_evaluation--;
	in_alignof--;
	ret.value = c_alignof_expr (expr.value);
	ret.original_code = ERROR_MARK;
	return ret;
	}
	}

	/* Parse a postfix expression (C90 6.3.1-6.3.2, C99 6.5.1-6.5.2).

	postfix-expression:
	primary-expression
	postfix-expression [ expression ]
	postfix-expression ( argument-expression-list[opt] )
	postfix-expression . identifier
	postfix-expression -> identifier
	postfix-expression ++
	postfix-expression --
	( type-name ) { initializer-list }
	( type-name ) { initializer-list , }

	argument-expression-list:
	argument-expression
	argument-expression-list , argument-expression

	primary-expression:
	identifier
	constant
	string-literal
	( expression )

	GNU extensions:

	primary-expression:
	__func__
	(treated as a keyword in GNU C)
	__FUNCTION__
	__PRETTY_FUNCTION__
	( compound-statement )
	__builtin_va_arg ( assignment-expression , type-name )
	__builtin_offsetof ( type-name , offsetof-member-designator )
	__builtin_choose_expr ( assignment-expression ,
	assignment-expression ,
	assignment-expression )
	__builtin_types_compatible_p ( type-name , type-name )

	offsetof-member-designator:
	identifier
	offsetof-member-designator . identifier
	offsetof-member-designator [ expression ]

	Objective-C:

	primary-expression:
	[ objc-receiver objc-message-args ]
	@selector ( objc-selector-arg )
	@protocol ( identifier )
	@encode ( type-name )
	objc-string-literal
	*/

	static struct c_expr
	c_parser_postfix_expression (c_parser *parser)
	{
	struct c_expr expr, e1, e2, e3;
	struct c_type_name t1, t2;
	switch (c_parser_peek_token (parser)->type)
	{
	case CPP_NUMBER:
	case CPP_CHAR:
	case CPP_WCHAR:
	expr.value = c_parser_peek_token (parser)->value;
	expr.original_code = ERROR_MARK;
	c_parser_consume_token (parser);
	break;
	case CPP_STRING:
	case CPP_WSTRING:
	expr.value = c_parser_peek_token (parser)->value;
	expr.original_code = STRING_CST;
	c_parser_consume_token (parser);
	break;
	case CPP_OBJC_STRING:
	gcc_assert (c_dialect_objc ());
	expr.value
	= objc_build_string_object (c_parser_peek_token (parser)->value);
	expr.original_code = ERROR_MARK;
	c_parser_consume_token (parser);
	break;
	case CPP_NAME:
	if (c_parser_peek_token (parser)->id_kind != C_ID_ID)
	{
	c_parser_error (parser, "expected expression");
	expr.value = error_mark_node;
	expr.original_code = ERROR_MARK;
	break;
	}
	{
	tree id = c_parser_peek_token (parser)->value;
	location_t loc = c_parser_peek_token (parser)->location;
	c_parser_consume_token (parser);
	expr.value = build_external_ref (id,
	(c_parser_peek_token (parser)->type
	== CPP_OPEN_PAREN), loc);
	expr.original_code = ERROR_MARK;
	}
	break;
	case CPP_OPEN_PAREN:
	/* A parenthesized expression, statement expression or compound
	literal. */
	if (c_parser_peek_2nd_token (parser)->type == CPP_OPEN_BRACE)
	{
	/* A statement expression. */
	tree stmt;
	c_parser_consume_token (parser);
	c_parser_consume_token (parser);
	if (cur_stmt_list == NULL)
	{
	error ("braced-group within expression allowed "
	"only inside a function");
	parser->error = true;
	c_parser_skip_until_found (parser, CPP_CLOSE_BRACE, NULL);
	c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, NULL);
	expr.value = error_mark_node;
	expr.original_code = ERROR_MARK;
	break;
	}
	stmt = c_begin_stmt_expr ();
	c_parser_compound_statement_nostart (parser);
	c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
	"expected %<)%>");
	if (pedantic)
	pedwarn ("ISO C forbids braced-groups within expressions");
	expr.value = c_finish_stmt_expr (stmt);
	expr.original_code = ERROR_MARK;
	}
	else if (c_token_starts_typename (c_parser_peek_2nd_token (parser)))
	{
	/* A compound literal. ??? Can we actually get here rather
	than going directly to
	c_parser_postfix_expression_after_paren_type from
	elsewhere? */
	struct c_type_name *type_name;
	c_parser_consume_token (parser);
	type_name = c_parser_type_name (parser);
	c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
	"expected %<)%>");
	if (type_name == NULL)
	{
	expr.value = error_mark_node;
	expr.original_code = ERROR_MARK;
	}
	else
	expr = c_parser_postfix_expression_after_paren_type (parser,
	type_name);
	}
	else
	{
	/* A parenthesized expression. */
	c_parser_consume_token (parser);
	expr = c_parser_expression (parser);
	if (TREE_CODE (expr.value) == MODIFY_EXPR)
	TREE_NO_WARNING (expr.value) = 1;
	expr.original_code = ERROR_MARK;
	c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
	"expected %<)%>");
	}
	break;
	case CPP_KEYWORD:
	switch (c_parser_peek_token (parser)->keyword)
	{
	case RID_FUNCTION_NAME:
	case RID_PRETTY_FUNCTION_NAME:
	case RID_C99_FUNCTION_NAME:
	expr.value = fname_decl (c_parser_peek_token (parser)->keyword,
	c_parser_peek_token (parser)->value);
	expr.original_code = ERROR_MARK;
	c_parser_consume_token (parser);
	break;
	case RID_VA_ARG:
	c_parser_consume_token (parser);
	if (!c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>"))
	{
	expr.value = error_mark_node;
	expr.original_code = ERROR_MARK;
	break;
	}
	e1 = c_parser_expr_no_commas (parser, NULL);
	if (!c_parser_require (parser, CPP_COMMA, "expected %<,%>"))
	{
	c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, NULL);
	expr.value = error_mark_node;
	expr.original_code = ERROR_MARK;
	break;
	}
	t1 = c_parser_type_name (parser);
	c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
	"expected %<)%>");
	if (t1 == NULL)
	{
	expr.value = error_mark_node;
	expr.original_code = ERROR_MARK;
	}
	else
	{
	expr.value = build_va_arg (e1.value, groktypename (t1));
	expr.original_code = ERROR_MARK;
	}
	break;
	case RID_OFFSETOF:
	c_parser_consume_token (parser);
	if (!c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>"))
	{
	expr.value = error_mark_node;
	expr.original_code = ERROR_MARK;
	break;
	}
	t1 = c_parser_type_name (parser);
	if (t1 == NULL)
	{
	expr.value = error_mark_node;
	expr.original_code = ERROR_MARK;
	break;
	}
	if (!c_parser_require (parser, CPP_COMMA, "expected %<,%>"))
	{
	c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, NULL);
	expr.value = error_mark_node;
	expr.original_code = ERROR_MARK;
	break;
	}
	{
	tree type = groktypename (t1);
	tree offsetof_ref;
	if (type == error_mark_node)
	offsetof_ref = error_mark_node;
	else
	offsetof_ref = build1 (INDIRECT_REF, type, null_pointer_node);
	/* Parse the second argument to __builtin_offsetof. We
	must have one identifier, and beyond that we want to
	accept sub structure and sub array references. */
	if (c_parser_next_token_is (parser, CPP_NAME))
	{
	offsetof_ref = build_component_ref
	(offsetof_ref, c_parser_peek_token (parser)->value);
	c_parser_consume_token (parser);
	while (c_parser_next_token_is (parser, CPP_DOT)
	\|\| c_parser_next_token_is (parser,
	CPP_OPEN_SQUARE))
	{
	if (c_parser_next_token_is (parser, CPP_DOT))
	{
	c_parser_consume_token (parser);
	if (c_parser_next_token_is_not (parser,
	CPP_NAME))
	{
	c_parser_error (parser, "expected identifier");
	break;
	}
	offsetof_ref = build_component_ref
	(offsetof_ref,
	c_parser_peek_token (parser)->value);
	c_parser_consume_token (parser);
	}
	else
	{
	tree idx;
	c_parser_consume_token (parser);
	idx = c_parser_expression (parser).value;
	c_parser_skip_until_found (parser, CPP_CLOSE_SQUARE,
	"expected %<]%>");
	offsetof_ref = build_array_ref (offsetof_ref, idx);
	}
	}
	}
	else
	c_parser_error (parser, "expected identifier");
	c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
	"expected %<)%>");
	expr.value = fold_offsetof (offsetof_ref, NULL_TREE);
	expr.original_code = ERROR_MARK;
	}
	break;
	case RID_CHOOSE_EXPR:
	c_parser_consume_token (parser);
	if (!c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>"))
	{
	expr.value = error_mark_node;
	expr.original_code = ERROR_MARK;
	break;
	}
	e1 = c_parser_expr_no_commas (parser, NULL);
	if (!c_parser_require (parser, CPP_COMMA, "expected %<,%>"))
	{
	c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, NULL);
	expr.value = error_mark_node;
	expr.original_code = ERROR_MARK;
	break;
	}
	e2 = c_parser_expr_no_commas (parser, NULL);
	if (!c_parser_require (parser, CPP_COMMA, "expected %<,%>"))
	{
	c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, NULL);
	expr.value = error_mark_node;
	expr.original_code = ERROR_MARK;
	break;
	}
	e3 = c_parser_expr_no_commas (parser, NULL);
	c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
	"expected %<)%>");
	{
	tree c;

	c = fold (e1.value);
	if (TREE_CODE (c) != INTEGER_CST)
	error ("first argument to %<__builtin_choose_expr%> not"
	" a constant");
	expr = integer_zerop (c) ? e3 : e2;
	}
	break;
	case RID_TYPES_COMPATIBLE_P:
	c_parser_consume_token (parser);
	if (!c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>"))
	{
	expr.value = error_mark_node;
	expr.original_code = ERROR_MARK;
	break;
	}
	t1 = c_parser_type_name (parser);
	if (t1 == NULL)
	{
	expr.value = error_mark_node;
	expr.original_code = ERROR_MARK;
	break;
	}
	if (!c_parser_require (parser, CPP_COMMA, "expected %<,%>"))
	{
	c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, NULL);
	expr.value = error_mark_node;
	expr.original_code = ERROR_MARK;
	break;
	}
	t2 = c_parser_type_name (parser);
	if (t2 == NULL)
	{
	expr.value = error_mark_node;
	expr.original_code = ERROR_MARK;
	break;
	}
	c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
	"expected %<)%>");
	{
	tree e1, e2;

	e1 = TYPE_MAIN_VARIANT (groktypename (t1));
	e2 = TYPE_MAIN_VARIANT (groktypename (t2));

	expr.value = comptypes (e1, e2)
	? build_int_cst (NULL_TREE, 1)
	: build_int_cst (NULL_TREE, 0);
	expr.original_code = ERROR_MARK;
	}
	break;
	case RID_AT_SELECTOR:
	gcc_assert (c_dialect_objc ());
	c_parser_consume_token (parser);
	if (!c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>"))
	{
	expr.value = error_mark_node;
	expr.original_code = ERROR_MARK;
	break;
	}
	{
	tree sel = c_parser_objc_selector_arg (parser);
	c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
	"expected %<)%>");
	expr.value = objc_build_selector_expr (sel);
	expr.original_code = ERROR_MARK;
	}
	break;
	case RID_AT_PROTOCOL:
	gcc_assert (c_dialect_objc ());
	c_parser_consume_token (parser);
	if (!c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>"))
	{
	expr.value = error_mark_node;
	expr.original_code = ERROR_MARK;
	break;
	}
	if (c_parser_next_token_is_not (parser, CPP_NAME))
	{
	c_parser_error (parser, "expected identifier");
	c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, NULL);
	expr.value = error_mark_node;
	expr.original_code = ERROR_MARK;
	break;
	}
	{
	tree id = c_parser_peek_token (parser)->value;
	c_parser_consume_token (parser);
	c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
	"expected %<)%>");
	expr.value = objc_build_protocol_expr (id);
	expr.original_code = ERROR_MARK;
	}
	break;
	case RID_AT_ENCODE:
	/* Extension to support C-structures in the archiver. */
	gcc_assert (c_dialect_objc ());
	c_parser_consume_token (parser);
	if (!c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>"))
	{
	expr.value = error_mark_node;
	expr.original_code = ERROR_MARK;
	break;
	}
	t1 = c_parser_type_name (parser);
	if (t1 == NULL)
	{
	expr.value = error_mark_node;
	expr.original_code = ERROR_MARK;
	c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, NULL);
	break;
	}
	c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
	"expected %<)%>");
	{
	tree type = groktypename (t1);
	expr.value = objc_build_encode_expr (type);
	expr.original_code = ERROR_MARK;
	}
	break;
	default:
	c_parser_error (parser, "expected expression");
	expr.value = error_mark_node;
	expr.original_code = ERROR_MARK;
	break;
	}
	break;
	case CPP_OPEN_SQUARE:
	if (c_dialect_objc ())
	{
	tree receiver, args;
	c_parser_consume_token (parser);
	receiver = c_parser_objc_receiver (parser);
	args = c_parser_objc_message_args (parser);
	c_parser_skip_until_found (parser, CPP_CLOSE_SQUARE,
	"expected %<]%>");
	expr.value = objc_build_message_expr (build_tree_list (receiver,
	args));
	expr.original_code = ERROR_MARK;
	break;
	}
	/* Else fall through to report error. */
	default:
	c_parser_error (parser, "expected expression");
	expr.value = error_mark_node;
	expr.original_code = ERROR_MARK;
	break;
	}
	return c_parser_postfix_expression_after_primary (parser, expr);
	}

	/* Parse a postfix expression after a parenthesized type name: the
	brace-enclosed initializer of a compound literal, possibly followed
	by some postfix operators. This is separate because it is not
	possible to tell until after the type name whether a cast
	expression has a cast or a compound literal, or whether the operand
	of sizeof is a parenthesized type name or starts with a compound
	literal. */

	static struct c_expr
	c_parser_postfix_expression_after_paren_type (c_parser *parser,
	struct c_type_name *type_name)
	{
	tree type;
	struct c_expr init;
	struct c_expr expr;
	start_init (NULL_TREE, NULL, 0);
	type = groktypename (type_name);
	if (type != error_mark_node && C_TYPE_VARIABLE_SIZE (type))
	{
	error ("compound literal has variable size");
	type = error_mark_node;
	}
	init = c_parser_braced_init (parser, type, false);
	finish_init ();
	maybe_warn_string_init (type, init);

	if (pedantic && !flag_isoc99)
	pedwarn ("ISO C90 forbids compound literals");
	expr.value = build_compound_literal (type, init.value);
	expr.original_code = ERROR_MARK;
	return c_parser_postfix_expression_after_primary (parser, expr);
	}

	/* Parse a postfix expression after the initial primary or compound
	literal; that is, parse a series of postfix operators. */

	static struct c_expr
	c_parser_postfix_expression_after_primary (c_parser *parser,
	struct c_expr expr)
	{
	tree ident, idx, exprlist;
	while (true)
	{
	switch (c_parser_peek_token (parser)->type)
	{
	case CPP_OPEN_SQUARE:
	/* Array reference. */
	c_parser_consume_token (parser);
	idx = c_parser_expression (parser).value;
	c_parser_skip_until_found (parser, CPP_CLOSE_SQUARE,
	"expected %<]%>");
	expr.value = build_array_ref (expr.value, idx);
	expr.original_code = ERROR_MARK;
	break;
	case CPP_OPEN_PAREN:
	/* Function call. */
	c_parser_consume_token (parser);
	if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN))
	exprlist = NULL_TREE;
	else
	exprlist = c_parser_expr_list (parser, true);
	c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
	"expected %<)%>");
	expr.value = build_function_call (expr.value, exprlist);
	expr.original_code = ERROR_MARK;
	break;
	case CPP_DOT:
	/* Structure element reference. */
	c_parser_consume_token (parser);
	expr = default_function_array_conversion (expr);
	if (c_parser_next_token_is (parser, CPP_NAME))
	ident = c_parser_peek_token (parser)->value;
	else
	{
	c_parser_error (parser, "expected identifier");
	expr.value = error_mark_node;
	expr.original_code = ERROR_MARK;
	return expr;
	}
	c_parser_consume_token (parser);
	expr.value = build_component_ref (expr.value, ident);
	expr.original_code = ERROR_MARK;
	break;
	case CPP_DEREF:
	/* Structure element reference. */
	c_parser_consume_token (parser);
	expr = default_function_array_conversion (expr);
	if (c_parser_next_token_is (parser, CPP_NAME))
	ident = c_parser_peek_token (parser)->value;
	else
	{
	c_parser_error (parser, "expected identifier");
	expr.value = error_mark_node;
	expr.original_code = ERROR_MARK;
	return expr;
	}
	c_parser_consume_token (parser);
	expr.value = build_component_ref (build_indirect_ref (expr.value,
	"->"), ident);
	expr.original_code = ERROR_MARK;
	break;
	case CPP_PLUS_PLUS:
	/* Postincrement. */
	c_parser_consume_token (parser);
	expr = default_function_array_conversion (expr);
	expr.value = build_unary_op (POSTINCREMENT_EXPR, expr.value, 0);
	expr.original_code = ERROR_MARK;
	break;
	case CPP_MINUS_MINUS:
	/* Postdecrement. */
	c_parser_consume_token (parser);
	expr = default_function_array_conversion (expr);
	expr.value = build_unary_op (POSTDECREMENT_EXPR, expr.value, 0);
	expr.original_code = ERROR_MARK;
	break;
	default:
	return expr;
	}
	}
	}

	/* Parse an expression (C90 6.3.17, C99 6.5.17).

	expression:
	assignment-expression
	expression , assignment-expression
	*/

	static struct c_expr
	c_parser_expression (c_parser *parser)
	{
	struct c_expr expr;
	expr = c_parser_expr_no_commas (parser, NULL);
	while (c_parser_next_token_is (parser, CPP_COMMA))
	{
	struct c_expr next;
	c_parser_consume_token (parser);
	next = c_parser_expr_no_commas (parser, NULL);
	next = default_function_array_conversion (next);
	expr.value = build_compound_expr (expr.value, next.value);
	expr.original_code = COMPOUND_EXPR;
	}
	return expr;
	}

	/* Parse an expression and convert functions or arrays to
	pointers. */

	static struct c_expr
	c_parser_expression_conv (c_parser *parser)
	{
	struct c_expr expr;
	expr = c_parser_expression (parser);
	expr = default_function_array_conversion (expr);
	return expr;
	}

	/* Parse a non-empty list of expressions. If CONVERT_P, convert
	functions and arrays to pointers.

	nonempty-expr-list:
	assignment-expression
	nonempty-expr-list , assignment-expression
	*/

	static tree
	c_parser_expr_list (c_parser *parser, bool convert_p)
	{
	struct c_expr expr;
	tree ret, cur;
	expr = c_parser_expr_no_commas (parser, NULL);
	if (convert_p)
	expr = default_function_array_conversion (expr);
	ret = cur = build_tree_list (NULL_TREE, expr.value);
	while (c_parser_next_token_is (parser, CPP_COMMA))
	{
	c_parser_consume_token (parser);
	expr = c_parser_expr_no_commas (parser, NULL);
	if (convert_p)
	expr = default_function_array_conversion (expr);
	cur = TREE_CHAIN (cur) = build_tree_list (NULL_TREE, expr.value);
	}
	return ret;
	}


	/* Parse Objective-C-specific constructs. */

	/* Parse an objc-class-definition.

	objc-class-definition:
	@interface identifier objc-superclass[opt] objc-protocol-refs[opt]
	objc-class-instance-variables[opt] objc-methodprotolist @end
	@implementation identifier objc-superclass[opt]
	objc-class-instance-variables[opt]
	@interface identifier ( identifier ) objc-protocol-refs[opt]
	objc-methodprotolist @end
	@implementation identifier ( identifier )

	objc-superclass:
	: identifier

	"@interface identifier (" must start "@interface identifier (
	identifier ) ...": objc-methodprotolist in the first production may
	not start with a parenthesized identifier as a declarator of a data
	definition with no declaration specifiers if the objc-superclass,
	objc-protocol-refs and objc-class-instance-variables are omitted. */

	static void
	c_parser_objc_class_definition (c_parser *parser)
	{
	bool iface_p;
	tree id1;
	tree superclass;
	if (c_parser_next_token_is_keyword (parser, RID_AT_INTERFACE))
	iface_p = true;
	else if (c_parser_next_token_is_keyword (parser, RID_AT_IMPLEMENTATION))
	iface_p = false;
	else
	gcc_unreachable ();
	c_parser_consume_token (parser);
	if (c_parser_next_token_is_not (parser, CPP_NAME))
	{
	c_parser_error (parser, "expected identifier");
	return;
	}
	id1 = c_parser_peek_token (parser)->value;
	c_parser_consume_token (parser);
	if (c_parser_next_token_is (parser, CPP_OPEN_PAREN))
	{
	tree id2;
	tree proto = NULL_TREE;
	c_parser_consume_token (parser);
	if (c_parser_next_token_is_not (parser, CPP_NAME))
	{
	c_parser_error (parser, "expected identifier");
	c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, NULL);
	return;
	}
	id2 = c_parser_peek_token (parser)->value;
	c_parser_consume_token (parser);
	c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, "expected %<)%>");
	if (!iface_p)
	{
	objc_start_category_implementation (id1, id2);
	return;
	}
	if (c_parser_next_token_is (parser, CPP_LESS))
	proto = c_parser_objc_protocol_refs (parser);
	objc_start_category_interface (id1, id2, proto);
	c_parser_objc_methodprotolist (parser);
	c_parser_require_keyword (parser, RID_AT_END, "expected %<@end%>");
	objc_finish_interface ();
	return;
	}
	if (c_parser_next_token_is (parser, CPP_COLON))
	{
	c_parser_consume_token (parser);
	if (c_parser_next_token_is_not (parser, CPP_NAME))
	{
	c_parser_error (parser, "expected identifier");
	return;
	}
	superclass = c_parser_peek_token (parser)->value;
	c_parser_consume_token (parser);
	}
	else
	superclass = NULL_TREE;
	if (iface_p)
	{
	tree proto = NULL_TREE;
	if (c_parser_next_token_is (parser, CPP_LESS))
	proto = c_parser_objc_protocol_refs (parser);
	objc_start_class_interface (id1, superclass, proto);
	}
	else
	objc_start_class_implementation (id1, superclass);
	if (c_parser_next_token_is (parser, CPP_OPEN_BRACE))
	c_parser_objc_class_instance_variables (parser);
	if (iface_p)
	{
	objc_continue_interface ();
	c_parser_objc_methodprotolist (parser);
	c_parser_require_keyword (parser, RID_AT_END, "expected %<@end%>");
	objc_finish_interface ();
	}
	else
	{
	objc_continue_implementation ();
	return;
	}
	}

	/* Parse objc-class-instance-variables.

	objc-class-instance-variables:
	{ objc-instance-variable-decl-list[opt] }

	objc-instance-variable-decl-list:
	objc-visibility-spec
	objc-instance-variable-decl ;
	;
	objc-instance-variable-decl-list objc-visibility-spec
	objc-instance-variable-decl-list objc-instance-variable-decl ;
	objc-instance-variable-decl-list ;

	objc-visibility-spec:
	@private
	@protected
	@public

	objc-instance-variable-decl:
	struct-declaration
	*/

	static void
	c_parser_objc_class_instance_variables (c_parser *parser)
	{
	gcc_assert (c_parser_next_token_is (parser, CPP_OPEN_BRACE));
	c_parser_consume_token (parser);
	while (c_parser_next_token_is_not (parser, CPP_EOF))
	{
	tree decls;
	/* Parse any stray semicolon. */
	if (c_parser_next_token_is (parser, CPP_SEMICOLON))
	{
	if (pedantic)
	pedwarn ("extra semicolon in struct or union specified");
	c_parser_consume_token (parser);
	continue;
	}
	/* Stop if at the end of the instance variables. */
	if (c_parser_next_token_is (parser, CPP_CLOSE_BRACE))
	{
	c_parser_consume_token (parser);
	break;
	}
	/* Parse any objc-visibility-spec. */
	if (c_parser_next_token_is_keyword (parser, RID_AT_PRIVATE))
	{
	c_parser_consume_token (parser);
	objc_set_visibility (2);
	continue;
	}
	else if (c_parser_next_token_is_keyword (parser, RID_AT_PROTECTED))
	{
	c_parser_consume_token (parser);
	objc_set_visibility (0);
	continue;
	}
	else if (c_parser_next_token_is_keyword (parser, RID_AT_PUBLIC))
	{
	c_parser_consume_token (parser);
	objc_set_visibility (1);
	continue;
	}
	else if (c_parser_next_token_is (parser, CPP_PRAGMA))
	{
	c_parser_pragma (parser, pragma_external);
	continue;
	}

	/* Parse some comma-separated declarations. */
	decls = c_parser_struct_declaration (parser);
	{
	/* Comma-separated instance variables are chained together in
	reverse order; add them one by one. */
	tree ivar = nreverse (decls);
	for (; ivar; ivar = TREE_CHAIN (ivar))
	objc_add_instance_variable (copy_node (ivar));
	}
	c_parser_skip_until_found (parser, CPP_SEMICOLON, "expected %<;%>");
	}
	}

	/* Parse an objc-class-declaration.

	objc-class-declaration:
	@class identifier-list ;
	*/

	static void
	c_parser_objc_class_declaration (c_parser *parser)
	{
	tree list = NULL_TREE;
	gcc_assert (c_parser_next_token_is_keyword (parser, RID_AT_CLASS));
	c_parser_consume_token (parser);
	/* Any identifiers, including those declared as type names, are OK
	here. */
	while (true)
	{
	tree id;
	if (c_parser_next_token_is_not (parser, CPP_NAME))
	{
	c_parser_error (parser, "expected identifier");
	break;
	}
	id = c_parser_peek_token (parser)->value;
	list = chainon (list, build_tree_list (NULL_TREE, id));
	c_parser_consume_token (parser);
	if (c_parser_next_token_is (parser, CPP_COMMA))
	c_parser_consume_token (parser);
	else
	break;
	}
	c_parser_skip_until_found (parser, CPP_SEMICOLON, "expected %<;%>");
	objc_declare_class (list);
	}

	/* Parse an objc-alias-declaration.

	objc-alias-declaration:
	@compatibility_alias identifier identifier ;
	*/

	static void
	c_parser_objc_alias_declaration (c_parser *parser)
	{
	tree id1, id2;
	gcc_assert (c_parser_next_token_is_keyword (parser, RID_AT_ALIAS));
	c_parser_consume_token (parser);
	if (c_parser_next_token_is_not (parser, CPP_NAME))
	{
	c_parser_error (parser, "expected identifier");
	c_parser_skip_until_found (parser, CPP_SEMICOLON, NULL);
	return;
	}
	id1 = c_parser_peek_token (parser)->value;
	c_parser_consume_token (parser);
	if (c_parser_next_token_is_not (parser, CPP_NAME))
	{
	c_parser_error (parser, "expected identifier");
	c_parser_skip_until_found (parser, CPP_SEMICOLON, NULL);
	return;
	}
	id2 = c_parser_peek_token (parser)->value;
	c_parser_consume_token (parser);
	c_parser_skip_until_found (parser, CPP_SEMICOLON, "expected %<;%>");
	objc_declare_alias (id1, id2);
	}

	/* Parse an objc-protocol-definition.

	objc-protocol-definition:
	@protocol identifier objc-protocol-refs[opt] objc-methodprotolist @end
	@protocol identifier-list ;

	"@protocol identifier ;" should be resolved as "@protocol
	identifier-list ;": objc-methodprotolist may not start with a
	semicolon in the first alternative if objc-protocol-refs are
	omitted. */

	static void
	c_parser_objc_protocol_definition (c_parser *parser)
	{
	gcc_assert (c_parser_next_token_is_keyword (parser, RID_AT_PROTOCOL));
	c_parser_consume_token (parser);
	if (c_parser_next_token_is_not (parser, CPP_NAME))
	{
	c_parser_error (parser, "expected identifier");
	return;
	}
	if (c_parser_peek_2nd_token (parser)->type == CPP_COMMA
	\|\| c_parser_peek_2nd_token (parser)->type == CPP_SEMICOLON)
	{
	tree list = NULL_TREE;
	/* Any identifiers, including those declared as type names, are
	OK here. */
	while (true)
	{
	tree id;
	if (c_parser_next_token_is_not (parser, CPP_NAME))
	{
	c_parser_error (parser, "expected identifier");
	break;
	}
	id = c_parser_peek_token (parser)->value;
	list = chainon (list, build_tree_list (NULL_TREE, id));
	c_parser_consume_token (parser);
	if (c_parser_next_token_is (parser, CPP_COMMA))
	c_parser_consume_token (parser);
	else
	break;
	}
	c_parser_skip_until_found (parser, CPP_SEMICOLON, "expected %<;%>");
	objc_declare_protocols (list);
	}
	else
	{
	tree id = c_parser_peek_token (parser)->value;
	tree proto = NULL_TREE;
	c_parser_consume_token (parser);
	if (c_parser_next_token_is (parser, CPP_LESS))
	proto = c_parser_objc_protocol_refs (parser);
	objc_pq_context = 1;
	objc_start_protocol (id, proto);
	c_parser_objc_methodprotolist (parser);
	c_parser_require_keyword (parser, RID_AT_END, "expected %<@end%>");
	objc_pq_context = 0;
	objc_finish_interface ();
	}
	}

	/* Parse an objc-method-type.

	objc-method-type:
	+
	-
	*/

	static enum tree_code
	c_parser_objc_method_type (c_parser *parser)
	{
	switch (c_parser_peek_token (parser)->type)
	{
	case CPP_PLUS:
	c_parser_consume_token (parser);
	return PLUS_EXPR;
	case CPP_MINUS:
	c_parser_consume_token (parser);
	return MINUS_EXPR;
	default:
	gcc_unreachable ();
	}
	}

	/* Parse an objc-method-definition.

	objc-method-definition:
	objc-method-type objc-method-decl ;[opt] compound-statement
	*/

	static void
	c_parser_objc_method_definition (c_parser *parser)
	{
	enum tree_code type = c_parser_objc_method_type (parser);
	tree decl;
	objc_set_method_type (type);
	objc_pq_context = 1;
	decl = c_parser_objc_method_decl (parser);
	if (c_parser_next_token_is (parser, CPP_SEMICOLON))
	{
	c_parser_consume_token (parser);
	if (pedantic)
	pedwarn ("extra semicolon in method definition specified");
	}
	if (!c_parser_next_token_is (parser, CPP_OPEN_BRACE))
	{
	c_parser_error (parser, "expected %<{%>");
	return;
	}
	objc_pq_context = 0;
	objc_start_method_definition (decl);
	add_stmt (c_parser_compound_statement (parser));
	objc_finish_method_definition (current_function_decl);
	}

	/* Parse an objc-methodprotolist.

	objc-methodprotolist:
	empty
	objc-methodprotolist objc-methodproto
	objc-methodprotolist declaration
	objc-methodprotolist ;

	The declaration is a data definition, which may be missing
	declaration specifiers under the same rules and diagnostics as
	other data definitions outside functions, and the stray semicolon
	is diagnosed the same way as a stray semicolon outside a
	function. */

	static void
	c_parser_objc_methodprotolist (c_parser *parser)
	{
	while (true)
	{
	/* The list is terminated by @end. */
	switch (c_parser_peek_token (parser)->type)
	{
	case CPP_SEMICOLON:
	if (pedantic)
	pedwarn ("ISO C does not allow extra %<;%> outside of a function");
	c_parser_consume_token (parser);
	break;
	case CPP_PLUS:
	case CPP_MINUS:
	c_parser_objc_methodproto (parser);
	break;
	case CPP_PRAGMA:
	c_parser_pragma (parser, pragma_external);
	break;
	case CPP_EOF:
	return;
	default:
	if (c_parser_next_token_is_keyword (parser, RID_AT_END))
	return;
	c_parser_declaration_or_fndef (parser, false, true, false, true);
	break;
	}
	}
	}

	/* Parse an objc-methodproto.

	objc-methodproto:
	objc-method-type objc-method-decl ;
	*/

	static void
	c_parser_objc_methodproto (c_parser *parser)
	{
	enum tree_code type = c_parser_objc_method_type (parser);
	tree decl;
	objc_set_method_type (type);
	/* Remember protocol qualifiers in prototypes. */
	objc_pq_context = 1;
	decl = c_parser_objc_method_decl (parser);
	/* Forget protocol qualifiers here. */
	objc_pq_context = 0;
	objc_add_method_declaration (decl);
	c_parser_skip_until_found (parser, CPP_SEMICOLON, "expected %<;%>");
	}

	/* Parse an objc-method-decl.

	objc-method-decl:
	( objc-type-name ) objc-selector
	objc-selector
	( objc-type-name ) objc-keyword-selector objc-optparmlist
	objc-keyword-selector objc-optparmlist

	objc-keyword-selector:
	objc-keyword-decl
	objc-keyword-selector objc-keyword-decl

	objc-keyword-decl:
	objc-selector : ( objc-type-name ) identifier
	objc-selector : identifier
	: ( objc-type-name ) identifier
	: identifier

	objc-optparmlist:
	objc-optparms objc-optellipsis

	objc-optparms:
	empty
	objc-opt-parms , parameter-declaration

	objc-optellipsis:
	empty
	, ...
	*/

	static tree
	c_parser_objc_method_decl (c_parser *parser)
	{
	tree type = NULL_TREE;
	tree sel;
	tree parms = NULL_TREE;
	bool ellipsis = false;

	if (c_parser_next_token_is (parser, CPP_OPEN_PAREN))
	{
	c_parser_consume_token (parser);
	type = c_parser_objc_type_name (parser);
	c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, "expected %<)%>");
	}
	sel = c_parser_objc_selector (parser);
	/* If there is no selector, or a colon follows, we have an
	objc-keyword-selector. If there is a selector, and a colon does
	not follow, that selector ends the objc-method-decl. */
	if (!sel \|\| c_parser_next_token_is (parser, CPP_COLON))
	{
	tree tsel = sel;
	tree list = NULL_TREE;
	while (true)
	{
	tree atype = NULL_TREE, id, keyworddecl;
	if (!c_parser_require (parser, CPP_COLON, "expected %<:%>"))
	break;
	if (c_parser_next_token_is (parser, CPP_OPEN_PAREN))
	{
	c_parser_consume_token (parser);
	atype = c_parser_objc_type_name (parser);
	c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
	"expected %<)%>");
	}
	if (c_parser_next_token_is_not (parser, CPP_NAME))
	{
	c_parser_error (parser, "expected identifier");
	return error_mark_node;
	}
	id = c_parser_peek_token (parser)->value;
	c_parser_consume_token (parser);
	keyworddecl = objc_build_keyword_decl (tsel, atype, id);
	list = chainon (list, keyworddecl);
	tsel = c_parser_objc_selector (parser);
	if (!tsel && c_parser_next_token_is_not (parser, CPP_COLON))
	break;
	}
	/* Parse the optional parameter list. Optional Objective-C
	method parameters follow the C syntax, and may include '...'
	to denote a variable number of arguments. */
	parms = make_node (TREE_LIST);
	while (c_parser_next_token_is (parser, CPP_COMMA))
	{
	struct c_parm *parm;
	c_parser_consume_token (parser);
	if (c_parser_next_token_is (parser, CPP_ELLIPSIS))
	{
	ellipsis = true;
	c_parser_consume_token (parser);
	break;
	}
	parm = c_parser_parameter_declaration (parser, NULL_TREE);
	if (parm == NULL)
	break;
	parms = chainon (parms,
	build_tree_list (NULL_TREE, grokparm (parm)));
	}
	sel = list;
	}
	return objc_build_method_signature (type, sel, parms, ellipsis);
	}

	/* Parse an objc-type-name.

	objc-type-name:
	objc-type-qualifiers[opt] type-name
	objc-type-qualifiers[opt]

	objc-type-qualifiers:
	objc-type-qualifier
	objc-type-qualifiers objc-type-qualifier

	objc-type-qualifier: one of
	in out inout bycopy byref oneway
	*/

	static tree
	c_parser_objc_type_name (c_parser *parser)
	{
	tree quals = NULL_TREE;
	struct c_type_name *typename = NULL;
	tree type = NULL_TREE;
	while (true)
	{
	c_token *token = c_parser_peek_token (parser);
	if (token->type == CPP_KEYWORD
	&& (token->keyword == RID_IN
	\|\| token->keyword == RID_OUT
	\|\| token->keyword == RID_INOUT
	\|\| token->keyword == RID_BYCOPY
	\|\| token->keyword == RID_BYREF
	\|\| token->keyword == RID_ONEWAY))
	{
	quals = chainon (quals, build_tree_list (NULL_TREE, token->value));
	c_parser_consume_token (parser);
	}
	else
	break;
	}
	if (c_parser_next_token_starts_typename (parser))
	typename = c_parser_type_name (parser);
	if (typename)
	type = groktypename (typename);
	return build_tree_list (quals, type);
	}

	/* Parse objc-protocol-refs.

	objc-protocol-refs:
	< identifier-list >
	*/

	static tree
	c_parser_objc_protocol_refs (c_parser *parser)
	{
	tree list = NULL_TREE;
	gcc_assert (c_parser_next_token_is (parser, CPP_LESS));
	c_parser_consume_token (parser);
	/* Any identifiers, including those declared as type names, are OK
	here. */
	while (true)
	{
	tree id;
	if (c_parser_next_token_is_not (parser, CPP_NAME))
	{
	c_parser_error (parser, "expected identifier");
	break;
	}
	id = c_parser_peek_token (parser)->value;
	list = chainon (list, build_tree_list (NULL_TREE, id));
	c_parser_consume_token (parser);
	if (c_parser_next_token_is (parser, CPP_COMMA))
	c_parser_consume_token (parser);
	else
	break;
	}
	c_parser_require (parser, CPP_GREATER, "expected %<>%>");
	return list;
	}

	/* Parse an objc-try-catch-statement.

	objc-try-catch-statement:
	@try compound-statement objc-catch-list[opt]
	@try compound-statement objc-catch-list[opt] @finally compound-statement

	objc-catch-list:
	@catch ( parameter-declaration ) compound-statement
	objc-catch-list @catch ( parameter-declaration ) compound-statement
	*/

	static void
	c_parser_objc_try_catch_statement (c_parser *parser)
	{
	location_t loc;
	tree stmt;
	gcc_assert (c_parser_next_token_is_keyword (parser, RID_AT_TRY));
	c_parser_consume_token (parser);
	loc = c_parser_peek_token (parser)->location;
	stmt = c_parser_compound_statement (parser);
	objc_begin_try_stmt (loc, stmt);
	while (c_parser_next_token_is_keyword (parser, RID_AT_CATCH))
	{
	struct c_parm *parm;
	c_parser_consume_token (parser);
	if (!c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>"))
	break;
	parm = c_parser_parameter_declaration (parser, NULL_TREE);
	if (parm == NULL)
	{
	c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, NULL);
	break;
	}
	c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, "expected %<)%>");
	objc_begin_catch_clause (grokparm (parm));
	if (c_parser_require (parser, CPP_OPEN_BRACE, "expected %<{%>"))
	c_parser_compound_statement_nostart (parser);
	objc_finish_catch_clause ();
	}
	if (c_parser_next_token_is_keyword (parser, RID_AT_FINALLY))
	{
	location_t finloc;
	tree finstmt;
	c_parser_consume_token (parser);
	finloc = c_parser_peek_token (parser)->location;
	finstmt = c_parser_compound_statement (parser);
	objc_build_finally_clause (finloc, finstmt);
	}
	objc_finish_try_stmt ();
	}

	/* Parse an objc-synchronized-statement.

	objc-synchronized-statement:
	@synchronized ( expression ) compound-statement
	*/

	static void
	c_parser_objc_synchronized_statement (c_parser *parser)
	{
	location_t loc;
	tree expr, stmt;
	gcc_assert (c_parser_next_token_is_keyword (parser, RID_AT_SYNCHRONIZED));
	c_parser_consume_token (parser);
	loc = c_parser_peek_token (parser)->location;
	if (c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>"))
	{
	expr = c_parser_expression (parser).value;
	c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, "expected %<)%>");
	}
	else
	expr = error_mark_node;
	stmt = c_parser_compound_statement (parser);
	objc_build_synchronized (loc, expr, stmt);
	}

	/* Parse an objc-selector; return NULL_TREE without an error if the
	next token is not an objc-selector.

	objc-selector:
	identifier
	one of
	enum struct union if else while do for switch case default
	break continue return goto asm sizeof typeof __alignof
	unsigned long const short volatile signed restrict _Complex
	in out inout bycopy byref oneway int char float double void _Bool

	??? Why this selection of keywords but not, for example, storage
	class specifiers? */

	static tree
	c_parser_objc_selector (c_parser *parser)
	{
	c_token *token = c_parser_peek_token (parser);
	tree value = token->value;
	if (token->type == CPP_NAME)
	{
	c_parser_consume_token (parser);
	return value;
	}
	if (token->type != CPP_KEYWORD)
	return NULL_TREE;
	switch (token->keyword)
	{
	case RID_ENUM:
	case RID_STRUCT:
	case RID_UNION:
	case RID_IF:
	case RID_ELSE:
	case RID_WHILE:
	case RID_DO:
	case RID_FOR:
	case RID_SWITCH:
	case RID_CASE:
	case RID_DEFAULT:
	case RID_BREAK:
	case RID_CONTINUE:
	case RID_RETURN:
	case RID_GOTO:
	case RID_ASM:
	case RID_SIZEOF:
	case RID_TYPEOF:
	case RID_ALIGNOF:
	case RID_UNSIGNED:
	case RID_LONG:
	case RID_CONST:
	case RID_SHORT:
	case RID_VOLATILE:
	case RID_SIGNED:
	case RID_RESTRICT:
	case RID_COMPLEX:
	case RID_IN:
	case RID_OUT:
	case RID_INOUT:
	case RID_BYCOPY:
	case RID_BYREF:
	case RID_ONEWAY:
	case RID_INT:
	case RID_CHAR:
	case RID_FLOAT:
	case RID_DOUBLE:
	case RID_VOID:
	case RID_BOOL:
	c_parser_consume_token (parser);
	return value;
	default:
	return NULL_TREE;
	}
	}

	/* Parse an objc-selector-arg.

	objc-selector-arg:
	objc-selector
	objc-keywordname-list

	objc-keywordname-list:
	objc-keywordname
	objc-keywordname-list objc-keywordname

	objc-keywordname:
	objc-selector :
	:
	*/

	static tree
	c_parser_objc_selector_arg (c_parser *parser)
	{
	tree sel = c_parser_objc_selector (parser);
	tree list = NULL_TREE;
	if (sel && c_parser_next_token_is_not (parser, CPP_COLON))
	return sel;
	while (true)
	{
	if (!c_parser_require (parser, CPP_COLON, "expected %<:%>"))
	return list;
	list = chainon (list, build_tree_list (sel, NULL_TREE));
	sel = c_parser_objc_selector (parser);
	if (!sel && c_parser_next_token_is_not (parser, CPP_COLON))
	break;
	}
	return list;
	}

	/* Parse an objc-receiver.

	objc-receiver:
	expression
	class-name
	type-name
	*/

	static tree
	c_parser_objc_receiver (c_parser *parser)
	{
	if (c_parser_peek_token (parser)->type == CPP_NAME
	&& (c_parser_peek_token (parser)->id_kind == C_ID_TYPENAME
	\|\| c_parser_peek_token (parser)->id_kind == C_ID_CLASSNAME))
	{
	tree id = c_parser_peek_token (parser)->value;
	c_parser_consume_token (parser);
	return objc_get_class_reference (id);
	}
	return c_parser_expression (parser).value;
	}

	/* Parse objc-message-args.

	objc-message-args:
	objc-selector
	objc-keywordarg-list

	objc-keywordarg-list:
	objc-keywordarg
	objc-keywordarg-list objc-keywordarg

	objc-keywordarg:
	objc-selector : objc-keywordexpr
	: objc-keywordexpr
	*/

	static tree
	c_parser_objc_message_args (c_parser *parser)
	{
	tree sel = c_parser_objc_selector (parser);
	tree list = NULL_TREE;
	if (sel && c_parser_next_token_is_not (parser, CPP_COLON))
	return sel;
	while (true)
	{
	tree keywordexpr;
	if (!c_parser_require (parser, CPP_COLON, "expected %<:%>"))
	return list;
	keywordexpr = c_parser_objc_keywordexpr (parser);
	list = chainon (list, build_tree_list (sel, keywordexpr));
	sel = c_parser_objc_selector (parser);
	if (!sel && c_parser_next_token_is_not (parser, CPP_COLON))
	break;
	}
	return list;
	}

	/* Parse an objc-keywordexpr.

	objc-keywordexpr:
	nonempty-expr-list
	*/

	static tree
	c_parser_objc_keywordexpr (c_parser *parser)
	{
	tree list = c_parser_expr_list (parser, true);
	if (TREE_CHAIN (list) == NULL_TREE)
	{
	/* Just return the expression, remove a level of
	indirection. */
	return TREE_VALUE (list);
	}
	else
	{
	/* We have a comma expression, we will collapse later. */
	return list;
	}
	}


	/* Handle pragmas. Some OpenMP pragmas are associated with, and therefore
	should be considered, statements. ALLOW_STMT is true if we're within
	the context of a function and such pragmas are to be allowed. Returns
	true if we actually parsed such a pragma. */

	static bool
	c_parser_pragma (c_parser *parser, enum pragma_context context)
	{
	unsigned int id;

	id = c_parser_peek_token (parser)->pragma_kind;
	gcc_assert (id != PRAGMA_NONE);

	switch (id)
	{
	case PRAGMA_OMP_BARRIER:
	if (context != pragma_compound)
	{
	if (context == pragma_stmt)
	c_parser_error (parser, "%<#pragma omp barrier%> may only be "
	"used in compound statements");
	goto bad_stmt;
	}
	c_parser_omp_barrier (parser);
	return false;

	case PRAGMA_OMP_FLUSH:
	if (context != pragma_compound)
	{
	if (context == pragma_stmt)
	c_parser_error (parser, "%<#pragma omp flush%> may only be "
	"used in compound statements");
	goto bad_stmt;
	}
	c_parser_omp_flush (parser);
	return false;

	case PRAGMA_OMP_THREADPRIVATE:
	c_parser_omp_threadprivate (parser);
	return false;

	case PRAGMA_OMP_SECTION:
	error ("%<#pragma omp section%> may only be used in "
	"%<#pragma omp sections%> construct");
	c_parser_skip_until_found (parser, CPP_PRAGMA_EOL, NULL);
	return false;

	case PRAGMA_GCC_PCH_PREPROCESS:
	c_parser_error (parser, "%<#pragma GCC pch_preprocess%> must be first");
	c_parser_skip_until_found (parser, CPP_PRAGMA_EOL, NULL);
	return false;

	default:
	if (id < PRAGMA_FIRST_EXTERNAL)
	{
	if (context == pragma_external)
	{
	bad_stmt:
	c_parser_error (parser, "expected declaration specifiers");
	c_parser_skip_until_found (parser, CPP_PRAGMA_EOL, NULL);
	return false;
	}
	c_parser_omp_construct (parser);
	return true;
	}
	break;
	}

	c_parser_consume_pragma (parser);
	c_invoke_pragma_handler (id);

	/* Skip to EOL, but suppress any error message. Those will have been
	generated by the handler routine through calling error, as opposed
	to calling c_parser_error. */
	parser->error = true;
	c_parser_skip_to_pragma_eol (parser);

	return false;
	}

	/* The interface the pragma parsers have to the lexer. */

	enum cpp_ttype
	pragma_lex (tree *value)
	{
	c_token *tok = c_parser_peek_token (the_parser);
	enum cpp_ttype ret = tok->type;

	*value = tok->value;
	if (ret == CPP_PRAGMA_EOL \|\| ret == CPP_EOF)
	ret = CPP_EOF;
	else
	{
	if (ret == CPP_KEYWORD)
	ret = CPP_NAME;
	c_parser_consume_token (the_parser);
	}

	return ret;
	}

	static void
	c_parser_pragma_pch_preprocess (c_parser *parser)
	{
	tree name = NULL;

	c_parser_consume_pragma (parser);
	if (c_parser_next_token_is (parser, CPP_STRING))
	{
	name = c_parser_peek_token (parser)->value;
	c_parser_consume_token (parser);
	}
	else
	c_parser_error (parser, "expected string literal");
	c_parser_skip_to_pragma_eol (parser);

	if (name)
	c_common_pch_pragma (parse_in, TREE_STRING_POINTER (name));
	}

	/* OpenMP 2.5 parsing routines. */

	/* Returns name of the next clause.
	If the clause is not recognized PRAGMA_OMP_CLAUSE_NONE is returned and
	the token is not consumed. Otherwise appropriate pragma_omp_clause is
	returned and the token is consumed. */

	static pragma_omp_clause
	c_parser_omp_clause_name (c_parser *parser)
	{
	pragma_omp_clause result = PRAGMA_OMP_CLAUSE_NONE;

	if (c_parser_next_token_is_keyword (parser, RID_IF))
	result = PRAGMA_OMP_CLAUSE_IF;
	else if (c_parser_next_token_is_keyword (parser, RID_DEFAULT))
	result = PRAGMA_OMP_CLAUSE_DEFAULT;
	else if (c_parser_next_token_is (parser, CPP_NAME))
	{
	const char *p = IDENTIFIER_POINTER (c_parser_peek_token (parser)->value);

	switch (p[0])
	{
	case 'c':
	if (!strcmp ("copyin", p))
	result = PRAGMA_OMP_CLAUSE_COPYIN;
	else if (!strcmp ("copyprivate", p))
	result = PRAGMA_OMP_CLAUSE_COPYPRIVATE;
	break;
	case 'f':
	if (!strcmp ("firstprivate", p))
	result = PRAGMA_OMP_CLAUSE_FIRSTPRIVATE;
	break;
	case 'l':
	if (!strcmp ("lastprivate", p))
	result = PRAGMA_OMP_CLAUSE_LASTPRIVATE;
	break;
	case 'n':
	if (!strcmp ("nowait", p))
	result = PRAGMA_OMP_CLAUSE_NOWAIT;
	else if (!strcmp ("num_threads", p))
	result = PRAGMA_OMP_CLAUSE_NUM_THREADS;
	break;
	case 'o':
	if (!strcmp ("ordered", p))
	result = PRAGMA_OMP_CLAUSE_ORDERED;
	break;
	case 'p':
	if (!strcmp ("private", p))
	result = PRAGMA_OMP_CLAUSE_PRIVATE;
	break;
	case 'r':
	if (!strcmp ("reduction", p))
	result = PRAGMA_OMP_CLAUSE_REDUCTION;
	break;
	case 's':
	if (!strcmp ("schedule", p))
	result = PRAGMA_OMP_CLAUSE_SCHEDULE;
	else if (!strcmp ("shared", p))
	result = PRAGMA_OMP_CLAUSE_SHARED;
	break;
	}
	}

	if (result != PRAGMA_OMP_CLAUSE_NONE)
	c_parser_consume_token (parser);

	return result;
	}

	/* Validate that a clause of the given type does not already exist. */

	static void
	check_no_duplicate_clause (tree clauses, enum tree_code code, const char *name)
	{
	tree c;

	for (c = clauses; c ; c = OMP_CLAUSE_CHAIN (c))
	if (OMP_CLAUSE_CODE (c) == code)
	{
	error ("too many %qs clauses", name);
	break;
	}
	}

	/* OpenMP 2.5:
	variable-list:
	identifier
	variable-list , identifier

	If KIND is nonzero, create the appropriate node and install the decl
	in OMP_CLAUSE_DECL and add the node to the head of the list.

	If KIND is zero, create a TREE_LIST with the decl in TREE_PURPOSE;
	return the list created. */

	static tree
	c_parser_omp_variable_list (c_parser *parser, enum omp_clause_code kind,
	tree list)
	{
	if (c_parser_next_token_is_not (parser, CPP_NAME)
	\|\| c_parser_peek_token (parser)->id_kind != C_ID_ID)
	c_parser_error (parser, "expected identifier");

	while (c_parser_next_token_is (parser, CPP_NAME)
	&& c_parser_peek_token (parser)->id_kind == C_ID_ID)
	{
	tree t = lookup_name (c_parser_peek_token (parser)->value);

	if (t == NULL_TREE)
	undeclared_variable (c_parser_peek_token (parser)->value,
	c_parser_peek_token (parser)->location);
	else if (t == error_mark_node)
	;
	else if (kind != 0)
	{
	tree u = build_omp_clause (kind);
	OMP_CLAUSE_DECL (u) = t;
	OMP_CLAUSE_CHAIN (u) = list;
	list = u;
	}
	else
	list = tree_cons (t, NULL_TREE, list);

	c_parser_consume_token (parser);

	if (c_parser_next_token_is_not (parser, CPP_COMMA))
	break;

	c_parser_consume_token (parser);
	}

	return list;
	}

	/* Similarly, but expect leading and trailing parenthesis. This is a very
	common case for omp clauses. */

	static tree
	c_parser_omp_var_list_parens (c_parser *parser, enum tree_code kind, tree list)
	{
	if (c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>"))
	{
	list = c_parser_omp_variable_list (parser, kind, list);
	c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, "expected %<)%>");
	}
	return list;
	}

	/* OpenMP 2.5:
	copyin ( variable-list ) */

	static tree
	c_parser_omp_clause_copyin (c_parser *parser, tree list)
	{
	return c_parser_omp_var_list_parens (parser, OMP_CLAUSE_COPYIN, list);
	}

	/* OpenMP 2.5:
	copyprivate ( variable-list ) */

	static tree
	c_parser_omp_clause_copyprivate (c_parser *parser, tree list)
	{
	return c_parser_omp_var_list_parens (parser, OMP_CLAUSE_COPYPRIVATE, list);
	}

	/* OpenMP 2.5:
	default ( shared \| none ) */

	static tree
	c_parser_omp_clause_default (c_parser *parser, tree list)
	{
	enum omp_clause_default_kind kind = OMP_CLAUSE_DEFAULT_UNSPECIFIED;
	tree c;

	if (!c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>"))
	return list;
	if (c_parser_next_token_is (parser, CPP_NAME))
	{
	const char *p = IDENTIFIER_POINTER (c_parser_peek_token (parser)->value);

	switch (p[0])
	{
	case 'n':
	if (strcmp ("none", p) != 0)
	goto invalid_kind;
	kind = OMP_CLAUSE_DEFAULT_NONE;
	break;

	case 's':
	if (strcmp ("shared", p) != 0)
	goto invalid_kind;
	kind = OMP_CLAUSE_DEFAULT_SHARED;
	break;

	default:
	goto invalid_kind;
	}

	c_parser_consume_token (parser);
	}
	else
	{
	invalid_kind:
	c_parser_error (parser, "expected %<none%> or %<shared%>");
	}
	c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, "expected %<)%>");

	if (kind == OMP_CLAUSE_DEFAULT_UNSPECIFIED)
	return list;

	check_no_duplicate_clause (list, OMP_CLAUSE_DEFAULT, "default");
	c = build_omp_clause (OMP_CLAUSE_DEFAULT);
	OMP_CLAUSE_CHAIN (c) = list;
	OMP_CLAUSE_DEFAULT_KIND (c) = kind;

	return c;
	}

	/* OpenMP 2.5:
	firstprivate ( variable-list ) */

	static tree
	c_parser_omp_clause_firstprivate (c_parser *parser, tree list)
	{
	return c_parser_omp_var_list_parens (parser, OMP_CLAUSE_FIRSTPRIVATE, list);
	}

	/* OpenMP 2.5:
	if ( expression ) */

	static tree
	c_parser_omp_clause_if (c_parser *parser, tree list)
	{
	if (c_parser_next_token_is (parser, CPP_OPEN_PAREN))
	{
	tree t = c_parser_paren_condition (parser);
	tree c;

	check_no_duplicate_clause (list, OMP_CLAUSE_IF, "if");

	c = build_omp_clause (OMP_CLAUSE_IF);
	OMP_CLAUSE_IF_EXPR (c) = t;
	OMP_CLAUSE_CHAIN (c) = list;
	list = c;
	}
	else
	c_parser_error (parser, "expected %<(%>");

	return list;
	}

	/* OpenMP 2.5:
	lastprivate ( variable-list ) */

	static tree
	c_parser_omp_clause_lastprivate (c_parser *parser, tree list)
	{
	return c_parser_omp_var_list_parens (parser, OMP_CLAUSE_LASTPRIVATE, list);
	}

	/* OpenMP 2.5:
	nowait */

	static tree
	c_parser_omp_clause_nowait (c_parser *parser ATTRIBUTE_UNUSED, tree list)
	{
	tree c;

	check_no_duplicate_clause (list, OMP_CLAUSE_NOWAIT, "nowait");

	c = build_omp_clause (OMP_CLAUSE_NOWAIT);
	OMP_CLAUSE_CHAIN (c) = list;
	return c;
	}

	/* OpenMP 2.5:
	num_threads ( expression ) */

	static tree
	c_parser_omp_clause_num_threads (c_parser *parser, tree list)
	{
	if (c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>"))
	{
	tree c, t = c_parser_expression (parser).value;

	c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, "expected %<)%>");

	if (!INTEGRAL_TYPE_P (TREE_TYPE (t)))
	{
	c_parser_error (parser, "expected integer expression");
	return list;
	}

	/* Attempt to statically determine when the number isn't positive. */
	c = fold_build2 (LE_EXPR, boolean_type_node, t,
	build_int_cst (TREE_TYPE (t), 0));
	if (c == boolean_true_node)
	{
	warning (0, "%<num_threads%> value must be positive");
	t = integer_one_node;
	}

	check_no_duplicate_clause (list, OMP_CLAUSE_NUM_THREADS, "num_threads");

	c = build_omp_clause (OMP_CLAUSE_NUM_THREADS);
	OMP_CLAUSE_NUM_THREADS_EXPR (c) = t;
	OMP_CLAUSE_CHAIN (c) = list;
	list = c;
	}

	return list;
	}

	/* OpenMP 2.5:
	ordered */

	static tree
	c_parser_omp_clause_ordered (c_parser *parser ATTRIBUTE_UNUSED, tree list)
	{
	tree c;

	check_no_duplicate_clause (list, OMP_CLAUSE_ORDERED, "ordered");

	c = build_omp_clause (OMP_CLAUSE_ORDERED);
	OMP_CLAUSE_CHAIN (c) = list;
	return c;
	}

	/* OpenMP 2.5:
	private ( variable-list ) */

	static tree
	c_parser_omp_clause_private (c_parser *parser, tree list)
	{
	return c_parser_omp_var_list_parens (parser, OMP_CLAUSE_PRIVATE, list);
	}

	/* OpenMP 2.5:
	reduction ( reduction-operator : variable-list )

	reduction-operator:
	One of: + * - & ^ \| && \|\| */

	static tree
	c_parser_omp_clause_reduction (c_parser *parser, tree list)
	{
	if (c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>"))
	{
	enum tree_code code;

	switch (c_parser_peek_token (parser)->type)
	{
	case CPP_PLUS:
	code = PLUS_EXPR;
	break;
	case CPP_MULT:
	code = MULT_EXPR;
	break;
	case CPP_MINUS:
	code = MINUS_EXPR;
	break;
	case CPP_AND:
	code = BIT_AND_EXPR;
	break;
	case CPP_XOR:
	code = BIT_XOR_EXPR;
	break;
	case CPP_OR:
	code = BIT_IOR_EXPR;
	break;
	case CPP_AND_AND:
	code = TRUTH_ANDIF_EXPR;
	break;
	case CPP_OR_OR:
	code = TRUTH_ORIF_EXPR;
	break;
	default:
	c_parser_error (parser,
	"expected %<+%>, %<*%>, %<-%>, %<&%>, "
	"%<^%>, %<\|%>, %<&&%>, or %<\|\|%>");
	c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, 0);
	return list;
	}
	c_parser_consume_token (parser);
	if (c_parser_require (parser, CPP_COLON, "expected %<:%>"))
	{
	tree nl, c;

	nl = c_parser_omp_variable_list (parser, OMP_CLAUSE_REDUCTION, list);
	for (c = nl; c != list; c = OMP_CLAUSE_CHAIN (c))
	OMP_CLAUSE_REDUCTION_CODE (c) = code;

	list = nl;
	}
	c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, "expected %<)%>");
	}
	return list;
	}

	/* OpenMP 2.5:
	schedule ( schedule-kind )
	schedule ( schedule-kind , expression )

	schedule-kind:
	static \| dynamic \| guided \| runtime
	*/

	static tree
	c_parser_omp_clause_schedule (c_parser *parser, tree list)
	{
	tree c, t;

	if (!c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>"))
	return list;

	c = build_omp_clause (OMP_CLAUSE_SCHEDULE);

	if (c_parser_next_token_is (parser, CPP_NAME))
	{
	tree kind = c_parser_peek_token (parser)->value;
	const char *p = IDENTIFIER_POINTER (kind);

	switch (p[0])
	{
	case 'd':
	if (strcmp ("dynamic", p) != 0)
	goto invalid_kind;
	OMP_CLAUSE_SCHEDULE_KIND (c) = OMP_CLAUSE_SCHEDULE_DYNAMIC;
	break;

	case 'g':
	if (strcmp ("guided", p) != 0)
	goto invalid_kind;
	OMP_CLAUSE_SCHEDULE_KIND (c) = OMP_CLAUSE_SCHEDULE_GUIDED;
	break;

	case 'r':
	if (strcmp ("runtime", p) != 0)
	goto invalid_kind;
	OMP_CLAUSE_SCHEDULE_KIND (c) = OMP_CLAUSE_SCHEDULE_RUNTIME;
	break;

	default:
	goto invalid_kind;
	}
	}
	else if (c_parser_next_token_is_keyword (parser, RID_STATIC))
	OMP_CLAUSE_SCHEDULE_KIND (c) = OMP_CLAUSE_SCHEDULE_STATIC;
	else
	goto invalid_kind;

	c_parser_consume_token (parser);
	if (c_parser_next_token_is (parser, CPP_COMMA))
	{
	c_parser_consume_token (parser);

	t = c_parser_expr_no_commas (parser, NULL).value;

	if (OMP_CLAUSE_SCHEDULE_KIND (c) == OMP_CLAUSE_SCHEDULE_RUNTIME)
	error ("schedule %<runtime%> does not take "
	"a %<chunk_size%> parameter");
	else if (TREE_CODE (TREE_TYPE (t)) == INTEGER_TYPE)
	OMP_CLAUSE_SCHEDULE_CHUNK_EXPR (c) = t;
	else
	c_parser_error (parser, "expected integer expression");

	c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, "expected %<)%>");
	}
	else
	c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
	"expected %<,%> or %<)%>");

	check_no_duplicate_clause (list, OMP_CLAUSE_SCHEDULE, "schedule");
	OMP_CLAUSE_CHAIN (c) = list;
	return c;

	invalid_kind:
	c_parser_error (parser, "invalid schedule kind");
	c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, 0);
	return list;
	}

	/* OpenMP 2.5:
	shared ( variable-list ) */

	static tree
	c_parser_omp_clause_shared (c_parser *parser, tree list)
	{
	return c_parser_omp_var_list_parens (parser, OMP_CLAUSE_SHARED, list);
	}

	/* Parse all OpenMP clauses. The set clauses allowed by the directive
	is a bitmask in MASK. Return the list of clauses found; the result
	of clause default goes in pdefault. /

	static tree
	c_parser_omp_all_clauses (c_parser *parser, unsigned int mask,
	const char *where)
	{
	tree clauses = NULL;

	while (c_parser_next_token_is_not (parser, CPP_PRAGMA_EOL))
	{
	const pragma_omp_clause c_kind = c_parser_omp_clause_name (parser);
	const char *c_name;
	tree prev = clauses;

	switch (c_kind)
	{
	case PRAGMA_OMP_CLAUSE_COPYIN:
	clauses = c_parser_omp_clause_copyin (parser, clauses);
	c_name = "copyin";
	break;
	case PRAGMA_OMP_CLAUSE_COPYPRIVATE:
	clauses = c_parser_omp_clause_copyprivate (parser, clauses);
	c_name = "copyprivate";
	break;
	case PRAGMA_OMP_CLAUSE_DEFAULT:
	clauses = c_parser_omp_clause_default (parser, clauses);
	c_name = "default";
	break;
	case PRAGMA_OMP_CLAUSE_FIRSTPRIVATE:
	clauses = c_parser_omp_clause_firstprivate (parser, clauses);
	c_name = "firstprivate";
	break;
	case PRAGMA_OMP_CLAUSE_IF:
	clauses = c_parser_omp_clause_if (parser, clauses);
	c_name = "if";
	break;
	case PRAGMA_OMP_CLAUSE_LASTPRIVATE:
	clauses = c_parser_omp_clause_lastprivate (parser, clauses);
	c_name = "lastprivate";
	break;
	case PRAGMA_OMP_CLAUSE_NOWAIT:
	clauses = c_parser_omp_clause_nowait (parser, clauses);
	c_name = "nowait";
	break;
	case PRAGMA_OMP_CLAUSE_NUM_THREADS:
	clauses = c_parser_omp_clause_num_threads (parser, clauses);
	c_name = "num_threads";
	break;
	case PRAGMA_OMP_CLAUSE_ORDERED:
	clauses = c_parser_omp_clause_ordered (parser, clauses);
	c_name = "ordered";
	break;
	case PRAGMA_OMP_CLAUSE_PRIVATE:
	clauses = c_parser_omp_clause_private (parser, clauses);
	c_name = "private";
	break;
	case PRAGMA_OMP_CLAUSE_REDUCTION:
	clauses = c_parser_omp_clause_reduction (parser, clauses);
	c_name = "reduction";
	break;
	case PRAGMA_OMP_CLAUSE_SCHEDULE:
	clauses = c_parser_omp_clause_schedule (parser, clauses);
	c_name = "schedule";
	break;
	case PRAGMA_OMP_CLAUSE_SHARED:
	clauses = c_parser_omp_clause_shared (parser, clauses);
	c_name = "shared";
	break;
	default:
	c_parser_error (parser, "expected %<#pragma omp%> clause");
	goto saw_error;
	}

	if (((mask >> c_kind) & 1) == 0 && !parser->error)
	{
	/* Remove the invalid clause(s) from the list to avoid
	confusing the rest of the compiler. */
	clauses = prev;
	error ("%qs is not valid for %qs", c_name, where);
	}
	}

	saw_error:
	c_parser_skip_to_pragma_eol (parser);

	return c_finish_omp_clauses (clauses);
	}

	/* OpenMP 2.5:
	structured-block:
	statement

	In practice, we're also interested in adding the statement to an
	outer node. So it is convenient if we work around the fact that
	c_parser_statement calls add_stmt. */

	static tree
	c_parser_omp_structured_block (c_parser *parser)
	{
	tree stmt = push_stmt_list ();
	c_parser_statement (parser);
	return pop_stmt_list (stmt);
	}

	/* OpenMP 2.5:
	# pragma omp atomic new-line
	expression-stmt

	expression-stmt:
	x binop= expr \| x++ \| ++x \| x-- \| --x
	binop:
	+, *, -, /, &, ^, \|, <<, >>

	where x is an lvalue expression with scalar type. */

	static void
	c_parser_omp_atomic (c_parser *parser)
	{
	tree lhs, rhs;
	tree stmt;
	enum tree_code code;

	c_parser_skip_to_pragma_eol (parser);

	lhs = c_parser_unary_expression (parser).value;
	switch (TREE_CODE (lhs))
	{
	case ERROR_MARK:
	saw_error:
	c_parser_skip_to_end_of_block_or_statement (parser);
	return;

	case PREINCREMENT_EXPR:
	case POSTINCREMENT_EXPR:
	lhs = TREE_OPERAND (lhs, 0);
	code = PLUS_EXPR;
	rhs = integer_one_node;
	break;

	case PREDECREMENT_EXPR:
	case POSTDECREMENT_EXPR:
	lhs = TREE_OPERAND (lhs, 0);
	code = MINUS_EXPR;
	rhs = integer_one_node;
	break;

	default:
	switch (c_parser_peek_token (parser)->type)
	{
	case CPP_MULT_EQ:
	code = MULT_EXPR;
	break;
	case CPP_DIV_EQ:
	code = TRUNC_DIV_EXPR;
	break;
	case CPP_PLUS_EQ:
	code = PLUS_EXPR;
	break;
	case CPP_MINUS_EQ:
	code = MINUS_EXPR;
	break;
	case CPP_LSHIFT_EQ:
	code = LSHIFT_EXPR;
	break;
	case CPP_RSHIFT_EQ:
	code = RSHIFT_EXPR;
	break;
	case CPP_AND_EQ:
	code = BIT_AND_EXPR;
	break;
	case CPP_OR_EQ:
	code = BIT_IOR_EXPR;
	break;
	case CPP_XOR_EQ:
	code = BIT_XOR_EXPR;
	break;
	default:
	c_parser_error (parser,
	"invalid operator for %<#pragma omp atomic%>");
	goto saw_error;
	}

	c_parser_consume_token (parser);
	rhs = c_parser_expression (parser).value;
	break;
	}
	stmt = c_finish_omp_atomic (code, lhs, rhs);
	if (stmt != error_mark_node)
	add_stmt (stmt);
	c_parser_skip_until_found (parser, CPP_SEMICOLON, "expected %<;%>");
	}


	/* OpenMP 2.5:
	# pragma omp barrier new-line
	*/

	static void
	c_parser_omp_barrier (c_parser *parser)
	{
	c_parser_consume_pragma (parser);
	c_parser_skip_to_pragma_eol (parser);

	c_finish_omp_barrier ();
	}

	/* OpenMP 2.5:
	# pragma omp critical [(name)] new-line
	structured-block
	*/

	static tree
	c_parser_omp_critical (c_parser *parser)
	{
	tree stmt, name = NULL;

	if (c_parser_next_token_is (parser, CPP_OPEN_PAREN))
	{
	c_parser_consume_token (parser);
	if (c_parser_next_token_is (parser, CPP_NAME))
	{
	name = c_parser_peek_token (parser)->value;
	c_parser_consume_token (parser);
	c_parser_require (parser, CPP_CLOSE_PAREN, "expected %<)%>");
	}
	else
	c_parser_error (parser, "expected identifier");
	}
	else if (c_parser_next_token_is_not (parser, CPP_PRAGMA_EOL))
	c_parser_error (parser, "expected %<(%> or end of line");
	c_parser_skip_to_pragma_eol (parser);

	stmt = c_parser_omp_structured_block (parser);
	return c_finish_omp_critical (stmt, name);
	}

	/* OpenMP 2.5:
	# pragma omp flush flush-vars[opt] new-line

	flush-vars:
	( variable-list ) */

	static void
	c_parser_omp_flush (c_parser *parser)
	{
	c_parser_consume_pragma (parser);
	if (c_parser_next_token_is (parser, CPP_OPEN_PAREN))
	c_parser_omp_var_list_parens (parser, 0, NULL);
	else if (c_parser_next_token_is_not (parser, CPP_PRAGMA_EOL))
	c_parser_error (parser, "expected %<(%> or end of line");
	c_parser_skip_to_pragma_eol (parser);

	c_finish_omp_flush ();
	}

	/* Parse the restricted form of the for statment allowed by OpenMP.
	The real trick here is to determine the loop control variable early
	so that we can push a new decl if necessary to make it private. */

	static tree
	c_parser_omp_for_loop (c_parser *parser)
	{
	tree decl, cond, incr, save_break, save_cont, body, init;
	location_t loc;

	if (!c_parser_next_token_is_keyword (parser, RID_FOR))
	{
	c_parser_error (parser, "for statement expected");
	return NULL;
	}
	loc = c_parser_peek_token (parser)->location;
	c_parser_consume_token (parser);

	if (!c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>"))
	return NULL;

	/* Parse the initialization declaration or expression. */
	if (c_parser_next_token_starts_declspecs (parser))
	{
	c_parser_declaration_or_fndef (parser, true, true, true, true);
	decl = check_for_loop_decls ();
	if (decl == NULL)
	goto error_init;
	init = decl;
	}
	else if (c_parser_next_token_is (parser, CPP_NAME)
	&& c_parser_peek_2nd_token (parser)->type == CPP_EQ)
	{
	decl = c_parser_postfix_expression (parser).value;

	c_parser_require (parser, CPP_EQ, "expected %<=%>");

	init = c_parser_expr_no_commas (parser, NULL).value;
	init = build_modify_expr (decl, NOP_EXPR, init);
	init = c_process_expr_stmt (init);

	c_parser_skip_until_found (parser, CPP_SEMICOLON, "expected %<;%>");
	}
	else
	goto error_init;

	/* Parse the loop condition. */
	cond = NULL_TREE;
	if (c_parser_next_token_is_not (parser, CPP_SEMICOLON))
	{
	cond = c_parser_expression_conv (parser).value;
	cond = c_objc_common_truthvalue_conversion (cond);
	if (EXPR_P (cond))
	SET_EXPR_LOCATION (cond, input_location);
	}
	c_parser_skip_until_found (parser, CPP_SEMICOLON, "expected %<;%>");

	/* Parse the increment expression. */
	incr = NULL_TREE;
	if (c_parser_next_token_is_not (parser, CPP_CLOSE_PAREN))
	incr = c_process_expr_stmt (c_parser_expression (parser).value);
	c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, "expected %<)%>");

	parse_body:
	save_break = c_break_label;
	c_break_label = size_one_node;
	save_cont = c_cont_label;
	c_cont_label = NULL_TREE;
	body = push_stmt_list ();

	add_stmt (c_parser_c99_block_statement (parser));
	if (c_cont_label)
	add_stmt (build1 (LABEL_EXPR, void_type_node, c_cont_label));

	body = pop_stmt_list (body);
	c_break_label = save_break;
	c_cont_label = save_cont;

	/* Only bother calling c_finish_omp_for if we havn't already generated
	an error from the initialization parsing. */
	if (decl != NULL && decl != error_mark_node && init != error_mark_node)
	return c_finish_omp_for (loc, decl, init, cond, incr, body, NULL);
	return NULL;

	error_init:
	c_parser_error (parser, "expected iteration declaration or initialization");
	c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, "expected %<)%>");
	decl = init = cond = incr = NULL_TREE;
	goto parse_body;
	}

	/* OpenMP 2.5:
	#pragma omp for for-clause[optseq] new-line
	for-loop
	*/

	#define OMP_FOR_CLAUSE_MASK \
	( (1u << PRAGMA_OMP_CLAUSE_PRIVATE) \
	\| (1u << PRAGMA_OMP_CLAUSE_FIRSTPRIVATE) \
	\| (1u << PRAGMA_OMP_CLAUSE_LASTPRIVATE) \
	\| (1u << PRAGMA_OMP_CLAUSE_REDUCTION) \
	\| (1u << PRAGMA_OMP_CLAUSE_ORDERED) \
	\| (1u << PRAGMA_OMP_CLAUSE_SCHEDULE) \
	\| (1u << PRAGMA_OMP_CLAUSE_NOWAIT))

	static tree
	c_parser_omp_for (c_parser *parser)
	{
	tree block, clauses, ret;

	clauses = c_parser_omp_all_clauses (parser, OMP_FOR_CLAUSE_MASK,
	"#pragma omp for");

	block = c_begin_compound_stmt (true);
	ret = c_parser_omp_for_loop (parser);
	if (ret)
	OMP_FOR_CLAUSES (ret) = clauses;
	block = c_end_compound_stmt (block, true);
	add_stmt (block);

	return ret;
	}

	/* OpenMP 2.5:
	# pragma omp master new-line
	structured-block
	*/

	static tree
	c_parser_omp_master (c_parser *parser)
	{
	c_parser_skip_to_pragma_eol (parser);
	return c_finish_omp_master (c_parser_omp_structured_block (parser));
	}

	/* OpenMP 2.5:
	# pragma omp ordered new-line
	structured-block
	*/

	static tree
	c_parser_omp_ordered (c_parser *parser)
	{
	c_parser_skip_to_pragma_eol (parser);
	return c_finish_omp_ordered (c_parser_omp_structured_block (parser));
	}

	/* OpenMP 2.5:

	section-scope:
	{ section-sequence }

	section-sequence:
	section-directive[opt] structured-block
	section-sequence section-directive structured-block */

	static tree
	c_parser_omp_sections_scope (c_parser *parser)
	{
	tree stmt, substmt;
	bool error_suppress = false;
	location_t loc;

	if (!c_parser_require (parser, CPP_OPEN_BRACE, "expected %<{%>"))
	{
	/* Avoid skipping until the end of the block. */
	parser->error = false;
	return NULL_TREE;
	}

	stmt = push_stmt_list ();

	loc = c_parser_peek_token (parser)->location;
	if (c_parser_peek_token (parser)->pragma_kind != PRAGMA_OMP_SECTION)
	{
	substmt = push_stmt_list ();

	while (1)
	{
	c_parser_statement (parser);

	if (c_parser_peek_token (parser)->pragma_kind == PRAGMA_OMP_SECTION)
	break;
	if (c_parser_next_token_is (parser, CPP_CLOSE_BRACE))
	break;
	if (c_parser_next_token_is (parser, CPP_EOF))
	break;
	}

	substmt = pop_stmt_list (substmt);
	substmt = build1 (OMP_SECTION, void_type_node, substmt);
	SET_EXPR_LOCATION (substmt, loc);
	add_stmt (substmt);
	}

	while (1)
	{
	if (c_parser_next_token_is (parser, CPP_CLOSE_BRACE))
	break;
	if (c_parser_next_token_is (parser, CPP_EOF))
	break;

	loc = c_parser_peek_token (parser)->location;
	if (c_parser_peek_token (parser)->pragma_kind == PRAGMA_OMP_SECTION)
	{
	c_parser_consume_pragma (parser);
	c_parser_skip_to_pragma_eol (parser);
	error_suppress = false;
	}
	else if (!error_suppress)
	{
	error ("expected %<#pragma omp section%> or %<}%>");
	error_suppress = true;
	}

	substmt = c_parser_omp_structured_block (parser);
	substmt = build1 (OMP_SECTION, void_type_node, substmt);
	SET_EXPR_LOCATION (substmt, loc);
	add_stmt (substmt);
	}
	c_parser_skip_until_found (parser, CPP_CLOSE_BRACE,
	"expected %<#pragma omp section%> or %<}%>");

	substmt = pop_stmt_list (stmt);

	stmt = make_node (OMP_SECTIONS);
	TREE_TYPE (stmt) = void_type_node;
	OMP_SECTIONS_BODY (stmt) = substmt;

	return add_stmt (stmt);
	}

	/* OpenMP 2.5:
	# pragma omp sections sections-clause[optseq] newline
	sections-scope
	*/

	#define OMP_SECTIONS_CLAUSE_MASK \
	( (1u << PRAGMA_OMP_CLAUSE_PRIVATE) \
	\| (1u << PRAGMA_OMP_CLAUSE_FIRSTPRIVATE) \
	\| (1u << PRAGMA_OMP_CLAUSE_LASTPRIVATE) \
	\| (1u << PRAGMA_OMP_CLAUSE_REDUCTION) \
	\| (1u << PRAGMA_OMP_CLAUSE_NOWAIT))

	static tree
	c_parser_omp_sections (c_parser *parser)
	{
	tree block, clauses, ret;

	clauses = c_parser_omp_all_clauses (parser, OMP_SECTIONS_CLAUSE_MASK,
	"#pragma omp sections");

	block = c_begin_compound_stmt (true);
	ret = c_parser_omp_sections_scope (parser);
	if (ret)
	OMP_SECTIONS_CLAUSES (ret) = clauses;
	block = c_end_compound_stmt (block, true);
	add_stmt (block);

	return ret;
	}

	/* OpenMP 2.5:
	# pragma parallel parallel-clause new-line
	# pragma parallel for parallel-for-clause new-line
	# pragma parallel sections parallel-sections-clause new-line
	*/

	#define OMP_PARALLEL_CLAUSE_MASK \
	( (1u << PRAGMA_OMP_CLAUSE_IF) \
	\| (1u << PRAGMA_OMP_CLAUSE_PRIVATE) \
	\| (1u << PRAGMA_OMP_CLAUSE_FIRSTPRIVATE) \
	\| (1u << PRAGMA_OMP_CLAUSE_DEFAULT) \
	\| (1u << PRAGMA_OMP_CLAUSE_SHARED) \
	\| (1u << PRAGMA_OMP_CLAUSE_COPYIN) \
	\| (1u << PRAGMA_OMP_CLAUSE_REDUCTION) \
	\| (1u << PRAGMA_OMP_CLAUSE_NUM_THREADS))

	static tree
	c_parser_omp_parallel (c_parser *parser)
	{
	enum pragma_kind p_kind = PRAGMA_OMP_PARALLEL;
	const char *p_name = "#pragma omp parallel";
	tree stmt, clauses, par_clause, ws_clause, block;
	unsigned int mask = OMP_PARALLEL_CLAUSE_MASK;

	if (c_parser_next_token_is_keyword (parser, RID_FOR))
	{
	c_parser_consume_token (parser);
	p_kind = PRAGMA_OMP_PARALLEL_FOR;
	p_name = "#pragma omp parallel for";
	mask \|= OMP_FOR_CLAUSE_MASK;
	mask &= ~(1u << PRAGMA_OMP_CLAUSE_NOWAIT);
	}
	else if (c_parser_next_token_is (parser, CPP_NAME))
	{
	const char *p = IDENTIFIER_POINTER (c_parser_peek_token (parser)->value);
	if (strcmp (p, "sections") == 0)
	{
	c_parser_consume_token (parser);
	p_kind = PRAGMA_OMP_PARALLEL_SECTIONS;
	p_name = "#pragma omp parallel sections";
	mask \|= OMP_SECTIONS_CLAUSE_MASK;
	mask &= ~(1u << PRAGMA_OMP_CLAUSE_NOWAIT);
	}
	}

	clauses = c_parser_omp_all_clauses (parser, mask, p_name);

	switch (p_kind)
	{
	case PRAGMA_OMP_PARALLEL:
	block = c_begin_omp_parallel ();
	c_parser_statement (parser);
	stmt = c_finish_omp_parallel (clauses, block);
	break;

	case PRAGMA_OMP_PARALLEL_FOR:
	block = c_begin_omp_parallel ();
	c_split_parallel_clauses (clauses, &par_clause, &ws_clause);
	stmt = c_parser_omp_for_loop (parser);
	if (stmt)
	OMP_FOR_CLAUSES (stmt) = ws_clause;
	stmt = c_finish_omp_parallel (par_clause, block);
	OMP_PARALLEL_COMBINED (stmt) = 1;
	break;

	case PRAGMA_OMP_PARALLEL_SECTIONS:
	block = c_begin_omp_parallel ();
	c_split_parallel_clauses (clauses, &par_clause, &ws_clause);
	stmt = c_parser_omp_sections_scope (parser);
	if (stmt)
	OMP_SECTIONS_CLAUSES (stmt) = ws_clause;
	stmt = c_finish_omp_parallel (par_clause, block);
	OMP_PARALLEL_COMBINED (stmt) = 1;
	break;

	default:
	gcc_unreachable ();
	}

	return stmt;
	}

	/* OpenMP 2.5:
	# pragma omp single single-clause[optseq] new-line
	structured-block
	*/

	#define OMP_SINGLE_CLAUSE_MASK \
	( (1u << PRAGMA_OMP_CLAUSE_PRIVATE) \
	\| (1u << PRAGMA_OMP_CLAUSE_FIRSTPRIVATE) \
	\| (1u << PRAGMA_OMP_CLAUSE_COPYPRIVATE) \
	\| (1u << PRAGMA_OMP_CLAUSE_NOWAIT))

	static tree
	c_parser_omp_single (c_parser *parser)
	{
	tree stmt = make_node (OMP_SINGLE);
	TREE_TYPE (stmt) = void_type_node;

	OMP_SINGLE_CLAUSES (stmt)
	= c_parser_omp_all_clauses (parser, OMP_SINGLE_CLAUSE_MASK,
	"#pragma omp single");
	OMP_SINGLE_BODY (stmt) = c_parser_omp_structured_block (parser);

	return add_stmt (stmt);
	}


	/* Main entry point to parsing most OpenMP pragmas. */

	static void
	c_parser_omp_construct (c_parser *parser)
	{
	enum pragma_kind p_kind;
	location_t loc;
	tree stmt;

	loc = c_parser_peek_token (parser)->location;
	p_kind = c_parser_peek_token (parser)->pragma_kind;
	c_parser_consume_pragma (parser);

	/* For all constructs below except #pragma omp atomic
	MUST_NOT_THROW catch handlers are needed when exceptions
	are enabled. */
	if (p_kind != PRAGMA_OMP_ATOMIC)
	c_maybe_initialize_eh ();

	switch (p_kind)
	{
	case PRAGMA_OMP_ATOMIC:
	c_parser_omp_atomic (parser);
	return;
	case PRAGMA_OMP_CRITICAL:
	stmt = c_parser_omp_critical (parser);
	break;
	case PRAGMA_OMP_FOR:
	stmt = c_parser_omp_for (parser);
	break;
	case PRAGMA_OMP_MASTER:
	stmt = c_parser_omp_master (parser);
	break;
	case PRAGMA_OMP_ORDERED:
	stmt = c_parser_omp_ordered (parser);
	break;
	case PRAGMA_OMP_PARALLEL:
	stmt = c_parser_omp_parallel (parser);
	break;
	case PRAGMA_OMP_SECTIONS:
	stmt = c_parser_omp_sections (parser);
	break;
	case PRAGMA_OMP_SINGLE:
	stmt = c_parser_omp_single (parser);
	break;
	default:
	gcc_unreachable ();
	}

	if (stmt)
	SET_EXPR_LOCATION (stmt, loc);
	}


	/* OpenMP 2.5:
	# pragma omp threadprivate (variable-list) */

	static void
	c_parser_omp_threadprivate (c_parser *parser)
	{
	tree vars, t;

	c_parser_consume_pragma (parser);
	vars = c_parser_omp_var_list_parens (parser, 0, NULL);

	if (!targetm.have_tls)
	sorry ("threadprivate variables not supported in this target");

	/* Mark every variable in VARS to be assigned thread local storage. */
	for (t = vars; t; t = TREE_CHAIN (t))
	{
	tree v = TREE_PURPOSE (t);

	/* If V had already been marked threadprivate, it doesn't matter
	whether it had been used prior to this point. */
	if (TREE_USED (v) && !C_DECL_THREADPRIVATE_P (v))
	error ("%qE declared %<threadprivate%> after first use", v);
	else if (! TREE_STATIC (v) && ! DECL_EXTERNAL (v))
	error ("automatic variable %qE cannot be %<threadprivate%>", v);
	else if (! COMPLETE_TYPE_P (TREE_TYPE (v)))
	error ("%<threadprivate%> %qE has incomplete type", v);
	else
	{
	if (! DECL_THREAD_LOCAL_P (v))
	{
	DECL_TLS_MODEL (v) = decl_default_tls_model (v);
	/* If rtl has been already set for this var, call
	make_decl_rtl once again, so that encode_section_info
	has a chance to look at the new decl flags. */
	if (DECL_RTL_SET_P (v))
	make_decl_rtl (v);
	}
	C_DECL_THREADPRIVATE_P (v) = 1;
	}
	}

	c_parser_skip_to_pragma_eol (parser);
	}


	/* Parse a single source file. */

	void
	c_parse_file (void)
	{
	/* Use local storage to begin. If the first token is a pragma, parse it.
	If it is #pragma GCC pch_preprocess, then this will load a PCH file
	which will cause garbage collection. */
	c_parser tparser;

	memset (&tparser, 0, sizeof tparser);
	the_parser = &tparser;

	if (c_parser_peek_token (&tparser)->pragma_kind == PRAGMA_GCC_PCH_PREPROCESS)
	c_parser_pragma_pch_preprocess (&tparser);

	the_parser = GGC_NEW (c_parser);
	*the_parser = tparser;

	c_parser_translation_unit (the_parser);
	the_parser = NULL;
	}

	#include "gt-c-parser.h"
	diff --git a/contrib/gcc/c-tree.h b/contrib/gcc/c-tree.h
	index 7e2c81f808ae..af2e798f2bf2 100644
	--- a/contrib/gcc/c-tree.h
	+++ b/contrib/gcc/c-tree.h
	@@ -1,635 +1,642 @@
	/* Definitions for C parsing and type checking.
	Copyright (C) 1987, 1993, 1994, 1995, 1997, 1998,
	1999, 2000, 2001, 2002, 2003, 2004, 2005 Free Software Foundation, Inc.

	This file is part of GCC.

	GCC is free software; you can redistribute it and/or modify it under
	the terms of the GNU General Public License as published by the Free
	Software Foundation; either version 2, or (at your option) any later
	version.

	GCC is distributed in the hope that it will be useful, but WITHOUT ANY
	WARRANTY; without even the implied warranty of MERCHANTABILITY or
	FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	for more details.

	You should have received a copy of the GNU General Public License
	along with GCC; see the file COPYING. If not, write to the Free
	Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
	02110-1301, USA. */

	#ifndef GCC_C_TREE_H
	#define GCC_C_TREE_H

	#include "c-common.h"
	#include "toplev.h"
	#include "diagnostic.h"

	/* struct lang_identifier is private to c-decl.c, but langhooks.c needs to
	know how big it is. This is sanity-checked in c-decl.c. */
	#define C_SIZEOF_STRUCT_LANG_IDENTIFIER \
	(sizeof (struct c_common_identifier) + 3 * sizeof (void *))

	/* Language-specific declaration information. */

	struct lang_decl GTY(())
	{
	char dummy;
	};

	/* In a RECORD_TYPE or UNION_TYPE, nonzero if any component is read-only. */
	#define C_TYPE_FIELDS_READONLY(TYPE) TREE_LANG_FLAG_1 (TYPE)

	/* In a RECORD_TYPE or UNION_TYPE, nonzero if any component is volatile. */
	#define C_TYPE_FIELDS_VOLATILE(TYPE) TREE_LANG_FLAG_2 (TYPE)

	/* In a RECORD_TYPE or UNION_TYPE or ENUMERAL_TYPE
	nonzero if the definition of the type has already started. */
	#define C_TYPE_BEING_DEFINED(TYPE) TYPE_LANG_FLAG_0 (TYPE)

	/* In an incomplete RECORD_TYPE or UNION_TYPE, a list of variable
	declarations whose type would be completed by completing that type. */
	#define C_TYPE_INCOMPLETE_VARS(TYPE) TYPE_VFIELD (TYPE)

	/* In an IDENTIFIER_NODE, nonzero if this identifier is actually a
	keyword. C_RID_CODE (node) is then the RID_* value of the keyword,
	and C_RID_YYCODE is the token number wanted by Yacc. */
	#define C_IS_RESERVED_WORD(ID) TREE_LANG_FLAG_0 (ID)

	struct lang_type GTY(())
	{
	/* In a RECORD_TYPE, a sorted array of the fields of the type. */
	struct sorted_fields_type * GTY ((reorder ("resort_sorted_fields"))) s;
	/* In an ENUMERAL_TYPE, the min and max values. */
	tree enum_min;
	tree enum_max;
	/* In a RECORD_TYPE, information specific to Objective-C, such
	as a list of adopted protocols or a pointer to a corresponding
	@interface. See objc/objc-act.h for details. */
	tree objc_info;
	};

	/* Record whether a type or decl was written with nonconstant size.
	Note that TYPE_SIZE may have simplified to a constant. */
	#define C_TYPE_VARIABLE_SIZE(TYPE) TYPE_LANG_FLAG_1 (TYPE)
	#define C_DECL_VARIABLE_SIZE(TYPE) DECL_LANG_FLAG_0 (TYPE)

	/* Record whether a typedef for type `int' was actually `signed int'. */
	#define C_TYPEDEF_EXPLICITLY_SIGNED(EXP) DECL_LANG_FLAG_1 (EXP)

	/* For a FUNCTION_DECL, nonzero if it was defined without an explicit
	return type. */
	#define C_FUNCTION_IMPLICIT_INT(EXP) DECL_LANG_FLAG_1 (EXP)

	/* For a FUNCTION_DECL, nonzero if it was an implicit declaration. */
	#define C_DECL_IMPLICIT(EXP) DECL_LANG_FLAG_2 (EXP)

	/* For FUNCTION_DECLs, evaluates true if the decl is built-in but has
	been declared. */
	#define C_DECL_DECLARED_BUILTIN(EXP) \
	DECL_LANG_FLAG_3 (FUNCTION_DECL_CHECK (EXP))

	/* For FUNCTION_DECLs, evaluates true if the decl is built-in, has a
	built-in prototype and does not have a non-built-in prototype. */
	#define C_DECL_BUILTIN_PROTOTYPE(EXP) \
	DECL_LANG_FLAG_6 (FUNCTION_DECL_CHECK (EXP))

	/* Record whether a decl was declared register. This is strictly a
	front-end flag, whereas DECL_REGISTER is used for code generation;
	they may differ for structures with volatile fields. */
	#define C_DECL_REGISTER(EXP) DECL_LANG_FLAG_4 (EXP)

	/* Record whether a decl was used in an expression anywhere except an
	unevaluated operand of sizeof / typeof / alignof. This is only
	used for functions declared static but not defined, though outside
	sizeof and typeof it is set for other function decls as well. */
	#define C_DECL_USED(EXP) DECL_LANG_FLAG_5 (FUNCTION_DECL_CHECK (EXP))

	/* Record whether a label was defined in a statement expression which
	has finished and so can no longer be jumped to. */
	#define C_DECL_UNJUMPABLE_STMT_EXPR(EXP) \
	DECL_LANG_FLAG_6 (LABEL_DECL_CHECK (EXP))

	/* Record whether a label was the subject of a goto from outside the
	current level of statement expression nesting and so cannot be
	defined right now. */
	#define C_DECL_UNDEFINABLE_STMT_EXPR(EXP) \
	DECL_LANG_FLAG_7 (LABEL_DECL_CHECK (EXP))

	/* Record whether a label was defined in the scope of an identifier
	with variably modified type which has finished and so can no longer
	be jumped to. */
	#define C_DECL_UNJUMPABLE_VM(EXP) \
	DECL_LANG_FLAG_3 (LABEL_DECL_CHECK (EXP))

	/* Record whether a label was the subject of a goto from outside the
	current level of scopes of identifiers with variably modified type
	and so cannot be defined right now. */
	#define C_DECL_UNDEFINABLE_VM(EXP) \
	DECL_LANG_FLAG_5 (LABEL_DECL_CHECK (EXP))

	/* Record whether a variable has been declared threadprivate by
	#pragma omp threadprivate. */
	#define C_DECL_THREADPRIVATE_P(DECL) DECL_LANG_FLAG_3 (VAR_DECL_CHECK (DECL))

	/* Nonzero for a decl which either doesn't exist or isn't a prototype.
	N.B. Could be simplified if all built-in decls had complete prototypes
	(but this is presently difficult because some of them need FILE). /
	#define C_DECL_ISNT_PROTOTYPE(EXP) \
	(EXP == 0 \
	\|\| (TYPE_ARG_TYPES (TREE_TYPE (EXP)) == 0 \
	&& !DECL_BUILT_IN (EXP)))

	/* For FUNCTION_TYPE, a hidden list of types of arguments. The same as
	TYPE_ARG_TYPES for functions with prototypes, but created for functions
	without prototypes. */
	#define TYPE_ACTUAL_ARG_TYPES(NODE) TYPE_LANG_SLOT_1 (NODE)

	/* Record parser information about an expression that is irrelevant
	for code generation alongside a tree representing its value. */
	struct c_expr
	{
	/* The value of the expression. */
	tree value;
	/* Record the original binary operator of an expression, which may
	have been changed by fold, STRING_CST for unparenthesized string
	constants, or ERROR_MARK for other expressions (including
	parenthesized expressions). */
	enum tree_code original_code;
	};

	/* A kind of type specifier. Note that this information is currently
	only used to distinguish tag definitions, tag references and typeof
	uses. */
	enum c_typespec_kind {
	/* A reserved keyword type specifier. */
	ctsk_resword,
	/* A reference to a tag, previously declared, such as "struct foo".
	This includes where the previous declaration was as a different
	kind of tag, in which case this is only valid if shadowing that
	tag in an inner scope. */
	ctsk_tagref,
	/* A reference to a tag, not previously declared in a visible
	scope. */
	ctsk_tagfirstref,
	/* A definition of a tag such as "struct foo { int a; }". */
	ctsk_tagdef,
	/* A typedef name. */
	ctsk_typedef,
	/* An ObjC-specific kind of type specifier. */
	ctsk_objc,
	/* A typeof specifier. */
	ctsk_typeof
	};

	/* A type specifier: this structure is created in the parser and
	passed to declspecs_add_type only. */
	struct c_typespec {
	/* What kind of type specifier this is. */
	enum c_typespec_kind kind;
	/* The specifier itself. */
	tree spec;
	};

	/* A storage class specifier. */
	enum c_storage_class {
	csc_none,
	csc_auto,
	csc_extern,
	csc_register,
	csc_static,
	csc_typedef
	};

	/* A type specifier keyword "void", "_Bool", "char", "int", "float",
	"double", or none of these. */
	enum c_typespec_keyword {
	cts_none,
	cts_void,
	cts_bool,
	cts_char,
	cts_int,
	cts_float,
	cts_double,
	cts_dfloat32,
	cts_dfloat64,
	cts_dfloat128
	};

	/* A sequence of declaration specifiers in C. */
	struct c_declspecs {
	/* The type specified, if a single type specifier such as a struct,
	union or enum specifier, typedef name or typeof specifies the
	whole type, or NULL_TREE if none or a keyword such as "void" or
	"char" is used. Does not include qualifiers. */
	tree type;
	/* The attributes from a typedef decl. */
	tree decl_attr;
	/* When parsing, the attributes. Outside the parser, this will be
	NULL; attributes (possibly from multiple lists) will be passed
	separately. */
	tree attrs;
	/* Any type specifier keyword used such as "int", not reflecting
	modifiers such as "short", or cts_none if none. */
	enum c_typespec_keyword typespec_word;
	/* The storage class specifier, or csc_none if none. */
	enum c_storage_class storage_class;
	/* Whether any declaration specifiers have been seen at all. */
	BOOL_BITFIELD declspecs_seen_p : 1;
	/* Whether a type specifier has been seen. */
	BOOL_BITFIELD type_seen_p : 1;
	/* Whether something other than a storage class specifier or
	attribute has been seen. This is used to warn for the
	obsolescent usage of storage class specifiers other than at the
	start of the list. (Doing this properly would require function
	specifiers to be handled separately from storage class
	specifiers.) */
	BOOL_BITFIELD non_sc_seen_p : 1;
	/* Whether the type is specified by a typedef or typeof name. */
	BOOL_BITFIELD typedef_p : 1;
	/* Whether a struct, union or enum type either had its content
	defined by a type specifier in the list or was the first visible
	declaration of its tag. */
	BOOL_BITFIELD tag_defined_p : 1;
	/* Whether the type is explicitly "signed" or specified by a typedef
	whose type is explicitly "signed". */
	BOOL_BITFIELD explicit_signed_p : 1;
	/* Whether the specifiers include a deprecated typedef. */
	BOOL_BITFIELD deprecated_p : 1;
	+ /* APPLE LOCAL begin "unavailable" attribute (radar 2809697) */
	+ /* Whether the specifiers include a unavailable typedef. */
	+ BOOL_BITFIELD unavailable_p : 1;
	+ /* APPLE LOCAL end "unavailable" attribute (radar 2809697) */
	/* Whether the type defaulted to "int" because there were no type
	specifiers. */
	BOOL_BITFIELD default_int_p;
	/* Whether "long" was specified. */
	BOOL_BITFIELD long_p : 1;
	/* Whether "long" was specified more than once. */
	BOOL_BITFIELD long_long_p : 1;
	/* Whether "short" was specified. */
	BOOL_BITFIELD short_p : 1;
	/* Whether "signed" was specified. */
	BOOL_BITFIELD signed_p : 1;
	/* Whether "unsigned" was specified. */
	BOOL_BITFIELD unsigned_p : 1;
	/* Whether "complex" was specified. */
	BOOL_BITFIELD complex_p : 1;
	/* Whether "inline" was specified. */
	BOOL_BITFIELD inline_p : 1;
	/* Whether "__thread" was specified. */
	BOOL_BITFIELD thread_p : 1;
	/* Whether "const" was specified. */
	BOOL_BITFIELD const_p : 1;
	/* Whether "volatile" was specified. */
	BOOL_BITFIELD volatile_p : 1;
	/* Whether "restrict" was specified. */
	BOOL_BITFIELD restrict_p : 1;
	};

	/* The various kinds of declarators in C. */
	enum c_declarator_kind {
	/* An identifier. */
	cdk_id,
	/* A function. */
	cdk_function,
	/* An array. */
	cdk_array,
	/* A pointer. */
	cdk_pointer,
	/* Parenthesized declarator with nested attributes. */
	cdk_attrs
	};

	/* Information about the parameters in a function declarator. */
	struct c_arg_info {
	/* A list of parameter decls. */
	tree parms;
	/* A list of structure, union and enum tags defined. */
	tree tags;
	/* A list of argument types to go in the FUNCTION_TYPE. */
	tree types;
	/* A list of non-parameter decls (notably enumeration constants)
	defined with the parameters. */
	tree others;
	/* A list of VLA sizes from the parameters. In a function
	definition, these are used to ensure that side-effects in sizes
	of arrays converted to pointers (such as a parameter int i[n++])
	take place; otherwise, they are ignored. */
	tree pending_sizes;
	/* True when these arguments had []. /
	BOOL_BITFIELD had_vla_unspec : 1;
	};

	/* A declarator. */
	struct c_declarator {
	/* The kind of declarator. */
	enum c_declarator_kind kind;
	/* Except for cdk_id, the contained declarator. For cdk_id, NULL. */
	struct c_declarator *declarator;
	location_t id_loc; /* Currently only set for cdk_id. */
	union {
	/* For identifiers, an IDENTIFIER_NODE or NULL_TREE if an abstract
	declarator. */
	tree id;
	/* For functions. */
	struct c_arg_info *arg_info;
	/* For arrays. */
	struct {
	/* The array dimension, or NULL for [] and []. /
	tree dimen;
	/* The qualifiers inside []. */
	int quals;
	/* The attributes (currently ignored) inside []. */
	tree attrs;
	/* Whether [static] was used. */
	BOOL_BITFIELD static_p : 1;
	/* Whether [] was used. /
	BOOL_BITFIELD vla_unspec_p : 1;
	} array;
	/* For pointers, the qualifiers on the pointer type. */
	int pointer_quals;
	/* For attributes. */
	tree attrs;
	} u;
	};

	/* A type name. */
	struct c_type_name {
	/* The declaration specifiers. */
	struct c_declspecs *specs;
	/* The declarator. */
	struct c_declarator *declarator;
	};

	/* A parameter. */
	struct c_parm {
	/* The declaration specifiers, minus any prefix attributes. */
	struct c_declspecs *specs;
	/* The attributes. */
	tree attrs;
	/* The declarator. */
	struct c_declarator *declarator;
	};

	/* Save and restore the variables in this file and elsewhere
	that keep track of the progress of compilation of the current function.
	Used for nested functions. */

	struct language_function GTY(())
	{
	struct c_language_function base;
	tree x_break_label;
	tree x_cont_label;
	struct c_switch * GTY((skip)) x_switch_stack;
	struct c_arg_info * GTY((skip)) arg_info;
	int returns_value;
	int returns_null;
	int returns_abnormally;
	int warn_about_return_type;
	};

	/* Save lists of labels used or defined in particular contexts.
	Allocated on the parser obstack. */

	struct c_label_list
	{
	/* The label at the head of the list. */
	tree label;
	/* The rest of the list. */
	struct c_label_list *next;
	};

	/* Statement expression context. */

	struct c_label_context_se
	{
	/* The labels defined at this level of nesting. */
	struct c_label_list *labels_def;
	/* The labels used at this level of nesting. */
	struct c_label_list *labels_used;
	/* The next outermost context. */
	struct c_label_context_se *next;
	};

	/* Context of variably modified declarations. */

	struct c_label_context_vm
	{
	/* The labels defined at this level of nesting. */
	struct c_label_list *labels_def;
	/* The labels used at this level of nesting. */
	struct c_label_list *labels_used;
	/* The scope of this context. Multiple contexts may be at the same
	numbered scope, since each variably modified declaration starts a
	new context. */
	unsigned scope;
	/* The next outermost context. */
	struct c_label_context_vm *next;
	};


	/* in c-parser.c */
	extern void c_parse_init (void);

	/* in c-aux-info.c */
	extern void gen_aux_info_record (tree, int, int, int);

	/* in c-decl.c */
	extern struct obstack parser_obstack;
	extern tree c_break_label;
	extern tree c_cont_label;

	extern int global_bindings_p (void);
	extern void push_scope (void);
	extern tree pop_scope (void);
	extern void insert_block (tree);
	extern void c_expand_body (tree);

	extern void c_init_decl_processing (void);
	extern void c_dup_lang_specific_decl (tree);
	extern void c_print_identifier (FILE *, tree, int);
	extern int quals_from_declspecs (const struct c_declspecs *);
	extern struct c_declarator build_array_declarator (tree, struct c_declspecs ,
	bool, bool);
	extern tree build_enumerator (tree, tree);
	extern tree check_for_loop_decls (void);
	extern void mark_forward_parm_decls (void);
	extern void declare_parm_level (void);
	extern void undeclared_variable (tree, location_t);
	extern tree declare_label (tree);
	extern tree define_label (location_t, tree);
	extern void c_maybe_initialize_eh (void);
	extern void finish_decl (tree, tree, tree);
	extern tree finish_enum (tree, tree, tree);
	extern void finish_function (void);
	extern tree finish_struct (tree, tree, tree);
	extern struct c_arg_info *get_parm_info (bool);
	extern tree grokfield (struct c_declarator , struct c_declspecs , tree);
	extern tree groktypename (struct c_type_name *);
	extern tree grokparm (const struct c_parm *);
	extern tree implicitly_declare (tree);
	extern void keep_next_level (void);
	extern void pending_xref_error (void);
	extern void c_push_function_context (struct function *);
	extern void c_pop_function_context (struct function *);
	extern void push_parm_decl (const struct c_parm *);
	extern struct c_declarator set_array_declarator_inner (struct c_declarator ,
	struct c_declarator *,
	bool);
	extern tree builtin_function (const char *, tree, int, enum built_in_class,
	const char *, tree);
	extern void shadow_tag (const struct c_declspecs *);
	extern void shadow_tag_warned (const struct c_declspecs *, int);
	extern tree start_enum (tree);
	extern int start_function (struct c_declspecs , struct c_declarator , tree);
	extern tree start_decl (struct c_declarator , struct c_declspecs , bool,
	tree);
	extern tree start_struct (enum tree_code, tree);
	extern void store_parm_decls (void);
	extern void store_parm_decls_from (struct c_arg_info *);
	extern tree xref_tag (enum tree_code, tree);
	extern struct c_typespec parser_xref_tag (enum tree_code, tree);
	extern int c_expand_decl (tree);
	extern struct c_parm build_c_parm (struct c_declspecs , tree,
	struct c_declarator *);
	extern struct c_declarator *build_attrs_declarator (tree,
	struct c_declarator *);
	extern struct c_declarator build_function_declarator (struct c_arg_info ,
	struct c_declarator *);
	extern struct c_declarator *build_id_declarator (tree);
	extern struct c_declarator make_pointer_declarator (struct c_declspecs ,
	struct c_declarator *);
	extern struct c_declspecs *build_null_declspecs (void);
	extern struct c_declspecs declspecs_add_qual (struct c_declspecs , tree);
	extern struct c_declspecs declspecs_add_type (struct c_declspecs ,
	struct c_typespec);
	extern struct c_declspecs declspecs_add_scspec (struct c_declspecs , tree);
	extern struct c_declspecs declspecs_add_attrs (struct c_declspecs , tree);
	extern struct c_declspecs finish_declspecs (struct c_declspecs );

	/* in c-objc-common.c */
	extern int c_disregard_inline_limits (tree);
	extern int c_cannot_inline_tree_fn (tree *);
	extern bool c_objc_common_init (void);
	extern bool c_missing_noreturn_ok_p (tree);
	extern tree c_objc_common_truthvalue_conversion (tree expr);
	extern bool c_warn_unused_global_decl (tree);
	extern void c_initialize_diagnostics (diagnostic_context *);
	extern bool c_vla_unspec_p (tree x, tree fn);

	#define c_build_type_variant(TYPE, CONST_P, VOLATILE_P) \
	c_build_qualified_type ((TYPE), \
	((CONST_P) ? TYPE_QUAL_CONST : 0) \| \
	((VOLATILE_P) ? TYPE_QUAL_VOLATILE : 0))

	/* in c-typeck.c */
	extern int in_alignof;
	extern int in_sizeof;
	extern int in_typeof;

	extern struct c_switch *c_switch_stack;
	extern struct c_label_context_se *label_context_stack_se;
	extern struct c_label_context_vm *label_context_stack_vm;

	extern tree require_complete_type (tree);
	extern int same_translation_unit_p (tree, tree);
	extern int comptypes (tree, tree);
	extern bool c_vla_type_p (tree);
	extern bool c_mark_addressable (tree);
	extern void c_incomplete_type_error (tree, tree);
	extern tree c_type_promotes_to (tree);
	extern struct c_expr default_function_array_conversion (struct c_expr);
	extern tree composite_type (tree, tree);
	extern tree build_component_ref (tree, tree);
	extern tree build_array_ref (tree, tree);
	extern tree build_external_ref (tree, int, location_t);
	extern void pop_maybe_used (bool);
	extern struct c_expr c_expr_sizeof_expr (struct c_expr);
	extern struct c_expr c_expr_sizeof_type (struct c_type_name *);
	extern struct c_expr parser_build_unary_op (enum tree_code, struct c_expr);
	extern struct c_expr parser_build_binary_op (enum tree_code, struct c_expr,
	struct c_expr);
	extern tree build_conditional_expr (tree, tree, tree);
	extern tree build_compound_expr (tree, tree);
	extern tree c_cast_expr (struct c_type_name *, tree);
	extern tree build_c_cast (tree, tree);
	extern void store_init_value (tree, tree);
	extern void error_init (const char *);
	extern void pedwarn_init (const char *);
	extern void maybe_warn_string_init (tree, struct c_expr);
	extern void start_init (tree, tree, int);
	extern void finish_init (void);
	extern void really_start_incremental_init (tree);
	extern void push_init_level (int);
	extern struct c_expr pop_init_level (int);
	extern void set_init_index (tree, tree);
	extern void set_init_label (tree);
	extern void process_init_element (struct c_expr);
	extern tree build_compound_literal (tree, tree);
	extern tree c_start_case (tree);
	extern void c_finish_case (tree);
	extern tree build_asm_expr (tree, tree, tree, tree, bool);
	extern tree build_asm_stmt (tree, tree);
	extern tree c_convert_parm_for_inlining (tree, tree, tree, int);
	extern int c_types_compatible_p (tree, tree);
	extern tree c_begin_compound_stmt (bool);
	extern tree c_end_compound_stmt (tree, bool);
	extern void c_finish_if_stmt (location_t, tree, tree, tree, bool);
	-extern void c_finish_loop (location_t, tree, tree, tree, tree, tree, bool);
	+/* APPLE LOCAL begin for-fsf-4_4 3274130 5295549 */ \
	+extern void c_finish_loop (location_t, tree, tree, tree, tree, tree, tree,
	+ bool);
	+/* APPLE LOCAL end for-fsf-4_4 3274130 5295549 */ \
	extern tree c_begin_stmt_expr (void);
	extern tree c_finish_stmt_expr (tree);
	extern tree c_process_expr_stmt (tree);
	extern tree c_finish_expr_stmt (tree);
	extern tree c_finish_return (tree);
	extern tree c_finish_bc_stmt (tree *, bool);
	extern tree c_finish_goto_label (tree);
	extern tree c_finish_goto_ptr (tree);
	extern void c_begin_vm_scope (unsigned int);
	extern void c_end_vm_scope (unsigned int);
	extern tree c_expr_to_decl (tree, bool , bool , bool *);
	extern tree c_begin_omp_parallel (void);
	extern tree c_finish_omp_parallel (tree, tree);
	extern tree c_finish_omp_clauses (tree);

	/* Set to 0 at beginning of a function definition, set to 1 if
	a return statement that specifies a return value is seen. */

	extern int current_function_returns_value;

	/* Set to 0 at beginning of a function definition, set to 1 if
	a return statement with no argument is seen. */

	extern int current_function_returns_null;

	/* Set to 0 at beginning of a function definition, set to 1 if
	a call to a noreturn function is seen. */

	extern int current_function_returns_abnormally;

	/* Nonzero means we are reading code that came from a system header file. */

	extern int system_header_p;

	/* True means global_bindings_p should return false even if the scope stack
	says we are in file scope. */

	extern bool c_override_global_bindings_to_false;

	/* True means we've initialized exception handling. */
	extern bool c_eh_initialized_p;

	/* In c-decl.c */
	extern void c_finish_incomplete_decl (tree);
	extern void c_write_global_declarations (void);

	/* In order for the format checking to accept the C frontend
	diagnostic framework extensions, you must include this file before
	toplev.h, not after. */
	#if GCC_VERSION >= 4001
	#define ATTRIBUTE_GCC_CDIAG(m, n) __attribute__ ((__format__ (GCC_DIAG_STYLE, m ,n))) ATTRIBUTE_NONNULL(m)
	#else
	#define ATTRIBUTE_GCC_CDIAG(m, n) ATTRIBUTE_NONNULL(m)
	#endif

	extern void pedwarn_c90 (const char *, ...) ATTRIBUTE_GCC_CDIAG(1,2);
	extern void pedwarn_c99 (const char *, ...) ATTRIBUTE_GCC_CDIAG(1,2);

	#endif /* ! GCC_C_TREE_H */
	diff --git a/contrib/gcc/c-typeck.c b/contrib/gcc/c-typeck.c
	index cd30cd1cd2d4..c60aa26bdc94 100644
	--- a/contrib/gcc/c-typeck.c
	+++ b/contrib/gcc/c-typeck.c
	@@ -1,8764 +1,8781 @@
	/* Build expressions with type checking for C compiler.
	Copyright (C) 1987, 1988, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
	1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006
	Free Software Foundation, Inc.

	This file is part of GCC.

	GCC is free software; you can redistribute it and/or modify it under
	the terms of the GNU General Public License as published by the Free
	Software Foundation; either version 2, or (at your option) any later
	version.

	GCC is distributed in the hope that it will be useful, but WITHOUT ANY
	WARRANTY; without even the implied warranty of MERCHANTABILITY or
	FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	for more details.

	You should have received a copy of the GNU General Public License
	along with GCC; see the file COPYING. If not, write to the Free
	Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
	02110-1301, USA. */


	/* This file is part of the C front end.
	It contains routines to build C expressions given their operands,
	including computing the types of the result, C-specific error checks,
	and some optimization. */

	#include "config.h"
	#include "system.h"
	#include "coretypes.h"
	#include "tm.h"
	#include "rtl.h"
	#include "tree.h"
	#include "langhooks.h"
	#include "c-tree.h"
	#include "tm_p.h"
	#include "flags.h"
	#include "output.h"
	#include "expr.h"
	#include "toplev.h"
	#include "intl.h"
	#include "ggc.h"
	#include "target.h"
	#include "tree-iterator.h"
	#include "tree-gimple.h"
	#include "tree-flow.h"

	/* Possible cases of implicit bad conversions. Used to select
	diagnostic messages in convert_for_assignment. */
	enum impl_conv {
	ic_argpass,
	ic_argpass_nonproto,
	ic_assign,
	ic_init,
	ic_return
	};

	/* The level of nesting inside "__alignof__". */
	int in_alignof;

	/* The level of nesting inside "sizeof". */
	int in_sizeof;

	/* The level of nesting inside "typeof". */
	int in_typeof;

	struct c_label_context_se *label_context_stack_se;
	struct c_label_context_vm *label_context_stack_vm;

	/* Nonzero if we've already printed a "missing braces around initializer"
	message within this initializer. */
	static int missing_braces_mentioned;

	static int require_constant_value;
	static int require_constant_elements;

	static bool null_pointer_constant_p (tree);
	static tree qualify_type (tree, tree);
	static int tagged_types_tu_compatible_p (tree, tree);
	static int comp_target_types (tree, tree);
	static int function_types_compatible_p (tree, tree);
	static int type_lists_compatible_p (tree, tree);
	static tree decl_constant_value_for_broken_optimization (tree);
	static tree lookup_field (tree, tree);
	static tree convert_arguments (tree, tree, tree, tree);
	static tree pointer_diff (tree, tree);
	static tree convert_for_assignment (tree, tree, enum impl_conv, tree, tree,
	int);
	static tree valid_compound_expr_initializer (tree, tree);
	static void push_string (const char *);
	static void push_member_name (tree);
	static int spelling_length (void);
	static char print_spelling (char );
	static void warning_init (const char *);
	static tree digest_init (tree, tree, bool, int);
	static void output_init_element (tree, bool, tree, tree, int);
	static void output_pending_init_elements (int);
	static int set_designator (int);
	static void push_range_stack (tree);
	static void add_pending_init (tree, tree);
	static void set_nonincremental_init (void);
	static void set_nonincremental_init_from_string (tree);
	static tree find_init_member (tree);
	static void readonly_error (tree, enum lvalue_use);
	static int lvalue_or_else (tree, enum lvalue_use);
	static int lvalue_p (tree);
	static void record_maybe_used_decl (tree);
	static int comptypes_internal (tree, tree);

	/* Return true if EXP is a null pointer constant, false otherwise. */

	static bool
	null_pointer_constant_p (tree expr)
	{
	/* This should really operate on c_expr structures, but they aren't
	yet available everywhere required. */
	tree type = TREE_TYPE (expr);
	return (TREE_CODE (expr) == INTEGER_CST
	&& !TREE_CONSTANT_OVERFLOW (expr)
	&& integer_zerop (expr)
	&& (INTEGRAL_TYPE_P (type)
	\|\| (TREE_CODE (type) == POINTER_TYPE
	&& VOID_TYPE_P (TREE_TYPE (type))
	&& TYPE_QUALS (TREE_TYPE (type)) == TYPE_UNQUALIFIED)));
	}
	/* This is a cache to hold if two types are compatible or not. */

	struct tagged_tu_seen_cache {
	const struct tagged_tu_seen_cache * next;
	tree t1;
	tree t2;
	/* The return value of tagged_types_tu_compatible_p if we had seen
	these two types already. */
	int val;
	};

	static const struct tagged_tu_seen_cache * tagged_tu_seen_base;
	static void free_all_tagged_tu_seen_up_to (const struct tagged_tu_seen_cache *);

	/* Do `exp = require_complete_type (exp);' to make sure exp
	does not have an incomplete type. (That includes void types.) */

	tree
	require_complete_type (tree value)
	{
	tree type = TREE_TYPE (value);

	if (value == error_mark_node \|\| type == error_mark_node)
	return error_mark_node;

	/* First, detect a valid value with a complete type. */
	if (COMPLETE_TYPE_P (type))
	return value;

	c_incomplete_type_error (value, type);
	return error_mark_node;
	}

	/* Print an error message for invalid use of an incomplete type.
	VALUE is the expression that was used (or 0 if that isn't known)
	and TYPE is the type that was invalid. */

	void
	c_incomplete_type_error (tree value, tree type)
	{
	const char *type_code_string;

	/* Avoid duplicate error message. */
	if (TREE_CODE (type) == ERROR_MARK)
	return;

	if (value != 0 && (TREE_CODE (value) == VAR_DECL
	\|\| TREE_CODE (value) == PARM_DECL))
	error ("%qD has an incomplete type", value);
	else
	{
	retry:
	/* We must print an error message. Be clever about what it says. */

	switch (TREE_CODE (type))
	{
	case RECORD_TYPE:
	type_code_string = "struct";
	break;

	case UNION_TYPE:
	type_code_string = "union";
	break;

	case ENUMERAL_TYPE:
	type_code_string = "enum";
	break;

	case VOID_TYPE:
	error ("invalid use of void expression");
	return;

	case ARRAY_TYPE:
	if (TYPE_DOMAIN (type))
	{
	if (TYPE_MAX_VALUE (TYPE_DOMAIN (type)) == NULL)
	{
	error ("invalid use of flexible array member");
	return;
	}
	type = TREE_TYPE (type);
	goto retry;
	}
	error ("invalid use of array with unspecified bounds");
	return;

	default:
	gcc_unreachable ();
	}

	if (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE)
	error ("invalid use of undefined type %<%s %E%>",
	type_code_string, TYPE_NAME (type));
	else
	/* If this type has a typedef-name, the TYPE_NAME is a TYPE_DECL. */
	error ("invalid use of incomplete typedef %qD", TYPE_NAME (type));
	}
	}

	/* Given a type, apply default promotions wrt unnamed function
	arguments and return the new type. */

	tree
	c_type_promotes_to (tree type)
	{
	if (TYPE_MAIN_VARIANT (type) == float_type_node)
	return double_type_node;

	if (c_promoting_integer_type_p (type))
	{
	/* Preserve unsignedness if not really getting any wider. */
	if (TYPE_UNSIGNED (type)
	&& (TYPE_PRECISION (type) == TYPE_PRECISION (integer_type_node)))
	return unsigned_type_node;
	return integer_type_node;
	}

	return type;
	}

	/* Return a variant of TYPE which has all the type qualifiers of LIKE
	as well as those of TYPE. */

	static tree
	qualify_type (tree type, tree like)
	{
	return c_build_qualified_type (type,
	TYPE_QUALS (type) \| TYPE_QUALS (like));
	}

	/* Return true iff the given tree T is a variable length array. */

	bool
	c_vla_type_p (tree t)
	{
	if (TREE_CODE (t) == ARRAY_TYPE
	&& C_TYPE_VARIABLE_SIZE (t))
	return true;
	return false;
	}

	/* Return the composite type of two compatible types.

	We assume that comptypes has already been done and returned
	nonzero; if that isn't so, this may crash. In particular, we
	assume that qualifiers match. */

	tree
	composite_type (tree t1, tree t2)
	{
	enum tree_code code1;
	enum tree_code code2;
	tree attributes;

	/* Save time if the two types are the same. */

	if (t1 == t2) return t1;

	/* If one type is nonsense, use the other. */
	if (t1 == error_mark_node)
	return t2;
	if (t2 == error_mark_node)
	return t1;

	code1 = TREE_CODE (t1);
	code2 = TREE_CODE (t2);

	/* Merge the attributes. */
	attributes = targetm.merge_type_attributes (t1, t2);

	/* If one is an enumerated type and the other is the compatible
	integer type, the composite type might be either of the two
	(DR#013 question 3). For consistency, use the enumerated type as
	the composite type. */

	if (code1 == ENUMERAL_TYPE && code2 == INTEGER_TYPE)
	return t1;
	if (code2 == ENUMERAL_TYPE && code1 == INTEGER_TYPE)
	return t2;

	gcc_assert (code1 == code2);

	switch (code1)
	{
	case POINTER_TYPE:
	/* For two pointers, do this recursively on the target type. */
	{
	tree pointed_to_1 = TREE_TYPE (t1);
	tree pointed_to_2 = TREE_TYPE (t2);
	tree target = composite_type (pointed_to_1, pointed_to_2);
	t1 = build_pointer_type (target);
	t1 = build_type_attribute_variant (t1, attributes);
	return qualify_type (t1, t2);
	}

	case ARRAY_TYPE:
	{
	tree elt = composite_type (TREE_TYPE (t1), TREE_TYPE (t2));
	int quals;
	tree unqual_elt;
	tree d1 = TYPE_DOMAIN (t1);
	tree d2 = TYPE_DOMAIN (t2);
	bool d1_variable, d2_variable;
	bool d1_zero, d2_zero;

	/* We should not have any type quals on arrays at all. */
	gcc_assert (!TYPE_QUALS (t1) && !TYPE_QUALS (t2));

	d1_zero = d1 == 0 \|\| !TYPE_MAX_VALUE (d1);
	d2_zero = d2 == 0 \|\| !TYPE_MAX_VALUE (d2);

	d1_variable = (!d1_zero
	&& (TREE_CODE (TYPE_MIN_VALUE (d1)) != INTEGER_CST
	\|\| TREE_CODE (TYPE_MAX_VALUE (d1)) != INTEGER_CST));
	d2_variable = (!d2_zero
	&& (TREE_CODE (TYPE_MIN_VALUE (d2)) != INTEGER_CST
	\|\| TREE_CODE (TYPE_MAX_VALUE (d2)) != INTEGER_CST));
	d1_variable = d1_variable \|\| (d1_zero && c_vla_type_p (t1));
	d2_variable = d2_variable \|\| (d2_zero && c_vla_type_p (t2));

	/* Save space: see if the result is identical to one of the args. */
	if (elt == TREE_TYPE (t1) && TYPE_DOMAIN (t1)
	&& (d2_variable \|\| d2_zero \|\| !d1_variable))
	return build_type_attribute_variant (t1, attributes);
	if (elt == TREE_TYPE (t2) && TYPE_DOMAIN (t2)
	&& (d1_variable \|\| d1_zero \|\| !d2_variable))
	return build_type_attribute_variant (t2, attributes);

	if (elt == TREE_TYPE (t1) && !TYPE_DOMAIN (t2) && !TYPE_DOMAIN (t1))
	return build_type_attribute_variant (t1, attributes);
	if (elt == TREE_TYPE (t2) && !TYPE_DOMAIN (t2) && !TYPE_DOMAIN (t1))
	return build_type_attribute_variant (t2, attributes);

	/* Merge the element types, and have a size if either arg has
	one. We may have qualifiers on the element types. To set
	up TYPE_MAIN_VARIANT correctly, we need to form the
	composite of the unqualified types and add the qualifiers
	back at the end. */
	quals = TYPE_QUALS (strip_array_types (elt));
	unqual_elt = c_build_qualified_type (elt, TYPE_UNQUALIFIED);
	t1 = build_array_type (unqual_elt,
	TYPE_DOMAIN ((TYPE_DOMAIN (t1)
	&& (d2_variable
	\|\| d2_zero
	\|\| !d1_variable))
	? t1
	: t2));
	t1 = c_build_qualified_type (t1, quals);
	return build_type_attribute_variant (t1, attributes);
	}

	case ENUMERAL_TYPE:
	case RECORD_TYPE:
	case UNION_TYPE:
	if (attributes != NULL)
	{
	/* Try harder not to create a new aggregate type. */
	if (attribute_list_equal (TYPE_ATTRIBUTES (t1), attributes))
	return t1;
	if (attribute_list_equal (TYPE_ATTRIBUTES (t2), attributes))
	return t2;
	}
	return build_type_attribute_variant (t1, attributes);

	case FUNCTION_TYPE:
	/* Function types: prefer the one that specified arg types.
	If both do, merge the arg types. Also merge the return types. */
	{
	tree valtype = composite_type (TREE_TYPE (t1), TREE_TYPE (t2));
	tree p1 = TYPE_ARG_TYPES (t1);
	tree p2 = TYPE_ARG_TYPES (t2);
	int len;
	tree newargs, n;
	int i;

	/* Save space: see if the result is identical to one of the args. */
	if (valtype == TREE_TYPE (t1) && !TYPE_ARG_TYPES (t2))
	return build_type_attribute_variant (t1, attributes);
	if (valtype == TREE_TYPE (t2) && !TYPE_ARG_TYPES (t1))
	return build_type_attribute_variant (t2, attributes);

	/* Simple way if one arg fails to specify argument types. */
	if (TYPE_ARG_TYPES (t1) == 0)
	{
	t1 = build_function_type (valtype, TYPE_ARG_TYPES (t2));
	t1 = build_type_attribute_variant (t1, attributes);
	return qualify_type (t1, t2);
	}
	if (TYPE_ARG_TYPES (t2) == 0)
	{
	t1 = build_function_type (valtype, TYPE_ARG_TYPES (t1));
	t1 = build_type_attribute_variant (t1, attributes);
	return qualify_type (t1, t2);
	}

	/* If both args specify argument types, we must merge the two
	lists, argument by argument. */
	/* Tell global_bindings_p to return false so that variable_size
	doesn't die on VLAs in parameter types. */
	c_override_global_bindings_to_false = true;

	len = list_length (p1);
	newargs = 0;

	for (i = 0; i < len; i++)
	newargs = tree_cons (NULL_TREE, NULL_TREE, newargs);

	n = newargs;

	for (; p1;
	p1 = TREE_CHAIN (p1), p2 = TREE_CHAIN (p2), n = TREE_CHAIN (n))
	{
	/* A null type means arg type is not specified.
	Take whatever the other function type has. */
	if (TREE_VALUE (p1) == 0)
	{
	TREE_VALUE (n) = TREE_VALUE (p2);
	goto parm_done;
	}
	if (TREE_VALUE (p2) == 0)
	{
	TREE_VALUE (n) = TREE_VALUE (p1);
	goto parm_done;
	}

	/* Given wait (union {union wait u; int i} *)
	and wait (union wait *),
	prefer union wait * as type of parm. */
	if (TREE_CODE (TREE_VALUE (p1)) == UNION_TYPE
	&& TREE_VALUE (p1) != TREE_VALUE (p2))
	{
	tree memb;
	tree mv2 = TREE_VALUE (p2);
	if (mv2 && mv2 != error_mark_node
	&& TREE_CODE (mv2) != ARRAY_TYPE)
	mv2 = TYPE_MAIN_VARIANT (mv2);
	for (memb = TYPE_FIELDS (TREE_VALUE (p1));
	memb; memb = TREE_CHAIN (memb))
	{
	tree mv3 = TREE_TYPE (memb);
	if (mv3 && mv3 != error_mark_node
	&& TREE_CODE (mv3) != ARRAY_TYPE)
	mv3 = TYPE_MAIN_VARIANT (mv3);
	if (comptypes (mv3, mv2))
	{
	TREE_VALUE (n) = composite_type (TREE_TYPE (memb),
	TREE_VALUE (p2));
	if (pedantic)
	pedwarn ("function types not truly compatible in ISO C");
	goto parm_done;
	}
	}
	}
	if (TREE_CODE (TREE_VALUE (p2)) == UNION_TYPE
	&& TREE_VALUE (p2) != TREE_VALUE (p1))
	{
	tree memb;
	tree mv1 = TREE_VALUE (p1);
	if (mv1 && mv1 != error_mark_node
	&& TREE_CODE (mv1) != ARRAY_TYPE)
	mv1 = TYPE_MAIN_VARIANT (mv1);
	for (memb = TYPE_FIELDS (TREE_VALUE (p2));
	memb; memb = TREE_CHAIN (memb))
	{
	tree mv3 = TREE_TYPE (memb);
	if (mv3 && mv3 != error_mark_node
	&& TREE_CODE (mv3) != ARRAY_TYPE)
	mv3 = TYPE_MAIN_VARIANT (mv3);
	if (comptypes (mv3, mv1))
	{
	TREE_VALUE (n) = composite_type (TREE_TYPE (memb),
	TREE_VALUE (p1));
	if (pedantic)
	pedwarn ("function types not truly compatible in ISO C");
	goto parm_done;
	}
	}
	}
	TREE_VALUE (n) = composite_type (TREE_VALUE (p1), TREE_VALUE (p2));
	parm_done: ;
	}

	c_override_global_bindings_to_false = false;
	t1 = build_function_type (valtype, newargs);
	t1 = qualify_type (t1, t2);
	/* ... falls through ... */
	}

	default:
	return build_type_attribute_variant (t1, attributes);
	}

	}

	/* Return the type of a conditional expression between pointers to
	possibly differently qualified versions of compatible types.

	We assume that comp_target_types has already been done and returned
	nonzero; if that isn't so, this may crash. */

	static tree
	common_pointer_type (tree t1, tree t2)
	{
	tree attributes;
	tree pointed_to_1, mv1;
	tree pointed_to_2, mv2;
	tree target;

	/* Save time if the two types are the same. */

	if (t1 == t2) return t1;

	/* If one type is nonsense, use the other. */
	if (t1 == error_mark_node)
	return t2;
	if (t2 == error_mark_node)
	return t1;

	gcc_assert (TREE_CODE (t1) == POINTER_TYPE
	&& TREE_CODE (t2) == POINTER_TYPE);

	/* Merge the attributes. */
	attributes = targetm.merge_type_attributes (t1, t2);

	/* Find the composite type of the target types, and combine the
	qualifiers of the two types' targets. Do not lose qualifiers on
	array element types by taking the TYPE_MAIN_VARIANT. */
	mv1 = pointed_to_1 = TREE_TYPE (t1);
	mv2 = pointed_to_2 = TREE_TYPE (t2);
	if (TREE_CODE (mv1) != ARRAY_TYPE)
	mv1 = TYPE_MAIN_VARIANT (pointed_to_1);
	if (TREE_CODE (mv2) != ARRAY_TYPE)
	mv2 = TYPE_MAIN_VARIANT (pointed_to_2);
	target = composite_type (mv1, mv2);
	t1 = build_pointer_type (c_build_qualified_type
	(target,
	TYPE_QUALS (pointed_to_1) \|
	TYPE_QUALS (pointed_to_2)));
	return build_type_attribute_variant (t1, attributes);
	}

	/* Return the common type for two arithmetic types under the usual
	arithmetic conversions. The default conversions have already been
	applied, and enumerated types converted to their compatible integer
	types. The resulting type is unqualified and has no attributes.

	This is the type for the result of most arithmetic operations
	if the operands have the given two types. */

	static tree
	c_common_type (tree t1, tree t2)
	{
	enum tree_code code1;
	enum tree_code code2;

	/* If one type is nonsense, use the other. */
	if (t1 == error_mark_node)
	return t2;
	if (t2 == error_mark_node)
	return t1;

	if (TYPE_QUALS (t1) != TYPE_UNQUALIFIED)
	t1 = TYPE_MAIN_VARIANT (t1);

	if (TYPE_QUALS (t2) != TYPE_UNQUALIFIED)
	t2 = TYPE_MAIN_VARIANT (t2);

	if (TYPE_ATTRIBUTES (t1) != NULL_TREE)
	t1 = build_type_attribute_variant (t1, NULL_TREE);

	if (TYPE_ATTRIBUTES (t2) != NULL_TREE)
	t2 = build_type_attribute_variant (t2, NULL_TREE);

	/* Save time if the two types are the same. */

	if (t1 == t2) return t1;

	code1 = TREE_CODE (t1);
	code2 = TREE_CODE (t2);

	gcc_assert (code1 == VECTOR_TYPE \|\| code1 == COMPLEX_TYPE
	\|\| code1 == REAL_TYPE \|\| code1 == INTEGER_TYPE);
	gcc_assert (code2 == VECTOR_TYPE \|\| code2 == COMPLEX_TYPE
	\|\| code2 == REAL_TYPE \|\| code2 == INTEGER_TYPE);

	/* When one operand is a decimal float type, the other operand cannot be
	a generic float type or a complex type. We also disallow vector types
	here. */
	if ((DECIMAL_FLOAT_TYPE_P (t1) \|\| DECIMAL_FLOAT_TYPE_P (t2))
	&& !(DECIMAL_FLOAT_TYPE_P (t1) && DECIMAL_FLOAT_TYPE_P (t2)))
	{
	if (code1 == VECTOR_TYPE \|\| code2 == VECTOR_TYPE)
	{
	error ("can%'t mix operands of decimal float and vector types");
	return error_mark_node;
	}
	if (code1 == COMPLEX_TYPE \|\| code2 == COMPLEX_TYPE)
	{
	error ("can%'t mix operands of decimal float and complex types");
	return error_mark_node;
	}
	if (code1 == REAL_TYPE && code2 == REAL_TYPE)
	{
	error ("can%'t mix operands of decimal float and other float types");
	return error_mark_node;
	}
	}

	/* If one type is a vector type, return that type. (How the usual
	arithmetic conversions apply to the vector types extension is not
	precisely specified.) */
	if (code1 == VECTOR_TYPE)
	return t1;

	if (code2 == VECTOR_TYPE)
	return t2;

	/* If one type is complex, form the common type of the non-complex
	components, then make that complex. Use T1 or T2 if it is the
	required type. */
	if (code1 == COMPLEX_TYPE \|\| code2 == COMPLEX_TYPE)
	{
	tree subtype1 = code1 == COMPLEX_TYPE ? TREE_TYPE (t1) : t1;
	tree subtype2 = code2 == COMPLEX_TYPE ? TREE_TYPE (t2) : t2;
	tree subtype = c_common_type (subtype1, subtype2);

	if (code1 == COMPLEX_TYPE && TREE_TYPE (t1) == subtype)
	return t1;
	else if (code2 == COMPLEX_TYPE && TREE_TYPE (t2) == subtype)
	return t2;
	else
	return build_complex_type (subtype);
	}

	/* If only one is real, use it as the result. */

	if (code1 == REAL_TYPE && code2 != REAL_TYPE)
	return t1;

	if (code2 == REAL_TYPE && code1 != REAL_TYPE)
	return t2;

	/* If both are real and either are decimal floating point types, use
	the decimal floating point type with the greater precision. */

	if (code1 == REAL_TYPE && code2 == REAL_TYPE)
	{
	if (TYPE_MAIN_VARIANT (t1) == dfloat128_type_node
	\|\| TYPE_MAIN_VARIANT (t2) == dfloat128_type_node)
	return dfloat128_type_node;
	else if (TYPE_MAIN_VARIANT (t1) == dfloat64_type_node
	\|\| TYPE_MAIN_VARIANT (t2) == dfloat64_type_node)
	return dfloat64_type_node;
	else if (TYPE_MAIN_VARIANT (t1) == dfloat32_type_node
	\|\| TYPE_MAIN_VARIANT (t2) == dfloat32_type_node)
	return dfloat32_type_node;
	}

	/* Both real or both integers; use the one with greater precision. */

	if (TYPE_PRECISION (t1) > TYPE_PRECISION (t2))
	return t1;
	else if (TYPE_PRECISION (t2) > TYPE_PRECISION (t1))
	return t2;

	/* Same precision. Prefer long longs to longs to ints when the
	same precision, following the C99 rules on integer type rank
	(which are equivalent to the C90 rules for C90 types). */

	if (TYPE_MAIN_VARIANT (t1) == long_long_unsigned_type_node
	\|\| TYPE_MAIN_VARIANT (t2) == long_long_unsigned_type_node)
	return long_long_unsigned_type_node;

	if (TYPE_MAIN_VARIANT (t1) == long_long_integer_type_node
	\|\| TYPE_MAIN_VARIANT (t2) == long_long_integer_type_node)
	{
	if (TYPE_UNSIGNED (t1) \|\| TYPE_UNSIGNED (t2))
	return long_long_unsigned_type_node;
	else
	return long_long_integer_type_node;
	}

	if (TYPE_MAIN_VARIANT (t1) == long_unsigned_type_node
	\|\| TYPE_MAIN_VARIANT (t2) == long_unsigned_type_node)
	return long_unsigned_type_node;

	if (TYPE_MAIN_VARIANT (t1) == long_integer_type_node
	\|\| TYPE_MAIN_VARIANT (t2) == long_integer_type_node)
	{
	/* But preserve unsignedness from the other type,
	since long cannot hold all the values of an unsigned int. */
	if (TYPE_UNSIGNED (t1) \|\| TYPE_UNSIGNED (t2))
	return long_unsigned_type_node;
	else
	return long_integer_type_node;
	}

	/* Likewise, prefer long double to double even if same size. */
	if (TYPE_MAIN_VARIANT (t1) == long_double_type_node
	\|\| TYPE_MAIN_VARIANT (t2) == long_double_type_node)
	return long_double_type_node;

	/* Otherwise prefer the unsigned one. */

	if (TYPE_UNSIGNED (t1))
	return t1;
	else
	return t2;
	}

	/* Wrapper around c_common_type that is used by c-common.c and other
	front end optimizations that remove promotions. ENUMERAL_TYPEs
	are allowed here and are converted to their compatible integer types.
	BOOLEAN_TYPEs are allowed here and return either boolean_type_node or
	preferably a non-Boolean type as the common type. */
	tree
	common_type (tree t1, tree t2)
	{
	if (TREE_CODE (t1) == ENUMERAL_TYPE)
	t1 = c_common_type_for_size (TYPE_PRECISION (t1), 1);
	if (TREE_CODE (t2) == ENUMERAL_TYPE)
	t2 = c_common_type_for_size (TYPE_PRECISION (t2), 1);

	/* If both types are BOOLEAN_TYPE, then return boolean_type_node. */
	if (TREE_CODE (t1) == BOOLEAN_TYPE
	&& TREE_CODE (t2) == BOOLEAN_TYPE)
	return boolean_type_node;

	/* If either type is BOOLEAN_TYPE, then return the other. */
	if (TREE_CODE (t1) == BOOLEAN_TYPE)
	return t2;
	if (TREE_CODE (t2) == BOOLEAN_TYPE)
	return t1;

	return c_common_type (t1, t2);
	}

	/* Return 1 if TYPE1 and TYPE2 are compatible types for assignment
	or various other operations. Return 2 if they are compatible
	but a warning may be needed if you use them together. */

	int
	comptypes (tree type1, tree type2)
	{
	const struct tagged_tu_seen_cache * tagged_tu_seen_base1 = tagged_tu_seen_base;
	int val;

	val = comptypes_internal (type1, type2);
	free_all_tagged_tu_seen_up_to (tagged_tu_seen_base1);

	return val;
	}

	/* Return 1 if TYPE1 and TYPE2 are compatible types for assignment
	or various other operations. Return 2 if they are compatible
	but a warning may be needed if you use them together. This
	differs from comptypes, in that we don't free the seen types. */

	static int
	comptypes_internal (tree type1, tree type2)
	{
	tree t1 = type1;
	tree t2 = type2;
	int attrval, val;

	/* Suppress errors caused by previously reported errors. */

	if (t1 == t2 \|\| !t1 \|\| !t2
	\|\| TREE_CODE (t1) == ERROR_MARK \|\| TREE_CODE (t2) == ERROR_MARK)
	return 1;

	/* If either type is the internal version of sizetype, return the
	language version. */
	if (TREE_CODE (t1) == INTEGER_TYPE && TYPE_IS_SIZETYPE (t1)
	&& TYPE_ORIG_SIZE_TYPE (t1))
	t1 = TYPE_ORIG_SIZE_TYPE (t1);

	if (TREE_CODE (t2) == INTEGER_TYPE && TYPE_IS_SIZETYPE (t2)
	&& TYPE_ORIG_SIZE_TYPE (t2))
	t2 = TYPE_ORIG_SIZE_TYPE (t2);


	/* Enumerated types are compatible with integer types, but this is
	not transitive: two enumerated types in the same translation unit
	are compatible with each other only if they are the same type. */

	if (TREE_CODE (t1) == ENUMERAL_TYPE && TREE_CODE (t2) != ENUMERAL_TYPE)
	t1 = c_common_type_for_size (TYPE_PRECISION (t1), TYPE_UNSIGNED (t1));
	else if (TREE_CODE (t2) == ENUMERAL_TYPE && TREE_CODE (t1) != ENUMERAL_TYPE)
	t2 = c_common_type_for_size (TYPE_PRECISION (t2), TYPE_UNSIGNED (t2));

	if (t1 == t2)
	return 1;

	/* Different classes of types can't be compatible. */

	if (TREE_CODE (t1) != TREE_CODE (t2))
	return 0;

	/* Qualifiers must match. C99 6.7.3p9 */

	if (TYPE_QUALS (t1) != TYPE_QUALS (t2))
	return 0;

	/* Allow for two different type nodes which have essentially the same
	definition. Note that we already checked for equality of the type
	qualifiers (just above). */

	if (TREE_CODE (t1) != ARRAY_TYPE
	&& TYPE_MAIN_VARIANT (t1) == TYPE_MAIN_VARIANT (t2))
	return 1;

	/* 1 if no need for warning yet, 2 if warning cause has been seen. */
	if (!(attrval = targetm.comp_type_attributes (t1, t2)))
	return 0;

	/* 1 if no need for warning yet, 2 if warning cause has been seen. */
	val = 0;

	switch (TREE_CODE (t1))
	{
	case POINTER_TYPE:
	/* Do not remove mode or aliasing information. */
	if (TYPE_MODE (t1) != TYPE_MODE (t2)
	\|\| TYPE_REF_CAN_ALIAS_ALL (t1) != TYPE_REF_CAN_ALIAS_ALL (t2))
	break;
	val = (TREE_TYPE (t1) == TREE_TYPE (t2)
	? 1 : comptypes_internal (TREE_TYPE (t1), TREE_TYPE (t2)));
	break;

	case FUNCTION_TYPE:
	val = function_types_compatible_p (t1, t2);
	break;

	case ARRAY_TYPE:
	{
	tree d1 = TYPE_DOMAIN (t1);
	tree d2 = TYPE_DOMAIN (t2);
	bool d1_variable, d2_variable;
	bool d1_zero, d2_zero;
	val = 1;

	/* Target types must match incl. qualifiers. */
	if (TREE_TYPE (t1) != TREE_TYPE (t2)
	&& 0 == (val = comptypes_internal (TREE_TYPE (t1), TREE_TYPE (t2))))
	return 0;

	/* Sizes must match unless one is missing or variable. */
	if (d1 == 0 \|\| d2 == 0 \|\| d1 == d2)
	break;

	d1_zero = !TYPE_MAX_VALUE (d1);
	d2_zero = !TYPE_MAX_VALUE (d2);

	d1_variable = (!d1_zero
	&& (TREE_CODE (TYPE_MIN_VALUE (d1)) != INTEGER_CST
	\|\| TREE_CODE (TYPE_MAX_VALUE (d1)) != INTEGER_CST));
	d2_variable = (!d2_zero
	&& (TREE_CODE (TYPE_MIN_VALUE (d2)) != INTEGER_CST
	\|\| TREE_CODE (TYPE_MAX_VALUE (d2)) != INTEGER_CST));
	d1_variable = d1_variable \|\| (d1_zero && c_vla_type_p (t1));
	d2_variable = d2_variable \|\| (d2_zero && c_vla_type_p (t2));

	if (d1_variable \|\| d2_variable)
	break;
	if (d1_zero && d2_zero)
	break;
	if (d1_zero \|\| d2_zero
	\|\| !tree_int_cst_equal (TYPE_MIN_VALUE (d1), TYPE_MIN_VALUE (d2))
	\|\| !tree_int_cst_equal (TYPE_MAX_VALUE (d1), TYPE_MAX_VALUE (d2)))
	val = 0;

	break;
	}

	case ENUMERAL_TYPE:
	case RECORD_TYPE:
	case UNION_TYPE:
	if (val != 1 && !same_translation_unit_p (t1, t2))
	{
	tree a1 = TYPE_ATTRIBUTES (t1);
	tree a2 = TYPE_ATTRIBUTES (t2);

	if (! attribute_list_contained (a1, a2)
	&& ! attribute_list_contained (a2, a1))
	break;

	if (attrval != 2)
	return tagged_types_tu_compatible_p (t1, t2);
	val = tagged_types_tu_compatible_p (t1, t2);
	}
	break;

	case VECTOR_TYPE:
	val = TYPE_VECTOR_SUBPARTS (t1) == TYPE_VECTOR_SUBPARTS (t2)
	&& comptypes_internal (TREE_TYPE (t1), TREE_TYPE (t2));
	break;

	default:
	break;
	}
	return attrval == 2 && val == 1 ? 2 : val;
	}

	/* Return 1 if TTL and TTR are pointers to types that are equivalent,
	ignoring their qualifiers. */

	static int
	comp_target_types (tree ttl, tree ttr)
	{
	int val;
	tree mvl, mvr;

	/* Do not lose qualifiers on element types of array types that are
	pointer targets by taking their TYPE_MAIN_VARIANT. */
	mvl = TREE_TYPE (ttl);
	mvr = TREE_TYPE (ttr);
	if (TREE_CODE (mvl) != ARRAY_TYPE)
	mvl = TYPE_MAIN_VARIANT (mvl);
	if (TREE_CODE (mvr) != ARRAY_TYPE)
	mvr = TYPE_MAIN_VARIANT (mvr);
	val = comptypes (mvl, mvr);

	if (val == 2 && pedantic)
	pedwarn ("types are not quite compatible");
	return val;
	}

	/* Subroutines of `comptypes'. */

	/* Determine whether two trees derive from the same translation unit.
	If the CONTEXT chain ends in a null, that tree's context is still
	being parsed, so if two trees have context chains ending in null,
	they're in the same translation unit. */
	int
	same_translation_unit_p (tree t1, tree t2)
	{
	while (t1 && TREE_CODE (t1) != TRANSLATION_UNIT_DECL)
	switch (TREE_CODE_CLASS (TREE_CODE (t1)))
	{
	case tcc_declaration:
	t1 = DECL_CONTEXT (t1); break;
	case tcc_type:
	t1 = TYPE_CONTEXT (t1); break;
	case tcc_exceptional:
	t1 = BLOCK_SUPERCONTEXT (t1); break; /* assume block */
	default: gcc_unreachable ();
	}

	while (t2 && TREE_CODE (t2) != TRANSLATION_UNIT_DECL)
	switch (TREE_CODE_CLASS (TREE_CODE (t2)))
	{
	case tcc_declaration:
	t2 = DECL_CONTEXT (t2); break;
	case tcc_type:
	t2 = TYPE_CONTEXT (t2); break;
	case tcc_exceptional:
	t2 = BLOCK_SUPERCONTEXT (t2); break; /* assume block */
	default: gcc_unreachable ();
	}

	return t1 == t2;
	}

	/* Allocate the seen two types, assuming that they are compatible. */

	static struct tagged_tu_seen_cache *
	alloc_tagged_tu_seen_cache (tree t1, tree t2)
	{
	struct tagged_tu_seen_cache *tu = XNEW (struct tagged_tu_seen_cache);
	tu->next = tagged_tu_seen_base;
	tu->t1 = t1;
	tu->t2 = t2;

	tagged_tu_seen_base = tu;

	/* The C standard says that two structures in different translation
	units are compatible with each other only if the types of their
	fields are compatible (among other things). We assume that they
	are compatible until proven otherwise when building the cache.
	An example where this can occur is:
	struct a
	{
	struct a *next;
	};
	If we are comparing this against a similar struct in another TU,
	and did not assume they were compatible, we end up with an infinite
	loop. */
	tu->val = 1;
	return tu;
	}

	/* Free the seen types until we get to TU_TIL. */

	static void
	free_all_tagged_tu_seen_up_to (const struct tagged_tu_seen_cache *tu_til)
	{
	const struct tagged_tu_seen_cache *tu = tagged_tu_seen_base;
	while (tu != tu_til)
	{
	struct tagged_tu_seen_cache tu1 = (struct tagged_tu_seen_cache)tu;
	tu = tu1->next;
	free (tu1);
	}
	tagged_tu_seen_base = tu_til;
	}

	/* Return 1 if two 'struct', 'union', or 'enum' types T1 and T2 are
	compatible. If the two types are not the same (which has been
	checked earlier), this can only happen when multiple translation
	units are being compiled. See C99 6.2.7 paragraph 1 for the exact
	rules. */

	static int
	tagged_types_tu_compatible_p (tree t1, tree t2)
	{
	tree s1, s2;
	bool needs_warning = false;

	/* We have to verify that the tags of the types are the same. This
	is harder than it looks because this may be a typedef, so we have
	to go look at the original type. It may even be a typedef of a
	typedef...
	In the case of compiler-created builtin structs the TYPE_DECL
	may be a dummy, with no DECL_ORIGINAL_TYPE. Don't fault. */
	while (TYPE_NAME (t1)
	&& TREE_CODE (TYPE_NAME (t1)) == TYPE_DECL
	&& DECL_ORIGINAL_TYPE (TYPE_NAME (t1)))
	t1 = DECL_ORIGINAL_TYPE (TYPE_NAME (t1));

	while (TYPE_NAME (t2)
	&& TREE_CODE (TYPE_NAME (t2)) == TYPE_DECL
	&& DECL_ORIGINAL_TYPE (TYPE_NAME (t2)))
	t2 = DECL_ORIGINAL_TYPE (TYPE_NAME (t2));

	/* C90 didn't have the requirement that the two tags be the same. */
	if (flag_isoc99 && TYPE_NAME (t1) != TYPE_NAME (t2))
	return 0;

	/* C90 didn't say what happened if one or both of the types were
	incomplete; we choose to follow C99 rules here, which is that they
	are compatible. */
	if (TYPE_SIZE (t1) == NULL
	\|\| TYPE_SIZE (t2) == NULL)
	return 1;

	{
	const struct tagged_tu_seen_cache * tts_i;
	for (tts_i = tagged_tu_seen_base; tts_i != NULL; tts_i = tts_i->next)
	if (tts_i->t1 == t1 && tts_i->t2 == t2)
	return tts_i->val;
	}

	switch (TREE_CODE (t1))
	{
	case ENUMERAL_TYPE:
	{
	struct tagged_tu_seen_cache *tu = alloc_tagged_tu_seen_cache (t1, t2);
	/* Speed up the case where the type values are in the same order. */
	tree tv1 = TYPE_VALUES (t1);
	tree tv2 = TYPE_VALUES (t2);

	if (tv1 == tv2)
	{
	return 1;
	}

	for (;tv1 && tv2; tv1 = TREE_CHAIN (tv1), tv2 = TREE_CHAIN (tv2))
	{
	if (TREE_PURPOSE (tv1) != TREE_PURPOSE (tv2))
	break;
	if (simple_cst_equal (TREE_VALUE (tv1), TREE_VALUE (tv2)) != 1)
	{
	tu->val = 0;
	return 0;
	}
	}

	if (tv1 == NULL_TREE && tv2 == NULL_TREE)
	{
	return 1;
	}
	if (tv1 == NULL_TREE \|\| tv2 == NULL_TREE)
	{
	tu->val = 0;
	return 0;
	}

	if (list_length (TYPE_VALUES (t1)) != list_length (TYPE_VALUES (t2)))
	{
	tu->val = 0;
	return 0;
	}

	for (s1 = TYPE_VALUES (t1); s1; s1 = TREE_CHAIN (s1))
	{
	s2 = purpose_member (TREE_PURPOSE (s1), TYPE_VALUES (t2));
	if (s2 == NULL
	\|\| simple_cst_equal (TREE_VALUE (s1), TREE_VALUE (s2)) != 1)
	{
	tu->val = 0;
	return 0;
	}
	}
	return 1;
	}

	case UNION_TYPE:
	{
	struct tagged_tu_seen_cache *tu = alloc_tagged_tu_seen_cache (t1, t2);
	if (list_length (TYPE_FIELDS (t1)) != list_length (TYPE_FIELDS (t2)))
	{
	tu->val = 0;
	return 0;
	}

	/* Speed up the common case where the fields are in the same order. */
	for (s1 = TYPE_FIELDS (t1), s2 = TYPE_FIELDS (t2); s1 && s2;
	s1 = TREE_CHAIN (s1), s2 = TREE_CHAIN (s2))
	{
	int result;


	if (DECL_NAME (s1) == NULL
	\|\| DECL_NAME (s1) != DECL_NAME (s2))
	break;
	result = comptypes_internal (TREE_TYPE (s1), TREE_TYPE (s2));
	if (result == 0)
	{
	tu->val = 0;
	return 0;
	}
	if (result == 2)
	needs_warning = true;

	if (TREE_CODE (s1) == FIELD_DECL
	&& simple_cst_equal (DECL_FIELD_BIT_OFFSET (s1),
	DECL_FIELD_BIT_OFFSET (s2)) != 1)
	{
	tu->val = 0;
	return 0;
	}
	}
	if (!s1 && !s2)
	{
	tu->val = needs_warning ? 2 : 1;
	return tu->val;
	}

	for (s1 = TYPE_FIELDS (t1); s1; s1 = TREE_CHAIN (s1))
	{
	bool ok = false;

	if (DECL_NAME (s1) != NULL)
	for (s2 = TYPE_FIELDS (t2); s2; s2 = TREE_CHAIN (s2))
	if (DECL_NAME (s1) == DECL_NAME (s2))
	{
	int result;
	result = comptypes_internal (TREE_TYPE (s1), TREE_TYPE (s2));
	if (result == 0)
	{
	tu->val = 0;
	return 0;
	}
	if (result == 2)
	needs_warning = true;

	if (TREE_CODE (s1) == FIELD_DECL
	&& simple_cst_equal (DECL_FIELD_BIT_OFFSET (s1),
	DECL_FIELD_BIT_OFFSET (s2)) != 1)
	break;

	ok = true;
	break;
	}
	if (!ok)
	{
	tu->val = 0;
	return 0;
	}
	}
	tu->val = needs_warning ? 2 : 10;
	return tu->val;
	}

	case RECORD_TYPE:
	{
	struct tagged_tu_seen_cache *tu = alloc_tagged_tu_seen_cache (t1, t2);

	for (s1 = TYPE_FIELDS (t1), s2 = TYPE_FIELDS (t2);
	s1 && s2;
	s1 = TREE_CHAIN (s1), s2 = TREE_CHAIN (s2))
	{
	int result;
	if (TREE_CODE (s1) != TREE_CODE (s2)
	\|\| DECL_NAME (s1) != DECL_NAME (s2))
	break;
	result = comptypes_internal (TREE_TYPE (s1), TREE_TYPE (s2));
	if (result == 0)
	break;
	if (result == 2)
	needs_warning = true;

	if (TREE_CODE (s1) == FIELD_DECL
	&& simple_cst_equal (DECL_FIELD_BIT_OFFSET (s1),
	DECL_FIELD_BIT_OFFSET (s2)) != 1)
	break;
	}
	if (s1 && s2)
	tu->val = 0;
	else
	tu->val = needs_warning ? 2 : 1;
	return tu->val;
	}

	default:
	gcc_unreachable ();
	}
	}

	/* Return 1 if two function types F1 and F2 are compatible.
	If either type specifies no argument types,
	the other must specify a fixed number of self-promoting arg types.
	Otherwise, if one type specifies only the number of arguments,
	the other must specify that number of self-promoting arg types.
	Otherwise, the argument types must match. */

	static int
	function_types_compatible_p (tree f1, tree f2)
	{
	tree args1, args2;
	/* 1 if no need for warning yet, 2 if warning cause has been seen. */
	int val = 1;
	int val1;
	tree ret1, ret2;

	ret1 = TREE_TYPE (f1);
	ret2 = TREE_TYPE (f2);

	/* 'volatile' qualifiers on a function's return type used to mean
	the function is noreturn. */
	if (TYPE_VOLATILE (ret1) != TYPE_VOLATILE (ret2))
	pedwarn ("function return types not compatible due to %<volatile%>");
	if (TYPE_VOLATILE (ret1))
	ret1 = build_qualified_type (TYPE_MAIN_VARIANT (ret1),
	TYPE_QUALS (ret1) & ~TYPE_QUAL_VOLATILE);
	if (TYPE_VOLATILE (ret2))
	ret2 = build_qualified_type (TYPE_MAIN_VARIANT (ret2),
	TYPE_QUALS (ret2) & ~TYPE_QUAL_VOLATILE);
	val = comptypes_internal (ret1, ret2);
	if (val == 0)
	return 0;

	args1 = TYPE_ARG_TYPES (f1);
	args2 = TYPE_ARG_TYPES (f2);

	/* An unspecified parmlist matches any specified parmlist
	whose argument types don't need default promotions. */

	if (args1 == 0)
	{
	if (!self_promoting_args_p (args2))
	return 0;
	/* If one of these types comes from a non-prototype fn definition,
	compare that with the other type's arglist.
	If they don't match, ask for a warning (but no error). */
	if (TYPE_ACTUAL_ARG_TYPES (f1)
	&& 1 != type_lists_compatible_p (args2, TYPE_ACTUAL_ARG_TYPES (f1)))
	val = 2;
	return val;
	}
	if (args2 == 0)
	{
	if (!self_promoting_args_p (args1))
	return 0;
	if (TYPE_ACTUAL_ARG_TYPES (f2)
	&& 1 != type_lists_compatible_p (args1, TYPE_ACTUAL_ARG_TYPES (f2)))
	val = 2;
	return val;
	}

	/* Both types have argument lists: compare them and propagate results. */
	val1 = type_lists_compatible_p (args1, args2);
	return val1 != 1 ? val1 : val;
	}

	/* Check two lists of types for compatibility,
	returning 0 for incompatible, 1 for compatible,
	or 2 for compatible with warning. */

	static int
	type_lists_compatible_p (tree args1, tree args2)
	{
	/* 1 if no need for warning yet, 2 if warning cause has been seen. */
	int val = 1;
	int newval = 0;

	while (1)
	{
	tree a1, mv1, a2, mv2;
	if (args1 == 0 && args2 == 0)
	return val;
	/* If one list is shorter than the other,
	they fail to match. */
	if (args1 == 0 \|\| args2 == 0)
	return 0;
	mv1 = a1 = TREE_VALUE (args1);
	mv2 = a2 = TREE_VALUE (args2);
	if (mv1 && mv1 != error_mark_node && TREE_CODE (mv1) != ARRAY_TYPE)
	mv1 = TYPE_MAIN_VARIANT (mv1);
	if (mv2 && mv2 != error_mark_node && TREE_CODE (mv2) != ARRAY_TYPE)
	mv2 = TYPE_MAIN_VARIANT (mv2);
	/* A null pointer instead of a type
	means there is supposed to be an argument
	but nothing is specified about what type it has.
	So match anything that self-promotes. */
	if (a1 == 0)
	{
	if (c_type_promotes_to (a2) != a2)
	return 0;
	}
	else if (a2 == 0)
	{
	if (c_type_promotes_to (a1) != a1)
	return 0;
	}
	/* If one of the lists has an error marker, ignore this arg. */
	else if (TREE_CODE (a1) == ERROR_MARK
	\|\| TREE_CODE (a2) == ERROR_MARK)
	;
	else if (!(newval = comptypes_internal (mv1, mv2)))
	{
	/* Allow wait (union {union wait u; int i} *)
	and wait (union wait ) to be compatible. /
	if (TREE_CODE (a1) == UNION_TYPE
	&& (TYPE_NAME (a1) == 0
	\|\| TYPE_TRANSPARENT_UNION (a1))
	&& TREE_CODE (TYPE_SIZE (a1)) == INTEGER_CST
	&& tree_int_cst_equal (TYPE_SIZE (a1),
	TYPE_SIZE (a2)))
	{
	tree memb;
	for (memb = TYPE_FIELDS (a1);
	memb; memb = TREE_CHAIN (memb))
	{
	tree mv3 = TREE_TYPE (memb);
	if (mv3 && mv3 != error_mark_node
	&& TREE_CODE (mv3) != ARRAY_TYPE)
	mv3 = TYPE_MAIN_VARIANT (mv3);
	if (comptypes_internal (mv3, mv2))
	break;
	}
	if (memb == 0)
	return 0;
	}
	else if (TREE_CODE (a2) == UNION_TYPE
	&& (TYPE_NAME (a2) == 0
	\|\| TYPE_TRANSPARENT_UNION (a2))
	&& TREE_CODE (TYPE_SIZE (a2)) == INTEGER_CST
	&& tree_int_cst_equal (TYPE_SIZE (a2),
	TYPE_SIZE (a1)))
	{
	tree memb;
	for (memb = TYPE_FIELDS (a2);
	memb; memb = TREE_CHAIN (memb))
	{
	tree mv3 = TREE_TYPE (memb);
	if (mv3 && mv3 != error_mark_node
	&& TREE_CODE (mv3) != ARRAY_TYPE)
	mv3 = TYPE_MAIN_VARIANT (mv3);
	if (comptypes_internal (mv3, mv1))
	break;
	}
	if (memb == 0)
	return 0;
	}
	else
	return 0;
	}

	/* comptypes said ok, but record if it said to warn. */
	if (newval > val)
	val = newval;

	args1 = TREE_CHAIN (args1);
	args2 = TREE_CHAIN (args2);
	}
	}

	/* Compute the size to increment a pointer by. */

	static tree
	c_size_in_bytes (tree type)
	{
	enum tree_code code = TREE_CODE (type);

	if (code == FUNCTION_TYPE \|\| code == VOID_TYPE \|\| code == ERROR_MARK)
	return size_one_node;

	if (!COMPLETE_OR_VOID_TYPE_P (type))
	{
	error ("arithmetic on pointer to an incomplete type");
	return size_one_node;
	}

	/* Convert in case a char is more than one unit. */
	return size_binop (CEIL_DIV_EXPR, TYPE_SIZE_UNIT (type),
	size_int (TYPE_PRECISION (char_type_node)
	/ BITS_PER_UNIT));
	}

	/* Return either DECL or its known constant value (if it has one). */

	tree
	decl_constant_value (tree decl)
	{
	if (/* Don't change a variable array bound or initial value to a constant
	in a place where a variable is invalid. Note that DECL_INITIAL
	isn't valid for a PARM_DECL. */
	current_function_decl != 0
	&& TREE_CODE (decl) != PARM_DECL
	&& !TREE_THIS_VOLATILE (decl)
	&& TREE_READONLY (decl)
	&& DECL_INITIAL (decl) != 0
	&& TREE_CODE (DECL_INITIAL (decl)) != ERROR_MARK
	/* This is invalid if initial value is not constant.
	If it has either a function call, a memory reference,
	or a variable, then re-evaluating it could give different results. */
	&& TREE_CONSTANT (DECL_INITIAL (decl))
	/* Check for cases where this is sub-optimal, even though valid. */
	&& TREE_CODE (DECL_INITIAL (decl)) != CONSTRUCTOR)
	return DECL_INITIAL (decl);
	return decl;
	}

	/* Return either DECL or its known constant value (if it has one), but
	return DECL if pedantic or DECL has mode BLKmode. This is for
	bug-compatibility with the old behavior of decl_constant_value
	(before GCC 3.0); every use of this function is a bug and it should
	be removed before GCC 3.1. It is not appropriate to use pedantic
	in a way that affects optimization, and BLKmode is probably not the
	right test for avoiding misoptimizations either. */

	static tree
	decl_constant_value_for_broken_optimization (tree decl)
	{
	tree ret;

	if (pedantic \|\| DECL_MODE (decl) == BLKmode)
	return decl;

	ret = decl_constant_value (decl);
	/* Avoid unwanted tree sharing between the initializer and current
	function's body where the tree can be modified e.g. by the
	gimplifier. */
	if (ret != decl && TREE_STATIC (decl))
	ret = unshare_expr (ret);
	return ret;
	}

	/* Convert the array expression EXP to a pointer. */
	static tree
	array_to_pointer_conversion (tree exp)
	{
	tree orig_exp = exp;
	tree type = TREE_TYPE (exp);
	tree adr;
	tree restype = TREE_TYPE (type);
	tree ptrtype;

	gcc_assert (TREE_CODE (type) == ARRAY_TYPE);

	STRIP_TYPE_NOPS (exp);

	if (TREE_NO_WARNING (orig_exp))
	TREE_NO_WARNING (exp) = 1;

	ptrtype = build_pointer_type (restype);

	if (TREE_CODE (exp) == INDIRECT_REF)
	return convert (ptrtype, TREE_OPERAND (exp, 0));

	if (TREE_CODE (exp) == VAR_DECL)
	{
	/* We are making an ADDR_EXPR of ptrtype. This is a valid
	ADDR_EXPR because it's the best way of representing what
	happens in C when we take the address of an array and place
	it in a pointer to the element type. */
	adr = build1 (ADDR_EXPR, ptrtype, exp);
	if (!c_mark_addressable (exp))
	return error_mark_node;
	TREE_SIDE_EFFECTS (adr) = 0; /* Default would be, same as EXP. */
	return adr;
	}

	/* This way is better for a COMPONENT_REF since it can
	simplify the offset for a component. */
	adr = build_unary_op (ADDR_EXPR, exp, 1);
	return convert (ptrtype, adr);
	}

	/* Convert the function expression EXP to a pointer. */
	static tree
	function_to_pointer_conversion (tree exp)
	{
	tree orig_exp = exp;

	gcc_assert (TREE_CODE (TREE_TYPE (exp)) == FUNCTION_TYPE);

	STRIP_TYPE_NOPS (exp);

	if (TREE_NO_WARNING (orig_exp))
	TREE_NO_WARNING (exp) = 1;

	return build_unary_op (ADDR_EXPR, exp, 0);
	}

	/* Perform the default conversion of arrays and functions to pointers.
	Return the result of converting EXP. For any other expression, just
	return EXP after removing NOPs. */

	struct c_expr
	default_function_array_conversion (struct c_expr exp)
	{
	tree orig_exp = exp.value;
	tree type = TREE_TYPE (exp.value);
	enum tree_code code = TREE_CODE (type);

	switch (code)
	{
	case ARRAY_TYPE:
	{
	bool not_lvalue = false;
	bool lvalue_array_p;

	while ((TREE_CODE (exp.value) == NON_LVALUE_EXPR
	\|\| TREE_CODE (exp.value) == NOP_EXPR
	\|\| TREE_CODE (exp.value) == CONVERT_EXPR)
	&& TREE_TYPE (TREE_OPERAND (exp.value, 0)) == type)
	{
	if (TREE_CODE (exp.value) == NON_LVALUE_EXPR)
	not_lvalue = true;
	exp.value = TREE_OPERAND (exp.value, 0);
	}

	if (TREE_NO_WARNING (orig_exp))
	TREE_NO_WARNING (exp.value) = 1;

	lvalue_array_p = !not_lvalue && lvalue_p (exp.value);
	if (!flag_isoc99 && !lvalue_array_p)
	{
	/* Before C99, non-lvalue arrays do not decay to pointers.
	Normally, using such an array would be invalid; but it can
	be used correctly inside sizeof or as a statement expression.
	Thus, do not give an error here; an error will result later. */
	return exp;
	}

	exp.value = array_to_pointer_conversion (exp.value);
	}
	break;
	case FUNCTION_TYPE:
	exp.value = function_to_pointer_conversion (exp.value);
	break;
	default:
	STRIP_TYPE_NOPS (exp.value);
	if (TREE_NO_WARNING (orig_exp))
	TREE_NO_WARNING (exp.value) = 1;
	break;
	}

	return exp;
	}


	/* EXP is an expression of integer type. Apply the integer promotions
	to it and return the promoted value. */

	tree
	perform_integral_promotions (tree exp)
	{
	tree type = TREE_TYPE (exp);
	enum tree_code code = TREE_CODE (type);

	gcc_assert (INTEGRAL_TYPE_P (type));

	/* Normally convert enums to int,
	but convert wide enums to something wider. */
	if (code == ENUMERAL_TYPE)
	{
	type = c_common_type_for_size (MAX (TYPE_PRECISION (type),
	TYPE_PRECISION (integer_type_node)),
	((TYPE_PRECISION (type)
	>= TYPE_PRECISION (integer_type_node))
	&& TYPE_UNSIGNED (type)));

	return convert (type, exp);
	}

	/* ??? This should no longer be needed now bit-fields have their
	proper types. */
	if (TREE_CODE (exp) == COMPONENT_REF
	&& DECL_C_BIT_FIELD (TREE_OPERAND (exp, 1))
	/* If it's thinner than an int, promote it like a
	c_promoting_integer_type_p, otherwise leave it alone. */
	&& 0 > compare_tree_int (DECL_SIZE (TREE_OPERAND (exp, 1)),
	TYPE_PRECISION (integer_type_node)))
	return convert (integer_type_node, exp);

	if (c_promoting_integer_type_p (type))
	{
	/* Preserve unsignedness if not really getting any wider. */
	if (TYPE_UNSIGNED (type)
	&& TYPE_PRECISION (type) == TYPE_PRECISION (integer_type_node))
	return convert (unsigned_type_node, exp);

	return convert (integer_type_node, exp);
	}

	return exp;
	}


	/* Perform default promotions for C data used in expressions.
	Enumeral types or short or char are converted to int.
	In addition, manifest constants symbols are replaced by their values. */

	tree
	default_conversion (tree exp)
	{
	tree orig_exp;
	tree type = TREE_TYPE (exp);
	enum tree_code code = TREE_CODE (type);

	/* Functions and arrays have been converted during parsing. */
	gcc_assert (code != FUNCTION_TYPE);
	if (code == ARRAY_TYPE)
	return exp;

	/* Constants can be used directly unless they're not loadable. */
	if (TREE_CODE (exp) == CONST_DECL)
	exp = DECL_INITIAL (exp);

	/* Replace a nonvolatile const static variable with its value unless
	it is an array, in which case we must be sure that taking the
	address of the array produces consistent results. */
	else if (optimize && TREE_CODE (exp) == VAR_DECL && code != ARRAY_TYPE)
	{
	exp = decl_constant_value_for_broken_optimization (exp);
	type = TREE_TYPE (exp);
	}

	/* Strip no-op conversions. */
	orig_exp = exp;
	STRIP_TYPE_NOPS (exp);

	if (TREE_NO_WARNING (orig_exp))
	TREE_NO_WARNING (exp) = 1;

	if (INTEGRAL_TYPE_P (type))
	return perform_integral_promotions (exp);

	if (code == VOID_TYPE)
	{
	error ("void value not ignored as it ought to be");
	return error_mark_node;
	}
	return exp;
	}

	/* Look up COMPONENT in a structure or union DECL.

	If the component name is not found, returns NULL_TREE. Otherwise,
	the return value is a TREE_LIST, with each TREE_VALUE a FIELD_DECL
	stepping down the chain to the component, which is in the last
	TREE_VALUE of the list. Normally the list is of length one, but if
	the component is embedded within (nested) anonymous structures or
	unions, the list steps down the chain to the component. */

	static tree
	lookup_field (tree decl, tree component)
	{
	tree type = TREE_TYPE (decl);
	tree field;

	/* If TYPE_LANG_SPECIFIC is set, then it is a sorted array of pointers
	to the field elements. Use a binary search on this array to quickly
	find the element. Otherwise, do a linear search. TYPE_LANG_SPECIFIC
	will always be set for structures which have many elements. */

	if (TYPE_LANG_SPECIFIC (type) && TYPE_LANG_SPECIFIC (type)->s)
	{
	int bot, top, half;
	tree *field_array = &TYPE_LANG_SPECIFIC (type)->s->elts[0];

	field = TYPE_FIELDS (type);
	bot = 0;
	top = TYPE_LANG_SPECIFIC (type)->s->len;
	while (top - bot > 1)
	{
	half = (top - bot + 1) >> 1;
	field = field_array[bot+half];

	if (DECL_NAME (field) == NULL_TREE)
	{
	/* Step through all anon unions in linear fashion. */
	while (DECL_NAME (field_array[bot]) == NULL_TREE)
	{
	field = field_array[bot++];
	if (TREE_CODE (TREE_TYPE (field)) == RECORD_TYPE
	\|\| TREE_CODE (TREE_TYPE (field)) == UNION_TYPE)
	{
	tree anon = lookup_field (field, component);

	if (anon)
	return tree_cons (NULL_TREE, field, anon);
	}
	}

	/* Entire record is only anon unions. */
	if (bot > top)
	return NULL_TREE;

	/* Restart the binary search, with new lower bound. */
	continue;
	}

	if (DECL_NAME (field) == component)
	break;
	if (DECL_NAME (field) < component)
	bot += half;
	else
	top = bot + half;
	}

	if (DECL_NAME (field_array[bot]) == component)
	field = field_array[bot];
	else if (DECL_NAME (field) != component)
	return NULL_TREE;
	}
	else
	{
	for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field))
	{
	if (DECL_NAME (field) == NULL_TREE
	&& (TREE_CODE (TREE_TYPE (field)) == RECORD_TYPE
	\|\| TREE_CODE (TREE_TYPE (field)) == UNION_TYPE))
	{
	tree anon = lookup_field (field, component);

	if (anon)
	return tree_cons (NULL_TREE, field, anon);
	}

	if (DECL_NAME (field) == component)
	break;
	}

	if (field == NULL_TREE)
	return NULL_TREE;
	}

	return tree_cons (NULL_TREE, field, NULL_TREE);
	}

	/* Make an expression to refer to the COMPONENT field of
	structure or union value DATUM. COMPONENT is an IDENTIFIER_NODE. */

	tree
	build_component_ref (tree datum, tree component)
	{
	tree type = TREE_TYPE (datum);
	enum tree_code code = TREE_CODE (type);
	tree field = NULL;
	tree ref;

	if (!objc_is_public (datum, component))
	return error_mark_node;

	/* See if there is a field or component with name COMPONENT. */

	if (code == RECORD_TYPE \|\| code == UNION_TYPE)
	{
	if (!COMPLETE_TYPE_P (type))
	{
	c_incomplete_type_error (NULL_TREE, type);
	return error_mark_node;
	}

	field = lookup_field (datum, component);

	if (!field)
	{
	error ("%qT has no member named %qE", type, component);
	return error_mark_node;
	}

	/* Chain the COMPONENT_REFs if necessary down to the FIELD.
	This might be better solved in future the way the C++ front
	end does it - by giving the anonymous entities each a
	separate name and type, and then have build_component_ref
	recursively call itself. We can't do that here. */
	do
	{
	tree subdatum = TREE_VALUE (field);
	int quals;
	tree subtype;

	if (TREE_TYPE (subdatum) == error_mark_node)
	return error_mark_node;

	quals = TYPE_QUALS (strip_array_types (TREE_TYPE (subdatum)));
	quals \|= TYPE_QUALS (TREE_TYPE (datum));
	subtype = c_build_qualified_type (TREE_TYPE (subdatum), quals);

	ref = build3 (COMPONENT_REF, subtype, datum, subdatum,
	NULL_TREE);
	if (TREE_READONLY (datum) \|\| TREE_READONLY (subdatum))
	TREE_READONLY (ref) = 1;
	if (TREE_THIS_VOLATILE (datum) \|\| TREE_THIS_VOLATILE (subdatum))
	TREE_THIS_VOLATILE (ref) = 1;

	if (TREE_DEPRECATED (subdatum))
	warn_deprecated_use (subdatum);

	+ /* APPLE LOCAL begin "unavailable" attribute (radar 2809697) */
	+ if (TREE_UNAVAILABLE (subdatum))
	+ error_unavailable_use (subdatum);
	+ /* APPLE LOCAL end "unavailable" attribute (radar 2809697) */
	+
	datum = ref;

	field = TREE_CHAIN (field);
	}
	while (field);

	return ref;
	}
	else if (code != ERROR_MARK)
	error ("request for member %qE in something not a structure or union",
	component);

	return error_mark_node;
	}

	/* Given an expression PTR for a pointer, return an expression
	for the value pointed to.
	ERRORSTRING is the name of the operator to appear in error messages. */

	tree
	build_indirect_ref (tree ptr, const char *errorstring)
	{
	tree pointer = default_conversion (ptr);
	tree type = TREE_TYPE (pointer);

	if (TREE_CODE (type) == POINTER_TYPE)
	{
	if (TREE_CODE (pointer) == CONVERT_EXPR
	\|\| TREE_CODE (pointer) == NOP_EXPR
	\|\| TREE_CODE (pointer) == VIEW_CONVERT_EXPR)
	{
	/* If a warning is issued, mark it to avoid duplicates from
	the backend. This only needs to be done at
	warn_strict_aliasing > 2. */
	if (warn_strict_aliasing > 2)
	if (strict_aliasing_warning (TREE_TYPE (TREE_OPERAND (pointer, 0)),
	type, TREE_OPERAND (pointer, 0)))
	TREE_NO_WARNING (pointer) = 1;
	}

	if (TREE_CODE (pointer) == ADDR_EXPR
	&& (TREE_TYPE (TREE_OPERAND (pointer, 0))
	== TREE_TYPE (type)))
	return TREE_OPERAND (pointer, 0);
	else
	{
	tree t = TREE_TYPE (type);
	tree ref;

	ref = build1 (INDIRECT_REF, t, pointer);

	if (!COMPLETE_OR_VOID_TYPE_P (t) && TREE_CODE (t) != ARRAY_TYPE)
	{
	error ("dereferencing pointer to incomplete type");
	return error_mark_node;
	}
	if (VOID_TYPE_P (t) && skip_evaluation == 0)
	warning (0, "dereferencing %<void *%> pointer");

	/* We must set TREE_READONLY when dereferencing a pointer to const,
	so that we get the proper error message if the result is used
	to assign to. Also, &* is supposed to be a no-op.
	And ANSI C seems to specify that the type of the result
	should be the const type. */
	/* A de-reference of a pointer to const is not a const. It is valid
	to change it via some other pointer. */
	TREE_READONLY (ref) = TYPE_READONLY (t);
	TREE_SIDE_EFFECTS (ref)
	= TYPE_VOLATILE (t) \|\| TREE_SIDE_EFFECTS (pointer);
	TREE_THIS_VOLATILE (ref) = TYPE_VOLATILE (t);
	return ref;
	}
	}
	else if (TREE_CODE (pointer) != ERROR_MARK)
	error ("invalid type argument of %qs (have %qT)", errorstring, type);
	return error_mark_node;
	}

	/* This handles expressions of the form "a[i]", which denotes
	an array reference.

	This is logically equivalent in C to *(a+i), but we may do it differently.
	If A is a variable or a member, we generate a primitive ARRAY_REF.
	This avoids forcing the array out of registers, and can work on
	arrays that are not lvalues (for example, members of structures returned
	by functions). */

	tree
	build_array_ref (tree array, tree index)
	{
	bool swapped = false;
	if (TREE_TYPE (array) == error_mark_node
	\|\| TREE_TYPE (index) == error_mark_node)
	return error_mark_node;

	if (TREE_CODE (TREE_TYPE (array)) != ARRAY_TYPE
	&& TREE_CODE (TREE_TYPE (array)) != POINTER_TYPE)
	{
	tree temp;
	if (TREE_CODE (TREE_TYPE (index)) != ARRAY_TYPE
	&& TREE_CODE (TREE_TYPE (index)) != POINTER_TYPE)
	{
	error ("subscripted value is neither array nor pointer");
	return error_mark_node;
	}
	temp = array;
	array = index;
	index = temp;
	swapped = true;
	}

	if (!INTEGRAL_TYPE_P (TREE_TYPE (index)))
	{
	error ("array subscript is not an integer");
	return error_mark_node;
	}

	if (TREE_CODE (TREE_TYPE (TREE_TYPE (array))) == FUNCTION_TYPE)
	{
	error ("subscripted value is pointer to function");
	return error_mark_node;
	}

	/* ??? Existing practice has been to warn only when the char
	index is syntactically the index, not for char[array]. */
	if (!swapped)
	warn_array_subscript_with_type_char (index);

	/* Apply default promotions after noticing character types. */
	index = default_conversion (index);

	gcc_assert (TREE_CODE (TREE_TYPE (index)) == INTEGER_TYPE);

	if (TREE_CODE (TREE_TYPE (array)) == ARRAY_TYPE)
	{
	tree rval, type;

	/* An array that is indexed by a non-constant
	cannot be stored in a register; we must be able to do
	address arithmetic on its address.
	Likewise an array of elements of variable size. */
	if (TREE_CODE (index) != INTEGER_CST
	\|\| (COMPLETE_TYPE_P (TREE_TYPE (TREE_TYPE (array)))
	&& TREE_CODE (TYPE_SIZE (TREE_TYPE (TREE_TYPE (array)))) != INTEGER_CST))
	{
	if (!c_mark_addressable (array))
	return error_mark_node;
	}
	/* An array that is indexed by a constant value which is not within
	the array bounds cannot be stored in a register either; because we
	would get a crash in store_bit_field/extract_bit_field when trying
	to access a non-existent part of the register. */
	if (TREE_CODE (index) == INTEGER_CST
	&& TYPE_DOMAIN (TREE_TYPE (array))
	&& !int_fits_type_p (index, TYPE_DOMAIN (TREE_TYPE (array))))
	{
	if (!c_mark_addressable (array))
	return error_mark_node;
	}

	if (pedantic)
	{
	tree foo = array;
	while (TREE_CODE (foo) == COMPONENT_REF)
	foo = TREE_OPERAND (foo, 0);
	if (TREE_CODE (foo) == VAR_DECL && C_DECL_REGISTER (foo))
	pedwarn ("ISO C forbids subscripting %<register%> array");
	else if (!flag_isoc99 && !lvalue_p (foo))
	pedwarn ("ISO C90 forbids subscripting non-lvalue array");
	}

	type = TREE_TYPE (TREE_TYPE (array));
	if (TREE_CODE (type) != ARRAY_TYPE)
	type = TYPE_MAIN_VARIANT (type);
	rval = build4 (ARRAY_REF, type, array, index, NULL_TREE, NULL_TREE);
	/* Array ref is const/volatile if the array elements are
	or if the array is. */
	TREE_READONLY (rval)
	\|= (TYPE_READONLY (TREE_TYPE (TREE_TYPE (array)))
	\| TREE_READONLY (array));
	TREE_SIDE_EFFECTS (rval)
	\|= (TYPE_VOLATILE (TREE_TYPE (TREE_TYPE (array)))
	\| TREE_SIDE_EFFECTS (array));
	TREE_THIS_VOLATILE (rval)
	\|= (TYPE_VOLATILE (TREE_TYPE (TREE_TYPE (array)))
	/* This was added by rms on 16 Nov 91.
	It fixes vol struct foo *a; a->elts[1]
	in an inline function.
	Hope it doesn't break something else. */
	\| TREE_THIS_VOLATILE (array));
	return require_complete_type (fold (rval));
	}
	else
	{
	tree ar = default_conversion (array);

	if (ar == error_mark_node)
	return ar;

	gcc_assert (TREE_CODE (TREE_TYPE (ar)) == POINTER_TYPE);
	gcc_assert (TREE_CODE (TREE_TYPE (TREE_TYPE (ar))) != FUNCTION_TYPE);

	return build_indirect_ref (build_binary_op (PLUS_EXPR, ar, index, 0),
	"array indexing");
	}
	}

	/* Build an external reference to identifier ID. FUN indicates
	whether this will be used for a function call. LOC is the source
	location of the identifier. */
	tree
	build_external_ref (tree id, int fun, location_t loc)
	{
	tree ref;
	tree decl = lookup_name (id);

	/* In Objective-C, an instance variable (ivar) may be preferred to
	whatever lookup_name() found. */
	decl = objc_lookup_ivar (decl, id);

	if (decl && decl != error_mark_node)
	ref = decl;
	else if (fun)
	/* Implicit function declaration. */
	ref = implicitly_declare (id);
	else if (decl == error_mark_node)
	/* Don't complain about something that's already been
	complained about. */
	return error_mark_node;
	else
	{
	undeclared_variable (id, loc);
	return error_mark_node;
	}

	if (TREE_TYPE (ref) == error_mark_node)
	return error_mark_node;

	if (TREE_DEPRECATED (ref))
	warn_deprecated_use (ref);

	+ /* APPLE LOCAL begin "unavailable" attribute (radar 2809697) */
	+ if (TREE_UNAVAILABLE (ref))
	+ error_unavailable_use (ref);
	+ /* APPLE LOCAL end "unavailable" attribute (radar 2809697) */
	+
	if (!skip_evaluation)
	assemble_external (ref);
	TREE_USED (ref) = 1;

	if (TREE_CODE (ref) == FUNCTION_DECL && !in_alignof)
	{
	if (!in_sizeof && !in_typeof)
	C_DECL_USED (ref) = 1;
	else if (DECL_INITIAL (ref) == 0
	&& DECL_EXTERNAL (ref)
	&& !TREE_PUBLIC (ref))
	record_maybe_used_decl (ref);
	}

	if (TREE_CODE (ref) == CONST_DECL)
	{
	used_types_insert (TREE_TYPE (ref));
	ref = DECL_INITIAL (ref);
	TREE_CONSTANT (ref) = 1;
	TREE_INVARIANT (ref) = 1;
	}
	else if (current_function_decl != 0
	&& !DECL_FILE_SCOPE_P (current_function_decl)
	&& (TREE_CODE (ref) == VAR_DECL
	\|\| TREE_CODE (ref) == PARM_DECL
	\|\| TREE_CODE (ref) == FUNCTION_DECL))
	{
	tree context = decl_function_context (ref);

	if (context != 0 && context != current_function_decl)
	DECL_NONLOCAL (ref) = 1;
	}
	/* C99 6.7.4p3: An inline definition of a function with external
	linkage ... shall not contain a reference to an identifier with
	internal linkage. */
	else if (current_function_decl != 0
	&& DECL_DECLARED_INLINE_P (current_function_decl)
	&& DECL_EXTERNAL (current_function_decl)
	&& VAR_OR_FUNCTION_DECL_P (ref)
	&& DECL_FILE_SCOPE_P (ref)
	&& pedantic
	&& (TREE_CODE (ref) != VAR_DECL \|\| TREE_STATIC (ref))
	&& ! TREE_PUBLIC (ref))
	pedwarn ("%H%qD is static but used in inline function %qD "
	"which is not static", &loc, ref, current_function_decl);

	return ref;
	}

	/* Record details of decls possibly used inside sizeof or typeof. */
	struct maybe_used_decl
	{
	/* The decl. */
	tree decl;
	/* The level seen at (in_sizeof + in_typeof). */
	int level;
	/* The next one at this level or above, or NULL. */
	struct maybe_used_decl *next;
	};

	static struct maybe_used_decl *maybe_used_decls;

	/* Record that DECL, an undefined static function reference seen
	inside sizeof or typeof, might be used if the operand of sizeof is
	a VLA type or the operand of typeof is a variably modified
	type. */

	static void
	record_maybe_used_decl (tree decl)
	{
	struct maybe_used_decl *t = XOBNEW (&parser_obstack, struct maybe_used_decl);
	t->decl = decl;
	t->level = in_sizeof + in_typeof;
	t->next = maybe_used_decls;
	maybe_used_decls = t;
	}

	/* Pop the stack of decls possibly used inside sizeof or typeof. If
	USED is false, just discard them. If it is true, mark them used
	(if no longer inside sizeof or typeof) or move them to the next
	level up (if still inside sizeof or typeof). */

	void
	pop_maybe_used (bool used)
	{
	struct maybe_used_decl *p = maybe_used_decls;
	int cur_level = in_sizeof + in_typeof;
	while (p && p->level > cur_level)
	{
	if (used)
	{
	if (cur_level == 0)
	C_DECL_USED (p->decl) = 1;
	else
	p->level = cur_level;
	}
	p = p->next;
	}
	if (!used \|\| cur_level == 0)
	maybe_used_decls = p;
	}

	/* Return the result of sizeof applied to EXPR. */

	struct c_expr
	c_expr_sizeof_expr (struct c_expr expr)
	{
	struct c_expr ret;
	if (expr.value == error_mark_node)
	{
	ret.value = error_mark_node;
	ret.original_code = ERROR_MARK;
	pop_maybe_used (false);
	}
	else
	{
	ret.value = c_sizeof (TREE_TYPE (expr.value));
	ret.original_code = ERROR_MARK;
	if (c_vla_type_p (TREE_TYPE (expr.value)))
	{
	/* sizeof is evaluated when given a vla (C99 6.5.3.4p2). */
	ret.value = build2 (COMPOUND_EXPR, TREE_TYPE (ret.value), expr.value, ret.value);
	}
	pop_maybe_used (C_TYPE_VARIABLE_SIZE (TREE_TYPE (expr.value)));
	}
	return ret;
	}

	/* Return the result of sizeof applied to T, a structure for the type
	name passed to sizeof (rather than the type itself). */

	struct c_expr
	c_expr_sizeof_type (struct c_type_name *t)
	{
	tree type;
	struct c_expr ret;
	type = groktypename (t);
	ret.value = c_sizeof (type);
	ret.original_code = ERROR_MARK;
	pop_maybe_used (type != error_mark_node
	? C_TYPE_VARIABLE_SIZE (type) : false);
	return ret;
	}

	/* Build a function call to function FUNCTION with parameters PARAMS.
	PARAMS is a list--a chain of TREE_LIST nodes--in which the
	TREE_VALUE of each node is a parameter-expression.
	FUNCTION's data type may be a function type or a pointer-to-function. */

	tree
	build_function_call (tree function, tree params)
	{
	tree fntype, fundecl = 0;
	tree coerced_params;
	tree name = NULL_TREE, result;
	tree tem;

	/* Strip NON_LVALUE_EXPRs, etc., since we aren't using as an lvalue. */
	STRIP_TYPE_NOPS (function);

	/* Convert anything with function type to a pointer-to-function. */
	if (TREE_CODE (function) == FUNCTION_DECL)
	{
	/* Implement type-directed function overloading for builtins.
	resolve_overloaded_builtin and targetm.resolve_overloaded_builtin
	handle all the type checking. The result is a complete expression
	that implements this function call. */
	tem = resolve_overloaded_builtin (function, params);
	if (tem)
	return tem;

	name = DECL_NAME (function);
	fundecl = function;
	}
	if (TREE_CODE (TREE_TYPE (function)) == FUNCTION_TYPE)
	function = function_to_pointer_conversion (function);

	/* For Objective-C, convert any calls via a cast to OBJC_TYPE_REF
	expressions, like those used for ObjC messenger dispatches. */
	function = objc_rewrite_function_call (function, params);

	fntype = TREE_TYPE (function);

	if (TREE_CODE (fntype) == ERROR_MARK)
	return error_mark_node;

	if (!(TREE_CODE (fntype) == POINTER_TYPE
	&& TREE_CODE (TREE_TYPE (fntype)) == FUNCTION_TYPE))
	{
	error ("called object %qE is not a function", function);
	return error_mark_node;
	}

	if (fundecl && TREE_THIS_VOLATILE (fundecl))
	current_function_returns_abnormally = 1;

	/* fntype now gets the type of function pointed to. */
	fntype = TREE_TYPE (fntype);

	/* Check that the function is called through a compatible prototype.
	If it is not, replace the call by a trap, wrapped up in a compound
	expression if necessary. This has the nice side-effect to prevent
	the tree-inliner from generating invalid assignment trees which may
	blow up in the RTL expander later. */
	if ((TREE_CODE (function) == NOP_EXPR
	\|\| TREE_CODE (function) == CONVERT_EXPR)
	&& TREE_CODE (tem = TREE_OPERAND (function, 0)) == ADDR_EXPR
	&& TREE_CODE (tem = TREE_OPERAND (tem, 0)) == FUNCTION_DECL
	&& !comptypes (fntype, TREE_TYPE (tem)))
	{
	tree return_type = TREE_TYPE (fntype);
	tree trap = build_function_call (built_in_decls[BUILT_IN_TRAP],
	NULL_TREE);

	/* This situation leads to run-time undefined behavior. We can't,
	therefore, simply error unless we can prove that all possible
	executions of the program must execute the code. */
	warning (0, "function called through a non-compatible type");

	/* We can, however, treat "undefined" any way we please.
	Call abort to encourage the user to fix the program. */
	inform ("if this code is reached, the program will abort");

	if (VOID_TYPE_P (return_type))
	return trap;
	else
	{
	tree rhs;

	if (AGGREGATE_TYPE_P (return_type))
	rhs = build_compound_literal (return_type,
	build_constructor (return_type, 0));
	else
	rhs = fold_convert (return_type, integer_zero_node);

	return build2 (COMPOUND_EXPR, return_type, trap, rhs);
	}
	}

	/* Convert the parameters to the types declared in the
	function prototype, or apply default promotions. */

	coerced_params
	= convert_arguments (TYPE_ARG_TYPES (fntype), params, function, fundecl);

	if (coerced_params == error_mark_node)
	return error_mark_node;

	/* Check that the arguments to the function are valid. */

	check_function_arguments (TYPE_ATTRIBUTES (fntype), coerced_params,
	TYPE_ARG_TYPES (fntype));

	if (require_constant_value)
	{
	result = fold_build3_initializer (CALL_EXPR, TREE_TYPE (fntype),
	function, coerced_params, NULL_TREE);

	if (TREE_CONSTANT (result)
	&& (name == NULL_TREE
	\|\| strncmp (IDENTIFIER_POINTER (name), "__builtin_", 10) != 0))
	pedwarn_init ("initializer element is not constant");
	}
	else
	result = fold_build3 (CALL_EXPR, TREE_TYPE (fntype),
	function, coerced_params, NULL_TREE);

	if (VOID_TYPE_P (TREE_TYPE (result)))
	return result;
	return require_complete_type (result);
	}

	/* Convert the argument expressions in the list VALUES
	to the types in the list TYPELIST. The result is a list of converted
	argument expressions, unless there are too few arguments in which
	case it is error_mark_node.

	If TYPELIST is exhausted, or when an element has NULL as its type,
	perform the default conversions.

	PARMLIST is the chain of parm decls for the function being called.
	It may be 0, if that info is not available.
	It is used only for generating error messages.

	FUNCTION is a tree for the called function. It is used only for
	error messages, where it is formatted with %qE.

	This is also where warnings about wrong number of args are generated.

	Both VALUES and the returned value are chains of TREE_LIST nodes
	with the elements of the list in the TREE_VALUE slots of those nodes. */

	static tree
	convert_arguments (tree typelist, tree values, tree function, tree fundecl)
	{
	tree typetail, valtail;
	tree result = NULL;
	int parmnum;
	tree selector;

	/* Change pointer to function to the function itself for
	diagnostics. */
	if (TREE_CODE (function) == ADDR_EXPR
	&& TREE_CODE (TREE_OPERAND (function, 0)) == FUNCTION_DECL)
	function = TREE_OPERAND (function, 0);

	/* Handle an ObjC selector specially for diagnostics. */
	selector = objc_message_selector ();

	/* Scan the given expressions and types, producing individual
	converted arguments and pushing them on RESULT in reverse order. */

	for (valtail = values, typetail = typelist, parmnum = 0;
	valtail;
	valtail = TREE_CHAIN (valtail), parmnum++)
	{
	tree type = typetail ? TREE_VALUE (typetail) : 0;
	tree val = TREE_VALUE (valtail);
	tree rname = function;
	int argnum = parmnum + 1;
	const char *invalid_func_diag;

	if (type == void_type_node)
	{
	error ("too many arguments to function %qE", function);
	break;
	}

	if (selector && argnum > 2)
	{
	rname = selector;
	argnum -= 2;
	}

	STRIP_TYPE_NOPS (val);

	val = require_complete_type (val);

	if (type != 0)
	{
	/* Formal parm type is specified by a function prototype. */
	tree parmval;

	if (type == error_mark_node \|\| !COMPLETE_TYPE_P (type))
	{
	error ("type of formal parameter %d is incomplete", parmnum + 1);
	parmval = val;
	}
	else
	{
	/* Optionally warn about conversions that
	differ from the default conversions. */
	if (warn_conversion \|\| warn_traditional)
	{
	unsigned int formal_prec = TYPE_PRECISION (type);

	if (INTEGRAL_TYPE_P (type)
	&& TREE_CODE (TREE_TYPE (val)) == REAL_TYPE)
	warning (0, "passing argument %d of %qE as integer "
	"rather than floating due to prototype",
	argnum, rname);
	if (INTEGRAL_TYPE_P (type)
	&& TREE_CODE (TREE_TYPE (val)) == COMPLEX_TYPE)
	warning (0, "passing argument %d of %qE as integer "
	"rather than complex due to prototype",
	argnum, rname);
	else if (TREE_CODE (type) == COMPLEX_TYPE
	&& TREE_CODE (TREE_TYPE (val)) == REAL_TYPE)
	warning (0, "passing argument %d of %qE as complex "
	"rather than floating due to prototype",
	argnum, rname);
	else if (TREE_CODE (type) == REAL_TYPE
	&& INTEGRAL_TYPE_P (TREE_TYPE (val)))
	warning (0, "passing argument %d of %qE as floating "
	"rather than integer due to prototype",
	argnum, rname);
	else if (TREE_CODE (type) == COMPLEX_TYPE
	&& INTEGRAL_TYPE_P (TREE_TYPE (val)))
	warning (0, "passing argument %d of %qE as complex "
	"rather than integer due to prototype",
	argnum, rname);
	else if (TREE_CODE (type) == REAL_TYPE
	&& TREE_CODE (TREE_TYPE (val)) == COMPLEX_TYPE)
	warning (0, "passing argument %d of %qE as floating "
	"rather than complex due to prototype",
	argnum, rname);
	/* ??? At some point, messages should be written about
	conversions between complex types, but that's too messy
	to do now. */
	else if (TREE_CODE (type) == REAL_TYPE
	&& TREE_CODE (TREE_TYPE (val)) == REAL_TYPE)
	{
	/* Warn if any argument is passed as `float',
	since without a prototype it would be `double'. */
	if (formal_prec == TYPE_PRECISION (float_type_node)
	&& type != dfloat32_type_node)
	warning (0, "passing argument %d of %qE as %<float%> "
	"rather than %<double%> due to prototype",
	argnum, rname);

	/* Warn if mismatch between argument and prototype
	for decimal float types. Warn of conversions with
	binary float types and of precision narrowing due to
	prototype. */
	else if (type != TREE_TYPE (val)
	&& (type == dfloat32_type_node
	\|\| type == dfloat64_type_node
	\|\| type == dfloat128_type_node
	\|\| TREE_TYPE (val) == dfloat32_type_node
	\|\| TREE_TYPE (val) == dfloat64_type_node
	\|\| TREE_TYPE (val) == dfloat128_type_node)
	&& (formal_prec
	<= TYPE_PRECISION (TREE_TYPE (val))
	\|\| (type == dfloat128_type_node
	&& (TREE_TYPE (val)
	!= dfloat64_type_node
	&& (TREE_TYPE (val)
	!= dfloat32_type_node)))
	\|\| (type == dfloat64_type_node
	&& (TREE_TYPE (val)
	!= dfloat32_type_node))))
	warning (0, "passing argument %d of %qE as %qT "
	"rather than %qT due to prototype",
	argnum, rname, type, TREE_TYPE (val));

	}
	/* Detect integer changing in width or signedness.
	These warnings are only activated with
	-Wconversion, not with -Wtraditional. */
	else if (warn_conversion && INTEGRAL_TYPE_P (type)
	&& INTEGRAL_TYPE_P (TREE_TYPE (val)))
	{
	tree would_have_been = default_conversion (val);
	tree type1 = TREE_TYPE (would_have_been);

	if (TREE_CODE (type) == ENUMERAL_TYPE
	&& (TYPE_MAIN_VARIANT (type)
	== TYPE_MAIN_VARIANT (TREE_TYPE (val))))
	/* No warning if function asks for enum
	and the actual arg is that enum type. */
	;
	else if (formal_prec != TYPE_PRECISION (type1))
	warning (OPT_Wconversion, "passing argument %d of %qE "
	"with different width due to prototype",
	argnum, rname);
	else if (TYPE_UNSIGNED (type) == TYPE_UNSIGNED (type1))
	;
	/* Don't complain if the formal parameter type
	is an enum, because we can't tell now whether
	the value was an enum--even the same enum. */
	else if (TREE_CODE (type) == ENUMERAL_TYPE)
	;
	else if (TREE_CODE (val) == INTEGER_CST
	&& int_fits_type_p (val, type))
	/* Change in signedness doesn't matter
	if a constant value is unaffected. */
	;
	/* If the value is extended from a narrower
	unsigned type, it doesn't matter whether we
	pass it as signed or unsigned; the value
	certainly is the same either way. */
	else if (TYPE_PRECISION (TREE_TYPE (val)) < TYPE_PRECISION (type)
	&& TYPE_UNSIGNED (TREE_TYPE (val)))
	;
	else if (TYPE_UNSIGNED (type))
	warning (OPT_Wconversion, "passing argument %d of %qE "
	"as unsigned due to prototype",
	argnum, rname);
	else
	warning (OPT_Wconversion, "passing argument %d of %qE "
	"as signed due to prototype", argnum, rname);
	}
	}

	parmval = convert_for_assignment (type, val, ic_argpass,
	fundecl, function,
	parmnum + 1);

	if (targetm.calls.promote_prototypes (fundecl ? TREE_TYPE (fundecl) : 0)
	&& INTEGRAL_TYPE_P (type)
	&& (TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node)))
	parmval = default_conversion (parmval);
	}
	result = tree_cons (NULL_TREE, parmval, result);
	}
	else if (TREE_CODE (TREE_TYPE (val)) == REAL_TYPE
	&& (TYPE_PRECISION (TREE_TYPE (val))
	< TYPE_PRECISION (double_type_node))
	&& !DECIMAL_FLOAT_MODE_P (TYPE_MODE (TREE_TYPE (val))))
	/* Convert `float' to `double'. */
	result = tree_cons (NULL_TREE, convert (double_type_node, val), result);
	else if ((invalid_func_diag =
	targetm.calls.invalid_arg_for_unprototyped_fn (typelist, fundecl, val)))
	{
	error (invalid_func_diag, "");
	return error_mark_node;
	}
	else
	/* Convert `short' and `char' to full-size `int'. */
	result = tree_cons (NULL_TREE, default_conversion (val), result);

	if (typetail)
	typetail = TREE_CHAIN (typetail);
	}

	if (typetail != 0 && TREE_VALUE (typetail) != void_type_node)
	{
	error ("too few arguments to function %qE", function);
	return error_mark_node;
	}

	return nreverse (result);
	}

	/* This is the entry point used by the parser to build unary operators
	in the input. CODE, a tree_code, specifies the unary operator, and
	ARG is the operand. For unary plus, the C parser currently uses
	CONVERT_EXPR for code. */

	struct c_expr
	parser_build_unary_op (enum tree_code code, struct c_expr arg)
	{
	struct c_expr result;

	result.original_code = ERROR_MARK;
	result.value = build_unary_op (code, arg.value, 0);

	if (TREE_OVERFLOW_P (result.value) && !TREE_OVERFLOW_P (arg.value))
	overflow_warning (result.value);

	return result;
	}

	/* This is the entry point used by the parser to build binary operators
	in the input. CODE, a tree_code, specifies the binary operator, and
	ARG1 and ARG2 are the operands. In addition to constructing the
	expression, we check for operands that were written with other binary
	operators in a way that is likely to confuse the user. */

	struct c_expr
	parser_build_binary_op (enum tree_code code, struct c_expr arg1,
	struct c_expr arg2)
	{
	struct c_expr result;

	enum tree_code code1 = arg1.original_code;
	enum tree_code code2 = arg2.original_code;

	result.value = build_binary_op (code, arg1.value, arg2.value, 1);
	result.original_code = code;

	if (TREE_CODE (result.value) == ERROR_MARK)
	return result;

	/* Check for cases such as x+y<<z which users are likely
	to misinterpret. */
	if (warn_parentheses)
	warn_about_parentheses (code, code1, code2);

	/* Warn about comparisons against string literals, with the exception
	of testing for equality or inequality of a string literal with NULL. */
	if (code == EQ_EXPR \|\| code == NE_EXPR)
	{
	if ((code1 == STRING_CST && !integer_zerop (arg2.value))
	\|\| (code2 == STRING_CST && !integer_zerop (arg1.value)))
	warning (OPT_Waddress,
	"comparison with string literal results in unspecified behaviour");
	}
	else if (TREE_CODE_CLASS (code) == tcc_comparison
	&& (code1 == STRING_CST \|\| code2 == STRING_CST))
	warning (OPT_Waddress,
	"comparison with string literal results in unspecified behaviour");

	if (TREE_OVERFLOW_P (result.value)
	&& !TREE_OVERFLOW_P (arg1.value)
	&& !TREE_OVERFLOW_P (arg2.value))
	overflow_warning (result.value);

	return result;
	}

	/* Return a tree for the difference of pointers OP0 and OP1.
	The resulting tree has type int. */

	static tree
	pointer_diff (tree op0, tree op1)
	{
	tree restype = ptrdiff_type_node;

	tree target_type = TREE_TYPE (TREE_TYPE (op0));
	tree con0, con1, lit0, lit1;
	tree orig_op1 = op1;

	if (pedantic \|\| warn_pointer_arith)
	{
	if (TREE_CODE (target_type) == VOID_TYPE)
	pedwarn ("pointer of type %<void *%> used in subtraction");
	if (TREE_CODE (target_type) == FUNCTION_TYPE)
	pedwarn ("pointer to a function used in subtraction");
	}

	/* If the conversion to ptrdiff_type does anything like widening or
	converting a partial to an integral mode, we get a convert_expression
	that is in the way to do any simplifications.
	(fold-const.c doesn't know that the extra bits won't be needed.
	split_tree uses STRIP_SIGN_NOPS, which leaves conversions to a
	different mode in place.)
	So first try to find a common term here 'by hand'; we want to cover
	at least the cases that occur in legal static initializers. */
	if ((TREE_CODE (op0) == NOP_EXPR \|\| TREE_CODE (op0) == CONVERT_EXPR)
	&& (TYPE_PRECISION (TREE_TYPE (op0))
	== TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (op0, 0)))))
	con0 = TREE_OPERAND (op0, 0);
	else
	con0 = op0;
	if ((TREE_CODE (op1) == NOP_EXPR \|\| TREE_CODE (op1) == CONVERT_EXPR)
	&& (TYPE_PRECISION (TREE_TYPE (op1))
	== TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (op1, 0)))))
	con1 = TREE_OPERAND (op1, 0);
	else
	con1 = op1;

	if (TREE_CODE (con0) == PLUS_EXPR)
	{
	lit0 = TREE_OPERAND (con0, 1);
	con0 = TREE_OPERAND (con0, 0);
	}
	else
	lit0 = integer_zero_node;

	if (TREE_CODE (con1) == PLUS_EXPR)
	{
	lit1 = TREE_OPERAND (con1, 1);
	con1 = TREE_OPERAND (con1, 0);
	}
	else
	lit1 = integer_zero_node;

	if (operand_equal_p (con0, con1, 0))
	{
	op0 = lit0;
	op1 = lit1;
	}


	/* First do the subtraction as integers;
	then drop through to build the divide operator.
	Do not do default conversions on the minus operator
	in case restype is a short type. */

	op0 = build_binary_op (MINUS_EXPR, convert (restype, op0),
	convert (restype, op1), 0);
	/* This generates an error if op1 is pointer to incomplete type. */
	if (!COMPLETE_OR_VOID_TYPE_P (TREE_TYPE (TREE_TYPE (orig_op1))))
	error ("arithmetic on pointer to an incomplete type");

	/* This generates an error if op0 is pointer to incomplete type. */
	op1 = c_size_in_bytes (target_type);

	/* Divide by the size, in easiest possible way. */
	return fold_build2 (EXACT_DIV_EXPR, restype, op0, convert (restype, op1));
	}

	/* Construct and perhaps optimize a tree representation
	for a unary operation. CODE, a tree_code, specifies the operation
	and XARG is the operand.
	For any CODE other than ADDR_EXPR, FLAG nonzero suppresses
	the default promotions (such as from short to int).
	For ADDR_EXPR, the default promotions are not applied; FLAG nonzero
	allows non-lvalues; this is only used to handle conversion of non-lvalue
	arrays to pointers in C99. */

	tree
	build_unary_op (enum tree_code code, tree xarg, int flag)
	{
	/* No default_conversion here. It causes trouble for ADDR_EXPR. */
	tree arg = xarg;
	tree argtype = 0;
	enum tree_code typecode = TREE_CODE (TREE_TYPE (arg));
	tree val;
	int noconvert = flag;
	const char *invalid_op_diag;

	if (typecode == ERROR_MARK)
	return error_mark_node;
	if (typecode == ENUMERAL_TYPE \|\| typecode == BOOLEAN_TYPE)
	typecode = INTEGER_TYPE;

	if ((invalid_op_diag
	= targetm.invalid_unary_op (code, TREE_TYPE (xarg))))
	{
	error (invalid_op_diag, "");
	return error_mark_node;
	}

	switch (code)
	{
	case CONVERT_EXPR:
	/* This is used for unary plus, because a CONVERT_EXPR
	is enough to prevent anybody from looking inside for
	associativity, but won't generate any code. */
	if (!(typecode == INTEGER_TYPE \|\| typecode == REAL_TYPE
	\|\| typecode == COMPLEX_TYPE
	\|\| typecode == VECTOR_TYPE))
	{
	error ("wrong type argument to unary plus");
	return error_mark_node;
	}
	else if (!noconvert)
	arg = default_conversion (arg);
	arg = non_lvalue (arg);
	break;

	case NEGATE_EXPR:
	if (!(typecode == INTEGER_TYPE \|\| typecode == REAL_TYPE
	\|\| typecode == COMPLEX_TYPE
	\|\| typecode == VECTOR_TYPE))
	{
	error ("wrong type argument to unary minus");
	return error_mark_node;
	}
	else if (!noconvert)
	arg = default_conversion (arg);
	break;

	case BIT_NOT_EXPR:
	if (typecode == INTEGER_TYPE \|\| typecode == VECTOR_TYPE)
	{
	if (!noconvert)
	arg = default_conversion (arg);
	}
	else if (typecode == COMPLEX_TYPE)
	{
	code = CONJ_EXPR;
	if (pedantic)
	pedwarn ("ISO C does not support %<~%> for complex conjugation");
	if (!noconvert)
	arg = default_conversion (arg);
	}
	else
	{
	error ("wrong type argument to bit-complement");
	return error_mark_node;
	}
	break;

	case ABS_EXPR:
	if (!(typecode == INTEGER_TYPE \|\| typecode == REAL_TYPE))
	{
	error ("wrong type argument to abs");
	return error_mark_node;
	}
	else if (!noconvert)
	arg = default_conversion (arg);
	break;

	case CONJ_EXPR:
	/* Conjugating a real value is a no-op, but allow it anyway. */
	if (!(typecode == INTEGER_TYPE \|\| typecode == REAL_TYPE
	\|\| typecode == COMPLEX_TYPE))
	{
	error ("wrong type argument to conjugation");
	return error_mark_node;
	}
	else if (!noconvert)
	arg = default_conversion (arg);
	break;

	case TRUTH_NOT_EXPR:
	if (typecode != INTEGER_TYPE
	&& typecode != REAL_TYPE && typecode != POINTER_TYPE
	&& typecode != COMPLEX_TYPE)
	{
	error ("wrong type argument to unary exclamation mark");
	return error_mark_node;
	}
	arg = c_objc_common_truthvalue_conversion (arg);
	return invert_truthvalue (arg);

	case REALPART_EXPR:
	if (TREE_CODE (arg) == COMPLEX_CST)
	return TREE_REALPART (arg);
	else if (TREE_CODE (TREE_TYPE (arg)) == COMPLEX_TYPE)
	return fold_build1 (REALPART_EXPR, TREE_TYPE (TREE_TYPE (arg)), arg);
	else
	return arg;

	case IMAGPART_EXPR:
	if (TREE_CODE (arg) == COMPLEX_CST)
	return TREE_IMAGPART (arg);
	else if (TREE_CODE (TREE_TYPE (arg)) == COMPLEX_TYPE)
	return fold_build1 (IMAGPART_EXPR, TREE_TYPE (TREE_TYPE (arg)), arg);
	else
	return convert (TREE_TYPE (arg), integer_zero_node);

	case PREINCREMENT_EXPR:
	case POSTINCREMENT_EXPR:
	case PREDECREMENT_EXPR:
	case POSTDECREMENT_EXPR:

	/* Increment or decrement the real part of the value,
	and don't change the imaginary part. */
	if (typecode == COMPLEX_TYPE)
	{
	tree real, imag;

	if (pedantic)
	pedwarn ("ISO C does not support %<++%> and %<--%>"
	" on complex types");

	arg = stabilize_reference (arg);
	real = build_unary_op (REALPART_EXPR, arg, 1);
	imag = build_unary_op (IMAGPART_EXPR, arg, 1);
	return build2 (COMPLEX_EXPR, TREE_TYPE (arg),
	build_unary_op (code, real, 1), imag);
	}

	/* Report invalid types. */

	if (typecode != POINTER_TYPE
	&& typecode != INTEGER_TYPE && typecode != REAL_TYPE)
	{
	if (code == PREINCREMENT_EXPR \|\| code == POSTINCREMENT_EXPR)
	error ("wrong type argument to increment");
	else
	error ("wrong type argument to decrement");

	return error_mark_node;
	}

	{
	tree inc;
	tree result_type = TREE_TYPE (arg);

	arg = get_unwidened (arg, 0);
	argtype = TREE_TYPE (arg);

	/* Compute the increment. */

	if (typecode == POINTER_TYPE)
	{
	/* If pointer target is an undefined struct,
	we just cannot know how to do the arithmetic. */
	if (!COMPLETE_OR_VOID_TYPE_P (TREE_TYPE (result_type)))
	{
	if (code == PREINCREMENT_EXPR \|\| code == POSTINCREMENT_EXPR)
	error ("increment of pointer to unknown structure");
	else
	error ("decrement of pointer to unknown structure");
	}
	else if ((pedantic \|\| warn_pointer_arith)
	&& (TREE_CODE (TREE_TYPE (result_type)) == FUNCTION_TYPE
	\|\| TREE_CODE (TREE_TYPE (result_type)) == VOID_TYPE))
	{
	if (code == PREINCREMENT_EXPR \|\| code == POSTINCREMENT_EXPR)
	pedwarn ("wrong type argument to increment");
	else
	pedwarn ("wrong type argument to decrement");
	}

	inc = c_size_in_bytes (TREE_TYPE (result_type));
	}
	else
	inc = integer_one_node;

	inc = convert (argtype, inc);

	/* Complain about anything else that is not a true lvalue. */
	if (!lvalue_or_else (arg, ((code == PREINCREMENT_EXPR
	\|\| code == POSTINCREMENT_EXPR)
	? lv_increment
	: lv_decrement)))
	return error_mark_node;

	/* Report a read-only lvalue. */
	if (TREE_READONLY (arg))
	{
	readonly_error (arg,
	((code == PREINCREMENT_EXPR
	\|\| code == POSTINCREMENT_EXPR)
	? lv_increment : lv_decrement));
	return error_mark_node;
	}

	if (TREE_CODE (TREE_TYPE (arg)) == BOOLEAN_TYPE)
	val = boolean_increment (code, arg);
	else
	val = build2 (code, TREE_TYPE (arg), arg, inc);
	TREE_SIDE_EFFECTS (val) = 1;
	val = convert (result_type, val);
	if (TREE_CODE (val) != code)
	TREE_NO_WARNING (val) = 1;
	return val;
	}

	case ADDR_EXPR:
	/* Note that this operation never does default_conversion. */

	/* Let &* cancel out to simplify resulting code. */
	if (TREE_CODE (arg) == INDIRECT_REF)
	{
	/* Don't let this be an lvalue. */
	if (lvalue_p (TREE_OPERAND (arg, 0)))
	return non_lvalue (TREE_OPERAND (arg, 0));
	return TREE_OPERAND (arg, 0);
	}

	/* For &x[y], return x+y */
	if (TREE_CODE (arg) == ARRAY_REF)
	{
	tree op0 = TREE_OPERAND (arg, 0);
	if (!c_mark_addressable (op0))
	return error_mark_node;
	return build_binary_op (PLUS_EXPR,
	(TREE_CODE (TREE_TYPE (op0)) == ARRAY_TYPE
	? array_to_pointer_conversion (op0)
	: op0),
	TREE_OPERAND (arg, 1), 1);
	}

	/* Anything not already handled and not a true memory reference
	or a non-lvalue array is an error. */
	else if (typecode != FUNCTION_TYPE && !flag
	&& !lvalue_or_else (arg, lv_addressof))
	return error_mark_node;

	/* Ordinary case; arg is a COMPONENT_REF or a decl. */
	argtype = TREE_TYPE (arg);

	/* If the lvalue is const or volatile, merge that into the type
	to which the address will point. Note that you can't get a
	restricted pointer by taking the address of something, so we
	only have to deal with `const' and `volatile' here. */
	if ((DECL_P (arg) \|\| REFERENCE_CLASS_P (arg))
	&& (TREE_READONLY (arg) \|\| TREE_THIS_VOLATILE (arg)))
	argtype = c_build_type_variant (argtype,
	TREE_READONLY (arg),
	TREE_THIS_VOLATILE (arg));

	if (!c_mark_addressable (arg))
	return error_mark_node;

	gcc_assert (TREE_CODE (arg) != COMPONENT_REF
	\|\| !DECL_C_BIT_FIELD (TREE_OPERAND (arg, 1)));

	argtype = build_pointer_type (argtype);

	/* ??? Cope with user tricks that amount to offsetof. Delete this
	when we have proper support for integer constant expressions. */
	val = get_base_address (arg);
	if (val && TREE_CODE (val) == INDIRECT_REF
	&& TREE_CONSTANT (TREE_OPERAND (val, 0)))
	{
	tree op0 = fold_convert (argtype, fold_offsetof (arg, val)), op1;

	op1 = fold_convert (argtype, TREE_OPERAND (val, 0));
	return fold_build2 (PLUS_EXPR, argtype, op0, op1);
	}

	val = build1 (ADDR_EXPR, argtype, arg);

	return val;

	default:
	gcc_unreachable ();
	}

	if (argtype == 0)
	argtype = TREE_TYPE (arg);
	return require_constant_value ? fold_build1_initializer (code, argtype, arg)
	: fold_build1 (code, argtype, arg);
	}

	/* Return nonzero if REF is an lvalue valid for this language.
	Lvalues can be assigned, unless their type has TYPE_READONLY.
	Lvalues can have their address taken, unless they have C_DECL_REGISTER. */

	static int
	lvalue_p (tree ref)
	{
	enum tree_code code = TREE_CODE (ref);

	switch (code)
	{
	case REALPART_EXPR:
	case IMAGPART_EXPR:
	case COMPONENT_REF:
	return lvalue_p (TREE_OPERAND (ref, 0));

	case COMPOUND_LITERAL_EXPR:
	case STRING_CST:
	return 1;

	case INDIRECT_REF:
	case ARRAY_REF:
	case VAR_DECL:
	case PARM_DECL:
	case RESULT_DECL:
	case ERROR_MARK:
	return (TREE_CODE (TREE_TYPE (ref)) != FUNCTION_TYPE
	&& TREE_CODE (TREE_TYPE (ref)) != METHOD_TYPE);

	case BIND_EXPR:
	return TREE_CODE (TREE_TYPE (ref)) == ARRAY_TYPE;

	default:
	return 0;
	}
	}

	/* Give an error for storing in something that is 'const'. */

	static void
	readonly_error (tree arg, enum lvalue_use use)
	{
	gcc_assert (use == lv_assign \|\| use == lv_increment \|\| use == lv_decrement
	\|\| use == lv_asm);
	/* Using this macro rather than (for example) arrays of messages
	ensures that all the format strings are checked at compile
	time. */
	#define READONLY_MSG(A, I, D, AS) (use == lv_assign ? (A) \
	: (use == lv_increment ? (I) \
	: (use == lv_decrement ? (D) : (AS))))
	if (TREE_CODE (arg) == COMPONENT_REF)
	{
	if (TYPE_READONLY (TREE_TYPE (TREE_OPERAND (arg, 0))))
	readonly_error (TREE_OPERAND (arg, 0), use);
	else
	error (READONLY_MSG (G_("assignment of read-only member %qD"),
	G_("increment of read-only member %qD"),
	G_("decrement of read-only member %qD"),
	G_("read-only member %qD used as %<asm%> output")),
	TREE_OPERAND (arg, 1));
	}
	else if (TREE_CODE (arg) == VAR_DECL)
	error (READONLY_MSG (G_("assignment of read-only variable %qD"),
	G_("increment of read-only variable %qD"),
	G_("decrement of read-only variable %qD"),
	G_("read-only variable %qD used as %<asm%> output")),
	arg);
	else
	error (READONLY_MSG (G_("assignment of read-only location"),
	G_("increment of read-only location"),
	G_("decrement of read-only location"),
	G_("read-only location used as %<asm%> output")));
	}


	/* Return nonzero if REF is an lvalue valid for this language;
	otherwise, print an error message and return zero. USE says
	how the lvalue is being used and so selects the error message. */

	static int
	lvalue_or_else (tree ref, enum lvalue_use use)
	{
	int win = lvalue_p (ref);

	if (!win)
	lvalue_error (use);

	return win;
	}

	/* Mark EXP saying that we need to be able to take the
	address of it; it should not be allocated in a register.
	Returns true if successful. */

	bool
	c_mark_addressable (tree exp)
	{
	tree x = exp;

	while (1)
	switch (TREE_CODE (x))
	{
	case COMPONENT_REF:
	if (DECL_C_BIT_FIELD (TREE_OPERAND (x, 1)))
	{
	error
	("cannot take address of bit-field %qD", TREE_OPERAND (x, 1));
	return false;
	}

	/* ... fall through ... */

	case ADDR_EXPR:
	case ARRAY_REF:
	case REALPART_EXPR:
	case IMAGPART_EXPR:
	x = TREE_OPERAND (x, 0);
	break;

	case COMPOUND_LITERAL_EXPR:
	case CONSTRUCTOR:
	TREE_ADDRESSABLE (x) = 1;
	return true;

	case VAR_DECL:
	case CONST_DECL:
	case PARM_DECL:
	case RESULT_DECL:
	if (C_DECL_REGISTER (x)
	&& DECL_NONLOCAL (x))
	{
	if (TREE_PUBLIC (x) \|\| TREE_STATIC (x) \|\| DECL_EXTERNAL (x))
	{
	error
	("global register variable %qD used in nested function", x);
	return false;
	}
	pedwarn ("register variable %qD used in nested function", x);
	}
	else if (C_DECL_REGISTER (x))
	{
	if (TREE_PUBLIC (x) \|\| TREE_STATIC (x) \|\| DECL_EXTERNAL (x))
	error ("address of global register variable %qD requested", x);
	else
	error ("address of register variable %qD requested", x);
	return false;
	}

	/* drops in */
	case FUNCTION_DECL:
	TREE_ADDRESSABLE (x) = 1;
	/* drops out */
	default:
	return true;
	}
	}

	/* Build and return a conditional expression IFEXP ? OP1 : OP2. */

	tree
	build_conditional_expr (tree ifexp, tree op1, tree op2)
	{
	tree type1;
	tree type2;
	enum tree_code code1;
	enum tree_code code2;
	tree result_type = NULL;
	tree orig_op1 = op1, orig_op2 = op2;

	/* Promote both alternatives. */

	if (TREE_CODE (TREE_TYPE (op1)) != VOID_TYPE)
	op1 = default_conversion (op1);
	if (TREE_CODE (TREE_TYPE (op2)) != VOID_TYPE)
	op2 = default_conversion (op2);

	if (TREE_CODE (ifexp) == ERROR_MARK
	\|\| TREE_CODE (TREE_TYPE (op1)) == ERROR_MARK
	\|\| TREE_CODE (TREE_TYPE (op2)) == ERROR_MARK)
	return error_mark_node;

	type1 = TREE_TYPE (op1);
	code1 = TREE_CODE (type1);
	type2 = TREE_TYPE (op2);
	code2 = TREE_CODE (type2);

	/* C90 does not permit non-lvalue arrays in conditional expressions.
	In C99 they will be pointers by now. */
	if (code1 == ARRAY_TYPE \|\| code2 == ARRAY_TYPE)
	{
	error ("non-lvalue array in conditional expression");
	return error_mark_node;
	}

	/* Quickly detect the usual case where op1 and op2 have the same type
	after promotion. */
	if (TYPE_MAIN_VARIANT (type1) == TYPE_MAIN_VARIANT (type2))
	{
	if (type1 == type2)
	result_type = type1;
	else
	result_type = TYPE_MAIN_VARIANT (type1);
	}
	else if ((code1 == INTEGER_TYPE \|\| code1 == REAL_TYPE
	\|\| code1 == COMPLEX_TYPE)
	&& (code2 == INTEGER_TYPE \|\| code2 == REAL_TYPE
	\|\| code2 == COMPLEX_TYPE))
	{
	result_type = c_common_type (type1, type2);

	/* If -Wsign-compare, warn here if type1 and type2 have
	different signedness. We'll promote the signed to unsigned
	and later code won't know it used to be different.
	Do this check on the original types, so that explicit casts
	will be considered, but default promotions won't. */
	if (warn_sign_compare && !skip_evaluation)
	{
	int unsigned_op1 = TYPE_UNSIGNED (TREE_TYPE (orig_op1));
	int unsigned_op2 = TYPE_UNSIGNED (TREE_TYPE (orig_op2));

	if (unsigned_op1 ^ unsigned_op2)
	{
	bool ovf;

	/* Do not warn if the result type is signed, since the
	signed type will only be chosen if it can represent
	all the values of the unsigned type. */
	if (!TYPE_UNSIGNED (result_type))
	/* OK */;
	/* Do not warn if the signed quantity is an unsuffixed
	integer literal (or some static constant expression
	involving such literals) and it is non-negative. */
	else if ((unsigned_op2
	&& tree_expr_nonnegative_warnv_p (op1, &ovf))
	\|\| (unsigned_op1
	&& tree_expr_nonnegative_warnv_p (op2, &ovf)))
	/* OK */;
	else
	warning (0, "signed and unsigned type in conditional expression");
	}
	}
	}
	else if (code1 == VOID_TYPE \|\| code2 == VOID_TYPE)
	{
	if (pedantic && (code1 != VOID_TYPE \|\| code2 != VOID_TYPE))
	pedwarn ("ISO C forbids conditional expr with only one void side");
	result_type = void_type_node;
	}
	else if (code1 == POINTER_TYPE && code2 == POINTER_TYPE)
	{
	if (comp_target_types (type1, type2))
	result_type = common_pointer_type (type1, type2);
	else if (null_pointer_constant_p (orig_op1))
	result_type = qualify_type (type2, type1);
	else if (null_pointer_constant_p (orig_op2))
	result_type = qualify_type (type1, type2);
	else if (VOID_TYPE_P (TREE_TYPE (type1)))
	{
	if (pedantic && TREE_CODE (TREE_TYPE (type2)) == FUNCTION_TYPE)
	pedwarn ("ISO C forbids conditional expr between "
	"%<void *%> and function pointer");
	result_type = build_pointer_type (qualify_type (TREE_TYPE (type1),
	TREE_TYPE (type2)));
	}
	else if (VOID_TYPE_P (TREE_TYPE (type2)))
	{
	if (pedantic && TREE_CODE (TREE_TYPE (type1)) == FUNCTION_TYPE)
	pedwarn ("ISO C forbids conditional expr between "
	"%<void *%> and function pointer");
	result_type = build_pointer_type (qualify_type (TREE_TYPE (type2),
	TREE_TYPE (type1)));
	}
	else
	{
	pedwarn ("pointer type mismatch in conditional expression");
	result_type = build_pointer_type (void_type_node);
	}
	}
	else if (code1 == POINTER_TYPE && code2 == INTEGER_TYPE)
	{
	if (!null_pointer_constant_p (orig_op2))
	pedwarn ("pointer/integer type mismatch in conditional expression");
	else
	{
	op2 = null_pointer_node;
	}
	result_type = type1;
	}
	else if (code2 == POINTER_TYPE && code1 == INTEGER_TYPE)
	{
	if (!null_pointer_constant_p (orig_op1))
	pedwarn ("pointer/integer type mismatch in conditional expression");
	else
	{
	op1 = null_pointer_node;
	}
	result_type = type2;
	}

	if (!result_type)
	{
	if (flag_cond_mismatch)
	result_type = void_type_node;
	else
	{
	error ("type mismatch in conditional expression");
	return error_mark_node;
	}
	}

	/* Merge const and volatile flags of the incoming types. */
	result_type
	= build_type_variant (result_type,
	TREE_READONLY (op1) \|\| TREE_READONLY (op2),
	TREE_THIS_VOLATILE (op1) \|\| TREE_THIS_VOLATILE (op2));

	if (result_type != TREE_TYPE (op1))
	op1 = convert_and_check (result_type, op1);
	if (result_type != TREE_TYPE (op2))
	op2 = convert_and_check (result_type, op2);

	return fold_build3 (COND_EXPR, result_type, ifexp, op1, op2);
	}

	/* Return a compound expression that performs two expressions and
	returns the value of the second of them. */

	tree
	build_compound_expr (tree expr1, tree expr2)
	{
	if (!TREE_SIDE_EFFECTS (expr1))
	{
	/* The left-hand operand of a comma expression is like an expression
	statement: with -Wextra or -Wunused, we should warn if it doesn't have
	any side-effects, unless it was explicitly cast to (void). */
	if (warn_unused_value)
	{
	if (VOID_TYPE_P (TREE_TYPE (expr1))
	&& (TREE_CODE (expr1) == NOP_EXPR
	\|\| TREE_CODE (expr1) == CONVERT_EXPR))
	; /* (void) a, b */
	else if (VOID_TYPE_P (TREE_TYPE (expr1))
	&& TREE_CODE (expr1) == COMPOUND_EXPR
	&& (TREE_CODE (TREE_OPERAND (expr1, 1)) == CONVERT_EXPR
	\|\| TREE_CODE (TREE_OPERAND (expr1, 1)) == NOP_EXPR))
	; /* (void) a, (void) b, c */
	else
	warning (0, "left-hand operand of comma expression has no effect");
	}
	}

	/* With -Wunused, we should also warn if the left-hand operand does have
	side-effects, but computes a value which is not used. For example, in
	`foo() + bar(), baz()' the result of the `+' operator is not used,
	so we should issue a warning. */
	else if (warn_unused_value)
	warn_if_unused_value (expr1, input_location);

	if (expr2 == error_mark_node)
	return error_mark_node;

	return build2 (COMPOUND_EXPR, TREE_TYPE (expr2), expr1, expr2);
	}

	/* Build an expression representing a cast to type TYPE of expression EXPR. */

	tree
	build_c_cast (tree type, tree expr)
	{
	tree value = expr;

	if (type == error_mark_node \|\| expr == error_mark_node)
	return error_mark_node;

	/* The ObjC front-end uses TYPE_MAIN_VARIANT to tie together types differing
	only in <protocol> qualifications. But when constructing cast expressions,
	the protocols do matter and must be kept around. */
	if (objc_is_object_ptr (type) && objc_is_object_ptr (TREE_TYPE (expr)))
	return build1 (NOP_EXPR, type, expr);

	type = TYPE_MAIN_VARIANT (type);

	if (TREE_CODE (type) == ARRAY_TYPE)
	{
	error ("cast specifies array type");
	return error_mark_node;
	}

	if (TREE_CODE (type) == FUNCTION_TYPE)
	{
	error ("cast specifies function type");
	return error_mark_node;
	}

	if (type == TYPE_MAIN_VARIANT (TREE_TYPE (value)))
	{
	if (pedantic)
	{
	if (TREE_CODE (type) == RECORD_TYPE
	\|\| TREE_CODE (type) == UNION_TYPE)
	pedwarn ("ISO C forbids casting nonscalar to the same type");
	}
	}
	else if (TREE_CODE (type) == UNION_TYPE)
	{
	tree field;

	for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field))
	if (comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (field)),
	TYPE_MAIN_VARIANT (TREE_TYPE (value))))
	break;

	if (field)
	{
	tree t;

	if (pedantic)
	pedwarn ("ISO C forbids casts to union type");
	t = digest_init (type,
	build_constructor_single (type, field, value),
	true, 0);
	TREE_CONSTANT (t) = TREE_CONSTANT (value);
	TREE_INVARIANT (t) = TREE_INVARIANT (value);
	return t;
	}
	error ("cast to union type from type not present in union");
	return error_mark_node;
	}
	else
	{
	tree otype, ovalue;

	if (type == void_type_node)
	return build1 (CONVERT_EXPR, type, value);

	otype = TREE_TYPE (value);

	/* Optionally warn about potentially worrisome casts. */

	if (warn_cast_qual
	&& TREE_CODE (type) == POINTER_TYPE
	&& TREE_CODE (otype) == POINTER_TYPE)
	{
	tree in_type = type;
	tree in_otype = otype;
	int added = 0;
	int discarded = 0;

	/* Check that the qualifiers on IN_TYPE are a superset of
	the qualifiers of IN_OTYPE. The outermost level of
	POINTER_TYPE nodes is uninteresting and we stop as soon
	as we hit a non-POINTER_TYPE node on either type. */
	do
	{
	in_otype = TREE_TYPE (in_otype);
	in_type = TREE_TYPE (in_type);

	/* GNU C allows cv-qualified function types. 'const'
	means the function is very pure, 'volatile' means it
	can't return. We need to warn when such qualifiers
	are added, not when they're taken away. */
	if (TREE_CODE (in_otype) == FUNCTION_TYPE
	&& TREE_CODE (in_type) == FUNCTION_TYPE)
	added \|= (TYPE_QUALS (in_type) & ~TYPE_QUALS (in_otype));
	else
	discarded \|= (TYPE_QUALS (in_otype) & ~TYPE_QUALS (in_type));
	}
	while (TREE_CODE (in_type) == POINTER_TYPE
	&& TREE_CODE (in_otype) == POINTER_TYPE);

	if (added)
	warning (0, "cast adds new qualifiers to function type");

	if (discarded)
	/* There are qualifiers present in IN_OTYPE that are not
	present in IN_TYPE. */
	warning (0, "cast discards qualifiers from pointer target type");
	}

	/* Warn about possible alignment problems. */
	if (STRICT_ALIGNMENT
	&& TREE_CODE (type) == POINTER_TYPE
	&& TREE_CODE (otype) == POINTER_TYPE
	&& TREE_CODE (TREE_TYPE (otype)) != VOID_TYPE
	&& TREE_CODE (TREE_TYPE (otype)) != FUNCTION_TYPE
	/* Don't warn about opaque types, where the actual alignment
	restriction is unknown. */
	&& !((TREE_CODE (TREE_TYPE (otype)) == UNION_TYPE
	\|\| TREE_CODE (TREE_TYPE (otype)) == RECORD_TYPE)
	&& TYPE_MODE (TREE_TYPE (otype)) == VOIDmode)
	&& TYPE_ALIGN (TREE_TYPE (type)) > TYPE_ALIGN (TREE_TYPE (otype)))
	warning (OPT_Wcast_align,
	"cast increases required alignment of target type");

	if (TREE_CODE (type) == INTEGER_TYPE
	&& TREE_CODE (otype) == POINTER_TYPE
	&& TYPE_PRECISION (type) != TYPE_PRECISION (otype))
	/* Unlike conversion of integers to pointers, where the
	warning is disabled for converting constants because
	of cases such as SIG_*, warn about converting constant
	pointers to integers. In some cases it may cause unwanted
	sign extension, and a warning is appropriate. */
	warning (OPT_Wpointer_to_int_cast,
	"cast from pointer to integer of different size");

	if (TREE_CODE (value) == CALL_EXPR
	&& TREE_CODE (type) != TREE_CODE (otype))
	warning (OPT_Wbad_function_cast, "cast from function call of type %qT "
	"to non-matching type %qT", otype, type);

	if (TREE_CODE (type) == POINTER_TYPE
	&& TREE_CODE (otype) == INTEGER_TYPE
	&& TYPE_PRECISION (type) != TYPE_PRECISION (otype)
	/* Don't warn about converting any constant. */
	&& !TREE_CONSTANT (value))
	warning (OPT_Wint_to_pointer_cast, "cast to pointer from integer "
	"of different size");

	if (warn_strict_aliasing <= 2)
	strict_aliasing_warning (otype, type, expr);

	/* If pedantic, warn for conversions between function and object
	pointer types, except for converting a null pointer constant
	to function pointer type. */
	if (pedantic
	&& TREE_CODE (type) == POINTER_TYPE
	&& TREE_CODE (otype) == POINTER_TYPE
	&& TREE_CODE (TREE_TYPE (otype)) == FUNCTION_TYPE
	&& TREE_CODE (TREE_TYPE (type)) != FUNCTION_TYPE)
	pedwarn ("ISO C forbids conversion of function pointer to object pointer type");

	if (pedantic
	&& TREE_CODE (type) == POINTER_TYPE
	&& TREE_CODE (otype) == POINTER_TYPE
	&& TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE
	&& TREE_CODE (TREE_TYPE (otype)) != FUNCTION_TYPE
	&& !null_pointer_constant_p (value))
	pedwarn ("ISO C forbids conversion of object pointer to function pointer type");

	ovalue = value;
	value = convert (type, value);

	/* Ignore any integer overflow caused by the cast. */
	if (TREE_CODE (value) == INTEGER_CST)
	{
	if (CONSTANT_CLASS_P (ovalue)
	&& (TREE_OVERFLOW (ovalue) \|\| TREE_CONSTANT_OVERFLOW (ovalue)))
	{
	/* Avoid clobbering a shared constant. */
	value = copy_node (value);
	TREE_OVERFLOW (value) = TREE_OVERFLOW (ovalue);
	TREE_CONSTANT_OVERFLOW (value) = TREE_CONSTANT_OVERFLOW (ovalue);
	}
	else if (TREE_OVERFLOW (value) \|\| TREE_CONSTANT_OVERFLOW (value))
	/* Reset VALUE's overflow flags, ensuring constant sharing. */
	value = build_int_cst_wide (TREE_TYPE (value),
	TREE_INT_CST_LOW (value),
	TREE_INT_CST_HIGH (value));
	}
	}

	/* Don't let a cast be an lvalue. */
	if (value == expr)
	value = non_lvalue (value);

	return value;
	}

	/* Interpret a cast of expression EXPR to type TYPE. */
	tree
	c_cast_expr (struct c_type_name *type_name, tree expr)
	{
	tree type;
	int saved_wsp = warn_strict_prototypes;

	/* This avoids warnings about unprototyped casts on
	integers. E.g. "#define SIG_DFL (void()())0". /
	if (TREE_CODE (expr) == INTEGER_CST)
	warn_strict_prototypes = 0;
	type = groktypename (type_name);
	warn_strict_prototypes = saved_wsp;

	return build_c_cast (type, expr);
	}

	/* Build an assignment expression of lvalue LHS from value RHS.
	MODIFYCODE is the code for a binary operator that we use
	to combine the old value of LHS with RHS to get the new value.
	Or else MODIFYCODE is NOP_EXPR meaning do a simple assignment. */

	tree
	build_modify_expr (tree lhs, enum tree_code modifycode, tree rhs)
	{
	tree result;
	tree newrhs;
	tree lhstype = TREE_TYPE (lhs);
	tree olhstype = lhstype;

	/* Types that aren't fully specified cannot be used in assignments. */
	lhs = require_complete_type (lhs);

	/* Avoid duplicate error messages from operands that had errors. */
	if (TREE_CODE (lhs) == ERROR_MARK \|\| TREE_CODE (rhs) == ERROR_MARK)
	return error_mark_node;

	if (!lvalue_or_else (lhs, lv_assign))
	return error_mark_node;

	STRIP_TYPE_NOPS (rhs);

	newrhs = rhs;

	/* If a binary op has been requested, combine the old LHS value with the RHS
	producing the value we should actually store into the LHS. */

	if (modifycode != NOP_EXPR)
	{
	lhs = stabilize_reference (lhs);
	newrhs = build_binary_op (modifycode, lhs, rhs, 1);
	}

	/* Give an error for storing in something that is 'const'. */

	if (TREE_READONLY (lhs) \|\| TYPE_READONLY (lhstype)
	\|\| ((TREE_CODE (lhstype) == RECORD_TYPE
	\|\| TREE_CODE (lhstype) == UNION_TYPE)
	&& C_TYPE_FIELDS_READONLY (lhstype)))
	{
	readonly_error (lhs, lv_assign);
	return error_mark_node;
	}

	/* If storing into a structure or union member,
	it has probably been given type `int'.
	Compute the type that would go with
	the actual amount of storage the member occupies. */

	if (TREE_CODE (lhs) == COMPONENT_REF
	&& (TREE_CODE (lhstype) == INTEGER_TYPE
	\|\| TREE_CODE (lhstype) == BOOLEAN_TYPE
	\|\| TREE_CODE (lhstype) == REAL_TYPE
	\|\| TREE_CODE (lhstype) == ENUMERAL_TYPE))
	lhstype = TREE_TYPE (get_unwidened (lhs, 0));

	/* If storing in a field that is in actuality a short or narrower than one,
	we must store in the field in its actual type. */

	if (lhstype != TREE_TYPE (lhs))
	{
	lhs = copy_node (lhs);
	TREE_TYPE (lhs) = lhstype;
	}

	/* Convert new value to destination type. */

	newrhs = convert_for_assignment (lhstype, newrhs, ic_assign,
	NULL_TREE, NULL_TREE, 0);
	if (TREE_CODE (newrhs) == ERROR_MARK)
	return error_mark_node;

	/* Emit ObjC write barrier, if necessary. */
	if (c_dialect_objc () && flag_objc_gc)
	{
	result = objc_generate_write_barrier (lhs, modifycode, newrhs);
	if (result)
	return result;
	}

	/* Scan operands. */

	result = build2 (MODIFY_EXPR, lhstype, lhs, newrhs);
	TREE_SIDE_EFFECTS (result) = 1;

	/* If we got the LHS in a different type for storing in,
	convert the result back to the nominal type of LHS
	so that the value we return always has the same type
	as the LHS argument. */

	if (olhstype == TREE_TYPE (result))
	return result;
	return convert_for_assignment (olhstype, result, ic_assign,
	NULL_TREE, NULL_TREE, 0);
	}

	/* Convert value RHS to type TYPE as preparation for an assignment
	to an lvalue of type TYPE.
	The real work of conversion is done by `convert'.
	The purpose of this function is to generate error messages
	for assignments that are not allowed in C.
	ERRTYPE says whether it is argument passing, assignment,
	initialization or return.

	FUNCTION is a tree for the function being called.
	PARMNUM is the number of the argument, for printing in error messages. */

	static tree
	convert_for_assignment (tree type, tree rhs, enum impl_conv errtype,
	tree fundecl, tree function, int parmnum)
	{
	enum tree_code codel = TREE_CODE (type);
	tree rhstype;
	enum tree_code coder;
	tree rname = NULL_TREE;
	bool objc_ok = false;

	if (errtype == ic_argpass \|\| errtype == ic_argpass_nonproto)
	{
	tree selector;
	/* Change pointer to function to the function itself for
	diagnostics. */
	if (TREE_CODE (function) == ADDR_EXPR
	&& TREE_CODE (TREE_OPERAND (function, 0)) == FUNCTION_DECL)
	function = TREE_OPERAND (function, 0);

	/* Handle an ObjC selector specially for diagnostics. */
	selector = objc_message_selector ();
	rname = function;
	if (selector && parmnum > 2)
	{
	rname = selector;
	parmnum -= 2;
	}
	}

	/* This macro is used to emit diagnostics to ensure that all format
	strings are complete sentences, visible to gettext and checked at
	compile time. */
	#define WARN_FOR_ASSIGNMENT(AR, AS, IN, RE) \
	do { \
	switch (errtype) \
	{ \
	case ic_argpass: \
	pedwarn (AR, parmnum, rname); \
	break; \
	case ic_argpass_nonproto: \
	warning (0, AR, parmnum, rname); \
	break; \
	case ic_assign: \
	pedwarn (AS); \
	break; \
	case ic_init: \
	pedwarn (IN); \
	break; \
	case ic_return: \
	pedwarn (RE); \
	break; \
	default: \
	gcc_unreachable (); \
	} \
	} while (0)

	STRIP_TYPE_NOPS (rhs);

	if (optimize && TREE_CODE (rhs) == VAR_DECL
	&& TREE_CODE (TREE_TYPE (rhs)) != ARRAY_TYPE)
	rhs = decl_constant_value_for_broken_optimization (rhs);

	rhstype = TREE_TYPE (rhs);
	coder = TREE_CODE (rhstype);

	if (coder == ERROR_MARK)
	return error_mark_node;

	if (c_dialect_objc ())
	{
	int parmno;

	switch (errtype)
	{
	case ic_return:
	parmno = 0;
	break;

	case ic_assign:
	parmno = -1;
	break;

	case ic_init:
	parmno = -2;
	break;

	default:
	parmno = parmnum;
	break;
	}

	objc_ok = objc_compare_types (type, rhstype, parmno, rname);
	}

	if (TYPE_MAIN_VARIANT (type) == TYPE_MAIN_VARIANT (rhstype))
	return rhs;

	if (coder == VOID_TYPE)
	{
	/* Except for passing an argument to an unprototyped function,
	this is a constraint violation. When passing an argument to
	an unprototyped function, it is compile-time undefined;
	making it a constraint in that case was rejected in
	DR#252. */
	error ("void value not ignored as it ought to be");
	return error_mark_node;
	}
	/* A type converts to a reference to it.
	This code doesn't fully support references, it's just for the
	special case of va_start and va_copy. */
	if (codel == REFERENCE_TYPE
	&& comptypes (TREE_TYPE (type), TREE_TYPE (rhs)) == 1)
	{
	if (!lvalue_p (rhs))
	{
	error ("cannot pass rvalue to reference parameter");
	return error_mark_node;
	}
	if (!c_mark_addressable (rhs))
	return error_mark_node;
	rhs = build1 (ADDR_EXPR, build_pointer_type (TREE_TYPE (rhs)), rhs);

	/* We already know that these two types are compatible, but they
	may not be exactly identical. In fact, `TREE_TYPE (type)' is
	likely to be __builtin_va_list and `TREE_TYPE (rhs)' is
	likely to be va_list, a typedef to __builtin_va_list, which
	is different enough that it will cause problems later. */
	if (TREE_TYPE (TREE_TYPE (rhs)) != TREE_TYPE (type))
	rhs = build1 (NOP_EXPR, build_pointer_type (TREE_TYPE (type)), rhs);

	rhs = build1 (NOP_EXPR, type, rhs);
	return rhs;
	}
	/* Some types can interconvert without explicit casts. */
	else if (codel == VECTOR_TYPE && coder == VECTOR_TYPE
	&& vector_types_convertible_p (type, TREE_TYPE (rhs), true))
	return convert (type, rhs);
	/* Arithmetic types all interconvert, and enum is treated like int. */
	else if ((codel == INTEGER_TYPE \|\| codel == REAL_TYPE
	\|\| codel == ENUMERAL_TYPE \|\| codel == COMPLEX_TYPE
	\|\| codel == BOOLEAN_TYPE)
	&& (coder == INTEGER_TYPE \|\| coder == REAL_TYPE
	\|\| coder == ENUMERAL_TYPE \|\| coder == COMPLEX_TYPE
	\|\| coder == BOOLEAN_TYPE))
	return convert_and_check (type, rhs);

	/* Aggregates in different TUs might need conversion. */
	if ((codel == RECORD_TYPE \|\| codel == UNION_TYPE)
	&& codel == coder
	&& comptypes (type, rhstype))
	return convert_and_check (type, rhs);

	/* Conversion to a transparent union from its member types.
	This applies only to function arguments. */
	if (codel == UNION_TYPE && TYPE_TRANSPARENT_UNION (type)
	&& (errtype == ic_argpass \|\| errtype == ic_argpass_nonproto))
	{
	tree memb, marginal_memb = NULL_TREE;

	for (memb = TYPE_FIELDS (type); memb ; memb = TREE_CHAIN (memb))
	{
	tree memb_type = TREE_TYPE (memb);

	if (comptypes (TYPE_MAIN_VARIANT (memb_type),
	TYPE_MAIN_VARIANT (rhstype)))
	break;

	if (TREE_CODE (memb_type) != POINTER_TYPE)
	continue;

	if (coder == POINTER_TYPE)
	{
	tree ttl = TREE_TYPE (memb_type);
	tree ttr = TREE_TYPE (rhstype);

	/* Any non-function converts to a [const][volatile] void *
	and vice versa; otherwise, targets must be the same.
	Meanwhile, the lhs target must have all the qualifiers of
	the rhs. */
	if (VOID_TYPE_P (ttl) \|\| VOID_TYPE_P (ttr)
	\|\| comp_target_types (memb_type, rhstype))
	{
	/* If this type won't generate any warnings, use it. */
	if (TYPE_QUALS (ttl) == TYPE_QUALS (ttr)
	\|\| ((TREE_CODE (ttr) == FUNCTION_TYPE
	&& TREE_CODE (ttl) == FUNCTION_TYPE)
	? ((TYPE_QUALS (ttl) \| TYPE_QUALS (ttr))
	== TYPE_QUALS (ttr))
	: ((TYPE_QUALS (ttl) \| TYPE_QUALS (ttr))
	== TYPE_QUALS (ttl))))
	break;

	/* Keep looking for a better type, but remember this one. */
	if (!marginal_memb)
	marginal_memb = memb;
	}
	}

	/* Can convert integer zero to any pointer type. */
	if (null_pointer_constant_p (rhs))
	{
	rhs = null_pointer_node;
	break;
	}
	}

	if (memb \|\| marginal_memb)
	{
	if (!memb)
	{
	/* We have only a marginally acceptable member type;
	it needs a warning. */
	tree ttl = TREE_TYPE (TREE_TYPE (marginal_memb));
	tree ttr = TREE_TYPE (rhstype);

	/* Const and volatile mean something different for function
	types, so the usual warnings are not appropriate. */
	if (TREE_CODE (ttr) == FUNCTION_TYPE
	&& TREE_CODE (ttl) == FUNCTION_TYPE)
	{
	/* Because const and volatile on functions are
	restrictions that say the function will not do
	certain things, it is okay to use a const or volatile
	function where an ordinary one is wanted, but not
	vice-versa. */
	if (TYPE_QUALS (ttl) & ~TYPE_QUALS (ttr))
	WARN_FOR_ASSIGNMENT (G_("passing argument %d of %qE "
	"makes qualified function "
	"pointer from unqualified"),
	G_("assignment makes qualified "
	"function pointer from "
	"unqualified"),
	G_("initialization makes qualified "
	"function pointer from "
	"unqualified"),
	G_("return makes qualified function "
	"pointer from unqualified"));
	}
	else if (TYPE_QUALS (ttr) & ~TYPE_QUALS (ttl))
	WARN_FOR_ASSIGNMENT (G_("passing argument %d of %qE discards "
	"qualifiers from pointer target type"),
	G_("assignment discards qualifiers "
	"from pointer target type"),
	G_("initialization discards qualifiers "
	"from pointer target type"),
	G_("return discards qualifiers from "
	"pointer target type"));

	memb = marginal_memb;
	}

	if (pedantic && (!fundecl \|\| !DECL_IN_SYSTEM_HEADER (fundecl)))
	pedwarn ("ISO C prohibits argument conversion to union type");

	return build_constructor_single (type, memb, rhs);
	}
	}

	/* Conversions among pointers */
	else if ((codel == POINTER_TYPE \|\| codel == REFERENCE_TYPE)
	&& (coder == codel))
	{
	tree ttl = TREE_TYPE (type);
	tree ttr = TREE_TYPE (rhstype);
	tree mvl = ttl;
	tree mvr = ttr;
	bool is_opaque_pointer;
	int target_cmp = 0; /* Cache comp_target_types () result. */

	if (TREE_CODE (mvl) != ARRAY_TYPE)
	mvl = TYPE_MAIN_VARIANT (mvl);
	if (TREE_CODE (mvr) != ARRAY_TYPE)
	mvr = TYPE_MAIN_VARIANT (mvr);
	/* Opaque pointers are treated like void pointers. */
	is_opaque_pointer = (targetm.vector_opaque_p (type)
	\|\| targetm.vector_opaque_p (rhstype))
	&& TREE_CODE (ttl) == VECTOR_TYPE
	&& TREE_CODE (ttr) == VECTOR_TYPE;

	/* C++ does not allow the implicit conversion void* -> T*. However,
	for the purpose of reducing the number of false positives, we
	tolerate the special case of

	int *p = NULL;

	where NULL is typically defined in C to be '(void ) 0'. /
	if (VOID_TYPE_P (ttr) && rhs != null_pointer_node && !VOID_TYPE_P (ttl))
	warning (OPT_Wc___compat, "request for implicit conversion from "
	"%qT to %qT not permitted in C++", rhstype, type);

	/* Check if the right-hand side has a format attribute but the
	left-hand side doesn't. */
	if (warn_missing_format_attribute
	&& check_missing_format_attribute (type, rhstype))
	{
	switch (errtype)
	{
	case ic_argpass:
	case ic_argpass_nonproto:
	warning (OPT_Wmissing_format_attribute,
	"argument %d of %qE might be "
	"a candidate for a format attribute",
	parmnum, rname);
	break;
	case ic_assign:
	warning (OPT_Wmissing_format_attribute,
	"assignment left-hand side might be "
	"a candidate for a format attribute");
	break;
	case ic_init:
	warning (OPT_Wmissing_format_attribute,
	"initialization left-hand side might be "
	"a candidate for a format attribute");
	break;
	case ic_return:
	warning (OPT_Wmissing_format_attribute,
	"return type might be "
	"a candidate for a format attribute");
	break;
	default:
	gcc_unreachable ();
	}
	}

	/* Any non-function converts to a [const][volatile] void *
	and vice versa; otherwise, targets must be the same.
	Meanwhile, the lhs target must have all the qualifiers of the rhs. */
	if (VOID_TYPE_P (ttl) \|\| VOID_TYPE_P (ttr)
	\|\| (target_cmp = comp_target_types (type, rhstype))
	\|\| is_opaque_pointer
	\|\| (c_common_unsigned_type (mvl)
	== c_common_unsigned_type (mvr)))
	{
	if (pedantic
	&& ((VOID_TYPE_P (ttl) && TREE_CODE (ttr) == FUNCTION_TYPE)
	\|\|
	(VOID_TYPE_P (ttr)
	&& !null_pointer_constant_p (rhs)
	&& TREE_CODE (ttl) == FUNCTION_TYPE)))
	WARN_FOR_ASSIGNMENT (G_("ISO C forbids passing argument %d of "
	"%qE between function pointer "
	"and %<void *%>"),
	G_("ISO C forbids assignment between "
	"function pointer and %<void *%>"),
	G_("ISO C forbids initialization between "
	"function pointer and %<void *%>"),
	G_("ISO C forbids return between function "
	"pointer and %<void *%>"));
	/* Const and volatile mean something different for function types,
	so the usual warnings are not appropriate. */
	else if (TREE_CODE (ttr) != FUNCTION_TYPE
	&& TREE_CODE (ttl) != FUNCTION_TYPE)
	{
	if (TYPE_QUALS (ttr) & ~TYPE_QUALS (ttl))
	{
	/* Types differing only by the presence of the 'volatile'
	qualifier are acceptable if the 'volatile' has been added
	in by the Objective-C EH machinery. */
	if (!objc_type_quals_match (ttl, ttr))
	WARN_FOR_ASSIGNMENT (G_("passing argument %d of %qE discards "
	"qualifiers from pointer target type"),
	G_("assignment discards qualifiers "
	"from pointer target type"),
	G_("initialization discards qualifiers "
	"from pointer target type"),
	G_("return discards qualifiers from "
	"pointer target type"));
	}
	/* If this is not a case of ignoring a mismatch in signedness,
	no warning. */
	else if (VOID_TYPE_P (ttl) \|\| VOID_TYPE_P (ttr)
	\|\| target_cmp)
	;
	/* If there is a mismatch, do warn. */
	else if (warn_pointer_sign)
	WARN_FOR_ASSIGNMENT (G_("pointer targets in passing argument "
	"%d of %qE differ in signedness"),
	G_("pointer targets in assignment "
	"differ in signedness"),
	G_("pointer targets in initialization "
	"differ in signedness"),
	G_("pointer targets in return differ "
	"in signedness"));
	}
	else if (TREE_CODE (ttl) == FUNCTION_TYPE
	&& TREE_CODE (ttr) == FUNCTION_TYPE)
	{
	/* Because const and volatile on functions are restrictions
	that say the function will not do certain things,
	it is okay to use a const or volatile function
	where an ordinary one is wanted, but not vice-versa. */
	if (TYPE_QUALS (ttl) & ~TYPE_QUALS (ttr))
	WARN_FOR_ASSIGNMENT (G_("passing argument %d of %qE makes "
	"qualified function pointer "
	"from unqualified"),
	G_("assignment makes qualified function "
	"pointer from unqualified"),
	G_("initialization makes qualified "
	"function pointer from unqualified"),
	G_("return makes qualified function "
	"pointer from unqualified"));
	}
	}
	else
	/* Avoid warning about the volatile ObjC EH puts on decls. */
	if (!objc_ok)
	WARN_FOR_ASSIGNMENT (G_("passing argument %d of %qE from "
	"incompatible pointer type"),
	G_("assignment from incompatible pointer type"),
	G_("initialization from incompatible "
	"pointer type"),
	G_("return from incompatible pointer type"));

	return convert (type, rhs);
	}
	else if (codel == POINTER_TYPE && coder == ARRAY_TYPE)
	{
	/* ??? This should not be an error when inlining calls to
	unprototyped functions. */
	error ("invalid use of non-lvalue array");
	return error_mark_node;
	}
	else if (codel == POINTER_TYPE && coder == INTEGER_TYPE)
	{
	/* An explicit constant 0 can convert to a pointer,
	or one that results from arithmetic, even including
	a cast to integer type. */
	if (!null_pointer_constant_p (rhs))
	WARN_FOR_ASSIGNMENT (G_("passing argument %d of %qE makes "
	"pointer from integer without a cast"),
	G_("assignment makes pointer from integer "
	"without a cast"),
	G_("initialization makes pointer from "
	"integer without a cast"),
	G_("return makes pointer from integer "
	"without a cast"));

	return convert (type, rhs);
	}
	else if (codel == INTEGER_TYPE && coder == POINTER_TYPE)
	{
	WARN_FOR_ASSIGNMENT (G_("passing argument %d of %qE makes integer "
	"from pointer without a cast"),
	G_("assignment makes integer from pointer "
	"without a cast"),
	G_("initialization makes integer from pointer "
	"without a cast"),
	G_("return makes integer from pointer "
	"without a cast"));
	return convert (type, rhs);
	}
	else if (codel == BOOLEAN_TYPE && coder == POINTER_TYPE)
	return convert (type, rhs);

	switch (errtype)
	{
	case ic_argpass:
	case ic_argpass_nonproto:
	/* ??? This should not be an error when inlining calls to
	unprototyped functions. */
	error ("incompatible type for argument %d of %qE", parmnum, rname);
	break;
	case ic_assign:
	error ("incompatible types in assignment");
	break;
	case ic_init:
	error ("incompatible types in initialization");
	break;
	case ic_return:
	error ("incompatible types in return");
	break;
	default:
	gcc_unreachable ();
	}

	return error_mark_node;
	}

	/* Convert VALUE for assignment into inlined parameter PARM. ARGNUM
	is used for error and warning reporting and indicates which argument
	is being processed. */

	tree
	c_convert_parm_for_inlining (tree parm, tree value, tree fn, int argnum)
	{
	tree ret, type;

	/* If FN was prototyped at the call site, the value has been converted
	already in convert_arguments.
	However, we might see a prototype now that was not in place when
	the function call was seen, so check that the VALUE actually matches
	PARM before taking an early exit. */
	if (!value
	\|\| (TYPE_ARG_TYPES (TREE_TYPE (fn))
	&& (TYPE_MAIN_VARIANT (TREE_TYPE (parm))
	== TYPE_MAIN_VARIANT (TREE_TYPE (value)))))
	return value;

	type = TREE_TYPE (parm);
	ret = convert_for_assignment (type, value,
	ic_argpass_nonproto, fn,
	fn, argnum);
	if (targetm.calls.promote_prototypes (TREE_TYPE (fn))
	&& INTEGRAL_TYPE_P (type)
	&& (TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node)))
	ret = default_conversion (ret);
	return ret;
	}

	/* If VALUE is a compound expr all of whose expressions are constant, then
	return its value. Otherwise, return error_mark_node.

	This is for handling COMPOUND_EXPRs as initializer elements
	which is allowed with a warning when -pedantic is specified. */

	static tree
	valid_compound_expr_initializer (tree value, tree endtype)
	{
	if (TREE_CODE (value) == COMPOUND_EXPR)
	{
	if (valid_compound_expr_initializer (TREE_OPERAND (value, 0), endtype)
	== error_mark_node)
	return error_mark_node;
	return valid_compound_expr_initializer (TREE_OPERAND (value, 1),
	endtype);
	}
	else if (!initializer_constant_valid_p (value, endtype))
	return error_mark_node;
	else
	return value;
	}

	/* Perform appropriate conversions on the initial value of a variable,
	store it in the declaration DECL,
	and print any error messages that are appropriate.
	If the init is invalid, store an ERROR_MARK. */

	void
	store_init_value (tree decl, tree init)
	{
	tree value, type;

	/* If variable's type was invalidly declared, just ignore it. */

	type = TREE_TYPE (decl);
	if (TREE_CODE (type) == ERROR_MARK)
	return;

	/* Digest the specified initializer into an expression. */

	value = digest_init (type, init, true, TREE_STATIC (decl));

	/* Store the expression if valid; else report error. */

	if (!in_system_header
	&& AGGREGATE_TYPE_P (TREE_TYPE (decl)) && !TREE_STATIC (decl))
	warning (OPT_Wtraditional, "traditional C rejects automatic "
	"aggregate initialization");

	DECL_INITIAL (decl) = value;

	/* ANSI wants warnings about out-of-range constant initializers. */
	STRIP_TYPE_NOPS (value);
	constant_expression_warning (value);

	/* Check if we need to set array size from compound literal size. */
	if (TREE_CODE (type) == ARRAY_TYPE
	&& TYPE_DOMAIN (type) == 0
	&& value != error_mark_node)
	{
	tree inside_init = init;

	STRIP_TYPE_NOPS (inside_init);
	inside_init = fold (inside_init);

	if (TREE_CODE (inside_init) == COMPOUND_LITERAL_EXPR)
	{
	tree cldecl = COMPOUND_LITERAL_EXPR_DECL (inside_init);

	if (TYPE_DOMAIN (TREE_TYPE (cldecl)))
	{
	/* For int foo[] = (int [3]){1}; we need to set array size
	now since later on array initializer will be just the
	brace enclosed list of the compound literal. */
	type = build_distinct_type_copy (TYPE_MAIN_VARIANT (type));
	TREE_TYPE (decl) = type;
	TYPE_DOMAIN (type) = TYPE_DOMAIN (TREE_TYPE (cldecl));
	layout_type (type);
	layout_decl (cldecl, 0);
	}
	}
	}
	}

	/* Methods for storing and printing names for error messages. */

	/* Implement a spelling stack that allows components of a name to be pushed
	and popped. Each element on the stack is this structure. */

	struct spelling
	{
	int kind;
	union
	{
	unsigned HOST_WIDE_INT i;
	const char *s;
	} u;
	};

	#define SPELLING_STRING 1
	#define SPELLING_MEMBER 2
	#define SPELLING_BOUNDS 3

	static struct spelling spelling; / Next stack element (unused). */
	static struct spelling spelling_base; / Spelling stack base. */
	static int spelling_size; /* Size of the spelling stack. */

	/* Macros to save and restore the spelling stack around push_... functions.
	Alternative to SAVE_SPELLING_STACK. */

	#define SPELLING_DEPTH() (spelling - spelling_base)
	#define RESTORE_SPELLING_DEPTH(DEPTH) (spelling = spelling_base + (DEPTH))

	/* Push an element on the spelling stack with type KIND and assign VALUE
	to MEMBER. */

	#define PUSH_SPELLING(KIND, VALUE, MEMBER) \
	{ \
	int depth = SPELLING_DEPTH (); \
	\
	if (depth >= spelling_size) \
	{ \
	spelling_size += 10; \
	spelling_base = XRESIZEVEC (struct spelling, spelling_base, \
	spelling_size); \
	RESTORE_SPELLING_DEPTH (depth); \
	} \
	\
	spelling->kind = (KIND); \
	spelling->MEMBER = (VALUE); \
	spelling++; \
	}

	/* Push STRING on the stack. Printed literally. */

	static void
	push_string (const char *string)
	{
	PUSH_SPELLING (SPELLING_STRING, string, u.s);
	}

	/* Push a member name on the stack. Printed as '.' STRING. */

	static void
	push_member_name (tree decl)
	{
	const char *const string
	= DECL_NAME (decl) ? IDENTIFIER_POINTER (DECL_NAME (decl)) : "<anonymous>";
	PUSH_SPELLING (SPELLING_MEMBER, string, u.s);
	}

	/* Push an array bounds on the stack. Printed as [BOUNDS]. */

	static void
	push_array_bounds (unsigned HOST_WIDE_INT bounds)
	{
	PUSH_SPELLING (SPELLING_BOUNDS, bounds, u.i);
	}

	/* Compute the maximum size in bytes of the printed spelling. */

	static int
	spelling_length (void)
	{
	int size = 0;
	struct spelling *p;

	for (p = spelling_base; p < spelling; p++)
	{
	if (p->kind == SPELLING_BOUNDS)
	size += 25;
	else
	size += strlen (p->u.s) + 1;
	}

	return size;
	}

	/* Print the spelling to BUFFER and return it. */

	static char *
	print_spelling (char *buffer)
	{
	char *d = buffer;
	struct spelling *p;

	for (p = spelling_base; p < spelling; p++)
	if (p->kind == SPELLING_BOUNDS)
	{
	sprintf (d, "[" HOST_WIDE_INT_PRINT_UNSIGNED "]", p->u.i);
	d += strlen (d);
	}
	else
	{
	const char *s;
	if (p->kind == SPELLING_MEMBER)
	*d++ = '.';
	for (s = p->u.s; (d = s++); d++)
	;
	}
	*d++ = '\0';
	return buffer;
	}

	/* Issue an error message for a bad initializer component.
	MSGID identifies the message.
	The component name is taken from the spelling stack. */

	void
	error_init (const char *msgid)
	{
	char *ofwhat;

	error ("%s", _(msgid));
	ofwhat = print_spelling ((char *) alloca (spelling_length () + 1));
	if (*ofwhat)
	error ("(near initialization for %qs)", ofwhat);
	}

	/* Issue a pedantic warning for a bad initializer component.
	MSGID identifies the message.
	The component name is taken from the spelling stack. */

	void
	pedwarn_init (const char *msgid)
	{
	char *ofwhat;

	pedwarn ("%s", _(msgid));
	ofwhat = print_spelling ((char *) alloca (spelling_length () + 1));
	if (*ofwhat)
	pedwarn ("(near initialization for %qs)", ofwhat);
	}

	/* Issue a warning for a bad initializer component.
	MSGID identifies the message.
	The component name is taken from the spelling stack. */

	static void
	warning_init (const char *msgid)
	{
	char *ofwhat;

	warning (0, "%s", _(msgid));
	ofwhat = print_spelling ((char *) alloca (spelling_length () + 1));
	if (*ofwhat)
	warning (0, "(near initialization for %qs)", ofwhat);
	}

	/* If TYPE is an array type and EXPR is a parenthesized string
	constant, warn if pedantic that EXPR is being used to initialize an
	object of type TYPE. */

	void
	maybe_warn_string_init (tree type, struct c_expr expr)
	{
	if (pedantic
	&& TREE_CODE (type) == ARRAY_TYPE
	&& TREE_CODE (expr.value) == STRING_CST
	&& expr.original_code != STRING_CST)
	pedwarn_init ("array initialized from parenthesized string constant");
	}

	/* Digest the parser output INIT as an initializer for type TYPE.
	Return a C expression of type TYPE to represent the initial value.

	If INIT is a string constant, STRICT_STRING is true if it is
	unparenthesized or we should not warn here for it being parenthesized.
	For other types of INIT, STRICT_STRING is not used.

	REQUIRE_CONSTANT requests an error if non-constant initializers or
	elements are seen. */

	static tree
	digest_init (tree type, tree init, bool strict_string, int require_constant)
	{
	enum tree_code code = TREE_CODE (type);
	tree inside_init = init;

	if (type == error_mark_node
	\|\| !init
	\|\| init == error_mark_node
	\|\| TREE_TYPE (init) == error_mark_node)
	return error_mark_node;

	STRIP_TYPE_NOPS (inside_init);

	inside_init = fold (inside_init);

	/* Initialization of an array of chars from a string constant
	optionally enclosed in braces. */

	if (code == ARRAY_TYPE && inside_init
	&& TREE_CODE (inside_init) == STRING_CST)
	{
	tree typ1 = TYPE_MAIN_VARIANT (TREE_TYPE (type));
	/* Note that an array could be both an array of character type
	and an array of wchar_t if wchar_t is signed char or unsigned
	char. */
	bool char_array = (typ1 == char_type_node
	\|\| typ1 == signed_char_type_node
	\|\| typ1 == unsigned_char_type_node);
	bool wchar_array = !!comptypes (typ1, wchar_type_node);
	if (char_array \|\| wchar_array)
	{
	struct c_expr expr;
	bool char_string;
	expr.value = inside_init;
	expr.original_code = (strict_string ? STRING_CST : ERROR_MARK);
	maybe_warn_string_init (type, expr);

	char_string
	= (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (inside_init)))
	== char_type_node);

	if (comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (inside_init)),
	TYPE_MAIN_VARIANT (type)))
	return inside_init;

	if (!wchar_array && !char_string)
	{
	error_init ("char-array initialized from wide string");
	return error_mark_node;
	}
	if (char_string && !char_array)
	{
	error_init ("wchar_t-array initialized from non-wide string");
	return error_mark_node;
	}

	TREE_TYPE (inside_init) = type;
	if (TYPE_DOMAIN (type) != 0
	&& TYPE_SIZE (type) != 0
	&& TREE_CODE (TYPE_SIZE (type)) == INTEGER_CST
	/* Subtract 1 (or sizeof (wchar_t))
	because it's ok to ignore the terminating null char
	that is counted in the length of the constant. */
	&& 0 > compare_tree_int (TYPE_SIZE_UNIT (type),
	TREE_STRING_LENGTH (inside_init)
	- ((TYPE_PRECISION (typ1)
	!= TYPE_PRECISION (char_type_node))
	? (TYPE_PRECISION (wchar_type_node)
	/ BITS_PER_UNIT)
	: 1)))
	pedwarn_init ("initializer-string for array of chars is too long");

	return inside_init;
	}
	else if (INTEGRAL_TYPE_P (typ1))
	{
	error_init ("array of inappropriate type initialized "
	"from string constant");
	return error_mark_node;
	}
	}

	/* Build a VECTOR_CST from a constant vector constructor. If the
	vector constructor is not constant (e.g. {1,2,3,foo()}) then punt
	below and handle as a constructor. */
	if (code == VECTOR_TYPE
	&& TREE_CODE (TREE_TYPE (inside_init)) == VECTOR_TYPE
	&& vector_types_convertible_p (TREE_TYPE (inside_init), type, true)
	&& TREE_CONSTANT (inside_init))
	{
	if (TREE_CODE (inside_init) == VECTOR_CST
	&& comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (inside_init)),
	TYPE_MAIN_VARIANT (type)))
	return inside_init;

	if (TREE_CODE (inside_init) == CONSTRUCTOR)
	{
	unsigned HOST_WIDE_INT ix;
	tree value;
	bool constant_p = true;

	/* Iterate through elements and check if all constructor
	elements are _CSTs. /
	FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (inside_init), ix, value)
	if (!CONSTANT_CLASS_P (value))
	{
	constant_p = false;
	break;
	}

	if (constant_p)
	return build_vector_from_ctor (type,
	CONSTRUCTOR_ELTS (inside_init));
	}
	}

	/* Any type can be initialized
	from an expression of the same type, optionally with braces. */

	if (inside_init && TREE_TYPE (inside_init) != 0
	&& (comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (inside_init)),
	TYPE_MAIN_VARIANT (type))
	\|\| (code == ARRAY_TYPE
	&& comptypes (TREE_TYPE (inside_init), type))
	\|\| (code == VECTOR_TYPE
	&& comptypes (TREE_TYPE (inside_init), type))
	\|\| (code == POINTER_TYPE
	&& TREE_CODE (TREE_TYPE (inside_init)) == ARRAY_TYPE
	&& comptypes (TREE_TYPE (TREE_TYPE (inside_init)),
	TREE_TYPE (type)))))
	{
	if (code == POINTER_TYPE)
	{
	if (TREE_CODE (TREE_TYPE (inside_init)) == ARRAY_TYPE)
	{
	if (TREE_CODE (inside_init) == STRING_CST
	\|\| TREE_CODE (inside_init) == COMPOUND_LITERAL_EXPR)
	inside_init = array_to_pointer_conversion (inside_init);
	else
	{
	error_init ("invalid use of non-lvalue array");
	return error_mark_node;
	}
	}
	}

	if (code == VECTOR_TYPE)
	/* Although the types are compatible, we may require a
	conversion. */
	inside_init = convert (type, inside_init);

	if (require_constant
	&& (code == VECTOR_TYPE \|\| !flag_isoc99)
	&& TREE_CODE (inside_init) == COMPOUND_LITERAL_EXPR)
	{
	/* As an extension, allow initializing objects with static storage
	duration with compound literals (which are then treated just as
	the brace enclosed list they contain). Also allow this for
	vectors, as we can only assign them with compound literals. */
	tree decl = COMPOUND_LITERAL_EXPR_DECL (inside_init);
	inside_init = DECL_INITIAL (decl);
	}

	if (code == ARRAY_TYPE && TREE_CODE (inside_init) != STRING_CST
	&& TREE_CODE (inside_init) != CONSTRUCTOR)
	{
	error_init ("array initialized from non-constant array expression");
	return error_mark_node;
	}

	if (optimize && TREE_CODE (inside_init) == VAR_DECL)
	inside_init = decl_constant_value_for_broken_optimization (inside_init);

	/* Compound expressions can only occur here if -pedantic or
	-pedantic-errors is specified. In the later case, we always want
	an error. In the former case, we simply want a warning. */
	if (require_constant && pedantic
	&& TREE_CODE (inside_init) == COMPOUND_EXPR)
	{
	inside_init
	= valid_compound_expr_initializer (inside_init,
	TREE_TYPE (inside_init));
	if (inside_init == error_mark_node)
	error_init ("initializer element is not constant");
	else
	pedwarn_init ("initializer element is not constant");
	if (flag_pedantic_errors)
	inside_init = error_mark_node;
	}
	else if (require_constant
	&& !initializer_constant_valid_p (inside_init,
	TREE_TYPE (inside_init)))
	{
	error_init ("initializer element is not constant");
	inside_init = error_mark_node;
	}

	/* Added to enable additional -Wmissing-format-attribute warnings. */
	if (TREE_CODE (TREE_TYPE (inside_init)) == POINTER_TYPE)
	inside_init = convert_for_assignment (type, inside_init, ic_init, NULL_TREE,
	NULL_TREE, 0);
	return inside_init;
	}

	/* Handle scalar types, including conversions. */

	if (code == INTEGER_TYPE \|\| code == REAL_TYPE \|\| code == POINTER_TYPE
	\|\| code == ENUMERAL_TYPE \|\| code == BOOLEAN_TYPE \|\| code == COMPLEX_TYPE
	\|\| code == VECTOR_TYPE)
	{
	if (TREE_CODE (TREE_TYPE (init)) == ARRAY_TYPE
	&& (TREE_CODE (init) == STRING_CST
	\|\| TREE_CODE (init) == COMPOUND_LITERAL_EXPR))
	init = array_to_pointer_conversion (init);
	inside_init
	= convert_for_assignment (type, init, ic_init,
	NULL_TREE, NULL_TREE, 0);

	/* Check to see if we have already given an error message. */
	if (inside_init == error_mark_node)
	;
	else if (require_constant && !TREE_CONSTANT (inside_init))
	{
	error_init ("initializer element is not constant");
	inside_init = error_mark_node;
	}
	else if (require_constant
	&& !initializer_constant_valid_p (inside_init,
	TREE_TYPE (inside_init)))
	{
	error_init ("initializer element is not computable at load time");
	inside_init = error_mark_node;
	}

	return inside_init;
	}

	/* Come here only for records and arrays. */

	if (COMPLETE_TYPE_P (type) && TREE_CODE (TYPE_SIZE (type)) != INTEGER_CST)
	{
	error_init ("variable-sized object may not be initialized");
	return error_mark_node;
	}

	error_init ("invalid initializer");
	return error_mark_node;
	}

	/* Handle initializers that use braces. */

	/* Type of object we are accumulating a constructor for.
	This type is always a RECORD_TYPE, UNION_TYPE or ARRAY_TYPE. */
	static tree constructor_type;

	/* For a RECORD_TYPE or UNION_TYPE, this is the chain of fields
	left to fill. */
	static tree constructor_fields;

	/* For an ARRAY_TYPE, this is the specified index
	at which to store the next element we get. */
	static tree constructor_index;

	/* For an ARRAY_TYPE, this is the maximum index. */
	static tree constructor_max_index;

	/* For a RECORD_TYPE, this is the first field not yet written out. */
	static tree constructor_unfilled_fields;

	/* For an ARRAY_TYPE, this is the index of the first element
	not yet written out. */
	static tree constructor_unfilled_index;

	/* In a RECORD_TYPE, the byte index of the next consecutive field.
	This is so we can generate gaps between fields, when appropriate. */
	static tree constructor_bit_index;

	/* If we are saving up the elements rather than allocating them,
	this is the list of elements so far (in reverse order,
	most recent first). */
	static VEC(constructor_elt,gc) *constructor_elements;

	/* 1 if constructor should be incrementally stored into a constructor chain,
	0 if all the elements should be kept in AVL tree. */
	static int constructor_incremental;

	/* 1 if so far this constructor's elements are all compile-time constants. */
	static int constructor_constant;

	/* 1 if so far this constructor's elements are all valid address constants. */
	static int constructor_simple;

	/* 1 if this constructor is erroneous so far. */
	static int constructor_erroneous;

	/* Structure for managing pending initializer elements, organized as an
	AVL tree. */

	struct init_node
	{
	struct init_node left, right;
	struct init_node *parent;
	int balance;
	tree purpose;
	tree value;
	};

	/* Tree of pending elements at this constructor level.
	These are elements encountered out of order
	which belong at places we haven't reached yet in actually
	writing the output.
	Will never hold tree nodes across GC runs. */
	static struct init_node *constructor_pending_elts;

	/* The SPELLING_DEPTH of this constructor. */
	static int constructor_depth;

	/* DECL node for which an initializer is being read.
	0 means we are reading a constructor expression
	such as (struct foo) {...}. */
	static tree constructor_decl;

	/* Nonzero if this is an initializer for a top-level decl. */
	static int constructor_top_level;

	/* Nonzero if there were any member designators in this initializer. */
	static int constructor_designated;

	/* Nesting depth of designator list. */
	static int designator_depth;

	/* Nonzero if there were diagnosed errors in this designator list. */
	static int designator_erroneous;


	/* This stack has a level for each implicit or explicit level of
	structuring in the initializer, including the outermost one. It
	saves the values of most of the variables above. */

	struct constructor_range_stack;

	struct constructor_stack
	{
	struct constructor_stack *next;
	tree type;
	tree fields;
	tree index;
	tree max_index;
	tree unfilled_index;
	tree unfilled_fields;
	tree bit_index;
	VEC(constructor_elt,gc) *elements;
	struct init_node *pending_elts;
	int offset;
	int depth;
	/* If value nonzero, this value should replace the entire
	constructor at this level. */
	struct c_expr replacement_value;
	struct constructor_range_stack *range_stack;
	char constant;
	char simple;
	char implicit;
	char erroneous;
	char outer;
	char incremental;
	char designated;
	};

	static struct constructor_stack *constructor_stack;

	/* This stack represents designators from some range designator up to
	the last designator in the list. */

	struct constructor_range_stack
	{
	struct constructor_range_stack next, prev;
	struct constructor_stack *stack;
	tree range_start;
	tree index;
	tree range_end;
	tree fields;
	};

	static struct constructor_range_stack *constructor_range_stack;

	/* This stack records separate initializers that are nested.
	Nested initializers can't happen in ANSI C, but GNU C allows them
	in cases like { ... (struct foo) { ... } ... }. */

	struct initializer_stack
	{
	struct initializer_stack *next;
	tree decl;
	struct constructor_stack *constructor_stack;
	struct constructor_range_stack *constructor_range_stack;
	VEC(constructor_elt,gc) *elements;
	struct spelling *spelling;
	struct spelling *spelling_base;
	int spelling_size;
	char top_level;
	char require_constant_value;
	char require_constant_elements;
	};

	static struct initializer_stack *initializer_stack;

	/* Prepare to parse and output the initializer for variable DECL. */

	void
	start_init (tree decl, tree asmspec_tree ATTRIBUTE_UNUSED, int top_level)
	{
	const char *locus;
	struct initializer_stack *p = XNEW (struct initializer_stack);

	p->decl = constructor_decl;
	p->require_constant_value = require_constant_value;
	p->require_constant_elements = require_constant_elements;
	p->constructor_stack = constructor_stack;
	p->constructor_range_stack = constructor_range_stack;
	p->elements = constructor_elements;
	p->spelling = spelling;
	p->spelling_base = spelling_base;
	p->spelling_size = spelling_size;
	p->top_level = constructor_top_level;
	p->next = initializer_stack;
	initializer_stack = p;

	constructor_decl = decl;
	constructor_designated = 0;
	constructor_top_level = top_level;

	if (decl != 0 && decl != error_mark_node)
	{
	require_constant_value = TREE_STATIC (decl);
	require_constant_elements
	= ((TREE_STATIC (decl) \|\| (pedantic && !flag_isoc99))
	/* For a scalar, you can always use any value to initialize,
	even within braces. */
	&& (TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE
	\|\| TREE_CODE (TREE_TYPE (decl)) == RECORD_TYPE
	\|\| TREE_CODE (TREE_TYPE (decl)) == UNION_TYPE
	\|\| TREE_CODE (TREE_TYPE (decl)) == QUAL_UNION_TYPE));
	locus = IDENTIFIER_POINTER (DECL_NAME (decl));
	}
	else
	{
	require_constant_value = 0;
	require_constant_elements = 0;
	locus = "(anonymous)";
	}

	constructor_stack = 0;
	constructor_range_stack = 0;

	missing_braces_mentioned = 0;

	spelling_base = 0;
	spelling_size = 0;
	RESTORE_SPELLING_DEPTH (0);

	if (locus)
	push_string (locus);
	}

	void
	finish_init (void)
	{
	struct initializer_stack *p = initializer_stack;

	/* Free the whole constructor stack of this initializer. */
	while (constructor_stack)
	{
	struct constructor_stack *q = constructor_stack;
	constructor_stack = q->next;
	free (q);
	}

	gcc_assert (!constructor_range_stack);

	/* Pop back to the data of the outer initializer (if any). */
	free (spelling_base);

	constructor_decl = p->decl;
	require_constant_value = p->require_constant_value;
	require_constant_elements = p->require_constant_elements;
	constructor_stack = p->constructor_stack;
	constructor_range_stack = p->constructor_range_stack;
	constructor_elements = p->elements;
	spelling = p->spelling;
	spelling_base = p->spelling_base;
	spelling_size = p->spelling_size;
	constructor_top_level = p->top_level;
	initializer_stack = p->next;
	free (p);
	}

	/* Call here when we see the initializer is surrounded by braces.
	This is instead of a call to push_init_level;
	it is matched by a call to pop_init_level.

	TYPE is the type to initialize, for a constructor expression.
	For an initializer for a decl, TYPE is zero. */

	void
	really_start_incremental_init (tree type)
	{
	struct constructor_stack *p = XNEW (struct constructor_stack);

	if (type == 0)
	type = TREE_TYPE (constructor_decl);

	if (targetm.vector_opaque_p (type))
	error ("opaque vector types cannot be initialized");

	p->type = constructor_type;
	p->fields = constructor_fields;
	p->index = constructor_index;
	p->max_index = constructor_max_index;
	p->unfilled_index = constructor_unfilled_index;
	p->unfilled_fields = constructor_unfilled_fields;
	p->bit_index = constructor_bit_index;
	p->elements = constructor_elements;
	p->constant = constructor_constant;
	p->simple = constructor_simple;
	p->erroneous = constructor_erroneous;
	p->pending_elts = constructor_pending_elts;
	p->depth = constructor_depth;
	p->replacement_value.value = 0;
	p->replacement_value.original_code = ERROR_MARK;
	p->implicit = 0;
	p->range_stack = 0;
	p->outer = 0;
	p->incremental = constructor_incremental;
	p->designated = constructor_designated;
	p->next = 0;
	constructor_stack = p;

	constructor_constant = 1;
	constructor_simple = 1;
	constructor_depth = SPELLING_DEPTH ();
	constructor_elements = 0;
	constructor_pending_elts = 0;
	constructor_type = type;
	constructor_incremental = 1;
	constructor_designated = 0;
	designator_depth = 0;
	designator_erroneous = 0;

	if (TREE_CODE (constructor_type) == RECORD_TYPE
	\|\| TREE_CODE (constructor_type) == UNION_TYPE)
	{
	constructor_fields = TYPE_FIELDS (constructor_type);
	/* Skip any nameless bit fields at the beginning. */
	while (constructor_fields != 0 && DECL_C_BIT_FIELD (constructor_fields)
	&& DECL_NAME (constructor_fields) == 0)
	constructor_fields = TREE_CHAIN (constructor_fields);

	constructor_unfilled_fields = constructor_fields;
	constructor_bit_index = bitsize_zero_node;
	}
	else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
	{
	if (TYPE_DOMAIN (constructor_type))
	{
	constructor_max_index
	= TYPE_MAX_VALUE (TYPE_DOMAIN (constructor_type));

	/* Detect non-empty initializations of zero-length arrays. */
	if (constructor_max_index == NULL_TREE
	&& TYPE_SIZE (constructor_type))
	constructor_max_index = build_int_cst (NULL_TREE, -1);

	/* constructor_max_index needs to be an INTEGER_CST. Attempts
	to initialize VLAs will cause a proper error; avoid tree
	checking errors as well by setting a safe value. */
	if (constructor_max_index
	&& TREE_CODE (constructor_max_index) != INTEGER_CST)
	constructor_max_index = build_int_cst (NULL_TREE, -1);

	constructor_index
	= convert (bitsizetype,
	TYPE_MIN_VALUE (TYPE_DOMAIN (constructor_type)));
	}
	else
	{
	constructor_index = bitsize_zero_node;
	constructor_max_index = NULL_TREE;
	}

	constructor_unfilled_index = constructor_index;
	}
	else if (TREE_CODE (constructor_type) == VECTOR_TYPE)
	{
	/* Vectors are like simple fixed-size arrays. */
	constructor_max_index =
	build_int_cst (NULL_TREE, TYPE_VECTOR_SUBPARTS (constructor_type) - 1);
	constructor_index = bitsize_zero_node;
	constructor_unfilled_index = constructor_index;
	}
	else
	{
	/* Handle the case of int x = {5}; */
	constructor_fields = constructor_type;
	constructor_unfilled_fields = constructor_type;
	}
	}

	/* Push down into a subobject, for initialization.
	If this is for an explicit set of braces, IMPLICIT is 0.
	If it is because the next element belongs at a lower level,
	IMPLICIT is 1 (or 2 if the push is because of designator list). */

	void
	push_init_level (int implicit)
	{
	struct constructor_stack *p;
	tree value = NULL_TREE;

	/* If we've exhausted any levels that didn't have braces,
	pop them now. If implicit == 1, this will have been done in
	process_init_element; do not repeat it here because in the case
	of excess initializers for an empty aggregate this leads to an
	infinite cycle of popping a level and immediately recreating
	it. */
	if (implicit != 1)
	{
	while (constructor_stack->implicit)
	{
	if ((TREE_CODE (constructor_type) == RECORD_TYPE
	\|\| TREE_CODE (constructor_type) == UNION_TYPE)
	&& constructor_fields == 0)
	process_init_element (pop_init_level (1));
	else if (TREE_CODE (constructor_type) == ARRAY_TYPE
	&& constructor_max_index
	&& tree_int_cst_lt (constructor_max_index,
	constructor_index))
	process_init_element (pop_init_level (1));
	else
	break;
	}
	}

	/* Unless this is an explicit brace, we need to preserve previous
	content if any. */
	if (implicit)
	{
	if ((TREE_CODE (constructor_type) == RECORD_TYPE
	\|\| TREE_CODE (constructor_type) == UNION_TYPE)
	&& constructor_fields)
	value = find_init_member (constructor_fields);
	else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
	value = find_init_member (constructor_index);
	}

	p = XNEW (struct constructor_stack);
	p->type = constructor_type;
	p->fields = constructor_fields;
	p->index = constructor_index;
	p->max_index = constructor_max_index;
	p->unfilled_index = constructor_unfilled_index;
	p->unfilled_fields = constructor_unfilled_fields;
	p->bit_index = constructor_bit_index;
	p->elements = constructor_elements;
	p->constant = constructor_constant;
	p->simple = constructor_simple;
	p->erroneous = constructor_erroneous;
	p->pending_elts = constructor_pending_elts;
	p->depth = constructor_depth;
	p->replacement_value.value = 0;
	p->replacement_value.original_code = ERROR_MARK;
	p->implicit = implicit;
	p->outer = 0;
	p->incremental = constructor_incremental;
	p->designated = constructor_designated;
	p->next = constructor_stack;
	p->range_stack = 0;
	constructor_stack = p;

	constructor_constant = 1;
	constructor_simple = 1;
	constructor_depth = SPELLING_DEPTH ();
	constructor_elements = 0;
	constructor_incremental = 1;
	constructor_designated = 0;
	constructor_pending_elts = 0;
	if (!implicit)
	{
	p->range_stack = constructor_range_stack;
	constructor_range_stack = 0;
	designator_depth = 0;
	designator_erroneous = 0;
	}

	/* Don't die if an entire brace-pair level is superfluous
	in the containing level. */
	if (constructor_type == 0)
	;
	else if (TREE_CODE (constructor_type) == RECORD_TYPE
	\|\| TREE_CODE (constructor_type) == UNION_TYPE)
	{
	/* Don't die if there are extra init elts at the end. */
	if (constructor_fields == 0)
	constructor_type = 0;
	else
	{
	constructor_type = TREE_TYPE (constructor_fields);
	push_member_name (constructor_fields);
	constructor_depth++;
	}
	}
	else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
	{
	constructor_type = TREE_TYPE (constructor_type);
	push_array_bounds (tree_low_cst (constructor_index, 1));
	constructor_depth++;
	}

	if (constructor_type == 0)
	{
	error_init ("extra brace group at end of initializer");
	constructor_fields = 0;
	constructor_unfilled_fields = 0;
	return;
	}

	if (value && TREE_CODE (value) == CONSTRUCTOR)
	{
	constructor_constant = TREE_CONSTANT (value);
	constructor_simple = TREE_STATIC (value);
	constructor_elements = CONSTRUCTOR_ELTS (value);
	if (!VEC_empty (constructor_elt, constructor_elements)
	&& (TREE_CODE (constructor_type) == RECORD_TYPE
	\|\| TREE_CODE (constructor_type) == ARRAY_TYPE))
	set_nonincremental_init ();
	}

	if (implicit == 1 && warn_missing_braces && !missing_braces_mentioned)
	{
	missing_braces_mentioned = 1;
	warning_init ("missing braces around initializer");
	}

	if (TREE_CODE (constructor_type) == RECORD_TYPE
	\|\| TREE_CODE (constructor_type) == UNION_TYPE)
	{
	constructor_fields = TYPE_FIELDS (constructor_type);
	/* Skip any nameless bit fields at the beginning. */
	while (constructor_fields != 0 && DECL_C_BIT_FIELD (constructor_fields)
	&& DECL_NAME (constructor_fields) == 0)
	constructor_fields = TREE_CHAIN (constructor_fields);

	constructor_unfilled_fields = constructor_fields;
	constructor_bit_index = bitsize_zero_node;
	}
	else if (TREE_CODE (constructor_type) == VECTOR_TYPE)
	{
	/* Vectors are like simple fixed-size arrays. */
	constructor_max_index =
	build_int_cst (NULL_TREE, TYPE_VECTOR_SUBPARTS (constructor_type) - 1);
	constructor_index = convert (bitsizetype, integer_zero_node);
	constructor_unfilled_index = constructor_index;
	}
	else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
	{
	if (TYPE_DOMAIN (constructor_type))
	{
	constructor_max_index
	= TYPE_MAX_VALUE (TYPE_DOMAIN (constructor_type));

	/* Detect non-empty initializations of zero-length arrays. */
	if (constructor_max_index == NULL_TREE
	&& TYPE_SIZE (constructor_type))
	constructor_max_index = build_int_cst (NULL_TREE, -1);

	/* constructor_max_index needs to be an INTEGER_CST. Attempts
	to initialize VLAs will cause a proper error; avoid tree
	checking errors as well by setting a safe value. */
	if (constructor_max_index
	&& TREE_CODE (constructor_max_index) != INTEGER_CST)
	constructor_max_index = build_int_cst (NULL_TREE, -1);

	constructor_index
	= convert (bitsizetype,
	TYPE_MIN_VALUE (TYPE_DOMAIN (constructor_type)));
	}
	else
	constructor_index = bitsize_zero_node;

	constructor_unfilled_index = constructor_index;
	if (value && TREE_CODE (value) == STRING_CST)
	{
	/* We need to split the char/wchar array into individual
	characters, so that we don't have to special case it
	everywhere. */
	set_nonincremental_init_from_string (value);
	}
	}
	else
	{
	if (constructor_type != error_mark_node)
	warning_init ("braces around scalar initializer");
	constructor_fields = constructor_type;
	constructor_unfilled_fields = constructor_type;
	}
	}

	/* At the end of an implicit or explicit brace level,
	finish up that level of constructor. If a single expression
	with redundant braces initialized that level, return the
	c_expr structure for that expression. Otherwise, the original_code
	element is set to ERROR_MARK.
	If we were outputting the elements as they are read, return 0 as the value
	from inner levels (process_init_element ignores that),
	but return error_mark_node as the value from the outermost level
	(that's what we want to put in DECL_INITIAL).
	Otherwise, return a CONSTRUCTOR expression as the value. */

	struct c_expr
	pop_init_level (int implicit)
	{
	struct constructor_stack *p;
	struct c_expr ret;
	ret.value = 0;
	ret.original_code = ERROR_MARK;

	if (implicit == 0)
	{
	/* When we come to an explicit close brace,
	pop any inner levels that didn't have explicit braces. */
	while (constructor_stack->implicit)
	process_init_element (pop_init_level (1));

	gcc_assert (!constructor_range_stack);
	}

	/* Now output all pending elements. */
	constructor_incremental = 1;
	output_pending_init_elements (1);

	p = constructor_stack;

	/* Error for initializing a flexible array member, or a zero-length
	array member in an inappropriate context. */
	if (constructor_type && constructor_fields
	&& TREE_CODE (constructor_type) == ARRAY_TYPE
	&& TYPE_DOMAIN (constructor_type)
	&& !TYPE_MAX_VALUE (TYPE_DOMAIN (constructor_type)))
	{
	/* Silently discard empty initializations. The parser will
	already have pedwarned for empty brackets. */
	if (integer_zerop (constructor_unfilled_index))
	constructor_type = NULL_TREE;
	else
	{
	gcc_assert (!TYPE_SIZE (constructor_type));

	if (constructor_depth > 2)
	error_init ("initialization of flexible array member in a nested context");
	else if (pedantic)
	pedwarn_init ("initialization of a flexible array member");

	/* We have already issued an error message for the existence
	of a flexible array member not at the end of the structure.
	Discard the initializer so that we do not die later. */
	if (TREE_CHAIN (constructor_fields) != NULL_TREE)
	constructor_type = NULL_TREE;
	}
	}

	/* Warn when some struct elements are implicitly initialized to zero. */
	if (warn_missing_field_initializers
	&& constructor_type
	&& TREE_CODE (constructor_type) == RECORD_TYPE
	&& constructor_unfilled_fields)
	{
	/* Do not warn for flexible array members or zero-length arrays. */
	while (constructor_unfilled_fields
	&& (!DECL_SIZE (constructor_unfilled_fields)
	\|\| integer_zerop (DECL_SIZE (constructor_unfilled_fields))))
	constructor_unfilled_fields = TREE_CHAIN (constructor_unfilled_fields);

	/* Do not warn if this level of the initializer uses member
	designators; it is likely to be deliberate. */
	if (constructor_unfilled_fields && !constructor_designated)
	{
	push_member_name (constructor_unfilled_fields);
	warning_init ("missing initializer");
	RESTORE_SPELLING_DEPTH (constructor_depth);
	}
	}

	/* Pad out the end of the structure. */
	if (p->replacement_value.value)
	/* If this closes a superfluous brace pair,
	just pass out the element between them. */
	ret = p->replacement_value;
	else if (constructor_type == 0)
	;
	else if (TREE_CODE (constructor_type) != RECORD_TYPE
	&& TREE_CODE (constructor_type) != UNION_TYPE
	&& TREE_CODE (constructor_type) != ARRAY_TYPE
	&& TREE_CODE (constructor_type) != VECTOR_TYPE)
	{
	/* A nonincremental scalar initializer--just return
	the element, after verifying there is just one. */
	if (VEC_empty (constructor_elt,constructor_elements))
	{
	if (!constructor_erroneous)
	error_init ("empty scalar initializer");
	ret.value = error_mark_node;
	}
	else if (VEC_length (constructor_elt,constructor_elements) != 1)
	{
	error_init ("extra elements in scalar initializer");
	ret.value = VEC_index (constructor_elt,constructor_elements,0)->value;
	}
	else
	ret.value = VEC_index (constructor_elt,constructor_elements,0)->value;
	}
	else
	{
	if (constructor_erroneous)
	ret.value = error_mark_node;
	else
	{
	ret.value = build_constructor (constructor_type,
	constructor_elements);
	if (constructor_constant)
	TREE_CONSTANT (ret.value) = TREE_INVARIANT (ret.value) = 1;
	if (constructor_constant && constructor_simple)
	TREE_STATIC (ret.value) = 1;
	}
	}

	constructor_type = p->type;
	constructor_fields = p->fields;
	constructor_index = p->index;
	constructor_max_index = p->max_index;
	constructor_unfilled_index = p->unfilled_index;
	constructor_unfilled_fields = p->unfilled_fields;
	constructor_bit_index = p->bit_index;
	constructor_elements = p->elements;
	constructor_constant = p->constant;
	constructor_simple = p->simple;
	constructor_erroneous = p->erroneous;
	constructor_incremental = p->incremental;
	constructor_designated = p->designated;
	constructor_pending_elts = p->pending_elts;
	constructor_depth = p->depth;
	if (!p->implicit)
	constructor_range_stack = p->range_stack;
	RESTORE_SPELLING_DEPTH (constructor_depth);

	constructor_stack = p->next;
	free (p);

	if (ret.value == 0 && constructor_stack == 0)
	ret.value = error_mark_node;
	return ret;
	}

	/* Common handling for both array range and field name designators.
	ARRAY argument is nonzero for array ranges. Returns zero for success. */

	static int
	set_designator (int array)
	{
	tree subtype;
	enum tree_code subcode;

	/* Don't die if an entire brace-pair level is superfluous
	in the containing level. */
	if (constructor_type == 0)
	return 1;

	/* If there were errors in this designator list already, bail out
	silently. */
	if (designator_erroneous)
	return 1;

	if (!designator_depth)
	{
	gcc_assert (!constructor_range_stack);

	/* Designator list starts at the level of closest explicit
	braces. */
	while (constructor_stack->implicit)
	process_init_element (pop_init_level (1));
	constructor_designated = 1;
	return 0;
	}

	switch (TREE_CODE (constructor_type))
	{
	case RECORD_TYPE:
	case UNION_TYPE:
	subtype = TREE_TYPE (constructor_fields);
	if (subtype != error_mark_node)
	subtype = TYPE_MAIN_VARIANT (subtype);
	break;
	case ARRAY_TYPE:
	subtype = TYPE_MAIN_VARIANT (TREE_TYPE (constructor_type));
	break;
	default:
	gcc_unreachable ();
	}

	subcode = TREE_CODE (subtype);
	if (array && subcode != ARRAY_TYPE)
	{
	error_init ("array index in non-array initializer");
	return 1;
	}
	else if (!array && subcode != RECORD_TYPE && subcode != UNION_TYPE)
	{
	error_init ("field name not in record or union initializer");
	return 1;
	}

	constructor_designated = 1;
	push_init_level (2);
	return 0;
	}

	/* If there are range designators in designator list, push a new designator
	to constructor_range_stack. RANGE_END is end of such stack range or
	NULL_TREE if there is no range designator at this level. */

	static void
	push_range_stack (tree range_end)
	{
	struct constructor_range_stack *p;

	p = GGC_NEW (struct constructor_range_stack);
	p->prev = constructor_range_stack;
	p->next = 0;
	p->fields = constructor_fields;
	p->range_start = constructor_index;
	p->index = constructor_index;
	p->stack = constructor_stack;
	p->range_end = range_end;
	if (constructor_range_stack)
	constructor_range_stack->next = p;
	constructor_range_stack = p;
	}

	/* Within an array initializer, specify the next index to be initialized.
	FIRST is that index. If LAST is nonzero, then initialize a range
	of indices, running from FIRST through LAST. */

	void
	set_init_index (tree first, tree last)
	{
	if (set_designator (1))
	return;

	designator_erroneous = 1;

	if (!INTEGRAL_TYPE_P (TREE_TYPE (first))
	\|\| (last && !INTEGRAL_TYPE_P (TREE_TYPE (last))))
	{
	error_init ("array index in initializer not of integer type");
	return;
	}

	if (TREE_CODE (first) != INTEGER_CST)
	error_init ("nonconstant array index in initializer");
	else if (last != 0 && TREE_CODE (last) != INTEGER_CST)
	error_init ("nonconstant array index in initializer");
	else if (TREE_CODE (constructor_type) != ARRAY_TYPE)
	error_init ("array index in non-array initializer");
	else if (tree_int_cst_sgn (first) == -1)
	error_init ("array index in initializer exceeds array bounds");
	else if (constructor_max_index
	&& tree_int_cst_lt (constructor_max_index, first))
	error_init ("array index in initializer exceeds array bounds");
	else
	{
	constructor_index = convert (bitsizetype, first);

	if (last)
	{
	if (tree_int_cst_equal (first, last))
	last = 0;
	else if (tree_int_cst_lt (last, first))
	{
	error_init ("empty index range in initializer");
	last = 0;
	}
	else
	{
	last = convert (bitsizetype, last);
	if (constructor_max_index != 0
	&& tree_int_cst_lt (constructor_max_index, last))
	{
	error_init ("array index range in initializer exceeds array bounds");
	last = 0;
	}
	}
	}

	designator_depth++;
	designator_erroneous = 0;
	if (constructor_range_stack \|\| last)
	push_range_stack (last);
	}
	}

	/* Within a struct initializer, specify the next field to be initialized. */

	void
	set_init_label (tree fieldname)
	{
	tree tail;

	if (set_designator (0))
	return;

	designator_erroneous = 1;

	if (TREE_CODE (constructor_type) != RECORD_TYPE
	&& TREE_CODE (constructor_type) != UNION_TYPE)
	{
	error_init ("field name not in record or union initializer");
	return;
	}

	for (tail = TYPE_FIELDS (constructor_type); tail;
	tail = TREE_CHAIN (tail))
	{
	if (DECL_NAME (tail) == fieldname)
	break;
	}

	if (tail == 0)
	error ("unknown field %qE specified in initializer", fieldname);
	else
	{
	constructor_fields = tail;
	designator_depth++;
	designator_erroneous = 0;
	if (constructor_range_stack)
	push_range_stack (NULL_TREE);
	}
	}

	/* Add a new initializer to the tree of pending initializers. PURPOSE
	identifies the initializer, either array index or field in a structure.
	VALUE is the value of that index or field. */

	static void
	add_pending_init (tree purpose, tree value)
	{
	struct init_node p, q, r;

	q = &constructor_pending_elts;
	p = 0;

	if (TREE_CODE (constructor_type) == ARRAY_TYPE)
	{
	while (*q != 0)
	{
	p = *q;
	if (tree_int_cst_lt (purpose, p->purpose))
	q = &p->left;
	else if (tree_int_cst_lt (p->purpose, purpose))
	q = &p->right;
	else
	{
	if (TREE_SIDE_EFFECTS (p->value))
	warning_init ("initialized field with side-effects overwritten");
	else if (warn_override_init)
	warning_init ("initialized field overwritten");
	p->value = value;
	return;
	}
	}
	}
	else
	{
	tree bitpos;

	bitpos = bit_position (purpose);
	while (*q != NULL)
	{
	p = *q;
	if (tree_int_cst_lt (bitpos, bit_position (p->purpose)))
	q = &p->left;
	else if (p->purpose != purpose)
	q = &p->right;
	else
	{
	if (TREE_SIDE_EFFECTS (p->value))
	warning_init ("initialized field with side-effects overwritten");
	else if (warn_override_init)
	warning_init ("initialized field overwritten");
	p->value = value;
	return;
	}
	}
	}

	r = GGC_NEW (struct init_node);
	r->purpose = purpose;
	r->value = value;

	*q = r;
	r->parent = p;
	r->left = 0;
	r->right = 0;
	r->balance = 0;

	while (p)
	{
	struct init_node *s;

	if (r == p->left)
	{
	if (p->balance == 0)
	p->balance = -1;
	else if (p->balance < 0)
	{
	if (r->balance < 0)
	{
	/* L rotation. */
	p->left = r->right;
	if (p->left)
	p->left->parent = p;
	r->right = p;

	p->balance = 0;
	r->balance = 0;

	s = p->parent;
	p->parent = r;
	r->parent = s;
	if (s)
	{
	if (s->left == p)
	s->left = r;
	else
	s->right = r;
	}
	else
	constructor_pending_elts = r;
	}
	else
	{
	/* LR rotation. */
	struct init_node *t = r->right;

	r->right = t->left;
	if (r->right)
	r->right->parent = r;
	t->left = r;

	p->left = t->right;
	if (p->left)
	p->left->parent = p;
	t->right = p;

	p->balance = t->balance < 0;
	r->balance = -(t->balance > 0);
	t->balance = 0;

	s = p->parent;
	p->parent = t;
	r->parent = t;
	t->parent = s;
	if (s)
	{
	if (s->left == p)
	s->left = t;
	else
	s->right = t;
	}
	else
	constructor_pending_elts = t;
	}
	break;
	}
	else
	{
	/* p->balance == +1; growth of left side balances the node. */
	p->balance = 0;
	break;
	}
	}
	else /* r == p->right */
	{
	if (p->balance == 0)
	/* Growth propagation from right side. */
	p->balance++;
	else if (p->balance > 0)
	{
	if (r->balance > 0)
	{
	/* R rotation. */
	p->right = r->left;
	if (p->right)
	p->right->parent = p;
	r->left = p;

	p->balance = 0;
	r->balance = 0;

	s = p->parent;
	p->parent = r;
	r->parent = s;
	if (s)
	{
	if (s->left == p)
	s->left = r;
	else
	s->right = r;
	}
	else
	constructor_pending_elts = r;
	}
	else /* r->balance == -1 */
	{
	/* RL rotation */
	struct init_node *t = r->left;

	r->left = t->right;
	if (r->left)
	r->left->parent = r;
	t->right = r;

	p->right = t->left;
	if (p->right)
	p->right->parent = p;
	t->left = p;

	r->balance = (t->balance < 0);
	p->balance = -(t->balance > 0);
	t->balance = 0;

	s = p->parent;
	p->parent = t;
	r->parent = t;
	t->parent = s;
	if (s)
	{
	if (s->left == p)
	s->left = t;
	else
	s->right = t;
	}
	else
	constructor_pending_elts = t;
	}
	break;
	}
	else
	{
	/* p->balance == -1; growth of right side balances the node. */
	p->balance = 0;
	break;
	}
	}

	r = p;
	p = p->parent;
	}
	}

	/* Build AVL tree from a sorted chain. */

	static void
	set_nonincremental_init (void)
	{
	unsigned HOST_WIDE_INT ix;
	tree index, value;

	if (TREE_CODE (constructor_type) != RECORD_TYPE
	&& TREE_CODE (constructor_type) != ARRAY_TYPE)
	return;

	FOR_EACH_CONSTRUCTOR_ELT (constructor_elements, ix, index, value)
	add_pending_init (index, value);
	constructor_elements = 0;
	if (TREE_CODE (constructor_type) == RECORD_TYPE)
	{
	constructor_unfilled_fields = TYPE_FIELDS (constructor_type);
	/* Skip any nameless bit fields at the beginning. */
	while (constructor_unfilled_fields != 0
	&& DECL_C_BIT_FIELD (constructor_unfilled_fields)
	&& DECL_NAME (constructor_unfilled_fields) == 0)
	constructor_unfilled_fields = TREE_CHAIN (constructor_unfilled_fields);

	}
	else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
	{
	if (TYPE_DOMAIN (constructor_type))
	constructor_unfilled_index
	= convert (bitsizetype,
	TYPE_MIN_VALUE (TYPE_DOMAIN (constructor_type)));
	else
	constructor_unfilled_index = bitsize_zero_node;
	}
	constructor_incremental = 0;
	}

	/* Build AVL tree from a string constant. */

	static void
	set_nonincremental_init_from_string (tree str)
	{
	tree value, purpose, type;
	HOST_WIDE_INT val[2];
	const char p, end;
	int byte, wchar_bytes, charwidth, bitpos;

	gcc_assert (TREE_CODE (constructor_type) == ARRAY_TYPE);

	if (TYPE_PRECISION (TREE_TYPE (TREE_TYPE (str)))
	== TYPE_PRECISION (char_type_node))
	wchar_bytes = 1;
	else
	{
	gcc_assert (TYPE_PRECISION (TREE_TYPE (TREE_TYPE (str)))
	== TYPE_PRECISION (wchar_type_node));
	wchar_bytes = TYPE_PRECISION (wchar_type_node) / BITS_PER_UNIT;
	}
	charwidth = TYPE_PRECISION (char_type_node);
	type = TREE_TYPE (constructor_type);
	p = TREE_STRING_POINTER (str);
	end = p + TREE_STRING_LENGTH (str);

	for (purpose = bitsize_zero_node;
	p < end && !tree_int_cst_lt (constructor_max_index, purpose);
	purpose = size_binop (PLUS_EXPR, purpose, bitsize_one_node))
	{
	if (wchar_bytes == 1)
	{
	val[1] = (unsigned char) *p++;
	val[0] = 0;
	}
	else
	{
	val[0] = 0;
	val[1] = 0;
	for (byte = 0; byte < wchar_bytes; byte++)
	{
	if (BYTES_BIG_ENDIAN)
	bitpos = (wchar_bytes - byte - 1) * charwidth;
	else
	bitpos = byte * charwidth;
	val[bitpos < HOST_BITS_PER_WIDE_INT]
	\|= ((unsigned HOST_WIDE_INT) ((unsigned char) *p++))
	<< (bitpos % HOST_BITS_PER_WIDE_INT);
	}
	}

	if (!TYPE_UNSIGNED (type))
	{
	bitpos = ((wchar_bytes - 1) * charwidth) + HOST_BITS_PER_CHAR;
	if (bitpos < HOST_BITS_PER_WIDE_INT)
	{
	if (val[1] & (((HOST_WIDE_INT) 1) << (bitpos - 1)))
	{
	val[1] \|= ((HOST_WIDE_INT) -1) << bitpos;
	val[0] = -1;
	}
	}
	else if (bitpos == HOST_BITS_PER_WIDE_INT)
	{
	if (val[1] < 0)
	val[0] = -1;
	}
	else if (val[0] & (((HOST_WIDE_INT) 1)
	<< (bitpos - 1 - HOST_BITS_PER_WIDE_INT)))
	val[0] \|= ((HOST_WIDE_INT) -1)
	<< (bitpos - HOST_BITS_PER_WIDE_INT);
	}

	value = build_int_cst_wide (type, val[1], val[0]);
	add_pending_init (purpose, value);
	}

	constructor_incremental = 0;
	}

	/* Return value of FIELD in pending initializer or zero if the field was
	not initialized yet. */

	static tree
	find_init_member (tree field)
	{
	struct init_node *p;

	if (TREE_CODE (constructor_type) == ARRAY_TYPE)
	{
	if (constructor_incremental
	&& tree_int_cst_lt (field, constructor_unfilled_index))
	set_nonincremental_init ();

	p = constructor_pending_elts;
	while (p)
	{
	if (tree_int_cst_lt (field, p->purpose))
	p = p->left;
	else if (tree_int_cst_lt (p->purpose, field))
	p = p->right;
	else
	return p->value;
	}
	}
	else if (TREE_CODE (constructor_type) == RECORD_TYPE)
	{
	tree bitpos = bit_position (field);

	if (constructor_incremental
	&& (!constructor_unfilled_fields
	\|\| tree_int_cst_lt (bitpos,
	bit_position (constructor_unfilled_fields))))
	set_nonincremental_init ();

	p = constructor_pending_elts;
	while (p)
	{
	if (field == p->purpose)
	return p->value;
	else if (tree_int_cst_lt (bitpos, bit_position (p->purpose)))
	p = p->left;
	else
	p = p->right;
	}
	}
	else if (TREE_CODE (constructor_type) == UNION_TYPE)
	{
	if (!VEC_empty (constructor_elt, constructor_elements)
	&& (VEC_last (constructor_elt, constructor_elements)->index
	== field))
	return VEC_last (constructor_elt, constructor_elements)->value;
	}
	return 0;
	}

	/* "Output" the next constructor element.
	At top level, really output it to assembler code now.
	Otherwise, collect it in a list from which we will make a CONSTRUCTOR.
	TYPE is the data type that the containing data type wants here.
	FIELD is the field (a FIELD_DECL) or the index that this element fills.
	If VALUE is a string constant, STRICT_STRING is true if it is
	unparenthesized or we should not warn here for it being parenthesized.
	For other types of VALUE, STRICT_STRING is not used.

	PENDING if non-nil means output pending elements that belong
	right after this element. (PENDING is normally 1;
	it is 0 while outputting pending elements, to avoid recursion.) */

	static void
	output_init_element (tree value, bool strict_string, tree type, tree field,
	int pending)
	{
	constructor_elt *celt;

	if (type == error_mark_node \|\| value == error_mark_node)
	{
	constructor_erroneous = 1;
	return;
	}
	if (TREE_CODE (TREE_TYPE (value)) == ARRAY_TYPE
	&& (TREE_CODE (value) == STRING_CST
	\|\| TREE_CODE (value) == COMPOUND_LITERAL_EXPR)
	&& !(TREE_CODE (value) == STRING_CST
	&& TREE_CODE (type) == ARRAY_TYPE
	&& INTEGRAL_TYPE_P (TREE_TYPE (type)))
	&& !comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (value)),
	TYPE_MAIN_VARIANT (type)))
	value = array_to_pointer_conversion (value);

	if (TREE_CODE (value) == COMPOUND_LITERAL_EXPR
	&& require_constant_value && !flag_isoc99 && pending)
	{
	/* As an extension, allow initializing objects with static storage
	duration with compound literals (which are then treated just as
	the brace enclosed list they contain). */
	tree decl = COMPOUND_LITERAL_EXPR_DECL (value);
	value = DECL_INITIAL (decl);
	}

	if (value == error_mark_node)
	constructor_erroneous = 1;
	else if (!TREE_CONSTANT (value))
	constructor_constant = 0;
	else if (!initializer_constant_valid_p (value, TREE_TYPE (value))
	\|\| ((TREE_CODE (constructor_type) == RECORD_TYPE
	\|\| TREE_CODE (constructor_type) == UNION_TYPE)
	&& DECL_C_BIT_FIELD (field)
	&& TREE_CODE (value) != INTEGER_CST))
	constructor_simple = 0;

	if (!initializer_constant_valid_p (value, TREE_TYPE (value)))
	{
	if (require_constant_value)
	{
	error_init ("initializer element is not constant");
	value = error_mark_node;
	}
	else if (require_constant_elements)
	pedwarn ("initializer element is not computable at load time");
	}

	/* If this field is empty (and not at the end of structure),
	don't do anything other than checking the initializer. */
	if (field
	&& (TREE_TYPE (field) == error_mark_node
	\|\| (COMPLETE_TYPE_P (TREE_TYPE (field))
	&& integer_zerop (TYPE_SIZE (TREE_TYPE (field)))
	&& (TREE_CODE (constructor_type) == ARRAY_TYPE
	\|\| TREE_CHAIN (field)))))
	return;

	value = digest_init (type, value, strict_string, require_constant_value);
	if (value == error_mark_node)
	{
	constructor_erroneous = 1;
	return;
	}

	/* If this element doesn't come next in sequence,
	put it on constructor_pending_elts. */
	if (TREE_CODE (constructor_type) == ARRAY_TYPE
	&& (!constructor_incremental
	\|\| !tree_int_cst_equal (field, constructor_unfilled_index)))
	{
	if (constructor_incremental
	&& tree_int_cst_lt (field, constructor_unfilled_index))
	set_nonincremental_init ();

	add_pending_init (field, value);
	return;
	}
	else if (TREE_CODE (constructor_type) == RECORD_TYPE
	&& (!constructor_incremental
	\|\| field != constructor_unfilled_fields))
	{
	/* We do this for records but not for unions. In a union,
	no matter which field is specified, it can be initialized
	right away since it starts at the beginning of the union. */
	if (constructor_incremental)
	{
	if (!constructor_unfilled_fields)
	set_nonincremental_init ();
	else
	{
	tree bitpos, unfillpos;

	bitpos = bit_position (field);
	unfillpos = bit_position (constructor_unfilled_fields);

	if (tree_int_cst_lt (bitpos, unfillpos))
	set_nonincremental_init ();
	}
	}

	add_pending_init (field, value);
	return;
	}
	else if (TREE_CODE (constructor_type) == UNION_TYPE
	&& !VEC_empty (constructor_elt, constructor_elements))
	{
	if (TREE_SIDE_EFFECTS (VEC_last (constructor_elt,
	constructor_elements)->value))
	warning_init ("initialized field with side-effects overwritten");
	else if (warn_override_init)
	warning_init ("initialized field overwritten");

	/* We can have just one union field set. */
	constructor_elements = 0;
	}

	/* Otherwise, output this element either to
	constructor_elements or to the assembler file. */

	celt = VEC_safe_push (constructor_elt, gc, constructor_elements, NULL);
	celt->index = field;
	celt->value = value;

	/* Advance the variable that indicates sequential elements output. */
	if (TREE_CODE (constructor_type) == ARRAY_TYPE)
	constructor_unfilled_index
	= size_binop (PLUS_EXPR, constructor_unfilled_index,
	bitsize_one_node);
	else if (TREE_CODE (constructor_type) == RECORD_TYPE)
	{
	constructor_unfilled_fields
	= TREE_CHAIN (constructor_unfilled_fields);

	/* Skip any nameless bit fields. */
	while (constructor_unfilled_fields != 0
	&& DECL_C_BIT_FIELD (constructor_unfilled_fields)
	&& DECL_NAME (constructor_unfilled_fields) == 0)
	constructor_unfilled_fields =
	TREE_CHAIN (constructor_unfilled_fields);
	}
	else if (TREE_CODE (constructor_type) == UNION_TYPE)
	constructor_unfilled_fields = 0;

	/* Now output any pending elements which have become next. */
	if (pending)
	output_pending_init_elements (0);
	}

	/* Output any pending elements which have become next.
	As we output elements, constructor_unfilled_{fields,index}
	advances, which may cause other elements to become next;
	if so, they too are output.

	If ALL is 0, we return when there are
	no more pending elements to output now.

	If ALL is 1, we output space as necessary so that
	we can output all the pending elements. */

	static void
	output_pending_init_elements (int all)
	{
	struct init_node *elt = constructor_pending_elts;
	tree next;

	retry:

	/* Look through the whole pending tree.
	If we find an element that should be output now,
	output it. Otherwise, set NEXT to the element
	that comes first among those still pending. */

	next = 0;
	while (elt)
	{
	if (TREE_CODE (constructor_type) == ARRAY_TYPE)
	{
	if (tree_int_cst_equal (elt->purpose,
	constructor_unfilled_index))
	output_init_element (elt->value, true,
	TREE_TYPE (constructor_type),
	constructor_unfilled_index, 0);
	else if (tree_int_cst_lt (constructor_unfilled_index,
	elt->purpose))
	{
	/* Advance to the next smaller node. */
	if (elt->left)
	elt = elt->left;
	else
	{
	/* We have reached the smallest node bigger than the
	current unfilled index. Fill the space first. */
	next = elt->purpose;
	break;
	}
	}
	else
	{
	/* Advance to the next bigger node. */
	if (elt->right)
	elt = elt->right;
	else
	{
	/* We have reached the biggest node in a subtree. Find
	the parent of it, which is the next bigger node. */
	while (elt->parent && elt->parent->right == elt)
	elt = elt->parent;
	elt = elt->parent;
	if (elt && tree_int_cst_lt (constructor_unfilled_index,
	elt->purpose))
	{
	next = elt->purpose;
	break;
	}
	}
	}
	}
	else if (TREE_CODE (constructor_type) == RECORD_TYPE
	\|\| TREE_CODE (constructor_type) == UNION_TYPE)
	{
	tree ctor_unfilled_bitpos, elt_bitpos;

	/* If the current record is complete we are done. */
	if (constructor_unfilled_fields == 0)
	break;

	ctor_unfilled_bitpos = bit_position (constructor_unfilled_fields);
	elt_bitpos = bit_position (elt->purpose);
	/* We can't compare fields here because there might be empty
	fields in between. */
	if (tree_int_cst_equal (elt_bitpos, ctor_unfilled_bitpos))
	{
	constructor_unfilled_fields = elt->purpose;
	output_init_element (elt->value, true, TREE_TYPE (elt->purpose),
	elt->purpose, 0);
	}
	else if (tree_int_cst_lt (ctor_unfilled_bitpos, elt_bitpos))
	{
	/* Advance to the next smaller node. */
	if (elt->left)
	elt = elt->left;
	else
	{
	/* We have reached the smallest node bigger than the
	current unfilled field. Fill the space first. */
	next = elt->purpose;
	break;
	}
	}
	else
	{
	/* Advance to the next bigger node. */
	if (elt->right)
	elt = elt->right;
	else
	{
	/* We have reached the biggest node in a subtree. Find
	the parent of it, which is the next bigger node. */
	while (elt->parent && elt->parent->right == elt)
	elt = elt->parent;
	elt = elt->parent;
	if (elt
	&& (tree_int_cst_lt (ctor_unfilled_bitpos,
	bit_position (elt->purpose))))
	{
	next = elt->purpose;
	break;
	}
	}
	}
	}
	}

	/* Ordinarily return, but not if we want to output all
	and there are elements left. */
	if (!(all && next != 0))
	return;

	/* If it's not incremental, just skip over the gap, so that after
	jumping to retry we will output the next successive element. */
	if (TREE_CODE (constructor_type) == RECORD_TYPE
	\|\| TREE_CODE (constructor_type) == UNION_TYPE)
	constructor_unfilled_fields = next;
	else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
	constructor_unfilled_index = next;

	/* ELT now points to the node in the pending tree with the next
	initializer to output. */
	goto retry;
	}

	/* Add one non-braced element to the current constructor level.
	This adjusts the current position within the constructor's type.
	This may also start or terminate implicit levels
	to handle a partly-braced initializer.

	Once this has found the correct level for the new element,
	it calls output_init_element. */

	void
	process_init_element (struct c_expr value)
	{
	tree orig_value = value.value;
	int string_flag = orig_value != 0 && TREE_CODE (orig_value) == STRING_CST;
	bool strict_string = value.original_code == STRING_CST;

	designator_depth = 0;
	designator_erroneous = 0;

	/* Handle superfluous braces around string cst as in
	char x[] = {"foo"}; */
	if (string_flag
	&& constructor_type
	&& TREE_CODE (constructor_type) == ARRAY_TYPE
	&& INTEGRAL_TYPE_P (TREE_TYPE (constructor_type))
	&& integer_zerop (constructor_unfilled_index))
	{
	if (constructor_stack->replacement_value.value)
	error_init ("excess elements in char array initializer");
	constructor_stack->replacement_value = value;
	return;
	}

	if (constructor_stack->replacement_value.value != 0)
	{
	error_init ("excess elements in struct initializer");
	return;
	}

	/* Ignore elements of a brace group if it is entirely superfluous
	and has already been diagnosed. */
	if (constructor_type == 0)
	return;

	/* If we've exhausted any levels that didn't have braces,
	pop them now. */
	while (constructor_stack->implicit)
	{
	if ((TREE_CODE (constructor_type) == RECORD_TYPE
	\|\| TREE_CODE (constructor_type) == UNION_TYPE)
	&& constructor_fields == 0)
	process_init_element (pop_init_level (1));
	else if (TREE_CODE (constructor_type) == ARRAY_TYPE
	&& (constructor_max_index == 0
	\|\| tree_int_cst_lt (constructor_max_index,
	constructor_index)))
	process_init_element (pop_init_level (1));
	else
	break;
	}

	/* In the case of [LO ... HI] = VALUE, only evaluate VALUE once. */
	if (constructor_range_stack)
	{
	/* If value is a compound literal and we'll be just using its
	content, don't put it into a SAVE_EXPR. */
	if (TREE_CODE (value.value) != COMPOUND_LITERAL_EXPR
	\|\| !require_constant_value
	\|\| flag_isoc99)
	value.value = save_expr (value.value);
	}

	while (1)
	{
	if (TREE_CODE (constructor_type) == RECORD_TYPE)
	{
	tree fieldtype;
	enum tree_code fieldcode;

	if (constructor_fields == 0)
	{
	pedwarn_init ("excess elements in struct initializer");
	break;
	}

	fieldtype = TREE_TYPE (constructor_fields);
	if (fieldtype != error_mark_node)
	fieldtype = TYPE_MAIN_VARIANT (fieldtype);
	fieldcode = TREE_CODE (fieldtype);

	/* Error for non-static initialization of a flexible array member. */
	if (fieldcode == ARRAY_TYPE
	&& !require_constant_value
	&& TYPE_SIZE (fieldtype) == NULL_TREE
	&& TREE_CHAIN (constructor_fields) == NULL_TREE)
	{
	error_init ("non-static initialization of a flexible array member");
	break;
	}

	/* Accept a string constant to initialize a subarray. */
	if (value.value != 0
	&& fieldcode == ARRAY_TYPE
	&& INTEGRAL_TYPE_P (TREE_TYPE (fieldtype))
	&& string_flag)
	value.value = orig_value;
	/* Otherwise, if we have come to a subaggregate,
	and we don't have an element of its type, push into it. */
	else if (value.value != 0
	&& value.value != error_mark_node
	&& TYPE_MAIN_VARIANT (TREE_TYPE (value.value)) != fieldtype
	&& (fieldcode == RECORD_TYPE \|\| fieldcode == ARRAY_TYPE
	\|\| fieldcode == UNION_TYPE))
	{
	push_init_level (1);
	continue;
	}

	if (value.value)
	{
	push_member_name (constructor_fields);
	output_init_element (value.value, strict_string,
	fieldtype, constructor_fields, 1);
	RESTORE_SPELLING_DEPTH (constructor_depth);
	}
	else
	/* Do the bookkeeping for an element that was
	directly output as a constructor. */
	{
	/* For a record, keep track of end position of last field. */
	if (DECL_SIZE (constructor_fields))
	constructor_bit_index
	= size_binop (PLUS_EXPR,
	bit_position (constructor_fields),
	DECL_SIZE (constructor_fields));

	/* If the current field was the first one not yet written out,
	it isn't now, so update. */
	if (constructor_unfilled_fields == constructor_fields)
	{
	constructor_unfilled_fields = TREE_CHAIN (constructor_fields);
	/* Skip any nameless bit fields. */
	while (constructor_unfilled_fields != 0
	&& DECL_C_BIT_FIELD (constructor_unfilled_fields)
	&& DECL_NAME (constructor_unfilled_fields) == 0)
	constructor_unfilled_fields =
	TREE_CHAIN (constructor_unfilled_fields);
	}
	}

	constructor_fields = TREE_CHAIN (constructor_fields);
	/* Skip any nameless bit fields at the beginning. */
	while (constructor_fields != 0
	&& DECL_C_BIT_FIELD (constructor_fields)
	&& DECL_NAME (constructor_fields) == 0)
	constructor_fields = TREE_CHAIN (constructor_fields);
	}
	else if (TREE_CODE (constructor_type) == UNION_TYPE)
	{
	tree fieldtype;
	enum tree_code fieldcode;

	if (constructor_fields == 0)
	{
	pedwarn_init ("excess elements in union initializer");
	break;
	}

	fieldtype = TREE_TYPE (constructor_fields);
	if (fieldtype != error_mark_node)
	fieldtype = TYPE_MAIN_VARIANT (fieldtype);
	fieldcode = TREE_CODE (fieldtype);

	/* Warn that traditional C rejects initialization of unions.
	We skip the warning if the value is zero. This is done
	under the assumption that the zero initializer in user
	code appears conditioned on e.g. __STDC__ to avoid
	"missing initializer" warnings and relies on default
	initialization to zero in the traditional C case.
	We also skip the warning if the initializer is designated,
	again on the assumption that this must be conditional on
	__STDC__ anyway (and we've already complained about the
	member-designator already). */
	if (!in_system_header && !constructor_designated
	&& !(value.value && (integer_zerop (value.value)
	\|\| real_zerop (value.value))))
	warning (OPT_Wtraditional, "traditional C rejects initialization "
	"of unions");

	/* Accept a string constant to initialize a subarray. */
	if (value.value != 0
	&& fieldcode == ARRAY_TYPE
	&& INTEGRAL_TYPE_P (TREE_TYPE (fieldtype))
	&& string_flag)
	value.value = orig_value;
	/* Otherwise, if we have come to a subaggregate,
	and we don't have an element of its type, push into it. */
	else if (value.value != 0
	&& value.value != error_mark_node
	&& TYPE_MAIN_VARIANT (TREE_TYPE (value.value)) != fieldtype
	&& (fieldcode == RECORD_TYPE \|\| fieldcode == ARRAY_TYPE
	\|\| fieldcode == UNION_TYPE))
	{
	push_init_level (1);
	continue;
	}

	if (value.value)
	{
	push_member_name (constructor_fields);
	output_init_element (value.value, strict_string,
	fieldtype, constructor_fields, 1);
	RESTORE_SPELLING_DEPTH (constructor_depth);
	}
	else
	/* Do the bookkeeping for an element that was
	directly output as a constructor. */
	{
	constructor_bit_index = DECL_SIZE (constructor_fields);
	constructor_unfilled_fields = TREE_CHAIN (constructor_fields);
	}

	constructor_fields = 0;
	}
	else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
	{
	tree elttype = TYPE_MAIN_VARIANT (TREE_TYPE (constructor_type));
	enum tree_code eltcode = TREE_CODE (elttype);

	/* Accept a string constant to initialize a subarray. */
	if (value.value != 0
	&& eltcode == ARRAY_TYPE
	&& INTEGRAL_TYPE_P (TREE_TYPE (elttype))
	&& string_flag)
	value.value = orig_value;
	/* Otherwise, if we have come to a subaggregate,
	and we don't have an element of its type, push into it. */
	else if (value.value != 0
	&& value.value != error_mark_node
	&& TYPE_MAIN_VARIANT (TREE_TYPE (value.value)) != elttype
	&& (eltcode == RECORD_TYPE \|\| eltcode == ARRAY_TYPE
	\|\| eltcode == UNION_TYPE))
	{
	push_init_level (1);
	continue;
	}

	if (constructor_max_index != 0
	&& (tree_int_cst_lt (constructor_max_index, constructor_index)
	\|\| integer_all_onesp (constructor_max_index)))
	{
	pedwarn_init ("excess elements in array initializer");
	break;
	}

	/* Now output the actual element. */
	if (value.value)
	{
	push_array_bounds (tree_low_cst (constructor_index, 1));
	output_init_element (value.value, strict_string,
	elttype, constructor_index, 1);
	RESTORE_SPELLING_DEPTH (constructor_depth);
	}

	constructor_index
	= size_binop (PLUS_EXPR, constructor_index, bitsize_one_node);

	if (!value.value)
	/* If we are doing the bookkeeping for an element that was
	directly output as a constructor, we must update
	constructor_unfilled_index. */
	constructor_unfilled_index = constructor_index;
	}
	else if (TREE_CODE (constructor_type) == VECTOR_TYPE)
	{
	tree elttype = TYPE_MAIN_VARIANT (TREE_TYPE (constructor_type));

	/* Do a basic check of initializer size. Note that vectors
	always have a fixed size derived from their type. */
	if (tree_int_cst_lt (constructor_max_index, constructor_index))
	{
	pedwarn_init ("excess elements in vector initializer");
	break;
	}

	/* Now output the actual element. */
	if (value.value)
	output_init_element (value.value, strict_string,
	elttype, constructor_index, 1);

	constructor_index
	= size_binop (PLUS_EXPR, constructor_index, bitsize_one_node);

	if (!value.value)
	/* If we are doing the bookkeeping for an element that was
	directly output as a constructor, we must update
	constructor_unfilled_index. */
	constructor_unfilled_index = constructor_index;
	}

	/* Handle the sole element allowed in a braced initializer
	for a scalar variable. */
	else if (constructor_type != error_mark_node
	&& constructor_fields == 0)
	{
	pedwarn_init ("excess elements in scalar initializer");
	break;
	}
	else
	{
	if (value.value)
	output_init_element (value.value, strict_string,
	constructor_type, NULL_TREE, 1);
	constructor_fields = 0;
	}

	/* Handle range initializers either at this level or anywhere higher
	in the designator stack. */
	if (constructor_range_stack)
	{
	struct constructor_range_stack p, range_stack;
	int finish = 0;

	range_stack = constructor_range_stack;
	constructor_range_stack = 0;
	while (constructor_stack != range_stack->stack)
	{
	gcc_assert (constructor_stack->implicit);
	process_init_element (pop_init_level (1));
	}
	for (p = range_stack;
	!p->range_end \|\| tree_int_cst_equal (p->index, p->range_end);
	p = p->prev)
	{
	gcc_assert (constructor_stack->implicit);
	process_init_element (pop_init_level (1));
	}

	p->index = size_binop (PLUS_EXPR, p->index, bitsize_one_node);
	if (tree_int_cst_equal (p->index, p->range_end) && !p->prev)
	finish = 1;

	while (1)
	{
	constructor_index = p->index;
	constructor_fields = p->fields;
	if (finish && p->range_end && p->index == p->range_start)
	{
	finish = 0;
	p->prev = 0;
	}
	p = p->next;
	if (!p)
	break;
	push_init_level (2);
	p->stack = constructor_stack;
	if (p->range_end && tree_int_cst_equal (p->index, p->range_end))
	p->index = p->range_start;
	}

	if (!finish)
	constructor_range_stack = range_stack;
	continue;
	}

	break;
	}

	constructor_range_stack = 0;
	}

	/* Build a complete asm-statement, whose components are a CV_QUALIFIER
	(guaranteed to be 'volatile' or null) and ARGS (represented using
	an ASM_EXPR node). */
	tree
	build_asm_stmt (tree cv_qualifier, tree args)
	{
	if (!ASM_VOLATILE_P (args) && cv_qualifier)
	ASM_VOLATILE_P (args) = 1;
	return add_stmt (args);
	}

	/* Build an asm-expr, whose components are a STRING, some OUTPUTS,
	some INPUTS, and some CLOBBERS. The latter three may be NULL.
	SIMPLE indicates whether there was anything at all after the
	string in the asm expression -- asm("blah") and asm("blah" : )
	are subtly different. We use a ASM_EXPR node to represent this. */
	tree
	build_asm_expr (tree string, tree outputs, tree inputs, tree clobbers,
	bool simple)
	{
	tree tail;
	tree args;
	int i;
	const char *constraint;
	const char **oconstraints;
	bool allows_mem, allows_reg, is_inout;
	int ninputs, noutputs;

	ninputs = list_length (inputs);
	noutputs = list_length (outputs);
	oconstraints = (const char *) alloca (noutputs sizeof (const char *));

	string = resolve_asm_operand_names (string, outputs, inputs);

	/* Remove output conversions that change the type but not the mode. */
	for (i = 0, tail = outputs; tail; ++i, tail = TREE_CHAIN (tail))
	{
	tree output = TREE_VALUE (tail);

	/* ??? Really, this should not be here. Users should be using a
	proper lvalue, dammit. But there's a long history of using casts
	in the output operands. In cases like longlong.h, this becomes a
	primitive form of typechecking -- if the cast can be removed, then
	the output operand had a type of the proper width; otherwise we'll
	get an error. Gross, but ... */
	STRIP_NOPS (output);

	if (!lvalue_or_else (output, lv_asm))
	output = error_mark_node;

	if (output != error_mark_node
	&& (TREE_READONLY (output)
	\|\| TYPE_READONLY (TREE_TYPE (output))
	\|\| ((TREE_CODE (TREE_TYPE (output)) == RECORD_TYPE
	\|\| TREE_CODE (TREE_TYPE (output)) == UNION_TYPE)
	&& C_TYPE_FIELDS_READONLY (TREE_TYPE (output)))))
	readonly_error (output, lv_asm);

	constraint = TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (tail)));
	oconstraints[i] = constraint;

	if (parse_output_constraint (&constraint, i, ninputs, noutputs,
	&allows_mem, &allows_reg, &is_inout))
	{
	/* If the operand is going to end up in memory,
	mark it addressable. */
	if (!allows_reg && !c_mark_addressable (output))
	output = error_mark_node;
	}
	else
	output = error_mark_node;

	TREE_VALUE (tail) = output;
	}

	for (i = 0, tail = inputs; tail; ++i, tail = TREE_CHAIN (tail))
	{
	tree input;

	constraint = TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (tail)));
	input = TREE_VALUE (tail);

	if (parse_input_constraint (&constraint, i, ninputs, noutputs, 0,
	oconstraints, &allows_mem, &allows_reg))
	{
	/* If the operand is going to end up in memory,
	mark it addressable. */
	if (!allows_reg && allows_mem)
	{
	/* Strip the nops as we allow this case. FIXME, this really
	should be rejected or made deprecated. */
	STRIP_NOPS (input);
	if (!c_mark_addressable (input))
	input = error_mark_node;
	}
	}
	else
	input = error_mark_node;

	TREE_VALUE (tail) = input;
	}

	args = build_stmt (ASM_EXPR, string, outputs, inputs, clobbers);

	/* asm statements without outputs, including simple ones, are treated
	as volatile. */
	ASM_INPUT_P (args) = simple;
	ASM_VOLATILE_P (args) = (noutputs == 0);

	return args;
	}

	/* Generate a goto statement to LABEL. */

	tree
	c_finish_goto_label (tree label)
	{
	tree decl = lookup_label (label);
	if (!decl)
	return NULL_TREE;

	if (C_DECL_UNJUMPABLE_STMT_EXPR (decl))
	{
	error ("jump into statement expression");
	return NULL_TREE;
	}

	if (C_DECL_UNJUMPABLE_VM (decl))
	{
	error ("jump into scope of identifier with variably modified type");
	return NULL_TREE;
	}

	if (!C_DECL_UNDEFINABLE_STMT_EXPR (decl))
	{
	/* No jump from outside this statement expression context, so
	record that there is a jump from within this context. */
	struct c_label_list *nlist;
	nlist = XOBNEW (&parser_obstack, struct c_label_list);
	nlist->next = label_context_stack_se->labels_used;
	nlist->label = decl;
	label_context_stack_se->labels_used = nlist;
	}

	if (!C_DECL_UNDEFINABLE_VM (decl))
	{
	/* No jump from outside this context context of identifiers with
	variably modified type, so record that there is a jump from
	within this context. */
	struct c_label_list *nlist;
	nlist = XOBNEW (&parser_obstack, struct c_label_list);
	nlist->next = label_context_stack_vm->labels_used;
	nlist->label = decl;
	label_context_stack_vm->labels_used = nlist;
	}

	TREE_USED (decl) = 1;
	return add_stmt (build1 (GOTO_EXPR, void_type_node, decl));
	}

	/* Generate a computed goto statement to EXPR. */

	tree
	c_finish_goto_ptr (tree expr)
	{
	if (pedantic)
	pedwarn ("ISO C forbids %<goto *expr;%>");
	expr = convert (ptr_type_node, expr);
	return add_stmt (build1 (GOTO_EXPR, void_type_node, expr));
	}

	/* Generate a C `return' statement. RETVAL is the expression for what
	to return, or a null pointer for `return;' with no value. */

	tree
	c_finish_return (tree retval)
	{
	tree valtype = TREE_TYPE (TREE_TYPE (current_function_decl)), ret_stmt;
	bool no_warning = false;

	if (TREE_THIS_VOLATILE (current_function_decl))
	warning (0, "function declared %<noreturn%> has a %<return%> statement");

	if (!retval)
	{
	current_function_returns_null = 1;
	if ((warn_return_type \|\| flag_isoc99)
	&& valtype != 0 && TREE_CODE (valtype) != VOID_TYPE)
	{
	pedwarn_c99 ("%<return%> with no value, in "
	"function returning non-void");
	no_warning = true;
	}
	}
	else if (valtype == 0 \|\| TREE_CODE (valtype) == VOID_TYPE)
	{
	current_function_returns_null = 1;
	if (pedantic \|\| TREE_CODE (TREE_TYPE (retval)) != VOID_TYPE)
	pedwarn ("%<return%> with a value, in function returning void");
	}
	else
	{
	tree t = convert_for_assignment (valtype, retval, ic_return,
	NULL_TREE, NULL_TREE, 0);
	tree res = DECL_RESULT (current_function_decl);
	tree inner;

	current_function_returns_value = 1;
	if (t == error_mark_node)
	return NULL_TREE;

	inner = t = convert (TREE_TYPE (res), t);

	/* Strip any conversions, additions, and subtractions, and see if
	we are returning the address of a local variable. Warn if so. */
	while (1)
	{
	switch (TREE_CODE (inner))
	{
	case NOP_EXPR: case NON_LVALUE_EXPR: case CONVERT_EXPR:
	case PLUS_EXPR:
	inner = TREE_OPERAND (inner, 0);
	continue;

	case MINUS_EXPR:
	/* If the second operand of the MINUS_EXPR has a pointer
	type (or is converted from it), this may be valid, so
	don't give a warning. */
	{
	tree op1 = TREE_OPERAND (inner, 1);

	while (!POINTER_TYPE_P (TREE_TYPE (op1))
	&& (TREE_CODE (op1) == NOP_EXPR
	\|\| TREE_CODE (op1) == NON_LVALUE_EXPR
	\|\| TREE_CODE (op1) == CONVERT_EXPR))
	op1 = TREE_OPERAND (op1, 0);

	if (POINTER_TYPE_P (TREE_TYPE (op1)))
	break;

	inner = TREE_OPERAND (inner, 0);
	continue;
	}

	case ADDR_EXPR:
	inner = TREE_OPERAND (inner, 0);

	while (REFERENCE_CLASS_P (inner)
	&& TREE_CODE (inner) != INDIRECT_REF)
	inner = TREE_OPERAND (inner, 0);

	if (DECL_P (inner)
	&& !DECL_EXTERNAL (inner)
	&& !TREE_STATIC (inner)
	&& DECL_CONTEXT (inner) == current_function_decl)
	warning (0, "function returns address of local variable");
	break;

	default:
	break;
	}

	break;
	}

	retval = build2 (MODIFY_EXPR, TREE_TYPE (res), res, t);
	}

	ret_stmt = build_stmt (RETURN_EXPR, retval);
	TREE_NO_WARNING (ret_stmt) \|= no_warning;
	return add_stmt (ret_stmt);
	}

	struct c_switch {
	/* The SWITCH_EXPR being built. */
	tree switch_expr;

	/* The original type of the testing expression, i.e. before the
	default conversion is applied. */
	tree orig_type;

	/* A splay-tree mapping the low element of a case range to the high
	element, or NULL_TREE if there is no high element. Used to
	determine whether or not a new case label duplicates an old case
	label. We need a tree, rather than simply a hash table, because
	of the GNU case range extension. */
	splay_tree cases;

	/* Number of nested statement expressions within this switch
	statement; if nonzero, case and default labels may not
	appear. */
	unsigned int blocked_stmt_expr;

	/* Scope of outermost declarations of identifiers with variably
	modified type within this switch statement; if nonzero, case and
	default labels may not appear. */
	unsigned int blocked_vm;

	/* The next node on the stack. */
	struct c_switch *next;
	};

	/* A stack of the currently active switch statements. The innermost
	switch statement is on the top of the stack. There is no need to
	mark the stack for garbage collection because it is only active
	during the processing of the body of a function, and we never
	collect at that point. */

	struct c_switch *c_switch_stack;

	/* Start a C switch statement, testing expression EXP. Return the new
	SWITCH_EXPR. */

	tree
	c_start_case (tree exp)
	{
	tree orig_type = error_mark_node;
	struct c_switch *cs;

	if (exp != error_mark_node)
	{
	orig_type = TREE_TYPE (exp);

	if (!INTEGRAL_TYPE_P (orig_type))
	{
	if (orig_type != error_mark_node)
	{
	error ("switch quantity not an integer");
	orig_type = error_mark_node;
	}
	exp = integer_zero_node;
	}
	else
	{
	tree type = TYPE_MAIN_VARIANT (orig_type);

	if (!in_system_header
	&& (type == long_integer_type_node
	\|\| type == long_unsigned_type_node))
	warning (OPT_Wtraditional, "%<long%> switch expression not "
	"converted to %<int%> in ISO C");

	exp = default_conversion (exp);
	}
	}

	/* Add this new SWITCH_EXPR to the stack. */
	cs = XNEW (struct c_switch);
	cs->switch_expr = build3 (SWITCH_EXPR, orig_type, exp, NULL_TREE, NULL_TREE);
	cs->orig_type = orig_type;
	cs->cases = splay_tree_new (case_compare, NULL, NULL);
	cs->blocked_stmt_expr = 0;
	cs->blocked_vm = 0;
	cs->next = c_switch_stack;
	c_switch_stack = cs;

	return add_stmt (cs->switch_expr);
	}

	/* Process a case label. */

	tree
	do_case (tree low_value, tree high_value)
	{
	tree label = NULL_TREE;

	if (c_switch_stack && !c_switch_stack->blocked_stmt_expr
	&& !c_switch_stack->blocked_vm)
	{
	label = c_add_case_label (c_switch_stack->cases,
	SWITCH_COND (c_switch_stack->switch_expr),
	c_switch_stack->orig_type,
	low_value, high_value);
	if (label == error_mark_node)
	label = NULL_TREE;
	}
	else if (c_switch_stack && c_switch_stack->blocked_stmt_expr)
	{
	if (low_value)
	error ("case label in statement expression not containing "
	"enclosing switch statement");
	else
	error ("%<default%> label in statement expression not containing "
	"enclosing switch statement");
	}
	else if (c_switch_stack && c_switch_stack->blocked_vm)
	{
	if (low_value)
	error ("case label in scope of identifier with variably modified "
	"type not containing enclosing switch statement");
	else
	error ("%<default%> label in scope of identifier with variably "
	"modified type not containing enclosing switch statement");
	}
	else if (low_value)
	error ("case label not within a switch statement");
	else
	error ("%<default%> label not within a switch statement");

	return label;
	}

	/* Finish the switch statement. */

	void
	c_finish_case (tree body)
	{
	struct c_switch *cs = c_switch_stack;
	location_t switch_location;

	SWITCH_BODY (cs->switch_expr) = body;

	/* We must not be within a statement expression nested in the switch
	at this point; we might, however, be within the scope of an
	identifier with variably modified type nested in the switch. */
	gcc_assert (!cs->blocked_stmt_expr);

	/* Emit warnings as needed. */
	if (EXPR_HAS_LOCATION (cs->switch_expr))
	switch_location = EXPR_LOCATION (cs->switch_expr);
	else
	switch_location = input_location;
	c_do_switch_warnings (cs->cases, switch_location,
	TREE_TYPE (cs->switch_expr),
	SWITCH_COND (cs->switch_expr));

	/* Pop the stack. */
	c_switch_stack = cs->next;
	splay_tree_delete (cs->cases);
	XDELETE (cs);
	}

	/* Emit an if statement. IF_LOCUS is the location of the 'if'. COND,
	THEN_BLOCK and ELSE_BLOCK are expressions to be used; ELSE_BLOCK
	may be null. NESTED_IF is true if THEN_BLOCK contains another IF
	statement, and was not surrounded with parenthesis. */

	void
	c_finish_if_stmt (location_t if_locus, tree cond, tree then_block,
	tree else_block, bool nested_if)
	{
	tree stmt;

	/* Diagnose an ambiguous else if if-then-else is nested inside if-then. */
	if (warn_parentheses && nested_if && else_block == NULL)
	{
	tree inner_if = then_block;

	/* We know from the grammar productions that there is an IF nested
	within THEN_BLOCK. Due to labels and c99 conditional declarations,
	it might not be exactly THEN_BLOCK, but should be the last
	non-container statement within. */
	while (1)
	switch (TREE_CODE (inner_if))
	{
	case COND_EXPR:
	goto found;
	case BIND_EXPR:
	inner_if = BIND_EXPR_BODY (inner_if);
	break;
	case STATEMENT_LIST:
	inner_if = expr_last (then_block);
	break;
	case TRY_FINALLY_EXPR:
	case TRY_CATCH_EXPR:
	inner_if = TREE_OPERAND (inner_if, 0);
	break;
	default:
	gcc_unreachable ();
	}
	found:

	if (COND_EXPR_ELSE (inner_if))
	warning (OPT_Wparentheses,
	"%Hsuggest explicit braces to avoid ambiguous %<else%>",
	&if_locus);
	}

	empty_body_warning (then_block, else_block);

	stmt = build3 (COND_EXPR, void_type_node, cond, then_block, else_block);
	SET_EXPR_LOCATION (stmt, if_locus);
	add_stmt (stmt);
	}

	-/* Emit a general-purpose loop construct. START_LOCUS is the location of
	- the beginning of the loop. COND is the loop condition. COND_IS_FIRST
	- is false for DO loops. INCR is the FOR increment expression. BODY is
	- the statement controlled by the loop. BLAB is the break label. CLAB is
	- the continue label. Everything is allowed to be NULL. */
	-
	+/* APPLE LOCAL begin for-fsf-4_4 3274130 5295549 */ \
	+/* Emit a general-purpose loop construct. START_LOCUS is the location
	+ of the beginning of the loop. COND is the loop condition.
	+ COND_IS_FIRST is false for DO loops. INCR is the FOR increment
	+ expression. BODY is the statement controlled by the loop. BLAB is
	+ the break label. CLAB is the continue label. ATTRS is the
	+ attributes associated with the loop, which at present are
	+ associated with the topmost label. Everything is allowed to be
	+ NULL. */
	+
	+/* APPLE LOCAL end for-fsf-4_4 3274130 5295549 */ \
	void
	c_finish_loop (location_t start_locus, tree cond, tree incr, tree body,
	- tree blab, tree clab, bool cond_is_first)
	+/* APPLE LOCAL begin for-fsf-4_4 3274130 5295549 */ \
	+ tree blab, tree clab, tree attrs, bool cond_is_first)
	+/* APPLE LOCAL end for-fsf-4_4 3274130 5295549 */ \
	{
	tree entry = NULL, exit = NULL, t;

	/* If the condition is zero don't generate a loop construct. */
	if (cond && integer_zerop (cond))
	{
	if (cond_is_first)
	{
	t = build_and_jump (&blab);
	SET_EXPR_LOCATION (t, start_locus);
	add_stmt (t);
	}
	}
	else
	{
	tree top = build1 (LABEL_EXPR, void_type_node, NULL_TREE);

	/* If we have an exit condition, then we build an IF with gotos either
	out of the loop, or to the top of it. If there's no exit condition,
	then we just build a jump back to the top. */
	exit = build_and_jump (&LABEL_EXPR_LABEL (top));

	if (cond && !integer_nonzerop (cond))
	{
	/* Canonicalize the loop condition to the end. This means
	generating a branch to the loop condition. Reuse the
	continue label, if possible. */
	if (cond_is_first)
	{
	if (incr \|\| !clab)
	{
	entry = build1 (LABEL_EXPR, void_type_node, NULL_TREE);
	t = build_and_jump (&LABEL_EXPR_LABEL (entry));
	}
	else
	t = build1 (GOTO_EXPR, void_type_node, clab);
	SET_EXPR_LOCATION (t, start_locus);
	add_stmt (t);
	}

	t = build_and_jump (&blab);
	exit = fold_build3 (COND_EXPR, void_type_node, cond, exit, t);
	if (cond_is_first)
	SET_EXPR_LOCATION (exit, start_locus);
	else
	SET_EXPR_LOCATION (exit, input_location);
	}

	add_stmt (top);
	}

	if (body)
	add_stmt (body);
	if (clab)
	add_stmt (build1 (LABEL_EXPR, void_type_node, clab));
	if (incr)
	add_stmt (incr);
	if (entry)
	add_stmt (entry);
	if (exit)
	add_stmt (exit);
	if (blab)
	add_stmt (build1 (LABEL_EXPR, void_type_node, blab));
	}

	tree
	c_finish_bc_stmt (tree *label_p, bool is_break)
	{
	bool skip;
	tree label = *label_p;

	/* In switch statements break is sometimes stylistically used after
	a return statement. This can lead to spurious warnings about
	control reaching the end of a non-void function when it is
	inlined. Note that we are calling block_may_fallthru with
	language specific tree nodes; this works because
	block_may_fallthru returns true when given something it does not
	understand. */
	skip = !block_may_fallthru (cur_stmt_list);

	if (!label)
	{
	if (!skip)
	*label_p = label = create_artificial_label ();
	}
	else if (TREE_CODE (label) == LABEL_DECL)
	;
	else switch (TREE_INT_CST_LOW (label))
	{
	case 0:
	if (is_break)
	error ("break statement not within loop or switch");
	else
	error ("continue statement not within a loop");
	return NULL_TREE;

	case 1:
	gcc_assert (is_break);
	error ("break statement used with OpenMP for loop");
	return NULL_TREE;

	default:
	gcc_unreachable ();
	}

	if (skip)
	return NULL_TREE;

	return add_stmt (build1 (GOTO_EXPR, void_type_node, label));
	}

	/* A helper routine for c_process_expr_stmt and c_finish_stmt_expr. */

	static void
	emit_side_effect_warnings (tree expr)
	{
	if (expr == error_mark_node)
	;
	else if (!TREE_SIDE_EFFECTS (expr))
	{
	if (!VOID_TYPE_P (TREE_TYPE (expr)) && !TREE_NO_WARNING (expr))
	warning (0, "%Hstatement with no effect",
	EXPR_HAS_LOCATION (expr) ? EXPR_LOCUS (expr) : &input_location);
	}
	else if (warn_unused_value)
	warn_if_unused_value (expr, input_location);
	}

	/* Process an expression as if it were a complete statement. Emit
	diagnostics, but do not call ADD_STMT. */

	tree
	c_process_expr_stmt (tree expr)
	{
	if (!expr)
	return NULL_TREE;

	if (warn_sequence_point)
	verify_sequence_points (expr);

	if (TREE_TYPE (expr) != error_mark_node
	&& !COMPLETE_OR_VOID_TYPE_P (TREE_TYPE (expr))
	&& TREE_CODE (TREE_TYPE (expr)) != ARRAY_TYPE)
	error ("expression statement has incomplete type");

	/* If we're not processing a statement expression, warn about unused values.
	Warnings for statement expressions will be emitted later, once we figure
	out which is the result. */
	if (!STATEMENT_LIST_STMT_EXPR (cur_stmt_list)
	&& (extra_warnings \|\| warn_unused_value))
	emit_side_effect_warnings (expr);

	/* If the expression is not of a type to which we cannot assign a line
	number, wrap the thing in a no-op NOP_EXPR. */
	if (DECL_P (expr) \|\| CONSTANT_CLASS_P (expr))
	expr = build1 (NOP_EXPR, TREE_TYPE (expr), expr);

	if (EXPR_P (expr))
	SET_EXPR_LOCATION (expr, input_location);

	return expr;
	}

	/* Emit an expression as a statement. */

	tree
	c_finish_expr_stmt (tree expr)
	{
	if (expr)
	return add_stmt (c_process_expr_stmt (expr));
	else
	return NULL;
	}

	/* Do the opposite and emit a statement as an expression. To begin,
	create a new binding level and return it. */

	tree
	c_begin_stmt_expr (void)
	{
	tree ret;
	struct c_label_context_se *nstack;
	struct c_label_list *glist;

	/* We must force a BLOCK for this level so that, if it is not expanded
	later, there is a way to turn off the entire subtree of blocks that
	are contained in it. */
	keep_next_level ();
	ret = c_begin_compound_stmt (true);
	if (c_switch_stack)
	{
	c_switch_stack->blocked_stmt_expr++;
	gcc_assert (c_switch_stack->blocked_stmt_expr != 0);
	}
	for (glist = label_context_stack_se->labels_used;
	glist != NULL;
	glist = glist->next)
	{
	C_DECL_UNDEFINABLE_STMT_EXPR (glist->label) = 1;
	}
	nstack = XOBNEW (&parser_obstack, struct c_label_context_se);
	nstack->labels_def = NULL;
	nstack->labels_used = NULL;
	nstack->next = label_context_stack_se;
	label_context_stack_se = nstack;

	/* Mark the current statement list as belonging to a statement list. */
	STATEMENT_LIST_STMT_EXPR (ret) = 1;

	return ret;
	}

	tree
	c_finish_stmt_expr (tree body)
	{
	tree last, type, tmp, val;
	tree *last_p;
	struct c_label_list dlist, glist, *glist_prev = NULL;

	body = c_end_compound_stmt (body, true);
	if (c_switch_stack)
	{
	gcc_assert (c_switch_stack->blocked_stmt_expr != 0);
	c_switch_stack->blocked_stmt_expr--;
	}
	/* It is no longer possible to jump to labels defined within this
	statement expression. */
	for (dlist = label_context_stack_se->labels_def;
	dlist != NULL;
	dlist = dlist->next)
	{
	C_DECL_UNJUMPABLE_STMT_EXPR (dlist->label) = 1;
	}
	/* It is again possible to define labels with a goto just outside
	this statement expression. */
	for (glist = label_context_stack_se->next->labels_used;
	glist != NULL;
	glist = glist->next)
	{
	C_DECL_UNDEFINABLE_STMT_EXPR (glist->label) = 0;
	glist_prev = glist;
	}
	if (glist_prev != NULL)
	glist_prev->next = label_context_stack_se->labels_used;
	else
	label_context_stack_se->next->labels_used
	= label_context_stack_se->labels_used;
	label_context_stack_se = label_context_stack_se->next;

	/* Locate the last statement in BODY. See c_end_compound_stmt
	about always returning a BIND_EXPR. */
	last_p = &BIND_EXPR_BODY (body);
	last = BIND_EXPR_BODY (body);

	continue_searching:
	if (TREE_CODE (last) == STATEMENT_LIST)
	{
	tree_stmt_iterator i;

	/* This can happen with degenerate cases like ({ }). No value. */
	if (!TREE_SIDE_EFFECTS (last))
	return body;

	/* If we're supposed to generate side effects warnings, process
	all of the statements except the last. */
	if (extra_warnings \|\| warn_unused_value)
	{
	for (i = tsi_start (last); !tsi_one_before_end_p (i); tsi_next (&i))
	emit_side_effect_warnings (tsi_stmt (i));
	}
	else
	i = tsi_last (last);
	last_p = tsi_stmt_ptr (i);
	last = *last_p;
	}

	/* If the end of the list is exception related, then the list was split
	by a call to push_cleanup. Continue searching. */
	if (TREE_CODE (last) == TRY_FINALLY_EXPR
	\|\| TREE_CODE (last) == TRY_CATCH_EXPR)
	{
	last_p = &TREE_OPERAND (last, 0);
	last = *last_p;
	goto continue_searching;
	}

	/* In the case that the BIND_EXPR is not necessary, return the
	expression out from inside it. */
	if (last == error_mark_node
	\|\| (last == BIND_EXPR_BODY (body)
	&& BIND_EXPR_VARS (body) == NULL))
	{
	/* Do not warn if the return value of a statement expression is
	unused. */
	if (EXPR_P (last))
	TREE_NO_WARNING (last) = 1;
	return last;
	}

	/* Extract the type of said expression. */
	type = TREE_TYPE (last);

	/* If we're not returning a value at all, then the BIND_EXPR that
	we already have is a fine expression to return. */
	if (!type \|\| VOID_TYPE_P (type))
	return body;

	/* Now that we've located the expression containing the value, it seems
	silly to make voidify_wrapper_expr repeat the process. Create a
	temporary of the appropriate type and stick it in a TARGET_EXPR. */
	tmp = create_tmp_var_raw (type, NULL);

	/* Unwrap a no-op NOP_EXPR as added by c_finish_expr_stmt. This avoids
	tree_expr_nonnegative_p giving up immediately. */
	val = last;
	if (TREE_CODE (val) == NOP_EXPR
	&& TREE_TYPE (val) == TREE_TYPE (TREE_OPERAND (val, 0)))
	val = TREE_OPERAND (val, 0);

	*last_p = build2 (MODIFY_EXPR, void_type_node, tmp, val);
	SET_EXPR_LOCUS (*last_p, EXPR_LOCUS (last));

	return build4 (TARGET_EXPR, type, tmp, body, NULL_TREE, NULL_TREE);
	}

	/* Begin the scope of an identifier of variably modified type, scope
	number SCOPE. Jumping from outside this scope to inside it is not
	permitted. */

	void
	c_begin_vm_scope (unsigned int scope)
	{
	struct c_label_context_vm *nstack;
	struct c_label_list *glist;

	gcc_assert (scope > 0);

	/* At file_scope, we don't have to do any processing. */
	if (label_context_stack_vm == NULL)
	return;

	if (c_switch_stack && !c_switch_stack->blocked_vm)
	c_switch_stack->blocked_vm = scope;
	for (glist = label_context_stack_vm->labels_used;
	glist != NULL;
	glist = glist->next)
	{
	C_DECL_UNDEFINABLE_VM (glist->label) = 1;
	}
	nstack = XOBNEW (&parser_obstack, struct c_label_context_vm);
	nstack->labels_def = NULL;
	nstack->labels_used = NULL;
	nstack->scope = scope;
	nstack->next = label_context_stack_vm;
	label_context_stack_vm = nstack;
	}

	/* End a scope which may contain identifiers of variably modified
	type, scope number SCOPE. */

	void
	c_end_vm_scope (unsigned int scope)
	{
	if (label_context_stack_vm == NULL)
	return;
	if (c_switch_stack && c_switch_stack->blocked_vm == scope)
	c_switch_stack->blocked_vm = 0;
	/* We may have a number of nested scopes of identifiers with
	variably modified type, all at this depth. Pop each in turn. */
	while (label_context_stack_vm->scope == scope)
	{
	struct c_label_list dlist, glist, *glist_prev = NULL;

	/* It is no longer possible to jump to labels defined within this
	scope. */
	for (dlist = label_context_stack_vm->labels_def;
	dlist != NULL;
	dlist = dlist->next)
	{
	C_DECL_UNJUMPABLE_VM (dlist->label) = 1;
	}
	/* It is again possible to define labels with a goto just outside
	this scope. */
	for (glist = label_context_stack_vm->next->labels_used;
	glist != NULL;
	glist = glist->next)
	{
	C_DECL_UNDEFINABLE_VM (glist->label) = 0;
	glist_prev = glist;
	}
	if (glist_prev != NULL)
	glist_prev->next = label_context_stack_vm->labels_used;
	else
	label_context_stack_vm->next->labels_used
	= label_context_stack_vm->labels_used;
	label_context_stack_vm = label_context_stack_vm->next;
	}
	}

	/* Begin and end compound statements. This is as simple as pushing
	and popping new statement lists from the tree. */

	tree
	c_begin_compound_stmt (bool do_scope)
	{
	tree stmt = push_stmt_list ();
	if (do_scope)
	push_scope ();
	return stmt;
	}

	tree
	c_end_compound_stmt (tree stmt, bool do_scope)
	{
	tree block = NULL;

	if (do_scope)
	{
	if (c_dialect_objc ())
	objc_clear_super_receiver ();
	block = pop_scope ();
	}

	stmt = pop_stmt_list (stmt);
	stmt = c_build_bind_expr (block, stmt);

	/* If this compound statement is nested immediately inside a statement
	expression, then force a BIND_EXPR to be created. Otherwise we'll
	do the wrong thing for ({ { 1; } }) or ({ 1; { } }). In particular,
	STATEMENT_LISTs merge, and thus we can lose track of what statement
	was really last. */
	if (cur_stmt_list
	&& STATEMENT_LIST_STMT_EXPR (cur_stmt_list)
	&& TREE_CODE (stmt) != BIND_EXPR)
	{
	stmt = build3 (BIND_EXPR, void_type_node, NULL, stmt, NULL);
	TREE_SIDE_EFFECTS (stmt) = 1;
	}

	return stmt;
	}

	/* Queue a cleanup. CLEANUP is an expression/statement to be executed
	when the current scope is exited. EH_ONLY is true when this is not
	meant to apply to normal control flow transfer. */

	void
	push_cleanup (tree ARG_UNUSED (decl), tree cleanup, bool eh_only)
	{
	enum tree_code code;
	tree stmt, list;
	bool stmt_expr;

	code = eh_only ? TRY_CATCH_EXPR : TRY_FINALLY_EXPR;
	stmt = build_stmt (code, NULL, cleanup);
	add_stmt (stmt);
	stmt_expr = STATEMENT_LIST_STMT_EXPR (cur_stmt_list);
	list = push_stmt_list ();
	TREE_OPERAND (stmt, 0) = list;
	STATEMENT_LIST_STMT_EXPR (list) = stmt_expr;
	}

	/* Build a binary-operation expression without default conversions.
	CODE is the kind of expression to build.
	This function differs from `build' in several ways:
	the data type of the result is computed and recorded in it,
	warnings are generated if arg data types are invalid,
	special handling for addition and subtraction of pointers is known,
	and some optimization is done (operations on narrow ints
	are done in the narrower type when that gives the same result).
	Constant folding is also done before the result is returned.

	Note that the operands will never have enumeral types, or function
	or array types, because either they will have the default conversions
	performed or they have both just been converted to some other type in which
	the arithmetic is to be done. */

	tree
	build_binary_op (enum tree_code code, tree orig_op0, tree orig_op1,
	int convert_p)
	{
	tree type0, type1;
	enum tree_code code0, code1;
	tree op0, op1;
	const char *invalid_op_diag;

	/* Expression code to give to the expression when it is built.
	Normally this is CODE, which is what the caller asked for,
	but in some special cases we change it. */
	enum tree_code resultcode = code;

	/* Data type in which the computation is to be performed.
	In the simplest cases this is the common type of the arguments. */
	tree result_type = NULL;

	/* Nonzero means operands have already been type-converted
	in whatever way is necessary.
	Zero means they need to be converted to RESULT_TYPE. */
	int converted = 0;

	/* Nonzero means create the expression with this type, rather than
	RESULT_TYPE. */
	tree build_type = 0;

	/* Nonzero means after finally constructing the expression
	convert it to this type. */
	tree final_type = 0;

	/* Nonzero if this is an operation like MIN or MAX which can
	safely be computed in short if both args are promoted shorts.
	Also implies COMMON.
	-1 indicates a bitwise operation; this makes a difference
	in the exact conditions for when it is safe to do the operation
	in a narrower mode. */
	int shorten = 0;

	/* Nonzero if this is a comparison operation;
	if both args are promoted shorts, compare the original shorts.
	Also implies COMMON. */
	int short_compare = 0;

	/* Nonzero if this is a right-shift operation, which can be computed on the
	original short and then promoted if the operand is a promoted short. */
	int short_shift = 0;

	/* Nonzero means set RESULT_TYPE to the common type of the args. */
	int common = 0;

	/* True means types are compatible as far as ObjC is concerned. */
	bool objc_ok;

	if (convert_p)
	{
	op0 = default_conversion (orig_op0);
	op1 = default_conversion (orig_op1);
	}
	else
	{
	op0 = orig_op0;
	op1 = orig_op1;
	}

	type0 = TREE_TYPE (op0);
	type1 = TREE_TYPE (op1);

	/* The expression codes of the data types of the arguments tell us
	whether the arguments are integers, floating, pointers, etc. */
	code0 = TREE_CODE (type0);
	code1 = TREE_CODE (type1);

	/* Strip NON_LVALUE_EXPRs, etc., since we aren't using as an lvalue. */
	STRIP_TYPE_NOPS (op0);
	STRIP_TYPE_NOPS (op1);

	/* If an error was already reported for one of the arguments,
	avoid reporting another error. */

	if (code0 == ERROR_MARK \|\| code1 == ERROR_MARK)
	return error_mark_node;

	if ((invalid_op_diag
	= targetm.invalid_binary_op (code, type0, type1)))
	{
	error (invalid_op_diag, "");
	return error_mark_node;
	}

	objc_ok = objc_compare_types (type0, type1, -3, NULL_TREE);

	switch (code)
	{
	case PLUS_EXPR:
	/* Handle the pointer + int case. */
	if (code0 == POINTER_TYPE && code1 == INTEGER_TYPE)
	return pointer_int_sum (PLUS_EXPR, op0, op1);
	else if (code1 == POINTER_TYPE && code0 == INTEGER_TYPE)
	return pointer_int_sum (PLUS_EXPR, op1, op0);
	else
	common = 1;
	break;

	case MINUS_EXPR:
	/* Subtraction of two similar pointers.
	We must subtract them as integers, then divide by object size. */
	if (code0 == POINTER_TYPE && code1 == POINTER_TYPE
	&& comp_target_types (type0, type1))
	return pointer_diff (op0, op1);
	/* Handle pointer minus int. Just like pointer plus int. */
	else if (code0 == POINTER_TYPE && code1 == INTEGER_TYPE)
	return pointer_int_sum (MINUS_EXPR, op0, op1);
	else
	common = 1;
	break;

	case MULT_EXPR:
	common = 1;
	break;

	case TRUNC_DIV_EXPR:
	case CEIL_DIV_EXPR:
	case FLOOR_DIV_EXPR:
	case ROUND_DIV_EXPR:
	case EXACT_DIV_EXPR:
	/* Floating point division by zero is a legitimate way to obtain
	infinities and NaNs. */
	if (skip_evaluation == 0 && integer_zerop (op1))
	warning (OPT_Wdiv_by_zero, "division by zero");

	if ((code0 == INTEGER_TYPE \|\| code0 == REAL_TYPE
	\|\| code0 == COMPLEX_TYPE \|\| code0 == VECTOR_TYPE)
	&& (code1 == INTEGER_TYPE \|\| code1 == REAL_TYPE
	\|\| code1 == COMPLEX_TYPE \|\| code1 == VECTOR_TYPE))
	{
	enum tree_code tcode0 = code0, tcode1 = code1;

	if (code0 == COMPLEX_TYPE \|\| code0 == VECTOR_TYPE)
	tcode0 = TREE_CODE (TREE_TYPE (TREE_TYPE (op0)));
	if (code1 == COMPLEX_TYPE \|\| code1 == VECTOR_TYPE)
	tcode1 = TREE_CODE (TREE_TYPE (TREE_TYPE (op1)));

	if (!(tcode0 == INTEGER_TYPE && tcode1 == INTEGER_TYPE))
	resultcode = RDIV_EXPR;
	else
	/* Although it would be tempting to shorten always here, that
	loses on some targets, since the modulo instruction is
	undefined if the quotient can't be represented in the
	computation mode. We shorten only if unsigned or if
	dividing by something we know != -1. */
	shorten = (TYPE_UNSIGNED (TREE_TYPE (orig_op0))
	\|\| (TREE_CODE (op1) == INTEGER_CST
	&& !integer_all_onesp (op1)));
	common = 1;
	}
	break;

	case BIT_AND_EXPR:
	case BIT_IOR_EXPR:
	case BIT_XOR_EXPR:
	if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE)
	shorten = -1;
	else if (code0 == VECTOR_TYPE && code1 == VECTOR_TYPE)
	common = 1;
	break;

	case TRUNC_MOD_EXPR:
	case FLOOR_MOD_EXPR:
	if (skip_evaluation == 0 && integer_zerop (op1))
	warning (OPT_Wdiv_by_zero, "division by zero");

	if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE)
	{
	/* Although it would be tempting to shorten always here, that loses
	on some targets, since the modulo instruction is undefined if the
	quotient can't be represented in the computation mode. We shorten
	only if unsigned or if dividing by something we know != -1. */
	shorten = (TYPE_UNSIGNED (TREE_TYPE (orig_op0))
	\|\| (TREE_CODE (op1) == INTEGER_CST
	&& !integer_all_onesp (op1)));
	common = 1;
	}
	break;

	case TRUTH_ANDIF_EXPR:
	case TRUTH_ORIF_EXPR:
	case TRUTH_AND_EXPR:
	case TRUTH_OR_EXPR:
	case TRUTH_XOR_EXPR:
	if ((code0 == INTEGER_TYPE \|\| code0 == POINTER_TYPE
	\|\| code0 == REAL_TYPE \|\| code0 == COMPLEX_TYPE)
	&& (code1 == INTEGER_TYPE \|\| code1 == POINTER_TYPE
	\|\| code1 == REAL_TYPE \|\| code1 == COMPLEX_TYPE))
	{
	/* Result of these operations is always an int,
	but that does not mean the operands should be
	converted to ints! */
	result_type = integer_type_node;
	op0 = c_common_truthvalue_conversion (op0);
	op1 = c_common_truthvalue_conversion (op1);
	converted = 1;
	}
	break;

	/* Shift operations: result has same type as first operand;
	always convert second operand to int.
	Also set SHORT_SHIFT if shifting rightward. */

	case RSHIFT_EXPR:
	if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE)
	{
	if (TREE_CODE (op1) == INTEGER_CST && skip_evaluation == 0)
	{
	if (tree_int_cst_sgn (op1) < 0)
	warning (0, "right shift count is negative");
	else
	{
	if (!integer_zerop (op1))
	short_shift = 1;

	if (compare_tree_int (op1, TYPE_PRECISION (type0)) >= 0)
	warning (0, "right shift count >= width of type");
	}
	}

	/* Use the type of the value to be shifted. */
	result_type = type0;
	/* Convert the shift-count to an integer, regardless of size
	of value being shifted. */
	if (TYPE_MAIN_VARIANT (TREE_TYPE (op1)) != integer_type_node)
	op1 = convert (integer_type_node, op1);
	/* Avoid converting op1 to result_type later. */
	converted = 1;
	}
	break;

	case LSHIFT_EXPR:
	if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE)
	{
	if (TREE_CODE (op1) == INTEGER_CST && skip_evaluation == 0)
	{
	if (tree_int_cst_sgn (op1) < 0)
	warning (0, "left shift count is negative");

	else if (compare_tree_int (op1, TYPE_PRECISION (type0)) >= 0)
	warning (0, "left shift count >= width of type");
	}

	/* Use the type of the value to be shifted. */
	result_type = type0;
	/* Convert the shift-count to an integer, regardless of size
	of value being shifted. */
	if (TYPE_MAIN_VARIANT (TREE_TYPE (op1)) != integer_type_node)
	op1 = convert (integer_type_node, op1);
	/* Avoid converting op1 to result_type later. */
	converted = 1;
	}
	break;

	case EQ_EXPR:
	case NE_EXPR:
	if (code0 == REAL_TYPE \|\| code1 == REAL_TYPE)
	warning (OPT_Wfloat_equal,
	"comparing floating point with == or != is unsafe");
	/* Result of comparison is always int,
	but don't convert the args to int! */
	build_type = integer_type_node;
	if ((code0 == INTEGER_TYPE \|\| code0 == REAL_TYPE
	\|\| code0 == COMPLEX_TYPE)
	&& (code1 == INTEGER_TYPE \|\| code1 == REAL_TYPE
	\|\| code1 == COMPLEX_TYPE))
	short_compare = 1;
	else if (code0 == POINTER_TYPE && code1 == POINTER_TYPE)
	{
	tree tt0 = TREE_TYPE (type0);
	tree tt1 = TREE_TYPE (type1);
	/* Anything compares with void . void compares with anything.
	Otherwise, the targets must be compatible
	and both must be object or both incomplete. */
	if (comp_target_types (type0, type1))
	result_type = common_pointer_type (type0, type1);
	else if (VOID_TYPE_P (tt0))
	{
	/* op0 != orig_op0 detects the case of something
	whose value is 0 but which isn't a valid null ptr const. */
	if (pedantic && !null_pointer_constant_p (orig_op0)
	&& TREE_CODE (tt1) == FUNCTION_TYPE)
	pedwarn ("ISO C forbids comparison of %<void *%>"
	" with function pointer");
	}
	else if (VOID_TYPE_P (tt1))
	{
	if (pedantic && !null_pointer_constant_p (orig_op1)
	&& TREE_CODE (tt0) == FUNCTION_TYPE)
	pedwarn ("ISO C forbids comparison of %<void *%>"
	" with function pointer");
	}
	else
	/* Avoid warning about the volatile ObjC EH puts on decls. */
	if (!objc_ok)
	pedwarn ("comparison of distinct pointer types lacks a cast");

	if (result_type == NULL_TREE)
	result_type = ptr_type_node;
	}
	else if (code0 == POINTER_TYPE && null_pointer_constant_p (orig_op1))
	{
	if (TREE_CODE (op0) == ADDR_EXPR
	&& DECL_P (TREE_OPERAND (op0, 0))
	&& (TREE_CODE (TREE_OPERAND (op0, 0)) == PARM_DECL
	\|\| TREE_CODE (TREE_OPERAND (op0, 0)) == LABEL_DECL
	\|\| !DECL_WEAK (TREE_OPERAND (op0, 0))))
	warning (OPT_Waddress, "the address of %qD will never be NULL",
	TREE_OPERAND (op0, 0));
	result_type = type0;
	}
	else if (code1 == POINTER_TYPE && null_pointer_constant_p (orig_op0))
	{
	if (TREE_CODE (op1) == ADDR_EXPR
	&& DECL_P (TREE_OPERAND (op1, 0))
	&& (TREE_CODE (TREE_OPERAND (op1, 0)) == PARM_DECL
	\|\| TREE_CODE (TREE_OPERAND (op1, 0)) == LABEL_DECL
	\|\| !DECL_WEAK (TREE_OPERAND (op1, 0))))
	warning (OPT_Waddress, "the address of %qD will never be NULL",
	TREE_OPERAND (op1, 0));
	result_type = type1;
	}
	else if (code0 == POINTER_TYPE && code1 == INTEGER_TYPE)
	{
	result_type = type0;
	pedwarn ("comparison between pointer and integer");
	}
	else if (code0 == INTEGER_TYPE && code1 == POINTER_TYPE)
	{
	result_type = type1;
	pedwarn ("comparison between pointer and integer");
	}
	break;

	case LE_EXPR:
	case GE_EXPR:
	case LT_EXPR:
	case GT_EXPR:
	build_type = integer_type_node;
	if ((code0 == INTEGER_TYPE \|\| code0 == REAL_TYPE)
	&& (code1 == INTEGER_TYPE \|\| code1 == REAL_TYPE))
	short_compare = 1;
	else if (code0 == POINTER_TYPE && code1 == POINTER_TYPE)
	{
	if (comp_target_types (type0, type1))
	{
	result_type = common_pointer_type (type0, type1);
	if (!COMPLETE_TYPE_P (TREE_TYPE (type0))
	!= !COMPLETE_TYPE_P (TREE_TYPE (type1)))
	pedwarn ("comparison of complete and incomplete pointers");
	else if (pedantic
	&& TREE_CODE (TREE_TYPE (type0)) == FUNCTION_TYPE)
	pedwarn ("ISO C forbids ordered comparisons of pointers to functions");
	}
	else
	{
	result_type = ptr_type_node;
	pedwarn ("comparison of distinct pointer types lacks a cast");
	}
	}
	else if (code0 == POINTER_TYPE && null_pointer_constant_p (orig_op1))
	{
	result_type = type0;
	if (pedantic \|\| extra_warnings)
	pedwarn ("ordered comparison of pointer with integer zero");
	}
	else if (code1 == POINTER_TYPE && null_pointer_constant_p (orig_op0))
	{
	result_type = type1;
	if (pedantic)
	pedwarn ("ordered comparison of pointer with integer zero");
	}
	else if (code0 == POINTER_TYPE && code1 == INTEGER_TYPE)
	{
	result_type = type0;
	pedwarn ("comparison between pointer and integer");
	}
	else if (code0 == INTEGER_TYPE && code1 == POINTER_TYPE)
	{
	result_type = type1;
	pedwarn ("comparison between pointer and integer");
	}
	break;

	default:
	gcc_unreachable ();
	}

	if (code0 == ERROR_MARK \|\| code1 == ERROR_MARK)
	return error_mark_node;

	if (code0 == VECTOR_TYPE && code1 == VECTOR_TYPE
	&& (!tree_int_cst_equal (TYPE_SIZE (type0), TYPE_SIZE (type1))
	\|\| !same_scalar_type_ignoring_signedness (TREE_TYPE (type0),
	TREE_TYPE (type1))))
	{
	binary_op_error (code, type0, type1);
	return error_mark_node;
	}

	if ((code0 == INTEGER_TYPE \|\| code0 == REAL_TYPE \|\| code0 == COMPLEX_TYPE
	\|\| code0 == VECTOR_TYPE)
	&&
	(code1 == INTEGER_TYPE \|\| code1 == REAL_TYPE \|\| code1 == COMPLEX_TYPE
	\|\| code1 == VECTOR_TYPE))
	{
	int none_complex = (code0 != COMPLEX_TYPE && code1 != COMPLEX_TYPE);

	if (shorten \|\| common \|\| short_compare)
	result_type = c_common_type (type0, type1);

	/* For certain operations (which identify themselves by shorten != 0)
	if both args were extended from the same smaller type,
	do the arithmetic in that type and then extend.

	shorten !=0 and !=1 indicates a bitwise operation.
	For them, this optimization is safe only if
	both args are zero-extended or both are sign-extended.
	Otherwise, we might change the result.
	Eg, (short)-1 \| (unsigned short)-1 is (int)-1
	but calculated in (unsigned short) it would be (unsigned short)-1. */

	if (shorten && none_complex)
	{
	int unsigned0, unsigned1;
	tree arg0, arg1;
	int uns;
	tree type;

	/* Cast OP0 and OP1 to RESULT_TYPE. Doing so prevents
	excessive narrowing when we call get_narrower below. For
	example, suppose that OP0 is of unsigned int extended
	from signed char and that RESULT_TYPE is long long int.
	If we explicitly cast OP0 to RESULT_TYPE, OP0 would look
	like

	(long long int) (unsigned int) signed_char

	which get_narrower would narrow down to

	(unsigned int) signed char

	If we do not cast OP0 first, get_narrower would return
	signed_char, which is inconsistent with the case of the
	explicit cast. */
	op0 = convert (result_type, op0);
	op1 = convert (result_type, op1);

	arg0 = get_narrower (op0, &unsigned0);
	arg1 = get_narrower (op1, &unsigned1);

	/* UNS is 1 if the operation to be done is an unsigned one. */
	uns = TYPE_UNSIGNED (result_type);

	final_type = result_type;

	/* Handle the case that OP0 (or OP1) does not contain a conversion
	but it requires conversion to FINAL_TYPE. */

	if ((TYPE_PRECISION (TREE_TYPE (op0))
	== TYPE_PRECISION (TREE_TYPE (arg0)))
	&& TREE_TYPE (op0) != final_type)
	unsigned0 = TYPE_UNSIGNED (TREE_TYPE (op0));
	if ((TYPE_PRECISION (TREE_TYPE (op1))
	== TYPE_PRECISION (TREE_TYPE (arg1)))
	&& TREE_TYPE (op1) != final_type)
	unsigned1 = TYPE_UNSIGNED (TREE_TYPE (op1));

	/* Now UNSIGNED0 is 1 if ARG0 zero-extends to FINAL_TYPE. */

	/* For bitwise operations, signedness of nominal type
	does not matter. Consider only how operands were extended. */
	if (shorten == -1)
	uns = unsigned0;

	/* Note that in all three cases below we refrain from optimizing
	an unsigned operation on sign-extended args.
	That would not be valid. */

	/* Both args variable: if both extended in same way
	from same width, do it in that width.
	Do it unsigned if args were zero-extended. */
	if ((TYPE_PRECISION (TREE_TYPE (arg0))
	< TYPE_PRECISION (result_type))
	&& (TYPE_PRECISION (TREE_TYPE (arg1))
	== TYPE_PRECISION (TREE_TYPE (arg0)))
	&& unsigned0 == unsigned1
	&& (unsigned0 \|\| !uns))
	result_type
	= c_common_signed_or_unsigned_type
	(unsigned0, common_type (TREE_TYPE (arg0), TREE_TYPE (arg1)));
	else if (TREE_CODE (arg0) == INTEGER_CST
	&& (unsigned1 \|\| !uns)
	&& (TYPE_PRECISION (TREE_TYPE (arg1))
	< TYPE_PRECISION (result_type))
	&& (type
	= c_common_signed_or_unsigned_type (unsigned1,
	TREE_TYPE (arg1)),
	int_fits_type_p (arg0, type)))
	result_type = type;
	else if (TREE_CODE (arg1) == INTEGER_CST
	&& (unsigned0 \|\| !uns)
	&& (TYPE_PRECISION (TREE_TYPE (arg0))
	< TYPE_PRECISION (result_type))
	&& (type
	= c_common_signed_or_unsigned_type (unsigned0,
	TREE_TYPE (arg0)),
	int_fits_type_p (arg1, type)))
	result_type = type;
	}

	/* Shifts can be shortened if shifting right. */

	if (short_shift)
	{
	int unsigned_arg;
	tree arg0 = get_narrower (op0, &unsigned_arg);

	final_type = result_type;

	if (arg0 == op0 && final_type == TREE_TYPE (op0))
	unsigned_arg = TYPE_UNSIGNED (TREE_TYPE (op0));

	if (TYPE_PRECISION (TREE_TYPE (arg0)) < TYPE_PRECISION (result_type)
	/* We can shorten only if the shift count is less than the
	number of bits in the smaller type size. */
	&& compare_tree_int (op1, TYPE_PRECISION (TREE_TYPE (arg0))) < 0
	/* We cannot drop an unsigned shift after sign-extension. */
	&& (!TYPE_UNSIGNED (final_type) \|\| unsigned_arg))
	{
	/* Do an unsigned shift if the operand was zero-extended. */
	result_type
	= c_common_signed_or_unsigned_type (unsigned_arg,
	TREE_TYPE (arg0));
	/* Convert value-to-be-shifted to that type. */
	if (TREE_TYPE (op0) != result_type)
	op0 = convert (result_type, op0);
	converted = 1;
	}
	}

	/* Comparison operations are shortened too but differently.
	They identify themselves by setting short_compare = 1. */

	if (short_compare)
	{
	/* Don't write &op0, etc., because that would prevent op0
	from being kept in a register.
	Instead, make copies of the our local variables and
	pass the copies by reference, then copy them back afterward. */
	tree xop0 = op0, xop1 = op1, xresult_type = result_type;
	enum tree_code xresultcode = resultcode;
	tree val
	= shorten_compare (&xop0, &xop1, &xresult_type, &xresultcode);

	if (val != 0)
	return val;

	op0 = xop0, op1 = xop1;
	converted = 1;
	resultcode = xresultcode;

	if (warn_sign_compare && skip_evaluation == 0)
	{
	int op0_signed = !TYPE_UNSIGNED (TREE_TYPE (orig_op0));
	int op1_signed = !TYPE_UNSIGNED (TREE_TYPE (orig_op1));
	int unsignedp0, unsignedp1;
	tree primop0 = get_narrower (op0, &unsignedp0);
	tree primop1 = get_narrower (op1, &unsignedp1);

	xop0 = orig_op0;
	xop1 = orig_op1;
	STRIP_TYPE_NOPS (xop0);
	STRIP_TYPE_NOPS (xop1);

	/* Give warnings for comparisons between signed and unsigned
	quantities that may fail.

	Do the checking based on the original operand trees, so that
	casts will be considered, but default promotions won't be.

	Do not warn if the comparison is being done in a signed type,
	since the signed type will only be chosen if it can represent
	all the values of the unsigned type. */
	if (!TYPE_UNSIGNED (result_type))
	/* OK */;
	/* Do not warn if both operands are the same signedness. */
	else if (op0_signed == op1_signed)
	/* OK */;
	else
	{
	tree sop, uop;
	bool ovf;

	if (op0_signed)
	sop = xop0, uop = xop1;
	else
	sop = xop1, uop = xop0;

	/* Do not warn if the signed quantity is an
	unsuffixed integer literal (or some static
	constant expression involving such literals or a
	conditional expression involving such literals)
	and it is non-negative. */
	if (tree_expr_nonnegative_warnv_p (sop, &ovf))
	/* OK */;
	/* Do not warn if the comparison is an equality operation,
	the unsigned quantity is an integral constant, and it
	would fit in the result if the result were signed. */
	else if (TREE_CODE (uop) == INTEGER_CST
	&& (resultcode == EQ_EXPR \|\| resultcode == NE_EXPR)
	&& int_fits_type_p
	(uop, c_common_signed_type (result_type)))
	/* OK */;
	/* Do not warn if the unsigned quantity is an enumeration
	constant and its maximum value would fit in the result
	if the result were signed. */
	else if (TREE_CODE (uop) == INTEGER_CST
	&& TREE_CODE (TREE_TYPE (uop)) == ENUMERAL_TYPE
	&& int_fits_type_p
	(TYPE_MAX_VALUE (TREE_TYPE (uop)),
	c_common_signed_type (result_type)))
	/* OK */;
	else
	warning (0, "comparison between signed and unsigned");
	}

	/* Warn if two unsigned values are being compared in a size
	larger than their original size, and one (and only one) is the
	result of a `~' operator. This comparison will always fail.

	Also warn if one operand is a constant, and the constant
	does not have all bits set that are set in the ~ operand
	when it is extended. */

	if ((TREE_CODE (primop0) == BIT_NOT_EXPR)
	!= (TREE_CODE (primop1) == BIT_NOT_EXPR))
	{
	if (TREE_CODE (primop0) == BIT_NOT_EXPR)
	primop0 = get_narrower (TREE_OPERAND (primop0, 0),
	&unsignedp0);
	else
	primop1 = get_narrower (TREE_OPERAND (primop1, 0),
	&unsignedp1);

	if (host_integerp (primop0, 0) \|\| host_integerp (primop1, 0))
	{
	tree primop;
	HOST_WIDE_INT constant, mask;
	int unsignedp, bits;

	if (host_integerp (primop0, 0))
	{
	primop = primop1;
	unsignedp = unsignedp1;
	constant = tree_low_cst (primop0, 0);
	}
	else
	{
	primop = primop0;
	unsignedp = unsignedp0;
	constant = tree_low_cst (primop1, 0);
	}

	bits = TYPE_PRECISION (TREE_TYPE (primop));
	if (bits < TYPE_PRECISION (result_type)
	&& bits < HOST_BITS_PER_WIDE_INT && unsignedp)
	{
	mask = (~(HOST_WIDE_INT) 0) << bits;
	if ((mask & constant) != mask)
	warning (0, "comparison of promoted ~unsigned with constant");
	}
	}
	else if (unsignedp0 && unsignedp1
	&& (TYPE_PRECISION (TREE_TYPE (primop0))
	< TYPE_PRECISION (result_type))
	&& (TYPE_PRECISION (TREE_TYPE (primop1))
	< TYPE_PRECISION (result_type)))
	warning (0, "comparison of promoted ~unsigned with unsigned");
	}
	}
	}
	}

	/* At this point, RESULT_TYPE must be nonzero to avoid an error message.
	If CONVERTED is zero, both args will be converted to type RESULT_TYPE.
	Then the expression will be built.
	It will be given type FINAL_TYPE if that is nonzero;
	otherwise, it will be given type RESULT_TYPE. */

	if (!result_type)
	{
	binary_op_error (code, TREE_TYPE (op0), TREE_TYPE (op1));
	return error_mark_node;
	}

	if (!converted)
	{
	if (TREE_TYPE (op0) != result_type)
	op0 = convert_and_check (result_type, op0);
	if (TREE_TYPE (op1) != result_type)
	op1 = convert_and_check (result_type, op1);

	/* This can happen if one operand has a vector type, and the other
	has a different type. */
	if (TREE_CODE (op0) == ERROR_MARK \|\| TREE_CODE (op1) == ERROR_MARK)
	return error_mark_node;
	}

	if (build_type == NULL_TREE)
	build_type = result_type;

	{
	/* Treat expressions in initializers specially as they can't trap. */
	tree result = require_constant_value ? fold_build2_initializer (resultcode,
	build_type,
	op0, op1)
	: fold_build2 (resultcode, build_type,
	op0, op1);

	if (final_type != 0)
	result = convert (final_type, result);
	return result;
	}
	}


	/* Convert EXPR to be a truth-value, validating its type for this
	purpose. */

	tree
	c_objc_common_truthvalue_conversion (tree expr)
	{
	switch (TREE_CODE (TREE_TYPE (expr)))
	{
	case ARRAY_TYPE:
	error ("used array that cannot be converted to pointer where scalar is required");
	return error_mark_node;

	case RECORD_TYPE:
	error ("used struct type value where scalar is required");
	return error_mark_node;

	case UNION_TYPE:
	error ("used union type value where scalar is required");
	return error_mark_node;

	case FUNCTION_TYPE:
	gcc_unreachable ();

	default:
	break;
	}

	/* ??? Should we also give an error for void and vectors rather than
	leaving those to give errors later? */
	return c_common_truthvalue_conversion (expr);
	}


	/* Convert EXPR to a contained DECL, updating TC, TI and *SE as
	required. */

	tree
	c_expr_to_decl (tree expr, bool *tc ATTRIBUTE_UNUSED,
	bool ti ATTRIBUTE_UNUSED, bool se)
	{
	if (TREE_CODE (expr) == COMPOUND_LITERAL_EXPR)
	{
	tree decl = COMPOUND_LITERAL_EXPR_DECL (expr);
	/* Executing a compound literal inside a function reinitializes
	it. */
	if (!TREE_STATIC (decl))
	*se = true;
	return decl;
	}
	else
	return expr;
	}

	/* Like c_begin_compound_stmt, except force the retention of the BLOCK. */

	tree
	c_begin_omp_parallel (void)
	{
	tree block;

	keep_next_level ();
	block = c_begin_compound_stmt (true);

	return block;
	}

	tree
	c_finish_omp_parallel (tree clauses, tree block)
	{
	tree stmt;

	block = c_end_compound_stmt (block, true);

	stmt = make_node (OMP_PARALLEL);
	TREE_TYPE (stmt) = void_type_node;
	OMP_PARALLEL_CLAUSES (stmt) = clauses;
	OMP_PARALLEL_BODY (stmt) = block;

	return add_stmt (stmt);
	}

	/* For all elements of CLAUSES, validate them vs OpenMP constraints.
	Remove any elements from the list that are invalid. */

	tree
	c_finish_omp_clauses (tree clauses)
	{
	bitmap_head generic_head, firstprivate_head, lastprivate_head;
	tree c, t, *pc = &clauses;
	const char *name;

	bitmap_obstack_initialize (NULL);
	bitmap_initialize (&generic_head, &bitmap_default_obstack);
	bitmap_initialize (&firstprivate_head, &bitmap_default_obstack);
	bitmap_initialize (&lastprivate_head, &bitmap_default_obstack);

	for (pc = &clauses, c = clauses; c ; c = *pc)
	{
	bool remove = false;
	bool need_complete = false;
	bool need_implicitly_determined = false;

	switch (OMP_CLAUSE_CODE (c))
	{
	case OMP_CLAUSE_SHARED:
	name = "shared";
	need_implicitly_determined = true;
	goto check_dup_generic;

	case OMP_CLAUSE_PRIVATE:
	name = "private";
	need_complete = true;
	need_implicitly_determined = true;
	goto check_dup_generic;

	case OMP_CLAUSE_REDUCTION:
	name = "reduction";
	need_implicitly_determined = true;
	t = OMP_CLAUSE_DECL (c);
	if (AGGREGATE_TYPE_P (TREE_TYPE (t))
	\|\| POINTER_TYPE_P (TREE_TYPE (t)))
	{
	error ("%qE has invalid type for %<reduction%>", t);
	remove = true;
	}
	else if (FLOAT_TYPE_P (TREE_TYPE (t)))
	{
	enum tree_code r_code = OMP_CLAUSE_REDUCTION_CODE (c);
	const char *r_name = NULL;

	switch (r_code)
	{
	case PLUS_EXPR:
	case MULT_EXPR:
	case MINUS_EXPR:
	break;
	case BIT_AND_EXPR:
	r_name = "&";
	break;
	case BIT_XOR_EXPR:
	r_name = "^";
	break;
	case BIT_IOR_EXPR:
	r_name = "\|";
	break;
	case TRUTH_ANDIF_EXPR:
	r_name = "&&";
	break;
	case TRUTH_ORIF_EXPR:
	r_name = "\|\|";
	break;
	default:
	gcc_unreachable ();
	}
	if (r_name)
	{
	error ("%qE has invalid type for %<reduction(%s)%>",
	t, r_name);
	remove = true;
	}
	}
	goto check_dup_generic;

	case OMP_CLAUSE_COPYPRIVATE:
	name = "copyprivate";
	goto check_dup_generic;

	case OMP_CLAUSE_COPYIN:
	name = "copyin";
	t = OMP_CLAUSE_DECL (c);
	if (TREE_CODE (t) != VAR_DECL \|\| !DECL_THREAD_LOCAL_P (t))
	{
	error ("%qE must be %<threadprivate%> for %<copyin%>", t);
	remove = true;
	}
	goto check_dup_generic;

	check_dup_generic:
	t = OMP_CLAUSE_DECL (c);
	if (TREE_CODE (t) != VAR_DECL && TREE_CODE (t) != PARM_DECL)
	{
	error ("%qE is not a variable in clause %qs", t, name);
	remove = true;
	}
	else if (bitmap_bit_p (&generic_head, DECL_UID (t))
	\|\| bitmap_bit_p (&firstprivate_head, DECL_UID (t))
	\|\| bitmap_bit_p (&lastprivate_head, DECL_UID (t)))
	{
	error ("%qE appears more than once in data clauses", t);
	remove = true;
	}
	else
	bitmap_set_bit (&generic_head, DECL_UID (t));
	break;

	case OMP_CLAUSE_FIRSTPRIVATE:
	name = "firstprivate";
	t = OMP_CLAUSE_DECL (c);
	need_complete = true;
	need_implicitly_determined = true;
	if (TREE_CODE (t) != VAR_DECL && TREE_CODE (t) != PARM_DECL)
	{
	error ("%qE is not a variable in clause %<firstprivate%>", t);
	remove = true;
	}
	else if (bitmap_bit_p (&generic_head, DECL_UID (t))
	\|\| bitmap_bit_p (&firstprivate_head, DECL_UID (t)))
	{
	error ("%qE appears more than once in data clauses", t);
	remove = true;
	}
	else
	bitmap_set_bit (&firstprivate_head, DECL_UID (t));
	break;

	case OMP_CLAUSE_LASTPRIVATE:
	name = "lastprivate";
	t = OMP_CLAUSE_DECL (c);
	need_complete = true;
	need_implicitly_determined = true;
	if (TREE_CODE (t) != VAR_DECL && TREE_CODE (t) != PARM_DECL)
	{
	error ("%qE is not a variable in clause %<lastprivate%>", t);
	remove = true;
	}
	else if (bitmap_bit_p (&generic_head, DECL_UID (t))
	\|\| bitmap_bit_p (&lastprivate_head, DECL_UID (t)))
	{
	error ("%qE appears more than once in data clauses", t);
	remove = true;
	}
	else
	bitmap_set_bit (&lastprivate_head, DECL_UID (t));
	break;

	case OMP_CLAUSE_IF:
	case OMP_CLAUSE_NUM_THREADS:
	case OMP_CLAUSE_SCHEDULE:
	case OMP_CLAUSE_NOWAIT:
	case OMP_CLAUSE_ORDERED:
	case OMP_CLAUSE_DEFAULT:
	pc = &OMP_CLAUSE_CHAIN (c);
	continue;

	default:
	gcc_unreachable ();
	}

	if (!remove)
	{
	t = OMP_CLAUSE_DECL (c);

	if (need_complete)
	{
	t = require_complete_type (t);
	if (t == error_mark_node)
	remove = true;
	}

	if (need_implicitly_determined)
	{
	const char *share_name = NULL;

	if (TREE_CODE (t) == VAR_DECL && DECL_THREAD_LOCAL_P (t))
	share_name = "threadprivate";
	else switch (c_omp_predetermined_sharing (t))
	{
	case OMP_CLAUSE_DEFAULT_UNSPECIFIED:
	break;
	case OMP_CLAUSE_DEFAULT_SHARED:
	share_name = "shared";
	break;
	case OMP_CLAUSE_DEFAULT_PRIVATE:
	share_name = "private";
	break;
	default:
	gcc_unreachable ();
	}
	if (share_name)
	{
	error ("%qE is predetermined %qs for %qs",
	t, share_name, name);
	remove = true;
	}
	}
	}

	if (remove)
	*pc = OMP_CLAUSE_CHAIN (c);
	else
	pc = &OMP_CLAUSE_CHAIN (c);
	}

	bitmap_obstack_release (NULL);
	return clauses;
	}
	diff --git a/contrib/gcc/cp/ChangeLog.apple b/contrib/gcc/cp/ChangeLog.apple
	new file mode 100644
	index 000000000000..a3eb8125a508
	--- /dev/null
	+++ b/contrib/gcc/cp/ChangeLog.apple
	@@ -0,0 +1,31 @@
	+2006-02-15 Fariborz Jahanian <fjahanian@apple.com>
	+
	+ Radar 4445586
	+ * semantics.c (begin_do_stmt): DO_STMT nodes take an
	+ extra argument to build.
	+
	+ # APPLE LOCAL begin for-fsf-4_4 3274130 5295549
	+2007-08-03 Geoffrey Keating <geoffk@apple.com>
	+
	+ Radar 5295549
	+ * parser.c (cp_parser_iteration_statement): Handle attributes.
	+ * semantics.c (begin_for_stmt): Put attributes in built tree.
	+ (begin_while_stmt): Put attributes in built tree.
	+ (begin_do_stmt): Put attributes in built tree.
	+ * pt.c (tsubst_expr): Handle attributes for FOR_STMT, WHILE_STMT,
	+ DO_STMT.
	+ * cp-gimplify.c (gimplify_cp_loop): Handle attributes.
	+ (gimplify_for_stmt): Pass attributes to gimplify_cp_loop.
	+ (gimplify_while_stmt): Pass attributes to gimplify_cp_loop.
	+ (gimplify_do_stmt): Pass attributes to gimplify_cp_loop.
	+ * dump.c (cp_dump_tree): Dump attributes for FOR_STMT, WHILE_STMT,
	+ DO_STMT.
	+ * cp-tree.h (begin_while_stmt): Update prototype.
	+ (begin_do_stmt): Likewise.
	+ (begin_for_stmt): Likewise.
	+ * cp-tree.def (FOR_STMT): Add extra parameter.
	+ (WHILE_STMT): Likewise.
	+ (DO_STMT): Likewise.
	+ * init.c (build_vec_init): Update for change to begin_for_stmt.
	+
	+ # APPLE LOCAL end for-fsf-4_4 3274130 5295549
	diff --git a/contrib/gcc/cp/cp-gimplify.c b/contrib/gcc/cp/cp-gimplify.c
	index 2be5857c1aaf..08d4ca02fbcc 100644
	--- a/contrib/gcc/cp/cp-gimplify.c
	+++ b/contrib/gcc/cp/cp-gimplify.c
	@@ -1,934 +1,952 @@
	/* C++-specific tree lowering bits; see also c-gimplify.c and tree-gimple.c.

	Copyright (C) 2002, 2003, 2004, 2005, 2006 Free Software Foundation, Inc.
	Contributed by Jason Merrill <jason@redhat.com>

	This file is part of GCC.

	GCC is free software; you can redistribute it and/or modify it under
	the terms of the GNU General Public License as published by the Free
	Software Foundation; either version 2, or (at your option) any later
	version.

	GCC is distributed in the hope that it will be useful, but WITHOUT ANY
	WARRANTY; without even the implied warranty of MERCHANTABILITY or
	FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	for more details.

	You should have received a copy of the GNU General Public License
	along with GCC; see the file COPYING. If not, write to the Free
	Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
	02110-1301, USA. */

	#include "config.h"
	#include "system.h"
	#include "coretypes.h"
	#include "tm.h"
	#include "tree.h"
	#include "cp-tree.h"
	#include "c-common.h"
	#include "toplev.h"
	#include "tree-gimple.h"
	#include "hashtab.h"
	#include "pointer-set.h"
	#include "flags.h"

	/* Local declarations. */

	enum bc_t { bc_break = 0, bc_continue = 1 };

	/* Stack of labels which are targets for "break" or "continue",
	linked through TREE_CHAIN. */
	static tree bc_label[2];

	/* Begin a scope which can be exited by a break or continue statement. BC
	indicates which.

	Just creates a label and pushes it into the current context. */

	static tree
	begin_bc_block (enum bc_t bc)
	{
	tree label = create_artificial_label ();
	TREE_CHAIN (label) = bc_label[bc];
	bc_label[bc] = label;
	return label;
	}

	/* Finish a scope which can be exited by a break or continue statement.
	LABEL was returned from the most recent call to begin_bc_block. BODY is
	an expression for the contents of the scope.

	If we saw a break (or continue) in the scope, append a LABEL_EXPR to
	body. Otherwise, just forget the label. */

	static tree
	finish_bc_block (enum bc_t bc, tree label, tree body)
	{
	gcc_assert (label == bc_label[bc]);

	if (TREE_USED (label))
	{
	tree t, sl = NULL;

	t = build1 (LABEL_EXPR, void_type_node, label);

	append_to_statement_list (body, &sl);
	append_to_statement_list (t, &sl);
	body = sl;
	}

	bc_label[bc] = TREE_CHAIN (label);
	TREE_CHAIN (label) = NULL_TREE;
	return body;
	}

	/* Build a GOTO_EXPR to represent a break or continue statement. BC
	indicates which. */

	static tree
	build_bc_goto (enum bc_t bc)
	{
	tree label = bc_label[bc];

	if (label == NULL_TREE)
	{
	if (bc == bc_break)
	error ("break statement not within loop or switch");
	else
	error ("continue statement not within loop or switch");

	return NULL_TREE;
	}

	/* Mark the label used for finish_bc_block. */
	TREE_USED (label) = 1;
	return build1 (GOTO_EXPR, void_type_node, label);
	}

	/* Genericize a TRY_BLOCK. */

	static void
	genericize_try_block (tree *stmt_p)
	{
	tree body = TRY_STMTS (*stmt_p);
	tree cleanup = TRY_HANDLERS (*stmt_p);

	gimplify_stmt (&body);

	if (CLEANUP_P (*stmt_p))
	/* A cleanup is an expression, so it doesn't need to be genericized. */;
	else
	gimplify_stmt (&cleanup);

	*stmt_p = build2 (TRY_CATCH_EXPR, void_type_node, body, cleanup);
	}

	/* Genericize a HANDLER by converting to a CATCH_EXPR. */

	static void
	genericize_catch_block (tree *stmt_p)
	{
	tree type = HANDLER_TYPE (*stmt_p);
	tree body = HANDLER_BODY (*stmt_p);

	gimplify_stmt (&body);

	/* FIXME should the caught type go in TREE_TYPE? */
	*stmt_p = build2 (CATCH_EXPR, void_type_node, type, body);
	}

	/* Genericize an EH_SPEC_BLOCK by converting it to a
	TRY_CATCH_EXPR/EH_FILTER_EXPR pair. */

	static void
	genericize_eh_spec_block (tree *stmt_p)
	{
	tree body = EH_SPEC_STMTS (*stmt_p);
	tree allowed = EH_SPEC_RAISES (*stmt_p);
	tree failure = build_call (call_unexpected_node,
	tree_cons (NULL_TREE, build_exc_ptr (),
	NULL_TREE));
	gimplify_stmt (&body);

	*stmt_p = gimple_build_eh_filter (body, allowed, failure);
	}

	/* Genericize an IF_STMT by turning it into a COND_EXPR. */

	static void
	gimplify_if_stmt (tree *stmt_p)
	{
	tree stmt, cond, then_, else_;

	stmt = *stmt_p;
	cond = IF_COND (stmt);
	then_ = THEN_CLAUSE (stmt);
	else_ = ELSE_CLAUSE (stmt);

	if (!then_)
	then_ = build_empty_stmt ();
	if (!else_)
	else_ = build_empty_stmt ();

	if (integer_nonzerop (cond) && !TREE_SIDE_EFFECTS (else_))
	stmt = then_;
	else if (integer_zerop (cond) && !TREE_SIDE_EFFECTS (then_))
	stmt = else_;
	else
	stmt = build3 (COND_EXPR, void_type_node, cond, then_, else_);
	*stmt_p = stmt;
	}

	/* Build a generic representation of one of the C loop forms. COND is the
	loop condition or NULL_TREE. BODY is the (possibly compound) statement
	controlled by the loop. INCR is the increment expression of a for-loop,
	or NULL_TREE. COND_IS_FIRST indicates whether the condition is
	evaluated before the loop body as in while and for loops, or after the
	loop body as in do-while loops. */

	static tree
	-gimplify_cp_loop (tree cond, tree body, tree incr, bool cond_is_first)
	+/* APPLE LOCAL begin for-fsf-4_4 3274130 5295549 */ \
	+gimplify_cp_loop (tree cond, tree body, tree incr, tree attrs,
	+ bool cond_is_first, tree inner_foreach)
	+/* APPLE LOCAL end for-fsf-4_4 3274130 5295549 */ \
	{
	tree top, entry, exit, cont_block, break_block, stmt_list, t;
	location_t stmt_locus;

	stmt_locus = input_location;
	stmt_list = NULL_TREE;
	entry = NULL_TREE;

	break_block = begin_bc_block (bc_break);
	cont_block = begin_bc_block (bc_continue);

	/* If condition is zero don't generate a loop construct. */
	if (cond && integer_zerop (cond))
	{
	top = NULL_TREE;
	exit = NULL_TREE;
	if (cond_is_first)
	{
	t = build_bc_goto (bc_break);
	append_to_statement_list (t, &stmt_list);
	}
	}
	else
	{
	/* If we use a LOOP_EXPR here, we have to feed the whole thing
	back through the main gimplifier to lower it. Given that we
	have to gimplify the loop body NOW so that we can resolve
	break/continue stmts, seems easier to just expand to gotos. */
	top = build1 (LABEL_EXPR, void_type_node, NULL_TREE);

	/* If we have an exit condition, then we build an IF with gotos either
	out of the loop, or to the top of it. If there's no exit condition,
	then we just build a jump back to the top. */
	exit = build_and_jump (&LABEL_EXPR_LABEL (top));
	+/* APPLE LOCAL begin for-fsf-4_4 3274130 5295549 */ \
	+
	+ /* Add the attributes to the 'top' label. */
	+ decl_attributes (&LABEL_EXPR_LABEL (top), attrs, 0);
	+
	+/* APPLE LOCAL end for-fsf-4_4 3274130 5295549 */ \
	if (cond && !integer_nonzerop (cond))
	{
	t = build_bc_goto (bc_break);
	exit = fold_build3 (COND_EXPR, void_type_node, cond, exit, t);
	gimplify_stmt (&exit);

	if (cond_is_first)
	{
	if (incr)
	{
	entry = build1 (LABEL_EXPR, void_type_node, NULL_TREE);
	t = build_and_jump (&LABEL_EXPR_LABEL (entry));
	}
	else
	t = build_bc_goto (bc_continue);
	append_to_statement_list (t, &stmt_list);
	}
	}
	}

	gimplify_stmt (&body);
	gimplify_stmt (&incr);

	body = finish_bc_block (bc_continue, cont_block, body);

	append_to_statement_list (top, &stmt_list);
	append_to_statement_list (body, &stmt_list);
	append_to_statement_list (incr, &stmt_list);
	append_to_statement_list (entry, &stmt_list);
	append_to_statement_list (exit, &stmt_list);

	annotate_all_with_locus (&stmt_list, stmt_locus);

	return finish_bc_block (bc_break, break_block, stmt_list);
	}

	/* Gimplify a FOR_STMT node. Move the stuff in the for-init-stmt into the
	prequeue and hand off to gimplify_cp_loop. */

	static void
	gimplify_for_stmt (tree stmt_p, tree pre_p)
	{
	tree stmt = *stmt_p;

	if (FOR_INIT_STMT (stmt))
	gimplify_and_add (FOR_INIT_STMT (stmt), pre_p);

	+/* APPLE LOCAL begin for-fsf-4_4 3274130 5295549 */ \
	*stmt_p = gimplify_cp_loop (FOR_COND (stmt), FOR_BODY (stmt),
	- FOR_EXPR (stmt), 1);
	+ FOR_EXPR (stmt), FOR_ATTRIBUTES (stmt), 1,
	+ NULL_TREE);
	+/* APPLE LOCAL end for-fsf-4_4 3274130 5295549 */ \
	}

	/* Gimplify a WHILE_STMT node. */

	static void
	gimplify_while_stmt (tree *stmt_p)
	{
	tree stmt = *stmt_p;
	+/* APPLE LOCAL begin for-fsf-4_4 3274130 5295549 */ \
	*stmt_p = gimplify_cp_loop (WHILE_COND (stmt), WHILE_BODY (stmt),
	- NULL_TREE, 1);
	+ NULL_TREE, WHILE_ATTRIBUTES (stmt), 1,
	+ NULL_TREE);
	+/* APPLE LOCAL end for-fsf-4_4 3274130 5295549 */ \
	}

	/* Gimplify a DO_STMT node. */

	static void
	gimplify_do_stmt (tree *stmt_p)
	{
	tree stmt = *stmt_p;
	+/* APPLE LOCAL begin for-fsf-4_4 3274130 5295549 */ \
	*stmt_p = gimplify_cp_loop (DO_COND (stmt), DO_BODY (stmt),
	- NULL_TREE, 0);
	+ NULL_TREE, DO_ATTRIBUTES (stmt), 0,
	+ DO_FOREACH (stmt));
	+/* APPLE LOCAL end for-fsf-4_4 3274130 5295549 */ \
	}

	/* Genericize a SWITCH_STMT by turning it into a SWITCH_EXPR. */

	static void
	gimplify_switch_stmt (tree *stmt_p)
	{
	tree stmt = *stmt_p;
	tree break_block, body;
	location_t stmt_locus = input_location;

	break_block = begin_bc_block (bc_break);

	body = SWITCH_STMT_BODY (stmt);
	if (!body)
	body = build_empty_stmt ();

	*stmt_p = build3 (SWITCH_EXPR, SWITCH_STMT_TYPE (stmt),
	SWITCH_STMT_COND (stmt), body, NULL_TREE);
	SET_EXPR_LOCATION (*stmt_p, stmt_locus);
	gimplify_stmt (stmt_p);

	stmt_p = finish_bc_block (bc_break, break_block, stmt_p);
	}

	/* Hook into the middle of gimplifying an OMP_FOR node. This is required
	in order to properly gimplify CONTINUE statements. Here we merely
	manage the continue stack; the rest of the job is performed by the
	regular gimplifier. */

	static enum gimplify_status
	cp_gimplify_omp_for (tree *expr_p)
	{
	tree for_stmt = *expr_p;
	tree cont_block;

	/* Protect ourselves from recursion. */
	if (OMP_FOR_GIMPLIFYING_P (for_stmt))
	return GS_UNHANDLED;
	OMP_FOR_GIMPLIFYING_P (for_stmt) = 1;

	/* Note that while technically the continue label is enabled too soon
	here, we should have already diagnosed invalid continues nested within
	statement expressions within the INIT, COND, or INCR expressions. */
	cont_block = begin_bc_block (bc_continue);

	gimplify_stmt (expr_p);

	OMP_FOR_BODY (for_stmt)
	= finish_bc_block (bc_continue, cont_block, OMP_FOR_BODY (for_stmt));
	OMP_FOR_GIMPLIFYING_P (for_stmt) = 0;

	return GS_ALL_DONE;
	}

	/* Gimplify an EXPR_STMT node. */

	static void
	gimplify_expr_stmt (tree *stmt_p)
	{
	tree stmt = EXPR_STMT_EXPR (*stmt_p);

	if (stmt == error_mark_node)
	stmt = NULL;

	/* Gimplification of a statement expression will nullify the
	statement if all its side effects are moved to PRE_P and POST_P.

	In this case we will not want to emit the gimplified statement.
	However, we may still want to emit a warning, so we do that before
	gimplification. */
	if (stmt && (extra_warnings \|\| warn_unused_value))
	{
	if (!TREE_SIDE_EFFECTS (stmt))
	{
	if (!IS_EMPTY_STMT (stmt)
	&& !VOID_TYPE_P (TREE_TYPE (stmt))
	&& !TREE_NO_WARNING (stmt))
	warning (OPT_Wextra, "statement with no effect");
	}
	else if (warn_unused_value)
	warn_if_unused_value (stmt, input_location);
	}

	if (stmt == NULL_TREE)
	stmt = alloc_stmt_list ();

	*stmt_p = stmt;
	}

	/* Gimplify initialization from an AGGR_INIT_EXPR. */

	static void
	cp_gimplify_init_expr (tree expr_p, tree pre_p, tree *post_p)
	{
	tree from = TREE_OPERAND (*expr_p, 1);
	tree to = TREE_OPERAND (*expr_p, 0);
	tree sub;

	/* What about code that pulls out the temp and uses it elsewhere? I
	think that such code never uses the TARGET_EXPR as an initializer. If
	I'm wrong, we'll abort because the temp won't have any RTL. In that
	case, I guess we'll need to replace references somehow. */
	if (TREE_CODE (from) == TARGET_EXPR)
	from = TARGET_EXPR_INITIAL (from);

	/* Look through any COMPOUND_EXPRs, since build_compound_expr pushes them
	inside the TARGET_EXPR. */
	sub = expr_last (from);

	/* If we are initializing from an AGGR_INIT_EXPR, drop the INIT_EXPR and
	replace the slot operand with our target.

	Should we add a target parm to gimplify_expr instead? No, as in this
	case we want to replace the INIT_EXPR. */
	if (TREE_CODE (sub) == AGGR_INIT_EXPR)
	{
	gimplify_expr (&to, pre_p, post_p, is_gimple_lvalue, fb_lvalue);
	TREE_OPERAND (sub, 2) = to;
	*expr_p = from;

	/* The initialization is now a side-effect, so the container can
	become void. */
	if (from != sub)
	TREE_TYPE (from) = void_type_node;
	}
	}

	/* Gimplify a MUST_NOT_THROW_EXPR. */

	static void
	gimplify_must_not_throw_expr (tree expr_p, tree pre_p)
	{
	tree stmt = *expr_p;
	tree temp = voidify_wrapper_expr (stmt, NULL);
	tree body = TREE_OPERAND (stmt, 0);

	gimplify_stmt (&body);

	stmt = gimple_build_eh_filter (body, NULL_TREE,
	build_call (terminate_node, NULL_TREE));

	if (temp)
	{
	append_to_statement_list (stmt, pre_p);
	*expr_p = temp;
	}
	else
	*expr_p = stmt;
	}

	/* Do C++-specific gimplification. Args are as for gimplify_expr. */

	int
	cp_gimplify_expr (tree expr_p, tree pre_p, tree *post_p)
	{
	int saved_stmts_are_full_exprs_p = 0;
	enum tree_code code = TREE_CODE (*expr_p);
	enum gimplify_status ret;

	if (STATEMENT_CODE_P (code))
	{
	saved_stmts_are_full_exprs_p = stmts_are_full_exprs_p ();
	current_stmt_tree ()->stmts_are_full_exprs_p
	= STMT_IS_FULL_EXPR_P (*expr_p);
	}

	switch (code)
	{
	case PTRMEM_CST:
	expr_p = cplus_expand_constant (expr_p);
	ret = GS_OK;
	break;

	case AGGR_INIT_EXPR:
	simplify_aggr_init_expr (expr_p);
	ret = GS_OK;
	break;

	case THROW_EXPR:
	/* FIXME communicate throw type to backend, probably by moving
	THROW_EXPR into ../tree.def. */
	expr_p = TREE_OPERAND (expr_p, 0);
	ret = GS_OK;
	break;

	case MUST_NOT_THROW_EXPR:
	gimplify_must_not_throw_expr (expr_p, pre_p);
	ret = GS_OK;
	break;

	/* We used to do this for MODIFY_EXPR as well, but that's unsafe; the
	LHS of an assignment might also be involved in the RHS, as in bug
	25979. */
	case INIT_EXPR:
	cp_gimplify_init_expr (expr_p, pre_p, post_p);
	ret = GS_OK;
	break;

	case EMPTY_CLASS_EXPR:
	/* We create an empty CONSTRUCTOR with RECORD_TYPE. */
	expr_p = build_constructor (TREE_TYPE (expr_p), NULL);
	ret = GS_OK;
	break;

	case BASELINK:
	expr_p = BASELINK_FUNCTIONS (expr_p);
	ret = GS_OK;
	break;

	case TRY_BLOCK:
	genericize_try_block (expr_p);
	ret = GS_OK;
	break;

	case HANDLER:
	genericize_catch_block (expr_p);
	ret = GS_OK;
	break;

	case EH_SPEC_BLOCK:
	genericize_eh_spec_block (expr_p);
	ret = GS_OK;
	break;

	case USING_STMT:
	/* Just ignore for now. Eventually we will want to pass this on to
	the debugger. */
	*expr_p = build_empty_stmt ();
	ret = GS_ALL_DONE;
	break;

	case IF_STMT:
	gimplify_if_stmt (expr_p);
	ret = GS_OK;
	break;

	case FOR_STMT:
	gimplify_for_stmt (expr_p, pre_p);
	ret = GS_ALL_DONE;
	break;

	case WHILE_STMT:
	gimplify_while_stmt (expr_p);
	ret = GS_ALL_DONE;
	break;

	case DO_STMT:
	gimplify_do_stmt (expr_p);
	ret = GS_ALL_DONE;
	break;

	case SWITCH_STMT:
	gimplify_switch_stmt (expr_p);
	ret = GS_ALL_DONE;
	break;

	case OMP_FOR:
	ret = cp_gimplify_omp_for (expr_p);
	break;

	case CONTINUE_STMT:
	*expr_p = build_bc_goto (bc_continue);
	ret = GS_ALL_DONE;
	break;

	case BREAK_STMT:
	*expr_p = build_bc_goto (bc_break);
	ret = GS_ALL_DONE;
	break;

	case EXPR_STMT:
	gimplify_expr_stmt (expr_p);
	ret = GS_OK;
	break;

	case UNARY_PLUS_EXPR:
	{
	tree arg = TREE_OPERAND (*expr_p, 0);
	tree type = TREE_TYPE (*expr_p);
	*expr_p = (TREE_TYPE (arg) != type) ? fold_convert (type, arg)
	: arg;
	ret = GS_OK;
	}
	break;

	default:
	ret = c_gimplify_expr (expr_p, pre_p, post_p);
	break;
	}

	/* Restore saved state. */
	if (STATEMENT_CODE_P (code))
	current_stmt_tree ()->stmts_are_full_exprs_p
	= saved_stmts_are_full_exprs_p;

	return ret;
	}

	static inline bool
	is_invisiref_parm (tree t)
	{
	return ((TREE_CODE (t) == PARM_DECL \|\| TREE_CODE (t) == RESULT_DECL)
	&& DECL_BY_REFERENCE (t));
	}

	/* Return true if the uid in both int tree maps are equal. */

	int
	cxx_int_tree_map_eq (const void va, const void vb)
	{
	const struct cxx_int_tree_map a = (const struct cxx_int_tree_map ) va;
	const struct cxx_int_tree_map b = (const struct cxx_int_tree_map ) vb;
	return (a->uid == b->uid);
	}

	/* Hash a UID in a cxx_int_tree_map. */

	unsigned int
	cxx_int_tree_map_hash (const void *item)
	{
	return ((const struct cxx_int_tree_map *)item)->uid;
	}

	/* Perform any pre-gimplification lowering of C++ front end trees to
	GENERIC. */

	static tree
	cp_genericize_r (tree stmt_p, int walk_subtrees, void *data)
	{
	tree stmt = *stmt_p;
	struct pointer_set_t p_set = (struct pointer_set_t) data;

	if (is_invisiref_parm (stmt)
	/* Don't dereference parms in a thunk, pass the references through. */
	&& !(DECL_THUNK_P (current_function_decl)
	&& TREE_CODE (stmt) == PARM_DECL))
	{
	*stmt_p = convert_from_reference (stmt);
	*walk_subtrees = 0;
	return NULL;
	}

	/* Map block scope extern declarations to visible declarations with the
	same name and type in outer scopes if any. */
	if (cp_function_chain->extern_decl_map
	&& (TREE_CODE (stmt) == FUNCTION_DECL \|\| TREE_CODE (stmt) == VAR_DECL)
	&& DECL_EXTERNAL (stmt))
	{
	struct cxx_int_tree_map *h, in;
	in.uid = DECL_UID (stmt);
	h = (struct cxx_int_tree_map *)
	htab_find_with_hash (cp_function_chain->extern_decl_map,
	&in, in.uid);
	if (h)
	{
	*stmt_p = h->to;
	*walk_subtrees = 0;
	return NULL;
	}
	}

	/* Other than invisiref parms, don't walk the same tree twice. */
	if (pointer_set_contains (p_set, stmt))
	{
	*walk_subtrees = 0;
	return NULL_TREE;
	}

	if (TREE_CODE (stmt) == ADDR_EXPR
	&& is_invisiref_parm (TREE_OPERAND (stmt, 0)))
	{
	*stmt_p = convert (TREE_TYPE (stmt), TREE_OPERAND (stmt, 0));
	*walk_subtrees = 0;
	}
	else if (TREE_CODE (stmt) == RETURN_EXPR
	&& TREE_OPERAND (stmt, 0)
	&& is_invisiref_parm (TREE_OPERAND (stmt, 0)))
	/* Don't dereference an invisiref RESULT_DECL inside a RETURN_EXPR. */
	*walk_subtrees = 0;
	else if (TREE_CODE (stmt) == OMP_CLAUSE)
	switch (OMP_CLAUSE_CODE (stmt))
	{
	case OMP_CLAUSE_PRIVATE:
	case OMP_CLAUSE_SHARED:
	case OMP_CLAUSE_FIRSTPRIVATE:
	case OMP_CLAUSE_LASTPRIVATE:
	case OMP_CLAUSE_COPYIN:
	case OMP_CLAUSE_COPYPRIVATE:
	/* Don't dereference an invisiref in OpenMP clauses. */
	if (is_invisiref_parm (OMP_CLAUSE_DECL (stmt)))
	*walk_subtrees = 0;
	break;
	case OMP_CLAUSE_REDUCTION:
	gcc_assert (!is_invisiref_parm (OMP_CLAUSE_DECL (stmt)));
	break;
	default:
	break;
	}
	else if (IS_TYPE_OR_DECL_P (stmt))
	*walk_subtrees = 0;

	/* Due to the way voidify_wrapper_expr is written, we don't get a chance
	to lower this construct before scanning it, so we need to lower these
	before doing anything else. */
	else if (TREE_CODE (stmt) == CLEANUP_STMT)
	*stmt_p = build2 (CLEANUP_EH_ONLY (stmt) ? TRY_CATCH_EXPR
	: TRY_FINALLY_EXPR,
	void_type_node,
	CLEANUP_BODY (stmt),
	CLEANUP_EXPR (stmt));

	pointer_set_insert (p_set, *stmt_p);

	return NULL;
	}

	void
	cp_genericize (tree fndecl)
	{
	tree t;
	struct pointer_set_t *p_set;

	/* Fix up the types of parms passed by invisible reference. */
	for (t = DECL_ARGUMENTS (fndecl); t; t = TREE_CHAIN (t))
	if (TREE_ADDRESSABLE (TREE_TYPE (t)))
	{
	/* If a function's arguments are copied to create a thunk,
	then DECL_BY_REFERENCE will be set -- but the type of the
	argument will be a pointer type, so we will never get
	here. */
	gcc_assert (!DECL_BY_REFERENCE (t));
	gcc_assert (DECL_ARG_TYPE (t) != TREE_TYPE (t));
	TREE_TYPE (t) = DECL_ARG_TYPE (t);
	DECL_BY_REFERENCE (t) = 1;
	TREE_ADDRESSABLE (t) = 0;
	relayout_decl (t);
	}

	/* Do the same for the return value. */
	if (TREE_ADDRESSABLE (TREE_TYPE (DECL_RESULT (fndecl))))
	{
	t = DECL_RESULT (fndecl);
	TREE_TYPE (t) = build_reference_type (TREE_TYPE (t));
	DECL_BY_REFERENCE (t) = 1;
	TREE_ADDRESSABLE (t) = 0;
	relayout_decl (t);
	}

	/* If we're a clone, the body is already GIMPLE. */
	if (DECL_CLONED_FUNCTION_P (fndecl))
	return;

	/* We do want to see every occurrence of the parms, so we can't just use
	walk_tree's hash functionality. */
	p_set = pointer_set_create ();
	walk_tree (&DECL_SAVED_TREE (fndecl), cp_genericize_r, p_set, NULL);
	pointer_set_destroy (p_set);

	/* Do everything else. */
	c_genericize (fndecl);

	gcc_assert (bc_label[bc_break] == NULL);
	gcc_assert (bc_label[bc_continue] == NULL);
	}

	/* Build code to apply FN to each member of ARG1 and ARG2. FN may be
	NULL if there is in fact nothing to do. ARG2 may be null if FN
	actually only takes one argument. */

	static tree
	cxx_omp_clause_apply_fn (tree fn, tree arg1, tree arg2)
	{
	tree defparm, parm;
	int i;

	if (fn == NULL)
	return NULL;

	defparm = TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (fn)));
	if (arg2)
	defparm = TREE_CHAIN (defparm);

	if (TREE_CODE (TREE_TYPE (arg1)) == ARRAY_TYPE)
	{
	tree inner_type = TREE_TYPE (arg1);
	tree start1, end1, p1;
	tree start2 = NULL, p2 = NULL;
	tree ret = NULL, lab, t;

	start1 = arg1;
	start2 = arg2;
	do
	{
	inner_type = TREE_TYPE (inner_type);
	start1 = build4 (ARRAY_REF, inner_type, start1,
	size_zero_node, NULL, NULL);
	if (arg2)
	start2 = build4 (ARRAY_REF, inner_type, start2,
	size_zero_node, NULL, NULL);
	}
	while (TREE_CODE (inner_type) == ARRAY_TYPE);
	start1 = build_fold_addr_expr (start1);
	if (arg2)
	start2 = build_fold_addr_expr (start2);

	end1 = TYPE_SIZE_UNIT (TREE_TYPE (arg1));
	end1 = fold_convert (TREE_TYPE (start1), end1);
	end1 = build2 (PLUS_EXPR, TREE_TYPE (start1), start1, end1);

	p1 = create_tmp_var (TREE_TYPE (start1), NULL);
	t = build2 (MODIFY_EXPR, void_type_node, p1, start1);
	append_to_statement_list (t, &ret);

	if (arg2)
	{
	p2 = create_tmp_var (TREE_TYPE (start2), NULL);
	t = build2 (MODIFY_EXPR, void_type_node, p2, start2);
	append_to_statement_list (t, &ret);
	}

	lab = create_artificial_label ();
	t = build1 (LABEL_EXPR, void_type_node, lab);
	append_to_statement_list (t, &ret);

	t = tree_cons (NULL, p1, NULL);
	if (arg2)
	t = tree_cons (NULL, p2, t);
	/* Handle default arguments. */
	i = 1 + (arg2 != NULL);
	for (parm = defparm; parm != void_list_node; parm = TREE_CHAIN (parm))
	t = tree_cons (NULL, convert_default_arg (TREE_VALUE (parm),
	TREE_PURPOSE (parm),
	fn, i++), t);
	t = build_call (fn, nreverse (t));
	append_to_statement_list (t, &ret);

	t = fold_convert (TREE_TYPE (p1), TYPE_SIZE_UNIT (inner_type));
	t = build2 (PLUS_EXPR, TREE_TYPE (p1), p1, t);
	t = build2 (MODIFY_EXPR, void_type_node, p1, t);
	append_to_statement_list (t, &ret);

	if (arg2)
	{
	t = fold_convert (TREE_TYPE (p2), TYPE_SIZE_UNIT (inner_type));
	t = build2 (PLUS_EXPR, TREE_TYPE (p2), p2, t);
	t = build2 (MODIFY_EXPR, void_type_node, p2, t);
	append_to_statement_list (t, &ret);
	}

	t = build2 (NE_EXPR, boolean_type_node, p1, end1);
	t = build3 (COND_EXPR, void_type_node, t, build_and_jump (&lab), NULL);
	append_to_statement_list (t, &ret);

	return ret;
	}
	else
	{
	tree t = tree_cons (NULL, build_fold_addr_expr (arg1), NULL);
	if (arg2)
	t = tree_cons (NULL, build_fold_addr_expr (arg2), t);
	/* Handle default arguments. */
	i = 1 + (arg2 != NULL);
	for (parm = defparm; parm != void_list_node; parm = TREE_CHAIN (parm))
	t = tree_cons (NULL, convert_default_arg (TREE_VALUE (parm),
	TREE_PURPOSE (parm),
	fn, i++), t);
	return build_call (fn, nreverse (t));
	}
	}

	/* Return code to initialize DECL with its default constructor, or
	NULL if there's nothing to do. */

	tree
	cxx_omp_clause_default_ctor (tree clause, tree decl)
	{
	tree info = CP_OMP_CLAUSE_INFO (clause);
	tree ret = NULL;

	if (info)
	ret = cxx_omp_clause_apply_fn (TREE_VEC_ELT (info, 0), decl, NULL);

	return ret;
	}

	/* Return code to initialize DST with a copy constructor from SRC. */

	tree
	cxx_omp_clause_copy_ctor (tree clause, tree dst, tree src)
	{
	tree info = CP_OMP_CLAUSE_INFO (clause);
	tree ret = NULL;

	if (info)
	ret = cxx_omp_clause_apply_fn (TREE_VEC_ELT (info, 0), dst, src);
	if (ret == NULL)
	ret = build2 (MODIFY_EXPR, void_type_node, dst, src);

	return ret;
	}

	/* Similarly, except use an assignment operator instead. */

	tree
	cxx_omp_clause_assign_op (tree clause, tree dst, tree src)
	{
	tree info = CP_OMP_CLAUSE_INFO (clause);
	tree ret = NULL;

	if (info)
	ret = cxx_omp_clause_apply_fn (TREE_VEC_ELT (info, 2), dst, src);
	if (ret == NULL)
	ret = build2 (MODIFY_EXPR, void_type_node, dst, src);

	return ret;
	}

	/* Return code to destroy DECL. */

	tree
	cxx_omp_clause_dtor (tree clause, tree decl)
	{
	tree info = CP_OMP_CLAUSE_INFO (clause);
	tree ret = NULL;

	if (info)
	ret = cxx_omp_clause_apply_fn (TREE_VEC_ELT (info, 1), decl, NULL);

	return ret;
	}

	/* True if OpenMP should privatize what this DECL points to rather
	than the DECL itself. */

	bool
	cxx_omp_privatize_by_reference (tree decl)
	{
	return is_invisiref_parm (decl);
	}
	diff --git a/contrib/gcc/cp/cp-tree.def b/contrib/gcc/cp/cp-tree.def
	index 55ef21ef7901..5915fb67981b 100644
	--- a/contrib/gcc/cp/cp-tree.def
	+++ b/contrib/gcc/cp/cp-tree.def
	@@ -1,349 +1,354 @@
	/* This file contains the definitions and documentation for the
	additional tree codes used in the GNU C++ compiler (see tree.def
	for the standard codes).
	Copyright (C) 1987, 1988, 1990, 1993, 1997, 1998, 2003, 2004, 2005,
	1999, 2000, 2001, 2002, 2003, 2004, 2005 Free Software Foundation, Inc.
	Hacked by Michael Tiemann (tiemann@cygnus.com)

	This file is part of GCC.

	GCC is free software; you can redistribute it and/or modify
	it under the terms of the GNU General Public License as published by
	the Free Software Foundation; either version 2, or (at your option)
	any later version.

	GCC is distributed in the hope that it will be useful,
	but WITHOUT ANY WARRANTY; without even the implied warranty of
	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	GNU General Public License for more details.

	You should have received a copy of the GNU General Public License
	along with GCC; see the file COPYING. If not, write to
	the Free Software Foundation, 51 Franklin Street, Fifth Floor,
	Boston, MA 02110-1301, USA. */


	/* An OFFSET_REF is used in two situations:

	1. An expression of the form `A::m' where `A' is a class and `m' is
	a non-static member. In this case, operand 0 will be a TYPE
	(corresponding to `A') and operand 1 will be a FIELD_DECL,
	BASELINK, or TEMPLATE_ID_EXPR (corresponding to `m').

	The expression is a pointer-to-member if its address is taken,
	but simply denotes a member of the object if its address is not
	taken.

	This form is only used during the parsing phase; once semantic
	analysis has taken place they are eliminated.

	2. An expression of the form `x.*p'. In this case, operand 0 will
	be an expression corresponding to `x' and operand 1 will be an
	expression with pointer-to-member type. */
	DEFTREECODE (OFFSET_REF, "offset_ref", tcc_reference, 2)

	/* A pointer-to-member constant. For a pointer-to-member constant
	`X::Y' The PTRMEM_CST_CLASS is the RECORD_TYPE for `X' and the
	PTRMEM_CST_MEMBER is the _DECL for `Y'. */
	DEFTREECODE (PTRMEM_CST, "ptrmem_cst", tcc_constant, 0)

	/* For NEW_EXPR, operand 0 is the placement list.
	Operand 1 is the new-declarator.
	Operand 2 is the number of elements in the array.
	Operand 3 is the initializer. */
	DEFTREECODE (NEW_EXPR, "nw_expr", tcc_expression, 4)
	DEFTREECODE (VEC_NEW_EXPR, "vec_nw_expr", tcc_expression, 3)

	/* For DELETE_EXPR, operand 0 is the store to be destroyed.
	Operand 1 is the value to pass to the destroying function
	saying whether the store should be deallocated as well. */
	DEFTREECODE (DELETE_EXPR, "dl_expr", tcc_expression, 2)
	DEFTREECODE (VEC_DELETE_EXPR, "vec_dl_expr", tcc_expression, 2)

	/* Value is reference to particular overloaded class method.
	Operand 0 is the class, operand 1 is the field
	The COMPLEXITY field holds the class level (usually 0). */
	DEFTREECODE (SCOPE_REF, "scope_ref", tcc_reference, 2)

	/* When composing an object with a member, this is the result.
	Operand 0 is the object. Operand 1 is the member (usually
	a dereferenced pointer to member). */
	DEFTREECODE (MEMBER_REF, "member_ref", tcc_reference, 2)

	/* Type conversion operator in C++. TREE_TYPE is type that this
	operator converts to. Operand is expression to be converted. */
	DEFTREECODE (TYPE_EXPR, "type_expr", tcc_expression, 1)

	/* For AGGR_INIT_EXPR, operand 0 is function which performs initialization,
	operand 1 is argument list to initialization function,
	and operand 2 is the slot which was allocated for this expression. */
	DEFTREECODE (AGGR_INIT_EXPR, "aggr_init_expr", tcc_expression, 3)

	/* A throw expression. operand 0 is the expression, if there was one,
	else it is NULL_TREE. */
	DEFTREECODE (THROW_EXPR, "throw_expr", tcc_expression, 1)

	/* An empty class object. The TREE_TYPE gives the class type. We use
	these to avoid actually creating instances of the empty classes. */
	DEFTREECODE (EMPTY_CLASS_EXPR, "empty_class_expr", tcc_expression, 0)

	/* A reference to a member function or member functions from a base
	class. BASELINK_FUNCTIONS gives the FUNCTION_DECL,
	TEMPLATE_DECL, OVERLOAD, or TEMPLATE_ID_EXPR corresponding to the
	functions. BASELINK_BINFO gives the base from which the functions
	come, i.e., the base to which the `this' pointer must be converted
	before the functions are called. BASELINK_ACCESS_BINFO gives the
	base used to name the functions.

	A BASELINK is an expression; the TREE_TYPE of the BASELINK gives
	the type of the expression. This type is either a FUNCTION_TYPE,
	METHOD_TYPE, or `unknown_type_node' indicating that the function is
	overloaded. */
	DEFTREECODE (BASELINK, "baselink", tcc_exceptional, 0)

	/* Template definition. The following fields have the specified uses,
	although there are other macros in cp-tree.h that should be used for
	accessing this data.
	DECL_ARGUMENTS template parm vector
	DECL_TEMPLATE_INFO template text &c
	DECL_VINDEX list of instantiations already produced;
	only done for functions so far
	For class template:
	DECL_INITIAL associated templates (methods &c)
	DECL_TEMPLATE_RESULT null
	For non-class templates:
	TREE_TYPE type of object to be constructed
	DECL_TEMPLATE_RESULT decl for object to be created
	(e.g., FUNCTION_DECL with tmpl parms used)
	*/
	DEFTREECODE (TEMPLATE_DECL, "template_decl", tcc_declaration, 0)

	/* Index into a template parameter list. The TEMPLATE_PARM_IDX gives
	the index (from 0) of the parameter, while the TEMPLATE_PARM_LEVEL
	gives the level (from 1) of the parameter.

	Here's an example:

	template <class T> // Index 0, Level 1.
	struct S
	{
	template <class U, // Index 0, Level 2.
	class V> // Index 1, Level 2.
	void f();
	};

	The DESCENDANTS will be a chain of TEMPLATE_PARM_INDEXs descended
	from this one. The first descendant will have the same IDX, but
	its LEVEL will be one less. The TREE_CHAIN field is used to chain
	together the descendants. The TEMPLATE_PARM_DECL is the
	declaration of this parameter, either a TYPE_DECL or CONST_DECL.
	The TEMPLATE_PARM_ORIG_LEVEL is the LEVEL of the most distant
	parent, i.e., the LEVEL that the parameter originally had when it
	was declared. For example, if we instantiate S<int>, we will have:

	struct S<int>
	{
	template <class U, // Index 0, Level 1, Orig Level 2
	class V> // Index 1, Level 1, Orig Level 2
	void f();
	};

	The LEVEL is the level of the parameter when we are worrying about
	the types of things; the ORIG_LEVEL is the level when we are
	worrying about instantiating things. */
	DEFTREECODE (TEMPLATE_PARM_INDEX, "template_parm_index", tcc_exceptional, 0)

	/* Index into a template parameter list for template template parameters.
	This parameter must be a type. The TYPE_FIELDS value will be a
	TEMPLATE_PARM_INDEX.

	It is used without template arguments like TT in C<TT>,
	TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO is NULL_TREE
	and TYPE_NAME is a TEMPLATE_DECL. */
	DEFTREECODE (TEMPLATE_TEMPLATE_PARM, "template_template_parm", tcc_type, 0)

	/* The ordering of the following codes is optimized for the checking
	macros in tree.h. Changing the order will degrade the speed of the
	compiler. TEMPLATE_TYPE_PARM, TYPENAME_TYPE, TYPEOF_TYPE,
	BOUND_TEMPLATE_TEMPLATE_PARM. */

	/* Index into a template parameter list. This parameter must be a type.
	The type.values field will be a TEMPLATE_PARM_INDEX. */
	DEFTREECODE (TEMPLATE_TYPE_PARM, "template_type_parm", tcc_type, 0)

	/* A type designated by `typename T::t'. TYPE_CONTEXT is `T',
	TYPE_NAME is an IDENTIFIER_NODE for `t'. If the type was named via
	template-id, TYPENAME_TYPE_FULLNAME will hold the TEMPLATE_ID_EXPR.
	TREE_TYPE is always NULL. */
	DEFTREECODE (TYPENAME_TYPE, "typename_type", tcc_type, 0)

	/* A type designated by `__typeof (expr)'. TYPEOF_TYPE_EXPR is the
	expression in question. */
	DEFTREECODE (TYPEOF_TYPE, "typeof_type", tcc_type, 0)

	/* Like TEMPLATE_TEMPLATE_PARM it is used with bound template arguments
	like TT<int>.
	In this case, TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO contains the
	template name and its bound arguments. TYPE_NAME is a TYPE_DECL. */
	DEFTREECODE (BOUND_TEMPLATE_TEMPLATE_PARM, "bound_template_template_parm",
	tcc_type, 0)

	/* For template template argument of the form `T::template C'.
	TYPE_CONTEXT is `T', the template parameter dependent object.
	TYPE_NAME is an IDENTIFIER_NODE for `C', the member class template. */
	DEFTREECODE (UNBOUND_CLASS_TEMPLATE, "unbound_class_template", tcc_type, 0)

	/* A using declaration. USING_DECL_SCOPE contains the specified
	scope. In a member using decl, unless DECL_DEPENDENT_P is true,
	USING_DECL_DECLS contains the _DECL or OVERLOAD so named. This is
	not an alias, but is later expanded into multiple aliases. */
	DEFTREECODE (USING_DECL, "using_decl", tcc_declaration, 0)

	/* A using directive. The operand is USING_STMT_NAMESPACE. */
	DEFTREECODE (USING_STMT, "using_directive", tcc_statement, 1)

	/* An un-parsed default argument. Holds a vector of input tokens and
	a vector of places where the argument was instantiated before
	parsing had occurred. */
	DEFTREECODE (DEFAULT_ARG, "default_arg", tcc_exceptional, 0)

	/* A template-id, like foo<int>. The first operand is the template.
	The second is NULL if there are no explicit arguments, or a
	TREE_VEC of arguments. The template will be a FUNCTION_DECL,
	TEMPLATE_DECL, or an OVERLOAD. If the template-id refers to a
	member template, the template may be an IDENTIFIER_NODE. */
	DEFTREECODE (TEMPLATE_ID_EXPR, "template_id_expr", tcc_expression, 2)

	/* A list-like node for chaining overloading candidates. TREE_TYPE is
	the original name, and the parameter is the FUNCTION_DECL. */
	DEFTREECODE (OVERLOAD, "overload", tcc_exceptional, 0)

	/* A pseudo-destructor, of the form "OBJECT.~DESTRUCTOR" or
	"OBJECT.SCOPE::~DESTRUCTOR. The first operand is the OBJECT. The
	second operand (if non-NULL) is the SCOPE. The third operand is
	the TYPE node corresponding to the DESTRUCTOR. The type of the
	first operand will always be a scalar type.

	The type of a PSEUDO_DTOR_EXPR is always "void", even though it can
	be used as if it were a zero-argument function. We handle the
	function-call case specially, and giving it "void" type prevents it
	being used in expressions in ways that are not permitted. */
	DEFTREECODE (PSEUDO_DTOR_EXPR, "pseudo_dtor_expr", tcc_expression, 3)

	/* A whole bunch of tree codes for the initial, superficial parsing of
	templates. */
	DEFTREECODE (MODOP_EXPR, "modop_expr", tcc_expression, 3)
	DEFTREECODE (CAST_EXPR, "cast_expr", tcc_unary, 1)
	DEFTREECODE (REINTERPRET_CAST_EXPR, "reinterpret_cast_expr", tcc_unary, 1)
	DEFTREECODE (CONST_CAST_EXPR, "const_cast_expr", tcc_unary, 1)
	DEFTREECODE (STATIC_CAST_EXPR, "static_cast_expr", tcc_unary, 1)
	DEFTREECODE (DYNAMIC_CAST_EXPR, "dynamic_cast_expr", tcc_unary, 1)
	DEFTREECODE (DOTSTAR_EXPR, "dotstar_expr", tcc_expression, 2)
	DEFTREECODE (TYPEID_EXPR, "typeid_expr", tcc_expression, 1)

	/* A placeholder for an expression that is not type-dependent, but
	does occur in a template. When an expression that is not
	type-dependent appears in a larger expression, we must compute the
	type of that larger expression. That computation would normally
	modify the original expression, which would change the mangling of
	that expression if it appeared in a template argument list. In
	that situation, we create a NON_DEPENDENT_EXPR to take the place of
	the original expression. The expression is the only operand -- it
	is only needed for diagnostics. */
	DEFTREECODE (NON_DEPENDENT_EXPR, "non_dependent_expr", tcc_expression, 1)

	/* CTOR_INITIALIZER is a placeholder in template code for a call to
	setup_vtbl_pointer (and appears in all functions, not just ctors). */
	DEFTREECODE (CTOR_INITIALIZER, "ctor_initializer", tcc_expression, 1)

	DEFTREECODE (TRY_BLOCK, "try_block", tcc_statement, 2)

	DEFTREECODE (EH_SPEC_BLOCK, "eh_spec_block", tcc_statement, 2)

	/* A HANDLER wraps a catch handler for the HANDLER_TYPE. If this is
	CATCH_ALL_TYPE, then the handler catches all types. The declaration of
	the catch variable is in HANDLER_PARMS, and the body block in
	HANDLER_BODY. */
	DEFTREECODE (HANDLER, "handler", tcc_statement, 2)

	/* A MUST_NOT_THROW_EXPR wraps an expression that may not
	throw, and must call terminate if it does. */
	DEFTREECODE (MUST_NOT_THROW_EXPR, "must_not_throw_expr", tcc_expression, 1)

	/* A CLEANUP_STMT marks the point at which a declaration is fully
	constructed. The CLEANUP_EXPR is run on behalf of CLEANUP_DECL
	when CLEANUP_BODY completes. */
	DEFTREECODE (CLEANUP_STMT, "cleanup_stmt", tcc_statement, 3)

	/* Represents an 'if' statement. The operands are IF_COND,
	THEN_CLAUSE, and ELSE_CLAUSE, respectively. */
	/* ??? It is currently still necessary to distinguish between IF_STMT
	and COND_EXPR for the benefit of templates. */
	DEFTREECODE (IF_STMT, "if_stmt", tcc_statement, 3)

	+/* APPLE LOCAL begin for-fsf-4_4 3274130 5295549 */ \
	/* Used to represent a `for' statement. The operands are
	- FOR_INIT_STMT, FOR_COND, FOR_EXPR, and FOR_BODY, respectively. */
	-DEFTREECODE (FOR_STMT, "for_stmt", tcc_statement, 4)
	+ FOR_INIT_STMT, FOR_COND, FOR_EXPR, FOR_BODY and FOR_ATTRIBUTES
	+ respectively. */
	+DEFTREECODE (FOR_STMT, "for_stmt", tcc_statement, 5)

	/* Used to represent a 'while' statement. The operands are WHILE_COND
	- and WHILE_BODY, respectively. */
	-DEFTREECODE (WHILE_STMT, "while_stmt", tcc_statement, 2)
	+ WHILE_BODY, and WHILE_ATTRIBUTES respectively. */
	+DEFTREECODE (WHILE_STMT, "while_stmt", tcc_statement, 3)

	-/* Used to represent a 'do' statement. The operands are DO_BODY and
	- DO_COND, respectively. */
	-DEFTREECODE (DO_STMT, "do_stmt", tcc_statement, 2)
	+/* APPLE LOCAL begin radar 4445586 */
	+/* Used to represent a 'do' statement. The operands are DO_BODY,
	+ DO_COND, DO_ATTRIBUTES, and DO_FOREACH respectively. */
	+DEFTREECODE (DO_STMT, "do_stmt", tcc_statement, 4)
	+/* APPLE LOCAL end radar 4445586 */

	+/* APPLE LOCAL end for-fsf-4_4 3274130 5295549 */ \
	/* Used to represent a 'break' statement. */
	DEFTREECODE (BREAK_STMT, "break_stmt", tcc_statement, 0)

	/* Used to represent a 'continue' statement. */
	DEFTREECODE (CONTINUE_STMT, "continue_stmt", tcc_statement, 0)

	/* Used to represent a 'switch' statement. The operands are
	SWITCH_STMT_COND, SWITCH_STMT_BODY and SWITCH_STMT_TYPE, respectively. */
	DEFTREECODE (SWITCH_STMT, "switch_stmt", tcc_statement, 3)

	/* Used to represent an expression statement. Use `EXPR_STMT_EXPR' to
	obtain the expression. */
	DEFTREECODE (EXPR_STMT, "expr_stmt", tcc_expression, 1)

	DEFTREECODE (TAG_DEFN, "tag_defn", tcc_expression, 0)

	/* Template instantiation level node.

	TINST_DECL contains the original DECL node.
	TINST_LOCATION contains the location where the template is instantiated.
	TINST_IN_SYSTEM_HEADER_P is true if the location is in a system header.

	A stack of template instantiation nodes is kept through the TREE_CHAIN
	fields of these nodes. */

	DEFTREECODE (TINST_LEVEL, "TINST_LEVEL", tcc_exceptional, 0)

	/* Represents an 'offsetof' expression during template expansion. */
	DEFTREECODE (OFFSETOF_EXPR, "offsetof_expr", tcc_expression, 1)

	/* Represents a 'sizeof' expression during template expansion. */
	DEFTREECODE (SIZEOF_EXPR, "sizeof_expr", tcc_expression, 1)

	/* Represents the -> operator during template expansion. */
	DEFTREECODE (ARROW_EXPR, "arrow_expr", tcc_expression, 1)

	/* Represents an '__alignof__' expression during template
	expansion. */
	DEFTREECODE (ALIGNOF_EXPR, "alignof_expr", tcc_expression, 1)

	/* A STMT_EXPR represents a statement-expression during template
	expansion. This is the GCC extension { ( ... ) }. The
	STMT_EXPR_STMT is the statement given by the expression. */
	DEFTREECODE (STMT_EXPR, "stmt_expr", tcc_expression, 1)

	/* Unary plus. Operand 0 is the expression to which the unary plus
	is applied. */
	DEFTREECODE (UNARY_PLUS_EXPR, "unary_plus_expr", tcc_unary, 1)

	/*
	Local variables:
	mode:c
	End:
	*/
	diff --git a/contrib/gcc/cp/cp-tree.h b/contrib/gcc/cp/cp-tree.h
	index 0b30f38809f3..6593832c6d70 100644
	--- a/contrib/gcc/cp/cp-tree.h
	+++ b/contrib/gcc/cp/cp-tree.h
	@@ -1,4583 +1,4604 @@
	/* Definitions for C++ parsing and type checking.
	Copyright (C) 1987, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
	2000, 2001, 2002, 2003, 2004, 2005, 2006 Free Software Foundation, Inc.
	Contributed by Michael Tiemann (tiemann@cygnus.com)

	This file is part of GCC.

	GCC is free software; you can redistribute it and/or modify
	it under the terms of the GNU General Public License as published by
	the Free Software Foundation; either version 2, or (at your option)
	any later version.

	GCC is distributed in the hope that it will be useful,
	but WITHOUT ANY WARRANTY; without even the implied warranty of
	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	GNU General Public License for more details.

	You should have received a copy of the GNU General Public License
	along with GCC; see the file COPYING. If not, write to
	the Free Software Foundation, 51 Franklin Street, Fifth Floor,
	Boston, MA 02110-1301, USA. */

	#ifndef GCC_CP_TREE_H
	#define GCC_CP_TREE_H

	#include "ggc.h"
	#include "function.h"
	#include "hashtab.h"
	#include "splay-tree.h"
	#include "vec.h"
	#include "varray.h"
	#include "c-common.h"
	#include "name-lookup.h"
	struct diagnostic_context;

	/* Usage of TREE_LANG_FLAG_?:
	0: IDENTIFIER_MARKED (IDENTIFIER_NODEs)
	NEW_EXPR_USE_GLOBAL (in NEW_EXPR).
	DELETE_EXPR_USE_GLOBAL (in DELETE_EXPR).
	COMPOUND_EXPR_OVERLOADED (in COMPOUND_EXPR).
	TREE_INDIRECT_USING (in NAMESPACE_DECL).
	CLEANUP_P (in TRY_BLOCK)
	AGGR_INIT_VIA_CTOR_P (in AGGR_INIT_EXPR)
	PTRMEM_OK_P (in ADDR_EXPR, OFFSET_REF)
	PAREN_STRING_LITERAL (in STRING_CST)
	DECL_PRETTY_FUNCTION_P (in VAR_DECL)
	KOENIG_LOOKUP_P (in CALL_EXPR)
	STATEMENT_LIST_NO_SCOPE (in STATEMENT_LIST).
	EXPR_STMT_STMT_EXPR_RESULT (in EXPR_STMT)
	STMT_EXPR_NO_SCOPE (in STMT_EXPR)
	BIND_EXPR_TRY_BLOCK (in BIND_EXPR)
	TYPENAME_IS_ENUM_P (in TYPENAME_TYPE)
	REFERENCE_REF_P (in INDIRECT_EXPR)
	QUALIFIED_NAME_IS_TEMPLATE (in SCOPE_REF)
	OMP_ATOMIC_DEPENDENT_P (in OMP_ATOMIC)
	OMP_FOR_GIMPLIFYING_P (in OMP_FOR)
	BASELINK_QUALIFIED_P (in BASELINK)
	TARGET_EXPR_IMPLICIT_P (in TARGET_EXPR)
	1: IDENTIFIER_VIRTUAL_P (in IDENTIFIER_NODE)
	TI_PENDING_TEMPLATE_FLAG.
	TEMPLATE_PARMS_FOR_INLINE.
	DELETE_EXPR_USE_VEC (in DELETE_EXPR).
	(TREE_CALLS_NEW) (in _EXPR or _REF) (commented-out).
	ICS_ELLIPSIS_FLAG (in _CONV)
	DECL_INITIALIZED_P (in VAR_DECL)
	TYPENAME_IS_CLASS_P (in TYPENAME_TYPE)
	STMT_IS_FULL_EXPR_P (in _STMT)
	2: IDENTIFIER_OPNAME_P (in IDENTIFIER_NODE)
	ICS_THIS_FLAG (in _CONV)
	DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (in VAR_DECL)
	STATEMENT_LIST_TRY_BLOCK (in STATEMENT_LIST)
	3: (TREE_REFERENCE_EXPR) (in NON_LVALUE_EXPR) (commented-out).
	ICS_BAD_FLAG (in _CONV)
	FN_TRY_BLOCK_P (in TRY_BLOCK)
	IDENTIFIER_CTOR_OR_DTOR_P (in IDENTIFIER_NODE)
	BIND_EXPR_BODY_BLOCK (in BIND_EXPR)
	DECL_NON_TRIVIALLY_INITIALIZED_P (in VAR_DECL)
	4: TREE_HAS_CONSTRUCTOR (in INDIRECT_REF, SAVE_EXPR, CONSTRUCTOR,
	or FIELD_DECL).
	IDENTIFIER_TYPENAME_P (in IDENTIFIER_NODE)
	DECL_TINFO_P (in VAR_DECL)
	5: C_IS_RESERVED_WORD (in IDENTIFIER_NODE)
	DECL_VTABLE_OR_VTT_P (in VAR_DECL)
	6: IDENTIFIER_REPO_CHOSEN (in IDENTIFIER_NODE)
	DECL_CONSTRUCTION_VTABLE_P (in VAR_DECL)
	TYPE_MARKED_P (in _TYPE)

	Usage of TYPE_LANG_FLAG_?:
	0: TYPE_DEPENDENT_P
	1: TYPE_HAS_CONSTRUCTOR.
	2: Unused
	3: TYPE_FOR_JAVA.
	4: TYPE_HAS_NONTRIVIAL_DESTRUCTOR
	5: IS_AGGR_TYPE.
	6: TYPE_DEPENDENT_P_VALID

	Usage of DECL_LANG_FLAG_?:
	0: DECL_ERROR_REPORTED (in VAR_DECL).
	DECL_TEMPLATE_PARM_P (in PARM_DECL, CONST_DECL, TYPE_DECL, or TEMPLATE_DECL)
	DECL_LOCAL_FUNCTION_P (in FUNCTION_DECL)
	DECL_MUTABLE_P (in FIELD_DECL)
	DECL_DEPENDENT_P (in USING_DECL)
	1: C_TYPEDEF_EXPLICITLY_SIGNED (in TYPE_DECL).
	DECL_TEMPLATE_INSTANTIATED (in a VAR_DECL or a FUNCTION_DECL)
	DECL_MEMBER_TEMPLATE_P (in TEMPLATE_DECL)
	2: DECL_THIS_EXTERN (in VAR_DECL or FUNCTION_DECL).
	DECL_IMPLICIT_TYPEDEF_P (in a TYPE_DECL)
	3: DECL_IN_AGGR_P.
	4: DECL_C_BIT_FIELD (in a FIELD_DECL)
	DECL_ANON_UNION_VAR_P (in a VAR_DECL)
	DECL_SELF_REFERENCE_P (in a TYPE_DECL)
	DECL_INVALID_OVERRIDER_P (in a FUNCTION_DECL)
	5: DECL_INTERFACE_KNOWN.
	6: DECL_THIS_STATIC (in VAR_DECL or FUNCTION_DECL).
	DECL_FIELD_IS_BASE (in FIELD_DECL)
	7: DECL_DEAD_FOR_LOCAL (in VAR_DECL).
	DECL_THUNK_P (in a member FUNCTION_DECL)

	Usage of language-independent fields in a language-dependent manner:

	TYPE_ALIAS_SET
	This field is used by TYPENAME_TYPEs, TEMPLATE_TYPE_PARMs, and so
	forth as a substitute for the mark bits provided in `lang_type'.
	At present, only the six low-order bits are used.

	TYPE_LANG_SLOT_1
	For an ENUMERAL_TYPE, this is ENUM_TEMPLATE_INFO.
	For a FUNCTION_TYPE or METHOD_TYPE, this is TYPE_RAISES_EXCEPTIONS

	BINFO_VIRTUALS
	For a binfo, this is a TREE_LIST. There is an entry for each
	virtual function declared either in BINFO or its direct and
	indirect primary bases.

	The BV_DELTA of each node gives the amount by which to adjust the
	`this' pointer when calling the function. If the method is an
	overridden version of a base class method, then it is assumed
	that, prior to adjustment, the this pointer points to an object
	of the base class.

	The BV_VCALL_INDEX of each node, if non-NULL, gives the vtable
	index of the vcall offset for this entry.

	The BV_FN is the declaration for the virtual function itself.

	BINFO_VTABLE
	This is an expression with POINTER_TYPE that gives the value
	to which the vptr should be initialized. Use get_vtbl_decl_for_binfo
	to extract the VAR_DECL for the complete vtable.

	DECL_ARGUMENTS
	For a VAR_DECL this is DECL_ANON_UNION_ELEMS.

	DECL_VINDEX
	This field is NULL for a non-virtual function. For a virtual
	function, it is eventually set to an INTEGER_CST indicating the
	index in the vtable at which this function can be found. When
	a virtual function is declared, but before it is known what
	function is overridden, this field is the error_mark_node.

	Temporarily, it may be set to a TREE_LIST whose TREE_VALUE is
	the virtual function this one overrides, and whose TREE_CHAIN is
	the old DECL_VINDEX. */

	/* Language-specific tree checkers. */

	#define VAR_OR_FUNCTION_DECL_CHECK(NODE) \
	TREE_CHECK2(NODE,VAR_DECL,FUNCTION_DECL)

	#define VAR_FUNCTION_OR_PARM_DECL_CHECK(NODE) \
	TREE_CHECK3(NODE,VAR_DECL,FUNCTION_DECL,PARM_DECL)

	#define VAR_TEMPL_TYPE_OR_FUNCTION_DECL_CHECK(NODE) \
	TREE_CHECK4(NODE,VAR_DECL,FUNCTION_DECL,TYPE_DECL,TEMPLATE_DECL)

	#define BOUND_TEMPLATE_TEMPLATE_PARM_TYPE_CHECK(NODE) \
	TREE_CHECK(NODE,BOUND_TEMPLATE_TEMPLATE_PARM)

	#if defined ENABLE_TREE_CHECKING && (GCC_VERSION >= 2007)
	#define NON_THUNK_FUNCTION_CHECK(NODE) __extension__ \
	({ const tree __t = (NODE); \
	if (TREE_CODE (__t) != FUNCTION_DECL && \
	TREE_CODE (__t) != TEMPLATE_DECL && __t->decl_common.lang_specific \
	&& __t->decl_common.lang_specific->decl_flags.thunk_p) \
	tree_check_failed (__t, __FILE__, __LINE__, __FUNCTION__, 0); \
	__t; })
	#define THUNK_FUNCTION_CHECK(NODE) __extension__ \
	({ const tree __t = (NODE); \
	if (TREE_CODE (__t) != FUNCTION_DECL \|\| !__t->decl_common.lang_specific \
	\|\| !__t->decl_common.lang_specific->decl_flags.thunk_p) \
	tree_check_failed (__t, __FILE__, __LINE__, __FUNCTION__, 0); \
	__t; })
	#else
	#define NON_THUNK_FUNCTION_CHECK(NODE) (NODE)
	#define THUNK_FUNCTION_CHECK(NODE) (NODE)
	#endif

	/* Language-dependent contents of an identifier. */

	struct lang_identifier GTY(())
	{
	struct c_common_identifier c_common;
	cxx_binding *namespace_bindings;
	cxx_binding *bindings;
	tree class_template_info;
	tree label_value;
	};

	/* In an IDENTIFIER_NODE, nonzero if this identifier is actually a
	keyword. C_RID_CODE (node) is then the RID_* value of the keyword,
	and C_RID_YYCODE is the token number wanted by Yacc. */

	#define C_IS_RESERVED_WORD(ID) TREE_LANG_FLAG_5 (ID)

	#define LANG_IDENTIFIER_CAST(NODE) \
	((struct lang_identifier*)IDENTIFIER_NODE_CHECK (NODE))

	struct template_parm_index_s GTY(())
	{
	struct tree_common common;
	HOST_WIDE_INT index;
	HOST_WIDE_INT level;
	HOST_WIDE_INT orig_level;
	tree decl;
	};
	typedef struct template_parm_index_s template_parm_index;

	struct tinst_level_s GTY(())
	{
	struct tree_common common;
	tree decl;
	location_t locus;
	int in_system_header_p;
	};
	typedef struct tinst_level_s * tinst_level_t;

	struct ptrmem_cst GTY(())
	{
	struct tree_common common;
	/* This isn't used, but the middle-end expects all constants to have
	this field. */
	rtx rtl;
	tree member;
	};
	typedef struct ptrmem_cst * ptrmem_cst_t;

	#define IDENTIFIER_GLOBAL_VALUE(NODE) \
	namespace_binding ((NODE), global_namespace)
	#define SET_IDENTIFIER_GLOBAL_VALUE(NODE, VAL) \
	set_namespace_binding ((NODE), global_namespace, (VAL))
	#define IDENTIFIER_NAMESPACE_VALUE(NODE) \
	namespace_binding ((NODE), current_namespace)
	#define SET_IDENTIFIER_NAMESPACE_VALUE(NODE, VAL) \
	set_namespace_binding ((NODE), current_namespace, (VAL))

	#define CLEANUP_P(NODE) TREE_LANG_FLAG_0 (TRY_BLOCK_CHECK (NODE))

	#define BIND_EXPR_TRY_BLOCK(NODE) \
	TREE_LANG_FLAG_0 (BIND_EXPR_CHECK (NODE))

	/* Used to mark the block around the member initializers and cleanups. */
	#define BIND_EXPR_BODY_BLOCK(NODE) \
	TREE_LANG_FLAG_3 (BIND_EXPR_CHECK (NODE))
	#define FUNCTION_NEEDS_BODY_BLOCK(NODE) \
	(DECL_CONSTRUCTOR_P (NODE) \|\| DECL_DESTRUCTOR_P (NODE))

	#define STATEMENT_LIST_NO_SCOPE(NODE) \
	TREE_LANG_FLAG_0 (STATEMENT_LIST_CHECK (NODE))
	#define STATEMENT_LIST_TRY_BLOCK(NODE) \
	TREE_LANG_FLAG_2 (STATEMENT_LIST_CHECK (NODE))

	/* Nonzero if this statement should be considered a full-expression,
	i.e., if temporaries created during this statement should have
	their destructors run at the end of this statement. */
	#define STMT_IS_FULL_EXPR_P(NODE) TREE_LANG_FLAG_1 ((NODE))

	/* Marks the result of a statement expression. */
	#define EXPR_STMT_STMT_EXPR_RESULT(NODE) \
	TREE_LANG_FLAG_0 (EXPR_STMT_CHECK (NODE))

	/* Nonzero if this statement-expression does not have an associated scope. */
	#define STMT_EXPR_NO_SCOPE(NODE) \
	TREE_LANG_FLAG_0 (STMT_EXPR_CHECK (NODE))

	/* Returns nonzero iff TYPE1 and TYPE2 are the same type, in the usual
	sense of `same'. */
	#define same_type_p(TYPE1, TYPE2) \
	comptypes ((TYPE1), (TYPE2), COMPARE_STRICT)

	/* Returns nonzero iff TYPE1 and TYPE2 are the same type, ignoring
	top-level qualifiers. */
	#define same_type_ignoring_top_level_qualifiers_p(TYPE1, TYPE2) \
	same_type_p (TYPE_MAIN_VARIANT (TYPE1), TYPE_MAIN_VARIANT (TYPE2))

	/* Nonzero if we are presently building a statement tree, rather
	than expanding each statement as we encounter it. */
	#define building_stmt_tree() (cur_stmt_list != NULL_TREE)

	/* Returns nonzero iff NODE is a declaration for the global function
	`main'. */
	#define DECL_MAIN_P(NODE) \
	(DECL_EXTERN_C_FUNCTION_P (NODE) \
	&& DECL_NAME (NODE) != NULL_TREE \
	&& MAIN_NAME_P (DECL_NAME (NODE)))

	/* The overloaded FUNCTION_DECL. */
	#define OVL_FUNCTION(NODE) \
	(((struct tree_overload*)OVERLOAD_CHECK (NODE))->function)
	#define OVL_CHAIN(NODE) TREE_CHAIN (NODE)
	/* Polymorphic access to FUNCTION and CHAIN. */
	#define OVL_CURRENT(NODE) \
	((TREE_CODE (NODE) == OVERLOAD) ? OVL_FUNCTION (NODE) : (NODE))
	#define OVL_NEXT(NODE) \
	((TREE_CODE (NODE) == OVERLOAD) ? TREE_CHAIN (NODE) : NULL_TREE)
	/* If set, this was imported in a using declaration.
	This is not to confuse with being used somewhere, which
	is not important for this node. */
	#define OVL_USED(NODE) TREE_USED (NODE)

	struct tree_overload GTY(())
	{
	struct tree_common common;
	tree function;
	};

	/* Returns true iff NODE is a BASELINK. */
	#define BASELINK_P(NODE) \
	(TREE_CODE (NODE) == BASELINK)
	/* The BINFO indicating the base from which the BASELINK_FUNCTIONS came. */
	#define BASELINK_BINFO(NODE) \
	(((struct tree_baselink*) BASELINK_CHECK (NODE))->binfo)
	/* The functions referred to by the BASELINK; either a FUNCTION_DECL,
	a TEMPLATE_DECL, an OVERLOAD, or a TEMPLATE_ID_EXPR. */
	#define BASELINK_FUNCTIONS(NODE) \
	(((struct tree_baselink*) BASELINK_CHECK (NODE))->functions)
	/* The BINFO in which the search for the functions indicated by this baselink
	began. This base is used to determine the accessibility of functions
	selected by overload resolution. */
	#define BASELINK_ACCESS_BINFO(NODE) \
	(((struct tree_baselink*) BASELINK_CHECK (NODE))->access_binfo)
	/* For a type-conversion operator, the BASELINK_OPTYPE indicates the type
	to which the conversion should occur. This value is important if
	the BASELINK_FUNCTIONS include a template conversion operator --
	the BASELINK_OPTYPE can be used to determine what type the user
	requested. */
	#define BASELINK_OPTYPE(NODE) \
	(TREE_CHAIN (BASELINK_CHECK (NODE)))
	/* Non-zero if this baselink was from a qualified lookup. */
	#define BASELINK_QUALIFIED_P(NODE) \
	TREE_LANG_FLAG_0 (BASELINK_CHECK (NODE))

	struct tree_baselink GTY(())
	{
	struct tree_common common;
	tree binfo;
	tree functions;
	tree access_binfo;
	};

	/* The different kinds of ids that we encounter. */

	typedef enum cp_id_kind
	{
	/* Not an id at all. */
	CP_ID_KIND_NONE,
	/* An unqualified-id that is not a template-id. */
	CP_ID_KIND_UNQUALIFIED,
	/* An unqualified-id that is a dependent name. */
	CP_ID_KIND_UNQUALIFIED_DEPENDENT,
	/* An unqualified template-id. */
	CP_ID_KIND_TEMPLATE_ID,
	/* A qualified-id. */
	CP_ID_KIND_QUALIFIED
	} cp_id_kind;

	/* Macros for access to language-specific slots in an identifier. */

	#define IDENTIFIER_NAMESPACE_BINDINGS(NODE) \
	(LANG_IDENTIFIER_CAST (NODE)->namespace_bindings)
	#define IDENTIFIER_TEMPLATE(NODE) \
	(LANG_IDENTIFIER_CAST (NODE)->class_template_info)

	/* The IDENTIFIER_BINDING is the innermost cxx_binding for the
	identifier. It's PREVIOUS is the next outermost binding. Each
	VALUE field is a DECL for the associated declaration. Thus,
	name lookup consists simply of pulling off the node at the front
	of the list (modulo oddities for looking up the names of types,
	and such.) You can use SCOPE field to determine the scope
	that bound the name. */
	#define IDENTIFIER_BINDING(NODE) \
	(LANG_IDENTIFIER_CAST (NODE)->bindings)

	/* TREE_TYPE only indicates on local and class scope the current
	type. For namespace scope, the presence of a type in any namespace
	is indicated with global_type_node, and the real type behind must
	be found through lookup. */
	#define IDENTIFIER_TYPE_VALUE(NODE) identifier_type_value (NODE)
	#define REAL_IDENTIFIER_TYPE_VALUE(NODE) TREE_TYPE (NODE)
	#define SET_IDENTIFIER_TYPE_VALUE(NODE,TYPE) (TREE_TYPE (NODE) = (TYPE))
	#define IDENTIFIER_HAS_TYPE_VALUE(NODE) (IDENTIFIER_TYPE_VALUE (NODE) ? 1 : 0)

	#define IDENTIFIER_LABEL_VALUE(NODE) \
	(LANG_IDENTIFIER_CAST (NODE)->label_value)
	#define SET_IDENTIFIER_LABEL_VALUE(NODE, VALUE) \
	IDENTIFIER_LABEL_VALUE (NODE) = (VALUE)

	/* Nonzero if this identifier is used as a virtual function name somewhere
	(optimizes searches). */
	#define IDENTIFIER_VIRTUAL_P(NODE) TREE_LANG_FLAG_1 (NODE)

	/* Nonzero if this identifier is the prefix for a mangled C++ operator
	name. */
	#define IDENTIFIER_OPNAME_P(NODE) TREE_LANG_FLAG_2 (NODE)

	/* Nonzero if this identifier is the name of a type-conversion
	operator. */
	#define IDENTIFIER_TYPENAME_P(NODE) \
	TREE_LANG_FLAG_4 (NODE)

	/* Nonzero if this identifier is the name of a constructor or
	destructor. */
	#define IDENTIFIER_CTOR_OR_DTOR_P(NODE) \
	TREE_LANG_FLAG_3 (NODE)

	/* True iff NAME is the DECL_ASSEMBLER_NAME for an entity with vague
	linkage which the prelinker has assigned to this translation
	unit. */
	#define IDENTIFIER_REPO_CHOSEN(NAME) \
	(TREE_LANG_FLAG_6 (NAME))

	/* In a RECORD_TYPE or UNION_TYPE, nonzero if any component is read-only. */
	#define C_TYPE_FIELDS_READONLY(TYPE) \
	(LANG_TYPE_CLASS_CHECK (TYPE)->fields_readonly)

	/* The tokens stored in the default argument. */

	#define DEFARG_TOKENS(NODE) \
	(((struct tree_default_arg *)DEFAULT_ARG_CHECK (NODE))->tokens)
	#define DEFARG_INSTANTIATIONS(NODE) \
	(((struct tree_default_arg *)DEFAULT_ARG_CHECK (NODE))->instantiations)

	struct tree_default_arg GTY (())
	{
	struct tree_common common;
	struct cp_token_cache *tokens;
	VEC(tree,gc) *instantiations;
	};

	enum cp_tree_node_structure_enum {
	TS_CP_GENERIC,
	TS_CP_IDENTIFIER,
	TS_CP_TPI,
	TS_CP_TINST_LEVEL,
	TS_CP_PTRMEM,
	TS_CP_BINDING,
	TS_CP_OVERLOAD,
	TS_CP_BASELINK,
	TS_CP_WRAPPER,
	TS_CP_DEFAULT_ARG,
	LAST_TS_CP_ENUM
	};

	/* The resulting tree type. */
	union lang_tree_node GTY((desc ("cp_tree_node_structure (&%h)"),
	chain_next ("(union lang_tree_node *)TREE_CHAIN (&%h.generic)")))
	{
	union tree_node GTY ((tag ("TS_CP_GENERIC"),
	desc ("tree_node_structure (&%h)"))) generic;
	struct template_parm_index_s GTY ((tag ("TS_CP_TPI"))) tpi;
	struct tinst_level_s GTY ((tag ("TS_CP_TINST_LEVEL"))) tinst_level;
	struct ptrmem_cst GTY ((tag ("TS_CP_PTRMEM"))) ptrmem;
	struct tree_overload GTY ((tag ("TS_CP_OVERLOAD"))) overload;
	struct tree_baselink GTY ((tag ("TS_CP_BASELINK"))) baselink;
	struct tree_default_arg GTY ((tag ("TS_CP_DEFAULT_ARG"))) default_arg;
	struct lang_identifier GTY ((tag ("TS_CP_IDENTIFIER"))) identifier;
	};


	enum cp_tree_index
	{
	CPTI_JAVA_BYTE_TYPE,
	CPTI_JAVA_SHORT_TYPE,
	CPTI_JAVA_INT_TYPE,
	CPTI_JAVA_LONG_TYPE,
	CPTI_JAVA_FLOAT_TYPE,
	CPTI_JAVA_DOUBLE_TYPE,
	CPTI_JAVA_CHAR_TYPE,
	CPTI_JAVA_BOOLEAN_TYPE,

	CPTI_WCHAR_DECL,
	CPTI_VTABLE_ENTRY_TYPE,
	CPTI_DELTA_TYPE,
	CPTI_VTABLE_INDEX_TYPE,
	CPTI_CLEANUP_TYPE,
	CPTI_VTT_PARM_TYPE,

	CPTI_CLASS_TYPE,
	CPTI_UNKNOWN_TYPE,
	CPTI_VTBL_TYPE,
	CPTI_VTBL_PTR_TYPE,
	CPTI_STD,
	CPTI_ABI,
	CPTI_CONST_TYPE_INFO_TYPE,
	CPTI_TYPE_INFO_PTR_TYPE,
	CPTI_ABORT_FNDECL,
	CPTI_GLOBAL_DELETE_FNDECL,
	CPTI_AGGR_TAG,

	CPTI_CTOR_IDENTIFIER,
	CPTI_COMPLETE_CTOR_IDENTIFIER,
	CPTI_BASE_CTOR_IDENTIFIER,
	CPTI_DTOR_IDENTIFIER,
	CPTI_COMPLETE_DTOR_IDENTIFIER,
	CPTI_BASE_DTOR_IDENTIFIER,
	CPTI_DELETING_DTOR_IDENTIFIER,
	CPTI_DELTA_IDENTIFIER,
	CPTI_IN_CHARGE_IDENTIFIER,
	CPTI_VTT_PARM_IDENTIFIER,
	CPTI_NELTS_IDENTIFIER,
	CPTI_THIS_IDENTIFIER,
	CPTI_PFN_IDENTIFIER,
	CPTI_VPTR_IDENTIFIER,
	CPTI_STD_IDENTIFIER,

	CPTI_LANG_NAME_C,
	CPTI_LANG_NAME_CPLUSPLUS,
	CPTI_LANG_NAME_JAVA,

	CPTI_EMPTY_EXCEPT_SPEC,
	CPTI_JCLASS,
	CPTI_TERMINATE,
	CPTI_CALL_UNEXPECTED,
	CPTI_ATEXIT,
	CPTI_DSO_HANDLE,
	CPTI_DCAST,

	CPTI_KEYED_CLASSES,

	CPTI_MAX
	};

	extern GTY(()) tree cp_global_trees[CPTI_MAX];

	#define java_byte_type_node cp_global_trees[CPTI_JAVA_BYTE_TYPE]
	#define java_short_type_node cp_global_trees[CPTI_JAVA_SHORT_TYPE]
	#define java_int_type_node cp_global_trees[CPTI_JAVA_INT_TYPE]
	#define java_long_type_node cp_global_trees[CPTI_JAVA_LONG_TYPE]
	#define java_float_type_node cp_global_trees[CPTI_JAVA_FLOAT_TYPE]
	#define java_double_type_node cp_global_trees[CPTI_JAVA_DOUBLE_TYPE]
	#define java_char_type_node cp_global_trees[CPTI_JAVA_CHAR_TYPE]
	#define java_boolean_type_node cp_global_trees[CPTI_JAVA_BOOLEAN_TYPE]

	#define wchar_decl_node cp_global_trees[CPTI_WCHAR_DECL]
	#define vtable_entry_type cp_global_trees[CPTI_VTABLE_ENTRY_TYPE]
	/* The type used to represent an offset by which to adjust the `this'
	pointer in pointer-to-member types. */
	#define delta_type_node cp_global_trees[CPTI_DELTA_TYPE]
	/* The type used to represent an index into the vtable. */
	#define vtable_index_type cp_global_trees[CPTI_VTABLE_INDEX_TYPE]

	#define class_type_node cp_global_trees[CPTI_CLASS_TYPE]
	#define unknown_type_node cp_global_trees[CPTI_UNKNOWN_TYPE]
	#define vtbl_type_node cp_global_trees[CPTI_VTBL_TYPE]
	#define vtbl_ptr_type_node cp_global_trees[CPTI_VTBL_PTR_TYPE]
	#define std_node cp_global_trees[CPTI_STD]
	#define abi_node cp_global_trees[CPTI_ABI]
	#define const_type_info_type_node cp_global_trees[CPTI_CONST_TYPE_INFO_TYPE]
	#define type_info_ptr_type cp_global_trees[CPTI_TYPE_INFO_PTR_TYPE]
	#define abort_fndecl cp_global_trees[CPTI_ABORT_FNDECL]
	#define global_delete_fndecl cp_global_trees[CPTI_GLOBAL_DELETE_FNDECL]
	#define current_aggr cp_global_trees[CPTI_AGGR_TAG]

	/* We cache these tree nodes so as to call get_identifier less
	frequently. */

	/* The name of a constructor that takes an in-charge parameter to
	decide whether or not to construct virtual base classes. */
	#define ctor_identifier cp_global_trees[CPTI_CTOR_IDENTIFIER]
	/* The name of a constructor that constructs virtual base classes. */
	#define complete_ctor_identifier cp_global_trees[CPTI_COMPLETE_CTOR_IDENTIFIER]
	/* The name of a constructor that does not construct virtual base classes. */
	#define base_ctor_identifier cp_global_trees[CPTI_BASE_CTOR_IDENTIFIER]
	/* The name of a destructor that takes an in-charge parameter to
	decide whether or not to destroy virtual base classes and whether
	or not to delete the object. */
	#define dtor_identifier cp_global_trees[CPTI_DTOR_IDENTIFIER]
	/* The name of a destructor that destroys virtual base classes. */
	#define complete_dtor_identifier cp_global_trees[CPTI_COMPLETE_DTOR_IDENTIFIER]
	/* The name of a destructor that does not destroy virtual base
	classes. */
	#define base_dtor_identifier cp_global_trees[CPTI_BASE_DTOR_IDENTIFIER]
	/* The name of a destructor that destroys virtual base classes, and
	then deletes the entire object. */
	#define deleting_dtor_identifier cp_global_trees[CPTI_DELETING_DTOR_IDENTIFIER]
	#define delta_identifier cp_global_trees[CPTI_DELTA_IDENTIFIER]
	#define in_charge_identifier cp_global_trees[CPTI_IN_CHARGE_IDENTIFIER]
	/* The name of the parameter that contains a pointer to the VTT to use
	for this subobject constructor or destructor. */
	#define vtt_parm_identifier cp_global_trees[CPTI_VTT_PARM_IDENTIFIER]
	#define nelts_identifier cp_global_trees[CPTI_NELTS_IDENTIFIER]
	#define this_identifier cp_global_trees[CPTI_THIS_IDENTIFIER]
	#define pfn_identifier cp_global_trees[CPTI_PFN_IDENTIFIER]
	#define vptr_identifier cp_global_trees[CPTI_VPTR_IDENTIFIER]
	/* The name of the std namespace. */
	#define std_identifier cp_global_trees[CPTI_STD_IDENTIFIER]
	#define lang_name_c cp_global_trees[CPTI_LANG_NAME_C]
	#define lang_name_cplusplus cp_global_trees[CPTI_LANG_NAME_CPLUSPLUS]
	#define lang_name_java cp_global_trees[CPTI_LANG_NAME_JAVA]

	/* Exception specifier used for throw(). */
	#define empty_except_spec cp_global_trees[CPTI_EMPTY_EXCEPT_SPEC]

	/* If non-NULL, a POINTER_TYPE equivalent to (java::lang::Class). /
	#define jclass_node cp_global_trees[CPTI_JCLASS]

	/* The declaration for `std::terminate'. */
	#define terminate_node cp_global_trees[CPTI_TERMINATE]

	/* The declaration for "__cxa_call_unexpected". */
	#define call_unexpected_node cp_global_trees[CPTI_CALL_UNEXPECTED]

	/* A pointer to `std::atexit'. */
	#define atexit_node cp_global_trees[CPTI_ATEXIT]

	/* A pointer to `__dso_handle'. */
	#define dso_handle_node cp_global_trees[CPTI_DSO_HANDLE]

	/* The declaration of the dynamic_cast runtime. */
	#define dynamic_cast_node cp_global_trees[CPTI_DCAST]

	/* The type of a destructor. */
	#define cleanup_type cp_global_trees[CPTI_CLEANUP_TYPE]

	/* The type of the vtt parameter passed to subobject constructors and
	destructors. */
	#define vtt_parm_type cp_global_trees[CPTI_VTT_PARM_TYPE]

	/* A TREE_LIST of the dynamic classes whose vtables may have to be
	emitted in this translation unit. */

	#define keyed_classes cp_global_trees[CPTI_KEYED_CLASSES]

	/* Node to indicate default access. This must be distinct from the
	access nodes in tree.h. */

	#define access_default_node null_node

	/* Global state. */

	struct saved_scope GTY(())
	{
	VEC(cxx_saved_binding,gc) *old_bindings;
	tree old_namespace;
	tree decl_ns_list;
	tree class_name;
	tree class_type;
	tree access_specifier;
	tree function_decl;
	VEC(tree,gc) *lang_base;
	tree lang_name;
	tree template_parms;
	struct cp_binding_level *x_previous_class_level;
	tree x_saved_tree;

	HOST_WIDE_INT x_processing_template_decl;
	int x_processing_specialization;
	bool x_processing_explicit_instantiation;
	int need_pop_function_context;
	bool skip_evaluation;

	struct stmt_tree_s x_stmt_tree;

	struct cp_binding_level *class_bindings;
	struct cp_binding_level *bindings;

	struct saved_scope *prev;
	};

	/* The current open namespace. */

	#define current_namespace scope_chain->old_namespace

	/* The stack for namespaces of current declarations. */

	#define decl_namespace_list scope_chain->decl_ns_list

	/* IDENTIFIER_NODE: name of current class */

	#define current_class_name scope_chain->class_name

	/* _TYPE: the type of the current class */

	#define current_class_type scope_chain->class_type

	/* When parsing a class definition, the access specifier most recently
	given by the user, or, if no access specifier was given, the
	default value appropriate for the kind of class (i.e., struct,
	class, or union). */

	#define current_access_specifier scope_chain->access_specifier

	/* Pointer to the top of the language name stack. */

	#define current_lang_base scope_chain->lang_base
	#define current_lang_name scope_chain->lang_name

	/* Parsing a function declarator leaves a list of parameter names
	or a chain or parameter decls here. */

	#define current_template_parms scope_chain->template_parms

	#define processing_template_decl scope_chain->x_processing_template_decl
	#define processing_specialization scope_chain->x_processing_specialization
	#define processing_explicit_instantiation scope_chain->x_processing_explicit_instantiation

	/* The cached class binding level, from the most recently exited
	class, or NULL if none. */

	#define previous_class_level scope_chain->x_previous_class_level

	/* A list of private types mentioned, for deferred access checking. */

	extern GTY(()) struct saved_scope *scope_chain;

	struct cxx_int_tree_map GTY(())
	{
	unsigned int uid;
	tree to;
	};

	extern unsigned int cxx_int_tree_map_hash (const void *);
	extern int cxx_int_tree_map_eq (const void , const void );

	/* Global state pertinent to the current function. */

	struct language_function GTY(())
	{
	struct c_language_function base;

	tree x_cdtor_label;
	tree x_current_class_ptr;
	tree x_current_class_ref;
	tree x_eh_spec_block;
	tree x_in_charge_parm;
	tree x_vtt_parm;
	tree x_return_value;

	int returns_value;
	int returns_null;
	int returns_abnormally;
	int in_function_try_handler;
	int in_base_initializer;

	/* True if this function can throw an exception. */
	BOOL_BITFIELD can_throw : 1;

	htab_t GTY((param_is(struct named_label_entry))) x_named_labels;
	struct cp_binding_level *bindings;
	VEC(tree,gc) *x_local_names;
	htab_t GTY((param_is (struct cxx_int_tree_map))) extern_decl_map;
	};

	/* The current C++-specific per-function global variables. */

	#define cp_function_chain (cfun->language)

	/* In a constructor destructor, the point at which all derived class
	destroying/construction has been has been done. Ie. just before a
	constructor returns, or before any base class destroying will be done
	in a destructor. */

	#define cdtor_label cp_function_chain->x_cdtor_label

	/* When we're processing a member function, current_class_ptr is the
	PARM_DECL for the `this' pointer. The current_class_ref is an
	expression for `this'. /

	#define current_class_ptr \
	(cfun ? cp_function_chain->x_current_class_ptr : NULL_TREE)
	#define current_class_ref \
	(cfun ? cp_function_chain->x_current_class_ref : NULL_TREE)

	/* The EH_SPEC_BLOCK for the exception-specifiers for the current
	function, if any. */

	#define current_eh_spec_block cp_function_chain->x_eh_spec_block

	/* The `__in_chrg' parameter for the current function. Only used for
	constructors and destructors. */

	#define current_in_charge_parm cp_function_chain->x_in_charge_parm

	/* The `__vtt_parm' parameter for the current function. Only used for
	constructors and destructors. */

	#define current_vtt_parm cp_function_chain->x_vtt_parm

	/* Set to 0 at beginning of a function definition, set to 1 if
	a return statement that specifies a return value is seen. */

	#define current_function_returns_value cp_function_chain->returns_value

	/* Set to 0 at beginning of a function definition, set to 1 if
	a return statement with no argument is seen. */

	#define current_function_returns_null cp_function_chain->returns_null

	/* Set to 0 at beginning of a function definition, set to 1 if
	a call to a noreturn function is seen. */

	#define current_function_returns_abnormally \
	cp_function_chain->returns_abnormally

	/* Nonzero if we are processing a base initializer. Zero elsewhere. */
	#define in_base_initializer cp_function_chain->in_base_initializer

	#define in_function_try_handler cp_function_chain->in_function_try_handler

	/* Expression always returned from function, or error_mark_node
	otherwise, for use by the automatic named return value optimization. */

	#define current_function_return_value \
	(cp_function_chain->x_return_value)

	/* True if NAME is the IDENTIFIER_NODE for an overloaded "operator
	new" or "operator delete". */
	#define NEW_DELETE_OPNAME_P(NAME) \
	((NAME) == ansi_opname (NEW_EXPR) \
	\|\| (NAME) == ansi_opname (VEC_NEW_EXPR) \
	\|\| (NAME) == ansi_opname (DELETE_EXPR) \
	\|\| (NAME) == ansi_opname (VEC_DELETE_EXPR))

	#define ansi_opname(CODE) \
	(operator_name_info[(int) (CODE)].identifier)
	#define ansi_assopname(CODE) \
	(assignment_operator_name_info[(int) (CODE)].identifier)

	/* True if NODE is an erroneous expression. */

	#define error_operand_p(NODE) \
	((NODE) == error_mark_node \
	\|\| ((NODE) && TREE_TYPE ((NODE)) == error_mark_node))

	/* C++ language-specific tree codes. */
	#define DEFTREECODE(SYM, NAME, TYPE, LENGTH) SYM,
	enum cplus_tree_code {
	CP_DUMMY_TREE_CODE = LAST_C_TREE_CODE,
	#include "cp-tree.def"
	LAST_CPLUS_TREE_CODE
	};
	#undef DEFTREECODE

	/* TRUE if a tree code represents a statement. */
	extern bool statement_code_p[MAX_TREE_CODES];

	#define STATEMENT_CODE_P(CODE) statement_code_p[(int) (CODE)]

	enum languages { lang_c, lang_cplusplus, lang_java };

	/* Macros to make error reporting functions' lives easier. */
	#define TYPE_IDENTIFIER(NODE) (DECL_NAME (TYPE_NAME (NODE)))
	#define TYPE_LINKAGE_IDENTIFIER(NODE) \
	(TYPE_IDENTIFIER (TYPE_MAIN_VARIANT (NODE)))
	#define TYPE_NAME_STRING(NODE) (IDENTIFIER_POINTER (TYPE_IDENTIFIER (NODE)))
	#define TYPE_NAME_LENGTH(NODE) (IDENTIFIER_LENGTH (TYPE_IDENTIFIER (NODE)))

	/* Nonzero if NODE has no name for linkage purposes. */
	#define TYPE_ANONYMOUS_P(NODE) \
	(TAGGED_TYPE_P (NODE) && ANON_AGGRNAME_P (TYPE_LINKAGE_IDENTIFIER (NODE)))

	/* The _DECL for this _TYPE. */
	#define TYPE_MAIN_DECL(NODE) (TYPE_STUB_DECL (TYPE_MAIN_VARIANT (NODE)))

	/* Nonzero if T is a class (or struct or union) type. Also nonzero
	for template type parameters, typename types, and instantiated
	template template parameters. Despite its name,
	this macro has nothing to do with the definition of aggregate given
	in the standard. Think of this macro as MAYBE_CLASS_TYPE_P. Keep
	these checks in ascending code order. */
	#define IS_AGGR_TYPE(T) \
	(TREE_CODE (T) == TEMPLATE_TYPE_PARM \
	\|\| TREE_CODE (T) == TYPENAME_TYPE \
	\|\| TREE_CODE (T) == TYPEOF_TYPE \
	\|\| TREE_CODE (T) == BOUND_TEMPLATE_TEMPLATE_PARM \
	\|\| TYPE_LANG_FLAG_5 (T))

	/* Set IS_AGGR_TYPE for T to VAL. T must be a class, struct, or
	union type. */
	#define SET_IS_AGGR_TYPE(T, VAL) \
	(TYPE_LANG_FLAG_5 (T) = (VAL))

	/* Nonzero if T is a class type. Zero for template type parameters,
	typename types, and so forth. */
	#define CLASS_TYPE_P(T) \
	(IS_AGGR_TYPE_CODE (TREE_CODE (T)) && TYPE_LANG_FLAG_5 (T))

	/* Keep these checks in ascending code order. */
	#define IS_AGGR_TYPE_CODE(T) \
	((T) == RECORD_TYPE \|\| (T) == UNION_TYPE)
	#define TAGGED_TYPE_P(T) \
	(CLASS_TYPE_P (T) \|\| TREE_CODE (T) == ENUMERAL_TYPE)
	#define IS_OVERLOAD_TYPE(T) TAGGED_TYPE_P (T)

	/* True if this a "Java" type, defined in 'extern "Java"'. */
	#define TYPE_FOR_JAVA(NODE) TYPE_LANG_FLAG_3 (NODE)

	/* True if this type is dependent. This predicate is only valid if
	TYPE_DEPENDENT_P_VALID is true. */
	#define TYPE_DEPENDENT_P(NODE) TYPE_LANG_FLAG_0 (NODE)

	/* True if dependent_type_p has been called for this type, with the
	result that TYPE_DEPENDENT_P is valid. */
	#define TYPE_DEPENDENT_P_VALID(NODE) TYPE_LANG_FLAG_6(NODE)

	/* Nonzero if this type is const-qualified. */
	#define CP_TYPE_CONST_P(NODE) \
	((cp_type_quals (NODE) & TYPE_QUAL_CONST) != 0)

	/* Nonzero if this type is volatile-qualified. */
	#define CP_TYPE_VOLATILE_P(NODE) \
	((cp_type_quals (NODE) & TYPE_QUAL_VOLATILE) != 0)

	/* Nonzero if this type is restrict-qualified. */
	#define CP_TYPE_RESTRICT_P(NODE) \
	((cp_type_quals (NODE) & TYPE_QUAL_RESTRICT) != 0)

	/* Nonzero if this type is const-qualified, but not
	volatile-qualified. Other qualifiers are ignored. This macro is
	used to test whether or not it is OK to bind an rvalue to a
	reference. */
	#define CP_TYPE_CONST_NON_VOLATILE_P(NODE) \
	((cp_type_quals (NODE) & (TYPE_QUAL_CONST \| TYPE_QUAL_VOLATILE)) \
	== TYPE_QUAL_CONST)

	#define FUNCTION_ARG_CHAIN(NODE) \
	TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (NODE)))

	/* Given a FUNCTION_DECL, returns the first TREE_LIST out of TYPE_ARG_TYPES
	which refers to a user-written parameter. */
	#define FUNCTION_FIRST_USER_PARMTYPE(NODE) \
	skip_artificial_parms_for ((NODE), TYPE_ARG_TYPES (TREE_TYPE (NODE)))

	/* Similarly, but for DECL_ARGUMENTS. */
	#define FUNCTION_FIRST_USER_PARM(NODE) \
	skip_artificial_parms_for ((NODE), DECL_ARGUMENTS (NODE))

	#define PROMOTES_TO_AGGR_TYPE(NODE, CODE) \
	(((CODE) == TREE_CODE (NODE) \
	&& IS_AGGR_TYPE (TREE_TYPE (NODE))) \
	\|\| IS_AGGR_TYPE (NODE))

	/* Nonzero iff TYPE is derived from PARENT. Ignores accessibility and
	ambiguity issues. */
	#define DERIVED_FROM_P(PARENT, TYPE) \
	(lookup_base ((TYPE), (PARENT), ba_any, NULL) != NULL_TREE)
	/* Nonzero iff TYPE is uniquely derived from PARENT. Ignores
	accessibility. */
	#define UNIQUELY_DERIVED_FROM_P(PARENT, TYPE) \
	(lookup_base ((TYPE), (PARENT), ba_unique \| ba_quiet, NULL) != NULL_TREE)
	/* Nonzero iff TYPE is publicly & uniquely derived from PARENT. */
	#define PUBLICLY_UNIQUELY_DERIVED_P(PARENT, TYPE) \
	(lookup_base ((TYPE), (PARENT), ba_ignore_scope \| ba_check \| ba_quiet, \
	NULL) != NULL_TREE)

	/* Gives the visibility specification for a class type. */
	#define CLASSTYPE_VISIBILITY(TYPE) \
	DECL_VISIBILITY (TYPE_NAME (TYPE))
	#define CLASSTYPE_VISIBILITY_SPECIFIED(TYPE) \
	DECL_VISIBILITY_SPECIFIED (TYPE_NAME (TYPE))

	typedef struct tree_pair_s GTY (())
	{
	tree purpose;
	tree value;
	} tree_pair_s;
	typedef tree_pair_s *tree_pair_p;
	DEF_VEC_O (tree_pair_s);
	DEF_VEC_ALLOC_O (tree_pair_s,gc);

	/* This is a few header flags for 'struct lang_type'. Actually,
	all but the first are used only for lang_type_class; they
	are put in this structure to save space. */
	struct lang_type_header GTY(())
	{
	BOOL_BITFIELD is_lang_type_class : 1;

	BOOL_BITFIELD has_type_conversion : 1;
	BOOL_BITFIELD has_init_ref : 1;
	BOOL_BITFIELD has_default_ctor : 1;
	BOOL_BITFIELD const_needs_init : 1;
	BOOL_BITFIELD ref_needs_init : 1;
	BOOL_BITFIELD has_const_assign_ref : 1;

	BOOL_BITFIELD spare : 1;
	};

	/* This structure provides additional information above and beyond
	what is provide in the ordinary tree_type. In the past, we used it
	for the types of class types, template parameters types, typename
	types, and so forth. However, there can be many (tens to hundreds
	of thousands) of template parameter types in a compilation, and
	there's no need for this additional information in that case.
	Therefore, we now use this data structure only for class types.

	In the past, it was thought that there would be relatively few
	class types. However, in the presence of heavy use of templates,
	many (i.e., thousands) of classes can easily be generated.
	Therefore, we should endeavor to keep the size of this structure to
	a minimum. */
	struct lang_type_class GTY(())
	{
	struct lang_type_header h;

	unsigned char align;

	unsigned has_mutable : 1;
	unsigned com_interface : 1;
	unsigned non_pod_class : 1;
	unsigned nearly_empty_p : 1;
	unsigned user_align : 1;
	unsigned has_assign_ref : 1;
	unsigned has_new : 1;
	unsigned has_array_new : 1;

	unsigned gets_delete : 2;
	unsigned interface_only : 1;
	unsigned interface_unknown : 1;
	unsigned contains_empty_class_p : 1;
	unsigned anon_aggr : 1;
	unsigned non_zero_init : 1;
	unsigned empty_p : 1;

	unsigned vec_new_uses_cookie : 1;
	unsigned declared_class : 1;
	unsigned diamond_shaped : 1;
	unsigned repeated_base : 1;
	unsigned being_defined : 1;
	unsigned java_interface : 1;
	unsigned debug_requested : 1;
	unsigned fields_readonly : 1;

	unsigned use_template : 2;
	unsigned ptrmemfunc_flag : 1;
	unsigned was_anonymous : 1;
	unsigned lazy_default_ctor : 1;
	unsigned lazy_copy_ctor : 1;
	unsigned lazy_assignment_op : 1;
	unsigned lazy_destructor : 1;

	unsigned has_const_init_ref : 1;
	unsigned has_complex_init_ref : 1;
	unsigned has_complex_assign_ref : 1;
	unsigned non_aggregate : 1;

	/* When adding a flag here, consider whether or not it ought to
	apply to a template instance if it applies to the template. If
	so, make sure to copy it in instantiate_class_template! */

	/* There are some bits left to fill out a 32-bit word. Keep track
	of this by updating the size of this bitfield whenever you add or
	remove a flag. */
	unsigned dummy : 12;

	tree primary_base;
	VEC(tree_pair_s,gc) *vcall_indices;
	tree vtables;
	tree typeinfo_var;
	VEC(tree,gc) *vbases;
	binding_table nested_udts;
	tree as_base;
	VEC(tree,gc) *pure_virtuals;
	tree friend_classes;
	VEC(tree,gc) * GTY((reorder ("resort_type_method_vec"))) methods;
	tree key_method;
	tree decl_list;
	tree template_info;
	tree befriending_classes;
	/* In a RECORD_TYPE, information specific to Objective-C++, such
	as a list of adopted protocols or a pointer to a corresponding
	@interface. See objc/objc-act.h for details. */
	tree objc_info;
	};

	struct lang_type_ptrmem GTY(())
	{
	struct lang_type_header h;
	tree record;
	};

	struct lang_type GTY(())
	{
	union lang_type_u
	{
	struct lang_type_header GTY((skip (""))) h;
	struct lang_type_class GTY((tag ("1"))) c;
	struct lang_type_ptrmem GTY((tag ("0"))) ptrmem;
	} GTY((desc ("%h.h.is_lang_type_class"))) u;
	};

	#if defined ENABLE_TREE_CHECKING && (GCC_VERSION >= 2007)

	#define LANG_TYPE_CLASS_CHECK(NODE) __extension__ \
	({ struct lang_type *lt = TYPE_LANG_SPECIFIC (NODE); \
	if (! lt->u.h.is_lang_type_class) \
	lang_check_failed (__FILE__, __LINE__, __FUNCTION__); \
	&lt->u.c; })

	#define LANG_TYPE_PTRMEM_CHECK(NODE) __extension__ \
	({ struct lang_type *lt = TYPE_LANG_SPECIFIC (NODE); \
	if (lt->u.h.is_lang_type_class) \
	lang_check_failed (__FILE__, __LINE__, __FUNCTION__); \
	&lt->u.ptrmem; })

	#else

	#define LANG_TYPE_CLASS_CHECK(NODE) (&TYPE_LANG_SPECIFIC (NODE)->u.c)
	#define LANG_TYPE_PTRMEM_CHECK(NODE) (&TYPE_LANG_SPECIFIC (NODE)->u.ptrmem)

	#endif /* ENABLE_TREE_CHECKING */

	/* Fields used for storing information before the class is defined.
	After the class is defined, these fields hold other information. */

	/* VEC(tree) of friends which were defined inline in this class
	definition. */
	#define CLASSTYPE_INLINE_FRIENDS(NODE) CLASSTYPE_PURE_VIRTUALS (NODE)

	/* Nonzero for _CLASSTYPE means that operator delete is defined. */
	#define TYPE_GETS_DELETE(NODE) (LANG_TYPE_CLASS_CHECK (NODE)->gets_delete)
	#define TYPE_GETS_REG_DELETE(NODE) (TYPE_GETS_DELETE (NODE) & 1)

	/* Nonzero if `new NODE[x]' should cause the allocation of extra
	storage to indicate how many array elements are in use. */
	#define TYPE_VEC_NEW_USES_COOKIE(NODE) \
	(CLASS_TYPE_P (NODE) \
	&& LANG_TYPE_CLASS_CHECK (NODE)->vec_new_uses_cookie)

	/* Nonzero means that this _CLASSTYPE node defines ways of converting
	itself to other types. */
	#define TYPE_HAS_CONVERSION(NODE) \
	(LANG_TYPE_CLASS_CHECK (NODE)->h.has_type_conversion)

	/* Nonzero means that NODE (a class type) has a default constructor --
	but that it has not yet been declared. */
	#define CLASSTYPE_LAZY_DEFAULT_CTOR(NODE) \
	(LANG_TYPE_CLASS_CHECK (NODE)->lazy_default_ctor)

	/* Nonzero means that NODE (a class type) has a copy constructor --
	but that it has not yet been declared. */
	#define CLASSTYPE_LAZY_COPY_CTOR(NODE) \
	(LANG_TYPE_CLASS_CHECK (NODE)->lazy_copy_ctor)

	/* Nonzero means that NODE (a class type) has an assignment operator
	-- but that it has not yet been declared. */
	#define CLASSTYPE_LAZY_ASSIGNMENT_OP(NODE) \
	(LANG_TYPE_CLASS_CHECK (NODE)->lazy_assignment_op)

	/* Nonzero means that NODE (a class type) has a destructor -- but that
	it has not yet been declared. */
	#define CLASSTYPE_LAZY_DESTRUCTOR(NODE) \
	(LANG_TYPE_CLASS_CHECK (NODE)->lazy_destructor)

	/* Nonzero means that this _CLASSTYPE node overloads operator=(X&). */
	#define TYPE_HAS_ASSIGN_REF(NODE) (LANG_TYPE_CLASS_CHECK (NODE)->has_assign_ref)

	/* True iff the class type NODE has an "operator =" whose parameter
	has a parameter of type "const X&". */
	#define TYPE_HAS_CONST_ASSIGN_REF(NODE) \
	(LANG_TYPE_CLASS_CHECK (NODE)->h.has_const_assign_ref)

	/* Nonzero means that this _CLASSTYPE node has an X(X&) constructor. */
	#define TYPE_HAS_INIT_REF(NODE) (LANG_TYPE_CLASS_CHECK (NODE)->h.has_init_ref)
	#define TYPE_HAS_CONST_INIT_REF(NODE) \
	(LANG_TYPE_CLASS_CHECK (NODE)->has_const_init_ref)

	/* Nonzero if this class defines an overloaded operator new. (An
	operator new [] doesn't count.) */
	#define TYPE_HAS_NEW_OPERATOR(NODE) \
	(LANG_TYPE_CLASS_CHECK (NODE)->has_new)

	/* Nonzero if this class defines an overloaded operator new[]. */
	#define TYPE_HAS_ARRAY_NEW_OPERATOR(NODE) \
	(LANG_TYPE_CLASS_CHECK (NODE)->has_array_new)

	/* Nonzero means that this type is being defined. I.e., the left brace
	starting the definition of this type has been seen. */
	#define TYPE_BEING_DEFINED(NODE) (LANG_TYPE_CLASS_CHECK (NODE)->being_defined)

	/* Mark bits for repeated base checks. */
	#define TYPE_MARKED_P(NODE) TREE_LANG_FLAG_6 (TYPE_CHECK (NODE))

	/* Nonzero if the class NODE has multiple paths to the same (virtual)
	base object. */
	#define CLASSTYPE_DIAMOND_SHAPED_P(NODE) \
	(LANG_TYPE_CLASS_CHECK(NODE)->diamond_shaped)

	/* Nonzero if the class NODE has multiple instances of the same base
	type. */
	#define CLASSTYPE_REPEATED_BASE_P(NODE) \
	(LANG_TYPE_CLASS_CHECK(NODE)->repeated_base)

	/* The member function with which the vtable will be emitted:
	the first noninline non-pure-virtual member function. NULL_TREE
	if there is no key function or if this is a class template */
	#define CLASSTYPE_KEY_METHOD(NODE) (LANG_TYPE_CLASS_CHECK (NODE)->key_method)

	/* Vector member functions defined in this class. Each element is
	either a FUNCTION_DECL, a TEMPLATE_DECL, or an OVERLOAD. All
	functions with the same name end up in the same slot. The first
	two elements are for constructors, and destructors, respectively.
	All template conversion operators to innermost template dependent
	types are overloaded on the next slot, if they exist. Note, the
	names for these functions will not all be the same. The
	non-template conversion operators & templated conversions to
	non-innermost template types are next, followed by ordinary member
	functions. There may be empty entries at the end of the vector.
	The conversion operators are unsorted. The ordinary member
	functions are sorted, once the class is complete. */
	#define CLASSTYPE_METHOD_VEC(NODE) (LANG_TYPE_CLASS_CHECK (NODE)->methods)

	/* For class templates, this is a TREE_LIST of all member data,
	functions, types, and friends in the order of declaration.
	The TREE_PURPOSE of each TREE_LIST is NULL_TREE for a friend,
	and the RECORD_TYPE for the class template otherwise. */
	#define CLASSTYPE_DECL_LIST(NODE) (LANG_TYPE_CLASS_CHECK (NODE)->decl_list)

	/* The slot in the CLASSTYPE_METHOD_VEC where constructors go. */
	#define CLASSTYPE_CONSTRUCTOR_SLOT 0

	/* The slot in the CLASSTYPE_METHOD_VEC where destructors go. */
	#define CLASSTYPE_DESTRUCTOR_SLOT 1

	/* The first slot in the CLASSTYPE_METHOD_VEC where conversion
	operators can appear. */
	#define CLASSTYPE_FIRST_CONVERSION_SLOT 2

	/* A FUNCTION_DECL or OVERLOAD for the constructors for NODE. These
	are the constructors that take an in-charge parameter. */
	#define CLASSTYPE_CONSTRUCTORS(NODE) \
	(VEC_index (tree, CLASSTYPE_METHOD_VEC (NODE), CLASSTYPE_CONSTRUCTOR_SLOT))

	/* A FUNCTION_DECL for the destructor for NODE. These are the
	destructors that take an in-charge parameter. If
	CLASSTYPE_LAZY_DESTRUCTOR is true, then this entry will be NULL
	until the destructor is created with lazily_declare_fn. */
	#define CLASSTYPE_DESTRUCTORS(NODE) \
	(CLASSTYPE_METHOD_VEC (NODE) \
	? VEC_index (tree, CLASSTYPE_METHOD_VEC (NODE), CLASSTYPE_DESTRUCTOR_SLOT) \
	: NULL_TREE)

	/* A dictionary of the nested user-defined-types (class-types, or enums)
	found within this class. This table includes nested member class
	templates. */
	#define CLASSTYPE_NESTED_UTDS(NODE) \
	(LANG_TYPE_CLASS_CHECK (NODE)->nested_udts)

	/* Nonzero if NODE has a primary base class, i.e., a base class with
	which it shares the virtual function table pointer. */
	#define CLASSTYPE_HAS_PRIMARY_BASE_P(NODE) \
	(CLASSTYPE_PRIMARY_BINFO (NODE) != NULL_TREE)

	/* If non-NULL, this is the binfo for the primary base class, i.e.,
	the base class which contains the virtual function table pointer
	for this class. */
	#define CLASSTYPE_PRIMARY_BINFO(NODE) \
	(LANG_TYPE_CLASS_CHECK (NODE)->primary_base)

	/* A vector of BINFOs for the direct and indirect virtual base classes
	that this type uses in a post-order depth-first left-to-right
	order. (In other words, these bases appear in the order that they
	should be initialized.) */
	#define CLASSTYPE_VBASECLASSES(NODE) (LANG_TYPE_CLASS_CHECK (NODE)->vbases)

	/* The type corresponding to NODE when NODE is used as a base class,
	i.e., NODE without virtual base classes. */

	#define CLASSTYPE_AS_BASE(NODE) (LANG_TYPE_CLASS_CHECK (NODE)->as_base)

	/* True iff NODE is the CLASSTYPE_AS_BASE version of some type. */

	#define IS_FAKE_BASE_TYPE(NODE) \
	(TREE_CODE (NODE) == RECORD_TYPE \
	&& TYPE_CONTEXT (NODE) && CLASS_TYPE_P (TYPE_CONTEXT (NODE)) \
	&& CLASSTYPE_AS_BASE (TYPE_CONTEXT (NODE)) == (NODE))

	/* These are the size and alignment of the type without its virtual
	base classes, for when we use this type as a base itself. */
	#define CLASSTYPE_SIZE(NODE) TYPE_SIZE (CLASSTYPE_AS_BASE (NODE))
	#define CLASSTYPE_SIZE_UNIT(NODE) TYPE_SIZE_UNIT (CLASSTYPE_AS_BASE (NODE))
	#define CLASSTYPE_ALIGN(NODE) TYPE_ALIGN (CLASSTYPE_AS_BASE (NODE))
	#define CLASSTYPE_USER_ALIGN(NODE) TYPE_USER_ALIGN (CLASSTYPE_AS_BASE (NODE))

	/* The alignment of NODE, without its virtual bases, in bytes. */
	#define CLASSTYPE_ALIGN_UNIT(NODE) \
	(CLASSTYPE_ALIGN (NODE) / BITS_PER_UNIT)

	/* True if this a Java interface type, declared with
	'__attribute__ ((java_interface))'. */
	#define TYPE_JAVA_INTERFACE(NODE) \
	(LANG_TYPE_CLASS_CHECK (NODE)->java_interface)

	/* A VEC(tree) of virtual functions which cannot be inherited by
	derived classes. When deriving from this type, the derived
	class must provide its own definition for each of these functions. */
	#define CLASSTYPE_PURE_VIRTUALS(NODE) \
	(LANG_TYPE_CLASS_CHECK (NODE)->pure_virtuals)

	/* Nonzero means that this type has an X() constructor. */
	#define TYPE_HAS_DEFAULT_CONSTRUCTOR(NODE) \
	(LANG_TYPE_CLASS_CHECK (NODE)->h.has_default_ctor)

	/* Nonzero means that this type contains a mutable member. */
	#define CLASSTYPE_HAS_MUTABLE(NODE) (LANG_TYPE_CLASS_CHECK (NODE)->has_mutable)
	#define TYPE_HAS_MUTABLE_P(NODE) (cp_has_mutable_p (NODE))

	/* Nonzero means that this class type is a non-POD class. */
	#define CLASSTYPE_NON_POD_P(NODE) (LANG_TYPE_CLASS_CHECK (NODE)->non_pod_class)

	/* Nonzero means that this class contains pod types whose default
	initialization is not a zero initialization (namely, pointers to
	data members). */
	#define CLASSTYPE_NON_ZERO_INIT_P(NODE) \
	(LANG_TYPE_CLASS_CHECK (NODE)->non_zero_init)

	/* Nonzero if this class is "empty" in the sense of the C++ ABI. */
	#define CLASSTYPE_EMPTY_P(NODE) \
	(LANG_TYPE_CLASS_CHECK (NODE)->empty_p)

	/* Nonzero if this class is "nearly empty", i.e., contains only a
	virtual function table pointer. */
	#define CLASSTYPE_NEARLY_EMPTY_P(NODE) \
	(LANG_TYPE_CLASS_CHECK (NODE)->nearly_empty_p)

	/* Nonzero if this class contains an empty subobject. */
	#define CLASSTYPE_CONTAINS_EMPTY_CLASS_P(NODE) \
	(LANG_TYPE_CLASS_CHECK (NODE)->contains_empty_class_p)

	/* A list of class types of which this type is a friend. The
	TREE_VALUE is normally a TYPE, but will be a TEMPLATE_DECL in the
	case of a template friend. */
	#define CLASSTYPE_FRIEND_CLASSES(NODE) \
	(LANG_TYPE_CLASS_CHECK (NODE)->friend_classes)

	/* A list of the classes which grant friendship to this class. */
	#define CLASSTYPE_BEFRIENDING_CLASSES(NODE) \
	(LANG_TYPE_CLASS_CHECK (NODE)->befriending_classes)

	/* Say whether this node was declared as a "class" or a "struct". */
	#define CLASSTYPE_DECLARED_CLASS(NODE) \
	(LANG_TYPE_CLASS_CHECK (NODE)->declared_class)

	/* Nonzero if this class has const members
	which have no specified initialization. */
	#define CLASSTYPE_READONLY_FIELDS_NEED_INIT(NODE) \
	(TYPE_LANG_SPECIFIC (NODE) \
	? LANG_TYPE_CLASS_CHECK (NODE)->h.const_needs_init : 0)
	#define SET_CLASSTYPE_READONLY_FIELDS_NEED_INIT(NODE, VALUE) \
	(LANG_TYPE_CLASS_CHECK (NODE)->h.const_needs_init = (VALUE))

	/* Nonzero if this class has ref members
	which have no specified initialization. */
	#define CLASSTYPE_REF_FIELDS_NEED_INIT(NODE) \
	(TYPE_LANG_SPECIFIC (NODE) \
	? LANG_TYPE_CLASS_CHECK (NODE)->h.ref_needs_init : 0)
	#define SET_CLASSTYPE_REF_FIELDS_NEED_INIT(NODE, VALUE) \
	(LANG_TYPE_CLASS_CHECK (NODE)->h.ref_needs_init = (VALUE))

	/* Nonzero if this class is included from a header file which employs
	`#pragma interface', and it is not included in its implementation file. */
	#define CLASSTYPE_INTERFACE_ONLY(NODE) \
	(LANG_TYPE_CLASS_CHECK (NODE)->interface_only)

	/* True if we have already determined whether or not vtables, VTTs,
	typeinfo, and other similar per-class data should be emitted in
	this translation unit. This flag does not indicate whether or not
	these items should be emitted; it only indicates that we know one
	way or the other. */
	#define CLASSTYPE_INTERFACE_KNOWN(NODE) \
	(LANG_TYPE_CLASS_CHECK (NODE)->interface_unknown == 0)
	/* The opposite of CLASSTYPE_INTERFACE_KNOWN. */
	#define CLASSTYPE_INTERFACE_UNKNOWN(NODE) \
	(LANG_TYPE_CLASS_CHECK (NODE)->interface_unknown)

	#define SET_CLASSTYPE_INTERFACE_UNKNOWN_X(NODE,X) \
	(LANG_TYPE_CLASS_CHECK (NODE)->interface_unknown = !!(X))
	#define SET_CLASSTYPE_INTERFACE_UNKNOWN(NODE) \
	(LANG_TYPE_CLASS_CHECK (NODE)->interface_unknown = 1)
	#define SET_CLASSTYPE_INTERFACE_KNOWN(NODE) \
	(LANG_TYPE_CLASS_CHECK (NODE)->interface_unknown = 0)

	/* Nonzero if a _DECL node requires us to output debug info for this class. */
	#define CLASSTYPE_DEBUG_REQUESTED(NODE) \
	(LANG_TYPE_CLASS_CHECK (NODE)->debug_requested)

	/* Additional macros for inheritance information. */

	/* Nonzero means that this class is on a path leading to a new vtable. */
	#define BINFO_VTABLE_PATH_MARKED(NODE) BINFO_FLAG_1 (NODE)

	/* Nonzero means B (a BINFO) has its own vtable. Any copies will not
	have this flag set. */
	#define BINFO_NEW_VTABLE_MARKED(B) (BINFO_FLAG_2 (B))

	/* Compare a BINFO_TYPE with another type for equality. For a binfo,
	this is functionally equivalent to using same_type_p, but
	measurably faster. At least one of the arguments must be a
	BINFO_TYPE. The other can be a BINFO_TYPE or a regular type. If
	BINFO_TYPE(T) ever stops being the main variant of the class the
	binfo is for, this macro must change. */
	#define SAME_BINFO_TYPE_P(A, B) ((A) == (B))

	/* Any subobject that needs a new vtable must have a vptr and must not
	be a non-virtual primary base (since it would then use the vtable from a
	derived class and never become non-primary.) */
	#define SET_BINFO_NEW_VTABLE_MARKED(B) \
	(BINFO_NEW_VTABLE_MARKED (B) = 1, \
	gcc_assert (!BINFO_PRIMARY_P (B) \|\| BINFO_VIRTUAL_P (B)), \
	gcc_assert (TYPE_VFIELD (BINFO_TYPE (B))))

	/* Nonzero if this binfo is for a dependent base - one that should not
	be searched. */
	#define BINFO_DEPENDENT_BASE_P(NODE) BINFO_FLAG_3 (NODE)

	/* Nonzero if this binfo has lost its primary base binfo (because that
	is a nearly-empty virtual base that has been taken by some other
	base in the complete hierarchy. */
	#define BINFO_LOST_PRIMARY_P(NODE) BINFO_FLAG_4 (NODE)

	/* Nonzero if this BINFO is a primary base class. */
	#define BINFO_PRIMARY_P(NODE) BINFO_FLAG_5(NODE)

	/* Used by various search routines. */
	#define IDENTIFIER_MARKED(NODE) TREE_LANG_FLAG_0 (NODE)

	/* A VEC(tree_pair_s) of the vcall indices associated with the class
	NODE. The PURPOSE of each element is a FUNCTION_DECL for a virtual
	function. The VALUE is the index into the virtual table where the
	vcall offset for that function is stored, when NODE is a virtual
	base. */
	#define CLASSTYPE_VCALL_INDICES(NODE) \
	(LANG_TYPE_CLASS_CHECK (NODE)->vcall_indices)

	/* The various vtables for the class NODE. The primary vtable will be
	first, followed by the construction vtables and VTT, if any. */
	#define CLASSTYPE_VTABLES(NODE) \
	(LANG_TYPE_CLASS_CHECK (NODE)->vtables)

	/* The std::type_info variable representing this class, or NULL if no
	such variable has been created. This field is only set for the
	TYPE_MAIN_VARIANT of the class. */
	#define CLASSTYPE_TYPEINFO_VAR(NODE) \
	(LANG_TYPE_CLASS_CHECK (NODE)->typeinfo_var)

	/* Accessor macros for the BINFO_VIRTUALS list. */

	/* The number of bytes by which to adjust the `this' pointer when
	calling this virtual function. Subtract this value from the this
	pointer. Always non-NULL, might be constant zero though. */
	#define BV_DELTA(NODE) (TREE_PURPOSE (NODE))

	/* If non-NULL, the vtable index at which to find the vcall offset
	when calling this virtual function. Add the value at that vtable
	index to the this pointer. */
	#define BV_VCALL_INDEX(NODE) (TREE_TYPE (NODE))

	/* The function to call. */
	#define BV_FN(NODE) (TREE_VALUE (NODE))


	/* For FUNCTION_TYPE or METHOD_TYPE, a list of the exceptions that
	this type can raise. Each TREE_VALUE is a _TYPE. The TREE_VALUE
	will be NULL_TREE to indicate a throw specification of `()', or
	no exceptions allowed. */
	#define TYPE_RAISES_EXCEPTIONS(NODE) TYPE_LANG_SLOT_1 (NODE)

	/* For FUNCTION_TYPE or METHOD_TYPE, return 1 iff it is declared `throw()'. */
	#define TYPE_NOTHROW_P(NODE) \
	(TYPE_RAISES_EXCEPTIONS (NODE) \
	&& TREE_VALUE (TYPE_RAISES_EXCEPTIONS (NODE)) == NULL_TREE)

	/* The binding level associated with the namespace. */
	#define NAMESPACE_LEVEL(NODE) \
	(DECL_LANG_SPECIFIC (NODE)->decl_flags.u.level)


	/* If a DECL has DECL_LANG_SPECIFIC, it is either a lang_decl_flags or
	a lang_decl (which has lang_decl_flags as its initial prefix).
	This macro is nonzero for tree nodes whose DECL_LANG_SPECIFIC is
	the full lang_decl, and not just lang_decl_flags. Keep these
	checks in ascending code order. */
	#define CAN_HAVE_FULL_LANG_DECL_P(NODE) \
	(!(TREE_CODE (NODE) == FIELD_DECL \
	\|\| TREE_CODE (NODE) == VAR_DECL \
	\|\| TREE_CODE (NODE) == CONST_DECL \
	\|\| TREE_CODE (NODE) == USING_DECL))

	struct lang_decl_flags GTY(())
	{
	ENUM_BITFIELD(languages) language : 4;
	unsigned global_ctor_p : 1;
	unsigned global_dtor_p : 1;
	unsigned anticipated_p : 1;
	unsigned template_conv_p : 1;

	unsigned operator_attr : 1;
	unsigned constructor_attr : 1;
	unsigned destructor_attr : 1;
	unsigned friend_attr : 1;
	unsigned static_function : 1;
	unsigned pure_virtual : 1;
	unsigned has_in_charge_parm_p : 1;
	unsigned has_vtt_parm_p : 1;

	unsigned deferred : 1;
	unsigned use_template : 2;
	unsigned nonconverting : 1;
	unsigned not_really_extern : 1;
	unsigned initialized_in_class : 1;
	unsigned assignment_operator_p : 1;
	unsigned u1sel : 1;

	unsigned u2sel : 1;
	unsigned can_be_full : 1;
	unsigned thunk_p : 1;
	unsigned this_thunk_p : 1;
	unsigned repo_available_p : 1;
	unsigned hidden_friend_p : 1;
	unsigned threadprivate_p : 1;
	/* One unused bit. */

	union lang_decl_u {
	/* In a FUNCTION_DECL for which DECL_THUNK_P holds, this is
	THUNK_ALIAS.
	In a FUNCTION_DECL for which DECL_THUNK_P does not hold,
	VAR_DECL, TYPE_DECL, or TEMPLATE_DECL, this is
	DECL_TEMPLATE_INFO. */
	tree GTY ((tag ("0"))) template_info;

	/* In a NAMESPACE_DECL, this is NAMESPACE_LEVEL. */
	struct cp_binding_level * GTY ((tag ("1"))) level;
	} GTY ((desc ("%1.u1sel"))) u;

	union lang_decl_u2 {
	/* In a FUNCTION_DECL for which DECL_THUNK_P holds, this is
	THUNK_VIRTUAL_OFFSET.
	Otherwise this is DECL_ACCESS. */
	tree GTY ((tag ("0"))) access;

	/* For VAR_DECL in function, this is DECL_DISCRIMINATOR. */
	int GTY ((tag ("1"))) discriminator;
	} GTY ((desc ("%1.u2sel"))) u2;
	};

	/* sorted_fields is sorted based on a pointer, so we need to be able
	to resort it if pointers get rearranged. */

	struct lang_decl GTY(())
	{
	struct lang_decl_flags decl_flags;

	union lang_decl_u4
	{
	struct full_lang_decl
	{
	/* In an overloaded operator, this is the value of
	DECL_OVERLOADED_OPERATOR_P. */
	ENUM_BITFIELD (tree_code) operator_code : 8;

	unsigned u3sel : 1;
	unsigned pending_inline_p : 1;
	unsigned spare : 22;

	/* For a non-thunk function decl, this is a tree list of
	friendly classes. For a thunk function decl, it is the
	thunked to function decl. */
	tree befriending_classes;

	/* For a non-virtual FUNCTION_DECL, this is
	DECL_FRIEND_CONTEXT. For a virtual FUNCTION_DECL for which
	DECL_THIS_THUNK_P does not hold, this is DECL_THUNKS. Both
	this pointer and result pointer adjusting thunks are
	chained here. This pointer thunks to return pointer thunks
	will be chained on the return pointer thunk. */
	tree context;

	union lang_decl_u5
	{
	/* In a non-thunk FUNCTION_DECL or TEMPLATE_DECL, this is
	DECL_CLONED_FUNCTION. */
	tree GTY ((tag ("0"))) cloned_function;

	/* In a FUNCTION_DECL for which THUNK_P holds this is the
	THUNK_FIXED_OFFSET. */
	HOST_WIDE_INT GTY ((tag ("1"))) fixed_offset;
	} GTY ((desc ("%0.decl_flags.thunk_p"))) u5;

	union lang_decl_u3
	{
	struct sorted_fields_type * GTY ((tag ("0"), reorder ("resort_sorted_fields")))
	sorted_fields;
	struct cp_token_cache * GTY ((tag ("2"))) pending_inline_info;
	struct language_function * GTY ((tag ("1")))
	saved_language_function;
	} GTY ((desc ("%1.u3sel + %1.pending_inline_p"))) u;
	} GTY ((tag ("1"))) f;
	} GTY ((desc ("%1.decl_flags.can_be_full"))) u;
	};

	#if defined ENABLE_TREE_CHECKING && (GCC_VERSION >= 2007)

	#define LANG_DECL_U2_CHECK(NODE, TF) __extension__ \
	({ struct lang_decl *lt = DECL_LANG_SPECIFIC (NODE); \
	if (lt->decl_flags.u2sel != TF) \
	lang_check_failed (__FILE__, __LINE__, __FUNCTION__); \
	&lt->decl_flags.u2; })

	#else

	#define LANG_DECL_U2_CHECK(NODE, TF) \
	(&DECL_LANG_SPECIFIC (NODE)->decl_flags.u2)

	#endif /* ENABLE_TREE_CHECKING */

	/* For a FUNCTION_DECL or a VAR_DECL, the language linkage for the
	declaration. Some entities (like a member function in a local
	class, or a local variable) do not have linkage at all, and this
	macro should not be used in those cases.

	Implementation note: A FUNCTION_DECL without DECL_LANG_SPECIFIC was
	created by language-independent code, and has C linkage. Most
	VAR_DECLs have C++ linkage, and do not have DECL_LANG_SPECIFIC, but
	we do create DECL_LANG_SPECIFIC for variables with non-C++ linkage. */
	#define DECL_LANGUAGE(NODE) \
	(DECL_LANG_SPECIFIC (NODE) \
	? DECL_LANG_SPECIFIC (NODE)->decl_flags.language \
	: (TREE_CODE (NODE) == FUNCTION_DECL \
	? lang_c : lang_cplusplus))

	/* Set the language linkage for NODE to LANGUAGE. */
	#define SET_DECL_LANGUAGE(NODE, LANGUAGE) \
	(DECL_LANG_SPECIFIC (NODE)->decl_flags.language = (LANGUAGE))

	/* For FUNCTION_DECLs: nonzero means that this function is a constructor. */
	#define DECL_CONSTRUCTOR_P(NODE) \
	(DECL_LANG_SPECIFIC (NODE)->decl_flags.constructor_attr)

	/* Nonzero if NODE (a FUNCTION_DECL) is a constructor for a complete
	object. */
	#define DECL_COMPLETE_CONSTRUCTOR_P(NODE) \
	(DECL_CONSTRUCTOR_P (NODE) \
	&& DECL_NAME (NODE) == complete_ctor_identifier)

	/* Nonzero if NODE (a FUNCTION_DECL) is a constructor for a base
	object. */
	#define DECL_BASE_CONSTRUCTOR_P(NODE) \
	(DECL_CONSTRUCTOR_P (NODE) \
	&& DECL_NAME (NODE) == base_ctor_identifier)

	/* Nonzero if NODE (a FUNCTION_DECL) is a constructor, but not either the
	specialized in-charge constructor or the specialized not-in-charge
	constructor. */
	#define DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P(NODE) \
	(DECL_CONSTRUCTOR_P (NODE) && !DECL_CLONED_FUNCTION_P (NODE))

	/* Nonzero if NODE (a FUNCTION_DECL) is a copy constructor. */
	#define DECL_COPY_CONSTRUCTOR_P(NODE) \
	(DECL_CONSTRUCTOR_P (NODE) && copy_fn_p (NODE) > 0)

	/* Nonzero if NODE is a destructor. */
	#define DECL_DESTRUCTOR_P(NODE) \
	(DECL_LANG_SPECIFIC (NODE)->decl_flags.destructor_attr)

	/* Nonzero if NODE (a FUNCTION_DECL) is a destructor, but not the
	specialized in-charge constructor, in-charge deleting constructor,
	or the base destructor. */
	#define DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P(NODE) \
	(DECL_DESTRUCTOR_P (NODE) && !DECL_CLONED_FUNCTION_P (NODE))

	/* Nonzero if NODE (a FUNCTION_DECL) is a destructor for a complete
	object. */
	#define DECL_COMPLETE_DESTRUCTOR_P(NODE) \
	(DECL_DESTRUCTOR_P (NODE) \
	&& DECL_NAME (NODE) == complete_dtor_identifier)

	/* Nonzero if NODE (a FUNCTION_DECL) is a destructor for a base
	object. */
	#define DECL_BASE_DESTRUCTOR_P(NODE) \
	(DECL_DESTRUCTOR_P (NODE) \
	&& DECL_NAME (NODE) == base_dtor_identifier)

	/* Nonzero if NODE (a FUNCTION_DECL) is a destructor for a complete
	object that deletes the object after it has been destroyed. */
	#define DECL_DELETING_DESTRUCTOR_P(NODE) \
	(DECL_DESTRUCTOR_P (NODE) \
	&& DECL_NAME (NODE) == deleting_dtor_identifier)

	/* Nonzero if NODE (a FUNCTION_DECL) is a cloned constructor or
	destructor. */
	#define DECL_CLONED_FUNCTION_P(NODE) \
	((TREE_CODE (NODE) == FUNCTION_DECL \
	\|\| TREE_CODE (NODE) == TEMPLATE_DECL) \
	&& DECL_LANG_SPECIFIC (NODE) \
	&& !DECL_LANG_SPECIFIC (NODE)->decl_flags.thunk_p \
	&& DECL_CLONED_FUNCTION (NODE) != NULL_TREE)

	/* If DECL_CLONED_FUNCTION_P holds, this is the function that was
	cloned. */
	#define DECL_CLONED_FUNCTION(NODE) \
	(DECL_LANG_SPECIFIC (NON_THUNK_FUNCTION_CHECK(NODE))->u.f.u5.cloned_function)

	/* Perform an action for each clone of FN, if FN is a function with
	clones. This macro should be used like:

	FOR_EACH_CLONE (clone, fn)
	{ ... }

	*/
	#define FOR_EACH_CLONE(CLONE, FN) \
	if (TREE_CODE (FN) == FUNCTION_DECL \
	&& (DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (FN) \
	\|\| DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (FN))) \
	for (CLONE = TREE_CHAIN (FN); \
	CLONE && DECL_CLONED_FUNCTION_P (CLONE); \
	CLONE = TREE_CHAIN (CLONE))

	/* Nonzero if NODE has DECL_DISCRIMINATOR and not DECL_ACCESS. */
	#define DECL_DISCRIMINATOR_P(NODE) \
	(TREE_CODE (NODE) == VAR_DECL \
	&& DECL_FUNCTION_SCOPE_P (NODE))

	/* Discriminator for name mangling. */
	#define DECL_DISCRIMINATOR(NODE) (LANG_DECL_U2_CHECK (NODE, 1)->discriminator)

	/* Nonzero if the VTT parm has been added to NODE. */
	#define DECL_HAS_VTT_PARM_P(NODE) \
	(DECL_LANG_SPECIFIC (NODE)->decl_flags.has_vtt_parm_p)

	/* Nonzero if NODE is a FUNCTION_DECL for which a VTT parameter is
	required. */
	#define DECL_NEEDS_VTT_PARM_P(NODE) \
	(CLASSTYPE_VBASECLASSES (DECL_CONTEXT (NODE)) \
	&& (DECL_BASE_CONSTRUCTOR_P (NODE) \
	\|\| DECL_BASE_DESTRUCTOR_P (NODE)))

	/* Nonzero if NODE is a user-defined conversion operator. */
	#define DECL_CONV_FN_P(NODE) \
	(DECL_NAME (NODE) && IDENTIFIER_TYPENAME_P (DECL_NAME (NODE)))

	/* If FN is a conversion operator, the type to which it converts.
	Otherwise, NULL_TREE. */
	#define DECL_CONV_FN_TYPE(FN) \
	(DECL_CONV_FN_P (FN) ? TREE_TYPE (DECL_NAME (FN)) : NULL_TREE)

	/* Nonzero if NODE, which is a TEMPLATE_DECL, is a template
	conversion operator to a type dependent on the innermost template
	args. */
	#define DECL_TEMPLATE_CONV_FN_P(NODE) \
	(DECL_LANG_SPECIFIC (NODE)->decl_flags.template_conv_p)

	/* Set the overloaded operator code for NODE to CODE. */
	#define SET_OVERLOADED_OPERATOR_CODE(NODE, CODE) \
	(DECL_LANG_SPECIFIC (NODE)->u.f.operator_code = (CODE))

	/* If NODE is an overloaded operator, then this returns the TREE_CODE
	associated with the overloaded operator.
	DECL_ASSIGNMENT_OPERATOR_P must also be checked to determine
	whether or not NODE is an assignment operator. If NODE is not an
	overloaded operator, ERROR_MARK is returned. Since the numerical
	value of ERROR_MARK is zero, this macro can be used as a predicate
	to test whether or not NODE is an overloaded operator. */
	#define DECL_OVERLOADED_OPERATOR_P(NODE) \
	(IDENTIFIER_OPNAME_P (DECL_NAME (NODE)) \
	? DECL_LANG_SPECIFIC (NODE)->u.f.operator_code : ERROR_MARK)

	/* Nonzero if NODE is an assignment operator. */
	#define DECL_ASSIGNMENT_OPERATOR_P(NODE) \
	(DECL_LANG_SPECIFIC (NODE)->decl_flags.assignment_operator_p)

	/* For FUNCTION_DECLs: nonzero means that this function is a
	constructor or a destructor with an extra in-charge parameter to
	control whether or not virtual bases are constructed. */
	#define DECL_HAS_IN_CHARGE_PARM_P(NODE) \
	(DECL_LANG_SPECIFIC (NODE)->decl_flags.has_in_charge_parm_p)

	/* Nonzero if DECL is a declaration of __builtin_constant_p. */
	#define DECL_IS_BUILTIN_CONSTANT_P(NODE) \
	(TREE_CODE (NODE) == FUNCTION_DECL \
	&& DECL_BUILT_IN_CLASS (NODE) == BUILT_IN_NORMAL \
	&& DECL_FUNCTION_CODE (NODE) == BUILT_IN_CONSTANT_P)

	/* Nonzero for _DECL means that this decl appears in (or will appear
	in) as a member in a RECORD_TYPE or UNION_TYPE node. It is also for
	detecting circularity in case members are multiply defined. In the
	case of a VAR_DECL, it is also used to determine how program storage
	should be allocated. */
	#define DECL_IN_AGGR_P(NODE) (DECL_LANG_FLAG_3 (NODE))

	/* Nonzero for a VAR_DECL means that the variable's initialization (if
	any) has been processed. (In general, DECL_INITIALIZED_P is
	!DECL_EXTERN, but static data members may be initialized even if
	not defined.) */
	#define DECL_INITIALIZED_P(NODE) \
	(TREE_LANG_FLAG_1 (VAR_DECL_CHECK (NODE)))

	/* Nonzero for a VAR_DECL iff an explicit initializer was provided. */
	#define DECL_NONTRIVIALLY_INITIALIZED_P(NODE) \
	(TREE_LANG_FLAG_3 (VAR_DECL_CHECK (NODE)))

	/* Nonzero for a VAR_DECL that was initialized with a
	constant-expression. */
	#define DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P(NODE) \
	(TREE_LANG_FLAG_2 (VAR_DECL_CHECK (NODE)))

	/* Nonzero for a VAR_DECL that can be used in an integral constant
	expression.

	[expr.const]

	An integral constant-expression can only involve ... const
	variables of static or enumeration types initialized with
	constant expressions ...

	The standard does not require that the expression be non-volatile.
	G++ implements the proposed correction in DR 457. */
	#define DECL_INTEGRAL_CONSTANT_VAR_P(NODE) \
	(TREE_CODE (NODE) == VAR_DECL \
	&& CP_TYPE_CONST_NON_VOLATILE_P (TREE_TYPE (NODE)) \
	&& INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (NODE)) \
	&& DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (NODE))

	/* Nonzero if the DECL was initialized in the class definition itself,
	rather than outside the class. This is used for both static member
	VAR_DECLS, and FUNTION_DECLS that are defined in the class. */
	#define DECL_INITIALIZED_IN_CLASS_P(DECL) \
	(DECL_LANG_SPECIFIC (DECL)->decl_flags.initialized_in_class)

	/* Nonzero for DECL means that this decl is just a friend declaration,
	and should not be added to the list of members for this class. */
	#define DECL_FRIEND_P(NODE) (DECL_LANG_SPECIFIC (NODE)->decl_flags.friend_attr)

	/* A TREE_LIST of the types which have befriended this FUNCTION_DECL. */
	#define DECL_BEFRIENDING_CLASSES(NODE) \
	(DECL_LANG_SPECIFIC (NODE)->u.f.befriending_classes)

	/* Nonzero for FUNCTION_DECL means that this decl is a static
	member function. */
	#define DECL_STATIC_FUNCTION_P(NODE) \
	(DECL_LANG_SPECIFIC (NODE)->decl_flags.static_function)

	/* Nonzero for FUNCTION_DECL means that this decl is a non-static
	member function. */
	#define DECL_NONSTATIC_MEMBER_FUNCTION_P(NODE) \
	(TREE_CODE (TREE_TYPE (NODE)) == METHOD_TYPE)

	/* Nonzero for FUNCTION_DECL means that this decl is a member function
	(static or non-static). */
	#define DECL_FUNCTION_MEMBER_P(NODE) \
	(DECL_NONSTATIC_MEMBER_FUNCTION_P (NODE) \|\| DECL_STATIC_FUNCTION_P (NODE))

	/* Nonzero for FUNCTION_DECL means that this member function
	has `this' as const X const. /
	#define DECL_CONST_MEMFUNC_P(NODE) \
	(DECL_NONSTATIC_MEMBER_FUNCTION_P (NODE) \
	&& CP_TYPE_CONST_P (TREE_TYPE (TREE_VALUE \
	(TYPE_ARG_TYPES (TREE_TYPE (NODE))))))

	/* Nonzero for FUNCTION_DECL means that this member function
	has `this' as volatile X const. /
	#define DECL_VOLATILE_MEMFUNC_P(NODE) \
	(DECL_NONSTATIC_MEMBER_FUNCTION_P (NODE) \
	&& CP_TYPE_VOLATILE_P (TREE_TYPE (TREE_VALUE \
	(TYPE_ARG_TYPES (TREE_TYPE (NODE))))))

	/* Nonzero for a DECL means that this member is a non-static member. */
	#define DECL_NONSTATIC_MEMBER_P(NODE) \
	((TREE_CODE (NODE) == FUNCTION_DECL \
	&& DECL_NONSTATIC_MEMBER_FUNCTION_P (NODE)) \
	\|\| TREE_CODE (NODE) == FIELD_DECL)

	/* Nonzero for _DECL means that this member object type
	is mutable. */
	#define DECL_MUTABLE_P(NODE) (DECL_LANG_FLAG_0 (NODE))

	/* Nonzero for _DECL means that this constructor is a non-converting
	constructor. */
	#define DECL_NONCONVERTING_P(NODE) \
	(DECL_LANG_SPECIFIC (NODE)->decl_flags.nonconverting)

	/* Nonzero for FUNCTION_DECL means that this member function is a pure
	virtual function. */
	#define DECL_PURE_VIRTUAL_P(NODE) \
	(DECL_LANG_SPECIFIC (NODE)->decl_flags.pure_virtual)

	/* True (in a FUNCTION_DECL) if NODE is a virtual function that is an
	invalid overrider for a function from a base class. Once we have
	complained about an invalid overrider we avoid complaining about it
	again. */
	#define DECL_INVALID_OVERRIDER_P(NODE) \
	(DECL_LANG_FLAG_4 (NODE))

	/* The thunks associated with NODE, a FUNCTION_DECL. */
	#define DECL_THUNKS(NODE) \
	(DECL_LANG_SPECIFIC (NODE)->u.f.context)

	/* Nonzero if NODE is a thunk, rather than an ordinary function. */
	#define DECL_THUNK_P(NODE) \
	(TREE_CODE (NODE) == FUNCTION_DECL \
	&& DECL_LANG_SPECIFIC (NODE) \
	&& DECL_LANG_SPECIFIC (NODE)->decl_flags.thunk_p)

	/* Set DECL_THUNK_P for node. */
	#define SET_DECL_THUNK_P(NODE, THIS_ADJUSTING) \
	(DECL_LANG_SPECIFIC (NODE)->decl_flags.thunk_p = 1, \
	DECL_LANG_SPECIFIC (NODE)->u.f.u3sel = 1, \
	DECL_LANG_SPECIFIC (NODE)->decl_flags.this_thunk_p = (THIS_ADJUSTING))

	/* Nonzero if NODE is a this pointer adjusting thunk. */
	#define DECL_THIS_THUNK_P(NODE) \
	(DECL_THUNK_P (NODE) && DECL_LANG_SPECIFIC (NODE)->decl_flags.this_thunk_p)

	/* Nonzero if NODE is a result pointer adjusting thunk. */
	#define DECL_RESULT_THUNK_P(NODE) \
	(DECL_THUNK_P (NODE) && !DECL_LANG_SPECIFIC (NODE)->decl_flags.this_thunk_p)

	/* Nonzero if NODE is a FUNCTION_DECL, but not a thunk. */
	#define DECL_NON_THUNK_FUNCTION_P(NODE) \
	(TREE_CODE (NODE) == FUNCTION_DECL && !DECL_THUNK_P (NODE))

	/* Nonzero if NODE is `extern "C"'. */
	#define DECL_EXTERN_C_P(NODE) \
	(DECL_LANGUAGE (NODE) == lang_c)

	/* Nonzero if NODE is an `extern "C"' function. */
	#define DECL_EXTERN_C_FUNCTION_P(NODE) \
	(DECL_NON_THUNK_FUNCTION_P (NODE) && DECL_EXTERN_C_P (NODE))

	/* True iff DECL is an entity with vague linkage whose definition is
	available in this translation unit. */
	#define DECL_REPO_AVAILABLE_P(NODE) \
	(DECL_LANG_SPECIFIC (NODE)->decl_flags.repo_available_p)

	/* Nonzero if this DECL is the __PRETTY_FUNCTION__ variable in a
	template function. */
	#define DECL_PRETTY_FUNCTION_P(NODE) \
	(TREE_LANG_FLAG_0 (VAR_DECL_CHECK (NODE)))

	/* The _TYPE context in which this _DECL appears. This field holds the
	class where a virtual function instance is actually defined. */
	#define DECL_CLASS_CONTEXT(NODE) \
	(DECL_CLASS_SCOPE_P (NODE) ? DECL_CONTEXT (NODE) : NULL_TREE)

	/* For a non-member friend function, the class (if any) in which this
	friend was defined. For example, given:

	struct S { friend void f (); };

	the DECL_FRIEND_CONTEXT for `f' will be `S'. */
	#define DECL_FRIEND_CONTEXT(NODE) \
	((DECL_FRIEND_P (NODE) && !DECL_FUNCTION_MEMBER_P (NODE)) \
	? DECL_LANG_SPECIFIC (NODE)->u.f.context \
	: NULL_TREE)

	/* Set the DECL_FRIEND_CONTEXT for NODE to CONTEXT. */
	#define SET_DECL_FRIEND_CONTEXT(NODE, CONTEXT) \
	(DECL_LANG_SPECIFIC (NODE)->u.f.context = (CONTEXT))

	/* NULL_TREE in DECL_CONTEXT represents the global namespace. */
	#define CP_DECL_CONTEXT(NODE) \
	(DECL_CONTEXT (NODE) ? DECL_CONTEXT (NODE) : global_namespace)
	#define CP_TYPE_CONTEXT(NODE) \
	(TYPE_CONTEXT (NODE) ? TYPE_CONTEXT (NODE) : global_namespace)
	#define FROB_CONTEXT(NODE) ((NODE) == global_namespace ? NULL_TREE : (NODE))

	/* 1 iff NODE has namespace scope, including the global namespace. */
	#define DECL_NAMESPACE_SCOPE_P(NODE) \
	(!DECL_TEMPLATE_PARM_P (NODE) \
	&& TREE_CODE (CP_DECL_CONTEXT (NODE)) == NAMESPACE_DECL)

	#define TYPE_NAMESPACE_SCOPE_P(NODE) \
	(TREE_CODE (CP_TYPE_CONTEXT (NODE)) == NAMESPACE_DECL)

	/* 1 iff NODE is a class member. */
	#define DECL_CLASS_SCOPE_P(NODE) \
	(DECL_CONTEXT (NODE) && TYPE_P (DECL_CONTEXT (NODE)))

	#define TYPE_CLASS_SCOPE_P(NODE) \
	(TYPE_CONTEXT (NODE) && TYPE_P (TYPE_CONTEXT (NODE)))

	/* 1 iff NODE is function-local. */
	#define DECL_FUNCTION_SCOPE_P(NODE) \
	(DECL_CONTEXT (NODE) \
	&& TREE_CODE (DECL_CONTEXT (NODE)) == FUNCTION_DECL)

	#define TYPE_FUNCTION_SCOPE_P(NODE) \
	(TYPE_CONTEXT (NODE) \
	&& TREE_CODE (TYPE_CONTEXT (NODE)) == FUNCTION_DECL)

	/* 1 iff VAR_DECL node NODE is a type-info decl. This flag is set for
	both the primary typeinfo object and the associated NTBS name. */
	#define DECL_TINFO_P(NODE) TREE_LANG_FLAG_4 (VAR_DECL_CHECK (NODE))

	/* 1 iff VAR_DECL node NODE is virtual table or VTT. */
	#define DECL_VTABLE_OR_VTT_P(NODE) TREE_LANG_FLAG_5 (VAR_DECL_CHECK (NODE))

	/* Returns 1 iff VAR_DECL is a construction virtual table.
	DECL_VTABLE_OR_VTT_P will be true in this case and must be checked
	before using this macro. */
	#define DECL_CONSTRUCTION_VTABLE_P(NODE) \
	TREE_LANG_FLAG_6 (VAR_DECL_CHECK (NODE))

	/* 1 iff NODE is function-local, but for types. */
	#define LOCAL_CLASS_P(NODE) \
	(decl_function_context (TYPE_MAIN_DECL (NODE)) != NULL_TREE)

	/* For a NAMESPACE_DECL: the list of using namespace directives
	The PURPOSE is the used namespace, the value is the namespace
	that is the common ancestor. */
	#define DECL_NAMESPACE_USING(NODE) DECL_VINDEX (NAMESPACE_DECL_CHECK (NODE))

	/* In a NAMESPACE_DECL, the DECL_INITIAL is used to record all users
	of a namespace, to record the transitive closure of using namespace. */
	#define DECL_NAMESPACE_USERS(NODE) DECL_INITIAL (NAMESPACE_DECL_CHECK (NODE))

	/* In a NAMESPACE_DECL, the list of namespaces which have associated
	themselves with this one. */
	#define DECL_NAMESPACE_ASSOCIATIONS(NODE) \
	(NAMESPACE_DECL_CHECK (NODE)->decl_non_common.saved_tree)

	/* In a NAMESPACE_DECL, points to the original namespace if this is
	a namespace alias. */
	#define DECL_NAMESPACE_ALIAS(NODE) \
	DECL_ABSTRACT_ORIGIN (NAMESPACE_DECL_CHECK (NODE))
	#define ORIGINAL_NAMESPACE(NODE) \
	(DECL_NAMESPACE_ALIAS (NODE) ? DECL_NAMESPACE_ALIAS (NODE) : (NODE))

	/* Nonzero if NODE is the std namespace. */
	#define DECL_NAMESPACE_STD_P(NODE) \
	(TREE_CODE (NODE) == NAMESPACE_DECL \
	&& CP_DECL_CONTEXT (NODE) == global_namespace \
	&& DECL_NAME (NODE) == std_identifier)

	/* In a TREE_LIST concatenating using directives, indicate indirect
	directives */
	#define TREE_INDIRECT_USING(NODE) (TREE_LIST_CHECK (NODE)->common.lang_flag_0)

	extern tree decl_shadowed_for_var_lookup (tree);
	extern void decl_shadowed_for_var_insert (tree, tree);

	/* Non zero if this is a using decl for a dependent scope. */
	#define DECL_DEPENDENT_P(NODE) DECL_LANG_FLAG_0 (USING_DECL_CHECK (NODE))

	/* The scope named in a using decl. */
	#define USING_DECL_SCOPE(NODE) TREE_TYPE (USING_DECL_CHECK (NODE))

	/* The decls named by a using decl. */
	#define USING_DECL_DECLS(NODE) DECL_INITIAL (USING_DECL_CHECK (NODE))

	/* In a VAR_DECL, true if we have a shadowed local variable
	in the shadowed var table for this VAR_DECL. */
	#define DECL_HAS_SHADOWED_FOR_VAR_P(NODE) \
	(VAR_DECL_CHECK (NODE)->decl_with_vis.shadowed_for_var_p)

	/* In a VAR_DECL for a variable declared in a for statement,
	this is the shadowed (local) variable. */
	#define DECL_SHADOWED_FOR_VAR(NODE) \
	(DECL_HAS_SHADOWED_FOR_VAR_P(NODE) ? decl_shadowed_for_var_lookup (NODE) : NULL)

	#define SET_DECL_SHADOWED_FOR_VAR(NODE, VAL) \
	(decl_shadowed_for_var_insert (NODE, VAL))

	/* In a FUNCTION_DECL, this is nonzero if this function was defined in
	the class definition. We have saved away the text of the function,
	but have not yet processed it. */
	#define DECL_PENDING_INLINE_P(NODE) \
	(DECL_LANG_SPECIFIC (NODE)->u.f.pending_inline_p)

	/* If DECL_PENDING_INLINE_P holds, this is the saved text of the
	function. */
	#define DECL_PENDING_INLINE_INFO(NODE) \
	(DECL_LANG_SPECIFIC (NODE)->u.f.u.pending_inline_info)

	/* For a TYPE_DECL: if this structure has many fields, we'll sort them
	and put them into a TREE_VEC. */
	#define DECL_SORTED_FIELDS(NODE) \
	(DECL_LANG_SPECIFIC (TYPE_DECL_CHECK (NODE))->u.f.u.sorted_fields)

	/* True if on the deferred_fns (see decl2.c) list. */
	#define DECL_DEFERRED_FN(DECL) \
	(DECL_LANG_SPECIFIC (DECL)->decl_flags.deferred)

	/* If non-NULL for a VAR_DECL, FUNCTION_DECL, TYPE_DECL or
	TEMPLATE_DECL, the entity is either a template specialization (if
	DECL_USE_TEMPLATE is non-zero) or the abstract instance of the
	template itself.

	In either case, DECL_TEMPLATE_INFO is a TREE_LIST, whose
	TREE_PURPOSE is the TEMPLATE_DECL of which this entity is a
	specialization or abstract instance. The TREE_VALUE is the
	template arguments used to specialize the template.

	Consider:

	template <typename T> struct S { friend void f(T) {} };

	In this case, S<int>::f is, from the point of view of the compiler,
	an instantiation of a template -- but, from the point of view of
	the language, each instantiation of S results in a wholly unrelated
	global function f. In this case, DECL_TEMPLATE_INFO for S<int>::f
	will be non-NULL, but DECL_USE_TEMPLATE will be zero. */
	#define DECL_TEMPLATE_INFO(NODE) \
	(DECL_LANG_SPECIFIC (VAR_TEMPL_TYPE_OR_FUNCTION_DECL_CHECK (NODE)) \
	->decl_flags.u.template_info)

	/* For a VAR_DECL, indicates that the variable is actually a
	non-static data member of anonymous union that has been promoted to
	variable status. */
	#define DECL_ANON_UNION_VAR_P(NODE) \
	(DECL_LANG_FLAG_4 (VAR_DECL_CHECK (NODE)))

	/* Template information for a RECORD_TYPE or UNION_TYPE. */
	#define CLASSTYPE_TEMPLATE_INFO(NODE) \
	(LANG_TYPE_CLASS_CHECK (RECORD_OR_UNION_CHECK (NODE))->template_info)

	/* Template information for an ENUMERAL_TYPE. Although an enumeration may
	not be a primary template, it may be declared within the scope of a
	primary template and the enumeration constants may depend on
	non-type template parameters. */
	#define ENUM_TEMPLATE_INFO(NODE) \
	(TYPE_LANG_SLOT_1 (ENUMERAL_TYPE_CHECK (NODE)))

	/* Template information for a template template parameter. */
	#define TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO(NODE) \
	(LANG_TYPE_CLASS_CHECK (BOUND_TEMPLATE_TEMPLATE_PARM_TYPE_CHECK (NODE)) \
	->template_info)

	/* Template information for an ENUMERAL_, RECORD_, or UNION_TYPE. */
	#define TYPE_TEMPLATE_INFO(NODE) \
	(TREE_CODE (NODE) == ENUMERAL_TYPE \
	? ENUM_TEMPLATE_INFO (NODE) : \
	(TREE_CODE (NODE) == BOUND_TEMPLATE_TEMPLATE_PARM \
	? TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (NODE) : \
	(TYPE_LANG_SPECIFIC (NODE) \
	? CLASSTYPE_TEMPLATE_INFO (NODE) \
	: NULL_TREE)))

	/* Set the template information for an ENUMERAL_, RECORD_, or
	UNION_TYPE to VAL. */
	#define SET_TYPE_TEMPLATE_INFO(NODE, VAL) \
	(TREE_CODE (NODE) == ENUMERAL_TYPE \
	? (ENUM_TEMPLATE_INFO (NODE) = (VAL)) \
	: (CLASSTYPE_TEMPLATE_INFO (NODE) = (VAL)))

	#define TI_TEMPLATE(NODE) (TREE_PURPOSE (NODE))
	#define TI_ARGS(NODE) (TREE_VALUE (NODE))
	#define TI_PENDING_TEMPLATE_FLAG(NODE) TREE_LANG_FLAG_1 (NODE)

	/* We use TREE_VECs to hold template arguments. If there is only one
	level of template arguments, then the TREE_VEC contains the
	arguments directly. If there is more than one level of template
	arguments, then each entry in the TREE_VEC is itself a TREE_VEC,
	containing the template arguments for a single level. The first
	entry in the outer TREE_VEC is the outermost level of template
	parameters; the last is the innermost.

	It is incorrect to ever form a template argument vector containing
	only one level of arguments, but which is a TREE_VEC containing as
	its only entry the TREE_VEC for that level. */

	/* Nonzero if the template arguments is actually a vector of vectors,
	rather than just a vector. */
	#define TMPL_ARGS_HAVE_MULTIPLE_LEVELS(NODE) \
	(NODE && TREE_VEC_ELT (NODE, 0) \
	&& TREE_CODE (TREE_VEC_ELT (NODE, 0)) == TREE_VEC)

	/* The depth of a template argument vector. When called directly by
	the parser, we use a TREE_LIST rather than a TREE_VEC to represent
	template arguments. In fact, we may even see NULL_TREE if there
	are no template arguments. In both of those cases, there is only
	one level of template arguments. */
	#define TMPL_ARGS_DEPTH(NODE) \
	(TMPL_ARGS_HAVE_MULTIPLE_LEVELS (NODE) ? TREE_VEC_LENGTH (NODE) : 1)

	/* The LEVELth level of the template ARGS. The outermost level of
	args is level 1, not level 0. */
	#define TMPL_ARGS_LEVEL(ARGS, LEVEL) \
	(TMPL_ARGS_HAVE_MULTIPLE_LEVELS (ARGS) \
	? TREE_VEC_ELT (ARGS, (LEVEL) - 1) : (ARGS))

	/* Set the LEVELth level of the template ARGS to VAL. This macro does
	not work with single-level argument vectors. */
	#define SET_TMPL_ARGS_LEVEL(ARGS, LEVEL, VAL) \
	(TREE_VEC_ELT (ARGS, (LEVEL) - 1) = (VAL))

	/* Accesses the IDXth parameter in the LEVELth level of the ARGS. */
	#define TMPL_ARG(ARGS, LEVEL, IDX) \
	(TREE_VEC_ELT (TMPL_ARGS_LEVEL (ARGS, LEVEL), IDX))

	/* Given a single level of template arguments in NODE, return the
	number of arguments. */
	#define NUM_TMPL_ARGS(NODE) \
	(TREE_VEC_LENGTH (NODE))

	/* Returns the innermost level of template arguments in ARGS. */
	#define INNERMOST_TEMPLATE_ARGS(NODE) \
	(get_innermost_template_args ((NODE), 1))

	/* The number of levels of template parameters given by NODE. */
	#define TMPL_PARMS_DEPTH(NODE) \
	((HOST_WIDE_INT) TREE_INT_CST_LOW (TREE_PURPOSE (NODE)))

	/* The TEMPLATE_DECL instantiated or specialized by NODE. This
	TEMPLATE_DECL will be the immediate parent, not the most general
	template. For example, in:

	template <class T> struct S { template <class U> void f(U); }

	the FUNCTION_DECL for S<int>::f<double> will have, as its
	DECL_TI_TEMPLATE, `template <class U> S<int>::f<U>'.

	As a special case, for a member friend template of a template
	class, this value will not be a TEMPLATE_DECL, but rather an
	IDENTIFIER_NODE or OVERLOAD indicating the name of the template and
	any explicit template arguments provided. For example, in:

	template <class T> struct S { friend void f<int>(int, double); }

	the DECL_TI_TEMPLATE will be an IDENTIFIER_NODE for `f' and the
	DECL_TI_ARGS will be {int}. */
	#define DECL_TI_TEMPLATE(NODE) TI_TEMPLATE (DECL_TEMPLATE_INFO (NODE))

	/* The template arguments used to obtain this decl from the most
	general form of DECL_TI_TEMPLATE. For the example given for
	DECL_TI_TEMPLATE, the DECL_TI_ARGS will be {int, double}. These
	are always the full set of arguments required to instantiate this
	declaration from the most general template specialized here. */
	#define DECL_TI_ARGS(NODE) TI_ARGS (DECL_TEMPLATE_INFO (NODE))

	/* The TEMPLATE_DECL associated with NODE, a class type. Even if NODE
	will be generated from a partial specialization, the TEMPLATE_DECL
	referred to here will be the original template. For example,
	given:

	template <typename T> struct S {};
	template <typename T> struct S<T*> {};

	the CLASSTPYE_TI_TEMPLATE for S<int> will be S, not the S<T>. */
	#define CLASSTYPE_TI_TEMPLATE(NODE) TI_TEMPLATE (CLASSTYPE_TEMPLATE_INFO (NODE))
	#define CLASSTYPE_TI_ARGS(NODE) TI_ARGS (CLASSTYPE_TEMPLATE_INFO (NODE))

	/* For a template instantiation TYPE, returns the TYPE corresponding
	to the primary template. Otherwise returns TYPE itself. */
	#define CLASSTYPE_PRIMARY_TEMPLATE_TYPE(TYPE) \
	((CLASSTYPE_USE_TEMPLATE ((TYPE)) \
	&& !CLASSTYPE_TEMPLATE_SPECIALIZATION ((TYPE))) \
	? TREE_TYPE (DECL_TEMPLATE_RESULT (DECL_PRIMARY_TEMPLATE \
	(CLASSTYPE_TI_TEMPLATE ((TYPE))))) \
	: (TYPE))

	/* Like CLASS_TI_TEMPLATE, but also works for ENUMERAL_TYPEs. */
	#define TYPE_TI_TEMPLATE(NODE) \
	(TI_TEMPLATE (TYPE_TEMPLATE_INFO (NODE)))

	/* Like DECL_TI_ARGS, but for an ENUMERAL_, RECORD_, or UNION_TYPE. */
	#define TYPE_TI_ARGS(NODE) \
	(TI_ARGS (TYPE_TEMPLATE_INFO (NODE)))

	#define INNERMOST_TEMPLATE_PARMS(NODE) TREE_VALUE (NODE)

	/* Nonzero if NODE (a TEMPLATE_DECL) is a member template, in the
	sense of [temp.mem]. */
	#define DECL_MEMBER_TEMPLATE_P(NODE) \
	(DECL_LANG_FLAG_1 (TEMPLATE_DECL_CHECK (NODE)))

	/* Nonzero if the NODE corresponds to the template parameters for a
	member template, whose inline definition is being processed after
	the class definition is complete. */
	#define TEMPLATE_PARMS_FOR_INLINE(NODE) TREE_LANG_FLAG_1 (NODE)

	/* In a FUNCTION_DECL, the saved language-specific per-function data. */
	#define DECL_SAVED_FUNCTION_DATA(NODE) \
	(DECL_LANG_SPECIFIC (FUNCTION_DECL_CHECK (NODE)) \
	->u.f.u.saved_language_function)

	/* Indicates an indirect_expr is for converting a reference. */
	#define REFERENCE_REF_P(NODE) \
	TREE_LANG_FLAG_0 (INDIRECT_REF_CHECK (NODE))

	#define NEW_EXPR_USE_GLOBAL(NODE) \
	TREE_LANG_FLAG_0 (NEW_EXPR_CHECK (NODE))
	#define DELETE_EXPR_USE_GLOBAL(NODE) \
	TREE_LANG_FLAG_0 (DELETE_EXPR_CHECK (NODE))
	#define DELETE_EXPR_USE_VEC(NODE) \
	TREE_LANG_FLAG_1 (DELETE_EXPR_CHECK (NODE))

	/* Indicates that this is a non-dependent COMPOUND_EXPR which will
	resolve to a function call. */
	#define COMPOUND_EXPR_OVERLOADED(NODE) \
	TREE_LANG_FLAG_0 (COMPOUND_EXPR_CHECK (NODE))

	/* In a CALL_EXPR appearing in a template, true if Koenig lookup
	should be performed at instantiation time. */
	#define KOENIG_LOOKUP_P(NODE) TREE_LANG_FLAG_0 (CALL_EXPR_CHECK (NODE))

	/* Indicates whether a string literal has been parenthesized. Such
	usages are disallowed in certain circumstances. */

	#define PAREN_STRING_LITERAL_P(NODE) \
	TREE_LANG_FLAG_0 (STRING_CST_CHECK (NODE))

	/* Nonzero if this AGGR_INIT_EXPR provides for initialization via a
	constructor call, rather than an ordinary function call. */
	#define AGGR_INIT_VIA_CTOR_P(NODE) \
	TREE_LANG_FLAG_0 (AGGR_INIT_EXPR_CHECK (NODE))

	/* The TYPE_MAIN_DECL for a class template type is a TYPE_DECL, not a
	TEMPLATE_DECL. This macro determines whether or not a given class
	type is really a template type, as opposed to an instantiation or
	specialization of one. */
	#define CLASSTYPE_IS_TEMPLATE(NODE) \
	(CLASSTYPE_TEMPLATE_INFO (NODE) \
	&& !CLASSTYPE_USE_TEMPLATE (NODE) \
	&& PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (NODE)))

	/* The name used by the user to name the typename type. Typically,
	this is an IDENTIFIER_NODE, and the same as the DECL_NAME on the
	corresponding TYPE_DECL. However, this may also be a
	TEMPLATE_ID_EXPR if we had something like `typename X::Y<T>'. */
	#define TYPENAME_TYPE_FULLNAME(NODE) (TYPENAME_TYPE_CHECK (NODE))->type.values

	/* True if a TYPENAME_TYPE was declared as an "enum". */
	#define TYPENAME_IS_ENUM_P(NODE) \
	(TREE_LANG_FLAG_0 (TYPENAME_TYPE_CHECK (NODE)))

	/* True if a TYPENAME_TYPE was declared as a "class", "struct", or
	"union". */
	#define TYPENAME_IS_CLASS_P(NODE) \
	(TREE_LANG_FLAG_1 (TYPENAME_TYPE_CHECK (NODE)))

	/* Nonzero in INTEGER_CST means that this int is negative by dint of
	using a twos-complement negated operand. */
	#define TREE_NEGATED_INT(NODE) TREE_LANG_FLAG_0 (INTEGER_CST_CHECK (NODE))

	/* [class.virtual]

	A class that declares or inherits a virtual function is called a
	polymorphic class. */
	#define TYPE_POLYMORPHIC_P(NODE) (TREE_LANG_FLAG_2 (NODE))

	/* Nonzero if this class has a virtual function table pointer. */
	#define TYPE_CONTAINS_VPTR_P(NODE) \
	(TYPE_POLYMORPHIC_P (NODE) \|\| CLASSTYPE_VBASECLASSES (NODE))

	/* This flag is true of a local VAR_DECL if it was declared in a for
	statement, but we are no longer in the scope of the for. */
	#define DECL_DEAD_FOR_LOCAL(NODE) DECL_LANG_FLAG_7 (VAR_DECL_CHECK (NODE))

	/* This flag is set on a VAR_DECL that is a DECL_DEAD_FOR_LOCAL
	if we already emitted a warning about using it. */
	#define DECL_ERROR_REPORTED(NODE) DECL_LANG_FLAG_0 (VAR_DECL_CHECK (NODE))

	/* Nonzero if NODE is a FUNCTION_DECL (for a function with global
	scope) declared in a local scope. */
	#define DECL_LOCAL_FUNCTION_P(NODE) \
	DECL_LANG_FLAG_0 (FUNCTION_DECL_CHECK (NODE))

	/* Nonzero if NODE is a DECL which we know about but which has not
	been explicitly declared, such as a built-in function or a friend
	declared inside a class. In the latter case DECL_HIDDEN_FRIEND_P
	will be set. */
	#define DECL_ANTICIPATED(NODE) \
	(DECL_LANG_SPECIFIC (DECL_COMMON_CHECK (NODE))->decl_flags.anticipated_p)

	/* Nonzero if NODE is a FUNCTION_DECL which was declared as a friend
	within a class but has not been declared in the surrounding scope.
	The function is invisible except via argument dependent lookup. */
	#define DECL_HIDDEN_FRIEND_P(NODE) \
	(DECL_LANG_SPECIFIC (DECL_COMMON_CHECK (NODE))->decl_flags.hidden_friend_p)

	/* Nonzero if DECL has been declared threadprivate by
	#pragma omp threadprivate. */
	#define CP_DECL_THREADPRIVATE_P(DECL) \
	(DECL_LANG_SPECIFIC (VAR_DECL_CHECK (DECL))->decl_flags.threadprivate_p)

	/* Record whether a typedef for type `int' was actually `signed int'. */
	#define C_TYPEDEF_EXPLICITLY_SIGNED(EXP) DECL_LANG_FLAG_1 (EXP)

	/* Returns nonzero if DECL has external linkage, as specified by the
	language standard. (This predicate may hold even when the
	corresponding entity is not actually given external linkage in the
	object file; see decl_linkage for details.) */
	#define DECL_EXTERNAL_LINKAGE_P(DECL) \
	(decl_linkage (DECL) == lk_external)

	/* Keep these codes in ascending code order. */

	#define INTEGRAL_CODE_P(CODE) \
	((CODE) == ENUMERAL_TYPE \
	\|\| (CODE) == BOOLEAN_TYPE \
	\|\| (CODE) == INTEGER_TYPE)

	/* [basic.fundamental]

	Types bool, char, wchar_t, and the signed and unsigned integer types
	are collectively called integral types.

	Note that INTEGRAL_TYPE_P, as defined in tree.h, allows enumeration
	types as well, which is incorrect in C++. Keep these checks in
	ascending code order. */
	#define CP_INTEGRAL_TYPE_P(TYPE) \
	(TREE_CODE (TYPE) == BOOLEAN_TYPE \
	\|\| TREE_CODE (TYPE) == INTEGER_TYPE)

	/* Returns true if TYPE is an integral or enumeration name. Keep
	these checks in ascending code order. */
	#define INTEGRAL_OR_ENUMERATION_TYPE_P(TYPE) \
	(TREE_CODE (TYPE) == ENUMERAL_TYPE \|\| CP_INTEGRAL_TYPE_P (TYPE))

	/* [basic.fundamental]

	Integral and floating types are collectively called arithmetic
	types.

	As a GNU extension, we also accept complex types.

	Keep these checks in ascending code order. */
	#define ARITHMETIC_TYPE_P(TYPE) \
	(CP_INTEGRAL_TYPE_P (TYPE) \
	\|\| TREE_CODE (TYPE) == REAL_TYPE \
	\|\| TREE_CODE (TYPE) == COMPLEX_TYPE)

	/* [basic.types]

	Arithmetic types, enumeration types, pointer types, and
	pointer-to-member types, are collectively called scalar types.

	Keep these checks in ascending code order. */
	#define SCALAR_TYPE_P(TYPE) \
	(TYPE_PTRMEM_P (TYPE) \
	\|\| TREE_CODE (TYPE) == ENUMERAL_TYPE \
	\|\| ARITHMETIC_TYPE_P (TYPE) \
	\|\| TYPE_PTR_P (TYPE) \
	\|\| TYPE_PTRMEMFUNC_P (TYPE))

	/* [dcl.init.aggr]

	An aggregate is an array or a class with no user-declared
	constructors, no private or protected non-static data members, no
	base classes, and no virtual functions.

	As an extension, we also treat vectors as aggregates. Keep these
	checks in ascending code order. */
	#define CP_AGGREGATE_TYPE_P(TYPE) \
	(TREE_CODE (TYPE) == VECTOR_TYPE \
	\|\|TREE_CODE (TYPE) == ARRAY_TYPE \
	\|\| (CLASS_TYPE_P (TYPE) && !CLASSTYPE_NON_AGGREGATE (TYPE)))

	/* Nonzero for a class type means that the class type has a
	user-declared constructor. */
	#define TYPE_HAS_CONSTRUCTOR(NODE) (TYPE_LANG_FLAG_1 (NODE))

	/* When appearing in an INDIRECT_REF, it means that the tree structure
	underneath is actually a call to a constructor. This is needed
	when the constructor must initialize local storage (which can
	be automatically destroyed), rather than allowing it to allocate
	space from the heap.

	When appearing in a SAVE_EXPR, it means that underneath
	is a call to a constructor.

	When appearing in a CONSTRUCTOR, the expression is a
	compound literal.

	When appearing in a FIELD_DECL, it means that this field
	has been duly initialized in its constructor. */
	#define TREE_HAS_CONSTRUCTOR(NODE) (TREE_LANG_FLAG_4 (NODE))

	/* True if NODE is a brace-enclosed initializer. */
	#define BRACE_ENCLOSED_INITIALIZER_P(NODE) \
	(TREE_CODE (NODE) == CONSTRUCTOR && !TREE_TYPE (NODE))

	/* True if NODE is a compound-literal, i.e., a brace-enclosed
	initializer cast to a particular type. */
	#define COMPOUND_LITERAL_P(NODE) \
	(TREE_CODE (NODE) == CONSTRUCTOR && TREE_HAS_CONSTRUCTOR (NODE))

	#define EMPTY_CONSTRUCTOR_P(NODE) (TREE_CODE (NODE) == CONSTRUCTOR \
	&& VEC_empty (constructor_elt, \
	CONSTRUCTOR_ELTS (NODE)) \
	&& !TREE_HAS_CONSTRUCTOR (NODE))

	/* Nonzero means that an object of this type can not be initialized using
	an initializer list. */
	#define CLASSTYPE_NON_AGGREGATE(NODE) \
	(LANG_TYPE_CLASS_CHECK (NODE)->non_aggregate)
	#define TYPE_NON_AGGREGATE_CLASS(NODE) \
	(IS_AGGR_TYPE (NODE) && CLASSTYPE_NON_AGGREGATE (NODE))

	/* Nonzero if there is a user-defined X::op=(x&) for this class. */
	#define TYPE_HAS_COMPLEX_ASSIGN_REF(NODE) (LANG_TYPE_CLASS_CHECK (NODE)->has_complex_assign_ref)
	#define TYPE_HAS_COMPLEX_INIT_REF(NODE) (LANG_TYPE_CLASS_CHECK (NODE)->has_complex_init_ref)

	/* Nonzero if TYPE has a trivial destructor. From [class.dtor]:

	A destructor is trivial if it is an implicitly declared
	destructor and if:

	- all of the direct base classes of its class have trivial
	destructors,

	- for all of the non-static data members of its class that are
	of class type (or array thereof), each such class has a
	trivial destructor. */
	#define TYPE_HAS_TRIVIAL_DESTRUCTOR(NODE) \
	(!TYPE_HAS_NONTRIVIAL_DESTRUCTOR (NODE))

	/* Nonzero for _TYPE node means that this type does not have a trivial
	destructor. Therefore, destroying an object of this type will
	involve a call to a destructor. This can apply to objects of
	ARRAY_TYPE is the type of the elements needs a destructor. */
	#define TYPE_HAS_NONTRIVIAL_DESTRUCTOR(NODE) \
	(TYPE_LANG_FLAG_4 (NODE))

	/* Nonzero for class type means that copy initialization of this type can use
	a bitwise copy. */
	#define TYPE_HAS_TRIVIAL_INIT_REF(NODE) \
	(TYPE_HAS_INIT_REF (NODE) && ! TYPE_HAS_COMPLEX_INIT_REF (NODE))

	/* Nonzero for class type means that assignment of this type can use
	a bitwise copy. */
	#define TYPE_HAS_TRIVIAL_ASSIGN_REF(NODE) \
	(TYPE_HAS_ASSIGN_REF (NODE) && ! TYPE_HAS_COMPLEX_ASSIGN_REF (NODE))

	/* Returns true if NODE is a pointer-to-data-member. */
	#define TYPE_PTRMEM_P(NODE) \
	(TREE_CODE (NODE) == OFFSET_TYPE)
	/* Returns true if NODE is a pointer. */
	#define TYPE_PTR_P(NODE) \
	(TREE_CODE (NODE) == POINTER_TYPE)

	/* Returns true if NODE is an object type:

	[basic.types]

	An object type is a (possibly cv-qualified) type that is not a
	function type, not a reference type, and not a void type.

	Keep these checks in ascending order, for speed. */
	#define TYPE_OBJ_P(NODE) \
	(TREE_CODE (NODE) != REFERENCE_TYPE \
	&& TREE_CODE (NODE) != VOID_TYPE \
	&& TREE_CODE (NODE) != FUNCTION_TYPE \
	&& TREE_CODE (NODE) != METHOD_TYPE)

	/* Returns true if NODE is a pointer to an object. Keep these checks
	in ascending tree code order. */
	#define TYPE_PTROB_P(NODE) \
	(TYPE_PTR_P (NODE) && TYPE_OBJ_P (TREE_TYPE (NODE)))

	/* Returns true if NODE is a reference to an object. Keep these checks
	in ascending tree code order. */
	#define TYPE_REF_OBJ_P(NODE) \
	(TREE_CODE (NODE) == REFERENCE_TYPE && TYPE_OBJ_P (TREE_TYPE (NODE)))

	/* Returns true if NODE is a pointer to an object, or a pointer to
	void. Keep these checks in ascending tree code order. */
	#define TYPE_PTROBV_P(NODE) \
	(TYPE_PTR_P (NODE) \
	&& !(TREE_CODE (TREE_TYPE (NODE)) == FUNCTION_TYPE \
	\|\| TREE_CODE (TREE_TYPE (NODE)) == METHOD_TYPE))

	/* Returns true if NODE is a pointer to function. */
	#define TYPE_PTRFN_P(NODE) \
	(TREE_CODE (NODE) == POINTER_TYPE \
	&& TREE_CODE (TREE_TYPE (NODE)) == FUNCTION_TYPE)

	/* Returns true if NODE is a reference to function. */
	#define TYPE_REFFN_P(NODE) \
	(TREE_CODE (NODE) == REFERENCE_TYPE \
	&& TREE_CODE (TREE_TYPE (NODE)) == FUNCTION_TYPE)

	/* Nonzero for _TYPE node means that this type is a pointer to member
	function type. */
	#define TYPE_PTRMEMFUNC_P(NODE) \
	(TREE_CODE (NODE) == RECORD_TYPE \
	&& TYPE_LANG_SPECIFIC (NODE) \
	&& TYPE_PTRMEMFUNC_FLAG (NODE))

	#define TYPE_PTRMEMFUNC_FLAG(NODE) \
	(LANG_TYPE_CLASS_CHECK (NODE)->ptrmemfunc_flag)

	/* Returns true if NODE is a pointer-to-member. */
	#define TYPE_PTR_TO_MEMBER_P(NODE) \
	(TYPE_PTRMEM_P (NODE) \|\| TYPE_PTRMEMFUNC_P (NODE))

	/* Indicates when overload resolution may resolve to a pointer to
	member function. [expr.unary.op]/3 */
	#define PTRMEM_OK_P(NODE) \
	TREE_LANG_FLAG_0 (TREE_CHECK2 ((NODE), ADDR_EXPR, OFFSET_REF))

	/* Get the POINTER_TYPE to the METHOD_TYPE associated with this
	pointer to member function. TYPE_PTRMEMFUNC_P _must_ be true,
	before using this macro. */
	#define TYPE_PTRMEMFUNC_FN_TYPE(NODE) \
	(TREE_TYPE (TYPE_FIELDS (NODE)))

	/* Returns `A' for a type like `int (A::)(double)' /
	#define TYPE_PTRMEMFUNC_OBJECT_TYPE(NODE) \
	TYPE_METHOD_BASETYPE (TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (NODE)))

	/* These are use to manipulate the canonical RECORD_TYPE from the
	hashed POINTER_TYPE, and can only be used on the POINTER_TYPE. */
	#define TYPE_GET_PTRMEMFUNC_TYPE(NODE) \
	(TYPE_LANG_SPECIFIC (NODE) ? LANG_TYPE_PTRMEM_CHECK (NODE)->record : NULL)
	#define TYPE_SET_PTRMEMFUNC_TYPE(NODE, VALUE) \
	do { \
	if (TYPE_LANG_SPECIFIC (NODE) == NULL) \
	{ \
	TYPE_LANG_SPECIFIC (NODE) = GGC_CNEWVAR \
	(struct lang_type, sizeof (struct lang_type_ptrmem)); \
	TYPE_LANG_SPECIFIC (NODE)->u.ptrmem.h.is_lang_type_class = 0; \
	} \
	TYPE_LANG_SPECIFIC (NODE)->u.ptrmem.record = (VALUE); \
	} while (0)

	/* For a pointer-to-member type of the form `T X::*', this is `X'.
	For a type like `void (X::*)() const', this type is `X', not `const
	X'. To get at the `const X' you have to look at the
	TYPE_PTRMEM_POINTED_TO_TYPE; there, the first parameter will have
	type `const X'. /
	#define TYPE_PTRMEM_CLASS_TYPE(NODE) \
	(TYPE_PTRMEM_P (NODE) \
	? TYPE_OFFSET_BASETYPE (NODE) \
	: TYPE_PTRMEMFUNC_OBJECT_TYPE (NODE))

	/* For a pointer-to-member type of the form `T X::', this is `T'. /
	#define TYPE_PTRMEM_POINTED_TO_TYPE(NODE) \
	(TYPE_PTRMEM_P (NODE) \
	? TREE_TYPE (NODE) \
	: TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (NODE)))

	/* For a pointer-to-member constant `X::Y' this is the RECORD_TYPE for
	`X'. */
	#define PTRMEM_CST_CLASS(NODE) \
	TYPE_PTRMEM_CLASS_TYPE (TREE_TYPE (PTRMEM_CST_CHECK (NODE)))

	/* For a pointer-to-member constant `X::Y' this is the _DECL for
	`Y'. */
	#define PTRMEM_CST_MEMBER(NODE) (((ptrmem_cst_t)PTRMEM_CST_CHECK (NODE))->member)

	/* The expression in question for a TYPEOF_TYPE. */
	#define TYPEOF_TYPE_EXPR(NODE) (TYPEOF_TYPE_CHECK (NODE))->type.values

	/* Nonzero for VAR_DECL and FUNCTION_DECL node means that `extern' was
	specified in its declaration. This can also be set for an
	erroneously declared PARM_DECL. */
	#define DECL_THIS_EXTERN(NODE) \
	DECL_LANG_FLAG_2 (VAR_FUNCTION_OR_PARM_DECL_CHECK (NODE))

	/* Nonzero for VAR_DECL and FUNCTION_DECL node means that `static' was
	specified in its declaration. This can also be set for an
	erroneously declared PARM_DECL. */
	#define DECL_THIS_STATIC(NODE) \
	DECL_LANG_FLAG_6 (VAR_FUNCTION_OR_PARM_DECL_CHECK (NODE))

	/* Nonzero for FIELD_DECL node means that this field is a base class
	of the parent object, as opposed to a member field. */
	#define DECL_FIELD_IS_BASE(NODE) \
	DECL_LANG_FLAG_6 (FIELD_DECL_CHECK (NODE))

	/* Nonzero if TYPE is an anonymous union or struct type. We have to use a
	flag for this because "A union for which objects or pointers are
	declared is not an anonymous union" [class.union]. */
	#define ANON_AGGR_TYPE_P(NODE) \
	(CLASS_TYPE_P (NODE) && LANG_TYPE_CLASS_CHECK (NODE)->anon_aggr)
	#define SET_ANON_AGGR_TYPE_P(NODE) \
	(LANG_TYPE_CLASS_CHECK (NODE)->anon_aggr = 1)

	/* Nonzero if TYPE is an anonymous union type. */
	#define ANON_UNION_TYPE_P(NODE) \
	(TREE_CODE (NODE) == UNION_TYPE && ANON_AGGR_TYPE_P (NODE))

	#define UNKNOWN_TYPE LANG_TYPE

	/* Define fields and accessors for nodes representing declared names. */

	#define TYPE_WAS_ANONYMOUS(NODE) (LANG_TYPE_CLASS_CHECK (NODE)->was_anonymous)

	/* C++: all of these are overloaded! These apply only to TYPE_DECLs. */

	/* The format of each node in the DECL_FRIENDLIST is as follows:

	The TREE_PURPOSE will be the name of a function, i.e., an
	IDENTIFIER_NODE. The TREE_VALUE will be itself a TREE_LIST, whose
	TREE_VALUEs are friends with the given name. */
	#define DECL_FRIENDLIST(NODE) (DECL_INITIAL (NODE))
	#define FRIEND_NAME(LIST) (TREE_PURPOSE (LIST))
	#define FRIEND_DECLS(LIST) (TREE_VALUE (LIST))

	/* The DECL_ACCESS, if non-NULL, is a TREE_LIST. The TREE_PURPOSE of
	each node is a type; the TREE_VALUE is the access granted for this
	DECL in that type. The DECL_ACCESS is set by access declarations.
	For example, if a member that would normally be public in a
	derived class is made protected, then the derived class and the
	protected_access_node will appear in the DECL_ACCESS for the node. */
	#define DECL_ACCESS(NODE) (LANG_DECL_U2_CHECK (NODE, 0)->access)

	/* Nonzero if the FUNCTION_DECL is a global constructor. */
	#define DECL_GLOBAL_CTOR_P(NODE) \
	(DECL_LANG_SPECIFIC (NODE)->decl_flags.global_ctor_p)

	/* Nonzero if the FUNCTION_DECL is a global destructor. */
	#define DECL_GLOBAL_DTOR_P(NODE) \
	(DECL_LANG_SPECIFIC (NODE)->decl_flags.global_dtor_p)

	/* Accessor macros for C++ template decl nodes. */

	/* The DECL_TEMPLATE_PARMS are a list. The TREE_PURPOSE of each node
	is a INT_CST whose TREE_INT_CST_LOW indicates the level of the
	template parameters, with 1 being the outermost set of template
	parameters. The TREE_VALUE is a vector, whose elements are the
	template parameters at each level. Each element in the vector is a
	TREE_LIST, whose TREE_VALUE is a PARM_DECL (if the parameter is a
	non-type parameter), or a TYPE_DECL (if the parameter is a type
	parameter). The TREE_PURPOSE is the default value, if any. The
	TEMPLATE_PARM_INDEX for the parameter is available as the
	DECL_INITIAL (for a PARM_DECL) or as the TREE_TYPE (for a
	TYPE_DECL). */
	#define DECL_TEMPLATE_PARMS(NODE) DECL_NON_COMMON_CHECK (NODE)->decl_non_common.arguments
	#define DECL_INNERMOST_TEMPLATE_PARMS(NODE) \
	INNERMOST_TEMPLATE_PARMS (DECL_TEMPLATE_PARMS (NODE))
	#define DECL_NTPARMS(NODE) \
	TREE_VEC_LENGTH (DECL_INNERMOST_TEMPLATE_PARMS (NODE))
	/* For function, method, class-data templates. */
	#define DECL_TEMPLATE_RESULT(NODE) DECL_RESULT_FLD (NODE)
	/* For a static member variable template, the
	DECL_TEMPLATE_INSTANTIATIONS list contains the explicitly and
	implicitly generated instantiations of the variable. There are no
	partial instantiations of static member variables, so all of these
	will be full instantiations.

	For a class template the DECL_TEMPLATE_INSTANTIATIONS lists holds
	all instantiations and specializations of the class type, including
	partial instantiations and partial specializations.

	In both cases, the TREE_PURPOSE of each node contains the arguments
	used; the TREE_VALUE contains the generated variable. The template
	arguments are always complete. For example, given:

	template <class T> struct S1 {
	template <class U> struct S2 {};
	template <class U> struct S2<U*> {};
	};

	the record for the partial specialization will contain, as its
	argument list, { {T}, {U*} }, and will be on the
	DECL_TEMPLATE_INSTANTIATIONS list for `template <class T> template
	<class U> struct S1<T>::S2'.

	This list is not used for function templates. */
	#define DECL_TEMPLATE_INSTANTIATIONS(NODE) DECL_VINDEX (NODE)
	/* For a function template, the DECL_TEMPLATE_SPECIALIZATIONS lists
	contains all instantiations and specializations of the function,
	including partial instantiations. For a partial instantiation
	which is a specialization, this list holds only full
	specializations of the template that are instantiations of the
	partial instantiation. For example, given:

	template <class T> struct S {
	template <class U> void f(U);
	template <> void f(T);
	};

	the `S<int>::f<int>(int)' function will appear on the
	DECL_TEMPLATE_SPECIALIZATIONS list for both `template <class T>
	template <class U> void S<T>::f(U)' and `template <class T> void
	S<int>::f(T)'. In the latter case, however, it will have only the
	innermost set of arguments (T, in this case). The DECL_TI_TEMPLATE
	for the function declaration will point at the specialization, not
	the fully general template.

	For a class template, this list contains the partial
	specializations of this template. (Full specializations are not
	recorded on this list.) The TREE_PURPOSE holds the arguments used
	in the partial specialization (e.g., for `template <class T> struct
	S<T, int>' this will be `T'.) The arguments will also include
	any outer template arguments. The TREE_VALUE holds the innermost
	template parameters for the specialization (e.g., `T' in the
	example above.) The TREE_TYPE is the _TYPE node for the partial
	specialization.

	This list is not used for static variable templates. */
	#define DECL_TEMPLATE_SPECIALIZATIONS(NODE) DECL_SIZE (NODE)

	/* Nonzero for a DECL which is actually a template parameter. Keep
	these checks in ascending tree code order. */
	#define DECL_TEMPLATE_PARM_P(NODE) \
	(DECL_LANG_FLAG_0 (NODE) \
	&& (TREE_CODE (NODE) == CONST_DECL \
	\|\| TREE_CODE (NODE) == PARM_DECL \
	\|\| TREE_CODE (NODE) == TYPE_DECL \
	\|\| TREE_CODE (NODE) == TEMPLATE_DECL))

	/* Mark NODE as a template parameter. */
	#define SET_DECL_TEMPLATE_PARM_P(NODE) \
	(DECL_LANG_FLAG_0 (NODE) = 1)

	/* Nonzero if NODE is a template template parameter. */
	#define DECL_TEMPLATE_TEMPLATE_PARM_P(NODE) \
	(TREE_CODE (NODE) == TEMPLATE_DECL && DECL_TEMPLATE_PARM_P (NODE))

	/* Nonzero if NODE is a TEMPLATE_DECL representing an
	UNBOUND_CLASS_TEMPLATE tree node. */
	#define DECL_UNBOUND_CLASS_TEMPLATE_P(NODE) \
	(TREE_CODE (NODE) == TEMPLATE_DECL && !DECL_TEMPLATE_RESULT (NODE))

	#define DECL_FUNCTION_TEMPLATE_P(NODE) \
	(TREE_CODE (NODE) == TEMPLATE_DECL \
	&& !DECL_UNBOUND_CLASS_TEMPLATE_P (NODE) \
	&& TREE_CODE (DECL_TEMPLATE_RESULT (NODE)) == FUNCTION_DECL)

	/* Nonzero for a DECL that represents a template class. */
	#define DECL_CLASS_TEMPLATE_P(NODE) \
	(TREE_CODE (NODE) == TEMPLATE_DECL \
	&& !DECL_UNBOUND_CLASS_TEMPLATE_P (NODE) \
	&& TREE_CODE (DECL_TEMPLATE_RESULT (NODE)) == TYPE_DECL \
	&& !DECL_TEMPLATE_TEMPLATE_PARM_P (NODE))

	/* Nonzero if NODE which declares a type. */
	#define DECL_DECLARES_TYPE_P(NODE) \
	(TREE_CODE (NODE) == TYPE_DECL \|\| DECL_CLASS_TEMPLATE_P (NODE))

	/* Nonzero if NODE is the typedef implicitly generated for a type when
	the type is declared. In C++, `struct S {};' is roughly
	equivalent to `struct S {}; typedef struct S S;' in C.
	DECL_IMPLICIT_TYPEDEF_P will hold for the typedef indicated in this
	example. In C++, there is a second implicit typedef for each
	class, in the scope of `S' itself, so that you can say `S::S'.
	DECL_SELF_REFERENCE_P will hold for that second typedef. */
	#define DECL_IMPLICIT_TYPEDEF_P(NODE) \
	(TREE_CODE (NODE) == TYPE_DECL && DECL_LANG_FLAG_2 (NODE))
	#define SET_DECL_IMPLICIT_TYPEDEF_P(NODE) \
	(DECL_LANG_FLAG_2 (NODE) = 1)
	#define DECL_SELF_REFERENCE_P(NODE) \
	(TREE_CODE (NODE) == TYPE_DECL && DECL_LANG_FLAG_4 (NODE))
	#define SET_DECL_SELF_REFERENCE_P(NODE) \
	(DECL_LANG_FLAG_4 (NODE) = 1)

	/* A `primary' template is one that has its own template header. A
	member function of a class template is a template, but not primary.
	A member template is primary. Friend templates are primary, too. */

	/* Returns the primary template corresponding to these parameters. */
	#define DECL_PRIMARY_TEMPLATE(NODE) \
	(TREE_TYPE (DECL_INNERMOST_TEMPLATE_PARMS (NODE)))

	/* Returns nonzero if NODE is a primary template. */
	#define PRIMARY_TEMPLATE_P(NODE) (DECL_PRIMARY_TEMPLATE (NODE) == (NODE))

	/* Non-zero iff NODE is a specialization of a template. The value
	indicates the type of specializations:

	1=implicit instantiation

	2=partial or explicit specialization, e.g.:

	template <> int min<int> (int, int),

	3=explicit instantiation, e.g.:

	template int min<int> (int, int);

	Note that NODE will be marked as a specialization even if the
	template it is instantiating is not a primary template. For
	example, given:

	template <typename T> struct O {
	void f();
	struct I {};
	};

	both O<int>::f and O<int>::I will be marked as instantiations.

	If DECL_USE_TEMPLATE is non-zero, then DECL_TEMPLATE_INFO will also
	be non-NULL. */
	#define DECL_USE_TEMPLATE(NODE) (DECL_LANG_SPECIFIC (NODE)->decl_flags.use_template)

	/* Like DECL_USE_TEMPLATE, but for class types. */
	#define CLASSTYPE_USE_TEMPLATE(NODE) \
	(LANG_TYPE_CLASS_CHECK (NODE)->use_template)

	/* True if NODE is a specialization of a primary template. */
	#define CLASSTYPE_SPECIALIZATION_OF_PRIMARY_TEMPLATE_P(NODE) \
	(CLASS_TYPE_P (NODE) \
	&& CLASSTYPE_USE_TEMPLATE (NODE) \
	&& PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (arg)))

	#define DECL_TEMPLATE_INSTANTIATION(NODE) (DECL_USE_TEMPLATE (NODE) & 1)
	#define CLASSTYPE_TEMPLATE_INSTANTIATION(NODE) \
	(CLASSTYPE_USE_TEMPLATE (NODE) & 1)

	#define DECL_TEMPLATE_SPECIALIZATION(NODE) (DECL_USE_TEMPLATE (NODE) == 2)
	#define SET_DECL_TEMPLATE_SPECIALIZATION(NODE) (DECL_USE_TEMPLATE (NODE) = 2)

	/* Returns true for an explicit or partial specialization of a class
	template. */
	#define CLASSTYPE_TEMPLATE_SPECIALIZATION(NODE) \
	(CLASSTYPE_USE_TEMPLATE (NODE) == 2)
	#define SET_CLASSTYPE_TEMPLATE_SPECIALIZATION(NODE) \
	(CLASSTYPE_USE_TEMPLATE (NODE) = 2)

	#define DECL_IMPLICIT_INSTANTIATION(NODE) (DECL_USE_TEMPLATE (NODE) == 1)
	#define SET_DECL_IMPLICIT_INSTANTIATION(NODE) (DECL_USE_TEMPLATE (NODE) = 1)
	#define CLASSTYPE_IMPLICIT_INSTANTIATION(NODE) \
	(CLASSTYPE_USE_TEMPLATE (NODE) == 1)
	#define SET_CLASSTYPE_IMPLICIT_INSTANTIATION(NODE) \
	(CLASSTYPE_USE_TEMPLATE (NODE) = 1)

	#define DECL_EXPLICIT_INSTANTIATION(NODE) (DECL_USE_TEMPLATE (NODE) == 3)
	#define SET_DECL_EXPLICIT_INSTANTIATION(NODE) (DECL_USE_TEMPLATE (NODE) = 3)
	#define CLASSTYPE_EXPLICIT_INSTANTIATION(NODE) \
	(CLASSTYPE_USE_TEMPLATE (NODE) == 3)
	#define SET_CLASSTYPE_EXPLICIT_INSTANTIATION(NODE) \
	(CLASSTYPE_USE_TEMPLATE (NODE) = 3)

	/* Nonzero if DECL is a friend function which is an instantiation
	from the point of view of the compiler, but not from the point of
	view of the language. For example given:
	template <class T> struct S { friend void f(T) {}; };
	the declaration of `void f(int)' generated when S<int> is
	instantiated will not be a DECL_TEMPLATE_INSTANTIATION, but will be
	a DECL_FRIEND_PSUEDO_TEMPLATE_INSTANTIATION. */
	#define DECL_FRIEND_PSEUDO_TEMPLATE_INSTANTIATION(DECL) \
	(DECL_TEMPLATE_INFO (DECL) && !DECL_USE_TEMPLATE (DECL))

	/* Nonzero iff we are currently processing a declaration for an
	entity with its own template parameter list, and which is not a
	full specialization. */
	#define PROCESSING_REAL_TEMPLATE_DECL_P() \
	(processing_template_decl > template_class_depth (current_scope ()))

	/* Nonzero if this VAR_DECL or FUNCTION_DECL has already been
	instantiated, i.e. its definition has been generated from the
	pattern given in the template. */
	#define DECL_TEMPLATE_INSTANTIATED(NODE) \
	DECL_LANG_FLAG_1 (VAR_OR_FUNCTION_DECL_CHECK (NODE))

	/* We know what we're doing with this decl now. */
	#define DECL_INTERFACE_KNOWN(NODE) DECL_LANG_FLAG_5 (NODE)

	/* DECL_EXTERNAL must be set on a decl until the decl is actually emitted,
	so that assemble_external will work properly. So we have this flag to
	tell us whether the decl is really not external. */
	#define DECL_NOT_REALLY_EXTERN(NODE) \
	(DECL_LANG_SPECIFIC (NODE)->decl_flags.not_really_extern)

	#define DECL_REALLY_EXTERN(NODE) \
	(DECL_EXTERNAL (NODE) && ! DECL_NOT_REALLY_EXTERN (NODE))

	/* A thunk is a stub function.

	A thunk is an alternate entry point for an ordinary FUNCTION_DECL.
	The address of the ordinary FUNCTION_DECL is given by the
	DECL_INITIAL, which is always an ADDR_EXPR whose operand is a
	FUNCTION_DECL. The job of the thunk is to either adjust the this
	pointer before transferring control to the FUNCTION_DECL, or call
	FUNCTION_DECL and then adjust the result value. Note, the result
	pointer adjusting thunk must perform a call to the thunked
	function, (or be implemented via passing some invisible parameter
	to the thunked function, which is modified to perform the
	adjustment just before returning).

	A thunk may perform either, or both, of the following operations:

	o Adjust the this or result pointer by a constant offset.
	o Adjust the this or result pointer by looking up a vcall or vbase offset
	in the vtable.

	A this pointer adjusting thunk converts from a base to a derived
	class, and hence adds the offsets. A result pointer adjusting thunk
	converts from a derived class to a base, and hence subtracts the
	offsets. If both operations are performed, then the constant
	adjustment is performed first for this pointer adjustment and last
	for the result pointer adjustment.

	The constant adjustment is given by THUNK_FIXED_OFFSET. If the
	vcall or vbase offset is required, THUNK_VIRTUAL_OFFSET is
	used. For this pointer adjusting thunks, it is the vcall offset
	into the vtable. For result pointer adjusting thunks it is the
	binfo of the virtual base to convert to. Use that binfo's vbase
	offset.

	It is possible to have equivalent covariant thunks. These are
	distinct virtual covariant thunks whose vbase offsets happen to
	have the same value. THUNK_ALIAS is used to pick one as the
	canonical thunk, which will get all the this pointer adjusting
	thunks attached to it. */

	/* An integer indicating how many bytes should be subtracted from the
	this or result pointer when this function is called. */
	#define THUNK_FIXED_OFFSET(DECL) \
	(DECL_LANG_SPECIFIC (THUNK_FUNCTION_CHECK (DECL))->u.f.u5.fixed_offset)

	/* A tree indicating how to perform the virtual adjustment. For a this
	adjusting thunk it is the number of bytes to be added to the vtable
	to find the vcall offset. For a result adjusting thunk, it is the
	binfo of the relevant virtual base. If NULL, then there is no
	virtual adjust. (The vptr is always located at offset zero from
	the this or result pointer.) (If the covariant type is within the
	class hierarchy being laid out, the vbase index is not yet known
	at the point we need to create the thunks, hence the need to use
	binfos.) */

	#define THUNK_VIRTUAL_OFFSET(DECL) \
	(LANG_DECL_U2_CHECK (FUNCTION_DECL_CHECK (DECL), 0)->access)

	/* A thunk which is equivalent to another thunk. */
	#define THUNK_ALIAS(DECL) \
	(DECL_LANG_SPECIFIC (FUNCTION_DECL_CHECK (DECL))->decl_flags.u.template_info)

	/* For thunk NODE, this is the FUNCTION_DECL thunked to. It is
	possible for the target to be a thunk too. */
	#define THUNK_TARGET(NODE) \
	(DECL_LANG_SPECIFIC (NODE)->u.f.befriending_classes)

	/* True for a SCOPE_REF iff the "template" keyword was used to
	indicate that the qualified name denotes a template. */
	#define QUALIFIED_NAME_IS_TEMPLATE(NODE) \
	(TREE_LANG_FLAG_0 (SCOPE_REF_CHECK (NODE)))

	/* True for an OMP_ATOMIC that has dependent parameters. These are stored
	as bare LHS/RHS, and not as ADDR/RHS, as in the generic statement. */
	#define OMP_ATOMIC_DEPENDENT_P(NODE) \
	(TREE_LANG_FLAG_0 (OMP_ATOMIC_CHECK (NODE)))

	/* Used to store the operation code when OMP_ATOMIC_DEPENDENT_P is set. */
	#define OMP_ATOMIC_CODE(NODE) \
	(OMP_ATOMIC_CHECK (NODE)->exp.complexity)

	/* Used while gimplifying continue statements bound to OMP_FOR nodes. */
	#define OMP_FOR_GIMPLIFYING_P(NODE) \
	(TREE_LANG_FLAG_0 (OMP_FOR_CHECK (NODE)))

	/* A language-specific token attached to the OpenMP data clauses to
	hold code (or code fragments) related to ctors, dtors, and op=.
	See semantics.c for details. */
	#define CP_OMP_CLAUSE_INFO(NODE) \
	TREE_TYPE (OMP_CLAUSE_RANGE_CHECK (NODE, OMP_CLAUSE_PRIVATE, \
	OMP_CLAUSE_COPYPRIVATE))

	/* These macros provide convenient access to the various _STMT nodes
	created when parsing template declarations. */
	#define TRY_STMTS(NODE) TREE_OPERAND (TRY_BLOCK_CHECK (NODE), 0)
	#define TRY_HANDLERS(NODE) TREE_OPERAND (TRY_BLOCK_CHECK (NODE), 1)

	#define EH_SPEC_STMTS(NODE) TREE_OPERAND (EH_SPEC_BLOCK_CHECK (NODE), 0)
	#define EH_SPEC_RAISES(NODE) TREE_OPERAND (EH_SPEC_BLOCK_CHECK (NODE), 1)

	#define USING_STMT_NAMESPACE(NODE) TREE_OPERAND (USING_STMT_CHECK (NODE), 0)

	/* Nonzero if this try block is a function try block. */
	#define FN_TRY_BLOCK_P(NODE) TREE_LANG_FLAG_3 (TRY_BLOCK_CHECK (NODE))
	#define HANDLER_PARMS(NODE) TREE_OPERAND (HANDLER_CHECK (NODE), 0)
	#define HANDLER_BODY(NODE) TREE_OPERAND (HANDLER_CHECK (NODE), 1)
	#define HANDLER_TYPE(NODE) TREE_TYPE (HANDLER_CHECK (NODE))

	/* CLEANUP_STMT accessors. The statement(s) covered, the cleanup to run
	and the VAR_DECL for which this cleanup exists. */
	#define CLEANUP_BODY(NODE) TREE_OPERAND (CLEANUP_STMT_CHECK (NODE), 0)
	#define CLEANUP_EXPR(NODE) TREE_OPERAND (CLEANUP_STMT_CHECK (NODE), 1)
	#define CLEANUP_DECL(NODE) TREE_OPERAND (CLEANUP_STMT_CHECK (NODE), 2)

	/* IF_STMT accessors. These give access to the condition of the if
	statement, the then block of the if statement, and the else block
	of the if statement if it exists. */
	#define IF_COND(NODE) TREE_OPERAND (IF_STMT_CHECK (NODE), 0)
	#define THEN_CLAUSE(NODE) TREE_OPERAND (IF_STMT_CHECK (NODE), 1)
	#define ELSE_CLAUSE(NODE) TREE_OPERAND (IF_STMT_CHECK (NODE), 2)

	/* WHILE_STMT accessors. These give access to the condition of the
	while statement and the body of the while statement, respectively. */
	#define WHILE_COND(NODE) TREE_OPERAND (WHILE_STMT_CHECK (NODE), 0)
	#define WHILE_BODY(NODE) TREE_OPERAND (WHILE_STMT_CHECK (NODE), 1)
	+/* APPLE LOCAL begin for-fsf-4_4 3274130 5295549 */ \
	+#define WHILE_ATTRIBUTES(NODE) TREE_OPERAND (WHILE_STMT_CHECK (NODE), 2)

	+/* APPLE LOCAL end for-fsf-4_4 3274130 5295549 */ \
	/* DO_STMT accessors. These give access to the condition of the do
	statement and the body of the do statement, respectively. */
	#define DO_COND(NODE) TREE_OPERAND (DO_STMT_CHECK (NODE), 0)
	#define DO_BODY(NODE) TREE_OPERAND (DO_STMT_CHECK (NODE), 1)
	-
	+/* APPLE LOCAL begin for-fsf-4_4 3274130 5295549 */ \
	+#define DO_ATTRIBUTES(NODE) TREE_OPERAND (DO_STMT_CHECK (NODE), 2)
	+/* APPLE LOCAL begin C* language */
	+/* Used as a flag to indicate synthesized inner do-while loop of a
	+ foreach statement. Used for generation of break/continue statement
	+ of the loop. */
	+#define DO_FOREACH(NODE) TREE_OPERAND (DO_STMT_CHECK (NODE), 3)
	+/* APPLE LOCAL end C* language */
	+
	+/* APPLE LOCAL end for-fsf-4_4 3274130 5295549 */ \
	/* FOR_STMT accessors. These give access to the init statement,
	condition, update expression, and body of the for statement,
	respectively. */
	#define FOR_INIT_STMT(NODE) TREE_OPERAND (FOR_STMT_CHECK (NODE), 0)
	#define FOR_COND(NODE) TREE_OPERAND (FOR_STMT_CHECK (NODE), 1)
	#define FOR_EXPR(NODE) TREE_OPERAND (FOR_STMT_CHECK (NODE), 2)
	#define FOR_BODY(NODE) TREE_OPERAND (FOR_STMT_CHECK (NODE), 3)
	+/* APPLE LOCAL begin for-fsf-4_4 3274130 5295549 */ \
	+#define FOR_ATTRIBUTES(NODE) TREE_OPERAND (FOR_STMT_CHECK (NODE), 4)

	+/* APPLE LOCAL end for-fsf-4_4 3274130 5295549 */ \
	#define SWITCH_STMT_COND(NODE) TREE_OPERAND (SWITCH_STMT_CHECK (NODE), 0)
	#define SWITCH_STMT_BODY(NODE) TREE_OPERAND (SWITCH_STMT_CHECK (NODE), 1)
	#define SWITCH_STMT_TYPE(NODE) TREE_OPERAND (SWITCH_STMT_CHECK (NODE), 2)

	/* STMT_EXPR accessor. */
	#define STMT_EXPR_STMT(NODE) TREE_OPERAND (STMT_EXPR_CHECK (NODE), 0)

	/* EXPR_STMT accessor. This gives the expression associated with an
	expression statement. */
	#define EXPR_STMT_EXPR(NODE) TREE_OPERAND (EXPR_STMT_CHECK (NODE), 0)

	/* True if this TARGET_EXPR was created by build_cplus_new, and so we can
	discard it if it isn't useful. */
	#define TARGET_EXPR_IMPLICIT_P(NODE) \
	TREE_LANG_FLAG_0 (TARGET_EXPR_CHECK (NODE))

	/* An enumeration of the kind of tags that C++ accepts. */
	enum tag_types {
	none_type = 0, /* Not a tag type. */
	record_type, /* "struct" types. */
	class_type, /* "class" types. */
	union_type, /* "union" types. */
	enum_type, /* "enum" types. */
	typename_type /* "typename" types. */
	};

	/* The various kinds of lvalues we distinguish. */
	typedef enum cp_lvalue_kind {
	clk_none = 0, /* Things that are not an lvalue. */
	clk_ordinary = 1, /* An ordinary lvalue. */
	clk_class = 2, /* An rvalue of class-type. */
	clk_bitfield = 4, /* An lvalue for a bit-field. */
	clk_packed = 8 /* An lvalue for a packed field. */
	} cp_lvalue_kind;

	/* Various kinds of template specialization, instantiation, etc. */
	typedef enum tmpl_spec_kind {
	tsk_none, /* Not a template at all. */
	tsk_invalid_member_spec, /* An explicit member template
	specialization, but the enclosing
	classes have not all been explicitly
	specialized. */
	tsk_invalid_expl_inst, /* An explicit instantiation containing
	template parameter lists. */
	tsk_excessive_parms, /* A template declaration with too many
	template parameter lists. */
	tsk_insufficient_parms, /* A template declaration with too few
	parameter lists. */
	tsk_template, /* A template declaration. */
	tsk_expl_spec, /* An explicit specialization. */
	tsk_expl_inst /* An explicit instantiation. */
	} tmpl_spec_kind;

	/* The various kinds of access. BINFO_ACCESS depends on these being
	two bit quantities. The numerical values are important; they are
	used to initialize RTTI data structures, so changing them changes
	the ABI. */
	typedef enum access_kind {
	ak_none = 0, /* Inaccessible. */
	ak_public = 1, /* Accessible, as a `public' thing. */
	ak_protected = 2, /* Accessible, as a `protected' thing. */
	ak_private = 3 /* Accessible, as a `private' thing. */
	} access_kind;

	/* The various kinds of special functions. If you add to this list,
	you should update special_function_p as well. */
	typedef enum special_function_kind {
	sfk_none = 0, /* Not a special function. This enumeral
	must have value zero; see
	special_function_p. */
	sfk_constructor, /* A constructor. */
	sfk_copy_constructor, /* A copy constructor. */
	sfk_assignment_operator, /* An assignment operator. */
	sfk_destructor, /* A destructor. */
	sfk_complete_destructor, /* A destructor for complete objects. */
	sfk_base_destructor, /* A destructor for base subobjects. */
	sfk_deleting_destructor, /* A destructor for complete objects that
	deletes the object after it has been
	destroyed. */
	sfk_conversion /* A conversion operator. */
	} special_function_kind;

	/* The various kinds of linkage. From [basic.link],

	A name is said to have linkage when it might denote the same
	object, reference, function, type, template, namespace or value
	as a name introduced in another scope:

	-- When a name has external linkage, the entity it denotes can
	be referred to from scopes of other translation units or from
	other scopes of the same translation unit.

	-- When a name has internal linkage, the entity it denotes can
	be referred to by names from other scopes in the same
	translation unit.

	-- When a name has no linkage, the entity it denotes cannot be
	referred to by names from other scopes. */

	typedef enum linkage_kind {
	lk_none, /* No linkage. */
	lk_internal, /* Internal linkage. */
	lk_external /* External linkage. */
	} linkage_kind;

	/* Bitmask flags to control type substitution. */
	typedef enum tsubst_flags_t {
	tf_none = 0, /* nothing special */
	tf_error = 1 << 0, /* give error messages */
	tf_warning = 1 << 1, /* give warnings too */
	tf_ignore_bad_quals = 1 << 2, /* ignore bad cvr qualifiers */
	tf_keep_type_decl = 1 << 3, /* retain typedef type decls
	(make_typename_type use) */
	tf_ptrmem_ok = 1 << 4, /* pointers to member ok (internal
	instantiate_type use) */
	tf_user = 1 << 5, /* found template must be a user template
	(lookup_template_class use) */
	tf_conv = 1 << 6, /* We are determining what kind of
	conversion might be permissible,
	not actually performing the
	conversion. */
	/* Convenient substitution flags combinations. */
	tf_warning_or_error = tf_warning \| tf_error
	} tsubst_flags_t;

	/* The kind of checking we can do looking in a class hierarchy. */
	typedef enum base_access {
	ba_any = 0, /* Do not check access, allow an ambiguous base,
	prefer a non-virtual base */
	ba_unique = 1 << 0, /* Must be a unique base. */
	ba_check_bit = 1 << 1, /* Check access. */
	ba_check = ba_unique \| ba_check_bit,
	ba_ignore_scope = 1 << 2, /* Ignore access allowed by local scope. */
	ba_quiet = 1 << 3 /* Do not issue error messages. */
	} base_access;

	/* The various kinds of access check during parsing. */
	typedef enum deferring_kind {
	dk_no_deferred = 0, /* Check access immediately */
	dk_deferred = 1, /* Deferred check */
	dk_no_check = 2 /* No access check */
	} deferring_kind;

	/* The kind of base we can find, looking in a class hierarchy.
	Values <0 indicate we failed. */
	typedef enum base_kind {
	bk_inaccessible = -3, /* The base is inaccessible */
	bk_ambig = -2, /* The base is ambiguous */
	bk_not_base = -1, /* It is not a base */
	bk_same_type = 0, /* It is the same type */
	bk_proper_base = 1, /* It is a proper base */
	bk_via_virtual = 2 /* It is a proper base, but via a virtual
	path. This might not be the canonical
	binfo. */
	} base_kind;

	/* Node for "pointer to (virtual) function".
	This may be distinct from ptr_type_node so gdb can distinguish them. */
	#define vfunc_ptr_type_node vtable_entry_type


	/* For building calls to `delete'. */
	extern GTY(()) tree integer_two_node;
	extern GTY(()) tree integer_three_node;

	/* The number of function bodies which we are currently processing.
	(Zero if we are at namespace scope, one inside the body of a
	function, two inside the body of a function in a local class, etc.) */
	extern int function_depth;

	/* in pt.c */

	/* These values are used for the `STRICT' parameter to type_unification and
	fn_type_unification. Their meanings are described with the
	documentation for fn_type_unification. */

	typedef enum unification_kind_t {
	DEDUCE_CALL,
	DEDUCE_CONV,
	DEDUCE_EXACT
	} unification_kind_t;

	/* Macros for operating on a template instantiation level node. */

	#define TINST_DECL(NODE) \
	(((tinst_level_t) TINST_LEVEL_CHECK (NODE))->decl)
	#define TINST_LOCATION(NODE) \
	(((tinst_level_t) TINST_LEVEL_CHECK (NODE))->locus)
	#define TINST_IN_SYSTEM_HEADER_P(NODE) \
	(((tinst_level_t) TINST_LEVEL_CHECK (NODE))->in_system_header_p)

	/* in class.c */

	extern int current_class_depth;

	/* An array of all local classes present in this translation unit, in
	declaration order. */
	extern GTY(()) VEC(tree,gc) *local_classes;

	/* Here's where we control how name mangling takes place. */

	/* Cannot use '$' up front, because this confuses gdb
	(names beginning with '$' are gdb-local identifiers).

	Note that all forms in which the '$' is significant are long enough
	for direct indexing (meaning that if we know there is a '$'
	at a particular location, we can index into the string at
	any other location that provides distinguishing characters). */

	/* Define NO_DOLLAR_IN_LABEL in your favorite tm file if your assembler
	doesn't allow '$' in symbol names. */
	#ifndef NO_DOLLAR_IN_LABEL

	#define JOINER '$'

	#define AUTO_TEMP_NAME "_$tmp_"
	#define VFIELD_BASE "$vf"
	#define VFIELD_NAME "_vptr$"
	#define VFIELD_NAME_FORMAT "_vptr$%s"
	#define ANON_AGGRNAME_FORMAT "$_%d"

	#else /* NO_DOLLAR_IN_LABEL */

	#ifndef NO_DOT_IN_LABEL

	#define JOINER '.'

	#define AUTO_TEMP_NAME "_.tmp_"
	#define VFIELD_BASE ".vf"
	#define VFIELD_NAME "_vptr."
	#define VFIELD_NAME_FORMAT "_vptr.%s"

	#define ANON_AGGRNAME_FORMAT "._%d"

	#else /* NO_DOT_IN_LABEL */

	#define IN_CHARGE_NAME "__in_chrg"
	#define AUTO_TEMP_NAME "__tmp_"
	#define TEMP_NAME_P(ID_NODE) \
	(!strncmp (IDENTIFIER_POINTER (ID_NODE), AUTO_TEMP_NAME, \
	sizeof (AUTO_TEMP_NAME) - 1))
	#define VTABLE_NAME "__vt_"
	#define VTABLE_NAME_P(ID_NODE) \
	(!strncmp (IDENTIFIER_POINTER (ID_NODE), VTABLE_NAME, \
	sizeof (VTABLE_NAME) - 1))
	#define VFIELD_BASE "__vfb"
	#define VFIELD_NAME "__vptr_"
	#define VFIELD_NAME_P(ID_NODE) \
	(!strncmp (IDENTIFIER_POINTER (ID_NODE), VFIELD_NAME, \
	sizeof (VFIELD_NAME) - 1))
	#define VFIELD_NAME_FORMAT "__vptr_%s"

	#define ANON_AGGRNAME_PREFIX "__anon_"
	#define ANON_AGGRNAME_P(ID_NODE) \
	(!strncmp (IDENTIFIER_POINTER (ID_NODE), ANON_AGGRNAME_PREFIX, \
	sizeof (ANON_AGGRNAME_PREFIX) - 1))
	#define ANON_AGGRNAME_FORMAT "__anon_%d"

	#endif /* NO_DOT_IN_LABEL */
	#endif /* NO_DOLLAR_IN_LABEL */

	#define THIS_NAME "this"

	#define IN_CHARGE_NAME "__in_chrg"

	#define VTBL_PTR_TYPE "__vtbl_ptr_type"
	#define VTABLE_DELTA_NAME "__delta"
	#define VTABLE_PFN_NAME "__pfn"

	#if !defined(NO_DOLLAR_IN_LABEL) \|\| !defined(NO_DOT_IN_LABEL)

	#define VTABLE_NAME_P(ID_NODE) (IDENTIFIER_POINTER (ID_NODE)[1] == 'v' \
	&& IDENTIFIER_POINTER (ID_NODE)[2] == 't' \
	&& IDENTIFIER_POINTER (ID_NODE)[3] == JOINER)

	#define TEMP_NAME_P(ID_NODE) \
	(!strncmp (IDENTIFIER_POINTER (ID_NODE), AUTO_TEMP_NAME, sizeof (AUTO_TEMP_NAME)-1))
	#define VFIELD_NAME_P(ID_NODE) \
	(!strncmp (IDENTIFIER_POINTER (ID_NODE), VFIELD_NAME, sizeof(VFIELD_NAME)-1))

	/* For anonymous aggregate types, we need some sort of name to
	hold on to. In practice, this should not appear, but it should
	not be harmful if it does. */
	#define ANON_AGGRNAME_P(ID_NODE) (IDENTIFIER_POINTER (ID_NODE)[0] == JOINER \
	&& IDENTIFIER_POINTER (ID_NODE)[1] == '_')
	#endif /* !defined(NO_DOLLAR_IN_LABEL) \|\| !defined(NO_DOT_IN_LABEL) */


	/* Nonzero if we're done parsing and into end-of-file activities. */

	extern int at_eof;

	/* A list of namespace-scope objects which have constructors or
	destructors which reside in the global scope. The decl is stored
	in the TREE_VALUE slot and the initializer is stored in the
	TREE_PURPOSE slot. */
	extern GTY(()) tree static_aggregates;

	/* Functions called along with real static constructors and destructors. */

	extern GTY(()) tree static_ctors;
	extern GTY(()) tree static_dtors;

	enum overload_flags { NO_SPECIAL = 0, DTOR_FLAG, OP_FLAG, TYPENAME_FLAG };

	/* These are uses as bits in flags passed to various functions to
	control their behavior. Despite the LOOKUP_ prefix, many of these
	do not control name lookup. ??? Functions using these flags should
	probably be modified to accept explicit boolean flags for the
	behaviors relevant to them. */
	/* Check for access violations. */
	#define LOOKUP_PROTECT (1 << 0)
	/* Complain if no suitable member function matching the arguments is
	found. */
	#define LOOKUP_COMPLAIN (1 << 1)
	#define LOOKUP_NORMAL (LOOKUP_PROTECT \| LOOKUP_COMPLAIN)
	/* Even if the function found by lookup is a virtual function, it
	should be called directly. */
	#define LOOKUP_NONVIRTUAL (1 << 2)
	/* Non-converting (i.e., "explicit") constructors are not tried. */
	#define LOOKUP_ONLYCONVERTING (1 << 3)
	/* If a temporary is created, it should be created so that it lives
	as long as the current variable bindings; otherwise it only lives
	until the end of the complete-expression. It also forces
	direct-initialization in cases where other parts of the compiler
	have already generated a temporary, such as reference
	initialization and the catch parameter. */
	#define DIRECT_BIND (1 << 4)
	/* User-defined conversions are not permitted. (Built-in conversions
	are permitted.) */
	#define LOOKUP_NO_CONVERSION (1 << 5)
	/* The user has explicitly called a destructor. (Therefore, we do
	not need to check that the object is non-NULL before calling the
	destructor.) */
	#define LOOKUP_DESTRUCTOR (1 << 6)
	/* Do not permit references to bind to temporaries. */
	#define LOOKUP_NO_TEMP_BIND (1 << 7)
	/* Do not accept objects, and possibly namespaces. */
	#define LOOKUP_PREFER_TYPES (1 << 8)
	/* Do not accept objects, and possibly types. */
	#define LOOKUP_PREFER_NAMESPACES (1 << 9)
	/* Accept types or namespaces. */
	#define LOOKUP_PREFER_BOTH (LOOKUP_PREFER_TYPES \| LOOKUP_PREFER_NAMESPACES)
	/* We are checking that a constructor can be called -- but we do not
	actually plan to call it. */
	#define LOOKUP_CONSTRUCTOR_CALLABLE (1 << 10)
	/* Return friend declarations and un-declared builtin functions.
	(Normally, these entities are registered in the symbol table, but
	not found by lookup.) */
	#define LOOKUP_HIDDEN (LOOKUP_CONSTRUCTOR_CALLABLE << 1)

	#define LOOKUP_NAMESPACES_ONLY(F) \
	(((F) & LOOKUP_PREFER_NAMESPACES) && !((F) & LOOKUP_PREFER_TYPES))
	#define LOOKUP_TYPES_ONLY(F) \
	(!((F) & LOOKUP_PREFER_NAMESPACES) && ((F) & LOOKUP_PREFER_TYPES))
	#define LOOKUP_QUALIFIERS_ONLY(F) ((F) & LOOKUP_PREFER_BOTH)


	/* These flags are used by the conversion code.
	CONV_IMPLICIT : Perform implicit conversions (standard and user-defined).
	CONV_STATIC : Perform the explicit conversions for static_cast.
	CONV_CONST : Perform the explicit conversions for const_cast.
	CONV_REINTERPRET: Perform the explicit conversions for reinterpret_cast.
	CONV_PRIVATE : Perform upcasts to private bases.
	CONV_FORCE_TEMP : Require a new temporary when converting to the same
	aggregate type. */

	#define CONV_IMPLICIT 1
	#define CONV_STATIC 2
	#define CONV_CONST 4
	#define CONV_REINTERPRET 8
	#define CONV_PRIVATE 16
	/* #define CONV_NONCONVERTING 32 */
	#define CONV_FORCE_TEMP 64
	#define CONV_OLD_CONVERT (CONV_IMPLICIT \| CONV_STATIC \| CONV_CONST \
	\| CONV_REINTERPRET)
	#define CONV_C_CAST (CONV_IMPLICIT \| CONV_STATIC \| CONV_CONST \
	\| CONV_REINTERPRET \| CONV_PRIVATE \| CONV_FORCE_TEMP)

	/* Used by build_expr_type_conversion to indicate which types are
	acceptable as arguments to the expression under consideration. */

	#define WANT_INT 1 /* integer types, including bool */
	#define WANT_FLOAT 2 /* floating point types */
	#define WANT_ENUM 4 /* enumerated types */
	#define WANT_POINTER 8 /* pointer types */
	#define WANT_NULL 16 /* null pointer constant */
	#define WANT_VECTOR 32 /* vector types */
	#define WANT_ARITH (WANT_INT \| WANT_FLOAT \| WANT_VECTOR)

	/* Used with comptypes, and related functions, to guide type
	comparison. */

	#define COMPARE_STRICT 0 /* Just check if the types are the
	same. */
	#define COMPARE_BASE 1 /* Check to see if the second type is
	derived from the first. */
	#define COMPARE_DERIVED 2 /* Like COMPARE_BASE, but in
	reverse. */
	#define COMPARE_REDECLARATION 4 /* The comparison is being done when
	another declaration of an existing
	entity is seen. */

	/* Used with push_overloaded_decl. */
	#define PUSH_GLOBAL 0 /* Push the DECL into namespace scope,
	regardless of the current scope. */
	#define PUSH_LOCAL 1 /* Push the DECL into the current
	scope. */
	#define PUSH_USING 2 /* We are pushing this DECL as the
	result of a using declaration. */

	/* Used with start function. */
	#define SF_DEFAULT 0 /* No flags. */
	#define SF_PRE_PARSED 1 /* The function declaration has
	already been parsed. */
	#define SF_INCLASS_INLINE 2 /* The function is an inline, defined
	in the class body. */

	/* Returns nonzero iff TYPE1 and TYPE2 are the same type, or if TYPE2
	is derived from TYPE1, or if TYPE2 is a pointer (reference) to a
	class derived from the type pointed to (referred to) by TYPE1. */
	#define same_or_base_type_p(TYPE1, TYPE2) \
	comptypes ((TYPE1), (TYPE2), COMPARE_BASE)

	/* These macros are used to access a TEMPLATE_PARM_INDEX. */
	#define TEMPLATE_PARM_INDEX_CAST(NODE) \
	((template_parm_index*)TEMPLATE_PARM_INDEX_CHECK (NODE))
	#define TEMPLATE_PARM_IDX(NODE) (TEMPLATE_PARM_INDEX_CAST (NODE)->index)
	#define TEMPLATE_PARM_LEVEL(NODE) (TEMPLATE_PARM_INDEX_CAST (NODE)->level)
	#define TEMPLATE_PARM_DESCENDANTS(NODE) (TREE_CHAIN (NODE))
	#define TEMPLATE_PARM_ORIG_LEVEL(NODE) (TEMPLATE_PARM_INDEX_CAST (NODE)->orig_level)
	#define TEMPLATE_PARM_DECL(NODE) (TEMPLATE_PARM_INDEX_CAST (NODE)->decl)

	/* These macros are for accessing the fields of TEMPLATE_TYPE_PARM,
	TEMPLATE_TEMPLATE_PARM and BOUND_TEMPLATE_TEMPLATE_PARM nodes. */
	#define TEMPLATE_TYPE_PARM_INDEX(NODE) \
	(TREE_CHECK3 ((NODE), TEMPLATE_TYPE_PARM, TEMPLATE_TEMPLATE_PARM, \
	BOUND_TEMPLATE_TEMPLATE_PARM))->type.values
	#define TEMPLATE_TYPE_IDX(NODE) \
	(TEMPLATE_PARM_IDX (TEMPLATE_TYPE_PARM_INDEX (NODE)))
	#define TEMPLATE_TYPE_LEVEL(NODE) \
	(TEMPLATE_PARM_LEVEL (TEMPLATE_TYPE_PARM_INDEX (NODE)))
	#define TEMPLATE_TYPE_ORIG_LEVEL(NODE) \
	(TEMPLATE_PARM_ORIG_LEVEL (TEMPLATE_TYPE_PARM_INDEX (NODE)))
	#define TEMPLATE_TYPE_DECL(NODE) \
	(TEMPLATE_PARM_DECL (TEMPLATE_TYPE_PARM_INDEX (NODE)))

	/* These constants can used as bit flags in the process of tree formatting.

	TFF_PLAIN_IDENTIFIER: unqualified part of a name.
	TFF_SCOPE: include the class and namespace scope of the name.
	TFF_CHASE_TYPEDEF: print the original type-id instead of the typedef-name.
	TFF_DECL_SPECIFIERS: print decl-specifiers.
	TFF_CLASS_KEY_OR_ENUM: precede a class-type name (resp. enum name) with
	a class-key (resp. `enum').
	TFF_RETURN_TYPE: include function return type.
	TFF_FUNCTION_DEFAULT_ARGUMENTS: include function default parameter values.
	TFF_EXCEPTION_SPECIFICATION: show function exception specification.
	TFF_TEMPLATE_HEADER: show the template<...> header in a
	template-declaration.
	TFF_TEMPLATE_NAME: show only template-name.
	TFF_EXPR_IN_PARENS: parenthesize expressions.
	TFF_NO_FUNCTION_ARGUMENTS: don't show function arguments. */

	#define TFF_PLAIN_IDENTIFIER (0)
	#define TFF_SCOPE (1)
	#define TFF_CHASE_TYPEDEF (1 << 1)
	#define TFF_DECL_SPECIFIERS (1 << 2)
	#define TFF_CLASS_KEY_OR_ENUM (1 << 3)
	#define TFF_RETURN_TYPE (1 << 4)
	#define TFF_FUNCTION_DEFAULT_ARGUMENTS (1 << 5)
	#define TFF_EXCEPTION_SPECIFICATION (1 << 6)
	#define TFF_TEMPLATE_HEADER (1 << 7)
	#define TFF_TEMPLATE_NAME (1 << 8)
	#define TFF_EXPR_IN_PARENS (1 << 9)
	#define TFF_NO_FUNCTION_ARGUMENTS (1 << 10)

	/* Returns the TEMPLATE_DECL associated to a TEMPLATE_TEMPLATE_PARM
	node. */
	#define TEMPLATE_TEMPLATE_PARM_TEMPLATE_DECL(NODE) \
	((TREE_CODE (NODE) == BOUND_TEMPLATE_TEMPLATE_PARM) \
	? TYPE_TI_TEMPLATE (NODE) \
	: TYPE_NAME (NODE))

	/* in lex.c */

	extern void init_reswords (void);

	/* Indexed by TREE_CODE, these tables give C-looking names to
	operators represented by TREE_CODES. For example,
	opname_tab[(int) MINUS_EXPR] == "-". */
	extern const char opname_tab, assignop_tab;

	typedef struct operator_name_info_t GTY(())
	{
	/* The IDENTIFIER_NODE for the operator. */
	tree identifier;
	/* The name of the operator. */
	const char *name;
	/* The mangled name of the operator. */
	const char *mangled_name;
	/* The arity of the operator. */
	int arity;
	} operator_name_info_t;

	/* A mapping from tree codes to operator name information. */
	extern GTY(()) operator_name_info_t operator_name_info
	[(int) LAST_CPLUS_TREE_CODE];
	/* Similar, but for assignment operators. */
	extern GTY(()) operator_name_info_t assignment_operator_name_info
	[(int) LAST_CPLUS_TREE_CODE];

	/* A type-qualifier, or bitmask therefore, using the TYPE_QUAL
	constants. */

	typedef int cp_cv_quals;

	/* A storage class. */

	typedef enum cp_storage_class {
	/* sc_none must be zero so that zeroing a cp_decl_specifier_seq
	sets the storage_class field to sc_none. */
	sc_none = 0,
	sc_auto,
	sc_register,
	sc_static,
	sc_extern,
	sc_mutable
	} cp_storage_class;

	/* An individual decl-specifier. */

	typedef enum cp_decl_spec {
	ds_first,
	ds_signed = ds_first,
	ds_unsigned,
	ds_short,
	ds_long,
	ds_const,
	ds_volatile,
	ds_restrict,
	ds_inline,
	ds_virtual,
	ds_explicit,
	ds_friend,
	ds_typedef,
	ds_complex,
	ds_thread,
	ds_last
	} cp_decl_spec;

	/* A decl-specifier-seq. */

	typedef struct cp_decl_specifier_seq {
	/* The number of times each of the keywords has been seen. */
	unsigned specs[(int) ds_last];
	/* The primary type, if any, given by the decl-specifier-seq.
	Modifiers, like "short", "const", and "unsigned" are not
	reflected here. This field will be a TYPE, unless a typedef-name
	was used, in which case it will be a TYPE_DECL. */
	tree type;
	/* The attributes, if any, provided with the specifier sequence. */
	tree attributes;
	/* If non-NULL, a built-in type that the user attempted to redefine
	to some other type. */
	tree redefined_builtin_type;
	/* The storage class specified -- or sc_none if no storage class was
	explicitly specified. */
	cp_storage_class storage_class;
	/* True iff TYPE_SPEC indicates a user-defined type. */
	BOOL_BITFIELD user_defined_type_p : 1;
	/* True iff multiple types were (erroneously) specified for this
	decl-specifier-seq. */
	BOOL_BITFIELD multiple_types_p : 1;
	/* True iff multiple storage classes were (erroneously) specified
	for this decl-specifier-seq or a combination of a storage class
	with a typedef specifier. */
	BOOL_BITFIELD conflicting_specifiers_p : 1;
	/* True iff at least one decl-specifier was found. */
	BOOL_BITFIELD any_specifiers_p : 1;
	/* True iff "int" was explicitly provided. */
	BOOL_BITFIELD explicit_int_p : 1;
	/* True iff "char" was explicitly provided. */
	BOOL_BITFIELD explicit_char_p : 1;
	} cp_decl_specifier_seq;

	/* The various kinds of declarators. */

	typedef enum cp_declarator_kind {
	cdk_id,
	cdk_function,
	cdk_array,
	cdk_pointer,
	cdk_reference,
	cdk_ptrmem,
	cdk_error
	} cp_declarator_kind;

	/* A declarator. */

	typedef struct cp_declarator cp_declarator;

	typedef struct cp_parameter_declarator cp_parameter_declarator;

	/* A parameter, before it has been semantically analyzed. */
	struct cp_parameter_declarator {
	/* The next parameter, or NULL_TREE if none. */
	cp_parameter_declarator *next;
	/* The decl-specifiers-seq for the parameter. */
	cp_decl_specifier_seq decl_specifiers;
	/* The declarator for the parameter. */
	cp_declarator *declarator;
	/* The default-argument expression, or NULL_TREE, if none. */
	tree default_argument;
	/* True iff this is the first parameter in the list and the
	parameter sequence ends with an ellipsis. */
	bool ellipsis_p;
	};

	/* A declarator. */
	struct cp_declarator {
	/* The kind of declarator. */
	cp_declarator_kind kind;
	/* Attributes that apply to this declarator. */
	tree attributes;
	/* For all but cdk_id and cdk_error, the contained declarator. For
	cdk_id and cdk_error, guaranteed to be NULL. */
	cp_declarator *declarator;
	location_t id_loc; /* Currently only set for cdk_id. */
	union {
	/* For identifiers. */
	struct {
	/* If non-NULL, the qualifying scope (a NAMESPACE_DECL or
	_TYPE) for this identifier. /
	tree qualifying_scope;
	/* The unqualified name of the entity -- an IDENTIFIER_NODE,
	BIT_NOT_EXPR, or TEMPLATE_ID_EXPR. */
	tree unqualified_name;
	/* If this is the name of a function, what kind of special
	function (if any). */
	special_function_kind sfk;
	} id;
	/* For functions. */
	struct {
	/* The parameters to the function. */
	cp_parameter_declarator *parameters;
	/* The cv-qualifiers for the function. */
	cp_cv_quals qualifiers;
	/* The exception-specification for the function. */
	tree exception_specification;
	} function;
	/* For arrays. */
	struct {
	/* The bounds to the array. */
	tree bounds;
	} array;
	/* For cdk_pointer, cdk_reference, and cdk_ptrmem. */
	struct {
	/* The cv-qualifiers for the pointer. */
	cp_cv_quals qualifiers;
	/* For cdk_ptrmem, the class type containing the member. */
	tree class_type;
	} pointer;
	} u;
	};

	/* A parameter list indicating for a function with no parameters,
	e.g "int f(void)". */
	extern cp_parameter_declarator *no_parameters;

	/* in call.c */
	extern bool check_dtor_name (tree, tree);

	extern tree build_vfield_ref (tree, tree);
	extern tree build_conditional_expr (tree, tree, tree);
	extern tree build_addr_func (tree);
	extern tree build_call (tree, tree);
	extern bool null_ptr_cst_p (tree);
	extern bool sufficient_parms_p (tree);
	extern tree type_decays_to (tree);
	extern tree build_user_type_conversion (tree, tree, int);
	extern tree build_new_function_call (tree, tree, bool);
	extern tree build_operator_new_call (tree, tree, tree , tree ,
	tree *);
	extern tree build_new_method_call (tree, tree, tree, tree, int,
	tree *);
	extern tree build_special_member_call (tree, tree, tree, tree, int);
	extern tree build_new_op (enum tree_code, int, tree, tree, tree, bool *);
	extern tree build_op_delete_call (enum tree_code, tree, tree, bool, tree, tree);
	extern bool can_convert (tree, tree);
	extern bool can_convert_arg (tree, tree, tree, int);
	extern bool can_convert_arg_bad (tree, tree, tree);
	extern bool enforce_access (tree, tree, tree);
	extern tree convert_default_arg (tree, tree, tree, int);
	extern tree convert_arg_to_ellipsis (tree);
	extern tree build_x_va_arg (tree, tree);
	extern tree cxx_type_promotes_to (tree);
	extern tree type_passed_as (tree);
	extern tree convert_for_arg_passing (tree, tree);
	extern bool is_properly_derived_from (tree, tree);
	extern tree initialize_reference (tree, tree, tree, tree *);
	extern tree make_temporary_var_for_ref_to_temp (tree, tree);
	extern tree strip_top_quals (tree);
	extern tree perform_implicit_conversion (tree, tree);
	extern tree perform_direct_initialization_if_possible (tree, tree, bool);
	extern tree in_charge_arg_for_name (tree);
	extern tree build_cxx_call (tree, tree);
	#ifdef ENABLE_CHECKING
	extern void validate_conversion_obstack (void);
	#endif /* ENABLE_CHECKING */

	/* in class.c */
	extern tree build_base_path (enum tree_code, tree,
	tree, int);
	extern tree convert_to_base (tree, tree, bool, bool);
	extern tree convert_to_base_statically (tree, tree);
	extern tree build_vtbl_ref (tree, tree);
	extern tree build_vfn_ref (tree, tree);
	extern tree get_vtable_decl (tree, int);
	extern void resort_type_method_vec (void , void ,
	gt_pointer_operator, void *);
	extern bool add_method (tree, tree, tree);
	extern bool currently_open_class (tree);
	extern tree currently_open_derived_class (tree);
	extern tree finish_struct (tree, tree);
	extern void finish_struct_1 (tree);
	extern int resolves_to_fixed_type_p (tree, int *);
	extern void init_class_processing (void);
	extern int is_empty_class (tree);
	extern void pushclass (tree);
	extern void popclass (void);
	extern void push_nested_class (tree);
	extern void pop_nested_class (void);
	extern int current_lang_depth (void);
	extern void push_lang_context (tree);
	extern void pop_lang_context (void);
	extern tree instantiate_type (tree, tree, tsubst_flags_t);
	extern void print_class_statistics (void);
	extern void cxx_print_statistics (void);
	extern void cxx_print_xnode (FILE *, tree, int);
	extern void cxx_print_decl (FILE *, tree, int);
	extern void cxx_print_type (FILE *, tree, int);
	extern void cxx_print_identifier (FILE *, tree, int);
	extern void cxx_print_error_function (struct diagnostic_context *,
	const char *);
	extern void build_self_reference (void);
	extern int same_signature_p (tree, tree);
	extern void maybe_add_class_template_decl_list (tree, tree, int);
	extern void unreverse_member_declarations (tree);
	extern void invalidate_class_lookup_cache (void);
	extern void maybe_note_name_used_in_class (tree, tree);
	extern void note_name_declared_in_class (tree, tree);
	extern tree get_vtbl_decl_for_binfo (tree);
	extern void debug_class (tree);
	extern void debug_thunks (tree);
	extern tree cp_fold_obj_type_ref (tree, tree);
	extern void set_linkage_according_to_type (tree, tree);
	extern void determine_key_method (tree);
	extern void check_for_override (tree, tree);
	extern void push_class_stack (void);
	extern void pop_class_stack (void);

	/* in cvt.c */
	extern tree convert_to_reference (tree, tree, int, int, tree);
	extern tree convert_from_reference (tree);
	extern tree force_rvalue (tree);
	extern tree ocp_convert (tree, tree, int, int);
	extern tree cp_convert (tree, tree);
	extern tree convert_to_void (tree, const char /implicit context*/);
	extern tree convert_force (tree, tree, int);
	extern tree build_expr_type_conversion (int, tree, bool);
	extern tree type_promotes_to (tree);
	extern tree perform_qualification_conversions (tree, tree);
	extern void clone_function_decl (tree, int);
	extern void adjust_clone_args (tree);

	/* decl.c */
	extern tree poplevel (int, int, int);
	extern void insert_block (tree);
	extern tree pushdecl (tree);
	extern tree pushdecl_maybe_friend (tree, bool);
	extern void cxx_init_decl_processing (void);
	enum cp_tree_node_structure_enum cp_tree_node_structure
	(union lang_tree_node *);
	extern bool cxx_mark_addressable (tree);
	extern void cxx_push_function_context (struct function *);
	extern void cxx_pop_function_context (struct function *);
	extern void maybe_push_cleanup_level (tree);
	extern void finish_scope (void);
	extern void push_switch (tree);
	extern void pop_switch (void);
	extern tree pushtag (tree, tree, tag_scope);
	extern tree make_anon_name (void);
	extern int decls_match (tree, tree);
	extern tree duplicate_decls (tree, tree, bool);
	extern tree pushdecl_top_level_maybe_friend (tree, bool);
	extern tree pushdecl_top_level_and_finish (tree, tree);
	extern tree declare_local_label (tree);
	extern tree define_label (location_t, tree);
	extern void check_goto (tree);
	extern bool check_omp_return (void);
	extern tree make_typename_type (tree, tree, enum tag_types, tsubst_flags_t);
	extern tree make_unbound_class_template (tree, tree, tree, tsubst_flags_t);
	extern tree check_for_out_of_scope_variable (tree);
	extern tree build_library_fn (tree, tree);
	extern tree build_library_fn_ptr (const char *, tree);
	extern tree build_cp_library_fn_ptr (const char *, tree);
	extern tree push_library_fn (tree, tree);
	extern tree push_void_library_fn (tree, tree);
	extern tree push_throw_library_fn (tree, tree);
	extern tree check_tag_decl (cp_decl_specifier_seq *);
	extern tree shadow_tag (cp_decl_specifier_seq *);
	extern tree groktypename (cp_decl_specifier_seq , const cp_declarator );
	extern tree start_decl (const cp_declarator , cp_decl_specifier_seq , int, tree, tree, tree *);
	extern void start_decl_1 (tree, bool);
	extern void cp_finish_decl (tree, tree, bool, tree, int);
	extern void finish_decl (tree, tree, tree);
	extern int cp_complete_array_type (tree *, tree, bool);
	extern tree build_ptrmemfunc_type (tree);
	extern tree build_ptrmem_type (tree, tree);
	/* the grokdeclarator prototype is in decl.h */
	extern tree build_this_parm (tree, cp_cv_quals);
	extern int copy_fn_p (tree);
	extern tree get_scope_of_declarator (const cp_declarator *);
	extern void grok_special_member_properties (tree);
	extern int grok_ctor_properties (tree, tree);
	extern bool grok_op_properties (tree, bool);
	extern tree xref_tag (enum tag_types, tree, tag_scope, bool);
	extern tree xref_tag_from_type (tree, tree, tag_scope);
	extern bool xref_basetypes (tree, tree);
	extern tree start_enum (tree);
	extern void finish_enum (tree);
	extern void build_enumerator (tree, tree, tree);
	extern void start_preparsed_function (tree, tree, int);
	extern int start_function (cp_decl_specifier_seq , const cp_declarator , tree);
	extern tree begin_function_body (void);
	extern void finish_function_body (tree);
	extern tree finish_function (int);
	extern tree start_method (cp_decl_specifier_seq , const cp_declarator , tree);
	extern tree finish_method (tree);
	extern void maybe_register_incomplete_var (tree);
	extern void complete_vars (tree);
	extern void finish_stmt (void);
	extern void print_other_binding_stack (struct cp_binding_level *);
	extern void revert_static_member_fn (tree);
	extern void fixup_anonymous_aggr (tree);
	extern int check_static_variable_definition (tree, tree);
	extern tree compute_array_index_type (tree, tree);
	extern tree check_default_argument (tree, tree);
	typedef int (walk_namespaces_fn) (tree, void );
	extern int walk_namespaces (walk_namespaces_fn,
	void *);
	extern int wrapup_globals_for_namespace (tree, void *);
	extern tree create_implicit_typedef (tree, tree);
	extern tree maybe_push_decl (tree);
	extern tree force_target_expr (tree, tree);
	extern tree build_target_expr_with_type (tree, tree);
	extern int local_variable_p (tree);
	extern int nonstatic_local_decl_p (tree);
	extern tree register_dtor_fn (tree);
	extern tmpl_spec_kind current_tmpl_spec_kind (int);
	extern tree cp_fname_init (const char , tree );
	extern tree builtin_function (const char *name, tree type,
	int code,
	enum built_in_class cl,
	const char *libname,
	tree attrs);
	extern tree check_elaborated_type_specifier (enum tag_types, tree, bool);
	extern void warn_extern_redeclared_static (tree, tree);
	extern const char *cxx_comdat_group (tree);
	extern bool cp_missing_noreturn_ok_p (tree);
	extern void initialize_artificial_var (tree, tree);
	extern tree check_var_type (tree, tree);
	extern tree reshape_init (tree, tree);

	/* in decl2.c */
	extern bool check_java_method (tree);
	extern tree build_memfn_type (tree, tree, cp_cv_quals);
	extern void maybe_retrofit_in_chrg (tree);
	extern void maybe_make_one_only (tree);
	extern void grokclassfn (tree, tree,
	enum overload_flags);
	extern tree grok_array_decl (tree, tree);
	extern tree delete_sanity (tree, tree, bool, int);
	extern tree check_classfn (tree, tree, tree);
	extern void check_member_template (tree);
	extern tree grokfield (const cp_declarator , cp_decl_specifier_seq ,
	tree, bool, tree, tree);
	extern tree grokbitfield (const cp_declarator , cp_decl_specifier_seq ,
	tree);
	extern void cplus_decl_attributes (tree *, tree, int);
	extern void finish_anon_union (tree);
	extern void cp_finish_file (void);
	extern tree coerce_new_type (tree);
	extern tree coerce_delete_type (tree);
	extern void comdat_linkage (tree);
	extern void determine_visibility (tree);
	extern void constrain_class_visibility (tree);
	extern void update_member_visibility (tree);
	extern void import_export_decl (tree);
	extern tree build_cleanup (tree);
	extern tree build_offset_ref_call_from_tree (tree, tree);
	extern void check_default_args (tree);
	extern void mark_used (tree);
	extern void finish_static_data_member_decl (tree, tree, bool, tree, int);
	extern tree cp_build_parm_decl (tree, tree);
	extern tree get_guard (tree);
	extern tree get_guard_cond (tree);
	extern tree set_guard (tree);
	extern tree cxx_callgraph_analyze_expr (tree , int , tree);
	extern void mark_needed (tree);
	extern bool decl_needed_p (tree);
	extern void note_vague_linkage_fn (tree);
	extern tree build_artificial_parm (tree, tree);

	/* in error.c */
	extern void init_error (void);
	extern const char *type_as_string (tree, int);
	extern const char *decl_as_string (tree, int);
	extern const char *expr_as_string (tree, int);
	extern const char *lang_decl_name (tree, int);
	extern const char *language_to_string (enum languages);
	extern const char *class_key_or_enum_as_string (tree);
	extern void print_instantiation_context (void);

	/* in except.c */
	extern void init_exception_processing (void);
	extern tree expand_start_catch_block (tree);
	extern void expand_end_catch_block (void);
	extern tree build_exc_ptr (void);
	extern tree build_throw (tree);
	extern int nothrow_libfn_p (tree);
	extern void check_handlers (tree);
	extern void choose_personality_routine (enum languages);
	extern tree eh_type_info (tree);

	/* in expr.c */
	extern rtx cxx_expand_expr (tree, rtx,
	enum machine_mode,
	int, rtx *);
	extern tree cplus_expand_constant (tree);

	/* friend.c */
	extern int is_friend (tree, tree);
	extern void make_friend_class (tree, tree, bool);
	extern void add_friend (tree, tree, bool);
	extern tree do_friend (tree, tree, tree, tree, enum overload_flags, bool);

	/* in init.c */
	extern tree expand_member_init (tree);
	extern void emit_mem_initializers (tree);
	extern tree build_aggr_init (tree, tree, int);
	extern int is_aggr_type (tree, int);
	extern tree get_type_value (tree);
	extern tree build_zero_init (tree, tree, bool);
	extern tree build_offset_ref (tree, tree, bool);
	extern tree build_new (tree, tree, tree, tree, int);
	extern tree build_vec_init (tree, tree, tree, bool, int);
	extern tree build_delete (tree, tree,
	special_function_kind,
	int, int);
	extern void push_base_cleanups (void);
	extern tree build_vec_delete (tree, tree,
	special_function_kind, int);
	extern tree create_temporary_var (tree);
	extern void initialize_vtbl_ptrs (tree);
	extern tree build_java_class_ref (tree);
	extern tree integral_constant_value (tree);

	/* in lex.c */
	extern void cxx_dup_lang_specific_decl (tree);
	extern void yyungetc (int, int);

	extern tree unqualified_name_lookup_error (tree);
	extern tree unqualified_fn_lookup_error (tree);
	extern tree build_lang_decl (enum tree_code, tree, tree);
	extern void retrofit_lang_decl (tree);
	extern tree copy_decl (tree);
	extern tree copy_type (tree);
	extern tree cxx_make_type (enum tree_code);
	extern tree make_aggr_type (enum tree_code);
	extern void yyerror (const char *);
	extern void yyhook (int);
	extern bool cxx_init (void);
	extern void cxx_finish (void);
	extern bool in_main_input_context (void);

	/* in method.c */
	extern void init_method (void);
	extern tree make_thunk (tree, bool, tree, tree);
	extern void finish_thunk (tree);
	extern void use_thunk (tree, bool);
	extern void synthesize_method (tree);
	extern tree lazily_declare_fn (special_function_kind,
	tree);
	extern tree skip_artificial_parms_for (tree, tree);
	extern tree make_alias_for (tree, tree);

	/* In optimize.c */
	extern bool maybe_clone_body (tree);

	/* in pt.c */
	extern void check_template_shadow (tree);
	extern tree get_innermost_template_args (tree, int);
	extern void maybe_begin_member_template_processing (tree);
	extern void maybe_end_member_template_processing (void);
	extern tree finish_member_template_decl (tree);
	extern void begin_template_parm_list (void);
	extern bool begin_specialization (void);
	extern void reset_specialization (void);
	extern void end_specialization (void);
	extern void begin_explicit_instantiation (void);
	extern void end_explicit_instantiation (void);
	extern tree check_explicit_specialization (tree, tree, int, int);
	extern tree process_template_parm (tree, tree, bool);
	extern tree end_template_parm_list (tree);
	extern void end_template_decl (void);
	extern tree push_template_decl (tree);
	extern tree push_template_decl_real (tree, bool);
	extern bool redeclare_class_template (tree, tree);
	extern tree lookup_template_class (tree, tree, tree, tree,
	int, tsubst_flags_t);
	extern tree lookup_template_function (tree, tree);
	extern int uses_template_parms (tree);
	extern int uses_template_parms_level (tree, int);
	extern tree instantiate_class_template (tree);
	extern tree instantiate_template (tree, tree, tsubst_flags_t);
	extern int fn_type_unification (tree, tree, tree, tree,
	tree, unification_kind_t, int);
	extern void mark_decl_instantiated (tree, int);
	extern int more_specialized_fn (tree, tree, int);
	extern void do_decl_instantiation (tree, tree);
	extern void do_type_instantiation (tree, tree, tsubst_flags_t);
	extern tree instantiate_decl (tree, int, bool);
	extern int comp_template_parms (tree, tree);
	extern int template_class_depth (tree);
	extern int is_specialization_of (tree, tree);
	extern bool is_specialization_of_friend (tree, tree);
	extern int comp_template_args (tree, tree);
	extern tree maybe_process_partial_specialization (tree);
	extern tree most_specialized_instantiation (tree);
	extern void print_candidates (tree);
	extern void instantiate_pending_templates (int);
	extern tree tsubst_default_argument (tree, tree, tree);
	extern tree tsubst_copy_and_build (tree, tree, tsubst_flags_t,
	tree, bool, bool);
	extern tree most_general_template (tree);
	extern tree get_mostly_instantiated_function_type (tree);
	extern int problematic_instantiation_changed (void);
	extern void record_last_problematic_instantiation (void);
	extern tree current_instantiation (void);
	extern tree maybe_get_template_decl_from_type_decl (tree);
	extern int processing_template_parmlist;
	extern bool dependent_type_p (tree);
	extern bool any_dependent_template_arguments_p (tree);
	extern bool dependent_template_p (tree);
	extern bool dependent_template_id_p (tree, tree);
	extern bool type_dependent_expression_p (tree);
	extern bool any_type_dependent_arguments_p (tree);
	extern bool value_dependent_expression_p (tree);
	extern bool any_value_dependent_elements_p (tree);
	extern tree resolve_typename_type (tree, bool);
	extern tree template_for_substitution (tree);
	extern tree build_non_dependent_expr (tree);
	extern tree build_non_dependent_args (tree);
	extern bool reregister_specialization (tree, tree, tree);
	extern tree fold_non_dependent_expr (tree);
	extern bool explicit_class_specialization_p (tree);
	extern tree outermost_tinst_level (void);

	/* in repo.c */
	extern void init_repo (void);
	extern int repo_emit_p (tree);
	extern bool repo_export_class_p (tree);
	extern void finish_repo (void);

	/* in rtti.c */
	/* A vector of all tinfo decls that haven't been emitted yet. */
	extern GTY(()) VEC(tree,gc) *unemitted_tinfo_decls;

	extern void init_rtti_processing (void);
	extern tree build_typeid (tree);
	extern tree get_tinfo_decl (tree);
	extern tree get_typeid (tree);
	extern tree build_dynamic_cast (tree, tree);
	extern void emit_support_tinfos (void);
	extern bool emit_tinfo_decl (tree);

	/* in search.c */
	extern bool accessible_base_p (tree, tree, bool);
	extern tree lookup_base (tree, tree, base_access,
	base_kind *);
	extern tree dcast_base_hint (tree, tree);
	extern int accessible_p (tree, tree, bool);
	extern tree lookup_field_1 (tree, tree, bool);
	extern tree lookup_field (tree, tree, int, bool);
	extern int lookup_fnfields_1 (tree, tree);
	extern int class_method_index_for_fn (tree, tree);
	extern tree lookup_fnfields (tree, tree, int);
	extern tree lookup_member (tree, tree, int, bool);
	extern int look_for_overrides (tree, tree);
	extern void get_pure_virtuals (tree);
	extern void maybe_suppress_debug_info (tree);
	extern void note_debug_info_needed (tree);
	extern void print_search_statistics (void);
	extern void reinit_search_statistics (void);
	extern tree current_scope (void);
	extern int at_function_scope_p (void);
	extern bool at_class_scope_p (void);
	extern bool at_namespace_scope_p (void);
	extern tree context_for_name_lookup (tree);
	extern tree lookup_conversions (tree);
	extern tree binfo_from_vbase (tree);
	extern tree binfo_for_vbase (tree, tree);
	extern tree look_for_overrides_here (tree, tree);
	#define dfs_skip_bases ((tree)1)
	extern tree dfs_walk_all (tree, tree () (tree, void ),
	tree () (tree, void ), void *);
	extern tree dfs_walk_once (tree, tree () (tree, void ),
	tree () (tree, void ), void *);
	extern tree binfo_via_virtual (tree, tree);
	extern tree build_baselink (tree, tree, tree, tree);
	extern tree adjust_result_of_qualified_name_lookup
	(tree, tree, tree);
	extern tree copied_binfo (tree, tree);
	extern tree original_binfo (tree, tree);
	extern int shared_member_p (tree);


	/* The representation of a deferred access check. */

	typedef struct deferred_access_check GTY(())
	{
	/* The base class in which the declaration is referenced. */
	tree binfo;
	/* The declaration whose access must be checked. */
	tree decl;
	/* The declaration that should be used in the error message. */
	tree diag_decl;
	} deferred_access_check;
	DEF_VEC_O(deferred_access_check);
	DEF_VEC_ALLOC_O(deferred_access_check,gc);

	/* in semantics.c */
	extern void push_deferring_access_checks (deferring_kind);
	extern void resume_deferring_access_checks (void);
	extern void stop_deferring_access_checks (void);
	extern void pop_deferring_access_checks (void);
	extern VEC (deferred_access_check,gc)* get_deferred_access_checks (void);
	extern void pop_to_parent_deferring_access_checks (void);
	extern void perform_access_checks (VEC (deferred_access_check,gc)*);
	extern void perform_deferred_access_checks (void);
	extern void perform_or_defer_access_check (tree, tree, tree);
	extern int stmts_are_full_exprs_p (void);
	extern void init_cp_semantics (void);
	extern tree do_poplevel (tree);
	extern void add_decl_expr (tree);
	extern tree finish_expr_stmt (tree);
	extern tree begin_if_stmt (void);
	extern void finish_if_stmt_cond (tree, tree);
	extern tree finish_then_clause (tree);
	extern void begin_else_clause (tree);
	extern void finish_else_clause (tree);
	extern void finish_if_stmt (tree);
	-extern tree begin_while_stmt (void);
	+/* APPLE LOCAL begin for-fsf-4_4 3274130 5295549 */ \
	+extern tree begin_while_stmt (tree);
	+/* APPLE LOCAL end for-fsf-4_4 3274130 5295549 */ \
	extern void finish_while_stmt_cond (tree, tree);
	extern void finish_while_stmt (tree);
	-extern tree begin_do_stmt (void);
	+/* APPLE LOCAL begin for-fsf-4_4 3274130 5295549 */ \
	+extern tree begin_do_stmt (tree);
	+/* APPLE LOCAL end for-fsf-4_4 3274130 5295549 */ \
	extern void finish_do_body (tree);
	extern void finish_do_stmt (tree, tree);
	extern tree finish_return_stmt (tree);
	-extern tree begin_for_stmt (void);
	+/* APPLE LOCAL begin for-fsf-4_4 3274130 5295549 */ \
	+extern tree begin_for_stmt (tree);
	+/* APPLE LOCAL end for-fsf-4_4 3274130 5295549 */ \
	extern void finish_for_init_stmt (tree);
	extern void finish_for_cond (tree, tree);
	extern void finish_for_expr (tree, tree);
	extern void finish_for_stmt (tree);
	extern tree finish_break_stmt (void);
	extern tree finish_continue_stmt (void);
	extern tree begin_switch_stmt (void);
	extern void finish_switch_cond (tree, tree);
	extern void finish_switch_stmt (tree);
	extern tree finish_case_label (tree, tree);
	extern tree finish_goto_stmt (tree);
	extern tree begin_try_block (void);
	extern void finish_try_block (tree);
	extern tree begin_eh_spec_block (void);
	extern void finish_eh_spec_block (tree, tree);
	extern void finish_handler_sequence (tree);
	extern tree begin_function_try_block (tree *);
	extern void finish_function_try_block (tree);
	extern void finish_function_handler_sequence (tree, tree);
	extern void finish_cleanup_try_block (tree);
	extern tree begin_handler (void);
	extern void finish_handler_parms (tree, tree);
	extern void finish_handler (tree);
	extern void finish_cleanup (tree, tree);

	enum {
	BCS_NO_SCOPE = 1,
	BCS_TRY_BLOCK = 2,
	BCS_FN_BODY = 4
	};
	extern tree begin_compound_stmt (unsigned int);

	extern void finish_compound_stmt (tree);
	extern tree finish_asm_stmt (int, tree, tree, tree, tree);
	extern tree finish_label_stmt (tree);
	extern void finish_label_decl (tree);
	extern tree finish_parenthesized_expr (tree);
	extern tree finish_non_static_data_member (tree, tree, tree);
	extern tree begin_stmt_expr (void);
	extern tree finish_stmt_expr_expr (tree, tree);
	extern tree finish_stmt_expr (tree, bool);
	extern tree perform_koenig_lookup (tree, tree);
	extern tree finish_call_expr (tree, tree, bool, bool);
	extern tree finish_increment_expr (tree, enum tree_code);
	extern tree finish_this_expr (void);
	extern tree finish_pseudo_destructor_expr (tree, tree, tree);
	extern tree finish_unary_op_expr (enum tree_code, tree);
	extern tree finish_compound_literal (tree, VEC(constructor_elt,gc) *);
	extern tree finish_fname (tree);
	extern void finish_translation_unit (void);
	extern tree finish_template_type_parm (tree, tree);
	extern tree finish_template_template_parm (tree, tree);
	extern tree begin_class_definition (tree, tree);
	extern void finish_template_decl (tree);
	extern tree finish_template_type (tree, tree, int);
	extern tree finish_base_specifier (tree, tree, bool);
	extern void finish_member_declaration (tree);
	extern void qualified_name_lookup_error (tree, tree, tree);
	extern void check_template_keyword (tree);
	extern tree finish_id_expression (tree, tree, tree,
	cp_id_kind *,
	bool, bool, bool *,
	bool, bool, bool, bool,
	const char **);
	extern tree finish_typeof (tree);
	extern tree finish_offsetof (tree);
	extern void finish_decl_cleanup (tree, tree);
	extern void finish_eh_cleanup (tree);
	extern void expand_body (tree);
	extern void finish_mem_initializers (tree);
	extern tree check_template_template_default_arg (tree);
	extern void expand_or_defer_fn (tree);
	extern void check_accessibility_of_qualified_id (tree, tree, tree);
	extern tree finish_qualified_id_expr (tree, tree, bool, bool,
	bool, bool);
	extern void simplify_aggr_init_expr (tree *);
	extern void finalize_nrv (tree *, tree, tree);
	extern void note_decl_for_pch (tree);
	extern tree finish_omp_clauses (tree);
	extern void finish_omp_threadprivate (tree);
	extern tree begin_omp_structured_block (void);
	extern tree finish_omp_structured_block (tree);
	extern tree begin_omp_parallel (void);
	extern tree finish_omp_parallel (tree, tree);
	extern tree finish_omp_for (location_t, tree, tree,
	tree, tree, tree, tree);
	extern void finish_omp_atomic (enum tree_code, tree, tree);
	extern void finish_omp_barrier (void);
	extern void finish_omp_flush (void);
	extern enum omp_clause_default_kind cxx_omp_predetermined_sharing (tree);
	extern tree cxx_omp_clause_default_ctor (tree, tree);
	extern tree cxx_omp_clause_copy_ctor (tree, tree, tree);
	extern tree cxx_omp_clause_assign_op (tree, tree, tree);
	extern tree cxx_omp_clause_dtor (tree, tree);
	extern bool cxx_omp_privatize_by_reference (tree);
	extern tree baselink_for_fns (tree);

	/* in tree.c */
	extern void lang_check_failed (const char *, int,
	const char *) ATTRIBUTE_NORETURN;
	extern tree stabilize_expr (tree, tree *);
	extern void stabilize_call (tree, tree *);
	extern bool stabilize_init (tree, tree *);
	extern tree add_stmt_to_compound (tree, tree);
	extern tree cxx_maybe_build_cleanup (tree);
	extern void init_tree (void);
	extern int pod_type_p (tree);
	extern bool class_tmpl_impl_spec_p (tree);
	extern int zero_init_p (tree);
	extern tree canonical_type_variant (tree);
	extern tree copy_binfo (tree, tree, tree,
	tree *, int);
	extern int member_p (tree);
	extern cp_lvalue_kind real_lvalue_p (tree);
	extern bool builtin_valid_in_constant_expr_p (tree);
	extern tree build_min (enum tree_code, tree, ...);
	extern tree build_min_nt (enum tree_code, ...);
	extern tree build_min_non_dep (enum tree_code, tree, ...);
	extern tree build_cplus_new (tree, tree);
	extern tree get_target_expr (tree);
	extern tree build_cplus_array_type (tree, tree);
	extern tree hash_tree_cons (tree, tree, tree);
	extern tree hash_tree_chain (tree, tree);
	extern tree build_qualified_name (tree, tree, tree, bool);
	extern int is_overloaded_fn (tree);
	extern tree get_first_fn (tree);
	extern tree ovl_cons (tree, tree);
	extern tree build_overload (tree, tree);
	extern const char *cxx_printable_name (tree, int);
	extern tree build_exception_variant (tree, tree);
	extern tree bind_template_template_parm (tree, tree);
	extern tree array_type_nelts_total (tree);
	extern tree array_type_nelts_top (tree);
	extern tree break_out_target_exprs (tree);
	extern tree get_type_decl (tree);
	extern tree decl_namespace_context (tree);
	extern bool decl_anon_ns_mem_p (tree);
	extern tree lvalue_type (tree);
	extern tree error_type (tree);
	extern int varargs_function_p (tree);
	extern bool really_overloaded_fn (tree);
	extern bool cp_tree_equal (tree, tree);
	extern tree no_linkage_check (tree, bool);
	extern void debug_binfo (tree);
	extern tree build_dummy_object (tree);
	extern tree maybe_dummy_object (tree, tree *);
	extern int is_dummy_object (tree);
	extern const struct attribute_spec cxx_attribute_table[];
	extern tree make_ptrmem_cst (tree, tree);
	extern tree cp_build_type_attribute_variant (tree, tree);
	extern tree cp_build_qualified_type_real (tree, int, tsubst_flags_t);
	#define cp_build_qualified_type(TYPE, QUALS) \
	cp_build_qualified_type_real ((TYPE), (QUALS), tf_warning_or_error)
	extern special_function_kind special_function_p (tree);
	extern int count_trees (tree);
	extern int char_type_p (tree);
	extern void verify_stmt_tree (tree);
	extern linkage_kind decl_linkage (tree);
	extern tree cp_walk_subtrees (tree, int, walk_tree_fn,
	void, struct pointer_set_t);
	extern int cp_cannot_inline_tree_fn (tree*);
	extern tree cp_add_pending_fn_decls (void*,tree);
	extern int cp_auto_var_in_fn_p (tree,tree);
	extern tree fold_if_not_in_template (tree);
	extern tree rvalue (tree);
	extern tree convert_bitfield_to_declared_type (tree);
	extern tree cp_save_expr (tree);
	extern bool cast_valid_in_integral_constant_expression_p (tree);

	/* in typeck.c */
	extern int string_conv_p (tree, tree, int);
	extern tree cp_truthvalue_conversion (tree);
	extern tree condition_conversion (tree);
	extern tree require_complete_type (tree);
	extern tree complete_type (tree);
	extern tree complete_type_or_else (tree, tree);
	extern int type_unknown_p (tree);
	extern bool comp_except_specs (tree, tree, bool);
	extern bool comptypes (tree, tree, int);
	extern bool compparms (tree, tree);
	extern int comp_cv_qualification (tree, tree);
	extern int comp_cv_qual_signature (tree, tree);
	extern tree cxx_sizeof_or_alignof_expr (tree, enum tree_code);
	extern tree cxx_sizeof_or_alignof_type (tree, enum tree_code, bool);
	#define cxx_sizeof_nowarn(T) cxx_sizeof_or_alignof_type (T, SIZEOF_EXPR, false)
	extern tree inline_conversion (tree);
	extern tree is_bitfield_expr_with_lowered_type (tree);
	extern tree unlowered_expr_type (tree);
	extern tree decay_conversion (tree);
	extern tree build_class_member_access_expr (tree, tree, tree, bool);
	extern tree finish_class_member_access_expr (tree, tree, bool);
	extern tree build_x_indirect_ref (tree, const char *);
	extern tree build_indirect_ref (tree, const char *);
	extern tree build_array_ref (tree, tree);
	extern tree get_member_function_from_ptrfunc (tree *, tree);
	extern tree build_x_binary_op (enum tree_code, tree,
	enum tree_code, tree,
	enum tree_code, bool *);
	extern tree build_x_unary_op (enum tree_code, tree);
	extern tree unary_complex_lvalue (enum tree_code, tree);
	extern tree build_x_conditional_expr (tree, tree, tree);
	extern tree build_x_compound_expr_from_list (tree, const char *);
	extern tree build_x_compound_expr (tree, tree);
	extern tree build_compound_expr (tree, tree);
	extern tree build_static_cast (tree, tree);
	extern tree build_reinterpret_cast (tree, tree);
	extern tree build_const_cast (tree, tree);
	extern tree build_c_cast (tree, tree);
	extern tree build_x_modify_expr (tree, enum tree_code, tree);
	extern tree build_modify_expr (tree, enum tree_code, tree);
	extern tree convert_for_initialization (tree, tree, tree, int,
	const char *, tree, int);
	extern int comp_ptr_ttypes (tree, tree);
	extern bool comp_ptr_ttypes_const (tree, tree);
	extern int ptr_reasonably_similar (tree, tree);
	extern tree build_ptrmemfunc (tree, tree, int, bool);
	extern int cp_type_quals (tree);
	extern bool cp_type_readonly (tree);
	extern bool cp_has_mutable_p (tree);
	extern bool at_least_as_qualified_p (tree, tree);
	extern void cp_apply_type_quals_to_decl (int, tree);
	extern tree build_ptrmemfunc1 (tree, tree, tree);
	extern void expand_ptrmemfunc_cst (tree, tree , tree );
	extern tree type_after_usual_arithmetic_conversions (tree, tree);
	extern tree composite_pointer_type (tree, tree, tree, tree,
	const char*);
	extern tree merge_types (tree, tree);
	extern tree check_return_expr (tree, bool *);
	#define cp_build_binary_op(code, arg1, arg2) \
	build_binary_op(code, arg1, arg2, 1)
	#define cxx_sizeof(T) cxx_sizeof_or_alignof_type (T, SIZEOF_EXPR, true)
	extern tree build_ptrmemfunc_access_expr (tree, tree);
	extern tree build_address (tree);
	extern tree build_nop (tree, tree);
	extern tree non_reference (tree);
	extern tree lookup_anon_field (tree, tree);
	extern bool invalid_nonstatic_memfn_p (tree);
	extern tree convert_member_func_to_ptr (tree, tree);
	extern tree convert_ptrmem (tree, tree, bool, bool);
	extern int lvalue_or_else (tree, enum lvalue_use);
	extern int lvalue_p (tree);

	/* in typeck2.c */
	extern void require_complete_eh_spec_types (tree, tree);
	extern void cxx_incomplete_type_diagnostic (tree, tree, int);
	#undef cxx_incomplete_type_error
	extern void cxx_incomplete_type_error (tree, tree);
	#define cxx_incomplete_type_error(V,T) \
	(cxx_incomplete_type_diagnostic ((V), (T), 0))
	extern tree error_not_base_type (tree, tree);
	extern tree binfo_or_else (tree, tree);
	extern void readonly_error (tree, const char *, int);
	extern void complete_type_check_abstract (tree);
	extern int abstract_virtuals_error (tree, tree);

	extern tree store_init_value (tree, tree);
	extern tree digest_init (tree, tree);
	extern tree build_scoped_ref (tree, tree, tree *);
	extern tree build_x_arrow (tree);
	extern tree build_m_component_ref (tree, tree);
	extern tree build_functional_cast (tree, tree);
	extern tree add_exception_specifier (tree, tree, int);
	extern tree merge_exception_specifiers (tree, tree);

	/* in mangle.c */
	extern void init_mangle (void);
	extern void mangle_decl (tree);
	extern const char *mangle_type_string (tree);
	extern tree mangle_typeinfo_for_type (tree);
	extern tree mangle_typeinfo_string_for_type (tree);
	extern tree mangle_vtbl_for_type (tree);
	extern tree mangle_vtt_for_type (tree);
	extern tree mangle_ctor_vtbl_for_type (tree, tree);
	extern tree mangle_thunk (tree, int, tree, tree);
	extern tree mangle_conv_op_name_for_type (tree);
	extern tree mangle_guard_variable (tree);
	extern tree mangle_ref_init_variable (tree);

	/* in dump.c */
	extern bool cp_dump_tree (void *, tree);

	/* In cp/cp-objcp-common.c. */

	extern HOST_WIDE_INT cxx_get_alias_set (tree);
	extern bool cxx_warn_unused_global_decl (tree);
	extern tree cp_expr_size (tree);
	extern size_t cp_tree_size (enum tree_code);
	extern bool cp_var_mod_type_p (tree, tree);
	extern void cxx_initialize_diagnostics (struct diagnostic_context *);
	extern int cxx_types_compatible_p (tree, tree);
	extern void init_shadowed_var_for_decl (void);
	extern tree cxx_staticp (tree);

	/* in cp-gimplify.c */
	extern int cp_gimplify_expr (tree , tree , tree *);
	extern void cp_genericize (tree);

	/* -- end of C++ */

	/* In order for the format checking to accept the C++ frontend
	diagnostic framework extensions, you must include this file before
	toplev.h, not after. We override the definition of GCC_DIAG_STYLE
	in c-common.h. */
	#undef GCC_DIAG_STYLE
	#define GCC_DIAG_STYLE __gcc_cxxdiag__
	#if GCC_VERSION >= 4001
	#define ATTRIBUTE_GCC_CXXDIAG(m, n) __attribute__ ((__format__ (GCC_DIAG_STYLE, m, n))) ATTRIBUTE_NONNULL(m)
	#else
	#define ATTRIBUTE_GCC_CXXDIAG(m, n) ATTRIBUTE_NONNULL(m)
	#endif
	extern void cp_cpp_error (cpp_reader *, int,
	const char , va_list )
	ATTRIBUTE_GCC_CXXDIAG(3,0);

	#endif /* ! GCC_CP_TREE_H */
	diff --git a/contrib/gcc/cp/decl.c b/contrib/gcc/cp/decl.c
	index dcceebaf1fd9..40e6c9221c9f 100644
	--- a/contrib/gcc/cp/decl.c
	+++ b/contrib/gcc/cp/decl.c
	@@ -1,11798 +1,11844 @@
	/* Process declarations and variables for C++ compiler.
	Copyright (C) 1988, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
	2001, 2002, 2003, 2004, 2005, 2006 Free Software Foundation, Inc.
	Contributed by Michael Tiemann (tiemann@cygnus.com)

	This file is part of GCC.

	GCC is free software; you can redistribute it and/or modify
	it under the terms of the GNU General Public License as published by
	the Free Software Foundation; either version 2, or (at your option)
	any later version.

	GCC is distributed in the hope that it will be useful,
	but WITHOUT ANY WARRANTY; without even the implied warranty of
	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	GNU General Public License for more details.

	You should have received a copy of the GNU General Public License
	along with GCC; see the file COPYING. If not, write to
	the Free Software Foundation, 51 Franklin Street, Fifth Floor,
	Boston, MA 02110-1301, USA. */


	/* Process declarations and symbol lookup for C++ front end.
	Also constructs types; the standard scalar types at initialization,
	and structure, union, array and enum types when they are declared. */

	/* ??? not all decl nodes are given the most useful possible
	line numbers. For example, the CONST_DECLs for enum values. */

	#include "config.h"
	#include "system.h"
	#include "coretypes.h"
	#include "tm.h"
	#include "tree.h"
	#include "rtl.h"
	#include "expr.h"
	#include "flags.h"
	#include "cp-tree.h"
	#include "tree-inline.h"
	#include "decl.h"
	#include "output.h"
	#include "except.h"
	#include "toplev.h"
	#include "hashtab.h"
	#include "tm_p.h"
	#include "target.h"
	#include "c-common.h"
	#include "c-pragma.h"
	#include "diagnostic.h"
	#include "debug.h"
	#include "timevar.h"
	#include "tree-flow.h"

	static tree grokparms (cp_parameter_declarator , tree );
	static const char *redeclaration_error_message (tree, tree);

	static int decl_jump_unsafe (tree);
	static void require_complete_types_for_parms (tree);
	static int ambi_op_p (enum tree_code);
	static int unary_op_p (enum tree_code);
	static void push_local_name (tree);
	static tree grok_reference_init (tree, tree, tree, tree *);
	static tree grokvardecl (tree, tree, const cp_decl_specifier_seq *,
	int, int, tree);
	static void record_unknown_type (tree, const char *);
	static tree builtin_function_1 (const char *, tree, tree,
	enum built_in_function code,
	enum built_in_class cl, const char *,
	tree);
	static tree build_library_fn_1 (tree, enum tree_code, tree);
	static int member_function_or_else (tree, tree, enum overload_flags);
	static void bad_specifiers (tree, const char *, int, int, int, int,
	int);
	static void check_for_uninitialized_const_var (tree);
	static hashval_t typename_hash (const void *);
	static int typename_compare (const void , const void );
	static tree local_variable_p_walkfn (tree , int , void *);
	static tree record_builtin_java_type (const char *, int);
	static const char *tag_name (enum tag_types);
	static tree lookup_and_check_tag (enum tag_types, tree, tag_scope, bool);
	static int walk_namespaces_r (tree, walk_namespaces_fn, void *);
	static void maybe_deduce_size_from_array_init (tree, tree);
	static void layout_var_decl (tree);
	static void maybe_commonize_var (tree);
	static tree check_initializer (tree, tree, int, tree *);
	static void make_rtl_for_nonlocal_decl (tree, tree, const char *);
	static void save_function_data (tree);
	static void check_function_type (tree, tree);
	static void finish_constructor_body (void);
	static void begin_destructor_body (void);
	static void finish_destructor_body (void);
	static tree create_array_type_for_decl (tree, tree, tree);
	static tree get_atexit_node (void);
	static tree get_dso_handle_node (void);
	static tree start_cleanup_fn (void);
	static void end_cleanup_fn (void);
	static tree cp_make_fname_decl (tree, int);
	static void initialize_predefined_identifiers (void);
	static tree check_special_function_return_type
	(special_function_kind, tree, tree);
	static tree push_cp_library_fn (enum tree_code, tree);
	static tree build_cp_library_fn (tree, enum tree_code, tree);
	static void store_parm_decls (tree);
	static void initialize_local_var (tree, tree);
	static void expand_static_init (tree, tree);
	static tree next_initializable_field (tree);

	/* The following symbols are subsumed in the cp_global_trees array, and
	listed here individually for documentation purposes.

	C++ extensions
	tree wchar_decl_node;

	tree vtable_entry_type;
	tree delta_type_node;
	tree __t_desc_type_node;

	tree class_type_node;
	tree unknown_type_node;

	Array type `vtable_entry_type[]'

	tree vtbl_type_node;
	tree vtbl_ptr_type_node;

	Namespaces,

	tree std_node;
	tree abi_node;

	A FUNCTION_DECL which can call `abort'. Not necessarily the
	one that the user will declare, but sufficient to be called
	by routines that want to abort the program.

	tree abort_fndecl;

	The FUNCTION_DECL for the default `::operator delete'.

	tree global_delete_fndecl;

	Used by RTTI
	tree type_info_type_node, tinfo_decl_id, tinfo_decl_type;
	tree tinfo_var_id; */

	tree cp_global_trees[CPTI_MAX];

	/* Indicates that there is a type value in some namespace, although
	that is not necessarily in scope at the moment. */

	tree global_type_node;

	/* The node that holds the "name" of the global scope. */
	tree global_scope_name;

	#define local_names cp_function_chain->x_local_names

	/* A list of objects which have constructors or destructors
	which reside in the global scope. The decl is stored in
	the TREE_VALUE slot and the initializer is stored
	in the TREE_PURPOSE slot. */
	tree static_aggregates;

	/* -- end of C++ */

	/* A node for the integer constants 2, and 3. */

	tree integer_two_node, integer_three_node;

	/* Used only for jumps to as-yet undefined labels, since jumps to
	defined labels can have their validity checked immediately. */

	struct named_label_use_entry GTY(())
	{
	struct named_label_use_entry *next;
	/* The binding level to which this entry is currently attached.
	This is initially the binding level in which the goto appeared,
	but is modified as scopes are closed. */
	struct cp_binding_level *binding_level;
	/* The head of the names list that was current when the goto appeared,
	or the inner scope popped. These are the decls that will not be
	skipped when jumping to the label. */
	tree names_in_scope;
	/* The location of the goto, for error reporting. */
	location_t o_goto_locus;
	/* True if an OpenMP structured block scope has been closed since
	the goto appeared. This means that the branch from the label will
	illegally exit an OpenMP scope. */
	bool in_omp_scope;
	};

	/* A list of all LABEL_DECLs in the function that have names. Here so
	we can clear out their names' definitions at the end of the
	function, and so we can check the validity of jumps to these labels. */

	struct named_label_entry GTY(())
	{
	/* The decl itself. */
	tree label_decl;

	/* The binding level to which the label is currently attached.
	This is initially set to the binding level in which the label
	is defined, but is modified as scopes are closed. */
	struct cp_binding_level *binding_level;
	/* The head of the names list that was current when the label was
	defined, or the inner scope popped. These are the decls that will
	be skipped when jumping to the label. */
	tree names_in_scope;
	/* A tree list of all decls from all binding levels that would be
	crossed by a backward branch to the label. */
	tree bad_decls;

	/* A list of uses of the label, before the label is defined. */
	struct named_label_use_entry *uses;

	/* The following bits are set after the label is defined, and are
	updated as scopes are popped. They indicate that a backward jump
	to the label will illegally enter a scope of the given flavor. */
	bool in_try_scope;
	bool in_catch_scope;
	bool in_omp_scope;
	};

	#define named_labels cp_function_chain->x_named_labels

	/* The number of function bodies which we are currently processing.
	(Zero if we are at namespace scope, one inside the body of a
	function, two inside the body of a function in a local class, etc.) */
	int function_depth;

	/* States indicating how grokdeclarator() should handle declspecs marked
	with __attribute__((deprecated)). An object declared as
	__attribute__((deprecated)) suppresses warnings of uses of other
	deprecated items. */
	+/* APPLE LOCAL begin "unavailable" attribute (radar 2809697) */
	+/* An object declared as __attribute__((unavailable)) suppresses
	+ any reports of being declared with unavailable or deprecated
	+ items. */
	+/* APPLE LOCAL end "unavailable" attribute (radar 2809697) */

	enum deprecated_states {
	DEPRECATED_NORMAL,
	DEPRECATED_SUPPRESS
	+ /* APPLE LOCAL "unavailable" attribute (radar 2809697) */
	+ , DEPRECATED_UNAVAILABLE_SUPPRESS
	};

	static enum deprecated_states deprecated_state = DEPRECATED_NORMAL;


	/* A TREE_LIST of VAR_DECLs. The TREE_PURPOSE is a RECORD_TYPE or
	UNION_TYPE; the TREE_VALUE is a VAR_DECL with that type. At the
	time the VAR_DECL was declared, the type was incomplete. */

	static GTY(()) tree incomplete_vars;

	/* Returns the kind of template specialization we are currently
	processing, given that it's declaration contained N_CLASS_SCOPES
	explicit scope qualifications. */

	tmpl_spec_kind
	current_tmpl_spec_kind (int n_class_scopes)
	{
	int n_template_parm_scopes = 0;
	int seen_specialization_p = 0;
	int innermost_specialization_p = 0;
	struct cp_binding_level *b;

	/* Scan through the template parameter scopes. */
	for (b = current_binding_level;
	b->kind == sk_template_parms;
	b = b->level_chain)
	{
	/* If we see a specialization scope inside a parameter scope,
	then something is wrong. That corresponds to a declaration
	like:

	template <class T> template <> ...

	which is always invalid since [temp.expl.spec] forbids the
	specialization of a class member template if the enclosing
	class templates are not explicitly specialized as well. */
	if (b->explicit_spec_p)
	{
	if (n_template_parm_scopes == 0)
	innermost_specialization_p = 1;
	else
	seen_specialization_p = 1;
	}
	else if (seen_specialization_p == 1)
	return tsk_invalid_member_spec;

	++n_template_parm_scopes;
	}

	/* Handle explicit instantiations. */
	if (processing_explicit_instantiation)
	{
	if (n_template_parm_scopes != 0)
	/* We've seen a template parameter list during an explicit
	instantiation. For example:

	template <class T> template void f(int);

	This is erroneous. */
	return tsk_invalid_expl_inst;
	else
	return tsk_expl_inst;
	}

	if (n_template_parm_scopes < n_class_scopes)
	/* We've not seen enough template headers to match all the
	specialized classes present. For example:

	template <class T> void R<T>::S<T>::f(int);

	This is invalid; there needs to be one set of template
	parameters for each class. */
	return tsk_insufficient_parms;
	else if (n_template_parm_scopes == n_class_scopes)
	/* We're processing a non-template declaration (even though it may
	be a member of a template class.) For example:

	template <class T> void S<T>::f(int);

	The `class T' maches the `S<T>', leaving no template headers
	corresponding to the `f'. */
	return tsk_none;
	else if (n_template_parm_scopes > n_class_scopes + 1)
	/* We've got too many template headers. For example:

	template <> template <class T> void f (T);

	There need to be more enclosing classes. */
	return tsk_excessive_parms;
	else
	/* This must be a template. It's of the form:

	template <class T> template <class U> void S<T>::f(U);

	This is a specialization if the innermost level was a
	specialization; otherwise it's just a definition of the
	template. */
	return innermost_specialization_p ? tsk_expl_spec : tsk_template;
	}

	/* Exit the current scope. */

	void
	finish_scope (void)
	{
	poplevel (0, 0, 0);
	}

	/* When a label goes out of scope, check to see if that label was used
	in a valid manner, and issue any appropriate warnings or errors. */

	static void
	pop_label (tree label, tree old_value)
	{
	if (!processing_template_decl)
	{
	if (DECL_INITIAL (label) == NULL_TREE)
	{
	location_t location;

	error ("label %q+D used but not defined", label);
	#ifdef USE_MAPPED_LOCATION
	location = input_location; /* FIXME want (input_filename, (line)0) */
	#else
	location.file = input_filename;
	location.line = 0;
	#endif
	/* Avoid crashing later. */
	define_label (location, DECL_NAME (label));
	}
	else if (!TREE_USED (label))
	warning (OPT_Wunused_label, "label %q+D defined but not used", label);
	}

	SET_IDENTIFIER_LABEL_VALUE (DECL_NAME (label), old_value);
	}

	/* At the end of a function, all labels declared within the function
	go out of scope. BLOCK is the top-level block for the
	function. */

	static int
	pop_labels_1 (void *slot, void data)
	{
	struct named_label_entry ent = (struct named_label_entry ) *slot;
	tree block = (tree) data;

	pop_label (ent->label_decl, NULL_TREE);

	/* Put the labels into the "variables" of the top-level block,
	so debugger can see them. */
	TREE_CHAIN (ent->label_decl) = BLOCK_VARS (block);
	BLOCK_VARS (block) = ent->label_decl;

	htab_clear_slot (named_labels, slot);

	return 1;
	}

	static void
	pop_labels (tree block)
	{
	if (named_labels)
	{
	htab_traverse (named_labels, pop_labels_1, block);
	named_labels = NULL;
	}
	}

	/* At the end of a block with local labels, restore the outer definition. */

	static void
	pop_local_label (tree label, tree old_value)
	{
	struct named_label_entry dummy;
	void **slot;

	pop_label (label, old_value);

	dummy.label_decl = label;
	slot = htab_find_slot (named_labels, &dummy, NO_INSERT);
	htab_clear_slot (named_labels, slot);
	}

	/* The following two routines are used to interface to Objective-C++.
	The binding level is purposely treated as an opaque type. */

	void *
	objc_get_current_scope (void)
	{
	return current_binding_level;
	}

	/* The following routine is used by the NeXT-style SJLJ exceptions;
	variables get marked 'volatile' so as to not be clobbered by
	_setjmp()/_longjmp() calls. All variables in the current scope,
	as well as parent scopes up to (but not including) ENCLOSING_BLK
	shall be thusly marked. */

	void
	objc_mark_locals_volatile (void *enclosing_blk)
	{
	struct cp_binding_level *scope;

	for (scope = current_binding_level;
	scope && scope != enclosing_blk;
	scope = scope->level_chain)
	{
	tree decl;

	for (decl = scope->names; decl; decl = TREE_CHAIN (decl))
	objc_volatilize_decl (decl);

	/* Do not climb up past the current function. */
	if (scope->kind == sk_function_parms)
	break;
	}
	}

	/* Update data for defined and undefined labels when leaving a scope. */

	static int
	poplevel_named_label_1 (void *slot, void data)
	{
	struct named_label_entry ent = (struct named_label_entry ) *slot;
	struct cp_binding_level bl = (struct cp_binding_level ) data;
	struct cp_binding_level *obl = bl->level_chain;

	if (ent->binding_level == bl)
	{
	tree decl;

	for (decl = ent->names_in_scope; decl; decl = TREE_CHAIN (decl))
	if (decl_jump_unsafe (decl))
	ent->bad_decls = tree_cons (NULL, decl, ent->bad_decls);

	ent->binding_level = obl;
	ent->names_in_scope = obl->names;
	switch (bl->kind)
	{
	case sk_try:
	ent->in_try_scope = true;
	break;
	case sk_catch:
	ent->in_catch_scope = true;
	break;
	case sk_omp:
	ent->in_omp_scope = true;
	break;
	default:
	break;
	}
	}
	else if (ent->uses)
	{
	struct named_label_use_entry *use;

	for (use = ent->uses; use ; use = use->next)
	if (use->binding_level == bl)
	{
	use->binding_level = obl;
	use->names_in_scope = obl->names;
	if (bl->kind == sk_omp)
	use->in_omp_scope = true;
	}
	}

	return 1;
	}

	/* Exit a binding level.
	Pop the level off, and restore the state of the identifier-decl mappings
	that were in effect when this level was entered.

	If KEEP == 1, this level had explicit declarations, so
	and create a "block" (a BLOCK node) for the level
	to record its declarations and subblocks for symbol table output.

	If FUNCTIONBODY is nonzero, this level is the body of a function,
	so create a block as if KEEP were set and also clear out all
	label names.

	If REVERSE is nonzero, reverse the order of decls before putting
	them into the BLOCK. */

	tree
	poplevel (int keep, int reverse, int functionbody)
	{
	tree link;
	/* The chain of decls was accumulated in reverse order.
	Put it into forward order, just for cleanliness. */
	tree decls;
	int tmp = functionbody;
	int real_functionbody;
	tree subblocks;
	tree block;
	tree decl;
	int leaving_for_scope;
	scope_kind kind;

	timevar_push (TV_NAME_LOOKUP);
	restart:

	block = NULL_TREE;

	gcc_assert (current_binding_level->kind != sk_class);

	real_functionbody = (current_binding_level->kind == sk_cleanup
	? ((functionbody = 0), tmp) : functionbody);
	subblocks = functionbody >= 0 ? current_binding_level->blocks : 0;

	gcc_assert (!VEC_length(cp_class_binding,
	current_binding_level->class_shadowed));

	/* We used to use KEEP == 2 to indicate that the new block should go
	at the beginning of the list of blocks at this binding level,
	rather than the end. This hack is no longer used. */
	gcc_assert (keep == 0 \|\| keep == 1);

	if (current_binding_level->keep)
	keep = 1;

	/* Any uses of undefined labels, and any defined labels, now operate
	under constraints of next binding contour. */
	if (cfun && !functionbody && named_labels)
	htab_traverse (named_labels, poplevel_named_label_1,
	current_binding_level);

	/* Get the decls in the order they were written.
	Usually current_binding_level->names is in reverse order.
	But parameter decls were previously put in forward order. */

	if (reverse)
	current_binding_level->names
	= decls = nreverse (current_binding_level->names);
	else
	decls = current_binding_level->names;

	/* If there were any declarations or structure tags in that level,
	or if this level is a function body,
	create a BLOCK to record them for the life of this function. */
	block = NULL_TREE;
	if (keep == 1 \|\| functionbody)
	block = make_node (BLOCK);
	if (block != NULL_TREE)
	{
	BLOCK_VARS (block) = decls;
	BLOCK_SUBBLOCKS (block) = subblocks;
	}

	/* In each subblock, record that this is its superior. */
	if (keep >= 0)
	for (link = subblocks; link; link = TREE_CHAIN (link))
	BLOCK_SUPERCONTEXT (link) = block;

	/* We still support the old for-scope rules, whereby the variables
	in a for-init statement were in scope after the for-statement
	ended. We only use the new rules if flag_new_for_scope is
	nonzero. */
	leaving_for_scope
	= current_binding_level->kind == sk_for && flag_new_for_scope == 1;

	/* Before we remove the declarations first check for unused variables. */
	if (warn_unused_variable
	&& !processing_template_decl)
	for (decl = getdecls (); decl; decl = TREE_CHAIN (decl))
	if (TREE_CODE (decl) == VAR_DECL
	&& ! TREE_USED (decl)
	&& ! DECL_IN_SYSTEM_HEADER (decl)
	&& DECL_NAME (decl) && ! DECL_ARTIFICIAL (decl))
	warning (OPT_Wunused_variable, "unused variable %q+D", decl);

	/* Remove declarations for all the DECLs in this level. */
	for (link = decls; link; link = TREE_CHAIN (link))
	{
	if (leaving_for_scope && TREE_CODE (link) == VAR_DECL
	&& DECL_NAME (link))
	{
	tree name = DECL_NAME (link);
	cxx_binding *ob;
	tree ns_binding;

	ob = outer_binding (name,
	IDENTIFIER_BINDING (name),
	/class_p=/true);
	if (!ob)
	ns_binding = IDENTIFIER_NAMESPACE_VALUE (name);
	else
	ns_binding = NULL_TREE;

	if (ob && ob->scope == current_binding_level->level_chain)
	/* We have something like:

	int i;
	for (int i; ;);

	and we are leaving the `for' scope. There's no reason to
	keep the binding of the inner `i' in this case. */
	pop_binding (name, link);
	else if ((ob && (TREE_CODE (ob->value) == TYPE_DECL))
	\|\| (ns_binding && TREE_CODE (ns_binding) == TYPE_DECL))
	/* Here, we have something like:

	typedef int I;

	void f () {
	for (int I; ;);
	}

	We must pop the for-scope binding so we know what's a
	type and what isn't. */
	pop_binding (name, link);
	else
	{
	/* Mark this VAR_DECL as dead so that we can tell we left it
	there only for backward compatibility. */
	DECL_DEAD_FOR_LOCAL (link) = 1;

	/* Keep track of what should have happened when we
	popped the binding. */
	if (ob && ob->value)
	{
	SET_DECL_SHADOWED_FOR_VAR (link, ob->value);
	DECL_HAS_SHADOWED_FOR_VAR_P (link) = 1;
	}

	/* Add it to the list of dead variables in the next
	outermost binding to that we can remove these when we
	leave that binding. */
	current_binding_level->level_chain->dead_vars_from_for
	= tree_cons (NULL_TREE, link,
	current_binding_level->level_chain->
	dead_vars_from_for);

	/* Although we don't pop the cxx_binding, we do clear
	its SCOPE since the scope is going away now. */
	IDENTIFIER_BINDING (name)->scope
	= current_binding_level->level_chain;
	}
	}
	else
	{
	tree name;

	/* Remove the binding. */
	decl = link;

	if (TREE_CODE (decl) == TREE_LIST)
	decl = TREE_VALUE (decl);
	name = decl;

	if (TREE_CODE (name) == OVERLOAD)
	name = OVL_FUNCTION (name);

	gcc_assert (DECL_P (name));
	pop_binding (DECL_NAME (name), decl);
	}
	}

	/* Remove declarations for any `for' variables from inner scopes
	that we kept around. */
	for (link = current_binding_level->dead_vars_from_for;
	link; link = TREE_CHAIN (link))
	pop_binding (DECL_NAME (TREE_VALUE (link)), TREE_VALUE (link));

	/* Restore the IDENTIFIER_TYPE_VALUEs. */
	for (link = current_binding_level->type_shadowed;
	link; link = TREE_CHAIN (link))
	SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (link), TREE_VALUE (link));

	/* Restore the IDENTIFIER_LABEL_VALUEs for local labels. */
	for (link = current_binding_level->shadowed_labels;
	link;
	link = TREE_CHAIN (link))
	pop_local_label (TREE_VALUE (link), TREE_PURPOSE (link));

	/* There may be OVERLOADs (wrapped in TREE_LISTs) on the BLOCK_VARs
	list if a `using' declaration put them there. The debugging
	back-ends won't understand OVERLOAD, so we remove them here.
	Because the BLOCK_VARS are (temporarily) shared with
	CURRENT_BINDING_LEVEL->NAMES we must do this fixup after we have
	popped all the bindings. */
	if (block)
	{
	tree* d;

	for (d = &BLOCK_VARS (block); *d; )
	{
	if (TREE_CODE (*d) == TREE_LIST)
	d = TREE_CHAIN (d);
	else
	d = &TREE_CHAIN (*d);
	}
	}

	/* If the level being exited is the top level of a function,
	check over all the labels. */
	if (functionbody)
	{
	/* Since this is the top level block of a function, the vars are
	the function's parameters. Don't leave them in the BLOCK
	because they are found in the FUNCTION_DECL instead. */
	BLOCK_VARS (block) = 0;
	pop_labels (block);
	}

	kind = current_binding_level->kind;
	if (kind == sk_cleanup)
	{
	tree stmt;

	/* If this is a temporary binding created for a cleanup, then we'll
	have pushed a statement list level. Pop that, create a new
	BIND_EXPR for the block, and insert it into the stream. */
	stmt = pop_stmt_list (current_binding_level->statement_list);
	stmt = c_build_bind_expr (block, stmt);
	add_stmt (stmt);
	}

	leave_scope ();
	if (functionbody)
	{
	/* The current function is being defined, so its DECL_INITIAL
	should be error_mark_node. */
	gcc_assert (DECL_INITIAL (current_function_decl) == error_mark_node);
	DECL_INITIAL (current_function_decl) = block;
	}
	else if (block)
	current_binding_level->blocks
	= chainon (current_binding_level->blocks, block);

	/* If we did not make a block for the level just exited,
	any blocks made for inner levels
	(since they cannot be recorded as subblocks in that level)
	must be carried forward so they will later become subblocks
	of something else. */
	else if (subblocks)
	current_binding_level->blocks
	= chainon (current_binding_level->blocks, subblocks);

	/* Each and every BLOCK node created here in `poplevel' is important
	(e.g. for proper debugging information) so if we created one
	earlier, mark it as "used". */
	if (block)
	TREE_USED (block) = 1;

	/* All temporary bindings created for cleanups are popped silently. */
	if (kind == sk_cleanup)
	goto restart;

	POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, block);
	}

	/* Insert BLOCK at the end of the list of subblocks of the
	current binding level. This is used when a BIND_EXPR is expanded,
	to handle the BLOCK node inside the BIND_EXPR. */

	void
	insert_block (tree block)
	{
	TREE_USED (block) = 1;
	current_binding_level->blocks
	= chainon (current_binding_level->blocks, block);
	}

	/* Walk all the namespaces contained NAMESPACE, including NAMESPACE
	itself, calling F for each. The DATA is passed to F as well. */

	static int
	walk_namespaces_r (tree namespace, walk_namespaces_fn f, void* data)
	{
	int result = 0;
	tree current = NAMESPACE_LEVEL (namespace)->namespaces;

	result \|= (*f) (namespace, data);

	for (; current; current = TREE_CHAIN (current))
	result \|= walk_namespaces_r (current, f, data);

	return result;
	}

	/* Walk all the namespaces, calling F for each. The DATA is passed to
	F as well. */

	int
	walk_namespaces (walk_namespaces_fn f, void* data)
	{
	return walk_namespaces_r (global_namespace, f, data);
	}

	/* Call wrapup_globals_declarations for the globals in NAMESPACE. If
	DATA is non-NULL, this is the last time we will call
	wrapup_global_declarations for this NAMESPACE. */

	int
	wrapup_globals_for_namespace (tree namespace, void* data)
	{
	struct cp_binding_level *level = NAMESPACE_LEVEL (namespace);
	VEC(tree,gc) *statics = level->static_decls;
	tree *vec = VEC_address (tree, statics);
	int len = VEC_length (tree, statics);
	int last_time = (data != 0);

	if (last_time)
	{
	check_global_declarations (vec, len);
	emit_debug_global_declarations (vec, len);
	return 0;
	}

	/* Write out any globals that need to be output. */
	return wrapup_global_declarations (vec, len);
	}


	/* In C++, you don't have to write `struct S' to refer to `S'; you
	can just use `S'. We accomplish this by creating a TYPE_DECL as
	if the user had written `typedef struct S S'. Create and return
	the TYPE_DECL for TYPE. */

	tree
	create_implicit_typedef (tree name, tree type)
	{
	tree decl;

	decl = build_decl (TYPE_DECL, name, type);
	DECL_ARTIFICIAL (decl) = 1;
	/* There are other implicit type declarations, like the one within
	a class that allows you to write `S::S'. We must distinguish
	amongst these. */
	SET_DECL_IMPLICIT_TYPEDEF_P (decl);
	TYPE_NAME (type) = decl;

	return decl;
	}

	/* Remember a local name for name-mangling purposes. */

	static void
	push_local_name (tree decl)
	{
	size_t i, nelts;
	tree t, name;

	timevar_push (TV_NAME_LOOKUP);

	name = DECL_NAME (decl);

	nelts = VEC_length (tree, local_names);
	for (i = 0; i < nelts; i++)
	{
	t = VEC_index (tree, local_names, i);
	if (DECL_NAME (t) == name)
	{
	if (!DECL_LANG_SPECIFIC (decl))
	retrofit_lang_decl (decl);
	DECL_LANG_SPECIFIC (decl)->decl_flags.u2sel = 1;
	if (DECL_LANG_SPECIFIC (t))
	DECL_DISCRIMINATOR (decl) = DECL_DISCRIMINATOR (t) + 1;
	else
	DECL_DISCRIMINATOR (decl) = 1;

	VEC_replace (tree, local_names, i, decl);
	timevar_pop (TV_NAME_LOOKUP);
	return;
	}
	}

	VEC_safe_push (tree, gc, local_names, decl);
	timevar_pop (TV_NAME_LOOKUP);
	}

	/* Subroutine of duplicate_decls: return truthvalue of whether
	or not types of these decls match.

	For C++, we must compare the parameter list so that `int' can match
	`int&' in a parameter position, but `int&' is not confused with
	`const int&'. */

	int
	decls_match (tree newdecl, tree olddecl)
	{
	int types_match;

	if (newdecl == olddecl)
	return 1;

	if (TREE_CODE (newdecl) != TREE_CODE (olddecl))
	/* If the two DECLs are not even the same kind of thing, we're not
	interested in their types. */
	return 0;

	if (TREE_CODE (newdecl) == FUNCTION_DECL)
	{
	tree f1 = TREE_TYPE (newdecl);
	tree f2 = TREE_TYPE (olddecl);
	tree p1 = TYPE_ARG_TYPES (f1);
	tree p2 = TYPE_ARG_TYPES (f2);

	if (CP_DECL_CONTEXT (newdecl) != CP_DECL_CONTEXT (olddecl)
	&& ! (DECL_EXTERN_C_P (newdecl)
	&& DECL_EXTERN_C_P (olddecl)))
	return 0;

	if (TREE_CODE (f1) != TREE_CODE (f2))
	return 0;

	if (same_type_p (TREE_TYPE (f1), TREE_TYPE (f2)))
	{
	if (p2 == NULL_TREE && DECL_EXTERN_C_P (olddecl)
	&& (DECL_BUILT_IN (olddecl)
	#ifndef NO_IMPLICIT_EXTERN_C
	\|\| (DECL_IN_SYSTEM_HEADER (newdecl) && !DECL_CLASS_SCOPE_P (newdecl))
	\|\| (DECL_IN_SYSTEM_HEADER (olddecl) && !DECL_CLASS_SCOPE_P (olddecl))
	#endif
	))
	{
	types_match = self_promoting_args_p (p1);
	if (p1 == void_list_node)
	TREE_TYPE (newdecl) = TREE_TYPE (olddecl);
	}
	#ifndef NO_IMPLICIT_EXTERN_C
	else if (p1 == NULL_TREE
	&& (DECL_EXTERN_C_P (olddecl)
	&& DECL_IN_SYSTEM_HEADER (olddecl)
	&& !DECL_CLASS_SCOPE_P (olddecl))
	&& (DECL_EXTERN_C_P (newdecl)
	&& DECL_IN_SYSTEM_HEADER (newdecl)
	&& !DECL_CLASS_SCOPE_P (newdecl)))
	{
	types_match = self_promoting_args_p (p2);
	TREE_TYPE (newdecl) = TREE_TYPE (olddecl);
	}
	#endif
	else
	types_match = compparms (p1, p2);
	}
	else
	types_match = 0;
	}
	else if (TREE_CODE (newdecl) == TEMPLATE_DECL)
	{
	if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl))
	!= TREE_CODE (DECL_TEMPLATE_RESULT (olddecl)))
	return 0;

	if (!comp_template_parms (DECL_TEMPLATE_PARMS (newdecl),
	DECL_TEMPLATE_PARMS (olddecl)))
	return 0;

	if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL)
	types_match = same_type_p (TREE_TYPE (DECL_TEMPLATE_RESULT (olddecl)),
	TREE_TYPE (DECL_TEMPLATE_RESULT (newdecl)));
	else
	types_match = decls_match (DECL_TEMPLATE_RESULT (olddecl),
	DECL_TEMPLATE_RESULT (newdecl));
	}
	else
	{
	/* Need to check scope for variable declaration (VAR_DECL).
	For typedef (TYPE_DECL), scope is ignored. */
	if (TREE_CODE (newdecl) == VAR_DECL
	&& CP_DECL_CONTEXT (newdecl) != CP_DECL_CONTEXT (olddecl)
	/* [dcl.link]
	Two declarations for an object with C language linkage
	with the same name (ignoring the namespace that qualify
	it) that appear in different namespace scopes refer to
	the same object. */
	&& !(DECL_EXTERN_C_P (olddecl) && DECL_EXTERN_C_P (newdecl)))
	return 0;

	if (TREE_TYPE (newdecl) == error_mark_node)
	types_match = TREE_TYPE (olddecl) == error_mark_node;
	else if (TREE_TYPE (olddecl) == NULL_TREE)
	types_match = TREE_TYPE (newdecl) == NULL_TREE;
	else if (TREE_TYPE (newdecl) == NULL_TREE)
	types_match = 0;
	else
	types_match = comptypes (TREE_TYPE (newdecl),
	TREE_TYPE (olddecl),
	COMPARE_REDECLARATION);
	}

	return types_match;
	}

	/* If NEWDECL is `static' and an `extern' was seen previously,
	warn about it. OLDDECL is the previous declaration.

	Note that this does not apply to the C++ case of declaring
	a variable `extern const' and then later `const'.

	Don't complain about built-in functions, since they are beyond
	the user's control. */

	void
	warn_extern_redeclared_static (tree newdecl, tree olddecl)
	{
	tree name;

	if (TREE_CODE (newdecl) == TYPE_DECL
	\|\| TREE_CODE (newdecl) == TEMPLATE_DECL
	\|\| TREE_CODE (newdecl) == CONST_DECL
	\|\| TREE_CODE (newdecl) == NAMESPACE_DECL)
	return;

	/* Don't get confused by static member functions; that's a different
	use of `static'. */
	if (TREE_CODE (newdecl) == FUNCTION_DECL
	&& DECL_STATIC_FUNCTION_P (newdecl))
	return;

	/* If the old declaration was `static', or the new one isn't, then
	then everything is OK. */
	if (DECL_THIS_STATIC (olddecl) \|\| !DECL_THIS_STATIC (newdecl))
	return;

	/* It's OK to declare a builtin function as `static'. */
	if (TREE_CODE (olddecl) == FUNCTION_DECL
	&& DECL_ARTIFICIAL (olddecl))
	return;

	name = DECL_ASSEMBLER_NAME (newdecl);
	pedwarn ("%qD was declared %<extern%> and later %<static%>", newdecl);
	pedwarn ("previous declaration of %q+D", olddecl);
	}

	/* NEW_DECL is a redeclaration of OLD_DECL; both are functions or
	function templates. If their exception specifications do not
	match, issue an a diagnostic. */

	static void
	check_redeclaration_exception_specification (tree new_decl,
	tree old_decl)
	{
	tree new_type;
	tree old_type;
	tree new_exceptions;
	tree old_exceptions;

	new_type = TREE_TYPE (new_decl);
	new_exceptions = TYPE_RAISES_EXCEPTIONS (new_type);
	old_type = TREE_TYPE (old_decl);
	old_exceptions = TYPE_RAISES_EXCEPTIONS (old_type);

	/* [except.spec]

	If any declaration of a function has an exception-specification,
	all declarations, including the definition and an explicit
	specialization, of that function shall have an
	exception-specification with the same set of type-ids. */
	if ((pedantic \|\| ! DECL_IN_SYSTEM_HEADER (old_decl))
	&& ! DECL_IS_BUILTIN (old_decl)
	&& flag_exceptions
	&& !comp_except_specs (new_exceptions, old_exceptions,
	/exact=/true))
	{
	error ("declaration of %qF throws different exceptions", new_decl);
	error ("from previous declaration %q+F", old_decl);
	}
	}

	/* If NEWDECL is a redeclaration of OLDDECL, merge the declarations.
	If the redeclaration is invalid, a diagnostic is issued, and the
	error_mark_node is returned. Otherwise, OLDDECL is returned.

	If NEWDECL is not a redeclaration of OLDDECL, NULL_TREE is
	returned.

	NEWDECL_IS_FRIEND is true if NEWDECL was declared as a friend. */

	tree
	duplicate_decls (tree newdecl, tree olddecl, bool newdecl_is_friend)
	{
	unsigned olddecl_uid = DECL_UID (olddecl);
	int olddecl_friend = 0, types_match = 0, hidden_friend = 0;
	int new_defines_function = 0;
	tree new_template;

	if (newdecl == olddecl)
	return olddecl;

	types_match = decls_match (newdecl, olddecl);

	/* If either the type of the new decl or the type of the old decl is an
	error_mark_node, then that implies that we have already issued an
	error (earlier) for some bogus type specification, and in that case,
	it is rather pointless to harass the user with yet more error message
	about the same declaration, so just pretend the types match here. */
	if (TREE_TYPE (newdecl) == error_mark_node
	\|\| TREE_TYPE (olddecl) == error_mark_node)
	return error_mark_node;

	if (DECL_P (olddecl)
	&& TREE_CODE (newdecl) == FUNCTION_DECL
	&& TREE_CODE (olddecl) == FUNCTION_DECL
	&& (DECL_UNINLINABLE (newdecl) \|\| DECL_UNINLINABLE (olddecl)))
	{
	if (DECL_DECLARED_INLINE_P (newdecl)
	&& DECL_UNINLINABLE (newdecl)
	&& lookup_attribute ("noinline", DECL_ATTRIBUTES (newdecl)))
	/* Already warned elsewhere. */;
	else if (DECL_DECLARED_INLINE_P (olddecl)
	&& DECL_UNINLINABLE (olddecl)
	&& lookup_attribute ("noinline", DECL_ATTRIBUTES (olddecl)))
	/* Already warned. */;
	else if (DECL_DECLARED_INLINE_P (newdecl)
	&& DECL_UNINLINABLE (olddecl)
	&& lookup_attribute ("noinline", DECL_ATTRIBUTES (olddecl)))
	{
	warning (OPT_Wattributes, "function %q+D redeclared as inline",
	newdecl);
	warning (OPT_Wattributes, "previous declaration of %q+D "
	"with attribute noinline", olddecl);
	}
	else if (DECL_DECLARED_INLINE_P (olddecl)
	&& DECL_UNINLINABLE (newdecl)
	&& lookup_attribute ("noinline", DECL_ATTRIBUTES (newdecl)))
	{
	warning (OPT_Wattributes, "function %q+D redeclared with "
	"attribute noinline", newdecl);
	warning (OPT_Wattributes, "previous declaration of %q+D was inline",
	olddecl);
	}
	}

	/* Check for redeclaration and other discrepancies. */
	if (TREE_CODE (olddecl) == FUNCTION_DECL
	&& DECL_ARTIFICIAL (olddecl))
	{
	gcc_assert (!DECL_HIDDEN_FRIEND_P (olddecl));
	if (TREE_CODE (newdecl) != FUNCTION_DECL)
	{
	/* Avoid warnings redeclaring built-ins which have not been
	explicitly declared. */
	if (DECL_ANTICIPATED (olddecl))
	return NULL_TREE;

	/* If you declare a built-in or predefined function name as static,
	the old definition is overridden, but optionally warn this was a
	bad choice of name. */
	if (! TREE_PUBLIC (newdecl))
	{
	warning (OPT_Wshadow, "shadowing %s function %q#D",
	DECL_BUILT_IN (olddecl) ? "built-in" : "library",
	olddecl);
	/* Discard the old built-in function. */
	return NULL_TREE;
	}
	/* If the built-in is not ansi, then programs can override
	it even globally without an error. */
	else if (! DECL_BUILT_IN (olddecl))
	warning (0, "library function %q#D redeclared as non-function %q#D",
	olddecl, newdecl);
	else
	{
	error ("declaration of %q#D", newdecl);
	error ("conflicts with built-in declaration %q#D",
	olddecl);
	}
	return NULL_TREE;
	}
	else if (!types_match)
	{
	/* Avoid warnings redeclaring built-ins which have not been
	explicitly declared. */
	if (DECL_ANTICIPATED (olddecl))
	{
	/* Deal with fileptr_type_node. FILE type is not known
	at the time we create the builtins. */
	tree t1, t2;

	for (t1 = TYPE_ARG_TYPES (TREE_TYPE (newdecl)),
	t2 = TYPE_ARG_TYPES (TREE_TYPE (olddecl));
	t1 \|\| t2;
	t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2))
	if (!t1 \|\| !t2)
	break;
	else if (TREE_VALUE (t2) == fileptr_type_node)
	{
	tree t = TREE_VALUE (t1);

	if (TREE_CODE (t) == POINTER_TYPE
	&& TYPE_NAME (TREE_TYPE (t))
	&& DECL_NAME (TYPE_NAME (TREE_TYPE (t)))
	== get_identifier ("FILE")
	&& compparms (TREE_CHAIN (t1), TREE_CHAIN (t2)))
	{
	tree oldargs = TYPE_ARG_TYPES (TREE_TYPE (olddecl));

	TYPE_ARG_TYPES (TREE_TYPE (olddecl))
	= TYPE_ARG_TYPES (TREE_TYPE (newdecl));
	types_match = decls_match (newdecl, olddecl);
	if (types_match)
	return duplicate_decls (newdecl, olddecl,
	newdecl_is_friend);
	TYPE_ARG_TYPES (TREE_TYPE (olddecl)) = oldargs;
	}
	}
	else if (! same_type_p (TREE_VALUE (t1), TREE_VALUE (t2)))
	break;
	}
	else if ((DECL_EXTERN_C_P (newdecl)
	&& DECL_EXTERN_C_P (olddecl))
	\|\| compparms (TYPE_ARG_TYPES (TREE_TYPE (newdecl)),
	TYPE_ARG_TYPES (TREE_TYPE (olddecl))))
	{
	/* A near match; override the builtin. */

	if (TREE_PUBLIC (newdecl))
	{
	warning (0, "new declaration %q#D", newdecl);
	warning (0, "ambiguates built-in declaration %q#D",
	olddecl);
	}
	else
	warning (OPT_Wshadow, "shadowing %s function %q#D",
	DECL_BUILT_IN (olddecl) ? "built-in" : "library",
	olddecl);
	}
	else
	/* Discard the old built-in function. */
	return NULL_TREE;

	/* Replace the old RTL to avoid problems with inlining. */
	COPY_DECL_RTL (newdecl, olddecl);
	}
	/* Even if the types match, prefer the new declarations type for
	built-ins which have not been explicitly declared, for
	exception lists, etc... */
	else if (DECL_ANTICIPATED (olddecl))
	{
	tree type = TREE_TYPE (newdecl);
	tree attribs = (*targetm.merge_type_attributes)
	(TREE_TYPE (olddecl), type);

	type = cp_build_type_attribute_variant (type, attribs);
	TREE_TYPE (newdecl) = TREE_TYPE (olddecl) = type;
	}

	/* Whether or not the builtin can throw exceptions has no
	bearing on this declarator. */
	TREE_NOTHROW (olddecl) = 0;

	if (DECL_THIS_STATIC (newdecl) && !DECL_THIS_STATIC (olddecl))
	{
	/* If a builtin function is redeclared as `static', merge
	the declarations, but make the original one static. */
	DECL_THIS_STATIC (olddecl) = 1;
	TREE_PUBLIC (olddecl) = 0;

	/* Make the old declaration consistent with the new one so
	that all remnants of the builtin-ness of this function
	will be banished. */
	SET_DECL_LANGUAGE (olddecl, DECL_LANGUAGE (newdecl));
	COPY_DECL_RTL (newdecl, olddecl);
	}
	}
	else if (TREE_CODE (olddecl) != TREE_CODE (newdecl))
	{
	if ((TREE_CODE (olddecl) == TYPE_DECL && DECL_ARTIFICIAL (olddecl)
	&& TREE_CODE (newdecl) != TYPE_DECL
	&& ! (TREE_CODE (newdecl) == TEMPLATE_DECL
	&& TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL))
	\|\| (TREE_CODE (newdecl) == TYPE_DECL && DECL_ARTIFICIAL (newdecl)
	&& TREE_CODE (olddecl) != TYPE_DECL
	&& ! (TREE_CODE (olddecl) == TEMPLATE_DECL
	&& (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl))
	== TYPE_DECL))))
	{
	/* We do nothing special here, because C++ does such nasty
	things with TYPE_DECLs. Instead, just let the TYPE_DECL
	get shadowed, and know that if we need to find a TYPE_DECL
	for a given name, we can look in the IDENTIFIER_TYPE_VALUE
	slot of the identifier. */
	return NULL_TREE;
	}

	if ((TREE_CODE (newdecl) == FUNCTION_DECL
	&& DECL_FUNCTION_TEMPLATE_P (olddecl))
	\|\| (TREE_CODE (olddecl) == FUNCTION_DECL
	&& DECL_FUNCTION_TEMPLATE_P (newdecl)))
	return NULL_TREE;

	error ("%q#D redeclared as different kind of symbol", newdecl);
	if (TREE_CODE (olddecl) == TREE_LIST)
	olddecl = TREE_VALUE (olddecl);
	error ("previous declaration of %q+#D", olddecl);

	return error_mark_node;
	}
	else if (!types_match)
	{
	if (CP_DECL_CONTEXT (newdecl) != CP_DECL_CONTEXT (olddecl))
	/* These are certainly not duplicate declarations; they're
	from different scopes. */
	return NULL_TREE;

	if (TREE_CODE (newdecl) == TEMPLATE_DECL)
	{
	/* The name of a class template may not be declared to refer to
	any other template, class, function, object, namespace, value,
	or type in the same scope. */
	if (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl)) == TYPE_DECL
	\|\| TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL)
	{
	error ("declaration of template %q#D", newdecl);
	error ("conflicts with previous declaration %q+#D", olddecl);
	}
	else if (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl)) == FUNCTION_DECL
	&& TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == FUNCTION_DECL
	&& compparms (TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (olddecl))),
	TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (newdecl))))
	&& comp_template_parms (DECL_TEMPLATE_PARMS (newdecl),
	DECL_TEMPLATE_PARMS (olddecl))
	/* Template functions can be disambiguated by
	return type. */
	&& same_type_p (TREE_TYPE (TREE_TYPE (newdecl)),
	TREE_TYPE (TREE_TYPE (olddecl))))
	{
	error ("new declaration %q#D", newdecl);
	error ("ambiguates old declaration %q+#D", olddecl);
	}
	return NULL_TREE;
	}
	if (TREE_CODE (newdecl) == FUNCTION_DECL)
	{
	if (DECL_EXTERN_C_P (newdecl) && DECL_EXTERN_C_P (olddecl))
	{
	error ("declaration of C function %q#D conflicts with",
	newdecl);
	error ("previous declaration %q+#D here", olddecl);
	}
	else if (compparms (TYPE_ARG_TYPES (TREE_TYPE (newdecl)),
	TYPE_ARG_TYPES (TREE_TYPE (olddecl))))
	{
	error ("new declaration %q#D", newdecl);
	error ("ambiguates old declaration %q+#D", olddecl);
	return error_mark_node;
	}
	else
	return NULL_TREE;
	}
	else
	{
	error ("conflicting declaration %q#D", newdecl);
	error ("%q+D has a previous declaration as %q#D", olddecl, olddecl);
	return error_mark_node;
	}
	}
	else if (TREE_CODE (newdecl) == FUNCTION_DECL
	&& ((DECL_TEMPLATE_SPECIALIZATION (olddecl)
	&& (!DECL_TEMPLATE_INFO (newdecl)
	\|\| (DECL_TI_TEMPLATE (newdecl)
	!= DECL_TI_TEMPLATE (olddecl))))
	\|\| (DECL_TEMPLATE_SPECIALIZATION (newdecl)
	&& (!DECL_TEMPLATE_INFO (olddecl)
	\|\| (DECL_TI_TEMPLATE (olddecl)
	!= DECL_TI_TEMPLATE (newdecl))))))
	/* It's OK to have a template specialization and a non-template
	with the same type, or to have specializations of two
	different templates with the same type. Note that if one is a
	specialization, and the other is an instantiation of the same
	template, that we do not exit at this point. That situation
	can occur if we instantiate a template class, and then
	specialize one of its methods. This situation is valid, but
	the declarations must be merged in the usual way. */
	return NULL_TREE;
	else if (TREE_CODE (newdecl) == FUNCTION_DECL
	&& ((DECL_TEMPLATE_INSTANTIATION (olddecl)
	&& !DECL_USE_TEMPLATE (newdecl))
	\|\| (DECL_TEMPLATE_INSTANTIATION (newdecl)
	&& !DECL_USE_TEMPLATE (olddecl))))
	/* One of the declarations is a template instantiation, and the
	other is not a template at all. That's OK. */
	return NULL_TREE;
	else if (TREE_CODE (newdecl) == NAMESPACE_DECL)
	{
	/* In [namespace.alias] we have:

	In a declarative region, a namespace-alias-definition can be
	used to redefine a namespace-alias declared in that declarative
	region to refer only to the namespace to which it already
	refers.

	Therefore, if we encounter a second alias directive for the same
	alias, we can just ignore the second directive. */
	if (DECL_NAMESPACE_ALIAS (newdecl)
	&& (DECL_NAMESPACE_ALIAS (newdecl)
	== DECL_NAMESPACE_ALIAS (olddecl)))
	return olddecl;
	/* [namespace.alias]

	A namespace-name or namespace-alias shall not be declared as
	the name of any other entity in the same declarative region.
	A namespace-name defined at global scope shall not be
	declared as the name of any other entity in any global scope
	of the program. */
	error ("declaration of namespace %qD conflicts with", newdecl);
	error ("previous declaration of namespace %q+D here", olddecl);
	return error_mark_node;
	}
	else
	{
	const char *errmsg = redeclaration_error_message (newdecl, olddecl);
	if (errmsg)
	{
	error (errmsg, newdecl);
	if (DECL_NAME (olddecl) != NULL_TREE)
	error ((DECL_INITIAL (olddecl) && namespace_bindings_p ())
	? "%q+#D previously defined here"
	: "%q+#D previously declared here", olddecl);
	return error_mark_node;
	}
	else if (TREE_CODE (olddecl) == FUNCTION_DECL
	&& DECL_INITIAL (olddecl) != NULL_TREE
	&& TYPE_ARG_TYPES (TREE_TYPE (olddecl)) == NULL_TREE
	&& TYPE_ARG_TYPES (TREE_TYPE (newdecl)) != NULL_TREE)
	{
	/* Prototype decl follows defn w/o prototype. */
	warning (0, "prototype for %q+#D", newdecl);
	warning (0, "%Jfollows non-prototype definition here", olddecl);
	}
	else if ((TREE_CODE (olddecl) == FUNCTION_DECL
	\|\| TREE_CODE (olddecl) == VAR_DECL)
	&& DECL_LANGUAGE (newdecl) != DECL_LANGUAGE (olddecl))
	{
	/* [dcl.link]
	If two declarations of the same function or object
	specify different linkage-specifications ..., the program
	is ill-formed.... Except for functions with C++ linkage,
	a function declaration without a linkage specification
	shall not precede the first linkage specification for
	that function. A function can be declared without a
	linkage specification after an explicit linkage
	specification has been seen; the linkage explicitly
	specified in the earlier declaration is not affected by
	such a function declaration.

	DR 563 raises the question why the restrictions on
	functions should not also apply to objects. Older
	versions of G++ silently ignore the linkage-specification
	for this example:

	namespace N {
	extern int i;
	extern "C" int i;
	}

	which is clearly wrong. Therefore, we now treat objects
	like functions. */
	if (current_lang_depth () == 0)
	{
	/* There is no explicit linkage-specification, so we use
	the linkage from the previous declaration. */
	if (!DECL_LANG_SPECIFIC (newdecl))
	retrofit_lang_decl (newdecl);
	SET_DECL_LANGUAGE (newdecl, DECL_LANGUAGE (olddecl));
	}
	else
	{
	error ("previous declaration of %q+#D with %qL linkage",
	olddecl, DECL_LANGUAGE (olddecl));
	error ("conflicts with new declaration with %qL linkage",
	DECL_LANGUAGE (newdecl));
	}
	}

	if (DECL_LANG_SPECIFIC (olddecl) && DECL_USE_TEMPLATE (olddecl))
	;
	else if (TREE_CODE (olddecl) == FUNCTION_DECL)
	{
	tree t1 = TYPE_ARG_TYPES (TREE_TYPE (olddecl));
	tree t2 = TYPE_ARG_TYPES (TREE_TYPE (newdecl));
	int i = 1;

	if (TREE_CODE (TREE_TYPE (newdecl)) == METHOD_TYPE)
	t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2);

	for (; t1 && t1 != void_list_node;
	t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2), i++)
	if (TREE_PURPOSE (t1) && TREE_PURPOSE (t2))
	{
	if (1 == simple_cst_equal (TREE_PURPOSE (t1),
	TREE_PURPOSE (t2)))
	{
	pedwarn ("default argument given for parameter %d of %q#D",
	i, newdecl);
	pedwarn ("after previous specification in %q+#D", olddecl);
	}
	else
	{
	error ("default argument given for parameter %d of %q#D",
	i, newdecl);
	error ("after previous specification in %q+#D",
	olddecl);
	}
	}

	if (DECL_DECLARED_INLINE_P (newdecl)
	&& ! DECL_DECLARED_INLINE_P (olddecl)
	&& TREE_ADDRESSABLE (olddecl) && warn_inline)
	{
	warning (0, "%q#D was used before it was declared inline", newdecl);
	warning (0, "%Jprevious non-inline declaration here", olddecl);
	}
	}
	}

	/* Do not merge an implicit typedef with an explicit one. In:

	class A;
	...
	typedef class A A __attribute__ ((foo));

	the attribute should apply only to the typedef. */
	if (TREE_CODE (olddecl) == TYPE_DECL
	&& (DECL_IMPLICIT_TYPEDEF_P (olddecl)
	\|\| DECL_IMPLICIT_TYPEDEF_P (newdecl)))
	return NULL_TREE;

	/* If new decl is `static' and an `extern' was seen previously,
	warn about it. */
	warn_extern_redeclared_static (newdecl, olddecl);

	/* We have committed to returning 1 at this point. */
	if (TREE_CODE (newdecl) == FUNCTION_DECL)
	{
	/* Now that functions must hold information normally held
	by field decls, there is extra work to do so that
	declaration information does not get destroyed during
	definition. */
	if (DECL_VINDEX (olddecl))
	DECL_VINDEX (newdecl) = DECL_VINDEX (olddecl);
	if (DECL_CONTEXT (olddecl))
	DECL_CONTEXT (newdecl) = DECL_CONTEXT (olddecl);
	DECL_STATIC_CONSTRUCTOR (newdecl) \|= DECL_STATIC_CONSTRUCTOR (olddecl);
	DECL_STATIC_DESTRUCTOR (newdecl) \|= DECL_STATIC_DESTRUCTOR (olddecl);
	DECL_PURE_VIRTUAL_P (newdecl) \|= DECL_PURE_VIRTUAL_P (olddecl);
	DECL_VIRTUAL_P (newdecl) \|= DECL_VIRTUAL_P (olddecl);
	DECL_INVALID_OVERRIDER_P (newdecl) \|= DECL_INVALID_OVERRIDER_P (olddecl);
	DECL_THIS_STATIC (newdecl) \|= DECL_THIS_STATIC (olddecl);
	if (DECL_OVERLOADED_OPERATOR_P (olddecl) != ERROR_MARK)
	SET_OVERLOADED_OPERATOR_CODE
	(newdecl, DECL_OVERLOADED_OPERATOR_P (olddecl));
	new_defines_function = DECL_INITIAL (newdecl) != NULL_TREE;

	/* Optionally warn about more than one declaration for the same
	name, but don't warn about a function declaration followed by a
	definition. */
	if (warn_redundant_decls && ! DECL_ARTIFICIAL (olddecl)
	&& !(new_defines_function && DECL_INITIAL (olddecl) == NULL_TREE)
	/* Don't warn about extern decl followed by definition. */
	&& !(DECL_EXTERNAL (olddecl) && ! DECL_EXTERNAL (newdecl))
	/* Don't warn about friends, let add_friend take care of it. */
	&& ! (newdecl_is_friend \|\| DECL_FRIEND_P (olddecl)))
	{
	warning (OPT_Wredundant_decls, "redundant redeclaration of %qD in same scope", newdecl);
	warning (OPT_Wredundant_decls, "previous declaration of %q+D", olddecl);
	}
	}

	/* Deal with C++: must preserve virtual function table size. */
	if (TREE_CODE (olddecl) == TYPE_DECL)
	{
	tree newtype = TREE_TYPE (newdecl);
	tree oldtype = TREE_TYPE (olddecl);

	if (newtype != error_mark_node && oldtype != error_mark_node
	&& TYPE_LANG_SPECIFIC (newtype) && TYPE_LANG_SPECIFIC (oldtype))
	CLASSTYPE_FRIEND_CLASSES (newtype)
	= CLASSTYPE_FRIEND_CLASSES (oldtype);

	DECL_ORIGINAL_TYPE (newdecl) = DECL_ORIGINAL_TYPE (olddecl);
	}

	/* Copy all the DECL_... slots specified in the new decl
	except for any that we copy here from the old type. */
	DECL_ATTRIBUTES (newdecl)
	= (*targetm.merge_decl_attributes) (olddecl, newdecl);

	if (TREE_CODE (newdecl) == TEMPLATE_DECL)
	{
	tree old_result;
	tree new_result;
	old_result = DECL_TEMPLATE_RESULT (olddecl);
	new_result = DECL_TEMPLATE_RESULT (newdecl);
	TREE_TYPE (olddecl) = TREE_TYPE (old_result);
	DECL_TEMPLATE_SPECIALIZATIONS (olddecl)
	= chainon (DECL_TEMPLATE_SPECIALIZATIONS (olddecl),
	DECL_TEMPLATE_SPECIALIZATIONS (newdecl));

	if (DECL_FUNCTION_TEMPLATE_P (newdecl))
	{
	DECL_INLINE (old_result)
	\|= DECL_INLINE (new_result);
	DECL_DECLARED_INLINE_P (old_result)
	\|= DECL_DECLARED_INLINE_P (new_result);
	check_redeclaration_exception_specification (newdecl, olddecl);
	}

	/* If the new declaration is a definition, update the file and
	line information on the declaration, and also make
	the old declaration the same definition. */
	if (DECL_INITIAL (old_result) == NULL_TREE
	&& DECL_INITIAL (new_result) != NULL_TREE)
	{
	DECL_SOURCE_LOCATION (olddecl)
	= DECL_SOURCE_LOCATION (old_result)
	= DECL_SOURCE_LOCATION (newdecl);
	DECL_INITIAL (old_result) = DECL_INITIAL (new_result);
	if (DECL_FUNCTION_TEMPLATE_P (newdecl))
	DECL_ARGUMENTS (old_result)
	= DECL_ARGUMENTS (new_result);
	}

	return olddecl;
	}

	if (types_match)
	{
	/* Automatically handles default parameters. */
	tree oldtype = TREE_TYPE (olddecl);
	tree newtype;

	/* Merge the data types specified in the two decls. */
	newtype = merge_types (TREE_TYPE (newdecl), TREE_TYPE (olddecl));

	/* If merge_types produces a non-typedef type, just use the old type. */
	if (TREE_CODE (newdecl) == TYPE_DECL
	&& newtype == DECL_ORIGINAL_TYPE (newdecl))
	newtype = oldtype;

	if (TREE_CODE (newdecl) == VAR_DECL)
	{
	DECL_THIS_EXTERN (newdecl) \|= DECL_THIS_EXTERN (olddecl);
	DECL_INITIALIZED_P (newdecl) \|= DECL_INITIALIZED_P (olddecl);
	DECL_NONTRIVIALLY_INITIALIZED_P (newdecl)
	\|= DECL_NONTRIVIALLY_INITIALIZED_P (olddecl);
	DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (newdecl)
	\|= DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (olddecl);

	/* Merge the threadprivate attribute from OLDDECL into NEWDECL. */
	if (DECL_LANG_SPECIFIC (olddecl)
	&& CP_DECL_THREADPRIVATE_P (olddecl))
	{
	/* Allocate a LANG_SPECIFIC structure for NEWDECL, if needed. */
	if (!DECL_LANG_SPECIFIC (newdecl))
	retrofit_lang_decl (newdecl);

	DECL_TLS_MODEL (newdecl) = DECL_TLS_MODEL (olddecl);
	CP_DECL_THREADPRIVATE_P (newdecl) = 1;
	}
	}

	/* Do this after calling `merge_types' so that default
	parameters don't confuse us. */
	else if (TREE_CODE (newdecl) == FUNCTION_DECL)
	check_redeclaration_exception_specification (newdecl, olddecl);
	TREE_TYPE (newdecl) = TREE_TYPE (olddecl) = newtype;

	if (TREE_CODE (newdecl) == FUNCTION_DECL)
	check_default_args (newdecl);

	/* Lay the type out, unless already done. */
	if (! same_type_p (newtype, oldtype)
	&& TREE_TYPE (newdecl) != error_mark_node
	&& !(processing_template_decl && uses_template_parms (newdecl)))
	layout_type (TREE_TYPE (newdecl));

	if ((TREE_CODE (newdecl) == VAR_DECL
	\|\| TREE_CODE (newdecl) == PARM_DECL
	\|\| TREE_CODE (newdecl) == RESULT_DECL
	\|\| TREE_CODE (newdecl) == FIELD_DECL
	\|\| TREE_CODE (newdecl) == TYPE_DECL)
	&& !(processing_template_decl && uses_template_parms (newdecl)))
	layout_decl (newdecl, 0);

	/* Merge the type qualifiers. */
	if (TREE_READONLY (newdecl))
	TREE_READONLY (olddecl) = 1;
	if (TREE_THIS_VOLATILE (newdecl))
	TREE_THIS_VOLATILE (olddecl) = 1;
	if (TREE_NOTHROW (newdecl))
	TREE_NOTHROW (olddecl) = 1;

	/* Merge deprecatedness. */
	if (TREE_DEPRECATED (newdecl))
	TREE_DEPRECATED (olddecl) = 1;

	/* Merge the initialization information. */
	if (DECL_INITIAL (newdecl) == NULL_TREE
	&& DECL_INITIAL (olddecl) != NULL_TREE)
	{
	DECL_INITIAL (newdecl) = DECL_INITIAL (olddecl);
	DECL_SOURCE_LOCATION (newdecl) = DECL_SOURCE_LOCATION (olddecl);
	if (CAN_HAVE_FULL_LANG_DECL_P (newdecl)
	&& DECL_LANG_SPECIFIC (newdecl)
	&& DECL_LANG_SPECIFIC (olddecl))
	{
	DECL_SAVED_TREE (newdecl) = DECL_SAVED_TREE (olddecl);
	DECL_STRUCT_FUNCTION (newdecl) = DECL_STRUCT_FUNCTION (olddecl);
	}
	}

	/* Merge the section attribute.
	We want to issue an error if the sections conflict but that must be
	done later in decl_attributes since we are called before attributes
	are assigned. */
	if (DECL_SECTION_NAME (newdecl) == NULL_TREE)
	DECL_SECTION_NAME (newdecl) = DECL_SECTION_NAME (olddecl);

	if (TREE_CODE (newdecl) == FUNCTION_DECL)
	{
	DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (newdecl)
	\|= DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (olddecl);
	DECL_NO_LIMIT_STACK (newdecl) \|= DECL_NO_LIMIT_STACK (olddecl);
	TREE_THIS_VOLATILE (newdecl) \|= TREE_THIS_VOLATILE (olddecl);
	TREE_READONLY (newdecl) \|= TREE_READONLY (olddecl);
	TREE_NOTHROW (newdecl) \|= TREE_NOTHROW (olddecl);
	DECL_IS_MALLOC (newdecl) \|= DECL_IS_MALLOC (olddecl);
	DECL_IS_PURE (newdecl) \|= DECL_IS_PURE (olddecl);
	/* Keep the old RTL. */
	COPY_DECL_RTL (olddecl, newdecl);
	}
	else if (TREE_CODE (newdecl) == VAR_DECL
	&& (DECL_SIZE (olddecl) \|\| !DECL_SIZE (newdecl)))
	{
	/* Keep the old RTL. We cannot keep the old RTL if the old
	declaration was for an incomplete object and the new
	declaration is not since many attributes of the RTL will
	change. */
	COPY_DECL_RTL (olddecl, newdecl);
	}
	}
	/* If cannot merge, then use the new type and qualifiers,
	and don't preserve the old rtl. */
	else
	{
	/* Clean out any memory we had of the old declaration. */
	tree oldstatic = value_member (olddecl, static_aggregates);
	if (oldstatic)
	TREE_VALUE (oldstatic) = error_mark_node;

	TREE_TYPE (olddecl) = TREE_TYPE (newdecl);
	TREE_READONLY (olddecl) = TREE_READONLY (newdecl);
	TREE_THIS_VOLATILE (olddecl) = TREE_THIS_VOLATILE (newdecl);
	TREE_SIDE_EFFECTS (olddecl) = TREE_SIDE_EFFECTS (newdecl);
	}

	/* Merge the storage class information. */
	merge_weak (newdecl, olddecl);

	DECL_ONE_ONLY (newdecl) \|= DECL_ONE_ONLY (olddecl);
	DECL_DEFER_OUTPUT (newdecl) \|= DECL_DEFER_OUTPUT (olddecl);
	TREE_PUBLIC (newdecl) = TREE_PUBLIC (olddecl);
	TREE_STATIC (olddecl) = TREE_STATIC (newdecl) \|= TREE_STATIC (olddecl);
	if (! DECL_EXTERNAL (olddecl))
	DECL_EXTERNAL (newdecl) = 0;

	new_template = NULL_TREE;
	if (DECL_LANG_SPECIFIC (newdecl) && DECL_LANG_SPECIFIC (olddecl))
	{
	DECL_INTERFACE_KNOWN (newdecl) \|= DECL_INTERFACE_KNOWN (olddecl);
	DECL_NOT_REALLY_EXTERN (newdecl) \|= DECL_NOT_REALLY_EXTERN (olddecl);
	DECL_COMDAT (newdecl) \|= DECL_COMDAT (olddecl);
	DECL_TEMPLATE_INSTANTIATED (newdecl)
	\|= DECL_TEMPLATE_INSTANTIATED (olddecl);

	/* If the OLDDECL is an instantiation and/or specialization,
	then the NEWDECL must be too. But, it may not yet be marked
	as such if the caller has created NEWDECL, but has not yet
	figured out that it is a redeclaration. */
	if (!DECL_USE_TEMPLATE (newdecl))
	DECL_USE_TEMPLATE (newdecl) = DECL_USE_TEMPLATE (olddecl);

	/* Don't really know how much of the language-specific
	values we should copy from old to new. */
	DECL_IN_AGGR_P (newdecl) = DECL_IN_AGGR_P (olddecl);
	DECL_LANG_SPECIFIC (newdecl)->decl_flags.u2 =
	DECL_LANG_SPECIFIC (olddecl)->decl_flags.u2;
	DECL_NONCONVERTING_P (newdecl) = DECL_NONCONVERTING_P (olddecl);
	DECL_REPO_AVAILABLE_P (newdecl) = DECL_REPO_AVAILABLE_P (olddecl);
	if (DECL_TEMPLATE_INFO (newdecl))
	new_template = DECL_TI_TEMPLATE (newdecl);
	DECL_TEMPLATE_INFO (newdecl) = DECL_TEMPLATE_INFO (olddecl);
	DECL_INITIALIZED_IN_CLASS_P (newdecl)
	\|= DECL_INITIALIZED_IN_CLASS_P (olddecl);
	olddecl_friend = DECL_FRIEND_P (olddecl);
	hidden_friend = (DECL_ANTICIPATED (olddecl)
	&& DECL_HIDDEN_FRIEND_P (olddecl)
	&& newdecl_is_friend);

	/* Only functions have DECL_BEFRIENDING_CLASSES. */
	if (TREE_CODE (newdecl) == FUNCTION_DECL
	\|\| DECL_FUNCTION_TEMPLATE_P (newdecl))
	{
	DECL_BEFRIENDING_CLASSES (newdecl)
	= chainon (DECL_BEFRIENDING_CLASSES (newdecl),
	DECL_BEFRIENDING_CLASSES (olddecl));
	/* DECL_THUNKS is only valid for virtual functions,
	otherwise it is a DECL_FRIEND_CONTEXT. */
	if (DECL_VIRTUAL_P (newdecl))
	DECL_THUNKS (newdecl) = DECL_THUNKS (olddecl);
	}
	}

	if (TREE_CODE (newdecl) == FUNCTION_DECL)
	{
	if (DECL_TEMPLATE_INSTANTIATION (olddecl)
	&& !DECL_TEMPLATE_INSTANTIATION (newdecl))
	{
	/* If newdecl is not a specialization, then it is not a
	template-related function at all. And that means that we
	should have exited above, returning 0. */
	gcc_assert (DECL_TEMPLATE_SPECIALIZATION (newdecl));

	if (TREE_USED (olddecl))
	/* From [temp.expl.spec]:

	If a template, a member template or the member of a class
	template is explicitly specialized then that
	specialization shall be declared before the first use of
	that specialization that would cause an implicit
	instantiation to take place, in every translation unit in
	which such a use occurs. */
	error ("explicit specialization of %qD after first use",
	olddecl);

	SET_DECL_TEMPLATE_SPECIALIZATION (olddecl);

	/* Don't propagate visibility from the template to the
	specialization here. We'll do that in determine_visibility if
	appropriate. */
	DECL_VISIBILITY_SPECIFIED (olddecl) = 0;

	/* [temp.expl.spec/14] We don't inline explicit specialization
	just because the primary template says so. */
	}
	else
	{
	if (DECL_PENDING_INLINE_INFO (newdecl) == 0)
	DECL_PENDING_INLINE_INFO (newdecl) = DECL_PENDING_INLINE_INFO (olddecl);

	DECL_DECLARED_INLINE_P (newdecl) \|= DECL_DECLARED_INLINE_P (olddecl);

	/* If either decl says `inline', this fn is inline, unless
	its definition was passed already. */
	if (DECL_INLINE (newdecl) && DECL_INITIAL (olddecl) == NULL_TREE)
	DECL_INLINE (olddecl) = 1;
	DECL_INLINE (newdecl) = DECL_INLINE (olddecl);

	DECL_UNINLINABLE (newdecl) = DECL_UNINLINABLE (olddecl)
	= (DECL_UNINLINABLE (newdecl) \|\| DECL_UNINLINABLE (olddecl));
	}

	/* Preserve abstractness on cloned [cd]tors. */
	DECL_ABSTRACT (newdecl) = DECL_ABSTRACT (olddecl);

	if (! types_match)
	{
	SET_DECL_LANGUAGE (olddecl, DECL_LANGUAGE (newdecl));
	COPY_DECL_ASSEMBLER_NAME (newdecl, olddecl);
	COPY_DECL_RTL (newdecl, olddecl);
	}
	if (! types_match \|\| new_defines_function)
	{
	/* These need to be copied so that the names are available.
	Note that if the types do match, we'll preserve inline
	info and other bits, but if not, we won't. */
	DECL_ARGUMENTS (olddecl) = DECL_ARGUMENTS (newdecl);
	DECL_RESULT (olddecl) = DECL_RESULT (newdecl);
	}
	if (new_defines_function)
	/* If defining a function declared with other language
	linkage, use the previously declared language linkage. */
	SET_DECL_LANGUAGE (newdecl, DECL_LANGUAGE (olddecl));
	else if (types_match)
	{
	/* If redeclaring a builtin function, and not a definition,
	it stays built in. */
	if (DECL_BUILT_IN (olddecl))
	{
	DECL_BUILT_IN_CLASS (newdecl) = DECL_BUILT_IN_CLASS (olddecl);
	DECL_FUNCTION_CODE (newdecl) = DECL_FUNCTION_CODE (olddecl);
	/* If we're keeping the built-in definition, keep the rtl,
	regardless of declaration matches. */
	COPY_DECL_RTL (olddecl, newdecl);
	}

	DECL_RESULT (newdecl) = DECL_RESULT (olddecl);
	/* Don't clear out the arguments if we're redefining a function. */
	if (DECL_ARGUMENTS (olddecl))
	DECL_ARGUMENTS (newdecl) = DECL_ARGUMENTS (olddecl);
	}
	}
	else if (TREE_CODE (newdecl) == NAMESPACE_DECL)
	NAMESPACE_LEVEL (newdecl) = NAMESPACE_LEVEL (olddecl);

	/* Now preserve various other info from the definition. */
	TREE_ADDRESSABLE (newdecl) = TREE_ADDRESSABLE (olddecl);
	TREE_ASM_WRITTEN (newdecl) = TREE_ASM_WRITTEN (olddecl);
	DECL_COMMON (newdecl) = DECL_COMMON (olddecl);
	COPY_DECL_ASSEMBLER_NAME (olddecl, newdecl);

	/* Warn about conflicting visibility specifications. */
	if (DECL_VISIBILITY_SPECIFIED (olddecl)
	&& DECL_VISIBILITY_SPECIFIED (newdecl)
	&& DECL_VISIBILITY (newdecl) != DECL_VISIBILITY (olddecl))
	{
	warning (OPT_Wattributes, "%q+D: visibility attribute ignored "
	"because it", newdecl);
	warning (OPT_Wattributes, "%Jconflicts with previous "
	"declaration here", olddecl);
	}
	/* Choose the declaration which specified visibility. */
	if (DECL_VISIBILITY_SPECIFIED (olddecl))
	{
	DECL_VISIBILITY (newdecl) = DECL_VISIBILITY (olddecl);
	DECL_VISIBILITY_SPECIFIED (newdecl) = 1;
	}
	/* Init priority used to be merged from newdecl to olddecl by the memcpy,
	so keep this behavior. */
	if (TREE_CODE (newdecl) == VAR_DECL && DECL_HAS_INIT_PRIORITY_P (newdecl))
	{
	SET_DECL_INIT_PRIORITY (olddecl, DECL_INIT_PRIORITY (newdecl));
	DECL_HAS_INIT_PRIORITY_P (olddecl) = 1;
	}

	/* The DECL_LANG_SPECIFIC information in OLDDECL will be replaced
	with that from NEWDECL below. */
	if (DECL_LANG_SPECIFIC (olddecl))
	{
	gcc_assert (DECL_LANG_SPECIFIC (olddecl)
	!= DECL_LANG_SPECIFIC (newdecl));
	ggc_free (DECL_LANG_SPECIFIC (olddecl));
	}

	if (TREE_CODE (newdecl) == FUNCTION_DECL)
	{
	int function_size;

	function_size = sizeof (struct tree_decl_common);

	memcpy ((char *) olddecl + sizeof (struct tree_common),
	(char *) newdecl + sizeof (struct tree_common),
	function_size - sizeof (struct tree_common));

	memcpy ((char *) olddecl + sizeof (struct tree_decl_common),
	(char *) newdecl + sizeof (struct tree_decl_common),
	sizeof (struct tree_function_decl) - sizeof (struct tree_decl_common));
	if (new_template)
	/* If newdecl is a template instantiation, it is possible that
	the following sequence of events has occurred:

	o A friend function was declared in a class template. The
	class template was instantiated.

	o The instantiation of the friend declaration was
	recorded on the instantiation list, and is newdecl.

	o Later, however, instantiate_class_template called pushdecl
	on the newdecl to perform name injection. But, pushdecl in
	turn called duplicate_decls when it discovered that another
	declaration of a global function with the same name already
	existed.

	o Here, in duplicate_decls, we decided to clobber newdecl.

	If we're going to do that, we'd better make sure that
	olddecl, and not newdecl, is on the list of
	instantiations so that if we try to do the instantiation
	again we won't get the clobbered declaration. */
	reregister_specialization (newdecl,
	new_template,
	olddecl);
	}
	else
	{
	size_t size = tree_code_size (TREE_CODE (olddecl));
	memcpy ((char *) olddecl + sizeof (struct tree_common),
	(char *) newdecl + sizeof (struct tree_common),
	sizeof (struct tree_decl_common) - sizeof (struct tree_common));
	switch (TREE_CODE (olddecl))
	{
	case LABEL_DECL:
	case VAR_DECL:
	case RESULT_DECL:
	case PARM_DECL:
	case FIELD_DECL:
	case TYPE_DECL:
	case CONST_DECL:
	{
	memcpy ((char *) olddecl + sizeof (struct tree_decl_common),
	(char *) newdecl + sizeof (struct tree_decl_common),
	size - sizeof (struct tree_decl_common)
	+ TREE_CODE_LENGTH (TREE_CODE (newdecl)) * sizeof (char *));
	}
	break;
	default:
	memcpy ((char *) olddecl + sizeof (struct tree_decl_common),
	(char *) newdecl + sizeof (struct tree_decl_common),
	sizeof (struct tree_decl_non_common) - sizeof (struct tree_decl_common)
	+ TREE_CODE_LENGTH (TREE_CODE (newdecl)) * sizeof (char *));
	break;
	}
	}
	DECL_UID (olddecl) = olddecl_uid;
	if (olddecl_friend)
	DECL_FRIEND_P (olddecl) = 1;
	if (hidden_friend)
	{
	DECL_ANTICIPATED (olddecl) = 1;
	DECL_HIDDEN_FRIEND_P (olddecl) = 1;
	}

	/* NEWDECL contains the merged attribute lists.
	Update OLDDECL to be the same. */
	DECL_ATTRIBUTES (olddecl) = DECL_ATTRIBUTES (newdecl);

	/* If OLDDECL had its DECL_RTL instantiated, re-invoke make_decl_rtl
	so that encode_section_info has a chance to look at the new decl
	flags and attributes. */
	if (DECL_RTL_SET_P (olddecl)
	&& (TREE_CODE (olddecl) == FUNCTION_DECL
	\|\| (TREE_CODE (olddecl) == VAR_DECL
	&& TREE_STATIC (olddecl))))
	make_decl_rtl (olddecl);

	/* The NEWDECL will no longer be needed. Because every out-of-class
	declaration of a member results in a call to duplicate_decls,
	freeing these nodes represents in a significant savings. */
	ggc_free (newdecl);

	return olddecl;
	}

	/* Return zero if the declaration NEWDECL is valid
	when the declaration OLDDECL (assumed to be for the same name)
	has already been seen.
	Otherwise return an error message format string with a %s
	where the identifier should go. */

	static const char *
	redeclaration_error_message (tree newdecl, tree olddecl)
	{
	if (TREE_CODE (newdecl) == TYPE_DECL)
	{
	/* Because C++ can put things into name space for free,
	constructs like "typedef struct foo { ... } foo"
	would look like an erroneous redeclaration. */
	if (same_type_p (TREE_TYPE (newdecl), TREE_TYPE (olddecl)))
	return NULL;
	else
	return "redefinition of %q#D";
	}
	else if (TREE_CODE (newdecl) == FUNCTION_DECL)
	{
	/* If this is a pure function, its olddecl will actually be
	the original initialization to `0' (which we force to call
	abort()). Don't complain about redefinition in this case. */
	if (DECL_LANG_SPECIFIC (olddecl) && DECL_PURE_VIRTUAL_P (olddecl)
	&& DECL_INITIAL (olddecl) == NULL_TREE)
	return NULL;

	/* If both functions come from different namespaces, this is not
	a redeclaration - this is a conflict with a used function. */
	if (DECL_NAMESPACE_SCOPE_P (olddecl)
	&& DECL_CONTEXT (olddecl) != DECL_CONTEXT (newdecl)
	&& ! decls_match (olddecl, newdecl))
	return "%qD conflicts with used function";

	/* We'll complain about linkage mismatches in
	warn_extern_redeclared_static. */

	/* Defining the same name twice is no good. */
	if (DECL_INITIAL (olddecl) != NULL_TREE
	&& DECL_INITIAL (newdecl) != NULL_TREE)
	{
	if (DECL_NAME (olddecl) == NULL_TREE)
	return "%q#D not declared in class";
	else
	return "redefinition of %q#D";
	}
	return NULL;
	}
	else if (TREE_CODE (newdecl) == TEMPLATE_DECL)
	{
	tree nt, ot;

	if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL)
	{
	if (COMPLETE_TYPE_P (TREE_TYPE (newdecl))
	&& COMPLETE_TYPE_P (TREE_TYPE (olddecl)))
	return "redefinition of %q#D";
	return NULL;
	}

	if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) != FUNCTION_DECL
	\|\| (DECL_TEMPLATE_RESULT (newdecl)
	== DECL_TEMPLATE_RESULT (olddecl)))
	return NULL;

	nt = DECL_TEMPLATE_RESULT (newdecl);
	if (DECL_TEMPLATE_INFO (nt))
	nt = DECL_TEMPLATE_RESULT (template_for_substitution (nt));
	ot = DECL_TEMPLATE_RESULT (olddecl);
	if (DECL_TEMPLATE_INFO (ot))
	ot = DECL_TEMPLATE_RESULT (template_for_substitution (ot));
	if (DECL_INITIAL (nt) && DECL_INITIAL (ot))
	return "redefinition of %q#D";

	return NULL;
	}
	else if (TREE_CODE (newdecl) == VAR_DECL
	&& DECL_THREAD_LOCAL_P (newdecl) != DECL_THREAD_LOCAL_P (olddecl)
	&& (! DECL_LANG_SPECIFIC (olddecl)
	\|\| ! CP_DECL_THREADPRIVATE_P (olddecl)
	\|\| DECL_THREAD_LOCAL_P (newdecl)))
	{
	/* Only variables can be thread-local, and all declarations must
	agree on this property. */
	if (DECL_THREAD_LOCAL_P (newdecl))
	return "thread-local declaration of %q#D follows "
	"non-thread-local declaration";
	else
	return "non-thread-local declaration of %q#D follows "
	"thread-local declaration";
	}
	else if (toplevel_bindings_p () \|\| DECL_NAMESPACE_SCOPE_P (newdecl))
	{
	/* The objects have been declared at namespace scope. If either
	is a member of an anonymous union, then this is an invalid
	redeclaration. For example:

	int i;
	union { int i; };

	is invalid. */
	if (DECL_ANON_UNION_VAR_P (newdecl)
	\|\| DECL_ANON_UNION_VAR_P (olddecl))
	return "redeclaration of %q#D";
	/* If at least one declaration is a reference, there is no
	conflict. For example:

	int i = 3;
	extern int i;

	is valid. */
	if (DECL_EXTERNAL (newdecl) \|\| DECL_EXTERNAL (olddecl))
	return NULL;
	/* Reject two definitions. */
	return "redefinition of %q#D";
	}
	else
	{
	/* Objects declared with block scope: */
	/* Reject two definitions, and reject a definition
	together with an external reference. */
	if (!(DECL_EXTERNAL (newdecl) && DECL_EXTERNAL (olddecl)))
	return "redeclaration of %q#D";
	return NULL;
	}
	}

	/* Hash and equality functions for the named_label table. */

	static hashval_t
	named_label_entry_hash (const void *data)
	{
	const struct named_label_entry ent = (const struct named_label_entry ) data;
	return DECL_UID (ent->label_decl);
	}

	static int
	named_label_entry_eq (const void a, const void b)
	{
	const struct named_label_entry ent_a = (const struct named_label_entry ) a;
	const struct named_label_entry ent_b = (const struct named_label_entry ) b;
	return ent_a->label_decl == ent_b->label_decl;
	}

	/* Create a new label, named ID. */

	static tree
	make_label_decl (tree id, int local_p)
	{
	struct named_label_entry *ent;
	void **slot;
	tree decl;

	decl = build_decl (LABEL_DECL, id, void_type_node);

	DECL_CONTEXT (decl) = current_function_decl;
	DECL_MODE (decl) = VOIDmode;
	C_DECLARED_LABEL_FLAG (decl) = local_p;

	/* Say where one reference is to the label, for the sake of the
	error if it is not defined. */
	DECL_SOURCE_LOCATION (decl) = input_location;

	/* Record the fact that this identifier is bound to this label. */
	SET_IDENTIFIER_LABEL_VALUE (id, decl);

	/* Create the label htab for the function on demand. */
	if (!named_labels)
	named_labels = htab_create_ggc (13, named_label_entry_hash,
	named_label_entry_eq, NULL);

	/* Record this label on the list of labels used in this function.
	We do this before calling make_label_decl so that we get the
	IDENTIFIER_LABEL_VALUE before the new label is declared. */
	ent = GGC_CNEW (struct named_label_entry);
	ent->label_decl = decl;

	slot = htab_find_slot (named_labels, ent, INSERT);
	gcc_assert (*slot == NULL);
	*slot = ent;

	return decl;
	}

	/* Look for a label named ID in the current function. If one cannot
	be found, create one. (We keep track of used, but undefined,
	labels, and complain about them at the end of a function.) */

	tree
	lookup_label (tree id)
	{
	tree decl;

	timevar_push (TV_NAME_LOOKUP);
	/* You can't use labels at global scope. */
	if (current_function_decl == NULL_TREE)
	{
	error ("label %qE referenced outside of any function", id);
	POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE);
	}

	/* See if we've already got this label. */
	decl = IDENTIFIER_LABEL_VALUE (id);
	if (decl != NULL_TREE && DECL_CONTEXT (decl) == current_function_decl)
	POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, decl);

	decl = make_label_decl (id, /local_p=/0);
	POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, decl);
	}

	/* Declare a local label named ID. */

	tree
	declare_local_label (tree id)
	{
	tree decl, shadow;

	/* Add a new entry to the SHADOWED_LABELS list so that when we leave
	this scope we can restore the old value of IDENTIFIER_TYPE_VALUE. */
	shadow = tree_cons (IDENTIFIER_LABEL_VALUE (id), NULL_TREE,
	current_binding_level->shadowed_labels);
	current_binding_level->shadowed_labels = shadow;

	decl = make_label_decl (id, /local_p=/1);
	TREE_VALUE (shadow) = decl;

	return decl;
	}

	/* Returns nonzero if it is ill-formed to jump past the declaration of
	DECL. Returns 2 if it's also a real problem. */

	static int
	decl_jump_unsafe (tree decl)
	{
	if (TREE_CODE (decl) != VAR_DECL \|\| TREE_STATIC (decl)
	\|\| TREE_TYPE (decl) == error_mark_node)
	return 0;

	if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl))
	\|\| DECL_NONTRIVIALLY_INITIALIZED_P (decl))
	return 2;

	if (pod_type_p (TREE_TYPE (decl)))
	return 0;

	/* The POD stuff is just pedantry; why should it matter if the class
	contains a field of pointer to member type? */
	return 1;
	}

	/* A subroutine of check_previous_goto_1 to identify a branch to the user. */

	static void
	identify_goto (tree decl, const location_t *locus)
	{
	if (decl)
	pedwarn ("jump to label %qD", decl);
	else
	pedwarn ("jump to case label");
	if (locus)
	pedwarn ("%H from here", locus);
	}

	/* Check that a single previously seen jump to a newly defined label
	is OK. DECL is the LABEL_DECL or 0; LEVEL is the binding_level for
	the jump context; NAMES are the names in scope in LEVEL at the jump
	context; LOCUS is the source position of the jump or 0. Returns
	true if all is well. */

	static bool
	check_previous_goto_1 (tree decl, struct cp_binding_level* level, tree names,
	bool exited_omp, const location_t *locus)
	{
	struct cp_binding_level *b;
	bool identified = false, saw_eh = false, saw_omp = false;

	if (exited_omp)
	{
	identify_goto (decl, locus);
	error (" exits OpenMP structured block");
	identified = saw_omp = true;
	}

	for (b = current_binding_level; b ; b = b->level_chain)
	{
	tree new_decls, old_decls = (b == level ? names : NULL_TREE);

	for (new_decls = b->names; new_decls != old_decls;
	new_decls = TREE_CHAIN (new_decls))
	{
	int problem = decl_jump_unsafe (new_decls);
	if (! problem)
	continue;

	if (!identified)
	{
	identify_goto (decl, locus);
	identified = true;
	}
	if (problem > 1)
	error (" crosses initialization of %q+#D", new_decls);
	else
	pedwarn (" enters scope of non-POD %q+#D", new_decls);
	}

	if (b == level)
	break;
	if ((b->kind == sk_try \|\| b->kind == sk_catch) && !saw_eh)
	{
	if (!identified)
	{
	identify_goto (decl, locus);
	identified = true;
	}
	if (b->kind == sk_try)
	error (" enters try block");
	else
	error (" enters catch block");
	saw_eh = true;
	}
	if (b->kind == sk_omp && !saw_omp)
	{
	if (!identified)
	{
	identify_goto (decl, locus);
	identified = true;
	}
	error (" enters OpenMP structured block");
	saw_omp = true;
	}
	}

	return !identified;
	}

	static void
	check_previous_goto (tree decl, struct named_label_use_entry *use)
	{
	check_previous_goto_1 (decl, use->binding_level,
	use->names_in_scope, use->in_omp_scope,
	&use->o_goto_locus);
	}

	static bool
	check_switch_goto (struct cp_binding_level* level)
	{
	return check_previous_goto_1 (NULL_TREE, level, level->names, false, NULL);
	}

	/* Check that a new jump to a label DECL is OK. Called by
	finish_goto_stmt. */

	void
	check_goto (tree decl)
	{
	struct named_label_entry *ent, dummy;
	bool saw_catch = false, identified = false;
	tree bad;

	/* We can't know where a computed goto is jumping.
	So we assume that it's OK. */
	if (TREE_CODE (decl) != LABEL_DECL)
	return;

	/* We didn't record any information about this label when we created it,
	and there's not much point since it's trivial to analyze as a return. */
	if (decl == cdtor_label)
	return;

	dummy.label_decl = decl;
	ent = (struct named_label_entry *) htab_find (named_labels, &dummy);
	gcc_assert (ent != NULL);

	/* If the label hasn't been defined yet, defer checking. */
	if (! DECL_INITIAL (decl))
	{
	struct named_label_use_entry *new_use;

	/* Don't bother creating another use if the last goto had the
	same data, and will therefore create the same set of errors. */
	if (ent->uses
	&& ent->uses->names_in_scope == current_binding_level->names)
	return;

	new_use = GGC_NEW (struct named_label_use_entry);
	new_use->binding_level = current_binding_level;
	new_use->names_in_scope = current_binding_level->names;
	new_use->o_goto_locus = input_location;
	new_use->in_omp_scope = false;

	new_use->next = ent->uses;
	ent->uses = new_use;
	return;
	}

	if (ent->in_try_scope \|\| ent->in_catch_scope
	\|\| ent->in_omp_scope \|\| ent->bad_decls)
	{
	pedwarn ("jump to label %q+D", decl);
	pedwarn (" from here");
	identified = true;
	}

	for (bad = ent->bad_decls; bad; bad = TREE_CHAIN (bad))
	{
	tree b = TREE_VALUE (bad);
	int u = decl_jump_unsafe (b);

	if (u > 1 && DECL_ARTIFICIAL (b))
	{
	/* Can't skip init of __exception_info. */
	error ("%J enters catch block", b);
	saw_catch = true;
	}
	else if (u > 1)
	error (" skips initialization of %q+#D", b);
	else
	pedwarn (" enters scope of non-POD %q+#D", b);
	}

	if (ent->in_try_scope)
	error (" enters try block");
	else if (ent->in_catch_scope && !saw_catch)
	error (" enters catch block");

	if (ent->in_omp_scope)
	error (" enters OpenMP structured block");
	else if (flag_openmp)
	{
	struct cp_binding_level *b;
	for (b = current_binding_level; b ; b = b->level_chain)
	{
	if (b == ent->binding_level)
	break;
	if (b->kind == sk_omp)
	{
	if (!identified)
	{
	pedwarn ("jump to label %q+D", decl);
	pedwarn (" from here");
	identified = true;
	}
	error (" exits OpenMP structured block");
	break;
	}
	}
	}
	}

	/* Check that a return is ok wrt OpenMP structured blocks.
	Called by finish_return_stmt. Returns true if all is well. */

	bool
	check_omp_return (void)
	{
	struct cp_binding_level *b;
	for (b = current_binding_level; b ; b = b->level_chain)
	if (b->kind == sk_omp)
	{
	error ("invalid exit from OpenMP structured block");
	return false;
	}
	return true;
	}

	/* Define a label, specifying the location in the source file.
	Return the LABEL_DECL node for the label. */

	tree
	define_label (location_t location, tree name)
	{
	struct named_label_entry *ent, dummy;
	struct cp_binding_level *p;
	tree decl;

	timevar_push (TV_NAME_LOOKUP);

	decl = lookup_label (name);

	dummy.label_decl = decl;
	ent = (struct named_label_entry *) htab_find (named_labels, &dummy);
	gcc_assert (ent != NULL);

	/* After labels, make any new cleanups in the function go into their
	own new (temporary) binding contour. */
	for (p = current_binding_level;
	p->kind != sk_function_parms;
	p = p->level_chain)
	p->more_cleanups_ok = 0;

	if (name == get_identifier ("wchar_t"))
	pedwarn ("label named wchar_t");

	if (DECL_INITIAL (decl) != NULL_TREE)
	{
	error ("duplicate label %qD", decl);
	POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
	}
	else
	{
	struct named_label_use_entry *use;

	/* Mark label as having been defined. */
	DECL_INITIAL (decl) = error_mark_node;
	/* Say where in the source. */
	DECL_SOURCE_LOCATION (decl) = location;

	ent->binding_level = current_binding_level;
	ent->names_in_scope = current_binding_level->names;

	for (use = ent->uses; use ; use = use->next)
	check_previous_goto (decl, use);
	ent->uses = NULL;
	}

	POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, decl);
	}

	struct cp_switch
	{
	struct cp_binding_level *level;
	struct cp_switch *next;
	/* The SWITCH_STMT being built. */
	tree switch_stmt;
	/* A splay-tree mapping the low element of a case range to the high
	element, or NULL_TREE if there is no high element. Used to
	determine whether or not a new case label duplicates an old case
	label. We need a tree, rather than simply a hash table, because
	of the GNU case range extension. */
	splay_tree cases;
	};

	/* A stack of the currently active switch statements. The innermost
	switch statement is on the top of the stack. There is no need to
	mark the stack for garbage collection because it is only active
	during the processing of the body of a function, and we never
	collect at that point. */

	static struct cp_switch *switch_stack;

	/* Called right after a switch-statement condition is parsed.
	SWITCH_STMT is the switch statement being parsed. */

	void
	push_switch (tree switch_stmt)
	{
	struct cp_switch *p = XNEW (struct cp_switch);
	p->level = current_binding_level;
	p->next = switch_stack;
	p->switch_stmt = switch_stmt;
	p->cases = splay_tree_new (case_compare, NULL, NULL);
	switch_stack = p;
	}

	void
	pop_switch (void)
	{
	struct cp_switch *cs = switch_stack;
	location_t switch_location;

	/* Emit warnings as needed. */
	if (EXPR_HAS_LOCATION (cs->switch_stmt))
	switch_location = EXPR_LOCATION (cs->switch_stmt);
	else
	switch_location = input_location;
	if (!processing_template_decl)
	c_do_switch_warnings (cs->cases, switch_location,
	SWITCH_STMT_TYPE (cs->switch_stmt),
	SWITCH_STMT_COND (cs->switch_stmt));

	splay_tree_delete (cs->cases);
	switch_stack = switch_stack->next;
	free (cs);
	}

	/* Note that we've seen a definition of a case label, and complain if this
	is a bad place for one. */

	tree
	finish_case_label (tree low_value, tree high_value)
	{
	tree cond, r;
	struct cp_binding_level *p;

	if (processing_template_decl)
	{
	tree label;

	/* For templates, just add the case label; we'll do semantic
	analysis at instantiation-time. */
	label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
	return add_stmt (build_case_label (low_value, high_value, label));
	}

	/* Find the condition on which this switch statement depends. */
	cond = SWITCH_STMT_COND (switch_stack->switch_stmt);
	if (cond && TREE_CODE (cond) == TREE_LIST)
	cond = TREE_VALUE (cond);

	if (!check_switch_goto (switch_stack->level))
	return error_mark_node;

	r = c_add_case_label (switch_stack->cases, cond, TREE_TYPE (cond),
	low_value, high_value);

	/* After labels, make any new cleanups in the function go into their
	own new (temporary) binding contour. */
	for (p = current_binding_level;
	p->kind != sk_function_parms;
	p = p->level_chain)
	p->more_cleanups_ok = 0;

	return r;
	}

	/* Hash a TYPENAME_TYPE. K is really of type `tree'. */

	static hashval_t
	typename_hash (const void* k)
	{
	hashval_t hash;
	tree t = (tree) k;

	hash = (htab_hash_pointer (TYPE_CONTEXT (t))
	^ htab_hash_pointer (DECL_NAME (TYPE_NAME (t))));

	return hash;
	}

	typedef struct typename_info {
	tree scope;
	tree name;
	tree template_id;
	bool enum_p;
	bool class_p;
	} typename_info;

	/* Compare two TYPENAME_TYPEs. K1 and K2 are really of type `tree'. */

	static int
	typename_compare (const void * k1, const void * k2)
	{
	tree t1;
	const typename_info *t2;

	t1 = (tree) k1;
	t2 = (const typename_info *) k2;

	return (DECL_NAME (TYPE_NAME (t1)) == t2->name
	&& TYPE_CONTEXT (t1) == t2->scope
	&& TYPENAME_TYPE_FULLNAME (t1) == t2->template_id
	&& TYPENAME_IS_ENUM_P (t1) == t2->enum_p
	&& TYPENAME_IS_CLASS_P (t1) == t2->class_p);
	}

	/* Build a TYPENAME_TYPE. If the type is `typename T::t', CONTEXT is
	the type of `T', NAME is the IDENTIFIER_NODE for `t'.

	Returns the new TYPENAME_TYPE. */

	static GTY ((param_is (union tree_node))) htab_t typename_htab;

	static tree
	build_typename_type (tree context, tree name, tree fullname,
	enum tag_types tag_type)
	{
	tree t;
	tree d;
	typename_info ti;
	void **e;
	hashval_t hash;

	if (typename_htab == NULL)
	typename_htab = htab_create_ggc (61, &typename_hash,
	&typename_compare, NULL);

	ti.scope = FROB_CONTEXT (context);
	ti.name = name;
	ti.template_id = fullname;
	ti.enum_p = tag_type == enum_type;
	ti.class_p = (tag_type == class_type
	\|\| tag_type == record_type
	\|\| tag_type == union_type);
	hash = (htab_hash_pointer (ti.scope)
	^ htab_hash_pointer (ti.name));

	/* See if we already have this type. */
	e = htab_find_slot_with_hash (typename_htab, &ti, hash, INSERT);
	if (*e)
	t = (tree) *e;
	else
	{
	/* Build the TYPENAME_TYPE. */
	t = make_aggr_type (TYPENAME_TYPE);
	TYPE_CONTEXT (t) = ti.scope;
	TYPENAME_TYPE_FULLNAME (t) = ti.template_id;
	TYPENAME_IS_ENUM_P (t) = ti.enum_p;
	TYPENAME_IS_CLASS_P (t) = ti.class_p;

	/* Build the corresponding TYPE_DECL. */
	d = build_decl (TYPE_DECL, name, t);
	TYPE_NAME (TREE_TYPE (d)) = d;
	TYPE_STUB_DECL (TREE_TYPE (d)) = d;
	DECL_CONTEXT (d) = FROB_CONTEXT (context);
	DECL_ARTIFICIAL (d) = 1;

	/* Store it in the hash table. */
	*e = t;
	}

	return t;
	}

	/* Resolve `typename CONTEXT::NAME'. TAG_TYPE indicates the tag
	provided to name the type. Returns an appropriate type, unless an
	error occurs, in which case error_mark_node is returned. If we
	locate a non-artificial TYPE_DECL and TF_KEEP_TYPE_DECL is set, we
	return that, rather than the _TYPE it corresponds to, in other
	cases we look through the type decl. If TF_ERROR is set, complain
	about errors, otherwise be quiet. */

	tree
	make_typename_type (tree context, tree name, enum tag_types tag_type,
	tsubst_flags_t complain)
	{
	tree fullname;
	tree t;
	bool want_template;

	if (name == error_mark_node
	\|\| context == NULL_TREE
	\|\| context == error_mark_node)
	return error_mark_node;

	if (TYPE_P (name))
	{
	if (!(TYPE_LANG_SPECIFIC (name)
	&& (CLASSTYPE_IS_TEMPLATE (name)
	\|\| CLASSTYPE_USE_TEMPLATE (name))))
	name = TYPE_IDENTIFIER (name);
	else
	/* Create a TEMPLATE_ID_EXPR for the type. */
	name = build_nt (TEMPLATE_ID_EXPR,
	CLASSTYPE_TI_TEMPLATE (name),
	CLASSTYPE_TI_ARGS (name));
	}
	else if (TREE_CODE (name) == TYPE_DECL)
	name = DECL_NAME (name);

	fullname = name;

	if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
	{
	name = TREE_OPERAND (name, 0);
	if (TREE_CODE (name) == TEMPLATE_DECL)
	name = TREE_OPERAND (fullname, 0) = DECL_NAME (name);
	else if (TREE_CODE (name) == OVERLOAD)
	{
	error ("%qD is not a type", name);
	return error_mark_node;
	}
	}
	if (TREE_CODE (name) == TEMPLATE_DECL)
	{
	error ("%qD used without template parameters", name);
	return error_mark_node;
	}
	gcc_assert (TREE_CODE (name) == IDENTIFIER_NODE);
	gcc_assert (TYPE_P (context));

	/* When the CONTEXT is a dependent type, NAME could refer to a
	dependent base class of CONTEXT. So we cannot peek inside it,
	even if CONTEXT is a currently open scope. */
	if (dependent_type_p (context))
	return build_typename_type (context, name, fullname, tag_type);

	if (!IS_AGGR_TYPE (context))
	{
	if (complain & tf_error)
	error ("%q#T is not a class", context);
	return error_mark_node;
	}

	want_template = TREE_CODE (fullname) == TEMPLATE_ID_EXPR;

	/* We should only set WANT_TYPE when we're a nested typename type.
	Then we can give better diagnostics if we find a non-type. */
	t = lookup_field (context, name, 0, /want_type=/true);
	if (!t)
	{
	if (complain & tf_error)
	error (want_template ? "no class template named %q#T in %q#T"
	: "no type named %q#T in %q#T", name, context);
	return error_mark_node;
	}

	if (want_template && !DECL_CLASS_TEMPLATE_P (t))
	{
	if (complain & tf_error)
	error ("%<typename %T::%D%> names %q#T, which is not a class template",
	context, name, t);
	return error_mark_node;
	}
	if (!want_template && TREE_CODE (t) != TYPE_DECL)
	{
	if (complain & tf_error)
	error ("%<typename %T::%D%> names %q#T, which is not a type",
	context, name, t);
	return error_mark_node;
	}

	if (complain & tf_error)
	perform_or_defer_access_check (TYPE_BINFO (context), t, t);

	if (want_template)
	return lookup_template_class (t, TREE_OPERAND (fullname, 1),
	NULL_TREE, context,
	/entering_scope=/0,
	tf_warning_or_error \| tf_user);

	if (DECL_ARTIFICIAL (t) \|\| !(complain & tf_keep_type_decl))
	t = TREE_TYPE (t);

	return t;
	}

	/* Resolve `CONTEXT::template NAME'. Returns a TEMPLATE_DECL if the name
	can be resolved or an UNBOUND_CLASS_TEMPLATE, unless an error occurs,
	in which case error_mark_node is returned.

	If PARM_LIST is non-NULL, also make sure that the template parameter
	list of TEMPLATE_DECL matches.

	If COMPLAIN zero, don't complain about any errors that occur. */

	tree
	make_unbound_class_template (tree context, tree name, tree parm_list,
	tsubst_flags_t complain)
	{
	tree t;
	tree d;

	if (TYPE_P (name))
	name = TYPE_IDENTIFIER (name);
	else if (DECL_P (name))
	name = DECL_NAME (name);
	gcc_assert (TREE_CODE (name) == IDENTIFIER_NODE);

	if (!dependent_type_p (context)
	\|\| currently_open_class (context))
	{
	tree tmpl = NULL_TREE;

	if (IS_AGGR_TYPE (context))
	tmpl = lookup_field (context, name, 0, false);

	if (!tmpl \|\| !DECL_CLASS_TEMPLATE_P (tmpl))
	{
	if (complain & tf_error)
	error ("no class template named %q#T in %q#T", name, context);
	return error_mark_node;
	}

	if (parm_list
	&& !comp_template_parms (DECL_TEMPLATE_PARMS (tmpl), parm_list))
	{
	if (complain & tf_error)
	{
	error ("template parameters do not match template");
	error ("%q+D declared here", tmpl);
	}
	return error_mark_node;
	}

	if (complain & tf_error)
	perform_or_defer_access_check (TYPE_BINFO (context), tmpl, tmpl);

	return tmpl;
	}

	/* Build the UNBOUND_CLASS_TEMPLATE. */
	t = make_aggr_type (UNBOUND_CLASS_TEMPLATE);
	TYPE_CONTEXT (t) = FROB_CONTEXT (context);
	TREE_TYPE (t) = NULL_TREE;

	/* Build the corresponding TEMPLATE_DECL. */
	d = build_decl (TEMPLATE_DECL, name, t);
	TYPE_NAME (TREE_TYPE (d)) = d;
	TYPE_STUB_DECL (TREE_TYPE (d)) = d;
	DECL_CONTEXT (d) = FROB_CONTEXT (context);
	DECL_ARTIFICIAL (d) = 1;
	DECL_TEMPLATE_PARMS (d) = parm_list;

	return t;
	}



	/* Push the declarations of builtin types into the namespace.
	RID_INDEX is the index of the builtin type in the array
	RID_POINTERS. NAME is the name used when looking up the builtin
	type. TYPE is the _TYPE node for the builtin type. */

	void
	record_builtin_type (enum rid rid_index,
	const char* name,
	tree type)
	{
	tree rname = NULL_TREE, tname = NULL_TREE;
	tree tdecl = NULL_TREE;

	if ((int) rid_index < (int) RID_MAX)
	rname = ridpointers[(int) rid_index];
	if (name)
	tname = get_identifier (name);

	/* The calls to SET_IDENTIFIER_GLOBAL_VALUE below should be
	eliminated. Built-in types should not be looked up name; their
	names are keywords that the parser can recognize. However, there
	is code in c-common.c that uses identifier_global_value to look
	up built-in types by name. */
	if (tname)
	{
	tdecl = build_decl (TYPE_DECL, tname, type);
	DECL_ARTIFICIAL (tdecl) = 1;
	SET_IDENTIFIER_GLOBAL_VALUE (tname, tdecl);
	}
	if (rname)
	{
	if (!tdecl)
	{
	tdecl = build_decl (TYPE_DECL, rname, type);
	DECL_ARTIFICIAL (tdecl) = 1;
	}
	SET_IDENTIFIER_GLOBAL_VALUE (rname, tdecl);
	}

	if (!TYPE_NAME (type))
	TYPE_NAME (type) = tdecl;

	if (tdecl)
	debug_hooks->type_decl (tdecl, 0);
	}

	/* Record one of the standard Java types.
	* Declare it as having the given NAME.
	* If SIZE > 0, it is the size of one of the integral types;
	* otherwise it is the negative of the size of one of the other types. */

	static tree
	record_builtin_java_type (const char* name, int size)
	{
	tree type, decl;
	if (size > 0)
	type = make_signed_type (size);
	else if (size > -32)
	{ /* "__java_char" or ""__java_boolean". */
	type = make_unsigned_type (-size);
	/if (size == -1) TREE_SET_CODE (type, BOOLEAN_TYPE);/
	}
	else
	{ /* "__java_float" or ""__java_double". */
	type = make_node (REAL_TYPE);
	TYPE_PRECISION (type) = - size;
	layout_type (type);
	}
	record_builtin_type (RID_MAX, name, type);
	decl = TYPE_NAME (type);

	/* Suppress generate debug symbol entries for these types,
	since for normal C++ they are just clutter.
	However, push_lang_context undoes this if extern "Java" is seen. */
	DECL_IGNORED_P (decl) = 1;

	TYPE_FOR_JAVA (type) = 1;
	return type;
	}

	/* Push a type into the namespace so that the back-ends ignore it. */

	static void
	record_unknown_type (tree type, const char* name)
	{
	tree decl = pushdecl (build_decl (TYPE_DECL, get_identifier (name), type));
	/* Make sure the "unknown type" typedecl gets ignored for debug info. */
	DECL_IGNORED_P (decl) = 1;
	TYPE_DECL_SUPPRESS_DEBUG (decl) = 1;
	TYPE_SIZE (type) = TYPE_SIZE (void_type_node);
	TYPE_ALIGN (type) = 1;
	TYPE_USER_ALIGN (type) = 0;
	TYPE_MODE (type) = TYPE_MODE (void_type_node);
	}

	/* A string for which we should create an IDENTIFIER_NODE at
	startup. */

	typedef struct predefined_identifier
	{
	/* The name of the identifier. */
	const char *const name;
	/* The place where the IDENTIFIER_NODE should be stored. */
	tree *const node;
	/* Nonzero if this is the name of a constructor or destructor. */
	const int ctor_or_dtor_p;
	} predefined_identifier;

	/* Create all the predefined identifiers. */

	static void
	initialize_predefined_identifiers (void)
	{
	const predefined_identifier *pid;

	/* A table of identifiers to create at startup. */
	static const predefined_identifier predefined_identifiers[] = {
	{ "C++", &lang_name_cplusplus, 0 },
	{ "C", &lang_name_c, 0 },
	{ "Java", &lang_name_java, 0 },
	/* Some of these names have a trailing space so that it is
	impossible for them to conflict with names written by users. */
	{ "__ct ", &ctor_identifier, 1 },
	{ "__base_ctor ", &base_ctor_identifier, 1 },
	{ "__comp_ctor ", &complete_ctor_identifier, 1 },
	{ "__dt ", &dtor_identifier, 1 },
	{ "__comp_dtor ", &complete_dtor_identifier, 1 },
	{ "__base_dtor ", &base_dtor_identifier, 1 },
	{ "__deleting_dtor ", &deleting_dtor_identifier, 1 },
	{ IN_CHARGE_NAME, &in_charge_identifier, 0 },
	{ "nelts", &nelts_identifier, 0 },
	{ THIS_NAME, &this_identifier, 0 },
	{ VTABLE_DELTA_NAME, &delta_identifier, 0 },
	{ VTABLE_PFN_NAME, &pfn_identifier, 0 },
	{ "_vptr", &vptr_identifier, 0 },
	{ "__vtt_parm", &vtt_parm_identifier, 0 },
	{ "::", &global_scope_name, 0 },
	{ "std", &std_identifier, 0 },
	{ NULL, NULL, 0 }
	};

	for (pid = predefined_identifiers; pid->name; ++pid)
	{
	*pid->node = get_identifier (pid->name);
	if (pid->ctor_or_dtor_p)
	IDENTIFIER_CTOR_OR_DTOR_P (*pid->node) = 1;
	}
	}

	/* Create the predefined scalar types of C,
	and some nodes representing standard constants (0, 1, (void *)0).
	Initialize the global binding level.
	Make definitions for built-in primitive functions. */

	void
	cxx_init_decl_processing (void)
	{
	tree void_ftype;
	tree void_ftype_ptr;

	build_common_tree_nodes (flag_signed_char, false);

	/* Create all the identifiers we need. */
	initialize_predefined_identifiers ();

	/* Create the global variables. */
	push_to_top_level ();

	current_function_decl = NULL_TREE;
	current_binding_level = NULL;
	/* Enter the global namespace. */
	gcc_assert (global_namespace == NULL_TREE);
	global_namespace = build_lang_decl (NAMESPACE_DECL, global_scope_name,
	void_type_node);
	TREE_PUBLIC (global_namespace) = 1;
	begin_scope (sk_namespace, global_namespace);

	current_lang_name = NULL_TREE;

	/* Adjust various flags based on command-line settings. */
	if (!flag_permissive)
	flag_pedantic_errors = 1;
	if (!flag_no_inline)
	{
	flag_inline_trees = 1;
	flag_no_inline = 1;
	}
	if (flag_inline_functions)
	flag_inline_trees = 2;

	if (flag_visibility_ms_compat)
	default_visibility = VISIBILITY_HIDDEN;

	/* Initially, C. */
	current_lang_name = lang_name_c;

	/* Create the `std' namespace. */
	push_namespace (std_identifier);
	std_node = current_namespace;
	pop_namespace ();

	c_common_nodes_and_builtins ();

	java_byte_type_node = record_builtin_java_type ("__java_byte", 8);
	java_short_type_node = record_builtin_java_type ("__java_short", 16);
	java_int_type_node = record_builtin_java_type ("__java_int", 32);
	java_long_type_node = record_builtin_java_type ("__java_long", 64);
	java_float_type_node = record_builtin_java_type ("__java_float", -32);
	java_double_type_node = record_builtin_java_type ("__java_double", -64);
	java_char_type_node = record_builtin_java_type ("__java_char", -16);
	java_boolean_type_node = record_builtin_java_type ("__java_boolean", -1);

	integer_two_node = build_int_cst (NULL_TREE, 2);
	integer_three_node = build_int_cst (NULL_TREE, 3);

	record_builtin_type (RID_BOOL, "bool", boolean_type_node);
	truthvalue_type_node = boolean_type_node;
	truthvalue_false_node = boolean_false_node;
	truthvalue_true_node = boolean_true_node;

	empty_except_spec = build_tree_list (NULL_TREE, NULL_TREE);

	#if 0
	record_builtin_type (RID_MAX, NULL, string_type_node);
	#endif

	delta_type_node = ptrdiff_type_node;
	vtable_index_type = ptrdiff_type_node;

	vtt_parm_type = build_pointer_type (const_ptr_type_node);
	void_ftype = build_function_type (void_type_node, void_list_node);
	void_ftype_ptr = build_function_type (void_type_node,
	tree_cons (NULL_TREE,
	ptr_type_node,
	void_list_node));
	void_ftype_ptr
	= build_exception_variant (void_ftype_ptr, empty_except_spec);

	/* C++ extensions */

	unknown_type_node = make_node (UNKNOWN_TYPE);
	record_unknown_type (unknown_type_node, "unknown type");

	/* Indirecting an UNKNOWN_TYPE node yields an UNKNOWN_TYPE node. */
	TREE_TYPE (unknown_type_node) = unknown_type_node;

	/* Looking up TYPE_POINTER_TO and TYPE_REFERENCE_TO yield the same
	result. */
	TYPE_POINTER_TO (unknown_type_node) = unknown_type_node;
	TYPE_REFERENCE_TO (unknown_type_node) = unknown_type_node;

	{
	/* Make sure we get a unique function type, so we can give
	its pointer type a name. (This wins for gdb.) */
	tree vfunc_type = make_node (FUNCTION_TYPE);
	TREE_TYPE (vfunc_type) = integer_type_node;
	TYPE_ARG_TYPES (vfunc_type) = NULL_TREE;
	layout_type (vfunc_type);

	vtable_entry_type = build_pointer_type (vfunc_type);
	}
	record_builtin_type (RID_MAX, VTBL_PTR_TYPE, vtable_entry_type);

	vtbl_type_node
	= build_cplus_array_type (vtable_entry_type, NULL_TREE);
	layout_type (vtbl_type_node);
	vtbl_type_node = build_qualified_type (vtbl_type_node, TYPE_QUAL_CONST);
	record_builtin_type (RID_MAX, NULL, vtbl_type_node);
	vtbl_ptr_type_node = build_pointer_type (vtable_entry_type);
	layout_type (vtbl_ptr_type_node);
	record_builtin_type (RID_MAX, NULL, vtbl_ptr_type_node);

	push_namespace (get_identifier ("__cxxabiv1"));
	abi_node = current_namespace;
	pop_namespace ();

	global_type_node = make_node (LANG_TYPE);
	record_unknown_type (global_type_node, "global type");

	/* Now, C++. */
	current_lang_name = lang_name_cplusplus;

	{
	tree bad_alloc_id;
	tree bad_alloc_type_node;
	tree bad_alloc_decl;
	tree newtype, deltype;
	tree ptr_ftype_sizetype;

	push_namespace (std_identifier);
	bad_alloc_id = get_identifier ("bad_alloc");
	bad_alloc_type_node = make_aggr_type (RECORD_TYPE);
	TYPE_CONTEXT (bad_alloc_type_node) = current_namespace;
	bad_alloc_decl
	= create_implicit_typedef (bad_alloc_id, bad_alloc_type_node);
	DECL_CONTEXT (bad_alloc_decl) = current_namespace;
	TYPE_STUB_DECL (bad_alloc_type_node) = bad_alloc_decl;
	pop_namespace ();

	ptr_ftype_sizetype
	= build_function_type (ptr_type_node,
	tree_cons (NULL_TREE,
	size_type_node,
	void_list_node));
	newtype = build_exception_variant
	(ptr_ftype_sizetype, add_exception_specifier
	(NULL_TREE, bad_alloc_type_node, -1));
	deltype = build_exception_variant (void_ftype_ptr, empty_except_spec);
	push_cp_library_fn (NEW_EXPR, newtype);
	push_cp_library_fn (VEC_NEW_EXPR, newtype);
	global_delete_fndecl = push_cp_library_fn (DELETE_EXPR, deltype);
	push_cp_library_fn (VEC_DELETE_EXPR, deltype);
	}

	abort_fndecl
	= build_library_fn_ptr ("__cxa_pure_virtual", void_ftype);

	/* Perform other language dependent initializations. */
	init_class_processing ();
	init_rtti_processing ();

	if (flag_exceptions)
	init_exception_processing ();

	if (! supports_one_only ())
	flag_weak = 0;

	make_fname_decl = cp_make_fname_decl;
	start_fname_decls ();

	/* Show we use EH for cleanups. */
	if (flag_exceptions)
	using_eh_for_cleanups ();
	}

	/* Generate an initializer for a function naming variable from
	NAME. NAME may be NULL, to indicate a dependent name. TYPE_P is
	filled in with the type of the init. */

	tree
	cp_fname_init (const char* name, tree *type_p)
	{
	tree domain = NULL_TREE;
	tree type;
	tree init = NULL_TREE;
	size_t length = 0;

	if (name)
	{
	length = strlen (name);
	domain = build_index_type (size_int (length));
	init = build_string (length + 1, name);
	}

	type = build_qualified_type (char_type_node, TYPE_QUAL_CONST);
	type = build_cplus_array_type (type, domain);

	*type_p = type;

	if (init)
	TREE_TYPE (init) = type;
	else
	init = error_mark_node;

	return init;
	}

	/* Create the VAR_DECL for __FUNCTION__ etc. ID is the name to give the
	decl, NAME is the initialization string and TYPE_DEP indicates whether
	NAME depended on the type of the function. We make use of that to detect
	__PRETTY_FUNCTION__ inside a template fn. This is being done
	lazily at the point of first use, so we mustn't push the decl now. */

	static tree
	cp_make_fname_decl (tree id, int type_dep)
	{
	const char *const name = (type_dep && processing_template_decl
	? NULL : fname_as_string (type_dep));
	tree type;
	tree init = cp_fname_init (name, &type);
	tree decl = build_decl (VAR_DECL, id, type);

	if (name)
	free ((char *) name);

	/* As we're using pushdecl_with_scope, we must set the context. */
	DECL_CONTEXT (decl) = current_function_decl;
	DECL_PRETTY_FUNCTION_P (decl) = type_dep;

	TREE_STATIC (decl) = 1;
	TREE_READONLY (decl) = 1;
	DECL_ARTIFICIAL (decl) = 1;

	TREE_USED (decl) = 1;

	if (current_function_decl)
	{
	struct cp_binding_level *b = current_binding_level;
	while (b->level_chain->kind != sk_function_parms)
	b = b->level_chain;
	pushdecl_with_scope (decl, b, /is_friend=/false);
	cp_finish_decl (decl, init, /init_const_expr_p=/false, NULL_TREE,
	LOOKUP_ONLYCONVERTING);
	}
	else
	pushdecl_top_level_and_finish (decl, init);

	return decl;
	}

	/* Make a definition for a builtin function named NAME in the current
	namespace, whose data type is TYPE and whose context is CONTEXT.
	TYPE should be a function type with argument types.

	CLASS and CODE tell later passes how to compile calls to this function.
	See tree.h for possible values.

	If LIBNAME is nonzero, use that for DECL_ASSEMBLER_NAME,
	the name to be called if we can't opencode the function.
	If ATTRS is nonzero, use that for the function's attribute
	list. */

	static tree
	builtin_function_1 (const char* name,
	tree type,
	tree context,
	enum built_in_function code,
	enum built_in_class class,
	const char* libname,
	tree attrs)
	{
	tree decl = build_library_fn_1 (get_identifier (name), ERROR_MARK, type);
	DECL_BUILT_IN_CLASS (decl) = class;
	DECL_FUNCTION_CODE (decl) = code;
	DECL_CONTEXT (decl) = context;

	pushdecl (decl);

	/* Since `pushdecl' relies on DECL_ASSEMBLER_NAME instead of DECL_NAME,
	we cannot change DECL_ASSEMBLER_NAME until we have installed this
	function in the namespace. */
	if (libname)
	SET_DECL_ASSEMBLER_NAME (decl, get_identifier (libname));

	/* A function in the user's namespace should have an explicit
	declaration before it is used. Mark the built-in function as
	anticipated but not actually declared. */
	if (name[0] != '_' \|\| name[1] != '_')
	DECL_ANTICIPATED (decl) = 1;

	/* Possibly apply some default attributes to this built-in function. */
	if (attrs)
	decl_attributes (&decl, attrs, ATTR_FLAG_BUILT_IN);
	else
	decl_attributes (&decl, NULL_TREE, 0);

	return decl;
	}

	/* Entry point for the benefit of c_common_nodes_and_builtins.

	Make a definition for a builtin function named NAME and whose data type
	is TYPE. TYPE should be a function type with argument types. This
	function places the anticipated declaration in the global namespace
	and additionally in the std namespace if appropriate.

	CLASS and CODE tell later passes how to compile calls to this function.
	See tree.h for possible values.

	If LIBNAME is nonzero, use that for DECL_ASSEMBLER_NAME,
	the name to be called if we can't opencode the function.

	If ATTRS is nonzero, use that for the function's attribute
	list. */

	tree
	builtin_function (const char* name,
	tree type,
	int code,
	enum built_in_class cl,
	const char* libname,
	tree attrs)
	{
	/* All builtins that don't begin with an '_' should additionally
	go in the 'std' namespace. */
	if (name[0] != '_')
	{
	push_namespace (std_identifier);
	builtin_function_1 (name, type, std_node, code, cl, libname, attrs);
	pop_namespace ();
	}

	return builtin_function_1 (name, type, NULL_TREE, code,
	cl, libname, attrs);
	}

	/* Generate a FUNCTION_DECL with the typical flags for a runtime library
	function. Not called directly. */

	static tree
	build_library_fn_1 (tree name, enum tree_code operator_code, tree type)
	{
	tree fn = build_lang_decl (FUNCTION_DECL, name, type);
	DECL_EXTERNAL (fn) = 1;
	TREE_PUBLIC (fn) = 1;
	DECL_ARTIFICIAL (fn) = 1;
	SET_OVERLOADED_OPERATOR_CODE (fn, operator_code);
	SET_DECL_LANGUAGE (fn, lang_c);
	/* Runtime library routines are, by definition, available in an
	external shared object. */
	DECL_VISIBILITY (fn) = VISIBILITY_DEFAULT;
	DECL_VISIBILITY_SPECIFIED (fn) = 1;
	return fn;
	}

	/* Returns the _DECL for a library function with C linkage.
	We assume that such functions never throw; if this is incorrect,
	callers should unset TREE_NOTHROW. */

	tree
	build_library_fn (tree name, tree type)
	{
	tree fn = build_library_fn_1 (name, ERROR_MARK, type);
	TREE_NOTHROW (fn) = 1;
	return fn;
	}

	/* Returns the _DECL for a library function with C++ linkage. */

	static tree
	build_cp_library_fn (tree name, enum tree_code operator_code, tree type)
	{
	tree fn = build_library_fn_1 (name, operator_code, type);
	TREE_NOTHROW (fn) = TYPE_NOTHROW_P (type);
	DECL_CONTEXT (fn) = FROB_CONTEXT (current_namespace);
	SET_DECL_LANGUAGE (fn, lang_cplusplus);
	return fn;
	}

	/* Like build_library_fn, but takes a C string instead of an
	IDENTIFIER_NODE. */

	tree
	build_library_fn_ptr (const char* name, tree type)
	{
	return build_library_fn (get_identifier (name), type);
	}

	/* Like build_cp_library_fn, but takes a C string instead of an
	IDENTIFIER_NODE. */

	tree
	build_cp_library_fn_ptr (const char* name, tree type)
	{
	return build_cp_library_fn (get_identifier (name), ERROR_MARK, type);
	}

	/* Like build_library_fn, but also pushes the function so that we will
	be able to find it via IDENTIFIER_GLOBAL_VALUE. */

	tree
	push_library_fn (tree name, tree type)
	{
	tree fn = build_library_fn (name, type);
	pushdecl_top_level (fn);
	return fn;
	}

	/* Like build_cp_library_fn, but also pushes the function so that it
	will be found by normal lookup. */

	static tree
	push_cp_library_fn (enum tree_code operator_code, tree type)
	{
	tree fn = build_cp_library_fn (ansi_opname (operator_code),
	operator_code,
	type);
	pushdecl (fn);
	return fn;
	}

	/* Like push_library_fn, but takes a TREE_LIST of parm types rather than
	a FUNCTION_TYPE. */

	tree
	push_void_library_fn (tree name, tree parmtypes)
	{
	tree type = build_function_type (void_type_node, parmtypes);
	return push_library_fn (name, type);
	}

	/* Like push_library_fn, but also note that this function throws
	and does not return. Used for __throw_foo and the like. */

	tree
	push_throw_library_fn (tree name, tree type)
	{
	tree fn = push_library_fn (name, type);
	TREE_THIS_VOLATILE (fn) = 1;
	TREE_NOTHROW (fn) = 0;
	return fn;
	}

	/* When we call finish_struct for an anonymous union, we create
	default copy constructors and such. But, an anonymous union
	shouldn't have such things; this function undoes the damage to the
	anonymous union type T.

	(The reason that we create the synthesized methods is that we don't
	distinguish `union { int i; }' from `typedef union { int i; } U'.
	The first is an anonymous union; the second is just an ordinary
	union type.) */

	void
	fixup_anonymous_aggr (tree t)
	{
	tree *q;

	/* Wipe out memory of synthesized methods. */
	TYPE_HAS_CONSTRUCTOR (t) = 0;
	TYPE_HAS_DEFAULT_CONSTRUCTOR (t) = 0;
	TYPE_HAS_INIT_REF (t) = 0;
	TYPE_HAS_CONST_INIT_REF (t) = 0;
	TYPE_HAS_ASSIGN_REF (t) = 0;
	TYPE_HAS_CONST_ASSIGN_REF (t) = 0;

	/* Splice the implicitly generated functions out of the TYPE_METHODS
	list. */
	q = &TYPE_METHODS (t);
	while (*q)
	{
	if (DECL_ARTIFICIAL (*q))
	q = TREE_CHAIN (q);
	else
	q = &TREE_CHAIN (*q);
	}

	/* ISO C++ 9.5.3. Anonymous unions may not have function members. */
	if (TYPE_METHODS (t))
	error ("%Jan anonymous union cannot have function members",
	TYPE_MAIN_DECL (t));

	/* Anonymous aggregates cannot have fields with ctors, dtors or complex
	assignment operators (because they cannot have these methods themselves).
	For anonymous unions this is already checked because they are not allowed
	in any union, otherwise we have to check it. */
	if (TREE_CODE (t) != UNION_TYPE)
	{
	tree field, type;

	for (field = TYPE_FIELDS (t); field; field = TREE_CHAIN (field))
	if (TREE_CODE (field) == FIELD_DECL)
	{
	type = TREE_TYPE (field);
	if (CLASS_TYPE_P (type))
	{
	if (TYPE_NEEDS_CONSTRUCTING (type))
	error ("member %q+#D with constructor not allowed "
	"in anonymous aggregate", field);
	if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
	error ("member %q+#D with destructor not allowed "
	"in anonymous aggregate", field);
	if (TYPE_HAS_COMPLEX_ASSIGN_REF (type))
	error ("member %q+#D with copy assignment operator "
	"not allowed in anonymous aggregate", field);
	}
	}
	}
	}

	/* Make sure that a declaration with no declarator is well-formed, i.e.
	just declares a tagged type or anonymous union.

	Returns the type declared; or NULL_TREE if none. */

	tree
	check_tag_decl (cp_decl_specifier_seq *declspecs)
	{
	int saw_friend = declspecs->specs[(int)ds_friend] != 0;
	int saw_typedef = declspecs->specs[(int)ds_typedef] != 0;
	/* If a class, struct, or enum type is declared by the DECLSPECS
	(i.e, if a class-specifier, enum-specifier, or non-typename
	elaborated-type-specifier appears in the DECLSPECS),
	DECLARED_TYPE is set to the corresponding type. */
	tree declared_type = NULL_TREE;
	bool error_p = false;

	if (declspecs->multiple_types_p)
	error ("multiple types in one declaration");
	else if (declspecs->redefined_builtin_type)
	{
	if (!in_system_header)
	pedwarn ("redeclaration of C++ built-in type %qT",
	declspecs->redefined_builtin_type);
	return NULL_TREE;
	}

	if (declspecs->type
	&& TYPE_P (declspecs->type)
	&& ((TREE_CODE (declspecs->type) != TYPENAME_TYPE
	&& IS_AGGR_TYPE (declspecs->type))
	\|\| TREE_CODE (declspecs->type) == ENUMERAL_TYPE))
	declared_type = declspecs->type;
	else if (declspecs->type == error_mark_node)
	error_p = true;
	if (declared_type == NULL_TREE && ! saw_friend && !error_p)
	pedwarn ("declaration does not declare anything");
	/* Check for an anonymous union. */
	else if (declared_type && IS_AGGR_TYPE_CODE (TREE_CODE (declared_type))
	&& TYPE_ANONYMOUS_P (declared_type))
	{
	/* 7/3 In a simple-declaration, the optional init-declarator-list
	can be omitted only when declaring a class (clause 9) or
	enumeration (7.2), that is, when the decl-specifier-seq contains
	either a class-specifier, an elaborated-type-specifier with
	a class-key (9.1), or an enum-specifier. In these cases and
	whenever a class-specifier or enum-specifier is present in the
	decl-specifier-seq, the identifiers in these specifiers are among
	the names being declared by the declaration (as class-name,
	enum-names, or enumerators, depending on the syntax). In such
	cases, and except for the declaration of an unnamed bit-field (9.6),
	the decl-specifier-seq shall introduce one or more names into the
	program, or shall redeclare a name introduced by a previous
	declaration. [Example:
	enum { }; // ill-formed
	typedef class { }; // ill-formed
	--end example] */
	if (saw_typedef)
	{
	error ("missing type-name in typedef-declaration");
	return NULL_TREE;
	}
	/* Anonymous unions are objects, so they can have specifiers. */;
	SET_ANON_AGGR_TYPE_P (declared_type);

	if (TREE_CODE (declared_type) != UNION_TYPE && pedantic
	&& !in_system_header)
	pedwarn ("ISO C++ prohibits anonymous structs");
	}

	else
	{
	if (declspecs->specs[(int)ds_inline]
	\|\| declspecs->specs[(int)ds_virtual])
	error ("%qs can only be specified for functions",
	declspecs->specs[(int)ds_inline]
	? "inline" : "virtual");
	else if (saw_friend
	&& (!current_class_type
	\|\| current_scope () != current_class_type))
	error ("%<friend%> can only be specified inside a class");
	else if (declspecs->specs[(int)ds_explicit])
	error ("%<explicit%> can only be specified for constructors");
	else if (declspecs->storage_class)
	error ("a storage class can only be specified for objects "
	"and functions");
	else if (declspecs->specs[(int)ds_const]
	\|\| declspecs->specs[(int)ds_volatile]
	\|\| declspecs->specs[(int)ds_restrict]
	\|\| declspecs->specs[(int)ds_thread])
	error ("qualifiers can only be specified for objects "
	"and functions");
	}

	return declared_type;
	}

	/* Called when a declaration is seen that contains no names to declare.
	If its type is a reference to a structure, union or enum inherited
	from a containing scope, shadow that tag name for the current scope
	with a forward reference.
	If its type defines a new named structure or union
	or defines an enum, it is valid but we need not do anything here.
	Otherwise, it is an error.

	C++: may have to grok the declspecs to learn about static,
	complain for anonymous unions.

	Returns the TYPE declared -- or NULL_TREE if none. */

	tree
	shadow_tag (cp_decl_specifier_seq *declspecs)
	{
	tree t = check_tag_decl (declspecs);

	if (!t)
	return NULL_TREE;

	if (declspecs->attributes)
	{
	warning (0, "attribute ignored in declaration of %q+#T", t);
	warning (0, "attribute for %q+#T must follow the %qs keyword",
	t, class_key_or_enum_as_string (t));

	}

	if (maybe_process_partial_specialization (t) == error_mark_node)
	return NULL_TREE;

	/* This is where the variables in an anonymous union are
	declared. An anonymous union declaration looks like:
	union { ... } ;
	because there is no declarator after the union, the parser
	sends that declaration here. */
	if (ANON_AGGR_TYPE_P (t))
	{
	fixup_anonymous_aggr (t);

	if (TYPE_FIELDS (t))
	{
	tree decl = grokdeclarator (/declarator=/NULL,
	declspecs, NORMAL, 0, NULL);
	finish_anon_union (decl);
	}
	}

	return t;
	}

	/* Decode a "typename", such as "int *", returning a ..._TYPE node. /

	tree
	groktypename (cp_decl_specifier_seq *type_specifiers,
	const cp_declarator *declarator)
	{
	tree attrs;
	tree type;
	attrs = type_specifiers->attributes;
	type_specifiers->attributes = NULL_TREE;
	type = grokdeclarator (declarator, type_specifiers, TYPENAME, 0, &attrs);
	if (attrs)
	cplus_decl_attributes (&type, attrs, 0);
	return type;
	}

	/* Decode a declarator in an ordinary declaration or data definition.
	This is called as soon as the type information and variable name
	have been parsed, before parsing the initializer if any.
	Here we create the ..._DECL node, fill in its type,
	and put it on the list of decls for the current context.
	The ..._DECL node is returned as the value.

	Exception: for arrays where the length is not specified,
	the type is left null, to be filled in by `cp_finish_decl'.

	Function definitions do not come here; they go to start_function
	instead. However, external and forward declarations of functions
	do go through here. Structure field declarations are done by
	grokfield and not through here. */

	tree
	start_decl (const cp_declarator *declarator,
	cp_decl_specifier_seq *declspecs,
	int initialized,
	tree attributes,
	tree prefix_attributes,
	tree *pushed_scope_p)
	{
	tree decl;
	tree type, tem;
	tree context;
	+ /* APPLE LOCAL "unavailable" attribute (radar 2809697) */
	+ tree a;
	bool was_public;

	*pushed_scope_p = NULL_TREE;

	- /* An object declared as __attribute__((deprecated)) suppresses
	- warnings of uses of other deprecated items. */
	+ /* APPLE LOCAL begin "unavailable" attribute (radar 2809697) */
	+ /* An object declared as __attribute__((unavailable)) suppresses
	+ any reports of being declared with unavailable or deprecated
	+ items. An object declared as __attribute__((deprecated))
	+ suppresses warnings of uses of other deprecated items. */
	+#ifdef A_LESS_INEFFICENT_WAY /* which I really don't want to do! */
	if (lookup_attribute ("deprecated", attributes))
	deprecated_state = DEPRECATED_SUPPRESS;
	+ else if (lookup_attribute ("unavailable", attributes))
	+ deprecated_state = DEPRECATED_UNAVAILABLE_SUPPRESS;
	+#else /* a more efficient way doing what lookup_attribute would do */
	+ for (a = attributes; a; a = TREE_CHAIN (a))
	+ {
	+ tree name = TREE_PURPOSE (a);
	+ if (TREE_CODE (name) == IDENTIFIER_NODE)
	+ if (is_attribute_p ("deprecated", name))
	+ {
	+ deprecated_state = DEPRECATED_SUPPRESS;
	+ break;
	+ }
	+ if (is_attribute_p ("unavailable", name))
	+ {
	+ deprecated_state = DEPRECATED_UNAVAILABLE_SUPPRESS;
	+ break;
	+ }
	+ }
	+#endif
	+ /* APPLE LOCAL end "unavailable" attribute (radar 2809697) */

	attributes = chainon (attributes, prefix_attributes);

	decl = grokdeclarator (declarator, declspecs, NORMAL, initialized,
	&attributes);

	deprecated_state = DEPRECATED_NORMAL;

	if (decl == NULL_TREE \|\| TREE_CODE (decl) == VOID_TYPE
	\|\| decl == error_mark_node)
	return error_mark_node;

	type = TREE_TYPE (decl);

	context = DECL_CONTEXT (decl);

	if (context)
	{
	*pushed_scope_p = push_scope (context);

	/* We are only interested in class contexts, later. */
	if (TREE_CODE (context) == NAMESPACE_DECL)
	context = NULL_TREE;
	}

	if (initialized)
	/* Is it valid for this decl to have an initializer at all?
	If not, set INITIALIZED to zero, which will indirectly
	tell `cp_finish_decl' to ignore the initializer once it is parsed. */
	switch (TREE_CODE (decl))
	{
	case TYPE_DECL:
	error ("typedef %qD is initialized (use __typeof__ instead)", decl);
	return error_mark_node;

	case FUNCTION_DECL:
	error ("function %q#D is initialized like a variable", decl);
	return error_mark_node;

	default:
	break;
	}

	if (initialized)
	{
	if (! toplevel_bindings_p ()
	&& DECL_EXTERNAL (decl))
	warning (0, "declaration of %q#D has %<extern%> and is initialized",
	decl);
	DECL_EXTERNAL (decl) = 0;
	if (toplevel_bindings_p ())
	TREE_STATIC (decl) = 1;
	}

	/* Set attributes here so if duplicate decl, will have proper attributes. */
	cplus_decl_attributes (&decl, attributes, 0);

	/* Dllimported symbols cannot be defined. Static data members (which
	can be initialized in-class and dllimported) go through grokfield,
	not here, so we don't need to exclude those decls when checking for
	a definition. */
	if (initialized && DECL_DLLIMPORT_P (decl))
	{
	error ("definition of %q#D is marked %<dllimport%>", decl);
	DECL_DLLIMPORT_P (decl) = 0;
	}

	/* If #pragma weak was used, mark the decl weak now. */
	maybe_apply_pragma_weak (decl);

	if (TREE_CODE (decl) == FUNCTION_DECL
	&& DECL_DECLARED_INLINE_P (decl)
	&& DECL_UNINLINABLE (decl)
	&& lookup_attribute ("noinline", DECL_ATTRIBUTES (decl)))
	warning (0, "inline function %q+D given attribute noinline", decl);

	if (context && COMPLETE_TYPE_P (complete_type (context)))
	{
	if (TREE_CODE (decl) == VAR_DECL)
	{
	tree field = lookup_field (context, DECL_NAME (decl), 0, false);
	if (field == NULL_TREE \|\| TREE_CODE (field) != VAR_DECL)
	error ("%q#D is not a static member of %q#T", decl, context);
	else
	{
	if (DECL_CONTEXT (field) != context)
	{
	if (!same_type_p (DECL_CONTEXT (field), context))
	pedwarn ("ISO C++ does not permit %<%T::%D%> "
	"to be defined as %<%T::%D%>",
	DECL_CONTEXT (field), DECL_NAME (decl),
	context, DECL_NAME (decl));
	DECL_CONTEXT (decl) = DECL_CONTEXT (field);
	}
	if (processing_specialization
	&& template_class_depth (context) == 0
	&& CLASSTYPE_TEMPLATE_SPECIALIZATION (context))
	error ("template header not allowed in member definition "
	"of explicitly specialized class");
	/* Static data member are tricky; an in-class initialization
	still doesn't provide a definition, so the in-class
	declaration will have DECL_EXTERNAL set, but will have an
	initialization. Thus, duplicate_decls won't warn
	about this situation, and so we check here. */
	if (initialized && DECL_INITIALIZED_IN_CLASS_P (field))
	error ("duplicate initialization of %qD", decl);
	if (duplicate_decls (decl, field, /newdecl_is_friend=/false))
	decl = field;
	}
	}
	else
	{
	tree field = check_classfn (context, decl,
	(processing_template_decl
	> template_class_depth (context))
	? current_template_parms
	: NULL_TREE);
	if (field && duplicate_decls (decl, field,
	/newdecl_is_friend=/false))
	decl = field;
	}

	/* cp_finish_decl sets DECL_EXTERNAL if DECL_IN_AGGR_P is set. */
	DECL_IN_AGGR_P (decl) = 0;
	/* Do not mark DECL as an explicit specialization if it was not
	already marked as an instantiation; a declaration should
	never be marked as a specialization unless we know what
	template is being specialized. */
	if (DECL_LANG_SPECIFIC (decl) && DECL_USE_TEMPLATE (decl))
	{
	SET_DECL_TEMPLATE_SPECIALIZATION (decl);

	/* [temp.expl.spec] An explicit specialization of a static data
	member of a template is a definition if the declaration
	includes an initializer; otherwise, it is a declaration.

	We check for processing_specialization so this only applies
	to the new specialization syntax. */
	if (!initialized && processing_specialization)
	DECL_EXTERNAL (decl) = 1;
	}

	if (DECL_EXTERNAL (decl) && ! DECL_TEMPLATE_SPECIALIZATION (decl))
	pedwarn ("declaration of %q#D outside of class is not definition",
	decl);
	}

	was_public = TREE_PUBLIC (decl);

	/* Enter this declaration into the symbol table. */
	tem = maybe_push_decl (decl);

	if (processing_template_decl)
	tem = push_template_decl (tem);
	if (tem == error_mark_node)
	return error_mark_node;

	/* Tell the back-end to use or not use .common as appropriate. If we say
	-fconserve-space, we want this to save .data space, at the expense of
	wrong semantics. If we say -fno-conserve-space, we want this to
	produce errors about redefs; to do this we force variables into the
	data segment. */
	if (flag_conserve_space
	&& TREE_CODE (tem) == VAR_DECL
	&& TREE_PUBLIC (tem)
	&& !DECL_THREAD_LOCAL_P (tem)
	&& !have_global_bss_p ())
	DECL_COMMON (tem) = 1;

	if (TREE_CODE (tem) == VAR_DECL
	&& DECL_NAMESPACE_SCOPE_P (tem) && !TREE_PUBLIC (tem) && !was_public
	&& !DECL_THIS_STATIC (tem) && !DECL_ARTIFICIAL (tem))
	{
	/* This is a const variable with implicit 'static'. Set
	DECL_THIS_STATIC so we can tell it from variables that are
	!TREE_PUBLIC because of the anonymous namespace. */
	gcc_assert (cp_type_readonly (TREE_TYPE (tem)));
	DECL_THIS_STATIC (tem) = 1;
	}

	if (!processing_template_decl && TREE_CODE (tem) == VAR_DECL)
	start_decl_1 (tem, initialized);

	return tem;
	}

	void
	start_decl_1 (tree decl, bool initialized)
	{
	tree type;

	gcc_assert (!processing_template_decl);

	if (error_operand_p (decl))
	return;

	gcc_assert (TREE_CODE (decl) == VAR_DECL);
	type = TREE_TYPE (decl);

	if (initialized)
	/* Is it valid for this decl to have an initializer at all?
	If not, set INITIALIZED to zero, which will indirectly
	tell `cp_finish_decl' to ignore the initializer once it is parsed. */
	{
	/* Don't allow initializations for incomplete types except for
	arrays which might be completed by the initialization. */
	if (COMPLETE_TYPE_P (complete_type (type)))
	; /* A complete type is ok. */
	else if (TREE_CODE (type) != ARRAY_TYPE)
	{
	error ("variable %q#D has initializer but incomplete type", decl);
	initialized = 0;
	type = TREE_TYPE (decl) = error_mark_node;
	}
	else if (!COMPLETE_TYPE_P (complete_type (TREE_TYPE (type))))
	{
	if (DECL_LANG_SPECIFIC (decl) && DECL_TEMPLATE_INFO (decl))
	error ("elements of array %q#D have incomplete type", decl);
	/* else we already gave an error in start_decl. */
	initialized = 0;
	}
	}
	else if (IS_AGGR_TYPE (type)
	&& ! DECL_EXTERNAL (decl))
	{
	if (!COMPLETE_TYPE_P (complete_type (type)))
	{
	error ("aggregate %q#D has incomplete type and cannot be defined",
	decl);
	/* Change the type so that assemble_variable will give
	DECL an rtl we can live with: (mem (const_int 0)). */
	type = TREE_TYPE (decl) = error_mark_node;
	}
	else
	{
	/* If any base type in the hierarchy of TYPE needs a constructor,
	then we set initialized to 1. This way any nodes which are
	created for the purposes of initializing this aggregate
	will live as long as it does. This is necessary for global
	aggregates which do not have their initializers processed until
	the end of the file. */
	initialized = TYPE_NEEDS_CONSTRUCTING (type);
	}
	}

	/* Create a new scope to hold this declaration if necessary.
	Whether or not a new scope is necessary cannot be determined
	until after the type has been completed; if the type is a
	specialization of a class template it is not until after
	instantiation has occurred that TYPE_HAS_NONTRIVIAL_DESTRUCTOR
	will be set correctly. */
	maybe_push_cleanup_level (type);
	}

	/* Handle initialization of references. DECL, TYPE, and INIT have the
	same meaning as in cp_finish_decl. *CLEANUP must be NULL on entry,
	but will be set to a new CLEANUP_STMT if a temporary is created
	that must be destroyed subsequently.

	Returns an initializer expression to use to initialize DECL, or
	NULL if the initialization can be performed statically.

	Quotes on semantics can be found in ARM 8.4.3. */

	static tree
	grok_reference_init (tree decl, tree type, tree init, tree *cleanup)
	{
	tree tmp;

	if (init == NULL_TREE)
	{
	if ((DECL_LANG_SPECIFIC (decl) == 0
	\|\| DECL_IN_AGGR_P (decl) == 0)
	&& ! DECL_THIS_EXTERN (decl))
	error ("%qD declared as reference but not initialized", decl);
	return NULL_TREE;
	}

	if (TREE_CODE (init) == CONSTRUCTOR)
	{
	error ("ISO C++ forbids use of initializer list to "
	"initialize reference %qD", decl);
	return NULL_TREE;
	}

	if (TREE_CODE (init) == TREE_LIST)
	init = build_x_compound_expr_from_list (init, "initializer");

	if (TREE_CODE (TREE_TYPE (type)) != ARRAY_TYPE
	&& TREE_CODE (TREE_TYPE (init)) == ARRAY_TYPE)
	/* Note: default conversion is only called in very special cases. */
	init = decay_conversion (init);

	/* Convert INIT to the reference type TYPE. This may involve the
	creation of a temporary, whose lifetime must be the same as that
	of the reference. If so, a DECL_EXPR for the temporary will be
	added just after the DECL_EXPR for DECL. That's why we don't set
	DECL_INITIAL for local references (instead assigning to them
	explicitly); we need to allow the temporary to be initialized
	first. */
	tmp = initialize_reference (type, init, decl, cleanup);

	if (tmp == error_mark_node)
	return NULL_TREE;
	else if (tmp == NULL_TREE)
	{
	error ("cannot initialize %qT from %qT", type, TREE_TYPE (init));
	return NULL_TREE;
	}

	if (TREE_STATIC (decl) && !TREE_CONSTANT (tmp))
	return tmp;

	DECL_INITIAL (decl) = tmp;

	return NULL_TREE;
	}

	/* Designated initializers in arrays are not supported in GNU C++.
	The parser cannot detect this error since it does not know whether
	a given brace-enclosed initializer is for a class type or for an
	array. This function checks that CE does not use a designated
	initializer. If it does, an error is issued. Returns true if CE
	is valid, i.e., does not have a designated initializer. */

	static bool
	check_array_designated_initializer (const constructor_elt *ce)
	{
	/* Designated initializers for array elements arenot supported. */
	if (ce->index)
	{
	/* The parser only allows identifiers as designated
	intializers. */
	gcc_assert (TREE_CODE (ce->index) == IDENTIFIER_NODE);
	error ("name %qD used in a GNU-style designated "
	"initializer for an array", ce->index);
	return false;
	}

	return true;
	}

	/* When parsing `int a[] = {1, 2};' we don't know the size of the
	array until we finish parsing the initializer. If that's the
	situation we're in, update DECL accordingly. */

	static void
	maybe_deduce_size_from_array_init (tree decl, tree init)
	{
	tree type = TREE_TYPE (decl);

	if (TREE_CODE (type) == ARRAY_TYPE
	&& TYPE_DOMAIN (type) == NULL_TREE
	&& TREE_CODE (decl) != TYPE_DECL)
	{
	/* do_default is really a C-ism to deal with tentative definitions.
	But let's leave it here to ease the eventual merge. */
	int do_default = !DECL_EXTERNAL (decl);
	tree initializer = init ? init : DECL_INITIAL (decl);
	int failure = 0;

	/* Check that there are no designated initializers in INIT, as
	those are not supported in GNU C++, and as the middle-end
	will crash if presented with a non-numeric designated
	initializer. */
	if (initializer && TREE_CODE (initializer) == CONSTRUCTOR)
	{
	VEC(constructor_elt,gc) *v = CONSTRUCTOR_ELTS (initializer);
	constructor_elt *ce;
	HOST_WIDE_INT i;
	for (i = 0;
	VEC_iterate (constructor_elt, v, i, ce);
	++i)
	if (!check_array_designated_initializer (ce))
	failure = 1;
	}

	if (!failure)
	{
	failure = cp_complete_array_type (&TREE_TYPE (decl), initializer,
	do_default);
	if (failure == 1)
	{
	error ("initializer fails to determine size of %qD", decl);
	TREE_TYPE (decl) = error_mark_node;
	}
	else if (failure == 2)
	{
	if (do_default)
	{
	error ("array size missing in %qD", decl);
	TREE_TYPE (decl) = error_mark_node;
	}
	/* If a `static' var's size isn't known, make it extern as
	well as static, so it does not get allocated. If it's not
	`static', then don't mark it extern; finish_incomplete_decl
	will give it a default size and it will get allocated. */
	else if (!pedantic && TREE_STATIC (decl) && !TREE_PUBLIC (decl))
	DECL_EXTERNAL (decl) = 1;
	}
	else if (failure == 3)
	{
	error ("zero-size array %qD", decl);
	TREE_TYPE (decl) = error_mark_node;
	}
	}

	cp_apply_type_quals_to_decl (cp_type_quals (TREE_TYPE (decl)), decl);

	layout_decl (decl, 0);
	}
	}

	/* Set DECL_SIZE, DECL_ALIGN, etc. for DECL (a VAR_DECL), and issue
	any appropriate error messages regarding the layout. */

	static void
	layout_var_decl (tree decl)
	{
	tree type;

	type = TREE_TYPE (decl);
	if (type == error_mark_node)
	return;

	/* If we haven't already layed out this declaration, do so now.
	Note that we must not call complete type for an external object
	because it's type might involve templates that we are not
	supposed to instantiate yet. (And it's perfectly valid to say
	`extern X x' for some incomplete type `X'.) */
	if (!DECL_EXTERNAL (decl))
	complete_type (type);
	if (!DECL_SIZE (decl)
	&& TREE_TYPE (decl) != error_mark_node
	&& (COMPLETE_TYPE_P (type)
	\|\| (TREE_CODE (type) == ARRAY_TYPE
	&& !TYPE_DOMAIN (type)
	&& COMPLETE_TYPE_P (TREE_TYPE (type)))))
	layout_decl (decl, 0);

	if (!DECL_EXTERNAL (decl) && DECL_SIZE (decl) == NULL_TREE)
	{
	/* An automatic variable with an incomplete type: that is an error.
	Don't talk about array types here, since we took care of that
	message in grokdeclarator. */
	error ("storage size of %qD isn't known", decl);
	TREE_TYPE (decl) = error_mark_node;
	}
	#if 0
	/* Keep this code around in case we later want to control debug info
	based on whether a type is "used". (jason 1999-11-11) */

	else if (!DECL_EXTERNAL (decl) && IS_AGGR_TYPE (ttype))
	/* Let debugger know it should output info for this type. */
	note_debug_info_needed (ttype);

	if (TREE_STATIC (decl) && DECL_CLASS_SCOPE_P (decl))
	note_debug_info_needed (DECL_CONTEXT (decl));
	#endif

	if ((DECL_EXTERNAL (decl) \|\| TREE_STATIC (decl))
	&& DECL_SIZE (decl) != NULL_TREE
	&& ! TREE_CONSTANT (DECL_SIZE (decl)))
	{
	if (TREE_CODE (DECL_SIZE (decl)) == INTEGER_CST)
	constant_expression_warning (DECL_SIZE (decl));
	else
	error ("storage size of %qD isn't constant", decl);
	}
	}

	/* If a local static variable is declared in an inline function, or if
	we have a weak definition, we must endeavor to create only one
	instance of the variable at link-time. */

	static void
	maybe_commonize_var (tree decl)
	{
	/* Static data in a function with comdat linkage also has comdat
	linkage. */
	if (TREE_STATIC (decl)
	/* Don't mess with __FUNCTION__. */
	&& ! DECL_ARTIFICIAL (decl)
	&& DECL_FUNCTION_SCOPE_P (decl)
	/* Unfortunately, import_export_decl has not always been called
	before the function is processed, so we cannot simply check
	DECL_COMDAT. */
	&& (DECL_COMDAT (DECL_CONTEXT (decl))
	\|\| ((DECL_DECLARED_INLINE_P (DECL_CONTEXT (decl))
	\|\| DECL_TEMPLATE_INSTANTIATION (DECL_CONTEXT (decl)))
	&& TREE_PUBLIC (DECL_CONTEXT (decl)))))
	{
	if (flag_weak)
	{
	/* With weak symbols, we simply make the variable COMDAT;
	that will cause copies in multiple translations units to
	be merged. */
	comdat_linkage (decl);
	}
	else
	{
	if (DECL_INITIAL (decl) == NULL_TREE
	\|\| DECL_INITIAL (decl) == error_mark_node)
	{
	/* Without weak symbols, we can use COMMON to merge
	uninitialized variables. */
	TREE_PUBLIC (decl) = 1;
	DECL_COMMON (decl) = 1;
	}
	else
	{
	/* While for initialized variables, we must use internal
	linkage -- which means that multiple copies will not
	be merged. */
	TREE_PUBLIC (decl) = 0;
	DECL_COMMON (decl) = 0;
	warning (0, "sorry: semantics of inline function static "
	"data %q+#D are wrong (you'll wind up "
	"with multiple copies)", decl);
	warning (0, "%J you can work around this by removing "
	"the initializer",
	decl);
	}
	}
	}
	else if (DECL_LANG_SPECIFIC (decl) && DECL_COMDAT (decl))
	/* Set it up again; we might have set DECL_INITIAL since the last
	time. */
	comdat_linkage (decl);
	}

	/* Issue an error message if DECL is an uninitialized const variable. */

	static void
	check_for_uninitialized_const_var (tree decl)
	{
	tree type = TREE_TYPE (decl);

	/* ``Unless explicitly declared extern, a const object does not have
	external linkage and must be initialized. ($8.4; $12.1)'' ARM
	7.1.6 */
	if (TREE_CODE (decl) == VAR_DECL
	&& TREE_CODE (type) != REFERENCE_TYPE
	&& CP_TYPE_CONST_P (type)
	&& !TYPE_NEEDS_CONSTRUCTING (type)
	&& !DECL_INITIAL (decl))
	error ("uninitialized const %qD", decl);
	}


	/* Structure holding the current initializer being processed by reshape_init.
	CUR is a pointer to the current element being processed, END is a pointer
	after the last element present in the initializer. */
	typedef struct reshape_iterator_t
	{
	constructor_elt *cur;
	constructor_elt *end;
	} reshape_iter;

	static tree reshape_init_r (tree, reshape_iter *, bool);

	/* FIELD is a FIELD_DECL or NULL. In the former case, the value
	returned is the next FIELD_DECL (possibly FIELD itself) that can be
	initialized. If there are no more such fields, the return value
	will be NULL. */

	static tree
	next_initializable_field (tree field)
	{
	while (field
	&& (TREE_CODE (field) != FIELD_DECL
	\|\| (DECL_C_BIT_FIELD (field) && !DECL_NAME (field))
	\|\| DECL_ARTIFICIAL (field)))
	field = TREE_CHAIN (field);

	return field;
	}

	/* Subroutine of reshape_init_array and reshape_init_vector, which does
	the actual work. ELT_TYPE is the element type of the array. MAX_INDEX is an
	INTEGER_CST representing the size of the array minus one (the maximum index),
	or NULL_TREE if the array was declared without specifying the size. D is
	the iterator within the constructor. */

	static tree
	reshape_init_array_1 (tree elt_type, tree max_index, reshape_iter *d)
	{
	tree new_init;
	bool sized_array_p = (max_index != NULL_TREE);
	unsigned HOST_WIDE_INT max_index_cst = 0;
	unsigned HOST_WIDE_INT index;

	/* The initializer for an array is always a CONSTRUCTOR. */
	new_init = build_constructor (NULL_TREE, NULL);

	if (sized_array_p)
	{
	/* Minus 1 is used for zero sized arrays. */
	if (integer_all_onesp (max_index))
	return new_init;

	if (host_integerp (max_index, 1))
	max_index_cst = tree_low_cst (max_index, 1);
	/* sizetype is sign extended, not zero extended. */
	else
	max_index_cst = tree_low_cst (fold_convert (size_type_node, max_index),
	1);
	}

	/* Loop until there are no more initializers. */
	for (index = 0;
	d->cur != d->end && (!sized_array_p \|\| index <= max_index_cst);
	++index)
	{
	tree elt_init;

	check_array_designated_initializer (d->cur);
	elt_init = reshape_init_r (elt_type, d, /first_initializer_p=/false);
	if (elt_init == error_mark_node)
	return error_mark_node;
	CONSTRUCTOR_APPEND_ELT (CONSTRUCTOR_ELTS (new_init), NULL_TREE, elt_init);
	}

	return new_init;
	}

	/* Subroutine of reshape_init_r, processes the initializers for arrays.
	Parameters are the same of reshape_init_r. */

	static tree
	reshape_init_array (tree type, reshape_iter *d)
	{
	tree max_index = NULL_TREE;

	gcc_assert (TREE_CODE (type) == ARRAY_TYPE);

	if (TYPE_DOMAIN (type))
	max_index = array_type_nelts (type);

	return reshape_init_array_1 (TREE_TYPE (type), max_index, d);
	}

	/* Subroutine of reshape_init_r, processes the initializers for vectors.
	Parameters are the same of reshape_init_r. */

	static tree
	reshape_init_vector (tree type, reshape_iter *d)
	{
	tree max_index = NULL_TREE;
	tree rtype;

	gcc_assert (TREE_CODE (type) == VECTOR_TYPE);

	if (COMPOUND_LITERAL_P (d->cur->value))
	{
	tree value = d->cur->value;
	if (!same_type_p (TREE_TYPE (value), type))
	{
	error ("invalid type %qT as initializer for a vector of type %qT",
	TREE_TYPE (d->cur->value), type);
	value = error_mark_node;
	}
	++d->cur;
	return value;
	}

	/* For a vector, the representation type is a struct
	containing a single member which is an array of the
	appropriate size. */
	rtype = TYPE_DEBUG_REPRESENTATION_TYPE (type);
	if (rtype && TYPE_DOMAIN (TREE_TYPE (TYPE_FIELDS (rtype))))
	max_index = array_type_nelts (TREE_TYPE (TYPE_FIELDS (rtype)));

	return reshape_init_array_1 (TREE_TYPE (type), max_index, d);
	}

	/* Subroutine of reshape_init_r, processes the initializers for classes
	or union. Parameters are the same of reshape_init_r. */

	static tree
	reshape_init_class (tree type, reshape_iter *d, bool first_initializer_p)
	{
	tree field;
	tree new_init;

	gcc_assert (CLASS_TYPE_P (type));

	/* The initializer for a class is always a CONSTRUCTOR. */
	new_init = build_constructor (NULL_TREE, NULL);
	field = next_initializable_field (TYPE_FIELDS (type));

	if (!field)
	{
	/* [dcl.init.aggr]

	An initializer for an aggregate member that is an
	empty class shall have the form of an empty
	initializer-list {}. */
	if (!first_initializer_p)
	{
	error ("initializer for %qT must be brace-enclosed", type);
	return error_mark_node;
	}
	return new_init;
	}

	/* Loop through the initializable fields, gathering initializers. */
	while (d->cur != d->end)
	{
	tree field_init;

	/* Handle designated initializers, as an extension. */
	if (d->cur->index)
	{
	field = lookup_field_1 (type, d->cur->index, /want_type=/false);

	if (!field \|\| TREE_CODE (field) != FIELD_DECL)
	{
	error ("%qT has no non-static data member named %qD", type,
	d->cur->index);
	return error_mark_node;
	}
	}

	/* If we processed all the member of the class, we are done. */
	if (!field)
	break;

	field_init = reshape_init_r (TREE_TYPE (field), d,
	/first_initializer_p=/false);
	CONSTRUCTOR_APPEND_ELT (CONSTRUCTOR_ELTS (new_init), field, field_init);

	/* [dcl.init.aggr]

	When a union is initialized with a brace-enclosed
	initializer, the braces shall only contain an
	initializer for the first member of the union. */
	if (TREE_CODE (type) == UNION_TYPE)
	break;

	field = next_initializable_field (TREE_CHAIN (field));
	}

	return new_init;
	}

	/* Subroutine of reshape_init, which processes a single initializer (part of
	a CONSTRUCTOR). TYPE is the type of the variable being initialized, D is the
	iterator within the CONSTRUCTOR which points to the initializer to process.
	FIRST_INITIALIZER_P is true if this is the first initializer of the
	CONSTRUCTOR node. */

	static tree
	reshape_init_r (tree type, reshape_iter *d, bool first_initializer_p)
	{
	tree init = d->cur->value;

	/* A non-aggregate type is always initialized with a single
	initializer. */
	if (!CP_AGGREGATE_TYPE_P (type))
	{
	/* It is invalid to initialize a non-aggregate type with a
	brace-enclosed initializer.
	We need to check for BRACE_ENCLOSED_INITIALIZER_P here because
	of g++.old-deja/g++.mike/p7626.C: a pointer-to-member constant is
	a CONSTRUCTOR (with a record type). */
	if (TREE_CODE (init) == CONSTRUCTOR
	&& BRACE_ENCLOSED_INITIALIZER_P (init)) /* p7626.C */
	{
	error ("braces around scalar initializer for type %qT", type);
	init = error_mark_node;
	}

	d->cur++;
	return init;
	}

	/* [dcl.init.aggr]

	All implicit type conversions (clause _conv_) are considered when
	initializing the aggregate member with an initializer from an
	initializer-list. If the initializer can initialize a member,
	the member is initialized. Otherwise, if the member is itself a
	non-empty subaggregate, brace elision is assumed and the
	initializer is considered for the initialization of the first
	member of the subaggregate. */
	if (TREE_CODE (init) != CONSTRUCTOR
	&& can_convert_arg (type, TREE_TYPE (init), init, LOOKUP_NORMAL))
	{
	d->cur++;
	return init;
	}

	/* [dcl.init.string]

	A char array (whether plain char, signed char, or unsigned char)
	can be initialized by a string-literal (optionally enclosed in
	braces); a wchar_t array can be initialized by a wide
	string-literal (optionally enclosed in braces). */
	if (TREE_CODE (type) == ARRAY_TYPE
	&& char_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (type))))
	{
	tree str_init = init;

	/* Strip one level of braces if and only if they enclose a single
	element (as allowed by [dcl.init.string]). */
	if (!first_initializer_p
	&& TREE_CODE (str_init) == CONSTRUCTOR
	&& VEC_length (constructor_elt, CONSTRUCTOR_ELTS (str_init)) == 1)
	{
	str_init = VEC_index (constructor_elt,
	CONSTRUCTOR_ELTS (str_init), 0)->value;
	}

	/* If it's a string literal, then it's the initializer for the array
	as a whole. Otherwise, continue with normal initialization for
	array types (one value per array element). */
	if (TREE_CODE (str_init) == STRING_CST)
	{
	d->cur++;
	return str_init;
	}
	}

	/* The following cases are about aggregates. If we are not within a full
	initializer already, and there is not a CONSTRUCTOR, it means that there
	is a missing set of braces (that is, we are processing the case for
	which reshape_init exists). */
	if (!first_initializer_p)
	{
	if (TREE_CODE (init) == CONSTRUCTOR)
	{
	if (TREE_TYPE (init) && TYPE_PTRMEMFUNC_P (TREE_TYPE (init)))
	/* There is no need to reshape pointer-to-member function
	initializers, as they are always constructed correctly
	by the front end. */
	;
	else if (COMPOUND_LITERAL_P (init))
	/* For a nested compound literal, there is no need to reshape since
	brace elision is not allowed. Even if we decided to allow it,
	we should add a call to reshape_init in finish_compound_literal,
	before calling digest_init, so changing this code would still
	not be necessary. */
	gcc_assert (!BRACE_ENCLOSED_INITIALIZER_P (init));
	else
	{
	++d->cur;
	gcc_assert (BRACE_ENCLOSED_INITIALIZER_P (init));
	return reshape_init (type, init);
	}
	}

	warning (OPT_Wmissing_braces, "missing braces around initializer for %qT",
	type);
	}

	/* Dispatch to specialized routines. */
	if (CLASS_TYPE_P (type))
	return reshape_init_class (type, d, first_initializer_p);
	else if (TREE_CODE (type) == ARRAY_TYPE)
	return reshape_init_array (type, d);
	else if (TREE_CODE (type) == VECTOR_TYPE)
	return reshape_init_vector (type, d);
	else
	gcc_unreachable();
	}

	/* Undo the brace-elision allowed by [dcl.init.aggr] in a
	brace-enclosed aggregate initializer.

	INIT is the CONSTRUCTOR containing the list of initializers describing
	a brace-enclosed initializer for an entity of the indicated aggregate TYPE.
	It may not presently match the shape of the TYPE; for example:

	struct S { int a; int b; };
	struct S a[] = { 1, 2, 3, 4 };

	Here INIT will hold a VEC of four elements, rather than a
	VEC of two elements, each itself a VEC of two elements. This
	routine transforms INIT from the former form into the latter. The
	revised CONSTRUCTOR node is returned. */

	tree
	reshape_init (tree type, tree init)
	{
	VEC(constructor_elt, gc) *v;
	reshape_iter d;
	tree new_init;

	gcc_assert (BRACE_ENCLOSED_INITIALIZER_P (init));

	v = CONSTRUCTOR_ELTS (init);

	/* An empty constructor does not need reshaping, and it is always a valid
	initializer. */
	if (VEC_empty (constructor_elt, v))
	return init;

	/* Recurse on this CONSTRUCTOR. */
	d.cur = VEC_index (constructor_elt, v, 0);
	d.end = d.cur + VEC_length (constructor_elt, v);

	new_init = reshape_init_r (type, &d, true);
	if (new_init == error_mark_node)
	return error_mark_node;

	/* Make sure all the element of the constructor were used. Otherwise,
	issue an error about exceeding initializers. */
	if (d.cur != d.end)
	error ("too many initializers for %qT", type);

	return new_init;
	}

	/* Verify INIT (the initializer for DECL), and record the
	initialization in DECL_INITIAL, if appropriate. CLEANUP is as for
	grok_reference_init.

	If the return value is non-NULL, it is an expression that must be
	evaluated dynamically to initialize DECL. */

	static tree
	check_initializer (tree decl, tree init, int flags, tree *cleanup)
	{
	tree type = TREE_TYPE (decl);
	tree init_code = NULL;

	/* Things that are going to be initialized need to have complete
	type. */
	TREE_TYPE (decl) = type = complete_type (TREE_TYPE (decl));

	if (type == error_mark_node)
	/* We will have already complained. */
	return NULL_TREE;

	if (TREE_CODE (type) == ARRAY_TYPE)
	{
	tree element_type = TREE_TYPE (type);

	/* The array type itself need not be complete, because the
	initializer may tell us how many elements are in the array.
	But, the elements of the array must be complete. */
	if (!COMPLETE_TYPE_P (complete_type (element_type)))
	{
	error ("elements of array %q#D have incomplete type", decl);
	return NULL_TREE;
	}
	/* It is not valid to initialize an a VLA. */
	if (init
	&& ((COMPLETE_TYPE_P (type) && !TREE_CONSTANT (TYPE_SIZE (type)))
	\|\| !TREE_CONSTANT (TYPE_SIZE (element_type))))
	{
	error ("variable-sized object %qD may not be initialized", decl);
	return NULL_TREE;
	}
	}
	else if (!COMPLETE_TYPE_P (type))
	{
	error ("%qD has incomplete type", decl);
	TREE_TYPE (decl) = error_mark_node;
	return NULL_TREE;
	}
	else
	/* There is no way to make a variable-sized class type in GNU C++. */
	gcc_assert (TREE_CONSTANT (TYPE_SIZE (type)));

	if (!CP_AGGREGATE_TYPE_P (type)
	&& init && BRACE_ENCLOSED_INITIALIZER_P (init)
	&& VEC_length (constructor_elt, CONSTRUCTOR_ELTS (init)) != 1)
	{
	error ("scalar object %qD requires one element in initializer", decl);
	TREE_TYPE (decl) = error_mark_node;
	return NULL_TREE;
	}

	if (TREE_CODE (decl) == CONST_DECL)
	{
	gcc_assert (TREE_CODE (type) != REFERENCE_TYPE);

	DECL_INITIAL (decl) = init;

	gcc_assert (init != NULL_TREE);
	init = NULL_TREE;
	}
	else if (!DECL_EXTERNAL (decl) && TREE_CODE (type) == REFERENCE_TYPE)
	init = grok_reference_init (decl, type, init, cleanup);
	else if (init)
	{
	/* Do not reshape constructors of vectors (they don't need to be
	reshaped. */
	if (TREE_CODE (init) == CONSTRUCTOR
	&& !COMPOUND_LITERAL_P (init)
	&& !TREE_TYPE (init)) /* ptrmemfunc */
	{
	init = reshape_init (type, init);

	if ((*targetm.vector_opaque_p) (type))
	{
	error ("opaque vector types cannot be initialized");
	init = error_mark_node;
	}
	}

	/* If DECL has an array type without a specific bound, deduce the
	array size from the initializer. */
	maybe_deduce_size_from_array_init (decl, init);
	type = TREE_TYPE (decl);
	if (type == error_mark_node)
	return NULL_TREE;

	if (TYPE_HAS_CONSTRUCTOR (type) \|\| TYPE_NEEDS_CONSTRUCTING (type))
	{
	if (TREE_CODE (type) == ARRAY_TYPE)
	goto initialize_aggr;
	else if (TREE_CODE (init) == CONSTRUCTOR)
	{
	if (TYPE_NON_AGGREGATE_CLASS (type))
	{
	error ("%qD must be initialized by constructor, "
	"not by %<{...}%>",
	decl);
	init = error_mark_node;
	}
	else
	goto dont_use_constructor;
	}
	else
	{
	int saved_stmts_are_full_exprs_p;

	initialize_aggr:
	saved_stmts_are_full_exprs_p = 0;
	if (building_stmt_tree ())
	{
	saved_stmts_are_full_exprs_p = stmts_are_full_exprs_p ();
	current_stmt_tree ()->stmts_are_full_exprs_p = 1;
	}
	init = build_aggr_init (decl, init, flags);
	if (building_stmt_tree ())
	current_stmt_tree ()->stmts_are_full_exprs_p =
	saved_stmts_are_full_exprs_p;
	return init;
	}
	}
	else
	{
	dont_use_constructor:
	if (TREE_CODE (init) != TREE_VEC)
	{
	init_code = store_init_value (decl, init);
	if (pedantic && TREE_CODE (type) == ARRAY_TYPE
	&& DECL_INITIAL (decl)
	&& TREE_CODE (DECL_INITIAL (decl)) == STRING_CST
	&& PAREN_STRING_LITERAL_P (DECL_INITIAL (decl)))
	warning (0, "array %qD initialized by parenthesized string literal %qE",
	decl, DECL_INITIAL (decl));
	init = NULL;
	}
	}
	}
	else if (DECL_EXTERNAL (decl))
	;
	else if (TYPE_P (type) && TYPE_NEEDS_CONSTRUCTING (type))
	goto initialize_aggr;
	else if (IS_AGGR_TYPE (type))
	{
	tree core_type = strip_array_types (type);

	if (CLASSTYPE_READONLY_FIELDS_NEED_INIT (core_type))
	error ("structure %qD with uninitialized const members", decl);
	if (CLASSTYPE_REF_FIELDS_NEED_INIT (core_type))
	error ("structure %qD with uninitialized reference members", decl);

	check_for_uninitialized_const_var (decl);
	}
	else
	check_for_uninitialized_const_var (decl);

	if (init && init != error_mark_node)
	init_code = build2 (INIT_EXPR, type, decl, init);

	return init_code;
	}

	/* If DECL is not a local variable, give it RTL. */

	static void
	make_rtl_for_nonlocal_decl (tree decl, tree init, const char* asmspec)
	{
	int toplev = toplevel_bindings_p ();
	int defer_p;
	const char *filename;

	/* Set the DECL_ASSEMBLER_NAME for the object. */
	if (asmspec)
	{
	/* The `register' keyword, when used together with an
	asm-specification, indicates that the variable should be
	placed in a particular register. */
	if (TREE_CODE (decl) == VAR_DECL && DECL_REGISTER (decl))
	{
	set_user_assembler_name (decl, asmspec);
	DECL_HARD_REGISTER (decl) = 1;
	}
	else
	{
	if (TREE_CODE (decl) == FUNCTION_DECL
	&& DECL_BUILT_IN_CLASS (decl) == BUILT_IN_NORMAL)
	set_builtin_user_assembler_name (decl, asmspec);
	set_user_assembler_name (decl, asmspec);
	}
	}

	/* Handle non-variables up front. */
	if (TREE_CODE (decl) != VAR_DECL)
	{
	rest_of_decl_compilation (decl, toplev, at_eof);
	return;
	}

	/* If we see a class member here, it should be a static data
	member. */
	if (DECL_LANG_SPECIFIC (decl) && DECL_IN_AGGR_P (decl))
	{
	gcc_assert (TREE_STATIC (decl));
	/* An in-class declaration of a static data member should be
	external; it is only a declaration, and not a definition. */
	if (init == NULL_TREE && DECL_INITIAL (decl) == NULL_TREE)
	gcc_assert (DECL_EXTERNAL (decl));
	}

	/* We don't create any RTL for local variables. */
	if (DECL_FUNCTION_SCOPE_P (decl) && !TREE_STATIC (decl))
	return;

	/* We defer emission of local statics until the corresponding
	DECL_EXPR is expanded. */
	defer_p = DECL_FUNCTION_SCOPE_P (decl) \|\| DECL_VIRTUAL_P (decl);

	/* We try to defer namespace-scope static constants so that they are
	not emitted into the object file unnecessarily. */
	filename = input_filename;
	if (!DECL_VIRTUAL_P (decl)
	&& TREE_READONLY (decl)
	&& DECL_INITIAL (decl) != NULL_TREE
	&& DECL_INITIAL (decl) != error_mark_node
	&& filename != NULL
	&& ! EMPTY_CONSTRUCTOR_P (DECL_INITIAL (decl))
	&& toplev
	&& !TREE_PUBLIC (decl))
	{
	/* Fool with the linkage of static consts according to #pragma
	interface. */
	struct c_fileinfo *finfo = get_fileinfo (filename);
	if (!finfo->interface_unknown && !TREE_PUBLIC (decl))
	{
	TREE_PUBLIC (decl) = 1;
	DECL_EXTERNAL (decl) = finfo->interface_only;
	}

	defer_p = 1;
	}
	/* Likewise for template instantiations. */
	else if (DECL_LANG_SPECIFIC (decl)
	&& DECL_IMPLICIT_INSTANTIATION (decl))
	defer_p = 1;

	/* If we're not deferring, go ahead and assemble the variable. */
	if (!defer_p)
	rest_of_decl_compilation (decl, toplev, at_eof);
	}

	/* Generate code to initialize DECL (a local variable). */

	static void
	initialize_local_var (tree decl, tree init)
	{
	tree type = TREE_TYPE (decl);
	tree cleanup;

	gcc_assert (TREE_CODE (decl) == VAR_DECL
	\|\| TREE_CODE (decl) == RESULT_DECL);
	gcc_assert (!TREE_STATIC (decl));

	if (DECL_SIZE (decl) == NULL_TREE)
	{
	/* If we used it already as memory, it must stay in memory. */
	DECL_INITIAL (decl) = NULL_TREE;
	TREE_ADDRESSABLE (decl) = TREE_USED (decl);
	}

	if (DECL_SIZE (decl) && type != error_mark_node)
	{
	int already_used;

	/* Compute and store the initial value. */
	already_used = TREE_USED (decl) \|\| TREE_USED (type);

	/* Perform the initialization. */
	if (init)
	{
	int saved_stmts_are_full_exprs_p;

	gcc_assert (building_stmt_tree ());
	saved_stmts_are_full_exprs_p = stmts_are_full_exprs_p ();
	current_stmt_tree ()->stmts_are_full_exprs_p = 1;
	finish_expr_stmt (init);
	current_stmt_tree ()->stmts_are_full_exprs_p =
	saved_stmts_are_full_exprs_p;
	}

	/* Set this to 0 so we can tell whether an aggregate which was
	initialized was ever used. Don't do this if it has a
	destructor, so we don't complain about the 'resource
	allocation is initialization' idiom. Now set
	attribute((unused)) on types so decls of that type will be
	marked used. (see TREE_USED, above.) */
	if (TYPE_NEEDS_CONSTRUCTING (type)
	&& ! already_used
	&& TYPE_HAS_TRIVIAL_DESTRUCTOR (type)
	&& DECL_NAME (decl))
	TREE_USED (decl) = 0;
	else if (already_used)
	TREE_USED (decl) = 1;
	}

	/* Generate a cleanup, if necessary. */
	cleanup = cxx_maybe_build_cleanup (decl);
	if (DECL_SIZE (decl) && cleanup)
	finish_decl_cleanup (decl, cleanup);
	}

	/* DECL is a VAR_DECL for a compiler-generated variable with static
	storage duration (like a virtual table) whose initializer is a
	compile-time constant. INIT must be either a TREE_LIST of values,
	or a CONSTRUCTOR. Initialize the variable and provide it to the
	back end. */

	void
	initialize_artificial_var (tree decl, tree init)
	{
	gcc_assert (DECL_ARTIFICIAL (decl));
	if (TREE_CODE (init) == TREE_LIST)
	init = build_constructor_from_list (NULL_TREE, init);
	gcc_assert (TREE_CODE (init) == CONSTRUCTOR);
	DECL_INITIAL (decl) = init;
	DECL_INITIALIZED_P (decl) = 1;
	determine_visibility (decl);
	layout_var_decl (decl);
	maybe_commonize_var (decl);
	make_rtl_for_nonlocal_decl (decl, init, /asmspec=/NULL);
	}

	/* INIT is the initializer for a variable, as represented by the
	parser. Returns true iff INIT is value-dependent. */

	static bool
	value_dependent_init_p (tree init)
	{
	if (TREE_CODE (init) == TREE_LIST)
	/* A parenthesized initializer, e.g.: int i (3, 2); ? */
	return any_value_dependent_elements_p (init);
	else if (TREE_CODE (init) == CONSTRUCTOR)
	/* A brace-enclosed initializer, e.g.: int i = { 3 }; ? */
	{
	VEC(constructor_elt, gc) *elts;
	size_t nelts;
	size_t i;

	elts = CONSTRUCTOR_ELTS (init);
	nelts = VEC_length (constructor_elt, elts);
	for (i = 0; i < nelts; ++i)
	if (value_dependent_init_p (VEC_index (constructor_elt,
	elts, i)->value))
	return true;
	}
	else
	/* It must be a simple expression, e.g., int i = 3; */
	return value_dependent_expression_p (init);

	return false;
	}

	/* Finish processing of a declaration;
	install its line number and initial value.
	If the length of an array type is not known before,
	it must be determined now, from the initial value, or it is an error.

	INIT is the initializer (if any) for DECL. If INIT_CONST_EXPR_P is
	true, then INIT is an integral constant expression.

	FLAGS is LOOKUP_ONLYCONVERTING if the = init syntax was used, else 0
	if the (init) syntax was used. */

	void
	cp_finish_decl (tree decl, tree init, bool init_const_expr_p,
	tree asmspec_tree, int flags)
	{
	tree type;
	tree cleanup;
	const char *asmspec = NULL;
	int was_readonly = 0;
	bool var_definition_p = false;
	int saved_processing_template_decl;

	if (decl == error_mark_node)
	return;
	else if (! decl)
	{
	if (init)
	error ("assignment (not initialization) in declaration");
	return;
	}

	gcc_assert (TREE_CODE (decl) != RESULT_DECL);
	/* Parameters are handled by store_parm_decls, not cp_finish_decl. */
	gcc_assert (TREE_CODE (decl) != PARM_DECL);

	type = TREE_TYPE (decl);
	if (type == error_mark_node)
	return;

	/* Assume no cleanup is required. */
	cleanup = NULL_TREE;
	saved_processing_template_decl = processing_template_decl;

	/* If a name was specified, get the string. */
	if (global_scope_p (current_binding_level))
	asmspec_tree = maybe_apply_renaming_pragma (decl, asmspec_tree);
	if (asmspec_tree && asmspec_tree != error_mark_node)
	asmspec = TREE_STRING_POINTER (asmspec_tree);

	if (current_class_type
	&& CP_DECL_CONTEXT (decl) == current_class_type
	&& TYPE_BEING_DEFINED (current_class_type)
	&& (DECL_INITIAL (decl) \|\| init))
	DECL_INITIALIZED_IN_CLASS_P (decl) = 1;

	if (processing_template_decl)
	{
	bool type_dependent_p;

	/* Add this declaration to the statement-tree. */
	if (at_function_scope_p ())
	add_decl_expr (decl);

	type_dependent_p = dependent_type_p (type);

	if (init && init_const_expr_p)
	{
	DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (decl) = 1;
	if (DECL_INTEGRAL_CONSTANT_VAR_P (decl))
	TREE_CONSTANT (decl) = 1;
	}

	/* Generally, initializers in templates are expanded when the
	template is instantiated. But, if DECL is an integral
	constant static data member, then it can be used in future
	integral constant expressions, and its value must be
	available. */
	if (!(init
	&& DECL_CLASS_SCOPE_P (decl)
	&& DECL_INTEGRAL_CONSTANT_VAR_P (decl)
	&& !type_dependent_p
	&& !value_dependent_init_p (init)))
	{
	if (init)
	DECL_INITIAL (decl) = init;
	if (TREE_CODE (decl) == VAR_DECL
	&& !DECL_PRETTY_FUNCTION_P (decl)
	&& !type_dependent_p)
	maybe_deduce_size_from_array_init (decl, init);
	goto finish_end;
	}

	init = fold_non_dependent_expr (init);
	processing_template_decl = 0;
	}

	/* Take care of TYPE_DECLs up front. */
	if (TREE_CODE (decl) == TYPE_DECL)
	{
	if (type != error_mark_node
	&& IS_AGGR_TYPE (type) && DECL_NAME (decl))
	{
	if (TREE_TYPE (DECL_NAME (decl)) && TREE_TYPE (decl) != type)
	warning (0, "shadowing previous type declaration of %q#D", decl);
	set_identifier_type_value (DECL_NAME (decl), decl);
	}

	/* If we have installed this as the canonical typedef for this
	type, and that type has not been defined yet, delay emitting
	the debug information for it, as we will emit it later. */
	if (TYPE_MAIN_DECL (TREE_TYPE (decl)) == decl
	&& !COMPLETE_TYPE_P (TREE_TYPE (decl)))
	TYPE_DECL_SUPPRESS_DEBUG (decl) = 1;

	rest_of_decl_compilation (decl, DECL_CONTEXT (decl) == NULL_TREE,
	at_eof);
	goto finish_end;
	}

	/* A reference will be modified here, as it is initialized. */
	if (! DECL_EXTERNAL (decl)
	&& TREE_READONLY (decl)
	&& TREE_CODE (type) == REFERENCE_TYPE)
	{
	was_readonly = 1;
	TREE_READONLY (decl) = 0;
	}

	if (TREE_CODE (decl) == VAR_DECL)
	{
	/* Only PODs can have thread-local storage. Other types may require
	various kinds of non-trivial initialization. */
	if (DECL_THREAD_LOCAL_P (decl) && !pod_type_p (TREE_TYPE (decl)))
	error ("%qD cannot be thread-local because it has non-POD type %qT",
	decl, TREE_TYPE (decl));
	/* If this is a local variable that will need a mangled name,
	register it now. We must do this before processing the
	initializer for the variable, since the initialization might
	require a guard variable, and since the mangled name of the
	guard variable will depend on the mangled name of this
	variable. */
	if (!processing_template_decl
	&& DECL_FUNCTION_SCOPE_P (decl)
	&& TREE_STATIC (decl)
	&& !DECL_ARTIFICIAL (decl))
	push_local_name (decl);
	/* Convert the initializer to the type of DECL, if we have not
	already initialized DECL. */
	if (!DECL_INITIALIZED_P (decl)
	/* If !DECL_EXTERNAL then DECL is being defined. In the
	case of a static data member initialized inside the
	class-specifier, there can be an initializer even if DECL
	is not defined. */
	&& (!DECL_EXTERNAL (decl) \|\| init))
	{
	if (init)
	{
	DECL_NONTRIVIALLY_INITIALIZED_P (decl) = 1;
	if (init_const_expr_p)
	{
	DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (decl) = 1;
	if (DECL_INTEGRAL_CONSTANT_VAR_P (decl))
	TREE_CONSTANT (decl) = 1;
	}
	}
	init = check_initializer (decl, init, flags, &cleanup);
	/* Thread-local storage cannot be dynamically initialized. */
	if (DECL_THREAD_LOCAL_P (decl) && init)
	{
	error ("%qD is thread-local and so cannot be dynamically "
	"initialized", decl);
	init = NULL_TREE;
	}

	/* Check that the initializer for a static data member was a
	constant. Although we check in the parser that the
	initializer is an integral constant expression, we do not
	simplify division-by-zero at the point at which it
	occurs. Therefore, in:

	struct S { static const int i = 7 / 0; };

	we issue an error at this point. It would
	probably be better to forbid division by zero in
	integral constant expressions. */
	if (DECL_EXTERNAL (decl) && init)
	{
	error ("%qD cannot be initialized by a non-constant expression"
	" when being declared", decl);
	DECL_INITIALIZED_IN_CLASS_P (decl) = 0;
	init = NULL_TREE;
	}

	/* Handle:

	[dcl.init]

	The memory occupied by any object of static storage
	duration is zero-initialized at program startup before
	any other initialization takes place.

	We cannot create an appropriate initializer until after
	the type of DECL is finalized. If DECL_INITIAL is set,
	then the DECL is statically initialized, and any
	necessary zero-initialization has already been performed. */
	if (TREE_STATIC (decl) && !DECL_INITIAL (decl))
	DECL_INITIAL (decl) = build_zero_init (TREE_TYPE (decl),
	/nelts=/NULL_TREE,
	/static_storage_p=/true);
	/* Remember that the initialization for this variable has
	taken place. */
	DECL_INITIALIZED_P (decl) = 1;
	/* This declaration is the definition of this variable,
	unless we are initializing a static data member within
	the class specifier. */
	if (!DECL_EXTERNAL (decl))
	var_definition_p = true;
	}
	/* If the variable has an array type, lay out the type, even if
	there is no initializer. It is valid to index through the
	array, and we must get TYPE_ALIGN set correctly on the array
	type. */
	else if (TREE_CODE (type) == ARRAY_TYPE)
	layout_type (type);
	}

	/* Add this declaration to the statement-tree. This needs to happen
	after the call to check_initializer so that the DECL_EXPR for a
	reference temp is added before the DECL_EXPR for the reference itself. */
	if (at_function_scope_p ())
	add_decl_expr (decl);

	/* Let the middle end know about variables and functions -- but not
	static data members in uninstantiated class templates. */
	if (!saved_processing_template_decl
	&& (TREE_CODE (decl) == VAR_DECL
	\|\| TREE_CODE (decl) == FUNCTION_DECL))
	{
	if (TREE_CODE (decl) == VAR_DECL)
	{
	layout_var_decl (decl);
	maybe_commonize_var (decl);
	}

	make_rtl_for_nonlocal_decl (decl, init, asmspec);

	/* Check for abstractness of the type. Notice that there is no
	need to strip array types here since the check for those types
	is already done within create_array_type_for_decl. */
	if (TREE_CODE (type) == FUNCTION_TYPE
	\|\| TREE_CODE (type) == METHOD_TYPE)
	abstract_virtuals_error (decl, TREE_TYPE (type));
	else
	abstract_virtuals_error (decl, type);

	/* This needs to happen after the linkage is set. */
	determine_visibility (decl);

	if (TREE_CODE (decl) == FUNCTION_DECL
	\|\| TREE_TYPE (decl) == error_mark_node)
	/* No initialization required. */
	;
	else if (DECL_EXTERNAL (decl)
	&& ! (DECL_LANG_SPECIFIC (decl)
	&& DECL_NOT_REALLY_EXTERN (decl)))
	{
	if (init)
	DECL_INITIAL (decl) = init;
	}
	else
	{
	/* A variable definition. */
	if (DECL_FUNCTION_SCOPE_P (decl))
	{
	/* Initialize the local variable. */
	if (processing_template_decl)
	DECL_INITIAL (decl) = init;
	else if (!TREE_STATIC (decl))
	initialize_local_var (decl, init);
	}

	/* If a variable is defined, and then a subsequent
	definition with external linkage is encountered, we will
	get here twice for the same variable. We want to avoid
	calling expand_static_init more than once. For variables
	that are not static data members, we can call
	expand_static_init only when we actually process the
	initializer. It is not legal to redeclare a static data
	member, so this issue does not arise in that case. */
	if (var_definition_p && TREE_STATIC (decl))
	{
	/* If a TREE_READONLY variable needs initialization
	at runtime, it is no longer readonly and we need to
	avoid MEM_READONLY_P being set on RTL created for it. */
	if (init)
	{
	if (TREE_READONLY (decl))
	TREE_READONLY (decl) = 0;
	was_readonly = 0;
	}
	expand_static_init (decl, init);
	}
	}
	}

	/* If a CLEANUP_STMT was created to destroy a temporary bound to a
	reference, insert it in the statement-tree now. */
	if (cleanup)
	push_cleanup (decl, cleanup, false);

	finish_end:
	processing_template_decl = saved_processing_template_decl;

	if (was_readonly)
	TREE_READONLY (decl) = 1;

	/* If this was marked 'used', be sure it will be output. */
	if (lookup_attribute ("used", DECL_ATTRIBUTES (decl)))
	mark_decl_referenced (decl);
	}

	/* This is here for a midend callback from c-common.c. */

	void
	finish_decl (tree decl, tree init, tree asmspec_tree)
	{
	cp_finish_decl (decl, init, /init_const_expr_p=/false, asmspec_tree, 0);
	}

	/* Returns a declaration for a VAR_DECL as if:

	extern "C" TYPE NAME;

	had been seen. Used to create compiler-generated global
	variables. */

	static tree
	declare_global_var (tree name, tree type)
	{
	tree decl;

	push_to_top_level ();
	decl = build_decl (VAR_DECL, name, type);
	TREE_PUBLIC (decl) = 1;
	DECL_EXTERNAL (decl) = 1;
	DECL_ARTIFICIAL (decl) = 1;
	/* If the user has explicitly declared this variable (perhaps
	because the code we are compiling is part of a low-level runtime
	library), then it is possible that our declaration will be merged
	with theirs by pushdecl. */
	decl = pushdecl (decl);
	finish_decl (decl, NULL_TREE, NULL_TREE);
	pop_from_top_level ();

	return decl;
	}

	/* Returns a pointer to the `atexit' function. Note that if
	FLAG_USE_CXA_ATEXIT is nonzero, then this will actually be the new
	`__cxa_atexit' function specified in the IA64 C++ ABI. */

	static tree
	get_atexit_node (void)
	{
	tree atexit_fndecl;
	tree arg_types;
	tree fn_type;
	tree fn_ptr_type;
	const char *name;
	bool use_aeabi_atexit;

	if (atexit_node)
	return atexit_node;

	if (flag_use_cxa_atexit)
	{
	/* The declaration for `__cxa_atexit' is:

	int __cxa_atexit (void ()(void ), void , void )

	We build up the argument types and then then function type
	itself. */

	use_aeabi_atexit = targetm.cxx.use_aeabi_atexit ();
	/* First, build the pointer-to-function type for the first
	argument. */
	arg_types = tree_cons (NULL_TREE, ptr_type_node, void_list_node);
	fn_type = build_function_type (void_type_node, arg_types);
	fn_ptr_type = build_pointer_type (fn_type);
	/* Then, build the rest of the argument types. */
	arg_types = tree_cons (NULL_TREE, ptr_type_node, void_list_node);
	if (use_aeabi_atexit)
	{
	arg_types = tree_cons (NULL_TREE, fn_ptr_type, arg_types);
	arg_types = tree_cons (NULL_TREE, ptr_type_node, arg_types);
	}
	else
	{
	arg_types = tree_cons (NULL_TREE, ptr_type_node, arg_types);
	arg_types = tree_cons (NULL_TREE, fn_ptr_type, arg_types);
	}
	/* And the final __cxa_atexit type. */
	fn_type = build_function_type (integer_type_node, arg_types);
	fn_ptr_type = build_pointer_type (fn_type);
	if (use_aeabi_atexit)
	name = "__aeabi_atexit";
	else
	name = "__cxa_atexit";
	}
	else
	{
	/* The declaration for `atexit' is:

	int atexit (void (*)());

	We build up the argument types and then then function type
	itself. */
	fn_type = build_function_type (void_type_node, void_list_node);
	fn_ptr_type = build_pointer_type (fn_type);
	arg_types = tree_cons (NULL_TREE, fn_ptr_type, void_list_node);
	/* Build the final atexit type. */
	fn_type = build_function_type (integer_type_node, arg_types);
	name = "atexit";
	}

	/* Now, build the function declaration. */
	push_lang_context (lang_name_c);
	atexit_fndecl = build_library_fn_ptr (name, fn_type);
	mark_used (atexit_fndecl);
	pop_lang_context ();
	atexit_node = decay_conversion (atexit_fndecl);

	return atexit_node;
	}

	/* Returns the __dso_handle VAR_DECL. */

	static tree
	get_dso_handle_node (void)
	{
	if (dso_handle_node)
	return dso_handle_node;

	/* Declare the variable. */
	dso_handle_node = declare_global_var (get_identifier ("__dso_handle"),
	ptr_type_node);

	return dso_handle_node;
	}

	/* Begin a new function with internal linkage whose job will be simply
	to destroy some particular variable. */

	static GTY(()) int start_cleanup_cnt;

	static tree
	start_cleanup_fn (void)
	{
	char name[32];
	tree parmtypes;
	tree fntype;
	tree fndecl;

	push_to_top_level ();

	/* No need to mangle this. */
	push_lang_context (lang_name_c);

	/* Build the parameter-types. */
	parmtypes = void_list_node;
	/* Functions passed to __cxa_atexit take an additional parameter.
	We'll just ignore it. After we implement the new calling
	convention for destructors, we can eliminate the use of
	additional cleanup functions entirely in the -fnew-abi case. */
	if (flag_use_cxa_atexit)
	parmtypes = tree_cons (NULL_TREE, ptr_type_node, parmtypes);
	/* Build the function type itself. */
	fntype = build_function_type (void_type_node, parmtypes);
	/* Build the name of the function. */
	sprintf (name, "__tcf_%d", start_cleanup_cnt++);
	/* Build the function declaration. */
	fndecl = build_lang_decl (FUNCTION_DECL, get_identifier (name), fntype);
	/* It's a function with internal linkage, generated by the
	compiler. */
	TREE_PUBLIC (fndecl) = 0;
	DECL_ARTIFICIAL (fndecl) = 1;
	/* Make the function `inline' so that it is only emitted if it is
	actually needed. It is unlikely that it will be inlined, since
	it is only called via a function pointer, but we avoid unnecessary
	emissions this way. */
	DECL_INLINE (fndecl) = 1;
	DECL_DECLARED_INLINE_P (fndecl) = 1;
	DECL_INTERFACE_KNOWN (fndecl) = 1;
	/* Build the parameter. */
	if (flag_use_cxa_atexit)
	{
	tree parmdecl;

	parmdecl = cp_build_parm_decl (NULL_TREE, ptr_type_node);
	DECL_CONTEXT (parmdecl) = fndecl;
	TREE_USED (parmdecl) = 1;
	DECL_ARGUMENTS (fndecl) = parmdecl;
	}

	pushdecl (fndecl);
	start_preparsed_function (fndecl, NULL_TREE, SF_PRE_PARSED);

	pop_lang_context ();

	return current_function_decl;
	}

	/* Finish the cleanup function begun by start_cleanup_fn. */

	static void
	end_cleanup_fn (void)
	{
	expand_or_defer_fn (finish_function (0));

	pop_from_top_level ();
	}

	/* Generate code to handle the destruction of DECL, an object with
	static storage duration. */

	tree
	register_dtor_fn (tree decl)
	{
	tree cleanup;
	tree compound_stmt;
	tree args;
	tree fcall;

	if (TYPE_HAS_TRIVIAL_DESTRUCTOR (TREE_TYPE (decl)))
	return void_zero_node;

	/* Call build_cleanup before we enter the anonymous function so that
	any access checks will be done relative to the current scope,
	rather than the scope of the anonymous function. */
	build_cleanup (decl);

	/* Now start the function. */
	cleanup = start_cleanup_fn ();

	/* Now, recompute the cleanup. It may contain SAVE_EXPRs that refer
	to the original function, rather than the anonymous one. That
	will make the back-end think that nested functions are in use,
	which causes confusion. */

	push_deferring_access_checks (dk_no_check);
	fcall = build_cleanup (decl);
	pop_deferring_access_checks ();

	/* Create the body of the anonymous function. */
	compound_stmt = begin_compound_stmt (BCS_FN_BODY);
	finish_expr_stmt (fcall);
	finish_compound_stmt (compound_stmt);
	end_cleanup_fn ();

	/* Call atexit with the cleanup function. */
	cxx_mark_addressable (cleanup);
	mark_used (cleanup);
	cleanup = build_unary_op (ADDR_EXPR, cleanup, 0);
	if (flag_use_cxa_atexit)
	{
	args = tree_cons (NULL_TREE,
	build_unary_op (ADDR_EXPR, get_dso_handle_node (), 0),
	NULL_TREE);
	if (targetm.cxx.use_aeabi_atexit ())
	{
	args = tree_cons (NULL_TREE, cleanup, args);
	args = tree_cons (NULL_TREE, null_pointer_node, args);
	}
	else
	{
	args = tree_cons (NULL_TREE, null_pointer_node, args);
	args = tree_cons (NULL_TREE, cleanup, args);
	}
	}
	else
	args = tree_cons (NULL_TREE, cleanup, NULL_TREE);
	return build_function_call (get_atexit_node (), args);
	}

	/* DECL is a VAR_DECL with static storage duration. INIT, if present,
	is its initializer. Generate code to handle the construction
	and destruction of DECL. */

	static void
	expand_static_init (tree decl, tree init)
	{
	gcc_assert (TREE_CODE (decl) == VAR_DECL);
	gcc_assert (TREE_STATIC (decl));

	/* Some variables require no initialization. */
	if (!init
	&& !TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl))
	&& TYPE_HAS_TRIVIAL_DESTRUCTOR (TREE_TYPE (decl)))
	return;

	if (DECL_FUNCTION_SCOPE_P (decl))
	{
	/* Emit code to perform this initialization but once. */
	tree if_stmt = NULL_TREE, inner_if_stmt = NULL_TREE;
	tree then_clause = NULL_TREE, inner_then_clause = NULL_TREE;
	tree guard, guard_addr, guard_addr_list;
	tree acquire_fn, release_fn, abort_fn;
	tree flag, begin;

	/* Emit code to perform this initialization but once. This code
	looks like:

	static <type> guard;
	if (!guard.first_byte) {
	if (__cxa_guard_acquire (&guard)) {
	bool flag = false;
	try {
	// Do initialization.
	flag = true; __cxa_guard_release (&guard);
	// Register variable for destruction at end of program.
	} catch {
	if (!flag) __cxa_guard_abort (&guard);
	}
	}

	Note that the `flag' variable is only set to 1 after the
	initialization is complete. This ensures that an exception,
	thrown during the construction, will cause the variable to
	reinitialized when we pass through this code again, as per:

	[stmt.dcl]

	If the initialization exits by throwing an exception, the
	initialization is not complete, so it will be tried again
	the next time control enters the declaration.

	This process should be thread-safe, too; multiple threads
	should not be able to initialize the variable more than
	once. */

	/* Create the guard variable. */
	guard = get_guard (decl);

	/* This optimization isn't safe on targets with relaxed memory
	consistency. On such targets we force synchronization in
	__cxa_guard_acquire. */
	if (!targetm.relaxed_ordering \|\| !flag_threadsafe_statics)
	{
	/* Begin the conditional initialization. */
	if_stmt = begin_if_stmt ();
	finish_if_stmt_cond (get_guard_cond (guard), if_stmt);
	then_clause = begin_compound_stmt (BCS_NO_SCOPE);
	}

	if (flag_threadsafe_statics)
	{
	guard_addr = build_address (guard);
	guard_addr_list = build_tree_list (NULL_TREE, guard_addr);

	acquire_fn = get_identifier ("__cxa_guard_acquire");
	release_fn = get_identifier ("__cxa_guard_release");
	abort_fn = get_identifier ("__cxa_guard_abort");
	if (!get_global_value_if_present (acquire_fn, &acquire_fn))
	{
	tree argtypes = tree_cons (NULL_TREE, TREE_TYPE (guard_addr),
	void_list_node);
	tree vfntype = build_function_type (void_type_node, argtypes);
	acquire_fn = push_library_fn
	(acquire_fn, build_function_type (integer_type_node, argtypes));
	release_fn = push_library_fn (release_fn, vfntype);
	abort_fn = push_library_fn (abort_fn, vfntype);
	}
	else
	{
	release_fn = identifier_global_value (release_fn);
	abort_fn = identifier_global_value (abort_fn);
	}

	inner_if_stmt = begin_if_stmt ();
	finish_if_stmt_cond (build_call (acquire_fn, guard_addr_list),
	inner_if_stmt);

	inner_then_clause = begin_compound_stmt (BCS_NO_SCOPE);
	begin = get_target_expr (boolean_false_node);
	flag = TARGET_EXPR_SLOT (begin);

	TARGET_EXPR_CLEANUP (begin)
	= build3 (COND_EXPR, void_type_node, flag,
	void_zero_node,
	build_call (abort_fn, guard_addr_list));
	CLEANUP_EH_ONLY (begin) = 1;

	/* Do the initialization itself. */
	init = add_stmt_to_compound (begin, init);
	init = add_stmt_to_compound
	(init, build2 (MODIFY_EXPR, void_type_node, flag, boolean_true_node));
	init = add_stmt_to_compound
	(init, build_call (release_fn, guard_addr_list));
	}
	else
	init = add_stmt_to_compound (init, set_guard (guard));

	/* Use atexit to register a function for destroying this static
	variable. */
	init = add_stmt_to_compound (init, register_dtor_fn (decl));

	finish_expr_stmt (init);

	if (flag_threadsafe_statics)
	{
	finish_compound_stmt (inner_then_clause);
	finish_then_clause (inner_if_stmt);
	finish_if_stmt (inner_if_stmt);
	}

	if (!targetm.relaxed_ordering \|\| !flag_threadsafe_statics)
	{
	finish_compound_stmt (then_clause);
	finish_then_clause (if_stmt);
	finish_if_stmt (if_stmt);
	}
	}
	else
	static_aggregates = tree_cons (init, decl, static_aggregates);
	}


	/* Make TYPE a complete type based on INITIAL_VALUE.
	Return 0 if successful, 1 if INITIAL_VALUE can't be deciphered,
	2 if there was no information (in which case assume 0 if DO_DEFAULT),
	3 if the initializer list is empty (in pedantic mode). */

	int
	cp_complete_array_type (tree *ptype, tree initial_value, bool do_default)
	{
	int failure;
	tree type, elt_type;

	if (initial_value)
	{
	/* An array of character type can be initialized from a
	brace-enclosed string constant.

	FIXME: this code is duplicated from reshape_init. Probably
	we should just call reshape_init here? */
	if (char_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (*ptype)))
	&& TREE_CODE (initial_value) == CONSTRUCTOR
	&& !VEC_empty (constructor_elt, CONSTRUCTOR_ELTS (initial_value)))
	{
	VEC(constructor_elt,gc) *v = CONSTRUCTOR_ELTS (initial_value);
	tree value = VEC_index (constructor_elt, v, 0)->value;

	if (TREE_CODE (value) == STRING_CST
	&& VEC_length (constructor_elt, v) == 1)
	initial_value = value;
	}
	}

	failure = complete_array_type (ptype, initial_value, do_default);

	/* We can create the array before the element type is complete, which
	means that we didn't have these two bits set in the original type
	either. In completing the type, we are expected to propagate these
	bits. See also complete_type which does the same thing for arrays
	of fixed size. */
	type = *ptype;
	if (TYPE_DOMAIN (type))
	{
	elt_type = TREE_TYPE (type);
	TYPE_NEEDS_CONSTRUCTING (type) = TYPE_NEEDS_CONSTRUCTING (elt_type);
	TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type)
	= TYPE_HAS_NONTRIVIAL_DESTRUCTOR (elt_type);
	}

	return failure;
	}

	/* Return zero if something is declared to be a member of type
	CTYPE when in the context of CUR_TYPE. STRING is the error
	message to print in that case. Otherwise, quietly return 1. */

	static int
	member_function_or_else (tree ctype, tree cur_type, enum overload_flags flags)
	{
	if (ctype && ctype != cur_type)
	{
	if (flags == DTOR_FLAG)
	error ("destructor for alien class %qT cannot be a member", ctype);
	else
	error ("constructor for alien class %qT cannot be a member", ctype);
	return 0;
	}
	return 1;
	}

	/* Subroutine of `grokdeclarator'. */

	/* Generate errors possibly applicable for a given set of specifiers.
	This is for ARM $7.1.2. */

	static void
	bad_specifiers (tree object,
	const char* type,
	int virtualp,
	int quals,
	int inlinep,
	int friendp,
	int raises)
	{
	if (virtualp)
	error ("%qD declared as a %<virtual%> %s", object, type);
	if (inlinep)
	error ("%qD declared as an %<inline%> %s", object, type);
	if (quals)
	error ("%<const%> and %<volatile%> function specifiers on "
	"%qD invalid in %s declaration",
	object, type);
	if (friendp)
	error ("%q+D declared as a friend", object);
	if (raises
	&& (TREE_CODE (object) == TYPE_DECL
	\|\| (!TYPE_PTRFN_P (TREE_TYPE (object))
	&& !TYPE_REFFN_P (TREE_TYPE (object))
	&& !TYPE_PTRMEMFUNC_P (TREE_TYPE (object)))))
	error ("%q+D declared with an exception specification", object);
	}

	/* DECL is a member function or static data member and is presently
	being defined. Check that the definition is taking place in a
	valid namespace. */

	static void
	check_class_member_definition_namespace (tree decl)
	{
	/* These checks only apply to member functions and static data
	members. */
	gcc_assert (TREE_CODE (decl) == FUNCTION_DECL
	\|\| TREE_CODE (decl) == VAR_DECL);
	/* We check for problems with specializations in pt.c in
	check_specialization_namespace, where we can issue better
	diagnostics. */
	if (processing_specialization)
	return;
	/* There are no restrictions on the placement of
	explicit instantiations. */
	if (processing_explicit_instantiation)
	return;
	/* [class.mfct]

	A member function definition that appears outside of the
	class definition shall appear in a namespace scope enclosing
	the class definition.

	[class.static.data]

	The definition for a static data member shall appear in a
	namespace scope enclosing the member's class definition. */
	if (!is_ancestor (current_namespace, DECL_CONTEXT (decl)))
	pedwarn ("definition of %qD is not in namespace enclosing %qT",
	decl, DECL_CONTEXT (decl));
	}

	/* Build a PARM_DECL for the "this" parameter. TYPE is the
	METHOD_TYPE for a non-static member function; QUALS are the
	cv-qualifiers that apply to the function. */

	tree
	build_this_parm (tree type, cp_cv_quals quals)
	{
	tree this_type;
	tree qual_type;
	tree parm;
	cp_cv_quals this_quals;

	this_type = TREE_VALUE (TYPE_ARG_TYPES (type));
	/* The `this' parameter is implicitly `const'; it cannot be
	assigned to. */
	this_quals = (quals & TYPE_QUAL_RESTRICT) \| TYPE_QUAL_CONST;
	qual_type = cp_build_qualified_type (this_type, this_quals);
	parm = build_artificial_parm (this_identifier, qual_type);
	cp_apply_type_quals_to_decl (this_quals, parm);
	return parm;
	}

	/* CTYPE is class type, or null if non-class.
	TYPE is type this FUNCTION_DECL should have, either FUNCTION_TYPE
	or METHOD_TYPE.
	DECLARATOR is the function's name.
	PARMS is a chain of PARM_DECLs for the function.
	VIRTUALP is truthvalue of whether the function is virtual or not.
	FLAGS are to be passed through to `grokclassfn'.
	QUALS are qualifiers indicating whether the function is `const'
	or `volatile'.
	RAISES is a list of exceptions that this function can raise.
	CHECK is 1 if we must find this method in CTYPE, 0 if we should
	not look, and -1 if we should not call `grokclassfn' at all.

	SFK is the kind of special function (if any) for the new function.

	Returns `NULL_TREE' if something goes wrong, after issuing
	applicable error messages. */

	static tree
	grokfndecl (tree ctype,
	tree type,
	tree declarator,
	tree parms,
	tree orig_declarator,
	int virtualp,
	enum overload_flags flags,
	cp_cv_quals quals,
	tree raises,
	int check,
	int friendp,
	int publicp,
	int inlinep,
	special_function_kind sfk,
	bool funcdef_flag,
	int template_count,
	tree in_namespace,
	tree* attrlist)
	{
	tree decl;
	int staticp = ctype && TREE_CODE (type) == FUNCTION_TYPE;
	tree t;

	if (raises)
	type = build_exception_variant (type, raises);

	decl = build_lang_decl (FUNCTION_DECL, declarator, type);
	if (TREE_CODE (type) == METHOD_TYPE)
	{
	tree parm;
	parm = build_this_parm (type, quals);
	TREE_CHAIN (parm) = parms;
	parms = parm;
	}
	DECL_ARGUMENTS (decl) = parms;
	/* Propagate volatile out from type to decl. */
	if (TYPE_VOLATILE (type))
	TREE_THIS_VOLATILE (decl) = 1;

	/* If pointers to member functions use the least significant bit to
	indicate whether a function is virtual, ensure a pointer
	to this function will have that bit clear. */
	if (TARGET_PTRMEMFUNC_VBIT_LOCATION == ptrmemfunc_vbit_in_pfn
	&& TREE_CODE (type) == METHOD_TYPE
	&& DECL_ALIGN (decl) < 2 * BITS_PER_UNIT)
	DECL_ALIGN (decl) = 2 * BITS_PER_UNIT;

	if (friendp
	&& TREE_CODE (orig_declarator) == TEMPLATE_ID_EXPR)
	{
	if (funcdef_flag)
	error
	("defining explicit specialization %qD in friend declaration",
	orig_declarator);
	else
	{
	tree fns = TREE_OPERAND (orig_declarator, 0);
	tree args = TREE_OPERAND (orig_declarator, 1);

	if (PROCESSING_REAL_TEMPLATE_DECL_P ())
	{
	/* Something like `template <class T> friend void f<T>()'. */
	error ("invalid use of template-id %qD in declaration "
	"of primary template",
	orig_declarator);
	return NULL_TREE;
	}


	/* A friend declaration of the form friend void f<>(). Record
	the information in the TEMPLATE_ID_EXPR. */
	SET_DECL_IMPLICIT_INSTANTIATION (decl);

	if (TREE_CODE (fns) == COMPONENT_REF)
	{
	/* Due to bison parser ickiness, we will have already looked
	up an operator_name or PFUNCNAME within the current class
	(see template_id in parse.y). If the current class contains
	such a name, we'll get a COMPONENT_REF here. Undo that. */

	gcc_assert (TREE_TYPE (TREE_OPERAND (fns, 0))
	== current_class_type);
	fns = TREE_OPERAND (fns, 1);
	}
	gcc_assert (TREE_CODE (fns) == IDENTIFIER_NODE
	\|\| TREE_CODE (fns) == OVERLOAD);
	DECL_TEMPLATE_INFO (decl) = tree_cons (fns, args, NULL_TREE);

	for (t = TYPE_ARG_TYPES (TREE_TYPE (decl)); t; t = TREE_CHAIN (t))
	if (TREE_PURPOSE (t)
	&& TREE_CODE (TREE_PURPOSE (t)) == DEFAULT_ARG)
	{
	error ("default arguments are not allowed in declaration "
	"of friend template specialization %qD",
	decl);
	return NULL_TREE;
	}

	if (inlinep)
	{
	error ("%<inline%> is not allowed in declaration of friend "
	"template specialization %qD",
	decl);
	return NULL_TREE;
	}
	}
	}

	/* If this decl has namespace scope, set that up. */
	if (in_namespace)
	set_decl_namespace (decl, in_namespace, friendp);
	else if (!ctype)
	DECL_CONTEXT (decl) = FROB_CONTEXT (current_namespace);

	/* `main' and builtins have implicit 'C' linkage. */
	if ((MAIN_NAME_P (declarator)
	\|\| (IDENTIFIER_LENGTH (declarator) > 10
	&& IDENTIFIER_POINTER (declarator)[0] == '_'
	&& IDENTIFIER_POINTER (declarator)[1] == '_'
	&& strncmp (IDENTIFIER_POINTER (declarator)+2, "builtin_", 8) == 0))
	&& current_lang_name == lang_name_cplusplus
	&& ctype == NULL_TREE
	/* NULL_TREE means global namespace. */
	&& DECL_CONTEXT (decl) == NULL_TREE)
	SET_DECL_LANGUAGE (decl, lang_c);

	/* Should probably propagate const out from type to decl I bet (mrs). */
	if (staticp)
	{
	DECL_STATIC_FUNCTION_P (decl) = 1;
	DECL_CONTEXT (decl) = ctype;
	}

	if (ctype)
	{
	DECL_CONTEXT (decl) = ctype;
	if (funcdef_flag)
	check_class_member_definition_namespace (decl);
	}

	if (ctype == NULL_TREE && DECL_MAIN_P (decl))
	{
	if (processing_template_decl)
	error ("cannot declare %<::main%> to be a template");
	if (inlinep)
	error ("cannot declare %<::main%> to be inline");
	if (!publicp)
	error ("cannot declare %<::main%> to be static");
	inlinep = 0;
	publicp = 1;
	}

	/* Members of anonymous types and local classes have no linkage; make
	them internal. If a typedef is made later, this will be changed. */
	if (ctype && (TYPE_ANONYMOUS_P (ctype)
	\|\| decl_function_context (TYPE_MAIN_DECL (ctype))))
	publicp = 0;

	if (publicp)
	{
	/* [basic.link]: A name with no linkage (notably, the name of a class
	or enumeration declared in a local scope) shall not be used to
	declare an entity with linkage.

	Only check this for public decls for now. See core 319, 389. */
	t = no_linkage_check (TREE_TYPE (decl),
	/relaxed_p=/false);
	if (t)
	{
	if (TYPE_ANONYMOUS_P (t))
	{
	if (DECL_EXTERN_C_P (decl))
	/* Allow this; it's pretty common in C. */;
	else
	{
	pedwarn ("non-local function %q#D uses anonymous type",
	decl);
	if (DECL_ORIGINAL_TYPE (TYPE_NAME (t)))
	pedwarn ("%q+#D does not refer to the unqualified "
	"type, so it is not used for linkage",
	TYPE_NAME (t));
	}
	}
	else
	pedwarn ("non-local function %q#D uses local type %qT", decl, t);
	}
	}

	TREE_PUBLIC (decl) = publicp;
	if (! publicp)
	{
	DECL_INTERFACE_KNOWN (decl) = 1;
	DECL_NOT_REALLY_EXTERN (decl) = 1;
	}

	/* If the declaration was declared inline, mark it as such. */
	if (inlinep)
	DECL_DECLARED_INLINE_P (decl) = 1;
	/* We inline functions that are explicitly declared inline, or, when
	the user explicitly asks us to, all functions. */
	if (DECL_DECLARED_INLINE_P (decl)
	\|\| (flag_inline_trees == 2 && !DECL_INLINE (decl) && funcdef_flag))
	DECL_INLINE (decl) = 1;

	DECL_EXTERNAL (decl) = 1;
	if (quals && TREE_CODE (type) == FUNCTION_TYPE)
	{
	error ("%smember function %qD cannot have cv-qualifier",
	(ctype ? "static " : "non-"), decl);
	quals = TYPE_UNQUALIFIED;
	}

	if (IDENTIFIER_OPNAME_P (DECL_NAME (decl))
	&& !grok_op_properties (decl, /complain=/true))
	return NULL_TREE;

	if (ctype && decl_function_context (decl))
	DECL_NO_STATIC_CHAIN (decl) = 1;

	if (funcdef_flag)
	/* Make the init_value nonzero so pushdecl knows this is not
	tentative. error_mark_node is replaced later with the BLOCK. */
	DECL_INITIAL (decl) = error_mark_node;

	if (TYPE_NOTHROW_P (type) \|\| nothrow_libfn_p (decl))
	TREE_NOTHROW (decl) = 1;

	/* Caller will do the rest of this. */
	if (check < 0)
	return decl;

	if (ctype != NULL_TREE)
	{
	if (sfk == sfk_constructor)
	DECL_CONSTRUCTOR_P (decl) = 1;

	grokclassfn (ctype, decl, flags);
	}

	decl = check_explicit_specialization (orig_declarator, decl,
	template_count,
	2 * funcdef_flag +
	4 * (friendp != 0));
	if (decl == error_mark_node)
	return NULL_TREE;

	if (attrlist)
	{
	cplus_decl_attributes (&decl, *attrlist, 0);
	*attrlist = NULL_TREE;
	}

	/* Check main's type after attributes have been applied. */
	if (ctype == NULL_TREE && DECL_MAIN_P (decl)
	&& !same_type_p (TREE_TYPE (TREE_TYPE (decl)),
	integer_type_node))
	{
	tree oldtypeargs = TYPE_ARG_TYPES (TREE_TYPE (decl));
	tree newtype;
	error ("%<::main%> must return %<int%>");
	newtype = build_function_type (integer_type_node, oldtypeargs);
	TREE_TYPE (decl) = newtype;
	}

	if (ctype != NULL_TREE
	&& (! TYPE_FOR_JAVA (ctype) \|\| check_java_method (decl))
	&& check)
	{
	tree old_decl;

	old_decl = check_classfn (ctype, decl,
	(processing_template_decl
	> template_class_depth (ctype))
	? current_template_parms
	: NULL_TREE);
	if (old_decl)
	{
	tree ok;
	tree pushed_scope;

	if (TREE_CODE (old_decl) == TEMPLATE_DECL)
	/* Because grokfndecl is always supposed to return a
	FUNCTION_DECL, we pull out the DECL_TEMPLATE_RESULT
	here. We depend on our callers to figure out that its
	really a template that's being returned. */
	old_decl = DECL_TEMPLATE_RESULT (old_decl);

	if (DECL_STATIC_FUNCTION_P (old_decl)
	&& TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE)
	/* Remove the `this' parm added by grokclassfn.
	XXX Isn't this done in start_function, too? */
	revert_static_member_fn (decl);
	if (DECL_ARTIFICIAL (old_decl))
	error ("definition of implicitly-declared %qD", old_decl);

	/* Since we've smashed OLD_DECL to its
	DECL_TEMPLATE_RESULT, we must do the same to DECL. */
	if (TREE_CODE (decl) == TEMPLATE_DECL)
	decl = DECL_TEMPLATE_RESULT (decl);

	/* Attempt to merge the declarations. This can fail, in
	the case of some invalid specialization declarations. */
	pushed_scope = push_scope (ctype);
	ok = duplicate_decls (decl, old_decl, friendp);
	if (pushed_scope)
	pop_scope (pushed_scope);
	if (!ok)
	{
	error ("no %q#D member function declared in class %qT",
	decl, ctype);
	return NULL_TREE;
	}
	return old_decl;
	}
	}

	if (DECL_CONSTRUCTOR_P (decl) && !grok_ctor_properties (ctype, decl))
	return NULL_TREE;

	if (ctype == NULL_TREE \|\| check)
	return decl;

	if (virtualp)
	DECL_VIRTUAL_P (decl) = 1;

	return decl;
	}

	/* DECL is a VAR_DECL for a static data member. Set flags to reflect
	the linkage that DECL will receive in the object file. */

	static void
	set_linkage_for_static_data_member (tree decl)
	{
	/* A static data member always has static storage duration and
	external linkage. Note that static data members are forbidden in
	local classes -- the only situation in which a class has
	non-external linkage. */
	TREE_PUBLIC (decl) = 1;
	TREE_STATIC (decl) = 1;
	/* For non-template classes, static data members are always put
	out in exactly those files where they are defined, just as
	with ordinary namespace-scope variables. */
	if (!processing_template_decl)
	DECL_INTERFACE_KNOWN (decl) = 1;
	}

	/* Create a VAR_DECL named NAME with the indicated TYPE.

	If SCOPE is non-NULL, it is the class type or namespace containing
	the variable. If SCOPE is NULL, the variable should is created in
	the innermost enclosings scope. */

	static tree
	grokvardecl (tree type,
	tree name,
	const cp_decl_specifier_seq *declspecs,
	int initialized,
	int constp,
	tree scope)
	{
	tree decl;
	tree explicit_scope;

	gcc_assert (!name \|\| TREE_CODE (name) == IDENTIFIER_NODE);

	/* Compute the scope in which to place the variable, but remember
	whether or not that scope was explicitly specified by the user. */
	explicit_scope = scope;
	if (!scope)
	{
	/* An explicit "extern" specifier indicates a namespace-scope
	variable. */
	if (declspecs->storage_class == sc_extern)
	scope = current_namespace;
	else if (!at_function_scope_p ())
	scope = current_scope ();
	}

	if (scope
	&& (/* If the variable is a namespace-scope variable declared in a
	template, we need DECL_LANG_SPECIFIC. */
	(TREE_CODE (scope) == NAMESPACE_DECL && processing_template_decl)
	/* Similarly for namespace-scope variables with language linkage
	other than C++. */
	\|\| (TREE_CODE (scope) == NAMESPACE_DECL
	&& current_lang_name != lang_name_cplusplus)
	/* Similarly for static data members. */
	\|\| TYPE_P (scope)))
	decl = build_lang_decl (VAR_DECL, name, type);
	else
	decl = build_decl (VAR_DECL, name, type);

	if (explicit_scope && TREE_CODE (explicit_scope) == NAMESPACE_DECL)
	set_decl_namespace (decl, explicit_scope, 0);
	else
	DECL_CONTEXT (decl) = FROB_CONTEXT (scope);

	if (declspecs->storage_class == sc_extern)
	{
	DECL_THIS_EXTERN (decl) = 1;
	DECL_EXTERNAL (decl) = !initialized;
	}

	if (DECL_CLASS_SCOPE_P (decl))
	{
	set_linkage_for_static_data_member (decl);
	/* This function is only called with out-of-class definitions. */
	DECL_EXTERNAL (decl) = 0;
	check_class_member_definition_namespace (decl);
	}
	/* At top level, either `static' or no s.c. makes a definition
	(perhaps tentative), and absence of `static' makes it public. */
	else if (toplevel_bindings_p ())
	{
	TREE_PUBLIC (decl) = (declspecs->storage_class != sc_static
	&& (DECL_THIS_EXTERN (decl) \|\| ! constp));
	TREE_STATIC (decl) = ! DECL_EXTERNAL (decl);
	}
	/* Not at top level, only `static' makes a static definition. */
	else
	{
	TREE_STATIC (decl) = declspecs->storage_class == sc_static;
	TREE_PUBLIC (decl) = DECL_EXTERNAL (decl);
	}

	if (declspecs->specs[(int)ds_thread])
	{
	if (targetm.have_tls)
	DECL_TLS_MODEL (decl) = decl_default_tls_model (decl);
	else
	/* A mere warning is sure to result in improper semantics
	at runtime. Don't bother to allow this to compile. */
	error ("thread-local storage not supported for this target");
	}

	if (TREE_PUBLIC (decl))
	{
	/* [basic.link]: A name with no linkage (notably, the name of a class
	or enumeration declared in a local scope) shall not be used to
	declare an entity with linkage.

	Only check this for public decls for now. */
	tree t = no_linkage_check (TREE_TYPE (decl), /relaxed_p=/false);
	if (t)
	{
	if (TYPE_ANONYMOUS_P (t))
	{
	if (DECL_EXTERN_C_P (decl))
	/* Allow this; it's pretty common in C. */
	;
	else
	{
	/* DRs 132, 319 and 389 seem to indicate types with
	no linkage can only be used to declare extern "C"
	entities. Since it's not always an error in the
	ISO C++ 90 Standard, we only issue a warning. */
	warning (0, "non-local variable %q#D uses anonymous type",
	decl);
	if (DECL_ORIGINAL_TYPE (TYPE_NAME (t)))
	warning (0, "%q+#D does not refer to the unqualified "
	"type, so it is not used for linkage",
	TYPE_NAME (t));
	}
	}
	else
	warning (0, "non-local variable %q#D uses local type %qT", decl, t);
	}
	}
	else
	DECL_INTERFACE_KNOWN (decl) = 1;

	return decl;
	}

	/* Create and return a canonical pointer to member function type, for
	TYPE, which is a POINTER_TYPE to a METHOD_TYPE. */

	tree
	build_ptrmemfunc_type (tree type)
	{
	tree field, fields;
	tree t;
	tree unqualified_variant = NULL_TREE;

	if (type == error_mark_node)
	return type;

	/* If a canonical type already exists for this type, use it. We use
	this method instead of type_hash_canon, because it only does a
	simple equality check on the list of field members. */

	if ((t = TYPE_GET_PTRMEMFUNC_TYPE (type)))
	return t;

	/* Make sure that we always have the unqualified pointer-to-member
	type first. */
	if (cp_type_quals (type) != TYPE_UNQUALIFIED)
	unqualified_variant
	= build_ptrmemfunc_type (TYPE_MAIN_VARIANT (type));

	t = make_aggr_type (RECORD_TYPE);
	xref_basetypes (t, NULL_TREE);

	/* Let the front-end know this is a pointer to member function... */
	TYPE_PTRMEMFUNC_FLAG (t) = 1;
	/* ... and not really an aggregate. */
	SET_IS_AGGR_TYPE (t, 0);

	field = build_decl (FIELD_DECL, pfn_identifier, type);
	fields = field;

	field = build_decl (FIELD_DECL, delta_identifier, delta_type_node);
	TREE_CHAIN (field) = fields;
	fields = field;

	finish_builtin_struct (t, "__ptrmemfunc_type", fields, ptr_type_node);

	/* Zap out the name so that the back-end will give us the debugging
	information for this anonymous RECORD_TYPE. */
	TYPE_NAME (t) = NULL_TREE;

	/* If this is not the unqualified form of this pointer-to-member
	type, set the TYPE_MAIN_VARIANT for this type to be the
	unqualified type. Since they are actually RECORD_TYPEs that are
	not variants of each other, we must do this manually. */
	if (cp_type_quals (type) != TYPE_UNQUALIFIED)
	{
	t = build_qualified_type (t, cp_type_quals (type));
	TYPE_MAIN_VARIANT (t) = unqualified_variant;
	TYPE_NEXT_VARIANT (t) = TYPE_NEXT_VARIANT (unqualified_variant);
	TYPE_NEXT_VARIANT (unqualified_variant) = t;
	}

	/* Cache this pointer-to-member type so that we can find it again
	later. */
	TYPE_SET_PTRMEMFUNC_TYPE (type, t);

	return t;
	}

	/* Create and return a pointer to data member type. */

	tree
	build_ptrmem_type (tree class_type, tree member_type)
	{
	if (TREE_CODE (member_type) == METHOD_TYPE)
	{
	tree arg_types;

	arg_types = TYPE_ARG_TYPES (member_type);
	class_type = (cp_build_qualified_type
	(class_type,
	cp_type_quals (TREE_TYPE (TREE_VALUE (arg_types)))));
	member_type
	= build_method_type_directly (class_type,
	TREE_TYPE (member_type),
	TREE_CHAIN (arg_types));
	return build_ptrmemfunc_type (build_pointer_type (member_type));
	}
	else
	{
	gcc_assert (TREE_CODE (member_type) != FUNCTION_TYPE);
	return build_offset_type (class_type, member_type);
	}
	}

	/* DECL is a VAR_DECL defined in-class, whose TYPE is also given.
	Check to see that the definition is valid. Issue appropriate error
	messages. Return 1 if the definition is particularly bad, or 0
	otherwise. */

	int
	check_static_variable_definition (tree decl, tree type)
	{
	/* Motion 10 at San Diego: If a static const integral data member is
	initialized with an integral constant expression, the initializer
	may appear either in the declaration (within the class), or in
	the definition, but not both. If it appears in the class, the
	member is a member constant. The file-scope definition is always
	required. */
	if (!ARITHMETIC_TYPE_P (type) && TREE_CODE (type) != ENUMERAL_TYPE)
	{
	error ("invalid in-class initialization of static data member "
	"of non-integral type %qT",
	type);
	/* If we just return the declaration, crashes will sometimes
	occur. We therefore return void_type_node, as if this were a
	friend declaration, to cause callers to completely ignore
	this declaration. */
	return 1;
	}
	else if (!CP_TYPE_CONST_P (type))
	error ("ISO C++ forbids in-class initialization of non-const "
	"static member %qD",
	decl);
	else if (pedantic && !INTEGRAL_TYPE_P (type))
	pedwarn ("ISO C++ forbids initialization of member constant "
	"%qD of non-integral type %qT", decl, type);

	return 0;
	}

	/* Given the SIZE (i.e., number of elements) in an array, compute an
	appropriate index type for the array. If non-NULL, NAME is the
	name of the thing being declared. */

	tree
	compute_array_index_type (tree name, tree size)
	{
	tree type;
	tree itype;

	if (error_operand_p (size))
	return error_mark_node;

	type = TREE_TYPE (size);
	/* The array bound must be an integer type. */
	if (!dependent_type_p (type) && !INTEGRAL_TYPE_P (type))
	{
	if (name)
	error ("size of array %qD has non-integral type %qT", name, type);
	else
	error ("size of array has non-integral type %qT", type);
	size = integer_one_node;
	type = TREE_TYPE (size);
	}

	if (abi_version_at_least (2)
	/* We should only handle value dependent expressions specially. */
	? value_dependent_expression_p (size)
	/* But for abi-1, we handled all instances in templates. This
	effects the manglings produced. */
	: processing_template_decl)
	return build_index_type (build_min (MINUS_EXPR, sizetype,
	size, integer_one_node));

	/* The size might be the result of a cast. */
	STRIP_TYPE_NOPS (size);

	/* It might be a const variable or enumeration constant. */
	size = integral_constant_value (size);

	/* Normally, the array-bound will be a constant. */
	if (TREE_CODE (size) == INTEGER_CST)
	{
	/* Check to see if the array bound overflowed. Make that an
	error, no matter how generous we're being. */
	int old_flag_pedantic_errors = flag_pedantic_errors;
	int old_pedantic = pedantic;
	pedantic = flag_pedantic_errors = 1;
	constant_expression_warning (size);
	pedantic = old_pedantic;
	flag_pedantic_errors = old_flag_pedantic_errors;

	/* An array must have a positive number of elements. */
	if (INT_CST_LT (size, integer_zero_node))
	{
	if (name)
	error ("size of array %qD is negative", name);
	else
	error ("size of array is negative");
	size = integer_one_node;
	}
	/* As an extension we allow zero-sized arrays. We always allow
	them in system headers because glibc uses them. */
	else if (integer_zerop (size) && pedantic && !in_system_header)
	{
	if (name)
	pedwarn ("ISO C++ forbids zero-size array %qD", name);
	else
	pedwarn ("ISO C++ forbids zero-size array");
	}
	}
	else if (TREE_CONSTANT (size))
	{
	/* `(int) &fn' is not a valid array bound. */
	if (name)
	error ("size of array %qD is not an integral constant-expression",
	name);
	else
	error ("size of array is not an integral constant-expression");
	size = integer_one_node;
	}
	else if (pedantic && warn_vla != 0)
	{
	if (name)
	pedwarn ("ISO C++ forbids variable length array %qD", name);
	else
	pedwarn ("ISO C++ forbids variable length array");
	}
	else if (warn_vla > 0)
	{
	if (name)
	warning (OPT_Wvla,
	"variable length array %qD is used", name);
	else
	warning (OPT_Wvla,
	"variable length array is used");
	}

	if (processing_template_decl && !TREE_CONSTANT (size))
	/* A variable sized array. */
	itype = build_min (MINUS_EXPR, sizetype, size, integer_one_node);
	else
	{
	HOST_WIDE_INT saved_processing_template_decl;

	/* Compute the index of the largest element in the array. It is
	one less than the number of elements in the array. We save
	and restore PROCESSING_TEMPLATE_DECL so that computations in
	cp_build_binary_op will be appropriately folded. */
	saved_processing_template_decl = processing_template_decl;
	processing_template_decl = 0;
	itype = cp_build_binary_op (MINUS_EXPR,
	cp_convert (ssizetype, size),
	cp_convert (ssizetype, integer_one_node));
	itype = fold (itype);
	processing_template_decl = saved_processing_template_decl;

	if (!TREE_CONSTANT (itype))
	/* A variable sized array. */
	itype = variable_size (itype);
	/* Make sure that there was no overflow when creating to a signed
	index type. (For example, on a 32-bit machine, an array with
	size 2^32 - 1 is too big.) */
	else if (TREE_CODE (itype) == INTEGER_CST
	&& TREE_OVERFLOW (itype))
	{
	error ("overflow in array dimension");
	TREE_OVERFLOW (itype) = 0;
	}
	}

	/* Create and return the appropriate index type. */
	return build_index_type (itype);
	}

	/* Returns the scope (if any) in which the entity declared by
	DECLARATOR will be located. If the entity was declared with an
	unqualified name, NULL_TREE is returned. */

	tree
	get_scope_of_declarator (const cp_declarator *declarator)
	{
	while (declarator && declarator->kind != cdk_id)
	declarator = declarator->declarator;

	/* If the declarator-id is a SCOPE_REF, the scope in which the
	declaration occurs is the first operand. */
	if (declarator
	&& declarator->u.id.qualifying_scope)
	return declarator->u.id.qualifying_scope;

	/* Otherwise, the declarator is not a qualified name; the entity will
	be declared in the current scope. */
	return NULL_TREE;
	}

	/* Returns an ARRAY_TYPE for an array with SIZE elements of the
	indicated TYPE. If non-NULL, NAME is the NAME of the declaration
	with this type. */

	static tree
	create_array_type_for_decl (tree name, tree type, tree size)
	{
	tree itype = NULL_TREE;
	const char* error_msg;

	/* If things have already gone awry, bail now. */
	if (type == error_mark_node \|\| size == error_mark_node)
	return error_mark_node;

	/* Assume that everything will go OK. */
	error_msg = NULL;

	/* There are some types which cannot be array elements. */
	switch (TREE_CODE (type))
	{
	case VOID_TYPE:
	error_msg = "array of void";
	break;

	case FUNCTION_TYPE:
	error_msg = "array of functions";
	break;

	case REFERENCE_TYPE:
	error_msg = "array of references";
	break;

	case METHOD_TYPE:
	error_msg = "array of function members";
	break;

	default:
	break;
	}

	/* If something went wrong, issue an error-message and return. */
	if (error_msg)
	{
	if (name)
	error ("declaration of %qD as %s", name, error_msg);
	else
	error ("creating %s", error_msg);

	return error_mark_node;
	}

	/* [dcl.array]

	The constant expressions that specify the bounds of the arrays
	can be omitted only for the first member of the sequence. */
	if (TREE_CODE (type) == ARRAY_TYPE && !TYPE_DOMAIN (type))
	{
	if (name)
	error ("declaration of %qD as multidimensional array must "
	"have bounds for all dimensions except the first",
	name);
	else
	error ("multidimensional array must have bounds for all "
	"dimensions except the first");

	return error_mark_node;
	}

	/* Figure out the index type for the array. */
	if (size)
	itype = compute_array_index_type (name, size);

	/* [dcl.array]
	T is called the array element type; this type shall not be [...] an
	abstract class type. */
	abstract_virtuals_error (name, type);

	return build_cplus_array_type (type, itype);
	}

	/* Check that it's OK to declare a function with the indicated TYPE.
	SFK indicates the kind of special function (if any) that this
	function is. OPTYPE is the type given in a conversion operator
	declaration, or the class type for a constructor/destructor.
	Returns the actual return type of the function; that
	may be different than TYPE if an error occurs, or for certain
	special functions. */

	static tree
	check_special_function_return_type (special_function_kind sfk,
	tree type,
	tree optype)
	{
	switch (sfk)
	{
	case sfk_constructor:
	if (type)
	error ("return type specification for constructor invalid");

	if (targetm.cxx.cdtor_returns_this () && !TYPE_FOR_JAVA (optype))
	type = build_pointer_type (optype);
	else
	type = void_type_node;
	break;

	case sfk_destructor:
	if (type)
	error ("return type specification for destructor invalid");
	/* We can't use the proper return type here because we run into
	problems with ambiguous bases and covariant returns.
	Java classes are left unchanged because (void *) isn't a valid
	Java type, and we don't want to change the Java ABI. */
	if (targetm.cxx.cdtor_returns_this () && !TYPE_FOR_JAVA (optype))
	type = build_pointer_type (void_type_node);
	else
	type = void_type_node;
	break;

	case sfk_conversion:
	if (type && !same_type_p (type, optype))
	error ("operator %qT declared to return %qT", optype, type);
	else if (type)
	pedwarn ("return type specified for %<operator %T%>", optype);
	type = optype;
	break;

	default:
	gcc_unreachable ();
	}

	return type;
	}

	/* A variable or data member (whose unqualified name is IDENTIFIER)
	has been declared with the indicated TYPE. If the TYPE is not
	acceptable, issue an error message and return a type to use for
	error-recovery purposes. */

	tree
	check_var_type (tree identifier, tree type)
	{
	if (VOID_TYPE_P (type))
	{
	if (!identifier)
	error ("unnamed variable or field declared void");
	else if (TREE_CODE (identifier) == IDENTIFIER_NODE)
	{
	gcc_assert (!IDENTIFIER_OPNAME_P (identifier));
	error ("variable or field %qE declared void", identifier);
	}
	else
	error ("variable or field declared void");
	type = error_mark_node;
	}

	return type;
	}

	/* Given declspecs and a declarator (abstract or otherwise), determine
	the name and type of the object declared and construct a DECL node
	for it.

	DECLSPECS is a chain of tree_list nodes whose value fields
	are the storage classes and type specifiers.

	DECL_CONTEXT says which syntactic context this declaration is in:
	NORMAL for most contexts. Make a VAR_DECL or FUNCTION_DECL or TYPE_DECL.
	FUNCDEF for a function definition. Like NORMAL but a few different
	error messages in each case. Return value may be zero meaning
	this definition is too screwy to try to parse.
	MEMFUNCDEF for a function definition. Like FUNCDEF but prepares to
	handle member functions (which have FIELD context).
	Return value may be zero meaning this definition is too screwy to
	try to parse.
	PARM for a parameter declaration (either within a function prototype
	or before a function body). Make a PARM_DECL, or return void_type_node.
	CATCHPARM for a parameter declaration before a catch clause.
	TYPENAME if for a typename (in a cast or sizeof).
	Don't make a DECL node; just return the ..._TYPE node.
	FIELD for a struct or union field; make a FIELD_DECL.
	BITFIELD for a field with specified width.
	INITIALIZED is 1 if the decl has an initializer.

	ATTRLIST is a pointer to the list of attributes, which may be NULL
	if there are none; *ATTRLIST may be modified if attributes from inside
	the declarator should be applied to the declaration.

	When this function is called, scoping variables (such as
	CURRENT_CLASS_TYPE) should reflect the scope in which the
	declaration occurs, not the scope in which the new declaration will
	be placed. For example, on:

	void S::f() { ... }

	when grokdeclarator is called for `S::f', the CURRENT_CLASS_TYPE
	should not be `S'.

	Returns a DECL (if a declarator is present), a TYPE (if there is no
	declarator, in cases like "struct S;"), or the ERROR_MARK_NODE if an
	error occurs. */

	tree
	grokdeclarator (const cp_declarator *declarator,
	const cp_decl_specifier_seq *declspecs,
	enum decl_context decl_context,
	int initialized,
	tree* attrlist)
	{
	tree type = NULL_TREE;
	int longlong = 0;
	int virtualp, explicitp, friendp, inlinep, staticp;
	int explicit_int = 0;
	int explicit_char = 0;
	int defaulted_int = 0;
	tree dependent_name = NULL_TREE;

	tree typedef_decl = NULL_TREE;
	const char *name = NULL;
	tree typedef_type = NULL_TREE;
	/* True if this declarator is a function definition. */
	bool funcdef_flag = false;
	cp_declarator_kind innermost_code = cdk_error;
	int bitfield = 0;
	#if 0
	/* See the code below that used this. */
	tree decl_attr = NULL_TREE;
	#endif

	/* Keep track of what sort of function is being processed
	so that we can warn about default return values, or explicit
	return values which do not match prescribed defaults. */
	special_function_kind sfk = sfk_none;

	tree dname = NULL_TREE;
	tree ctor_return_type = NULL_TREE;
	enum overload_flags flags = NO_SPECIAL;
	/* cv-qualifiers that apply to the declarator, for a declaration of
	a member function. */
	cp_cv_quals memfn_quals = TYPE_UNQUALIFIED;
	/* cv-qualifiers that apply to the type specified by the DECLSPECS. */
	int type_quals;
	tree raises = NULL_TREE;
	int template_count = 0;
	tree returned_attrs = NULL_TREE;
	tree parms = NULL_TREE;
	const cp_declarator *id_declarator;
	/* The unqualified name of the declarator; either an
	IDENTIFIER_NODE, BIT_NOT_EXPR, or TEMPLATE_ID_EXPR. */
	tree unqualified_id;
	/* The class type, if any, in which this entity is located,
	or NULL_TREE if none. Note that this value may be different from
	the current class type; for example if an attempt is made to declare
	"A::f" inside "B", this value will be "A". */
	tree ctype = current_class_type;
	/* The NAMESPACE_DECL for the namespace in which this entity is
	located. If an unqualified name is used to declare the entity,
	this value will be NULL_TREE, even if the entity is located at
	namespace scope. */
	tree in_namespace = NULL_TREE;
	cp_storage_class storage_class;
	bool unsigned_p, signed_p, short_p, long_p, thread_p;
	bool type_was_error_mark_node = false;

	signed_p = declspecs->specs[(int)ds_signed];
	unsigned_p = declspecs->specs[(int)ds_unsigned];
	short_p = declspecs->specs[(int)ds_short];
	long_p = declspecs->specs[(int)ds_long];
	longlong = declspecs->specs[(int)ds_long] >= 2;
	thread_p = declspecs->specs[(int)ds_thread];

	if (decl_context == FUNCDEF)
	funcdef_flag = true, decl_context = NORMAL;
	else if (decl_context == MEMFUNCDEF)
	funcdef_flag = true, decl_context = FIELD;
	else if (decl_context == BITFIELD)
	bitfield = 1, decl_context = FIELD;

	/* Look inside a declarator for the name being declared
	and get it as a string, for an error message. */
	for (id_declarator = declarator;
	id_declarator;
	id_declarator = id_declarator->declarator)
	{
	if (id_declarator->kind != cdk_id)
	innermost_code = id_declarator->kind;

	switch (id_declarator->kind)
	{
	case cdk_function:
	if (id_declarator->declarator
	&& id_declarator->declarator->kind == cdk_id)
	{
	sfk = id_declarator->declarator->u.id.sfk;
	if (sfk == sfk_destructor)
	flags = DTOR_FLAG;
	}
	break;

	case cdk_id:
	{
	tree qualifying_scope = id_declarator->u.id.qualifying_scope;
	tree decl = id_declarator->u.id.unqualified_name;
	if (!decl)
	break;
	if (qualifying_scope)
	{
	if (at_function_scope_p ())
	{
	/* [dcl.meaning]

	A declarator-id shall not be qualified except
	for ...

	None of the cases are permitted in block
	scope. */
	if (qualifying_scope == global_namespace)
	error ("invalid use of qualified-name %<::%D%>",
	decl);
	else if (TYPE_P (qualifying_scope))
	error ("invalid use of qualified-name %<%T::%D%>",
	qualifying_scope, decl);
	else
	error ("invalid use of qualified-name %<%D::%D%>",
	qualifying_scope, decl);
	return error_mark_node;
	}
	else if (TYPE_P (qualifying_scope))
	{
	ctype = qualifying_scope;
	if (innermost_code != cdk_function
	&& current_class_type
	&& !UNIQUELY_DERIVED_FROM_P (ctype,
	current_class_type))
	{
	error ("type %qT is not derived from type %qT",
	ctype, current_class_type);
	return error_mark_node;
	}
	}
	else if (TREE_CODE (qualifying_scope) == NAMESPACE_DECL)
	in_namespace = qualifying_scope;
	}
	switch (TREE_CODE (decl))
	{
	case BIT_NOT_EXPR:
	{
	tree type;

	if (innermost_code != cdk_function)
	{
	error ("declaration of %qD as non-function", decl);
	return error_mark_node;
	}
	else if (!qualifying_scope
	&& !(current_class_type && at_class_scope_p ()))
	{
	error ("declaration of %qD as non-member", decl);
	return error_mark_node;
	}

	type = TREE_OPERAND (decl, 0);
	name = IDENTIFIER_POINTER (constructor_name (type));
	dname = decl;
	}
	break;

	case TEMPLATE_ID_EXPR:
	{
	tree fns = TREE_OPERAND (decl, 0);

	dname = fns;
	if (TREE_CODE (dname) != IDENTIFIER_NODE)
	{
	gcc_assert (is_overloaded_fn (dname));
	dname = DECL_NAME (get_first_fn (dname));
	}
	}
	/* Fall through. */

	case IDENTIFIER_NODE:
	if (TREE_CODE (decl) == IDENTIFIER_NODE)
	dname = decl;

	if (C_IS_RESERVED_WORD (dname))
	{
	error ("declarator-id missing; using reserved word %qD",
	dname);
	name = IDENTIFIER_POINTER (dname);
	}
	else if (!IDENTIFIER_TYPENAME_P (dname))
	name = IDENTIFIER_POINTER (dname);
	else
	{
	gcc_assert (flags == NO_SPECIAL);
	flags = TYPENAME_FLAG;
	ctor_return_type = TREE_TYPE (dname);
	sfk = sfk_conversion;
	if (is_typename_at_global_scope (dname))
	name = IDENTIFIER_POINTER (dname);
	else
	name = "<invalid operator>";
	}
	break;

	default:
	gcc_unreachable ();
	}
	break;

	case cdk_array:
	case cdk_pointer:
	case cdk_reference:
	case cdk_ptrmem:
	break;

	case cdk_error:
	return error_mark_node;

	default:
	gcc_unreachable ();
	}
	}
	if (id_declarator->kind == cdk_id)
	break;
	}

	/* [dcl.fct.edf]

	The declarator in a function-definition shall have the form
	D1 ( parameter-declaration-clause) ... */
	if (funcdef_flag && innermost_code != cdk_function)
	{
	error ("function definition does not declare parameters");
	return error_mark_node;
	}

	if (((dname && IDENTIFIER_OPNAME_P (dname)) \|\| flags == TYPENAME_FLAG)
	&& innermost_code != cdk_function
	&& ! (ctype && !declspecs->any_specifiers_p))
	{
	error ("declaration of %qD as non-function", dname);
	return error_mark_node;
	}

	/* Anything declared one level down from the top level
	must be one of the parameters of a function
	(because the body is at least two levels down). */

	/* This heuristic cannot be applied to C++ nodes! Fixed, however,
	by not allowing C++ class definitions to specify their parameters
	with xdecls (must be spec.d in the parmlist).

	Since we now wait to push a class scope until we are sure that
	we are in a legitimate method context, we must set oldcname
	explicitly (since current_class_name is not yet alive).

	We also want to avoid calling this a PARM if it is in a namespace. */

	if (decl_context == NORMAL && !toplevel_bindings_p ())
	{
	struct cp_binding_level *b = current_binding_level;
	current_binding_level = b->level_chain;
	if (current_binding_level != 0 && toplevel_bindings_p ())
	decl_context = PARM;
	current_binding_level = b;
	}

	if (name == NULL)
	name = decl_context == PARM ? "parameter" : "type name";

	/* If there were multiple types specified in the decl-specifier-seq,
	issue an error message. */
	if (declspecs->multiple_types_p)
	{
	error ("two or more data types in declaration of %qs", name);
	return error_mark_node;
	}

	/* Extract the basic type from the decl-specifier-seq. */
	type = declspecs->type;
	if (type == error_mark_node)
	{
	type = NULL_TREE;
	type_was_error_mark_node = true;
	}
	+
	+ /* APPLE LOCAL begin unavailable attribute (radar 2809697) --bowdidge */
	+ /* If the entire declaration is itself tagged as unavailable then
	+ suppress reports of unavailable/deprecated items. If the
	+ entire declaration is tagged as only deprecated we still
	+ report unavailable uses. */
	+ if (type && TREE_DEPRECATED (type) && TREE_UNAVAILABLE (type))
	+ {
	+ if (deprecated_state != DEPRECATED_UNAVAILABLE_SUPPRESS)
	+ warn_deprecated_use (type);
	+ }
	+ else
	+ /* APPLE LOCAL end unavailable attribute (radar 2809697) --bowdidge */
	/* If the entire declaration is itself tagged as deprecated then
	suppress reports of deprecated items. */
	if (type && TREE_DEPRECATED (type)
	&& deprecated_state != DEPRECATED_SUPPRESS)
	warn_deprecated_use (type);
	if (type && TREE_CODE (type) == TYPE_DECL)
	{
	typedef_decl = type;
	type = TREE_TYPE (typedef_decl);
	}
	/* No type at all: default to `int', and set DEFAULTED_INT
	because it was not a user-defined typedef. */
	if (type == NULL_TREE && (signed_p \|\| unsigned_p \|\| long_p \|\| short_p))
	{
	/* These imply 'int'. */
	type = integer_type_node;
	defaulted_int = 1;
	}
	/* Gather flags. */
	explicit_int = declspecs->explicit_int_p;
	explicit_char = declspecs->explicit_char_p;

	#if 0
	/* See the code below that used this. */
	if (typedef_decl)
	decl_attr = DECL_ATTRIBUTES (typedef_decl);
	#endif
	typedef_type = type;


	if (sfk != sfk_conversion)
	ctor_return_type = ctype;

	if (sfk != sfk_none)
	type = check_special_function_return_type (sfk, type,
	ctor_return_type);
	else if (type == NULL_TREE)
	{
	int is_main;

	explicit_int = -1;

	/* We handle `main' specially here, because 'main () { }' is so
	common. With no options, it is allowed. With -Wreturn-type,
	it is a warning. It is only an error with -pedantic-errors. */
	is_main = (funcdef_flag
	&& dname && MAIN_NAME_P (dname)
	&& ctype == NULL_TREE
	&& in_namespace == NULL_TREE
	&& current_namespace == global_namespace);

	if (type_was_error_mark_node)
	/* We've already issued an error, don't complain more. */;
	else if (in_system_header \|\| flag_ms_extensions)
	/* Allow it, sigh. */;
	else if (pedantic \|\| ! is_main)
	pedwarn ("ISO C++ forbids declaration of %qs with no type", name);
	else if (warn_return_type)
	warning (0, "ISO C++ forbids declaration of %qs with no type", name);

	type = integer_type_node;
	}

	ctype = NULL_TREE;

	/* Now process the modifiers that were specified
	and check for invalid combinations. */

	/* Long double is a special combination. */
	if (long_p && !longlong && TYPE_MAIN_VARIANT (type) == double_type_node)
	{
	long_p = false;
	type = build_qualified_type (long_double_type_node,
	cp_type_quals (type));
	}

	/* Check all other uses of type modifiers. */

	if (unsigned_p \|\| signed_p \|\| long_p \|\| short_p)
	{
	int ok = 0;

	if ((signed_p \|\| unsigned_p) && TREE_CODE (type) != INTEGER_TYPE)
	error ("%<signed%> or %<unsigned%> invalid for %qs", name);
	else if (signed_p && unsigned_p)
	error ("%<signed%> and %<unsigned%> specified together for %qs", name);
	else if (longlong && TREE_CODE (type) != INTEGER_TYPE)
	error ("%<long long%> invalid for %qs", name);
	else if (long_p && TREE_CODE (type) == REAL_TYPE)
	error ("%<long%> invalid for %qs", name);
	else if (short_p && TREE_CODE (type) == REAL_TYPE)
	error ("%<short%> invalid for %qs", name);
	else if ((long_p \|\| short_p) && TREE_CODE (type) != INTEGER_TYPE)
	error ("%<long%> or %<short%> invalid for %qs", name);
	else if ((long_p \|\| short_p) && explicit_char)
	error ("%<long%> or %<short%> specified with char for %qs", name);
	else if (long_p && short_p)
	error ("%<long%> and %<short%> specified together for %qs", name);
	else
	{
	ok = 1;
	if (!explicit_int && !defaulted_int && !explicit_char && pedantic)
	{
	pedwarn ("long, short, signed or unsigned used invalidly for %qs",
	name);
	if (flag_pedantic_errors)
	ok = 0;
	}
	}

	/* Discard the type modifiers if they are invalid. */
	if (! ok)
	{
	unsigned_p = false;
	signed_p = false;
	long_p = false;
	short_p = false;
	longlong = 0;
	}
	}

	/* Decide whether an integer type is signed or not.
	Optionally treat bitfields as signed by default. */
	if (unsigned_p
	/* [class.bit]

	It is implementation-defined whether a plain (neither
	explicitly signed or unsigned) char, short, int, or long
	bit-field is signed or unsigned.

	Naturally, we extend this to long long as well. Note that
	this does not include wchar_t. */
	\|\| (bitfield && !flag_signed_bitfields
	&& !signed_p
	/* A typedef for plain `int' without `signed' can be
	controlled just like plain `int', but a typedef for
	`signed int' cannot be so controlled. */
	&& !(typedef_decl
	&& C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl))
	&& TREE_CODE (type) == INTEGER_TYPE
	&& !same_type_p (TYPE_MAIN_VARIANT (type), wchar_type_node)))
	{
	if (longlong)
	type = long_long_unsigned_type_node;
	else if (long_p)
	type = long_unsigned_type_node;
	else if (short_p)
	type = short_unsigned_type_node;
	else if (type == char_type_node)
	type = unsigned_char_type_node;
	else if (typedef_decl)
	type = c_common_unsigned_type (type);
	else
	type = unsigned_type_node;
	}
	else if (signed_p && type == char_type_node)
	type = signed_char_type_node;
	else if (longlong)
	type = long_long_integer_type_node;
	else if (long_p)
	type = long_integer_type_node;
	else if (short_p)
	type = short_integer_type_node;

	if (declspecs->specs[(int)ds_complex])
	{
	if (TREE_CODE (type) != INTEGER_TYPE && TREE_CODE (type) != REAL_TYPE)
	error ("complex invalid for %qs", name);
	/* If we just have "complex", it is equivalent to
	"complex double", but if any modifiers at all are specified it is
	the complex form of TYPE. E.g, "complex short" is
	"complex short int". */

	else if (defaulted_int && ! longlong
	&& ! (long_p \|\| short_p \|\| signed_p \|\| unsigned_p))
	type = complex_double_type_node;
	else if (type == integer_type_node)
	type = complex_integer_type_node;
	else if (type == float_type_node)
	type = complex_float_type_node;
	else if (type == double_type_node)
	type = complex_double_type_node;
	else if (type == long_double_type_node)
	type = complex_long_double_type_node;
	else
	type = build_complex_type (type);
	}

	type_quals = TYPE_UNQUALIFIED;
	if (declspecs->specs[(int)ds_const])
	type_quals \|= TYPE_QUAL_CONST;
	if (declspecs->specs[(int)ds_volatile])
	type_quals \|= TYPE_QUAL_VOLATILE;
	if (declspecs->specs[(int)ds_restrict])
	type_quals \|= TYPE_QUAL_RESTRICT;
	if (sfk == sfk_conversion && type_quals != TYPE_UNQUALIFIED)
	error ("qualifiers are not allowed on declaration of %<operator %T%>",
	ctor_return_type);

	if (TREE_CODE (type) == FUNCTION_TYPE
	&& type_quals != TYPE_UNQUALIFIED)
	{
	/* This was an error in C++98 (cv-qualifiers cannot be added to
	a function type), but DR 295 makes the code well-formed by
	dropping the extra qualifiers. */
	if (pedantic)
	{
	tree bad_type = build_qualified_type (type, type_quals);
	pedwarn ("ignoring %qV qualifiers added to function type %qT",
	bad_type, type);
	}
	type_quals = TYPE_UNQUALIFIED;
	}
	type_quals \|= cp_type_quals (type);
	type = cp_build_qualified_type_real
	(type, type_quals, ((typedef_decl && !DECL_ARTIFICIAL (typedef_decl)
	? tf_ignore_bad_quals : 0) \| tf_warning_or_error));
	/* We might have ignored or rejected some of the qualifiers. */
	type_quals = cp_type_quals (type);

	staticp = 0;
	inlinep = !! declspecs->specs[(int)ds_inline];
	virtualp = !! declspecs->specs[(int)ds_virtual];
	explicitp = !! declspecs->specs[(int)ds_explicit];

	storage_class = declspecs->storage_class;
	if (storage_class == sc_static)
	staticp = 1 + (decl_context == FIELD);

	if (virtualp && staticp == 2)
	{
	error ("member %qD cannot be declared both virtual and static", dname);
	storage_class = sc_none;
	staticp = 0;
	}
	friendp = !! declspecs->specs[(int)ds_friend];

	if (dependent_name && !friendp)
	{
	error ("%<%T::%D%> is not a valid declarator", ctype, dependent_name);
	return error_mark_node;
	}

	/* Issue errors about use of storage classes for parameters. */
	if (decl_context == PARM)
	{
	if (declspecs->specs[(int)ds_typedef])
	{
	error ("typedef declaration invalid in parameter declaration");
	return error_mark_node;
	}
	else if (storage_class == sc_static
	\|\| storage_class == sc_extern
	\|\| thread_p)
	error ("storage class specifiers invalid in parameter declarations");
	}

	/* Give error if `virtual' is used outside of class declaration. */
	if (virtualp
	&& (current_class_name == NULL_TREE \|\| decl_context != FIELD))
	{
	error ("virtual outside class declaration");
	virtualp = 0;
	}

	/* Static anonymous unions are dealt with here. */
	if (staticp && decl_context == TYPENAME
	&& declspecs->type
	&& ANON_AGGR_TYPE_P (declspecs->type))
	decl_context = FIELD;

	/* Warn about storage classes that are invalid for certain
	kinds of declarations (parameters, typenames, etc.). */
	if (thread_p
	&& ((storage_class
	&& storage_class != sc_extern
	&& storage_class != sc_static)
	\|\| declspecs->specs[(int)ds_typedef]))
	{
	error ("multiple storage classes in declaration of %qs", name);
	thread_p = false;
	}
	if (declspecs->conflicting_specifiers_p)
	{
	error ("conflicting specifiers in declaration of %qs", name);
	storage_class = sc_none;
	}
	else if (decl_context != NORMAL
	&& ((storage_class != sc_none
	&& storage_class != sc_mutable)
	\|\| thread_p))
	{
	if ((decl_context == PARM \|\| decl_context == CATCHPARM)
	&& (storage_class == sc_register
	\|\| storage_class == sc_auto))
	;
	else if (declspecs->specs[(int)ds_typedef])
	;
	else if (decl_context == FIELD
	/* C++ allows static class elements. */
	&& storage_class == sc_static)
	/* C++ also allows inlines and signed and unsigned elements,
	but in those cases we don't come in here. */
	;
	else
	{
	if (decl_context == FIELD)
	error ("storage class specified for %qs", name);
	else
	{
	if (decl_context == PARM \|\| decl_context == CATCHPARM)
	error ("storage class specified for parameter %qs", name);
	else
	error ("storage class specified for typename");
	}
	if (storage_class == sc_register
	\|\| storage_class == sc_auto
	\|\| storage_class == sc_extern
	\|\| thread_p)
	storage_class = sc_none;
	}
	}
	else if (storage_class == sc_extern && initialized
	&& !funcdef_flag)
	{
	if (toplevel_bindings_p ())
	{
	/* It's common practice (and completely valid) to have a const
	be initialized and declared extern. */
	if (!(type_quals & TYPE_QUAL_CONST))
	warning (0, "%qs initialized and declared %<extern%>", name);
	}
	else
	error ("%qs has both %<extern%> and initializer", name);
	}
	else if (storage_class == sc_extern && funcdef_flag
	&& ! toplevel_bindings_p ())
	error ("nested function %qs declared %<extern%>", name);
	else if (toplevel_bindings_p ())
	{
	if (storage_class == sc_auto)
	error ("top-level declaration of %qs specifies %<auto%>", name);
	}
	else if (thread_p
	&& storage_class != sc_extern
	&& storage_class != sc_static)
	{
	error ("function-scope %qs implicitly auto and declared %<__thread%>",
	name);
	thread_p = false;
	}

	if (storage_class && friendp)
	error ("storage class specifiers invalid in friend function declarations");

	if (!id_declarator)
	unqualified_id = NULL_TREE;
	else
	{
	unqualified_id = id_declarator->u.id.unqualified_name;
	switch (TREE_CODE (unqualified_id))
	{
	case BIT_NOT_EXPR:
	unqualified_id
	= constructor_name (TREE_OPERAND (unqualified_id, 0));
	break;

	case IDENTIFIER_NODE:
	case TEMPLATE_ID_EXPR:
	break;

	default:
	gcc_unreachable ();
	}
	}

	/* Determine the type of the entity declared by recurring on the
	declarator. */
	for (; declarator; declarator = declarator->declarator)
	{
	const cp_declarator *inner_declarator;
	tree attrs;

	if (type == error_mark_node)
	return error_mark_node;

	attrs = declarator->attributes;
	if (attrs)
	{
	int attr_flags;

	attr_flags = 0;
	if (declarator == NULL \|\| declarator->kind == cdk_id)
	attr_flags \|= (int) ATTR_FLAG_DECL_NEXT;
	if (declarator->kind == cdk_function)
	attr_flags \|= (int) ATTR_FLAG_FUNCTION_NEXT;
	if (declarator->kind == cdk_array)
	attr_flags \|= (int) ATTR_FLAG_ARRAY_NEXT;
	returned_attrs = decl_attributes (&type,
	chainon (returned_attrs, attrs),
	attr_flags);
	}

	if (declarator->kind == cdk_id)
	break;

	inner_declarator = declarator->declarator;

	switch (declarator->kind)
	{
	case cdk_array:
	type = create_array_type_for_decl (dname, type,
	declarator->u.array.bounds);
	break;

	case cdk_function:
	{
	tree arg_types;
	int funcdecl_p;

	/* Declaring a function type.
	Make sure we have a valid type for the function to return. */

	/* We now know that the TYPE_QUALS don't apply to the
	decl, but to its return type. */
	type_quals = TYPE_UNQUALIFIED;

	/* Warn about some types functions can't return. */

	if (TREE_CODE (type) == FUNCTION_TYPE)
	{
	error ("%qs declared as function returning a function", name);
	type = integer_type_node;
	}
	if (TREE_CODE (type) == ARRAY_TYPE)
	{
	error ("%qs declared as function returning an array", name);
	type = integer_type_node;
	}

	/* Pick up type qualifiers which should be applied to `this'. */
	memfn_quals = declarator->u.function.qualifiers;

	/* Pick up the exception specifications. */
	raises = declarator->u.function.exception_specification;

	/* Say it's a definition only for the CALL_EXPR
	closest to the identifier. */
	funcdecl_p = inner_declarator && inner_declarator->kind == cdk_id;

	if (ctype == NULL_TREE
	&& decl_context == FIELD
	&& funcdecl_p
	&& (friendp == 0 \|\| dname == current_class_name))
	ctype = current_class_type;

	if (ctype && (sfk == sfk_constructor
	\|\| sfk == sfk_destructor))
	{
	/* We are within a class's scope. If our declarator name
	is the same as the class name, and we are defining
	a function, then it is a constructor/destructor, and
	therefore returns a void type. */

	/* ISO C++ 12.4/2. A destructor may not be declared
	const or volatile. A destructor may not be
	static.

	ISO C++ 12.1. A constructor may not be declared
	const or volatile. A constructor may not be
	virtual. A constructor may not be static. */
	if (staticp == 2)
	error ((flags == DTOR_FLAG)
	? "destructor cannot be static member function"
	: "constructor cannot be static member function");
	if (memfn_quals)
	{
	error ((flags == DTOR_FLAG)
	? "destructors may not be cv-qualified"
	: "constructors may not be cv-qualified");
	memfn_quals = TYPE_UNQUALIFIED;
	}

	if (decl_context == FIELD
	&& !member_function_or_else (ctype,
	current_class_type,
	flags))
	return error_mark_node;

	if (flags != DTOR_FLAG)
	{
	/* It's a constructor. */
	if (explicitp == 1)
	explicitp = 2;
	if (virtualp)
	{
	pedwarn ("constructors cannot be declared virtual");
	virtualp = 0;
	}
	if (decl_context == FIELD
	&& sfk != sfk_constructor)
	return error_mark_node;
	}
	if (decl_context == FIELD)
	staticp = 0;
	}
	else if (friendp)
	{
	if (initialized)
	error ("can't initialize friend function %qs", name);
	if (virtualp)
	{
	/* Cannot be both friend and virtual. */
	error ("virtual functions cannot be friends");
	friendp = 0;
	}
	if (decl_context == NORMAL)
	error ("friend declaration not in class definition");
	if (current_function_decl && funcdef_flag)
	error ("can't define friend function %qs in a local "
	"class definition",
	name);
	}

	arg_types = grokparms (declarator->u.function.parameters,
	&parms);

	if (inner_declarator
	&& inner_declarator->kind == cdk_id
	&& inner_declarator->u.id.sfk == sfk_destructor
	&& arg_types != void_list_node)
	{
	error ("destructors may not have parameters");
	arg_types = void_list_node;
	parms = NULL_TREE;
	}

	type = build_function_type (type, arg_types);
	}
	break;

	case cdk_pointer:
	case cdk_reference:
	case cdk_ptrmem:
	/* Filter out pointers-to-references and references-to-references.
	We can get these if a TYPE_DECL is used. */

	if (TREE_CODE (type) == REFERENCE_TYPE)
	{
	error (declarator->kind == cdk_reference
	? "cannot declare reference to %q#T"
	: "cannot declare pointer to %q#T", type);
	type = TREE_TYPE (type);
	}
	else if (VOID_TYPE_P (type))
	{
	if (declarator->kind == cdk_reference)
	error ("cannot declare reference to %q#T", type);
	else if (declarator->kind == cdk_ptrmem)
	error ("cannot declare pointer to %q#T member", type);
	}

	/* We now know that the TYPE_QUALS don't apply to the decl,
	but to the target of the pointer. */
	type_quals = TYPE_UNQUALIFIED;

	if (declarator->kind == cdk_ptrmem
	&& (TREE_CODE (type) == FUNCTION_TYPE \|\| memfn_quals))
	{
	memfn_quals \|= cp_type_quals (type);
	type = build_memfn_type (type,
	declarator->u.pointer.class_type,
	memfn_quals);
	memfn_quals = TYPE_UNQUALIFIED;
	}

	if (declarator->kind == cdk_reference)
	{
	if (!VOID_TYPE_P (type))
	type = build_reference_type (type);
	}
	else if (TREE_CODE (type) == METHOD_TYPE)
	type = build_ptrmemfunc_type (build_pointer_type (type));
	else if (declarator->kind == cdk_ptrmem)
	{
	gcc_assert (TREE_CODE (declarator->u.pointer.class_type)
	!= NAMESPACE_DECL);
	if (declarator->u.pointer.class_type == error_mark_node)
	/* We will already have complained. */
	type = error_mark_node;
	else
	type = build_ptrmem_type (declarator->u.pointer.class_type,
	type);
	}
	else
	type = build_pointer_type (type);

	/* Process a list of type modifier keywords (such as
	const or volatile) that were given inside the `' or `&'. /

	if (declarator->u.pointer.qualifiers)
	{
	type
	= cp_build_qualified_type (type,
	declarator->u.pointer.qualifiers);
	type_quals = cp_type_quals (type);
	}
	ctype = NULL_TREE;
	break;

	case cdk_error:
	break;

	default:
	gcc_unreachable ();
	}
	}

	if (unqualified_id && TREE_CODE (unqualified_id) == TEMPLATE_ID_EXPR
	&& TREE_CODE (type) != FUNCTION_TYPE
	&& TREE_CODE (type) != METHOD_TYPE)
	{
	error ("template-id %qD used as a declarator",
	unqualified_id);
	unqualified_id = dname;
	}

	/* If TYPE is a FUNCTION_TYPE, but the function name was explicitly
	qualified with a class-name, turn it into a METHOD_TYPE, unless
	we know that the function is static. We take advantage of this
	opportunity to do other processing that pertains to entities
	explicitly declared to be class members. Note that if DECLARATOR
	is non-NULL, we know it is a cdk_id declarator; otherwise, we
	would not have exited the loop above. */
	if (declarator
	&& declarator->u.id.qualifying_scope
	&& TYPE_P (declarator->u.id.qualifying_scope))
	{
	tree t;

	ctype = declarator->u.id.qualifying_scope;
	ctype = TYPE_MAIN_VARIANT (ctype);
	t = ctype;
	while (t != NULL_TREE && CLASS_TYPE_P (t))
	{
	/* You're supposed to have one `template <...>' for every
	template class, but you don't need one for a full
	specialization. For example:

	template <class T> struct S{};
	template <> struct S<int> { void f(); };
	void S<int>::f () {}

	is correct; there shouldn't be a `template <>' for the
	definition of `S<int>::f'. */
	if (CLASSTYPE_TEMPLATE_SPECIALIZATION (t)
	&& !any_dependent_template_arguments_p (CLASSTYPE_TI_ARGS (t)))
	/* T is an explicit (not partial) specialization. All
	containing classes must therefore also be explicitly
	specialized. */
	break;
	if ((CLASSTYPE_USE_TEMPLATE (t) \|\| CLASSTYPE_IS_TEMPLATE (t))
	&& PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (t)))
	template_count += 1;

	t = TYPE_MAIN_DECL (t);
	t = DECL_CONTEXT (t);
	}

	if (ctype == current_class_type)
	{
	if (friendp)
	pedwarn ("member functions are implicitly friends of their class");
	else
	pedwarn ("extra qualification %<%T::%> on member %qs",
	ctype, name);
	}
	else if (/* If the qualifying type is already complete, then we
	can skip the following checks. */
	!COMPLETE_TYPE_P (ctype)
	&& (/* If the function is being defined, then
	qualifying type must certainly be complete. */
	funcdef_flag
	/* A friend declaration of "T::f" is OK, even if
	"T" is a template parameter. But, if this
	function is not a friend, the qualifying type
	must be a class. */
	\|\| (!friendp && !CLASS_TYPE_P (ctype))
	/* For a declaration, the type need not be
	complete, if either it is dependent (since there
	is no meaningful definition of complete in that
	case) or the qualifying class is currently being
	defined. */
	\|\| !(dependent_type_p (ctype)
	\|\| currently_open_class (ctype)))
	/* Check that the qualifying type is complete. */
	&& !complete_type_or_else (ctype, NULL_TREE))
	return error_mark_node;
	else if (TREE_CODE (type) == FUNCTION_TYPE)
	{
	tree sname = declarator->u.id.unqualified_name;

	if (current_class_type
	&& (!friendp \|\| funcdef_flag))
	{
	error (funcdef_flag
	? "cannot define member function %<%T::%s%> within %<%T%>"
	: "cannot declare member function %<%T::%s%> within %<%T%>",
	ctype, name, current_class_type);
	return error_mark_node;
	}

	if (TREE_CODE (sname) == IDENTIFIER_NODE
	&& NEW_DELETE_OPNAME_P (sname))
	/* Overloaded operator new and operator delete
	are always static functions. */
	;
	else
	type = build_memfn_type (type, ctype, memfn_quals);
	}
	else if (declspecs->specs[(int)ds_typedef]
	&& current_class_type)
	{
	error ("cannot declare member %<%T::%s%> within %qT",
	ctype, name, current_class_type);
	return error_mark_node;
	}
	}

	/* Now TYPE has the actual type. */

	if (returned_attrs)
	{
	if (attrlist)
	attrlist = chainon (returned_attrs, attrlist);
	else
	attrlist = &returned_attrs;
	}

	/* Did array size calculations overflow? */

	if (TREE_CODE (type) == ARRAY_TYPE
	&& COMPLETE_TYPE_P (type)
	&& TREE_CODE (TYPE_SIZE_UNIT (type)) == INTEGER_CST
	&& TREE_OVERFLOW (TYPE_SIZE_UNIT (type)))
	{
	error ("size of array %qs is too large", name);
	/* If we proceed with the array type as it is, we'll eventually
	crash in tree_low_cst(). */
	type = error_mark_node;
	}

	if ((decl_context == FIELD \|\| decl_context == PARM)
	&& !processing_template_decl
	&& variably_modified_type_p (type, NULL_TREE))
	{
	if (decl_context == FIELD)
	error ("data member may not have variably modified type %qT", type);
	else
	error ("parameter may not have variably modified type %qT", type);
	type = error_mark_node;
	}

	if (explicitp == 1 \|\| (explicitp && friendp))
	{
	/* [dcl.fct.spec] The explicit specifier shall only be used in
	declarations of constructors within a class definition. */
	error ("only declarations of constructors can be %<explicit%>");
	explicitp = 0;
	}

	if (storage_class == sc_mutable)
	{
	if (decl_context != FIELD \|\| friendp)
	{
	error ("non-member %qs cannot be declared %<mutable%>", name);
	storage_class = sc_none;
	}
	else if (decl_context == TYPENAME \|\| declspecs->specs[(int)ds_typedef])
	{
	error ("non-object member %qs cannot be declared %<mutable%>", name);
	storage_class = sc_none;
	}
	else if (TREE_CODE (type) == FUNCTION_TYPE
	\|\| TREE_CODE (type) == METHOD_TYPE)
	{
	error ("function %qs cannot be declared %<mutable%>", name);
	storage_class = sc_none;
	}
	else if (staticp)
	{
	error ("static %qs cannot be declared %<mutable%>", name);
	storage_class = sc_none;
	}
	else if (type_quals & TYPE_QUAL_CONST)
	{
	error ("const %qs cannot be declared %<mutable%>", name);
	storage_class = sc_none;
	}
	}

	/* If this is declaring a typedef name, return a TYPE_DECL. */
	if (declspecs->specs[(int)ds_typedef] && decl_context != TYPENAME)
	{
	tree decl;

	/* Note that the grammar rejects storage classes
	in typenames, fields or parameters. */
	if (current_lang_name == lang_name_java)
	TYPE_FOR_JAVA (type) = 1;

	/* This declaration:

	typedef void f(int) const;

	declares a function type which is not a member of any
	particular class, but which is cv-qualified; for
	example "f S::*" declares a pointer to a const-qualified
	member function of S. We record the cv-qualification in the
	function type. */
	if (memfn_quals && TREE_CODE (type) == FUNCTION_TYPE)
	type = cp_build_qualified_type (type, memfn_quals);

	if (decl_context == FIELD)
	decl = build_lang_decl (TYPE_DECL, unqualified_id, type);
	else
	decl = build_decl (TYPE_DECL, unqualified_id, type);
	if (id_declarator && declarator->u.id.qualifying_scope)
	error ("%Jtypedef name may not be a nested-name-specifier", decl);

	if (decl_context != FIELD)
	{
	if (!current_function_decl)
	DECL_CONTEXT (decl) = FROB_CONTEXT (current_namespace);
	else if (DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (current_function_decl)
	\|\| (DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P
	(current_function_decl)))
	/* The TYPE_DECL is "abstract" because there will be
	clones of this constructor/destructor, and there will
	be copies of this TYPE_DECL generated in those
	clones. */
	DECL_ABSTRACT (decl) = 1;
	}
	else if (constructor_name_p (unqualified_id, current_class_type))
	pedwarn ("ISO C++ forbids nested type %qD with same name "
	"as enclosing class",
	unqualified_id);

	/* If the user declares "typedef struct {...} foo" then the
	struct will have an anonymous name. Fill that name in now.
	Nothing can refer to it, so nothing needs know about the name
	change. */
	if (type != error_mark_node
	&& unqualified_id
	&& TYPE_NAME (type)
	&& TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
	&& TYPE_ANONYMOUS_P (type)
	/* Don't do this if there are attributes. */
	&& (!attrlist \|\| !*attrlist)
	&& cp_type_quals (type) == TYPE_UNQUALIFIED)
	{
	tree oldname = TYPE_NAME (type);
	tree t;

	/* Replace the anonymous name with the real name everywhere. */
	for (t = TYPE_MAIN_VARIANT (type); t; t = TYPE_NEXT_VARIANT (t))
	if (TYPE_NAME (t) == oldname)
	TYPE_NAME (t) = decl;

	if (TYPE_LANG_SPECIFIC (type))
	TYPE_WAS_ANONYMOUS (type) = 1;

	/* If this is a typedef within a template class, the nested
	type is a (non-primary) template. The name for the
	template needs updating as well. */
	if (TYPE_LANG_SPECIFIC (type) && CLASSTYPE_TEMPLATE_INFO (type))
	DECL_NAME (CLASSTYPE_TI_TEMPLATE (type))
	= TYPE_IDENTIFIER (type);

	/* FIXME remangle member functions; member functions of a
	type with external linkage have external linkage. */
	}

	/* Any qualifiers on a function type typedef have already been
	dealt with. */
	if (memfn_quals && !ctype && TREE_CODE (type) == FUNCTION_TYPE)
	memfn_quals = TYPE_UNQUALIFIED;

	if (signed_p
	\|\| (typedef_decl && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl)))
	C_TYPEDEF_EXPLICITLY_SIGNED (decl) = 1;

	bad_specifiers (decl, "type", virtualp,
	memfn_quals != TYPE_UNQUALIFIED,
	inlinep, friendp, raises != NULL_TREE);

	return decl;
	}

	/* Detect the case of an array type of unspecified size
	which came, as such, direct from a typedef name.
	We must copy the type, so that the array's domain can be
	individually set by the object's initializer. */

	if (type && typedef_type
	&& TREE_CODE (type) == ARRAY_TYPE && !TYPE_DOMAIN (type)
	&& TYPE_MAIN_VARIANT (type) == TYPE_MAIN_VARIANT (typedef_type))
	type = build_cplus_array_type (TREE_TYPE (type), NULL_TREE);

	/* Detect where we're using a typedef of function type to declare a
	function. PARMS will not be set, so we must create it now. */

	if (type == typedef_type && TREE_CODE (type) == FUNCTION_TYPE)
	{
	tree decls = NULL_TREE;
	tree args;

	for (args = TYPE_ARG_TYPES (type); args; args = TREE_CHAIN (args))
	{
	tree decl = cp_build_parm_decl (NULL_TREE, TREE_VALUE (args));

	TREE_CHAIN (decl) = decls;
	decls = decl;
	}

	parms = nreverse (decls);

	if (decl_context != TYPENAME)
	{
	/* A cv-qualifier-seq shall only be part of the function type
	for a non-static member function. [8.3.5/4 dcl.fct] */
	if (cp_type_quals (type) != TYPE_UNQUALIFIED
	&& (current_class_type == NULL_TREE \|\| staticp) )
	{
	error ("qualified function types cannot be used to declare %s functions",
	(staticp? "static member" : "free"));
	type = TYPE_MAIN_VARIANT (type);
	}

	/* The qualifiers on the function type become the qualifiers on
	the non-static member function. */
	memfn_quals \|= cp_type_quals (type);
	}
	}

	/* If this is a type name (such as, in a cast or sizeof),
	compute the type and return it now. */

	if (decl_context == TYPENAME)
	{
	/* Note that the grammar rejects storage classes
	in typenames, fields or parameters. */
	if (type_quals != TYPE_UNQUALIFIED)
	type_quals = TYPE_UNQUALIFIED;

	/* Special case: "friend class foo" looks like a TYPENAME context. */
	if (friendp)
	{
	if (type_quals != TYPE_UNQUALIFIED)
	{
	error ("type qualifiers specified for friend class declaration");
	type_quals = TYPE_UNQUALIFIED;
	}
	if (inlinep)
	{
	error ("%<inline%> specified for friend class declaration");
	inlinep = 0;
	}

	if (!current_aggr)
	{
	/* Don't allow friend declaration without a class-key. */
	if (TREE_CODE (type) == TEMPLATE_TYPE_PARM)
	pedwarn ("template parameters cannot be friends");
	else if (TREE_CODE (type) == TYPENAME_TYPE)
	pedwarn ("friend declaration requires class-key, "
	"i.e. %<friend class %T::%D%>",
	TYPE_CONTEXT (type), TYPENAME_TYPE_FULLNAME (type));
	else
	pedwarn ("friend declaration requires class-key, "
	"i.e. %<friend %#T%>",
	type);
	}

	/* Only try to do this stuff if we didn't already give up. */
	if (type != integer_type_node)
	{
	/* A friendly class? */
	if (current_class_type)
	make_friend_class (current_class_type, TYPE_MAIN_VARIANT (type),
	/complain=/true);
	else
	error ("trying to make class %qT a friend of global scope",
	type);

	type = void_type_node;
	}
	}
	else if (memfn_quals)
	{
	if (ctype == NULL_TREE)
	{
	if (TREE_CODE (type) != METHOD_TYPE)
	error ("invalid qualifiers on non-member function type");
	else
	ctype = TYPE_METHOD_BASETYPE (type);
	}
	if (ctype)
	type = build_memfn_type (type, ctype, memfn_quals);
	}

	return type;
	}
	else if (unqualified_id == NULL_TREE && decl_context != PARM
	&& decl_context != CATCHPARM
	&& TREE_CODE (type) != UNION_TYPE
	&& ! bitfield)
	{
	error ("abstract declarator %qT used as declaration", type);
	return error_mark_node;
	}

	/* Only functions may be declared using an operator-function-id. */
	if (unqualified_id
	&& IDENTIFIER_OPNAME_P (unqualified_id)
	&& TREE_CODE (type) != FUNCTION_TYPE
	&& TREE_CODE (type) != METHOD_TYPE)
	{
	error ("declaration of %qD as non-function", unqualified_id);
	return error_mark_node;
	}

	/* We don't check parameter types here because we can emit a better
	error message later. */
	if (decl_context != PARM)
	{
	type = check_var_type (unqualified_id, type);
	if (type == error_mark_node)
	return error_mark_node;
	}

	/* Now create the decl, which may be a VAR_DECL, a PARM_DECL
	or a FUNCTION_DECL, depending on DECL_CONTEXT and TYPE. */

	if (decl_context == PARM \|\| decl_context == CATCHPARM)
	{
	if (ctype \|\| in_namespace)
	error ("cannot use %<::%> in parameter declaration");

	/* A parameter declared as an array of T is really a pointer to T.
	One declared as a function is really a pointer to a function.
	One declared as a member is really a pointer to member. */

	if (TREE_CODE (type) == ARRAY_TYPE)
	{
	/* Transfer const-ness of array into that of type pointed to. */
	type = build_pointer_type (TREE_TYPE (type));
	type_quals = TYPE_UNQUALIFIED;
	}
	else if (TREE_CODE (type) == FUNCTION_TYPE)
	type = build_pointer_type (type);
	}

	{
	tree decl;

	if (decl_context == PARM)
	{
	decl = cp_build_parm_decl (unqualified_id, type);

	bad_specifiers (decl, "parameter", virtualp,
	memfn_quals != TYPE_UNQUALIFIED,
	inlinep, friendp, raises != NULL_TREE);
	}
	else if (decl_context == FIELD)
	{
	/* The C99 flexible array extension. */
	if (!staticp && TREE_CODE (type) == ARRAY_TYPE
	&& TYPE_DOMAIN (type) == NULL_TREE)
	{
	tree itype = compute_array_index_type (dname, integer_zero_node);
	type = build_cplus_array_type (TREE_TYPE (type), itype);
	}

	if (type == error_mark_node)
	{
	/* Happens when declaring arrays of sizes which
	are error_mark_node, for example. */
	decl = NULL_TREE;
	}
	else if (in_namespace && !friendp)
	{
	/* Something like struct S { int N::j; }; */
	error ("invalid use of %<::%>");
	return error_mark_node;
	}
	else if (TREE_CODE (type) == FUNCTION_TYPE)
	{
	int publicp = 0;
	tree function_context;

	if (friendp == 0)
	{
	if (ctype == NULL_TREE)
	ctype = current_class_type;

	if (ctype == NULL_TREE)
	{
	error ("can't make %qD into a method -- not in a class",
	unqualified_id);
	return error_mark_node;
	}

	/* ``A union may [ ... ] not [ have ] virtual functions.''
	ARM 9.5 */
	if (virtualp && TREE_CODE (ctype) == UNION_TYPE)
	{
	error ("function %qD declared virtual inside a union",
	unqualified_id);
	return error_mark_node;
	}

	if (NEW_DELETE_OPNAME_P (unqualified_id))
	{
	if (virtualp)
	{
	error ("%qD cannot be declared virtual, since it "
	"is always static",
	unqualified_id);
	virtualp = 0;
	}
	}
	else if (staticp < 2)
	type = build_memfn_type (type, ctype, memfn_quals);
	}

	/* Check that the name used for a destructor makes sense. */
	if (sfk == sfk_destructor)
	{
	if (!ctype)
	{
	gcc_assert (friendp);
	error ("expected qualified name in friend declaration "
	"for destructor %qD",
	id_declarator->u.id.unqualified_name);
	return error_mark_node;
	}

	if (!same_type_p (TREE_OPERAND
	(id_declarator->u.id.unqualified_name, 0),
	ctype))
	{
	error ("declaration of %qD as member of %qT",
	id_declarator->u.id.unqualified_name, ctype);
	return error_mark_node;
	}
	}

	/* Tell grokfndecl if it needs to set TREE_PUBLIC on the node. */
	function_context = (ctype != NULL_TREE) ?
	decl_function_context (TYPE_MAIN_DECL (ctype)) : NULL_TREE;
	publicp = (! friendp \|\| ! staticp)
	&& function_context == NULL_TREE;
	decl = grokfndecl (ctype, type,
	TREE_CODE (unqualified_id) != TEMPLATE_ID_EXPR
	? unqualified_id : dname,
	parms,
	unqualified_id,
	virtualp, flags, memfn_quals, raises,
	friendp ? -1 : 0, friendp, publicp, inlinep,
	sfk,
	funcdef_flag, template_count, in_namespace, attrlist);
	if (decl == NULL_TREE)
	return error_mark_node;
	#if 0
	/* This clobbers the attrs stored in `decl' from `attrlist'. */
	/* The decl and setting of decl_attr is also turned off. */
	decl = build_decl_attribute_variant (decl, decl_attr);
	#endif

	/* [class.conv.ctor]

	A constructor declared without the function-specifier
	explicit that can be called with a single parameter
	specifies a conversion from the type of its first
	parameter to the type of its class. Such a constructor
	is called a converting constructor. */
	if (explicitp == 2)
	DECL_NONCONVERTING_P (decl) = 1;
	else if (DECL_CONSTRUCTOR_P (decl))
	{
	/* The constructor can be called with exactly one
	parameter if there is at least one parameter, and
	any subsequent parameters have default arguments.
	Ignore any compiler-added parms. */
	tree arg_types = FUNCTION_FIRST_USER_PARMTYPE (decl);

	if (arg_types == void_list_node
	\|\| (arg_types
	&& TREE_CHAIN (arg_types)
	&& TREE_CHAIN (arg_types) != void_list_node
	&& !TREE_PURPOSE (TREE_CHAIN (arg_types))))
	DECL_NONCONVERTING_P (decl) = 1;
	}
	}
	else if (TREE_CODE (type) == METHOD_TYPE)
	{
	/* We only get here for friend declarations of
	members of other classes. */
	/* All method decls are public, so tell grokfndecl to set
	TREE_PUBLIC, also. */
	decl = grokfndecl (ctype, type,
	TREE_CODE (unqualified_id) != TEMPLATE_ID_EXPR
	? unqualified_id : dname,
	parms,
	unqualified_id,
	virtualp, flags, memfn_quals, raises,
	friendp ? -1 : 0, friendp, 1, 0, sfk,
	funcdef_flag, template_count, in_namespace,
	attrlist);
	if (decl == NULL_TREE)
	return error_mark_node;
	}
	else if (!staticp && !dependent_type_p (type)
	&& !COMPLETE_TYPE_P (complete_type (type))
	&& (TREE_CODE (type) != ARRAY_TYPE \|\| initialized == 0))
	{
	if (unqualified_id)
	error ("field %qD has incomplete type", unqualified_id);
	else
	error ("name %qT has incomplete type", type);

	/* If we're instantiating a template, tell them which
	instantiation made the field's type be incomplete. */
	if (current_class_type
	&& TYPE_NAME (current_class_type)
	&& IDENTIFIER_TEMPLATE (TYPE_IDENTIFIER (current_class_type))
	&& declspecs->type
	&& declspecs->type == type)
	error (" in instantiation of template %qT",
	current_class_type);

	return error_mark_node;
	}
	else
	{
	if (friendp)
	{
	error ("%qE is neither function nor member function; "
	"cannot be declared friend", unqualified_id);
	friendp = 0;
	}
	decl = NULL_TREE;
	}

	if (friendp)
	{
	/* Friends are treated specially. */
	if (ctype == current_class_type)
	; /* We already issued a pedwarn. */
	else if (decl && DECL_NAME (decl))
	{
	if (template_class_depth (current_class_type) == 0)
	{
	decl = check_explicit_specialization
	(unqualified_id, decl, template_count,
	2 * funcdef_flag + 4);
	if (decl == error_mark_node)
	return error_mark_node;
	}

	decl = do_friend (ctype, unqualified_id, decl,
	*attrlist, flags,
	funcdef_flag);
	return decl;
	}
	else
	return error_mark_node;
	}

	/* Structure field. It may not be a function, except for C++. */

	if (decl == NULL_TREE)
	{
	if (initialized)
	{
	if (!staticp)
	{
	/* An attempt is being made to initialize a non-static
	member. But, from [class.mem]:

	4 A member-declarator can contain a
	constant-initializer only if it declares a static
	member (_class.static_) of integral or enumeration
	type, see _class.static.data_.

	This used to be relatively common practice, but
	the rest of the compiler does not correctly
	handle the initialization unless the member is
	static so we make it static below. */
	pedwarn ("ISO C++ forbids initialization of member %qD",
	unqualified_id);
	pedwarn ("making %qD static", unqualified_id);
	staticp = 1;
	}

	if (uses_template_parms (type))
	/* We'll check at instantiation time. */
	;
	else if (check_static_variable_definition (unqualified_id,
	type))
	/* If we just return the declaration, crashes
	will sometimes occur. We therefore return
	void_type_node, as if this was a friend
	declaration, to cause callers to completely
	ignore this declaration. */
	return error_mark_node;
	}

	if (staticp)
	{
	/* C++ allows static class members. All other work
	for this is done by grokfield. */
	decl = build_lang_decl (VAR_DECL, unqualified_id, type);
	set_linkage_for_static_data_member (decl);
	/* Even if there is an in-class initialization, DECL
	is considered undefined until an out-of-class
	definition is provided. */
	DECL_EXTERNAL (decl) = 1;

	if (thread_p)
	{
	if (targetm.have_tls)
	DECL_TLS_MODEL (decl) = decl_default_tls_model (decl);
	else
	/* A mere warning is sure to result in improper
	semantics at runtime. Don't bother to allow this to
	compile. */
	error ("thread-local storage not supported for this target");
	}
	}
	else
	{
	decl = build_decl (FIELD_DECL, unqualified_id, type);
	DECL_NONADDRESSABLE_P (decl) = bitfield;
	if (storage_class == sc_mutable)
	{
	DECL_MUTABLE_P (decl) = 1;
	storage_class = sc_none;
	}
	}

	bad_specifiers (decl, "field", virtualp,
	memfn_quals != TYPE_UNQUALIFIED,
	inlinep, friendp, raises != NULL_TREE);
	}
	}
	else if (TREE_CODE (type) == FUNCTION_TYPE
	\|\| TREE_CODE (type) == METHOD_TYPE)
	{
	tree original_name;
	int publicp = 0;

	if (!unqualified_id)
	return error_mark_node;

	if (TREE_CODE (unqualified_id) == TEMPLATE_ID_EXPR)
	original_name = dname;
	else
	original_name = unqualified_id;

	if (storage_class == sc_auto)
	error ("storage class %<auto%> invalid for function %qs", name);
	else if (storage_class == sc_register)
	error ("storage class %<register%> invalid for function %qs", name);
	else if (thread_p)
	error ("storage class %<__thread%> invalid for function %qs", name);

	/* Function declaration not at top level.
	Storage classes other than `extern' are not allowed
	and `extern' makes no difference. */
	if (! toplevel_bindings_p ()
	&& (storage_class == sc_static
	\|\| declspecs->specs[(int)ds_inline])
	&& pedantic)
	{
	if (storage_class == sc_static)
	pedwarn ("%<static%> specified invalid for function %qs "
	"declared out of global scope", name);
	else
	pedwarn ("%<inline%> specifier invalid for function %qs "
	"declared out of global scope", name);
	}

	if (ctype == NULL_TREE)
	{
	if (virtualp)
	{
	error ("virtual non-class function %qs", name);
	virtualp = 0;
	}
	}
	else if (TREE_CODE (type) == FUNCTION_TYPE && staticp < 2
	&& !NEW_DELETE_OPNAME_P (original_name))
	type = build_method_type_directly (ctype,
	TREE_TYPE (type),
	TYPE_ARG_TYPES (type));

	/* Record presence of `static'. */
	publicp = (ctype != NULL_TREE
	\|\| storage_class == sc_extern
	\|\| storage_class != sc_static);

	decl = grokfndecl (ctype, type, original_name, parms, unqualified_id,
	virtualp, flags, memfn_quals, raises,
	1, friendp,
	publicp, inlinep, sfk, funcdef_flag,
	template_count, in_namespace, attrlist);
	if (decl == NULL_TREE)
	return error_mark_node;

	if (staticp == 1)
	{
	int invalid_static = 0;

	/* Don't allow a static member function in a class, and forbid
	declaring main to be static. */
	if (TREE_CODE (type) == METHOD_TYPE)
	{
	pedwarn ("cannot declare member function %qD to have "
	"static linkage", decl);
	invalid_static = 1;
	}
	else if (current_function_decl)
	{
	/* FIXME need arm citation */
	error ("cannot declare static function inside another function");
	invalid_static = 1;
	}

	if (invalid_static)
	{
	staticp = 0;
	storage_class = sc_none;
	}
	}
	}
	else
	{
	/* It's a variable. */

	/* An uninitialized decl with `extern' is a reference. */
	decl = grokvardecl (type, unqualified_id,
	declspecs,
	initialized,
	(type_quals & TYPE_QUAL_CONST) != 0,
	ctype ? ctype : in_namespace);
	bad_specifiers (decl, "variable", virtualp,
	memfn_quals != TYPE_UNQUALIFIED,
	inlinep, friendp, raises != NULL_TREE);

	if (ctype)
	{
	DECL_CONTEXT (decl) = ctype;
	if (staticp == 1)
	{
	pedwarn ("%<static%> may not be used when defining "
	"(as opposed to declaring) a static data member");
	staticp = 0;
	storage_class = sc_none;
	}
	if (storage_class == sc_register && TREE_STATIC (decl))
	{
	error ("static member %qD declared %<register%>", decl);
	storage_class = sc_none;
	}
	if (storage_class == sc_extern && pedantic)
	{
	pedwarn ("cannot explicitly declare member %q#D to have "
	"extern linkage",
	decl);
	storage_class = sc_none;
	}
	}
	}

	/* Record `register' declaration for warnings on &
	and in case doing stupid register allocation. */

	if (storage_class == sc_register)
	DECL_REGISTER (decl) = 1;
	else if (storage_class == sc_extern)
	DECL_THIS_EXTERN (decl) = 1;
	else if (storage_class == sc_static)
	DECL_THIS_STATIC (decl) = 1;

	/* Record constancy and volatility. There's no need to do this
	when processing a template; we'll do this for the instantiated
	declaration based on the type of DECL. */
	if (!processing_template_decl)
	cp_apply_type_quals_to_decl (type_quals, decl);

	return decl;
	}
	}

	/* Subroutine of start_function. Ensure that each of the parameter
	types (as listed in PARMS) is complete, as is required for a
	function definition. */

	static void
	require_complete_types_for_parms (tree parms)
	{
	for (; parms; parms = TREE_CHAIN (parms))
	{
	if (dependent_type_p (TREE_TYPE (parms)))
	continue;
	if (!VOID_TYPE_P (TREE_TYPE (parms))
	&& complete_type_or_else (TREE_TYPE (parms), parms))
	{
	relayout_decl (parms);
	DECL_ARG_TYPE (parms) = type_passed_as (TREE_TYPE (parms));
	}
	else
	/* grokparms or complete_type_or_else will have already issued
	an error. */
	TREE_TYPE (parms) = error_mark_node;
	}
	}

	/* Returns nonzero if T is a local variable. */

	int
	local_variable_p (tree t)
	{
	if ((TREE_CODE (t) == VAR_DECL
	/* A VAR_DECL with a context that is a _TYPE is a static data
	member. */
	&& !TYPE_P (CP_DECL_CONTEXT (t))
	/* Any other non-local variable must be at namespace scope. */
	&& !DECL_NAMESPACE_SCOPE_P (t))
	\|\| (TREE_CODE (t) == PARM_DECL))
	return 1;

	return 0;
	}

	/* Returns nonzero if T is an automatic local variable or a label.
	(These are the declarations that need to be remapped when the code
	containing them is duplicated.) */

	int
	nonstatic_local_decl_p (tree t)
	{
	return ((local_variable_p (t) && !TREE_STATIC (t))
	\|\| TREE_CODE (t) == LABEL_DECL
	\|\| TREE_CODE (t) == RESULT_DECL);
	}

	/* Like local_variable_p, but suitable for use as a tree-walking
	function. */

	static tree
	local_variable_p_walkfn (tree tp, int walk_subtrees,
	void *data ATTRIBUTE_UNUSED)
	{
	if (local_variable_p (tp) && !DECL_ARTIFICIAL (tp))
	return *tp;
	else if (TYPE_P (*tp))
	*walk_subtrees = 0;

	return NULL_TREE;
	}


	/* Check that ARG, which is a default-argument expression for a
	parameter DECL, is valid. Returns ARG, or ERROR_MARK_NODE, if
	something goes wrong. DECL may also be a _TYPE node, rather than a
	DECL, if there is no DECL available. */

	tree
	check_default_argument (tree decl, tree arg)
	{
	tree var;
	tree decl_type;

	if (TREE_CODE (arg) == DEFAULT_ARG)
	/* We get a DEFAULT_ARG when looking at an in-class declaration
	with a default argument. Ignore the argument for now; we'll
	deal with it after the class is complete. */
	return arg;

	if (TYPE_P (decl))
	{
	decl_type = decl;
	decl = NULL_TREE;
	}
	else
	decl_type = TREE_TYPE (decl);

	if (arg == error_mark_node
	\|\| decl == error_mark_node
	\|\| TREE_TYPE (arg) == error_mark_node
	\|\| decl_type == error_mark_node)
	/* Something already went wrong. There's no need to check
	further. */
	return error_mark_node;

	/* [dcl.fct.default]

	A default argument expression is implicitly converted to the
	parameter type. */
	if (!TREE_TYPE (arg)
	\|\| !can_convert_arg (decl_type, TREE_TYPE (arg), arg, LOOKUP_NORMAL))
	{
	if (decl)
	error ("default argument for %q#D has type %qT",
	decl, TREE_TYPE (arg));
	else
	error ("default argument for parameter of type %qT has type %qT",
	decl_type, TREE_TYPE (arg));

	return error_mark_node;
	}

	/* [dcl.fct.default]

	Local variables shall not be used in default argument
	expressions.

	The keyword `this' shall not be used in a default argument of a
	member function. */
	var = walk_tree_without_duplicates (&arg, local_variable_p_walkfn,
	NULL);
	if (var)
	{
	error ("default argument %qE uses local variable %qD", arg, var);
	return error_mark_node;
	}

	/* All is well. */
	return arg;
	}

	/* Decode the list of parameter types for a function type.
	Given the list of things declared inside the parens,
	return a list of types.

	If this parameter does not end with an ellipsis, we append
	void_list_node.

	PARMS is set to the chain of PARM_DECLs created. /

	static tree
	grokparms (cp_parameter_declarator first_parm, tree parms)
	{
	tree result = NULL_TREE;
	tree decls = NULL_TREE;
	int ellipsis = !first_parm \|\| first_parm->ellipsis_p;
	cp_parameter_declarator *parm;
	int any_error = 0;

	for (parm = first_parm; parm != NULL; parm = parm->next)
	{
	tree type = NULL_TREE;
	tree init = parm->default_argument;
	tree attrs;
	tree decl;

	if (parm == no_parameters)
	break;

	attrs = parm->decl_specifiers.attributes;
	parm->decl_specifiers.attributes = NULL_TREE;
	decl = grokdeclarator (parm->declarator, &parm->decl_specifiers,
	PARM, init != NULL_TREE, &attrs);
	if (! decl \|\| TREE_TYPE (decl) == error_mark_node)
	continue;

	if (attrs)
	cplus_decl_attributes (&decl, attrs, 0);

	type = TREE_TYPE (decl);
	if (VOID_TYPE_P (type))
	{
	if (same_type_p (type, void_type_node)
	&& DECL_SELF_REFERENCE_P (type)
	&& !DECL_NAME (decl) && !result && !parm->next && !ellipsis)
	/* this is a parmlist of `(void)', which is ok. */
	break;
	cxx_incomplete_type_error (decl, type);
	/* It's not a good idea to actually create parameters of
	type `void'; other parts of the compiler assume that a
	void type terminates the parameter list. */
	type = error_mark_node;
	TREE_TYPE (decl) = error_mark_node;
	}

	if (type != error_mark_node)
	{
	/* Top-level qualifiers on the parameters are
	ignored for function types. */
	type = cp_build_qualified_type (type, 0);
	if (TREE_CODE (type) == METHOD_TYPE)
	{
	error ("parameter %qD invalidly declared method type", decl);
	type = build_pointer_type (type);
	TREE_TYPE (decl) = type;
	}
	else if (abstract_virtuals_error (decl, type))
	any_error = 1; /* Seems like a good idea. */
	else if (POINTER_TYPE_P (type))
	{
	/* [dcl.fct]/6, parameter types cannot contain pointers
	(references) to arrays of unknown bound. */
	tree t = TREE_TYPE (type);
	int ptr = TYPE_PTR_P (type);

	while (1)
	{
	if (TYPE_PTR_P (t))
	ptr = 1;
	else if (TREE_CODE (t) != ARRAY_TYPE)
	break;
	else if (!TYPE_DOMAIN (t))
	break;
	t = TREE_TYPE (t);
	}
	if (TREE_CODE (t) == ARRAY_TYPE)
	error ("parameter %qD includes %s to array of unknown "
	"bound %qT",
	decl, ptr ? "pointer" : "reference", t);
	}

	if (any_error)
	init = NULL_TREE;
	else if (init && !processing_template_decl)
	init = check_default_argument (decl, init);
	}

	TREE_CHAIN (decl) = decls;
	decls = decl;
	result = tree_cons (init, type, result);
	}
	decls = nreverse (decls);
	result = nreverse (result);
	if (!ellipsis)
	result = chainon (result, void_list_node);
	*parms = decls;

	return result;
	}


	/* D is a constructor or overloaded `operator='.

	Let T be the class in which D is declared. Then, this function
	returns:

	-1 if D's is an ill-formed constructor or copy assignment operator
	whose first parameter is of type `T'.
	0 if D is not a copy constructor or copy assignment
	operator.
	1 if D is a copy constructor or copy assignment operator whose
	first parameter is a reference to const qualified T.
	2 if D is a copy constructor or copy assignment operator whose
	first parameter is a reference to non-const qualified T.

	This function can be used as a predicate. Positive values indicate
	a copy constructor and nonzero values indicate a copy assignment
	operator. */

	int
	copy_fn_p (tree d)
	{
	tree args;
	tree arg_type;
	int result = 1;

	gcc_assert (DECL_FUNCTION_MEMBER_P (d));

	if (TREE_CODE (d) == TEMPLATE_DECL
	\|\| (DECL_TEMPLATE_INFO (d)
	&& DECL_MEMBER_TEMPLATE_P (DECL_TI_TEMPLATE (d))))
	/* Instantiations of template member functions are never copy
	functions. Note that member functions of templated classes are
	represented as template functions internally, and we must
	accept those as copy functions. */
	return 0;

	args = FUNCTION_FIRST_USER_PARMTYPE (d);
	if (!args)
	return 0;

	arg_type = TREE_VALUE (args);
	if (arg_type == error_mark_node)
	return 0;

	if (TYPE_MAIN_VARIANT (arg_type) == DECL_CONTEXT (d))
	{
	/* Pass by value copy assignment operator. */
	result = -1;
	}
	else if (TREE_CODE (arg_type) == REFERENCE_TYPE
	&& TYPE_MAIN_VARIANT (TREE_TYPE (arg_type)) == DECL_CONTEXT (d))
	{
	if (CP_TYPE_CONST_P (TREE_TYPE (arg_type)))
	result = 2;
	}
	else
	return 0;

	args = TREE_CHAIN (args);

	if (args && args != void_list_node && !TREE_PURPOSE (args))
	/* There are more non-optional args. */
	return 0;

	return result;
	}

	/* Remember any special properties of member function DECL. */

	void grok_special_member_properties (tree decl)
	{
	tree class_type;

	if (!DECL_NONSTATIC_MEMBER_FUNCTION_P (decl))
	return;

	class_type = DECL_CONTEXT (decl);
	if (DECL_CONSTRUCTOR_P (decl))
	{
	int ctor = copy_fn_p (decl);

	TYPE_HAS_CONSTRUCTOR (class_type) = 1;

	if (ctor > 0)
	{
	/* [class.copy]

	A non-template constructor for class X is a copy
	constructor if its first parameter is of type X&, const
	X&, volatile X& or const volatile X&, and either there
	are no other parameters or else all other parameters have
	default arguments. */
	TYPE_HAS_INIT_REF (class_type) = 1;
	if (ctor > 1)
	TYPE_HAS_CONST_INIT_REF (class_type) = 1;
	}
	else if (sufficient_parms_p (FUNCTION_FIRST_USER_PARMTYPE (decl)))
	TYPE_HAS_DEFAULT_CONSTRUCTOR (class_type) = 1;
	}
	else if (DECL_OVERLOADED_OPERATOR_P (decl) == NOP_EXPR)
	{
	/* [class.copy]

	A non-template assignment operator for class X is a copy
	assignment operator if its parameter is of type X, X&, const
	X&, volatile X& or const volatile X&. */

	int assop = copy_fn_p (decl);

	if (assop)
	{
	TYPE_HAS_ASSIGN_REF (class_type) = 1;
	if (assop != 1)
	TYPE_HAS_CONST_ASSIGN_REF (class_type) = 1;
	}
	}
	}

	/* Check a constructor DECL has the correct form. Complains
	if the class has a constructor of the form X(X). */

	int
	grok_ctor_properties (tree ctype, tree decl)
	{
	int ctor_parm = copy_fn_p (decl);

	if (ctor_parm < 0)
	{
	/* [class.copy]

	A declaration of a constructor for a class X is ill-formed if
	its first parameter is of type (optionally cv-qualified) X
	and either there are no other parameters or else all other
	parameters have default arguments.

	We don't complain about member template instantiations that
	have this form, though; they can occur as we try to decide
	what constructor to use during overload resolution. Since
	overload resolution will never prefer such a constructor to
	the non-template copy constructor (which is either explicitly
	or implicitly defined), there's no need to worry about their
	existence. Theoretically, they should never even be
	instantiated, but that's hard to forestall. */
	error ("invalid constructor; you probably meant %<%T (const %T&)%>",
	ctype, ctype);
	return 0;
	}

	return 1;
	}

	/* An operator with this code is unary, but can also be binary. */

	static int
	ambi_op_p (enum tree_code code)
	{
	return (code == INDIRECT_REF
	\|\| code == ADDR_EXPR
	\|\| code == UNARY_PLUS_EXPR
	\|\| code == NEGATE_EXPR
	\|\| code == PREINCREMENT_EXPR
	\|\| code == PREDECREMENT_EXPR);
	}

	/* An operator with this name can only be unary. */

	static int
	unary_op_p (enum tree_code code)
	{
	return (code == TRUTH_NOT_EXPR
	\|\| code == BIT_NOT_EXPR
	\|\| code == COMPONENT_REF
	\|\| code == TYPE_EXPR);
	}

	/* DECL is a declaration for an overloaded operator. If COMPLAIN is true,
	errors are issued for invalid declarations. */

	bool
	grok_op_properties (tree decl, bool complain)
	{
	tree argtypes = TYPE_ARG_TYPES (TREE_TYPE (decl));
	tree argtype;
	int methodp = (TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE);
	tree name = DECL_NAME (decl);
	enum tree_code operator_code;
	int arity;
	bool ellipsis_p;
	tree class_type;

	/* Count the number of arguments and check for ellipsis. */
	for (argtype = argtypes, arity = 0;
	argtype && argtype != void_list_node;
	argtype = TREE_CHAIN (argtype))
	++arity;
	ellipsis_p = !argtype;

	class_type = DECL_CONTEXT (decl);
	if (class_type && !CLASS_TYPE_P (class_type))
	class_type = NULL_TREE;

	if (DECL_CONV_FN_P (decl))
	operator_code = TYPE_EXPR;
	else
	do
	{
	#define DEF_OPERATOR(NAME, CODE, MANGLING, ARITY, ASSN_P) \
	if (ansi_opname (CODE) == name) \
	{ \
	operator_code = (CODE); \
	break; \
	} \
	else if (ansi_assopname (CODE) == name) \
	{ \
	operator_code = (CODE); \
	DECL_ASSIGNMENT_OPERATOR_P (decl) = 1; \
	break; \
	}

	#include "operators.def"
	#undef DEF_OPERATOR

	gcc_unreachable ();
	}
	while (0);
	gcc_assert (operator_code != LAST_CPLUS_TREE_CODE);
	SET_OVERLOADED_OPERATOR_CODE (decl, operator_code);

	if (class_type)
	switch (operator_code)
	{
	case NEW_EXPR:
	TYPE_HAS_NEW_OPERATOR (class_type) = 1;
	break;

	case DELETE_EXPR:
	TYPE_GETS_DELETE (class_type) \|= 1;
	break;

	case VEC_NEW_EXPR:
	TYPE_HAS_ARRAY_NEW_OPERATOR (class_type) = 1;
	break;

	case VEC_DELETE_EXPR:
	TYPE_GETS_DELETE (class_type) \|= 2;
	break;

	default:
	break;
	}

	/* [basic.std.dynamic.allocation]/1:

	A program is ill-formed if an allocation function is declared
	in a namespace scope other than global scope or declared static
	in global scope.

	The same also holds true for deallocation functions. */
	if (operator_code == NEW_EXPR \|\| operator_code == VEC_NEW_EXPR
	\|\| operator_code == DELETE_EXPR \|\| operator_code == VEC_DELETE_EXPR)
	{
	if (DECL_NAMESPACE_SCOPE_P (decl))
	{
	if (CP_DECL_CONTEXT (decl) != global_namespace)
	{
	error ("%qD may not be declared within a namespace", decl);
	return false;
	}
	else if (!TREE_PUBLIC (decl))
	{
	error ("%qD may not be declared as static", decl);
	return false;
	}
	}
	}

	if (operator_code == NEW_EXPR \|\| operator_code == VEC_NEW_EXPR)
	TREE_TYPE (decl) = coerce_new_type (TREE_TYPE (decl));
	else if (operator_code == DELETE_EXPR \|\| operator_code == VEC_DELETE_EXPR)
	TREE_TYPE (decl) = coerce_delete_type (TREE_TYPE (decl));
	else
	{
	/* An operator function must either be a non-static member function
	or have at least one parameter of a class, a reference to a class,
	an enumeration, or a reference to an enumeration. 13.4.0.6 */
	if (! methodp \|\| DECL_STATIC_FUNCTION_P (decl))
	{
	if (operator_code == TYPE_EXPR
	\|\| operator_code == CALL_EXPR
	\|\| operator_code == COMPONENT_REF
	\|\| operator_code == ARRAY_REF
	\|\| operator_code == NOP_EXPR)
	{
	error ("%qD must be a nonstatic member function", decl);
	return false;
	}
	else
	{
	tree p;

	if (DECL_STATIC_FUNCTION_P (decl))
	{
	error ("%qD must be either a non-static member "
	"function or a non-member function", decl);
	return false;
	}

	for (p = argtypes; p && p != void_list_node; p = TREE_CHAIN (p))
	{
	tree arg = non_reference (TREE_VALUE (p));
	if (arg == error_mark_node)
	return false;

	/* IS_AGGR_TYPE, rather than CLASS_TYPE_P, is used
	because these checks are performed even on
	template functions. */
	if (IS_AGGR_TYPE (arg) \|\| TREE_CODE (arg) == ENUMERAL_TYPE)
	break;
	}

	if (!p \|\| p == void_list_node)
	{
	if (complain)
	error ("%qD must have an argument of class or "
	"enumerated type", decl);
	return false;
	}
	}
	}

	/* There are no restrictions on the arguments to an overloaded
	"operator ()". */
	if (operator_code == CALL_EXPR)
	return true;

	/* Warn about conversion operators that will never be used. */
	if (IDENTIFIER_TYPENAME_P (name)
	&& ! DECL_TEMPLATE_INFO (decl)
	&& warn_conversion
	/* Warn only declaring the function; there is no need to
	warn again about out-of-class definitions. */
	&& class_type == current_class_type)
	{
	tree t = TREE_TYPE (name);
	int ref = (TREE_CODE (t) == REFERENCE_TYPE);
	const char *what = 0;

	if (ref)
	t = TYPE_MAIN_VARIANT (TREE_TYPE (t));

	if (TREE_CODE (t) == VOID_TYPE)
	what = "void";
	else if (class_type)
	{
	if (t == class_type)
	what = "the same type";
	/* Don't force t to be complete here. */
	else if (IS_AGGR_TYPE (t)
	&& COMPLETE_TYPE_P (t)
	&& DERIVED_FROM_P (t, class_type))
	what = "a base class";
	}

	if (what)
	warning (OPT_Wconversion, "conversion to %s%s will never use a type "
	"conversion operator",
	ref ? "a reference to " : "", what);
	}

	if (operator_code == COND_EXPR)
	{
	/* 13.4.0.3 */
	error ("ISO C++ prohibits overloading operator ?:");
	return false;
	}
	else if (ellipsis_p)
	{
	error ("%qD must not have variable number of arguments", decl);
	return false;
	}
	else if (ambi_op_p (operator_code))
	{
	if (arity == 1)
	/* We pick the one-argument operator codes by default, so
	we don't have to change anything. */
	;
	else if (arity == 2)
	{
	/* If we thought this was a unary operator, we now know
	it to be a binary operator. */
	switch (operator_code)
	{
	case INDIRECT_REF:
	operator_code = MULT_EXPR;
	break;

	case ADDR_EXPR:
	operator_code = BIT_AND_EXPR;
	break;

	case UNARY_PLUS_EXPR:
	operator_code = PLUS_EXPR;
	break;

	case NEGATE_EXPR:
	operator_code = MINUS_EXPR;
	break;

	case PREINCREMENT_EXPR:
	operator_code = POSTINCREMENT_EXPR;
	break;

	case PREDECREMENT_EXPR:
	operator_code = POSTDECREMENT_EXPR;
	break;

	default:
	gcc_unreachable ();
	}

	SET_OVERLOADED_OPERATOR_CODE (decl, operator_code);

	if ((operator_code == POSTINCREMENT_EXPR
	\|\| operator_code == POSTDECREMENT_EXPR)
	&& ! processing_template_decl
	&& ! same_type_p (TREE_VALUE (TREE_CHAIN (argtypes)), integer_type_node))
	{
	if (methodp)
	error ("postfix %qD must take %<int%> as its argument",
	decl);
	else
	error ("postfix %qD must take %<int%> as its second "
	"argument", decl);
	return false;
	}
	}
	else
	{
	if (methodp)
	error ("%qD must take either zero or one argument", decl);
	else
	error ("%qD must take either one or two arguments", decl);
	return false;
	}

	/* More Effective C++ rule 6. */
	if (warn_ecpp
	&& (operator_code == POSTINCREMENT_EXPR
	\|\| operator_code == POSTDECREMENT_EXPR
	\|\| operator_code == PREINCREMENT_EXPR
	\|\| operator_code == PREDECREMENT_EXPR))
	{
	tree arg = TREE_VALUE (argtypes);
	tree ret = TREE_TYPE (TREE_TYPE (decl));
	if (methodp \|\| TREE_CODE (arg) == REFERENCE_TYPE)
	arg = TREE_TYPE (arg);
	arg = TYPE_MAIN_VARIANT (arg);
	if (operator_code == PREINCREMENT_EXPR
	\|\| operator_code == PREDECREMENT_EXPR)
	{
	if (TREE_CODE (ret) != REFERENCE_TYPE
	\|\| !same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (ret)),
	arg))
	warning (OPT_Weffc__, "prefix %qD should return %qT", decl,
	build_reference_type (arg));
	}
	else
	{
	if (!same_type_p (TYPE_MAIN_VARIANT (ret), arg))
	warning (OPT_Weffc__, "postfix %qD should return %qT", decl, arg);
	}
	}
	}
	else if (unary_op_p (operator_code))
	{
	if (arity != 1)
	{
	if (methodp)
	error ("%qD must take %<void%>", decl);
	else
	error ("%qD must take exactly one argument", decl);
	return false;
	}
	}
	else /* if (binary_op_p (operator_code)) */
	{
	if (arity != 2)
	{
	if (methodp)
	error ("%qD must take exactly one argument", decl);
	else
	error ("%qD must take exactly two arguments", decl);
	return false;
	}

	/* More Effective C++ rule 7. */
	if (warn_ecpp
	&& (operator_code == TRUTH_ANDIF_EXPR
	\|\| operator_code == TRUTH_ORIF_EXPR
	\|\| operator_code == COMPOUND_EXPR))
	warning (OPT_Weffc__, "user-defined %qD always evaluates both arguments",
	decl);
	}

	/* Effective C++ rule 23. */
	if (warn_ecpp
	&& arity == 2
	&& !DECL_ASSIGNMENT_OPERATOR_P (decl)
	&& (operator_code == PLUS_EXPR
	\|\| operator_code == MINUS_EXPR
	\|\| operator_code == TRUNC_DIV_EXPR
	\|\| operator_code == MULT_EXPR
	\|\| operator_code == TRUNC_MOD_EXPR)
	&& TREE_CODE (TREE_TYPE (TREE_TYPE (decl))) == REFERENCE_TYPE)
	warning (OPT_Weffc__, "%qD should return by value", decl);

	/* [over.oper]/8 */
	for (; argtypes && argtypes != void_list_node;
	argtypes = TREE_CHAIN (argtypes))
	if (TREE_PURPOSE (argtypes))
	{
	TREE_PURPOSE (argtypes) = NULL_TREE;
	if (operator_code == POSTINCREMENT_EXPR
	\|\| operator_code == POSTDECREMENT_EXPR)
	{
	if (pedantic)
	pedwarn ("%qD cannot have default arguments", decl);
	}
	else
	{
	error ("%qD cannot have default arguments", decl);
	return false;
	}
	}
	}
	return true;
	}

	/* Return a string giving the keyword associate with CODE. */

	static const char *
	tag_name (enum tag_types code)
	{
	switch (code)
	{
	case record_type:
	return "struct";
	case class_type:
	return "class";
	case union_type:
	return "union";
	case enum_type:
	return "enum";
	case typename_type:
	return "typename";
	default:
	gcc_unreachable ();
	}
	}

	/* Name lookup in an elaborated-type-specifier (after the keyword
	indicated by TAG_CODE) has found the TYPE_DECL DECL. If the
	elaborated-type-specifier is invalid, issue a diagnostic and return
	error_mark_node; otherwise, return the *_TYPE to which it referred.
	If ALLOW_TEMPLATE_P is true, TYPE may be a class template. */

	tree
	check_elaborated_type_specifier (enum tag_types tag_code,
	tree decl,
	bool allow_template_p)
	{
	tree type;

	/* In the case of:

	struct S { struct S *p; };

	name lookup will find the TYPE_DECL for the implicit "S::S"
	typedef. Adjust for that here. */
	if (DECL_SELF_REFERENCE_P (decl))
	decl = TYPE_NAME (TREE_TYPE (decl));

	type = TREE_TYPE (decl);

	/* Check TEMPLATE_TYPE_PARM first because DECL_IMPLICIT_TYPEDEF_P
	is false for this case as well. */
	if (TREE_CODE (type) == TEMPLATE_TYPE_PARM)
	{
	error ("using template type parameter %qT after %qs",
	type, tag_name (tag_code));
	return error_mark_node;
	}
	/* [dcl.type.elab]

	If the identifier resolves to a typedef-name or a template
	type-parameter, the elaborated-type-specifier is ill-formed.

	In other words, the only legitimate declaration to use in the
	elaborated type specifier is the implicit typedef created when
	the type is declared. */
	else if (!DECL_IMPLICIT_TYPEDEF_P (decl)
	&& tag_code != typename_type)
	{
	error ("using typedef-name %qD after %qs", decl, tag_name (tag_code));
	error ("%q+D has a previous declaration here", decl);
	return error_mark_node;
	}
	else if (TREE_CODE (type) != RECORD_TYPE
	&& TREE_CODE (type) != UNION_TYPE
	&& tag_code != enum_type
	&& tag_code != typename_type)
	{
	error ("%qT referred to as %qs", type, tag_name (tag_code));
	error ("%q+T has a previous declaration here", type);
	return error_mark_node;
	}
	else if (TREE_CODE (type) != ENUMERAL_TYPE
	&& tag_code == enum_type)
	{
	error ("%qT referred to as enum", type);
	error ("%q+T has a previous declaration here", type);
	return error_mark_node;
	}
	else if (!allow_template_p
	&& TREE_CODE (type) == RECORD_TYPE
	&& CLASSTYPE_IS_TEMPLATE (type))
	{
	/* If a class template appears as elaborated type specifier
	without a template header such as:

	template <class T> class C {};
	void f(class C); // No template header here

	then the required template argument is missing. */
	error ("template argument required for %<%s %T%>",
	tag_name (tag_code),
	DECL_NAME (CLASSTYPE_TI_TEMPLATE (type)));
	return error_mark_node;
	}

	return type;
	}

	/* Lookup NAME in elaborate type specifier in scope according to
	SCOPE and issue diagnostics if necessary.
	Return *_TYPE node upon success, NULL_TREE when the NAME is not
	found, and ERROR_MARK_NODE for type error. */

	static tree
	lookup_and_check_tag (enum tag_types tag_code, tree name,
	tag_scope scope, bool template_header_p)
	{
	tree t;
	tree decl;
	if (scope == ts_global)
	{
	/* First try ordinary name lookup, ignoring hidden class name
	injected via friend declaration. */
	decl = lookup_name_prefer_type (name, 2);
	/* If that fails, the name will be placed in the smallest
	non-class, non-function-prototype scope according to 3.3.1/5.
	We may already have a hidden name declared as friend in this
	scope. So lookup again but not ignoring hidden names.
	If we find one, that name will be made visible rather than
	creating a new tag. */
	if (!decl)
	decl = lookup_type_scope (name, ts_within_enclosing_non_class);
	}
	else
	decl = lookup_type_scope (name, scope);

	if (decl && DECL_CLASS_TEMPLATE_P (decl))
	decl = DECL_TEMPLATE_RESULT (decl);

	if (decl && TREE_CODE (decl) == TYPE_DECL)
	{
	/* Look for invalid nested type:
	class C {
	class C {};
	}; */
	if (scope == ts_current && DECL_SELF_REFERENCE_P (decl))
	{
	error ("%qD has the same name as the class in which it is "
	"declared",
	decl);
	return error_mark_node;
	}

	/* Two cases we need to consider when deciding if a class
	template is allowed as an elaborated type specifier:
	1. It is a self reference to its own class.
	2. It comes with a template header.

	For example:

	template <class T> class C {
	class C *c1; // DECL_SELF_REFERENCE_P is true
	class D;
	};
	template <class U> class C; // template_header_p is true
	template <class T> class C<T>::D {
	class C *c2; // DECL_SELF_REFERENCE_P is true
	}; */

	t = check_elaborated_type_specifier (tag_code,
	decl,
	template_header_p
	\| DECL_SELF_REFERENCE_P (decl));
	return t;
	}
	else
	return NULL_TREE;
	}

	/* Get the struct, enum or union (TAG_CODE says which) with tag NAME.
	Define the tag as a forward-reference if it is not defined.

	If a declaration is given, process it here, and report an error if
	multiple declarations are not identical.

	SCOPE is TS_CURRENT when this is also a definition. Only look in
	the current frame for the name (since C++ allows new names in any
	scope.) It is TS_WITHIN_ENCLOSING_NON_CLASS if this is a friend
	declaration. Only look beginning from the current scope outward up
	till the nearest non-class scope. Otherwise it is TS_GLOBAL.

	TEMPLATE_HEADER_P is true when this declaration is preceded by
	a set of template parameters. */

	tree
	xref_tag (enum tag_types tag_code, tree name,
	tag_scope scope, bool template_header_p)
	{
	enum tree_code code;
	tree t;
	tree context = NULL_TREE;

	timevar_push (TV_NAME_LOOKUP);

	gcc_assert (TREE_CODE (name) == IDENTIFIER_NODE);

	switch (tag_code)
	{
	case record_type:
	case class_type:
	code = RECORD_TYPE;
	break;
	case union_type:
	code = UNION_TYPE;
	break;
	case enum_type:
	code = ENUMERAL_TYPE;
	break;
	default:
	gcc_unreachable ();
	}

	/* In case of anonymous name, xref_tag is only called to
	make type node and push name. Name lookup is not required. */
	if (ANON_AGGRNAME_P (name))
	t = NULL_TREE;
	else
	t = lookup_and_check_tag (tag_code, name,
	scope, template_header_p);

	if (t == error_mark_node)
	POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);

	if (scope != ts_current && t && current_class_type
	&& template_class_depth (current_class_type)
	&& template_header_p)
	{
	/* Since SCOPE is not TS_CURRENT, we are not looking at a
	definition of this tag. Since, in addition, we are currently
	processing a (member) template declaration of a template
	class, we must be very careful; consider:

	template <class X>
	struct S1

	template <class U>
	struct S2
	{ template <class V>
	friend struct S1; };

	Here, the S2::S1 declaration should not be confused with the
	outer declaration. In particular, the inner version should
	have a template parameter of level 2, not level 1. This
	would be particularly important if the member declaration
	were instead:

	template <class V = U> friend struct S1;

	say, when we should tsubst into `U' when instantiating
	S2. On the other hand, when presented with:

	template <class T>
	struct S1 {
	template <class U>
	struct S2 {};
	template <class U>
	friend struct S2;
	};

	we must find the inner binding eventually. We
	accomplish this by making sure that the new type we
	create to represent this declaration has the right
	TYPE_CONTEXT. */
	context = TYPE_CONTEXT (t);
	t = NULL_TREE;
	}

	if (! t)
	{
	/* If no such tag is yet defined, create a forward-reference node
	and record it as the "definition".
	When a real declaration of this type is found,
	the forward-reference will be altered into a real type. */
	if (code == ENUMERAL_TYPE)
	{
	error ("use of enum %q#D without previous declaration", name);
	POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
	}
	else
	{
	t = make_aggr_type (code);
	TYPE_CONTEXT (t) = context;
	t = pushtag (name, t, scope);
	}
	}
	else
	{
	if (template_header_p && IS_AGGR_TYPE (t))
	{
	if (!redeclare_class_template (t, current_template_parms))
	POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
	}
	else if (!processing_template_decl
	&& CLASS_TYPE_P (t)
	&& CLASSTYPE_IS_TEMPLATE (t))
	{
	error ("redeclaration of %qT as a non-template", t);
	error ("previous declaration %q+D", t);
	POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
	}

	/* Make injected friend class visible. */
	if (scope != ts_within_enclosing_non_class
	&& hidden_name_p (TYPE_NAME (t)))
	{
	DECL_ANTICIPATED (TYPE_NAME (t)) = 0;
	DECL_FRIEND_P (TYPE_NAME (t)) = 0;

	if (TYPE_TEMPLATE_INFO (t))
	{
	DECL_ANTICIPATED (TYPE_TI_TEMPLATE (t)) = 0;
	DECL_FRIEND_P (TYPE_TI_TEMPLATE (t)) = 0;
	}
	}
	}

	POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
	}

	tree
	xref_tag_from_type (tree old, tree id, tag_scope scope)
	{
	enum tag_types tag_kind;

	if (TREE_CODE (old) == RECORD_TYPE)
	tag_kind = (CLASSTYPE_DECLARED_CLASS (old) ? class_type : record_type);
	else
	tag_kind = union_type;

	if (id == NULL_TREE)
	id = TYPE_IDENTIFIER (old);

	return xref_tag (tag_kind, id, scope, false);
	}

	/* Create the binfo hierarchy for REF with (possibly NULL) base list
	BASE_LIST. For each element on BASE_LIST the TREE_PURPOSE is an
	access_* node, and the TREE_VALUE is the type of the base-class.
	Non-NULL TREE_TYPE indicates virtual inheritance.

	Returns true if the binfo heirarchy was successfully created,
	false if an error was detected. */

	bool
	xref_basetypes (tree ref, tree base_list)
	{
	tree *basep;
	tree binfo, base_binfo;
	unsigned max_vbases = 0; /* Maximum direct & indirect virtual bases. */
	unsigned max_bases = 0; /* Maximum direct bases. */
	int i;
	tree default_access;
	tree igo_prev; /* Track Inheritance Graph Order. */

	if (ref == error_mark_node)
	return false;

	/* The base of a derived class is private by default, all others are
	public. */
	default_access = (TREE_CODE (ref) == RECORD_TYPE
	&& CLASSTYPE_DECLARED_CLASS (ref)
	? access_private_node : access_public_node);

	/* First, make sure that any templates in base-classes are
	instantiated. This ensures that if we call ourselves recursively
	we do not get confused about which classes are marked and which
	are not. */
	basep = &base_list;
	while (*basep)
	{
	tree basetype = TREE_VALUE (*basep);

	if (!(processing_template_decl && uses_template_parms (basetype))
	&& !complete_type_or_else (basetype, NULL))
	/* An incomplete type. Remove it from the list. */
	basep = TREE_CHAIN (basep);
	else
	{
	max_bases++;
	if (TREE_TYPE (*basep))
	max_vbases++;
	if (CLASS_TYPE_P (basetype))
	max_vbases += VEC_length (tree, CLASSTYPE_VBASECLASSES (basetype));
	basep = &TREE_CHAIN (*basep);
	}
	}

	TYPE_MARKED_P (ref) = 1;

	/* The binfo slot should be empty, unless this is an (ill-formed)
	redefinition. */
	gcc_assert (!TYPE_BINFO (ref) \|\| TYPE_SIZE (ref));
	gcc_assert (TYPE_MAIN_VARIANT (ref) == ref);

	binfo = make_tree_binfo (max_bases);

	TYPE_BINFO (ref) = binfo;
	BINFO_OFFSET (binfo) = size_zero_node;
	BINFO_TYPE (binfo) = ref;

	if (max_bases)
	{
	BINFO_BASE_ACCESSES (binfo) = VEC_alloc (tree, gc, max_bases);
	/* An aggregate cannot have baseclasses. */
	CLASSTYPE_NON_AGGREGATE (ref) = 1;

	if (TREE_CODE (ref) == UNION_TYPE)
	{
	error ("derived union %qT invalid", ref);
	return false;
	}
	}

	if (max_bases > 1)
	{
	if (TYPE_FOR_JAVA (ref))
	{
	error ("Java class %qT cannot have multiple bases", ref);
	return false;
	}
	}

	if (max_vbases)
	{
	CLASSTYPE_VBASECLASSES (ref) = VEC_alloc (tree, gc, max_vbases);

	if (TYPE_FOR_JAVA (ref))
	{
	error ("Java class %qT cannot have virtual bases", ref);
	return false;
	}
	}

	for (igo_prev = binfo; base_list; base_list = TREE_CHAIN (base_list))
	{
	tree access = TREE_PURPOSE (base_list);
	int via_virtual = TREE_TYPE (base_list) != NULL_TREE;
	tree basetype = TREE_VALUE (base_list);

	if (access == access_default_node)
	access = default_access;

	if (TREE_CODE (basetype) == TYPE_DECL)
	basetype = TREE_TYPE (basetype);
	if (TREE_CODE (basetype) != RECORD_TYPE
	&& TREE_CODE (basetype) != TYPENAME_TYPE
	&& TREE_CODE (basetype) != TEMPLATE_TYPE_PARM
	&& TREE_CODE (basetype) != BOUND_TEMPLATE_TEMPLATE_PARM)
	{
	error ("base type %qT fails to be a struct or class type",
	basetype);
	return false;
	}

	if (TYPE_FOR_JAVA (basetype) && (current_lang_depth () == 0))
	TYPE_FOR_JAVA (ref) = 1;

	base_binfo = NULL_TREE;
	if (CLASS_TYPE_P (basetype) && !dependent_type_p (basetype))
	{
	base_binfo = TYPE_BINFO (basetype);
	/* The original basetype could have been a typedef'd type. */
	basetype = BINFO_TYPE (base_binfo);

	/* Inherit flags from the base. */
	TYPE_HAS_NEW_OPERATOR (ref)
	\|= TYPE_HAS_NEW_OPERATOR (basetype);
	TYPE_HAS_ARRAY_NEW_OPERATOR (ref)
	\|= TYPE_HAS_ARRAY_NEW_OPERATOR (basetype);
	TYPE_GETS_DELETE (ref) \|= TYPE_GETS_DELETE (basetype);
	TYPE_HAS_CONVERSION (ref) \|= TYPE_HAS_CONVERSION (basetype);
	CLASSTYPE_DIAMOND_SHAPED_P (ref)
	\|= CLASSTYPE_DIAMOND_SHAPED_P (basetype);
	CLASSTYPE_REPEATED_BASE_P (ref)
	\|= CLASSTYPE_REPEATED_BASE_P (basetype);
	}

	/* We must do this test after we've seen through a typedef
	type. */
	if (TYPE_MARKED_P (basetype))
	{
	if (basetype == ref)
	error ("recursive type %qT undefined", basetype);
	else
	error ("duplicate base type %qT invalid", basetype);
	return false;
	}
	TYPE_MARKED_P (basetype) = 1;

	base_binfo = copy_binfo (base_binfo, basetype, ref,
	&igo_prev, via_virtual);
	if (!BINFO_INHERITANCE_CHAIN (base_binfo))
	BINFO_INHERITANCE_CHAIN (base_binfo) = binfo;

	BINFO_BASE_APPEND (binfo, base_binfo);
	BINFO_BASE_ACCESS_APPEND (binfo, access);
	}

	if (VEC_space (tree, CLASSTYPE_VBASECLASSES (ref), 1))
	/* If we have space in the vbase vector, we must have shared at
	least one of them, and are therefore diamond shaped. */
	CLASSTYPE_DIAMOND_SHAPED_P (ref) = 1;

	/* Unmark all the types. */
	for (i = 0; BINFO_BASE_ITERATE (binfo, i, base_binfo); i++)
	TYPE_MARKED_P (BINFO_TYPE (base_binfo)) = 0;
	TYPE_MARKED_P (ref) = 0;

	/* Now see if we have a repeated base type. */
	if (!CLASSTYPE_REPEATED_BASE_P (ref))
	{
	for (base_binfo = binfo; base_binfo;
	base_binfo = TREE_CHAIN (base_binfo))
	{
	if (TYPE_MARKED_P (BINFO_TYPE (base_binfo)))
	{
	CLASSTYPE_REPEATED_BASE_P (ref) = 1;
	break;
	}
	TYPE_MARKED_P (BINFO_TYPE (base_binfo)) = 1;
	}
	for (base_binfo = binfo; base_binfo;
	base_binfo = TREE_CHAIN (base_binfo))
	if (TYPE_MARKED_P (BINFO_TYPE (base_binfo)))
	TYPE_MARKED_P (BINFO_TYPE (base_binfo)) = 0;
	else
	break;
	}

	return true;
	}


	/* Begin compiling the definition of an enumeration type.
	NAME is its name.
	Returns the type object, as yet incomplete.
	Also records info about it so that build_enumerator
	may be used to declare the individual values as they are read. */

	tree
	start_enum (tree name)
	{
	tree enumtype;

	gcc_assert (TREE_CODE (name) == IDENTIFIER_NODE);

	/* If this is the real definition for a previous forward reference,
	fill in the contents in the same object that used to be the
	forward reference. */

	enumtype = lookup_and_check_tag (enum_type, name,
	/tag_scope=/ts_current,
	/template_header_p=/false);

	if (enumtype != NULL_TREE && TREE_CODE (enumtype) == ENUMERAL_TYPE)
	{
	error ("multiple definition of %q#T", enumtype);
	error ("%Jprevious definition here", TYPE_MAIN_DECL (enumtype));
	/* Clear out TYPE_VALUES, and start again. */
	TYPE_VALUES (enumtype) = NULL_TREE;
	}
	else
	{
	/* In case of error, make a dummy enum to allow parsing to
	continue. */
	if (enumtype == error_mark_node)
	name = make_anon_name ();

	enumtype = make_node (ENUMERAL_TYPE);
	enumtype = pushtag (name, enumtype, /tag_scope=/ts_current);
	}

	return enumtype;
	}

	/* After processing and defining all the values of an enumeration type,
	install their decls in the enumeration type and finish it off.
	ENUMTYPE is the type object and VALUES a list of name-value pairs. */

	void
	finish_enum (tree enumtype)
	{
	tree values;
	tree decl;
	tree value;
	tree minnode;
	tree maxnode;
	tree t;
	bool unsignedp;
	bool use_short_enum;
	int lowprec;
	int highprec;
	int precision;
	integer_type_kind itk;
	tree underlying_type = NULL_TREE;

	/* We built up the VALUES in reverse order. */
	TYPE_VALUES (enumtype) = nreverse (TYPE_VALUES (enumtype));

	/* For an enum defined in a template, just set the type of the values;
	all further processing is postponed until the template is
	instantiated. We need to set the type so that tsubst of a CONST_DECL
	works. */
	if (processing_template_decl)
	{
	for (values = TYPE_VALUES (enumtype);
	values;
	values = TREE_CHAIN (values))
	TREE_TYPE (TREE_VALUE (values)) = enumtype;
	if (at_function_scope_p ())
	add_stmt (build_min (TAG_DEFN, enumtype));
	return;
	}

	/* Determine the minimum and maximum values of the enumerators. */
	if (TYPE_VALUES (enumtype))
	{
	minnode = maxnode = NULL_TREE;

	for (values = TYPE_VALUES (enumtype);
	values;
	values = TREE_CHAIN (values))
	{
	decl = TREE_VALUE (values);

	/* [dcl.enum]: Following the closing brace of an enum-specifier,
	each enumerator has the type of its enumeration. Prior to the
	closing brace, the type of each enumerator is the type of its
	initializing value. */
	TREE_TYPE (decl) = enumtype;

	/* Update the minimum and maximum values, if appropriate. */
	value = DECL_INITIAL (decl);
	if (value == error_mark_node)
	value = integer_zero_node;
	/* Figure out what the minimum and maximum values of the
	enumerators are. */
	if (!minnode)
	minnode = maxnode = value;
	else if (tree_int_cst_lt (maxnode, value))
	maxnode = value;
	else if (tree_int_cst_lt (value, minnode))
	minnode = value;
	}
	}
	else
	/* [dcl.enum]

	If the enumerator-list is empty, the underlying type is as if
	the enumeration had a single enumerator with value 0. */
	minnode = maxnode = integer_zero_node;

	/* Compute the number of bits require to represent all values of the
	enumeration. We must do this before the type of MINNODE and
	MAXNODE are transformed, since min_precision relies on the
	TREE_TYPE of the value it is passed. */
	unsignedp = tree_int_cst_sgn (minnode) >= 0;
	lowprec = min_precision (minnode, unsignedp);
	highprec = min_precision (maxnode, unsignedp);
	precision = MAX (lowprec, highprec);

	/* Determine the underlying type of the enumeration.

	[dcl.enum]

	The underlying type of an enumeration is an integral type that
	can represent all the enumerator values defined in the
	enumeration. It is implementation-defined which integral type is
	used as the underlying type for an enumeration except that the
	underlying type shall not be larger than int unless the value of
	an enumerator cannot fit in an int or unsigned int.

	We use "int" or an "unsigned int" as the underlying type, even if
	a smaller integral type would work, unless the user has
	explicitly requested that we use the smallest possible type. The
	user can request that for all enumerations with a command line
	flag, or for just one enumeration with an attribute. */

	use_short_enum = flag_short_enums
	\|\| lookup_attribute ("packed", TYPE_ATTRIBUTES (enumtype));

	for (itk = (use_short_enum ? itk_char : itk_int);
	itk != itk_none;
	itk++)
	{
	underlying_type = integer_types[itk];
	if (TYPE_PRECISION (underlying_type) >= precision
	&& TYPE_UNSIGNED (underlying_type) == unsignedp)
	break;
	}
	if (itk == itk_none)
	{
	/* DR 377

	IF no integral type can represent all the enumerator values, the
	enumeration is ill-formed. */
	error ("no integral type can represent all of the enumerator values "
	"for %qT", enumtype);
	precision = TYPE_PRECISION (long_long_integer_type_node);
	underlying_type = integer_types[itk_unsigned_long_long];
	}

	/* Compute the minium and maximum values for the type.

	[dcl.enum]

	For an enumeration where emin is the smallest enumerator and emax
	is the largest, the values of the enumeration are the values of the
	underlying type in the range bmin to bmax, where bmin and bmax are,
	respectively, the smallest and largest values of the smallest bit-
	field that can store emin and emax. */

	/* The middle-end currently assumes that types with TYPE_PRECISION
	narrower than their underlying type are suitably zero or sign
	extended to fill their mode. g++ doesn't make these guarantees.
	Until the middle-end can represent such paradoxical types, we
	set the TYPE_PRECISION to the width of the underlying type. */
	TYPE_PRECISION (enumtype) = TYPE_PRECISION (underlying_type);

	set_min_and_max_values_for_integral_type (enumtype, precision, unsignedp);

	/* [dcl.enum]

	The value of sizeof() applied to an enumeration type, an object
	of an enumeration type, or an enumerator, is the value of sizeof()
	applied to the underlying type. */
	TYPE_SIZE (enumtype) = TYPE_SIZE (underlying_type);
	TYPE_SIZE_UNIT (enumtype) = TYPE_SIZE_UNIT (underlying_type);
	TYPE_MODE (enumtype) = TYPE_MODE (underlying_type);
	TYPE_ALIGN (enumtype) = TYPE_ALIGN (underlying_type);
	TYPE_USER_ALIGN (enumtype) = TYPE_USER_ALIGN (underlying_type);
	TYPE_UNSIGNED (enumtype) = TYPE_UNSIGNED (underlying_type);

	/* Convert each of the enumerators to the type of the underlying
	type of the enumeration. */
	for (values = TYPE_VALUES (enumtype); values; values = TREE_CHAIN (values))
	{
	location_t saved_location;

	decl = TREE_VALUE (values);
	saved_location = input_location;
	input_location = DECL_SOURCE_LOCATION (decl);
	value = perform_implicit_conversion (underlying_type,
	DECL_INITIAL (decl));
	input_location = saved_location;

	/* Do not clobber shared ints. */
	value = copy_node (value);

	TREE_TYPE (value) = enumtype;
	DECL_INITIAL (decl) = value;
	TREE_VALUE (values) = value;
	}

	/* Fix up all variant types of this enum type. */
	for (t = TYPE_MAIN_VARIANT (enumtype); t; t = TYPE_NEXT_VARIANT (t))
	{
	TYPE_VALUES (t) = TYPE_VALUES (enumtype);
	TYPE_MIN_VALUE (t) = TYPE_MIN_VALUE (enumtype);
	TYPE_MAX_VALUE (t) = TYPE_MAX_VALUE (enumtype);
	TYPE_SIZE (t) = TYPE_SIZE (enumtype);
	TYPE_SIZE_UNIT (t) = TYPE_SIZE_UNIT (enumtype);
	TYPE_MODE (t) = TYPE_MODE (enumtype);
	TYPE_PRECISION (t) = TYPE_PRECISION (enumtype);
	TYPE_ALIGN (t) = TYPE_ALIGN (enumtype);
	TYPE_USER_ALIGN (t) = TYPE_USER_ALIGN (enumtype);
	TYPE_UNSIGNED (t) = TYPE_UNSIGNED (enumtype);
	}

	/* Finish debugging output for this type. */
	rest_of_type_compilation (enumtype, namespace_bindings_p ());
	}

	/* Build and install a CONST_DECL for an enumeration constant of the
	enumeration type ENUMTYPE whose NAME and VALUE (if any) are provided.
	Assignment of sequential values by default is handled here. */

	void
	build_enumerator (tree name, tree value, tree enumtype)
	{
	tree decl;
	tree context;
	tree type;

	/* If the VALUE was erroneous, pretend it wasn't there; that will
	result in the enum being assigned the next value in sequence. */
	if (value == error_mark_node)
	value = NULL_TREE;

	/* Remove no-op casts from the value. */
	if (value)
	STRIP_TYPE_NOPS (value);

	if (! processing_template_decl)
	{
	/* Validate and default VALUE. */
	if (value != NULL_TREE)
	{
	value = integral_constant_value (value);

	if (TREE_CODE (value) == INTEGER_CST)
	{
	value = perform_integral_promotions (value);
	constant_expression_warning (value);
	}
	else
	{
	error ("enumerator value for %qD not integer constant", name);
	value = NULL_TREE;
	}
	}

	/* Default based on previous value. */
	if (value == NULL_TREE)
	{
	if (TYPE_VALUES (enumtype))
	{
	HOST_WIDE_INT hi;
	unsigned HOST_WIDE_INT lo;
	tree prev_value;
	bool overflowed;

	/* The next value is the previous value plus one. We can
	safely assume that the previous value is an INTEGER_CST.
	add_double doesn't know the type of the target expression,
	so we must check with int_fits_type_p as well. */
	prev_value = DECL_INITIAL (TREE_VALUE (TYPE_VALUES (enumtype)));
	overflowed = add_double (TREE_INT_CST_LOW (prev_value),
	TREE_INT_CST_HIGH (prev_value),
	1, 0, &lo, &hi);
	value = build_int_cst_wide (TREE_TYPE (prev_value), lo, hi);
	overflowed \|= !int_fits_type_p (value, TREE_TYPE (prev_value));

	if (overflowed)
	{
	error ("overflow in enumeration values at %qD", name);
	value = error_mark_node;
	}
	}
	else
	value = integer_zero_node;
	}

	/* Remove no-op casts from the value. */
	STRIP_TYPE_NOPS (value);
	}

	/* C++ associates enums with global, function, or class declarations. */
	context = current_scope ();

	/* Build the actual enumeration constant. Note that the enumeration
	constants have the type of their initializers until the
	enumeration is complete:

	[ dcl.enum ]

	Following the closing brace of an enum-specifier, each enumer-
	ator has the type of its enumeration. Prior to the closing
	brace, the type of each enumerator is the type of its
	initializing value.

	In finish_enum we will reset the type. Of course, if we're
	processing a template, there may be no value. */
	type = value ? TREE_TYPE (value) : NULL_TREE;

	if (context && context == current_class_type)
	/* This enum declaration is local to the class. We need the full
	lang_decl so that we can record DECL_CLASS_CONTEXT, for example. */
	decl = build_lang_decl (CONST_DECL, name, type);
	else
	/* It's a global enum, or it's local to a function. (Note local to
	a function could mean local to a class method. */
	decl = build_decl (CONST_DECL, name, type);

	DECL_CONTEXT (decl) = FROB_CONTEXT (context);
	TREE_CONSTANT (decl) = 1;
	TREE_INVARIANT (decl) = 1;
	TREE_READONLY (decl) = 1;
	DECL_INITIAL (decl) = value;

	if (context && context == current_class_type)
	/* In something like `struct S { enum E { i = 7 }; };' we put `i'
	on the TYPE_FIELDS list for `S'. (That's so that you can say
	things like `S::i' later.) */
	finish_member_declaration (decl);
	else
	pushdecl (decl);

	/* Add this enumeration constant to the list for this type. */
	TYPE_VALUES (enumtype) = tree_cons (name, decl, TYPE_VALUES (enumtype));
	}


	/* We're defining DECL. Make sure that it's type is OK. */

	static void
	check_function_type (tree decl, tree current_function_parms)
	{
	tree fntype = TREE_TYPE (decl);
	tree return_type = complete_type (TREE_TYPE (fntype));

	/* In a function definition, arg types must be complete. */
	require_complete_types_for_parms (current_function_parms);

	if (dependent_type_p (return_type))
	return;
	if (!COMPLETE_OR_VOID_TYPE_P (return_type))
	{
	tree args = TYPE_ARG_TYPES (fntype);

	error ("return type %q#T is incomplete", return_type);

	/* Make it return void instead. */
	if (TREE_CODE (fntype) == METHOD_TYPE)
	fntype = build_method_type_directly (TREE_TYPE (TREE_VALUE (args)),
	void_type_node,
	TREE_CHAIN (args));
	else
	fntype = build_function_type (void_type_node, args);
	TREE_TYPE (decl)
	= build_exception_variant (fntype,
	TYPE_RAISES_EXCEPTIONS (TREE_TYPE (decl)));
	}
	else
	abstract_virtuals_error (decl, TREE_TYPE (fntype));
	}

	/* Create the FUNCTION_DECL for a function definition.
	DECLSPECS and DECLARATOR are the parts of the declaration;
	they describe the function's name and the type it returns,
	but twisted together in a fashion that parallels the syntax of C.

	FLAGS is a bitwise or of SF_PRE_PARSED (indicating that the
	DECLARATOR is really the DECL for the function we are about to
	process and that DECLSPECS should be ignored), SF_INCLASS_INLINE
	indicating that the function is an inline defined in-class.

	This function creates a binding context for the function body
	as well as setting up the FUNCTION_DECL in current_function_decl.

	For C++, we must first check whether that datum makes any sense.
	For example, "class A local_a(1,2);" means that variable local_a
	is an aggregate of type A, which should have a constructor
	applied to it with the argument list [1, 2].

	On entry, DECL_INITIAL (decl1) should be NULL_TREE or error_mark_node,
	or may be a BLOCK if the function has been defined previously
	in this translation unit. On exit, DECL_INITIAL (decl1) will be
	error_mark_node if the function has never been defined, or
	a BLOCK if the function has been defined somewhere. */

	void
	start_preparsed_function (tree decl1, tree attrs, int flags)
	{
	tree ctype = NULL_TREE;
	tree fntype;
	tree restype;
	int doing_friend = 0;
	struct cp_binding_level *bl;
	tree current_function_parms;
	struct c_fileinfo *finfo
	= get_fileinfo (LOCATION_FILE (DECL_SOURCE_LOCATION (decl1)));
	bool honor_interface;

	/* Sanity check. */
	gcc_assert (TREE_CODE (TREE_VALUE (void_list_node)) == VOID_TYPE);
	gcc_assert (TREE_CHAIN (void_list_node) == NULL_TREE);

	fntype = TREE_TYPE (decl1);
	if (TREE_CODE (fntype) == METHOD_TYPE)
	ctype = TYPE_METHOD_BASETYPE (fntype);

	/* ISO C++ 11.4/5. A friend function defined in a class is in
	the (lexical) scope of the class in which it is defined. */
	if (!ctype && DECL_FRIEND_P (decl1))
	{
	ctype = DECL_FRIEND_CONTEXT (decl1);

	/* CTYPE could be null here if we're dealing with a template;
	for example, `inline friend float foo()' inside a template
	will have no CTYPE set. */
	if (ctype && TREE_CODE (ctype) != RECORD_TYPE)
	ctype = NULL_TREE;
	else
	doing_friend = 1;
	}

	if (DECL_DECLARED_INLINE_P (decl1)
	&& lookup_attribute ("noinline", attrs))
	warning (0, "inline function %q+D given attribute noinline", decl1);

	if (DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (decl1))
	/* This is a constructor, we must ensure that any default args
	introduced by this definition are propagated to the clones
	now. The clones are used directly in overload resolution. */
	adjust_clone_args (decl1);

	/* Sometimes we don't notice that a function is a static member, and
	build a METHOD_TYPE for it. Fix that up now. */
	if (ctype != NULL_TREE && DECL_STATIC_FUNCTION_P (decl1)
	&& TREE_CODE (TREE_TYPE (decl1)) == METHOD_TYPE)
	{
	revert_static_member_fn (decl1);
	ctype = NULL_TREE;
	}

	/* Set up current_class_type, and enter the scope of the class, if
	appropriate. */
	if (ctype)
	push_nested_class (ctype);
	else if (DECL_STATIC_FUNCTION_P (decl1))
	push_nested_class (DECL_CONTEXT (decl1));

	/* Now that we have entered the scope of the class, we must restore
	the bindings for any template parameters surrounding DECL1, if it
	is an inline member template. (Order is important; consider the
	case where a template parameter has the same name as a field of
	the class.) It is not until after this point that
	PROCESSING_TEMPLATE_DECL is guaranteed to be set up correctly. */
	if (flags & SF_INCLASS_INLINE)
	maybe_begin_member_template_processing (decl1);

	/* Effective C++ rule 15. */
	if (warn_ecpp
	&& DECL_OVERLOADED_OPERATOR_P (decl1) == NOP_EXPR
	&& TREE_CODE (TREE_TYPE (fntype)) == VOID_TYPE)
	warning (OPT_Weffc__, "%<operator=%> should return a reference to %<*this%>");

	/* Make the init_value nonzero so pushdecl knows this is not tentative.
	error_mark_node is replaced below (in poplevel) with the BLOCK. */
	if (!DECL_INITIAL (decl1))
	DECL_INITIAL (decl1) = error_mark_node;

	/* This function exists in static storage.
	(This does not mean `static' in the C sense!) */
	TREE_STATIC (decl1) = 1;

	/* We must call push_template_decl after current_class_type is set
	up. (If we are processing inline definitions after exiting a
	class scope, current_class_type will be NULL_TREE until set above
	by push_nested_class.) */
	if (processing_template_decl)
	{
	/* FIXME: Handle error_mark_node more gracefully. */
	tree newdecl1 = push_template_decl (decl1);
	if (newdecl1 != error_mark_node)
	decl1 = newdecl1;
	}

	/* We are now in the scope of the function being defined. */
	current_function_decl = decl1;

	/* Save the parm names or decls from this function's declarator
	where store_parm_decls will find them. */
	current_function_parms = DECL_ARGUMENTS (decl1);

	/* Make sure the parameter and return types are reasonable. When
	you declare a function, these types can be incomplete, but they
	must be complete when you define the function. */
	check_function_type (decl1, current_function_parms);

	/* Build the return declaration for the function. */
	restype = TREE_TYPE (fntype);
	/* Promote the value to int before returning it. */
	if (c_promoting_integer_type_p (restype))
	restype = type_promotes_to (restype);
	if (DECL_RESULT (decl1) == NULL_TREE)
	{
	tree resdecl;

	resdecl = build_decl (RESULT_DECL, 0, TYPE_MAIN_VARIANT (restype));
	DECL_ARTIFICIAL (resdecl) = 1;
	DECL_IGNORED_P (resdecl) = 1;
	DECL_RESULT (decl1) = resdecl;

	cp_apply_type_quals_to_decl (cp_type_quals (restype), resdecl);
	}

	/* Let the user know we're compiling this function. */
	announce_function (decl1);

	/* Record the decl so that the function name is defined.
	If we already have a decl for this name, and it is a FUNCTION_DECL,
	use the old decl. */
	if (!processing_template_decl && !(flags & SF_PRE_PARSED))
	{
	/* A specialization is not used to guide overload resolution. */
	if (!DECL_FUNCTION_MEMBER_P (decl1)
	&& !(DECL_USE_TEMPLATE (decl1) &&
	PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (decl1))))
	{
	tree olddecl = pushdecl (decl1);

	if (olddecl == error_mark_node)
	/* If something went wrong when registering the declaration,
	use DECL1; we have to have a FUNCTION_DECL to use when
	parsing the body of the function. */
	;
	else
	/* Otherwise, OLDDECL is either a previous declaration of
	the same function or DECL1 itself. */
	decl1 = olddecl;
	}
	else
	{
	/* We need to set the DECL_CONTEXT. */
	if (!DECL_CONTEXT (decl1) && DECL_TEMPLATE_INFO (decl1))
	DECL_CONTEXT (decl1) = DECL_CONTEXT (DECL_TI_TEMPLATE (decl1));
	}
	fntype = TREE_TYPE (decl1);

	/* If #pragma weak applies, mark the decl appropriately now.
	The pragma only applies to global functions. Because
	determining whether or not the #pragma applies involves
	computing the mangled name for the declaration, we cannot
	apply the pragma until after we have merged this declaration
	with any previous declarations; if the original declaration
	has a linkage specification, that specification applies to
	the definition as well, and may affect the mangled name. */
	if (!DECL_CONTEXT (decl1))
	maybe_apply_pragma_weak (decl1);
	}

	/* Reset this in case the call to pushdecl changed it. */
	current_function_decl = decl1;

	gcc_assert (DECL_INITIAL (decl1));

	/* This function may already have been parsed, in which case just
	return; our caller will skip over the body without parsing. */
	if (DECL_INITIAL (decl1) != error_mark_node)
	return;

	/* Initialize RTL machinery. We cannot do this until
	CURRENT_FUNCTION_DECL and DECL_RESULT are set up. We do this
	even when processing a template; this is how we get
	CFUN set up, and our per-function variables initialized.
	FIXME factor out the non-RTL stuff. */
	bl = current_binding_level;
	allocate_struct_function (decl1);
	current_binding_level = bl;

	/* Even though we're inside a function body, we still don't want to
	call expand_expr to calculate the size of a variable-sized array.
	We haven't necessarily assigned RTL to all variables yet, so it's
	not safe to try to expand expressions involving them. */
	cfun->x_dont_save_pending_sizes_p = 1;

	/* Start the statement-tree, start the tree now. */
	DECL_SAVED_TREE (decl1) = push_stmt_list ();

	/* If we are (erroneously) defining a function that we have already
	defined before, wipe out what we knew before. */
	if (!DECL_PENDING_INLINE_P (decl1))
	DECL_SAVED_FUNCTION_DATA (decl1) = NULL;

	if (ctype && !doing_friend && !DECL_STATIC_FUNCTION_P (decl1))
	{
	/* We know that this was set up by `grokclassfn'. We do not
	wait until `store_parm_decls', since evil parse errors may
	never get us to that point. Here we keep the consistency
	between `current_class_type' and `current_class_ptr'. */
	tree t = DECL_ARGUMENTS (decl1);

	gcc_assert (t != NULL_TREE && TREE_CODE (t) == PARM_DECL);
	gcc_assert (TREE_CODE (TREE_TYPE (t)) == POINTER_TYPE);

	cp_function_chain->x_current_class_ref
	= build_indirect_ref (t, NULL);
	cp_function_chain->x_current_class_ptr = t;

	/* Constructors and destructors need to know whether they're "in
	charge" of initializing virtual base classes. */
	t = TREE_CHAIN (t);
	if (DECL_HAS_IN_CHARGE_PARM_P (decl1))
	{
	current_in_charge_parm = t;
	t = TREE_CHAIN (t);
	}
	if (DECL_HAS_VTT_PARM_P (decl1))
	{
	gcc_assert (DECL_NAME (t) == vtt_parm_identifier);
	current_vtt_parm = t;
	}
	}

	honor_interface = (!DECL_TEMPLATE_INSTANTIATION (decl1)
	/* Implicitly-defined methods (like the
	destructor for a class in which no destructor
	is explicitly declared) must not be defined
	until their definition is needed. So, we
	ignore interface specifications for
	compiler-generated functions. */
	&& !DECL_ARTIFICIAL (decl1));

	if (DECL_INTERFACE_KNOWN (decl1))
	{
	tree ctx = decl_function_context (decl1);

	if (DECL_NOT_REALLY_EXTERN (decl1))
	DECL_EXTERNAL (decl1) = 0;

	if (ctx != NULL_TREE && DECL_DECLARED_INLINE_P (ctx)
	&& TREE_PUBLIC (ctx))
	/* This is a function in a local class in an extern inline
	function. */
	comdat_linkage (decl1);
	}
	/* If this function belongs to an interface, it is public.
	If it belongs to someone else's interface, it is also external.
	This only affects inlines and template instantiations. */
	else if (!finfo->interface_unknown && honor_interface)
	{
	if (DECL_DECLARED_INLINE_P (decl1)
	\|\| DECL_TEMPLATE_INSTANTIATION (decl1)
	\|\| processing_template_decl)
	{
	DECL_EXTERNAL (decl1)
	= (finfo->interface_only
	\|\| (DECL_DECLARED_INLINE_P (decl1)
	&& ! flag_implement_inlines
	&& !DECL_VINDEX (decl1)));

	/* For WIN32 we also want to put these in linkonce sections. */
	maybe_make_one_only (decl1);
	}
	else
	DECL_EXTERNAL (decl1) = 0;
	DECL_INTERFACE_KNOWN (decl1) = 1;
	/* If this function is in an interface implemented in this file,
	make sure that the backend knows to emit this function
	here. */
	if (!DECL_EXTERNAL (decl1))
	mark_needed (decl1);
	}
	else if (finfo->interface_unknown && finfo->interface_only
	&& honor_interface)
	{
	/* If MULTIPLE_SYMBOL_SPACES is defined and we saw a #pragma
	interface, we will have both finfo->interface_unknown and
	finfo->interface_only set. In that case, we don't want to
	use the normal heuristics because someone will supply a
	#pragma implementation elsewhere, and deducing it here would
	produce a conflict. */
	comdat_linkage (decl1);
	DECL_EXTERNAL (decl1) = 0;
	DECL_INTERFACE_KNOWN (decl1) = 1;
	DECL_DEFER_OUTPUT (decl1) = 1;
	}
	else
	{
	/* This is a definition, not a reference.
	So clear DECL_EXTERNAL. */
	DECL_EXTERNAL (decl1) = 0;

	if ((DECL_DECLARED_INLINE_P (decl1)
	\|\| DECL_TEMPLATE_INSTANTIATION (decl1))
	&& ! DECL_INTERFACE_KNOWN (decl1)
	/* Don't try to defer nested functions for now. */
	&& ! decl_function_context (decl1))
	DECL_DEFER_OUTPUT (decl1) = 1;
	else
	DECL_INTERFACE_KNOWN (decl1) = 1;
	}

	/* Determine the ELF visibility attribute for the function. We must not
	do this before calling "pushdecl", as we must allow "duplicate_decls"
	to merge any attributes appropriately. We also need to wait until
	linkage is set. */
	if (!DECL_CLONED_FUNCTION_P (decl1))
	determine_visibility (decl1);

	begin_scope (sk_function_parms, decl1);

	++function_depth;

	if (DECL_DESTRUCTOR_P (decl1)
	\|\| (DECL_CONSTRUCTOR_P (decl1)
	&& targetm.cxx.cdtor_returns_this ()))
	{
	cdtor_label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
	DECL_CONTEXT (cdtor_label) = current_function_decl;
	}

	start_fname_decls ();

	store_parm_decls (current_function_parms);
	}


	/* Like start_preparsed_function, except that instead of a
	FUNCTION_DECL, this function takes DECLSPECS and DECLARATOR.

	Returns 1 on success. If the DECLARATOR is not suitable for a function
	(it defines a datum instead), we return 0, which tells
	yyparse to report a parse error. */

	int
	start_function (cp_decl_specifier_seq *declspecs,
	const cp_declarator *declarator,
	tree attrs)
	{
	tree decl1;

	decl1 = grokdeclarator (declarator, declspecs, FUNCDEF, 1, &attrs);
	/* If the declarator is not suitable for a function definition,
	cause a syntax error. */
	if (decl1 == NULL_TREE \|\| TREE_CODE (decl1) != FUNCTION_DECL)
	return 0;

	if (DECL_MAIN_P (decl1))
	/* main must return int. grokfndecl should have corrected it
	(and issued a diagnostic) if the user got it wrong. */
	gcc_assert (same_type_p (TREE_TYPE (TREE_TYPE (decl1)),
	integer_type_node));

	start_preparsed_function (decl1, attrs, /flags=/SF_DEFAULT);

	return 1;
	}

	/* Returns true iff an EH_SPEC_BLOCK should be created in the body of
	FN. */

	static bool
	use_eh_spec_block (tree fn)
	{
	return (flag_exceptions && flag_enforce_eh_specs
	&& !processing_template_decl
	&& TYPE_RAISES_EXCEPTIONS (TREE_TYPE (fn))
	/* We insert the EH_SPEC_BLOCK only in the original
	function; then, it is copied automatically to the
	clones. */
	&& !DECL_CLONED_FUNCTION_P (fn)
	/* Implicitly-generated constructors and destructors have
	exception specifications. However, those specifications
	are the union of the possible exceptions specified by the
	constructors/destructors for bases and members, so no
	unallowed exception will ever reach this function. By
	not creating the EH_SPEC_BLOCK we save a little memory,
	and we avoid spurious warnings about unreachable
	code. */
	&& !DECL_ARTIFICIAL (fn));
	}

	/* Store the parameter declarations into the current function declaration.
	This is called after parsing the parameter declarations, before
	digesting the body of the function.

	Also install to binding contour return value identifier, if any. */

	static void
	store_parm_decls (tree current_function_parms)
	{
	tree fndecl = current_function_decl;
	tree parm;

	/* This is a chain of any other decls that came in among the parm
	declarations. If a parm is declared with enum {foo, bar} x;
	then CONST_DECLs for foo and bar are put here. */
	tree nonparms = NULL_TREE;

	if (current_function_parms)
	{
	/* This case is when the function was defined with an ANSI prototype.
	The parms already have decls, so we need not do anything here
	except record them as in effect
	and complain if any redundant old-style parm decls were written. */

	tree specparms = current_function_parms;
	tree next;

	/* Must clear this because it might contain TYPE_DECLs declared
	at class level. */
	current_binding_level->names = NULL;

	/* If we're doing semantic analysis, then we'll call pushdecl
	for each of these. We must do them in reverse order so that
	they end in the correct forward order. */
	specparms = nreverse (specparms);

	for (parm = specparms; parm; parm = next)
	{
	next = TREE_CHAIN (parm);
	if (TREE_CODE (parm) == PARM_DECL)
	{
	if (DECL_NAME (parm) == NULL_TREE
	\|\| TREE_CODE (parm) != VOID_TYPE)
	pushdecl (parm);
	else
	error ("parameter %qD declared void", parm);
	}
	else
	{
	/* If we find an enum constant or a type tag,
	put it aside for the moment. */
	TREE_CHAIN (parm) = NULL_TREE;
	nonparms = chainon (nonparms, parm);
	}
	}

	/* Get the decls in their original chain order and record in the
	function. This is all and only the PARM_DECLs that were
	pushed into scope by the loop above. */
	DECL_ARGUMENTS (fndecl) = getdecls ();
	}
	else
	DECL_ARGUMENTS (fndecl) = NULL_TREE;

	/* Now store the final chain of decls for the arguments
	as the decl-chain of the current lexical scope.
	Put the enumerators in as well, at the front so that
	DECL_ARGUMENTS is not modified. */
	current_binding_level->names = chainon (nonparms, DECL_ARGUMENTS (fndecl));

	if (use_eh_spec_block (current_function_decl))
	current_eh_spec_block = begin_eh_spec_block ();
	}


	/* We have finished doing semantic analysis on DECL, but have not yet
	generated RTL for its body. Save away our current state, so that
	when we want to generate RTL later we know what to do. */

	static void
	save_function_data (tree decl)
	{
	struct language_function *f;

	/* Save the language-specific per-function data so that we can
	get it back when we really expand this function. */
	gcc_assert (!DECL_PENDING_INLINE_P (decl));

	/* Make a copy. */
	f = GGC_NEW (struct language_function);
	memcpy (f, cp_function_chain, sizeof (struct language_function));
	DECL_SAVED_FUNCTION_DATA (decl) = f;

	/* Clear out the bits we don't need. */
	f->base.x_stmt_tree.x_cur_stmt_list = NULL_TREE;
	f->bindings = NULL;
	f->x_local_names = NULL;
	}


	/* Set the return value of the constructor (if present). */

	static void
	finish_constructor_body (void)
	{
	tree val;
	tree exprstmt;

	if (targetm.cxx.cdtor_returns_this ())
	{
	/* Any return from a constructor will end up here. */
	add_stmt (build_stmt (LABEL_EXPR, cdtor_label));

	val = DECL_ARGUMENTS (current_function_decl);
	val = build2 (MODIFY_EXPR, TREE_TYPE (val),
	DECL_RESULT (current_function_decl), val);
	/* Return the address of the object. */
	exprstmt = build_stmt (RETURN_EXPR, val);
	add_stmt (exprstmt);
	}
	}

	/* Do all the processing for the beginning of a destructor; set up the
	vtable pointers and cleanups for bases and members. */

	static void
	begin_destructor_body (void)
	{
	tree compound_stmt;

	/* If the CURRENT_CLASS_TYPE is incomplete, we will have already
	issued an error message. We still want to try to process the
	body of the function, but initialize_vtbl_ptrs will crash if
	TYPE_BINFO is NULL. */
	if (COMPLETE_TYPE_P (current_class_type))
	{
	compound_stmt = begin_compound_stmt (0);
	/* Make all virtual function table pointers in non-virtual base
	classes point to CURRENT_CLASS_TYPE's virtual function
	tables. */
	initialize_vtbl_ptrs (current_class_ptr);
	finish_compound_stmt (compound_stmt);

	/* And insert cleanups for our bases and members so that they
	will be properly destroyed if we throw. */
	push_base_cleanups ();
	}
	}

	/* At the end of every destructor we generate code to delete the object if
	necessary. Do that now. */

	static void
	finish_destructor_body (void)
	{
	tree exprstmt;

	/* Any return from a destructor will end up here; that way all base
	and member cleanups will be run when the function returns. */
	add_stmt (build_stmt (LABEL_EXPR, cdtor_label));

	/* In a virtual destructor, we must call delete. */
	if (DECL_VIRTUAL_P (current_function_decl))
	{
	tree if_stmt;
	tree virtual_size = cxx_sizeof (current_class_type);

	/* [class.dtor]

	At the point of definition of a virtual destructor (including
	an implicit definition), non-placement operator delete shall
	be looked up in the scope of the destructor's class and if
	found shall be accessible and unambiguous. */
	exprstmt = build_op_delete_call(DELETE_EXPR, current_class_ptr,
	virtual_size,
	/global_p=/false,
	/placement=/NULL_TREE,
	/alloc_fn=/NULL_TREE);

	if_stmt = begin_if_stmt ();
	finish_if_stmt_cond (build2 (BIT_AND_EXPR, integer_type_node,
	current_in_charge_parm,
	integer_one_node),
	if_stmt);
	finish_expr_stmt (exprstmt);
	finish_then_clause (if_stmt);
	finish_if_stmt (if_stmt);
	}

	if (targetm.cxx.cdtor_returns_this ())
	{
	tree val;

	val = DECL_ARGUMENTS (current_function_decl);
	val = build2 (MODIFY_EXPR, TREE_TYPE (val),
	DECL_RESULT (current_function_decl), val);
	/* Return the address of the object. */
	exprstmt = build_stmt (RETURN_EXPR, val);
	add_stmt (exprstmt);
	}
	}

	/* Do the necessary processing for the beginning of a function body, which
	in this case includes member-initializers, but not the catch clauses of
	a function-try-block. Currently, this means opening a binding level
	for the member-initializers (in a ctor) and member cleanups (in a dtor). */

	tree
	begin_function_body (void)
	{
	tree stmt;

	if (! FUNCTION_NEEDS_BODY_BLOCK (current_function_decl))
	return NULL_TREE;

	if (processing_template_decl)
	/* Do nothing now. */;
	else
	/* Always keep the BLOCK node associated with the outermost pair of
	curly braces of a function. These are needed for correct
	operation of dwarfout.c. */
	keep_next_level (true);

	stmt = begin_compound_stmt (BCS_FN_BODY);

	if (processing_template_decl)
	/* Do nothing now. */;
	else if (DECL_DESTRUCTOR_P (current_function_decl))
	begin_destructor_body ();

	return stmt;
	}

	/* Do the processing for the end of a function body. Currently, this means
	closing out the cleanups for fully-constructed bases and members, and in
	the case of the destructor, deleting the object if desired. Again, this
	is only meaningful for [cd]tors, since they are the only functions where
	there is a significant distinction between the main body and any
	function catch clauses. Handling, say, main() return semantics here
	would be wrong, as flowing off the end of a function catch clause for
	main() would also need to return 0. */

	void
	finish_function_body (tree compstmt)
	{
	if (compstmt == NULL_TREE)
	return;

	/* Close the block. */
	finish_compound_stmt (compstmt);

	if (processing_template_decl)
	/* Do nothing now. */;
	else if (DECL_CONSTRUCTOR_P (current_function_decl))
	finish_constructor_body ();
	else if (DECL_DESTRUCTOR_P (current_function_decl))
	finish_destructor_body ();
	}

	/* Given a function, returns the BLOCK corresponding to the outermost level
	of curly braces, skipping the artificial block created for constructor
	initializers. */

	static tree
	outer_curly_brace_block (tree fndecl)
	{
	tree block = BLOCK_SUBBLOCKS (DECL_INITIAL (fndecl));
	if (FUNCTION_NEEDS_BODY_BLOCK (current_function_decl))
	/* Skip the artificial function body block. */
	block = BLOCK_SUBBLOCKS (block);
	return block;
	}

	/* Finish up a function declaration and compile that function
	all the way to assembler language output. The free the storage
	for the function definition.

	FLAGS is a bitwise or of the following values:
	2 - INCLASS_INLINE
	We just finished processing the body of an in-class inline
	function definition. (This processing will have taken place
	after the class definition is complete.) */

	tree
	finish_function (int flags)
	{
	tree fndecl = current_function_decl;
	tree fntype, ctype = NULL_TREE;
	int inclass_inline = (flags & 2) != 0;
	int nested;

	/* When we get some parse errors, we can end up without a
	current_function_decl, so cope. */
	if (fndecl == NULL_TREE)
	return error_mark_node;

	if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fndecl)
	&& DECL_VIRTUAL_P (fndecl)
	&& !processing_template_decl)
	{
	tree fnclass = DECL_CONTEXT (fndecl);
	if (fndecl == CLASSTYPE_KEY_METHOD (fnclass))
	keyed_classes = tree_cons (NULL_TREE, fnclass, keyed_classes);
	}

	nested = function_depth > 1;
	fntype = TREE_TYPE (fndecl);

	/* TREE_READONLY (fndecl) = 1;
	This caused &foo to be of type ptr-to-const-function
	which then got a warning when stored in a ptr-to-function variable. */

	gcc_assert (building_stmt_tree ());
	/* The current function is being defined, so its DECL_INITIAL should
	be set, and unless there's a multiple definition, it should be
	error_mark_node. */
	gcc_assert (DECL_INITIAL (fndecl) == error_mark_node);

	/* For a cloned function, we've already got all the code we need;
	there's no need to add any extra bits. */
	if (!DECL_CLONED_FUNCTION_P (fndecl))
	{
	if (DECL_MAIN_P (current_function_decl))
	{
	tree stmt;

	/* Make it so that `main' always returns 0 by default (or
	1 for VMS). */
	#if VMS_TARGET
	stmt = finish_return_stmt (integer_one_node);
	#else
	stmt = finish_return_stmt (integer_zero_node);
	#endif
	/* Hack. We don't want the middle-end to warn that this
	return is unreachable, so put the statement on the
	special line 0. */
	#ifdef USE_MAPPED_LOCATION
	SET_EXPR_LOCATION (stmt, UNKNOWN_LOCATION);
	#else
	annotate_with_file_line (stmt, input_filename, 0);
	#endif
	}

	if (use_eh_spec_block (current_function_decl))
	finish_eh_spec_block (TYPE_RAISES_EXCEPTIONS
	(TREE_TYPE (current_function_decl)),
	current_eh_spec_block);
	}

	/* If we're saving up tree structure, tie off the function now. */
	DECL_SAVED_TREE (fndecl) = pop_stmt_list (DECL_SAVED_TREE (fndecl));

	finish_fname_decls ();

	/* If this function can't throw any exceptions, remember that. */
	if (!processing_template_decl
	&& !cp_function_chain->can_throw
	&& !flag_non_call_exceptions
	&& !DECL_REPLACEABLE_P (fndecl))
	TREE_NOTHROW (fndecl) = 1;

	/* This must come after expand_function_end because cleanups might
	have declarations (from inline functions) that need to go into
	this function's blocks. */

	/* If the current binding level isn't the outermost binding level
	for this function, either there is a bug, or we have experienced
	syntax errors and the statement tree is malformed. */
	if (current_binding_level->kind != sk_function_parms)
	{
	/* Make sure we have already experienced errors. */
	gcc_assert (errorcount);

	/* Throw away the broken statement tree and extra binding
	levels. */
	DECL_SAVED_TREE (fndecl) = alloc_stmt_list ();

	while (current_binding_level->kind != sk_function_parms)
	{
	if (current_binding_level->kind == sk_class)
	pop_nested_class ();
	else
	poplevel (0, 0, 0);
	}
	}
	poplevel (1, 0, 1);

	/* Statements should always be full-expressions at the outermost set
	of curly braces for a function. */
	gcc_assert (stmts_are_full_exprs_p ());

	/* Set up the named return value optimization, if we can. Candidate
	variables are selected in check_return_expr. */
	if (current_function_return_value)
	{
	tree r = current_function_return_value;
	tree outer;

	if (r != error_mark_node
	/* This is only worth doing for fns that return in memory--and
	simpler, since we don't have to worry about promoted modes. */
	&& aggregate_value_p (TREE_TYPE (TREE_TYPE (fndecl)), fndecl)
	/* Only allow this for variables declared in the outer scope of
	the function so we know that their lifetime always ends with a
	return; see g++.dg/opt/nrv6.C. We could be more flexible if
	we were to do this optimization in tree-ssa. */
	&& (outer = outer_curly_brace_block (fndecl))
	&& chain_member (r, BLOCK_VARS (outer)))
	finalize_nrv (&DECL_SAVED_TREE (fndecl), r, DECL_RESULT (fndecl));

	current_function_return_value = NULL_TREE;
	}

	/* Remember that we were in class scope. */
	if (current_class_name)
	ctype = current_class_type;

	/* Must mark the RESULT_DECL as being in this function. */
	DECL_CONTEXT (DECL_RESULT (fndecl)) = fndecl;

	/* Set the BLOCK_SUPERCONTEXT of the outermost function scope to point
	to the FUNCTION_DECL node itself. */
	BLOCK_SUPERCONTEXT (DECL_INITIAL (fndecl)) = fndecl;

	/* Save away current state, if appropriate. */
	if (!processing_template_decl)
	save_function_data (fndecl);

	/* Complain if there's just no return statement. */
	if (warn_return_type
	&& TREE_CODE (TREE_TYPE (fntype)) != VOID_TYPE
	&& !dependent_type_p (TREE_TYPE (fntype))
	&& !current_function_returns_value && !current_function_returns_null
	/* Don't complain if we abort or throw. */
	&& !current_function_returns_abnormally
	&& !DECL_NAME (DECL_RESULT (fndecl))
	/* Normally, with -Wreturn-type, flow will complain. Unless we're an
	inline function, as we might never be compiled separately. */
	&& (DECL_INLINE (fndecl) \|\| processing_template_decl)
	/* Structor return values (if any) are set by the compiler. */
	&& !DECL_CONSTRUCTOR_P (fndecl)
	&& !DECL_DESTRUCTOR_P (fndecl))
	warning (OPT_Wreturn_type, "no return statement in function returning non-void");

	/* Store the end of the function, so that we get good line number
	info for the epilogue. */
	cfun->function_end_locus = input_location;

	/* Genericize before inlining. */
	if (!processing_template_decl)
	{
	struct language_function *f = DECL_SAVED_FUNCTION_DATA (fndecl);
	cp_genericize (fndecl);
	/* Clear out the bits we don't need. */
	f->x_current_class_ptr = NULL;
	f->x_current_class_ref = NULL;
	f->x_eh_spec_block = NULL;
	f->x_in_charge_parm = NULL;
	f->x_vtt_parm = NULL;
	f->x_return_value = NULL;
	f->bindings = NULL;
	f->extern_decl_map = NULL;

	/* Handle attribute((warn_unused_result)). Relies on gimple input. */
	c_warn_unused_result (&DECL_SAVED_TREE (fndecl));
	}
	/* Clear out the bits we don't need. */
	local_names = NULL;

	/* We're leaving the context of this function, so zap cfun. It's still in
	DECL_STRUCT_FUNCTION, and we'll restore it in tree_rest_of_compilation. */
	cfun = NULL;
	current_function_decl = NULL;

	/* If this is an in-class inline definition, we may have to pop the
	bindings for the template parameters that we added in
	maybe_begin_member_template_processing when start_function was
	called. */
	if (inclass_inline)
	maybe_end_member_template_processing ();

	/* Leave the scope of the class. */
	if (ctype)
	pop_nested_class ();

	--function_depth;

	/* Clean up. */
	if (! nested)
	/* Let the error reporting routines know that we're outside a
	function. For a nested function, this value is used in
	cxx_pop_function_context and then reset via pop_function_context. */
	current_function_decl = NULL_TREE;

	return fndecl;
	}

	/* Create the FUNCTION_DECL for a function definition.
	DECLSPECS and DECLARATOR are the parts of the declaration;
	they describe the return type and the name of the function,
	but twisted together in a fashion that parallels the syntax of C.

	This function creates a binding context for the function body
	as well as setting up the FUNCTION_DECL in current_function_decl.

	Returns a FUNCTION_DECL on success.

	If the DECLARATOR is not suitable for a function (it defines a datum
	instead), we return 0, which tells yyparse to report a parse error.

	May return void_type_node indicating that this method is actually
	a friend. See grokfield for more details.

	Came here with a `.pushlevel' .

	DO NOT MAKE ANY CHANGES TO THIS CODE WITHOUT MAKING CORRESPONDING
	CHANGES TO CODE IN `grokfield'. */

	tree
	start_method (cp_decl_specifier_seq *declspecs,
	const cp_declarator *declarator, tree attrlist)
	{
	tree fndecl = grokdeclarator (declarator, declspecs, MEMFUNCDEF, 0,
	&attrlist);

	if (fndecl == error_mark_node)
	return error_mark_node;

	if (fndecl == NULL \|\| TREE_CODE (fndecl) != FUNCTION_DECL)
	{
	error ("invalid member function declaration");
	return error_mark_node;
	}

	if (attrlist)
	cplus_decl_attributes (&fndecl, attrlist, 0);

	/* Pass friends other than inline friend functions back. */
	if (fndecl == void_type_node)
	return fndecl;

	if (DECL_IN_AGGR_P (fndecl))
	{
	if (DECL_CONTEXT (fndecl)
	&& TREE_CODE (DECL_CONTEXT (fndecl)) != NAMESPACE_DECL)
	error ("%qD is already defined in class %qT", fndecl,
	DECL_CONTEXT (fndecl));
	return error_mark_node;
	}

	check_template_shadow (fndecl);

	DECL_DECLARED_INLINE_P (fndecl) = 1;
	if (flag_default_inline)
	DECL_INLINE (fndecl) = 1;

	/* We process method specializations in finish_struct_1. */
	if (processing_template_decl && !DECL_TEMPLATE_SPECIALIZATION (fndecl))
	{
	fndecl = push_template_decl (fndecl);
	if (fndecl == error_mark_node)
	return fndecl;
	}

	if (! DECL_FRIEND_P (fndecl))
	{
	if (TREE_CHAIN (fndecl))
	{
	fndecl = copy_node (fndecl);
	TREE_CHAIN (fndecl) = NULL_TREE;
	}
	}

	finish_decl (fndecl, NULL_TREE, NULL_TREE);

	/* Make a place for the parms. */
	begin_scope (sk_function_parms, fndecl);

	DECL_IN_AGGR_P (fndecl) = 1;
	return fndecl;
	}

	/* Go through the motions of finishing a function definition.
	We don't compile this method until after the whole class has
	been processed.

	FINISH_METHOD must return something that looks as though it
	came from GROKFIELD (since we are defining a method, after all).

	This is called after parsing the body of the function definition.
	STMTS is the chain of statements that makes up the function body.

	DECL is the ..._DECL that `start_method' provided. */

	tree
	finish_method (tree decl)
	{
	tree fndecl = decl;
	tree old_initial;

	tree link;

	if (decl == void_type_node)
	return decl;

	old_initial = DECL_INITIAL (fndecl);

	/* Undo the level for the parms (from start_method).
	This is like poplevel, but it causes nothing to be
	saved. Saving information here confuses symbol-table
	output routines. Besides, this information will
	be correctly output when this method is actually
	compiled. */

	/* Clear out the meanings of the local variables of this level;
	also record in each decl which block it belongs to. */

	for (link = current_binding_level->names; link; link = TREE_CHAIN (link))
	{
	if (DECL_NAME (link) != NULL_TREE)
	pop_binding (DECL_NAME (link), link);
	gcc_assert (TREE_CODE (link) != FUNCTION_DECL);
	DECL_CONTEXT (link) = NULL_TREE;
	}

	poplevel (0, 0, 0);

	DECL_INITIAL (fndecl) = old_initial;

	/* We used to check if the context of FNDECL was different from
	current_class_type as another way to get inside here. This didn't work
	for String.cc in libg++. */
	if (DECL_FRIEND_P (fndecl))
	{
	VEC_safe_push (tree, gc, CLASSTYPE_INLINE_FRIENDS (current_class_type),
	fndecl);
	decl = void_type_node;
	}

	return decl;
	}


	/* VAR is a VAR_DECL. If its type is incomplete, remember VAR so that
	we can lay it out later, when and if its type becomes complete. */

	void
	maybe_register_incomplete_var (tree var)
	{
	gcc_assert (TREE_CODE (var) == VAR_DECL);

	/* Keep track of variables with incomplete types. */
	if (!processing_template_decl && TREE_TYPE (var) != error_mark_node
	&& DECL_EXTERNAL (var))
	{
	tree inner_type = TREE_TYPE (var);

	while (TREE_CODE (inner_type) == ARRAY_TYPE)
	inner_type = TREE_TYPE (inner_type);
	inner_type = TYPE_MAIN_VARIANT (inner_type);

	if ((!COMPLETE_TYPE_P (inner_type) && CLASS_TYPE_P (inner_type))
	/* RTTI TD entries are created while defining the type_info. */
	\|\| (TYPE_LANG_SPECIFIC (inner_type)
	&& TYPE_BEING_DEFINED (inner_type)))
	incomplete_vars = tree_cons (inner_type, var, incomplete_vars);
	}
	}

	/* Called when a class type (given by TYPE) is defined. If there are
	any existing VAR_DECLs whose type hsa been completed by this
	declaration, update them now. */

	void
	complete_vars (tree type)
	{
	tree *list = &incomplete_vars;

	gcc_assert (CLASS_TYPE_P (type));
	while (*list)
	{
	if (same_type_p (type, TREE_PURPOSE (*list)))
	{
	tree var = TREE_VALUE (*list);
	tree type = TREE_TYPE (var);
	/* Complete the type of the variable. The VAR_DECL itself
	will be laid out in expand_expr. */
	complete_type (type);
	cp_apply_type_quals_to_decl (cp_type_quals (type), var);
	/* Remove this entry from the list. */
	list = TREE_CHAIN (list);
	}
	else
	list = &TREE_CHAIN (*list);
	}

	/* Check for pending declarations which may have abstract type. */
	complete_type_check_abstract (type);
	}

	/* If DECL is of a type which needs a cleanup, build that cleanup
	here. */

	tree
	cxx_maybe_build_cleanup (tree decl)
	{
	tree type = TREE_TYPE (decl);

	if (type != error_mark_node && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
	{
	int flags = LOOKUP_NORMAL\|LOOKUP_DESTRUCTOR;
	tree rval;
	bool has_vbases = (TREE_CODE (type) == RECORD_TYPE
	&& CLASSTYPE_VBASECLASSES (type));

	if (TREE_CODE (type) == ARRAY_TYPE)
	rval = decl;
	else
	{
	cxx_mark_addressable (decl);
	rval = build_unary_op (ADDR_EXPR, decl, 0);
	}

	/* Optimize for space over speed here. */
	if (!has_vbases \|\| flag_expensive_optimizations)
	flags \|= LOOKUP_NONVIRTUAL;

	rval = build_delete (TREE_TYPE (rval), rval,
	sfk_complete_destructor, flags, 0);

	return rval;
	}
	return NULL_TREE;
	}

	/* When a stmt has been parsed, this function is called. */

	void
	finish_stmt (void)
	{
	}

	/* DECL was originally constructed as a non-static member function,
	but turned out to be static. Update it accordingly. */

	void
	revert_static_member_fn (tree decl)
	{
	tree tmp;
	tree function = TREE_TYPE (decl);
	tree args = TYPE_ARG_TYPES (function);

	if (cp_type_quals (TREE_TYPE (TREE_VALUE (args)))
	!= TYPE_UNQUALIFIED)
	error ("static member function %q#D declared with type qualifiers", decl);

	args = TREE_CHAIN (args);
	tmp = build_function_type (TREE_TYPE (function), args);
	tmp = build_qualified_type (tmp, cp_type_quals (function));
	tmp = build_exception_variant (tmp,
	TYPE_RAISES_EXCEPTIONS (function));
	TREE_TYPE (decl) = tmp;
	if (DECL_ARGUMENTS (decl))
	DECL_ARGUMENTS (decl) = TREE_CHAIN (DECL_ARGUMENTS (decl));
	DECL_STATIC_FUNCTION_P (decl) = 1;
	}

	/* Initialize the variables used during compilation of a C++
	function. */

	void
	cxx_push_function_context (struct function * f)
	{
	struct language_function *p = GGC_CNEW (struct language_function);
	f->language = p;

	/* Whenever we start a new function, we destroy temporaries in the
	usual way. */
	current_stmt_tree ()->stmts_are_full_exprs_p = 1;

	if (f->decl)
	{
	tree fn = f->decl;

	if (DECL_SAVED_FUNCTION_DATA (fn))
	{
	/* If we already parsed this function, and we're just expanding it
	now, restore saved state. */
	cp_function_chain = DECL_SAVED_FUNCTION_DATA (fn);

	/* We don't need the saved data anymore. Unless this is an inline
	function; we need the named return value info for
	declare_return_variable. */
	if (! DECL_INLINE (fn))
	DECL_SAVED_FUNCTION_DATA (fn) = NULL;
	}
	}
	}

	/* Free the language-specific parts of F, now that we've finished
	compiling the function. */

	void
	cxx_pop_function_context (struct function * f)
	{
	f->language = 0;
	}

	/* Return which tree structure is used by T, or TS_CP_GENERIC if T is
	one of the language-independent trees. */

	enum cp_tree_node_structure_enum
	cp_tree_node_structure (union lang_tree_node * t)
	{
	switch (TREE_CODE (&t->generic))
	{
	case DEFAULT_ARG: return TS_CP_DEFAULT_ARG;
	case IDENTIFIER_NODE: return TS_CP_IDENTIFIER;
	case OVERLOAD: return TS_CP_OVERLOAD;
	case TEMPLATE_PARM_INDEX: return TS_CP_TPI;
	case TINST_LEVEL: return TS_CP_TINST_LEVEL;
	case PTRMEM_CST: return TS_CP_PTRMEM;
	case BASELINK: return TS_CP_BASELINK;
	default: return TS_CP_GENERIC;
	}
	}

	/* Build the void_list_node (void_type_node having been created). */
	tree
	build_void_list_node (void)
	{
	tree t = build_tree_list (NULL_TREE, void_type_node);
	return t;
	}

	bool
	cp_missing_noreturn_ok_p (tree decl)
	{
	/* A missing noreturn is ok for the `main' function. */
	return DECL_MAIN_P (decl);
	}

	/* Return the COMDAT group into which DECL should be placed. */

	const char *
	cxx_comdat_group (tree decl)
	{
	tree name;

	/* Virtual tables, construction virtual tables, and virtual table
	tables all go in a single COMDAT group, named after the primary
	virtual table. */
	if (TREE_CODE (decl) == VAR_DECL && DECL_VTABLE_OR_VTT_P (decl))
	name = DECL_ASSEMBLER_NAME (CLASSTYPE_VTABLES (DECL_CONTEXT (decl)));
	/* For all other DECLs, the COMDAT group is the mangled name of the
	declaration itself. */
	else
	{
	while (DECL_THUNK_P (decl))
	{
	/* If TARGET_USE_LOCAL_THUNK_ALIAS_P, use_thunk puts the thunk
	into the same section as the target function. In that case
	we must return target's name. */
	tree target = THUNK_TARGET (decl);
	if (TARGET_USE_LOCAL_THUNK_ALIAS_P (target)
	&& DECL_SECTION_NAME (target) != NULL
	&& DECL_ONE_ONLY (target))
	decl = target;
	else
	break;
	}
	name = DECL_ASSEMBLER_NAME (decl);
	}

	return IDENTIFIER_POINTER (name);
	}

	#include "gt-cp-decl.h"
	diff --git a/contrib/gcc/cp/dump.c b/contrib/gcc/cp/dump.c
	index c63cfe2bd898..b4253f3bd9cb 100644
	--- a/contrib/gcc/cp/dump.c
	+++ b/contrib/gcc/cp/dump.c
	@@ -1,472 +1,481 @@
	/* Tree-dumping functionality for intermediate representation.
	Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005
	Free Software Foundation, Inc.
	Written by Mark Mitchell <mark@codesourcery.com>

	This file is part of GCC.

	GCC is free software; you can redistribute it and/or modify
	it under the terms of the GNU General Public License as published by
	the Free Software Foundation; either version 2, or (at your option)
	any later version.

	GCC is distributed in the hope that it will be useful,
	but WITHOUT ANY WARRANTY; without even the implied warranty of
	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	GNU General Public License for more details.

	You should have received a copy of the GNU General Public License
	along with GCC; see the file COPYING. If not, write to
	the Free Software Foundation, 51 Franklin Street, Fifth Floor,
	Boston, MA 02110-1301, USA. */

	#include "config.h"
	#include "system.h"
	#include "coretypes.h"
	#include "tm.h"
	#include "tree.h"
	#include "cp-tree.h"
	#include "tree-dump.h"

	static void dump_access (dump_info_p, tree);

	static void dump_op (dump_info_p, tree);

	/* Dump a representation of the accessibility information associated
	with T. */

	static void
	dump_access (dump_info_p di, tree t)
	{
	if (TREE_PROTECTED(t))
	dump_string_field (di, "accs", "prot");
	else if (TREE_PRIVATE(t))
	dump_string_field (di, "accs", "priv");
	else
	dump_string_field (di, "accs", "pub");
	}

	/* Dump a representation of the specific operator for an overloaded
	operator associated with node t. */

	static void
	dump_op (dump_info_p di, tree t)
	{
	switch (DECL_OVERLOADED_OPERATOR_P (t)) {
	case NEW_EXPR:
	dump_string (di, "new");
	break;
	case VEC_NEW_EXPR:
	dump_string (di, "vecnew");
	break;
	case DELETE_EXPR:
	dump_string (di, "delete");
	break;
	case VEC_DELETE_EXPR:
	dump_string (di, "vecdelete");
	break;
	case UNARY_PLUS_EXPR:
	dump_string (di, "pos");
	break;
	case NEGATE_EXPR:
	dump_string (di, "neg");
	break;
	case ADDR_EXPR:
	dump_string (di, "addr");
	break;
	case INDIRECT_REF:
	dump_string(di, "deref");
	break;
	case BIT_NOT_EXPR:
	dump_string(di, "not");
	break;
	case TRUTH_NOT_EXPR:
	dump_string(di, "lnot");
	break;
	case PREINCREMENT_EXPR:
	dump_string(di, "preinc");
	break;
	case PREDECREMENT_EXPR:
	dump_string(di, "predec");
	break;
	case PLUS_EXPR:
	if (DECL_ASSIGNMENT_OPERATOR_P (t))
	dump_string (di, "plusassign");
	else
	dump_string(di, "plus");
	break;
	case MINUS_EXPR:
	if (DECL_ASSIGNMENT_OPERATOR_P (t))
	dump_string (di, "minusassign");
	else
	dump_string(di, "minus");
	break;
	case MULT_EXPR:
	if (DECL_ASSIGNMENT_OPERATOR_P (t))
	dump_string (di, "multassign");
	else
	dump_string (di, "mult");
	break;
	case TRUNC_DIV_EXPR:
	if (DECL_ASSIGNMENT_OPERATOR_P (t))
	dump_string (di, "divassign");
	else
	dump_string (di, "div");
	break;
	case TRUNC_MOD_EXPR:
	if (DECL_ASSIGNMENT_OPERATOR_P (t))
	dump_string (di, "modassign");
	else
	dump_string (di, "mod");
	break;
	case BIT_AND_EXPR:
	if (DECL_ASSIGNMENT_OPERATOR_P (t))
	dump_string (di, "andassign");
	else
	dump_string (di, "and");
	break;
	case BIT_IOR_EXPR:
	if (DECL_ASSIGNMENT_OPERATOR_P (t))
	dump_string (di, "orassign");
	else
	dump_string (di, "or");
	break;
	case BIT_XOR_EXPR:
	if (DECL_ASSIGNMENT_OPERATOR_P (t))
	dump_string (di, "xorassign");
	else
	dump_string (di, "xor");
	break;
	case LSHIFT_EXPR:
	if (DECL_ASSIGNMENT_OPERATOR_P (t))
	dump_string (di, "lshiftassign");
	else
	dump_string (di, "lshift");
	break;
	case RSHIFT_EXPR:
	if (DECL_ASSIGNMENT_OPERATOR_P (t))
	dump_string (di, "rshiftassign");
	else
	dump_string (di, "rshift");
	break;
	case EQ_EXPR:
	dump_string (di, "eq");
	break;
	case NE_EXPR:
	dump_string (di, "ne");
	break;
	case LT_EXPR:
	dump_string (di, "lt");
	break;
	case GT_EXPR:
	dump_string (di, "gt");
	break;
	case LE_EXPR:
	dump_string (di, "le");
	break;
	case GE_EXPR:
	dump_string (di, "ge");
	break;
	case TRUTH_ANDIF_EXPR:
	dump_string (di, "land");
	break;
	case TRUTH_ORIF_EXPR:
	dump_string (di, "lor");
	break;
	case COMPOUND_EXPR:
	dump_string (di, "compound");
	break;
	case MEMBER_REF:
	dump_string (di, "memref");
	break;
	case COMPONENT_REF:
	dump_string (di, "ref");
	break;
	case ARRAY_REF:
	dump_string (di, "subs");
	break;
	case POSTINCREMENT_EXPR:
	dump_string (di, "postinc");
	break;
	case POSTDECREMENT_EXPR:
	dump_string (di, "postdec");
	break;
	case CALL_EXPR:
	dump_string (di, "call");
	break;
	case NOP_EXPR:
	if (DECL_ASSIGNMENT_OPERATOR_P (t))
	dump_string (di, "assign");
	break;
	default:
	break;
	}
	}

	bool
	cp_dump_tree (void* dump_info, tree t)
	{
	enum tree_code code;
	dump_info_p di = (dump_info_p) dump_info;

	/* Figure out what kind of node this is. */
	code = TREE_CODE (t);

	if (DECL_P (t))
	{
	if (DECL_LANG_SPECIFIC (t) && DECL_LANGUAGE (t) != lang_cplusplus)
	dump_string_field (di, "lang", language_to_string (DECL_LANGUAGE (t)));
	}

	switch (code)
	{
	case IDENTIFIER_NODE:
	if (IDENTIFIER_OPNAME_P (t))
	{
	dump_string_field (di, "note", "operator");
	return true;
	}
	else if (IDENTIFIER_TYPENAME_P (t))
	{
	dump_child ("tynm", TREE_TYPE (t));
	return true;
	}
	break;

	case OFFSET_TYPE:
	dump_string_field (di, "note", "ptrmem");
	dump_child ("ptd", TYPE_PTRMEM_POINTED_TO_TYPE (t));
	dump_child ("cls", TYPE_PTRMEM_CLASS_TYPE (t));
	return true;

	case RECORD_TYPE:
	if (TYPE_PTRMEMFUNC_P (t))
	{
	dump_string_field (di, "note", "ptrmem");
	dump_child ("ptd", TYPE_PTRMEM_POINTED_TO_TYPE (t));
	dump_child ("cls", TYPE_PTRMEM_CLASS_TYPE (t));
	return true;
	}
	/* Fall through. */

	case UNION_TYPE:
	/* Is it a type used as a base? */
	if (TYPE_CONTEXT (t) && TREE_CODE (TYPE_CONTEXT (t)) == TREE_CODE (t)
	&& CLASSTYPE_AS_BASE (TYPE_CONTEXT (t)) == t)
	{
	dump_child ("bfld", TYPE_CONTEXT (t));
	return true;
	}

	if (! IS_AGGR_TYPE (t))
	break;

	dump_child ("vfld", TYPE_VFIELD (t));
	if (CLASSTYPE_TEMPLATE_SPECIALIZATION(t))
	dump_string(di, "spec");

	if (!dump_flag (di, TDF_SLIM, t) && TYPE_BINFO (t))
	{
	int i;
	tree binfo;
	tree base_binfo;

	for (binfo = TYPE_BINFO (t), i = 0;
	BINFO_BASE_ITERATE (binfo, i, base_binfo); ++i)
	{
	dump_child ("base", BINFO_TYPE (base_binfo));
	if (BINFO_VIRTUAL_P (base_binfo))
	dump_string_field (di, "spec", "virt");
	dump_access (di, base_binfo);
	}
	}
	break;

	case FIELD_DECL:
	dump_access (di, t);
	if (DECL_MUTABLE_P (t))
	dump_string_field (di, "spec", "mutable");
	break;

	case VAR_DECL:
	if (TREE_CODE (CP_DECL_CONTEXT (t)) == RECORD_TYPE)
	dump_access (di, t);
	if (TREE_STATIC (t) && !TREE_PUBLIC (t))
	dump_string_field (di, "link", "static");
	break;

	case FUNCTION_DECL:
	if (!DECL_THUNK_P (t))
	{
	if (DECL_OVERLOADED_OPERATOR_P (t)) {
	dump_string_field (di, "note", "operator");
	dump_op (di, t);
	}
	if (DECL_FUNCTION_MEMBER_P (t))
	{
	dump_string_field (di, "note", "member");
	dump_access (di, t);
	}
	if (DECL_PURE_VIRTUAL_P (t))
	dump_string_field (di, "spec", "pure");
	if (DECL_VIRTUAL_P (t))
	dump_string_field (di, "spec", "virt");
	if (DECL_CONSTRUCTOR_P (t))
	dump_string_field (di, "note", "constructor");
	if (DECL_DESTRUCTOR_P (t))
	dump_string_field (di, "note", "destructor");
	if (DECL_CONV_FN_P (t))
	dump_string_field (di, "note", "conversion");
	if (DECL_GLOBAL_CTOR_P (t))
	dump_string_field (di, "note", "global init");
	if (DECL_GLOBAL_DTOR_P (t))
	dump_string_field (di, "note", "global fini");
	if (DECL_FRIEND_PSEUDO_TEMPLATE_INSTANTIATION (t))
	dump_string_field (di, "note", "pseudo tmpl");
	}
	else
	{
	tree virt = THUNK_VIRTUAL_OFFSET (t);

	dump_string_field (di, "note", "thunk");
	if (DECL_THIS_THUNK_P (t))
	dump_string_field (di, "note", "this adjusting");
	else
	{
	dump_string_field (di, "note", "result adjusting");
	if (virt)
	virt = BINFO_VPTR_FIELD (virt);
	}
	dump_int (di, "fixd", THUNK_FIXED_OFFSET (t));
	if (virt)
	dump_int (di, "virt", tree_low_cst (virt, 0));
	dump_child ("fn", DECL_INITIAL (t));
	}
	break;

	case NAMESPACE_DECL:
	if (DECL_NAMESPACE_ALIAS (t))
	dump_child ("alis", DECL_NAMESPACE_ALIAS (t));
	else if (!dump_flag (di, TDF_SLIM, t))
	dump_child ("dcls", cp_namespace_decls (t));
	break;

	case TEMPLATE_DECL:
	dump_child ("rslt", DECL_TEMPLATE_RESULT (t));
	dump_child ("inst", DECL_TEMPLATE_INSTANTIATIONS (t));
	dump_child ("spcs", DECL_TEMPLATE_SPECIALIZATIONS (t));
	dump_child ("prms", DECL_TEMPLATE_PARMS (t));
	break;

	case OVERLOAD:
	dump_child ("crnt", OVL_CURRENT (t));
	dump_child ("chan", OVL_CHAIN (t));
	break;

	case TRY_BLOCK:
	dump_stmt (di, t);
	if (CLEANUP_P (t))
	dump_string_field (di, "note", "cleanup");
	dump_child ("body", TRY_STMTS (t));
	dump_child ("hdlr", TRY_HANDLERS (t));
	break;

	case EH_SPEC_BLOCK:
	dump_stmt (di, t);
	dump_child ("body", EH_SPEC_STMTS (t));
	dump_child ("raises", EH_SPEC_RAISES (t));
	break;

	case PTRMEM_CST:
	dump_child ("clas", PTRMEM_CST_CLASS (t));
	dump_child ("mbr", PTRMEM_CST_MEMBER (t));
	break;

	case THROW_EXPR:
	/* These nodes are unary, but do not have code class `1'. */
	dump_child ("op 0", TREE_OPERAND (t, 0));
	break;

	case AGGR_INIT_EXPR:
	dump_int (di, "ctor", AGGR_INIT_VIA_CTOR_P (t));
	dump_child ("fn", TREE_OPERAND (t, 0));
	dump_child ("args", TREE_OPERAND (t, 1));
	dump_child ("decl", TREE_OPERAND (t, 2));
	break;

	case HANDLER:
	dump_stmt (di, t);
	dump_child ("parm", HANDLER_PARMS (t));
	dump_child ("body", HANDLER_BODY (t));
	break;

	case MUST_NOT_THROW_EXPR:
	dump_stmt (di, t);
	dump_child ("body", TREE_OPERAND (t, 0));
	break;

	case USING_STMT:
	dump_stmt (di, t);
	dump_child ("nmsp", USING_STMT_NAMESPACE (t));
	break;

	case CLEANUP_STMT:
	dump_stmt (di, t);
	dump_child ("decl", CLEANUP_DECL (t));
	dump_child ("expr", CLEANUP_EXPR (t));
	dump_child ("body", CLEANUP_BODY (t));
	break;

	case IF_STMT:
	dump_stmt (di, t);
	dump_child ("cond", IF_COND (t));
	dump_child ("then", THEN_CLAUSE (t));
	dump_child ("else", ELSE_CLAUSE (t));
	break;

	case BREAK_STMT:
	case CONTINUE_STMT:
	dump_stmt (di, t);
	break;

	case DO_STMT:
	dump_stmt (di, t);
	dump_child ("body", DO_BODY (t));
	dump_child ("cond", DO_COND (t));
	+/* APPLE LOCAL begin for-fsf-4_4 3274130 5295549 */ \
	+ dump_child ("attrs", DO_ATTRIBUTES (t));
	+/* APPLE LOCAL end for-fsf-4_4 3274130 5295549 */ \
	break;

	case FOR_STMT:
	dump_stmt (di, t);
	dump_child ("init", FOR_INIT_STMT (t));
	dump_child ("cond", FOR_COND (t));
	dump_child ("expr", FOR_EXPR (t));
	dump_child ("body", FOR_BODY (t));
	+/* APPLE LOCAL begin for-fsf-4_4 3274130 5295549 */ \
	+ dump_child ("attrs", FOR_ATTRIBUTES (t));
	+/* APPLE LOCAL end for-fsf-4_4 3274130 5295549 */ \
	break;

	case SWITCH_STMT:
	dump_stmt (di, t);
	dump_child ("cond", SWITCH_STMT_COND (t));
	dump_child ("body", SWITCH_STMT_BODY (t));
	break;

	case WHILE_STMT:
	dump_stmt (di, t);
	dump_child ("cond", WHILE_COND (t));
	dump_child ("body", WHILE_BODY (t));
	+/* APPLE LOCAL begin for-fsf-4_4 3274130 5295549 */ \
	+ dump_child ("attrs", WHILE_ATTRIBUTES (t));
	+/* APPLE LOCAL end for-fsf-4_4 3274130 5295549 */ \
	break;

	case STMT_EXPR:
	dump_child ("stmt", STMT_EXPR_STMT (t));
	break;

	case EXPR_STMT:
	dump_stmt (di, t);
	dump_child ("expr", EXPR_STMT_EXPR (t));
	break;

	default:
	break;
	}

	return c_dump_tree (di, t);
	}
	diff --git a/contrib/gcc/cp/init.c b/contrib/gcc/cp/init.c
	index 70bc76470f1c..fbdd609497b9 100644
	--- a/contrib/gcc/cp/init.c
	+++ b/contrib/gcc/cp/init.c
	@@ -1,3009 +1,3011 @@
	/* Handle initialization things in C++.
	Copyright (C) 1987, 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
	1999, 2000, 2001, 2002, 2003, 2004, 2005 Free Software Foundation, Inc.
	Contributed by Michael Tiemann (tiemann@cygnus.com)

	This file is part of GCC.

	GCC is free software; you can redistribute it and/or modify
	it under the terms of the GNU General Public License as published by
	the Free Software Foundation; either version 2, or (at your option)
	any later version.

	GCC is distributed in the hope that it will be useful,
	but WITHOUT ANY WARRANTY; without even the implied warranty of
	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	GNU General Public License for more details.

	You should have received a copy of the GNU General Public License
	along with GCC; see the file COPYING. If not, write to
	the Free Software Foundation, 51 Franklin Street, Fifth Floor,
	Boston, MA 02110-1301, USA. */

	/* High-level class interface. */

	#include "config.h"
	#include "system.h"
	#include "coretypes.h"
	#include "tm.h"
	#include "tree.h"
	#include "rtl.h"
	#include "expr.h"
	#include "cp-tree.h"
	#include "flags.h"
	#include "output.h"
	#include "except.h"
	#include "toplev.h"
	#include "target.h"

	static bool begin_init_stmts (tree , tree );
	static tree finish_init_stmts (bool, tree, tree);
	static void construct_virtual_base (tree, tree);
	static void expand_aggr_init_1 (tree, tree, tree, tree, int);
	static void expand_default_init (tree, tree, tree, tree, int);
	static tree build_vec_delete_1 (tree, tree, tree, special_function_kind, int);
	static void perform_member_init (tree, tree);
	static tree build_builtin_delete_call (tree);
	static int member_init_ok_or_else (tree, tree, tree);
	static void expand_virtual_init (tree, tree);
	static tree sort_mem_initializers (tree, tree);
	static tree initializing_context (tree);
	static void expand_cleanup_for_base (tree, tree);
	static tree get_temp_regvar (tree, tree);
	static tree dfs_initialize_vtbl_ptrs (tree, void *);
	static tree build_default_init (tree, tree);
	static tree build_dtor_call (tree, special_function_kind, int);
	static tree build_field_list (tree, tree, int *);
	static tree build_vtbl_address (tree);

	/* We are about to generate some complex initialization code.
	Conceptually, it is all a single expression. However, we may want
	to include conditionals, loops, and other such statement-level
	constructs. Therefore, we build the initialization code inside a
	statement-expression. This function starts such an expression.
	STMT_EXPR_P and COMPOUND_STMT_P are filled in by this function;
	pass them back to finish_init_stmts when the expression is
	complete. */

	static bool
	begin_init_stmts (tree stmt_expr_p, tree compound_stmt_p)
	{
	bool is_global = !building_stmt_tree ();

	*stmt_expr_p = begin_stmt_expr ();
	*compound_stmt_p = begin_compound_stmt (BCS_NO_SCOPE);

	return is_global;
	}

	/* Finish out the statement-expression begun by the previous call to
	begin_init_stmts. Returns the statement-expression itself. */

	static tree
	finish_init_stmts (bool is_global, tree stmt_expr, tree compound_stmt)
	{
	finish_compound_stmt (compound_stmt);

	stmt_expr = finish_stmt_expr (stmt_expr, true);

	gcc_assert (!building_stmt_tree () == is_global);

	return stmt_expr;
	}

	/* Constructors */

	/* Called from initialize_vtbl_ptrs via dfs_walk. BINFO is the base
	which we want to initialize the vtable pointer for, DATA is
	TREE_LIST whose TREE_VALUE is the this ptr expression. */

	static tree
	dfs_initialize_vtbl_ptrs (tree binfo, void *data)
	{
	if (!TYPE_CONTAINS_VPTR_P (BINFO_TYPE (binfo)))
	return dfs_skip_bases;

	if (!BINFO_PRIMARY_P (binfo) \|\| BINFO_VIRTUAL_P (binfo))
	{
	tree base_ptr = TREE_VALUE ((tree) data);

	base_ptr = build_base_path (PLUS_EXPR, base_ptr, binfo, /nonnull=/1);

	expand_virtual_init (binfo, base_ptr);
	}

	return NULL_TREE;
	}

	/* Initialize all the vtable pointers in the object pointed to by
	ADDR. */

	void
	initialize_vtbl_ptrs (tree addr)
	{
	tree list;
	tree type;

	type = TREE_TYPE (TREE_TYPE (addr));
	list = build_tree_list (type, addr);

	/* Walk through the hierarchy, initializing the vptr in each base
	class. We do these in pre-order because we can't find the virtual
	bases for a class until we've initialized the vtbl for that
	class. */
	dfs_walk_once (TYPE_BINFO (type), dfs_initialize_vtbl_ptrs, NULL, list);
	}

	/* Return an expression for the zero-initialization of an object with
	type T. This expression will either be a constant (in the case
	that T is a scalar), or a CONSTRUCTOR (in the case that T is an
	aggregate). In either case, the value can be used as DECL_INITIAL
	for a decl of the indicated TYPE; it is a valid static initializer.
	If NELTS is non-NULL, and TYPE is an ARRAY_TYPE, NELTS is the
	number of elements in the array. If STATIC_STORAGE_P is TRUE,
	initializers are only generated for entities for which
	zero-initialization does not simply mean filling the storage with
	zero bytes. */

	tree
	build_zero_init (tree type, tree nelts, bool static_storage_p)
	{
	tree init = NULL_TREE;

	/* [dcl.init]

	To zero-initialization storage for an object of type T means:

	-- if T is a scalar type, the storage is set to the value of zero
	converted to T.

	-- if T is a non-union class type, the storage for each nonstatic
	data member and each base-class subobject is zero-initialized.

	-- if T is a union type, the storage for its first data member is
	zero-initialized.

	-- if T is an array type, the storage for each element is
	zero-initialized.

	-- if T is a reference type, no initialization is performed. */

	gcc_assert (nelts == NULL_TREE \|\| TREE_CODE (nelts) == INTEGER_CST);

	if (type == error_mark_node)
	;
	else if (static_storage_p && zero_init_p (type))
	/* In order to save space, we do not explicitly build initializers
	for items that do not need them. GCC's semantics are that
	items with static storage duration that are not otherwise
	initialized are initialized to zero. */
	;
	else if (SCALAR_TYPE_P (type))
	init = convert (type, integer_zero_node);
	else if (CLASS_TYPE_P (type))
	{
	tree field;
	VEC(constructor_elt,gc) *v = NULL;

	/* Iterate over the fields, building initializations. */
	for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field))
	{
	if (TREE_CODE (field) != FIELD_DECL)
	continue;

	/* Note that for class types there will be FIELD_DECLs
	corresponding to base classes as well. Thus, iterating
	over TYPE_FIELDs will result in correct initialization of
	all of the subobjects. */
	if (!static_storage_p \|\| !zero_init_p (TREE_TYPE (field)))
	{
	tree value = build_zero_init (TREE_TYPE (field),
	/nelts=/NULL_TREE,
	static_storage_p);
	CONSTRUCTOR_APPEND_ELT(v, field, value);
	}

	/* For unions, only the first field is initialized. */
	if (TREE_CODE (type) == UNION_TYPE)
	break;
	}

	/* Build a constructor to contain the initializations. */
	init = build_constructor (type, v);
	}
	else if (TREE_CODE (type) == ARRAY_TYPE)
	{
	tree max_index;
	VEC(constructor_elt,gc) *v = NULL;

	/* Iterate over the array elements, building initializations. */
	if (nelts)
	max_index = fold_build2 (MINUS_EXPR, TREE_TYPE (nelts),
	nelts, integer_one_node);
	else
	max_index = array_type_nelts (type);

	/* If we have an error_mark here, we should just return error mark
	as we don't know the size of the array yet. */
	if (max_index == error_mark_node)
	return error_mark_node;
	gcc_assert (TREE_CODE (max_index) == INTEGER_CST);

	/* A zero-sized array, which is accepted as an extension, will
	have an upper bound of -1. */
	if (!tree_int_cst_equal (max_index, integer_minus_one_node))
	{
	constructor_elt *ce;

	v = VEC_alloc (constructor_elt, gc, 1);
	ce = VEC_quick_push (constructor_elt, v, NULL);

	/* If this is a one element array, we just use a regular init. */
	if (tree_int_cst_equal (size_zero_node, max_index))
	ce->index = size_zero_node;
	else
	ce->index = build2 (RANGE_EXPR, sizetype, size_zero_node,
	max_index);

	ce->value = build_zero_init (TREE_TYPE (type),
	/nelts=/NULL_TREE,
	static_storage_p);
	}

	/* Build a constructor to contain the initializations. */
	init = build_constructor (type, v);
	}
	else if (TREE_CODE (type) == VECTOR_TYPE)
	init = fold_convert (type, integer_zero_node);
	else
	gcc_assert (TREE_CODE (type) == REFERENCE_TYPE);

	/* In all cases, the initializer is a constant. */
	if (init)
	{
	TREE_CONSTANT (init) = 1;
	TREE_INVARIANT (init) = 1;
	}

	return init;
	}

	/* Build an expression for the default-initialization of an object of
	the indicated TYPE. If NELTS is non-NULL, and TYPE is an
	ARRAY_TYPE, NELTS is the number of elements in the array. If
	initialization of TYPE requires calling constructors, this function
	returns NULL_TREE; the caller is responsible for arranging for the
	constructors to be called. */

	static tree
	build_default_init (tree type, tree nelts)
	{
	/* [dcl.init]:

	To default-initialize an object of type T means:

	--if T is a non-POD class type (clause _class_), the default construc-
	tor for T is called (and the initialization is ill-formed if T has
	no accessible default constructor);

	--if T is an array type, each element is default-initialized;

	--otherwise, the storage for the object is zero-initialized.

	A program that calls for default-initialization of an entity of refer-
	ence type is ill-formed. */

	/* If TYPE_NEEDS_CONSTRUCTING is true, the caller is responsible for
	performing the initialization. This is confusing in that some
	non-PODs do not have TYPE_NEEDS_CONSTRUCTING set. (For example,
	a class with a pointer-to-data member as a non-static data member
	does not have TYPE_NEEDS_CONSTRUCTING set.) Therefore, we end up
	passing non-PODs to build_zero_init below, which is contrary to
	the semantics quoted above from [dcl.init].

	It happens, however, that the behavior of the constructor the
	standard says we should have generated would be precisely the
	same as that obtained by calling build_zero_init below, so things
	work out OK. */
	if (TYPE_NEEDS_CONSTRUCTING (type)
	\|\| (nelts && TREE_CODE (nelts) != INTEGER_CST))
	return NULL_TREE;

	/* At this point, TYPE is either a POD class type, an array of POD
	classes, or something even more innocuous. */
	return build_zero_init (type, nelts, /static_storage_p=/false);
	}

	/* Initialize MEMBER, a FIELD_DECL, with INIT, a TREE_LIST of
	arguments. If TREE_LIST is void_type_node, an empty initializer
	list was given; if NULL_TREE no initializer was given. */

	static void
	perform_member_init (tree member, tree init)
	{
	tree decl;
	tree type = TREE_TYPE (member);
	bool explicit;

	explicit = (init != NULL_TREE);

	/* Effective C++ rule 12 requires that all data members be
	initialized. */
	if (warn_ecpp && !explicit && TREE_CODE (type) != ARRAY_TYPE)
	warning (OPT_Weffc__, "%J%qD should be initialized in the member initialization "
	"list", current_function_decl, member);

	if (init == void_type_node)
	init = NULL_TREE;

	/* Get an lvalue for the data member. */
	decl = build_class_member_access_expr (current_class_ref, member,
	/access_path=/NULL_TREE,
	/preserve_reference=/true);
	if (decl == error_mark_node)
	return;

	/* Deal with this here, as we will get confused if we try to call the
	assignment op for an anonymous union. This can happen in a
	synthesized copy constructor. */
	if (ANON_AGGR_TYPE_P (type))
	{
	if (init)
	{
	init = build2 (INIT_EXPR, type, decl, TREE_VALUE (init));
	finish_expr_stmt (init);
	}
	}
	else if (TYPE_NEEDS_CONSTRUCTING (type))
	{
	if (explicit
	&& TREE_CODE (type) == ARRAY_TYPE
	&& init != NULL_TREE
	&& TREE_CHAIN (init) == NULL_TREE
	&& TREE_CODE (TREE_TYPE (TREE_VALUE (init))) == ARRAY_TYPE)
	{
	/* Initialization of one array from another. */
	finish_expr_stmt (build_vec_init (decl, NULL_TREE, TREE_VALUE (init),
	/explicit_default_init_p=/false,
	/* from_array=*/1));
	}
	else
	finish_expr_stmt (build_aggr_init (decl, init, 0));
	}
	else
	{
	if (init == NULL_TREE)
	{
	if (explicit)
	{
	init = build_default_init (type, /nelts=/NULL_TREE);
	if (TREE_CODE (type) == REFERENCE_TYPE)
	warning (0, "%Jdefault-initialization of %q#D, "
	"which has reference type",
	current_function_decl, member);
	}
	/* member traversal: note it leaves init NULL */
	else if (TREE_CODE (type) == REFERENCE_TYPE)
	pedwarn ("%Juninitialized reference member %qD",
	current_function_decl, member);
	else if (CP_TYPE_CONST_P (type))
	pedwarn ("%Juninitialized member %qD with %<const%> type %qT",
	current_function_decl, member, type);
	}
	else if (TREE_CODE (init) == TREE_LIST)
	/* There was an explicit member initialization. Do some work
	in that case. */
	init = build_x_compound_expr_from_list (init, "member initializer");

	if (init)
	finish_expr_stmt (build_modify_expr (decl, INIT_EXPR, init));
	}

	if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
	{
	tree expr;

	expr = build_class_member_access_expr (current_class_ref, member,
	/access_path=/NULL_TREE,
	/preserve_reference=/false);
	expr = build_delete (type, expr, sfk_complete_destructor,
	LOOKUP_NONVIRTUAL\|LOOKUP_DESTRUCTOR, 0);

	if (expr != error_mark_node)
	finish_eh_cleanup (expr);
	}
	}

	/* Returns a TREE_LIST containing (as the TREE_PURPOSE of each node) all
	the FIELD_DECLs on the TYPE_FIELDS list for T, in reverse order. */

	static tree
	build_field_list (tree t, tree list, int *uses_unions_p)
	{
	tree fields;

	*uses_unions_p = 0;

	/* Note whether or not T is a union. */
	if (TREE_CODE (t) == UNION_TYPE)
	*uses_unions_p = 1;

	for (fields = TYPE_FIELDS (t); fields; fields = TREE_CHAIN (fields))
	{
	/* Skip CONST_DECLs for enumeration constants and so forth. */
	if (TREE_CODE (fields) != FIELD_DECL \|\| DECL_ARTIFICIAL (fields))
	continue;

	/* Keep track of whether or not any fields are unions. */
	if (TREE_CODE (TREE_TYPE (fields)) == UNION_TYPE)
	*uses_unions_p = 1;

	/* For an anonymous struct or union, we must recursively
	consider the fields of the anonymous type. They can be
	directly initialized from the constructor. */
	if (ANON_AGGR_TYPE_P (TREE_TYPE (fields)))
	{
	/* Add this field itself. Synthesized copy constructors
	initialize the entire aggregate. */
	list = tree_cons (fields, NULL_TREE, list);
	/* And now add the fields in the anonymous aggregate. */
	list = build_field_list (TREE_TYPE (fields), list,
	uses_unions_p);
	}
	/* Add this field. */
	else if (DECL_NAME (fields))
	list = tree_cons (fields, NULL_TREE, list);
	}

	return list;
	}

	/* The MEM_INITS are a TREE_LIST. The TREE_PURPOSE of each list gives
	a FIELD_DECL or BINFO in T that needs initialization. The
	TREE_VALUE gives the initializer, or list of initializer arguments.

	Return a TREE_LIST containing all of the initializations required
	for T, in the order in which they should be performed. The output
	list has the same format as the input. */

	static tree
	sort_mem_initializers (tree t, tree mem_inits)
	{
	tree init;
	tree base, binfo, base_binfo;
	tree sorted_inits;
	tree next_subobject;
	VEC(tree,gc) *vbases;
	int i;
	int uses_unions_p;

	/* Build up a list of initializations. The TREE_PURPOSE of entry
	will be the subobject (a FIELD_DECL or BINFO) to initialize. The
	TREE_VALUE will be the constructor arguments, or NULL if no
	explicit initialization was provided. */
	sorted_inits = NULL_TREE;

	/* Process the virtual bases. */
	for (vbases = CLASSTYPE_VBASECLASSES (t), i = 0;
	VEC_iterate (tree, vbases, i, base); i++)
	sorted_inits = tree_cons (base, NULL_TREE, sorted_inits);

	/* Process the direct bases. */
	for (binfo = TYPE_BINFO (t), i = 0;
	BINFO_BASE_ITERATE (binfo, i, base_binfo); ++i)
	if (!BINFO_VIRTUAL_P (base_binfo))
	sorted_inits = tree_cons (base_binfo, NULL_TREE, sorted_inits);

	/* Process the non-static data members. */
	sorted_inits = build_field_list (t, sorted_inits, &uses_unions_p);
	/* Reverse the entire list of initializations, so that they are in
	the order that they will actually be performed. */
	sorted_inits = nreverse (sorted_inits);

	/* If the user presented the initializers in an order different from
	that in which they will actually occur, we issue a warning. Keep
	track of the next subobject which can be explicitly initialized
	without issuing a warning. */
	next_subobject = sorted_inits;

	/* Go through the explicit initializers, filling in TREE_PURPOSE in
	the SORTED_INITS. */
	for (init = mem_inits; init; init = TREE_CHAIN (init))
	{
	tree subobject;
	tree subobject_init;

	subobject = TREE_PURPOSE (init);

	/* If the explicit initializers are in sorted order, then
	SUBOBJECT will be NEXT_SUBOBJECT, or something following
	it. */
	for (subobject_init = next_subobject;
	subobject_init;
	subobject_init = TREE_CHAIN (subobject_init))
	if (TREE_PURPOSE (subobject_init) == subobject)
	break;

	/* Issue a warning if the explicit initializer order does not
	match that which will actually occur.
	??? Are all these on the correct lines? */
	if (warn_reorder && !subobject_init)
	{
	if (TREE_CODE (TREE_PURPOSE (next_subobject)) == FIELD_DECL)
	warning (OPT_Wreorder, "%q+D will be initialized after",
	TREE_PURPOSE (next_subobject));
	else
	warning (OPT_Wreorder, "base %qT will be initialized after",
	TREE_PURPOSE (next_subobject));
	if (TREE_CODE (subobject) == FIELD_DECL)
	warning (OPT_Wreorder, " %q+#D", subobject);
	else
	warning (OPT_Wreorder, " base %qT", subobject);
	warning (OPT_Wreorder, "%J when initialized here", current_function_decl);
	}

	/* Look again, from the beginning of the list. */
	if (!subobject_init)
	{
	subobject_init = sorted_inits;
	while (TREE_PURPOSE (subobject_init) != subobject)
	subobject_init = TREE_CHAIN (subobject_init);
	}

	/* It is invalid to initialize the same subobject more than
	once. */
	if (TREE_VALUE (subobject_init))
	{
	if (TREE_CODE (subobject) == FIELD_DECL)
	error ("%Jmultiple initializations given for %qD",
	current_function_decl, subobject);
	else
	error ("%Jmultiple initializations given for base %qT",
	current_function_decl, subobject);
	}

	/* Record the initialization. */
	TREE_VALUE (subobject_init) = TREE_VALUE (init);
	next_subobject = subobject_init;
	}

	/* [class.base.init]

	If a ctor-initializer specifies more than one mem-initializer for
	multiple members of the same union (including members of
	anonymous unions), the ctor-initializer is ill-formed. */
	if (uses_unions_p)
	{
	tree last_field = NULL_TREE;
	for (init = sorted_inits; init; init = TREE_CHAIN (init))
	{
	tree field;
	tree field_type;
	int done;

	/* Skip uninitialized members and base classes. */
	if (!TREE_VALUE (init)
	\|\| TREE_CODE (TREE_PURPOSE (init)) != FIELD_DECL)
	continue;
	/* See if this field is a member of a union, or a member of a
	structure contained in a union, etc. */
	field = TREE_PURPOSE (init);
	for (field_type = DECL_CONTEXT (field);
	!same_type_p (field_type, t);
	field_type = TYPE_CONTEXT (field_type))
	if (TREE_CODE (field_type) == UNION_TYPE)
	break;
	/* If this field is not a member of a union, skip it. */
	if (TREE_CODE (field_type) != UNION_TYPE)
	continue;

	/* It's only an error if we have two initializers for the same
	union type. */
	if (!last_field)
	{
	last_field = field;
	continue;
	}

	/* See if LAST_FIELD and the field initialized by INIT are
	members of the same union. If so, there's a problem,
	unless they're actually members of the same structure
	which is itself a member of a union. For example, given:

	union { struct { int i; int j; }; };

	initializing both `i' and `j' makes sense. */
	field_type = DECL_CONTEXT (field);
	done = 0;
	do
	{
	tree last_field_type;

	last_field_type = DECL_CONTEXT (last_field);
	while (1)
	{
	if (same_type_p (last_field_type, field_type))
	{
	if (TREE_CODE (field_type) == UNION_TYPE)
	error ("%Jinitializations for multiple members of %qT",
	current_function_decl, last_field_type);
	done = 1;
	break;
	}

	if (same_type_p (last_field_type, t))
	break;

	last_field_type = TYPE_CONTEXT (last_field_type);
	}

	/* If we've reached the outermost class, then we're
	done. */
	if (same_type_p (field_type, t))
	break;

	field_type = TYPE_CONTEXT (field_type);
	}
	while (!done);

	last_field = field;
	}
	}

	return sorted_inits;
	}

	/* Initialize all bases and members of CURRENT_CLASS_TYPE. MEM_INITS
	is a TREE_LIST giving the explicit mem-initializer-list for the
	constructor. The TREE_PURPOSE of each entry is a subobject (a
	FIELD_DECL or a BINFO) of the CURRENT_CLASS_TYPE. The TREE_VALUE
	is a TREE_LIST giving the arguments to the constructor or
	void_type_node for an empty list of arguments. */

	void
	emit_mem_initializers (tree mem_inits)
	{
	/* We will already have issued an error message about the fact that
	the type is incomplete. */
	if (!COMPLETE_TYPE_P (current_class_type))
	return;

	/* Sort the mem-initializers into the order in which the
	initializations should be performed. */
	mem_inits = sort_mem_initializers (current_class_type, mem_inits);

	in_base_initializer = 1;

	/* Initialize base classes. */
	while (mem_inits
	&& TREE_CODE (TREE_PURPOSE (mem_inits)) != FIELD_DECL)
	{
	tree subobject = TREE_PURPOSE (mem_inits);
	tree arguments = TREE_VALUE (mem_inits);

	/* If these initializations are taking place in a copy
	constructor, the base class should probably be explicitly
	initialized. */
	if (extra_warnings && !arguments
	&& DECL_COPY_CONSTRUCTOR_P (current_function_decl)
	&& TYPE_NEEDS_CONSTRUCTING (BINFO_TYPE (subobject)))
	warning (OPT_Wextra, "%Jbase class %q#T should be explicitly initialized in the "
	"copy constructor",
	current_function_decl, BINFO_TYPE (subobject));

	/* If an explicit -- but empty -- initializer list was present,
	treat it just like default initialization at this point. */
	if (arguments == void_type_node)
	arguments = NULL_TREE;

	/* Initialize the base. */
	if (BINFO_VIRTUAL_P (subobject))
	construct_virtual_base (subobject, arguments);
	else
	{
	tree base_addr;

	base_addr = build_base_path (PLUS_EXPR, current_class_ptr,
	subobject, 1);
	expand_aggr_init_1 (subobject, NULL_TREE,
	build_indirect_ref (base_addr, NULL),
	arguments,
	LOOKUP_NORMAL);
	expand_cleanup_for_base (subobject, NULL_TREE);
	}

	mem_inits = TREE_CHAIN (mem_inits);
	}
	in_base_initializer = 0;

	/* Initialize the vptrs. */
	initialize_vtbl_ptrs (current_class_ptr);

	/* Initialize the data members. */
	while (mem_inits)
	{
	perform_member_init (TREE_PURPOSE (mem_inits),
	TREE_VALUE (mem_inits));
	mem_inits = TREE_CHAIN (mem_inits);
	}
	}

	/* Returns the address of the vtable (i.e., the value that should be
	assigned to the vptr) for BINFO. */

	static tree
	build_vtbl_address (tree binfo)
	{
	tree binfo_for = binfo;
	tree vtbl;

	if (BINFO_VPTR_INDEX (binfo) && BINFO_VIRTUAL_P (binfo))
	/* If this is a virtual primary base, then the vtable we want to store
	is that for the base this is being used as the primary base of. We
	can't simply skip the initialization, because we may be expanding the
	inits of a subobject constructor where the virtual base layout
	can be different. */
	while (BINFO_PRIMARY_P (binfo_for))
	binfo_for = BINFO_INHERITANCE_CHAIN (binfo_for);

	/* Figure out what vtable BINFO's vtable is based on, and mark it as
	used. */
	vtbl = get_vtbl_decl_for_binfo (binfo_for);
	assemble_external (vtbl);
	TREE_USED (vtbl) = 1;

	/* Now compute the address to use when initializing the vptr. */
	vtbl = unshare_expr (BINFO_VTABLE (binfo_for));
	if (TREE_CODE (vtbl) == VAR_DECL)
	vtbl = build1 (ADDR_EXPR, build_pointer_type (TREE_TYPE (vtbl)), vtbl);

	return vtbl;
	}

	/* This code sets up the virtual function tables appropriate for
	the pointer DECL. It is a one-ply initialization.

	BINFO is the exact type that DECL is supposed to be. In
	multiple inheritance, this might mean "C's A" if C : A, B. */

	static void
	expand_virtual_init (tree binfo, tree decl)
	{
	tree vtbl, vtbl_ptr;
	tree vtt_index;

	/* Compute the initializer for vptr. */
	vtbl = build_vtbl_address (binfo);

	/* We may get this vptr from a VTT, if this is a subobject
	constructor or subobject destructor. */
	vtt_index = BINFO_VPTR_INDEX (binfo);
	if (vtt_index)
	{
	tree vtbl2;
	tree vtt_parm;

	/* Compute the value to use, when there's a VTT. */
	vtt_parm = current_vtt_parm;
	vtbl2 = build2 (PLUS_EXPR,
	TREE_TYPE (vtt_parm),
	vtt_parm,
	vtt_index);
	vtbl2 = build_indirect_ref (vtbl2, NULL);
	vtbl2 = convert (TREE_TYPE (vtbl), vtbl2);

	/* The actual initializer is the VTT value only in the subobject
	constructor. In maybe_clone_body we'll substitute NULL for
	the vtt_parm in the case of the non-subobject constructor. */
	vtbl = build3 (COND_EXPR,
	TREE_TYPE (vtbl),
	build2 (EQ_EXPR, boolean_type_node,
	current_in_charge_parm, integer_zero_node),
	vtbl2,
	vtbl);
	}

	/* Compute the location of the vtpr. */
	vtbl_ptr = build_vfield_ref (build_indirect_ref (decl, NULL),
	TREE_TYPE (binfo));
	gcc_assert (vtbl_ptr != error_mark_node);

	/* Assign the vtable to the vptr. */
	vtbl = convert_force (TREE_TYPE (vtbl_ptr), vtbl, 0);
	finish_expr_stmt (build_modify_expr (vtbl_ptr, NOP_EXPR, vtbl));
	}

	/* If an exception is thrown in a constructor, those base classes already
	constructed must be destroyed. This function creates the cleanup
	for BINFO, which has just been constructed. If FLAG is non-NULL,
	it is a DECL which is nonzero when this base needs to be
	destroyed. */

	static void
	expand_cleanup_for_base (tree binfo, tree flag)
	{
	tree expr;

	if (TYPE_HAS_TRIVIAL_DESTRUCTOR (BINFO_TYPE (binfo)))
	return;

	/* Call the destructor. */
	expr = build_special_member_call (current_class_ref,
	base_dtor_identifier,
	NULL_TREE,
	binfo,
	LOOKUP_NORMAL \| LOOKUP_NONVIRTUAL);
	if (flag)
	expr = fold_build3 (COND_EXPR, void_type_node,
	c_common_truthvalue_conversion (flag),
	expr, integer_zero_node);

	finish_eh_cleanup (expr);
	}

	/* Construct the virtual base-class VBASE passing the ARGUMENTS to its
	constructor. */

	static void
	construct_virtual_base (tree vbase, tree arguments)
	{
	tree inner_if_stmt;
	tree exp;
	tree flag;

	/* If there are virtual base classes with destructors, we need to
	emit cleanups to destroy them if an exception is thrown during
	the construction process. These exception regions (i.e., the
	period during which the cleanups must occur) begin from the time
	the construction is complete to the end of the function. If we
	create a conditional block in which to initialize the
	base-classes, then the cleanup region for the virtual base begins
	inside a block, and ends outside of that block. This situation
	confuses the sjlj exception-handling code. Therefore, we do not
	create a single conditional block, but one for each
	initialization. (That way the cleanup regions always begin
	in the outer block.) We trust the back-end to figure out
	that the FLAG will not change across initializations, and
	avoid doing multiple tests. */
	flag = TREE_CHAIN (DECL_ARGUMENTS (current_function_decl));
	inner_if_stmt = begin_if_stmt ();
	finish_if_stmt_cond (flag, inner_if_stmt);

	/* Compute the location of the virtual base. If we're
	constructing virtual bases, then we must be the most derived
	class. Therefore, we don't have to look up the virtual base;
	we already know where it is. */
	exp = convert_to_base_statically (current_class_ref, vbase);

	expand_aggr_init_1 (vbase, current_class_ref, exp, arguments,
	LOOKUP_COMPLAIN);
	finish_then_clause (inner_if_stmt);
	finish_if_stmt (inner_if_stmt);

	expand_cleanup_for_base (vbase, flag);
	}

	/* Find the context in which this FIELD can be initialized. */

	static tree
	initializing_context (tree field)
	{
	tree t = DECL_CONTEXT (field);

	/* Anonymous union members can be initialized in the first enclosing
	non-anonymous union context. */
	while (t && ANON_AGGR_TYPE_P (t))
	t = TYPE_CONTEXT (t);
	return t;
	}

	/* Function to give error message if member initialization specification
	is erroneous. FIELD is the member we decided to initialize.
	TYPE is the type for which the initialization is being performed.
	FIELD must be a member of TYPE.

	MEMBER_NAME is the name of the member. */

	static int
	member_init_ok_or_else (tree field, tree type, tree member_name)
	{
	if (field == error_mark_node)
	return 0;
	if (!field)
	{
	error ("class %qT does not have any field named %qD", type,
	member_name);
	return 0;
	}
	if (TREE_CODE (field) == VAR_DECL)
	{
	error ("%q#D is a static data member; it can only be "
	"initialized at its definition",
	field);
	return 0;
	}
	if (TREE_CODE (field) != FIELD_DECL)
	{
	error ("%q#D is not a non-static data member of %qT",
	field, type);
	return 0;
	}
	if (initializing_context (field) != type)
	{
	error ("class %qT does not have any field named %qD", type,
	member_name);
	return 0;
	}

	return 1;
	}

	/* NAME is a FIELD_DECL, an IDENTIFIER_NODE which names a field, or it
	is a _TYPE node or TYPE_DECL which names a base for that type.
	Check the validity of NAME, and return either the base _TYPE, base
	binfo, or the FIELD_DECL of the member. If NAME is invalid, return
	NULL_TREE and issue a diagnostic.

	An old style unnamed direct single base construction is permitted,
	where NAME is NULL. */

	tree
	expand_member_init (tree name)
	{
	tree basetype;
	tree field;

	if (!current_class_ref)
	return NULL_TREE;

	if (!name)
	{
	/* This is an obsolete unnamed base class initializer. The
	parser will already have warned about its use. */
	switch (BINFO_N_BASE_BINFOS (TYPE_BINFO (current_class_type)))
	{
	case 0:
	error ("unnamed initializer for %qT, which has no base classes",
	current_class_type);
	return NULL_TREE;
	case 1:
	basetype = BINFO_TYPE
	(BINFO_BASE_BINFO (TYPE_BINFO (current_class_type), 0));
	break;
	default:
	error ("unnamed initializer for %qT, which uses multiple inheritance",
	current_class_type);
	return NULL_TREE;
	}
	}
	else if (TYPE_P (name))
	{
	basetype = TYPE_MAIN_VARIANT (name);
	name = TYPE_NAME (name);
	}
	else if (TREE_CODE (name) == TYPE_DECL)
	basetype = TYPE_MAIN_VARIANT (TREE_TYPE (name));
	else
	basetype = NULL_TREE;

	if (basetype)
	{
	tree class_binfo;
	tree direct_binfo;
	tree virtual_binfo;
	int i;

	if (current_template_parms)
	return basetype;

	class_binfo = TYPE_BINFO (current_class_type);
	direct_binfo = NULL_TREE;
	virtual_binfo = NULL_TREE;

	/* Look for a direct base. */
	for (i = 0; BINFO_BASE_ITERATE (class_binfo, i, direct_binfo); ++i)
	if (SAME_BINFO_TYPE_P (BINFO_TYPE (direct_binfo), basetype))
	break;

	/* Look for a virtual base -- unless the direct base is itself
	virtual. */
	if (!direct_binfo \|\| !BINFO_VIRTUAL_P (direct_binfo))
	virtual_binfo = binfo_for_vbase (basetype, current_class_type);

	/* [class.base.init]

	If a mem-initializer-id is ambiguous because it designates
	both a direct non-virtual base class and an inherited virtual
	base class, the mem-initializer is ill-formed. */
	if (direct_binfo && virtual_binfo)
	{
	error ("%qD is both a direct base and an indirect virtual base",
	basetype);
	return NULL_TREE;
	}

	if (!direct_binfo && !virtual_binfo)
	{
	if (CLASSTYPE_VBASECLASSES (current_class_type))
	error ("type %qT is not a direct or virtual base of %qT",
	basetype, current_class_type);
	else
	error ("type %qT is not a direct base of %qT",
	basetype, current_class_type);
	return NULL_TREE;
	}

	return direct_binfo ? direct_binfo : virtual_binfo;
	}
	else
	{
	if (TREE_CODE (name) == IDENTIFIER_NODE)
	field = lookup_field (current_class_type, name, 1, false);
	else
	field = name;

	if (member_init_ok_or_else (field, current_class_type, name))
	return field;
	}

	return NULL_TREE;
	}

	/* This is like `expand_member_init', only it stores one aggregate
	value into another.

	INIT comes in two flavors: it is either a value which
	is to be stored in EXP, or it is a parameter list
	to go to a constructor, which will operate on EXP.
	If INIT is not a parameter list for a constructor, then set
	LOOKUP_ONLYCONVERTING.
	If FLAGS is LOOKUP_ONLYCONVERTING then it is the = init form of
	the initializer, if FLAGS is 0, then it is the (init) form.
	If `init' is a CONSTRUCTOR, then we emit a warning message,
	explaining that such initializations are invalid.

	If INIT resolves to a CALL_EXPR which happens to return
	something of the type we are looking for, then we know
	that we can safely use that call to perform the
	initialization.

	The virtual function table pointer cannot be set up here, because
	we do not really know its type.

	This never calls operator=().

	When initializing, nothing is CONST.

	A default copy constructor may have to be used to perform the
	initialization.

	A constructor or a conversion operator may have to be used to
	perform the initialization, but not both, as it would be ambiguous. */

	tree
	build_aggr_init (tree exp, tree init, int flags)
	{
	tree stmt_expr;
	tree compound_stmt;
	int destroy_temps;
	tree type = TREE_TYPE (exp);
	int was_const = TREE_READONLY (exp);
	int was_volatile = TREE_THIS_VOLATILE (exp);
	int is_global;

	if (init == error_mark_node)
	return error_mark_node;

	TREE_READONLY (exp) = 0;
	TREE_THIS_VOLATILE (exp) = 0;

	if (init && TREE_CODE (init) != TREE_LIST)
	flags \|= LOOKUP_ONLYCONVERTING;

	if (TREE_CODE (type) == ARRAY_TYPE)
	{
	tree itype;

	/* An array may not be initialized use the parenthesized
	initialization form -- unless the initializer is "()". */
	if (init && TREE_CODE (init) == TREE_LIST)
	{
	error ("bad array initializer");
	return error_mark_node;
	}
	/* Must arrange to initialize each element of EXP
	from elements of INIT. */
	itype = init ? TREE_TYPE (init) : NULL_TREE;
	if (cp_type_quals (type) != TYPE_UNQUALIFIED)
	TREE_TYPE (exp) = TYPE_MAIN_VARIANT (type);
	if (itype && cp_type_quals (itype) != TYPE_UNQUALIFIED)
	itype = TREE_TYPE (init) = TYPE_MAIN_VARIANT (itype);
	stmt_expr = build_vec_init (exp, NULL_TREE, init,
	/explicit_default_init_p=/false,
	itype && same_type_p (itype,
	TREE_TYPE (exp)));
	TREE_READONLY (exp) = was_const;
	TREE_THIS_VOLATILE (exp) = was_volatile;
	TREE_TYPE (exp) = type;
	if (init)
	TREE_TYPE (init) = itype;
	return stmt_expr;
	}

	if (TREE_CODE (exp) == VAR_DECL \|\| TREE_CODE (exp) == PARM_DECL)
	/* Just know that we've seen something for this node. */
	TREE_USED (exp) = 1;

	TREE_TYPE (exp) = TYPE_MAIN_VARIANT (type);
	is_global = begin_init_stmts (&stmt_expr, &compound_stmt);
	destroy_temps = stmts_are_full_exprs_p ();
	current_stmt_tree ()->stmts_are_full_exprs_p = 0;
	expand_aggr_init_1 (TYPE_BINFO (type), exp, exp,
	init, LOOKUP_NORMAL\|flags);
	stmt_expr = finish_init_stmts (is_global, stmt_expr, compound_stmt);
	current_stmt_tree ()->stmts_are_full_exprs_p = destroy_temps;
	TREE_TYPE (exp) = type;
	TREE_READONLY (exp) = was_const;
	TREE_THIS_VOLATILE (exp) = was_volatile;

	return stmt_expr;
	}

	static void
	expand_default_init (tree binfo, tree true_exp, tree exp, tree init, int flags)
	{
	tree type = TREE_TYPE (exp);
	tree ctor_name;

	/* It fails because there may not be a constructor which takes
	its own type as the first (or only parameter), but which does
	take other types via a conversion. So, if the thing initializing
	the expression is a unit element of type X, first try X(X&),
	followed by initialization by X. If neither of these work
	out, then look hard. */
	tree rval;
	tree parms;

	if (init && TREE_CODE (init) != TREE_LIST
	&& (flags & LOOKUP_ONLYCONVERTING))
	{
	/* Base subobjects should only get direct-initialization. */
	gcc_assert (true_exp == exp);

	if (flags & DIRECT_BIND)
	/* Do nothing. We hit this in two cases: Reference initialization,
	where we aren't initializing a real variable, so we don't want
	to run a new constructor; and catching an exception, where we
	have already built up the constructor call so we could wrap it
	in an exception region. */;
	else if (BRACE_ENCLOSED_INITIALIZER_P (init))
	{
	/* A brace-enclosed initializer for an aggregate. */
	gcc_assert (CP_AGGREGATE_TYPE_P (type));
	init = digest_init (type, init);
	}
	else
	init = ocp_convert (type, init, CONV_IMPLICIT\|CONV_FORCE_TEMP, flags);

	if (TREE_CODE (init) == MUST_NOT_THROW_EXPR)
	/* We need to protect the initialization of a catch parm with a
	call to terminate(), which shows up as a MUST_NOT_THROW_EXPR
	around the TARGET_EXPR for the copy constructor. See
	initialize_handler_parm. */
	{
	TREE_OPERAND (init, 0) = build2 (INIT_EXPR, TREE_TYPE (exp), exp,
	TREE_OPERAND (init, 0));
	TREE_TYPE (init) = void_type_node;
	}
	else
	init = build2 (INIT_EXPR, TREE_TYPE (exp), exp, init);
	TREE_SIDE_EFFECTS (init) = 1;
	finish_expr_stmt (init);
	return;
	}

	if (init == NULL_TREE
	\|\| (TREE_CODE (init) == TREE_LIST && ! TREE_TYPE (init)))
	{
	parms = init;
	if (parms)
	init = TREE_VALUE (parms);
	}
	else
	parms = build_tree_list (NULL_TREE, init);

	if (true_exp == exp)
	ctor_name = complete_ctor_identifier;
	else
	ctor_name = base_ctor_identifier;

	rval = build_special_member_call (exp, ctor_name, parms, binfo, flags);
	if (TREE_SIDE_EFFECTS (rval))
	finish_expr_stmt (convert_to_void (rval, NULL));
	}

	/* This function is responsible for initializing EXP with INIT
	(if any).

	BINFO is the binfo of the type for who we are performing the
	initialization. For example, if W is a virtual base class of A and B,
	and C : A, B.
	If we are initializing B, then W must contain B's W vtable, whereas
	were we initializing C, W must contain C's W vtable.

	TRUE_EXP is nonzero if it is the true expression being initialized.
	In this case, it may be EXP, or may just contain EXP. The reason we
	need this is because if EXP is a base element of TRUE_EXP, we
	don't necessarily know by looking at EXP where its virtual
	baseclass fields should really be pointing. But we do know
	from TRUE_EXP. In constructors, we don't know anything about
	the value being initialized.

	FLAGS is just passed to `build_new_method_call'. See that function
	for its description. */

	static void
	expand_aggr_init_1 (tree binfo, tree true_exp, tree exp, tree init, int flags)
	{
	tree type = TREE_TYPE (exp);

	gcc_assert (init != error_mark_node && type != error_mark_node);
	gcc_assert (building_stmt_tree ());

	/* Use a function returning the desired type to initialize EXP for us.
	If the function is a constructor, and its first argument is
	NULL_TREE, know that it was meant for us--just slide exp on
	in and expand the constructor. Constructors now come
	as TARGET_EXPRs. */

	if (init && TREE_CODE (exp) == VAR_DECL
	&& COMPOUND_LITERAL_P (init))
	{
	/* If store_init_value returns NULL_TREE, the INIT has been
	recorded as the DECL_INITIAL for EXP. That means there's
	nothing more we have to do. */
	init = store_init_value (exp, init);
	if (init)
	finish_expr_stmt (init);
	return;
	}

	/* We know that expand_default_init can handle everything we want
	at this point. */
	expand_default_init (binfo, true_exp, exp, init, flags);
	}

	/* Report an error if TYPE is not a user-defined, aggregate type. If
	OR_ELSE is nonzero, give an error message. */

	int
	is_aggr_type (tree type, int or_else)
	{
	if (type == error_mark_node)
	return 0;

	if (! IS_AGGR_TYPE (type)
	&& TREE_CODE (type) != TEMPLATE_TYPE_PARM
	&& TREE_CODE (type) != BOUND_TEMPLATE_TEMPLATE_PARM)
	{
	if (or_else)
	error ("%qT is not an aggregate type", type);
	return 0;
	}
	return 1;
	}

	tree
	get_type_value (tree name)
	{
	if (name == error_mark_node)
	return NULL_TREE;

	if (IDENTIFIER_HAS_TYPE_VALUE (name))
	return IDENTIFIER_TYPE_VALUE (name);
	else
	return NULL_TREE;
	}

	/* Build a reference to a member of an aggregate. This is not a C++
	`&', but really something which can have its address taken, and
	then act as a pointer to member, for example TYPE :: FIELD can have
	its address taken by saying & TYPE :: FIELD. ADDRESS_P is true if
	this expression is the operand of "&".

	@@ Prints out lousy diagnostics for operator <typename>
	@@ fields.

	@@ This function should be rewritten and placed in search.c. */

	tree
	build_offset_ref (tree type, tree member, bool address_p)
	{
	tree decl;
	tree basebinfo = NULL_TREE;

	/* class templates can come in as TEMPLATE_DECLs here. */
	if (TREE_CODE (member) == TEMPLATE_DECL)
	return member;

	if (dependent_type_p (type) \|\| type_dependent_expression_p (member))
	return build_qualified_name (NULL_TREE, type, member,
	/template_p=/false);

	gcc_assert (TYPE_P (type));
	if (! is_aggr_type (type, 1))
	return error_mark_node;

	gcc_assert (DECL_P (member) \|\| BASELINK_P (member));
	/* Callers should call mark_used before this point. */
	gcc_assert (!DECL_P (member) \|\| TREE_USED (member));

	if (!COMPLETE_TYPE_P (complete_type (type))
	&& !TYPE_BEING_DEFINED (type))
	{
	error ("incomplete type %qT does not have member %qD", type, member);
	return error_mark_node;
	}

	/* Entities other than non-static members need no further
	processing. */
	if (TREE_CODE (member) == TYPE_DECL)
	return member;
	if (TREE_CODE (member) == VAR_DECL \|\| TREE_CODE (member) == CONST_DECL)
	return convert_from_reference (member);

	if (TREE_CODE (member) == FIELD_DECL && DECL_C_BIT_FIELD (member))
	{
	error ("invalid pointer to bit-field %qD", member);
	return error_mark_node;
	}

	/* Set up BASEBINFO for member lookup. */
	decl = maybe_dummy_object (type, &basebinfo);

	/* A lot of this logic is now handled in lookup_member. */
	if (BASELINK_P (member))
	{
	/* Go from the TREE_BASELINK to the member function info. */
	tree t = BASELINK_FUNCTIONS (member);

	if (TREE_CODE (t) != TEMPLATE_ID_EXPR && !really_overloaded_fn (t))
	{
	/* Get rid of a potential OVERLOAD around it. */
	t = OVL_CURRENT (t);

	/* Unique functions are handled easily. */

	/* For non-static member of base class, we need a special rule
	for access checking [class.protected]:

	If the access is to form a pointer to member, the
	nested-name-specifier shall name the derived class
	(or any class derived from that class). */
	if (address_p && DECL_P (t)
	&& DECL_NONSTATIC_MEMBER_P (t))
	perform_or_defer_access_check (TYPE_BINFO (type), t, t);
	else
	perform_or_defer_access_check (basebinfo, t, t);

	if (DECL_STATIC_FUNCTION_P (t))
	return t;
	member = t;
	}
	else
	TREE_TYPE (member) = unknown_type_node;
	}
	else if (address_p && TREE_CODE (member) == FIELD_DECL)
	/* We need additional test besides the one in
	check_accessibility_of_qualified_id in case it is
	a pointer to non-static member. */
	perform_or_defer_access_check (TYPE_BINFO (type), member, member);

	if (!address_p)
	{
	/* If MEMBER is non-static, then the program has fallen afoul of
	[expr.prim]:

	An id-expression that denotes a nonstatic data member or
	nonstatic member function of a class can only be used:

	-- as part of a class member access (_expr.ref_) in which the
	object-expression refers to the member's class or a class
	derived from that class, or

	-- to form a pointer to member (_expr.unary.op_), or

	-- in the body of a nonstatic member function of that class or
	of a class derived from that class (_class.mfct.nonstatic_), or

	-- in a mem-initializer for a constructor for that class or for
	a class derived from that class (_class.base.init_). */
	if (DECL_NONSTATIC_MEMBER_FUNCTION_P (member))
	{
	/* Build a representation of a the qualified name suitable
	for use as the operand to "&" -- even though the "&" is
	not actually present. */
	member = build2 (OFFSET_REF, TREE_TYPE (member), decl, member);
	/* In Microsoft mode, treat a non-static member function as if
	it were a pointer-to-member. */
	if (flag_ms_extensions)
	{
	PTRMEM_OK_P (member) = 1;
	return build_unary_op (ADDR_EXPR, member, 0);
	}
	error ("invalid use of non-static member function %qD",
	TREE_OPERAND (member, 1));
	return error_mark_node;
	}
	else if (TREE_CODE (member) == FIELD_DECL)
	{
	error ("invalid use of non-static data member %qD", member);
	return error_mark_node;
	}
	return member;
	}

	member = build2 (OFFSET_REF, TREE_TYPE (member), decl, member);
	PTRMEM_OK_P (member) = 1;
	return member;
	}

	/* If DECL is a scalar enumeration constant or variable with a
	constant initializer, return the initializer (or, its initializers,
	recursively); otherwise, return DECL. If INTEGRAL_P, the
	initializer is only returned if DECL is an integral
	constant-expression. */

	static tree
	constant_value_1 (tree decl, bool integral_p)
	{
	while (TREE_CODE (decl) == CONST_DECL
	\|\| (integral_p
	? DECL_INTEGRAL_CONSTANT_VAR_P (decl)
	: (TREE_CODE (decl) == VAR_DECL
	&& CP_TYPE_CONST_NON_VOLATILE_P (TREE_TYPE (decl)))))
	{
	tree init;
	/* Static data members in template classes may have
	non-dependent initializers. References to such non-static
	data members are not value-dependent, so we must retrieve the
	initializer here. The DECL_INITIAL will have the right type,
	but will not have been folded because that would prevent us
	from performing all appropriate semantic checks at
	instantiation time. */
	if (DECL_CLASS_SCOPE_P (decl)
	&& CLASSTYPE_TEMPLATE_INFO (DECL_CONTEXT (decl))
	&& uses_template_parms (CLASSTYPE_TI_ARGS
	(DECL_CONTEXT (decl))))
	{
	++processing_template_decl;
	init = fold_non_dependent_expr (DECL_INITIAL (decl));
	--processing_template_decl;
	}
	else
	{
	/* If DECL is a static data member in a template
	specialization, we must instantiate it here. The
	initializer for the static data member is not processed
	until needed; we need it now. */
	mark_used (decl);
	init = DECL_INITIAL (decl);
	}
	if (init == error_mark_node)
	return decl;
	if (!init
	\|\| !TREE_TYPE (init)
	\|\| (integral_p
	? !INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (init))
	: (!TREE_CONSTANT (init)
	/* Do not return an aggregate constant (of which
	string literals are a special case), as we do not
	want to make inadvertent copies of such entities,
	and we must be sure that their addresses are the
	same everywhere. */
	\|\| TREE_CODE (init) == CONSTRUCTOR
	\|\| TREE_CODE (init) == STRING_CST)))
	break;
	decl = unshare_expr (init);
	}
	return decl;
	}

	/* If DECL is a CONST_DECL, or a constant VAR_DECL initialized by
	constant of integral or enumeration type, then return that value.
	These are those variables permitted in constant expressions by
	[5.19/1]. */

	tree
	integral_constant_value (tree decl)
	{
	return constant_value_1 (decl, /integral_p=/true);
	}

	/* A more relaxed version of integral_constant_value, used by the
	common C/C++ code and by the C++ front-end for optimization
	purposes. */

	tree
	decl_constant_value (tree decl)
	{
	return constant_value_1 (decl,
	/integral_p=/processing_template_decl);
	}

	/* Common subroutines of build_new and build_vec_delete. */

	/* Call the global __builtin_delete to delete ADDR. */

	static tree
	build_builtin_delete_call (tree addr)
	{
	mark_used (global_delete_fndecl);
	return build_call (global_delete_fndecl, build_tree_list (NULL_TREE, addr));
	}

	/* Build and return a NEW_EXPR. If NELTS is non-NULL, TYPE[NELTS] is
	the type of the object being allocated; otherwise, it's just TYPE.
	INIT is the initializer, if any. USE_GLOBAL_NEW is true if the
	user explicitly wrote "::operator new". PLACEMENT, if non-NULL, is
	the TREE_LIST of arguments to be provided as arguments to a
	placement new operator. This routine performs no semantic checks;
	it just creates and returns a NEW_EXPR. */

	static tree
	build_raw_new_expr (tree placement, tree type, tree nelts, tree init,
	int use_global_new)
	{
	tree new_expr;

	new_expr = build4 (NEW_EXPR, build_pointer_type (type), placement, type,
	nelts, init);
	NEW_EXPR_USE_GLOBAL (new_expr) = use_global_new;
	TREE_SIDE_EFFECTS (new_expr) = 1;

	return new_expr;
	}

	/* Generate code for a new-expression, including calling the "operator
	new" function, initializing the object, and, if an exception occurs
	during construction, cleaning up. The arguments are as for
	build_raw_new_expr. */

	static tree
	build_new_1 (tree placement, tree type, tree nelts, tree init,
	bool globally_qualified_p)
	{
	tree size, rval;
	/* True iff this is a call to "operator new[]" instead of just
	"operator new". */
	bool array_p = false;
	/* True iff ARRAY_P is true and the bound of the array type is
	not necessarily a compile time constant. For example, VLA_P is
	true for "new int[f()]". */
	bool vla_p = false;
	/* The type being allocated. If ARRAY_P is true, this will be an
	ARRAY_TYPE. */
	tree full_type;
	/* If ARRAY_P is true, the element type of the array. This is an
	never ARRAY_TYPE; for something like "new int[3][4]", the
	ELT_TYPE is "int". If ARRAY_P is false, this is the same type as
	FULL_TYPE. */
	tree elt_type;
	/* The type of the new-expression. (This type is always a pointer
	type.) */
	tree pointer_type;
	/* A pointer type pointing to the FULL_TYPE. */
	tree full_pointer_type;
	tree outer_nelts = NULL_TREE;
	tree alloc_call, alloc_expr;
	/* The address returned by the call to "operator new". This node is
	a VAR_DECL and is therefore reusable. */
	tree alloc_node;
	tree alloc_fn;
	tree cookie_expr, init_expr;
	int nothrow, check_new;
	int use_java_new = 0;
	/* If non-NULL, the number of extra bytes to allocate at the
	beginning of the storage allocated for an array-new expression in
	order to store the number of elements. */
	tree cookie_size = NULL_TREE;
	/* True if the function we are calling is a placement allocation
	function. */
	bool placement_allocation_fn_p;
	tree args = NULL_TREE;
	/* True if the storage must be initialized, either by a constructor
	or due to an explicit new-initializer. */
	bool is_initialized;
	/* The address of the thing allocated, not including any cookie. In
	particular, if an array cookie is in use, DATA_ADDR is the
	address of the first array element. This node is a VAR_DECL, and
	is therefore reusable. */
	tree data_addr;
	tree init_preeval_expr = NULL_TREE;

	if (nelts)
	{
	tree index;

	outer_nelts = nelts;
	array_p = true;

	/* ??? The middle-end will error on us for building a VLA outside a
	function context. Methinks that's not it's purvey. So we'll do
	our own VLA layout later. */
	vla_p = true;
	index = convert (sizetype, nelts);
	index = size_binop (MINUS_EXPR, index, size_one_node);
	index = build_index_type (index);
	full_type = build_cplus_array_type (type, NULL_TREE);
	/* We need a copy of the type as build_array_type will return a shared copy
	of the incomplete array type. */
	full_type = build_distinct_type_copy (full_type);
	TYPE_DOMAIN (full_type) = index;
	}
	else
	{
	full_type = type;
	if (TREE_CODE (type) == ARRAY_TYPE)
	{
	array_p = true;
	nelts = array_type_nelts_top (type);
	outer_nelts = nelts;
	type = TREE_TYPE (type);
	}
	}

	if (!complete_type_or_else (type, NULL_TREE))
	return error_mark_node;

	/* If our base type is an array, then make sure we know how many elements
	it has. */
	for (elt_type = type;
	TREE_CODE (elt_type) == ARRAY_TYPE;
	elt_type = TREE_TYPE (elt_type))
	nelts = cp_build_binary_op (MULT_EXPR, nelts,
	array_type_nelts_top (elt_type));

	if (TREE_CODE (elt_type) == VOID_TYPE)
	{
	error ("invalid type %<void%> for new");
	return error_mark_node;
	}

	if (abstract_virtuals_error (NULL_TREE, elt_type))
	return error_mark_node;

	is_initialized = (TYPE_NEEDS_CONSTRUCTING (elt_type) \|\| init);
	if (CP_TYPE_CONST_P (elt_type) && !is_initialized)
	{
	error ("uninitialized const in %<new%> of %q#T", elt_type);
	return error_mark_node;
	}

	size = size_in_bytes (elt_type);
	if (array_p)
	{
	size = size_binop (MULT_EXPR, size, convert (sizetype, nelts));
	if (vla_p)
	{
	tree n, bitsize;

	/* Do our own VLA layout. Setting TYPE_SIZE/_UNIT is
	necessary in order for the <INIT_EXPR <*foo> <CONSTRUCTOR
	...>> to be valid. */
	TYPE_SIZE_UNIT (full_type) = size;
	n = convert (bitsizetype, nelts);
	bitsize = size_binop (MULT_EXPR, TYPE_SIZE (elt_type), n);
	TYPE_SIZE (full_type) = bitsize;
	}
	}

	alloc_fn = NULL_TREE;

	/* Allocate the object. */
	if (! placement && TYPE_FOR_JAVA (elt_type))
	{
	tree class_addr;
	tree class_decl = build_java_class_ref (elt_type);
	static const char alloc_name[] = "_Jv_AllocObject";

	if (class_decl == error_mark_node)
	return error_mark_node;

	use_java_new = 1;
	if (!get_global_value_if_present (get_identifier (alloc_name),
	&alloc_fn))
	{
	error ("call to Java constructor with %qs undefined", alloc_name);
	return error_mark_node;
	}
	else if (really_overloaded_fn (alloc_fn))
	{
	error ("%qD should never be overloaded", alloc_fn);
	return error_mark_node;
	}
	alloc_fn = OVL_CURRENT (alloc_fn);
	class_addr = build1 (ADDR_EXPR, jclass_node, class_decl);
	alloc_call = (build_function_call
	(alloc_fn,
	build_tree_list (NULL_TREE, class_addr)));
	}
	else
	{
	tree fnname;
	tree fns;

	fnname = ansi_opname (array_p ? VEC_NEW_EXPR : NEW_EXPR);

	if (!globally_qualified_p
	&& CLASS_TYPE_P (elt_type)
	&& (array_p
	? TYPE_HAS_ARRAY_NEW_OPERATOR (elt_type)
	: TYPE_HAS_NEW_OPERATOR (elt_type)))
	{
	/* Use a class-specific operator new. */
	/* If a cookie is required, add some extra space. */
	if (array_p && TYPE_VEC_NEW_USES_COOKIE (elt_type))
	{
	cookie_size = targetm.cxx.get_cookie_size (elt_type);
	size = size_binop (PLUS_EXPR, size, cookie_size);
	}
	/* Create the argument list. */
	args = tree_cons (NULL_TREE, size, placement);
	/* Do name-lookup to find the appropriate operator. */
	fns = lookup_fnfields (elt_type, fnname, /protect=/2);
	if (fns == NULL_TREE)
	{
	error ("no suitable %qD found in class %qT", fnname, elt_type);
	return error_mark_node;
	}
	if (TREE_CODE (fns) == TREE_LIST)
	{
	error ("request for member %qD is ambiguous", fnname);
	print_candidates (fns);
	return error_mark_node;
	}
	alloc_call = build_new_method_call (build_dummy_object (elt_type),
	fns, args,
	/conversion_path=/NULL_TREE,
	LOOKUP_NORMAL,
	&alloc_fn);
	}
	else
	{
	/* Use a global operator new. */
	/* See if a cookie might be required. */
	if (array_p && TYPE_VEC_NEW_USES_COOKIE (elt_type))
	cookie_size = targetm.cxx.get_cookie_size (elt_type);
	else
	cookie_size = NULL_TREE;

	alloc_call = build_operator_new_call (fnname, placement,
	&size, &cookie_size,
	&alloc_fn);
	}
	}

	if (alloc_call == error_mark_node)
	return error_mark_node;

	gcc_assert (alloc_fn != NULL_TREE);

	/* In the simple case, we can stop now. */
	pointer_type = build_pointer_type (type);
	if (!cookie_size && !is_initialized)
	return build_nop (pointer_type, alloc_call);

	/* While we're working, use a pointer to the type we've actually
	allocated. Store the result of the call in a variable so that we
	can use it more than once. */
	full_pointer_type = build_pointer_type (full_type);
	alloc_expr = get_target_expr (build_nop (full_pointer_type, alloc_call));
	alloc_node = TARGET_EXPR_SLOT (alloc_expr);

	/* Strip any COMPOUND_EXPRs from ALLOC_CALL. */
	while (TREE_CODE (alloc_call) == COMPOUND_EXPR)
	alloc_call = TREE_OPERAND (alloc_call, 1);

	/* Now, check to see if this function is actually a placement
	allocation function. This can happen even when PLACEMENT is NULL
	because we might have something like:

	struct S { void* operator new (size_t, int i = 0); };

	A call to `new S' will get this allocation function, even though
	there is no explicit placement argument. If there is more than
	one argument, or there are variable arguments, then this is a
	placement allocation function. */
	placement_allocation_fn_p
	= (type_num_arguments (TREE_TYPE (alloc_fn)) > 1
	\|\| varargs_function_p (alloc_fn));

	/* Preevaluate the placement args so that we don't reevaluate them for a
	placement delete. */
	if (placement_allocation_fn_p)
	{
	tree inits;
	stabilize_call (alloc_call, &inits);
	if (inits)
	alloc_expr = build2 (COMPOUND_EXPR, TREE_TYPE (alloc_expr), inits,
	alloc_expr);
	}

	/* unless an allocation function is declared with an empty excep-
	tion-specification (_except.spec_), throw(), it indicates failure to
	allocate storage by throwing a bad_alloc exception (clause _except_,
	_lib.bad.alloc_); it returns a non-null pointer otherwise If the allo-
	cation function is declared with an empty exception-specification,
	throw(), it returns null to indicate failure to allocate storage and a
	non-null pointer otherwise.

	So check for a null exception spec on the op new we just called. */

	nothrow = TYPE_NOTHROW_P (TREE_TYPE (alloc_fn));
	check_new = (flag_check_new \|\| nothrow) && ! use_java_new;

	if (cookie_size)
	{
	tree cookie;
	tree cookie_ptr;

	/* Adjust so we're pointing to the start of the object. */
	data_addr = get_target_expr (build2 (PLUS_EXPR, full_pointer_type,
	alloc_node, cookie_size));

	/* Store the number of bytes allocated so that we can know how
	many elements to destroy later. We use the last sizeof
	(size_t) bytes to store the number of elements. */
	cookie_ptr = build2 (MINUS_EXPR, build_pointer_type (sizetype),
	data_addr, size_in_bytes (sizetype));
	cookie = build_indirect_ref (cookie_ptr, NULL);

	cookie_expr = build2 (MODIFY_EXPR, sizetype, cookie, nelts);

	if (targetm.cxx.cookie_has_size ())
	{
	/* Also store the element size. */
	cookie_ptr = build2 (MINUS_EXPR, build_pointer_type (sizetype),
	cookie_ptr, size_in_bytes (sizetype));
	cookie = build_indirect_ref (cookie_ptr, NULL);
	cookie = build2 (MODIFY_EXPR, sizetype, cookie,
	size_in_bytes(elt_type));
	cookie_expr = build2 (COMPOUND_EXPR, TREE_TYPE (cookie_expr),
	cookie, cookie_expr);
	}
	data_addr = TARGET_EXPR_SLOT (data_addr);
	}
	else
	{
	cookie_expr = NULL_TREE;
	data_addr = alloc_node;
	}

	/* Now initialize the allocated object. Note that we preevaluate the
	initialization expression, apart from the actual constructor call or
	assignment--we do this because we want to delay the allocation as long
	as possible in order to minimize the size of the exception region for
	placement delete. */
	if (is_initialized)
	{
	bool stable;

	init_expr = build_indirect_ref (data_addr, NULL);

	if (array_p)
	{
	bool explicit_default_init_p = false;

	if (init == void_zero_node)
	{
	init = NULL_TREE;
	explicit_default_init_p = true;
	}
	else if (init)
	pedwarn ("ISO C++ forbids initialization in array new");

	init_expr
	= build_vec_init (init_expr,
	cp_build_binary_op (MINUS_EXPR, outer_nelts,
	integer_one_node),
	init,
	explicit_default_init_p,
	/from_array=/0);

	/* An array initialization is stable because the initialization
	of each element is a full-expression, so the temporaries don't
	leak out. */
	stable = true;
	}
	else
	{
	if (init == void_zero_node)
	init = build_default_init (full_type, nelts);

	if (TYPE_NEEDS_CONSTRUCTING (type))
	{
	init_expr = build_special_member_call (init_expr,
	complete_ctor_identifier,
	init, elt_type,
	LOOKUP_NORMAL);
	stable = stabilize_init (init_expr, &init_preeval_expr);
	}
	else
	{
	/* We are processing something like `new int (10)', which
	means allocate an int, and initialize it with 10. */

	if (TREE_CODE (init) == TREE_LIST)
	init = build_x_compound_expr_from_list (init,
	"new initializer");
	else
	gcc_assert (TREE_CODE (init) != CONSTRUCTOR
	\|\| TREE_TYPE (init) != NULL_TREE);

	init_expr = build_modify_expr (init_expr, INIT_EXPR, init);
	stable = stabilize_init (init_expr, &init_preeval_expr);
	}
	}

	if (init_expr == error_mark_node)
	return error_mark_node;

	/* If any part of the object initialization terminates by throwing an
	exception and a suitable deallocation function can be found, the
	deallocation function is called to free the memory in which the
	object was being constructed, after which the exception continues
	to propagate in the context of the new-expression. If no
	unambiguous matching deallocation function can be found,
	propagating the exception does not cause the object's memory to be
	freed. */
	if (flag_exceptions && ! use_java_new)
	{
	enum tree_code dcode = array_p ? VEC_DELETE_EXPR : DELETE_EXPR;
	tree cleanup;

	/* The Standard is unclear here, but the right thing to do
	is to use the same method for finding deallocation
	functions that we use for finding allocation functions. */
	cleanup = build_op_delete_call (dcode, alloc_node, size,
	globally_qualified_p,
	(placement_allocation_fn_p
	? alloc_call : NULL_TREE),
	alloc_fn);

	if (!cleanup)
	/* We're done. */;
	else if (stable)
	/* This is much simpler if we were able to preevaluate all of
	the arguments to the constructor call. */
	init_expr = build2 (TRY_CATCH_EXPR, void_type_node,
	init_expr, cleanup);
	else
	/* Ack! First we allocate the memory. Then we set our sentry
	variable to true, and expand a cleanup that deletes the
	memory if sentry is true. Then we run the constructor, and
	finally clear the sentry.

	We need to do this because we allocate the space first, so
	if there are any temporaries with cleanups in the
	constructor args and we weren't able to preevaluate them, we
	need this EH region to extend until end of full-expression
	to preserve nesting. */
	{
	tree end, sentry, begin;

	begin = get_target_expr (boolean_true_node);
	CLEANUP_EH_ONLY (begin) = 1;

	sentry = TARGET_EXPR_SLOT (begin);

	TARGET_EXPR_CLEANUP (begin)
	= build3 (COND_EXPR, void_type_node, sentry,
	cleanup, void_zero_node);

	end = build2 (MODIFY_EXPR, TREE_TYPE (sentry),
	sentry, boolean_false_node);

	init_expr
	= build2 (COMPOUND_EXPR, void_type_node, begin,
	build2 (COMPOUND_EXPR, void_type_node, init_expr,
	end));
	}

	}
	}
	else
	init_expr = NULL_TREE;

	/* Now build up the return value in reverse order. */

	rval = data_addr;

	if (init_expr)
	rval = build2 (COMPOUND_EXPR, TREE_TYPE (rval), init_expr, rval);
	if (cookie_expr)
	rval = build2 (COMPOUND_EXPR, TREE_TYPE (rval), cookie_expr, rval);

	if (rval == alloc_node)
	/* If we don't have an initializer or a cookie, strip the TARGET_EXPR
	and return the call (which doesn't need to be adjusted). */
	rval = TARGET_EXPR_INITIAL (alloc_expr);
	else
	{
	if (check_new)
	{
	tree ifexp = cp_build_binary_op (NE_EXPR, alloc_node,
	integer_zero_node);
	rval = build_conditional_expr (ifexp, rval, alloc_node);
	}

	/* Perform the allocation before anything else, so that ALLOC_NODE
	has been initialized before we start using it. */
	rval = build2 (COMPOUND_EXPR, TREE_TYPE (rval), alloc_expr, rval);
	}

	if (init_preeval_expr)
	rval = build2 (COMPOUND_EXPR, TREE_TYPE (rval), init_preeval_expr, rval);

	/* Convert to the final type. */
	rval = build_nop (pointer_type, rval);

	/* A new-expression is never an lvalue. */
	gcc_assert (!lvalue_p (rval));

	return rval;
	}

	/* Generate a representation for a C++ "new" expression. PLACEMENT is
	a TREE_LIST of placement-new arguments (or NULL_TREE if none). If
	NELTS is NULL, TYPE is the type of the storage to be allocated. If
	NELTS is not NULL, then this is an array-new allocation; TYPE is
	the type of the elements in the array and NELTS is the number of
	elements in the array. INIT, if non-NULL, is the initializer for
	the new object, or void_zero_node to indicate an initializer of
	"()". If USE_GLOBAL_NEW is true, then the user explicitly wrote
	"::new" rather than just "new". */

	tree
	build_new (tree placement, tree type, tree nelts, tree init,
	int use_global_new)
	{
	tree rval;
	tree orig_placement;
	tree orig_nelts;
	tree orig_init;

	if (placement == error_mark_node \|\| type == error_mark_node
	\|\| init == error_mark_node)
	return error_mark_node;

	orig_placement = placement;
	orig_nelts = nelts;
	orig_init = init;

	if (processing_template_decl)
	{
	if (dependent_type_p (type)
	\|\| any_type_dependent_arguments_p (placement)
	\|\| (nelts && type_dependent_expression_p (nelts))
	\|\| (init != void_zero_node
	&& any_type_dependent_arguments_p (init)))
	return build_raw_new_expr (placement, type, nelts, init,
	use_global_new);
	placement = build_non_dependent_args (placement);
	if (nelts)
	nelts = build_non_dependent_expr (nelts);
	if (init != void_zero_node)
	init = build_non_dependent_args (init);
	}

	if (nelts)
	{
	if (!build_expr_type_conversion (WANT_INT \| WANT_ENUM, nelts, false))
	pedwarn ("size in array new must have integral type");
	nelts = cp_save_expr (cp_convert (sizetype, nelts));
	/* It is valid to allocate a zero-element array:

	[expr.new]

	When the value of the expression in a direct-new-declarator
	is zero, the allocation function is called to allocate an
	array with no elements. The pointer returned by the
	new-expression is non-null. [Note: If the library allocation
	function is called, the pointer returned is distinct from the
	pointer to any other object.]

	However, that is not generally useful, so we issue a
	warning. */
	if (integer_zerop (nelts))
	warning (0, "allocating zero-element array");
	}

	/* ``A reference cannot be created by the new operator. A reference
	is not an object (8.2.2, 8.4.3), so a pointer to it could not be
	returned by new.'' ARM 5.3.3 */
	if (TREE_CODE (type) == REFERENCE_TYPE)
	{
	error ("new cannot be applied to a reference type");
	type = TREE_TYPE (type);
	}

	if (TREE_CODE (type) == FUNCTION_TYPE)
	{
	error ("new cannot be applied to a function type");
	return error_mark_node;
	}

	rval = build_new_1 (placement, type, nelts, init, use_global_new);
	if (rval == error_mark_node)
	return error_mark_node;

	if (processing_template_decl)
	return build_raw_new_expr (orig_placement, type, orig_nelts, orig_init,
	use_global_new);

	/* Wrap it in a NOP_EXPR so warn_if_unused_value doesn't complain. */
	rval = build1 (NOP_EXPR, TREE_TYPE (rval), rval);
	TREE_NO_WARNING (rval) = 1;

	return rval;
	}

	/* Given a Java class, return a decl for the corresponding java.lang.Class. */

	tree
	build_java_class_ref (tree type)
	{
	tree name = NULL_TREE, class_decl;
	static tree CL_suffix = NULL_TREE;
	if (CL_suffix == NULL_TREE)
	CL_suffix = get_identifier("class$");
	if (jclass_node == NULL_TREE)
	{
	jclass_node = IDENTIFIER_GLOBAL_VALUE (get_identifier ("jclass"));
	if (jclass_node == NULL_TREE)
	{
	error ("call to Java constructor, while %<jclass%> undefined");
	return error_mark_node;
	}
	jclass_node = TREE_TYPE (jclass_node);
	}

	/* Mangle the class$ field. */
	{
	tree field;
	for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field))
	if (DECL_NAME (field) == CL_suffix)
	{
	mangle_decl (field);
	name = DECL_ASSEMBLER_NAME (field);
	break;
	}
	if (!field)
	{
	error ("can't find %<class$%> in %qT", type);
	return error_mark_node;
	}
	}

	class_decl = IDENTIFIER_GLOBAL_VALUE (name);
	if (class_decl == NULL_TREE)
	{
	class_decl = build_decl (VAR_DECL, name, TREE_TYPE (jclass_node));
	TREE_STATIC (class_decl) = 1;
	DECL_EXTERNAL (class_decl) = 1;
	TREE_PUBLIC (class_decl) = 1;
	DECL_ARTIFICIAL (class_decl) = 1;
	DECL_IGNORED_P (class_decl) = 1;
	pushdecl_top_level (class_decl);
	make_decl_rtl (class_decl);
	}
	return class_decl;
	}

	static tree
	build_vec_delete_1 (tree base, tree maxindex, tree type,
	special_function_kind auto_delete_vec, int use_global_delete)
	{
	tree virtual_size;
	tree ptype = build_pointer_type (type = complete_type (type));
	tree size_exp = size_in_bytes (type);

	/* Temporary variables used by the loop. */
	tree tbase, tbase_init;

	/* This is the body of the loop that implements the deletion of a
	single element, and moves temp variables to next elements. */
	tree body;

	/* This is the LOOP_EXPR that governs the deletion of the elements. */
	tree loop = 0;

	/* This is the thing that governs what to do after the loop has run. */
	tree deallocate_expr = 0;

	/* This is the BIND_EXPR which holds the outermost iterator of the
	loop. It is convenient to set this variable up and test it before
	executing any other code in the loop.
	This is also the containing expression returned by this function. */
	tree controller = NULL_TREE;

	/* We should only have 1-D arrays here. */
	gcc_assert (TREE_CODE (type) != ARRAY_TYPE);

	if (! IS_AGGR_TYPE (type) \|\| TYPE_HAS_TRIVIAL_DESTRUCTOR (type))
	goto no_destructor;

	/* The below is short by the cookie size. */
	virtual_size = size_binop (MULT_EXPR, size_exp,
	convert (sizetype, maxindex));

	tbase = create_temporary_var (ptype);
	tbase_init = build_modify_expr (tbase, NOP_EXPR,
	fold_build2 (PLUS_EXPR, ptype,
	base,
	virtual_size));
	DECL_REGISTER (tbase) = 1;
	controller = build3 (BIND_EXPR, void_type_node, tbase,
	NULL_TREE, NULL_TREE);
	TREE_SIDE_EFFECTS (controller) = 1;

	body = build1 (EXIT_EXPR, void_type_node,
	build2 (EQ_EXPR, boolean_type_node, tbase,
	fold_convert (ptype, base)));
	body = build_compound_expr
	(body, build_modify_expr (tbase, NOP_EXPR,
	build2 (MINUS_EXPR, ptype, tbase, size_exp)));
	body = build_compound_expr
	(body, build_delete (ptype, tbase, sfk_complete_destructor,
	LOOKUP_NORMAL\|LOOKUP_DESTRUCTOR, 1));

	loop = build1 (LOOP_EXPR, void_type_node, body);
	loop = build_compound_expr (tbase_init, loop);

	no_destructor:
	/* If the delete flag is one, or anything else with the low bit set,
	delete the storage. */
	if (auto_delete_vec != sfk_base_destructor)
	{
	tree base_tbd;

	/* The below is short by the cookie size. */
	virtual_size = size_binop (MULT_EXPR, size_exp,
	convert (sizetype, maxindex));

	if (! TYPE_VEC_NEW_USES_COOKIE (type))
	/* no header */
	base_tbd = base;
	else
	{
	tree cookie_size;

	cookie_size = targetm.cxx.get_cookie_size (type);
	base_tbd
	= cp_convert (ptype,
	cp_build_binary_op (MINUS_EXPR,
	cp_convert (string_type_node,
	base),
	cookie_size));
	/* True size with header. */
	virtual_size = size_binop (PLUS_EXPR, virtual_size, cookie_size);
	}

	if (auto_delete_vec == sfk_deleting_destructor)
	deallocate_expr = build_op_delete_call (VEC_DELETE_EXPR,
	base_tbd, virtual_size,
	use_global_delete & 1,
	/placement=/NULL_TREE,
	/alloc_fn=/NULL_TREE);
	}

	body = loop;
	if (!deallocate_expr)
	;
	else if (!body)
	body = deallocate_expr;
	else
	body = build_compound_expr (body, deallocate_expr);

	if (!body)
	body = integer_zero_node;

	/* Outermost wrapper: If pointer is null, punt. */
	body = fold_build3 (COND_EXPR, void_type_node,
	fold_build2 (NE_EXPR, boolean_type_node, base,
	convert (TREE_TYPE (base),
	integer_zero_node)),
	body, integer_zero_node);
	body = build1 (NOP_EXPR, void_type_node, body);

	if (controller)
	{
	TREE_OPERAND (controller, 1) = body;
	body = controller;
	}

	if (TREE_CODE (base) == SAVE_EXPR)
	/* Pre-evaluate the SAVE_EXPR outside of the BIND_EXPR. */
	body = build2 (COMPOUND_EXPR, void_type_node, base, body);

	return convert_to_void (body, /implicit=/NULL);
	}

	/* Create an unnamed variable of the indicated TYPE. */

	tree
	create_temporary_var (tree type)
	{
	tree decl;

	decl = build_decl (VAR_DECL, NULL_TREE, type);
	TREE_USED (decl) = 1;
	DECL_ARTIFICIAL (decl) = 1;
	DECL_IGNORED_P (decl) = 1;
	DECL_SOURCE_LOCATION (decl) = input_location;
	DECL_CONTEXT (decl) = current_function_decl;

	return decl;
	}

	/* Create a new temporary variable of the indicated TYPE, initialized
	to INIT.

	It is not entered into current_binding_level, because that breaks
	things when it comes time to do final cleanups (which take place
	"outside" the binding contour of the function). */

	static tree
	get_temp_regvar (tree type, tree init)
	{
	tree decl;

	decl = create_temporary_var (type);
	add_decl_expr (decl);

	finish_expr_stmt (build_modify_expr (decl, INIT_EXPR, init));

	return decl;
	}

	/* `build_vec_init' returns tree structure that performs
	initialization of a vector of aggregate types.

	BASE is a reference to the vector, of ARRAY_TYPE.
	MAXINDEX is the maximum index of the array (one less than the
	number of elements). It is only used if
	TYPE_DOMAIN (TREE_TYPE (BASE)) == NULL_TREE.

	INIT is the (possibly NULL) initializer.

	If EXPLICIT_DEFAULT_INIT_P is true, then INIT must be NULL. All
	elements in the array are default-initialized.

	FROM_ARRAY is 0 if we should init everything with INIT
	(i.e., every element initialized from INIT).
	FROM_ARRAY is 1 if we should index into INIT in parallel
	with initialization of DECL.
	FROM_ARRAY is 2 if we should index into INIT in parallel,
	but use assignment instead of initialization. */

	tree
	build_vec_init (tree base, tree maxindex, tree init,
	bool explicit_default_init_p,
	int from_array)
	{
	tree rval;
	tree base2 = NULL_TREE;
	tree size;
	tree itype = NULL_TREE;
	tree iterator;
	/* The type of the array. */
	tree atype = TREE_TYPE (base);
	/* The type of an element in the array. */
	tree type = TREE_TYPE (atype);
	/* The element type reached after removing all outer array
	types. */
	tree inner_elt_type;
	/* The type of a pointer to an element in the array. */
	tree ptype;
	tree stmt_expr;
	tree compound_stmt;
	int destroy_temps;
	tree try_block = NULL_TREE;
	int num_initialized_elts = 0;
	bool is_global;

	if (TYPE_DOMAIN (atype))
	maxindex = array_type_nelts (atype);

	if (maxindex == NULL_TREE \|\| maxindex == error_mark_node)
	return error_mark_node;

	if (explicit_default_init_p)
	gcc_assert (!init);

	inner_elt_type = strip_array_types (atype);
	if (init
	&& (from_array == 2
	? (!CLASS_TYPE_P (inner_elt_type)
	\|\| !TYPE_HAS_COMPLEX_ASSIGN_REF (inner_elt_type))
	: !TYPE_NEEDS_CONSTRUCTING (type))
	&& ((TREE_CODE (init) == CONSTRUCTOR
	/* Don't do this if the CONSTRUCTOR might contain something
	that might throw and require us to clean up. */
	&& (VEC_empty (constructor_elt, CONSTRUCTOR_ELTS (init))
	\|\| ! TYPE_HAS_NONTRIVIAL_DESTRUCTOR (inner_elt_type)))
	\|\| from_array))
	{
	/* Do non-default initialization of POD arrays resulting from
	brace-enclosed initializers. In this case, digest_init and
	store_constructor will handle the semantics for us. */

	stmt_expr = build2 (INIT_EXPR, atype, base, init);
	return stmt_expr;
	}

	maxindex = cp_convert (ptrdiff_type_node, maxindex);
	ptype = build_pointer_type (type);
	size = size_in_bytes (type);
	if (TREE_CODE (TREE_TYPE (base)) == ARRAY_TYPE)
	base = cp_convert (ptype, decay_conversion (base));

	/* The code we are generating looks like:
	({
	T* t1 = (T*) base;
	T* rval = t1;
	ptrdiff_t iterator = maxindex;
	try {
	for (; iterator != -1; --iterator) {
	... initialize *t1 ...
	++t1;
	}
	} catch (...) {
	... destroy elements that were constructed ...
	}
	rval;
	})

	We can omit the try and catch blocks if we know that the
	initialization will never throw an exception, or if the array
	elements do not have destructors. We can omit the loop completely if
	the elements of the array do not have constructors.

	We actually wrap the entire body of the above in a STMT_EXPR, for
	tidiness.

	When copying from array to another, when the array elements have
	only trivial copy constructors, we should use __builtin_memcpy
	rather than generating a loop. That way, we could take advantage
	of whatever cleverness the back-end has for dealing with copies
	of blocks of memory. */

	is_global = begin_init_stmts (&stmt_expr, &compound_stmt);
	destroy_temps = stmts_are_full_exprs_p ();
	current_stmt_tree ()->stmts_are_full_exprs_p = 0;
	rval = get_temp_regvar (ptype, base);
	base = get_temp_regvar (ptype, rval);
	iterator = get_temp_regvar (ptrdiff_type_node, maxindex);

	/* Protect the entire array initialization so that we can destroy
	the partially constructed array if an exception is thrown.
	But don't do this if we're assigning. */
	if (flag_exceptions && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type)
	&& from_array != 2)
	{
	try_block = begin_try_block ();
	}

	if (init != NULL_TREE && TREE_CODE (init) == CONSTRUCTOR)
	{
	/* Do non-default initialization of non-POD arrays resulting from
	brace-enclosed initializers. */
	unsigned HOST_WIDE_INT idx;
	tree elt;
	from_array = 0;

	FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (init), idx, elt)
	{
	tree baseref = build1 (INDIRECT_REF, type, base);

	num_initialized_elts++;

	current_stmt_tree ()->stmts_are_full_exprs_p = 1;
	if (IS_AGGR_TYPE (type) \|\| TREE_CODE (type) == ARRAY_TYPE)
	finish_expr_stmt (build_aggr_init (baseref, elt, 0));
	else
	finish_expr_stmt (build_modify_expr (baseref, NOP_EXPR,
	elt));
	current_stmt_tree ()->stmts_are_full_exprs_p = 0;

	finish_expr_stmt (build_unary_op (PREINCREMENT_EXPR, base, 0));
	finish_expr_stmt (build_unary_op (PREDECREMENT_EXPR, iterator, 0));
	}

	/* Clear out INIT so that we don't get confused below. */
	init = NULL_TREE;
	}
	else if (from_array)
	{
	/* If initializing one array from another, initialize element by
	element. We rely upon the below calls the do argument
	checking. */
	if (init)
	{
	base2 = decay_conversion (init);
	itype = TREE_TYPE (base2);
	base2 = get_temp_regvar (itype, base2);
	itype = TREE_TYPE (itype);
	}
	else if (TYPE_LANG_SPECIFIC (type)
	&& TYPE_NEEDS_CONSTRUCTING (type)
	&& ! TYPE_HAS_DEFAULT_CONSTRUCTOR (type))
	{
	error ("initializer ends prematurely");
	return error_mark_node;
	}
	}

	/* Now, default-initialize any remaining elements. We don't need to
	do that if a) the type does not need constructing, or b) we've
	already initialized all the elements.

	We do need to keep going if we're copying an array. */

	if (from_array
	\|\| ((TYPE_NEEDS_CONSTRUCTING (type) \|\| explicit_default_init_p)
	&& ! (host_integerp (maxindex, 0)
	&& (num_initialized_elts
	== tree_low_cst (maxindex, 0) + 1))))
	{
	/* If the ITERATOR is equal to -1, then we don't have to loop;
	we've already initialized all the elements. */
	tree for_stmt;
	tree elt_init;
	tree to;

	- for_stmt = begin_for_stmt ();
	+/* APPLE LOCAL begin for-fsf-4_4 3274130 5295549 */ \
	+ for_stmt = begin_for_stmt (NULL_TREE);
	+/* APPLE LOCAL end for-fsf-4_4 3274130 5295549 */ \
	finish_for_init_stmt (for_stmt);
	finish_for_cond (build2 (NE_EXPR, boolean_type_node, iterator,
	build_int_cst (TREE_TYPE (iterator), -1)),
	for_stmt);
	finish_for_expr (build_unary_op (PREDECREMENT_EXPR, iterator, 0),
	for_stmt);

	to = build1 (INDIRECT_REF, type, base);

	if (from_array)
	{
	tree from;

	if (base2)
	from = build1 (INDIRECT_REF, itype, base2);
	else
	from = NULL_TREE;

	if (from_array == 2)
	elt_init = build_modify_expr (to, NOP_EXPR, from);
	else if (TYPE_NEEDS_CONSTRUCTING (type))
	elt_init = build_aggr_init (to, from, 0);
	else if (from)
	elt_init = build_modify_expr (to, NOP_EXPR, from);
	else
	gcc_unreachable ();
	}
	else if (TREE_CODE (type) == ARRAY_TYPE)
	{
	if (init != 0)
	sorry
	("cannot initialize multi-dimensional array with initializer");
	elt_init = build_vec_init (build1 (INDIRECT_REF, type, base),
	0, 0,
	/explicit_default_init_p=/false,
	0);
	}
	else if (!TYPE_NEEDS_CONSTRUCTING (type))
	elt_init = (build_modify_expr
	(to, INIT_EXPR,
	build_zero_init (type, size_one_node,
	/static_storage_p=/false)));
	else
	elt_init = build_aggr_init (to, init, 0);

	current_stmt_tree ()->stmts_are_full_exprs_p = 1;
	finish_expr_stmt (elt_init);
	current_stmt_tree ()->stmts_are_full_exprs_p = 0;

	finish_expr_stmt (build_unary_op (PREINCREMENT_EXPR, base, 0));
	if (base2)
	finish_expr_stmt (build_unary_op (PREINCREMENT_EXPR, base2, 0));

	finish_for_stmt (for_stmt);
	}

	/* Make sure to cleanup any partially constructed elements. */
	if (flag_exceptions && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type)
	&& from_array != 2)
	{
	tree e;
	tree m = cp_build_binary_op (MINUS_EXPR, maxindex, iterator);

	/* Flatten multi-dimensional array since build_vec_delete only
	expects one-dimensional array. */
	if (TREE_CODE (type) == ARRAY_TYPE)
	m = cp_build_binary_op (MULT_EXPR, m,
	array_type_nelts_total (type));

	finish_cleanup_try_block (try_block);
	e = build_vec_delete_1 (rval, m,
	inner_elt_type, sfk_base_destructor,
	/use_global_delete=/0);
	finish_cleanup (e, try_block);
	}

	/* The value of the array initialization is the array itself, RVAL
	is a pointer to the first element. */
	finish_stmt_expr_expr (rval, stmt_expr);

	stmt_expr = finish_init_stmts (is_global, stmt_expr, compound_stmt);

	/* Now convert make the result have the correct type. */
	atype = build_pointer_type (atype);
	stmt_expr = build1 (NOP_EXPR, atype, stmt_expr);
	stmt_expr = build_indirect_ref (stmt_expr, NULL);

	current_stmt_tree ()->stmts_are_full_exprs_p = destroy_temps;
	return stmt_expr;
	}

	/* Call the DTOR_KIND destructor for EXP. FLAGS are as for
	build_delete. */

	static tree
	build_dtor_call (tree exp, special_function_kind dtor_kind, int flags)
	{
	tree name;
	tree fn;
	switch (dtor_kind)
	{
	case sfk_complete_destructor:
	name = complete_dtor_identifier;
	break;

	case sfk_base_destructor:
	name = base_dtor_identifier;
	break;

	case sfk_deleting_destructor:
	name = deleting_dtor_identifier;
	break;

	default:
	gcc_unreachable ();
	}
	fn = lookup_fnfields (TREE_TYPE (exp), name, /protect=/2);
	return build_new_method_call (exp, fn,
	/args=/NULL_TREE,
	/conversion_path=/NULL_TREE,
	flags,
	/fn_p=/NULL);
	}

	/* Generate a call to a destructor. TYPE is the type to cast ADDR to.
	ADDR is an expression which yields the store to be destroyed.
	AUTO_DELETE is the name of the destructor to call, i.e., either
	sfk_complete_destructor, sfk_base_destructor, or
	sfk_deleting_destructor.

	FLAGS is the logical disjunction of zero or more LOOKUP_
	flags. See cp-tree.h for more info. */

	tree
	build_delete (tree type, tree addr, special_function_kind auto_delete,
	int flags, int use_global_delete)
	{
	tree expr;

	if (addr == error_mark_node)
	return error_mark_node;

	/* Can happen when CURRENT_EXCEPTION_OBJECT gets its type
	set to `error_mark_node' before it gets properly cleaned up. */
	if (type == error_mark_node)
	return error_mark_node;

	type = TYPE_MAIN_VARIANT (type);

	if (TREE_CODE (type) == POINTER_TYPE)
	{
	bool complete_p = true;

	type = TYPE_MAIN_VARIANT (TREE_TYPE (type));
	if (TREE_CODE (type) == ARRAY_TYPE)
	goto handle_array;

	/* We don't want to warn about delete of void*, only other
	incomplete types. Deleting other incomplete types
	invokes undefined behavior, but it is not ill-formed, so
	compile to something that would even do The Right Thing
	(TM) should the type have a trivial dtor and no delete
	operator. */
	if (!VOID_TYPE_P (type))
	{
	complete_type (type);
	if (!COMPLETE_TYPE_P (type))
	{
	warning (0, "possible problem detected in invocation of "
	"delete operator:");
	cxx_incomplete_type_diagnostic (addr, type, 1);
	inform ("neither the destructor nor the class-specific "
	"operator delete will be called, even if they are "
	"declared when the class is defined.");
	complete_p = false;
	}
	}
	if (VOID_TYPE_P (type) \|\| !complete_p \|\| !IS_AGGR_TYPE (type))
	/* Call the builtin operator delete. */
	return build_builtin_delete_call (addr);
	if (TREE_SIDE_EFFECTS (addr))
	addr = save_expr (addr);

	/* Throw away const and volatile on target type of addr. */
	addr = convert_force (build_pointer_type (type), addr, 0);
	}
	else if (TREE_CODE (type) == ARRAY_TYPE)
	{
	handle_array:

	if (TYPE_DOMAIN (type) == NULL_TREE)
	{
	error ("unknown array size in delete");
	return error_mark_node;
	}
	return build_vec_delete (addr, array_type_nelts (type),
	auto_delete, use_global_delete);
	}
	else
	{
	/* Don't check PROTECT here; leave that decision to the
	destructor. If the destructor is accessible, call it,
	else report error. */
	addr = build_unary_op (ADDR_EXPR, addr, 0);
	if (TREE_SIDE_EFFECTS (addr))
	addr = save_expr (addr);

	addr = convert_force (build_pointer_type (type), addr, 0);
	}

	gcc_assert (IS_AGGR_TYPE (type));

	if (TYPE_HAS_TRIVIAL_DESTRUCTOR (type))
	{
	if (auto_delete != sfk_deleting_destructor)
	return void_zero_node;

	return build_op_delete_call (DELETE_EXPR, addr,
	cxx_sizeof_nowarn (type),
	use_global_delete,
	/placement=/NULL_TREE,
	/alloc_fn=/NULL_TREE);
	}
	else
	{
	tree do_delete = NULL_TREE;
	tree ifexp;

	if (CLASSTYPE_LAZY_DESTRUCTOR (type))
	lazily_declare_fn (sfk_destructor, type);

	/* For `::delete x', we must not use the deleting destructor
	since then we would not be sure to get the global `operator
	delete'. */
	if (use_global_delete && auto_delete == sfk_deleting_destructor)
	{
	/* We will use ADDR multiple times so we must save it. */
	addr = save_expr (addr);
	/* Delete the object. */
	do_delete = build_builtin_delete_call (addr);
	/* Otherwise, treat this like a complete object destructor
	call. */
	auto_delete = sfk_complete_destructor;
	}
	/* If the destructor is non-virtual, there is no deleting
	variant. Instead, we must explicitly call the appropriate
	`operator delete' here. */
	else if (!DECL_VIRTUAL_P (CLASSTYPE_DESTRUCTORS (type))
	&& auto_delete == sfk_deleting_destructor)
	{
	/* We will use ADDR multiple times so we must save it. */
	addr = save_expr (addr);
	/* Build the call. */
	do_delete = build_op_delete_call (DELETE_EXPR,
	addr,
	cxx_sizeof_nowarn (type),
	/global_p=/false,
	/placement=/NULL_TREE,
	/alloc_fn=/NULL_TREE);
	/* Call the complete object destructor. */
	auto_delete = sfk_complete_destructor;
	}
	else if (auto_delete == sfk_deleting_destructor
	&& TYPE_GETS_REG_DELETE (type))
	{
	/* Make sure we have access to the member op delete, even though
	we'll actually be calling it from the destructor. */
	build_op_delete_call (DELETE_EXPR, addr, cxx_sizeof_nowarn (type),
	/global_p=/false,
	/placement=/NULL_TREE,
	/alloc_fn=/NULL_TREE);
	}

	expr = build_dtor_call (build_indirect_ref (addr, NULL),
	auto_delete, flags);
	if (do_delete)
	expr = build2 (COMPOUND_EXPR, void_type_node, expr, do_delete);

	if (flags & LOOKUP_DESTRUCTOR)
	/* Explicit destructor call; don't check for null pointer. */
	ifexp = integer_one_node;
	else
	/* Handle deleting a null pointer. */
	ifexp = fold (cp_build_binary_op (NE_EXPR, addr, integer_zero_node));

	if (ifexp != integer_one_node)
	expr = build3 (COND_EXPR, void_type_node,
	ifexp, expr, void_zero_node);

	return expr;
	}
	}

	/* At the beginning of a destructor, push cleanups that will call the
	destructors for our base classes and members.

	Called from begin_destructor_body. */

	void
	push_base_cleanups (void)
	{
	tree binfo, base_binfo;
	int i;
	tree member;
	tree expr;
	VEC(tree,gc) *vbases;

	/* Run destructors for all virtual baseclasses. */
	if (CLASSTYPE_VBASECLASSES (current_class_type))
	{
	tree cond = (condition_conversion
	(build2 (BIT_AND_EXPR, integer_type_node,
	current_in_charge_parm,
	integer_two_node)));

	/* The CLASSTYPE_VBASECLASSES vector is in initialization
	order, which is also the right order for pushing cleanups. */
	for (vbases = CLASSTYPE_VBASECLASSES (current_class_type), i = 0;
	VEC_iterate (tree, vbases, i, base_binfo); i++)
	{
	if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (BINFO_TYPE (base_binfo)))
	{
	expr = build_special_member_call (current_class_ref,
	base_dtor_identifier,
	NULL_TREE,
	base_binfo,
	(LOOKUP_NORMAL
	\| LOOKUP_NONVIRTUAL));
	expr = build3 (COND_EXPR, void_type_node, cond,
	expr, void_zero_node);
	finish_decl_cleanup (NULL_TREE, expr);
	}
	}
	}

	/* Take care of the remaining baseclasses. */
	for (binfo = TYPE_BINFO (current_class_type), i = 0;
	BINFO_BASE_ITERATE (binfo, i, base_binfo); i++)
	{
	if (TYPE_HAS_TRIVIAL_DESTRUCTOR (BINFO_TYPE (base_binfo))
	\|\| BINFO_VIRTUAL_P (base_binfo))
	continue;

	expr = build_special_member_call (current_class_ref,
	base_dtor_identifier,
	NULL_TREE, base_binfo,
	LOOKUP_NORMAL \| LOOKUP_NONVIRTUAL);
	finish_decl_cleanup (NULL_TREE, expr);
	}

	for (member = TYPE_FIELDS (current_class_type); member;
	member = TREE_CHAIN (member))
	{
	if (TREE_TYPE (member) == error_mark_node
	\|\| TREE_CODE (member) != FIELD_DECL
	\|\| DECL_ARTIFICIAL (member))
	continue;
	if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TREE_TYPE (member)))
	{
	tree this_member = (build_class_member_access_expr
	(current_class_ref, member,
	/access_path=/NULL_TREE,
	/preserve_reference=/false));
	tree this_type = TREE_TYPE (member);
	expr = build_delete (this_type, this_member,
	sfk_complete_destructor,
	LOOKUP_NONVIRTUAL\|LOOKUP_DESTRUCTOR\|LOOKUP_NORMAL,
	0);
	finish_decl_cleanup (NULL_TREE, expr);
	}
	}
	}

	/* Build a C++ vector delete expression.
	MAXINDEX is the number of elements to be deleted.
	ELT_SIZE is the nominal size of each element in the vector.
	BASE is the expression that should yield the store to be deleted.
	This function expands (or synthesizes) these calls itself.
	AUTO_DELETE_VEC says whether the container (vector) should be deallocated.

	This also calls delete for virtual baseclasses of elements of the vector.

	Update: MAXINDEX is no longer needed. The size can be extracted from the
	start of the vector for pointers, and from the type for arrays. We still
	use MAXINDEX for arrays because it happens to already have one of the
	values we'd have to extract. (We could use MAXINDEX with pointers to
	confirm the size, and trap if the numbers differ; not clear that it'd
	be worth bothering.) */

	tree
	build_vec_delete (tree base, tree maxindex,
	special_function_kind auto_delete_vec, int use_global_delete)
	{
	tree type;
	tree rval;
	tree base_init = NULL_TREE;

	type = TREE_TYPE (base);

	if (TREE_CODE (type) == POINTER_TYPE)
	{
	/* Step back one from start of vector, and read dimension. */
	tree cookie_addr;

	if (TREE_SIDE_EFFECTS (base))
	{
	base_init = get_target_expr (base);
	base = TARGET_EXPR_SLOT (base_init);
	}
	type = strip_array_types (TREE_TYPE (type));
	cookie_addr = build2 (MINUS_EXPR,
	build_pointer_type (sizetype),
	base,
	TYPE_SIZE_UNIT (sizetype));
	maxindex = build_indirect_ref (cookie_addr, NULL);
	}
	else if (TREE_CODE (type) == ARRAY_TYPE)
	{
	/* Get the total number of things in the array, maxindex is a
	bad name. */
	maxindex = array_type_nelts_total (type);
	type = strip_array_types (type);
	base = build_unary_op (ADDR_EXPR, base, 1);
	if (TREE_SIDE_EFFECTS (base))
	{
	base_init = get_target_expr (base);
	base = TARGET_EXPR_SLOT (base_init);
	}
	}
	else
	{
	if (base != error_mark_node)
	error ("type to vector delete is neither pointer or array type");
	return error_mark_node;
	}

	rval = build_vec_delete_1 (base, maxindex, type, auto_delete_vec,
	use_global_delete);
	if (base_init)
	rval = build2 (COMPOUND_EXPR, TREE_TYPE (rval), base_init, rval);

	return rval;
	}
	diff --git a/contrib/gcc/cp/parser.c b/contrib/gcc/cp/parser.c
	index a021d5bcdfa0..94f90783fed8 100644
	--- a/contrib/gcc/cp/parser.c
	+++ b/contrib/gcc/cp/parser.c
	@@ -1,19489 +1,19514 @@
	/* C++ Parser.
	Copyright (C) 2000, 2001, 2002, 2003, 2004,
	2005 Free Software Foundation, Inc.
	Written by Mark Mitchell <mark@codesourcery.com>.

	This file is part of GCC.

	GCC is free software; you can redistribute it and/or modify it
	under the terms of the GNU General Public License as published by
	the Free Software Foundation; either version 2, or (at your option)
	any later version.

	GCC is distributed in the hope that it will be useful, but
	WITHOUT ANY WARRANTY; without even the implied warranty of
	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	General Public License for more details.

	You should have received a copy of the GNU General Public License
	along with GCC; see the file COPYING. If not, write to the Free
	Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
	02110-1301, USA. */

	#include "config.h"
	#include "system.h"
	#include "coretypes.h"
	#include "tm.h"
	#include "dyn-string.h"
	#include "varray.h"
	#include "cpplib.h"
	#include "tree.h"
	#include "cp-tree.h"
	#include "c-pragma.h"
	#include "decl.h"
	#include "flags.h"
	#include "diagnostic.h"
	#include "toplev.h"
	#include "output.h"
	#include "target.h"
	#include "cgraph.h"
	#include "c-common.h"


	/* The lexer. */

	/* The cp_lexer_* routines mediate between the lexer proper (in libcpp
	and c-lex.c) and the C++ parser. */

	/* A token's value and its associated deferred access checks and
	qualifying scope. */

	struct tree_check GTY(())
	{
	/* The value associated with the token. */
	tree value;
	/* The checks that have been associated with value. */
	VEC (deferred_access_check, gc)* checks;
	/* The token's qualifying scope (used when it is a
	CPP_NESTED_NAME_SPECIFIER). */
	tree qualifying_scope;
	};

	/* A C++ token. */

	typedef struct cp_token GTY (())
	{
	/* The kind of token. */
	ENUM_BITFIELD (cpp_ttype) type : 8;
	/* If this token is a keyword, this value indicates which keyword.
	Otherwise, this value is RID_MAX. */
	ENUM_BITFIELD (rid) keyword : 8;
	/* Token flags. */
	unsigned char flags;
	/* Identifier for the pragma. */
	ENUM_BITFIELD (pragma_kind) pragma_kind : 6;
	/* True if this token is from a system header. */
	BOOL_BITFIELD in_system_header : 1;
	/* True if this token is from a context where it is implicitly extern "C" */
	BOOL_BITFIELD implicit_extern_c : 1;
	/* True for a CPP_NAME token that is not a keyword (i.e., for which
	KEYWORD is RID_MAX) iff this name was looked up and found to be
	ambiguous. An error has already been reported. */
	BOOL_BITFIELD ambiguous_p : 1;
	/* The input file stack index at which this token was found. */
	unsigned input_file_stack_index : INPUT_FILE_STACK_BITS;
	/* The value associated with this token, if any. */
	union cp_token_value {
	/* Used for CPP_NESTED_NAME_SPECIFIER and CPP_TEMPLATE_ID. */
	struct tree_check* GTY((tag ("1"))) tree_check_value;
	/* Use for all other tokens. */
	tree GTY((tag ("0"))) value;
	} GTY((desc ("(%1.type == CPP_TEMPLATE_ID) \|\| (%1.type == CPP_NESTED_NAME_SPECIFIER)"))) u;
	/* The location at which this token was found. */
	location_t location;
	} cp_token;

	/* We use a stack of token pointer for saving token sets. */
	typedef struct cp_token *cp_token_position;
	DEF_VEC_P (cp_token_position);
	DEF_VEC_ALLOC_P (cp_token_position,heap);

	static const cp_token eof_token =
	{
	CPP_EOF, RID_MAX, 0, PRAGMA_NONE, 0, 0, false, 0, { NULL },
	#if USE_MAPPED_LOCATION
	0
	#else
	{0, 0}
	#endif
	};

	/* The cp_lexer structure represents the C++ lexer. It is responsible
	for managing the token stream from the preprocessor and supplying
	it to the parser. Tokens are never added to the cp_lexer after
	it is created. */

	typedef struct cp_lexer GTY (())
	{
	/* The memory allocated for the buffer. NULL if this lexer does not
	own the token buffer. */
	cp_token * GTY ((length ("%h.buffer_length"))) buffer;
	/* If the lexer owns the buffer, this is the number of tokens in the
	buffer. */
	size_t buffer_length;

	/* A pointer just past the last available token. The tokens
	in this lexer are [buffer, last_token). */
	cp_token_position GTY ((skip)) last_token;

	/* The next available token. If NEXT_TOKEN is &eof_token, then there are
	no more available tokens. */
	cp_token_position GTY ((skip)) next_token;

	/* A stack indicating positions at which cp_lexer_save_tokens was
	called. The top entry is the most recent position at which we
	began saving tokens. If the stack is non-empty, we are saving
	tokens. */
	VEC(cp_token_position,heap) *GTY ((skip)) saved_tokens;

	/* The next lexer in a linked list of lexers. */
	struct cp_lexer *next;

	/* True if we should output debugging information. */
	bool debugging_p;

	/* True if we're in the context of parsing a pragma, and should not
	increment past the end-of-line marker. */
	bool in_pragma;
	} cp_lexer;

	/* cp_token_cache is a range of tokens. There is no need to represent
	allocate heap memory for it, since tokens are never removed from the
	lexer's array. There is also no need for the GC to walk through
	a cp_token_cache, since everything in here is referenced through
	a lexer. */

	typedef struct cp_token_cache GTY(())
	{
	/* The beginning of the token range. */
	cp_token * GTY((skip)) first;

	/* Points immediately after the last token in the range. */
	cp_token * GTY ((skip)) last;
	} cp_token_cache;

	/* Prototypes. */

	static cp_lexer *cp_lexer_new_main
	(void);
	static cp_lexer *cp_lexer_new_from_tokens
	(cp_token_cache *tokens);
	static void cp_lexer_destroy
	(cp_lexer *);
	static int cp_lexer_saving_tokens
	(const cp_lexer *);
	static cp_token_position cp_lexer_token_position
	(cp_lexer *, bool);
	static cp_token *cp_lexer_token_at
	(cp_lexer *, cp_token_position);
	static void cp_lexer_get_preprocessor_token
	(cp_lexer , cp_token );
	static inline cp_token *cp_lexer_peek_token
	(cp_lexer *);
	static cp_token *cp_lexer_peek_nth_token
	(cp_lexer *, size_t);
	static inline bool cp_lexer_next_token_is
	(cp_lexer *, enum cpp_ttype);
	static bool cp_lexer_next_token_is_not
	(cp_lexer *, enum cpp_ttype);
	static bool cp_lexer_next_token_is_keyword
	(cp_lexer *, enum rid);
	static cp_token *cp_lexer_consume_token
	(cp_lexer *);
	static void cp_lexer_purge_token
	(cp_lexer *);
	static void cp_lexer_purge_tokens_after
	(cp_lexer *, cp_token_position);
	static void cp_lexer_save_tokens
	(cp_lexer *);
	static void cp_lexer_commit_tokens
	(cp_lexer *);
	static void cp_lexer_rollback_tokens
	(cp_lexer *);
	#ifdef ENABLE_CHECKING
	static void cp_lexer_print_token
	(FILE , cp_token );
	static inline bool cp_lexer_debugging_p
	(cp_lexer *);
	static void cp_lexer_start_debugging
	(cp_lexer *) ATTRIBUTE_UNUSED;
	static void cp_lexer_stop_debugging
	(cp_lexer *) ATTRIBUTE_UNUSED;
	#else
	/* If we define cp_lexer_debug_stream to NULL it will provoke warnings
	about passing NULL to functions that require non-NULL arguments
	(fputs, fprintf). It will never be used, so all we need is a value
	of the right type that's guaranteed not to be NULL. */
	#define cp_lexer_debug_stream stdout
	#define cp_lexer_print_token(str, tok) (void) 0
	#define cp_lexer_debugging_p(lexer) 0
	#endif /* ENABLE_CHECKING */

	static cp_token_cache *cp_token_cache_new
	(cp_token , cp_token );

	static void cp_parser_initial_pragma
	(cp_token *);

	/* Manifest constants. */
	#define CP_LEXER_BUFFER_SIZE ((256 * 1024) / sizeof (cp_token))
	#define CP_SAVED_TOKEN_STACK 5

	/* A token type for keywords, as opposed to ordinary identifiers. */
	#define CPP_KEYWORD ((enum cpp_ttype) (N_TTYPES + 1))

	/* A token type for template-ids. If a template-id is processed while
	parsing tentatively, it is replaced with a CPP_TEMPLATE_ID token;
	the value of the CPP_TEMPLATE_ID is whatever was returned by
	cp_parser_template_id. */
	#define CPP_TEMPLATE_ID ((enum cpp_ttype) (CPP_KEYWORD + 1))

	/* A token type for nested-name-specifiers. If a
	nested-name-specifier is processed while parsing tentatively, it is
	replaced with a CPP_NESTED_NAME_SPECIFIER token; the value of the
	CPP_NESTED_NAME_SPECIFIER is whatever was returned by
	cp_parser_nested_name_specifier_opt. */
	#define CPP_NESTED_NAME_SPECIFIER ((enum cpp_ttype) (CPP_TEMPLATE_ID + 1))

	/* A token type for tokens that are not tokens at all; these are used
	to represent slots in the array where there used to be a token
	that has now been deleted. */
	#define CPP_PURGED ((enum cpp_ttype) (CPP_NESTED_NAME_SPECIFIER + 1))

	/* The number of token types, including C++-specific ones. */
	#define N_CP_TTYPES ((int) (CPP_PURGED + 1))

	/* Variables. */

	#ifdef ENABLE_CHECKING
	/* The stream to which debugging output should be written. */
	static FILE *cp_lexer_debug_stream;
	#endif /* ENABLE_CHECKING */

	/* Create a new main C++ lexer, the lexer that gets tokens from the
	preprocessor. */

	static cp_lexer *
	cp_lexer_new_main (void)
	{
	cp_token first_token;
	cp_lexer *lexer;
	cp_token *pos;
	size_t alloc;
	size_t space;
	cp_token *buffer;

	/* It's possible that parsing the first pragma will load a PCH file,
	which is a GC collection point. So we have to do that before
	allocating any memory. */
	cp_parser_initial_pragma (&first_token);

	/* Tell c_lex_with_flags not to merge string constants. */
	c_lex_return_raw_strings = true;

	c_common_no_more_pch ();

	/* Allocate the memory. */
	lexer = GGC_CNEW (cp_lexer);

	#ifdef ENABLE_CHECKING
	/* Initially we are not debugging. */
	lexer->debugging_p = false;
	#endif /* ENABLE_CHECKING */
	lexer->saved_tokens = VEC_alloc (cp_token_position, heap,
	CP_SAVED_TOKEN_STACK);

	/* Create the buffer. */
	alloc = CP_LEXER_BUFFER_SIZE;
	buffer = GGC_NEWVEC (cp_token, alloc);

	/* Put the first token in the buffer. */
	space = alloc;
	pos = buffer;
	*pos = first_token;

	/* Get the remaining tokens from the preprocessor. */
	while (pos->type != CPP_EOF)
	{
	pos++;
	if (!--space)
	{
	space = alloc;
	alloc *= 2;
	buffer = GGC_RESIZEVEC (cp_token, buffer, alloc);
	pos = buffer + space;
	}
	cp_lexer_get_preprocessor_token (lexer, pos);
	}
	lexer->buffer = buffer;
	lexer->buffer_length = alloc - space;
	lexer->last_token = pos;
	lexer->next_token = lexer->buffer_length ? buffer : (cp_token *)&eof_token;

	/* Subsequent preprocessor diagnostics should use compiler
	diagnostic functions to get the compiler source location. */
	cpp_get_options (parse_in)->client_diagnostic = true;
	cpp_get_callbacks (parse_in)->error = cp_cpp_error;

	gcc_assert (lexer->next_token->type != CPP_PURGED);
	return lexer;
	}

	/* Create a new lexer whose token stream is primed with the tokens in
	CACHE. When these tokens are exhausted, no new tokens will be read. */

	static cp_lexer *
	cp_lexer_new_from_tokens (cp_token_cache *cache)
	{
	cp_token *first = cache->first;
	cp_token *last = cache->last;
	cp_lexer *lexer = GGC_CNEW (cp_lexer);

	/* We do not own the buffer. */
	lexer->buffer = NULL;
	lexer->buffer_length = 0;
	lexer->next_token = first == last ? (cp_token *)&eof_token : first;
	lexer->last_token = last;

	lexer->saved_tokens = VEC_alloc (cp_token_position, heap,
	CP_SAVED_TOKEN_STACK);

	#ifdef ENABLE_CHECKING
	/* Initially we are not debugging. */
	lexer->debugging_p = false;
	#endif

	gcc_assert (lexer->next_token->type != CPP_PURGED);
	return lexer;
	}

	/* Frees all resources associated with LEXER. */

	static void
	cp_lexer_destroy (cp_lexer *lexer)
	{
	if (lexer->buffer)
	ggc_free (lexer->buffer);
	VEC_free (cp_token_position, heap, lexer->saved_tokens);
	ggc_free (lexer);
	}

	/* Returns nonzero if debugging information should be output. */

	#ifdef ENABLE_CHECKING

	static inline bool
	cp_lexer_debugging_p (cp_lexer *lexer)
	{
	return lexer->debugging_p;
	}

	#endif /* ENABLE_CHECKING */

	static inline cp_token_position
	cp_lexer_token_position (cp_lexer *lexer, bool previous_p)
	{
	gcc_assert (!previous_p \|\| lexer->next_token != &eof_token);

	return lexer->next_token - previous_p;
	}

	static inline cp_token *
	cp_lexer_token_at (cp_lexer *lexer ATTRIBUTE_UNUSED, cp_token_position pos)
	{
	return pos;
	}

	/* nonzero if we are presently saving tokens. */

	static inline int
	cp_lexer_saving_tokens (const cp_lexer* lexer)
	{
	return VEC_length (cp_token_position, lexer->saved_tokens) != 0;
	}

	/* Store the next token from the preprocessor in *TOKEN. Return true
	if we reach EOF. */

	static void
	cp_lexer_get_preprocessor_token (cp_lexer *lexer ATTRIBUTE_UNUSED ,
	cp_token *token)
	{
	static int is_extern_c = 0;

	/* Get a new token from the preprocessor. */
	token->type
	= c_lex_with_flags (&token->u.value, &token->location, &token->flags);
	token->input_file_stack_index = input_file_stack_tick;
	token->keyword = RID_MAX;
	token->pragma_kind = PRAGMA_NONE;
	token->in_system_header = in_system_header;

	/* On some systems, some header files are surrounded by an
	implicit extern "C" block. Set a flag in the token if it
	comes from such a header. */
	is_extern_c += pending_lang_change;
	pending_lang_change = 0;
	token->implicit_extern_c = is_extern_c > 0;

	/* Check to see if this token is a keyword. */
	if (token->type == CPP_NAME)
	{
	if (C_IS_RESERVED_WORD (token->u.value))
	{
	/* Mark this token as a keyword. */
	token->type = CPP_KEYWORD;
	/* Record which keyword. */
	token->keyword = C_RID_CODE (token->u.value);
	/* Update the value. Some keywords are mapped to particular
	entities, rather than simply having the value of the
	corresponding IDENTIFIER_NODE. For example, `__const' is
	mapped to `const'. */
	token->u.value = ridpointers[token->keyword];
	}
	else
	{
	token->ambiguous_p = false;
	token->keyword = RID_MAX;
	}
	}
	/* Handle Objective-C++ keywords. */
	else if (token->type == CPP_AT_NAME)
	{
	token->type = CPP_KEYWORD;
	switch (C_RID_CODE (token->u.value))
	{
	/* Map 'class' to '@class', 'private' to '@private', etc. */
	case RID_CLASS: token->keyword = RID_AT_CLASS; break;
	case RID_PRIVATE: token->keyword = RID_AT_PRIVATE; break;
	case RID_PROTECTED: token->keyword = RID_AT_PROTECTED; break;
	case RID_PUBLIC: token->keyword = RID_AT_PUBLIC; break;
	case RID_THROW: token->keyword = RID_AT_THROW; break;
	case RID_TRY: token->keyword = RID_AT_TRY; break;
	case RID_CATCH: token->keyword = RID_AT_CATCH; break;
	default: token->keyword = C_RID_CODE (token->u.value);
	}
	}
	else if (token->type == CPP_PRAGMA)
	{
	/* We smuggled the cpp_token->u.pragma value in an INTEGER_CST. */
	token->pragma_kind = TREE_INT_CST_LOW (token->u.value);
	token->u.value = NULL_TREE;
	}
	}

	/* Update the globals input_location and in_system_header and the
	input file stack from TOKEN. */
	static inline void
	cp_lexer_set_source_position_from_token (cp_token *token)
	{
	if (token->type != CPP_EOF)
	{
	input_location = token->location;
	in_system_header = token->in_system_header;
	restore_input_file_stack (token->input_file_stack_index);
	}
	}

	/* Return a pointer to the next token in the token stream, but do not
	consume it. */

	static inline cp_token *
	cp_lexer_peek_token (cp_lexer *lexer)
	{
	if (cp_lexer_debugging_p (lexer))
	{
	fputs ("cp_lexer: peeking at token: ", cp_lexer_debug_stream);
	cp_lexer_print_token (cp_lexer_debug_stream, lexer->next_token);
	putc ('\n', cp_lexer_debug_stream);
	}
	return lexer->next_token;
	}

	/* Return true if the next token has the indicated TYPE. */

	static inline bool
	cp_lexer_next_token_is (cp_lexer* lexer, enum cpp_ttype type)
	{
	return cp_lexer_peek_token (lexer)->type == type;
	}

	/* Return true if the next token does not have the indicated TYPE. */

	static inline bool
	cp_lexer_next_token_is_not (cp_lexer* lexer, enum cpp_ttype type)
	{
	return !cp_lexer_next_token_is (lexer, type);
	}

	/* Return true if the next token is the indicated KEYWORD. */

	static inline bool
	cp_lexer_next_token_is_keyword (cp_lexer* lexer, enum rid keyword)
	{
	return cp_lexer_peek_token (lexer)->keyword == keyword;
	}

	/* Return true if the next token is a keyword for a decl-specifier. */

	static bool
	cp_lexer_next_token_is_decl_specifier_keyword (cp_lexer *lexer)
	{
	cp_token *token;

	token = cp_lexer_peek_token (lexer);
	switch (token->keyword)
	{
	/* Storage classes. */
	case RID_AUTO:
	case RID_REGISTER:
	case RID_STATIC:
	case RID_EXTERN:
	case RID_MUTABLE:
	case RID_THREAD:
	/* Elaborated type specifiers. */
	case RID_ENUM:
	case RID_CLASS:
	case RID_STRUCT:
	case RID_UNION:
	case RID_TYPENAME:
	/* Simple type specifiers. */
	case RID_CHAR:
	case RID_WCHAR:
	case RID_BOOL:
	case RID_SHORT:
	case RID_INT:
	case RID_LONG:
	case RID_SIGNED:
	case RID_UNSIGNED:
	case RID_FLOAT:
	case RID_DOUBLE:
	case RID_VOID:
	/* GNU extensions. */
	case RID_ATTRIBUTE:
	case RID_TYPEOF:
	return true;

	default:
	return false;
	}
	}

	/* Return a pointer to the Nth token in the token stream. If N is 1,
	then this is precisely equivalent to cp_lexer_peek_token (except
	that it is not inline). One would like to disallow that case, but
	there is one case (cp_parser_nth_token_starts_template_id) where
	the caller passes a variable for N and it might be 1. */

	static cp_token *
	cp_lexer_peek_nth_token (cp_lexer* lexer, size_t n)
	{
	cp_token *token;

	/* N is 1-based, not zero-based. */
	gcc_assert (n > 0);

	if (cp_lexer_debugging_p (lexer))
	fprintf (cp_lexer_debug_stream,
	"cp_lexer: peeking ahead %ld at token: ", (long)n);

	--n;
	token = lexer->next_token;
	gcc_assert (!n \|\| token != &eof_token);
	while (n != 0)
	{
	++token;
	if (token == lexer->last_token)
	{
	token = (cp_token *)&eof_token;
	break;
	}

	if (token->type != CPP_PURGED)
	--n;
	}

	if (cp_lexer_debugging_p (lexer))
	{
	cp_lexer_print_token (cp_lexer_debug_stream, token);
	putc ('\n', cp_lexer_debug_stream);
	}

	return token;
	}

	/* Return the next token, and advance the lexer's next_token pointer
	to point to the next non-purged token. */

	static cp_token *
	cp_lexer_consume_token (cp_lexer* lexer)
	{
	cp_token *token = lexer->next_token;

	gcc_assert (token != &eof_token);
	gcc_assert (!lexer->in_pragma \|\| token->type != CPP_PRAGMA_EOL);

	do
	{
	lexer->next_token++;
	if (lexer->next_token == lexer->last_token)
	{
	lexer->next_token = (cp_token *)&eof_token;
	break;
	}

	}
	while (lexer->next_token->type == CPP_PURGED);

	cp_lexer_set_source_position_from_token (token);

	/* Provide debugging output. */
	if (cp_lexer_debugging_p (lexer))
	{
	fputs ("cp_lexer: consuming token: ", cp_lexer_debug_stream);
	cp_lexer_print_token (cp_lexer_debug_stream, token);
	putc ('\n', cp_lexer_debug_stream);
	}

	return token;
	}

	/* Permanently remove the next token from the token stream, and
	advance the next_token pointer to refer to the next non-purged
	token. */

	static void
	cp_lexer_purge_token (cp_lexer *lexer)
	{
	cp_token *tok = lexer->next_token;

	gcc_assert (tok != &eof_token);
	tok->type = CPP_PURGED;
	tok->location = UNKNOWN_LOCATION;
	tok->u.value = NULL_TREE;
	tok->keyword = RID_MAX;

	do
	{
	tok++;
	if (tok == lexer->last_token)
	{
	tok = (cp_token *)&eof_token;
	break;
	}
	}
	while (tok->type == CPP_PURGED);
	lexer->next_token = tok;
	}

	/* Permanently remove all tokens after TOK, up to, but not
	including, the token that will be returned next by
	cp_lexer_peek_token. */

	static void
	cp_lexer_purge_tokens_after (cp_lexer lexer, cp_token tok)
	{
	cp_token *peek = lexer->next_token;

	if (peek == &eof_token)
	peek = lexer->last_token;

	gcc_assert (tok < peek);

	for ( tok += 1; tok != peek; tok += 1)
	{
	tok->type = CPP_PURGED;
	tok->location = UNKNOWN_LOCATION;
	tok->u.value = NULL_TREE;
	tok->keyword = RID_MAX;
	}
	}

	/* Begin saving tokens. All tokens consumed after this point will be
	preserved. */

	static void
	cp_lexer_save_tokens (cp_lexer* lexer)
	{
	/* Provide debugging output. */
	if (cp_lexer_debugging_p (lexer))
	fprintf (cp_lexer_debug_stream, "cp_lexer: saving tokens\n");

	VEC_safe_push (cp_token_position, heap,
	lexer->saved_tokens, lexer->next_token);
	}

	/* Commit to the portion of the token stream most recently saved. */

	static void
	cp_lexer_commit_tokens (cp_lexer* lexer)
	{
	/* Provide debugging output. */
	if (cp_lexer_debugging_p (lexer))
	fprintf (cp_lexer_debug_stream, "cp_lexer: committing tokens\n");

	VEC_pop (cp_token_position, lexer->saved_tokens);
	}

	/* Return all tokens saved since the last call to cp_lexer_save_tokens
	to the token stream. Stop saving tokens. */

	static void
	cp_lexer_rollback_tokens (cp_lexer* lexer)
	{
	/* Provide debugging output. */
	if (cp_lexer_debugging_p (lexer))
	fprintf (cp_lexer_debug_stream, "cp_lexer: restoring tokens\n");

	lexer->next_token = VEC_pop (cp_token_position, lexer->saved_tokens);
	}

	/* Print a representation of the TOKEN on the STREAM. */

	#ifdef ENABLE_CHECKING

	static void
	cp_lexer_print_token (FILE * stream, cp_token *token)
	{
	/* We don't use cpp_type2name here because the parser defines
	a few tokens of its own. */
	static const char *const token_names[] = {
	/* cpplib-defined token types */
	#define OP(e, s) #e,
	#define TK(e, s) #e,
	TTYPE_TABLE
	#undef OP
	#undef TK
	/* C++ parser token types - see "Manifest constants", above. */
	"KEYWORD",
	"TEMPLATE_ID",
	"NESTED_NAME_SPECIFIER",
	"PURGED"
	};

	/* If we have a name for the token, print it out. Otherwise, we
	simply give the numeric code. */
	gcc_assert (token->type < ARRAY_SIZE(token_names));
	fputs (token_names[token->type], stream);

	/* For some tokens, print the associated data. */
	switch (token->type)
	{
	case CPP_KEYWORD:
	/* Some keywords have a value that is not an IDENTIFIER_NODE.
	For example, `struct' is mapped to an INTEGER_CST. */
	if (TREE_CODE (token->u.value) != IDENTIFIER_NODE)
	break;
	/* else fall through */
	case CPP_NAME:
	fputs (IDENTIFIER_POINTER (token->u.value), stream);
	break;

	case CPP_STRING:
	case CPP_WSTRING:
	fprintf (stream, " \"%s\"", TREE_STRING_POINTER (token->u.value));
	break;

	default:
	break;
	}
	}

	/* Start emitting debugging information. */

	static void
	cp_lexer_start_debugging (cp_lexer* lexer)
	{
	lexer->debugging_p = true;
	}

	/* Stop emitting debugging information. */

	static void
	cp_lexer_stop_debugging (cp_lexer* lexer)
	{
	lexer->debugging_p = false;
	}

	#endif /* ENABLE_CHECKING */

	/* Create a new cp_token_cache, representing a range of tokens. */

	static cp_token_cache *
	cp_token_cache_new (cp_token first, cp_token last)
	{
	cp_token_cache *cache = GGC_NEW (cp_token_cache);
	cache->first = first;
	cache->last = last;
	return cache;
	}


	/* Decl-specifiers. */

	/* Set DECL_SPECS to represent an empty decl-specifier-seq. /

	static void
	clear_decl_specs (cp_decl_specifier_seq *decl_specs)
	{
	memset (decl_specs, 0, sizeof (cp_decl_specifier_seq));
	}

	/* Declarators. */

	/* Nothing other than the parser should be creating declarators;
	declarators are a semi-syntactic representation of C++ entities.
	Other parts of the front end that need to create entities (like
	VAR_DECLs or FUNCTION_DECLs) should do that directly. */

	static cp_declarator *make_call_declarator
	(cp_declarator , cp_parameter_declarator , cp_cv_quals, tree);
	static cp_declarator *make_array_declarator
	(cp_declarator *, tree);
	static cp_declarator *make_pointer_declarator
	(cp_cv_quals, cp_declarator *);
	static cp_declarator *make_reference_declarator
	(cp_cv_quals, cp_declarator *);
	static cp_parameter_declarator *make_parameter_declarator
	(cp_decl_specifier_seq , cp_declarator , tree);
	static cp_declarator *make_ptrmem_declarator
	(cp_cv_quals, tree, cp_declarator *);

	/* An erroneous declarator. */
	static cp_declarator *cp_error_declarator;

	/* The obstack on which declarators and related data structures are
	allocated. */
	static struct obstack declarator_obstack;

	/* Alloc BYTES from the declarator memory pool. */

	static inline void *
	alloc_declarator (size_t bytes)
	{
	return obstack_alloc (&declarator_obstack, bytes);
	}

	/* Allocate a declarator of the indicated KIND. Clear fields that are
	common to all declarators. */

	static cp_declarator *
	make_declarator (cp_declarator_kind kind)
	{
	cp_declarator *declarator;

	declarator = (cp_declarator *) alloc_declarator (sizeof (cp_declarator));
	declarator->kind = kind;
	declarator->attributes = NULL_TREE;
	declarator->declarator = NULL;

	return declarator;
	}

	/* Make a declarator for a generalized identifier. If
	QUALIFYING_SCOPE is non-NULL, the identifier is
	QUALIFYING_SCOPE::UNQUALIFIED_NAME; otherwise, it is just
	UNQUALIFIED_NAME. SFK indicates the kind of special function this
	is, if any. */

	static cp_declarator *
	make_id_declarator (tree qualifying_scope, tree unqualified_name,
	special_function_kind sfk)
	{
	cp_declarator *declarator;

	/* It is valid to write:

	class C { void f(); };
	typedef C D;
	void D::f();

	The standard is not clear about whether `typedef const C D' is
	legal; as of 2002-09-15 the committee is considering that
	question. EDG 3.0 allows that syntax. Therefore, we do as
	well. */
	if (qualifying_scope && TYPE_P (qualifying_scope))
	qualifying_scope = TYPE_MAIN_VARIANT (qualifying_scope);

	gcc_assert (TREE_CODE (unqualified_name) == IDENTIFIER_NODE
	\|\| TREE_CODE (unqualified_name) == BIT_NOT_EXPR
	\|\| TREE_CODE (unqualified_name) == TEMPLATE_ID_EXPR);

	declarator = make_declarator (cdk_id);
	declarator->u.id.qualifying_scope = qualifying_scope;
	declarator->u.id.unqualified_name = unqualified_name;
	declarator->u.id.sfk = sfk;

	return declarator;
	}

	/* Make a declarator for a pointer to TARGET. CV_QUALIFIERS is a list
	of modifiers such as const or volatile to apply to the pointer
	type, represented as identifiers. */

	cp_declarator *
	make_pointer_declarator (cp_cv_quals cv_qualifiers, cp_declarator *target)
	{
	cp_declarator *declarator;

	declarator = make_declarator (cdk_pointer);
	declarator->declarator = target;
	declarator->u.pointer.qualifiers = cv_qualifiers;
	declarator->u.pointer.class_type = NULL_TREE;

	return declarator;
	}

	/* Like make_pointer_declarator -- but for references. */

	cp_declarator *
	make_reference_declarator (cp_cv_quals cv_qualifiers, cp_declarator *target)
	{
	cp_declarator *declarator;

	declarator = make_declarator (cdk_reference);
	declarator->declarator = target;
	declarator->u.pointer.qualifiers = cv_qualifiers;
	declarator->u.pointer.class_type = NULL_TREE;

	return declarator;
	}

	/* Like make_pointer_declarator -- but for a pointer to a non-static
	member of CLASS_TYPE. */

	cp_declarator *
	make_ptrmem_declarator (cp_cv_quals cv_qualifiers, tree class_type,
	cp_declarator *pointee)
	{
	cp_declarator *declarator;

	declarator = make_declarator (cdk_ptrmem);
	declarator->declarator = pointee;
	declarator->u.pointer.qualifiers = cv_qualifiers;
	declarator->u.pointer.class_type = class_type;

	return declarator;
	}

	/* Make a declarator for the function given by TARGET, with the
	indicated PARMS. The CV_QUALIFIERS aply to the function, as in
	"const"-qualified member function. The EXCEPTION_SPECIFICATION
	indicates what exceptions can be thrown. */

	cp_declarator *
	make_call_declarator (cp_declarator *target,
	cp_parameter_declarator *parms,
	cp_cv_quals cv_qualifiers,
	tree exception_specification)
	{
	cp_declarator *declarator;

	declarator = make_declarator (cdk_function);
	declarator->declarator = target;
	declarator->u.function.parameters = parms;
	declarator->u.function.qualifiers = cv_qualifiers;
	declarator->u.function.exception_specification = exception_specification;

	return declarator;
	}

	/* Make a declarator for an array of BOUNDS elements, each of which is
	defined by ELEMENT. */

	cp_declarator *
	make_array_declarator (cp_declarator *element, tree bounds)
	{
	cp_declarator *declarator;

	declarator = make_declarator (cdk_array);
	declarator->declarator = element;
	declarator->u.array.bounds = bounds;

	return declarator;
	}

	cp_parameter_declarator *no_parameters;

	/* Create a parameter declarator with the indicated DECL_SPECIFIERS,
	DECLARATOR and DEFAULT_ARGUMENT. */

	cp_parameter_declarator *
	make_parameter_declarator (cp_decl_specifier_seq *decl_specifiers,
	cp_declarator *declarator,
	tree default_argument)
	{
	cp_parameter_declarator *parameter;

	parameter = ((cp_parameter_declarator *)
	alloc_declarator (sizeof (cp_parameter_declarator)));
	parameter->next = NULL;
	if (decl_specifiers)
	parameter->decl_specifiers = *decl_specifiers;
	else
	clear_decl_specs (&parameter->decl_specifiers);
	parameter->declarator = declarator;
	parameter->default_argument = default_argument;
	parameter->ellipsis_p = false;

	return parameter;
	}

	/* Returns true iff DECLARATOR is a declaration for a function. */

	static bool
	function_declarator_p (const cp_declarator *declarator)
	{
	while (declarator)
	{
	if (declarator->kind == cdk_function
	&& declarator->declarator->kind == cdk_id)
	return true;
	if (declarator->kind == cdk_id
	\|\| declarator->kind == cdk_error)
	return false;
	declarator = declarator->declarator;
	}
	return false;
	}

	/* The parser. */

	/* Overview
	--------

	A cp_parser parses the token stream as specified by the C++
	grammar. Its job is purely parsing, not semantic analysis. For
	example, the parser breaks the token stream into declarators,
	expressions, statements, and other similar syntactic constructs.
	It does not check that the types of the expressions on either side
	of an assignment-statement are compatible, or that a function is
	not declared with a parameter of type `void'.

	The parser invokes routines elsewhere in the compiler to perform
	semantic analysis and to build up the abstract syntax tree for the
	code processed.

	The parser (and the template instantiation code, which is, in a
	way, a close relative of parsing) are the only parts of the
	compiler that should be calling push_scope and pop_scope, or
	related functions. The parser (and template instantiation code)
	keeps track of what scope is presently active; everything else
	should simply honor that. (The code that generates static
	initializers may also need to set the scope, in order to check
	access control correctly when emitting the initializers.)

	Methodology
	-----------

	The parser is of the standard recursive-descent variety. Upcoming
	tokens in the token stream are examined in order to determine which
	production to use when parsing a non-terminal. Some C++ constructs
	require arbitrary look ahead to disambiguate. For example, it is
	impossible, in the general case, to tell whether a statement is an
	expression or declaration without scanning the entire statement.
	Therefore, the parser is capable of "parsing tentatively." When the
	parser is not sure what construct comes next, it enters this mode.
	Then, while we attempt to parse the construct, the parser queues up
	error messages, rather than issuing them immediately, and saves the
	tokens it consumes. If the construct is parsed successfully, the
	parser "commits", i.e., it issues any queued error messages and
	the tokens that were being preserved are permanently discarded.
	If, however, the construct is not parsed successfully, the parser
	rolls back its state completely so that it can resume parsing using
	a different alternative.

	Future Improvements
	-------------------

	The performance of the parser could probably be improved substantially.
	We could often eliminate the need to parse tentatively by looking ahead
	a little bit. In some places, this approach might not entirely eliminate
	the need to parse tentatively, but it might still speed up the average
	case. */

	/* Flags that are passed to some parsing functions. These values can
	be bitwise-ored together. */

	typedef enum cp_parser_flags
	{
	/* No flags. */
	CP_PARSER_FLAGS_NONE = 0x0,
	/* The construct is optional. If it is not present, then no error
	should be issued. */
	CP_PARSER_FLAGS_OPTIONAL = 0x1,
	/* When parsing a type-specifier, do not allow user-defined types. */
	CP_PARSER_FLAGS_NO_USER_DEFINED_TYPES = 0x2
	} cp_parser_flags;

	/* The different kinds of declarators we want to parse. */

	typedef enum cp_parser_declarator_kind
	{
	/* We want an abstract declarator. */
	CP_PARSER_DECLARATOR_ABSTRACT,
	/* We want a named declarator. */
	CP_PARSER_DECLARATOR_NAMED,
	/* We don't mind, but the name must be an unqualified-id. */
	CP_PARSER_DECLARATOR_EITHER
	} cp_parser_declarator_kind;

	/* The precedence values used to parse binary expressions. The minimum value
	of PREC must be 1, because zero is reserved to quickly discriminate
	binary operators from other tokens. */

	enum cp_parser_prec
	{
	PREC_NOT_OPERATOR,
	PREC_LOGICAL_OR_EXPRESSION,
	PREC_LOGICAL_AND_EXPRESSION,
	PREC_INCLUSIVE_OR_EXPRESSION,
	PREC_EXCLUSIVE_OR_EXPRESSION,
	PREC_AND_EXPRESSION,
	PREC_EQUALITY_EXPRESSION,
	PREC_RELATIONAL_EXPRESSION,
	PREC_SHIFT_EXPRESSION,
	PREC_ADDITIVE_EXPRESSION,
	PREC_MULTIPLICATIVE_EXPRESSION,
	PREC_PM_EXPRESSION,
	NUM_PREC_VALUES = PREC_PM_EXPRESSION
	};

	/* A mapping from a token type to a corresponding tree node type, with a
	precedence value. */

	typedef struct cp_parser_binary_operations_map_node
	{
	/* The token type. */
	enum cpp_ttype token_type;
	/* The corresponding tree code. */
	enum tree_code tree_type;
	/* The precedence of this operator. */
	enum cp_parser_prec prec;
	} cp_parser_binary_operations_map_node;

	/* The status of a tentative parse. */

	typedef enum cp_parser_status_kind
	{
	/* No errors have occurred. */
	CP_PARSER_STATUS_KIND_NO_ERROR,
	/* An error has occurred. */
	CP_PARSER_STATUS_KIND_ERROR,
	/* We are committed to this tentative parse, whether or not an error
	has occurred. */
	CP_PARSER_STATUS_KIND_COMMITTED
	} cp_parser_status_kind;

	typedef struct cp_parser_expression_stack_entry
	{
	/* Left hand side of the binary operation we are currently
	parsing. */
	tree lhs;
	/* Original tree code for left hand side, if it was a binary
	expression itself (used for -Wparentheses). */
	enum tree_code lhs_type;
	/* Tree code for the binary operation we are parsing. */
	enum tree_code tree_type;
	/* Precedence of the binary operation we are parsing. */
	int prec;
	} cp_parser_expression_stack_entry;

	/* The stack for storing partial expressions. We only need NUM_PREC_VALUES
	entries because precedence levels on the stack are monotonically
	increasing. */
	typedef struct cp_parser_expression_stack_entry
	cp_parser_expression_stack[NUM_PREC_VALUES];

	/* Context that is saved and restored when parsing tentatively. */
	typedef struct cp_parser_context GTY (())
	{
	/* If this is a tentative parsing context, the status of the
	tentative parse. */
	enum cp_parser_status_kind status;
	/* If non-NULL, we have just seen a `x->' or `x.' expression. Names
	that are looked up in this context must be looked up both in the
	scope given by OBJECT_TYPE (the type of `x' or `*x') and also in
	the context of the containing expression. */
	tree object_type;

	/* The next parsing context in the stack. */
	struct cp_parser_context *next;
	} cp_parser_context;

	/* Prototypes. */

	/* Constructors and destructors. */

	static cp_parser_context *cp_parser_context_new
	(cp_parser_context *);

	/* Class variables. */

	static GTY((deletable)) cp_parser_context* cp_parser_context_free_list;

	/* The operator-precedence table used by cp_parser_binary_expression.
	Transformed into an associative array (binops_by_token) by
	cp_parser_new. */

	static const cp_parser_binary_operations_map_node binops[] = {
	{ CPP_DEREF_STAR, MEMBER_REF, PREC_PM_EXPRESSION },
	{ CPP_DOT_STAR, DOTSTAR_EXPR, PREC_PM_EXPRESSION },

	{ CPP_MULT, MULT_EXPR, PREC_MULTIPLICATIVE_EXPRESSION },
	{ CPP_DIV, TRUNC_DIV_EXPR, PREC_MULTIPLICATIVE_EXPRESSION },
	{ CPP_MOD, TRUNC_MOD_EXPR, PREC_MULTIPLICATIVE_EXPRESSION },

	{ CPP_PLUS, PLUS_EXPR, PREC_ADDITIVE_EXPRESSION },
	{ CPP_MINUS, MINUS_EXPR, PREC_ADDITIVE_EXPRESSION },

	{ CPP_LSHIFT, LSHIFT_EXPR, PREC_SHIFT_EXPRESSION },
	{ CPP_RSHIFT, RSHIFT_EXPR, PREC_SHIFT_EXPRESSION },

	{ CPP_LESS, LT_EXPR, PREC_RELATIONAL_EXPRESSION },
	{ CPP_GREATER, GT_EXPR, PREC_RELATIONAL_EXPRESSION },
	{ CPP_LESS_EQ, LE_EXPR, PREC_RELATIONAL_EXPRESSION },
	{ CPP_GREATER_EQ, GE_EXPR, PREC_RELATIONAL_EXPRESSION },

	{ CPP_EQ_EQ, EQ_EXPR, PREC_EQUALITY_EXPRESSION },
	{ CPP_NOT_EQ, NE_EXPR, PREC_EQUALITY_EXPRESSION },

	{ CPP_AND, BIT_AND_EXPR, PREC_AND_EXPRESSION },

	{ CPP_XOR, BIT_XOR_EXPR, PREC_EXCLUSIVE_OR_EXPRESSION },

	{ CPP_OR, BIT_IOR_EXPR, PREC_INCLUSIVE_OR_EXPRESSION },

	{ CPP_AND_AND, TRUTH_ANDIF_EXPR, PREC_LOGICAL_AND_EXPRESSION },

	{ CPP_OR_OR, TRUTH_ORIF_EXPR, PREC_LOGICAL_OR_EXPRESSION }
	};

	/* The same as binops, but initialized by cp_parser_new so that
	binops_by_token[N].token_type == N. Used in cp_parser_binary_expression
	for speed. */
	static cp_parser_binary_operations_map_node binops_by_token[N_CP_TTYPES];

	/* Constructors and destructors. */

	/* Construct a new context. The context below this one on the stack
	is given by NEXT. */

	static cp_parser_context *
	cp_parser_context_new (cp_parser_context* next)
	{
	cp_parser_context *context;

	/* Allocate the storage. */
	if (cp_parser_context_free_list != NULL)
	{
	/* Pull the first entry from the free list. */
	context = cp_parser_context_free_list;
	cp_parser_context_free_list = context->next;
	memset (context, 0, sizeof (*context));
	}
	else
	context = GGC_CNEW (cp_parser_context);

	/* No errors have occurred yet in this context. */
	context->status = CP_PARSER_STATUS_KIND_NO_ERROR;
	/* If this is not the bottomost context, copy information that we
	need from the previous context. */
	if (next)
	{
	/* If, in the NEXT context, we are parsing an `x->' or `x.'
	expression, then we are parsing one in this context, too. */
	context->object_type = next->object_type;
	/* Thread the stack. */
	context->next = next;
	}

	return context;
	}

	/* The cp_parser structure represents the C++ parser. */

	typedef struct cp_parser GTY(())
	{
	/* The lexer from which we are obtaining tokens. */
	cp_lexer *lexer;

	/* The scope in which names should be looked up. If NULL_TREE, then
	we look up names in the scope that is currently open in the
	source program. If non-NULL, this is either a TYPE or
	NAMESPACE_DECL for the scope in which we should look. It can
	also be ERROR_MARK, when we've parsed a bogus scope.

	This value is not cleared automatically after a name is looked
	up, so we must be careful to clear it before starting a new look
	up sequence. (If it is not cleared, then `X::Y' followed by `Z'
	will look up `Z' in the scope of `X', rather than the current
	scope.) Unfortunately, it is difficult to tell when name lookup
	is complete, because we sometimes peek at a token, look it up,
	and then decide not to consume it. */
	tree scope;

	/* OBJECT_SCOPE and QUALIFYING_SCOPE give the scopes in which the
	last lookup took place. OBJECT_SCOPE is used if an expression
	like "x->y" or "x.y" was used; it gives the type of "*x" or "x",
	respectively. QUALIFYING_SCOPE is used for an expression of the
	form "X::Y"; it refers to X. */
	tree object_scope;
	tree qualifying_scope;

	/* A stack of parsing contexts. All but the bottom entry on the
	stack will be tentative contexts.

	We parse tentatively in order to determine which construct is in
	use in some situations. For example, in order to determine
	whether a statement is an expression-statement or a
	declaration-statement we parse it tentatively as a
	declaration-statement. If that fails, we then reparse the same
	token stream as an expression-statement. */
	cp_parser_context *context;

	/* True if we are parsing GNU C++. If this flag is not set, then
	GNU extensions are not recognized. */
	bool allow_gnu_extensions_p;

	/* TRUE if the `>' token should be interpreted as the greater-than
	operator. FALSE if it is the end of a template-id or
	template-parameter-list. */
	bool greater_than_is_operator_p;

	/* TRUE if default arguments are allowed within a parameter list
	that starts at this point. FALSE if only a gnu extension makes
	them permissible. */
	bool default_arg_ok_p;

	/* TRUE if we are parsing an integral constant-expression. See
	[expr.const] for a precise definition. */
	bool integral_constant_expression_p;

	/* TRUE if we are parsing an integral constant-expression -- but a
	non-constant expression should be permitted as well. This flag
	is used when parsing an array bound so that GNU variable-length
	arrays are tolerated. */
	bool allow_non_integral_constant_expression_p;

	/* TRUE if ALLOW_NON_CONSTANT_EXPRESSION_P is TRUE and something has
	been seen that makes the expression non-constant. */
	bool non_integral_constant_expression_p;

	/* TRUE if local variable names and `this' are forbidden in the
	current context. */
	bool local_variables_forbidden_p;

	/* TRUE if the declaration we are parsing is part of a
	linkage-specification of the form `extern string-literal
	declaration'. */
	bool in_unbraced_linkage_specification_p;

	/* TRUE if we are presently parsing a declarator, after the
	direct-declarator. */
	bool in_declarator_p;

	/* TRUE if we are presently parsing a template-argument-list. */
	bool in_template_argument_list_p;

	/* Set to IN_ITERATION_STMT if parsing an iteration-statement,
	to IN_OMP_BLOCK if parsing OpenMP structured block and
	IN_OMP_FOR if parsing OpenMP loop. If parsing a switch statement,
	this is bitwise ORed with IN_SWITCH_STMT, unless parsing an
	iteration-statement, OpenMP block or loop within that switch. */
	#define IN_SWITCH_STMT 1
	#define IN_ITERATION_STMT 2
	#define IN_OMP_BLOCK 4
	#define IN_OMP_FOR 8
	unsigned char in_statement;

	/* TRUE if we are presently parsing the body of a switch statement.
	Note that this doesn't quite overlap with in_statement above.
	The difference relates to giving the right sets of error messages:
	"case not in switch" vs "break statement used with OpenMP...". */
	bool in_switch_statement_p;

	/* TRUE if we are parsing a type-id in an expression context. In
	such a situation, both "type (expr)" and "type (type)" are valid
	alternatives. */
	bool in_type_id_in_expr_p;

	/* TRUE if we are currently in a header file where declarations are
	implicitly extern "C". */
	bool implicit_extern_c;

	/* TRUE if strings in expressions should be translated to the execution
	character set. */
	bool translate_strings_p;

	/* TRUE if we are presently parsing the body of a function, but not
	a local class. */
	bool in_function_body;

	/* If non-NULL, then we are parsing a construct where new type
	definitions are not permitted. The string stored here will be
	issued as an error message if a type is defined. */
	const char *type_definition_forbidden_message;

	/* A list of lists. The outer list is a stack, used for member
	functions of local classes. At each level there are two sub-list,
	one on TREE_VALUE and one on TREE_PURPOSE. Each of those
	sub-lists has a FUNCTION_DECL or TEMPLATE_DECL on their
	TREE_VALUE's. The functions are chained in reverse declaration
	order.

	The TREE_PURPOSE sublist contains those functions with default
	arguments that need post processing, and the TREE_VALUE sublist
	contains those functions with definitions that need post
	processing.

	These lists can only be processed once the outermost class being
	defined is complete. */
	tree unparsed_functions_queues;

	/* The number of classes whose definitions are currently in
	progress. */
	unsigned num_classes_being_defined;

	/* The number of template parameter lists that apply directly to the
	current declaration. */
	unsigned num_template_parameter_lists;
	} cp_parser;

	/* Prototypes. */

	/* Constructors and destructors. */

	static cp_parser *cp_parser_new
	(void);

	/* Routines to parse various constructs.

	Those that return `tree' will return the error_mark_node (rather
	than NULL_TREE) if a parse error occurs, unless otherwise noted.
	Sometimes, they will return an ordinary node if error-recovery was
	attempted, even though a parse error occurred. So, to check
	whether or not a parse error occurred, you should always use
	cp_parser_error_occurred. If the construct is optional (indicated
	either by an `_opt' in the name of the function that does the
	parsing or via a FLAGS parameter), then NULL_TREE is returned if
	the construct is not present. */

	/* Lexical conventions [gram.lex] */

	static tree cp_parser_identifier
	(cp_parser *);
	static tree cp_parser_string_literal
	(cp_parser *, bool, bool);

	/* Basic concepts [gram.basic] */

	static bool cp_parser_translation_unit
	(cp_parser *);

	/* Expressions [gram.expr] */

	static tree cp_parser_primary_expression
	(cp_parser , bool, bool, bool, cp_id_kind );
	static tree cp_parser_id_expression
	(cp_parser , bool, bool, bool , bool, bool);
	static tree cp_parser_unqualified_id
	(cp_parser *, bool, bool, bool, bool);
	static tree cp_parser_nested_name_specifier_opt
	(cp_parser *, bool, bool, bool, bool);
	static tree cp_parser_nested_name_specifier
	(cp_parser *, bool, bool, bool, bool);
	static tree cp_parser_class_or_namespace_name
	(cp_parser *, bool, bool, bool, bool, bool);
	static tree cp_parser_postfix_expression
	(cp_parser *, bool, bool);
	static tree cp_parser_postfix_open_square_expression
	(cp_parser *, tree, bool);
	static tree cp_parser_postfix_dot_deref_expression
	(cp_parser , enum cpp_ttype, tree, bool, cp_id_kind );
	static tree cp_parser_parenthesized_expression_list
	(cp_parser , bool, bool, bool );
	static void cp_parser_pseudo_destructor_name
	(cp_parser , tree , tree *);
	static tree cp_parser_unary_expression
	(cp_parser *, bool, bool);
	static enum tree_code cp_parser_unary_operator
	(cp_token *);
	static tree cp_parser_new_expression
	(cp_parser *);
	static tree cp_parser_new_placement
	(cp_parser *);
	static tree cp_parser_new_type_id
	(cp_parser , tree );
	static cp_declarator *cp_parser_new_declarator_opt
	(cp_parser *);
	static cp_declarator *cp_parser_direct_new_declarator
	(cp_parser *);
	static tree cp_parser_new_initializer
	(cp_parser *);
	static tree cp_parser_delete_expression
	(cp_parser *);
	static tree cp_parser_cast_expression
	(cp_parser *, bool, bool);
	static tree cp_parser_binary_expression
	(cp_parser *, bool);
	static tree cp_parser_question_colon_clause
	(cp_parser *, tree);
	static tree cp_parser_assignment_expression
	(cp_parser *, bool);
	static enum tree_code cp_parser_assignment_operator_opt
	(cp_parser *);
	static tree cp_parser_expression
	(cp_parser *, bool);
	static tree cp_parser_constant_expression
	(cp_parser , bool, bool );
	static tree cp_parser_builtin_offsetof
	(cp_parser *);

	/* Statements [gram.stmt.stmt] */

	static void cp_parser_statement
	(cp_parser , tree, bool, bool );
	static void cp_parser_label_for_labeled_statement
	(cp_parser *);
	static tree cp_parser_expression_statement
	(cp_parser *, tree);
	static tree cp_parser_compound_statement
	(cp_parser *, tree, bool);
	static void cp_parser_statement_seq_opt
	(cp_parser *, tree);
	static tree cp_parser_selection_statement
	(cp_parser , bool );
	static tree cp_parser_condition
	(cp_parser *);
	static tree cp_parser_iteration_statement
	(cp_parser *);
	static void cp_parser_for_init_statement
	(cp_parser *);
	static tree cp_parser_jump_statement
	(cp_parser *);
	static void cp_parser_declaration_statement
	(cp_parser *);

	static tree cp_parser_implicitly_scoped_statement
	(cp_parser , bool );
	static void cp_parser_already_scoped_statement
	(cp_parser *);

	/* Declarations [gram.dcl.dcl] */

	static void cp_parser_declaration_seq_opt
	(cp_parser *);
	static void cp_parser_declaration
	(cp_parser *);
	static void cp_parser_block_declaration
	(cp_parser *, bool);
	static void cp_parser_simple_declaration
	(cp_parser *, bool);
	static void cp_parser_decl_specifier_seq
	(cp_parser , cp_parser_flags, cp_decl_specifier_seq , int *);
	static tree cp_parser_storage_class_specifier_opt
	(cp_parser *);
	static tree cp_parser_function_specifier_opt
	(cp_parser , cp_decl_specifier_seq );
	static tree cp_parser_type_specifier
	(cp_parser , cp_parser_flags, cp_decl_specifier_seq , bool,
	int , bool );
	static tree cp_parser_simple_type_specifier
	(cp_parser , cp_decl_specifier_seq , cp_parser_flags);
	static tree cp_parser_type_name
	(cp_parser *);
	static tree cp_parser_elaborated_type_specifier
	(cp_parser *, bool, bool);
	static tree cp_parser_enum_specifier
	(cp_parser *);
	static void cp_parser_enumerator_list
	(cp_parser *, tree);
	static void cp_parser_enumerator_definition
	(cp_parser *, tree);
	static tree cp_parser_namespace_name
	(cp_parser *);
	static void cp_parser_namespace_definition
	(cp_parser *);
	static void cp_parser_namespace_body
	(cp_parser *);
	static tree cp_parser_qualified_namespace_specifier
	(cp_parser *);
	static void cp_parser_namespace_alias_definition
	(cp_parser *);
	static bool cp_parser_using_declaration
	(cp_parser *, bool);
	static void cp_parser_using_directive
	(cp_parser *);
	static void cp_parser_asm_definition
	(cp_parser *);
	static void cp_parser_linkage_specification
	(cp_parser *);

	/* Declarators [gram.dcl.decl] */

	static tree cp_parser_init_declarator
	(cp_parser , cp_decl_specifier_seq , VEC (deferred_access_check,gc), bool, bool, int, bool );
	static cp_declarator *cp_parser_declarator
	(cp_parser , cp_parser_declarator_kind, int , bool *, bool);
	static cp_declarator *cp_parser_direct_declarator
	(cp_parser , cp_parser_declarator_kind, int , bool);
	static enum tree_code cp_parser_ptr_operator
	(cp_parser , tree , cp_cv_quals *);
	static cp_cv_quals cp_parser_cv_qualifier_seq_opt
	(cp_parser *);
	static tree cp_parser_declarator_id
	(cp_parser *, bool);
	static tree cp_parser_type_id
	(cp_parser *);
	static void cp_parser_type_specifier_seq
	(cp_parser , bool, cp_decl_specifier_seq );
	static cp_parameter_declarator *cp_parser_parameter_declaration_clause
	(cp_parser *);
	static cp_parameter_declarator *cp_parser_parameter_declaration_list
	(cp_parser , bool );
	static cp_parameter_declarator *cp_parser_parameter_declaration
	(cp_parser , bool, bool );
	static void cp_parser_function_body
	(cp_parser *);
	static tree cp_parser_initializer
	(cp_parser , bool , bool *);
	static tree cp_parser_initializer_clause
	(cp_parser , bool );
	static VEC(constructor_elt,gc) *cp_parser_initializer_list
	(cp_parser , bool );

	static bool cp_parser_ctor_initializer_opt_and_function_body
	(cp_parser *);

	/* Classes [gram.class] */

	static tree cp_parser_class_name
	(cp_parser *, bool, bool, enum tag_types, bool, bool, bool);
	static tree cp_parser_class_specifier
	(cp_parser *);
	static tree cp_parser_class_head
	(cp_parser , bool , tree , tree );
	static enum tag_types cp_parser_class_key
	(cp_parser *);
	static void cp_parser_member_specification_opt
	(cp_parser *);
	static void cp_parser_member_declaration
	(cp_parser *);
	static tree cp_parser_pure_specifier
	(cp_parser *);
	static tree cp_parser_constant_initializer
	(cp_parser *);

	/* Derived classes [gram.class.derived] */

	static tree cp_parser_base_clause
	(cp_parser *);
	static tree cp_parser_base_specifier
	(cp_parser *);

	/* Special member functions [gram.special] */

	static tree cp_parser_conversion_function_id
	(cp_parser *);
	static tree cp_parser_conversion_type_id
	(cp_parser *);
	static cp_declarator *cp_parser_conversion_declarator_opt
	(cp_parser *);
	static bool cp_parser_ctor_initializer_opt
	(cp_parser *);
	static void cp_parser_mem_initializer_list
	(cp_parser *);
	static tree cp_parser_mem_initializer
	(cp_parser *);
	static tree cp_parser_mem_initializer_id
	(cp_parser *);

	/* Overloading [gram.over] */

	static tree cp_parser_operator_function_id
	(cp_parser *);
	static tree cp_parser_operator
	(cp_parser *);

	/* Templates [gram.temp] */

	static void cp_parser_template_declaration
	(cp_parser *, bool);
	static tree cp_parser_template_parameter_list
	(cp_parser *);
	static tree cp_parser_template_parameter
	(cp_parser , bool );
	static tree cp_parser_type_parameter
	(cp_parser *);
	static tree cp_parser_template_id
	(cp_parser *, bool, bool, bool);
	static tree cp_parser_template_name
	(cp_parser , bool, bool, bool, bool );
	static tree cp_parser_template_argument_list
	(cp_parser *);
	static tree cp_parser_template_argument
	(cp_parser *);
	static void cp_parser_explicit_instantiation
	(cp_parser *);
	static void cp_parser_explicit_specialization
	(cp_parser *);

	/* Exception handling [gram.exception] */

	static tree cp_parser_try_block
	(cp_parser *);
	static bool cp_parser_function_try_block
	(cp_parser *);
	static void cp_parser_handler_seq
	(cp_parser *);
	static void cp_parser_handler
	(cp_parser *);
	static tree cp_parser_exception_declaration
	(cp_parser *);
	static tree cp_parser_throw_expression
	(cp_parser *);
	static tree cp_parser_exception_specification_opt
	(cp_parser *);
	static tree cp_parser_type_id_list
	(cp_parser *);

	/* GNU Extensions */

	static tree cp_parser_asm_specification_opt
	(cp_parser *);
	static tree cp_parser_asm_operand_list
	(cp_parser *);
	static tree cp_parser_asm_clobber_list
	(cp_parser *);
	static tree cp_parser_attributes_opt
	(cp_parser *);
	static tree cp_parser_attribute_list
	(cp_parser *);
	static bool cp_parser_extension_opt
	(cp_parser , int );
	static void cp_parser_label_declaration
	(cp_parser *);

	enum pragma_context { pragma_external, pragma_stmt, pragma_compound };
	static bool cp_parser_pragma
	(cp_parser *, enum pragma_context);

	/* Objective-C++ Productions */

	static tree cp_parser_objc_message_receiver
	(cp_parser *);
	static tree cp_parser_objc_message_args
	(cp_parser *);
	static tree cp_parser_objc_message_expression
	(cp_parser *);
	static tree cp_parser_objc_encode_expression
	(cp_parser *);
	static tree cp_parser_objc_defs_expression
	(cp_parser *);
	static tree cp_parser_objc_protocol_expression
	(cp_parser *);
	static tree cp_parser_objc_selector_expression
	(cp_parser *);
	static tree cp_parser_objc_expression
	(cp_parser *);
	static bool cp_parser_objc_selector_p
	(enum cpp_ttype);
	static tree cp_parser_objc_selector
	(cp_parser *);
	static tree cp_parser_objc_protocol_refs_opt
	(cp_parser *);
	static void cp_parser_objc_declaration
	(cp_parser *);
	static tree cp_parser_objc_statement
	(cp_parser *);

	/* Utility Routines */

	static tree cp_parser_lookup_name
	(cp_parser , tree, enum tag_types, bool, bool, bool, tree );
	static tree cp_parser_lookup_name_simple
	(cp_parser *, tree);
	static tree cp_parser_maybe_treat_template_as_class
	(tree, bool);
	static bool cp_parser_check_declarator_template_parameters
	(cp_parser , cp_declarator );
	static bool cp_parser_check_template_parameters
	(cp_parser *, unsigned);
	static tree cp_parser_simple_cast_expression
	(cp_parser *);
	static tree cp_parser_global_scope_opt
	(cp_parser *, bool);
	static bool cp_parser_constructor_declarator_p
	(cp_parser *, bool);
	static tree cp_parser_function_definition_from_specifiers_and_declarator
	(cp_parser , cp_decl_specifier_seq , tree, const cp_declarator *);
	static tree cp_parser_function_definition_after_declarator
	(cp_parser *, bool);
	static void cp_parser_template_declaration_after_export
	(cp_parser *, bool);
	static void cp_parser_perform_template_parameter_access_checks
	(VEC (deferred_access_check,gc)*);
	static tree cp_parser_single_declaration
	(cp_parser , VEC (deferred_access_check,gc), bool, bool *);
	static tree cp_parser_functional_cast
	(cp_parser *, tree);
	static tree cp_parser_save_member_function_body
	(cp_parser , cp_decl_specifier_seq , cp_declarator *, tree);
	static tree cp_parser_enclosed_template_argument_list
	(cp_parser *);
	static void cp_parser_save_default_args
	(cp_parser *, tree);
	static void cp_parser_late_parsing_for_member
	(cp_parser *, tree);
	static void cp_parser_late_parsing_default_args
	(cp_parser *, tree);
	static tree cp_parser_sizeof_operand
	(cp_parser *, enum rid);
	static bool cp_parser_declares_only_class_p
	(cp_parser *);
	static void cp_parser_set_storage_class
	(cp_parser , cp_decl_specifier_seq , enum rid);
	static void cp_parser_set_decl_spec_type
	(cp_decl_specifier_seq *, tree, bool);
	static bool cp_parser_friend_p
	(const cp_decl_specifier_seq *);
	static cp_token *cp_parser_require
	(cp_parser , enum cpp_ttype, const char );
	static cp_token *cp_parser_require_keyword
	(cp_parser , enum rid, const char );
	static bool cp_parser_token_starts_function_definition_p
	(cp_token *);
	static bool cp_parser_next_token_starts_class_definition_p
	(cp_parser *);
	static bool cp_parser_next_token_ends_template_argument_p
	(cp_parser *);
	static bool cp_parser_nth_token_starts_template_argument_list_p
	(cp_parser *, size_t);
	static enum tag_types cp_parser_token_is_class_key
	(cp_token *);
	static void cp_parser_check_class_key
	(enum tag_types, tree type);
	static void cp_parser_check_access_in_redeclaration
	(tree type);
	static bool cp_parser_optional_template_keyword
	(cp_parser *);
	static void cp_parser_pre_parsed_nested_name_specifier
	(cp_parser *);
	static void cp_parser_cache_group
	(cp_parser *, enum cpp_ttype, unsigned);
	static void cp_parser_parse_tentatively
	(cp_parser *);
	static void cp_parser_commit_to_tentative_parse
	(cp_parser *);
	static void cp_parser_abort_tentative_parse
	(cp_parser *);
	static bool cp_parser_parse_definitely
	(cp_parser *);
	static inline bool cp_parser_parsing_tentatively
	(cp_parser *);
	static bool cp_parser_uncommitted_to_tentative_parse_p
	(cp_parser *);
	static void cp_parser_error
	(cp_parser , const char );
	static void cp_parser_name_lookup_error
	(cp_parser , tree, tree, const char );
	static bool cp_parser_simulate_error
	(cp_parser *);
	static bool cp_parser_check_type_definition
	(cp_parser *);
	static void cp_parser_check_for_definition_in_return_type
	(cp_declarator *, tree);
	static void cp_parser_check_for_invalid_template_id
	(cp_parser *, tree);
	static bool cp_parser_non_integral_constant_expression
	(cp_parser , const char );
	static void cp_parser_diagnose_invalid_type_name
	(cp_parser *, tree, tree);
	static bool cp_parser_parse_and_diagnose_invalid_type_name
	(cp_parser *);
	static int cp_parser_skip_to_closing_parenthesis
	(cp_parser *, bool, bool, bool);
	static void cp_parser_skip_to_end_of_statement
	(cp_parser *);
	static void cp_parser_consume_semicolon_at_end_of_statement
	(cp_parser *);
	static void cp_parser_skip_to_end_of_block_or_statement
	(cp_parser *);
	static void cp_parser_skip_to_closing_brace
	(cp_parser *);
	static void cp_parser_skip_to_end_of_template_parameter_list
	(cp_parser *);
	static void cp_parser_skip_to_pragma_eol
	(cp_parser, cp_token );
	static bool cp_parser_error_occurred
	(cp_parser *);
	static bool cp_parser_allow_gnu_extensions_p
	(cp_parser *);
	static bool cp_parser_is_string_literal
	(cp_token *);
	static bool cp_parser_is_keyword
	(cp_token *, enum rid);
	static tree cp_parser_make_typename_type
	(cp_parser *, tree, tree);

	/* Returns nonzero if we are parsing tentatively. */

	static inline bool
	cp_parser_parsing_tentatively (cp_parser* parser)
	{
	return parser->context->next != NULL;
	}

	/* Returns nonzero if TOKEN is a string literal. */

	static bool
	cp_parser_is_string_literal (cp_token* token)
	{
	return (token->type == CPP_STRING \|\| token->type == CPP_WSTRING);
	}

	/* Returns nonzero if TOKEN is the indicated KEYWORD. */

	static bool
	cp_parser_is_keyword (cp_token* token, enum rid keyword)
	{
	return token->keyword == keyword;
	}

	/* If not parsing tentatively, issue a diagnostic of the form
	FILE:LINE: MESSAGE before TOKEN
	where TOKEN is the next token in the input stream. MESSAGE
	(specified by the caller) is usually of the form "expected
	OTHER-TOKEN". */

	static void
	cp_parser_error (cp_parser* parser, const char* message)
	{
	if (!cp_parser_simulate_error (parser))
	{
	cp_token *token = cp_lexer_peek_token (parser->lexer);
	/* This diagnostic makes more sense if it is tagged to the line
	of the token we just peeked at. */
	cp_lexer_set_source_position_from_token (token);

	if (token->type == CPP_PRAGMA)
	{
	error ("%<#pragma%> is not allowed here");
	cp_parser_skip_to_pragma_eol (parser, token);
	return;
	}

	c_parse_error (message,
	/* Because c_parser_error does not understand
	CPP_KEYWORD, keywords are treated like
	identifiers. */
	(token->type == CPP_KEYWORD ? CPP_NAME : token->type),
	token->u.value);
	}
	}

	/* Issue an error about name-lookup failing. NAME is the
	IDENTIFIER_NODE DECL is the result of
	the lookup (as returned from cp_parser_lookup_name). DESIRED is
	the thing that we hoped to find. */

	static void
	cp_parser_name_lookup_error (cp_parser* parser,
	tree name,
	tree decl,
	const char* desired)
	{
	/* If name lookup completely failed, tell the user that NAME was not
	declared. */
	if (decl == error_mark_node)
	{
	if (parser->scope && parser->scope != global_namespace)
	error ("%<%D::%D%> has not been declared",
	parser->scope, name);
	else if (parser->scope == global_namespace)
	error ("%<::%D%> has not been declared", name);
	else if (parser->object_scope
	&& !CLASS_TYPE_P (parser->object_scope))
	error ("request for member %qD in non-class type %qT",
	name, parser->object_scope);
	else if (parser->object_scope)
	error ("%<%T::%D%> has not been declared",
	parser->object_scope, name);
	else
	error ("%qD has not been declared", name);
	}
	else if (parser->scope && parser->scope != global_namespace)
	error ("%<%D::%D%> %s", parser->scope, name, desired);
	else if (parser->scope == global_namespace)
	error ("%<::%D%> %s", name, desired);
	else
	error ("%qD %s", name, desired);
	}

	/* If we are parsing tentatively, remember that an error has occurred
	during this tentative parse. Returns true if the error was
	simulated; false if a message should be issued by the caller. */

	static bool
	cp_parser_simulate_error (cp_parser* parser)
	{
	if (cp_parser_uncommitted_to_tentative_parse_p (parser))
	{
	parser->context->status = CP_PARSER_STATUS_KIND_ERROR;
	return true;
	}
	return false;
	}

	/* Check for repeated decl-specifiers. */

	static void
	cp_parser_check_decl_spec (cp_decl_specifier_seq *decl_specs)
	{
	cp_decl_spec ds;

	for (ds = ds_first; ds != ds_last; ++ds)
	{
	unsigned count = decl_specs->specs[(int)ds];
	if (count < 2)
	continue;
	/* The "long" specifier is a special case because of "long long". */
	if (ds == ds_long)
	{
	if (count > 2)
	error ("%<long long long%> is too long for GCC");
	else if (pedantic && !in_system_header && warn_long_long)
	pedwarn ("ISO C++ does not support %<long long%>");
	}
	else if (count > 1)
	{
	static const char *const decl_spec_names[] = {
	"signed",
	"unsigned",
	"short",
	"long",
	"const",
	"volatile",
	"restrict",
	"inline",
	"virtual",
	"explicit",
	"friend",
	"typedef",
	"__complex",
	"__thread"
	};
	error ("duplicate %qs", decl_spec_names[(int)ds]);
	}
	}
	}

	/* This function is called when a type is defined. If type
	definitions are forbidden at this point, an error message is
	issued. */

	static bool
	cp_parser_check_type_definition (cp_parser* parser)
	{
	/* If types are forbidden here, issue a message. */
	if (parser->type_definition_forbidden_message)
	{
	/* Use `%s' to print the string in case there are any escape
	characters in the message. */
	error ("%s", parser->type_definition_forbidden_message);
	return false;
	}
	return true;
	}

	/* This function is called when the DECLARATOR is processed. The TYPE
	was a type defined in the decl-specifiers. If it is invalid to
	define a type in the decl-specifiers for DECLARATOR, an error is
	issued. */

	static void
	cp_parser_check_for_definition_in_return_type (cp_declarator *declarator,
	tree type)
	{
	/* [dcl.fct] forbids type definitions in return types.
	Unfortunately, it's not easy to know whether or not we are
	processing a return type until after the fact. */
	while (declarator
	&& (declarator->kind == cdk_pointer
	\|\| declarator->kind == cdk_reference
	\|\| declarator->kind == cdk_ptrmem))
	declarator = declarator->declarator;
	if (declarator
	&& declarator->kind == cdk_function)
	{
	error ("new types may not be defined in a return type");
	inform ("(perhaps a semicolon is missing after the definition of %qT)",
	type);
	}
	}

	/* A type-specifier (TYPE) has been parsed which cannot be followed by
	"<" in any valid C++ program. If the next token is indeed "<",
	issue a message warning the user about what appears to be an
	invalid attempt to form a template-id. */

	static void
	cp_parser_check_for_invalid_template_id (cp_parser* parser,
	tree type)
	{
	cp_token_position start = 0;

	if (cp_lexer_next_token_is (parser->lexer, CPP_LESS))
	{
	if (TYPE_P (type))
	error ("%qT is not a template", type);
	else if (TREE_CODE (type) == IDENTIFIER_NODE)
	error ("%qE is not a template", type);
	else
	error ("invalid template-id");
	/* Remember the location of the invalid "<". */
	if (cp_parser_uncommitted_to_tentative_parse_p (parser))
	start = cp_lexer_token_position (parser->lexer, true);
	/* Consume the "<". */
	cp_lexer_consume_token (parser->lexer);
	/* Parse the template arguments. */
	cp_parser_enclosed_template_argument_list (parser);
	/* Permanently remove the invalid template arguments so that
	this error message is not issued again. */
	if (start)
	cp_lexer_purge_tokens_after (parser->lexer, start);
	}
	}

	/* If parsing an integral constant-expression, issue an error message
	about the fact that THING appeared and return true. Otherwise,
	return false. In either case, set
	PARSER->NON_INTEGRAL_CONSTANT_EXPRESSION_P. */

	static bool
	cp_parser_non_integral_constant_expression (cp_parser *parser,
	const char *thing)
	{
	parser->non_integral_constant_expression_p = true;
	if (parser->integral_constant_expression_p)
	{
	if (!parser->allow_non_integral_constant_expression_p)
	{
	error ("%s cannot appear in a constant-expression", thing);
	return true;
	}
	}
	return false;
	}

	/* Emit a diagnostic for an invalid type name. SCOPE is the
	qualifying scope (or NULL, if none) for ID. This function commits
	to the current active tentative parse, if any. (Otherwise, the
	problematic construct might be encountered again later, resulting
	in duplicate error messages.) */

	static void
	cp_parser_diagnose_invalid_type_name (cp_parser *parser, tree scope, tree id)
	{
	tree decl, old_scope;
	/* Try to lookup the identifier. */
	old_scope = parser->scope;
	parser->scope = scope;
	decl = cp_parser_lookup_name_simple (parser, id);
	parser->scope = old_scope;
	/* If the lookup found a template-name, it means that the user forgot
	to specify an argument list. Emit a useful error message. */
	if (TREE_CODE (decl) == TEMPLATE_DECL)
	error ("invalid use of template-name %qE without an argument list", decl);
	else if (TREE_CODE (id) == BIT_NOT_EXPR)
	error ("invalid use of destructor %qD as a type", id);
	else if (TREE_CODE (decl) == TYPE_DECL)
	/* Something like 'unsigned A a;' */
	error ("invalid combination of multiple type-specifiers");
	else if (!parser->scope)
	{
	/* Issue an error message. */
	error ("%qE does not name a type", id);
	/* If we're in a template class, it's possible that the user was
	referring to a type from a base class. For example:

	template <typename T> struct A { typedef T X; };
	template <typename T> struct B : public A<T> { X x; };

	The user should have said "typename A<T>::X". */
	if (processing_template_decl && current_class_type
	&& TYPE_BINFO (current_class_type))
	{
	tree b;

	for (b = TREE_CHAIN (TYPE_BINFO (current_class_type));
	b;
	b = TREE_CHAIN (b))
	{
	tree base_type = BINFO_TYPE (b);
	if (CLASS_TYPE_P (base_type)
	&& dependent_type_p (base_type))
	{
	tree field;
	/* Go from a particular instantiation of the
	template (which will have an empty TYPE_FIELDs),
	to the main version. */
	base_type = CLASSTYPE_PRIMARY_TEMPLATE_TYPE (base_type);
	for (field = TYPE_FIELDS (base_type);
	field;
	field = TREE_CHAIN (field))
	if (TREE_CODE (field) == TYPE_DECL
	&& DECL_NAME (field) == id)
	{
	inform ("(perhaps %<typename %T::%E%> was intended)",
	BINFO_TYPE (b), id);
	break;
	}
	if (field)
	break;
	}
	}
	}
	}
	/* Here we diagnose qualified-ids where the scope is actually correct,
	but the identifier does not resolve to a valid type name. */
	else if (parser->scope != error_mark_node)
	{
	if (TREE_CODE (parser->scope) == NAMESPACE_DECL)
	error ("%qE in namespace %qE does not name a type",
	id, parser->scope);
	else if (TYPE_P (parser->scope))
	error ("%qE in class %qT does not name a type", id, parser->scope);
	else
	gcc_unreachable ();
	}
	cp_parser_commit_to_tentative_parse (parser);
	}

	/* Check for a common situation where a type-name should be present,
	but is not, and issue a sensible error message. Returns true if an
	invalid type-name was detected.

	The situation handled by this function are variable declarations of the
	form `ID a', where `ID' is an id-expression and `a' is a plain identifier.
	Usually, `ID' should name a type, but if we got here it means that it
	does not. We try to emit the best possible error message depending on
	how exactly the id-expression looks like. */

	static bool
	cp_parser_parse_and_diagnose_invalid_type_name (cp_parser *parser)
	{
	tree id;

	cp_parser_parse_tentatively (parser);
	id = cp_parser_id_expression (parser,
	/template_keyword_p=/false,
	/check_dependency_p=/true,
	/template_p=/NULL,
	/declarator_p=/true,
	/optional_p=/false);
	/* After the id-expression, there should be a plain identifier,
	otherwise this is not a simple variable declaration. Also, if
	the scope is dependent, we cannot do much. */
	if (!cp_lexer_next_token_is (parser->lexer, CPP_NAME)
	\|\| (parser->scope && TYPE_P (parser->scope)
	&& dependent_type_p (parser->scope))
	\|\| TREE_CODE (id) == TYPE_DECL)
	{
	cp_parser_abort_tentative_parse (parser);
	return false;
	}
	if (!cp_parser_parse_definitely (parser))
	return false;

	/* Emit a diagnostic for the invalid type. */
	cp_parser_diagnose_invalid_type_name (parser, parser->scope, id);
	/* Skip to the end of the declaration; there's no point in
	trying to process it. */
	cp_parser_skip_to_end_of_block_or_statement (parser);
	return true;
	}

	/* Consume tokens up to, and including, the next non-nested closing `)'.
	Returns 1 iff we found a closing `)'. RECOVERING is true, if we
	are doing error recovery. Returns -1 if OR_COMMA is true and we
	found an unnested comma. */

	static int
	cp_parser_skip_to_closing_parenthesis (cp_parser *parser,
	bool recovering,
	bool or_comma,
	bool consume_paren)
	{
	unsigned paren_depth = 0;
	unsigned brace_depth = 0;

	if (recovering && !or_comma
	&& cp_parser_uncommitted_to_tentative_parse_p (parser))
	return 0;

	while (true)
	{
	cp_token * token = cp_lexer_peek_token (parser->lexer);

	switch (token->type)
	{
	case CPP_EOF:
	case CPP_PRAGMA_EOL:
	/* If we've run out of tokens, then there is no closing `)'. */
	return 0;

	case CPP_SEMICOLON:
	/* This matches the processing in skip_to_end_of_statement. */
	if (!brace_depth)
	return 0;
	break;

	case CPP_OPEN_BRACE:
	++brace_depth;
	break;
	case CPP_CLOSE_BRACE:
	if (!brace_depth--)
	return 0;
	break;

	case CPP_COMMA:
	if (recovering && or_comma && !brace_depth && !paren_depth)
	return -1;
	break;

	case CPP_OPEN_PAREN:
	if (!brace_depth)
	++paren_depth;
	break;

	case CPP_CLOSE_PAREN:
	if (!brace_depth && !paren_depth--)
	{
	if (consume_paren)
	cp_lexer_consume_token (parser->lexer);
	return 1;
	}
	break;

	default:
	break;
	}

	/* Consume the token. */
	cp_lexer_consume_token (parser->lexer);
	}
	}

	/* Consume tokens until we reach the end of the current statement.
	Normally, that will be just before consuming a `;'. However, if a
	non-nested `}' comes first, then we stop before consuming that. */

	static void
	cp_parser_skip_to_end_of_statement (cp_parser* parser)
	{
	unsigned nesting_depth = 0;

	while (true)
	{
	cp_token *token = cp_lexer_peek_token (parser->lexer);

	switch (token->type)
	{
	case CPP_EOF:
	case CPP_PRAGMA_EOL:
	/* If we've run out of tokens, stop. */
	return;

	case CPP_SEMICOLON:
	/* If the next token is a `;', we have reached the end of the
	statement. */
	if (!nesting_depth)
	return;
	break;

	case CPP_CLOSE_BRACE:
	/* If this is a non-nested '}', stop before consuming it.
	That way, when confronted with something like:

	{ 3 + }

	we stop before consuming the closing '}', even though we
	have not yet reached a `;'. */
	if (nesting_depth == 0)
	return;

	/* If it is the closing '}' for a block that we have
	scanned, stop -- but only after consuming the token.
	That way given:

	void f g () { ... }
	typedef int I;

	we will stop after the body of the erroneously declared
	function, but before consuming the following `typedef'
	declaration. */
	if (--nesting_depth == 0)
	{
	cp_lexer_consume_token (parser->lexer);
	return;
	}

	case CPP_OPEN_BRACE:
	++nesting_depth;
	break;

	default:
	break;
	}

	/* Consume the token. */
	cp_lexer_consume_token (parser->lexer);
	}
	}

	/* This function is called at the end of a statement or declaration.
	If the next token is a semicolon, it is consumed; otherwise, error
	recovery is attempted. */

	static void
	cp_parser_consume_semicolon_at_end_of_statement (cp_parser *parser)
	{
	/* Look for the trailing `;'. */
	if (!cp_parser_require (parser, CPP_SEMICOLON, "`;'"))
	{
	/* If there is additional (erroneous) input, skip to the end of
	the statement. */
	cp_parser_skip_to_end_of_statement (parser);
	/* If the next token is now a `;', consume it. */
	if (cp_lexer_next_token_is (parser->lexer, CPP_SEMICOLON))
	cp_lexer_consume_token (parser->lexer);
	}
	}

	/* Skip tokens until we have consumed an entire block, or until we
	have consumed a non-nested `;'. */

	static void
	cp_parser_skip_to_end_of_block_or_statement (cp_parser* parser)
	{
	int nesting_depth = 0;

	while (nesting_depth >= 0)
	{
	cp_token *token = cp_lexer_peek_token (parser->lexer);

	switch (token->type)
	{
	case CPP_EOF:
	case CPP_PRAGMA_EOL:
	/* If we've run out of tokens, stop. */
	return;

	case CPP_SEMICOLON:
	/* Stop if this is an unnested ';'. */
	if (!nesting_depth)
	nesting_depth = -1;
	break;

	case CPP_CLOSE_BRACE:
	/* Stop if this is an unnested '}', or closes the outermost
	nesting level. */
	nesting_depth--;
	if (!nesting_depth)
	nesting_depth = -1;
	break;

	case CPP_OPEN_BRACE:
	/* Nest. */
	nesting_depth++;
	break;

	default:
	break;
	}

	/* Consume the token. */
	cp_lexer_consume_token (parser->lexer);
	}
	}

	/* Skip tokens until a non-nested closing curly brace is the next
	token. */

	static void
	cp_parser_skip_to_closing_brace (cp_parser *parser)
	{
	unsigned nesting_depth = 0;

	while (true)
	{
	cp_token *token = cp_lexer_peek_token (parser->lexer);

	switch (token->type)
	{
	case CPP_EOF:
	case CPP_PRAGMA_EOL:
	/* If we've run out of tokens, stop. */
	return;

	case CPP_CLOSE_BRACE:
	/* If the next token is a non-nested `}', then we have reached
	the end of the current block. */
	if (nesting_depth-- == 0)
	return;
	break;

	case CPP_OPEN_BRACE:
	/* If it the next token is a `{', then we are entering a new
	block. Consume the entire block. */
	++nesting_depth;
	break;

	default:
	break;
	}

	/* Consume the token. */
	cp_lexer_consume_token (parser->lexer);
	}
	}

	/* Consume tokens until we reach the end of the pragma. The PRAGMA_TOK
	parameter is the PRAGMA token, allowing us to purge the entire pragma
	sequence. */

	static void
	cp_parser_skip_to_pragma_eol (cp_parser* parser, cp_token *pragma_tok)
	{
	cp_token *token;

	parser->lexer->in_pragma = false;

	do
	token = cp_lexer_consume_token (parser->lexer);
	while (token->type != CPP_PRAGMA_EOL && token->type != CPP_EOF);

	/* Ensure that the pragma is not parsed again. */
	cp_lexer_purge_tokens_after (parser->lexer, pragma_tok);
	}

	/* Require pragma end of line, resyncing with it as necessary. The
	arguments are as for cp_parser_skip_to_pragma_eol. */

	static void
	cp_parser_require_pragma_eol (cp_parser parser, cp_token pragma_tok)
	{
	parser->lexer->in_pragma = false;
	if (!cp_parser_require (parser, CPP_PRAGMA_EOL, "end of line"))
	cp_parser_skip_to_pragma_eol (parser, pragma_tok);
	}

	/* This is a simple wrapper around make_typename_type. When the id is
	an unresolved identifier node, we can provide a superior diagnostic
	using cp_parser_diagnose_invalid_type_name. */

	static tree
	cp_parser_make_typename_type (cp_parser *parser, tree scope, tree id)
	{
	tree result;
	if (TREE_CODE (id) == IDENTIFIER_NODE)
	{
	result = make_typename_type (scope, id, typename_type,
	/complain=/tf_none);
	if (result == error_mark_node)
	cp_parser_diagnose_invalid_type_name (parser, scope, id);
	return result;
	}
	return make_typename_type (scope, id, typename_type, tf_error);
	}


	/* Create a new C++ parser. */

	static cp_parser *
	cp_parser_new (void)
	{
	cp_parser *parser;
	cp_lexer *lexer;
	unsigned i;

	/* cp_lexer_new_main is called before calling ggc_alloc because
	cp_lexer_new_main might load a PCH file. */
	lexer = cp_lexer_new_main ();

	/* Initialize the binops_by_token so that we can get the tree
	directly from the token. */
	for (i = 0; i < sizeof (binops) / sizeof (binops[0]); i++)
	binops_by_token[binops[i].token_type] = binops[i];

	parser = GGC_CNEW (cp_parser);
	parser->lexer = lexer;
	parser->context = cp_parser_context_new (NULL);

	/* For now, we always accept GNU extensions. */
	parser->allow_gnu_extensions_p = 1;

	/* The `>' token is a greater-than operator, not the end of a
	template-id. */
	parser->greater_than_is_operator_p = true;

	parser->default_arg_ok_p = true;

	/* We are not parsing a constant-expression. */
	parser->integral_constant_expression_p = false;
	parser->allow_non_integral_constant_expression_p = false;
	parser->non_integral_constant_expression_p = false;

	/* Local variable names are not forbidden. */
	parser->local_variables_forbidden_p = false;

	/* We are not processing an `extern "C"' declaration. */
	parser->in_unbraced_linkage_specification_p = false;

	/* We are not processing a declarator. */
	parser->in_declarator_p = false;

	/* We are not processing a template-argument-list. */
	parser->in_template_argument_list_p = false;

	/* We are not in an iteration statement. */
	parser->in_statement = 0;

	/* We are not in a switch statement. */
	parser->in_switch_statement_p = false;

	/* We are not parsing a type-id inside an expression. */
	parser->in_type_id_in_expr_p = false;

	/* Declarations aren't implicitly extern "C". */
	parser->implicit_extern_c = false;

	/* String literals should be translated to the execution character set. */
	parser->translate_strings_p = true;

	/* We are not parsing a function body. */
	parser->in_function_body = false;

	/* The unparsed function queue is empty. */
	parser->unparsed_functions_queues = build_tree_list (NULL_TREE, NULL_TREE);

	/* There are no classes being defined. */
	parser->num_classes_being_defined = 0;

	/* No template parameters apply. */
	parser->num_template_parameter_lists = 0;

	return parser;
	}

	/* Create a cp_lexer structure which will emit the tokens in CACHE
	and push it onto the parser's lexer stack. This is used for delayed
	parsing of in-class method bodies and default arguments, and should
	not be confused with tentative parsing. */
	static void
	cp_parser_push_lexer_for_tokens (cp_parser parser, cp_token_cache cache)
	{
	cp_lexer *lexer = cp_lexer_new_from_tokens (cache);
	lexer->next = parser->lexer;
	parser->lexer = lexer;

	/* Move the current source position to that of the first token in the
	new lexer. */
	cp_lexer_set_source_position_from_token (lexer->next_token);
	}

	/* Pop the top lexer off the parser stack. This is never used for the
	"main" lexer, only for those pushed by cp_parser_push_lexer_for_tokens. */
	static void
	cp_parser_pop_lexer (cp_parser *parser)
	{
	cp_lexer *lexer = parser->lexer;
	parser->lexer = lexer->next;
	cp_lexer_destroy (lexer);

	/* Put the current source position back where it was before this
	lexer was pushed. */
	cp_lexer_set_source_position_from_token (parser->lexer->next_token);
	}

	/* Lexical conventions [gram.lex] */

	/* Parse an identifier. Returns an IDENTIFIER_NODE representing the
	identifier. */

	static tree
	cp_parser_identifier (cp_parser* parser)
	{
	cp_token *token;

	/* Look for the identifier. */
	token = cp_parser_require (parser, CPP_NAME, "identifier");
	/* Return the value. */
	return token ? token->u.value : error_mark_node;
	}

	/* Parse a sequence of adjacent string constants. Returns a
	TREE_STRING representing the combined, nul-terminated string
	constant. If TRANSLATE is true, translate the string to the
	execution character set. If WIDE_OK is true, a wide string is
	invalid here.

	C++98 [lex.string] says that if a narrow string literal token is
	adjacent to a wide string literal token, the behavior is undefined.
	However, C99 6.4.5p4 says that this results in a wide string literal.
	We follow C99 here, for consistency with the C front end.

	This code is largely lifted from lex_string() in c-lex.c.

	FUTURE: ObjC++ will need to handle @-strings here. */
	static tree
	cp_parser_string_literal (cp_parser *parser, bool translate, bool wide_ok)
	{
	tree value;
	bool wide = false;
	size_t count;
	struct obstack str_ob;
	cpp_string str, istr, *strs;
	cp_token *tok;

	tok = cp_lexer_peek_token (parser->lexer);
	if (!cp_parser_is_string_literal (tok))
	{
	cp_parser_error (parser, "expected string-literal");
	return error_mark_node;
	}

	/* Try to avoid the overhead of creating and destroying an obstack
	for the common case of just one string. */
	if (!cp_parser_is_string_literal
	(cp_lexer_peek_nth_token (parser->lexer, 2)))
	{
	cp_lexer_consume_token (parser->lexer);

	str.text = (const unsigned char *)TREE_STRING_POINTER (tok->u.value);
	str.len = TREE_STRING_LENGTH (tok->u.value);
	count = 1;
	if (tok->type == CPP_WSTRING)
	wide = true;

	strs = &str;
	}
	else
	{
	gcc_obstack_init (&str_ob);
	count = 0;

	do
	{
	cp_lexer_consume_token (parser->lexer);
	count++;
	str.text = (unsigned char *)TREE_STRING_POINTER (tok->u.value);
	str.len = TREE_STRING_LENGTH (tok->u.value);
	if (tok->type == CPP_WSTRING)
	wide = true;

	obstack_grow (&str_ob, &str, sizeof (cpp_string));

	tok = cp_lexer_peek_token (parser->lexer);
	}
	while (cp_parser_is_string_literal (tok));

	strs = (cpp_string *) obstack_finish (&str_ob);
	}

	if (wide && !wide_ok)
	{
	cp_parser_error (parser, "a wide string is invalid in this context");
	wide = false;
	}

	if ((translate ? cpp_interpret_string : cpp_interpret_string_notranslate)
	(parse_in, strs, count, &istr, wide))
	{
	value = build_string (istr.len, (char *)istr.text);
	free ((void *)istr.text);

	TREE_TYPE (value) = wide ? wchar_array_type_node : char_array_type_node;
	value = fix_string_type (value);
	}
	else
	/* cpp_interpret_string has issued an error. */
	value = error_mark_node;

	if (count > 1)
	obstack_free (&str_ob, 0);

	return value;
	}


	/* Basic concepts [gram.basic] */

	/* Parse a translation-unit.

	translation-unit:
	declaration-seq [opt]

	Returns TRUE if all went well. */

	static bool
	cp_parser_translation_unit (cp_parser* parser)
	{
	/* The address of the first non-permanent object on the declarator
	obstack. */
	static void *declarator_obstack_base;

	bool success;

	/* Create the declarator obstack, if necessary. */
	if (!cp_error_declarator)
	{
	gcc_obstack_init (&declarator_obstack);
	/* Create the error declarator. */
	cp_error_declarator = make_declarator (cdk_error);
	/* Create the empty parameter list. */
	no_parameters = make_parameter_declarator (NULL, NULL, NULL_TREE);
	/* Remember where the base of the declarator obstack lies. */
	declarator_obstack_base = obstack_next_free (&declarator_obstack);
	}

	cp_parser_declaration_seq_opt (parser);

	/* If there are no tokens left then all went well. */
	if (cp_lexer_next_token_is (parser->lexer, CPP_EOF))
	{
	/* Get rid of the token array; we don't need it any more. */
	cp_lexer_destroy (parser->lexer);
	parser->lexer = NULL;

	/* This file might have been a context that's implicitly extern
	"C". If so, pop the lang context. (Only relevant for PCH.) */
	if (parser->implicit_extern_c)
	{
	pop_lang_context ();
	parser->implicit_extern_c = false;
	}

	/* Finish up. */
	finish_translation_unit ();

	success = true;
	}
	else
	{
	cp_parser_error (parser, "expected declaration");
	success = false;
	}

	/* Make sure the declarator obstack was fully cleaned up. */
	gcc_assert (obstack_next_free (&declarator_obstack)
	== declarator_obstack_base);

	/* All went well. */
	return success;
	}

	/* Expressions [gram.expr] */

	/* Parse a primary-expression.

	primary-expression:
	literal
	this
	( expression )
	id-expression

	GNU Extensions:

	primary-expression:
	( compound-statement )
	__builtin_va_arg ( assignment-expression , type-id )
	__builtin_offsetof ( type-id , offsetof-expression )

	Objective-C++ Extension:

	primary-expression:
	objc-expression

	literal:
	__null

	ADDRESS_P is true iff this expression was immediately preceded by
	"&" and therefore might denote a pointer-to-member. CAST_P is true
	iff this expression is the target of a cast. TEMPLATE_ARG_P is
	true iff this expression is a template argument.

	Returns a representation of the expression. Upon return, *IDK
	indicates what kind of id-expression (if any) was present. */

	static tree
	cp_parser_primary_expression (cp_parser *parser,
	bool address_p,
	bool cast_p,
	bool template_arg_p,
	cp_id_kind *idk)
	{
	cp_token *token;

	/* Assume the primary expression is not an id-expression. */
	*idk = CP_ID_KIND_NONE;

	/* Peek at the next token. */
	token = cp_lexer_peek_token (parser->lexer);
	switch (token->type)
	{
	/* literal:
	integer-literal
	character-literal
	floating-literal
	string-literal
	boolean-literal */
	case CPP_CHAR:
	case CPP_WCHAR:
	case CPP_NUMBER:
	token = cp_lexer_consume_token (parser->lexer);
	/* Floating-point literals are only allowed in an integral
	constant expression if they are cast to an integral or
	enumeration type. */
	if (TREE_CODE (token->u.value) == REAL_CST
	&& parser->integral_constant_expression_p
	&& pedantic)
	{
	/* CAST_P will be set even in invalid code like "int(2.7 +
	...)". Therefore, we have to check that the next token
	is sure to end the cast. */
	if (cast_p)
	{
	cp_token *next_token;

	next_token = cp_lexer_peek_token (parser->lexer);
	if (/* The comma at the end of an
	enumerator-definition. */
	next_token->type != CPP_COMMA
	/* The curly brace at the end of an enum-specifier. */
	&& next_token->type != CPP_CLOSE_BRACE
	/* The end of a statement. */
	&& next_token->type != CPP_SEMICOLON
	/* The end of the cast-expression. */
	&& next_token->type != CPP_CLOSE_PAREN
	/* The end of an array bound. */
	&& next_token->type != CPP_CLOSE_SQUARE
	/* The closing ">" in a template-argument-list. */
	&& (next_token->type != CPP_GREATER
	\|\| parser->greater_than_is_operator_p))
	cast_p = false;
	}

	/* If we are within a cast, then the constraint that the
	cast is to an integral or enumeration type will be
	checked at that point. If we are not within a cast, then
	this code is invalid. */
	if (!cast_p)
	cp_parser_non_integral_constant_expression
	(parser, "floating-point literal");
	}
	return token->u.value;

	case CPP_STRING:
	case CPP_WSTRING:
	/* ??? Should wide strings be allowed when parser->translate_strings_p
	is false (i.e. in attributes)? If not, we can kill the third
	argument to cp_parser_string_literal. */
	return cp_parser_string_literal (parser,
	parser->translate_strings_p,
	true);

	case CPP_OPEN_PAREN:
	{
	tree expr;
	bool saved_greater_than_is_operator_p;

	/* Consume the `('. */
	cp_lexer_consume_token (parser->lexer);
	/* Within a parenthesized expression, a `>' token is always
	the greater-than operator. */
	saved_greater_than_is_operator_p
	= parser->greater_than_is_operator_p;
	parser->greater_than_is_operator_p = true;
	/* If we see `( { ' then we are looking at the beginning of
	a GNU statement-expression. */
	if (cp_parser_allow_gnu_extensions_p (parser)
	&& cp_lexer_next_token_is (parser->lexer, CPP_OPEN_BRACE))
	{
	/* Statement-expressions are not allowed by the standard. */
	if (pedantic)
	pedwarn ("ISO C++ forbids braced-groups within expressions");

	/* And they're not allowed outside of a function-body; you
	cannot, for example, write:

	int i = ({ int j = 3; j + 1; });

	at class or namespace scope. */
	if (!parser->in_function_body)
	error ("statement-expressions are allowed only inside functions");
	/* Start the statement-expression. */
	expr = begin_stmt_expr ();
	/* Parse the compound-statement. */
	cp_parser_compound_statement (parser, expr, false);
	/* Finish up. */
	expr = finish_stmt_expr (expr, false);
	}
	else
	{
	/* Parse the parenthesized expression. */
	expr = cp_parser_expression (parser, cast_p);
	/* Let the front end know that this expression was
	enclosed in parentheses. This matters in case, for
	example, the expression is of the form `A::B', since
	`&A::B' might be a pointer-to-member, but `&(A::B)' is
	not. */
	finish_parenthesized_expr (expr);
	}
	/* The `>' token might be the end of a template-id or
	template-parameter-list now. */
	parser->greater_than_is_operator_p
	= saved_greater_than_is_operator_p;
	/* Consume the `)'. */
	if (!cp_parser_require (parser, CPP_CLOSE_PAREN, "`)'"))
	cp_parser_skip_to_end_of_statement (parser);

	return expr;
	}

	case CPP_KEYWORD:
	switch (token->keyword)
	{
	/* These two are the boolean literals. */
	case RID_TRUE:
	cp_lexer_consume_token (parser->lexer);
	return boolean_true_node;
	case RID_FALSE:
	cp_lexer_consume_token (parser->lexer);
	return boolean_false_node;

	/* The `__null' literal. */
	case RID_NULL:
	cp_lexer_consume_token (parser->lexer);
	return null_node;

	/* Recognize the `this' keyword. */
	case RID_THIS:
	cp_lexer_consume_token (parser->lexer);
	if (parser->local_variables_forbidden_p)
	{
	error ("%<this%> may not be used in this context");
	return error_mark_node;
	}
	/* Pointers cannot appear in constant-expressions. */
	if (cp_parser_non_integral_constant_expression (parser,
	"`this'"))
	return error_mark_node;
	return finish_this_expr ();

	/* The `operator' keyword can be the beginning of an
	id-expression. */
	case RID_OPERATOR:
	goto id_expression;

	case RID_FUNCTION_NAME:
	case RID_PRETTY_FUNCTION_NAME:
	case RID_C99_FUNCTION_NAME:
	/* The symbols __FUNCTION__, __PRETTY_FUNCTION__, and
	__func__ are the names of variables -- but they are
	treated specially. Therefore, they are handled here,
	rather than relying on the generic id-expression logic
	below. Grammatically, these names are id-expressions.

	Consume the token. */
	token = cp_lexer_consume_token (parser->lexer);
	/* Look up the name. */
	return finish_fname (token->u.value);

	case RID_VA_ARG:
	{
	tree expression;
	tree type;

	/* The `__builtin_va_arg' construct is used to handle
	`va_arg'. Consume the `__builtin_va_arg' token. */
	cp_lexer_consume_token (parser->lexer);
	/* Look for the opening `('. */
	cp_parser_require (parser, CPP_OPEN_PAREN, "`('");
	/* Now, parse the assignment-expression. */
	expression = cp_parser_assignment_expression (parser,
	/cast_p=/false);
	/* Look for the `,'. */
	cp_parser_require (parser, CPP_COMMA, "`,'");
	/* Parse the type-id. */
	type = cp_parser_type_id (parser);
	/* Look for the closing `)'. */
	cp_parser_require (parser, CPP_CLOSE_PAREN, "`)'");
	/* Using `va_arg' in a constant-expression is not
	allowed. */
	if (cp_parser_non_integral_constant_expression (parser,
	"`va_arg'"))
	return error_mark_node;
	return build_x_va_arg (expression, type);
	}

	case RID_OFFSETOF:
	return cp_parser_builtin_offsetof (parser);

	/* Objective-C++ expressions. */
	case RID_AT_ENCODE:
	case RID_AT_PROTOCOL:
	case RID_AT_SELECTOR:
	return cp_parser_objc_expression (parser);

	default:
	cp_parser_error (parser, "expected primary-expression");
	return error_mark_node;
	}

	/* An id-expression can start with either an identifier, a
	`::' as the beginning of a qualified-id, or the "operator"
	keyword. */
	case CPP_NAME:
	case CPP_SCOPE:
	case CPP_TEMPLATE_ID:
	case CPP_NESTED_NAME_SPECIFIER:
	{
	tree id_expression;
	tree decl;
	const char *error_msg;
	bool template_p;
	bool done;

	id_expression:
	/* Parse the id-expression. */
	id_expression
	= cp_parser_id_expression (parser,
	/template_keyword_p=/false,
	/check_dependency_p=/true,
	&template_p,
	/declarator_p=/false,
	/optional_p=/false);
	if (id_expression == error_mark_node)
	return error_mark_node;
	token = cp_lexer_peek_token (parser->lexer);
	done = (token->type != CPP_OPEN_SQUARE
	&& token->type != CPP_OPEN_PAREN
	&& token->type != CPP_DOT
	&& token->type != CPP_DEREF
	&& token->type != CPP_PLUS_PLUS
	&& token->type != CPP_MINUS_MINUS);
	/* If we have a template-id, then no further lookup is
	required. If the template-id was for a template-class, we
	will sometimes have a TYPE_DECL at this point. */
	if (TREE_CODE (id_expression) == TEMPLATE_ID_EXPR
	\|\| TREE_CODE (id_expression) == TYPE_DECL)
	decl = id_expression;
	/* Look up the name. */
	else
	{
	tree ambiguous_decls;

	decl = cp_parser_lookup_name (parser, id_expression,
	none_type,
	template_p,
	/is_namespace=/false,
	/check_dependency=/true,
	&ambiguous_decls);
	/* If the lookup was ambiguous, an error will already have
	been issued. */
	if (ambiguous_decls)
	return error_mark_node;

	/* In Objective-C++, an instance variable (ivar) may be preferred
	to whatever cp_parser_lookup_name() found. */
	decl = objc_lookup_ivar (decl, id_expression);

	/* If name lookup gives us a SCOPE_REF, then the
	qualifying scope was dependent. */
	if (TREE_CODE (decl) == SCOPE_REF)
	{
	/* At this point, we do not know if DECL is a valid
	integral constant expression. We assume that it is
	in fact such an expression, so that code like:

	template <int N> struct A {
	int a[B<N>::i];
	};

	is accepted. At template-instantiation time, we
	will check that B<N>::i is actually a constant. */
	return decl;
	}
	/* Check to see if DECL is a local variable in a context
	where that is forbidden. */
	if (parser->local_variables_forbidden_p
	&& local_variable_p (decl))
	{
	/* It might be that we only found DECL because we are
	trying to be generous with pre-ISO scoping rules.
	For example, consider:

	int i;
	void g() {
	for (int i = 0; i < 10; ++i) {}
	extern void f(int j = i);
	}

	Here, name look up will originally find the out
	of scope `i'. We need to issue a warning message,
	but then use the global `i'. */
	decl = check_for_out_of_scope_variable (decl);
	if (local_variable_p (decl))
	{
	error ("local variable %qD may not appear in this context",
	decl);
	return error_mark_node;
	}
	}
	}

	decl = (finish_id_expression
	(id_expression, decl, parser->scope,
	idk,
	parser->integral_constant_expression_p,
	parser->allow_non_integral_constant_expression_p,
	&parser->non_integral_constant_expression_p,
	template_p, done, address_p,
	template_arg_p,
	&error_msg));
	if (error_msg)
	cp_parser_error (parser, error_msg);
	return decl;
	}

	/* Anything else is an error. */
	default:
	/* ...unless we have an Objective-C++ message or string literal, that is. */
	if (c_dialect_objc ()
	&& (token->type == CPP_OPEN_SQUARE \|\| token->type == CPP_OBJC_STRING))
	return cp_parser_objc_expression (parser);

	cp_parser_error (parser, "expected primary-expression");
	return error_mark_node;
	}
	}

	/* Parse an id-expression.

	id-expression:
	unqualified-id
	qualified-id

	qualified-id:
	:: [opt] nested-name-specifier template [opt] unqualified-id
	:: identifier
	:: operator-function-id
	:: template-id

	Return a representation of the unqualified portion of the
	identifier. Sets PARSER->SCOPE to the qualifying scope if there is
	a `::' or nested-name-specifier.

	Often, if the id-expression was a qualified-id, the caller will
	want to make a SCOPE_REF to represent the qualified-id. This
	function does not do this in order to avoid wastefully creating
	SCOPE_REFs when they are not required.

	If TEMPLATE_KEYWORD_P is true, then we have just seen the
	`template' keyword.

	If CHECK_DEPENDENCY_P is false, then names are looked up inside
	uninstantiated templates.

	If *TEMPLATE_P is non-NULL, it is set to true iff the
	`template' keyword is used to explicitly indicate that the entity
	named is a template.

	If DECLARATOR_P is true, the id-expression is appearing as part of
	a declarator, rather than as part of an expression. */

	static tree
	cp_parser_id_expression (cp_parser *parser,
	bool template_keyword_p,
	bool check_dependency_p,
	bool *template_p,
	bool declarator_p,
	bool optional_p)
	{
	bool global_scope_p;
	bool nested_name_specifier_p;

	/* Assume the `template' keyword was not used. */
	if (template_p)
	*template_p = template_keyword_p;

	/* Look for the optional `::' operator. */
	global_scope_p
	= (cp_parser_global_scope_opt (parser, /current_scope_valid_p=/false)
	!= NULL_TREE);
	/* Look for the optional nested-name-specifier. */
	nested_name_specifier_p
	= (cp_parser_nested_name_specifier_opt (parser,
	/typename_keyword_p=/false,
	check_dependency_p,
	/type_p=/false,
	declarator_p)
	!= NULL_TREE);
	/* If there is a nested-name-specifier, then we are looking at
	the first qualified-id production. */
	if (nested_name_specifier_p)
	{
	tree saved_scope;
	tree saved_object_scope;
	tree saved_qualifying_scope;
	tree unqualified_id;
	bool is_template;

	/* See if the next token is the `template' keyword. */
	if (!template_p)
	template_p = &is_template;
	*template_p = cp_parser_optional_template_keyword (parser);
	/* Name lookup we do during the processing of the
	unqualified-id might obliterate SCOPE. */
	saved_scope = parser->scope;
	saved_object_scope = parser->object_scope;
	saved_qualifying_scope = parser->qualifying_scope;
	/* Process the final unqualified-id. */
	unqualified_id = cp_parser_unqualified_id (parser, *template_p,
	check_dependency_p,
	declarator_p,
	/optional_p=/false);
	/* Restore the SAVED_SCOPE for our caller. */
	parser->scope = saved_scope;
	parser->object_scope = saved_object_scope;
	parser->qualifying_scope = saved_qualifying_scope;

	return unqualified_id;
	}
	/* Otherwise, if we are in global scope, then we are looking at one
	of the other qualified-id productions. */
	else if (global_scope_p)
	{
	cp_token *token;
	tree id;

	/* Peek at the next token. */
	token = cp_lexer_peek_token (parser->lexer);

	/* If it's an identifier, and the next token is not a "<", then
	we can avoid the template-id case. This is an optimization
	for this common case. */
	if (token->type == CPP_NAME
	&& !cp_parser_nth_token_starts_template_argument_list_p
	(parser, 2))
	return cp_parser_identifier (parser);

	cp_parser_parse_tentatively (parser);
	/* Try a template-id. */
	id = cp_parser_template_id (parser,
	/template_keyword_p=/false,
	/check_dependency_p=/true,
	declarator_p);
	/* If that worked, we're done. */
	if (cp_parser_parse_definitely (parser))
	return id;

	/* Peek at the next token. (Changes in the token buffer may
	have invalidated the pointer obtained above.) */
	token = cp_lexer_peek_token (parser->lexer);

	switch (token->type)
	{
	case CPP_NAME:
	return cp_parser_identifier (parser);

	case CPP_KEYWORD:
	if (token->keyword == RID_OPERATOR)
	return cp_parser_operator_function_id (parser);
	/* Fall through. */

	default:
	cp_parser_error (parser, "expected id-expression");
	return error_mark_node;
	}
	}
	else
	return cp_parser_unqualified_id (parser, template_keyword_p,
	/check_dependency_p=/true,
	declarator_p,
	optional_p);
	}

	/* Parse an unqualified-id.

	unqualified-id:
	identifier
	operator-function-id
	conversion-function-id
	~ class-name
	template-id

	If TEMPLATE_KEYWORD_P is TRUE, we have just seen the `template'
	keyword, in a construct like `A::template ...'.

	Returns a representation of unqualified-id. For the `identifier'
	production, an IDENTIFIER_NODE is returned. For the `~ class-name'
	production a BIT_NOT_EXPR is returned; the operand of the
	BIT_NOT_EXPR is an IDENTIFIER_NODE for the class-name. For the
	other productions, see the documentation accompanying the
	corresponding parsing functions. If CHECK_DEPENDENCY_P is false,
	names are looked up in uninstantiated templates. If DECLARATOR_P
	is true, the unqualified-id is appearing as part of a declarator,
	rather than as part of an expression. */

	static tree
	cp_parser_unqualified_id (cp_parser* parser,
	bool template_keyword_p,
	bool check_dependency_p,
	bool declarator_p,
	bool optional_p)
	{
	cp_token *token;

	/* Peek at the next token. */
	token = cp_lexer_peek_token (parser->lexer);

	switch (token->type)
	{
	case CPP_NAME:
	{
	tree id;

	/* We don't know yet whether or not this will be a
	template-id. */
	cp_parser_parse_tentatively (parser);
	/* Try a template-id. */
	id = cp_parser_template_id (parser, template_keyword_p,
	check_dependency_p,
	declarator_p);
	/* If it worked, we're done. */
	if (cp_parser_parse_definitely (parser))
	return id;
	/* Otherwise, it's an ordinary identifier. */
	return cp_parser_identifier (parser);
	}

	case CPP_TEMPLATE_ID:
	return cp_parser_template_id (parser, template_keyword_p,
	check_dependency_p,
	declarator_p);

	case CPP_COMPL:
	{
	tree type_decl;
	tree qualifying_scope;
	tree object_scope;
	tree scope;
	bool done;

	/* Consume the `~' token. */
	cp_lexer_consume_token (parser->lexer);
	/* Parse the class-name. The standard, as written, seems to
	say that:

	template <typename T> struct S { ~S (); };
	template <typename T> S<T>::~S() {}

	is invalid, since `~' must be followed by a class-name, but
	`S<T>' is dependent, and so not known to be a class.
	That's not right; we need to look in uninstantiated
	templates. A further complication arises from:

	template <typename T> void f(T t) {
	t.T::~T();
	}

	Here, it is not possible to look up `T' in the scope of `T'
	itself. We must look in both the current scope, and the
	scope of the containing complete expression.

	Yet another issue is:

	struct S {
	int S;
	~S();
	};

	S::~S() {}

	The standard does not seem to say that the `S' in `~S'
	should refer to the type `S' and not the data member
	`S::S'. */

	/* DR 244 says that we look up the name after the "~" in the
	same scope as we looked up the qualifying name. That idea
	isn't fully worked out; it's more complicated than that. */
	scope = parser->scope;
	object_scope = parser->object_scope;
	qualifying_scope = parser->qualifying_scope;

	/* Check for invalid scopes. */
	if (scope == error_mark_node)
	{
	if (cp_lexer_next_token_is (parser->lexer, CPP_NAME))
	cp_lexer_consume_token (parser->lexer);
	return error_mark_node;
	}
	if (scope && TREE_CODE (scope) == NAMESPACE_DECL)
	{
	if (!cp_parser_uncommitted_to_tentative_parse_p (parser))
	error ("scope %qT before %<~%> is not a class-name", scope);
	cp_parser_simulate_error (parser);
	if (cp_lexer_next_token_is (parser->lexer, CPP_NAME))
	cp_lexer_consume_token (parser->lexer);
	return error_mark_node;
	}
	gcc_assert (!scope \|\| TYPE_P (scope));

	/* If the name is of the form "X::~X" it's OK. */
	token = cp_lexer_peek_token (parser->lexer);
	if (scope
	&& token->type == CPP_NAME
	&& (cp_lexer_peek_nth_token (parser->lexer, 2)->type
	== CPP_OPEN_PAREN)
	&& constructor_name_p (token->u.value, scope))
	{
	cp_lexer_consume_token (parser->lexer);
	return build_nt (BIT_NOT_EXPR, scope);
	}

	/* If there was an explicit qualification (S::~T), first look
	in the scope given by the qualification (i.e., S). */
	done = false;
	type_decl = NULL_TREE;
	if (scope)
	{
	cp_parser_parse_tentatively (parser);
	type_decl = cp_parser_class_name (parser,
	/typename_keyword_p=/false,
	/template_keyword_p=/false,
	none_type,
	/check_dependency=/false,
	/class_head_p=/false,
	declarator_p);
	if (cp_parser_parse_definitely (parser))
	done = true;
	}
	/* In "N::S::~S", look in "N" as well. */
	if (!done && scope && qualifying_scope)
	{
	cp_parser_parse_tentatively (parser);
	parser->scope = qualifying_scope;
	parser->object_scope = NULL_TREE;
	parser->qualifying_scope = NULL_TREE;
	type_decl
	= cp_parser_class_name (parser,
	/typename_keyword_p=/false,
	/template_keyword_p=/false,
	none_type,
	/check_dependency=/false,
	/class_head_p=/false,
	declarator_p);
	if (cp_parser_parse_definitely (parser))
	done = true;
	}
	/* In "p->S::~T", look in the scope given by "p" as well. /
	else if (!done && object_scope)
	{
	cp_parser_parse_tentatively (parser);
	parser->scope = object_scope;
	parser->object_scope = NULL_TREE;
	parser->qualifying_scope = NULL_TREE;
	type_decl
	= cp_parser_class_name (parser,
	/typename_keyword_p=/false,
	/template_keyword_p=/false,
	none_type,
	/check_dependency=/false,
	/class_head_p=/false,
	declarator_p);
	if (cp_parser_parse_definitely (parser))
	done = true;
	}
	/* Look in the surrounding context. */
	if (!done)
	{
	parser->scope = NULL_TREE;
	parser->object_scope = NULL_TREE;
	parser->qualifying_scope = NULL_TREE;
	type_decl
	= cp_parser_class_name (parser,
	/typename_keyword_p=/false,
	/template_keyword_p=/false,
	none_type,
	/check_dependency=/false,
	/class_head_p=/false,
	declarator_p);
	}
	/* If an error occurred, assume that the name of the
	destructor is the same as the name of the qualifying
	class. That allows us to keep parsing after running
	into ill-formed destructor names. */
	if (type_decl == error_mark_node && scope)
	return build_nt (BIT_NOT_EXPR, scope);
	else if (type_decl == error_mark_node)
	return error_mark_node;

	/* Check that destructor name and scope match. */
	if (declarator_p && scope && !check_dtor_name (scope, type_decl))
	{
	if (!cp_parser_uncommitted_to_tentative_parse_p (parser))
	error ("declaration of %<~%T%> as member of %qT",
	type_decl, scope);
	cp_parser_simulate_error (parser);
	return error_mark_node;
	}

	/* [class.dtor]

	A typedef-name that names a class shall not be used as the
	identifier in the declarator for a destructor declaration. */
	if (declarator_p
	&& !DECL_IMPLICIT_TYPEDEF_P (type_decl)
	&& !DECL_SELF_REFERENCE_P (type_decl)
	&& !cp_parser_uncommitted_to_tentative_parse_p (parser))
	error ("typedef-name %qD used as destructor declarator",
	type_decl);

	return build_nt (BIT_NOT_EXPR, TREE_TYPE (type_decl));
	}

	case CPP_KEYWORD:
	if (token->keyword == RID_OPERATOR)
	{
	tree id;

	/* This could be a template-id, so we try that first. */
	cp_parser_parse_tentatively (parser);
	/* Try a template-id. */
	id = cp_parser_template_id (parser, template_keyword_p,
	/check_dependency_p=/true,
	declarator_p);
	/* If that worked, we're done. */
	if (cp_parser_parse_definitely (parser))
	return id;
	/* We still don't know whether we're looking at an
	operator-function-id or a conversion-function-id. */
	cp_parser_parse_tentatively (parser);
	/* Try an operator-function-id. */
	id = cp_parser_operator_function_id (parser);
	/* If that didn't work, try a conversion-function-id. */
	if (!cp_parser_parse_definitely (parser))
	id = cp_parser_conversion_function_id (parser);

	return id;
	}
	/* Fall through. */

	default:
	if (optional_p)
	return NULL_TREE;
	cp_parser_error (parser, "expected unqualified-id");
	return error_mark_node;
	}
	}

	/* Parse an (optional) nested-name-specifier.

	nested-name-specifier:
	class-or-namespace-name :: nested-name-specifier [opt]
	class-or-namespace-name :: template nested-name-specifier [opt]

	PARSER->SCOPE should be set appropriately before this function is
	called. TYPENAME_KEYWORD_P is TRUE if the `typename' keyword is in
	effect. TYPE_P is TRUE if we non-type bindings should be ignored
	in name lookups.

	Sets PARSER->SCOPE to the class (TYPE) or namespace
	(NAMESPACE_DECL) specified by the nested-name-specifier, or leaves
	it unchanged if there is no nested-name-specifier. Returns the new
	scope iff there is a nested-name-specifier, or NULL_TREE otherwise.

	If IS_DECLARATION is TRUE, the nested-name-specifier is known to be
	part of a declaration and/or decl-specifier. */

	static tree
	cp_parser_nested_name_specifier_opt (cp_parser *parser,
	bool typename_keyword_p,
	bool check_dependency_p,
	bool type_p,
	bool is_declaration)
	{
	bool success = false;
	cp_token_position start = 0;
	cp_token *token;

	/* Remember where the nested-name-specifier starts. */
	if (cp_parser_uncommitted_to_tentative_parse_p (parser))
	{
	start = cp_lexer_token_position (parser->lexer, false);
	push_deferring_access_checks (dk_deferred);
	}

	while (true)
	{
	tree new_scope;
	tree old_scope;
	tree saved_qualifying_scope;
	bool template_keyword_p;

	/* Spot cases that cannot be the beginning of a
	nested-name-specifier. */
	token = cp_lexer_peek_token (parser->lexer);

	/* If the next token is CPP_NESTED_NAME_SPECIFIER, just process
	the already parsed nested-name-specifier. */
	if (token->type == CPP_NESTED_NAME_SPECIFIER)
	{
	/* Grab the nested-name-specifier and continue the loop. */
	cp_parser_pre_parsed_nested_name_specifier (parser);
	/* If we originally encountered this nested-name-specifier
	with IS_DECLARATION set to false, we will not have
	resolved TYPENAME_TYPEs, so we must do so here. */
	if (is_declaration
	&& TREE_CODE (parser->scope) == TYPENAME_TYPE)
	{
	new_scope = resolve_typename_type (parser->scope,
	/only_current_p=/false);
	if (new_scope != error_mark_node)
	parser->scope = new_scope;
	}
	success = true;
	continue;
	}

	/* Spot cases that cannot be the beginning of a
	nested-name-specifier. On the second and subsequent times
	through the loop, we look for the `template' keyword. */
	if (success && token->keyword == RID_TEMPLATE)
	;
	/* A template-id can start a nested-name-specifier. */
	else if (token->type == CPP_TEMPLATE_ID)
	;
	else
	{
	/* If the next token is not an identifier, then it is
	definitely not a class-or-namespace-name. */
	if (token->type != CPP_NAME)
	break;
	/* If the following token is neither a `<' (to begin a
	template-id), nor a `::', then we are not looking at a
	nested-name-specifier. */
	token = cp_lexer_peek_nth_token (parser->lexer, 2);
	if (token->type != CPP_SCOPE
	&& !cp_parser_nth_token_starts_template_argument_list_p
	(parser, 2))
	break;
	}

	/* The nested-name-specifier is optional, so we parse
	tentatively. */
	cp_parser_parse_tentatively (parser);

	/* Look for the optional `template' keyword, if this isn't the
	first time through the loop. */
	if (success)
	template_keyword_p = cp_parser_optional_template_keyword (parser);
	else
	template_keyword_p = false;

	/* Save the old scope since the name lookup we are about to do
	might destroy it. */
	old_scope = parser->scope;
	saved_qualifying_scope = parser->qualifying_scope;
	/* In a declarator-id like "X<T>::I::Y<T>" we must be able to
	look up names in "X<T>::I" in order to determine that "Y" is
	a template. So, if we have a typename at this point, we make
	an effort to look through it. */
	if (is_declaration
	&& !typename_keyword_p
	&& parser->scope
	&& TREE_CODE (parser->scope) == TYPENAME_TYPE)
	parser->scope = resolve_typename_type (parser->scope,
	/only_current_p=/false);
	/* Parse the qualifying entity. */
	new_scope
	= cp_parser_class_or_namespace_name (parser,
	typename_keyword_p,
	template_keyword_p,
	check_dependency_p,
	type_p,
	is_declaration);
	/* Look for the `::' token. */
	cp_parser_require (parser, CPP_SCOPE, "`::'");

	/* If we found what we wanted, we keep going; otherwise, we're
	done. */
	if (!cp_parser_parse_definitely (parser))
	{
	bool error_p = false;

	/* Restore the OLD_SCOPE since it was valid before the
	failed attempt at finding the last
	class-or-namespace-name. */
	parser->scope = old_scope;
	parser->qualifying_scope = saved_qualifying_scope;
	if (cp_parser_uncommitted_to_tentative_parse_p (parser))
	break;
	/* If the next token is an identifier, and the one after
	that is a `::', then any valid interpretation would have
	found a class-or-namespace-name. */
	while (cp_lexer_next_token_is (parser->lexer, CPP_NAME)
	&& (cp_lexer_peek_nth_token (parser->lexer, 2)->type
	== CPP_SCOPE)
	&& (cp_lexer_peek_nth_token (parser->lexer, 3)->type
	!= CPP_COMPL))
	{
	token = cp_lexer_consume_token (parser->lexer);
	if (!error_p)
	{
	if (!token->ambiguous_p)
	{
	tree decl;
	tree ambiguous_decls;

	decl = cp_parser_lookup_name (parser, token->u.value,
	none_type,
	/is_template=/false,
	/is_namespace=/false,
	/check_dependency=/true,
	&ambiguous_decls);
	if (TREE_CODE (decl) == TEMPLATE_DECL)
	error ("%qD used without template parameters", decl);
	else if (ambiguous_decls)
	{
	error ("reference to %qD is ambiguous",
	token->u.value);
	print_candidates (ambiguous_decls);
	decl = error_mark_node;
	}
	else
	cp_parser_name_lookup_error
	(parser, token->u.value, decl,
	"is not a class or namespace");
	}
	parser->scope = error_mark_node;
	error_p = true;
	/* Treat this as a successful nested-name-specifier
	due to:

	[basic.lookup.qual]

	If the name found is not a class-name (clause
	_class_) or namespace-name (_namespace.def_), the
	program is ill-formed. */
	success = true;
	}
	cp_lexer_consume_token (parser->lexer);
	}
	break;
	}
	/* We've found one valid nested-name-specifier. */
	success = true;
	/* Name lookup always gives us a DECL. */
	if (TREE_CODE (new_scope) == TYPE_DECL)
	new_scope = TREE_TYPE (new_scope);
	/* Uses of "template" must be followed by actual templates. */
	if (template_keyword_p
	&& !(CLASS_TYPE_P (new_scope)
	&& ((CLASSTYPE_USE_TEMPLATE (new_scope)
	&& PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (new_scope)))
	\|\| CLASSTYPE_IS_TEMPLATE (new_scope)))
	&& !(TREE_CODE (new_scope) == TYPENAME_TYPE
	&& (TREE_CODE (TYPENAME_TYPE_FULLNAME (new_scope))
	== TEMPLATE_ID_EXPR)))
	pedwarn (TYPE_P (new_scope)
	? "%qT is not a template"
	: "%qD is not a template",
	new_scope);
	/* If it is a class scope, try to complete it; we are about to
	be looking up names inside the class. */
	if (TYPE_P (new_scope)
	/* Since checking types for dependency can be expensive,
	avoid doing it if the type is already complete. */
	&& !COMPLETE_TYPE_P (new_scope)
	/* Do not try to complete dependent types. */
	&& !dependent_type_p (new_scope))
	new_scope = complete_type (new_scope);
	/* Make sure we look in the right scope the next time through
	the loop. */
	parser->scope = new_scope;
	}

	/* If parsing tentatively, replace the sequence of tokens that makes
	up the nested-name-specifier with a CPP_NESTED_NAME_SPECIFIER
	token. That way, should we re-parse the token stream, we will
	not have to repeat the effort required to do the parse, nor will
	we issue duplicate error messages. */
	if (success && start)
	{
	cp_token *token;

	token = cp_lexer_token_at (parser->lexer, start);
	/* Reset the contents of the START token. */
	token->type = CPP_NESTED_NAME_SPECIFIER;
	/* Retrieve any deferred checks. Do not pop this access checks yet
	so the memory will not be reclaimed during token replacing below. */
	token->u.tree_check_value = GGC_CNEW (struct tree_check);
	token->u.tree_check_value->value = parser->scope;
	token->u.tree_check_value->checks = get_deferred_access_checks ();
	token->u.tree_check_value->qualifying_scope =
	parser->qualifying_scope;
	token->keyword = RID_MAX;

	/* Purge all subsequent tokens. */
	cp_lexer_purge_tokens_after (parser->lexer, start);
	}

	if (start)
	pop_to_parent_deferring_access_checks ();

	return success ? parser->scope : NULL_TREE;
	}

	/* Parse a nested-name-specifier. See
	cp_parser_nested_name_specifier_opt for details. This function
	behaves identically, except that it will an issue an error if no
	nested-name-specifier is present. */

	static tree
	cp_parser_nested_name_specifier (cp_parser *parser,
	bool typename_keyword_p,
	bool check_dependency_p,
	bool type_p,
	bool is_declaration)
	{
	tree scope;

	/* Look for the nested-name-specifier. */
	scope = cp_parser_nested_name_specifier_opt (parser,
	typename_keyword_p,
	check_dependency_p,
	type_p,
	is_declaration);
	/* If it was not present, issue an error message. */
	if (!scope)
	{
	cp_parser_error (parser, "expected nested-name-specifier");
	parser->scope = NULL_TREE;
	}

	return scope;
	}

	/* Parse a class-or-namespace-name.

	class-or-namespace-name:
	class-name
	namespace-name

	TYPENAME_KEYWORD_P is TRUE iff the `typename' keyword is in effect.
	TEMPLATE_KEYWORD_P is TRUE iff the `template' keyword is in effect.
	CHECK_DEPENDENCY_P is FALSE iff dependent names should be looked up.
	TYPE_P is TRUE iff the next name should be taken as a class-name,
	even the same name is declared to be another entity in the same
	scope.

	Returns the class (TYPE_DECL) or namespace (NAMESPACE_DECL)
	specified by the class-or-namespace-name. If neither is found the
	ERROR_MARK_NODE is returned. */

	static tree
	cp_parser_class_or_namespace_name (cp_parser *parser,
	bool typename_keyword_p,
	bool template_keyword_p,
	bool check_dependency_p,
	bool type_p,
	bool is_declaration)
	{
	tree saved_scope;
	tree saved_qualifying_scope;
	tree saved_object_scope;
	tree scope;
	bool only_class_p;

	/* Before we try to parse the class-name, we must save away the
	current PARSER->SCOPE since cp_parser_class_name will destroy
	it. */
	saved_scope = parser->scope;
	saved_qualifying_scope = parser->qualifying_scope;
	saved_object_scope = parser->object_scope;
	/* Try for a class-name first. If the SAVED_SCOPE is a type, then
	there is no need to look for a namespace-name. */
	only_class_p = template_keyword_p \|\| (saved_scope && TYPE_P (saved_scope));
	if (!only_class_p)
	cp_parser_parse_tentatively (parser);
	scope = cp_parser_class_name (parser,
	typename_keyword_p,
	template_keyword_p,
	type_p ? class_type : none_type,
	check_dependency_p,
	/class_head_p=/false,
	is_declaration);
	/* If that didn't work, try for a namespace-name. */
	if (!only_class_p && !cp_parser_parse_definitely (parser))
	{
	/* Restore the saved scope. */
	parser->scope = saved_scope;
	parser->qualifying_scope = saved_qualifying_scope;
	parser->object_scope = saved_object_scope;
	/* If we are not looking at an identifier followed by the scope
	resolution operator, then this is not part of a
	nested-name-specifier. (Note that this function is only used
	to parse the components of a nested-name-specifier.) */
	if (cp_lexer_next_token_is_not (parser->lexer, CPP_NAME)
	\|\| cp_lexer_peek_nth_token (parser->lexer, 2)->type != CPP_SCOPE)
	return error_mark_node;
	scope = cp_parser_namespace_name (parser);
	}

	return scope;
	}

	/* Parse a postfix-expression.

	postfix-expression:
	primary-expression
	postfix-expression [ expression ]
	postfix-expression ( expression-list [opt] )
	simple-type-specifier ( expression-list [opt] )
	typename :: [opt] nested-name-specifier identifier
	( expression-list [opt] )
	typename :: [opt] nested-name-specifier template [opt] template-id
	( expression-list [opt] )
	postfix-expression . template [opt] id-expression
	postfix-expression -> template [opt] id-expression
	postfix-expression . pseudo-destructor-name
	postfix-expression -> pseudo-destructor-name
	postfix-expression ++
	postfix-expression --
	dynamic_cast < type-id > ( expression )
	static_cast < type-id > ( expression )
	reinterpret_cast < type-id > ( expression )
	const_cast < type-id > ( expression )
	typeid ( expression )
	typeid ( type-id )

	GNU Extension:

	postfix-expression:
	( type-id ) { initializer-list , [opt] }

	This extension is a GNU version of the C99 compound-literal
	construct. (The C99 grammar uses `type-name' instead of `type-id',
	but they are essentially the same concept.)

	If ADDRESS_P is true, the postfix expression is the operand of the
	`&' operator. CAST_P is true if this expression is the target of a
	cast.

	Returns a representation of the expression. */

	static tree
	cp_parser_postfix_expression (cp_parser *parser, bool address_p, bool cast_p)
	{
	cp_token *token;
	enum rid keyword;
	cp_id_kind idk = CP_ID_KIND_NONE;
	tree postfix_expression = NULL_TREE;

	/* Peek at the next token. */
	token = cp_lexer_peek_token (parser->lexer);
	/* Some of the productions are determined by keywords. */
	keyword = token->keyword;
	switch (keyword)
	{
	case RID_DYNCAST:
	case RID_STATCAST:
	case RID_REINTCAST:
	case RID_CONSTCAST:
	{
	tree type;
	tree expression;
	const char *saved_message;

	/* All of these can be handled in the same way from the point
	of view of parsing. Begin by consuming the token
	identifying the cast. */
	cp_lexer_consume_token (parser->lexer);

	/* New types cannot be defined in the cast. */
	saved_message = parser->type_definition_forbidden_message;
	parser->type_definition_forbidden_message
	= "types may not be defined in casts";

	/* Look for the opening `<'. */
	cp_parser_require (parser, CPP_LESS, "`<'");
	/* Parse the type to which we are casting. */
	type = cp_parser_type_id (parser);
	/* Look for the closing `>'. */
	cp_parser_require (parser, CPP_GREATER, "`>'");
	/* Restore the old message. */
	parser->type_definition_forbidden_message = saved_message;

	/* And the expression which is being cast. */
	cp_parser_require (parser, CPP_OPEN_PAREN, "`('");
	expression = cp_parser_expression (parser, /cast_p=/true);
	cp_parser_require (parser, CPP_CLOSE_PAREN, "`)'");

	/* Only type conversions to integral or enumeration types
	can be used in constant-expressions. */
	if (!cast_valid_in_integral_constant_expression_p (type)
	&& (cp_parser_non_integral_constant_expression
	(parser,
	"a cast to a type other than an integral or "
	"enumeration type")))
	return error_mark_node;

	switch (keyword)
	{
	case RID_DYNCAST:
	postfix_expression
	= build_dynamic_cast (type, expression);
	break;
	case RID_STATCAST:
	postfix_expression
	= build_static_cast (type, expression);
	break;
	case RID_REINTCAST:
	postfix_expression
	= build_reinterpret_cast (type, expression);
	break;
	case RID_CONSTCAST:
	postfix_expression
	= build_const_cast (type, expression);
	break;
	default:
	gcc_unreachable ();
	}
	}
	break;

	case RID_TYPEID:
	{
	tree type;
	const char *saved_message;
	bool saved_in_type_id_in_expr_p;

	/* Consume the `typeid' token. */
	cp_lexer_consume_token (parser->lexer);
	/* Look for the `(' token. */
	cp_parser_require (parser, CPP_OPEN_PAREN, "`('");
	/* Types cannot be defined in a `typeid' expression. */
	saved_message = parser->type_definition_forbidden_message;
	parser->type_definition_forbidden_message
	= "types may not be defined in a `typeid\' expression";
	/* We can't be sure yet whether we're looking at a type-id or an
	expression. */
	cp_parser_parse_tentatively (parser);
	/* Try a type-id first. */
	saved_in_type_id_in_expr_p = parser->in_type_id_in_expr_p;
	parser->in_type_id_in_expr_p = true;
	type = cp_parser_type_id (parser);
	parser->in_type_id_in_expr_p = saved_in_type_id_in_expr_p;
	/* Look for the `)' token. Otherwise, we can't be sure that
	we're not looking at an expression: consider `typeid (int
	(3))', for example. */
	cp_parser_require (parser, CPP_CLOSE_PAREN, "`)'");
	/* If all went well, simply lookup the type-id. */
	if (cp_parser_parse_definitely (parser))
	postfix_expression = get_typeid (type);
	/* Otherwise, fall back to the expression variant. */
	else
	{
	tree expression;

	/* Look for an expression. */
	expression = cp_parser_expression (parser, /cast_p=/false);
	/* Compute its typeid. */
	postfix_expression = build_typeid (expression);
	/* Look for the `)' token. */
	cp_parser_require (parser, CPP_CLOSE_PAREN, "`)'");
	}
	/* Restore the saved message. */
	parser->type_definition_forbidden_message = saved_message;
	/* `typeid' may not appear in an integral constant expression. */
	if (cp_parser_non_integral_constant_expression(parser,
	"`typeid' operator"))
	return error_mark_node;
	}
	break;

	case RID_TYPENAME:
	{
	tree type;
	/* The syntax permitted here is the same permitted for an
	elaborated-type-specifier. */
	type = cp_parser_elaborated_type_specifier (parser,
	/is_friend=/false,
	/is_declaration=/false);
	postfix_expression = cp_parser_functional_cast (parser, type);
	}
	break;

	default:
	{
	tree type;

	/* If the next thing is a simple-type-specifier, we may be
	looking at a functional cast. We could also be looking at
	an id-expression. So, we try the functional cast, and if
	that doesn't work we fall back to the primary-expression. */
	cp_parser_parse_tentatively (parser);
	/* Look for the simple-type-specifier. */
	type = cp_parser_simple_type_specifier (parser,
	/decl_specs=/NULL,
	CP_PARSER_FLAGS_NONE);
	/* Parse the cast itself. */
	if (!cp_parser_error_occurred (parser))
	postfix_expression
	= cp_parser_functional_cast (parser, type);
	/* If that worked, we're done. */
	if (cp_parser_parse_definitely (parser))
	break;

	/* If the functional-cast didn't work out, try a
	compound-literal. */
	if (cp_parser_allow_gnu_extensions_p (parser)
	&& cp_lexer_next_token_is (parser->lexer, CPP_OPEN_PAREN))
	{
	VEC(constructor_elt,gc) *initializer_list = NULL;
	bool saved_in_type_id_in_expr_p;

	cp_parser_parse_tentatively (parser);
	/* Consume the `('. */
	cp_lexer_consume_token (parser->lexer);
	/* Parse the type. */
	saved_in_type_id_in_expr_p = parser->in_type_id_in_expr_p;
	parser->in_type_id_in_expr_p = true;
	type = cp_parser_type_id (parser);
	parser->in_type_id_in_expr_p = saved_in_type_id_in_expr_p;
	/* Look for the `)'. */
	cp_parser_require (parser, CPP_CLOSE_PAREN, "`)'");
	/* Look for the `{'. */
	cp_parser_require (parser, CPP_OPEN_BRACE, "`{'");
	/* If things aren't going well, there's no need to
	keep going. */
	if (!cp_parser_error_occurred (parser))
	{
	bool non_constant_p;
	/* Parse the initializer-list. */
	initializer_list
	= cp_parser_initializer_list (parser, &non_constant_p);
	/* Allow a trailing `,'. */
	if (cp_lexer_next_token_is (parser->lexer, CPP_COMMA))
	cp_lexer_consume_token (parser->lexer);
	/* Look for the final `}'. */
	cp_parser_require (parser, CPP_CLOSE_BRACE, "`}'");
	}
	/* If that worked, we're definitely looking at a
	compound-literal expression. */
	if (cp_parser_parse_definitely (parser))
	{
	/* Warn the user that a compound literal is not
	allowed in standard C++. */
	if (pedantic)
	pedwarn ("ISO C++ forbids compound-literals");
	/* For simplicitly, we disallow compound literals in
	constant-expressions for simpliicitly. We could
	allow compound literals of integer type, whose
	initializer was a constant, in constant
	expressions. Permitting that usage, as a further
	extension, would not change the meaning of any
	currently accepted programs. (Of course, as
	compound literals are not part of ISO C++, the
	standard has nothing to say.) */
	if (cp_parser_non_integral_constant_expression
	(parser, "non-constant compound literals"))
	{
	postfix_expression = error_mark_node;
	break;
	}
	/* Form the representation of the compound-literal. */
	postfix_expression
	= finish_compound_literal (type, initializer_list);
	break;
	}
	}

	/* It must be a primary-expression. */
	postfix_expression
	= cp_parser_primary_expression (parser, address_p, cast_p,
	/template_arg_p=/false,
	&idk);
	}
	break;
	}

	/* Keep looping until the postfix-expression is complete. */
	while (true)
	{
	if (idk == CP_ID_KIND_UNQUALIFIED
	&& TREE_CODE (postfix_expression) == IDENTIFIER_NODE
	&& cp_lexer_next_token_is_not (parser->lexer, CPP_OPEN_PAREN))
	/* It is not a Koenig lookup function call. */
	postfix_expression
	= unqualified_name_lookup_error (postfix_expression);

	/* Peek at the next token. */
	token = cp_lexer_peek_token (parser->lexer);

	switch (token->type)
	{
	case CPP_OPEN_SQUARE:
	postfix_expression
	= cp_parser_postfix_open_square_expression (parser,
	postfix_expression,
	false);
	idk = CP_ID_KIND_NONE;
	break;

	case CPP_OPEN_PAREN:
	/* postfix-expression ( expression-list [opt] ) */
	{
	bool koenig_p;
	bool is_builtin_constant_p;
	bool saved_integral_constant_expression_p = false;
	bool saved_non_integral_constant_expression_p = false;
	tree args;

	is_builtin_constant_p
	= DECL_IS_BUILTIN_CONSTANT_P (postfix_expression);
	if (is_builtin_constant_p)
	{
	/* The whole point of __builtin_constant_p is to allow
	non-constant expressions to appear as arguments. */
	saved_integral_constant_expression_p
	= parser->integral_constant_expression_p;
	saved_non_integral_constant_expression_p
	= parser->non_integral_constant_expression_p;
	parser->integral_constant_expression_p = false;
	}
	args = (cp_parser_parenthesized_expression_list
	(parser, /is_attribute_list=/false,
	/cast_p=/false,
	/non_constant_p=/NULL));
	if (is_builtin_constant_p)
	{
	parser->integral_constant_expression_p
	= saved_integral_constant_expression_p;
	parser->non_integral_constant_expression_p
	= saved_non_integral_constant_expression_p;
	}

	if (args == error_mark_node)
	{
	postfix_expression = error_mark_node;
	break;
	}

	/* Function calls are not permitted in
	constant-expressions. */
	if (! builtin_valid_in_constant_expr_p (postfix_expression)
	&& cp_parser_non_integral_constant_expression (parser,
	"a function call"))
	{
	postfix_expression = error_mark_node;
	break;
	}

	koenig_p = false;
	if (idk == CP_ID_KIND_UNQUALIFIED)
	{
	if (TREE_CODE (postfix_expression) == IDENTIFIER_NODE)
	{
	if (args)
	{
	koenig_p = true;
	postfix_expression
	= perform_koenig_lookup (postfix_expression, args);
	}
	else
	postfix_expression
	= unqualified_fn_lookup_error (postfix_expression);
	}
	/* We do not perform argument-dependent lookup if
	normal lookup finds a non-function, in accordance
	with the expected resolution of DR 218. */
	else if (args && is_overloaded_fn (postfix_expression))
	{
	tree fn = get_first_fn (postfix_expression);

	if (TREE_CODE (fn) == TEMPLATE_ID_EXPR)
	fn = OVL_CURRENT (TREE_OPERAND (fn, 0));

	/* Only do argument dependent lookup if regular
	lookup does not find a set of member functions.
	[basic.lookup.koenig]/2a */
	if (!DECL_FUNCTION_MEMBER_P (fn))
	{
	koenig_p = true;
	postfix_expression
	= perform_koenig_lookup (postfix_expression, args);
	}
	}
	}

	if (TREE_CODE (postfix_expression) == COMPONENT_REF)
	{
	tree instance = TREE_OPERAND (postfix_expression, 0);
	tree fn = TREE_OPERAND (postfix_expression, 1);

	if (processing_template_decl
	&& (type_dependent_expression_p (instance)
	\|\| (!BASELINK_P (fn)
	&& TREE_CODE (fn) != FIELD_DECL)
	\|\| type_dependent_expression_p (fn)
	\|\| any_type_dependent_arguments_p (args)))
	{
	postfix_expression
	= build_min_nt (CALL_EXPR, postfix_expression,
	args, NULL_TREE);
	break;
	}

	if (BASELINK_P (fn))
	postfix_expression
	= (build_new_method_call
	(instance, fn, args, NULL_TREE,
	(idk == CP_ID_KIND_QUALIFIED
	? LOOKUP_NONVIRTUAL : LOOKUP_NORMAL),
	/fn_p=/NULL));
	else
	postfix_expression
	= finish_call_expr (postfix_expression, args,
	/disallow_virtual=/false,
	/koenig_p=/false);
	}
	else if (TREE_CODE (postfix_expression) == OFFSET_REF
	\|\| TREE_CODE (postfix_expression) == MEMBER_REF
	\|\| TREE_CODE (postfix_expression) == DOTSTAR_EXPR)
	postfix_expression = (build_offset_ref_call_from_tree
	(postfix_expression, args));
	else if (idk == CP_ID_KIND_QUALIFIED)
	/* A call to a static class member, or a namespace-scope
	function. */
	postfix_expression
	= finish_call_expr (postfix_expression, args,
	/disallow_virtual=/true,
	koenig_p);
	else
	/* All other function calls. */
	postfix_expression
	= finish_call_expr (postfix_expression, args,
	/disallow_virtual=/false,
	koenig_p);

	/* The POSTFIX_EXPRESSION is certainly no longer an id. */
	idk = CP_ID_KIND_NONE;
	}
	break;

	case CPP_DOT:
	case CPP_DEREF:
	/* postfix-expression . template [opt] id-expression
	postfix-expression . pseudo-destructor-name
	postfix-expression -> template [opt] id-expression
	postfix-expression -> pseudo-destructor-name */

	/* Consume the `.' or `->' operator. */
	cp_lexer_consume_token (parser->lexer);

	postfix_expression
	= cp_parser_postfix_dot_deref_expression (parser, token->type,
	postfix_expression,
	false, &idk);
	break;

	case CPP_PLUS_PLUS:
	/* postfix-expression ++ */
	/* Consume the `++' token. */
	cp_lexer_consume_token (parser->lexer);
	/* Generate a representation for the complete expression. */
	postfix_expression
	= finish_increment_expr (postfix_expression,
	POSTINCREMENT_EXPR);
	/* Increments may not appear in constant-expressions. */
	if (cp_parser_non_integral_constant_expression (parser,
	"an increment"))
	postfix_expression = error_mark_node;
	idk = CP_ID_KIND_NONE;
	break;

	case CPP_MINUS_MINUS:
	/* postfix-expression -- */
	/* Consume the `--' token. */
	cp_lexer_consume_token (parser->lexer);
	/* Generate a representation for the complete expression. */
	postfix_expression
	= finish_increment_expr (postfix_expression,
	POSTDECREMENT_EXPR);
	/* Decrements may not appear in constant-expressions. */
	if (cp_parser_non_integral_constant_expression (parser,
	"a decrement"))
	postfix_expression = error_mark_node;
	idk = CP_ID_KIND_NONE;
	break;

	default:
	return postfix_expression;
	}
	}

	/* We should never get here. */
	gcc_unreachable ();
	return error_mark_node;
	}

	/* A subroutine of cp_parser_postfix_expression that also gets hijacked
	by cp_parser_builtin_offsetof. We're looking for

	postfix-expression [ expression ]

	FOR_OFFSETOF is set if we're being called in that context, which
	changes how we deal with integer constant expressions. */

	static tree
	cp_parser_postfix_open_square_expression (cp_parser *parser,
	tree postfix_expression,
	bool for_offsetof)
	{
	tree index;

	/* Consume the `[' token. */
	cp_lexer_consume_token (parser->lexer);

	/* Parse the index expression. */
	/* ??? For offsetof, there is a question of what to allow here. If
	offsetof is not being used in an integral constant expression context,
	then we could get the right answer by computing the value at runtime.
	If we are in an integral constant expression context, then we might
	could accept any constant expression; hard to say without analysis.
	Rather than open the barn door too wide right away, allow only integer
	constant expressions here. */
	if (for_offsetof)
	index = cp_parser_constant_expression (parser, false, NULL);
	else
	index = cp_parser_expression (parser, /cast_p=/false);

	/* Look for the closing `]'. */
	cp_parser_require (parser, CPP_CLOSE_SQUARE, "`]'");

	/* Build the ARRAY_REF. */
	postfix_expression = grok_array_decl (postfix_expression, index);

	/* When not doing offsetof, array references are not permitted in
	constant-expressions. */
	if (!for_offsetof
	&& (cp_parser_non_integral_constant_expression
	(parser, "an array reference")))
	postfix_expression = error_mark_node;

	return postfix_expression;
	}

	/* A subroutine of cp_parser_postfix_expression that also gets hijacked
	by cp_parser_builtin_offsetof. We're looking for

	postfix-expression . template [opt] id-expression
	postfix-expression . pseudo-destructor-name
	postfix-expression -> template [opt] id-expression
	postfix-expression -> pseudo-destructor-name

	FOR_OFFSETOF is set if we're being called in that context. That sorta
	limits what of the above we'll actually accept, but nevermind.
	TOKEN_TYPE is the "." or "->" token, which will already have been
	removed from the stream. */

	static tree
	cp_parser_postfix_dot_deref_expression (cp_parser *parser,
	enum cpp_ttype token_type,
	tree postfix_expression,
	bool for_offsetof, cp_id_kind *idk)
	{
	tree name;
	bool dependent_p;
	bool pseudo_destructor_p;
	tree scope = NULL_TREE;

	/* If this is a `->' operator, dereference the pointer. */
	if (token_type == CPP_DEREF)
	postfix_expression = build_x_arrow (postfix_expression);
	/* Check to see whether or not the expression is type-dependent. */
	dependent_p = type_dependent_expression_p (postfix_expression);
	/* The identifier following the `->' or `.' is not qualified. */
	parser->scope = NULL_TREE;
	parser->qualifying_scope = NULL_TREE;
	parser->object_scope = NULL_TREE;
	*idk = CP_ID_KIND_NONE;
	/* Enter the scope corresponding to the type of the object
	given by the POSTFIX_EXPRESSION. */
	if (!dependent_p && TREE_TYPE (postfix_expression) != NULL_TREE)
	{
	scope = TREE_TYPE (postfix_expression);
	/* According to the standard, no expression should ever have
	reference type. Unfortunately, we do not currently match
	the standard in this respect in that our internal representation
	of an expression may have reference type even when the standard
	says it does not. Therefore, we have to manually obtain the
	underlying type here. */
	scope = non_reference (scope);
	/* The type of the POSTFIX_EXPRESSION must be complete. */
	if (scope == unknown_type_node)
	{
	error ("%qE does not have class type", postfix_expression);
	scope = NULL_TREE;
	}
	else
	scope = complete_type_or_else (scope, NULL_TREE);
	/* Let the name lookup machinery know that we are processing a
	class member access expression. */
	parser->context->object_type = scope;
	/* If something went wrong, we want to be able to discern that case,
	as opposed to the case where there was no SCOPE due to the type
	of expression being dependent. */
	if (!scope)
	scope = error_mark_node;
	/* If the SCOPE was erroneous, make the various semantic analysis
	functions exit quickly -- and without issuing additional error
	messages. */
	if (scope == error_mark_node)
	postfix_expression = error_mark_node;
	}

	/* Assume this expression is not a pseudo-destructor access. */
	pseudo_destructor_p = false;

	/* If the SCOPE is a scalar type, then, if this is a valid program,
	we must be looking at a pseudo-destructor-name. */
	if (scope && SCALAR_TYPE_P (scope))
	{
	tree s;
	tree type;

	cp_parser_parse_tentatively (parser);
	/* Parse the pseudo-destructor-name. */
	s = NULL_TREE;
	cp_parser_pseudo_destructor_name (parser, &s, &type);
	if (cp_parser_parse_definitely (parser))
	{
	pseudo_destructor_p = true;
	postfix_expression
	= finish_pseudo_destructor_expr (postfix_expression,
	s, TREE_TYPE (type));
	}
	}

	if (!pseudo_destructor_p)
	{
	/* If the SCOPE is not a scalar type, we are looking at an
	ordinary class member access expression, rather than a
	pseudo-destructor-name. */
	bool template_p;
	/* Parse the id-expression. */
	name = (cp_parser_id_expression
	(parser,
	cp_parser_optional_template_keyword (parser),
	/check_dependency_p=/true,
	&template_p,
	/declarator_p=/false,
	/optional_p=/false));
	/* In general, build a SCOPE_REF if the member name is qualified.
	However, if the name was not dependent and has already been
	resolved; there is no need to build the SCOPE_REF. For example;

	struct X { void f(); };
	template <typename T> void f(T* t) { t->X::f(); }

	Even though "t" is dependent, "X::f" is not and has been resolved
	to a BASELINK; there is no need to include scope information. */

	/* But we do need to remember that there was an explicit scope for
	virtual function calls. */
	if (parser->scope)
	*idk = CP_ID_KIND_QUALIFIED;

	/* If the name is a template-id that names a type, we will get a
	TYPE_DECL here. That is invalid code. */
	if (TREE_CODE (name) == TYPE_DECL)
	{
	error ("invalid use of %qD", name);
	postfix_expression = error_mark_node;
	}
	else
	{
	if (name != error_mark_node && !BASELINK_P (name) && parser->scope)
	{
	name = build_qualified_name (/type=/NULL_TREE,
	parser->scope,
	name,
	template_p);
	parser->scope = NULL_TREE;
	parser->qualifying_scope = NULL_TREE;
	parser->object_scope = NULL_TREE;
	}
	if (scope && name && BASELINK_P (name))
	adjust_result_of_qualified_name_lookup
	(name, BINFO_TYPE (BASELINK_ACCESS_BINFO (name)), scope);
	postfix_expression
	= finish_class_member_access_expr (postfix_expression, name,
	template_p);
	}
	}

	/* We no longer need to look up names in the scope of the object on
	the left-hand side of the `.' or `->' operator. */
	parser->context->object_type = NULL_TREE;

	/* Outside of offsetof, these operators may not appear in
	constant-expressions. */
	if (!for_offsetof
	&& (cp_parser_non_integral_constant_expression
	(parser, token_type == CPP_DEREF ? "'->'" : "`.'")))
	postfix_expression = error_mark_node;

	return postfix_expression;
	}

	/* Parse a parenthesized expression-list.

	expression-list:
	assignment-expression
	expression-list, assignment-expression

	attribute-list:
	expression-list
	identifier
	identifier, expression-list

	CAST_P is true if this expression is the target of a cast.

	Returns a TREE_LIST. The TREE_VALUE of each node is a
	representation of an assignment-expression. Note that a TREE_LIST
	is returned even if there is only a single expression in the list.
	error_mark_node is returned if the ( and or ) are
	missing. NULL_TREE is returned on no expressions. The parentheses
	are eaten. IS_ATTRIBUTE_LIST is true if this is really an attribute
	list being parsed. If NON_CONSTANT_P is non-NULL, *NON_CONSTANT_P
	indicates whether or not all of the expressions in the list were
	constant. */

	static tree
	cp_parser_parenthesized_expression_list (cp_parser* parser,
	bool is_attribute_list,
	bool cast_p,
	bool *non_constant_p)
	{
	tree expression_list = NULL_TREE;
	bool fold_expr_p = is_attribute_list;
	tree identifier = NULL_TREE;

	/* Assume all the expressions will be constant. */
	if (non_constant_p)
	*non_constant_p = false;

	if (!cp_parser_require (parser, CPP_OPEN_PAREN, "`('"))
	return error_mark_node;

	/* Consume expressions until there are no more. */
	if (cp_lexer_next_token_is_not (parser->lexer, CPP_CLOSE_PAREN))
	while (true)
	{
	tree expr;

	/* At the beginning of attribute lists, check to see if the
	next token is an identifier. */
	if (is_attribute_list
	&& cp_lexer_peek_token (parser->lexer)->type == CPP_NAME)
	{
	cp_token *token;

	/* Consume the identifier. */
	token = cp_lexer_consume_token (parser->lexer);
	/* Save the identifier. */
	identifier = token->u.value;
	}
	else
	{
	/* Parse the next assignment-expression. */
	if (non_constant_p)
	{
	bool expr_non_constant_p;
	expr = (cp_parser_constant_expression
	(parser, /allow_non_constant_p=/true,
	&expr_non_constant_p));
	if (expr_non_constant_p)
	*non_constant_p = true;
	}
	else
	expr = cp_parser_assignment_expression (parser, cast_p);

	if (fold_expr_p)
	expr = fold_non_dependent_expr (expr);

	/* Add it to the list. We add error_mark_node
	expressions to the list, so that we can still tell if
	the correct form for a parenthesized expression-list
	is found. That gives better errors. */
	expression_list = tree_cons (NULL_TREE, expr, expression_list);

	if (expr == error_mark_node)
	goto skip_comma;
	}

	/* After the first item, attribute lists look the same as
	expression lists. */
	is_attribute_list = false;

	get_comma:;
	/* If the next token isn't a `,', then we are done. */
	if (cp_lexer_next_token_is_not (parser->lexer, CPP_COMMA))
	break;

	/* Otherwise, consume the `,' and keep going. */
	cp_lexer_consume_token (parser->lexer);
	}

	if (!cp_parser_require (parser, CPP_CLOSE_PAREN, "`)'"))
	{
	int ending;

	skip_comma:;
	/* We try and resync to an unnested comma, as that will give the
	user better diagnostics. */
	ending = cp_parser_skip_to_closing_parenthesis (parser,
	/recovering=/true,
	/or_comma=/true,
	/consume_paren=/true);
	if (ending < 0)
	goto get_comma;
	if (!ending)
	return error_mark_node;
	}

	/* We built up the list in reverse order so we must reverse it now. */
	expression_list = nreverse (expression_list);
	if (identifier)
	expression_list = tree_cons (NULL_TREE, identifier, expression_list);

	return expression_list;
	}

	/* Parse a pseudo-destructor-name.

	pseudo-destructor-name:
	:: [opt] nested-name-specifier [opt] type-name :: ~ type-name
	:: [opt] nested-name-specifier template template-id :: ~ type-name
	:: [opt] nested-name-specifier [opt] ~ type-name

	If either of the first two productions is used, sets *SCOPE to the
	TYPE specified before the final `::'. Otherwise, *SCOPE is set to
	NULL_TREE. *TYPE is set to the TYPE_DECL for the final type-name,
	or ERROR_MARK_NODE if the parse fails. */

	static void
	cp_parser_pseudo_destructor_name (cp_parser* parser,
	tree* scope,
	tree* type)
	{
	bool nested_name_specifier_p;

	/* Assume that things will not work out. */
	*type = error_mark_node;

	/* Look for the optional `::' operator. */
	cp_parser_global_scope_opt (parser, /current_scope_valid_p=/true);
	/* Look for the optional nested-name-specifier. */
	nested_name_specifier_p
	= (cp_parser_nested_name_specifier_opt (parser,
	/typename_keyword_p=/false,
	/check_dependency_p=/true,
	/type_p=/false,
	/is_declaration=/true)
	!= NULL_TREE);
	/* Now, if we saw a nested-name-specifier, we might be doing the
	second production. */
	if (nested_name_specifier_p
	&& cp_lexer_next_token_is_keyword (parser->lexer, RID_TEMPLATE))
	{
	/* Consume the `template' keyword. */
	cp_lexer_consume_token (parser->lexer);
	/* Parse the template-id. */
	cp_parser_template_id (parser,
	/template_keyword_p=/true,
	/check_dependency_p=/false,
	/is_declaration=/true);
	/* Look for the `::' token. */
	cp_parser_require (parser, CPP_SCOPE, "`::'");
	}
	/* If the next token is not a `~', then there might be some
	additional qualification. */
	else if (cp_lexer_next_token_is_not (parser->lexer, CPP_COMPL))
	{
	/* Look for the type-name. */
	*scope = TREE_TYPE (cp_parser_type_name (parser));

	if (*scope == error_mark_node)
	return;

	/* If we don't have ::~, then something has gone wrong. Since
	the only caller of this function is looking for something
	after `.' or `->' after a scalar type, most likely the
	program is trying to get a member of a non-aggregate
	type. */
	if (cp_lexer_next_token_is_not (parser->lexer, CPP_SCOPE)
	\|\| cp_lexer_peek_nth_token (parser->lexer, 2)->type != CPP_COMPL)
	{
	cp_parser_error (parser, "request for member of non-aggregate type");
	return;
	}

	/* Look for the `::' token. */
	cp_parser_require (parser, CPP_SCOPE, "`::'");
	}
	else
	*scope = NULL_TREE;

	/* Look for the `~'. */
	cp_parser_require (parser, CPP_COMPL, "`~'");
	/* Look for the type-name again. We are not responsible for
	checking that it matches the first type-name. */
	*type = cp_parser_type_name (parser);
	}

	/* Parse a unary-expression.

	unary-expression:
	postfix-expression
	++ cast-expression
	-- cast-expression
	unary-operator cast-expression
	sizeof unary-expression
	sizeof ( type-id )
	new-expression
	delete-expression

	GNU Extensions:

	unary-expression:
	__extension__ cast-expression
	__alignof__ unary-expression
	__alignof__ ( type-id )
	__real__ cast-expression
	__imag__ cast-expression
	&& identifier

	ADDRESS_P is true iff the unary-expression is appearing as the
	operand of the `&' operator. CAST_P is true if this expression is
	the target of a cast.

	Returns a representation of the expression. */

	static tree
	cp_parser_unary_expression (cp_parser *parser, bool address_p, bool cast_p)
	{
	cp_token *token;
	enum tree_code unary_operator;

	/* Peek at the next token. */
	token = cp_lexer_peek_token (parser->lexer);
	/* Some keywords give away the kind of expression. */
	if (token->type == CPP_KEYWORD)
	{
	enum rid keyword = token->keyword;

	switch (keyword)
	{
	case RID_ALIGNOF:
	case RID_SIZEOF:
	{
	tree operand;
	enum tree_code op;

	op = keyword == RID_ALIGNOF ? ALIGNOF_EXPR : SIZEOF_EXPR;
	/* Consume the token. */
	cp_lexer_consume_token (parser->lexer);
	/* Parse the operand. */
	operand = cp_parser_sizeof_operand (parser, keyword);

	if (TYPE_P (operand))
	return cxx_sizeof_or_alignof_type (operand, op, true);
	else
	return cxx_sizeof_or_alignof_expr (operand, op);
	}

	case RID_NEW:
	return cp_parser_new_expression (parser);

	case RID_DELETE:
	return cp_parser_delete_expression (parser);

	case RID_EXTENSION:
	{
	/* The saved value of the PEDANTIC flag. */
	int saved_pedantic;
	tree expr;

	/* Save away the PEDANTIC flag. */
	cp_parser_extension_opt (parser, &saved_pedantic);
	/* Parse the cast-expression. */
	expr = cp_parser_simple_cast_expression (parser);
	/* Restore the PEDANTIC flag. */
	pedantic = saved_pedantic;

	return expr;
	}

	case RID_REALPART:
	case RID_IMAGPART:
	{
	tree expression;

	/* Consume the `__real__' or `__imag__' token. */
	cp_lexer_consume_token (parser->lexer);
	/* Parse the cast-expression. */
	expression = cp_parser_simple_cast_expression (parser);
	/* Create the complete representation. */
	return build_x_unary_op ((keyword == RID_REALPART
	? REALPART_EXPR : IMAGPART_EXPR),
	expression);
	}
	break;

	default:
	break;
	}
	}

	/* Look for the `:: new' and `:: delete', which also signal the
	beginning of a new-expression, or delete-expression,
	respectively. If the next token is `::', then it might be one of
	these. */
	if (cp_lexer_next_token_is (parser->lexer, CPP_SCOPE))
	{
	enum rid keyword;

	/* See if the token after the `::' is one of the keywords in
	which we're interested. */
	keyword = cp_lexer_peek_nth_token (parser->lexer, 2)->keyword;
	/* If it's `new', we have a new-expression. */
	if (keyword == RID_NEW)
	return cp_parser_new_expression (parser);
	/* Similarly, for `delete'. */
	else if (keyword == RID_DELETE)
	return cp_parser_delete_expression (parser);
	}

	/* Look for a unary operator. */
	unary_operator = cp_parser_unary_operator (token);
	/* The `++' and `--' operators can be handled similarly, even though
	they are not technically unary-operators in the grammar. */
	if (unary_operator == ERROR_MARK)
	{
	if (token->type == CPP_PLUS_PLUS)
	unary_operator = PREINCREMENT_EXPR;
	else if (token->type == CPP_MINUS_MINUS)
	unary_operator = PREDECREMENT_EXPR;
	/* Handle the GNU address-of-label extension. */
	else if (cp_parser_allow_gnu_extensions_p (parser)
	&& token->type == CPP_AND_AND)
	{
	tree identifier;

	/* Consume the '&&' token. */
	cp_lexer_consume_token (parser->lexer);
	/* Look for the identifier. */
	identifier = cp_parser_identifier (parser);
	/* Create an expression representing the address. */
	return finish_label_address_expr (identifier);
	}
	}
	if (unary_operator != ERROR_MARK)
	{
	tree cast_expression;
	tree expression = error_mark_node;
	const char *non_constant_p = NULL;

	/* Consume the operator token. */
	token = cp_lexer_consume_token (parser->lexer);
	/* Parse the cast-expression. */
	cast_expression
	= cp_parser_cast_expression (parser,
	unary_operator == ADDR_EXPR,
	/cast_p=/false);
	/* Now, build an appropriate representation. */
	switch (unary_operator)
	{
	case INDIRECT_REF:
	non_constant_p = "`*'";
	expression = build_x_indirect_ref (cast_expression, "unary *");
	break;

	case ADDR_EXPR:
	non_constant_p = "`&'";
	/* Fall through. */
	case BIT_NOT_EXPR:
	expression = build_x_unary_op (unary_operator, cast_expression);
	break;

	case PREINCREMENT_EXPR:
	case PREDECREMENT_EXPR:
	non_constant_p = (unary_operator == PREINCREMENT_EXPR
	? "`++'" : "`--'");
	/* Fall through. */
	case UNARY_PLUS_EXPR:
	case NEGATE_EXPR:
	case TRUTH_NOT_EXPR:
	expression = finish_unary_op_expr (unary_operator, cast_expression);
	break;

	default:
	gcc_unreachable ();
	}

	if (non_constant_p
	&& cp_parser_non_integral_constant_expression (parser,
	non_constant_p))
	expression = error_mark_node;

	return expression;
	}

	return cp_parser_postfix_expression (parser, address_p, cast_p);
	}

	/* Returns ERROR_MARK if TOKEN is not a unary-operator. If TOKEN is a
	unary-operator, the corresponding tree code is returned. */

	static enum tree_code
	cp_parser_unary_operator (cp_token* token)
	{
	switch (token->type)
	{
	case CPP_MULT:
	return INDIRECT_REF;

	case CPP_AND:
	return ADDR_EXPR;

	case CPP_PLUS:
	return UNARY_PLUS_EXPR;

	case CPP_MINUS:
	return NEGATE_EXPR;

	case CPP_NOT:
	return TRUTH_NOT_EXPR;

	case CPP_COMPL:
	return BIT_NOT_EXPR;

	default:
	return ERROR_MARK;
	}
	}

	/* Parse a new-expression.

	new-expression:
	:: [opt] new new-placement [opt] new-type-id new-initializer [opt]
	:: [opt] new new-placement [opt] ( type-id ) new-initializer [opt]

	Returns a representation of the expression. */

	static tree
	cp_parser_new_expression (cp_parser* parser)
	{
	bool global_scope_p;
	tree placement;
	tree type;
	tree initializer;
	tree nelts;

	/* Look for the optional `::' operator. */
	global_scope_p
	= (cp_parser_global_scope_opt (parser,
	/current_scope_valid_p=/false)
	!= NULL_TREE);
	/* Look for the `new' operator. */
	cp_parser_require_keyword (parser, RID_NEW, "`new'");
	/* There's no easy way to tell a new-placement from the
	`( type-id )' construct. */
	cp_parser_parse_tentatively (parser);
	/* Look for a new-placement. */
	placement = cp_parser_new_placement (parser);
	/* If that didn't work out, there's no new-placement. */
	if (!cp_parser_parse_definitely (parser))
	placement = NULL_TREE;

	/* If the next token is a `(', then we have a parenthesized
	type-id. */
	if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_PAREN))
	{
	/* Consume the `('. */
	cp_lexer_consume_token (parser->lexer);
	/* Parse the type-id. */
	type = cp_parser_type_id (parser);
	/* Look for the closing `)'. */
	cp_parser_require (parser, CPP_CLOSE_PAREN, "`)'");
	/* There should not be a direct-new-declarator in this production,
	but GCC used to allowed this, so we check and emit a sensible error
	message for this case. */
	if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_SQUARE))
	{
	error ("array bound forbidden after parenthesized type-id");
	inform ("try removing the parentheses around the type-id");
	cp_parser_direct_new_declarator (parser);
	}
	nelts = NULL_TREE;
	}
	/* Otherwise, there must be a new-type-id. */
	else
	type = cp_parser_new_type_id (parser, &nelts);

	/* If the next token is a `(', then we have a new-initializer. */
	if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_PAREN))
	initializer = cp_parser_new_initializer (parser);
	else
	initializer = NULL_TREE;

	/* A new-expression may not appear in an integral constant
	expression. */
	if (cp_parser_non_integral_constant_expression (parser, "`new'"))
	return error_mark_node;

	/* Create a representation of the new-expression. */
	return build_new (placement, type, nelts, initializer, global_scope_p);
	}

	/* Parse a new-placement.

	new-placement:
	( expression-list )

	Returns the same representation as for an expression-list. */

	static tree
	cp_parser_new_placement (cp_parser* parser)
	{
	tree expression_list;

	/* Parse the expression-list. */
	expression_list = (cp_parser_parenthesized_expression_list
	(parser, false, /cast_p=/false,
	/non_constant_p=/NULL));

	return expression_list;
	}

	/* Parse a new-type-id.

	new-type-id:
	type-specifier-seq new-declarator [opt]

	Returns the TYPE allocated. If the new-type-id indicates an array
	type, *NELTS is set to the number of elements in the last array
	bound; the TYPE will not include the last array bound. */

	static tree
	cp_parser_new_type_id (cp_parser* parser, tree *nelts)
	{
	cp_decl_specifier_seq type_specifier_seq;
	cp_declarator *new_declarator;
	cp_declarator *declarator;
	cp_declarator *outer_declarator;
	const char *saved_message;
	tree type;

	/* The type-specifier sequence must not contain type definitions.
	(It cannot contain declarations of new types either, but if they
	are not definitions we will catch that because they are not
	complete.) */
	saved_message = parser->type_definition_forbidden_message;
	parser->type_definition_forbidden_message
	= "types may not be defined in a new-type-id";
	/* Parse the type-specifier-seq. */
	cp_parser_type_specifier_seq (parser, /is_condition=/false,
	&type_specifier_seq);
	/* Restore the old message. */
	parser->type_definition_forbidden_message = saved_message;
	/* Parse the new-declarator. */
	new_declarator = cp_parser_new_declarator_opt (parser);

	/* Determine the number of elements in the last array dimension, if
	any. */
	*nelts = NULL_TREE;
	/* Skip down to the last array dimension. */
	declarator = new_declarator;
	outer_declarator = NULL;
	while (declarator && (declarator->kind == cdk_pointer
	\|\| declarator->kind == cdk_ptrmem))
	{
	outer_declarator = declarator;
	declarator = declarator->declarator;
	}
	while (declarator
	&& declarator->kind == cdk_array
	&& declarator->declarator
	&& declarator->declarator->kind == cdk_array)
	{
	outer_declarator = declarator;
	declarator = declarator->declarator;
	}

	if (declarator && declarator->kind == cdk_array)
	{
	*nelts = declarator->u.array.bounds;
	if (*nelts == error_mark_node)
	*nelts = integer_one_node;

	if (outer_declarator)
	outer_declarator->declarator = declarator->declarator;
	else
	new_declarator = NULL;
	}

	type = groktypename (&type_specifier_seq, new_declarator);
	if (TREE_CODE (type) == ARRAY_TYPE && *nelts == NULL_TREE)
	{
	*nelts = array_type_nelts_top (type);
	type = TREE_TYPE (type);
	}
	return type;
	}

	/* Parse an (optional) new-declarator.

	new-declarator:
	ptr-operator new-declarator [opt]
	direct-new-declarator

	Returns the declarator. */

	static cp_declarator *
	cp_parser_new_declarator_opt (cp_parser* parser)
	{
	enum tree_code code;
	tree type;
	cp_cv_quals cv_quals;

	/* We don't know if there's a ptr-operator next, or not. */
	cp_parser_parse_tentatively (parser);
	/* Look for a ptr-operator. */
	code = cp_parser_ptr_operator (parser, &type, &cv_quals);
	/* If that worked, look for more new-declarators. */
	if (cp_parser_parse_definitely (parser))
	{
	cp_declarator *declarator;

	/* Parse another optional declarator. */
	declarator = cp_parser_new_declarator_opt (parser);

	/* Create the representation of the declarator. */
	if (type)
	declarator = make_ptrmem_declarator (cv_quals, type, declarator);
	else if (code == INDIRECT_REF)
	declarator = make_pointer_declarator (cv_quals, declarator);
	else
	declarator = make_reference_declarator (cv_quals, declarator);

	return declarator;
	}

	/* If the next token is a `[', there is a direct-new-declarator. */
	if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_SQUARE))
	return cp_parser_direct_new_declarator (parser);

	return NULL;
	}

	/* Parse a direct-new-declarator.

	direct-new-declarator:
	[ expression ]
	direct-new-declarator [constant-expression]

	*/

	static cp_declarator *
	cp_parser_direct_new_declarator (cp_parser* parser)
	{
	cp_declarator *declarator = NULL;

	while (true)
	{
	tree expression;

	/* Look for the opening `['. */
	cp_parser_require (parser, CPP_OPEN_SQUARE, "`['");
	/* The first expression is not required to be constant. */
	if (!declarator)
	{
	expression = cp_parser_expression (parser, /cast_p=/false);
	/* The standard requires that the expression have integral
	type. DR 74 adds enumeration types. We believe that the
	real intent is that these expressions be handled like the
	expression in a `switch' condition, which also allows
	classes with a single conversion to integral or
	enumeration type. */
	if (!processing_template_decl)
	{
	expression
	= build_expr_type_conversion (WANT_INT \| WANT_ENUM,
	expression,
	/complain=/true);
	if (!expression)
	{
	error ("expression in new-declarator must have integral "
	"or enumeration type");
	expression = error_mark_node;
	}
	}
	}
	/* But all the other expressions must be. */
	else
	expression
	= cp_parser_constant_expression (parser,
	/allow_non_constant=/false,
	NULL);
	/* Look for the closing `]'. */
	cp_parser_require (parser, CPP_CLOSE_SQUARE, "`]'");

	/* Add this bound to the declarator. */
	declarator = make_array_declarator (declarator, expression);

	/* If the next token is not a `[', then there are no more
	bounds. */
	if (cp_lexer_next_token_is_not (parser->lexer, CPP_OPEN_SQUARE))
	break;
	}

	return declarator;
	}

	/* Parse a new-initializer.

	new-initializer:
	( expression-list [opt] )

	Returns a representation of the expression-list. If there is no
	expression-list, VOID_ZERO_NODE is returned. */

	static tree
	cp_parser_new_initializer (cp_parser* parser)
	{
	tree expression_list;

	expression_list = (cp_parser_parenthesized_expression_list
	(parser, false, /cast_p=/false,
	/non_constant_p=/NULL));
	if (!expression_list)
	expression_list = void_zero_node;

	return expression_list;
	}

	/* Parse a delete-expression.

	delete-expression:
	:: [opt] delete cast-expression
	:: [opt] delete [ ] cast-expression

	Returns a representation of the expression. */

	static tree
	cp_parser_delete_expression (cp_parser* parser)
	{
	bool global_scope_p;
	bool array_p;
	tree expression;

	/* Look for the optional `::' operator. */
	global_scope_p
	= (cp_parser_global_scope_opt (parser,
	/current_scope_valid_p=/false)
	!= NULL_TREE);
	/* Look for the `delete' keyword. */
	cp_parser_require_keyword (parser, RID_DELETE, "`delete'");
	/* See if the array syntax is in use. */
	if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_SQUARE))
	{
	/* Consume the `[' token. */
	cp_lexer_consume_token (parser->lexer);
	/* Look for the `]' token. */
	cp_parser_require (parser, CPP_CLOSE_SQUARE, "`]'");
	/* Remember that this is the `[]' construct. */
	array_p = true;
	}
	else
	array_p = false;

	/* Parse the cast-expression. */
	expression = cp_parser_simple_cast_expression (parser);

	/* A delete-expression may not appear in an integral constant
	expression. */
	if (cp_parser_non_integral_constant_expression (parser, "`delete'"))
	return error_mark_node;

	return delete_sanity (expression, NULL_TREE, array_p, global_scope_p);
	}

	/* Parse a cast-expression.

	cast-expression:
	unary-expression
	( type-id ) cast-expression

	ADDRESS_P is true iff the unary-expression is appearing as the
	operand of the `&' operator. CAST_P is true if this expression is
	the target of a cast.

	Returns a representation of the expression. */

	static tree
	cp_parser_cast_expression (cp_parser *parser, bool address_p, bool cast_p)
	{
	/* If it's a `(', then we might be looking at a cast. */
	if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_PAREN))
	{
	tree type = NULL_TREE;
	tree expr = NULL_TREE;
	bool compound_literal_p;
	const char *saved_message;

	/* There's no way to know yet whether or not this is a cast.
	For example, `(int (3))' is a unary-expression, while `(int)
	3' is a cast. So, we resort to parsing tentatively. */
	cp_parser_parse_tentatively (parser);
	/* Types may not be defined in a cast. */
	saved_message = parser->type_definition_forbidden_message;
	parser->type_definition_forbidden_message
	= "types may not be defined in casts";
	/* Consume the `('. */
	cp_lexer_consume_token (parser->lexer);
	/* A very tricky bit is that `(struct S) { 3 }' is a
	compound-literal (which we permit in C++ as an extension).
	But, that construct is not a cast-expression -- it is a
	postfix-expression. (The reason is that `(struct S) { 3 }.i'
	is legal; if the compound-literal were a cast-expression,
	you'd need an extra set of parentheses.) But, if we parse
	the type-id, and it happens to be a class-specifier, then we
	will commit to the parse at that point, because we cannot
	undo the action that is done when creating a new class. So,
	then we cannot back up and do a postfix-expression.

	Therefore, we scan ahead to the closing `)', and check to see
	if the token after the `)' is a `{'. If so, we are not
	looking at a cast-expression.

	Save tokens so that we can put them back. */
	cp_lexer_save_tokens (parser->lexer);
	/* Skip tokens until the next token is a closing parenthesis.
	If we find the closing `)', and the next token is a `{', then
	we are looking at a compound-literal. */
	compound_literal_p
	= (cp_parser_skip_to_closing_parenthesis (parser, false, false,
	/consume_paren=/true)
	&& cp_lexer_next_token_is (parser->lexer, CPP_OPEN_BRACE));
	/* Roll back the tokens we skipped. */
	cp_lexer_rollback_tokens (parser->lexer);
	/* If we were looking at a compound-literal, simulate an error
	so that the call to cp_parser_parse_definitely below will
	fail. */
	if (compound_literal_p)
	cp_parser_simulate_error (parser);
	else
	{
	bool saved_in_type_id_in_expr_p = parser->in_type_id_in_expr_p;
	parser->in_type_id_in_expr_p = true;
	/* Look for the type-id. */
	type = cp_parser_type_id (parser);
	/* Look for the closing `)'. */
	cp_parser_require (parser, CPP_CLOSE_PAREN, "`)'");
	parser->in_type_id_in_expr_p = saved_in_type_id_in_expr_p;
	}

	/* Restore the saved message. */
	parser->type_definition_forbidden_message = saved_message;

	/* If ok so far, parse the dependent expression. We cannot be
	sure it is a cast. Consider `(T ())'. It is a parenthesized
	ctor of T, but looks like a cast to function returning T
	without a dependent expression. */
	if (!cp_parser_error_occurred (parser))
	expr = cp_parser_cast_expression (parser,
	/address_p=/false,
	/cast_p=/true);

	if (cp_parser_parse_definitely (parser))
	{
	/* Warn about old-style casts, if so requested. */
	if (warn_old_style_cast
	&& !in_system_header
	&& !VOID_TYPE_P (type)
	&& current_lang_name != lang_name_c)
	warning (OPT_Wold_style_cast, "use of old-style cast");

	/* Only type conversions to integral or enumeration types
	can be used in constant-expressions. */
	if (!cast_valid_in_integral_constant_expression_p (type)
	&& (cp_parser_non_integral_constant_expression
	(parser,
	"a cast to a type other than an integral or "
	"enumeration type")))
	return error_mark_node;

	/* Perform the cast. */
	expr = build_c_cast (type, expr);
	return expr;
	}
	}

	/* If we get here, then it's not a cast, so it must be a
	unary-expression. */
	return cp_parser_unary_expression (parser, address_p, cast_p);
	}

	/* Parse a binary expression of the general form:

	pm-expression:
	cast-expression
	pm-expression .* cast-expression
	pm-expression ->* cast-expression

	multiplicative-expression:
	pm-expression
	multiplicative-expression * pm-expression
	multiplicative-expression / pm-expression
	multiplicative-expression % pm-expression

	additive-expression:
	multiplicative-expression
	additive-expression + multiplicative-expression
	additive-expression - multiplicative-expression

	shift-expression:
	additive-expression
	shift-expression << additive-expression
	shift-expression >> additive-expression

	relational-expression:
	shift-expression
	relational-expression < shift-expression
	relational-expression > shift-expression
	relational-expression <= shift-expression
	relational-expression >= shift-expression

	GNU Extension:

	relational-expression:
	relational-expression <? shift-expression
	relational-expression >? shift-expression

	equality-expression:
	relational-expression
	equality-expression == relational-expression
	equality-expression != relational-expression

	and-expression:
	equality-expression
	and-expression & equality-expression

	exclusive-or-expression:
	and-expression
	exclusive-or-expression ^ and-expression

	inclusive-or-expression:
	exclusive-or-expression
	inclusive-or-expression \| exclusive-or-expression

	logical-and-expression:
	inclusive-or-expression
	logical-and-expression && inclusive-or-expression

	logical-or-expression:
	logical-and-expression
	logical-or-expression \|\| logical-and-expression

	All these are implemented with a single function like:

	binary-expression:
	simple-cast-expression
	binary-expression <token> binary-expression

	CAST_P is true if this expression is the target of a cast.

	The binops_by_token map is used to get the tree codes for each <token> type.
	binary-expressions are associated according to a precedence table. */

	#define TOKEN_PRECEDENCE(token) \
	((token->type == CPP_GREATER && !parser->greater_than_is_operator_p) \
	? PREC_NOT_OPERATOR \
	: binops_by_token[token->type].prec)

	static tree
	cp_parser_binary_expression (cp_parser* parser, bool cast_p)
	{
	cp_parser_expression_stack stack;
	cp_parser_expression_stack_entry *sp = &stack[0];
	tree lhs, rhs;
	cp_token *token;
	enum tree_code tree_type, lhs_type, rhs_type;
	enum cp_parser_prec prec = PREC_NOT_OPERATOR, new_prec, lookahead_prec;
	bool overloaded_p;

	/* Parse the first expression. */
	lhs = cp_parser_cast_expression (parser, /address_p=/false, cast_p);
	lhs_type = ERROR_MARK;

	for (;;)
	{
	/* Get an operator token. */
	token = cp_lexer_peek_token (parser->lexer);

	new_prec = TOKEN_PRECEDENCE (token);

	/* Popping an entry off the stack means we completed a subexpression:
	- either we found a token which is not an operator (`>' where it is not
	an operator, or prec == PREC_NOT_OPERATOR), in which case popping
	will happen repeatedly;
	- or, we found an operator which has lower priority. This is the case
	where the recursive descent ascends, as in `3 * 4 + 5' after
	parsing `3 * 4'. */
	if (new_prec <= prec)
	{
	if (sp == stack)
	break;
	else
	goto pop;
	}

	get_rhs:
	tree_type = binops_by_token[token->type].tree_type;

	/* We used the operator token. */
	cp_lexer_consume_token (parser->lexer);

	/* Extract another operand. It may be the RHS of this expression
	or the LHS of a new, higher priority expression. */
	rhs = cp_parser_simple_cast_expression (parser);
	rhs_type = ERROR_MARK;

	/* Get another operator token. Look up its precedence to avoid
	building a useless (immediately popped) stack entry for common
	cases such as 3 + 4 + 5 or 3 * 4 + 5. */
	token = cp_lexer_peek_token (parser->lexer);
	lookahead_prec = TOKEN_PRECEDENCE (token);
	if (lookahead_prec > new_prec)
	{
	/* ... and prepare to parse the RHS of the new, higher priority
	expression. Since precedence levels on the stack are
	monotonically increasing, we do not have to care about
	stack overflows. */
	sp->prec = prec;
	sp->tree_type = tree_type;
	sp->lhs = lhs;
	sp->lhs_type = lhs_type;
	sp++;
	lhs = rhs;
	lhs_type = rhs_type;
	prec = new_prec;
	new_prec = lookahead_prec;
	goto get_rhs;

	pop:
	/* If the stack is not empty, we have parsed into LHS the right side
	(`4' in the example above) of an expression we had suspended.
	We can use the information on the stack to recover the LHS (`3')
	from the stack together with the tree code (`MULT_EXPR'), and
	the precedence of the higher level subexpression
	(`PREC_ADDITIVE_EXPRESSION'). TOKEN is the CPP_PLUS token,
	which will be used to actually build the additive expression. */
	--sp;
	prec = sp->prec;
	tree_type = sp->tree_type;
	rhs = lhs;
	rhs_type = lhs_type;
	lhs = sp->lhs;
	lhs_type = sp->lhs_type;
	}

	overloaded_p = false;
	lhs = build_x_binary_op (tree_type, lhs, lhs_type, rhs, rhs_type,
	&overloaded_p);
	lhs_type = tree_type;

	/* If the binary operator required the use of an overloaded operator,
	then this expression cannot be an integral constant-expression.
	An overloaded operator can be used even if both operands are
	otherwise permissible in an integral constant-expression if at
	least one of the operands is of enumeration type. */

	if (overloaded_p
	&& (cp_parser_non_integral_constant_expression
	(parser, "calls to overloaded operators")))
	return error_mark_node;
	}

	return lhs;
	}


	/* Parse the `? expression : assignment-expression' part of a
	conditional-expression. The LOGICAL_OR_EXPR is the
	logical-or-expression that started the conditional-expression.
	Returns a representation of the entire conditional-expression.

	This routine is used by cp_parser_assignment_expression.

	? expression : assignment-expression

	GNU Extensions:

	? : assignment-expression */

	static tree
	cp_parser_question_colon_clause (cp_parser* parser, tree logical_or_expr)
	{
	tree expr;
	tree assignment_expr;

	/* Consume the `?' token. */
	cp_lexer_consume_token (parser->lexer);
	if (cp_parser_allow_gnu_extensions_p (parser)
	&& cp_lexer_next_token_is (parser->lexer, CPP_COLON))
	/* Implicit true clause. */
	expr = NULL_TREE;
	else
	/* Parse the expression. */
	expr = cp_parser_expression (parser, /cast_p=/false);

	/* The next token should be a `:'. */
	cp_parser_require (parser, CPP_COLON, "`:'");
	/* Parse the assignment-expression. */
	assignment_expr = cp_parser_assignment_expression (parser, /cast_p=/false);

	/* Build the conditional-expression. */
	return build_x_conditional_expr (logical_or_expr,
	expr,
	assignment_expr);
	}

	/* Parse an assignment-expression.

	assignment-expression:
	conditional-expression
	logical-or-expression assignment-operator assignment_expression
	throw-expression

	CAST_P is true if this expression is the target of a cast.

	Returns a representation for the expression. */

	static tree
	cp_parser_assignment_expression (cp_parser* parser, bool cast_p)
	{
	tree expr;

	/* If the next token is the `throw' keyword, then we're looking at
	a throw-expression. */
	if (cp_lexer_next_token_is_keyword (parser->lexer, RID_THROW))
	expr = cp_parser_throw_expression (parser);
	/* Otherwise, it must be that we are looking at a
	logical-or-expression. */
	else
	{
	/* Parse the binary expressions (logical-or-expression). */
	expr = cp_parser_binary_expression (parser, cast_p);
	/* If the next token is a `?' then we're actually looking at a
	conditional-expression. */
	if (cp_lexer_next_token_is (parser->lexer, CPP_QUERY))
	return cp_parser_question_colon_clause (parser, expr);
	else
	{
	enum tree_code assignment_operator;

	/* If it's an assignment-operator, we're using the second
	production. */
	assignment_operator
	= cp_parser_assignment_operator_opt (parser);
	if (assignment_operator != ERROR_MARK)
	{
	tree rhs;

	/* Parse the right-hand side of the assignment. */
	rhs = cp_parser_assignment_expression (parser, cast_p);
	/* An assignment may not appear in a
	constant-expression. */
	if (cp_parser_non_integral_constant_expression (parser,
	"an assignment"))
	return error_mark_node;
	/* Build the assignment expression. */
	expr = build_x_modify_expr (expr,
	assignment_operator,
	rhs);
	}
	}
	}

	return expr;
	}

	/* Parse an (optional) assignment-operator.

	assignment-operator: one of
	= *= /= %= += -= >>= <<= &= ^= \|=

	GNU Extension:

	assignment-operator: one of
	<?= >?=

	If the next token is an assignment operator, the corresponding tree
	code is returned, and the token is consumed. For example, for
	`+=', PLUS_EXPR is returned. For `=' itself, the code returned is
	NOP_EXPR. For `/', TRUNC_DIV_EXPR is returned; for `%',
	TRUNC_MOD_EXPR is returned. If TOKEN is not an assignment
	operator, ERROR_MARK is returned. */

	static enum tree_code
	cp_parser_assignment_operator_opt (cp_parser* parser)
	{
	enum tree_code op;
	cp_token *token;

	/* Peek at the next toen. */
	token = cp_lexer_peek_token (parser->lexer);

	switch (token->type)
	{
	case CPP_EQ:
	op = NOP_EXPR;
	break;

	case CPP_MULT_EQ:
	op = MULT_EXPR;
	break;

	case CPP_DIV_EQ:
	op = TRUNC_DIV_EXPR;
	break;

	case CPP_MOD_EQ:
	op = TRUNC_MOD_EXPR;
	break;

	case CPP_PLUS_EQ:
	op = PLUS_EXPR;
	break;

	case CPP_MINUS_EQ:
	op = MINUS_EXPR;
	break;

	case CPP_RSHIFT_EQ:
	op = RSHIFT_EXPR;
	break;

	case CPP_LSHIFT_EQ:
	op = LSHIFT_EXPR;
	break;

	case CPP_AND_EQ:
	op = BIT_AND_EXPR;
	break;

	case CPP_XOR_EQ:
	op = BIT_XOR_EXPR;
	break;

	case CPP_OR_EQ:
	op = BIT_IOR_EXPR;
	break;

	default:
	/* Nothing else is an assignment operator. */
	op = ERROR_MARK;
	}

	/* If it was an assignment operator, consume it. */
	if (op != ERROR_MARK)
	cp_lexer_consume_token (parser->lexer);

	return op;
	}

	/* Parse an expression.

	expression:
	assignment-expression
	expression , assignment-expression

	CAST_P is true if this expression is the target of a cast.

	Returns a representation of the expression. */

	static tree
	cp_parser_expression (cp_parser* parser, bool cast_p)
	{
	tree expression = NULL_TREE;

	while (true)
	{
	tree assignment_expression;

	/* Parse the next assignment-expression. */
	assignment_expression
	= cp_parser_assignment_expression (parser, cast_p);
	/* If this is the first assignment-expression, we can just
	save it away. */
	if (!expression)
	expression = assignment_expression;
	else
	expression = build_x_compound_expr (expression,
	assignment_expression);
	/* If the next token is not a comma, then we are done with the
	expression. */
	if (cp_lexer_next_token_is_not (parser->lexer, CPP_COMMA))
	break;
	/* Consume the `,'. */
	cp_lexer_consume_token (parser->lexer);
	/* A comma operator cannot appear in a constant-expression. */
	if (cp_parser_non_integral_constant_expression (parser,
	"a comma operator"))
	expression = error_mark_node;
	}

	return expression;
	}

	/* Parse a constant-expression.

	constant-expression:
	conditional-expression

	If ALLOW_NON_CONSTANT_P a non-constant expression is silently
	accepted. If ALLOW_NON_CONSTANT_P is true and the expression is not
	constant, *NON_CONSTANT_P is set to TRUE. If ALLOW_NON_CONSTANT_P
	is false, NON_CONSTANT_P should be NULL. */

	static tree
	cp_parser_constant_expression (cp_parser* parser,
	bool allow_non_constant_p,
	bool *non_constant_p)
	{
	bool saved_integral_constant_expression_p;
	bool saved_allow_non_integral_constant_expression_p;
	bool saved_non_integral_constant_expression_p;
	tree expression;

	/* It might seem that we could simply parse the
	conditional-expression, and then check to see if it were
	TREE_CONSTANT. However, an expression that is TREE_CONSTANT is
	one that the compiler can figure out is constant, possibly after
	doing some simplifications or optimizations. The standard has a
	precise definition of constant-expression, and we must honor
	that, even though it is somewhat more restrictive.

	For example:

	int i[(2, 3)];

	is not a legal declaration, because `(2, 3)' is not a
	constant-expression. The `,' operator is forbidden in a
	constant-expression. However, GCC's constant-folding machinery
	will fold this operation to an INTEGER_CST for `3'. */

	/* Save the old settings. */
	saved_integral_constant_expression_p = parser->integral_constant_expression_p;
	saved_allow_non_integral_constant_expression_p
	= parser->allow_non_integral_constant_expression_p;
	saved_non_integral_constant_expression_p = parser->non_integral_constant_expression_p;
	/* We are now parsing a constant-expression. */
	parser->integral_constant_expression_p = true;
	parser->allow_non_integral_constant_expression_p = allow_non_constant_p;
	parser->non_integral_constant_expression_p = false;
	/* Although the grammar says "conditional-expression", we parse an
	"assignment-expression", which also permits "throw-expression"
	and the use of assignment operators. In the case that
	ALLOW_NON_CONSTANT_P is false, we get better errors than we would
	otherwise. In the case that ALLOW_NON_CONSTANT_P is true, it is
	actually essential that we look for an assignment-expression.
	For example, cp_parser_initializer_clauses uses this function to
	determine whether a particular assignment-expression is in fact
	constant. */
	expression = cp_parser_assignment_expression (parser, /cast_p=/false);
	/* Restore the old settings. */
	parser->integral_constant_expression_p
	= saved_integral_constant_expression_p;
	parser->allow_non_integral_constant_expression_p
	= saved_allow_non_integral_constant_expression_p;
	if (allow_non_constant_p)
	*non_constant_p = parser->non_integral_constant_expression_p;
	else if (parser->non_integral_constant_expression_p)
	expression = error_mark_node;
	parser->non_integral_constant_expression_p
	= saved_non_integral_constant_expression_p;

	return expression;
	}

	/* Parse __builtin_offsetof.

	offsetof-expression:
	"__builtin_offsetof" "(" type-id "," offsetof-member-designator ")"

	offsetof-member-designator:
	id-expression
	\| offsetof-member-designator "." id-expression
	\| offsetof-member-designator "[" expression "]" */

	static tree
	cp_parser_builtin_offsetof (cp_parser *parser)
	{
	int save_ice_p, save_non_ice_p;
	tree type, expr;
	cp_id_kind dummy;

	/* We're about to accept non-integral-constant things, but will
	definitely yield an integral constant expression. Save and
	restore these values around our local parsing. */
	save_ice_p = parser->integral_constant_expression_p;
	save_non_ice_p = parser->non_integral_constant_expression_p;

	/* Consume the "__builtin_offsetof" token. */
	cp_lexer_consume_token (parser->lexer);
	/* Consume the opening `('. */
	cp_parser_require (parser, CPP_OPEN_PAREN, "`('");
	/* Parse the type-id. */
	type = cp_parser_type_id (parser);
	/* Look for the `,'. */
	cp_parser_require (parser, CPP_COMMA, "`,'");

	/* Build the (type )null that begins the traditional offsetof macro. /
	expr = build_static_cast (build_pointer_type (type), null_pointer_node);

	/* Parse the offsetof-member-designator. We begin as if we saw "expr->". */
	expr = cp_parser_postfix_dot_deref_expression (parser, CPP_DEREF, expr,
	true, &dummy);
	while (true)
	{
	cp_token *token = cp_lexer_peek_token (parser->lexer);
	switch (token->type)
	{
	case CPP_OPEN_SQUARE:
	/* offsetof-member-designator "[" expression "]" */
	expr = cp_parser_postfix_open_square_expression (parser, expr, true);
	break;

	case CPP_DOT:
	/* offsetof-member-designator "." identifier */
	cp_lexer_consume_token (parser->lexer);
	expr = cp_parser_postfix_dot_deref_expression (parser, CPP_DOT, expr,
	true, &dummy);
	break;

	case CPP_CLOSE_PAREN:
	/* Consume the ")" token. */
	cp_lexer_consume_token (parser->lexer);
	goto success;

	default:
	/* Error. We know the following require will fail, but
	that gives the proper error message. */
	cp_parser_require (parser, CPP_CLOSE_PAREN, "`)'");
	cp_parser_skip_to_closing_parenthesis (parser, true, false, true);
	expr = error_mark_node;
	goto failure;
	}
	}

	success:
	/* If we're processing a template, we can't finish the semantics yet.
	Otherwise we can fold the entire expression now. */
	if (processing_template_decl)
	expr = build1 (OFFSETOF_EXPR, size_type_node, expr);
	else
	expr = finish_offsetof (expr);

	failure:
	parser->integral_constant_expression_p = save_ice_p;
	parser->non_integral_constant_expression_p = save_non_ice_p;

	return expr;
	}

	/* Statements [gram.stmt.stmt] */

	/* Parse a statement.

	statement:
	labeled-statement
	expression-statement
	compound-statement
	selection-statement
	iteration-statement
	jump-statement
	declaration-statement
	try-block

	IN_COMPOUND is true when the statement is nested inside a
	cp_parser_compound_statement; this matters for certain pragmas.

	If IF_P is not NULL, *IF_P is set to indicate whether the statement
	is a (possibly labeled) if statement which is not enclosed in braces
	and has an else clause. This is used to implement -Wparentheses. */

	static void
	cp_parser_statement (cp_parser* parser, tree in_statement_expr,
	bool in_compound, bool *if_p)
	{
	tree statement;
	cp_token *token;
	location_t statement_location;

	restart:
	if (if_p != NULL)
	*if_p = false;
	/* There is no statement yet. */
	statement = NULL_TREE;
	/* Peek at the next token. */
	token = cp_lexer_peek_token (parser->lexer);
	/* Remember the location of the first token in the statement. */
	statement_location = token->location;
	/* If this is a keyword, then that will often determine what kind of
	statement we have. */
	if (token->type == CPP_KEYWORD)
	{
	enum rid keyword = token->keyword;

	switch (keyword)
	{
	case RID_CASE:
	case RID_DEFAULT:
	/* Looks like a labeled-statement with a case label.
	Parse the label, and then use tail recursion to parse
	the statement. */
	cp_parser_label_for_labeled_statement (parser);
	goto restart;

	case RID_IF:
	case RID_SWITCH:
	statement = cp_parser_selection_statement (parser, if_p);
	break;

	case RID_WHILE:
	case RID_DO:
	case RID_FOR:
	statement = cp_parser_iteration_statement (parser);
	break;

	case RID_BREAK:
	case RID_CONTINUE:
	case RID_RETURN:
	case RID_GOTO:
	statement = cp_parser_jump_statement (parser);
	break;

	/* Objective-C++ exception-handling constructs. */
	case RID_AT_TRY:
	case RID_AT_CATCH:
	case RID_AT_FINALLY:
	case RID_AT_SYNCHRONIZED:
	case RID_AT_THROW:
	statement = cp_parser_objc_statement (parser);
	break;

	case RID_TRY:
	statement = cp_parser_try_block (parser);
	break;

	default:
	/* It might be a keyword like `int' that can start a
	declaration-statement. */
	break;
	}
	}
	else if (token->type == CPP_NAME)
	{
	/* If the next token is a `:', then we are looking at a
	labeled-statement. */
	token = cp_lexer_peek_nth_token (parser->lexer, 2);
	if (token->type == CPP_COLON)
	{
	/* Looks like a labeled-statement with an ordinary label.
	Parse the label, and then use tail recursion to parse
	the statement. */
	cp_parser_label_for_labeled_statement (parser);
	goto restart;
	}
	}
	/* Anything that starts with a `{' must be a compound-statement. */
	else if (token->type == CPP_OPEN_BRACE)
	statement = cp_parser_compound_statement (parser, NULL, false);
	/* CPP_PRAGMA is a #pragma inside a function body, which constitutes
	a statement all its own. */
	else if (token->type == CPP_PRAGMA)
	{
	/* Only certain OpenMP pragmas are attached to statements, and thus
	are considered statements themselves. All others are not. In
	the context of a compound, accept the pragma as a "statement" and
	return so that we can check for a close brace. Otherwise we
	require a real statement and must go back and read one. */
	if (in_compound)
	cp_parser_pragma (parser, pragma_compound);
	else if (!cp_parser_pragma (parser, pragma_stmt))
	goto restart;
	return;
	}
	else if (token->type == CPP_EOF)
	{
	cp_parser_error (parser, "expected statement");
	return;
	}

	/* Everything else must be a declaration-statement or an
	expression-statement. Try for the declaration-statement
	first, unless we are looking at a `;', in which case we know that
	we have an expression-statement. */
	if (!statement)
	{
	if (cp_lexer_next_token_is_not (parser->lexer, CPP_SEMICOLON))
	{
	cp_parser_parse_tentatively (parser);
	/* Try to parse the declaration-statement. */
	cp_parser_declaration_statement (parser);
	/* If that worked, we're done. */
	if (cp_parser_parse_definitely (parser))
	return;
	}
	/* Look for an expression-statement instead. */
	statement = cp_parser_expression_statement (parser, in_statement_expr);
	}

	/* Set the line number for the statement. */
	if (statement && STATEMENT_CODE_P (TREE_CODE (statement)))
	SET_EXPR_LOCATION (statement, statement_location);
	}

	/* Parse the label for a labeled-statement, i.e.

	identifier :
	case constant-expression :
	default :

	GNU Extension:
	case constant-expression ... constant-expression : statement

	When a label is parsed without errors, the label is added to the
	parse tree by the finish_* functions, so this function doesn't
	have to return the label. */

	static void
	cp_parser_label_for_labeled_statement (cp_parser* parser)
	{
	cp_token *token;

	/* The next token should be an identifier. */
	token = cp_lexer_peek_token (parser->lexer);
	if (token->type != CPP_NAME
	&& token->type != CPP_KEYWORD)
	{
	cp_parser_error (parser, "expected labeled-statement");
	return;
	}

	switch (token->keyword)
	{
	case RID_CASE:
	{
	tree expr, expr_hi;
	cp_token *ellipsis;

	/* Consume the `case' token. */
	cp_lexer_consume_token (parser->lexer);
	/* Parse the constant-expression. */
	expr = cp_parser_constant_expression (parser,
	/allow_non_constant_p=/false,
	NULL);

	ellipsis = cp_lexer_peek_token (parser->lexer);
	if (ellipsis->type == CPP_ELLIPSIS)
	{
	/* Consume the `...' token. */
	cp_lexer_consume_token (parser->lexer);
	expr_hi =
	cp_parser_constant_expression (parser,
	/allow_non_constant_p=/false,
	NULL);
	/* We don't need to emit warnings here, as the common code
	will do this for us. */
	}
	else
	expr_hi = NULL_TREE;

	if (parser->in_switch_statement_p)
	finish_case_label (expr, expr_hi);
	else
	error ("case label %qE not within a switch statement", expr);
	}
	break;

	case RID_DEFAULT:
	/* Consume the `default' token. */
	cp_lexer_consume_token (parser->lexer);

	if (parser->in_switch_statement_p)
	finish_case_label (NULL_TREE, NULL_TREE);
	else
	error ("case label not within a switch statement");
	break;

	default:
	/* Anything else must be an ordinary label. */
	finish_label_stmt (cp_parser_identifier (parser));
	break;
	}

	/* Require the `:' token. */
	cp_parser_require (parser, CPP_COLON, "`:'");
	}

	/* Parse an expression-statement.

	expression-statement:
	expression [opt] ;

	Returns the new EXPR_STMT -- or NULL_TREE if the expression
	statement consists of nothing more than an `;'. IN_STATEMENT_EXPR_P
	indicates whether this expression-statement is part of an
	expression statement. */

	static tree
	cp_parser_expression_statement (cp_parser* parser, tree in_statement_expr)
	{
	tree statement = NULL_TREE;

	/* If the next token is a ';', then there is no expression
	statement. */
	if (cp_lexer_next_token_is_not (parser->lexer, CPP_SEMICOLON))
	statement = cp_parser_expression (parser, /cast_p=/false);

	/* Consume the final `;'. */
	cp_parser_consume_semicolon_at_end_of_statement (parser);

	if (in_statement_expr
	&& cp_lexer_next_token_is (parser->lexer, CPP_CLOSE_BRACE))
	/* This is the final expression statement of a statement
	expression. */
	statement = finish_stmt_expr_expr (statement, in_statement_expr);
	else if (statement)
	statement = finish_expr_stmt (statement);
	else
	finish_stmt ();

	return statement;
	}

	/* Parse a compound-statement.

	compound-statement:
	{ statement-seq [opt] }

	Returns a tree representing the statement. */

	static tree
	cp_parser_compound_statement (cp_parser *parser, tree in_statement_expr,
	bool in_try)
	{
	tree compound_stmt;

	/* Consume the `{'. */
	if (!cp_parser_require (parser, CPP_OPEN_BRACE, "`{'"))
	return error_mark_node;
	/* Begin the compound-statement. */
	compound_stmt = begin_compound_stmt (in_try ? BCS_TRY_BLOCK : 0);
	/* Parse an (optional) statement-seq. */
	cp_parser_statement_seq_opt (parser, in_statement_expr);
	/* Finish the compound-statement. */
	finish_compound_stmt (compound_stmt);
	/* Consume the `}'. */
	cp_parser_require (parser, CPP_CLOSE_BRACE, "`}'");

	return compound_stmt;
	}

	/* Parse an (optional) statement-seq.

	statement-seq:
	statement
	statement-seq [opt] statement */

	static void
	cp_parser_statement_seq_opt (cp_parser* parser, tree in_statement_expr)
	{
	/* Scan statements until there aren't any more. */
	while (true)
	{
	cp_token *token = cp_lexer_peek_token (parser->lexer);

	/* If we're looking at a `}', then we've run out of statements. */
	if (token->type == CPP_CLOSE_BRACE
	\|\| token->type == CPP_EOF
	\|\| token->type == CPP_PRAGMA_EOL)
	break;

	/* Parse the statement. */
	cp_parser_statement (parser, in_statement_expr, true, NULL);
	}
	}

	/* Parse a selection-statement.

	selection-statement:
	if ( condition ) statement
	if ( condition ) statement else statement
	switch ( condition ) statement

	Returns the new IF_STMT or SWITCH_STMT.

	If IF_P is not NULL, *IF_P is set to indicate whether the statement
	is a (possibly labeled) if statement which is not enclosed in
	braces and has an else clause. This is used to implement
	-Wparentheses. */

	static tree
	cp_parser_selection_statement (cp_parser* parser, bool *if_p)
	{
	cp_token *token;
	enum rid keyword;

	if (if_p != NULL)
	*if_p = false;

	/* Peek at the next token. */
	token = cp_parser_require (parser, CPP_KEYWORD, "selection-statement");

	/* See what kind of keyword it is. */
	keyword = token->keyword;
	switch (keyword)
	{
	case RID_IF:
	case RID_SWITCH:
	{
	tree statement;
	tree condition;

	/* Look for the `('. */
	if (!cp_parser_require (parser, CPP_OPEN_PAREN, "`('"))
	{
	cp_parser_skip_to_end_of_statement (parser);
	return error_mark_node;
	}

	/* Begin the selection-statement. */
	if (keyword == RID_IF)
	statement = begin_if_stmt ();
	else
	statement = begin_switch_stmt ();

	/* Parse the condition. */
	condition = cp_parser_condition (parser);
	/* Look for the `)'. */
	if (!cp_parser_require (parser, CPP_CLOSE_PAREN, "`)'"))
	cp_parser_skip_to_closing_parenthesis (parser, true, false,
	/consume_paren=/true);

	if (keyword == RID_IF)
	{
	bool nested_if;

	/* Add the condition. */
	finish_if_stmt_cond (condition, statement);

	/* Parse the then-clause. */
	cp_parser_implicitly_scoped_statement (parser, &nested_if);
	finish_then_clause (statement);

	/* If the next token is `else', parse the else-clause. */
	if (cp_lexer_next_token_is_keyword (parser->lexer,
	RID_ELSE))
	{
	/* Consume the `else' keyword. */
	cp_lexer_consume_token (parser->lexer);
	begin_else_clause (statement);
	/* Parse the else-clause. */
	cp_parser_implicitly_scoped_statement (parser, NULL);
	finish_else_clause (statement);

	/* If we are currently parsing a then-clause, then
	IF_P will not be NULL. We set it to true to
	indicate that this if statement has an else clause.
	This may trigger the Wparentheses warning below
	when we get back up to the parent if statement. */
	if (if_p != NULL)
	*if_p = true;
	}
	else
	{
	/* This if statement does not have an else clause. If
	NESTED_IF is true, then the then-clause is an if
	statement which does have an else clause. We warn
	about the potential ambiguity. */
	if (nested_if)
	warning (OPT_Wparentheses,
	("%Hsuggest explicit braces "
	"to avoid ambiguous %<else%>"),
	EXPR_LOCUS (statement));
	}

	/* Now we're all done with the if-statement. */
	finish_if_stmt (statement);
	}
	else
	{
	bool in_switch_statement_p;
	unsigned char in_statement;

	/* Add the condition. */
	finish_switch_cond (condition, statement);

	/* Parse the body of the switch-statement. */
	in_switch_statement_p = parser->in_switch_statement_p;
	in_statement = parser->in_statement;
	parser->in_switch_statement_p = true;
	parser->in_statement \|= IN_SWITCH_STMT;
	cp_parser_implicitly_scoped_statement (parser, NULL);
	parser->in_switch_statement_p = in_switch_statement_p;
	parser->in_statement = in_statement;

	/* Now we're all done with the switch-statement. */
	finish_switch_stmt (statement);
	}

	return statement;
	}
	break;

	default:
	cp_parser_error (parser, "expected selection-statement");
	return error_mark_node;
	}
	}

	/* Parse a condition.

	condition:
	expression
	type-specifier-seq declarator = assignment-expression

	GNU Extension:

	condition:
	type-specifier-seq declarator asm-specification [opt]
	attributes [opt] = assignment-expression

	Returns the expression that should be tested. */

	static tree
	cp_parser_condition (cp_parser* parser)
	{
	cp_decl_specifier_seq type_specifiers;
	const char *saved_message;

	/* Try the declaration first. */
	cp_parser_parse_tentatively (parser);
	/* New types are not allowed in the type-specifier-seq for a
	condition. */
	saved_message = parser->type_definition_forbidden_message;
	parser->type_definition_forbidden_message
	= "types may not be defined in conditions";
	/* Parse the type-specifier-seq. */
	cp_parser_type_specifier_seq (parser, /is_condition==/true,
	&type_specifiers);
	/* Restore the saved message. */
	parser->type_definition_forbidden_message = saved_message;
	/* If all is well, we might be looking at a declaration. */
	if (!cp_parser_error_occurred (parser))
	{
	tree decl;
	tree asm_specification;
	tree attributes;
	cp_declarator *declarator;
	tree initializer = NULL_TREE;

	/* Parse the declarator. */
	declarator = cp_parser_declarator (parser, CP_PARSER_DECLARATOR_NAMED,
	/ctor_dtor_or_conv_p=/NULL,
	/parenthesized_p=/NULL,
	/member_p=/false);
	/* Parse the attributes. */
	attributes = cp_parser_attributes_opt (parser);
	/* Parse the asm-specification. */
	asm_specification = cp_parser_asm_specification_opt (parser);
	/* If the next token is not an `=', then we might still be
	looking at an expression. For example:

	if (A(a).x)

	looks like a decl-specifier-seq and a declarator -- but then
	there is no `=', so this is an expression. */
	cp_parser_require (parser, CPP_EQ, "`='");
	/* If we did see an `=', then we are looking at a declaration
	for sure. */
	if (cp_parser_parse_definitely (parser))
	{
	tree pushed_scope;
	bool non_constant_p;

	/* Create the declaration. */
	decl = start_decl (declarator, &type_specifiers,
	/initialized_p=/true,
	attributes, /prefix_attributes=/NULL_TREE,
	&pushed_scope);
	/* Parse the assignment-expression. */
	initializer
	= cp_parser_constant_expression (parser,
	/allow_non_constant_p=/true,
	&non_constant_p);
	if (!non_constant_p)
	initializer = fold_non_dependent_expr (initializer);

	/* Process the initializer. */
	cp_finish_decl (decl,
	initializer, !non_constant_p,
	asm_specification,
	LOOKUP_ONLYCONVERTING);

	if (pushed_scope)
	pop_scope (pushed_scope);

	return convert_from_reference (decl);
	}
	}
	/* If we didn't even get past the declarator successfully, we are
	definitely not looking at a declaration. */
	else
	cp_parser_abort_tentative_parse (parser);

	/* Otherwise, we are looking at an expression. */
	return cp_parser_expression (parser, /cast_p=/false);
	}

	/* Parse an iteration-statement.

	iteration-statement:
	while ( condition ) statement
	do statement while ( expression ) ;
	for ( for-init-statement condition [opt] ; expression [opt] )
	statement

	+ APPLE LOCAL begin for-fsf-4_4 3274130 5295549
	+ GNU extension:
	+
	+ while attributes [opt] ( condition ) statement
	+ do attributes [opt] statement while ( expression ) ;
	+ for attributes [opt]
	+ ( for-init-statement condition [opt] ; expression [opt] )
	+ statement
	+
	+ APPLE LOCAL end for-fsf-4_4 3274130 5295549
	Returns the new WHILE_STMT, DO_STMT, or FOR_STMT. */

	static tree
	cp_parser_iteration_statement (cp_parser* parser)
	{
	cp_token *token;
	enum rid keyword;
	- tree statement;
	+/* APPLE LOCAL begin for-fsf-4_4 3274130 5295549 */ \
	+ tree statement, attributes;
	+/* APPLE LOCAL end for-fsf-4_4 3274130 5295549 */ \
	unsigned char in_statement;

	- /* Peek at the next token. */
	+/* APPLE LOCAL begin for-fsf-4_4 3274130 5295549 */ \
	+ /* Get the keyword at the start of the loop. */
	+/* APPLE LOCAL end for-fsf-4_4 3274130 5295549 */ \
	token = cp_parser_require (parser, CPP_KEYWORD, "iteration-statement");
	if (!token)
	return error_mark_node;

	/* Remember whether or not we are already within an iteration
	statement. */
	in_statement = parser->in_statement;

	+/* APPLE LOCAL begin for-fsf-4_4 3274130 5295549 */ \
	+ /* Parse the attributes, if any. */
	+ attributes = cp_parser_attributes_opt (parser);
	+
	+/* APPLE LOCAL end for-fsf-4_4 3274130 5295549 */ \
	/* See what kind of keyword it is. */
	keyword = token->keyword;
	switch (keyword)
	{
	case RID_WHILE:
	{
	tree condition;

	/* Begin the while-statement. */
	- statement = begin_while_stmt ();
	+/* APPLE LOCAL begin for-fsf-4_4 3274130 5295549 */ \
	+ statement = begin_while_stmt (attributes);
	+/* APPLE LOCAL end for-fsf-4_4 3274130 5295549 */ \
	/* Look for the `('. */
	cp_parser_require (parser, CPP_OPEN_PAREN, "`('");
	/* Parse the condition. */
	condition = cp_parser_condition (parser);
	finish_while_stmt_cond (condition, statement);
	/* Look for the `)'. */
	cp_parser_require (parser, CPP_CLOSE_PAREN, "`)'");
	/* Parse the dependent statement. */
	parser->in_statement = IN_ITERATION_STMT;
	cp_parser_already_scoped_statement (parser);
	parser->in_statement = in_statement;
	/* We're done with the while-statement. */
	finish_while_stmt (statement);
	}
	break;

	case RID_DO:
	{
	tree expression;

	/* Begin the do-statement. */
	- statement = begin_do_stmt ();
	+/* APPLE LOCAL begin for-fsf-4_4 3274130 5295549 */ \
	+ statement = begin_do_stmt (attributes);
	+/* APPLE LOCAL end for-fsf-4_4 3274130 5295549 */ \
	/* Parse the body of the do-statement. */
	parser->in_statement = IN_ITERATION_STMT;
	cp_parser_implicitly_scoped_statement (parser, NULL);
	parser->in_statement = in_statement;
	finish_do_body (statement);
	/* Look for the `while' keyword. */
	cp_parser_require_keyword (parser, RID_WHILE, "`while'");
	/* Look for the `('. */
	cp_parser_require (parser, CPP_OPEN_PAREN, "`('");
	/* Parse the expression. */
	expression = cp_parser_expression (parser, /cast_p=/false);
	/* We're done with the do-statement. */
	finish_do_stmt (expression, statement);
	/* Look for the `)'. */
	cp_parser_require (parser, CPP_CLOSE_PAREN, "`)'");
	/* Look for the `;'. */
	cp_parser_require (parser, CPP_SEMICOLON, "`;'");
	}
	break;

	case RID_FOR:
	{
	tree condition = NULL_TREE;
	tree expression = NULL_TREE;

	/* Begin the for-statement. */
	- statement = begin_for_stmt ();
	+/* APPLE LOCAL begin for-fsf-4_4 3274130 5295549 */ \
	+ statement = begin_for_stmt (attributes);
	+/* APPLE LOCAL end for-fsf-4_4 3274130 5295549 */ \
	/* Look for the `('. */
	cp_parser_require (parser, CPP_OPEN_PAREN, "`('");
	/* Parse the initialization. */
	cp_parser_for_init_statement (parser);
	finish_for_init_stmt (statement);

	/* If there's a condition, process it. */
	if (cp_lexer_next_token_is_not (parser->lexer, CPP_SEMICOLON))
	condition = cp_parser_condition (parser);
	finish_for_cond (condition, statement);
	/* Look for the `;'. */
	cp_parser_require (parser, CPP_SEMICOLON, "`;'");

	/* If there's an expression, process it. */
	if (cp_lexer_next_token_is_not (parser->lexer, CPP_CLOSE_PAREN))
	expression = cp_parser_expression (parser, /cast_p=/false);
	finish_for_expr (expression, statement);
	/* Look for the `)'. */
	cp_parser_require (parser, CPP_CLOSE_PAREN, "`)'");

	/* Parse the body of the for-statement. */
	parser->in_statement = IN_ITERATION_STMT;
	cp_parser_already_scoped_statement (parser);
	parser->in_statement = in_statement;

	/* We're done with the for-statement. */
	finish_for_stmt (statement);
	}
	break;

	default:
	cp_parser_error (parser, "expected iteration-statement");
	statement = error_mark_node;
	break;
	}

	return statement;
	}

	/* Parse a for-init-statement.

	for-init-statement:
	expression-statement
	simple-declaration */

	static void
	cp_parser_for_init_statement (cp_parser* parser)
	{
	/* If the next token is a `;', then we have an empty
	expression-statement. Grammatically, this is also a
	simple-declaration, but an invalid one, because it does not
	declare anything. Therefore, if we did not handle this case
	specially, we would issue an error message about an invalid
	declaration. */
	if (cp_lexer_next_token_is_not (parser->lexer, CPP_SEMICOLON))
	{
	/* We're going to speculatively look for a declaration, falling back
	to an expression, if necessary. */
	cp_parser_parse_tentatively (parser);
	/* Parse the declaration. */
	cp_parser_simple_declaration (parser,
	/function_definition_allowed_p=/false);
	/* If the tentative parse failed, then we shall need to look for an
	expression-statement. */
	if (cp_parser_parse_definitely (parser))
	return;
	}

	cp_parser_expression_statement (parser, false);
	}

	/* Parse a jump-statement.

	jump-statement:
	break ;
	continue ;
	return expression [opt] ;
	goto identifier ;

	GNU extension:

	jump-statement:
	goto * expression ;

	Returns the new BREAK_STMT, CONTINUE_STMT, RETURN_EXPR, or GOTO_EXPR. */

	static tree
	cp_parser_jump_statement (cp_parser* parser)
	{
	tree statement = error_mark_node;
	cp_token *token;
	enum rid keyword;

	/* Peek at the next token. */
	token = cp_parser_require (parser, CPP_KEYWORD, "jump-statement");
	if (!token)
	return error_mark_node;

	/* See what kind of keyword it is. */
	keyword = token->keyword;
	switch (keyword)
	{
	case RID_BREAK:
	switch (parser->in_statement)
	{
	case 0:
	error ("break statement not within loop or switch");
	break;
	default:
	gcc_assert ((parser->in_statement & IN_SWITCH_STMT)
	\|\| parser->in_statement == IN_ITERATION_STMT);
	statement = finish_break_stmt ();
	break;
	case IN_OMP_BLOCK:
	error ("invalid exit from OpenMP structured block");
	break;
	case IN_OMP_FOR:
	error ("break statement used with OpenMP for loop");
	break;
	}
	cp_parser_require (parser, CPP_SEMICOLON, "%<;%>");
	break;

	case RID_CONTINUE:
	switch (parser->in_statement & ~IN_SWITCH_STMT)
	{
	case 0:
	error ("continue statement not within a loop");
	break;
	case IN_ITERATION_STMT:
	case IN_OMP_FOR:
	statement = finish_continue_stmt ();
	break;
	case IN_OMP_BLOCK:
	error ("invalid exit from OpenMP structured block");
	break;
	default:
	gcc_unreachable ();
	}
	cp_parser_require (parser, CPP_SEMICOLON, "%<;%>");
	break;

	case RID_RETURN:
	{
	tree expr;

	/* If the next token is a `;', then there is no
	expression. */
	if (cp_lexer_next_token_is_not (parser->lexer, CPP_SEMICOLON))
	expr = cp_parser_expression (parser, /cast_p=/false);
	else
	expr = NULL_TREE;
	/* Build the return-statement. */
	statement = finish_return_stmt (expr);
	/* Look for the final `;'. */
	cp_parser_require (parser, CPP_SEMICOLON, "%<;%>");
	}
	break;

	case RID_GOTO:
	/* Create the goto-statement. */
	if (cp_lexer_next_token_is (parser->lexer, CPP_MULT))
	{
	/* Issue a warning about this use of a GNU extension. */
	if (pedantic)
	pedwarn ("ISO C++ forbids computed gotos");
	/* Consume the '' token. /
	cp_lexer_consume_token (parser->lexer);
	/* Parse the dependent expression. */
	finish_goto_stmt (cp_parser_expression (parser, /cast_p=/false));
	}
	else
	finish_goto_stmt (cp_parser_identifier (parser));
	/* Look for the final `;'. */
	cp_parser_require (parser, CPP_SEMICOLON, "%<;%>");
	break;

	default:
	cp_parser_error (parser, "expected jump-statement");
	break;
	}

	return statement;
	}

	/* Parse a declaration-statement.

	declaration-statement:
	block-declaration */

	static void
	cp_parser_declaration_statement (cp_parser* parser)
	{
	void *p;

	/* Get the high-water mark for the DECLARATOR_OBSTACK. */
	p = obstack_alloc (&declarator_obstack, 0);

	/* Parse the block-declaration. */
	cp_parser_block_declaration (parser, /statement_p=/true);

	/* Free any declarators allocated. */
	obstack_free (&declarator_obstack, p);

	/* Finish off the statement. */
	finish_stmt ();
	}

	/* Some dependent statements (like `if (cond) statement'), are
	implicitly in their own scope. In other words, if the statement is
	a single statement (as opposed to a compound-statement), it is
	none-the-less treated as if it were enclosed in braces. Any
	declarations appearing in the dependent statement are out of scope
	after control passes that point. This function parses a statement,
	but ensures that is in its own scope, even if it is not a
	compound-statement.

	If IF_P is not NULL, *IF_P is set to indicate whether the statement
	is a (possibly labeled) if statement which is not enclosed in
	braces and has an else clause. This is used to implement
	-Wparentheses.

	Returns the new statement. */

	static tree
	cp_parser_implicitly_scoped_statement (cp_parser* parser, bool *if_p)
	{
	tree statement;

	if (if_p != NULL)
	*if_p = false;

	/* Mark if () ; with a special NOP_EXPR. */
	if (cp_lexer_next_token_is (parser->lexer, CPP_SEMICOLON))
	{
	cp_lexer_consume_token (parser->lexer);
	statement = add_stmt (build_empty_stmt ());
	}
	/* if a compound is opened, we simply parse the statement directly. */
	else if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_BRACE))
	statement = cp_parser_compound_statement (parser, NULL, false);
	/* If the token is not a `{', then we must take special action. */
	else
	{
	/* Create a compound-statement. */
	statement = begin_compound_stmt (0);
	/* Parse the dependent-statement. */
	cp_parser_statement (parser, NULL_TREE, false, if_p);
	/* Finish the dummy compound-statement. */
	finish_compound_stmt (statement);
	}

	/* Return the statement. */
	return statement;
	}

	/* For some dependent statements (like `while (cond) statement'), we
	have already created a scope. Therefore, even if the dependent
	statement is a compound-statement, we do not want to create another
	scope. */

	static void
	cp_parser_already_scoped_statement (cp_parser* parser)
	{
	/* If the token is a `{', then we must take special action. */
	if (cp_lexer_next_token_is_not (parser->lexer, CPP_OPEN_BRACE))
	cp_parser_statement (parser, NULL_TREE, false, NULL);
	else
	{
	/* Avoid calling cp_parser_compound_statement, so that we
	don't create a new scope. Do everything else by hand. */
	cp_parser_require (parser, CPP_OPEN_BRACE, "`{'");
	cp_parser_statement_seq_opt (parser, NULL_TREE);
	cp_parser_require (parser, CPP_CLOSE_BRACE, "`}'");
	}
	}

	/* Declarations [gram.dcl.dcl] */

	/* Parse an optional declaration-sequence.

	declaration-seq:
	declaration
	declaration-seq declaration */

	static void
	cp_parser_declaration_seq_opt (cp_parser* parser)
	{
	while (true)
	{
	cp_token *token;

	token = cp_lexer_peek_token (parser->lexer);

	if (token->type == CPP_CLOSE_BRACE
	\|\| token->type == CPP_EOF
	\|\| token->type == CPP_PRAGMA_EOL)
	break;

	if (token->type == CPP_SEMICOLON)
	{
	/* A declaration consisting of a single semicolon is
	invalid. Allow it unless we're being pedantic. */
	cp_lexer_consume_token (parser->lexer);
	if (pedantic && !in_system_header)
	pedwarn ("extra %<;%>");
	continue;
	}

	/* If we're entering or exiting a region that's implicitly
	extern "C", modify the lang context appropriately. */
	if (!parser->implicit_extern_c && token->implicit_extern_c)
	{
	push_lang_context (lang_name_c);
	parser->implicit_extern_c = true;
	}
	else if (parser->implicit_extern_c && !token->implicit_extern_c)
	{
	pop_lang_context ();
	parser->implicit_extern_c = false;
	}

	if (token->type == CPP_PRAGMA)
	{
	/* A top-level declaration can consist solely of a #pragma.
	A nested declaration cannot, so this is done here and not
	in cp_parser_declaration. (A #pragma at block scope is
	handled in cp_parser_statement.) */
	cp_parser_pragma (parser, pragma_external);
	continue;
	}

	/* Parse the declaration itself. */
	cp_parser_declaration (parser);
	}
	}

	/* Parse a declaration.

	declaration:
	block-declaration
	function-definition
	template-declaration
	explicit-instantiation
	explicit-specialization
	linkage-specification
	namespace-definition

	GNU extension:

	declaration:
	__extension__ declaration */

	static void
	cp_parser_declaration (cp_parser* parser)
	{
	cp_token token1;
	cp_token token2;
	int saved_pedantic;
	void *p;

	/* Check for the `__extension__' keyword. */
	if (cp_parser_extension_opt (parser, &saved_pedantic))
	{
	/* Parse the qualified declaration. */
	cp_parser_declaration (parser);
	/* Restore the PEDANTIC flag. */
	pedantic = saved_pedantic;

	return;
	}

	/* Try to figure out what kind of declaration is present. */
	token1 = *cp_lexer_peek_token (parser->lexer);

	if (token1.type != CPP_EOF)
	token2 = *cp_lexer_peek_nth_token (parser->lexer, 2);
	else
	{
	token2.type = CPP_EOF;
	token2.keyword = RID_MAX;
	}

	/* Get the high-water mark for the DECLARATOR_OBSTACK. */
	p = obstack_alloc (&declarator_obstack, 0);

	/* If the next token is `extern' and the following token is a string
	literal, then we have a linkage specification. */
	if (token1.keyword == RID_EXTERN
	&& cp_parser_is_string_literal (&token2))
	cp_parser_linkage_specification (parser);
	/* If the next token is `template', then we have either a template
	declaration, an explicit instantiation, or an explicit
	specialization. */
	else if (token1.keyword == RID_TEMPLATE)
	{
	/* `template <>' indicates a template specialization. */
	if (token2.type == CPP_LESS
	&& cp_lexer_peek_nth_token (parser->lexer, 3)->type == CPP_GREATER)
	cp_parser_explicit_specialization (parser);
	/* `template <' indicates a template declaration. */
	else if (token2.type == CPP_LESS)
	cp_parser_template_declaration (parser, /member_p=/false);
	/* Anything else must be an explicit instantiation. */
	else
	cp_parser_explicit_instantiation (parser);
	}
	/* If the next token is `export', then we have a template
	declaration. */
	else if (token1.keyword == RID_EXPORT)
	cp_parser_template_declaration (parser, /member_p=/false);
	/* If the next token is `extern', 'static' or 'inline' and the one
	after that is `template', we have a GNU extended explicit
	instantiation directive. */
	else if (cp_parser_allow_gnu_extensions_p (parser)
	&& (token1.keyword == RID_EXTERN
	\|\| token1.keyword == RID_STATIC
	\|\| token1.keyword == RID_INLINE)
	&& token2.keyword == RID_TEMPLATE)
	cp_parser_explicit_instantiation (parser);
	/* If the next token is `namespace', check for a named or unnamed
	namespace definition. */
	else if (token1.keyword == RID_NAMESPACE
	&& (/* A named namespace definition. */
	(token2.type == CPP_NAME
	&& (cp_lexer_peek_nth_token (parser->lexer, 3)->type
	!= CPP_EQ))
	/* An unnamed namespace definition. */
	\|\| token2.type == CPP_OPEN_BRACE
	\|\| token2.keyword == RID_ATTRIBUTE))
	cp_parser_namespace_definition (parser);
	/* Objective-C++ declaration/definition. */
	else if (c_dialect_objc () && OBJC_IS_AT_KEYWORD (token1.keyword))
	cp_parser_objc_declaration (parser);
	/* We must have either a block declaration or a function
	definition. */
	else
	/* Try to parse a block-declaration, or a function-definition. */
	cp_parser_block_declaration (parser, /statement_p=/false);

	/* Free any declarators allocated. */
	obstack_free (&declarator_obstack, p);
	}

	/* Parse a block-declaration.

	block-declaration:
	simple-declaration
	asm-definition
	namespace-alias-definition
	using-declaration
	using-directive

	GNU Extension:

	block-declaration:
	__extension__ block-declaration
	label-declaration

	If STATEMENT_P is TRUE, then this block-declaration is occurring as
	part of a declaration-statement. */

	static void
	cp_parser_block_declaration (cp_parser *parser,
	bool statement_p)
	{
	cp_token *token1;
	int saved_pedantic;

	/* Check for the `__extension__' keyword. */
	if (cp_parser_extension_opt (parser, &saved_pedantic))
	{
	/* Parse the qualified declaration. */
	cp_parser_block_declaration (parser, statement_p);
	/* Restore the PEDANTIC flag. */
	pedantic = saved_pedantic;

	return;
	}

	/* Peek at the next token to figure out which kind of declaration is
	present. */
	token1 = cp_lexer_peek_token (parser->lexer);

	/* If the next keyword is `asm', we have an asm-definition. */
	if (token1->keyword == RID_ASM)
	{
	if (statement_p)
	cp_parser_commit_to_tentative_parse (parser);
	cp_parser_asm_definition (parser);
	}
	/* If the next keyword is `namespace', we have a
	namespace-alias-definition. */
	else if (token1->keyword == RID_NAMESPACE)
	cp_parser_namespace_alias_definition (parser);
	/* If the next keyword is `using', we have either a
	using-declaration or a using-directive. */
	else if (token1->keyword == RID_USING)
	{
	cp_token *token2;

	if (statement_p)
	cp_parser_commit_to_tentative_parse (parser);
	/* If the token after `using' is `namespace', then we have a
	using-directive. */
	token2 = cp_lexer_peek_nth_token (parser->lexer, 2);
	if (token2->keyword == RID_NAMESPACE)
	cp_parser_using_directive (parser);
	/* Otherwise, it's a using-declaration. */
	else
	cp_parser_using_declaration (parser,
	/access_declaration_p=/false);
	}
	/* If the next keyword is `__label__' we have a label declaration. */
	else if (token1->keyword == RID_LABEL)
	{
	if (statement_p)
	cp_parser_commit_to_tentative_parse (parser);
	cp_parser_label_declaration (parser);
	}
	/* Anything else must be a simple-declaration. */
	else
	cp_parser_simple_declaration (parser, !statement_p);
	}

	/* Parse a simple-declaration.

	simple-declaration:
	decl-specifier-seq [opt] init-declarator-list [opt] ;

	init-declarator-list:
	init-declarator
	init-declarator-list , init-declarator

	If FUNCTION_DEFINITION_ALLOWED_P is TRUE, then we also recognize a
	function-definition as a simple-declaration. */

	static void
	cp_parser_simple_declaration (cp_parser* parser,
	bool function_definition_allowed_p)
	{
	cp_decl_specifier_seq decl_specifiers;
	int declares_class_or_enum;
	bool saw_declarator;

	/* Defer access checks until we know what is being declared; the
	checks for names appearing in the decl-specifier-seq should be
	done as if we were in the scope of the thing being declared. */
	push_deferring_access_checks (dk_deferred);

	/* Parse the decl-specifier-seq. We have to keep track of whether
	or not the decl-specifier-seq declares a named class or
	enumeration type, since that is the only case in which the
	init-declarator-list is allowed to be empty.

	[dcl.dcl]

	In a simple-declaration, the optional init-declarator-list can be
	omitted only when declaring a class or enumeration, that is when
	the decl-specifier-seq contains either a class-specifier, an
	elaborated-type-specifier, or an enum-specifier. */
	cp_parser_decl_specifier_seq (parser,
	CP_PARSER_FLAGS_OPTIONAL,
	&decl_specifiers,
	&declares_class_or_enum);
	/* We no longer need to defer access checks. */
	stop_deferring_access_checks ();

	/* In a block scope, a valid declaration must always have a
	decl-specifier-seq. By not trying to parse declarators, we can
	resolve the declaration/expression ambiguity more quickly. */
	if (!function_definition_allowed_p
	&& !decl_specifiers.any_specifiers_p)
	{
	cp_parser_error (parser, "expected declaration");
	goto done;
	}

	/* If the next two tokens are both identifiers, the code is
	erroneous. The usual cause of this situation is code like:

	T t;

	where "T" should name a type -- but does not. */
	if (!decl_specifiers.type
	&& cp_parser_parse_and_diagnose_invalid_type_name (parser))
	{
	/* If parsing tentatively, we should commit; we really are
	looking at a declaration. */
	cp_parser_commit_to_tentative_parse (parser);
	/* Give up. */
	goto done;
	}

	/* If we have seen at least one decl-specifier, and the next token
	is not a parenthesis, then we must be looking at a declaration.
	(After "int (" we might be looking at a functional cast.) */
	if (decl_specifiers.any_specifiers_p
	&& cp_lexer_next_token_is_not (parser->lexer, CPP_OPEN_PAREN))
	cp_parser_commit_to_tentative_parse (parser);

	/* Keep going until we hit the `;' at the end of the simple
	declaration. */
	saw_declarator = false;
	while (cp_lexer_next_token_is_not (parser->lexer,
	CPP_SEMICOLON))
	{
	cp_token *token;
	bool function_definition_p;
	tree decl;

	if (saw_declarator)
	{
	/* If we are processing next declarator, coma is expected */
	token = cp_lexer_peek_token (parser->lexer);
	gcc_assert (token->type == CPP_COMMA);
	cp_lexer_consume_token (parser->lexer);
	}
	else
	saw_declarator = true;

	/* Parse the init-declarator. */
	decl = cp_parser_init_declarator (parser, &decl_specifiers,
	/checks=/NULL,
	function_definition_allowed_p,
	/member_p=/false,
	declares_class_or_enum,
	&function_definition_p);
	/* If an error occurred while parsing tentatively, exit quickly.
	(That usually happens when in the body of a function; each
	statement is treated as a declaration-statement until proven
	otherwise.) */
	if (cp_parser_error_occurred (parser))
	goto done;
	/* Handle function definitions specially. */
	if (function_definition_p)
	{
	/* If the next token is a `,', then we are probably
	processing something like:

	void f() {}, *p;

	which is erroneous. */
	if (cp_lexer_next_token_is (parser->lexer, CPP_COMMA))
	error ("mixing declarations and function-definitions is forbidden");
	/* Otherwise, we're done with the list of declarators. */
	else
	{
	pop_deferring_access_checks ();
	return;
	}
	}
	/* The next token should be either a `,' or a `;'. */
	token = cp_lexer_peek_token (parser->lexer);
	/* If it's a `,', there are more declarators to come. */
	if (token->type == CPP_COMMA)
	/* will be consumed next time around */;
	/* If it's a `;', we are done. */
	else if (token->type == CPP_SEMICOLON)
	break;
	/* Anything else is an error. */
	else
	{
	/* If we have already issued an error message we don't need
	to issue another one. */
	if (decl != error_mark_node
	\|\| cp_parser_uncommitted_to_tentative_parse_p (parser))
	cp_parser_error (parser, "expected %<,%> or %<;%>");
	/* Skip tokens until we reach the end of the statement. */
	cp_parser_skip_to_end_of_statement (parser);
	/* If the next token is now a `;', consume it. */
	if (cp_lexer_next_token_is (parser->lexer, CPP_SEMICOLON))
	cp_lexer_consume_token (parser->lexer);
	goto done;
	}
	/* After the first time around, a function-definition is not
	allowed -- even if it was OK at first. For example:

	int i, f() {}

	is not valid. */
	function_definition_allowed_p = false;
	}

	/* Issue an error message if no declarators are present, and the
	decl-specifier-seq does not itself declare a class or
	enumeration. */
	if (!saw_declarator)
	{
	if (cp_parser_declares_only_class_p (parser))
	shadow_tag (&decl_specifiers);
	/* Perform any deferred access checks. */
	perform_deferred_access_checks ();
	}

	/* Consume the `;'. */
	cp_parser_require (parser, CPP_SEMICOLON, "`;'");

	done:
	pop_deferring_access_checks ();
	}

	/* Parse a decl-specifier-seq.

	decl-specifier-seq:
	decl-specifier-seq [opt] decl-specifier

	decl-specifier:
	storage-class-specifier
	type-specifier
	function-specifier
	friend
	typedef

	GNU Extension:

	decl-specifier:
	attributes

	Set *DECL_SPECS to a representation of the decl-specifier-seq.

	The parser flags FLAGS is used to control type-specifier parsing.

	*DECLARES_CLASS_OR_ENUM is set to the bitwise or of the following
	flags:

	1: one of the decl-specifiers is an elaborated-type-specifier
	(i.e., a type declaration)
	2: one of the decl-specifiers is an enum-specifier or a
	class-specifier (i.e., a type definition)

	*/

	static void
	cp_parser_decl_specifier_seq (cp_parser* parser,
	cp_parser_flags flags,
	cp_decl_specifier_seq *decl_specs,
	int* declares_class_or_enum)
	{
	bool constructor_possible_p = !parser->in_declarator_p;

	/* Clear DECL_SPECS. */
	clear_decl_specs (decl_specs);

	/* Assume no class or enumeration type is declared. */
	*declares_class_or_enum = 0;

	/* Keep reading specifiers until there are no more to read. */
	while (true)
	{
	bool constructor_p;
	bool found_decl_spec;
	cp_token *token;

	/* Peek at the next token. */
	token = cp_lexer_peek_token (parser->lexer);
	/* Handle attributes. */
	if (token->keyword == RID_ATTRIBUTE)
	{
	/* Parse the attributes. */
	decl_specs->attributes
	= chainon (decl_specs->attributes,
	cp_parser_attributes_opt (parser));
	continue;
	}
	/* Assume we will find a decl-specifier keyword. */
	found_decl_spec = true;
	/* If the next token is an appropriate keyword, we can simply
	add it to the list. */
	switch (token->keyword)
	{
	/* decl-specifier:
	friend */
	case RID_FRIEND:
	if (!at_class_scope_p ())
	{
	error ("%<friend%> used outside of class");
	cp_lexer_purge_token (parser->lexer);
	}
	else
	{
	++decl_specs->specs[(int) ds_friend];
	/* Consume the token. */
	cp_lexer_consume_token (parser->lexer);
	}
	break;

	/* function-specifier:
	inline
	virtual
	explicit */
	case RID_INLINE:
	case RID_VIRTUAL:
	case RID_EXPLICIT:
	cp_parser_function_specifier_opt (parser, decl_specs);
	break;

	/* decl-specifier:
	typedef */
	case RID_TYPEDEF:
	++decl_specs->specs[(int) ds_typedef];
	/* Consume the token. */
	cp_lexer_consume_token (parser->lexer);
	/* A constructor declarator cannot appear in a typedef. */
	constructor_possible_p = false;
	/* The "typedef" keyword can only occur in a declaration; we
	may as well commit at this point. */
	cp_parser_commit_to_tentative_parse (parser);

	if (decl_specs->storage_class != sc_none)
	decl_specs->conflicting_specifiers_p = true;
	break;

	/* storage-class-specifier:
	auto
	register
	static
	extern
	mutable

	GNU Extension:
	thread */
	case RID_AUTO:
	case RID_REGISTER:
	case RID_STATIC:
	case RID_EXTERN:
	case RID_MUTABLE:
	/* Consume the token. */
	cp_lexer_consume_token (parser->lexer);
	cp_parser_set_storage_class (parser, decl_specs, token->keyword);
	break;
	case RID_THREAD:
	/* Consume the token. */
	cp_lexer_consume_token (parser->lexer);
	++decl_specs->specs[(int) ds_thread];
	break;

	default:
	/* We did not yet find a decl-specifier yet. */
	found_decl_spec = false;
	break;
	}

	/* Constructors are a special case. The `S' in `S()' is not a
	decl-specifier; it is the beginning of the declarator. */
	constructor_p
	= (!found_decl_spec
	&& constructor_possible_p
	&& (cp_parser_constructor_declarator_p
	(parser, decl_specs->specs[(int) ds_friend] != 0)));

	/* If we don't have a DECL_SPEC yet, then we must be looking at
	a type-specifier. */
	if (!found_decl_spec && !constructor_p)
	{
	int decl_spec_declares_class_or_enum;
	bool is_cv_qualifier;
	tree type_spec;

	type_spec
	= cp_parser_type_specifier (parser, flags,
	decl_specs,
	/is_declaration=/true,
	&decl_spec_declares_class_or_enum,
	&is_cv_qualifier);

	*declares_class_or_enum \|= decl_spec_declares_class_or_enum;

	/* If this type-specifier referenced a user-defined type
	(a typedef, class-name, etc.), then we can't allow any
	more such type-specifiers henceforth.

	[dcl.spec]

	The longest sequence of decl-specifiers that could
	possibly be a type name is taken as the
	decl-specifier-seq of a declaration. The sequence shall
	be self-consistent as described below.

	[dcl.type]

	As a general rule, at most one type-specifier is allowed
	in the complete decl-specifier-seq of a declaration. The
	only exceptions are the following:

	-- const or volatile can be combined with any other
	type-specifier.

	-- signed or unsigned can be combined with char, long,
	short, or int.

	-- ..

	Example:

	typedef char* Pc;
	void g (const int Pc);

	Here, Pc is not part of the decl-specifier seq; it's
	the declarator. Therefore, once we see a type-specifier
	(other than a cv-qualifier), we forbid any additional
	user-defined types. We do still allow things like `int
	int' to be considered a decl-specifier-seq, and issue the
	error message later. */
	if (type_spec && !is_cv_qualifier)
	flags \|= CP_PARSER_FLAGS_NO_USER_DEFINED_TYPES;
	/* A constructor declarator cannot follow a type-specifier. */
	if (type_spec)
	{
	constructor_possible_p = false;
	found_decl_spec = true;
	}
	}

	/* If we still do not have a DECL_SPEC, then there are no more
	decl-specifiers. */
	if (!found_decl_spec)
	break;

	decl_specs->any_specifiers_p = true;
	/* After we see one decl-specifier, further decl-specifiers are
	always optional. */
	flags \|= CP_PARSER_FLAGS_OPTIONAL;
	}

	cp_parser_check_decl_spec (decl_specs);

	/* Don't allow a friend specifier with a class definition. */
	if (decl_specs->specs[(int) ds_friend] != 0
	&& (*declares_class_or_enum & 2))
	error ("class definition may not be declared a friend");
	}

	/* Parse an (optional) storage-class-specifier.

	storage-class-specifier:
	auto
	register
	static
	extern
	mutable

	GNU Extension:

	storage-class-specifier:
	thread

	Returns an IDENTIFIER_NODE corresponding to the keyword used. */

	static tree
	cp_parser_storage_class_specifier_opt (cp_parser* parser)
	{
	switch (cp_lexer_peek_token (parser->lexer)->keyword)
	{
	case RID_AUTO:
	case RID_REGISTER:
	case RID_STATIC:
	case RID_EXTERN:
	case RID_MUTABLE:
	case RID_THREAD:
	/* Consume the token. */
	return cp_lexer_consume_token (parser->lexer)->u.value;

	default:
	return NULL_TREE;
	}
	}

	/* Parse an (optional) function-specifier.

	function-specifier:
	inline
	virtual
	explicit

	Returns an IDENTIFIER_NODE corresponding to the keyword used.
	Updates DECL_SPECS, if it is non-NULL. */

	static tree
	cp_parser_function_specifier_opt (cp_parser* parser,
	cp_decl_specifier_seq *decl_specs)
	{
	switch (cp_lexer_peek_token (parser->lexer)->keyword)
	{
	case RID_INLINE:
	if (decl_specs)
	++decl_specs->specs[(int) ds_inline];
	break;

	case RID_VIRTUAL:
	/* 14.5.2.3 [temp.mem]

	A member function template shall not be virtual. */
	if (PROCESSING_REAL_TEMPLATE_DECL_P ())
	error ("templates may not be %<virtual%>");
	else if (decl_specs)
	++decl_specs->specs[(int) ds_virtual];
	break;

	case RID_EXPLICIT:
	if (decl_specs)
	++decl_specs->specs[(int) ds_explicit];
	break;

	default:
	return NULL_TREE;
	}

	/* Consume the token. */
	return cp_lexer_consume_token (parser->lexer)->u.value;
	}

	/* Parse a linkage-specification.

	linkage-specification:
	extern string-literal { declaration-seq [opt] }
	extern string-literal declaration */

	static void
	cp_parser_linkage_specification (cp_parser* parser)
	{
	tree linkage;

	/* Look for the `extern' keyword. */
	cp_parser_require_keyword (parser, RID_EXTERN, "`extern'");

	/* Look for the string-literal. */
	linkage = cp_parser_string_literal (parser, false, false);

	/* Transform the literal into an identifier. If the literal is a
	wide-character string, or contains embedded NULs, then we can't
	handle it as the user wants. */
	if (strlen (TREE_STRING_POINTER (linkage))
	!= (size_t) (TREE_STRING_LENGTH (linkage) - 1))
	{
	cp_parser_error (parser, "invalid linkage-specification");
	/* Assume C++ linkage. */
	linkage = lang_name_cplusplus;
	}
	else
	linkage = get_identifier (TREE_STRING_POINTER (linkage));

	/* We're now using the new linkage. */
	push_lang_context (linkage);

	/* If the next token is a `{', then we're using the first
	production. */
	if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_BRACE))
	{
	/* Consume the `{' token. */
	cp_lexer_consume_token (parser->lexer);
	/* Parse the declarations. */
	cp_parser_declaration_seq_opt (parser);
	/* Look for the closing `}'. */
	cp_parser_require (parser, CPP_CLOSE_BRACE, "`}'");
	}
	/* Otherwise, there's just one declaration. */
	else
	{
	bool saved_in_unbraced_linkage_specification_p;

	saved_in_unbraced_linkage_specification_p
	= parser->in_unbraced_linkage_specification_p;
	parser->in_unbraced_linkage_specification_p = true;
	cp_parser_declaration (parser);
	parser->in_unbraced_linkage_specification_p
	= saved_in_unbraced_linkage_specification_p;
	}

	/* We're done with the linkage-specification. */
	pop_lang_context ();
	}

	/* Special member functions [gram.special] */

	/* Parse a conversion-function-id.

	conversion-function-id:
	operator conversion-type-id

	Returns an IDENTIFIER_NODE representing the operator. */

	static tree
	cp_parser_conversion_function_id (cp_parser* parser)
	{
	tree type;
	tree saved_scope;
	tree saved_qualifying_scope;
	tree saved_object_scope;
	tree pushed_scope = NULL_TREE;

	/* Look for the `operator' token. */
	if (!cp_parser_require_keyword (parser, RID_OPERATOR, "`operator'"))
	return error_mark_node;
	/* When we parse the conversion-type-id, the current scope will be
	reset. However, we need that information in able to look up the
	conversion function later, so we save it here. */
	saved_scope = parser->scope;
	saved_qualifying_scope = parser->qualifying_scope;
	saved_object_scope = parser->object_scope;
	/* We must enter the scope of the class so that the names of
	entities declared within the class are available in the
	conversion-type-id. For example, consider:

	struct S {
	typedef int I;
	operator I();
	};

	S::operator I() { ... }

	In order to see that `I' is a type-name in the definition, we
	must be in the scope of `S'. */
	if (saved_scope)
	pushed_scope = push_scope (saved_scope);
	/* Parse the conversion-type-id. */
	type = cp_parser_conversion_type_id (parser);
	/* Leave the scope of the class, if any. */
	if (pushed_scope)
	pop_scope (pushed_scope);
	/* Restore the saved scope. */
	parser->scope = saved_scope;
	parser->qualifying_scope = saved_qualifying_scope;
	parser->object_scope = saved_object_scope;
	/* If the TYPE is invalid, indicate failure. */
	if (type == error_mark_node)
	return error_mark_node;
	return mangle_conv_op_name_for_type (type);
	}

	/* Parse a conversion-type-id:

	conversion-type-id:
	type-specifier-seq conversion-declarator [opt]

	Returns the TYPE specified. */

	static tree
	cp_parser_conversion_type_id (cp_parser* parser)
	{
	tree attributes;
	cp_decl_specifier_seq type_specifiers;
	cp_declarator *declarator;
	tree type_specified;

	/* Parse the attributes. */
	attributes = cp_parser_attributes_opt (parser);
	/* Parse the type-specifiers. */
	cp_parser_type_specifier_seq (parser, /is_condition=/false,
	&type_specifiers);
	/* If that didn't work, stop. */
	if (type_specifiers.type == error_mark_node)
	return error_mark_node;
	/* Parse the conversion-declarator. */
	declarator = cp_parser_conversion_declarator_opt (parser);

	type_specified = grokdeclarator (declarator, &type_specifiers, TYPENAME,
	/initialized=/0, &attributes);
	if (attributes)
	cplus_decl_attributes (&type_specified, attributes, /flags=/0);
	return type_specified;
	}

	/* Parse an (optional) conversion-declarator.

	conversion-declarator:
	ptr-operator conversion-declarator [opt]

	*/

	static cp_declarator *
	cp_parser_conversion_declarator_opt (cp_parser* parser)
	{
	enum tree_code code;
	tree class_type;
	cp_cv_quals cv_quals;

	/* We don't know if there's a ptr-operator next, or not. */
	cp_parser_parse_tentatively (parser);
	/* Try the ptr-operator. */
	code = cp_parser_ptr_operator (parser, &class_type, &cv_quals);
	/* If it worked, look for more conversion-declarators. */
	if (cp_parser_parse_definitely (parser))
	{
	cp_declarator *declarator;

	/* Parse another optional declarator. */
	declarator = cp_parser_conversion_declarator_opt (parser);

	/* Create the representation of the declarator. */
	if (class_type)
	declarator = make_ptrmem_declarator (cv_quals, class_type,
	declarator);
	else if (code == INDIRECT_REF)
	declarator = make_pointer_declarator (cv_quals, declarator);
	else
	declarator = make_reference_declarator (cv_quals, declarator);

	return declarator;
	}

	return NULL;
	}

	/* Parse an (optional) ctor-initializer.

	ctor-initializer:
	: mem-initializer-list

	Returns TRUE iff the ctor-initializer was actually present. */

	static bool
	cp_parser_ctor_initializer_opt (cp_parser* parser)
	{
	/* If the next token is not a `:', then there is no
	ctor-initializer. */
	if (cp_lexer_next_token_is_not (parser->lexer, CPP_COLON))
	{
	/* Do default initialization of any bases and members. */
	if (DECL_CONSTRUCTOR_P (current_function_decl))
	finish_mem_initializers (NULL_TREE);

	return false;
	}

	/* Consume the `:' token. */
	cp_lexer_consume_token (parser->lexer);
	/* And the mem-initializer-list. */
	cp_parser_mem_initializer_list (parser);

	return true;
	}

	/* Parse a mem-initializer-list.

	mem-initializer-list:
	mem-initializer
	mem-initializer , mem-initializer-list */

	static void
	cp_parser_mem_initializer_list (cp_parser* parser)
	{
	tree mem_initializer_list = NULL_TREE;

	/* Let the semantic analysis code know that we are starting the
	mem-initializer-list. */
	if (!DECL_CONSTRUCTOR_P (current_function_decl))
	error ("only constructors take base initializers");

	/* Loop through the list. */
	while (true)
	{
	tree mem_initializer;

	/* Parse the mem-initializer. */
	mem_initializer = cp_parser_mem_initializer (parser);
	/* Add it to the list, unless it was erroneous. */
	if (mem_initializer != error_mark_node)
	{
	TREE_CHAIN (mem_initializer) = mem_initializer_list;
	mem_initializer_list = mem_initializer;
	}
	/* If the next token is not a `,', we're done. */
	if (cp_lexer_next_token_is_not (parser->lexer, CPP_COMMA))
	break;
	/* Consume the `,' token. */
	cp_lexer_consume_token (parser->lexer);
	}

	/* Perform semantic analysis. */
	if (DECL_CONSTRUCTOR_P (current_function_decl))
	finish_mem_initializers (mem_initializer_list);
	}

	/* Parse a mem-initializer.

	mem-initializer:
	mem-initializer-id ( expression-list [opt] )

	GNU extension:

	mem-initializer:
	( expression-list [opt] )

	Returns a TREE_LIST. The TREE_PURPOSE is the TYPE (for a base
	class) or FIELD_DECL (for a non-static data member) to initialize;
	the TREE_VALUE is the expression-list. An empty initialization
	list is represented by void_list_node. */

	static tree
	cp_parser_mem_initializer (cp_parser* parser)
	{
	tree mem_initializer_id;
	tree expression_list;
	tree member;

	/* Find out what is being initialized. */
	if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_PAREN))
	{
	pedwarn ("anachronistic old-style base class initializer");
	mem_initializer_id = NULL_TREE;
	}
	else
	mem_initializer_id = cp_parser_mem_initializer_id (parser);
	member = expand_member_init (mem_initializer_id);
	if (member && !DECL_P (member))
	in_base_initializer = 1;

	expression_list
	= cp_parser_parenthesized_expression_list (parser, false,
	/cast_p=/false,
	/non_constant_p=/NULL);
	if (expression_list == error_mark_node)
	return error_mark_node;
	if (!expression_list)
	expression_list = void_type_node;

	in_base_initializer = 0;

	return member ? build_tree_list (member, expression_list) : error_mark_node;
	}

	/* Parse a mem-initializer-id.

	mem-initializer-id:
	:: [opt] nested-name-specifier [opt] class-name
	identifier

	Returns a TYPE indicating the class to be initializer for the first
	production. Returns an IDENTIFIER_NODE indicating the data member
	to be initialized for the second production. */

	static tree
	cp_parser_mem_initializer_id (cp_parser* parser)
	{
	bool global_scope_p;
	bool nested_name_specifier_p;
	bool template_p = false;
	tree id;

	/* `typename' is not allowed in this context ([temp.res]). */
	if (cp_lexer_next_token_is_keyword (parser->lexer, RID_TYPENAME))
	{
	error ("keyword %<typename%> not allowed in this context (a qualified "
	"member initializer is implicitly a type)");
	cp_lexer_consume_token (parser->lexer);
	}
	/* Look for the optional `::' operator. */
	global_scope_p
	= (cp_parser_global_scope_opt (parser,
	/current_scope_valid_p=/false)
	!= NULL_TREE);
	/* Look for the optional nested-name-specifier. The simplest way to
	implement:

	[temp.res]

	The keyword `typename' is not permitted in a base-specifier or
	mem-initializer; in these contexts a qualified name that
	depends on a template-parameter is implicitly assumed to be a
	type name.

	is to assume that we have seen the `typename' keyword at this
	point. */
	nested_name_specifier_p
	= (cp_parser_nested_name_specifier_opt (parser,
	/typename_keyword_p=/true,
	/check_dependency_p=/true,
	/type_p=/true,
	/is_declaration=/true)
	!= NULL_TREE);
	if (nested_name_specifier_p)
	template_p = cp_parser_optional_template_keyword (parser);
	/* If there is a `::' operator or a nested-name-specifier, then we
	are definitely looking for a class-name. */
	if (global_scope_p \|\| nested_name_specifier_p)
	return cp_parser_class_name (parser,
	/typename_keyword_p=/true,
	/template_keyword_p=/template_p,
	none_type,
	/check_dependency_p=/true,
	/class_head_p=/false,
	/is_declaration=/true);
	/* Otherwise, we could also be looking for an ordinary identifier. */
	cp_parser_parse_tentatively (parser);
	/* Try a class-name. */
	id = cp_parser_class_name (parser,
	/typename_keyword_p=/true,
	/template_keyword_p=/false,
	none_type,
	/check_dependency_p=/true,
	/class_head_p=/false,
	/is_declaration=/true);
	/* If we found one, we're done. */
	if (cp_parser_parse_definitely (parser))
	return id;
	/* Otherwise, look for an ordinary identifier. */
	return cp_parser_identifier (parser);
	}

	/* Overloading [gram.over] */

	/* Parse an operator-function-id.

	operator-function-id:
	operator operator

	Returns an IDENTIFIER_NODE for the operator which is a
	human-readable spelling of the identifier, e.g., `operator +'. */

	static tree
	cp_parser_operator_function_id (cp_parser* parser)
	{
	/* Look for the `operator' keyword. */
	if (!cp_parser_require_keyword (parser, RID_OPERATOR, "`operator'"))
	return error_mark_node;
	/* And then the name of the operator itself. */
	return cp_parser_operator (parser);
	}

	/* Parse an operator.

	operator:
	new delete new[] delete[] + - * / % ^ & \| ~ ! = < >
	+= -= *= /= %= ^= &= \|= << >> >>= <<= == != <= >= &&
	\|\| ++ -- , ->* -> () []

	GNU Extensions:

	operator:
	<? >? <?= >?=

	Returns an IDENTIFIER_NODE for the operator which is a
	human-readable spelling of the identifier, e.g., `operator +'. */

	static tree
	cp_parser_operator (cp_parser* parser)
	{
	tree id = NULL_TREE;
	cp_token *token;

	/* Peek at the next token. */
	token = cp_lexer_peek_token (parser->lexer);
	/* Figure out which operator we have. */
	switch (token->type)
	{
	case CPP_KEYWORD:
	{
	enum tree_code op;

	/* The keyword should be either `new' or `delete'. */
	if (token->keyword == RID_NEW)
	op = NEW_EXPR;
	else if (token->keyword == RID_DELETE)
	op = DELETE_EXPR;
	else
	break;

	/* Consume the `new' or `delete' token. */
	cp_lexer_consume_token (parser->lexer);

	/* Peek at the next token. */
	token = cp_lexer_peek_token (parser->lexer);
	/* If it's a `[' token then this is the array variant of the
	operator. */
	if (token->type == CPP_OPEN_SQUARE)
	{
	/* Consume the `[' token. */
	cp_lexer_consume_token (parser->lexer);
	/* Look for the `]' token. */
	cp_parser_require (parser, CPP_CLOSE_SQUARE, "`]'");
	id = ansi_opname (op == NEW_EXPR
	? VEC_NEW_EXPR : VEC_DELETE_EXPR);
	}
	/* Otherwise, we have the non-array variant. */
	else
	id = ansi_opname (op);

	return id;
	}

	case CPP_PLUS:
	id = ansi_opname (PLUS_EXPR);
	break;

	case CPP_MINUS:
	id = ansi_opname (MINUS_EXPR);
	break;

	case CPP_MULT:
	id = ansi_opname (MULT_EXPR);
	break;

	case CPP_DIV:
	id = ansi_opname (TRUNC_DIV_EXPR);
	break;

	case CPP_MOD:
	id = ansi_opname (TRUNC_MOD_EXPR);
	break;

	case CPP_XOR:
	id = ansi_opname (BIT_XOR_EXPR);
	break;

	case CPP_AND:
	id = ansi_opname (BIT_AND_EXPR);
	break;

	case CPP_OR:
	id = ansi_opname (BIT_IOR_EXPR);
	break;

	case CPP_COMPL:
	id = ansi_opname (BIT_NOT_EXPR);
	break;

	case CPP_NOT:
	id = ansi_opname (TRUTH_NOT_EXPR);
	break;

	case CPP_EQ:
	id = ansi_assopname (NOP_EXPR);
	break;

	case CPP_LESS:
	id = ansi_opname (LT_EXPR);
	break;

	case CPP_GREATER:
	id = ansi_opname (GT_EXPR);
	break;

	case CPP_PLUS_EQ:
	id = ansi_assopname (PLUS_EXPR);
	break;

	case CPP_MINUS_EQ:
	id = ansi_assopname (MINUS_EXPR);
	break;

	case CPP_MULT_EQ:
	id = ansi_assopname (MULT_EXPR);
	break;

	case CPP_DIV_EQ:
	id = ansi_assopname (TRUNC_DIV_EXPR);
	break;

	case CPP_MOD_EQ:
	id = ansi_assopname (TRUNC_MOD_EXPR);
	break;

	case CPP_XOR_EQ:
	id = ansi_assopname (BIT_XOR_EXPR);
	break;

	case CPP_AND_EQ:
	id = ansi_assopname (BIT_AND_EXPR);
	break;

	case CPP_OR_EQ:
	id = ansi_assopname (BIT_IOR_EXPR);
	break;

	case CPP_LSHIFT:
	id = ansi_opname (LSHIFT_EXPR);
	break;

	case CPP_RSHIFT:
	id = ansi_opname (RSHIFT_EXPR);
	break;

	case CPP_LSHIFT_EQ:
	id = ansi_assopname (LSHIFT_EXPR);
	break;

	case CPP_RSHIFT_EQ:
	id = ansi_assopname (RSHIFT_EXPR);
	break;

	case CPP_EQ_EQ:
	id = ansi_opname (EQ_EXPR);
	break;

	case CPP_NOT_EQ:
	id = ansi_opname (NE_EXPR);
	break;

	case CPP_LESS_EQ:
	id = ansi_opname (LE_EXPR);
	break;

	case CPP_GREATER_EQ:
	id = ansi_opname (GE_EXPR);
	break;

	case CPP_AND_AND:
	id = ansi_opname (TRUTH_ANDIF_EXPR);
	break;

	case CPP_OR_OR:
	id = ansi_opname (TRUTH_ORIF_EXPR);
	break;

	case CPP_PLUS_PLUS:
	id = ansi_opname (POSTINCREMENT_EXPR);
	break;

	case CPP_MINUS_MINUS:
	id = ansi_opname (PREDECREMENT_EXPR);
	break;

	case CPP_COMMA:
	id = ansi_opname (COMPOUND_EXPR);
	break;

	case CPP_DEREF_STAR:
	id = ansi_opname (MEMBER_REF);
	break;

	case CPP_DEREF:
	id = ansi_opname (COMPONENT_REF);
	break;

	case CPP_OPEN_PAREN:
	/* Consume the `('. */
	cp_lexer_consume_token (parser->lexer);
	/* Look for the matching `)'. */
	cp_parser_require (parser, CPP_CLOSE_PAREN, "`)'");
	return ansi_opname (CALL_EXPR);

	case CPP_OPEN_SQUARE:
	/* Consume the `['. */
	cp_lexer_consume_token (parser->lexer);
	/* Look for the matching `]'. */
	cp_parser_require (parser, CPP_CLOSE_SQUARE, "`]'");
	return ansi_opname (ARRAY_REF);

	default:
	/* Anything else is an error. */
	break;
	}

	/* If we have selected an identifier, we need to consume the
	operator token. */
	if (id)
	cp_lexer_consume_token (parser->lexer);
	/* Otherwise, no valid operator name was present. */
	else
	{
	cp_parser_error (parser, "expected operator");
	id = error_mark_node;
	}

	return id;
	}

	/* Parse a template-declaration.

	template-declaration:
	export [opt] template < template-parameter-list > declaration

	If MEMBER_P is TRUE, this template-declaration occurs within a
	class-specifier.

	The grammar rule given by the standard isn't correct. What
	is really meant is:

	template-declaration:
	export [opt] template-parameter-list-seq
	decl-specifier-seq [opt] init-declarator [opt] ;
	export [opt] template-parameter-list-seq
	function-definition

	template-parameter-list-seq:
	template-parameter-list-seq [opt]
	template < template-parameter-list > */

	static void
	cp_parser_template_declaration (cp_parser* parser, bool member_p)
	{
	/* Check for `export'. */
	if (cp_lexer_next_token_is_keyword (parser->lexer, RID_EXPORT))
	{
	/* Consume the `export' token. */
	cp_lexer_consume_token (parser->lexer);
	/* Warn that we do not support `export'. */
	warning (0, "keyword %<export%> not implemented, and will be ignored");
	}

	cp_parser_template_declaration_after_export (parser, member_p);
	}

	/* Parse a template-parameter-list.

	template-parameter-list:
	template-parameter
	template-parameter-list , template-parameter

	Returns a TREE_LIST. Each node represents a template parameter.
	The nodes are connected via their TREE_CHAINs. */

	static tree
	cp_parser_template_parameter_list (cp_parser* parser)
	{
	tree parameter_list = NULL_TREE;

	begin_template_parm_list ();
	while (true)
	{
	tree parameter;
	cp_token *token;
	bool is_non_type;

	/* Parse the template-parameter. */
	parameter = cp_parser_template_parameter (parser, &is_non_type);
	/* Add it to the list. */
	if (parameter != error_mark_node)
	parameter_list = process_template_parm (parameter_list,
	parameter,
	is_non_type);
	else
	{
	tree err_parm = build_tree_list (parameter, parameter);
	TREE_VALUE (err_parm) = error_mark_node;
	parameter_list = chainon (parameter_list, err_parm);
	}

	/* Peek at the next token. */
	token = cp_lexer_peek_token (parser->lexer);
	/* If it's not a `,', we're done. */
	if (token->type != CPP_COMMA)
	break;
	/* Otherwise, consume the `,' token. */
	cp_lexer_consume_token (parser->lexer);
	}

	return end_template_parm_list (parameter_list);
	}

	/* Parse a template-parameter.

	template-parameter:
	type-parameter
	parameter-declaration

	If all goes well, returns a TREE_LIST. The TREE_VALUE represents
	the parameter. The TREE_PURPOSE is the default value, if any.
	Returns ERROR_MARK_NODE on failure. *IS_NON_TYPE is set to true
	iff this parameter is a non-type parameter. */

	static tree
	cp_parser_template_parameter (cp_parser* parser, bool *is_non_type)
	{
	cp_token *token;
	cp_parameter_declarator *parameter_declarator;
	tree parm;

	/* Assume it is a type parameter or a template parameter. */
	*is_non_type = false;
	/* Peek at the next token. */
	token = cp_lexer_peek_token (parser->lexer);
	/* If it is `class' or `template', we have a type-parameter. */
	if (token->keyword == RID_TEMPLATE)
	return cp_parser_type_parameter (parser);
	/* If it is `class' or `typename' we do not know yet whether it is a
	type parameter or a non-type parameter. Consider:

	template <typename T, typename T::X X> ...

	or:

	template <class C, class D*> ...

	Here, the first parameter is a type parameter, and the second is
	a non-type parameter. We can tell by looking at the token after
	the identifier -- if it is a `,', `=', or `>' then we have a type
	parameter. */
	if (token->keyword == RID_TYPENAME \|\| token->keyword == RID_CLASS)
	{
	/* Peek at the token after `class' or `typename'. */
	token = cp_lexer_peek_nth_token (parser->lexer, 2);
	/* If it's an identifier, skip it. */
	if (token->type == CPP_NAME)
	token = cp_lexer_peek_nth_token (parser->lexer, 3);
	/* Now, see if the token looks like the end of a template
	parameter. */
	if (token->type == CPP_COMMA
	\|\| token->type == CPP_EQ
	\|\| token->type == CPP_GREATER)
	return cp_parser_type_parameter (parser);
	}

	/* Otherwise, it is a non-type parameter.

	[temp.param]

	When parsing a default template-argument for a non-type
	template-parameter, the first non-nested `>' is taken as the end
	of the template parameter-list rather than a greater-than
	operator. */
	*is_non_type = true;
	parameter_declarator
	= cp_parser_parameter_declaration (parser, /template_parm_p=/true,
	/parenthesized_p=/NULL);
	parm = grokdeclarator (parameter_declarator->declarator,
	&parameter_declarator->decl_specifiers,
	PARM, /initialized=/0,
	/attrlist=/NULL);
	if (parm == error_mark_node)
	return error_mark_node;
	return build_tree_list (parameter_declarator->default_argument, parm);
	}

	/* Parse a type-parameter.

	type-parameter:
	class identifier [opt]
	class identifier [opt] = type-id
	typename identifier [opt]
	typename identifier [opt] = type-id
	template < template-parameter-list > class identifier [opt]
	template < template-parameter-list > class identifier [opt]
	= id-expression

	Returns a TREE_LIST. The TREE_VALUE is itself a TREE_LIST. The
	TREE_PURPOSE is the default-argument, if any. The TREE_VALUE is
	the declaration of the parameter. */

	static tree
	cp_parser_type_parameter (cp_parser* parser)
	{
	cp_token *token;
	tree parameter;

	/* Look for a keyword to tell us what kind of parameter this is. */
	token = cp_parser_require (parser, CPP_KEYWORD,
	"`class', `typename', or `template'");
	if (!token)
	return error_mark_node;

	switch (token->keyword)
	{
	case RID_CLASS:
	case RID_TYPENAME:
	{
	tree identifier;
	tree default_argument;

	/* If the next token is an identifier, then it names the
	parameter. */
	if (cp_lexer_next_token_is (parser->lexer, CPP_NAME))
	identifier = cp_parser_identifier (parser);
	else
	identifier = NULL_TREE;

	/* Create the parameter. */
	parameter = finish_template_type_parm (class_type_node, identifier);

	/* If the next token is an `=', we have a default argument. */
	if (cp_lexer_next_token_is (parser->lexer, CPP_EQ))
	{
	/* Consume the `=' token. */
	cp_lexer_consume_token (parser->lexer);
	/* Parse the default-argument. */
	push_deferring_access_checks (dk_no_deferred);
	default_argument = cp_parser_type_id (parser);
	pop_deferring_access_checks ();
	}
	else
	default_argument = NULL_TREE;

	/* Create the combined representation of the parameter and the
	default argument. */
	parameter = build_tree_list (default_argument, parameter);
	}
	break;

	case RID_TEMPLATE:
	{
	tree parameter_list;
	tree identifier;
	tree default_argument;

	/* Look for the `<'. */
	cp_parser_require (parser, CPP_LESS, "`<'");
	/* Parse the template-parameter-list. */
	parameter_list = cp_parser_template_parameter_list (parser);
	/* Look for the `>'. */
	cp_parser_require (parser, CPP_GREATER, "`>'");
	/* Look for the `class' keyword. */
	cp_parser_require_keyword (parser, RID_CLASS, "`class'");
	/* If the next token is an `=', then there is a
	default-argument. If the next token is a `>', we are at
	the end of the parameter-list. If the next token is a `,',
	then we are at the end of this parameter. */
	if (cp_lexer_next_token_is_not (parser->lexer, CPP_EQ)
	&& cp_lexer_next_token_is_not (parser->lexer, CPP_GREATER)
	&& cp_lexer_next_token_is_not (parser->lexer, CPP_COMMA))
	{
	identifier = cp_parser_identifier (parser);
	/* Treat invalid names as if the parameter were nameless. */
	if (identifier == error_mark_node)
	identifier = NULL_TREE;
	}
	else
	identifier = NULL_TREE;

	/* Create the template parameter. */
	parameter = finish_template_template_parm (class_type_node,
	identifier);

	/* If the next token is an `=', then there is a
	default-argument. */
	if (cp_lexer_next_token_is (parser->lexer, CPP_EQ))
	{
	bool is_template;

	/* Consume the `='. */
	cp_lexer_consume_token (parser->lexer);
	/* Parse the id-expression. */
	push_deferring_access_checks (dk_no_deferred);
	default_argument
	= cp_parser_id_expression (parser,
	/template_keyword_p=/false,
	/check_dependency_p=/true,
	/template_p=/&is_template,
	/declarator_p=/false,
	/optional_p=/false);
	if (TREE_CODE (default_argument) == TYPE_DECL)
	/* If the id-expression was a template-id that refers to
	a template-class, we already have the declaration here,
	so no further lookup is needed. */
	;
	else
	/* Look up the name. */
	default_argument
	= cp_parser_lookup_name (parser, default_argument,
	none_type,
	/is_template=/is_template,
	/is_namespace=/false,
	/check_dependency=/true,
	/ambiguous_decls=/NULL);
	/* See if the default argument is valid. */
	default_argument
	= check_template_template_default_arg (default_argument);
	pop_deferring_access_checks ();
	}
	else
	default_argument = NULL_TREE;

	/* Create the combined representation of the parameter and the
	default argument. */
	parameter = build_tree_list (default_argument, parameter);
	}
	break;

	default:
	gcc_unreachable ();
	break;
	}

	return parameter;
	}

	/* Parse a template-id.

	template-id:
	template-name < template-argument-list [opt] >

	If TEMPLATE_KEYWORD_P is TRUE, then we have just seen the
	`template' keyword. In this case, a TEMPLATE_ID_EXPR will be
	returned. Otherwise, if the template-name names a function, or set
	of functions, returns a TEMPLATE_ID_EXPR. If the template-name
	names a class, returns a TYPE_DECL for the specialization.

	If CHECK_DEPENDENCY_P is FALSE, names are looked up in
	uninstantiated templates. */

	static tree
	cp_parser_template_id (cp_parser *parser,
	bool template_keyword_p,
	bool check_dependency_p,
	bool is_declaration)
	{
	int i;
	tree template;
	tree arguments;
	tree template_id;
	cp_token_position start_of_id = 0;
	deferred_access_check *chk;
	VEC (deferred_access_check,gc) *access_check;
	cp_token next_token, next_token_2;
	bool is_identifier;

	/* If the next token corresponds to a template-id, there is no need
	to reparse it. */
	next_token = cp_lexer_peek_token (parser->lexer);
	if (next_token->type == CPP_TEMPLATE_ID)
	{
	struct tree_check *check_value;

	/* Get the stored value. */
	check_value = cp_lexer_consume_token (parser->lexer)->u.tree_check_value;
	/* Perform any access checks that were deferred. */
	access_check = check_value->checks;
	if (access_check)
	{
	for (i = 0 ;
	VEC_iterate (deferred_access_check, access_check, i, chk) ;
	++i)
	{
	perform_or_defer_access_check (chk->binfo,
	chk->decl,
	chk->diag_decl);
	}
	}
	/* Return the stored value. */
	return check_value->value;
	}

	/* Avoid performing name lookup if there is no possibility of
	finding a template-id. */
	if ((next_token->type != CPP_NAME && next_token->keyword != RID_OPERATOR)
	\|\| (next_token->type == CPP_NAME
	&& !cp_parser_nth_token_starts_template_argument_list_p
	(parser, 2)))
	{
	cp_parser_error (parser, "expected template-id");
	return error_mark_node;
	}

	/* Remember where the template-id starts. */
	if (cp_parser_uncommitted_to_tentative_parse_p (parser))
	start_of_id = cp_lexer_token_position (parser->lexer, false);

	push_deferring_access_checks (dk_deferred);

	/* Parse the template-name. */
	is_identifier = false;
	template = cp_parser_template_name (parser, template_keyword_p,
	check_dependency_p,
	is_declaration,
	&is_identifier);
	if (template == error_mark_node \|\| is_identifier)
	{
	pop_deferring_access_checks ();
	return template;
	}

	/* If we find the sequence `[:' after a template-name, it's probably
	a digraph-typo for `< ::'. Substitute the tokens and check if we can
	parse correctly the argument list. */
	next_token = cp_lexer_peek_token (parser->lexer);
	next_token_2 = cp_lexer_peek_nth_token (parser->lexer, 2);
	if (next_token->type == CPP_OPEN_SQUARE
	&& next_token->flags & DIGRAPH
	&& next_token_2->type == CPP_COLON
	&& !(next_token_2->flags & PREV_WHITE))
	{
	cp_parser_parse_tentatively (parser);
	/* Change `:' into `::'. */
	next_token_2->type = CPP_SCOPE;
	/* Consume the first token (CPP_OPEN_SQUARE - which we pretend it is
	CPP_LESS. */
	cp_lexer_consume_token (parser->lexer);
	/* Parse the arguments. */
	arguments = cp_parser_enclosed_template_argument_list (parser);
	if (!cp_parser_parse_definitely (parser))
	{
	/* If we couldn't parse an argument list, then we revert our changes
	and return simply an error. Maybe this is not a template-id
	after all. */
	next_token_2->type = CPP_COLON;
	cp_parser_error (parser, "expected %<<%>");
	pop_deferring_access_checks ();
	return error_mark_node;
	}
	/* Otherwise, emit an error about the invalid digraph, but continue
	parsing because we got our argument list. */
	pedwarn ("%<<::%> cannot begin a template-argument list");
	inform ("%<<:%> is an alternate spelling for %<[%>. Insert whitespace "
	"between %<<%> and %<::%>");
	if (!flag_permissive)
	{
	static bool hint;
	if (!hint)
	{
	inform ("(if you use -fpermissive G++ will accept your code)");
	hint = true;
	}
	}
	}
	else
	{
	/* Look for the `<' that starts the template-argument-list. */
	if (!cp_parser_require (parser, CPP_LESS, "`<'"))
	{
	pop_deferring_access_checks ();
	return error_mark_node;
	}
	/* Parse the arguments. */
	arguments = cp_parser_enclosed_template_argument_list (parser);
	}

	/* Build a representation of the specialization. */
	if (TREE_CODE (template) == IDENTIFIER_NODE)
	template_id = build_min_nt (TEMPLATE_ID_EXPR, template, arguments);
	else if (DECL_CLASS_TEMPLATE_P (template)
	\|\| DECL_TEMPLATE_TEMPLATE_PARM_P (template))
	{
	bool entering_scope;
	/* In "template <typename T> ... A<T>::", A<T> is the abstract A
	template (rather than some instantiation thereof) only if
	is not nested within some other construct. For example, in
	"template <typename T> void f(T) { A<T>::", A<T> is just an
	instantiation of A. */
	entering_scope = (template_parm_scope_p ()
	&& cp_lexer_next_token_is (parser->lexer,
	CPP_SCOPE));
	template_id
	= finish_template_type (template, arguments, entering_scope);
	}
	else
	{
	/* If it's not a class-template or a template-template, it should be
	a function-template. */
	gcc_assert ((DECL_FUNCTION_TEMPLATE_P (template)
	\|\| TREE_CODE (template) == OVERLOAD
	\|\| BASELINK_P (template)));

	template_id = lookup_template_function (template, arguments);
	}

	/* If parsing tentatively, replace the sequence of tokens that makes
	up the template-id with a CPP_TEMPLATE_ID token. That way,
	should we re-parse the token stream, we will not have to repeat
	the effort required to do the parse, nor will we issue duplicate
	error messages about problems during instantiation of the
	template. */
	if (start_of_id)
	{
	cp_token *token = cp_lexer_token_at (parser->lexer, start_of_id);

	/* Reset the contents of the START_OF_ID token. */
	token->type = CPP_TEMPLATE_ID;
	/* Retrieve any deferred checks. Do not pop this access checks yet
	so the memory will not be reclaimed during token replacing below. */
	token->u.tree_check_value = GGC_CNEW (struct tree_check);
	token->u.tree_check_value->value = template_id;
	token->u.tree_check_value->checks = get_deferred_access_checks ();
	token->keyword = RID_MAX;

	/* Purge all subsequent tokens. */
	cp_lexer_purge_tokens_after (parser->lexer, start_of_id);

	/* ??? Can we actually assume that, if template_id ==
	error_mark_node, we will have issued a diagnostic to the
	user, as opposed to simply marking the tentative parse as
	failed? */
	if (cp_parser_error_occurred (parser) && template_id != error_mark_node)
	error ("parse error in template argument list");
	}

	pop_deferring_access_checks ();
	return template_id;
	}

	/* Parse a template-name.

	template-name:
	identifier

	The standard should actually say:

	template-name:
	identifier
	operator-function-id

	A defect report has been filed about this issue.

	A conversion-function-id cannot be a template name because they cannot
	be part of a template-id. In fact, looking at this code:

	a.operator K<int>()

	the conversion-function-id is "operator K<int>", and K<int> is a type-id.
	It is impossible to call a templated conversion-function-id with an
	explicit argument list, since the only allowed template parameter is
	the type to which it is converting.

	If TEMPLATE_KEYWORD_P is true, then we have just seen the
	`template' keyword, in a construction like:

	T::template f<3>()

	In that case `f' is taken to be a template-name, even though there
	is no way of knowing for sure.

	Returns the TEMPLATE_DECL for the template, or an OVERLOAD if the
	name refers to a set of overloaded functions, at least one of which
	is a template, or an IDENTIFIER_NODE with the name of the template,
	if TEMPLATE_KEYWORD_P is true. If CHECK_DEPENDENCY_P is FALSE,
	names are looked up inside uninstantiated templates. */

	static tree
	cp_parser_template_name (cp_parser* parser,
	bool template_keyword_p,
	bool check_dependency_p,
	bool is_declaration,
	bool *is_identifier)
	{
	tree identifier;
	tree decl;
	tree fns;

	/* If the next token is `operator', then we have either an
	operator-function-id or a conversion-function-id. */
	if (cp_lexer_next_token_is_keyword (parser->lexer, RID_OPERATOR))
	{
	/* We don't know whether we're looking at an
	operator-function-id or a conversion-function-id. */
	cp_parser_parse_tentatively (parser);
	/* Try an operator-function-id. */
	identifier = cp_parser_operator_function_id (parser);
	/* If that didn't work, try a conversion-function-id. */
	if (!cp_parser_parse_definitely (parser))
	{
	cp_parser_error (parser, "expected template-name");
	return error_mark_node;
	}
	}
	/* Look for the identifier. */
	else
	identifier = cp_parser_identifier (parser);

	/* If we didn't find an identifier, we don't have a template-id. */
	if (identifier == error_mark_node)
	return error_mark_node;

	/* If the name immediately followed the `template' keyword, then it
	is a template-name. However, if the next token is not `<', then
	we do not treat it as a template-name, since it is not being used
	as part of a template-id. This enables us to handle constructs
	like:

	template <typename T> struct S { S(); };
	template <typename T> S<T>::S();

	correctly. We would treat `S' as a template -- if it were `S<T>'
	-- but we do not if there is no `<'. */

	if (processing_template_decl
	&& cp_parser_nth_token_starts_template_argument_list_p (parser, 1))
	{
	/* In a declaration, in a dependent context, we pretend that the
	"template" keyword was present in order to improve error
	recovery. For example, given:

	template <typename T> void f(T::X<int>);

	we want to treat "X<int>" as a template-id. */
	if (is_declaration
	&& !template_keyword_p
	&& parser->scope && TYPE_P (parser->scope)
	&& check_dependency_p
	&& dependent_type_p (parser->scope)
	/* Do not do this for dtors (or ctors), since they never
	need the template keyword before their name. */
	&& !constructor_name_p (identifier, parser->scope))
	{
	cp_token_position start = 0;

	/* Explain what went wrong. */
	error ("non-template %qD used as template", identifier);
	inform ("use %<%T::template %D%> to indicate that it is a template",
	parser->scope, identifier);
	/* If parsing tentatively, find the location of the "<" token. */
	if (cp_parser_simulate_error (parser))
	start = cp_lexer_token_position (parser->lexer, true);
	/* Parse the template arguments so that we can issue error
	messages about them. */
	cp_lexer_consume_token (parser->lexer);
	cp_parser_enclosed_template_argument_list (parser);
	/* Skip tokens until we find a good place from which to
	continue parsing. */
	cp_parser_skip_to_closing_parenthesis (parser,
	/recovering=/true,
	/or_comma=/true,
	/consume_paren=/false);
	/* If parsing tentatively, permanently remove the
	template argument list. That will prevent duplicate
	error messages from being issued about the missing
	"template" keyword. */
	if (start)
	cp_lexer_purge_tokens_after (parser->lexer, start);
	if (is_identifier)
	*is_identifier = true;
	return identifier;
	}

	/* If the "template" keyword is present, then there is generally
	no point in doing name-lookup, so we just return IDENTIFIER.
	But, if the qualifying scope is non-dependent then we can
	(and must) do name-lookup normally. */
	if (template_keyword_p
	&& (!parser->scope
	\|\| (TYPE_P (parser->scope)
	&& dependent_type_p (parser->scope))))
	return identifier;
	}

	/* Look up the name. */
	decl = cp_parser_lookup_name (parser, identifier,
	none_type,
	/is_template=/false,
	/is_namespace=/false,
	check_dependency_p,
	/ambiguous_decls=/NULL);
	decl = maybe_get_template_decl_from_type_decl (decl);

	/* If DECL is a template, then the name was a template-name. */
	if (TREE_CODE (decl) == TEMPLATE_DECL)
	;
	else
	{
	tree fn = NULL_TREE;

	/* The standard does not explicitly indicate whether a name that
	names a set of overloaded declarations, some of which are
	templates, is a template-name. However, such a name should
	be a template-name; otherwise, there is no way to form a
	template-id for the overloaded templates. */
	fns = BASELINK_P (decl) ? BASELINK_FUNCTIONS (decl) : decl;
	if (TREE_CODE (fns) == OVERLOAD)
	for (fn = fns; fn; fn = OVL_NEXT (fn))
	if (TREE_CODE (OVL_CURRENT (fn)) == TEMPLATE_DECL)
	break;

	if (!fn)
	{
	/* The name does not name a template. */
	cp_parser_error (parser, "expected template-name");
	return error_mark_node;
	}
	}

	/* If DECL is dependent, and refers to a function, then just return
	its name; we will look it up again during template instantiation. */
	if (DECL_FUNCTION_TEMPLATE_P (decl) \|\| !DECL_P (decl))
	{
	tree scope = CP_DECL_CONTEXT (get_first_fn (decl));
	if (TYPE_P (scope) && dependent_type_p (scope))
	return identifier;
	}

	return decl;
	}

	/* Parse a template-argument-list.

	template-argument-list:
	template-argument
	template-argument-list , template-argument

	Returns a TREE_VEC containing the arguments. */

	static tree
	cp_parser_template_argument_list (cp_parser* parser)
	{
	tree fixed_args[10];
	unsigned n_args = 0;
	unsigned alloced = 10;
	tree *arg_ary = fixed_args;
	tree vec;
	bool saved_in_template_argument_list_p;
	bool saved_ice_p;
	bool saved_non_ice_p;

	saved_in_template_argument_list_p = parser->in_template_argument_list_p;
	parser->in_template_argument_list_p = true;
	/* Even if the template-id appears in an integral
	constant-expression, the contents of the argument list do
	not. */
	saved_ice_p = parser->integral_constant_expression_p;
	parser->integral_constant_expression_p = false;
	saved_non_ice_p = parser->non_integral_constant_expression_p;
	parser->non_integral_constant_expression_p = false;
	/* Parse the arguments. */
	do
	{
	tree argument;

	if (n_args)
	/* Consume the comma. */
	cp_lexer_consume_token (parser->lexer);

	/* Parse the template-argument. */
	argument = cp_parser_template_argument (parser);
	if (n_args == alloced)
	{
	alloced *= 2;

	if (arg_ary == fixed_args)
	{
	arg_ary = XNEWVEC (tree, alloced);
	memcpy (arg_ary, fixed_args, sizeof (tree) * n_args);
	}
	else
	arg_ary = XRESIZEVEC (tree, arg_ary, alloced);
	}
	arg_ary[n_args++] = argument;
	}
	while (cp_lexer_next_token_is (parser->lexer, CPP_COMMA));

	vec = make_tree_vec (n_args);

	while (n_args--)
	TREE_VEC_ELT (vec, n_args) = arg_ary[n_args];

	if (arg_ary != fixed_args)
	free (arg_ary);
	parser->non_integral_constant_expression_p = saved_non_ice_p;
	parser->integral_constant_expression_p = saved_ice_p;
	parser->in_template_argument_list_p = saved_in_template_argument_list_p;
	return vec;
	}

	/* Parse a template-argument.

	template-argument:
	assignment-expression
	type-id
	id-expression

	The representation is that of an assignment-expression, type-id, or
	id-expression -- except that the qualified id-expression is
	evaluated, so that the value returned is either a DECL or an
	OVERLOAD.

	Although the standard says "assignment-expression", it forbids
	throw-expressions or assignments in the template argument.
	Therefore, we use "conditional-expression" instead. */

	static tree
	cp_parser_template_argument (cp_parser* parser)
	{
	tree argument;
	bool template_p;
	bool address_p;
	bool maybe_type_id = false;
	cp_token *token;
	cp_id_kind idk;

	/* There's really no way to know what we're looking at, so we just
	try each alternative in order.

	[temp.arg]

	In a template-argument, an ambiguity between a type-id and an
	expression is resolved to a type-id, regardless of the form of
	the corresponding template-parameter.

	Therefore, we try a type-id first. */
	cp_parser_parse_tentatively (parser);
	argument = cp_parser_type_id (parser);
	/* If there was no error parsing the type-id but the next token is a '>>',
	we probably found a typo for '> >'. But there are type-id which are
	also valid expressions. For instance:

	struct X { int operator >> (int); };
	template <int V> struct Foo {};
	Foo<X () >> 5> r;

	Here 'X()' is a valid type-id of a function type, but the user just
	wanted to write the expression "X() >> 5". Thus, we remember that we
	found a valid type-id, but we still try to parse the argument as an
	expression to see what happens. */
	if (!cp_parser_error_occurred (parser)
	&& cp_lexer_next_token_is (parser->lexer, CPP_RSHIFT))
	{
	maybe_type_id = true;
	cp_parser_abort_tentative_parse (parser);
	}
	else
	{
	/* If the next token isn't a `,' or a `>', then this argument wasn't
	really finished. This means that the argument is not a valid
	type-id. */
	if (!cp_parser_next_token_ends_template_argument_p (parser))
	cp_parser_error (parser, "expected template-argument");
	/* If that worked, we're done. */
	if (cp_parser_parse_definitely (parser))
	return argument;
	}
	/* We're still not sure what the argument will be. */
	cp_parser_parse_tentatively (parser);
	/* Try a template. */
	argument = cp_parser_id_expression (parser,
	/template_keyword_p=/false,
	/check_dependency_p=/true,
	&template_p,
	/declarator_p=/false,
	/optional_p=/false);
	/* If the next token isn't a `,' or a `>', then this argument wasn't
	really finished. */
	if (!cp_parser_next_token_ends_template_argument_p (parser))
	cp_parser_error (parser, "expected template-argument");
	if (!cp_parser_error_occurred (parser))
	{
	/* Figure out what is being referred to. If the id-expression
	was for a class template specialization, then we will have a
	TYPE_DECL at this point. There is no need to do name lookup
	at this point in that case. */
	if (TREE_CODE (argument) != TYPE_DECL)
	argument = cp_parser_lookup_name (parser, argument,
	none_type,
	/is_template=/template_p,
	/is_namespace=/false,
	/check_dependency=/true,
	/ambiguous_decls=/NULL);
	if (TREE_CODE (argument) != TEMPLATE_DECL
	&& TREE_CODE (argument) != UNBOUND_CLASS_TEMPLATE)
	cp_parser_error (parser, "expected template-name");
	}
	if (cp_parser_parse_definitely (parser))
	return argument;
	/* It must be a non-type argument. There permitted cases are given
	in [temp.arg.nontype]:

	-- an integral constant-expression of integral or enumeration
	type; or

	-- the name of a non-type template-parameter; or

	-- the name of an object or function with external linkage...

	-- the address of an object or function with external linkage...

	-- a pointer to member... */
	/* Look for a non-type template parameter. */
	if (cp_lexer_next_token_is (parser->lexer, CPP_NAME))
	{
	cp_parser_parse_tentatively (parser);
	argument = cp_parser_primary_expression (parser,
	/adress_p=/false,
	/cast_p=/false,
	/template_arg_p=/true,
	&idk);
	if (TREE_CODE (argument) != TEMPLATE_PARM_INDEX
	\|\| !cp_parser_next_token_ends_template_argument_p (parser))
	cp_parser_simulate_error (parser);
	if (cp_parser_parse_definitely (parser))
	return argument;
	}

	/* If the next token is "&", the argument must be the address of an
	object or function with external linkage. */
	address_p = cp_lexer_next_token_is (parser->lexer, CPP_AND);
	if (address_p)
	cp_lexer_consume_token (parser->lexer);
	/* See if we might have an id-expression. */
	token = cp_lexer_peek_token (parser->lexer);
	if (token->type == CPP_NAME
	\|\| token->keyword == RID_OPERATOR
	\|\| token->type == CPP_SCOPE
	\|\| token->type == CPP_TEMPLATE_ID
	\|\| token->type == CPP_NESTED_NAME_SPECIFIER)
	{
	cp_parser_parse_tentatively (parser);
	argument = cp_parser_primary_expression (parser,
	address_p,
	/cast_p=/false,
	/template_arg_p=/true,
	&idk);
	if (cp_parser_error_occurred (parser)
	\|\| !cp_parser_next_token_ends_template_argument_p (parser))
	cp_parser_abort_tentative_parse (parser);
	else
	{
	if (TREE_CODE (argument) == INDIRECT_REF)
	{
	gcc_assert (REFERENCE_REF_P (argument));
	argument = TREE_OPERAND (argument, 0);
	}

	if (TREE_CODE (argument) == VAR_DECL)
	{
	/* A variable without external linkage might still be a
	valid constant-expression, so no error is issued here
	if the external-linkage check fails. */
	if (!address_p && !DECL_EXTERNAL_LINKAGE_P (argument))
	cp_parser_simulate_error (parser);
	}
	else if (is_overloaded_fn (argument))
	/* All overloaded functions are allowed; if the external
	linkage test does not pass, an error will be issued
	later. */
	;
	else if (address_p
	&& (TREE_CODE (argument) == OFFSET_REF
	\|\| TREE_CODE (argument) == SCOPE_REF))
	/* A pointer-to-member. */
	;
	else if (TREE_CODE (argument) == TEMPLATE_PARM_INDEX)
	;
	else
	cp_parser_simulate_error (parser);

	if (cp_parser_parse_definitely (parser))
	{
	if (address_p)
	argument = build_x_unary_op (ADDR_EXPR, argument);
	return argument;
	}
	}
	}
	/* If the argument started with "&", there are no other valid
	alternatives at this point. */
	if (address_p)
	{
	cp_parser_error (parser, "invalid non-type template argument");
	return error_mark_node;
	}

	/* If the argument wasn't successfully parsed as a type-id followed
	by '>>', the argument can only be a constant expression now.
	Otherwise, we try parsing the constant-expression tentatively,
	because the argument could really be a type-id. */
	if (maybe_type_id)
	cp_parser_parse_tentatively (parser);
	argument = cp_parser_constant_expression (parser,
	/allow_non_constant_p=/false,
	/non_constant_p=/NULL);
	argument = fold_non_dependent_expr (argument);
	if (!maybe_type_id)
	return argument;
	if (!cp_parser_next_token_ends_template_argument_p (parser))
	cp_parser_error (parser, "expected template-argument");
	if (cp_parser_parse_definitely (parser))
	return argument;
	/* We did our best to parse the argument as a non type-id, but that
	was the only alternative that matched (albeit with a '>' after
	it). We can assume it's just a typo from the user, and a
	diagnostic will then be issued. */
	return cp_parser_type_id (parser);
	}

	/* Parse an explicit-instantiation.

	explicit-instantiation:
	template declaration

	Although the standard says `declaration', what it really means is:

	explicit-instantiation:
	template decl-specifier-seq [opt] declarator [opt] ;

	Things like `template int S<int>::i = 5, int S<double>::j;' are not
	supposed to be allowed. A defect report has been filed about this
	issue.

	GNU Extension:

	explicit-instantiation:
	storage-class-specifier template
	decl-specifier-seq [opt] declarator [opt] ;
	function-specifier template
	decl-specifier-seq [opt] declarator [opt] ; */

	static void
	cp_parser_explicit_instantiation (cp_parser* parser)
	{
	int declares_class_or_enum;
	cp_decl_specifier_seq decl_specifiers;
	tree extension_specifier = NULL_TREE;

	/* Look for an (optional) storage-class-specifier or
	function-specifier. */
	if (cp_parser_allow_gnu_extensions_p (parser))
	{
	extension_specifier
	= cp_parser_storage_class_specifier_opt (parser);
	if (!extension_specifier)
	extension_specifier
	= cp_parser_function_specifier_opt (parser,
	/decl_specs=/NULL);
	}

	/* Look for the `template' keyword. */
	cp_parser_require_keyword (parser, RID_TEMPLATE, "`template'");
	/* Let the front end know that we are processing an explicit
	instantiation. */
	begin_explicit_instantiation ();
	/* [temp.explicit] says that we are supposed to ignore access
	control while processing explicit instantiation directives. */
	push_deferring_access_checks (dk_no_check);
	/* Parse a decl-specifier-seq. */
	cp_parser_decl_specifier_seq (parser,
	CP_PARSER_FLAGS_OPTIONAL,
	&decl_specifiers,
	&declares_class_or_enum);
	/* If there was exactly one decl-specifier, and it declared a class,
	and there's no declarator, then we have an explicit type
	instantiation. */
	if (declares_class_or_enum && cp_parser_declares_only_class_p (parser))
	{
	tree type;

	type = check_tag_decl (&decl_specifiers);
	/* Turn access control back on for names used during
	template instantiation. */
	pop_deferring_access_checks ();
	if (type)
	do_type_instantiation (type, extension_specifier,
	/complain=/tf_error);
	}
	else
	{
	cp_declarator *declarator;
	tree decl;

	/* Parse the declarator. */
	declarator
	= cp_parser_declarator (parser, CP_PARSER_DECLARATOR_NAMED,
	/ctor_dtor_or_conv_p=/NULL,
	/parenthesized_p=/NULL,
	/member_p=/false);
	if (declares_class_or_enum & 2)
	cp_parser_check_for_definition_in_return_type (declarator,
	decl_specifiers.type);
	if (declarator != cp_error_declarator)
	{
	decl = grokdeclarator (declarator, &decl_specifiers,
	NORMAL, 0, &decl_specifiers.attributes);
	/* Turn access control back on for names used during
	template instantiation. */
	pop_deferring_access_checks ();
	/* Do the explicit instantiation. */
	do_decl_instantiation (decl, extension_specifier);
	}
	else
	{
	pop_deferring_access_checks ();
	/* Skip the body of the explicit instantiation. */
	cp_parser_skip_to_end_of_statement (parser);
	}
	}
	/* We're done with the instantiation. */
	end_explicit_instantiation ();

	cp_parser_consume_semicolon_at_end_of_statement (parser);
	}

	/* Parse an explicit-specialization.

	explicit-specialization:
	template < > declaration

	Although the standard says `declaration', what it really means is:

	explicit-specialization:
	template <> decl-specifier [opt] init-declarator [opt] ;
	template <> function-definition
	template <> explicit-specialization
	template <> template-declaration */

	static void
	cp_parser_explicit_specialization (cp_parser* parser)
	{
	bool need_lang_pop;
	/* Look for the `template' keyword. */
	cp_parser_require_keyword (parser, RID_TEMPLATE, "`template'");
	/* Look for the `<'. */
	cp_parser_require (parser, CPP_LESS, "`<'");
	/* Look for the `>'. */
	cp_parser_require (parser, CPP_GREATER, "`>'");
	/* We have processed another parameter list. */
	++parser->num_template_parameter_lists;
	/* [temp]

	A template ... explicit specialization ... shall not have C
	linkage. */
	if (current_lang_name == lang_name_c)
	{
	error ("template specialization with C linkage");
	/* Give it C++ linkage to avoid confusing other parts of the
	front end. */
	push_lang_context (lang_name_cplusplus);
	need_lang_pop = true;
	}
	else
	need_lang_pop = false;
	/* Let the front end know that we are beginning a specialization. */
	if (!begin_specialization ())
	{
	end_specialization ();
	cp_parser_skip_to_end_of_block_or_statement (parser);
	return;
	}

	/* If the next keyword is `template', we need to figure out whether
	or not we're looking a template-declaration. */
	if (cp_lexer_next_token_is_keyword (parser->lexer, RID_TEMPLATE))
	{
	if (cp_lexer_peek_nth_token (parser->lexer, 2)->type == CPP_LESS
	&& cp_lexer_peek_nth_token (parser->lexer, 3)->type != CPP_GREATER)
	cp_parser_template_declaration_after_export (parser,
	/member_p=/false);
	else
	cp_parser_explicit_specialization (parser);
	}
	else
	/* Parse the dependent declaration. */
	cp_parser_single_declaration (parser,
	/checks=/NULL,
	/member_p=/false,
	/friend_p=/NULL);
	/* We're done with the specialization. */
	end_specialization ();
	/* For the erroneous case of a template with C linkage, we pushed an
	implicit C++ linkage scope; exit that scope now. */
	if (need_lang_pop)
	pop_lang_context ();
	/* We're done with this parameter list. */
	--parser->num_template_parameter_lists;
	}

	/* Parse a type-specifier.

	type-specifier:
	simple-type-specifier
	class-specifier
	enum-specifier
	elaborated-type-specifier
	cv-qualifier

	GNU Extension:

	type-specifier:
	__complex__

	Returns a representation of the type-specifier. For a
	class-specifier, enum-specifier, or elaborated-type-specifier, a
	TREE_TYPE is returned; otherwise, a TYPE_DECL is returned.

	The parser flags FLAGS is used to control type-specifier parsing.

	If IS_DECLARATION is TRUE, then this type-specifier is appearing
	in a decl-specifier-seq.

	If DECLARES_CLASS_OR_ENUM is non-NULL, and the type-specifier is a
	class-specifier, enum-specifier, or elaborated-type-specifier, then
	*DECLARES_CLASS_OR_ENUM is set to a nonzero value. The value is 1
	if a type is declared; 2 if it is defined. Otherwise, it is set to
	zero.

	If IS_CV_QUALIFIER is non-NULL, and the type-specifier is a
	cv-qualifier, then IS_CV_QUALIFIER is set to TRUE. Otherwise, it
	is set to FALSE. */

	static tree
	cp_parser_type_specifier (cp_parser* parser,
	cp_parser_flags flags,
	cp_decl_specifier_seq *decl_specs,
	bool is_declaration,
	int* declares_class_or_enum,
	bool* is_cv_qualifier)
	{
	tree type_spec = NULL_TREE;
	cp_token *token;
	enum rid keyword;
	cp_decl_spec ds = ds_last;

	/* Assume this type-specifier does not declare a new type. */
	if (declares_class_or_enum)
	*declares_class_or_enum = 0;
	/* And that it does not specify a cv-qualifier. */
	if (is_cv_qualifier)
	*is_cv_qualifier = false;
	/* Peek at the next token. */
	token = cp_lexer_peek_token (parser->lexer);

	/* If we're looking at a keyword, we can use that to guide the
	production we choose. */
	keyword = token->keyword;
	switch (keyword)
	{
	case RID_ENUM:
	/* Look for the enum-specifier. */
	type_spec = cp_parser_enum_specifier (parser);
	/* If that worked, we're done. */
	if (type_spec)
	{
	if (declares_class_or_enum)
	*declares_class_or_enum = 2;
	if (decl_specs)
	cp_parser_set_decl_spec_type (decl_specs,
	type_spec,
	/user_defined_p=/true);
	return type_spec;
	}
	else
	goto elaborated_type_specifier;

	/* Any of these indicate either a class-specifier, or an
	elaborated-type-specifier. */
	case RID_CLASS:
	case RID_STRUCT:
	case RID_UNION:
	/* Parse tentatively so that we can back up if we don't find a
	class-specifier. */
	cp_parser_parse_tentatively (parser);
	/* Look for the class-specifier. */
	type_spec = cp_parser_class_specifier (parser);
	/* If that worked, we're done. */
	if (cp_parser_parse_definitely (parser))
	{
	if (declares_class_or_enum)
	*declares_class_or_enum = 2;
	if (decl_specs)
	cp_parser_set_decl_spec_type (decl_specs,
	type_spec,
	/user_defined_p=/true);
	return type_spec;
	}

	/* Fall through. */
	elaborated_type_specifier:
	/* We're declaring (not defining) a class or enum. */
	if (declares_class_or_enum)
	*declares_class_or_enum = 1;

	/* Fall through. */
	case RID_TYPENAME:
	/* Look for an elaborated-type-specifier. */
	type_spec
	= (cp_parser_elaborated_type_specifier
	(parser,
	decl_specs && decl_specs->specs[(int) ds_friend],
	is_declaration));
	if (decl_specs)
	cp_parser_set_decl_spec_type (decl_specs,
	type_spec,
	/user_defined_p=/true);
	return type_spec;

	case RID_CONST:
	ds = ds_const;
	if (is_cv_qualifier)
	*is_cv_qualifier = true;
	break;

	case RID_VOLATILE:
	ds = ds_volatile;
	if (is_cv_qualifier)
	*is_cv_qualifier = true;
	break;

	case RID_RESTRICT:
	ds = ds_restrict;
	if (is_cv_qualifier)
	*is_cv_qualifier = true;
	break;

	case RID_COMPLEX:
	/* The `__complex__' keyword is a GNU extension. */
	ds = ds_complex;
	break;

	default:
	break;
	}

	/* Handle simple keywords. */
	if (ds != ds_last)
	{
	if (decl_specs)
	{
	++decl_specs->specs[(int)ds];
	decl_specs->any_specifiers_p = true;
	}
	return cp_lexer_consume_token (parser->lexer)->u.value;
	}

	/* If we do not already have a type-specifier, assume we are looking
	at a simple-type-specifier. */
	type_spec = cp_parser_simple_type_specifier (parser,
	decl_specs,
	flags);

	/* If we didn't find a type-specifier, and a type-specifier was not
	optional in this context, issue an error message. */
	if (!type_spec && !(flags & CP_PARSER_FLAGS_OPTIONAL))
	{
	cp_parser_error (parser, "expected type specifier");
	return error_mark_node;
	}

	return type_spec;
	}

	/* Parse a simple-type-specifier.

	simple-type-specifier:
	:: [opt] nested-name-specifier [opt] type-name
	:: [opt] nested-name-specifier template template-id
	char
	wchar_t
	bool
	short
	int
	long
	signed
	unsigned
	float
	double
	void

	GNU Extension:

	simple-type-specifier:
	__typeof__ unary-expression
	__typeof__ ( type-id )

	Returns the indicated TYPE_DECL. If DECL_SPECS is not NULL, it is
	appropriately updated. */

	static tree
	cp_parser_simple_type_specifier (cp_parser* parser,
	cp_decl_specifier_seq *decl_specs,
	cp_parser_flags flags)
	{
	tree type = NULL_TREE;
	cp_token *token;

	/* Peek at the next token. */
	token = cp_lexer_peek_token (parser->lexer);

	/* If we're looking at a keyword, things are easy. */
	switch (token->keyword)
	{
	case RID_CHAR:
	if (decl_specs)
	decl_specs->explicit_char_p = true;
	type = char_type_node;
	break;
	case RID_WCHAR:
	type = wchar_type_node;
	break;
	case RID_BOOL:
	type = boolean_type_node;
	break;
	case RID_SHORT:
	if (decl_specs)
	++decl_specs->specs[(int) ds_short];
	type = short_integer_type_node;
	break;
	case RID_INT:
	if (decl_specs)
	decl_specs->explicit_int_p = true;
	type = integer_type_node;
	break;
	case RID_LONG:
	if (decl_specs)
	++decl_specs->specs[(int) ds_long];
	type = long_integer_type_node;
	break;
	case RID_SIGNED:
	if (decl_specs)
	++decl_specs->specs[(int) ds_signed];
	type = integer_type_node;
	break;
	case RID_UNSIGNED:
	if (decl_specs)
	++decl_specs->specs[(int) ds_unsigned];
	type = unsigned_type_node;
	break;
	case RID_FLOAT:
	type = float_type_node;
	break;
	case RID_DOUBLE:
	type = double_type_node;
	break;
	case RID_VOID:
	type = void_type_node;
	break;

	case RID_TYPEOF:
	/* Consume the `typeof' token. */
	cp_lexer_consume_token (parser->lexer);
	/* Parse the operand to `typeof'. */
	type = cp_parser_sizeof_operand (parser, RID_TYPEOF);
	/* If it is not already a TYPE, take its type. */
	if (!TYPE_P (type))
	type = finish_typeof (type);

	if (decl_specs)
	cp_parser_set_decl_spec_type (decl_specs, type,
	/user_defined_p=/true);

	return type;

	default:
	break;
	}

	/* If the type-specifier was for a built-in type, we're done. */
	if (type)
	{
	tree id;

	/* Record the type. */
	if (decl_specs
	&& (token->keyword != RID_SIGNED
	&& token->keyword != RID_UNSIGNED
	&& token->keyword != RID_SHORT
	&& token->keyword != RID_LONG))
	cp_parser_set_decl_spec_type (decl_specs,
	type,
	/user_defined=/false);
	if (decl_specs)
	decl_specs->any_specifiers_p = true;

	/* Consume the token. */
	id = cp_lexer_consume_token (parser->lexer)->u.value;

	/* There is no valid C++ program where a non-template type is
	followed by a "<". That usually indicates that the user thought
	that the type was a template. */
	cp_parser_check_for_invalid_template_id (parser, type);

	return TYPE_NAME (type);
	}

	/* The type-specifier must be a user-defined type. */
	if (!(flags & CP_PARSER_FLAGS_NO_USER_DEFINED_TYPES))
	{
	bool qualified_p;
	bool global_p;

	/* Don't gobble tokens or issue error messages if this is an
	optional type-specifier. */
	if (flags & CP_PARSER_FLAGS_OPTIONAL)
	cp_parser_parse_tentatively (parser);

	/* Look for the optional `::' operator. */
	global_p
	= (cp_parser_global_scope_opt (parser,
	/current_scope_valid_p=/false)
	!= NULL_TREE);
	/* Look for the nested-name specifier. */
	qualified_p
	= (cp_parser_nested_name_specifier_opt (parser,
	/typename_keyword_p=/false,
	/check_dependency_p=/true,
	/type_p=/false,
	/is_declaration=/false)
	!= NULL_TREE);
	/* If we have seen a nested-name-specifier, and the next token
	is `template', then we are using the template-id production. */
	if (parser->scope
	&& cp_parser_optional_template_keyword (parser))
	{
	/* Look for the template-id. */
	type = cp_parser_template_id (parser,
	/template_keyword_p=/true,
	/check_dependency_p=/true,
	/is_declaration=/false);
	/* If the template-id did not name a type, we are out of
	luck. */
	if (TREE_CODE (type) != TYPE_DECL)
	{
	cp_parser_error (parser, "expected template-id for type");
	type = NULL_TREE;
	}
	}
	/* Otherwise, look for a type-name. */
	else
	type = cp_parser_type_name (parser);
	/* Keep track of all name-lookups performed in class scopes. */
	if (type
	&& !global_p
	&& !qualified_p
	&& TREE_CODE (type) == TYPE_DECL
	&& TREE_CODE (DECL_NAME (type)) == IDENTIFIER_NODE)
	maybe_note_name_used_in_class (DECL_NAME (type), type);
	/* If it didn't work out, we don't have a TYPE. */
	if ((flags & CP_PARSER_FLAGS_OPTIONAL)
	&& !cp_parser_parse_definitely (parser))
	type = NULL_TREE;
	if (type && decl_specs)
	cp_parser_set_decl_spec_type (decl_specs, type,
	/user_defined=/true);
	}

	/* If we didn't get a type-name, issue an error message. */
	if (!type && !(flags & CP_PARSER_FLAGS_OPTIONAL))
	{
	cp_parser_error (parser, "expected type-name");
	return error_mark_node;
	}

	/* There is no valid C++ program where a non-template type is
	followed by a "<". That usually indicates that the user thought
	that the type was a template. */
	if (type && type != error_mark_node)
	{
	/* As a last-ditch effort, see if TYPE is an Objective-C type.
	If it is, then the '<'...'>' enclose protocol names rather than
	template arguments, and so everything is fine. */
	if (c_dialect_objc ()
	&& (objc_is_id (type) \|\| objc_is_class_name (type)))
	{
	tree protos = cp_parser_objc_protocol_refs_opt (parser);
	tree qual_type = objc_get_protocol_qualified_type (type, protos);

	/* Clobber the "unqualified" type previously entered into
	DECL_SPECS with the new, improved protocol-qualified version. */
	if (decl_specs)
	decl_specs->type = qual_type;

	return qual_type;
	}

	cp_parser_check_for_invalid_template_id (parser, TREE_TYPE (type));
	}

	return type;
	}

	/* Parse a type-name.

	type-name:
	class-name
	enum-name
	typedef-name

	enum-name:
	identifier

	typedef-name:
	identifier

	Returns a TYPE_DECL for the type. */

	static tree
	cp_parser_type_name (cp_parser* parser)
	{
	tree type_decl;
	tree identifier;

	/* We can't know yet whether it is a class-name or not. */
	cp_parser_parse_tentatively (parser);
	/* Try a class-name. */
	type_decl = cp_parser_class_name (parser,
	/typename_keyword_p=/false,
	/template_keyword_p=/false,
	none_type,
	/check_dependency_p=/true,
	/class_head_p=/false,
	/is_declaration=/false);
	/* If it's not a class-name, keep looking. */
	if (!cp_parser_parse_definitely (parser))
	{
	/* It must be a typedef-name or an enum-name. */
	identifier = cp_parser_identifier (parser);
	if (identifier == error_mark_node)
	return error_mark_node;

	/* Look up the type-name. */
	type_decl = cp_parser_lookup_name_simple (parser, identifier);

	if (TREE_CODE (type_decl) != TYPE_DECL
	&& (objc_is_id (identifier) \|\| objc_is_class_name (identifier)))
	{
	/* See if this is an Objective-C type. */
	tree protos = cp_parser_objc_protocol_refs_opt (parser);
	tree type = objc_get_protocol_qualified_type (identifier, protos);
	if (type)
	type_decl = TYPE_NAME (type);
	}

	/* Issue an error if we did not find a type-name. */
	if (TREE_CODE (type_decl) != TYPE_DECL)
	{
	if (!cp_parser_simulate_error (parser))
	cp_parser_name_lookup_error (parser, identifier, type_decl,
	"is not a type");
	type_decl = error_mark_node;
	}
	/* Remember that the name was used in the definition of the
	current class so that we can check later to see if the
	meaning would have been different after the class was
	entirely defined. */
	else if (type_decl != error_mark_node
	&& !parser->scope)
	maybe_note_name_used_in_class (identifier, type_decl);
	}

	return type_decl;
	}


	/* Parse an elaborated-type-specifier. Note that the grammar given
	here incorporates the resolution to DR68.

	elaborated-type-specifier:
	class-key :: [opt] nested-name-specifier [opt] identifier
	class-key :: [opt] nested-name-specifier [opt] template [opt] template-id
	enum :: [opt] nested-name-specifier [opt] identifier
	typename :: [opt] nested-name-specifier identifier
	typename :: [opt] nested-name-specifier template [opt]
	template-id

	GNU extension:

	elaborated-type-specifier:
	class-key attributes :: [opt] nested-name-specifier [opt] identifier
	class-key attributes :: [opt] nested-name-specifier [opt]
	template [opt] template-id
	enum attributes :: [opt] nested-name-specifier [opt] identifier

	If IS_FRIEND is TRUE, then this elaborated-type-specifier is being
	declared `friend'. If IS_DECLARATION is TRUE, then this
	elaborated-type-specifier appears in a decl-specifiers-seq, i.e.,
	something is being declared.

	Returns the TYPE specified. */

	static tree
	cp_parser_elaborated_type_specifier (cp_parser* parser,
	bool is_friend,
	bool is_declaration)
	{
	enum tag_types tag_type;
	tree identifier;
	tree type = NULL_TREE;
	tree attributes = NULL_TREE;

	/* See if we're looking at the `enum' keyword. */
	if (cp_lexer_next_token_is_keyword (parser->lexer, RID_ENUM))
	{
	/* Consume the `enum' token. */
	cp_lexer_consume_token (parser->lexer);
	/* Remember that it's an enumeration type. */
	tag_type = enum_type;
	/* Parse the attributes. */
	attributes = cp_parser_attributes_opt (parser);
	}
	/* Or, it might be `typename'. */
	else if (cp_lexer_next_token_is_keyword (parser->lexer,
	RID_TYPENAME))
	{
	/* Consume the `typename' token. */
	cp_lexer_consume_token (parser->lexer);
	/* Remember that it's a `typename' type. */
	tag_type = typename_type;
	/* The `typename' keyword is only allowed in templates. */
	if (!processing_template_decl)
	pedwarn ("using %<typename%> outside of template");
	}
	/* Otherwise it must be a class-key. */
	else
	{
	tag_type = cp_parser_class_key (parser);
	if (tag_type == none_type)
	return error_mark_node;
	/* Parse the attributes. */
	attributes = cp_parser_attributes_opt (parser);
	}

	/* Look for the `::' operator. */
	cp_parser_global_scope_opt (parser,
	/current_scope_valid_p=/false);
	/* Look for the nested-name-specifier. */
	if (tag_type == typename_type)
	{
	if (!cp_parser_nested_name_specifier (parser,
	/typename_keyword_p=/true,
	/check_dependency_p=/true,
	/type_p=/true,
	is_declaration))
	return error_mark_node;
	}
	else
	/* Even though `typename' is not present, the proposed resolution
	to Core Issue 180 says that in `class A<T>::B', `B' should be
	considered a type-name, even if `A<T>' is dependent. */
	cp_parser_nested_name_specifier_opt (parser,
	/typename_keyword_p=/true,
	/check_dependency_p=/true,
	/type_p=/true,
	is_declaration);
	/* For everything but enumeration types, consider a template-id.
	For an enumeration type, consider only a plain identifier. */
	if (tag_type != enum_type)
	{
	bool template_p = false;
	tree decl;

	/* Allow the `template' keyword. */
	template_p = cp_parser_optional_template_keyword (parser);
	/* If we didn't see `template', we don't know if there's a
	template-id or not. */
	if (!template_p)
	cp_parser_parse_tentatively (parser);
	/* Parse the template-id. */
	decl = cp_parser_template_id (parser, template_p,
	/check_dependency_p=/true,
	is_declaration);
	/* If we didn't find a template-id, look for an ordinary
	identifier. */
	if (!template_p && !cp_parser_parse_definitely (parser))
	;
	/* If DECL is a TEMPLATE_ID_EXPR, and the `typename' keyword is
	in effect, then we must assume that, upon instantiation, the
	template will correspond to a class. */
	else if (TREE_CODE (decl) == TEMPLATE_ID_EXPR
	&& tag_type == typename_type)
	type = make_typename_type (parser->scope, decl,
	typename_type,
	/complain=/tf_error);
	else
	type = TREE_TYPE (decl);
	}

	if (!type)
	{
	identifier = cp_parser_identifier (parser);

	if (identifier == error_mark_node)
	{
	parser->scope = NULL_TREE;
	return error_mark_node;
	}

	/* For a `typename', we needn't call xref_tag. */
	if (tag_type == typename_type
	&& TREE_CODE (parser->scope) != NAMESPACE_DECL)
	return cp_parser_make_typename_type (parser, parser->scope,
	identifier);
	/* Look up a qualified name in the usual way. */
	if (parser->scope)
	{
	tree decl;

	decl = cp_parser_lookup_name (parser, identifier,
	tag_type,
	/is_template=/false,
	/is_namespace=/false,
	/check_dependency=/true,
	/ambiguous_decls=/NULL);

	/* If we are parsing friend declaration, DECL may be a
	TEMPLATE_DECL tree node here. However, we need to check
	whether this TEMPLATE_DECL results in valid code. Consider
	the following example:

	namespace N {
	template <class T> class C {};
	}
	class X {
	template <class T> friend class N::C; // #1, valid code
	};
	template <class T> class Y {
	friend class N::C; // #2, invalid code
	};

	For both case #1 and #2, we arrive at a TEMPLATE_DECL after
	name lookup of `N::C'. We see that friend declaration must
	be template for the code to be valid. Note that
	processing_template_decl does not work here since it is
	always 1 for the above two cases. */

	decl = (cp_parser_maybe_treat_template_as_class
	(decl, /tag_name_p=/is_friend
	&& parser->num_template_parameter_lists));

	if (TREE_CODE (decl) != TYPE_DECL)
	{
	cp_parser_diagnose_invalid_type_name (parser,
	parser->scope,
	identifier);
	return error_mark_node;
	}

	if (TREE_CODE (TREE_TYPE (decl)) != TYPENAME_TYPE)
	{
	bool allow_template = (parser->num_template_parameter_lists
	\|\| DECL_SELF_REFERENCE_P (decl));
	type = check_elaborated_type_specifier (tag_type, decl,
	allow_template);

	if (type == error_mark_node)
	return error_mark_node;
	}

	type = TREE_TYPE (decl);
	}
	else
	{
	/* An elaborated-type-specifier sometimes introduces a new type and
	sometimes names an existing type. Normally, the rule is that it
	introduces a new type only if there is not an existing type of
	the same name already in scope. For example, given:

	struct S {};
	void f() { struct S s; }

	the `struct S' in the body of `f' is the same `struct S' as in
	the global scope; the existing definition is used. However, if
	there were no global declaration, this would introduce a new
	local class named `S'.

	An exception to this rule applies to the following code:

	namespace N { struct S; }

	Here, the elaborated-type-specifier names a new type
	unconditionally; even if there is already an `S' in the
	containing scope this declaration names a new type.
	This exception only applies if the elaborated-type-specifier
	forms the complete declaration:

	[class.name]

	A declaration consisting solely of `class-key identifier ;' is
	either a redeclaration of the name in the current scope or a
	forward declaration of the identifier as a class name. It
	introduces the name into the current scope.

	We are in this situation precisely when the next token is a `;'.

	An exception to the exception is that a `friend' declaration does
	not name a new type; i.e., given:

	struct S { friend struct T; };

	`T' is not a new type in the scope of `S'.

	Also, `new struct S' or `sizeof (struct S)' never results in the
	definition of a new type; a new type can only be declared in a
	declaration context. */

	tag_scope ts;
	bool template_p;

	if (is_friend)
	/* Friends have special name lookup rules. */
	ts = ts_within_enclosing_non_class;
	else if (is_declaration
	&& cp_lexer_next_token_is (parser->lexer,
	CPP_SEMICOLON))
	/* This is a `class-key identifier ;' */
	ts = ts_current;
	else
	ts = ts_global;

	template_p =
	(parser->num_template_parameter_lists
	&& (cp_parser_next_token_starts_class_definition_p (parser)
	\|\| cp_lexer_next_token_is (parser->lexer, CPP_SEMICOLON)));
	/* An unqualified name was used to reference this type, so
	there were no qualifying templates. */
	if (!cp_parser_check_template_parameters (parser,
	/num_templates=/0))
	return error_mark_node;
	type = xref_tag (tag_type, identifier, ts, template_p);
	}
	}

	if (type == error_mark_node)
	return error_mark_node;

	/* Allow attributes on forward declarations of classes. */
	if (attributes)
	{
	if (TREE_CODE (type) == TYPENAME_TYPE)
	warning (OPT_Wattributes,
	"attributes ignored on uninstantiated type");
	else if (tag_type != enum_type && CLASSTYPE_TEMPLATE_INSTANTIATION (type)
	&& ! processing_explicit_instantiation)
	warning (OPT_Wattributes,
	"attributes ignored on template instantiation");
	else if (is_declaration && cp_parser_declares_only_class_p (parser))
	cplus_decl_attributes (&type, attributes, (int) ATTR_FLAG_TYPE_IN_PLACE);
	else
	warning (OPT_Wattributes,
	"attributes ignored on elaborated-type-specifier that is not a forward declaration");
	}

	if (tag_type != enum_type)
	cp_parser_check_class_key (tag_type, type);

	/* A "<" cannot follow an elaborated type specifier. If that
	happens, the user was probably trying to form a template-id. */
	cp_parser_check_for_invalid_template_id (parser, type);

	return type;
	}

	/* Parse an enum-specifier.

	enum-specifier:
	enum identifier [opt] { enumerator-list [opt] }

	GNU Extensions:
	enum attributes[opt] identifier [opt] { enumerator-list [opt] }
	attributes[opt]

	Returns an ENUM_TYPE representing the enumeration, or NULL_TREE
	if the token stream isn't an enum-specifier after all. */

	static tree
	cp_parser_enum_specifier (cp_parser* parser)
	{
	tree identifier;
	tree type;
	tree attributes;

	/* Parse tentatively so that we can back up if we don't find a
	enum-specifier. */
	cp_parser_parse_tentatively (parser);

	/* Caller guarantees that the current token is 'enum', an identifier
	possibly follows, and the token after that is an opening brace.
	If we don't have an identifier, fabricate an anonymous name for
	the enumeration being defined. */
	cp_lexer_consume_token (parser->lexer);

	attributes = cp_parser_attributes_opt (parser);

	if (cp_lexer_next_token_is (parser->lexer, CPP_NAME))
	identifier = cp_parser_identifier (parser);
	else
	identifier = make_anon_name ();

	/* Look for the `{' but don't consume it yet. */
	if (!cp_lexer_next_token_is (parser->lexer, CPP_OPEN_BRACE))
	cp_parser_simulate_error (parser);

	if (!cp_parser_parse_definitely (parser))
	return NULL_TREE;

	/* Issue an error message if type-definitions are forbidden here. */
	if (!cp_parser_check_type_definition (parser))
	type = error_mark_node;
	else
	/* Create the new type. We do this before consuming the opening
	brace so the enum will be recorded as being on the line of its
	tag (or the 'enum' keyword, if there is no tag). */
	type = start_enum (identifier);

	/* Consume the opening brace. */
	cp_lexer_consume_token (parser->lexer);

	if (type == error_mark_node)
	{
	cp_parser_skip_to_end_of_block_or_statement (parser);
	return error_mark_node;
	}

	/* If the next token is not '}', then there are some enumerators. */
	if (cp_lexer_next_token_is_not (parser->lexer, CPP_CLOSE_BRACE))
	cp_parser_enumerator_list (parser, type);

	/* Consume the final '}'. */
	cp_parser_require (parser, CPP_CLOSE_BRACE, "`}'");

	/* Look for trailing attributes to apply to this enumeration, and
	apply them if appropriate. */
	if (cp_parser_allow_gnu_extensions_p (parser))
	{
	tree trailing_attr = cp_parser_attributes_opt (parser);
	cplus_decl_attributes (&type,
	trailing_attr,
	(int) ATTR_FLAG_TYPE_IN_PLACE);
	}

	/* Finish up the enumeration. */
	finish_enum (type);

	return type;
	}

	/* Parse an enumerator-list. The enumerators all have the indicated
	TYPE.

	enumerator-list:
	enumerator-definition
	enumerator-list , enumerator-definition */

	static void
	cp_parser_enumerator_list (cp_parser* parser, tree type)
	{
	while (true)
	{
	/* Parse an enumerator-definition. */
	cp_parser_enumerator_definition (parser, type);

	/* If the next token is not a ',', we've reached the end of
	the list. */
	if (cp_lexer_next_token_is_not (parser->lexer, CPP_COMMA))
	break;
	/* Otherwise, consume the `,' and keep going. */
	cp_lexer_consume_token (parser->lexer);
	/* If the next token is a `}', there is a trailing comma. */
	if (cp_lexer_next_token_is (parser->lexer, CPP_CLOSE_BRACE))
	{
	if (pedantic && !in_system_header)
	pedwarn ("comma at end of enumerator list");
	break;
	}
	}
	}

	/* Parse an enumerator-definition. The enumerator has the indicated
	TYPE.

	enumerator-definition:
	enumerator
	enumerator = constant-expression

	enumerator:
	identifier */

	static void
	cp_parser_enumerator_definition (cp_parser* parser, tree type)
	{
	tree identifier;
	tree value;

	/* Look for the identifier. */
	identifier = cp_parser_identifier (parser);
	if (identifier == error_mark_node)
	return;

	/* If the next token is an '=', then there is an explicit value. */
	if (cp_lexer_next_token_is (parser->lexer, CPP_EQ))
	{
	/* Consume the `=' token. */
	cp_lexer_consume_token (parser->lexer);
	/* Parse the value. */
	value = cp_parser_constant_expression (parser,
	/allow_non_constant_p=/false,
	NULL);
	}
	else
	value = NULL_TREE;

	/* Create the enumerator. */
	build_enumerator (identifier, value, type);
	}

	/* Parse a namespace-name.

	namespace-name:
	original-namespace-name
	namespace-alias

	Returns the NAMESPACE_DECL for the namespace. */

	static tree
	cp_parser_namespace_name (cp_parser* parser)
	{
	tree identifier;
	tree namespace_decl;

	/* Get the name of the namespace. */
	identifier = cp_parser_identifier (parser);
	if (identifier == error_mark_node)
	return error_mark_node;

	/* Look up the identifier in the currently active scope. Look only
	for namespaces, due to:

	[basic.lookup.udir]

	When looking up a namespace-name in a using-directive or alias
	definition, only namespace names are considered.

	And:

	[basic.lookup.qual]

	During the lookup of a name preceding the :: scope resolution
	operator, object, function, and enumerator names are ignored.

	(Note that cp_parser_class_or_namespace_name only calls this
	function if the token after the name is the scope resolution
	operator.) */
	namespace_decl = cp_parser_lookup_name (parser, identifier,
	none_type,
	/is_template=/false,
	/is_namespace=/true,
	/check_dependency=/true,
	/ambiguous_decls=/NULL);
	/* If it's not a namespace, issue an error. */
	if (namespace_decl == error_mark_node
	\|\| TREE_CODE (namespace_decl) != NAMESPACE_DECL)
	{
	if (!cp_parser_uncommitted_to_tentative_parse_p (parser))
	error ("%qD is not a namespace-name", identifier);
	cp_parser_error (parser, "expected namespace-name");
	namespace_decl = error_mark_node;
	}

	return namespace_decl;
	}

	/* Parse a namespace-definition.

	namespace-definition:
	named-namespace-definition
	unnamed-namespace-definition

	named-namespace-definition:
	original-namespace-definition
	extension-namespace-definition

	original-namespace-definition:
	namespace identifier { namespace-body }

	extension-namespace-definition:
	namespace original-namespace-name { namespace-body }

	unnamed-namespace-definition:
	namespace { namespace-body } */

	static void
	cp_parser_namespace_definition (cp_parser* parser)
	{
	tree identifier, attribs;

	/* Look for the `namespace' keyword. */
	cp_parser_require_keyword (parser, RID_NAMESPACE, "`namespace'");

	/* Get the name of the namespace. We do not attempt to distinguish
	between an original-namespace-definition and an
	extension-namespace-definition at this point. The semantic
	analysis routines are responsible for that. */
	if (cp_lexer_next_token_is (parser->lexer, CPP_NAME))
	identifier = cp_parser_identifier (parser);
	else
	identifier = NULL_TREE;

	/* Parse any specified attributes. */
	attribs = cp_parser_attributes_opt (parser);

	/* Look for the `{' to start the namespace. */
	cp_parser_require (parser, CPP_OPEN_BRACE, "`{'");
	/* Start the namespace. */
	push_namespace_with_attribs (identifier, attribs);
	/* Parse the body of the namespace. */
	cp_parser_namespace_body (parser);
	/* Finish the namespace. */
	pop_namespace ();
	/* Look for the final `}'. */
	cp_parser_require (parser, CPP_CLOSE_BRACE, "`}'");
	}

	/* Parse a namespace-body.

	namespace-body:
	declaration-seq [opt] */

	static void
	cp_parser_namespace_body (cp_parser* parser)
	{
	cp_parser_declaration_seq_opt (parser);
	}

	/* Parse a namespace-alias-definition.

	namespace-alias-definition:
	namespace identifier = qualified-namespace-specifier ; */

	static void
	cp_parser_namespace_alias_definition (cp_parser* parser)
	{
	tree identifier;
	tree namespace_specifier;

	/* Look for the `namespace' keyword. */
	cp_parser_require_keyword (parser, RID_NAMESPACE, "`namespace'");
	/* Look for the identifier. */
	identifier = cp_parser_identifier (parser);
	if (identifier == error_mark_node)
	return;
	/* Look for the `=' token. */
	cp_parser_require (parser, CPP_EQ, "`='");
	/* Look for the qualified-namespace-specifier. */
	namespace_specifier
	= cp_parser_qualified_namespace_specifier (parser);
	/* Look for the `;' token. */
	cp_parser_require (parser, CPP_SEMICOLON, "`;'");

	/* Register the alias in the symbol table. */
	do_namespace_alias (identifier, namespace_specifier);
	}

	/* Parse a qualified-namespace-specifier.

	qualified-namespace-specifier:
	:: [opt] nested-name-specifier [opt] namespace-name

	Returns a NAMESPACE_DECL corresponding to the specified
	namespace. */

	static tree
	cp_parser_qualified_namespace_specifier (cp_parser* parser)
	{
	/* Look for the optional `::'. */
	cp_parser_global_scope_opt (parser,
	/current_scope_valid_p=/false);

	/* Look for the optional nested-name-specifier. */
	cp_parser_nested_name_specifier_opt (parser,
	/typename_keyword_p=/false,
	/check_dependency_p=/true,
	/type_p=/false,
	/is_declaration=/true);

	return cp_parser_namespace_name (parser);
	}

	/* Parse a using-declaration, or, if ACCESS_DECLARATION_P is true, an
	access declaration.

	using-declaration:
	using typename [opt] :: [opt] nested-name-specifier unqualified-id ;
	using :: unqualified-id ;

	access-declaration:
	qualified-id ;

	*/

	static bool
	cp_parser_using_declaration (cp_parser* parser,
	bool access_declaration_p)
	{
	cp_token *token;
	bool typename_p = false;
	bool global_scope_p;
	tree decl;
	tree identifier;
	tree qscope;

	if (access_declaration_p)
	cp_parser_parse_tentatively (parser);
	else
	{
	/* Look for the `using' keyword. */
	cp_parser_require_keyword (parser, RID_USING, "`using'");

	/* Peek at the next token. */
	token = cp_lexer_peek_token (parser->lexer);
	/* See if it's `typename'. */
	if (token->keyword == RID_TYPENAME)
	{
	/* Remember that we've seen it. */
	typename_p = true;
	/* Consume the `typename' token. */
	cp_lexer_consume_token (parser->lexer);
	}
	}

	/* Look for the optional global scope qualification. */
	global_scope_p
	= (cp_parser_global_scope_opt (parser,
	/current_scope_valid_p=/false)
	!= NULL_TREE);

	/* If we saw `typename', or didn't see `::', then there must be a
	nested-name-specifier present. */
	if (typename_p \|\| !global_scope_p)
	qscope = cp_parser_nested_name_specifier (parser, typename_p,
	/check_dependency_p=/true,
	/type_p=/false,
	/is_declaration=/true);
	/* Otherwise, we could be in either of the two productions. In that
	case, treat the nested-name-specifier as optional. */
	else
	qscope = cp_parser_nested_name_specifier_opt (parser,
	/typename_keyword_p=/false,
	/check_dependency_p=/true,
	/type_p=/false,
	/is_declaration=/true);
	if (!qscope)
	qscope = global_namespace;

	if (access_declaration_p && cp_parser_error_occurred (parser))
	/* Something has already gone wrong; there's no need to parse
	further. Since an error has occurred, the return value of
	cp_parser_parse_definitely will be false, as required. */
	return cp_parser_parse_definitely (parser);

	/* Parse the unqualified-id. */
	identifier = cp_parser_unqualified_id (parser,
	/template_keyword_p=/false,
	/check_dependency_p=/true,
	/declarator_p=/true,
	/optional_p=/false);

	if (access_declaration_p)
	{
	if (cp_lexer_next_token_is_not (parser->lexer, CPP_SEMICOLON))
	cp_parser_simulate_error (parser);
	if (!cp_parser_parse_definitely (parser))
	return false;
	}

	/* The function we call to handle a using-declaration is different
	depending on what scope we are in. */
	if (qscope == error_mark_node \|\| identifier == error_mark_node)
	;
	else if (TREE_CODE (identifier) != IDENTIFIER_NODE
	&& TREE_CODE (identifier) != BIT_NOT_EXPR)
	/* [namespace.udecl]

	A using declaration shall not name a template-id. */
	error ("a template-id may not appear in a using-declaration");
	else
	{
	if (at_class_scope_p ())
	{
	/* Create the USING_DECL. */
	decl = do_class_using_decl (parser->scope, identifier);
	/* Add it to the list of members in this class. */
	finish_member_declaration (decl);
	}
	else
	{
	decl = cp_parser_lookup_name_simple (parser, identifier);
	if (decl == error_mark_node)
	cp_parser_name_lookup_error (parser, identifier, decl, NULL);
	else if (!at_namespace_scope_p ())
	do_local_using_decl (decl, qscope, identifier);
	else
	do_toplevel_using_decl (decl, qscope, identifier);
	}
	}

	/* Look for the final `;'. */
	cp_parser_require (parser, CPP_SEMICOLON, "`;'");

	return true;
	}

	/* Parse a using-directive.

	using-directive:
	using namespace :: [opt] nested-name-specifier [opt]
	namespace-name ; */

	static void
	cp_parser_using_directive (cp_parser* parser)
	{
	tree namespace_decl;
	tree attribs;

	/* Look for the `using' keyword. */
	cp_parser_require_keyword (parser, RID_USING, "`using'");
	/* And the `namespace' keyword. */
	cp_parser_require_keyword (parser, RID_NAMESPACE, "`namespace'");
	/* Look for the optional `::' operator. */
	cp_parser_global_scope_opt (parser, /current_scope_valid_p=/false);
	/* And the optional nested-name-specifier. */
	cp_parser_nested_name_specifier_opt (parser,
	/typename_keyword_p=/false,
	/check_dependency_p=/true,
	/type_p=/false,
	/is_declaration=/true);
	/* Get the namespace being used. */
	namespace_decl = cp_parser_namespace_name (parser);
	/* And any specified attributes. */
	attribs = cp_parser_attributes_opt (parser);
	/* Update the symbol table. */
	parse_using_directive (namespace_decl, attribs);
	/* Look for the final `;'. */
	cp_parser_require (parser, CPP_SEMICOLON, "`;'");
	}

	/* Parse an asm-definition.

	asm-definition:
	asm ( string-literal ) ;

	GNU Extension:

	asm-definition:
	asm volatile [opt] ( string-literal ) ;
	asm volatile [opt] ( string-literal : asm-operand-list [opt] ) ;
	asm volatile [opt] ( string-literal : asm-operand-list [opt]
	: asm-operand-list [opt] ) ;
	asm volatile [opt] ( string-literal : asm-operand-list [opt]
	: asm-operand-list [opt]
	: asm-operand-list [opt] ) ; */

	static void
	cp_parser_asm_definition (cp_parser* parser)
	{
	tree string;
	tree outputs = NULL_TREE;
	tree inputs = NULL_TREE;
	tree clobbers = NULL_TREE;
	tree asm_stmt;
	bool volatile_p = false;
	bool extended_p = false;

	/* Look for the `asm' keyword. */
	cp_parser_require_keyword (parser, RID_ASM, "`asm'");
	/* See if the next token is `volatile'. */
	if (cp_parser_allow_gnu_extensions_p (parser)
	&& cp_lexer_next_token_is_keyword (parser->lexer, RID_VOLATILE))
	{
	/* Remember that we saw the `volatile' keyword. */
	volatile_p = true;
	/* Consume the token. */
	cp_lexer_consume_token (parser->lexer);
	}
	/* Look for the opening `('. */
	if (!cp_parser_require (parser, CPP_OPEN_PAREN, "`('"))
	return;
	/* Look for the string. */
	string = cp_parser_string_literal (parser, false, false);
	if (string == error_mark_node)
	{
	cp_parser_skip_to_closing_parenthesis (parser, true, false,
	/consume_paren=/true);
	return;
	}

	/* If we're allowing GNU extensions, check for the extended assembly
	syntax. Unfortunately, the `:' tokens need not be separated by
	a space in C, and so, for compatibility, we tolerate that here
	too. Doing that means that we have to treat the `::' operator as
	two `:' tokens. */
	if (cp_parser_allow_gnu_extensions_p (parser)
	&& parser->in_function_body
	&& (cp_lexer_next_token_is (parser->lexer, CPP_COLON)
	\|\| cp_lexer_next_token_is (parser->lexer, CPP_SCOPE)))
	{
	bool inputs_p = false;
	bool clobbers_p = false;

	/* The extended syntax was used. */
	extended_p = true;

	/* Look for outputs. */
	if (cp_lexer_next_token_is (parser->lexer, CPP_COLON))
	{
	/* Consume the `:'. */
	cp_lexer_consume_token (parser->lexer);
	/* Parse the output-operands. */
	if (cp_lexer_next_token_is_not (parser->lexer,
	CPP_COLON)
	&& cp_lexer_next_token_is_not (parser->lexer,
	CPP_SCOPE)
	&& cp_lexer_next_token_is_not (parser->lexer,
	CPP_CLOSE_PAREN))
	outputs = cp_parser_asm_operand_list (parser);
	}
	/* If the next token is `::', there are no outputs, and the
	next token is the beginning of the inputs. */
	else if (cp_lexer_next_token_is (parser->lexer, CPP_SCOPE))
	/* The inputs are coming next. */
	inputs_p = true;

	/* Look for inputs. */
	if (inputs_p
	\|\| cp_lexer_next_token_is (parser->lexer, CPP_COLON))
	{
	/* Consume the `:' or `::'. */
	cp_lexer_consume_token (parser->lexer);
	/* Parse the output-operands. */
	if (cp_lexer_next_token_is_not (parser->lexer,
	CPP_COLON)
	&& cp_lexer_next_token_is_not (parser->lexer,
	CPP_CLOSE_PAREN))
	inputs = cp_parser_asm_operand_list (parser);
	}
	else if (cp_lexer_next_token_is (parser->lexer, CPP_SCOPE))
	/* The clobbers are coming next. */
	clobbers_p = true;

	/* Look for clobbers. */
	if (clobbers_p
	\|\| cp_lexer_next_token_is (parser->lexer, CPP_COLON))
	{
	/* Consume the `:' or `::'. */
	cp_lexer_consume_token (parser->lexer);
	/* Parse the clobbers. */
	if (cp_lexer_next_token_is_not (parser->lexer,
	CPP_CLOSE_PAREN))
	clobbers = cp_parser_asm_clobber_list (parser);
	}
	}
	/* Look for the closing `)'. */
	if (!cp_parser_require (parser, CPP_CLOSE_PAREN, "`)'"))
	cp_parser_skip_to_closing_parenthesis (parser, true, false,
	/consume_paren=/true);
	cp_parser_require (parser, CPP_SEMICOLON, "`;'");

	/* Create the ASM_EXPR. */
	if (parser->in_function_body)
	{
	asm_stmt = finish_asm_stmt (volatile_p, string, outputs,
	inputs, clobbers);
	/* If the extended syntax was not used, mark the ASM_EXPR. */
	if (!extended_p)
	{
	tree temp = asm_stmt;
	if (TREE_CODE (temp) == CLEANUP_POINT_EXPR)
	temp = TREE_OPERAND (temp, 0);

	ASM_INPUT_P (temp) = 1;
	}
	}
	else
	cgraph_add_asm_node (string);
	}

	/* Declarators [gram.dcl.decl] */

	/* Parse an init-declarator.

	init-declarator:
	declarator initializer [opt]

	GNU Extension:

	init-declarator:
	declarator asm-specification [opt] attributes [opt] initializer [opt]

	function-definition:
	decl-specifier-seq [opt] declarator ctor-initializer [opt]
	function-body
	decl-specifier-seq [opt] declarator function-try-block

	GNU Extension:

	function-definition:
	__extension__ function-definition

	The DECL_SPECIFIERS apply to this declarator. Returns a
	representation of the entity declared. If MEMBER_P is TRUE, then
	this declarator appears in a class scope. The new DECL created by
	this declarator is returned.

	The CHECKS are access checks that should be performed once we know
	what entity is being declared (and, therefore, what classes have
	befriended it).

	If FUNCTION_DEFINITION_ALLOWED_P then we handle the declarator and
	for a function-definition here as well. If the declarator is a
	declarator for a function-definition, *FUNCTION_DEFINITION_P will
	be TRUE upon return. By that point, the function-definition will
	have been completely parsed.

	FUNCTION_DEFINITION_P may be NULL if FUNCTION_DEFINITION_ALLOWED_P
	is FALSE. */

	static tree
	cp_parser_init_declarator (cp_parser* parser,
	cp_decl_specifier_seq *decl_specifiers,
	VEC (deferred_access_check,gc)* checks,
	bool function_definition_allowed_p,
	bool member_p,
	int declares_class_or_enum,
	bool* function_definition_p)
	{
	cp_token *token;
	cp_declarator *declarator;
	tree prefix_attributes;
	tree attributes;
	tree asm_specification;
	tree initializer;
	tree decl = NULL_TREE;
	tree scope;
	bool is_initialized;
	/* Only valid if IS_INITIALIZED is true. In that case, CPP_EQ if
	initialized with "= ..", CPP_OPEN_PAREN if initialized with
	"(...)". */
	enum cpp_ttype initialization_kind;
	bool is_parenthesized_init = false;
	bool is_non_constant_init;
	int ctor_dtor_or_conv_p;
	bool friend_p;
	tree pushed_scope = NULL;

	/* Gather the attributes that were provided with the
	decl-specifiers. */
	prefix_attributes = decl_specifiers->attributes;

	/* Assume that this is not the declarator for a function
	definition. */
	if (function_definition_p)
	*function_definition_p = false;

	/* Defer access checks while parsing the declarator; we cannot know
	what names are accessible until we know what is being
	declared. */
	resume_deferring_access_checks ();

	/* Parse the declarator. */
	declarator
	= cp_parser_declarator (parser, CP_PARSER_DECLARATOR_NAMED,
	&ctor_dtor_or_conv_p,
	/parenthesized_p=/NULL,
	/member_p=/false);
	/* Gather up the deferred checks. */
	stop_deferring_access_checks ();

	/* If the DECLARATOR was erroneous, there's no need to go
	further. */
	if (declarator == cp_error_declarator)
	return error_mark_node;

	/* Check that the number of template-parameter-lists is OK. */
	if (!cp_parser_check_declarator_template_parameters (parser, declarator))
	return error_mark_node;

	if (declares_class_or_enum & 2)
	cp_parser_check_for_definition_in_return_type (declarator,
	decl_specifiers->type);

	/* Figure out what scope the entity declared by the DECLARATOR is
	located in. `grokdeclarator' sometimes changes the scope, so
	we compute it now. */
	scope = get_scope_of_declarator (declarator);

	/* If we're allowing GNU extensions, look for an asm-specification
	and attributes. */
	if (cp_parser_allow_gnu_extensions_p (parser))
	{
	/* Look for an asm-specification. */
	asm_specification = cp_parser_asm_specification_opt (parser);
	/* And attributes. */
	attributes = cp_parser_attributes_opt (parser);
	}
	else
	{
	asm_specification = NULL_TREE;
	attributes = NULL_TREE;
	}

	/* Peek at the next token. */
	token = cp_lexer_peek_token (parser->lexer);
	/* Check to see if the token indicates the start of a
	function-definition. */
	if (cp_parser_token_starts_function_definition_p (token))
	{
	if (!function_definition_allowed_p)
	{
	/* If a function-definition should not appear here, issue an
	error message. */
	cp_parser_error (parser,
	"a function-definition is not allowed here");
	return error_mark_node;
	}
	else
	{
	/* Neither attributes nor an asm-specification are allowed
	on a function-definition. */
	if (asm_specification)
	error ("an asm-specification is not allowed on a function-definition");
	if (attributes)
	error ("attributes are not allowed on a function-definition");
	/* This is a function-definition. */
	*function_definition_p = true;

	/* Parse the function definition. */
	if (member_p)
	decl = cp_parser_save_member_function_body (parser,
	decl_specifiers,
	declarator,
	prefix_attributes);
	else
	decl
	= (cp_parser_function_definition_from_specifiers_and_declarator
	(parser, decl_specifiers, prefix_attributes, declarator));

	return decl;
	}
	}

	/* [dcl.dcl]

	Only in function declarations for constructors, destructors, and
	type conversions can the decl-specifier-seq be omitted.

	We explicitly postpone this check past the point where we handle
	function-definitions because we tolerate function-definitions
	that are missing their return types in some modes. */
	if (!decl_specifiers->any_specifiers_p && ctor_dtor_or_conv_p <= 0)
	{
	cp_parser_error (parser,
	"expected constructor, destructor, or type conversion");
	return error_mark_node;
	}

	/* An `=' or an `(' indicates an initializer. */
	if (token->type == CPP_EQ
	\|\| token->type == CPP_OPEN_PAREN)
	{
	is_initialized = true;
	initialization_kind = token->type;
	}
	else
	{
	/* If the init-declarator isn't initialized and isn't followed by a
	`,' or `;', it's not a valid init-declarator. */
	if (token->type != CPP_COMMA
	&& token->type != CPP_SEMICOLON)
	{
	cp_parser_error (parser, "expected initializer");
	return error_mark_node;
	}
	is_initialized = false;
	initialization_kind = CPP_EOF;
	}

	/* Because start_decl has side-effects, we should only call it if we
	know we're going ahead. By this point, we know that we cannot
	possibly be looking at any other construct. */
	cp_parser_commit_to_tentative_parse (parser);

	/* If the decl specifiers were bad, issue an error now that we're
	sure this was intended to be a declarator. Then continue
	declaring the variable(s), as int, to try to cut down on further
	errors. */
	if (decl_specifiers->any_specifiers_p
	&& decl_specifiers->type == error_mark_node)
	{
	cp_parser_error (parser, "invalid type in declaration");
	decl_specifiers->type = integer_type_node;
	}

	/* Check to see whether or not this declaration is a friend. */
	friend_p = cp_parser_friend_p (decl_specifiers);

	/* Enter the newly declared entry in the symbol table. If we're
	processing a declaration in a class-specifier, we wait until
	after processing the initializer. */
	if (!member_p)
	{
	if (parser->in_unbraced_linkage_specification_p)
	decl_specifiers->storage_class = sc_extern;
	decl = start_decl (declarator, decl_specifiers,
	is_initialized, attributes, prefix_attributes,
	&pushed_scope);
	}
	else if (scope)
	/* Enter the SCOPE. That way unqualified names appearing in the
	initializer will be looked up in SCOPE. */
	pushed_scope = push_scope (scope);

	/* Perform deferred access control checks, now that we know in which
	SCOPE the declared entity resides. */
	if (!member_p && decl)
	{
	tree saved_current_function_decl = NULL_TREE;

	/* If the entity being declared is a function, pretend that we
	are in its scope. If it is a `friend', it may have access to
	things that would not otherwise be accessible. */
	if (TREE_CODE (decl) == FUNCTION_DECL)
	{
	saved_current_function_decl = current_function_decl;
	current_function_decl = decl;
	}

	/* Perform access checks for template parameters. */
	cp_parser_perform_template_parameter_access_checks (checks);

	/* Perform the access control checks for the declarator and the
	the decl-specifiers. */
	perform_deferred_access_checks ();

	/* Restore the saved value. */
	if (TREE_CODE (decl) == FUNCTION_DECL)
	current_function_decl = saved_current_function_decl;
	}

	/* Parse the initializer. */
	initializer = NULL_TREE;
	is_parenthesized_init = false;
	is_non_constant_init = true;
	if (is_initialized)
	{
	if (function_declarator_p (declarator))
	{
	if (initialization_kind == CPP_EQ)
	initializer = cp_parser_pure_specifier (parser);
	else
	{
	/* If the declaration was erroneous, we don't really
	know what the user intended, so just silently
	consume the initializer. */
	if (decl != error_mark_node)
	error ("initializer provided for function");
	cp_parser_skip_to_closing_parenthesis (parser,
	/recovering=/true,
	/or_comma=/false,
	/consume_paren=/true);
	}
	}
	else
	initializer = cp_parser_initializer (parser,
	&is_parenthesized_init,
	&is_non_constant_init);
	}

	/* The old parser allows attributes to appear after a parenthesized
	initializer. Mark Mitchell proposed removing this functionality
	on the GCC mailing lists on 2002-08-13. This parser accepts the
	attributes -- but ignores them. */
	if (cp_parser_allow_gnu_extensions_p (parser) && is_parenthesized_init)
	if (cp_parser_attributes_opt (parser))
	warning (OPT_Wattributes,
	"attributes after parenthesized initializer ignored");

	/* For an in-class declaration, use `grokfield' to create the
	declaration. */
	if (member_p)
	{
	if (pushed_scope)
	{
	pop_scope (pushed_scope);
	pushed_scope = false;
	}
	decl = grokfield (declarator, decl_specifiers,
	initializer, !is_non_constant_init,
	/asmspec=/NULL_TREE,
	prefix_attributes);
	if (decl && TREE_CODE (decl) == FUNCTION_DECL)
	cp_parser_save_default_args (parser, decl);
	}

	/* Finish processing the declaration. But, skip friend
	declarations. */
	if (!friend_p && decl && decl != error_mark_node)
	{
	cp_finish_decl (decl,
	initializer, !is_non_constant_init,
	asm_specification,
	/* If the initializer is in parentheses, then this is
	a direct-initialization, which means that an
	`explicit' constructor is OK. Otherwise, an
	`explicit' constructor cannot be used. */
	((is_parenthesized_init \|\| !is_initialized)
	? 0 : LOOKUP_ONLYCONVERTING));
	}
	if (!friend_p && pushed_scope)
	pop_scope (pushed_scope);

	return decl;
	}

	/* Parse a declarator.

	declarator:
	direct-declarator
	ptr-operator declarator

	abstract-declarator:
	ptr-operator abstract-declarator [opt]
	direct-abstract-declarator

	GNU Extensions:

	declarator:
	attributes [opt] direct-declarator
	attributes [opt] ptr-operator declarator

	abstract-declarator:
	attributes [opt] ptr-operator abstract-declarator [opt]
	attributes [opt] direct-abstract-declarator

	If CTOR_DTOR_OR_CONV_P is not NULL, *CTOR_DTOR_OR_CONV_P is used to
	detect constructor, destructor or conversion operators. It is set
	to -1 if the declarator is a name, and +1 if it is a
	function. Otherwise it is set to zero. Usually you just want to
	test for >0, but internally the negative value is used.

	(The reason for CTOR_DTOR_OR_CONV_P is that a declaration must have
	a decl-specifier-seq unless it declares a constructor, destructor,
	or conversion. It might seem that we could check this condition in
	semantic analysis, rather than parsing, but that makes it difficult
	to handle something like `f()'. We want to notice that there are
	no decl-specifiers, and therefore realize that this is an
	expression, not a declaration.)

	If PARENTHESIZED_P is non-NULL, *PARENTHESIZED_P is set to true iff
	the declarator is a direct-declarator of the form "(...)".

	MEMBER_P is true iff this declarator is a member-declarator. */

	static cp_declarator *
	cp_parser_declarator (cp_parser* parser,
	cp_parser_declarator_kind dcl_kind,
	int* ctor_dtor_or_conv_p,
	bool* parenthesized_p,
	bool member_p)
	{
	cp_token *token;
	cp_declarator *declarator;
	enum tree_code code;
	cp_cv_quals cv_quals;
	tree class_type;
	tree attributes = NULL_TREE;

	/* Assume this is not a constructor, destructor, or type-conversion
	operator. */
	if (ctor_dtor_or_conv_p)
	*ctor_dtor_or_conv_p = 0;

	if (cp_parser_allow_gnu_extensions_p (parser))
	attributes = cp_parser_attributes_opt (parser);

	/* Peek at the next token. */
	token = cp_lexer_peek_token (parser->lexer);

	/* Check for the ptr-operator production. */
	cp_parser_parse_tentatively (parser);
	/* Parse the ptr-operator. */
	code = cp_parser_ptr_operator (parser,
	&class_type,
	&cv_quals);
	/* If that worked, then we have a ptr-operator. */
	if (cp_parser_parse_definitely (parser))
	{
	/* If a ptr-operator was found, then this declarator was not
	parenthesized. */
	if (parenthesized_p)
	*parenthesized_p = true;
	/* The dependent declarator is optional if we are parsing an
	abstract-declarator. */
	if (dcl_kind != CP_PARSER_DECLARATOR_NAMED)
	cp_parser_parse_tentatively (parser);

	/* Parse the dependent declarator. */
	declarator = cp_parser_declarator (parser, dcl_kind,
	/ctor_dtor_or_conv_p=/NULL,
	/parenthesized_p=/NULL,
	/member_p=/false);

	/* If we are parsing an abstract-declarator, we must handle the
	case where the dependent declarator is absent. */
	if (dcl_kind != CP_PARSER_DECLARATOR_NAMED
	&& !cp_parser_parse_definitely (parser))
	declarator = NULL;

	/* Build the representation of the ptr-operator. */
	if (class_type)
	declarator = make_ptrmem_declarator (cv_quals,
	class_type,
	declarator);
	else if (code == INDIRECT_REF)
	declarator = make_pointer_declarator (cv_quals, declarator);
	else
	declarator = make_reference_declarator (cv_quals, declarator);
	}
	/* Everything else is a direct-declarator. */
	else
	{
	if (parenthesized_p)
	*parenthesized_p = cp_lexer_next_token_is (parser->lexer,
	CPP_OPEN_PAREN);
	declarator = cp_parser_direct_declarator (parser, dcl_kind,
	ctor_dtor_or_conv_p,
	member_p);
	}

	if (attributes && declarator && declarator != cp_error_declarator)
	declarator->attributes = attributes;

	return declarator;
	}

	/* Parse a direct-declarator or direct-abstract-declarator.

	direct-declarator:
	declarator-id
	direct-declarator ( parameter-declaration-clause )
	cv-qualifier-seq [opt]
	exception-specification [opt]
	direct-declarator [ constant-expression [opt] ]
	( declarator )

	direct-abstract-declarator:
	direct-abstract-declarator [opt]
	( parameter-declaration-clause )
	cv-qualifier-seq [opt]
	exception-specification [opt]
	direct-abstract-declarator [opt] [ constant-expression [opt] ]
	( abstract-declarator )

	Returns a representation of the declarator. DCL_KIND is
	CP_PARSER_DECLARATOR_ABSTRACT, if we are parsing a
	direct-abstract-declarator. It is CP_PARSER_DECLARATOR_NAMED, if
	we are parsing a direct-declarator. It is
	CP_PARSER_DECLARATOR_EITHER, if we can accept either - in the case
	of ambiguity we prefer an abstract declarator, as per
	[dcl.ambig.res]. CTOR_DTOR_OR_CONV_P and MEMBER_P are as for
	cp_parser_declarator. */

	static cp_declarator *
	cp_parser_direct_declarator (cp_parser* parser,
	cp_parser_declarator_kind dcl_kind,
	int* ctor_dtor_or_conv_p,
	bool member_p)
	{
	cp_token *token;
	cp_declarator *declarator = NULL;
	tree scope = NULL_TREE;
	bool saved_default_arg_ok_p = parser->default_arg_ok_p;
	bool saved_in_declarator_p = parser->in_declarator_p;
	bool first = true;
	tree pushed_scope = NULL_TREE;

	while (true)
	{
	/* Peek at the next token. */
	token = cp_lexer_peek_token (parser->lexer);
	if (token->type == CPP_OPEN_PAREN)
	{
	/* This is either a parameter-declaration-clause, or a
	parenthesized declarator. When we know we are parsing a
	named declarator, it must be a parenthesized declarator
	if FIRST is true. For instance, `(int)' is a
	parameter-declaration-clause, with an omitted
	direct-abstract-declarator. But `((*))', is a
	parenthesized abstract declarator. Finally, when T is a
	template parameter `(T)' is a
	parameter-declaration-clause, and not a parenthesized
	named declarator.

	We first try and parse a parameter-declaration-clause,
	and then try a nested declarator (if FIRST is true).

	It is not an error for it not to be a
	parameter-declaration-clause, even when FIRST is
	false. Consider,

	int i (int);
	int i (3);

	The first is the declaration of a function while the
	second is a the definition of a variable, including its
	initializer.

	Having seen only the parenthesis, we cannot know which of
	these two alternatives should be selected. Even more
	complex are examples like:

	int i (int (a));
	int i (int (3));

	The former is a function-declaration; the latter is a
	variable initialization.

	Thus again, we try a parameter-declaration-clause, and if
	that fails, we back out and return. */

	if (!first \|\| dcl_kind != CP_PARSER_DECLARATOR_NAMED)
	{
	cp_parameter_declarator *params;
	unsigned saved_num_template_parameter_lists;

	/* In a member-declarator, the only valid interpretation
	of a parenthesis is the start of a
	parameter-declaration-clause. (It is invalid to
	initialize a static data member with a parenthesized
	initializer; only the "=" form of initialization is
	permitted.) */
	if (!member_p)
	cp_parser_parse_tentatively (parser);

	/* Consume the `('. */
	cp_lexer_consume_token (parser->lexer);
	if (first)
	{
	/* If this is going to be an abstract declarator, we're
	in a declarator and we can't have default args. */
	parser->default_arg_ok_p = false;
	parser->in_declarator_p = true;
	}

	/* Inside the function parameter list, surrounding
	template-parameter-lists do not apply. */
	saved_num_template_parameter_lists
	= parser->num_template_parameter_lists;
	parser->num_template_parameter_lists = 0;

	/* Parse the parameter-declaration-clause. */
	params = cp_parser_parameter_declaration_clause (parser);

	parser->num_template_parameter_lists
	= saved_num_template_parameter_lists;

	/* If all went well, parse the cv-qualifier-seq and the
	exception-specification. */
	if (member_p \|\| cp_parser_parse_definitely (parser))
	{
	cp_cv_quals cv_quals;
	tree exception_specification;

	if (ctor_dtor_or_conv_p)
	ctor_dtor_or_conv_p = ctor_dtor_or_conv_p < 0;
	first = false;
	/* Consume the `)'. */
	cp_parser_require (parser, CPP_CLOSE_PAREN, "`)'");

	/* Parse the cv-qualifier-seq. */
	cv_quals = cp_parser_cv_qualifier_seq_opt (parser);
	/* And the exception-specification. */
	exception_specification
	= cp_parser_exception_specification_opt (parser);

	/* Create the function-declarator. */
	declarator = make_call_declarator (declarator,
	params,
	cv_quals,
	exception_specification);
	/* Any subsequent parameter lists are to do with
	return type, so are not those of the declared
	function. */
	parser->default_arg_ok_p = false;

	/* Repeat the main loop. */
	continue;
	}
	}

	/* If this is the first, we can try a parenthesized
	declarator. */
	if (first)
	{
	bool saved_in_type_id_in_expr_p;

	parser->default_arg_ok_p = saved_default_arg_ok_p;
	parser->in_declarator_p = saved_in_declarator_p;

	/* Consume the `('. */
	cp_lexer_consume_token (parser->lexer);
	/* Parse the nested declarator. */
	saved_in_type_id_in_expr_p = parser->in_type_id_in_expr_p;
	parser->in_type_id_in_expr_p = true;
	declarator
	= cp_parser_declarator (parser, dcl_kind, ctor_dtor_or_conv_p,
	/parenthesized_p=/NULL,
	member_p);
	parser->in_type_id_in_expr_p = saved_in_type_id_in_expr_p;
	first = false;
	/* Expect a `)'. */
	if (!cp_parser_require (parser, CPP_CLOSE_PAREN, "`)'"))
	declarator = cp_error_declarator;
	if (declarator == cp_error_declarator)
	break;

	goto handle_declarator;
	}
	/* Otherwise, we must be done. */
	else
	break;
	}
	else if ((!first \|\| dcl_kind != CP_PARSER_DECLARATOR_NAMED)
	&& token->type == CPP_OPEN_SQUARE)
	{
	/* Parse an array-declarator. */
	tree bounds;

	if (ctor_dtor_or_conv_p)
	*ctor_dtor_or_conv_p = 0;

	first = false;
	parser->default_arg_ok_p = false;
	parser->in_declarator_p = true;
	/* Consume the `['. */
	cp_lexer_consume_token (parser->lexer);
	/* Peek at the next token. */
	token = cp_lexer_peek_token (parser->lexer);
	/* If the next token is `]', then there is no
	constant-expression. */
	if (token->type != CPP_CLOSE_SQUARE)
	{
	bool non_constant_p;

	bounds
	= cp_parser_constant_expression (parser,
	/allow_non_constant=/true,
	&non_constant_p);
	if (!non_constant_p)
	bounds = fold_non_dependent_expr (bounds);
	/* Normally, the array bound must be an integral constant
	expression. However, as an extension, we allow VLAs
	in function scopes. */
	else if (!parser->in_function_body)
	{
	error ("array bound is not an integer constant");
	bounds = error_mark_node;
	}
	}
	else
	bounds = NULL_TREE;
	/* Look for the closing `]'. */
	if (!cp_parser_require (parser, CPP_CLOSE_SQUARE, "`]'"))
	{
	declarator = cp_error_declarator;
	break;
	}

	declarator = make_array_declarator (declarator, bounds);
	}
	else if (first && dcl_kind != CP_PARSER_DECLARATOR_ABSTRACT)
	{
	tree qualifying_scope;
	tree unqualified_name;
	special_function_kind sfk;
	bool abstract_ok;

	/* Parse a declarator-id */
	abstract_ok = (dcl_kind == CP_PARSER_DECLARATOR_EITHER);
	if (abstract_ok)
	cp_parser_parse_tentatively (parser);
	unqualified_name
	= cp_parser_declarator_id (parser, /optional_p=/abstract_ok);
	qualifying_scope = parser->scope;
	if (abstract_ok)
	{
	if (!cp_parser_parse_definitely (parser))
	unqualified_name = error_mark_node;
	else if (unqualified_name
	&& (qualifying_scope
	\|\| (TREE_CODE (unqualified_name)
	!= IDENTIFIER_NODE)))
	{
	cp_parser_error (parser, "expected unqualified-id");
	unqualified_name = error_mark_node;
	}
	}

	if (!unqualified_name)
	return NULL;
	if (unqualified_name == error_mark_node)
	{
	declarator = cp_error_declarator;
	break;
	}

	if (qualifying_scope && at_namespace_scope_p ()
	&& TREE_CODE (qualifying_scope) == TYPENAME_TYPE)
	{
	/* In the declaration of a member of a template class
	outside of the class itself, the SCOPE will sometimes
	be a TYPENAME_TYPE. For example, given:

	template <typename T>
	int S<T>::R::i = 3;

	the SCOPE will be a TYPENAME_TYPE for `S<T>::R'. In
	this context, we must resolve S<T>::R to an ordinary
	type, rather than a typename type.

	The reason we normally avoid resolving TYPENAME_TYPEs
	is that a specialization of `S' might render
	`S<T>::R' not a type. However, if `S' is
	specialized, then this `i' will not be used, so there
	is no harm in resolving the types here. */
	tree type;

	/* Resolve the TYPENAME_TYPE. */
	type = resolve_typename_type (qualifying_scope,
	/only_current_p=/false);
	/* If that failed, the declarator is invalid. */
	if (type == error_mark_node)
	error ("%<%T::%D%> is not a type",
	TYPE_CONTEXT (qualifying_scope),
	TYPE_IDENTIFIER (qualifying_scope));
	qualifying_scope = type;
	}

	sfk = sfk_none;
	if (unqualified_name)
	{
	tree class_type;

	if (qualifying_scope
	&& CLASS_TYPE_P (qualifying_scope))
	class_type = qualifying_scope;
	else
	class_type = current_class_type;

	if (TREE_CODE (unqualified_name) == TYPE_DECL)
	{
	tree name_type = TREE_TYPE (unqualified_name);
	if (class_type && same_type_p (name_type, class_type))
	{
	if (qualifying_scope
	&& CLASSTYPE_USE_TEMPLATE (name_type))
	{
	error ("invalid use of constructor as a template");
	inform ("use %<%T::%D%> instead of %<%T::%D%> to "
	"name the constructor in a qualified name",
	class_type,
	DECL_NAME (TYPE_TI_TEMPLATE (class_type)),
	class_type, name_type);
	declarator = cp_error_declarator;
	break;
	}
	else
	unqualified_name = constructor_name (class_type);
	}
	else
	{
	/* We do not attempt to print the declarator
	here because we do not have enough
	information about its original syntactic
	form. */
	cp_parser_error (parser, "invalid declarator");
	declarator = cp_error_declarator;
	break;
	}
	}

	if (class_type)
	{
	if (TREE_CODE (unqualified_name) == BIT_NOT_EXPR)
	sfk = sfk_destructor;
	else if (IDENTIFIER_TYPENAME_P (unqualified_name))
	sfk = sfk_conversion;
	else if (/* There's no way to declare a constructor
	for an anonymous type, even if the type
	got a name for linkage purposes. */
	!TYPE_WAS_ANONYMOUS (class_type)
	&& constructor_name_p (unqualified_name,
	class_type))
	{
	unqualified_name = constructor_name (class_type);
	sfk = sfk_constructor;
	}

	if (ctor_dtor_or_conv_p && sfk != sfk_none)
	*ctor_dtor_or_conv_p = -1;
	}
	}
	declarator = make_id_declarator (qualifying_scope,
	unqualified_name,
	sfk);
	declarator->id_loc = token->location;

	handle_declarator:;
	scope = get_scope_of_declarator (declarator);
	if (scope)
	/* Any names that appear after the declarator-id for a
	member are looked up in the containing scope. */
	pushed_scope = push_scope (scope);
	parser->in_declarator_p = true;
	if ((ctor_dtor_or_conv_p && *ctor_dtor_or_conv_p)
	\|\| (declarator && declarator->kind == cdk_id))
	/* Default args are only allowed on function
	declarations. */
	parser->default_arg_ok_p = saved_default_arg_ok_p;
	else
	parser->default_arg_ok_p = false;

	first = false;
	}
	/* We're done. */
	else
	break;
	}

	/* For an abstract declarator, we might wind up with nothing at this
	point. That's an error; the declarator is not optional. */
	if (!declarator)
	cp_parser_error (parser, "expected declarator");

	/* If we entered a scope, we must exit it now. */
	if (pushed_scope)
	pop_scope (pushed_scope);

	parser->default_arg_ok_p = saved_default_arg_ok_p;
	parser->in_declarator_p = saved_in_declarator_p;

	return declarator;
	}

	/* Parse a ptr-operator.

	ptr-operator:
	* cv-qualifier-seq [opt]
	&
	:: [opt] nested-name-specifier * cv-qualifier-seq [opt]

	GNU Extension:

	ptr-operator:
	& cv-qualifier-seq [opt]

	Returns INDIRECT_REF if a pointer, or pointer-to-member, was used.
	Returns ADDR_EXPR if a reference was used. In the case of a
	pointer-to-member, *TYPE is filled in with the TYPE containing the
	member. *CV_QUALS is filled in with the cv-qualifier-seq, or
	TYPE_UNQUALIFIED, if there are no cv-qualifiers. Returns
	ERROR_MARK if an error occurred. */

	static enum tree_code
	cp_parser_ptr_operator (cp_parser* parser,
	tree* type,
	cp_cv_quals *cv_quals)
	{
	enum tree_code code = ERROR_MARK;
	cp_token *token;

	/* Assume that it's not a pointer-to-member. */
	*type = NULL_TREE;
	/* And that there are no cv-qualifiers. */
	*cv_quals = TYPE_UNQUALIFIED;

	/* Peek at the next token. */
	token = cp_lexer_peek_token (parser->lexer);
	/* If it's a `' or `&' we have a pointer or reference. /
	if (token->type == CPP_MULT \|\| token->type == CPP_AND)
	{
	/* Remember which ptr-operator we were processing. */
	code = (token->type == CPP_AND ? ADDR_EXPR : INDIRECT_REF);

	/* Consume the `' or `&'. /
	cp_lexer_consume_token (parser->lexer);

	/* A `*' can be followed by a cv-qualifier-seq, and so can a
	`&', if we are allowing GNU extensions. (The only qualifier
	that can legally appear after `&' is `restrict', but that is
	enforced during semantic analysis. */
	if (code == INDIRECT_REF
	\|\| cp_parser_allow_gnu_extensions_p (parser))
	*cv_quals = cp_parser_cv_qualifier_seq_opt (parser);
	}
	else
	{
	/* Try the pointer-to-member case. */
	cp_parser_parse_tentatively (parser);
	/* Look for the optional `::' operator. */
	cp_parser_global_scope_opt (parser,
	/current_scope_valid_p=/false);
	/* Look for the nested-name specifier. */
	cp_parser_nested_name_specifier (parser,
	/typename_keyword_p=/false,
	/check_dependency_p=/true,
	/type_p=/false,
	/is_declaration=/false);
	/* If we found it, and the next token is a `*', then we are
	indeed looking at a pointer-to-member operator. */
	if (!cp_parser_error_occurred (parser)
	&& cp_parser_require (parser, CPP_MULT, "`*'"))
	{
	/* Indicate that the `' operator was used. /
	code = INDIRECT_REF;

	if (TREE_CODE (parser->scope) == NAMESPACE_DECL)
	error ("%qD is a namespace", parser->scope);
	else
	{
	/* The type of which the member is a member is given by the
	current SCOPE. */
	*type = parser->scope;
	/* The next name will not be qualified. */
	parser->scope = NULL_TREE;
	parser->qualifying_scope = NULL_TREE;
	parser->object_scope = NULL_TREE;
	/* Look for the optional cv-qualifier-seq. */
	*cv_quals = cp_parser_cv_qualifier_seq_opt (parser);
	}
	}
	/* If that didn't work we don't have a ptr-operator. */
	if (!cp_parser_parse_definitely (parser))
	cp_parser_error (parser, "expected ptr-operator");
	}

	return code;
	}

	/* Parse an (optional) cv-qualifier-seq.

	cv-qualifier-seq:
	cv-qualifier cv-qualifier-seq [opt]

	cv-qualifier:
	const
	volatile

	GNU Extension:

	cv-qualifier:
	__restrict__

	Returns a bitmask representing the cv-qualifiers. */

	static cp_cv_quals
	cp_parser_cv_qualifier_seq_opt (cp_parser* parser)
	{
	cp_cv_quals cv_quals = TYPE_UNQUALIFIED;

	while (true)
	{
	cp_token *token;
	cp_cv_quals cv_qualifier;

	/* Peek at the next token. */
	token = cp_lexer_peek_token (parser->lexer);
	/* See if it's a cv-qualifier. */
	switch (token->keyword)
	{
	case RID_CONST:
	cv_qualifier = TYPE_QUAL_CONST;
	break;

	case RID_VOLATILE:
	cv_qualifier = TYPE_QUAL_VOLATILE;
	break;

	case RID_RESTRICT:
	cv_qualifier = TYPE_QUAL_RESTRICT;
	break;

	default:
	cv_qualifier = TYPE_UNQUALIFIED;
	break;
	}

	if (!cv_qualifier)
	break;

	if (cv_quals & cv_qualifier)
	{
	error ("duplicate cv-qualifier");
	cp_lexer_purge_token (parser->lexer);
	}
	else
	{
	cp_lexer_consume_token (parser->lexer);
	cv_quals \|= cv_qualifier;
	}
	}

	return cv_quals;
	}

	/* Parse a declarator-id.

	declarator-id:
	id-expression
	:: [opt] nested-name-specifier [opt] type-name

	In the `id-expression' case, the value returned is as for
	cp_parser_id_expression if the id-expression was an unqualified-id.
	If the id-expression was a qualified-id, then a SCOPE_REF is
	returned. The first operand is the scope (either a NAMESPACE_DECL
	or TREE_TYPE), but the second is still just a representation of an
	unqualified-id. */

	static tree
	cp_parser_declarator_id (cp_parser* parser, bool optional_p)
	{
	tree id;
	/* The expression must be an id-expression. Assume that qualified
	names are the names of types so that:

	template <class T>
	int S<T>::R::i = 3;

	will work; we must treat `S<T>::R' as the name of a type.
	Similarly, assume that qualified names are templates, where
	required, so that:

	template <class T>
	int S<T>::R<T>::i = 3;

	will work, too. */
	id = cp_parser_id_expression (parser,
	/template_keyword_p=/false,
	/check_dependency_p=/false,
	/template_p=/NULL,
	/declarator_p=/true,
	optional_p);
	if (id && BASELINK_P (id))
	id = BASELINK_FUNCTIONS (id);
	return id;
	}

	/* Parse a type-id.

	type-id:
	type-specifier-seq abstract-declarator [opt]

	Returns the TYPE specified. */

	static tree
	cp_parser_type_id (cp_parser* parser)
	{
	cp_decl_specifier_seq type_specifier_seq;
	cp_declarator *abstract_declarator;

	/* Parse the type-specifier-seq. */
	cp_parser_type_specifier_seq (parser, /is_condition=/false,
	&type_specifier_seq);
	if (type_specifier_seq.type == error_mark_node)
	return error_mark_node;

	/* There might or might not be an abstract declarator. */
	cp_parser_parse_tentatively (parser);
	/* Look for the declarator. */
	abstract_declarator
	= cp_parser_declarator (parser, CP_PARSER_DECLARATOR_ABSTRACT, NULL,
	/parenthesized_p=/NULL,
	/member_p=/false);
	/* Check to see if there really was a declarator. */
	if (!cp_parser_parse_definitely (parser))
	abstract_declarator = NULL;

	return groktypename (&type_specifier_seq, abstract_declarator);
	}

	/* Parse a type-specifier-seq.

	type-specifier-seq:
	type-specifier type-specifier-seq [opt]

	GNU extension:

	type-specifier-seq:
	attributes type-specifier-seq [opt]

	If IS_CONDITION is true, we are at the start of a "condition",
	e.g., we've just seen "if (".

	Sets TYPE_SPECIFIER_SEQ to represent the sequence. /

	static void
	cp_parser_type_specifier_seq (cp_parser* parser,
	bool is_condition,
	cp_decl_specifier_seq *type_specifier_seq)
	{
	bool seen_type_specifier = false;
	cp_parser_flags flags = CP_PARSER_FLAGS_OPTIONAL;

	/* Clear the TYPE_SPECIFIER_SEQ. */
	clear_decl_specs (type_specifier_seq);

	/* Parse the type-specifiers and attributes. */
	while (true)
	{
	tree type_specifier;
	bool is_cv_qualifier;

	/* Check for attributes first. */
	if (cp_lexer_next_token_is_keyword (parser->lexer, RID_ATTRIBUTE))
	{
	type_specifier_seq->attributes =
	chainon (type_specifier_seq->attributes,
	cp_parser_attributes_opt (parser));
	continue;
	}

	/* Look for the type-specifier. */
	type_specifier = cp_parser_type_specifier (parser,
	flags,
	type_specifier_seq,
	/is_declaration=/false,
	NULL,
	&is_cv_qualifier);
	if (!type_specifier)
	{
	/* If the first type-specifier could not be found, this is not a
	type-specifier-seq at all. */
	if (!seen_type_specifier)
	{
	cp_parser_error (parser, "expected type-specifier");
	type_specifier_seq->type = error_mark_node;
	return;
	}
	/* If subsequent type-specifiers could not be found, the
	type-specifier-seq is complete. */
	break;
	}

	seen_type_specifier = true;
	/* The standard says that a condition can be:

	type-specifier-seq declarator = assignment-expression

	However, given:

	struct S {};
	if (int S = ...)

	we should treat the "S" as a declarator, not as a
	type-specifier. The standard doesn't say that explicitly for
	type-specifier-seq, but it does say that for
	decl-specifier-seq in an ordinary declaration. Perhaps it
	would be clearer just to allow a decl-specifier-seq here, and
	then add a semantic restriction that if any decl-specifiers
	that are not type-specifiers appear, the program is invalid. */
	if (is_condition && !is_cv_qualifier)
	flags \|= CP_PARSER_FLAGS_NO_USER_DEFINED_TYPES;
	}

	cp_parser_check_decl_spec (type_specifier_seq);
	}

	/* Parse a parameter-declaration-clause.

	parameter-declaration-clause:
	parameter-declaration-list [opt] ... [opt]
	parameter-declaration-list , ...

	Returns a representation for the parameter declarations. A return
	value of NULL indicates a parameter-declaration-clause consisting
	only of an ellipsis. */

	static cp_parameter_declarator *
	cp_parser_parameter_declaration_clause (cp_parser* parser)
	{
	cp_parameter_declarator *parameters;
	cp_token *token;
	bool ellipsis_p;
	bool is_error;

	/* Peek at the next token. */
	token = cp_lexer_peek_token (parser->lexer);
	/* Check for trivial parameter-declaration-clauses. */
	if (token->type == CPP_ELLIPSIS)
	{
	/* Consume the `...' token. */
	cp_lexer_consume_token (parser->lexer);
	return NULL;
	}
	else if (token->type == CPP_CLOSE_PAREN)
	/* There are no parameters. */
	{
	#ifndef NO_IMPLICIT_EXTERN_C
	if (in_system_header && current_class_type == NULL
	&& current_lang_name == lang_name_c)
	return NULL;
	else
	#endif
	return no_parameters;
	}
	/* Check for `(void)', too, which is a special case. */
	else if (token->keyword == RID_VOID
	&& (cp_lexer_peek_nth_token (parser->lexer, 2)->type
	== CPP_CLOSE_PAREN))
	{
	/* Consume the `void' token. */
	cp_lexer_consume_token (parser->lexer);
	/* There are no parameters. */
	return no_parameters;
	}

	/* Parse the parameter-declaration-list. */
	parameters = cp_parser_parameter_declaration_list (parser, &is_error);
	/* If a parse error occurred while parsing the
	parameter-declaration-list, then the entire
	parameter-declaration-clause is erroneous. */
	if (is_error)
	return NULL;

	/* Peek at the next token. */
	token = cp_lexer_peek_token (parser->lexer);
	/* If it's a `,', the clause should terminate with an ellipsis. */
	if (token->type == CPP_COMMA)
	{
	/* Consume the `,'. */
	cp_lexer_consume_token (parser->lexer);
	/* Expect an ellipsis. */
	ellipsis_p
	= (cp_parser_require (parser, CPP_ELLIPSIS, "`...'") != NULL);
	}
	/* It might also be `...' if the optional trailing `,' was
	omitted. */
	else if (token->type == CPP_ELLIPSIS)
	{
	/* Consume the `...' token. */
	cp_lexer_consume_token (parser->lexer);
	/* And remember that we saw it. */
	ellipsis_p = true;
	}
	else
	ellipsis_p = false;

	/* Finish the parameter list. */
	if (parameters && ellipsis_p)
	parameters->ellipsis_p = true;

	return parameters;
	}

	/* Parse a parameter-declaration-list.

	parameter-declaration-list:
	parameter-declaration
	parameter-declaration-list , parameter-declaration

	Returns a representation of the parameter-declaration-list, as for
	cp_parser_parameter_declaration_clause. However, the
	`void_list_node' is never appended to the list. Upon return,
	IS_ERROR will be true iff an error occurred. /

	static cp_parameter_declarator *
	cp_parser_parameter_declaration_list (cp_parser* parser, bool *is_error)
	{
	cp_parameter_declarator *parameters = NULL;
	cp_parameter_declarator **tail = &parameters;
	bool saved_in_unbraced_linkage_specification_p;

	/* Assume all will go well. */
	*is_error = false;
	/* The special considerations that apply to a function within an
	unbraced linkage specifications do not apply to the parameters
	to the function. */
	saved_in_unbraced_linkage_specification_p
	= parser->in_unbraced_linkage_specification_p;
	parser->in_unbraced_linkage_specification_p = false;

	/* Look for more parameters. */
	while (true)
	{
	cp_parameter_declarator *parameter;
	bool parenthesized_p;
	/* Parse the parameter. */
	parameter
	= cp_parser_parameter_declaration (parser,
	/template_parm_p=/false,
	&parenthesized_p);

	/* If a parse error occurred parsing the parameter declaration,
	then the entire parameter-declaration-list is erroneous. */
	if (!parameter)
	{
	*is_error = true;
	parameters = NULL;
	break;
	}
	/* Add the new parameter to the list. */
	*tail = parameter;
	tail = &parameter->next;

	/* Peek at the next token. */
	if (cp_lexer_next_token_is (parser->lexer, CPP_CLOSE_PAREN)
	\|\| cp_lexer_next_token_is (parser->lexer, CPP_ELLIPSIS)
	/* These are for Objective-C++ */
	\|\| cp_lexer_next_token_is (parser->lexer, CPP_SEMICOLON)
	\|\| cp_lexer_next_token_is (parser->lexer, CPP_OPEN_BRACE))
	/* The parameter-declaration-list is complete. */
	break;
	else if (cp_lexer_next_token_is (parser->lexer, CPP_COMMA))
	{
	cp_token *token;

	/* Peek at the next token. */
	token = cp_lexer_peek_nth_token (parser->lexer, 2);
	/* If it's an ellipsis, then the list is complete. */
	if (token->type == CPP_ELLIPSIS)
	break;
	/* Otherwise, there must be more parameters. Consume the
	`,'. */
	cp_lexer_consume_token (parser->lexer);
	/* When parsing something like:

	int i(float f, double d)

	we can tell after seeing the declaration for "f" that we
	are not looking at an initialization of a variable "i",
	but rather at the declaration of a function "i".

	Due to the fact that the parsing of template arguments
	(as specified to a template-id) requires backtracking we
	cannot use this technique when inside a template argument
	list. */
	if (!parser->in_template_argument_list_p
	&& !parser->in_type_id_in_expr_p
	&& cp_parser_uncommitted_to_tentative_parse_p (parser)
	/* However, a parameter-declaration of the form
	"foat(f)" (which is a valid declaration of a
	parameter "f") can also be interpreted as an
	expression (the conversion of "f" to "float"). */
	&& !parenthesized_p)
	cp_parser_commit_to_tentative_parse (parser);
	}
	else
	{
	cp_parser_error (parser, "expected %<,%> or %<...%>");
	if (!cp_parser_uncommitted_to_tentative_parse_p (parser))
	cp_parser_skip_to_closing_parenthesis (parser,
	/recovering=/true,
	/or_comma=/false,
	/consume_paren=/false);
	break;
	}
	}

	parser->in_unbraced_linkage_specification_p
	= saved_in_unbraced_linkage_specification_p;

	return parameters;
	}

	/* Parse a parameter declaration.

	parameter-declaration:
	decl-specifier-seq declarator
	decl-specifier-seq declarator = assignment-expression
	decl-specifier-seq abstract-declarator [opt]
	decl-specifier-seq abstract-declarator [opt] = assignment-expression

	If TEMPLATE_PARM_P is TRUE, then this parameter-declaration
	declares a template parameter. (In that case, a non-nested `>'
	token encountered during the parsing of the assignment-expression
	is not interpreted as a greater-than operator.)

	Returns a representation of the parameter, or NULL if an error
	occurs. If PARENTHESIZED_P is non-NULL, *PARENTHESIZED_P is set to
	true iff the declarator is of the form "(p)". */

	static cp_parameter_declarator *
	cp_parser_parameter_declaration (cp_parser *parser,
	bool template_parm_p,
	bool *parenthesized_p)
	{
	int declares_class_or_enum;
	bool greater_than_is_operator_p;
	cp_decl_specifier_seq decl_specifiers;
	cp_declarator *declarator;
	tree default_argument;
	cp_token *token;
	const char *saved_message;

	/* In a template parameter, `>' is not an operator.

	[temp.param]

	When parsing a default template-argument for a non-type
	template-parameter, the first non-nested `>' is taken as the end
	of the template parameter-list rather than a greater-than
	operator. */
	greater_than_is_operator_p = !template_parm_p;

	/* Type definitions may not appear in parameter types. */
	saved_message = parser->type_definition_forbidden_message;
	parser->type_definition_forbidden_message
	= "types may not be defined in parameter types";

	/* Parse the declaration-specifiers. */
	cp_parser_decl_specifier_seq (parser,
	CP_PARSER_FLAGS_NONE,
	&decl_specifiers,
	&declares_class_or_enum);
	/* If an error occurred, there's no reason to attempt to parse the
	rest of the declaration. */
	if (cp_parser_error_occurred (parser))
	{
	parser->type_definition_forbidden_message = saved_message;
	return NULL;
	}

	/* Peek at the next token. */
	token = cp_lexer_peek_token (parser->lexer);
	/* If the next token is a `)', `,', `=', `>', or `...', then there
	is no declarator. */
	if (token->type == CPP_CLOSE_PAREN
	\|\| token->type == CPP_COMMA
	\|\| token->type == CPP_EQ
	\|\| token->type == CPP_ELLIPSIS
	\|\| token->type == CPP_GREATER)
	{
	declarator = NULL;
	if (parenthesized_p)
	*parenthesized_p = false;
	}
	/* Otherwise, there should be a declarator. */
	else
	{
	bool saved_default_arg_ok_p = parser->default_arg_ok_p;
	parser->default_arg_ok_p = false;

	/* After seeing a decl-specifier-seq, if the next token is not a
	"(", there is no possibility that the code is a valid
	expression. Therefore, if parsing tentatively, we commit at
	this point. */
	if (!parser->in_template_argument_list_p
	/* In an expression context, having seen:

	(int((char ...

	we cannot be sure whether we are looking at a
	function-type (taking a "char" as a parameter) or a cast
	of some object of type "char" to "int". */
	&& !parser->in_type_id_in_expr_p
	&& cp_parser_uncommitted_to_tentative_parse_p (parser)
	&& cp_lexer_next_token_is_not (parser->lexer, CPP_OPEN_PAREN))
	cp_parser_commit_to_tentative_parse (parser);
	/* Parse the declarator. */
	declarator = cp_parser_declarator (parser,
	CP_PARSER_DECLARATOR_EITHER,
	/ctor_dtor_or_conv_p=/NULL,
	parenthesized_p,
	/member_p=/false);
	parser->default_arg_ok_p = saved_default_arg_ok_p;
	/* After the declarator, allow more attributes. */
	decl_specifiers.attributes
	= chainon (decl_specifiers.attributes,
	cp_parser_attributes_opt (parser));
	}

	/* The restriction on defining new types applies only to the type
	of the parameter, not to the default argument. */
	parser->type_definition_forbidden_message = saved_message;

	/* If the next token is `=', then process a default argument. */
	if (cp_lexer_next_token_is (parser->lexer, CPP_EQ))
	{
	bool saved_greater_than_is_operator_p;
	/* Consume the `='. */
	cp_lexer_consume_token (parser->lexer);

	/* If we are defining a class, then the tokens that make up the
	default argument must be saved and processed later. */
	if (!template_parm_p && at_class_scope_p ()
	&& TYPE_BEING_DEFINED (current_class_type))
	{
	unsigned depth = 0;
	cp_token *first_token;
	cp_token *token;

	/* Add tokens until we have processed the entire default
	argument. We add the range [first_token, token). */
	first_token = cp_lexer_peek_token (parser->lexer);
	while (true)
	{
	bool done = false;

	/* Peek at the next token. */
	token = cp_lexer_peek_token (parser->lexer);
	/* What we do depends on what token we have. */
	switch (token->type)
	{
	/* In valid code, a default argument must be
	immediately followed by a `,' `)', or `...'. */
	case CPP_COMMA:
	case CPP_CLOSE_PAREN:
	case CPP_ELLIPSIS:
	/* If we run into a non-nested `;', `}', or `]',
	then the code is invalid -- but the default
	argument is certainly over. */
	case CPP_SEMICOLON:
	case CPP_CLOSE_BRACE:
	case CPP_CLOSE_SQUARE:
	if (depth == 0)
	done = true;
	/* Update DEPTH, if necessary. */
	else if (token->type == CPP_CLOSE_PAREN
	\|\| token->type == CPP_CLOSE_BRACE
	\|\| token->type == CPP_CLOSE_SQUARE)
	--depth;
	break;

	case CPP_OPEN_PAREN:
	case CPP_OPEN_SQUARE:
	case CPP_OPEN_BRACE:
	++depth;
	break;

	case CPP_GREATER:
	/* If we see a non-nested `>', and `>' is not an
	operator, then it marks the end of the default
	argument. */
	if (!depth && !greater_than_is_operator_p)
	done = true;
	break;

	/* If we run out of tokens, issue an error message. */
	case CPP_EOF:
	case CPP_PRAGMA_EOL:
	error ("file ends in default argument");
	done = true;
	break;

	case CPP_NAME:
	case CPP_SCOPE:
	/* In these cases, we should look for template-ids.
	For example, if the default argument is
	`X<int, double>()', we need to do name lookup to
	figure out whether or not `X' is a template; if
	so, the `,' does not end the default argument.

	That is not yet done. */
	break;

	default:
	break;
	}

	/* If we've reached the end, stop. */
	if (done)
	break;

	/* Add the token to the token block. */
	token = cp_lexer_consume_token (parser->lexer);
	}

	/* Create a DEFAULT_ARG to represented the unparsed default
	argument. */
	default_argument = make_node (DEFAULT_ARG);
	DEFARG_TOKENS (default_argument)
	= cp_token_cache_new (first_token, token);
	DEFARG_INSTANTIATIONS (default_argument) = NULL;
	}
	/* Outside of a class definition, we can just parse the
	assignment-expression. */
	else
	{
	bool saved_local_variables_forbidden_p;

	/* Make sure that PARSER->GREATER_THAN_IS_OPERATOR_P is
	set correctly. */
	saved_greater_than_is_operator_p
	= parser->greater_than_is_operator_p;
	parser->greater_than_is_operator_p = greater_than_is_operator_p;
	/* Local variable names (and the `this' keyword) may not
	appear in a default argument. */
	saved_local_variables_forbidden_p
	= parser->local_variables_forbidden_p;
	parser->local_variables_forbidden_p = true;
	/* The default argument expression may cause implicitly
	defined member functions to be synthesized, which will
	result in garbage collection. We must treat this
	situation as if we were within the body of function so as
	to avoid collecting live data on the stack. */
	++function_depth;
	/* Parse the assignment-expression. */
	if (template_parm_p)
	push_deferring_access_checks (dk_no_deferred);
	default_argument
	= cp_parser_assignment_expression (parser, /cast_p=/false);
	if (template_parm_p)
	pop_deferring_access_checks ();
	/* Restore saved state. */
	--function_depth;
	parser->greater_than_is_operator_p
	= saved_greater_than_is_operator_p;
	parser->local_variables_forbidden_p
	= saved_local_variables_forbidden_p;
	}
	if (!parser->default_arg_ok_p)
	{
	if (!flag_pedantic_errors)
	warning (0, "deprecated use of default argument for parameter of non-function");
	else
	{
	error ("default arguments are only permitted for function parameters");
	default_argument = NULL_TREE;
	}
	}
	}
	else
	default_argument = NULL_TREE;

	return make_parameter_declarator (&decl_specifiers,
	declarator,
	default_argument);
	}

	/* Parse a function-body.

	function-body:
	compound_statement */

	static void
	cp_parser_function_body (cp_parser *parser)
	{
	cp_parser_compound_statement (parser, NULL, false);
	}

	/* Parse a ctor-initializer-opt followed by a function-body. Return
	true if a ctor-initializer was present. */

	static bool
	cp_parser_ctor_initializer_opt_and_function_body (cp_parser *parser)
	{
	tree body;
	bool ctor_initializer_p;

	/* Begin the function body. */
	body = begin_function_body ();
	/* Parse the optional ctor-initializer. */
	ctor_initializer_p = cp_parser_ctor_initializer_opt (parser);
	/* Parse the function-body. */
	cp_parser_function_body (parser);
	/* Finish the function body. */
	finish_function_body (body);

	return ctor_initializer_p;
	}

	/* Parse an initializer.

	initializer:
	= initializer-clause
	( expression-list )

	Returns an expression representing the initializer. If no
	initializer is present, NULL_TREE is returned.

	*IS_PARENTHESIZED_INIT is set to TRUE if the `( expression-list )'
	production is used, and zero otherwise. *IS_PARENTHESIZED_INIT is
	set to FALSE if there is no initializer present. If there is an
	initializer, and it is not a constant-expression, *NON_CONSTANT_P
	is set to true; otherwise it is set to false. */

	static tree
	cp_parser_initializer (cp_parser* parser, bool* is_parenthesized_init,
	bool* non_constant_p)
	{
	cp_token *token;
	tree init;

	/* Peek at the next token. */
	token = cp_lexer_peek_token (parser->lexer);

	/* Let our caller know whether or not this initializer was
	parenthesized. */
	*is_parenthesized_init = (token->type == CPP_OPEN_PAREN);
	/* Assume that the initializer is constant. */
	*non_constant_p = false;

	if (token->type == CPP_EQ)
	{
	/* Consume the `='. */
	cp_lexer_consume_token (parser->lexer);
	/* Parse the initializer-clause. */
	init = cp_parser_initializer_clause (parser, non_constant_p);
	}
	else if (token->type == CPP_OPEN_PAREN)
	init = cp_parser_parenthesized_expression_list (parser, false,
	/cast_p=/false,
	non_constant_p);
	else
	{
	/* Anything else is an error. */
	cp_parser_error (parser, "expected initializer");
	init = error_mark_node;
	}

	return init;
	}

	/* Parse an initializer-clause.

	initializer-clause:
	assignment-expression
	{ initializer-list , [opt] }
	{ }

	Returns an expression representing the initializer.

	If the `assignment-expression' production is used the value
	returned is simply a representation for the expression.

	Otherwise, a CONSTRUCTOR is returned. The CONSTRUCTOR_ELTS will be
	the elements of the initializer-list (or NULL, if the last
	production is used). The TREE_TYPE for the CONSTRUCTOR will be
	NULL_TREE. There is no way to detect whether or not the optional
	trailing `,' was provided. NON_CONSTANT_P is as for
	cp_parser_initializer. */

	static tree
	cp_parser_initializer_clause (cp_parser* parser, bool* non_constant_p)
	{
	tree initializer;

	/* Assume the expression is constant. */
	*non_constant_p = false;

	/* If it is not a `{', then we are looking at an
	assignment-expression. */
	if (cp_lexer_next_token_is_not (parser->lexer, CPP_OPEN_BRACE))
	{
	initializer
	= cp_parser_constant_expression (parser,
	/allow_non_constant_p=/true,
	non_constant_p);
	if (!*non_constant_p)
	initializer = fold_non_dependent_expr (initializer);
	}
	else
	{
	/* Consume the `{' token. */
	cp_lexer_consume_token (parser->lexer);
	/* Create a CONSTRUCTOR to represent the braced-initializer. */
	initializer = make_node (CONSTRUCTOR);
	/* If it's not a `}', then there is a non-trivial initializer. */
	if (cp_lexer_next_token_is_not (parser->lexer, CPP_CLOSE_BRACE))
	{
	/* Parse the initializer list. */
	CONSTRUCTOR_ELTS (initializer)
	= cp_parser_initializer_list (parser, non_constant_p);
	/* A trailing `,' token is allowed. */
	if (cp_lexer_next_token_is (parser->lexer, CPP_COMMA))
	cp_lexer_consume_token (parser->lexer);
	}
	/* Now, there should be a trailing `}'. */
	cp_parser_require (parser, CPP_CLOSE_BRACE, "`}'");
	}

	return initializer;
	}

	/* Parse an initializer-list.

	initializer-list:
	initializer-clause
	initializer-list , initializer-clause

	GNU Extension:

	initializer-list:
	identifier : initializer-clause
	initializer-list, identifier : initializer-clause

	Returns a VEC of constructor_elt. The VALUE of each elt is an expression
	for the initializer. If the INDEX of the elt is non-NULL, it is the
	IDENTIFIER_NODE naming the field to initialize. NON_CONSTANT_P is
	as for cp_parser_initializer. */

	static VEC(constructor_elt,gc) *
	cp_parser_initializer_list (cp_parser* parser, bool* non_constant_p)
	{
	VEC(constructor_elt,gc) *v = NULL;

	/* Assume all of the expressions are constant. */
	*non_constant_p = false;

	/* Parse the rest of the list. */
	while (true)
	{
	cp_token *token;
	tree identifier;
	tree initializer;
	bool clause_non_constant_p;

	/* If the next token is an identifier and the following one is a
	colon, we are looking at the GNU designated-initializer
	syntax. */
	if (cp_parser_allow_gnu_extensions_p (parser)
	&& cp_lexer_next_token_is (parser->lexer, CPP_NAME)
	&& cp_lexer_peek_nth_token (parser->lexer, 2)->type == CPP_COLON)
	{
	/* Warn the user that they are using an extension. */
	if (pedantic)
	pedwarn ("ISO C++ does not allow designated initializers");
	/* Consume the identifier. */
	identifier = cp_lexer_consume_token (parser->lexer)->u.value;
	/* Consume the `:'. */
	cp_lexer_consume_token (parser->lexer);
	}
	else
	identifier = NULL_TREE;

	/* Parse the initializer. */
	initializer = cp_parser_initializer_clause (parser,
	&clause_non_constant_p);
	/* If any clause is non-constant, so is the entire initializer. */
	if (clause_non_constant_p)
	*non_constant_p = true;

	/* Add it to the vector. */
	CONSTRUCTOR_APPEND_ELT(v, identifier, initializer);

	/* If the next token is not a comma, we have reached the end of
	the list. */
	if (cp_lexer_next_token_is_not (parser->lexer, CPP_COMMA))
	break;

	/* Peek at the next token. */
	token = cp_lexer_peek_nth_token (parser->lexer, 2);
	/* If the next token is a `}', then we're still done. An
	initializer-clause can have a trailing `,' after the
	initializer-list and before the closing `}'. */
	if (token->type == CPP_CLOSE_BRACE)
	break;

	/* Consume the `,' token. */
	cp_lexer_consume_token (parser->lexer);
	}

	return v;
	}

	/* Classes [gram.class] */

	/* Parse a class-name.

	class-name:
	identifier
	template-id

	TYPENAME_KEYWORD_P is true iff the `typename' keyword has been used
	to indicate that names looked up in dependent types should be
	assumed to be types. TEMPLATE_KEYWORD_P is true iff the `template'
	keyword has been used to indicate that the name that appears next
	is a template. TAG_TYPE indicates the explicit tag given before
	the type name, if any. If CHECK_DEPENDENCY_P is FALSE, names are
	looked up in dependent scopes. If CLASS_HEAD_P is TRUE, this class
	is the class being defined in a class-head.

	Returns the TYPE_DECL representing the class. */

	static tree
	cp_parser_class_name (cp_parser *parser,
	bool typename_keyword_p,
	bool template_keyword_p,
	enum tag_types tag_type,
	bool check_dependency_p,
	bool class_head_p,
	bool is_declaration)
	{
	tree decl;
	tree scope;
	bool typename_p;
	cp_token *token;

	/* All class-names start with an identifier. */
	token = cp_lexer_peek_token (parser->lexer);
	if (token->type != CPP_NAME && token->type != CPP_TEMPLATE_ID)
	{
	cp_parser_error (parser, "expected class-name");
	return error_mark_node;
	}

	/* PARSER->SCOPE can be cleared when parsing the template-arguments
	to a template-id, so we save it here. */
	scope = parser->scope;
	if (scope == error_mark_node)
	return error_mark_node;

	/* Any name names a type if we're following the `typename' keyword
	in a qualified name where the enclosing scope is type-dependent. */
	typename_p = (typename_keyword_p && scope && TYPE_P (scope)
	&& dependent_type_p (scope));
	/* Handle the common case (an identifier, but not a template-id)
	efficiently. */
	if (token->type == CPP_NAME
	&& !cp_parser_nth_token_starts_template_argument_list_p (parser, 2))
	{
	cp_token *identifier_token;
	tree identifier;
	bool ambiguous_p;

	/* Look for the identifier. */
	identifier_token = cp_lexer_peek_token (parser->lexer);
	ambiguous_p = identifier_token->ambiguous_p;
	identifier = cp_parser_identifier (parser);
	/* If the next token isn't an identifier, we are certainly not
	looking at a class-name. */
	if (identifier == error_mark_node)
	decl = error_mark_node;
	/* If we know this is a type-name, there's no need to look it
	up. */
	else if (typename_p)
	decl = identifier;
	else
	{
	tree ambiguous_decls;
	/* If we already know that this lookup is ambiguous, then
	we've already issued an error message; there's no reason
	to check again. */
	if (ambiguous_p)
	{
	cp_parser_simulate_error (parser);
	return error_mark_node;
	}
	/* If the next token is a `::', then the name must be a type
	name.

	[basic.lookup.qual]

	During the lookup for a name preceding the :: scope
	resolution operator, object, function, and enumerator
	names are ignored. */
	if (cp_lexer_next_token_is (parser->lexer, CPP_SCOPE))
	tag_type = typename_type;
	/* Look up the name. */
	decl = cp_parser_lookup_name (parser, identifier,
	tag_type,
	/is_template=/false,
	/is_namespace=/false,
	check_dependency_p,
	&ambiguous_decls);
	if (ambiguous_decls)
	{
	error ("reference to %qD is ambiguous", identifier);
	print_candidates (ambiguous_decls);
	if (cp_parser_parsing_tentatively (parser))
	{
	identifier_token->ambiguous_p = true;
	cp_parser_simulate_error (parser);
	}
	return error_mark_node;
	}
	}
	}
	else
	{
	/* Try a template-id. */
	decl = cp_parser_template_id (parser, template_keyword_p,
	check_dependency_p,
	is_declaration);
	if (decl == error_mark_node)
	return error_mark_node;
	}

	decl = cp_parser_maybe_treat_template_as_class (decl, class_head_p);

	/* If this is a typename, create a TYPENAME_TYPE. */
	if (typename_p && decl != error_mark_node)
	{
	decl = make_typename_type (scope, decl, typename_type,
	/complain=/tf_error);
	if (decl != error_mark_node)
	decl = TYPE_NAME (decl);
	}

	/* Check to see that it is really the name of a class. */
	if (TREE_CODE (decl) == TEMPLATE_ID_EXPR
	&& TREE_CODE (TREE_OPERAND (decl, 0)) == IDENTIFIER_NODE
	&& cp_lexer_next_token_is (parser->lexer, CPP_SCOPE))
	/* Situations like this:

	template <typename T> struct A {
	typename T::template X<int>::I i;
	};

	are problematic. Is `T::template X<int>' a class-name? The
	standard does not seem to be definitive, but there is no other
	valid interpretation of the following `::'. Therefore, those
	names are considered class-names. */
	{
	decl = make_typename_type (scope, decl, tag_type, tf_error);
	if (decl != error_mark_node)
	decl = TYPE_NAME (decl);
	}
	else if (TREE_CODE (decl) != TYPE_DECL
	\|\| TREE_TYPE (decl) == error_mark_node
	\|\| !IS_AGGR_TYPE (TREE_TYPE (decl)))
	decl = error_mark_node;

	if (decl == error_mark_node)
	cp_parser_error (parser, "expected class-name");

	return decl;
	}

	/* Parse a class-specifier.

	class-specifier:
	class-head { member-specification [opt] }

	Returns the TREE_TYPE representing the class. */

	static tree
	cp_parser_class_specifier (cp_parser* parser)
	{
	cp_token *token;
	tree type;
	tree attributes = NULL_TREE;
	int has_trailing_semicolon;
	bool nested_name_specifier_p;
	unsigned saved_num_template_parameter_lists;
	bool saved_in_function_body;
	tree old_scope = NULL_TREE;
	tree scope = NULL_TREE;
	tree bases;

	push_deferring_access_checks (dk_no_deferred);

	/* Parse the class-head. */
	type = cp_parser_class_head (parser,
	&nested_name_specifier_p,
	&attributes,
	&bases);
	/* If the class-head was a semantic disaster, skip the entire body
	of the class. */
	if (!type)
	{
	cp_parser_skip_to_end_of_block_or_statement (parser);
	pop_deferring_access_checks ();
	return error_mark_node;
	}

	/* Look for the `{'. */
	if (!cp_parser_require (parser, CPP_OPEN_BRACE, "`{'"))
	{
	pop_deferring_access_checks ();
	return error_mark_node;
	}

	/* Process the base classes. If they're invalid, skip the
	entire class body. */
	if (!xref_basetypes (type, bases))
	{
	cp_parser_skip_to_closing_brace (parser);

	/* Consuming the closing brace yields better error messages
	later on. */
	cp_lexer_consume_token (parser->lexer);
	pop_deferring_access_checks ();
	return error_mark_node;
	}

	/* Issue an error message if type-definitions are forbidden here. */
	cp_parser_check_type_definition (parser);
	/* Remember that we are defining one more class. */
	++parser->num_classes_being_defined;
	/* Inside the class, surrounding template-parameter-lists do not
	apply. */
	saved_num_template_parameter_lists
	= parser->num_template_parameter_lists;
	parser->num_template_parameter_lists = 0;
	/* We are not in a function body. */
	saved_in_function_body = parser->in_function_body;
	parser->in_function_body = false;

	/* Start the class. */
	if (nested_name_specifier_p)
	{
	scope = CP_DECL_CONTEXT (TYPE_MAIN_DECL (type));
	old_scope = push_inner_scope (scope);
	}
	type = begin_class_definition (type, attributes);

	if (type == error_mark_node)
	/* If the type is erroneous, skip the entire body of the class. */
	cp_parser_skip_to_closing_brace (parser);
	else
	/* Parse the member-specification. */
	cp_parser_member_specification_opt (parser);

	/* Look for the trailing `}'. */
	cp_parser_require (parser, CPP_CLOSE_BRACE, "`}'");
	/* We get better error messages by noticing a common problem: a
	missing trailing `;'. */
	token = cp_lexer_peek_token (parser->lexer);
	has_trailing_semicolon = (token->type == CPP_SEMICOLON);
	/* Look for trailing attributes to apply to this class. */
	if (cp_parser_allow_gnu_extensions_p (parser))
	attributes = cp_parser_attributes_opt (parser);
	if (type != error_mark_node)
	type = finish_struct (type, attributes);
	if (nested_name_specifier_p)
	pop_inner_scope (old_scope, scope);
	/* If this class is not itself within the scope of another class,
	then we need to parse the bodies of all of the queued function
	definitions. Note that the queued functions defined in a class
	are not always processed immediately following the
	class-specifier for that class. Consider:

	struct A {
	struct B { void f() { sizeof (A); } };
	};

	If `f' were processed before the processing of `A' were
	completed, there would be no way to compute the size of `A'.
	Note that the nesting we are interested in here is lexical --
	not the semantic nesting given by TYPE_CONTEXT. In particular,
	for:

	struct A { struct B; };
	struct A::B { void f() { } };

	there is no need to delay the parsing of `A::B::f'. */
	if (--parser->num_classes_being_defined == 0)
	{
	tree queue_entry;
	tree fn;
	tree class_type = NULL_TREE;
	tree pushed_scope = NULL_TREE;

	/* In a first pass, parse default arguments to the functions.
	Then, in a second pass, parse the bodies of the functions.
	This two-phased approach handles cases like:

	struct S {
	void f() { g(); }
	void g(int i = 3);
	};

	*/
	for (TREE_PURPOSE (parser->unparsed_functions_queues)
	= nreverse (TREE_PURPOSE (parser->unparsed_functions_queues));
	(queue_entry = TREE_PURPOSE (parser->unparsed_functions_queues));
	TREE_PURPOSE (parser->unparsed_functions_queues)
	= TREE_CHAIN (TREE_PURPOSE (parser->unparsed_functions_queues)))
	{
	fn = TREE_VALUE (queue_entry);
	/* If there are default arguments that have not yet been processed,
	take care of them now. */
	if (class_type != TREE_PURPOSE (queue_entry))
	{
	if (pushed_scope)
	pop_scope (pushed_scope);
	class_type = TREE_PURPOSE (queue_entry);
	pushed_scope = push_scope (class_type);
	}
	/* Make sure that any template parameters are in scope. */
	maybe_begin_member_template_processing (fn);
	/* Parse the default argument expressions. */
	cp_parser_late_parsing_default_args (parser, fn);
	/* Remove any template parameters from the symbol table. */
	maybe_end_member_template_processing ();
	}
	if (pushed_scope)
	pop_scope (pushed_scope);
	/* Now parse the body of the functions. */
	for (TREE_VALUE (parser->unparsed_functions_queues)
	= nreverse (TREE_VALUE (parser->unparsed_functions_queues));
	(queue_entry = TREE_VALUE (parser->unparsed_functions_queues));
	TREE_VALUE (parser->unparsed_functions_queues)
	= TREE_CHAIN (TREE_VALUE (parser->unparsed_functions_queues)))
	{
	/* Figure out which function we need to process. */
	fn = TREE_VALUE (queue_entry);
	/* Parse the function. */
	cp_parser_late_parsing_for_member (parser, fn);
	}
	}

	/* Put back any saved access checks. */
	pop_deferring_access_checks ();

	/* Restore saved state. */
	parser->in_function_body = saved_in_function_body;
	parser->num_template_parameter_lists
	= saved_num_template_parameter_lists;

	return type;
	}

	/* Parse a class-head.

	class-head:
	class-key identifier [opt] base-clause [opt]
	class-key nested-name-specifier identifier base-clause [opt]
	class-key nested-name-specifier [opt] template-id
	base-clause [opt]

	GNU Extensions:
	class-key attributes identifier [opt] base-clause [opt]
	class-key attributes nested-name-specifier identifier base-clause [opt]
	class-key attributes nested-name-specifier [opt] template-id
	base-clause [opt]

	Returns the TYPE of the indicated class. Sets
	*NESTED_NAME_SPECIFIER_P to TRUE iff one of the productions
	involving a nested-name-specifier was used, and FALSE otherwise.

	Returns error_mark_node if this is not a class-head.

	Returns NULL_TREE if the class-head is syntactically valid, but
	semantically invalid in a way that means we should skip the entire
	body of the class. */

	static tree
	cp_parser_class_head (cp_parser* parser,
	bool* nested_name_specifier_p,
	tree *attributes_p,
	tree *bases)
	{
	tree nested_name_specifier;
	enum tag_types class_key;
	tree id = NULL_TREE;
	tree type = NULL_TREE;
	tree attributes;
	bool template_id_p = false;
	bool qualified_p = false;
	bool invalid_nested_name_p = false;
	bool invalid_explicit_specialization_p = false;
	tree pushed_scope = NULL_TREE;
	unsigned num_templates;

	/* Assume no nested-name-specifier will be present. */
	*nested_name_specifier_p = false;
	/* Assume no template parameter lists will be used in defining the
	type. */
	num_templates = 0;

	/* Look for the class-key. */
	class_key = cp_parser_class_key (parser);
	if (class_key == none_type)
	return error_mark_node;

	/* Parse the attributes. */
	attributes = cp_parser_attributes_opt (parser);

	/* If the next token is `::', that is invalid -- but sometimes
	people do try to write:

	struct ::S {};

	Handle this gracefully by accepting the extra qualifier, and then
	issuing an error about it later if this really is a
	class-head. If it turns out just to be an elaborated type
	specifier, remain silent. */
	if (cp_parser_global_scope_opt (parser, /current_scope_valid_p=/false))
	qualified_p = true;

	push_deferring_access_checks (dk_no_check);

	/* Determine the name of the class. Begin by looking for an
	optional nested-name-specifier. */
	nested_name_specifier
	= cp_parser_nested_name_specifier_opt (parser,
	/typename_keyword_p=/false,
	/check_dependency_p=/false,
	/type_p=/false,
	/is_declaration=/false);
	/* If there was a nested-name-specifier, then there must be an
	identifier. */
	if (nested_name_specifier)
	{
	/* Although the grammar says `identifier', it really means
	`class-name' or `template-name'. You are only allowed to
	define a class that has already been declared with this
	syntax.

	The proposed resolution for Core Issue 180 says that wherever
	you see `class T::X' you should treat `X' as a type-name.

	It is OK to define an inaccessible class; for example:

	class A { class B; };
	class A::B {};

	We do not know if we will see a class-name, or a
	template-name. We look for a class-name first, in case the
	class-name is a template-id; if we looked for the
	template-name first we would stop after the template-name. */
	cp_parser_parse_tentatively (parser);
	type = cp_parser_class_name (parser,
	/typename_keyword_p=/false,
	/template_keyword_p=/false,
	class_type,
	/check_dependency_p=/false,
	/class_head_p=/true,
	/is_declaration=/false);
	/* If that didn't work, ignore the nested-name-specifier. */
	if (!cp_parser_parse_definitely (parser))
	{
	invalid_nested_name_p = true;
	id = cp_parser_identifier (parser);
	if (id == error_mark_node)
	id = NULL_TREE;
	}
	/* If we could not find a corresponding TYPE, treat this
	declaration like an unqualified declaration. */
	if (type == error_mark_node)
	nested_name_specifier = NULL_TREE;
	/* Otherwise, count the number of templates used in TYPE and its
	containing scopes. */
	else
	{
	tree scope;

	for (scope = TREE_TYPE (type);
	scope && TREE_CODE (scope) != NAMESPACE_DECL;
	scope = (TYPE_P (scope)
	? TYPE_CONTEXT (scope)
	: DECL_CONTEXT (scope)))
	if (TYPE_P (scope)
	&& CLASS_TYPE_P (scope)
	&& CLASSTYPE_TEMPLATE_INFO (scope)
	&& PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (scope))
	&& !CLASSTYPE_TEMPLATE_SPECIALIZATION (scope))
	++num_templates;
	}
	}
	/* Otherwise, the identifier is optional. */
	else
	{
	/* We don't know whether what comes next is a template-id,
	an identifier, or nothing at all. */
	cp_parser_parse_tentatively (parser);
	/* Check for a template-id. */
	id = cp_parser_template_id (parser,
	/template_keyword_p=/false,
	/check_dependency_p=/true,
	/is_declaration=/true);
	/* If that didn't work, it could still be an identifier. */
	if (!cp_parser_parse_definitely (parser))
	{
	if (cp_lexer_next_token_is (parser->lexer, CPP_NAME))
	id = cp_parser_identifier (parser);
	else
	id = NULL_TREE;
	}
	else
	{
	template_id_p = true;
	++num_templates;
	}
	}

	pop_deferring_access_checks ();

	if (id)
	cp_parser_check_for_invalid_template_id (parser, id);

	/* If it's not a `:' or a `{' then we can't really be looking at a
	class-head, since a class-head only appears as part of a
	class-specifier. We have to detect this situation before calling
	xref_tag, since that has irreversible side-effects. */
	if (!cp_parser_next_token_starts_class_definition_p (parser))
	{
	cp_parser_error (parser, "expected %<{%> or %<:%>");
	return error_mark_node;
	}

	/* At this point, we're going ahead with the class-specifier, even
	if some other problem occurs. */
	cp_parser_commit_to_tentative_parse (parser);
	/* Issue the error about the overly-qualified name now. */
	if (qualified_p)
	cp_parser_error (parser,
	"global qualification of class name is invalid");
	else if (invalid_nested_name_p)
	cp_parser_error (parser,
	"qualified name does not name a class");
	else if (nested_name_specifier)
	{
	tree scope;

	/* Reject typedef-names in class heads. */
	if (!DECL_IMPLICIT_TYPEDEF_P (type))
	{
	error ("invalid class name in declaration of %qD", type);
	type = NULL_TREE;
	goto done;
	}

	/* Figure out in what scope the declaration is being placed. */
	scope = current_scope ();
	/* If that scope does not contain the scope in which the
	class was originally declared, the program is invalid. */
	if (scope && !is_ancestor (scope, nested_name_specifier))
	{
	error ("declaration of %qD in %qD which does not enclose %qD",
	type, scope, nested_name_specifier);
	type = NULL_TREE;
	goto done;
	}
	/* [dcl.meaning]

	A declarator-id shall not be qualified exception of the
	definition of a ... nested class outside of its class
	... [or] a the definition or explicit instantiation of a
	class member of a namespace outside of its namespace. */
	if (scope == nested_name_specifier)
	{
	pedwarn ("extra qualification ignored");
	nested_name_specifier = NULL_TREE;
	num_templates = 0;
	}
	}
	/* An explicit-specialization must be preceded by "template <>". If
	it is not, try to recover gracefully. */
	if (at_namespace_scope_p ()
	&& parser->num_template_parameter_lists == 0
	&& template_id_p)
	{
	error ("an explicit specialization must be preceded by %<template <>%>");
	invalid_explicit_specialization_p = true;
	/* Take the same action that would have been taken by
	cp_parser_explicit_specialization. */
	++parser->num_template_parameter_lists;
	begin_specialization ();
	}
	/* There must be no "return" statements between this point and the
	end of this function; set "type "to the correct return value and
	use "goto done;" to return. */
	/* Make sure that the right number of template parameters were
	present. */
	if (!cp_parser_check_template_parameters (parser, num_templates))
	{
	/* If something went wrong, there is no point in even trying to
	process the class-definition. */
	type = NULL_TREE;
	goto done;
	}

	/* Look up the type. */
	if (template_id_p)
	{
	type = TREE_TYPE (id);
	type = maybe_process_partial_specialization (type);
	if (nested_name_specifier)
	pushed_scope = push_scope (nested_name_specifier);
	}
	else if (nested_name_specifier)
	{
	tree class_type;

	/* Given:

	template <typename T> struct S { struct T };
	template <typename T> struct S<T>::T { };

	we will get a TYPENAME_TYPE when processing the definition of
	`S::T'. We need to resolve it to the actual type before we
	try to define it. */
	if (TREE_CODE (TREE_TYPE (type)) == TYPENAME_TYPE)
	{
	class_type = resolve_typename_type (TREE_TYPE (type),
	/only_current_p=/false);
	if (class_type != error_mark_node)
	type = TYPE_NAME (class_type);
	else
	{
	cp_parser_error (parser, "could not resolve typename type");
	type = error_mark_node;
	}
	}

	maybe_process_partial_specialization (TREE_TYPE (type));
	class_type = current_class_type;
	/* Enter the scope indicated by the nested-name-specifier. */
	pushed_scope = push_scope (nested_name_specifier);
	/* Get the canonical version of this type. */
	type = TYPE_MAIN_DECL (TREE_TYPE (type));
	if (PROCESSING_REAL_TEMPLATE_DECL_P ()
	&& !CLASSTYPE_TEMPLATE_SPECIALIZATION (TREE_TYPE (type)))
	{
	type = push_template_decl (type);
	if (type == error_mark_node)
	{
	type = NULL_TREE;
	goto done;
	}
	}

	type = TREE_TYPE (type);
	*nested_name_specifier_p = true;
	}
	else /* The name is not a nested name. */
	{
	/* If the class was unnamed, create a dummy name. */
	if (!id)
	id = make_anon_name ();
	type = xref_tag (class_key, id, /tag_scope=/ts_current,
	parser->num_template_parameter_lists);
	}

	/* Indicate whether this class was declared as a `class' or as a
	`struct'. */
	if (TREE_CODE (type) == RECORD_TYPE)
	CLASSTYPE_DECLARED_CLASS (type) = (class_key == class_type);
	cp_parser_check_class_key (class_key, type);

	/* If this type was already complete, and we see another definition,
	that's an error. */
	if (type != error_mark_node && COMPLETE_TYPE_P (type))
	{
	error ("redefinition of %q#T", type);
	error ("previous definition of %q+#T", type);
	type = NULL_TREE;
	goto done;
	}
	else if (type == error_mark_node)
	type = NULL_TREE;

	/* We will have entered the scope containing the class; the names of
	base classes should be looked up in that context. For example:

	struct A { struct B {}; struct C; };
	struct A::C : B {};

	is valid. */
	*bases = NULL_TREE;

	/* Get the list of base-classes, if there is one. */
	if (cp_lexer_next_token_is (parser->lexer, CPP_COLON))
	*bases = cp_parser_base_clause (parser);

	done:
	/* Leave the scope given by the nested-name-specifier. We will
	enter the class scope itself while processing the members. */
	if (pushed_scope)
	pop_scope (pushed_scope);

	if (invalid_explicit_specialization_p)
	{
	end_specialization ();
	--parser->num_template_parameter_lists;
	}
	*attributes_p = attributes;
	return type;
	}

	/* Parse a class-key.

	class-key:
	class
	struct
	union

	Returns the kind of class-key specified, or none_type to indicate
	error. */

	static enum tag_types
	cp_parser_class_key (cp_parser* parser)
	{
	cp_token *token;
	enum tag_types tag_type;

	/* Look for the class-key. */
	token = cp_parser_require (parser, CPP_KEYWORD, "class-key");
	if (!token)
	return none_type;

	/* Check to see if the TOKEN is a class-key. */
	tag_type = cp_parser_token_is_class_key (token);
	if (!tag_type)
	cp_parser_error (parser, "expected class-key");
	return tag_type;
	}

	/* Parse an (optional) member-specification.

	member-specification:
	member-declaration member-specification [opt]
	access-specifier : member-specification [opt] */

	static void
	cp_parser_member_specification_opt (cp_parser* parser)
	{
	while (true)
	{
	cp_token *token;
	enum rid keyword;

	/* Peek at the next token. */
	token = cp_lexer_peek_token (parser->lexer);
	/* If it's a `}', or EOF then we've seen all the members. */
	if (token->type == CPP_CLOSE_BRACE
	\|\| token->type == CPP_EOF
	\|\| token->type == CPP_PRAGMA_EOL)
	break;

	/* See if this token is a keyword. */
	keyword = token->keyword;
	switch (keyword)
	{
	case RID_PUBLIC:
	case RID_PROTECTED:
	case RID_PRIVATE:
	/* Consume the access-specifier. */
	cp_lexer_consume_token (parser->lexer);
	/* Remember which access-specifier is active. */
	current_access_specifier = token->u.value;
	/* Look for the `:'. */
	cp_parser_require (parser, CPP_COLON, "`:'");
	break;

	default:
	/* Accept #pragmas at class scope. */
	if (token->type == CPP_PRAGMA)
	{
	cp_parser_pragma (parser, pragma_external);
	break;
	}

	/* Otherwise, the next construction must be a
	member-declaration. */
	cp_parser_member_declaration (parser);
	}
	}
	}

	/* Parse a member-declaration.

	member-declaration:
	decl-specifier-seq [opt] member-declarator-list [opt] ;
	function-definition ; [opt]
	:: [opt] nested-name-specifier template [opt] unqualified-id ;
	using-declaration
	template-declaration

	member-declarator-list:
	member-declarator
	member-declarator-list , member-declarator

	member-declarator:
	declarator pure-specifier [opt]
	declarator constant-initializer [opt]
	identifier [opt] : constant-expression

	GNU Extensions:

	member-declaration:
	__extension__ member-declaration

	member-declarator:
	declarator attributes [opt] pure-specifier [opt]
	declarator attributes [opt] constant-initializer [opt]
	identifier [opt] attributes [opt] : constant-expression */

	static void
	cp_parser_member_declaration (cp_parser* parser)
	{
	cp_decl_specifier_seq decl_specifiers;
	tree prefix_attributes;
	tree decl;
	int declares_class_or_enum;
	bool friend_p;
	cp_token *token;
	int saved_pedantic;

	/* Check for the `__extension__' keyword. */
	if (cp_parser_extension_opt (parser, &saved_pedantic))
	{
	/* Recurse. */
	cp_parser_member_declaration (parser);
	/* Restore the old value of the PEDANTIC flag. */
	pedantic = saved_pedantic;

	return;
	}

	/* Check for a template-declaration. */
	if (cp_lexer_next_token_is_keyword (parser->lexer, RID_TEMPLATE))
	{
	/* An explicit specialization here is an error condition, and we
	expect the specialization handler to detect and report this. */
	if (cp_lexer_peek_nth_token (parser->lexer, 2)->type == CPP_LESS
	&& cp_lexer_peek_nth_token (parser->lexer, 3)->type == CPP_GREATER)
	cp_parser_explicit_specialization (parser);
	else
	cp_parser_template_declaration (parser, /member_p=/true);

	return;
	}

	/* Check for a using-declaration. */
	if (cp_lexer_next_token_is_keyword (parser->lexer, RID_USING))
	{
	/* Parse the using-declaration. */
	cp_parser_using_declaration (parser,
	/access_declaration_p=/false);
	return;
	}

	/* Check for @defs. */
	if (cp_lexer_next_token_is_keyword (parser->lexer, RID_AT_DEFS))
	{
	tree ivar, member;
	tree ivar_chains = cp_parser_objc_defs_expression (parser);
	ivar = ivar_chains;
	while (ivar)
	{
	member = ivar;
	ivar = TREE_CHAIN (member);
	TREE_CHAIN (member) = NULL_TREE;
	finish_member_declaration (member);
	}
	return;
	}

	if (cp_parser_using_declaration (parser, /access_declaration=/true))
	return;

	/* Parse the decl-specifier-seq. */
	cp_parser_decl_specifier_seq (parser,
	CP_PARSER_FLAGS_OPTIONAL,
	&decl_specifiers,
	&declares_class_or_enum);
	prefix_attributes = decl_specifiers.attributes;
	decl_specifiers.attributes = NULL_TREE;
	/* Check for an invalid type-name. */
	if (!decl_specifiers.type
	&& cp_parser_parse_and_diagnose_invalid_type_name (parser))
	return;
	/* If there is no declarator, then the decl-specifier-seq should
	specify a type. */
	if (cp_lexer_next_token_is (parser->lexer, CPP_SEMICOLON))
	{
	/* If there was no decl-specifier-seq, and the next token is a
	`;', then we have something like:

	struct S { ; };

	[class.mem]

	Each member-declaration shall declare at least one member
	name of the class. */
	if (!decl_specifiers.any_specifiers_p)
	{
	cp_token *token = cp_lexer_peek_token (parser->lexer);
	if (pedantic && !token->in_system_header)
	pedwarn ("%Hextra %<;%>", &token->location);
	}
	else
	{
	tree type;

	/* See if this declaration is a friend. */
	friend_p = cp_parser_friend_p (&decl_specifiers);
	/* If there were decl-specifiers, check to see if there was
	a class-declaration. */
	type = check_tag_decl (&decl_specifiers);
	/* Nested classes have already been added to the class, but
	a `friend' needs to be explicitly registered. */
	if (friend_p)
	{
	/* If the `friend' keyword was present, the friend must
	be introduced with a class-key. */
	if (!declares_class_or_enum)
	error ("a class-key must be used when declaring a friend");
	/* In this case:

	template <typename T> struct A {
	friend struct A<T>::B;
	};

	A<T>::B will be represented by a TYPENAME_TYPE, and
	therefore not recognized by check_tag_decl. */
	if (!type
	&& decl_specifiers.type
	&& TYPE_P (decl_specifiers.type))
	type = decl_specifiers.type;
	if (!type \|\| !TYPE_P (type))
	error ("friend declaration does not name a class or "
	"function");
	else
	make_friend_class (current_class_type, type,
	/complain=/true);
	}
	/* If there is no TYPE, an error message will already have
	been issued. */
	else if (!type \|\| type == error_mark_node)
	;
	/* An anonymous aggregate has to be handled specially; such
	a declaration really declares a data member (with a
	particular type), as opposed to a nested class. */
	else if (ANON_AGGR_TYPE_P (type))
	{
	/* Remove constructors and such from TYPE, now that we
	know it is an anonymous aggregate. */
	fixup_anonymous_aggr (type);
	/* And make the corresponding data member. */
	decl = build_decl (FIELD_DECL, NULL_TREE, type);
	/* Add it to the class. */
	finish_member_declaration (decl);
	}
	else
	cp_parser_check_access_in_redeclaration (TYPE_NAME (type));
	}
	}
	else
	{
	/* See if these declarations will be friends. */
	friend_p = cp_parser_friend_p (&decl_specifiers);

	/* Keep going until we hit the `;' at the end of the
	declaration. */
	while (cp_lexer_next_token_is_not (parser->lexer, CPP_SEMICOLON))
	{
	tree attributes = NULL_TREE;
	tree first_attribute;

	/* Peek at the next token. */
	token = cp_lexer_peek_token (parser->lexer);

	/* Check for a bitfield declaration. */
	if (token->type == CPP_COLON
	\|\| (token->type == CPP_NAME
	&& cp_lexer_peek_nth_token (parser->lexer, 2)->type
	== CPP_COLON))
	{
	tree identifier;
	tree width;

	/* Get the name of the bitfield. Note that we cannot just
	check TOKEN here because it may have been invalidated by
	the call to cp_lexer_peek_nth_token above. */
	if (cp_lexer_peek_token (parser->lexer)->type != CPP_COLON)
	identifier = cp_parser_identifier (parser);
	else
	identifier = NULL_TREE;

	/* Consume the `:' token. */
	cp_lexer_consume_token (parser->lexer);
	/* Get the width of the bitfield. */
	width
	= cp_parser_constant_expression (parser,
	/allow_non_constant=/false,
	NULL);

	/* Look for attributes that apply to the bitfield. */
	attributes = cp_parser_attributes_opt (parser);
	/* Remember which attributes are prefix attributes and
	which are not. */
	first_attribute = attributes;
	/* Combine the attributes. */
	attributes = chainon (prefix_attributes, attributes);

	/* Create the bitfield declaration. */
	decl = grokbitfield (identifier
	? make_id_declarator (NULL_TREE,
	identifier,
	sfk_none)
	: NULL,
	&decl_specifiers,
	width);
	/* Apply the attributes. */
	cplus_decl_attributes (&decl, attributes, /flags=/0);
	}
	else
	{
	cp_declarator *declarator;
	tree initializer;
	tree asm_specification;
	int ctor_dtor_or_conv_p;

	/* Parse the declarator. */
	declarator
	= cp_parser_declarator (parser, CP_PARSER_DECLARATOR_NAMED,
	&ctor_dtor_or_conv_p,
	/parenthesized_p=/NULL,
	/member_p=/true);

	/* If something went wrong parsing the declarator, make sure
	that we at least consume some tokens. */
	if (declarator == cp_error_declarator)
	{
	/* Skip to the end of the statement. */
	cp_parser_skip_to_end_of_statement (parser);
	/* If the next token is not a semicolon, that is
	probably because we just skipped over the body of
	a function. So, we consume a semicolon if
	present, but do not issue an error message if it
	is not present. */
	if (cp_lexer_next_token_is (parser->lexer,
	CPP_SEMICOLON))
	cp_lexer_consume_token (parser->lexer);
	return;
	}

	if (declares_class_or_enum & 2)
	cp_parser_check_for_definition_in_return_type
	(declarator, decl_specifiers.type);

	/* Look for an asm-specification. */
	asm_specification = cp_parser_asm_specification_opt (parser);
	/* Look for attributes that apply to the declaration. */
	attributes = cp_parser_attributes_opt (parser);
	/* Remember which attributes are prefix attributes and
	which are not. */
	first_attribute = attributes;
	/* Combine the attributes. */
	attributes = chainon (prefix_attributes, attributes);

	/* If it's an `=', then we have a constant-initializer or a
	pure-specifier. It is not correct to parse the
	initializer before registering the member declaration
	since the member declaration should be in scope while
	its initializer is processed. However, the rest of the
	front end does not yet provide an interface that allows
	us to handle this correctly. */
	if (cp_lexer_next_token_is (parser->lexer, CPP_EQ))
	{
	/* In [class.mem]:

	A pure-specifier shall be used only in the declaration of
	a virtual function.

	A member-declarator can contain a constant-initializer
	only if it declares a static member of integral or
	enumeration type.

	Therefore, if the DECLARATOR is for a function, we look
	for a pure-specifier; otherwise, we look for a
	constant-initializer. When we call `grokfield', it will
	perform more stringent semantics checks. */
	if (function_declarator_p (declarator))
	initializer = cp_parser_pure_specifier (parser);
	else
	/* Parse the initializer. */
	initializer = cp_parser_constant_initializer (parser);
	}
	/* Otherwise, there is no initializer. */
	else
	initializer = NULL_TREE;

	/* See if we are probably looking at a function
	definition. We are certainly not looking at a
	member-declarator. Calling `grokfield' has
	side-effects, so we must not do it unless we are sure
	that we are looking at a member-declarator. */
	if (cp_parser_token_starts_function_definition_p
	(cp_lexer_peek_token (parser->lexer)))
	{
	/* The grammar does not allow a pure-specifier to be
	used when a member function is defined. (It is
	possible that this fact is an oversight in the
	standard, since a pure function may be defined
	outside of the class-specifier. */
	if (initializer)
	error ("pure-specifier on function-definition");
	decl = cp_parser_save_member_function_body (parser,
	&decl_specifiers,
	declarator,
	attributes);
	/* If the member was not a friend, declare it here. */
	if (!friend_p)
	finish_member_declaration (decl);
	/* Peek at the next token. */
	token = cp_lexer_peek_token (parser->lexer);
	/* If the next token is a semicolon, consume it. */
	if (token->type == CPP_SEMICOLON)
	cp_lexer_consume_token (parser->lexer);
	return;
	}
	else
	/* Create the declaration. */
	decl = grokfield (declarator, &decl_specifiers,
	initializer, /init_const_expr_p=/true,
	asm_specification,
	attributes);
	}

	/* Reset PREFIX_ATTRIBUTES. */
	while (attributes && TREE_CHAIN (attributes) != first_attribute)
	attributes = TREE_CHAIN (attributes);
	if (attributes)
	TREE_CHAIN (attributes) = NULL_TREE;

	/* If there is any qualification still in effect, clear it
	now; we will be starting fresh with the next declarator. */
	parser->scope = NULL_TREE;
	parser->qualifying_scope = NULL_TREE;
	parser->object_scope = NULL_TREE;
	/* If it's a `,', then there are more declarators. */
	if (cp_lexer_next_token_is (parser->lexer, CPP_COMMA))
	cp_lexer_consume_token (parser->lexer);
	/* If the next token isn't a `;', then we have a parse error. */
	else if (cp_lexer_next_token_is_not (parser->lexer,
	CPP_SEMICOLON))
	{
	cp_parser_error (parser, "expected %<;%>");
	/* Skip tokens until we find a `;'. */
	cp_parser_skip_to_end_of_statement (parser);

	break;
	}

	if (decl)
	{
	/* Add DECL to the list of members. */
	if (!friend_p)
	finish_member_declaration (decl);

	if (TREE_CODE (decl) == FUNCTION_DECL)
	cp_parser_save_default_args (parser, decl);
	}
	}
	}

	cp_parser_require (parser, CPP_SEMICOLON, "`;'");
	}

	/* Parse a pure-specifier.

	pure-specifier:
	= 0

	Returns INTEGER_ZERO_NODE if a pure specifier is found.
	Otherwise, ERROR_MARK_NODE is returned. */

	static tree
	cp_parser_pure_specifier (cp_parser* parser)
	{
	cp_token *token;

	/* Look for the `=' token. */
	if (!cp_parser_require (parser, CPP_EQ, "`='"))
	return error_mark_node;
	/* Look for the `0' token. */
	token = cp_lexer_consume_token (parser->lexer);
	/* c_lex_with_flags marks a single digit '0' with PURE_ZERO. */
	if (token->type != CPP_NUMBER \|\| !(token->flags & PURE_ZERO))
	{
	cp_parser_error (parser,
	"invalid pure specifier (only `= 0' is allowed)");
	cp_parser_skip_to_end_of_statement (parser);
	return error_mark_node;
	}
	if (PROCESSING_REAL_TEMPLATE_DECL_P ())
	{
	error ("templates may not be %<virtual%>");
	return error_mark_node;
	}

	return integer_zero_node;
	}

	/* Parse a constant-initializer.

	constant-initializer:
	= constant-expression

	Returns a representation of the constant-expression. */

	static tree
	cp_parser_constant_initializer (cp_parser* parser)
	{
	/* Look for the `=' token. */
	if (!cp_parser_require (parser, CPP_EQ, "`='"))
	return error_mark_node;

	/* It is invalid to write:

	struct S { static const int i = { 7 }; };

	*/
	if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_BRACE))
	{
	cp_parser_error (parser,
	"a brace-enclosed initializer is not allowed here");
	/* Consume the opening brace. */
	cp_lexer_consume_token (parser->lexer);
	/* Skip the initializer. */
	cp_parser_skip_to_closing_brace (parser);
	/* Look for the trailing `}'. */
	cp_parser_require (parser, CPP_CLOSE_BRACE, "`}'");

	return error_mark_node;
	}

	return cp_parser_constant_expression (parser,
	/allow_non_constant=/false,
	NULL);
	}

	/* Derived classes [gram.class.derived] */

	/* Parse a base-clause.

	base-clause:
	: base-specifier-list

	base-specifier-list:
	base-specifier
	base-specifier-list , base-specifier

	Returns a TREE_LIST representing the base-classes, in the order in
	which they were declared. The representation of each node is as
	described by cp_parser_base_specifier.

	In the case that no bases are specified, this function will return
	NULL_TREE, not ERROR_MARK_NODE. */

	static tree
	cp_parser_base_clause (cp_parser* parser)
	{
	tree bases = NULL_TREE;

	/* Look for the `:' that begins the list. */
	cp_parser_require (parser, CPP_COLON, "`:'");

	/* Scan the base-specifier-list. */
	while (true)
	{
	cp_token *token;
	tree base;

	/* Look for the base-specifier. */
	base = cp_parser_base_specifier (parser);
	/* Add BASE to the front of the list. */
	if (base != error_mark_node)
	{
	TREE_CHAIN (base) = bases;
	bases = base;
	}
	/* Peek at the next token. */
	token = cp_lexer_peek_token (parser->lexer);
	/* If it's not a comma, then the list is complete. */
	if (token->type != CPP_COMMA)
	break;
	/* Consume the `,'. */
	cp_lexer_consume_token (parser->lexer);
	}

	/* PARSER->SCOPE may still be non-NULL at this point, if the last
	base class had a qualified name. However, the next name that
	appears is certainly not qualified. */
	parser->scope = NULL_TREE;
	parser->qualifying_scope = NULL_TREE;
	parser->object_scope = NULL_TREE;

	return nreverse (bases);
	}

	/* Parse a base-specifier.

	base-specifier:
	:: [opt] nested-name-specifier [opt] class-name
	virtual access-specifier [opt] :: [opt] nested-name-specifier
	[opt] class-name
	access-specifier virtual [opt] :: [opt] nested-name-specifier
	[opt] class-name

	Returns a TREE_LIST. The TREE_PURPOSE will be one of
	ACCESS_{DEFAULT,PUBLIC,PROTECTED,PRIVATE}_[VIRTUAL]_NODE to
	indicate the specifiers provided. The TREE_VALUE will be a TYPE
	(or the ERROR_MARK_NODE) indicating the type that was specified. */

	static tree
	cp_parser_base_specifier (cp_parser* parser)
	{
	cp_token *token;
	bool done = false;
	bool virtual_p = false;
	bool duplicate_virtual_error_issued_p = false;
	bool duplicate_access_error_issued_p = false;
	bool class_scope_p, template_p;
	tree access = access_default_node;
	tree type;

	/* Process the optional `virtual' and `access-specifier'. */
	while (!done)
	{
	/* Peek at the next token. */
	token = cp_lexer_peek_token (parser->lexer);
	/* Process `virtual'. */
	switch (token->keyword)
	{
	case RID_VIRTUAL:
	/* If `virtual' appears more than once, issue an error. */
	if (virtual_p && !duplicate_virtual_error_issued_p)
	{
	cp_parser_error (parser,
	"%<virtual%> specified more than once in base-specified");
	duplicate_virtual_error_issued_p = true;
	}

	virtual_p = true;

	/* Consume the `virtual' token. */
	cp_lexer_consume_token (parser->lexer);

	break;

	case RID_PUBLIC:
	case RID_PROTECTED:
	case RID_PRIVATE:
	/* If more than one access specifier appears, issue an
	error. */
	if (access != access_default_node
	&& !duplicate_access_error_issued_p)
	{
	cp_parser_error (parser,
	"more than one access specifier in base-specified");
	duplicate_access_error_issued_p = true;
	}

	access = ridpointers[(int) token->keyword];

	/* Consume the access-specifier. */
	cp_lexer_consume_token (parser->lexer);

	break;

	default:
	done = true;
	break;
	}
	}
	/* It is not uncommon to see programs mechanically, erroneously, use
	the 'typename' keyword to denote (dependent) qualified types
	as base classes. */
	if (cp_lexer_next_token_is_keyword (parser->lexer, RID_TYPENAME))
	{
	if (!processing_template_decl)
	error ("keyword %<typename%> not allowed outside of templates");
	else
	error ("keyword %<typename%> not allowed in this context "
	"(the base class is implicitly a type)");
	cp_lexer_consume_token (parser->lexer);
	}

	/* Look for the optional `::' operator. */
	cp_parser_global_scope_opt (parser, /current_scope_valid_p=/false);
	/* Look for the nested-name-specifier. The simplest way to
	implement:

	[temp.res]

	The keyword `typename' is not permitted in a base-specifier or
	mem-initializer; in these contexts a qualified name that
	depends on a template-parameter is implicitly assumed to be a
	type name.

	is to pretend that we have seen the `typename' keyword at this
	point. */
	cp_parser_nested_name_specifier_opt (parser,
	/typename_keyword_p=/true,
	/check_dependency_p=/true,
	typename_type,
	/is_declaration=/true);
	/* If the base class is given by a qualified name, assume that names
	we see are type names or templates, as appropriate. */
	class_scope_p = (parser->scope && TYPE_P (parser->scope));
	template_p = class_scope_p && cp_parser_optional_template_keyword (parser);

	/* Finally, look for the class-name. */
	type = cp_parser_class_name (parser,
	class_scope_p,
	template_p,
	typename_type,
	/check_dependency_p=/true,
	/class_head_p=/false,
	/is_declaration=/true);

	if (type == error_mark_node)
	return error_mark_node;

	return finish_base_specifier (TREE_TYPE (type), access, virtual_p);
	}

	/* Exception handling [gram.exception] */

	/* Parse an (optional) exception-specification.

	exception-specification:
	throw ( type-id-list [opt] )

	Returns a TREE_LIST representing the exception-specification. The
	TREE_VALUE of each node is a type. */

	static tree
	cp_parser_exception_specification_opt (cp_parser* parser)
	{
	cp_token *token;
	tree type_id_list;

	/* Peek at the next token. */
	token = cp_lexer_peek_token (parser->lexer);
	/* If it's not `throw', then there's no exception-specification. */
	if (!cp_parser_is_keyword (token, RID_THROW))
	return NULL_TREE;

	/* Consume the `throw'. */
	cp_lexer_consume_token (parser->lexer);

	/* Look for the `('. */
	cp_parser_require (parser, CPP_OPEN_PAREN, "`('");

	/* Peek at the next token. */
	token = cp_lexer_peek_token (parser->lexer);
	/* If it's not a `)', then there is a type-id-list. */
	if (token->type != CPP_CLOSE_PAREN)
	{
	const char *saved_message;

	/* Types may not be defined in an exception-specification. */
	saved_message = parser->type_definition_forbidden_message;
	parser->type_definition_forbidden_message
	= "types may not be defined in an exception-specification";
	/* Parse the type-id-list. */
	type_id_list = cp_parser_type_id_list (parser);
	/* Restore the saved message. */
	parser->type_definition_forbidden_message = saved_message;
	}
	else
	type_id_list = empty_except_spec;

	/* Look for the `)'. */
	cp_parser_require (parser, CPP_CLOSE_PAREN, "`)'");

	return type_id_list;
	}

	/* Parse an (optional) type-id-list.

	type-id-list:
	type-id
	type-id-list , type-id

	Returns a TREE_LIST. The TREE_VALUE of each node is a TYPE,
	in the order that the types were presented. */

	static tree
	cp_parser_type_id_list (cp_parser* parser)
	{
	tree types = NULL_TREE;

	while (true)
	{
	cp_token *token;
	tree type;

	/* Get the next type-id. */
	type = cp_parser_type_id (parser);
	/* Add it to the list. */
	types = add_exception_specifier (types, type, /complain=/1);
	/* Peek at the next token. */
	token = cp_lexer_peek_token (parser->lexer);
	/* If it is not a `,', we are done. */
	if (token->type != CPP_COMMA)
	break;
	/* Consume the `,'. */
	cp_lexer_consume_token (parser->lexer);
	}

	return nreverse (types);
	}

	/* Parse a try-block.

	try-block:
	try compound-statement handler-seq */

	static tree
	cp_parser_try_block (cp_parser* parser)
	{
	tree try_block;

	cp_parser_require_keyword (parser, RID_TRY, "`try'");
	try_block = begin_try_block ();
	cp_parser_compound_statement (parser, NULL, true);
	finish_try_block (try_block);
	cp_parser_handler_seq (parser);
	finish_handler_sequence (try_block);

	return try_block;
	}

	/* Parse a function-try-block.

	function-try-block:
	try ctor-initializer [opt] function-body handler-seq */

	static bool
	cp_parser_function_try_block (cp_parser* parser)
	{
	tree compound_stmt;
	tree try_block;
	bool ctor_initializer_p;

	/* Look for the `try' keyword. */
	if (!cp_parser_require_keyword (parser, RID_TRY, "`try'"))
	return false;
	/* Let the rest of the front-end know where we are. */
	try_block = begin_function_try_block (&compound_stmt);
	/* Parse the function-body. */
	ctor_initializer_p
	= cp_parser_ctor_initializer_opt_and_function_body (parser);
	/* We're done with the `try' part. */
	finish_function_try_block (try_block);
	/* Parse the handlers. */
	cp_parser_handler_seq (parser);
	/* We're done with the handlers. */
	finish_function_handler_sequence (try_block, compound_stmt);

	return ctor_initializer_p;
	}

	/* Parse a handler-seq.

	handler-seq:
	handler handler-seq [opt] */

	static void
	cp_parser_handler_seq (cp_parser* parser)
	{
	while (true)
	{
	cp_token *token;

	/* Parse the handler. */
	cp_parser_handler (parser);
	/* Peek at the next token. */
	token = cp_lexer_peek_token (parser->lexer);
	/* If it's not `catch' then there are no more handlers. */
	if (!cp_parser_is_keyword (token, RID_CATCH))
	break;
	}
	}

	/* Parse a handler.

	handler:
	catch ( exception-declaration ) compound-statement */

	static void
	cp_parser_handler (cp_parser* parser)
	{
	tree handler;
	tree declaration;

	cp_parser_require_keyword (parser, RID_CATCH, "`catch'");
	handler = begin_handler ();
	cp_parser_require (parser, CPP_OPEN_PAREN, "`('");
	declaration = cp_parser_exception_declaration (parser);
	finish_handler_parms (declaration, handler);
	cp_parser_require (parser, CPP_CLOSE_PAREN, "`)'");
	cp_parser_compound_statement (parser, NULL, false);
	finish_handler (handler);
	}

	/* Parse an exception-declaration.

	exception-declaration:
	type-specifier-seq declarator
	type-specifier-seq abstract-declarator
	type-specifier-seq
	...

	Returns a VAR_DECL for the declaration, or NULL_TREE if the
	ellipsis variant is used. */

	static tree
	cp_parser_exception_declaration (cp_parser* parser)
	{
	cp_decl_specifier_seq type_specifiers;
	cp_declarator *declarator;
	const char *saved_message;

	/* If it's an ellipsis, it's easy to handle. */
	if (cp_lexer_next_token_is (parser->lexer, CPP_ELLIPSIS))
	{
	/* Consume the `...' token. */
	cp_lexer_consume_token (parser->lexer);
	return NULL_TREE;
	}

	/* Types may not be defined in exception-declarations. */
	saved_message = parser->type_definition_forbidden_message;
	parser->type_definition_forbidden_message
	= "types may not be defined in exception-declarations";

	/* Parse the type-specifier-seq. */
	cp_parser_type_specifier_seq (parser, /is_condition=/false,
	&type_specifiers);
	/* If it's a `)', then there is no declarator. */
	if (cp_lexer_next_token_is (parser->lexer, CPP_CLOSE_PAREN))
	declarator = NULL;
	else
	declarator = cp_parser_declarator (parser, CP_PARSER_DECLARATOR_EITHER,
	/ctor_dtor_or_conv_p=/NULL,
	/parenthesized_p=/NULL,
	/member_p=/false);

	/* Restore the saved message. */
	parser->type_definition_forbidden_message = saved_message;

	if (!type_specifiers.any_specifiers_p)
	return error_mark_node;

	return grokdeclarator (declarator, &type_specifiers, CATCHPARM, 1, NULL);
	}

	/* Parse a throw-expression.

	throw-expression:
	throw assignment-expression [opt]

	Returns a THROW_EXPR representing the throw-expression. */

	static tree
	cp_parser_throw_expression (cp_parser* parser)
	{
	tree expression;
	cp_token* token;

	cp_parser_require_keyword (parser, RID_THROW, "`throw'");
	token = cp_lexer_peek_token (parser->lexer);
	/* Figure out whether or not there is an assignment-expression
	following the "throw" keyword. */
	if (token->type == CPP_COMMA
	\|\| token->type == CPP_SEMICOLON
	\|\| token->type == CPP_CLOSE_PAREN
	\|\| token->type == CPP_CLOSE_SQUARE
	\|\| token->type == CPP_CLOSE_BRACE
	\|\| token->type == CPP_COLON)
	expression = NULL_TREE;
	else
	expression = cp_parser_assignment_expression (parser,
	/cast_p=/false);

	return build_throw (expression);
	}

	/* GNU Extensions */

	/* Parse an (optional) asm-specification.

	asm-specification:
	asm ( string-literal )

	If the asm-specification is present, returns a STRING_CST
	corresponding to the string-literal. Otherwise, returns
	NULL_TREE. */

	static tree
	cp_parser_asm_specification_opt (cp_parser* parser)
	{
	cp_token *token;
	tree asm_specification;

	/* Peek at the next token. */
	token = cp_lexer_peek_token (parser->lexer);
	/* If the next token isn't the `asm' keyword, then there's no
	asm-specification. */
	if (!cp_parser_is_keyword (token, RID_ASM))
	return NULL_TREE;

	/* Consume the `asm' token. */
	cp_lexer_consume_token (parser->lexer);
	/* Look for the `('. */
	cp_parser_require (parser, CPP_OPEN_PAREN, "`('");

	/* Look for the string-literal. */
	asm_specification = cp_parser_string_literal (parser, false, false);

	/* Look for the `)'. */
	cp_parser_require (parser, CPP_CLOSE_PAREN, "`('");

	return asm_specification;
	}

	/* Parse an asm-operand-list.

	asm-operand-list:
	asm-operand
	asm-operand-list , asm-operand

	asm-operand:
	string-literal ( expression )
	[ string-literal ] string-literal ( expression )

	Returns a TREE_LIST representing the operands. The TREE_VALUE of
	each node is the expression. The TREE_PURPOSE is itself a
	TREE_LIST whose TREE_PURPOSE is a STRING_CST for the bracketed
	string-literal (or NULL_TREE if not present) and whose TREE_VALUE
	is a STRING_CST for the string literal before the parenthesis. */

	static tree
	cp_parser_asm_operand_list (cp_parser* parser)
	{
	tree asm_operands = NULL_TREE;

	while (true)
	{
	tree string_literal;
	tree expression;
	tree name;

	if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_SQUARE))
	{
	/* Consume the `[' token. */
	cp_lexer_consume_token (parser->lexer);
	/* Read the operand name. */
	name = cp_parser_identifier (parser);
	if (name != error_mark_node)
	name = build_string (IDENTIFIER_LENGTH (name),
	IDENTIFIER_POINTER (name));
	/* Look for the closing `]'. */
	cp_parser_require (parser, CPP_CLOSE_SQUARE, "`]'");
	}
	else
	name = NULL_TREE;
	/* Look for the string-literal. */
	string_literal = cp_parser_string_literal (parser, false, false);

	/* Look for the `('. */
	cp_parser_require (parser, CPP_OPEN_PAREN, "`('");
	/* Parse the expression. */
	expression = cp_parser_expression (parser, /cast_p=/false);
	/* Look for the `)'. */
	cp_parser_require (parser, CPP_CLOSE_PAREN, "`)'");

	/* Add this operand to the list. */
	asm_operands = tree_cons (build_tree_list (name, string_literal),
	expression,
	asm_operands);
	/* If the next token is not a `,', there are no more
	operands. */
	if (cp_lexer_next_token_is_not (parser->lexer, CPP_COMMA))
	break;
	/* Consume the `,'. */
	cp_lexer_consume_token (parser->lexer);
	}

	return nreverse (asm_operands);
	}

	/* Parse an asm-clobber-list.

	asm-clobber-list:
	string-literal
	asm-clobber-list , string-literal

	Returns a TREE_LIST, indicating the clobbers in the order that they
	appeared. The TREE_VALUE of each node is a STRING_CST. */

	static tree
	cp_parser_asm_clobber_list (cp_parser* parser)
	{
	tree clobbers = NULL_TREE;

	while (true)
	{
	tree string_literal;

	/* Look for the string literal. */
	string_literal = cp_parser_string_literal (parser, false, false);
	/* Add it to the list. */
	clobbers = tree_cons (NULL_TREE, string_literal, clobbers);
	/* If the next token is not a `,', then the list is
	complete. */
	if (cp_lexer_next_token_is_not (parser->lexer, CPP_COMMA))
	break;
	/* Consume the `,' token. */
	cp_lexer_consume_token (parser->lexer);
	}

	return clobbers;
	}

	/* Parse an (optional) series of attributes.

	attributes:
	attributes attribute

	attribute:
	__attribute__ (( attribute-list [opt] ))

	The return value is as for cp_parser_attribute_list. */

	static tree
	cp_parser_attributes_opt (cp_parser* parser)
	{
	tree attributes = NULL_TREE;

	while (true)
	{
	cp_token *token;
	tree attribute_list;

	/* Peek at the next token. */
	token = cp_lexer_peek_token (parser->lexer);
	/* If it's not `__attribute__', then we're done. */
	if (token->keyword != RID_ATTRIBUTE)
	break;

	/* Consume the `__attribute__' keyword. */
	cp_lexer_consume_token (parser->lexer);
	/* Look for the two `(' tokens. */
	cp_parser_require (parser, CPP_OPEN_PAREN, "`('");
	cp_parser_require (parser, CPP_OPEN_PAREN, "`('");

	/* Peek at the next token. */
	token = cp_lexer_peek_token (parser->lexer);
	if (token->type != CPP_CLOSE_PAREN)
	/* Parse the attribute-list. */
	attribute_list = cp_parser_attribute_list (parser);
	else
	/* If the next token is a `)', then there is no attribute
	list. */
	attribute_list = NULL;

	/* Look for the two `)' tokens. */
	cp_parser_require (parser, CPP_CLOSE_PAREN, "`)'");
	cp_parser_require (parser, CPP_CLOSE_PAREN, "`)'");

	/* Add these new attributes to the list. */
	attributes = chainon (attributes, attribute_list);
	}

	return attributes;
	}

	/* Parse an attribute-list.

	attribute-list:
	attribute
	attribute-list , attribute

	attribute:
	identifier
	identifier ( identifier )
	identifier ( identifier , expression-list )
	identifier ( expression-list )

	Returns a TREE_LIST, or NULL_TREE on error. Each node corresponds
	to an attribute. The TREE_PURPOSE of each node is the identifier
	indicating which attribute is in use. The TREE_VALUE represents
	the arguments, if any. */

	static tree
	cp_parser_attribute_list (cp_parser* parser)
	{
	tree attribute_list = NULL_TREE;
	bool save_translate_strings_p = parser->translate_strings_p;

	parser->translate_strings_p = false;
	while (true)
	{
	cp_token *token;
	tree identifier;
	tree attribute;

	/* Look for the identifier. We also allow keywords here; for
	example `__attribute__ ((const))' is legal. */
	token = cp_lexer_peek_token (parser->lexer);
	if (token->type == CPP_NAME
	\|\| token->type == CPP_KEYWORD)
	{
	tree arguments = NULL_TREE;

	/* Consume the token. */
	token = cp_lexer_consume_token (parser->lexer);

	/* Save away the identifier that indicates which attribute
	this is. */
	identifier = token->u.value;
	attribute = build_tree_list (identifier, NULL_TREE);

	/* Peek at the next token. */
	token = cp_lexer_peek_token (parser->lexer);
	/* If it's an `(', then parse the attribute arguments. */
	if (token->type == CPP_OPEN_PAREN)
	{
	arguments = cp_parser_parenthesized_expression_list
	(parser, true, /cast_p=/false,
	/non_constant_p=/NULL);
	/* Save the arguments away. */
	TREE_VALUE (attribute) = arguments;
	}

	if (arguments != error_mark_node)
	{
	/* Add this attribute to the list. */
	TREE_CHAIN (attribute) = attribute_list;
	attribute_list = attribute;
	}

	token = cp_lexer_peek_token (parser->lexer);
	}
	/* Now, look for more attributes. If the next token isn't a
	`,', we're done. */
	if (token->type != CPP_COMMA)
	break;

	/* Consume the comma and keep going. */
	cp_lexer_consume_token (parser->lexer);
	}
	parser->translate_strings_p = save_translate_strings_p;

	/* We built up the list in reverse order. */
	return nreverse (attribute_list);
	}

	/* Parse an optional `__extension__' keyword. Returns TRUE if it is
	present, and FALSE otherwise. *SAVED_PEDANTIC is set to the
	current value of the PEDANTIC flag, regardless of whether or not
	the `__extension__' keyword is present. The caller is responsible
	for restoring the value of the PEDANTIC flag. */

	static bool
	cp_parser_extension_opt (cp_parser* parser, int* saved_pedantic)
	{
	/* Save the old value of the PEDANTIC flag. */
	*saved_pedantic = pedantic;

	if (cp_lexer_next_token_is_keyword (parser->lexer, RID_EXTENSION))
	{
	/* Consume the `__extension__' token. */
	cp_lexer_consume_token (parser->lexer);
	/* We're not being pedantic while the `__extension__' keyword is
	in effect. */
	pedantic = 0;

	return true;
	}

	return false;
	}

	/* Parse a label declaration.

	label-declaration:
	__label__ label-declarator-seq ;

	label-declarator-seq:
	identifier , label-declarator-seq
	identifier */

	static void
	cp_parser_label_declaration (cp_parser* parser)
	{
	/* Look for the `__label__' keyword. */
	cp_parser_require_keyword (parser, RID_LABEL, "`__label__'");

	while (true)
	{
	tree identifier;

	/* Look for an identifier. */
	identifier = cp_parser_identifier (parser);
	/* If we failed, stop. */
	if (identifier == error_mark_node)
	break;
	/* Declare it as a label. */
	finish_label_decl (identifier);
	/* If the next token is a `;', stop. */
	if (cp_lexer_next_token_is (parser->lexer, CPP_SEMICOLON))
	break;
	/* Look for the `,' separating the label declarations. */
	cp_parser_require (parser, CPP_COMMA, "`,'");
	}

	/* Look for the final `;'. */
	cp_parser_require (parser, CPP_SEMICOLON, "`;'");
	}

	/* Support Functions */

	/* Looks up NAME in the current scope, as given by PARSER->SCOPE.
	NAME should have one of the representations used for an
	id-expression. If NAME is the ERROR_MARK_NODE, the ERROR_MARK_NODE
	is returned. If PARSER->SCOPE is a dependent type, then a
	SCOPE_REF is returned.

	If NAME is a TEMPLATE_ID_EXPR, then it will be immediately
	returned; the name was already resolved when the TEMPLATE_ID_EXPR
	was formed. Abstractly, such entities should not be passed to this
	function, because they do not need to be looked up, but it is
	simpler to check for this special case here, rather than at the
	call-sites.

	In cases not explicitly covered above, this function returns a
	DECL, OVERLOAD, or baselink representing the result of the lookup.
	If there was no entity with the indicated NAME, the ERROR_MARK_NODE
	is returned.

	If TAG_TYPE is not NONE_TYPE, it indicates an explicit type keyword
	(e.g., "struct") that was used. In that case bindings that do not
	refer to types are ignored.

	If IS_TEMPLATE is TRUE, bindings that do not refer to templates are
	ignored.

	If IS_NAMESPACE is TRUE, bindings that do not refer to namespaces
	are ignored.

	If CHECK_DEPENDENCY is TRUE, names are not looked up in dependent
	types.

	If AMBIGUOUS_DECLS is non-NULL, *AMBIGUOUS_DECLS is set to a
	TREE_LIST of candidates if name-lookup results in an ambiguity, and
	NULL_TREE otherwise. */

	static tree
	cp_parser_lookup_name (cp_parser *parser, tree name,
	enum tag_types tag_type,
	bool is_template,
	bool is_namespace,
	bool check_dependency,
	tree *ambiguous_decls)
	{
	int flags = 0;
	tree decl;
	tree object_type = parser->context->object_type;

	if (!cp_parser_uncommitted_to_tentative_parse_p (parser))
	flags \|= LOOKUP_COMPLAIN;

	/* Assume that the lookup will be unambiguous. */
	if (ambiguous_decls)
	*ambiguous_decls = NULL_TREE;

	/* Now that we have looked up the name, the OBJECT_TYPE (if any) is
	no longer valid. Note that if we are parsing tentatively, and
	the parse fails, OBJECT_TYPE will be automatically restored. */
	parser->context->object_type = NULL_TREE;

	if (name == error_mark_node)
	return error_mark_node;

	/* A template-id has already been resolved; there is no lookup to
	do. */
	if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
	return name;
	if (BASELINK_P (name))
	{
	gcc_assert (TREE_CODE (BASELINK_FUNCTIONS (name))
	== TEMPLATE_ID_EXPR);
	return name;
	}

	/* A BIT_NOT_EXPR is used to represent a destructor. By this point,
	it should already have been checked to make sure that the name
	used matches the type being destroyed. */
	if (TREE_CODE (name) == BIT_NOT_EXPR)
	{
	tree type;

	/* Figure out to which type this destructor applies. */
	if (parser->scope)
	type = parser->scope;
	else if (object_type)
	type = object_type;
	else
	type = current_class_type;
	/* If that's not a class type, there is no destructor. */
	if (!type \|\| !CLASS_TYPE_P (type))
	return error_mark_node;
	if (CLASSTYPE_LAZY_DESTRUCTOR (type))
	lazily_declare_fn (sfk_destructor, type);
	if (!CLASSTYPE_DESTRUCTORS (type))
	return error_mark_node;
	/* If it was a class type, return the destructor. */
	return CLASSTYPE_DESTRUCTORS (type);
	}

	/* By this point, the NAME should be an ordinary identifier. If
	the id-expression was a qualified name, the qualifying scope is
	stored in PARSER->SCOPE at this point. */
	gcc_assert (TREE_CODE (name) == IDENTIFIER_NODE);

	/* Perform the lookup. */
	if (parser->scope)
	{
	bool dependent_p;

	if (parser->scope == error_mark_node)
	return error_mark_node;

	/* If the SCOPE is dependent, the lookup must be deferred until
	the template is instantiated -- unless we are explicitly
	looking up names in uninstantiated templates. Even then, we
	cannot look up the name if the scope is not a class type; it
	might, for example, be a template type parameter. */
	dependent_p = (TYPE_P (parser->scope)
	&& !(parser->in_declarator_p
	&& currently_open_class (parser->scope))
	&& dependent_type_p (parser->scope));
	if ((check_dependency \|\| !CLASS_TYPE_P (parser->scope))
	&& dependent_p)
	{
	if (tag_type)
	{
	tree type;

	/* The resolution to Core Issue 180 says that `struct
	A::B' should be considered a type-name, even if `A'
	is dependent. */
	type = make_typename_type (parser->scope, name, tag_type,
	/complain=/tf_error);
	decl = TYPE_NAME (type);
	}
	else if (is_template
	&& (cp_parser_next_token_ends_template_argument_p (parser)
	\|\| cp_lexer_next_token_is (parser->lexer,
	CPP_CLOSE_PAREN)))
	decl = make_unbound_class_template (parser->scope,
	name, NULL_TREE,
	/complain=/tf_error);
	else
	decl = build_qualified_name (/type=/NULL_TREE,
	parser->scope, name,
	is_template);
	}
	else
	{
	tree pushed_scope = NULL_TREE;

	/* If PARSER->SCOPE is a dependent type, then it must be a
	class type, and we must not be checking dependencies;
	otherwise, we would have processed this lookup above. So
	that PARSER->SCOPE is not considered a dependent base by
	lookup_member, we must enter the scope here. */
	if (dependent_p)
	pushed_scope = push_scope (parser->scope);
	/* If the PARSER->SCOPE is a template specialization, it
	may be instantiated during name lookup. In that case,
	errors may be issued. Even if we rollback the current
	tentative parse, those errors are valid. */
	decl = lookup_qualified_name (parser->scope, name,
	tag_type != none_type,
	/complain=/true);
	if (pushed_scope)
	pop_scope (pushed_scope);
	}
	parser->qualifying_scope = parser->scope;
	parser->object_scope = NULL_TREE;
	}
	else if (object_type)
	{
	tree object_decl = NULL_TREE;
	/* Look up the name in the scope of the OBJECT_TYPE, unless the
	OBJECT_TYPE is not a class. */
	if (CLASS_TYPE_P (object_type))
	/* If the OBJECT_TYPE is a template specialization, it may
	be instantiated during name lookup. In that case, errors
	may be issued. Even if we rollback the current tentative
	parse, those errors are valid. */
	object_decl = lookup_member (object_type,
	name,
	/protect=/0,
	tag_type != none_type);
	/* Look it up in the enclosing context, too. */
	decl = lookup_name_real (name, tag_type != none_type,
	/nonclass=/0,
	/block_p=/true, is_namespace, flags);
	parser->object_scope = object_type;
	parser->qualifying_scope = NULL_TREE;
	if (object_decl)
	decl = object_decl;
	}
	else
	{
	decl = lookup_name_real (name, tag_type != none_type,
	/nonclass=/0,
	/block_p=/true, is_namespace, flags);
	parser->qualifying_scope = NULL_TREE;
	parser->object_scope = NULL_TREE;
	}

	/* If the lookup failed, let our caller know. */
	if (!decl \|\| decl == error_mark_node)
	return error_mark_node;

	/* If it's a TREE_LIST, the result of the lookup was ambiguous. */
	if (TREE_CODE (decl) == TREE_LIST)
	{
	if (ambiguous_decls)
	*ambiguous_decls = decl;
	/* The error message we have to print is too complicated for
	cp_parser_error, so we incorporate its actions directly. */
	if (!cp_parser_simulate_error (parser))
	{
	error ("reference to %qD is ambiguous", name);
	print_candidates (decl);
	}
	return error_mark_node;
	}

	gcc_assert (DECL_P (decl)
	\|\| TREE_CODE (decl) == OVERLOAD
	\|\| TREE_CODE (decl) == SCOPE_REF
	\|\| TREE_CODE (decl) == UNBOUND_CLASS_TEMPLATE
	\|\| BASELINK_P (decl));

	/* If we have resolved the name of a member declaration, check to
	see if the declaration is accessible. When the name resolves to
	set of overloaded functions, accessibility is checked when
	overload resolution is done.

	During an explicit instantiation, access is not checked at all,
	as per [temp.explicit]. */
	if (DECL_P (decl))
	check_accessibility_of_qualified_id (decl, object_type, parser->scope);

	return decl;
	}

	/* Like cp_parser_lookup_name, but for use in the typical case where
	CHECK_ACCESS is TRUE, IS_TYPE is FALSE, IS_TEMPLATE is FALSE,
	IS_NAMESPACE is FALSE, and CHECK_DEPENDENCY is TRUE. */

	static tree
	cp_parser_lookup_name_simple (cp_parser* parser, tree name)
	{
	return cp_parser_lookup_name (parser, name,
	none_type,
	/is_template=/false,
	/is_namespace=/false,
	/check_dependency=/true,
	/ambiguous_decls=/NULL);
	}

	/* If DECL is a TEMPLATE_DECL that can be treated like a TYPE_DECL in
	the current context, return the TYPE_DECL. If TAG_NAME_P is
	true, the DECL indicates the class being defined in a class-head,
	or declared in an elaborated-type-specifier.

	Otherwise, return DECL. */

	static tree
	cp_parser_maybe_treat_template_as_class (tree decl, bool tag_name_p)
	{
	/* If the TEMPLATE_DECL is being declared as part of a class-head,
	the translation from TEMPLATE_DECL to TYPE_DECL occurs:

	struct A {
	template <typename T> struct B;
	};

	template <typename T> struct A::B {};

	Similarly, in an elaborated-type-specifier:

	namespace N { struct X{}; }

	struct A {
	template <typename T> friend struct N::X;
	};

	However, if the DECL refers to a class type, and we are in
	the scope of the class, then the name lookup automatically
	finds the TYPE_DECL created by build_self_reference rather
	than a TEMPLATE_DECL. For example, in:

	template <class T> struct S {
	S s;
	};

	there is no need to handle such case. */

	if (DECL_CLASS_TEMPLATE_P (decl) && tag_name_p)
	return DECL_TEMPLATE_RESULT (decl);

	return decl;
	}

	/* If too many, or too few, template-parameter lists apply to the
	declarator, issue an error message. Returns TRUE if all went well,
	and FALSE otherwise. */

	static bool
	cp_parser_check_declarator_template_parameters (cp_parser* parser,
	cp_declarator *declarator)
	{
	unsigned num_templates;

	/* We haven't seen any classes that involve template parameters yet. */
	num_templates = 0;

	switch (declarator->kind)
	{
	case cdk_id:
	if (declarator->u.id.qualifying_scope)
	{
	tree scope;
	tree member;

	scope = declarator->u.id.qualifying_scope;
	member = declarator->u.id.unqualified_name;

	while (scope && CLASS_TYPE_P (scope))
	{
	/* You're supposed to have one `template <...>'
	for every template class, but you don't need one
	for a full specialization. For example:

	template <class T> struct S{};
	template <> struct S<int> { void f(); };
	void S<int>::f () {}

	is correct; there shouldn't be a `template <>' for
	the definition of `S<int>::f'. */
	if (!CLASSTYPE_TEMPLATE_INFO (scope))
	/* If SCOPE does not have template information of any
	kind, then it is not a template, nor is it nested
	within a template. */
	break;
	if (explicit_class_specialization_p (scope))
	break;
	if (PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (scope)))
	++num_templates;

	scope = TYPE_CONTEXT (scope);
	}
	}
	else if (TREE_CODE (declarator->u.id.unqualified_name)
	== TEMPLATE_ID_EXPR)
	/* If the DECLARATOR has the form `X<y>' then it uses one
	additional level of template parameters. */
	++num_templates;

	return cp_parser_check_template_parameters (parser,
	num_templates);

	case cdk_function:
	case cdk_array:
	case cdk_pointer:
	case cdk_reference:
	case cdk_ptrmem:
	return (cp_parser_check_declarator_template_parameters
	(parser, declarator->declarator));

	case cdk_error:
	return true;

	default:
	gcc_unreachable ();
	}
	return false;
	}

	/* NUM_TEMPLATES were used in the current declaration. If that is
	invalid, return FALSE and issue an error messages. Otherwise,
	return TRUE. */

	static bool
	cp_parser_check_template_parameters (cp_parser* parser,
	unsigned num_templates)
	{
	/* If there are more template classes than parameter lists, we have
	something like:

	template <class T> void S<T>::R<T>::f (); */
	if (parser->num_template_parameter_lists < num_templates)
	{
	error ("too few template-parameter-lists");
	return false;
	}
	/* If there are the same number of template classes and parameter
	lists, that's OK. */
	if (parser->num_template_parameter_lists == num_templates)
	return true;
	/* If there are more, but only one more, then we are referring to a
	member template. That's OK too. */
	if (parser->num_template_parameter_lists == num_templates + 1)
	return true;
	/* Otherwise, there are too many template parameter lists. We have
	something like:

	template <class T> template <class U> void S::f(); */
	error ("too many template-parameter-lists");
	return false;
	}

	/* Parse an optional `::' token indicating that the following name is
	from the global namespace. If so, PARSER->SCOPE is set to the
	GLOBAL_NAMESPACE. Otherwise, PARSER->SCOPE is set to NULL_TREE,
	unless CURRENT_SCOPE_VALID_P is TRUE, in which case it is left alone.
	Returns the new value of PARSER->SCOPE, if the `::' token is
	present, and NULL_TREE otherwise. */

	static tree
	cp_parser_global_scope_opt (cp_parser* parser, bool current_scope_valid_p)
	{
	cp_token *token;

	/* Peek at the next token. */
	token = cp_lexer_peek_token (parser->lexer);
	/* If we're looking at a `::' token then we're starting from the
	global namespace, not our current location. */
	if (token->type == CPP_SCOPE)
	{
	/* Consume the `::' token. */
	cp_lexer_consume_token (parser->lexer);
	/* Set the SCOPE so that we know where to start the lookup. */
	parser->scope = global_namespace;
	parser->qualifying_scope = global_namespace;
	parser->object_scope = NULL_TREE;

	return parser->scope;
	}
	else if (!current_scope_valid_p)
	{
	parser->scope = NULL_TREE;
	parser->qualifying_scope = NULL_TREE;
	parser->object_scope = NULL_TREE;
	}

	return NULL_TREE;
	}

	/* Returns TRUE if the upcoming token sequence is the start of a
	constructor declarator. If FRIEND_P is true, the declarator is
	preceded by the `friend' specifier. */

	static bool
	cp_parser_constructor_declarator_p (cp_parser *parser, bool friend_p)
	{
	bool constructor_p;
	tree type_decl = NULL_TREE;
	bool nested_name_p;
	cp_token *next_token;

	/* The common case is that this is not a constructor declarator, so
	try to avoid doing lots of work if at all possible. It's not
	valid declare a constructor at function scope. */
	if (parser->in_function_body)
	return false;
	/* And only certain tokens can begin a constructor declarator. */
	next_token = cp_lexer_peek_token (parser->lexer);
	if (next_token->type != CPP_NAME
	&& next_token->type != CPP_SCOPE
	&& next_token->type != CPP_NESTED_NAME_SPECIFIER
	&& next_token->type != CPP_TEMPLATE_ID)
	return false;

	/* Parse tentatively; we are going to roll back all of the tokens
	consumed here. */
	cp_parser_parse_tentatively (parser);
	/* Assume that we are looking at a constructor declarator. */
	constructor_p = true;

	/* Look for the optional `::' operator. */
	cp_parser_global_scope_opt (parser,
	/current_scope_valid_p=/false);
	/* Look for the nested-name-specifier. */
	nested_name_p
	= (cp_parser_nested_name_specifier_opt (parser,
	/typename_keyword_p=/false,
	/check_dependency_p=/false,
	/type_p=/false,
	/is_declaration=/false)
	!= NULL_TREE);
	/* Outside of a class-specifier, there must be a
	nested-name-specifier. */
	if (!nested_name_p &&
	(!at_class_scope_p () \|\| !TYPE_BEING_DEFINED (current_class_type)
	\|\| friend_p))
	constructor_p = false;
	/* If we still think that this might be a constructor-declarator,
	look for a class-name. */
	if (constructor_p)
	{
	/* If we have:

	template <typename T> struct S { S(); };
	template <typename T> S<T>::S ();

	we must recognize that the nested `S' names a class.
	Similarly, for:

	template <typename T> S<T>::S<T> ();

	we must recognize that the nested `S' names a template. */
	type_decl = cp_parser_class_name (parser,
	/typename_keyword_p=/false,
	/template_keyword_p=/false,
	none_type,
	/check_dependency_p=/false,
	/class_head_p=/false,
	/is_declaration=/false);
	/* If there was no class-name, then this is not a constructor. */
	constructor_p = !cp_parser_error_occurred (parser);
	}

	/* If we're still considering a constructor, we have to see a `(',
	to begin the parameter-declaration-clause, followed by either a
	`)', an `...', or a decl-specifier. We need to check for a
	type-specifier to avoid being fooled into thinking that:

	S::S (f) (int);

	is a constructor. (It is actually a function named `f' that
	takes one parameter (of type `int') and returns a value of type
	`S::S'. */
	if (constructor_p
	&& cp_parser_require (parser, CPP_OPEN_PAREN, "`('"))
	{
	if (cp_lexer_next_token_is_not (parser->lexer, CPP_CLOSE_PAREN)
	&& cp_lexer_next_token_is_not (parser->lexer, CPP_ELLIPSIS)
	/* A parameter declaration begins with a decl-specifier,
	which is either the "attribute" keyword, a storage class
	specifier, or (usually) a type-specifier. */
	&& !cp_lexer_next_token_is_decl_specifier_keyword (parser->lexer))
	{
	tree type;
	tree pushed_scope = NULL_TREE;
	unsigned saved_num_template_parameter_lists;

	/* Names appearing in the type-specifier should be looked up
	in the scope of the class. */
	if (current_class_type)
	type = NULL_TREE;
	else
	{
	type = TREE_TYPE (type_decl);
	if (TREE_CODE (type) == TYPENAME_TYPE)
	{
	type = resolve_typename_type (type,
	/only_current_p=/false);
	if (type == error_mark_node)
	{
	cp_parser_abort_tentative_parse (parser);
	return false;
	}
	}
	pushed_scope = push_scope (type);
	}

	/* Inside the constructor parameter list, surrounding
	template-parameter-lists do not apply. */
	saved_num_template_parameter_lists
	= parser->num_template_parameter_lists;
	parser->num_template_parameter_lists = 0;

	/* Look for the type-specifier. */
	cp_parser_type_specifier (parser,
	CP_PARSER_FLAGS_NONE,
	/decl_specs=/NULL,
	/is_declarator=/true,
	/declares_class_or_enum=/NULL,
	/is_cv_qualifier=/NULL);

	parser->num_template_parameter_lists
	= saved_num_template_parameter_lists;

	/* Leave the scope of the class. */
	if (pushed_scope)
	pop_scope (pushed_scope);

	constructor_p = !cp_parser_error_occurred (parser);
	}
	}
	else
	constructor_p = false;
	/* We did not really want to consume any tokens. */
	cp_parser_abort_tentative_parse (parser);

	return constructor_p;
	}

	/* Parse the definition of the function given by the DECL_SPECIFIERS,
	ATTRIBUTES, and DECLARATOR. The access checks have been deferred;
	they must be performed once we are in the scope of the function.

	Returns the function defined. */

	static tree
	cp_parser_function_definition_from_specifiers_and_declarator
	(cp_parser* parser,
	cp_decl_specifier_seq *decl_specifiers,
	tree attributes,
	const cp_declarator *declarator)
	{
	tree fn;
	bool success_p;

	/* Begin the function-definition. */
	success_p = start_function (decl_specifiers, declarator, attributes);

	/* The things we're about to see are not directly qualified by any
	template headers we've seen thus far. */
	reset_specialization ();

	/* If there were names looked up in the decl-specifier-seq that we
	did not check, check them now. We must wait until we are in the
	scope of the function to perform the checks, since the function
	might be a friend. */
	perform_deferred_access_checks ();

	if (!success_p)
	{
	/* Skip the entire function. */
	cp_parser_skip_to_end_of_block_or_statement (parser);
	fn = error_mark_node;
	}
	else if (DECL_INITIAL (current_function_decl) != error_mark_node)
	{
	/* Seen already, skip it. An error message has already been output. */
	cp_parser_skip_to_end_of_block_or_statement (parser);
	fn = current_function_decl;
	current_function_decl = NULL_TREE;
	/* If this is a function from a class, pop the nested class. */
	if (current_class_name)
	pop_nested_class ();
	}
	else
	fn = cp_parser_function_definition_after_declarator (parser,
	/inline_p=/false);

	return fn;
	}

	/* Parse the part of a function-definition that follows the
	declarator. INLINE_P is TRUE iff this function is an inline
	function defined with a class-specifier.

	Returns the function defined. */

	static tree
	cp_parser_function_definition_after_declarator (cp_parser* parser,
	bool inline_p)
	{
	tree fn;
	bool ctor_initializer_p = false;
	bool saved_in_unbraced_linkage_specification_p;
	bool saved_in_function_body;
	unsigned saved_num_template_parameter_lists;

	saved_in_function_body = parser->in_function_body;
	parser->in_function_body = true;
	/* If the next token is `return', then the code may be trying to
	make use of the "named return value" extension that G++ used to
	support. */
	if (cp_lexer_next_token_is_keyword (parser->lexer, RID_RETURN))
	{
	/* Consume the `return' keyword. */
	cp_lexer_consume_token (parser->lexer);
	/* Look for the identifier that indicates what value is to be
	returned. */
	cp_parser_identifier (parser);
	/* Issue an error message. */
	error ("named return values are no longer supported");
	/* Skip tokens until we reach the start of the function body. */
	while (true)
	{
	cp_token *token = cp_lexer_peek_token (parser->lexer);
	if (token->type == CPP_OPEN_BRACE
	\|\| token->type == CPP_EOF
	\|\| token->type == CPP_PRAGMA_EOL)
	break;
	cp_lexer_consume_token (parser->lexer);
	}
	}
	/* The `extern' in `extern "C" void f () { ... }' does not apply to
	anything declared inside `f'. */
	saved_in_unbraced_linkage_specification_p
	= parser->in_unbraced_linkage_specification_p;
	parser->in_unbraced_linkage_specification_p = false;
	/* Inside the function, surrounding template-parameter-lists do not
	apply. */
	saved_num_template_parameter_lists
	= parser->num_template_parameter_lists;
	parser->num_template_parameter_lists = 0;
	/* If the next token is `try', then we are looking at a
	function-try-block. */
	if (cp_lexer_next_token_is_keyword (parser->lexer, RID_TRY))
	ctor_initializer_p = cp_parser_function_try_block (parser);
	/* A function-try-block includes the function-body, so we only do
	this next part if we're not processing a function-try-block. */
	else
	ctor_initializer_p
	= cp_parser_ctor_initializer_opt_and_function_body (parser);

	/* Finish the function. */
	fn = finish_function ((ctor_initializer_p ? 1 : 0) \|
	(inline_p ? 2 : 0));
	/* Generate code for it, if necessary. */
	expand_or_defer_fn (fn);
	/* Restore the saved values. */
	parser->in_unbraced_linkage_specification_p
	= saved_in_unbraced_linkage_specification_p;
	parser->num_template_parameter_lists
	= saved_num_template_parameter_lists;
	parser->in_function_body = saved_in_function_body;

	return fn;
	}

	/* Parse a template-declaration, assuming that the `export' (and
	`extern') keywords, if present, has already been scanned. MEMBER_P
	is as for cp_parser_template_declaration. */

	static void
	cp_parser_template_declaration_after_export (cp_parser* parser, bool member_p)
	{
	tree decl = NULL_TREE;
	VEC (deferred_access_check,gc) *checks;
	tree parameter_list;
	bool friend_p = false;
	bool need_lang_pop;

	/* Look for the `template' keyword. */
	if (!cp_parser_require_keyword (parser, RID_TEMPLATE, "`template'"))
	return;

	/* And the `<'. */
	if (!cp_parser_require (parser, CPP_LESS, "`<'"))
	return;
	if (at_class_scope_p () && current_function_decl)
	{
	/* 14.5.2.2 [temp.mem]

	A local class shall not have member templates. */
	error ("invalid declaration of member template in local class");
	cp_parser_skip_to_end_of_block_or_statement (parser);
	return;
	}
	/* [temp]

	A template ... shall not have C linkage. */
	if (current_lang_name == lang_name_c)
	{
	error ("template with C linkage");
	/* Give it C++ linkage to avoid confusing other parts of the
	front end. */
	push_lang_context (lang_name_cplusplus);
	need_lang_pop = true;
	}
	else
	need_lang_pop = false;

	/* We cannot perform access checks on the template parameter
	declarations until we know what is being declared, just as we
	cannot check the decl-specifier list. */
	push_deferring_access_checks (dk_deferred);

	/* If the next token is `>', then we have an invalid
	specialization. Rather than complain about an invalid template
	parameter, issue an error message here. */
	if (cp_lexer_next_token_is (parser->lexer, CPP_GREATER))
	{
	cp_parser_error (parser, "invalid explicit specialization");
	begin_specialization ();
	parameter_list = NULL_TREE;
	}
	else
	/* Parse the template parameters. */
	parameter_list = cp_parser_template_parameter_list (parser);

	/* Get the deferred access checks from the parameter list. These
	will be checked once we know what is being declared, as for a
	member template the checks must be performed in the scope of the
	class containing the member. */
	checks = get_deferred_access_checks ();

	/* Look for the `>'. */
	cp_parser_skip_to_end_of_template_parameter_list (parser);
	/* We just processed one more parameter list. */
	++parser->num_template_parameter_lists;
	/* If the next token is `template', there are more template
	parameters. */
	if (cp_lexer_next_token_is_keyword (parser->lexer,
	RID_TEMPLATE))
	cp_parser_template_declaration_after_export (parser, member_p);
	else
	{
	/* There are no access checks when parsing a template, as we do not
	know if a specialization will be a friend. */
	push_deferring_access_checks (dk_no_check);
	decl = cp_parser_single_declaration (parser,
	checks,
	member_p,
	&friend_p);
	pop_deferring_access_checks ();

	/* If this is a member template declaration, let the front
	end know. */
	if (member_p && !friend_p && decl)
	{
	if (TREE_CODE (decl) == TYPE_DECL)
	cp_parser_check_access_in_redeclaration (decl);

	decl = finish_member_template_decl (decl);
	}
	else if (friend_p && decl && TREE_CODE (decl) == TYPE_DECL)
	make_friend_class (current_class_type, TREE_TYPE (decl),
	/complain=/true);
	}
	/* We are done with the current parameter list. */
	--parser->num_template_parameter_lists;

	pop_deferring_access_checks ();

	/* Finish up. */
	finish_template_decl (parameter_list);

	/* Register member declarations. */
	if (member_p && !friend_p && decl && !DECL_CLASS_TEMPLATE_P (decl))
	finish_member_declaration (decl);
	/* For the erroneous case of a template with C linkage, we pushed an
	implicit C++ linkage scope; exit that scope now. */
	if (need_lang_pop)
	pop_lang_context ();
	/* If DECL is a function template, we must return to parse it later.
	(Even though there is no definition, there might be default
	arguments that need handling.) */
	if (member_p && decl
	&& (TREE_CODE (decl) == FUNCTION_DECL
	\|\| DECL_FUNCTION_TEMPLATE_P (decl)))
	TREE_VALUE (parser->unparsed_functions_queues)
	= tree_cons (NULL_TREE, decl,
	TREE_VALUE (parser->unparsed_functions_queues));
	}

	/* Perform the deferred access checks from a template-parameter-list.
	CHECKS is a TREE_LIST of access checks, as returned by
	get_deferred_access_checks. */

	static void
	cp_parser_perform_template_parameter_access_checks (VEC (deferred_access_check,gc)* checks)
	{
	++processing_template_parmlist;
	perform_access_checks (checks);
	--processing_template_parmlist;
	}

	/* Parse a `decl-specifier-seq [opt] init-declarator [opt] ;' or
	`function-definition' sequence. MEMBER_P is true, this declaration
	appears in a class scope.

	Returns the DECL for the declared entity. If FRIEND_P is non-NULL,
	FRIEND_P is set to TRUE iff the declaration is a friend. /

	static tree
	cp_parser_single_declaration (cp_parser* parser,
	VEC (deferred_access_check,gc)* checks,
	bool member_p,
	bool* friend_p)
	{
	int declares_class_or_enum;
	tree decl = NULL_TREE;
	cp_decl_specifier_seq decl_specifiers;
	bool function_definition_p = false;

	/* This function is only used when processing a template
	declaration. */
	gcc_assert (innermost_scope_kind () == sk_template_parms
	\|\| innermost_scope_kind () == sk_template_spec);

	/* Defer access checks until we know what is being declared. */
	push_deferring_access_checks (dk_deferred);

	/* Try the `decl-specifier-seq [opt] init-declarator [opt]'
	alternative. */
	cp_parser_decl_specifier_seq (parser,
	CP_PARSER_FLAGS_OPTIONAL,
	&decl_specifiers,
	&declares_class_or_enum);
	if (friend_p)
	*friend_p = cp_parser_friend_p (&decl_specifiers);

	/* There are no template typedefs. */
	if (decl_specifiers.specs[(int) ds_typedef])
	{
	error ("template declaration of %qs", "typedef");
	decl = error_mark_node;
	}

	/* Gather up the access checks that occurred the
	decl-specifier-seq. */
	stop_deferring_access_checks ();

	/* Check for the declaration of a template class. */
	if (declares_class_or_enum)
	{
	if (cp_parser_declares_only_class_p (parser))
	{
	decl = shadow_tag (&decl_specifiers);

	/* In this case:

	struct C {
	friend template <typename T> struct A<T>::B;
	};

	A<T>::B will be represented by a TYPENAME_TYPE, and
	therefore not recognized by shadow_tag. */
	if (friend_p && *friend_p
	&& !decl
	&& decl_specifiers.type
	&& TYPE_P (decl_specifiers.type))
	decl = decl_specifiers.type;

	if (decl && decl != error_mark_node)
	decl = TYPE_NAME (decl);
	else
	decl = error_mark_node;

	/* Perform access checks for template parameters. */
	cp_parser_perform_template_parameter_access_checks (checks);
	}
	}
	/* If it's not a template class, try for a template function. If
	the next token is a `;', then this declaration does not declare
	anything. But, if there were errors in the decl-specifiers, then
	the error might well have come from an attempted class-specifier.
	In that case, there's no need to warn about a missing declarator. */
	if (!decl
	&& (cp_lexer_next_token_is_not (parser->lexer, CPP_SEMICOLON)
	\|\| decl_specifiers.type != error_mark_node))
	decl = cp_parser_init_declarator (parser,
	&decl_specifiers,
	checks,
	/function_definition_allowed_p=/true,
	member_p,
	declares_class_or_enum,
	&function_definition_p);

	pop_deferring_access_checks ();

	/* Clear any current qualification; whatever comes next is the start
	of something new. */
	parser->scope = NULL_TREE;
	parser->qualifying_scope = NULL_TREE;
	parser->object_scope = NULL_TREE;
	/* Look for a trailing `;' after the declaration. */
	if (!function_definition_p
	&& (decl == error_mark_node
	\|\| !cp_parser_require (parser, CPP_SEMICOLON, "`;'")))
	cp_parser_skip_to_end_of_block_or_statement (parser);

	return decl;
	}

	/* Parse a cast-expression that is not the operand of a unary "&". */

	static tree
	cp_parser_simple_cast_expression (cp_parser *parser)
	{
	return cp_parser_cast_expression (parser, /address_p=/false,
	/cast_p=/false);
	}

	/* Parse a functional cast to TYPE. Returns an expression
	representing the cast. */

	static tree
	cp_parser_functional_cast (cp_parser* parser, tree type)
	{
	tree expression_list;
	tree cast;

	expression_list
	= cp_parser_parenthesized_expression_list (parser, false,
	/cast_p=/true,
	/non_constant_p=/NULL);

	cast = build_functional_cast (type, expression_list);
	/* [expr.const]/1: In an integral constant expression "only type
	conversions to integral or enumeration type can be used". */
	if (TREE_CODE (type) == TYPE_DECL)
	type = TREE_TYPE (type);
	if (cast != error_mark_node
	&& !cast_valid_in_integral_constant_expression_p (type)
	&& (cp_parser_non_integral_constant_expression
	(parser, "a call to a constructor")))
	return error_mark_node;
	return cast;
	}

	/* Save the tokens that make up the body of a member function defined
	in a class-specifier. The DECL_SPECIFIERS and DECLARATOR have
	already been parsed. The ATTRIBUTES are any GNU "__attribute__"
	specifiers applied to the declaration. Returns the FUNCTION_DECL
	for the member function. */

	static tree
	cp_parser_save_member_function_body (cp_parser* parser,
	cp_decl_specifier_seq *decl_specifiers,
	cp_declarator *declarator,
	tree attributes)
	{
	cp_token *first;
	cp_token *last;
	tree fn;

	/* Create the function-declaration. */
	fn = start_method (decl_specifiers, declarator, attributes);
	/* If something went badly wrong, bail out now. */
	if (fn == error_mark_node)
	{
	/* If there's a function-body, skip it. */
	if (cp_parser_token_starts_function_definition_p
	(cp_lexer_peek_token (parser->lexer)))
	cp_parser_skip_to_end_of_block_or_statement (parser);
	return error_mark_node;
	}

	/* Remember it, if there default args to post process. */
	cp_parser_save_default_args (parser, fn);

	/* Save away the tokens that make up the body of the
	function. */
	first = parser->lexer->next_token;
	cp_parser_cache_group (parser, CPP_CLOSE_BRACE, /depth=/0);
	/* Handle function try blocks. */
	while (cp_lexer_next_token_is_keyword (parser->lexer, RID_CATCH))
	cp_parser_cache_group (parser, CPP_CLOSE_BRACE, /depth=/0);
	last = parser->lexer->next_token;

	/* Save away the inline definition; we will process it when the
	class is complete. */
	DECL_PENDING_INLINE_INFO (fn) = cp_token_cache_new (first, last);
	DECL_PENDING_INLINE_P (fn) = 1;

	/* We need to know that this was defined in the class, so that
	friend templates are handled correctly. */
	DECL_INITIALIZED_IN_CLASS_P (fn) = 1;

	/* We're done with the inline definition. */
	finish_method (fn);

	/* Add FN to the queue of functions to be parsed later. */
	TREE_VALUE (parser->unparsed_functions_queues)
	= tree_cons (NULL_TREE, fn,
	TREE_VALUE (parser->unparsed_functions_queues));

	return fn;
	}

	/* Parse a template-argument-list, as well as the trailing ">" (but
	not the opening ">"). See cp_parser_template_argument_list for the
	return value. */

	static tree
	cp_parser_enclosed_template_argument_list (cp_parser* parser)
	{
	tree arguments;
	tree saved_scope;
	tree saved_qualifying_scope;
	tree saved_object_scope;
	bool saved_greater_than_is_operator_p;
	bool saved_skip_evaluation;

	/* [temp.names]

	When parsing a template-id, the first non-nested `>' is taken as
	the end of the template-argument-list rather than a greater-than
	operator. */
	saved_greater_than_is_operator_p
	= parser->greater_than_is_operator_p;
	parser->greater_than_is_operator_p = false;
	/* Parsing the argument list may modify SCOPE, so we save it
	here. */
	saved_scope = parser->scope;
	saved_qualifying_scope = parser->qualifying_scope;
	saved_object_scope = parser->object_scope;
	/* We need to evaluate the template arguments, even though this
	template-id may be nested within a "sizeof". */
	saved_skip_evaluation = skip_evaluation;
	skip_evaluation = false;
	/* Parse the template-argument-list itself. */
	if (cp_lexer_next_token_is (parser->lexer, CPP_GREATER))
	arguments = NULL_TREE;
	else
	arguments = cp_parser_template_argument_list (parser);
	/* Look for the `>' that ends the template-argument-list. If we find
	a '>>' instead, it's probably just a typo. */
	if (cp_lexer_next_token_is (parser->lexer, CPP_RSHIFT))
	{
	if (!saved_greater_than_is_operator_p)
	{
	/* If we're in a nested template argument list, the '>>' has
	to be a typo for '> >'. We emit the error message, but we
	continue parsing and we push a '>' as next token, so that
	the argument list will be parsed correctly. Note that the
	global source location is still on the token before the
	'>>', so we need to say explicitly where we want it. */
	cp_token *token = cp_lexer_peek_token (parser->lexer);
	error ("%H%<>>%> should be %<> >%> "
	"within a nested template argument list",
	&token->location);

	/* ??? Proper recovery should terminate two levels of
	template argument list here. */
	token->type = CPP_GREATER;
	}
	else
	{
	/* If this is not a nested template argument list, the '>>'
	is a typo for '>'. Emit an error message and continue.
	Same deal about the token location, but here we can get it
	right by consuming the '>>' before issuing the diagnostic. */
	cp_lexer_consume_token (parser->lexer);
	error ("spurious %<>>%>, use %<>%> to terminate "
	"a template argument list");
	}
	}
	else
	cp_parser_skip_to_end_of_template_parameter_list (parser);
	/* The `>' token might be a greater-than operator again now. */
	parser->greater_than_is_operator_p
	= saved_greater_than_is_operator_p;
	/* Restore the SAVED_SCOPE. */
	parser->scope = saved_scope;
	parser->qualifying_scope = saved_qualifying_scope;
	parser->object_scope = saved_object_scope;
	skip_evaluation = saved_skip_evaluation;

	return arguments;
	}

	/* MEMBER_FUNCTION is a member function, or a friend. If default
	arguments, or the body of the function have not yet been parsed,
	parse them now. */

	static void
	cp_parser_late_parsing_for_member (cp_parser* parser, tree member_function)
	{
	/* If this member is a template, get the underlying
	FUNCTION_DECL. */
	if (DECL_FUNCTION_TEMPLATE_P (member_function))
	member_function = DECL_TEMPLATE_RESULT (member_function);

	/* There should not be any class definitions in progress at this
	point; the bodies of members are only parsed outside of all class
	definitions. */
	gcc_assert (parser->num_classes_being_defined == 0);
	/* While we're parsing the member functions we might encounter more
	classes. We want to handle them right away, but we don't want
	them getting mixed up with functions that are currently in the
	queue. */
	parser->unparsed_functions_queues
	= tree_cons (NULL_TREE, NULL_TREE, parser->unparsed_functions_queues);

	/* Make sure that any template parameters are in scope. */
	maybe_begin_member_template_processing (member_function);

	/* If the body of the function has not yet been parsed, parse it
	now. */
	if (DECL_PENDING_INLINE_P (member_function))
	{
	tree function_scope;
	cp_token_cache *tokens;

	/* The function is no longer pending; we are processing it. */
	tokens = DECL_PENDING_INLINE_INFO (member_function);
	DECL_PENDING_INLINE_INFO (member_function) = NULL;
	DECL_PENDING_INLINE_P (member_function) = 0;

	/* If this is a local class, enter the scope of the containing
	function. */
	function_scope = current_function_decl;
	if (function_scope)
	push_function_context_to (function_scope);


	/* Push the body of the function onto the lexer stack. */
	cp_parser_push_lexer_for_tokens (parser, tokens);

	/* Let the front end know that we going to be defining this
	function. */
	start_preparsed_function (member_function, NULL_TREE,
	SF_PRE_PARSED \| SF_INCLASS_INLINE);

	/* Don't do access checking if it is a templated function. */
	if (processing_template_decl)
	push_deferring_access_checks (dk_no_check);

	/* Now, parse the body of the function. */
	cp_parser_function_definition_after_declarator (parser,
	/inline_p=/true);

	if (processing_template_decl)
	pop_deferring_access_checks ();

	/* Leave the scope of the containing function. */
	if (function_scope)
	pop_function_context_from (function_scope);
	cp_parser_pop_lexer (parser);
	}

	/* Remove any template parameters from the symbol table. */
	maybe_end_member_template_processing ();

	/* Restore the queue. */
	parser->unparsed_functions_queues
	= TREE_CHAIN (parser->unparsed_functions_queues);
	}

	/* If DECL contains any default args, remember it on the unparsed
	functions queue. */

	static void
	cp_parser_save_default_args (cp_parser* parser, tree decl)
	{
	tree probe;

	for (probe = TYPE_ARG_TYPES (TREE_TYPE (decl));
	probe;
	probe = TREE_CHAIN (probe))
	if (TREE_PURPOSE (probe))
	{
	TREE_PURPOSE (parser->unparsed_functions_queues)
	= tree_cons (current_class_type, decl,
	TREE_PURPOSE (parser->unparsed_functions_queues));
	break;
	}
	}

	/* FN is a FUNCTION_DECL which may contains a parameter with an
	unparsed DEFAULT_ARG. Parse the default args now. This function
	assumes that the current scope is the scope in which the default
	argument should be processed. */

	static void
	cp_parser_late_parsing_default_args (cp_parser *parser, tree fn)
	{
	bool saved_local_variables_forbidden_p;
	tree parm;

	/* While we're parsing the default args, we might (due to the
	statement expression extension) encounter more classes. We want
	to handle them right away, but we don't want them getting mixed
	up with default args that are currently in the queue. */
	parser->unparsed_functions_queues
	= tree_cons (NULL_TREE, NULL_TREE, parser->unparsed_functions_queues);

	/* Local variable names (and the `this' keyword) may not appear
	in a default argument. */
	saved_local_variables_forbidden_p = parser->local_variables_forbidden_p;
	parser->local_variables_forbidden_p = true;

	for (parm = TYPE_ARG_TYPES (TREE_TYPE (fn));
	parm;
	parm = TREE_CHAIN (parm))
	{
	cp_token_cache *tokens;
	tree default_arg = TREE_PURPOSE (parm);
	tree parsed_arg;
	VEC(tree,gc) *insts;
	tree copy;
	unsigned ix;

	if (!default_arg)
	continue;

	if (TREE_CODE (default_arg) != DEFAULT_ARG)
	/* This can happen for a friend declaration for a function
	already declared with default arguments. */
	continue;

	/* Push the saved tokens for the default argument onto the parser's
	lexer stack. */
	tokens = DEFARG_TOKENS (default_arg);
	cp_parser_push_lexer_for_tokens (parser, tokens);

	/* Parse the assignment-expression. */
	parsed_arg = cp_parser_assignment_expression (parser, /cast_p=/false);

	if (!processing_template_decl)
	parsed_arg = check_default_argument (TREE_VALUE (parm), parsed_arg);

	TREE_PURPOSE (parm) = parsed_arg;

	/* Update any instantiations we've already created. */
	for (insts = DEFARG_INSTANTIATIONS (default_arg), ix = 0;
	VEC_iterate (tree, insts, ix, copy); ix++)
	TREE_PURPOSE (copy) = parsed_arg;

	/* If the token stream has not been completely used up, then
	there was extra junk after the end of the default
	argument. */
	if (!cp_lexer_next_token_is (parser->lexer, CPP_EOF))
	cp_parser_error (parser, "expected %<,%>");

	/* Revert to the main lexer. */
	cp_parser_pop_lexer (parser);
	}

	/* Make sure no default arg is missing. */
	check_default_args (fn);

	/* Restore the state of local_variables_forbidden_p. */
	parser->local_variables_forbidden_p = saved_local_variables_forbidden_p;

	/* Restore the queue. */
	parser->unparsed_functions_queues
	= TREE_CHAIN (parser->unparsed_functions_queues);
	}

	/* Parse the operand of `sizeof' (or a similar operator). Returns
	either a TYPE or an expression, depending on the form of the
	input. The KEYWORD indicates which kind of expression we have
	encountered. */

	static tree
	cp_parser_sizeof_operand (cp_parser* parser, enum rid keyword)
	{
	static const char *format;
	tree expr = NULL_TREE;
	const char *saved_message;
	bool saved_integral_constant_expression_p;
	bool saved_non_integral_constant_expression_p;

	/* Initialize FORMAT the first time we get here. */
	if (!format)
	format = "types may not be defined in '%s' expressions";

	/* Types cannot be defined in a `sizeof' expression. Save away the
	old message. */
	saved_message = parser->type_definition_forbidden_message;
	/* And create the new one. */
	parser->type_definition_forbidden_message
	= XNEWVEC (const char, strlen (format)
	+ strlen (IDENTIFIER_POINTER (ridpointers[keyword]))
	+ 1 /* `\0' */);
	sprintf ((char *) parser->type_definition_forbidden_message,
	format, IDENTIFIER_POINTER (ridpointers[keyword]));

	/* The restrictions on constant-expressions do not apply inside
	sizeof expressions. */
	saved_integral_constant_expression_p
	= parser->integral_constant_expression_p;
	saved_non_integral_constant_expression_p
	= parser->non_integral_constant_expression_p;
	parser->integral_constant_expression_p = false;

	/* Do not actually evaluate the expression. */
	++skip_evaluation;
	/* If it's a `(', then we might be looking at the type-id
	construction. */
	if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_PAREN))
	{
	tree type;
	bool saved_in_type_id_in_expr_p;

	/* We can't be sure yet whether we're looking at a type-id or an
	expression. */
	cp_parser_parse_tentatively (parser);
	/* Consume the `('. */
	cp_lexer_consume_token (parser->lexer);
	/* Parse the type-id. */
	saved_in_type_id_in_expr_p = parser->in_type_id_in_expr_p;
	parser->in_type_id_in_expr_p = true;
	type = cp_parser_type_id (parser);
	parser->in_type_id_in_expr_p = saved_in_type_id_in_expr_p;
	/* Now, look for the trailing `)'. */
	cp_parser_require (parser, CPP_CLOSE_PAREN, "%<)%>");
	/* If all went well, then we're done. */
	if (cp_parser_parse_definitely (parser))
	{
	cp_decl_specifier_seq decl_specs;

	/* Build a trivial decl-specifier-seq. */
	clear_decl_specs (&decl_specs);
	decl_specs.type = type;

	/* Call grokdeclarator to figure out what type this is. */
	expr = grokdeclarator (NULL,
	&decl_specs,
	TYPENAME,
	/initialized=/0,
	/attrlist=/NULL);
	}
	}

	/* If the type-id production did not work out, then we must be
	looking at the unary-expression production. */
	if (!expr)
	expr = cp_parser_unary_expression (parser, /address_p=/false,
	/cast_p=/false);
	/* Go back to evaluating expressions. */
	--skip_evaluation;

	/* Free the message we created. */
	free ((char *) parser->type_definition_forbidden_message);
	/* And restore the old one. */
	parser->type_definition_forbidden_message = saved_message;
	parser->integral_constant_expression_p
	= saved_integral_constant_expression_p;
	parser->non_integral_constant_expression_p
	= saved_non_integral_constant_expression_p;

	return expr;
	}

	/* If the current declaration has no declarator, return true. */

	static bool
	cp_parser_declares_only_class_p (cp_parser *parser)
	{
	/* If the next token is a `;' or a `,' then there is no
	declarator. */
	return (cp_lexer_next_token_is (parser->lexer, CPP_SEMICOLON)
	\|\| cp_lexer_next_token_is (parser->lexer, CPP_COMMA));
	}

	/* Update the DECL_SPECS to reflect the storage class indicated by
	KEYWORD. */

	static void
	cp_parser_set_storage_class (cp_parser *parser,
	cp_decl_specifier_seq *decl_specs,
	enum rid keyword)
	{
	cp_storage_class storage_class;

	if (parser->in_unbraced_linkage_specification_p)
	{
	error ("invalid use of %qD in linkage specification",
	ridpointers[keyword]);
	return;
	}
	else if (decl_specs->storage_class != sc_none)
	{
	decl_specs->conflicting_specifiers_p = true;
	return;
	}

	if ((keyword == RID_EXTERN \|\| keyword == RID_STATIC)
	&& decl_specs->specs[(int) ds_thread])
	{
	error ("%<__thread%> before %qD", ridpointers[keyword]);
	decl_specs->specs[(int) ds_thread] = 0;
	}

	switch (keyword)
	{
	case RID_AUTO:
	storage_class = sc_auto;
	break;
	case RID_REGISTER:
	storage_class = sc_register;
	break;
	case RID_STATIC:
	storage_class = sc_static;
	break;
	case RID_EXTERN:
	storage_class = sc_extern;
	break;
	case RID_MUTABLE:
	storage_class = sc_mutable;
	break;
	default:
	gcc_unreachable ();
	}
	decl_specs->storage_class = storage_class;

	/* A storage class specifier cannot be applied alongside a typedef
	specifier. If there is a typedef specifier present then set
	conflicting_specifiers_p which will trigger an error later
	on in grokdeclarator. */
	if (decl_specs->specs[(int)ds_typedef])
	decl_specs->conflicting_specifiers_p = true;
	}

	/* Update the DECL_SPECS to reflect the TYPE_SPEC. If USER_DEFINED_P
	is true, the type is a user-defined type; otherwise it is a
	built-in type specified by a keyword. */

	static void
	cp_parser_set_decl_spec_type (cp_decl_specifier_seq *decl_specs,
	tree type_spec,
	bool user_defined_p)
	{
	decl_specs->any_specifiers_p = true;

	/* If the user tries to redeclare bool or wchar_t (with, for
	example, in "typedef int wchar_t;") we remember that this is what
	happened. In system headers, we ignore these declarations so
	that G++ can work with system headers that are not C++-safe. */
	if (decl_specs->specs[(int) ds_typedef]
	&& !user_defined_p
	&& (type_spec == boolean_type_node
	\|\| type_spec == wchar_type_node)
	&& (decl_specs->type
	\|\| decl_specs->specs[(int) ds_long]
	\|\| decl_specs->specs[(int) ds_short]
	\|\| decl_specs->specs[(int) ds_unsigned]
	\|\| decl_specs->specs[(int) ds_signed]))
	{
	decl_specs->redefined_builtin_type = type_spec;
	if (!decl_specs->type)
	{
	decl_specs->type = type_spec;
	decl_specs->user_defined_type_p = false;
	}
	}
	else if (decl_specs->type)
	decl_specs->multiple_types_p = true;
	else
	{
	decl_specs->type = type_spec;
	decl_specs->user_defined_type_p = user_defined_p;
	decl_specs->redefined_builtin_type = NULL_TREE;
	}
	}

	/* DECL_SPECIFIERS is the representation of a decl-specifier-seq.
	Returns TRUE iff `friend' appears among the DECL_SPECIFIERS. */

	static bool
	cp_parser_friend_p (const cp_decl_specifier_seq *decl_specifiers)
	{
	return decl_specifiers->specs[(int) ds_friend] != 0;
	}

	/* If the next token is of the indicated TYPE, consume it. Otherwise,
	issue an error message indicating that TOKEN_DESC was expected.

	Returns the token consumed, if the token had the appropriate type.
	Otherwise, returns NULL. */

	static cp_token *
	cp_parser_require (cp_parser* parser,
	enum cpp_ttype type,
	const char* token_desc)
	{
	if (cp_lexer_next_token_is (parser->lexer, type))
	return cp_lexer_consume_token (parser->lexer);
	else
	{
	/* Output the MESSAGE -- unless we're parsing tentatively. */
	if (!cp_parser_simulate_error (parser))
	{
	char *message = concat ("expected ", token_desc, NULL);
	cp_parser_error (parser, message);
	free (message);
	}
	return NULL;
	}
	}

	/* An error message is produced if the next token is not '>'.
	All further tokens are skipped until the desired token is
	found or '{', '}', ';' or an unbalanced ')' or ']'. */

	static void
	cp_parser_skip_to_end_of_template_parameter_list (cp_parser* parser)
	{
	/* Current level of '< ... >'. */
	unsigned level = 0;
	/* Ignore '<' and '>' nested inside '( ... )' or '[ ... ]'. */
	unsigned nesting_depth = 0;

	/* Are we ready, yet? If not, issue error message. */
	if (cp_parser_require (parser, CPP_GREATER, "%<>%>"))
	return;

	/* Skip tokens until the desired token is found. */
	while (true)
	{
	/* Peek at the next token. */
	switch (cp_lexer_peek_token (parser->lexer)->type)
	{
	case CPP_LESS:
	if (!nesting_depth)
	++level;
	break;

	case CPP_GREATER:
	if (!nesting_depth && level-- == 0)
	{
	/* We've reached the token we want, consume it and stop. */
	cp_lexer_consume_token (parser->lexer);
	return;
	}
	break;

	case CPP_OPEN_PAREN:
	case CPP_OPEN_SQUARE:
	++nesting_depth;
	break;

	case CPP_CLOSE_PAREN:
	case CPP_CLOSE_SQUARE:
	if (nesting_depth-- == 0)
	return;
	break;

	case CPP_EOF:
	case CPP_PRAGMA_EOL:
	case CPP_SEMICOLON:
	case CPP_OPEN_BRACE:
	case CPP_CLOSE_BRACE:
	/* The '>' was probably forgotten, don't look further. */
	return;

	default:
	break;
	}

	/* Consume this token. */
	cp_lexer_consume_token (parser->lexer);
	}
	}

	/* If the next token is the indicated keyword, consume it. Otherwise,
	issue an error message indicating that TOKEN_DESC was expected.

	Returns the token consumed, if the token had the appropriate type.
	Otherwise, returns NULL. */

	static cp_token *
	cp_parser_require_keyword (cp_parser* parser,
	enum rid keyword,
	const char* token_desc)
	{
	cp_token *token = cp_parser_require (parser, CPP_KEYWORD, token_desc);

	if (token && token->keyword != keyword)
	{
	dyn_string_t error_msg;

	/* Format the error message. */
	error_msg = dyn_string_new (0);
	dyn_string_append_cstr (error_msg, "expected ");
	dyn_string_append_cstr (error_msg, token_desc);
	cp_parser_error (parser, error_msg->s);
	dyn_string_delete (error_msg);
	return NULL;
	}

	return token;
	}

	/* Returns TRUE iff TOKEN is a token that can begin the body of a
	function-definition. */

	static bool
	cp_parser_token_starts_function_definition_p (cp_token* token)
	{
	return (/* An ordinary function-body begins with an `{'. */
	token->type == CPP_OPEN_BRACE
	/* A ctor-initializer begins with a `:'. */
	\|\| token->type == CPP_COLON
	/* A function-try-block begins with `try'. */
	\|\| token->keyword == RID_TRY
	/* The named return value extension begins with `return'. */
	\|\| token->keyword == RID_RETURN);
	}

	/* Returns TRUE iff the next token is the ":" or "{" beginning a class
	definition. */

	static bool
	cp_parser_next_token_starts_class_definition_p (cp_parser *parser)
	{
	cp_token *token;

	token = cp_lexer_peek_token (parser->lexer);
	return (token->type == CPP_OPEN_BRACE \|\| token->type == CPP_COLON);
	}

	/* Returns TRUE iff the next token is the "," or ">" ending a
	template-argument. */

	static bool
	cp_parser_next_token_ends_template_argument_p (cp_parser *parser)
	{
	cp_token *token;

	token = cp_lexer_peek_token (parser->lexer);
	return (token->type == CPP_COMMA \|\| token->type == CPP_GREATER);
	}

	/* Returns TRUE iff the n-th token is a "<", or the n-th is a "[" and the
	(n+1)-th is a ":" (which is a possible digraph typo for "< ::"). */

	static bool
	cp_parser_nth_token_starts_template_argument_list_p (cp_parser * parser,
	size_t n)
	{
	cp_token *token;

	token = cp_lexer_peek_nth_token (parser->lexer, n);
	if (token->type == CPP_LESS)
	return true;
	/* Check for the sequence `<::' in the original code. It would be lexed as
	`[:', where `[' is a digraph, and there is no whitespace before
	`:'. */
	if (token->type == CPP_OPEN_SQUARE && token->flags & DIGRAPH)
	{
	cp_token *token2;
	token2 = cp_lexer_peek_nth_token (parser->lexer, n+1);
	if (token2->type == CPP_COLON && !(token2->flags & PREV_WHITE))
	return true;
	}
	return false;
	}

	/* Returns the kind of tag indicated by TOKEN, if it is a class-key,
	or none_type otherwise. */

	static enum tag_types
	cp_parser_token_is_class_key (cp_token* token)
	{
	switch (token->keyword)
	{
	case RID_CLASS:
	return class_type;
	case RID_STRUCT:
	return record_type;
	case RID_UNION:
	return union_type;

	default:
	return none_type;
	}
	}

	/* Issue an error message if the CLASS_KEY does not match the TYPE. */

	static void
	cp_parser_check_class_key (enum tag_types class_key, tree type)
	{
	if ((TREE_CODE (type) == UNION_TYPE) != (class_key == union_type))
	pedwarn ("%qs tag used in naming %q#T",
	class_key == union_type ? "union"
	: class_key == record_type ? "struct" : "class",
	type);
	}

	/* Issue an error message if DECL is redeclared with different
	access than its original declaration [class.access.spec/3].
	This applies to nested classes and nested class templates.
	[class.mem/1]. */

	static void
	cp_parser_check_access_in_redeclaration (tree decl)
	{
	if (!CLASS_TYPE_P (TREE_TYPE (decl)))
	return;

	if ((TREE_PRIVATE (decl)
	!= (current_access_specifier == access_private_node))
	\|\| (TREE_PROTECTED (decl)
	!= (current_access_specifier == access_protected_node)))
	error ("%qD redeclared with different access", decl);
	}

	/* Look for the `template' keyword, as a syntactic disambiguator.
	Return TRUE iff it is present, in which case it will be
	consumed. */

	static bool
	cp_parser_optional_template_keyword (cp_parser *parser)
	{
	if (cp_lexer_next_token_is_keyword (parser->lexer, RID_TEMPLATE))
	{
	/* The `template' keyword can only be used within templates;
	outside templates the parser can always figure out what is a
	template and what is not. */
	if (!processing_template_decl)
	{
	error ("%<template%> (as a disambiguator) is only allowed "
	"within templates");
	/* If this part of the token stream is rescanned, the same
	error message would be generated. So, we purge the token
	from the stream. */
	cp_lexer_purge_token (parser->lexer);
	return false;
	}
	else
	{
	/* Consume the `template' keyword. */
	cp_lexer_consume_token (parser->lexer);
	return true;
	}
	}

	return false;
	}

	/* The next token is a CPP_NESTED_NAME_SPECIFIER. Consume the token,
	set PARSER->SCOPE, and perform other related actions. */

	static void
	cp_parser_pre_parsed_nested_name_specifier (cp_parser *parser)
	{
	int i;
	struct tree_check *check_value;
	deferred_access_check *chk;
	VEC (deferred_access_check,gc) *checks;

	/* Get the stored value. */
	check_value = cp_lexer_consume_token (parser->lexer)->u.tree_check_value;
	/* Perform any access checks that were deferred. */
	checks = check_value->checks;
	if (checks)
	{
	for (i = 0 ;
	VEC_iterate (deferred_access_check, checks, i, chk) ;
	++i)
	{
	perform_or_defer_access_check (chk->binfo,
	chk->decl,
	chk->diag_decl);
	}
	}
	/* Set the scope from the stored value. */
	parser->scope = check_value->value;
	parser->qualifying_scope = check_value->qualifying_scope;
	parser->object_scope = NULL_TREE;
	}

	/* Consume tokens up through a non-nested END token. */

	static void
	cp_parser_cache_group (cp_parser *parser,
	enum cpp_ttype end,
	unsigned depth)
	{
	while (true)
	{
	cp_token *token;

	/* Abort a parenthesized expression if we encounter a brace. */
	if ((end == CPP_CLOSE_PAREN \|\| depth == 0)
	&& cp_lexer_next_token_is (parser->lexer, CPP_SEMICOLON))
	return;
	/* If we've reached the end of the file, stop. */
	if (cp_lexer_next_token_is (parser->lexer, CPP_EOF)
	\|\| (end != CPP_PRAGMA_EOL
	&& cp_lexer_next_token_is (parser->lexer, CPP_PRAGMA_EOL)))
	return;
	/* Consume the next token. */
	token = cp_lexer_consume_token (parser->lexer);
	/* See if it starts a new group. */
	if (token->type == CPP_OPEN_BRACE)
	{
	cp_parser_cache_group (parser, CPP_CLOSE_BRACE, depth + 1);
	if (depth == 0)
	return;
	}
	else if (token->type == CPP_OPEN_PAREN)
	cp_parser_cache_group (parser, CPP_CLOSE_PAREN, depth + 1);
	else if (token->type == CPP_PRAGMA)
	cp_parser_cache_group (parser, CPP_PRAGMA_EOL, depth + 1);
	else if (token->type == end)
	return;
	}
	}

	/* Begin parsing tentatively. We always save tokens while parsing
	tentatively so that if the tentative parsing fails we can restore the
	tokens. */

	static void
	cp_parser_parse_tentatively (cp_parser* parser)
	{
	/* Enter a new parsing context. */
	parser->context = cp_parser_context_new (parser->context);
	/* Begin saving tokens. */
	cp_lexer_save_tokens (parser->lexer);
	/* In order to avoid repetitive access control error messages,
	access checks are queued up until we are no longer parsing
	tentatively. */
	push_deferring_access_checks (dk_deferred);
	}

	/* Commit to the currently active tentative parse. */

	static void
	cp_parser_commit_to_tentative_parse (cp_parser* parser)
	{
	cp_parser_context *context;
	cp_lexer *lexer;

	/* Mark all of the levels as committed. */
	lexer = parser->lexer;
	for (context = parser->context; context->next; context = context->next)
	{
	if (context->status == CP_PARSER_STATUS_KIND_COMMITTED)
	break;
	context->status = CP_PARSER_STATUS_KIND_COMMITTED;
	while (!cp_lexer_saving_tokens (lexer))
	lexer = lexer->next;
	cp_lexer_commit_tokens (lexer);
	}
	}

	/* Abort the currently active tentative parse. All consumed tokens
	will be rolled back, and no diagnostics will be issued. */

	static void
	cp_parser_abort_tentative_parse (cp_parser* parser)
	{
	cp_parser_simulate_error (parser);
	/* Now, pretend that we want to see if the construct was
	successfully parsed. */
	cp_parser_parse_definitely (parser);
	}

	/* Stop parsing tentatively. If a parse error has occurred, restore the
	token stream. Otherwise, commit to the tokens we have consumed.
	Returns true if no error occurred; false otherwise. */

	static bool
	cp_parser_parse_definitely (cp_parser* parser)
	{
	bool error_occurred;
	cp_parser_context *context;

	/* Remember whether or not an error occurred, since we are about to
	destroy that information. */
	error_occurred = cp_parser_error_occurred (parser);
	/* Remove the topmost context from the stack. */
	context = parser->context;
	parser->context = context->next;
	/* If no parse errors occurred, commit to the tentative parse. */
	if (!error_occurred)
	{
	/* Commit to the tokens read tentatively, unless that was
	already done. */
	if (context->status != CP_PARSER_STATUS_KIND_COMMITTED)
	cp_lexer_commit_tokens (parser->lexer);

	pop_to_parent_deferring_access_checks ();
	}
	/* Otherwise, if errors occurred, roll back our state so that things
	are just as they were before we began the tentative parse. */
	else
	{
	cp_lexer_rollback_tokens (parser->lexer);
	pop_deferring_access_checks ();
	}
	/* Add the context to the front of the free list. */
	context->next = cp_parser_context_free_list;
	cp_parser_context_free_list = context;

	return !error_occurred;
	}

	/* Returns true if we are parsing tentatively and are not committed to
	this tentative parse. */

	static bool
	cp_parser_uncommitted_to_tentative_parse_p (cp_parser* parser)
	{
	return (cp_parser_parsing_tentatively (parser)
	&& parser->context->status != CP_PARSER_STATUS_KIND_COMMITTED);
	}

	/* Returns nonzero iff an error has occurred during the most recent
	tentative parse. */

	static bool
	cp_parser_error_occurred (cp_parser* parser)
	{
	return (cp_parser_parsing_tentatively (parser)
	&& parser->context->status == CP_PARSER_STATUS_KIND_ERROR);
	}

	/* Returns nonzero if GNU extensions are allowed. */

	static bool
	cp_parser_allow_gnu_extensions_p (cp_parser* parser)
	{
	return parser->allow_gnu_extensions_p;
	}

	/* Objective-C++ Productions */


	/* Parse an Objective-C expression, which feeds into a primary-expression
	above.

	objc-expression:
	objc-message-expression
	objc-string-literal
	objc-encode-expression
	objc-protocol-expression
	objc-selector-expression

	Returns a tree representation of the expression. */

	static tree
	cp_parser_objc_expression (cp_parser* parser)
	{
	/* Try to figure out what kind of declaration is present. */
	cp_token *kwd = cp_lexer_peek_token (parser->lexer);

	switch (kwd->type)
	{
	case CPP_OPEN_SQUARE:
	return cp_parser_objc_message_expression (parser);

	case CPP_OBJC_STRING:
	kwd = cp_lexer_consume_token (parser->lexer);
	return objc_build_string_object (kwd->u.value);

	case CPP_KEYWORD:
	switch (kwd->keyword)
	{
	case RID_AT_ENCODE:
	return cp_parser_objc_encode_expression (parser);

	case RID_AT_PROTOCOL:
	return cp_parser_objc_protocol_expression (parser);

	case RID_AT_SELECTOR:
	return cp_parser_objc_selector_expression (parser);

	default:
	break;
	}
	default:
	error ("misplaced %<@%D%> Objective-C++ construct", kwd->u.value);
	cp_parser_skip_to_end_of_block_or_statement (parser);
	}

	return error_mark_node;
	}

	/* Parse an Objective-C message expression.

	objc-message-expression:
	[ objc-message-receiver objc-message-args ]

	Returns a representation of an Objective-C message. */

	static tree
	cp_parser_objc_message_expression (cp_parser* parser)
	{
	tree receiver, messageargs;

	cp_lexer_consume_token (parser->lexer); /* Eat '['. */
	receiver = cp_parser_objc_message_receiver (parser);
	messageargs = cp_parser_objc_message_args (parser);
	cp_parser_require (parser, CPP_CLOSE_SQUARE, "`]'");

	return objc_build_message_expr (build_tree_list (receiver, messageargs));
	}

	/* Parse an objc-message-receiver.

	objc-message-receiver:
	expression
	simple-type-specifier

	Returns a representation of the type or expression. */

	static tree
	cp_parser_objc_message_receiver (cp_parser* parser)
	{
	tree rcv;

	/* An Objective-C message receiver may be either (1) a type
	or (2) an expression. */
	cp_parser_parse_tentatively (parser);
	rcv = cp_parser_expression (parser, false);

	if (cp_parser_parse_definitely (parser))
	return rcv;

	rcv = cp_parser_simple_type_specifier (parser,
	/decl_specs=/NULL,
	CP_PARSER_FLAGS_NONE);

	return objc_get_class_reference (rcv);
	}

	/* Parse the arguments and selectors comprising an Objective-C message.

	objc-message-args:
	objc-selector
	objc-selector-args
	objc-selector-args , objc-comma-args

	objc-selector-args:
	objc-selector [opt] : assignment-expression
	objc-selector-args objc-selector [opt] : assignment-expression

	objc-comma-args:
	assignment-expression
	objc-comma-args , assignment-expression

	Returns a TREE_LIST, with TREE_PURPOSE containing a list of
	selector arguments and TREE_VALUE containing a list of comma
	arguments. */

	static tree
	cp_parser_objc_message_args (cp_parser* parser)
	{
	tree sel_args = NULL_TREE, addl_args = NULL_TREE;
	bool maybe_unary_selector_p = true;
	cp_token *token = cp_lexer_peek_token (parser->lexer);

	while (cp_parser_objc_selector_p (token->type) \|\| token->type == CPP_COLON)
	{
	tree selector = NULL_TREE, arg;

	if (token->type != CPP_COLON)
	selector = cp_parser_objc_selector (parser);

	/* Detect if we have a unary selector. */
	if (maybe_unary_selector_p
	&& cp_lexer_next_token_is_not (parser->lexer, CPP_COLON))
	return build_tree_list (selector, NULL_TREE);

	maybe_unary_selector_p = false;
	cp_parser_require (parser, CPP_COLON, "`:'");
	arg = cp_parser_assignment_expression (parser, false);

	sel_args
	= chainon (sel_args,
	build_tree_list (selector, arg));

	token = cp_lexer_peek_token (parser->lexer);
	}

	/* Handle non-selector arguments, if any. */
	while (token->type == CPP_COMMA)
	{
	tree arg;

	cp_lexer_consume_token (parser->lexer);
	arg = cp_parser_assignment_expression (parser, false);

	addl_args
	= chainon (addl_args,
	build_tree_list (NULL_TREE, arg));

	token = cp_lexer_peek_token (parser->lexer);
	}

	return build_tree_list (sel_args, addl_args);
	}

	/* Parse an Objective-C encode expression.

	objc-encode-expression:
	@encode objc-typename

	Returns an encoded representation of the type argument. */

	static tree
	cp_parser_objc_encode_expression (cp_parser* parser)
	{
	tree type;

	cp_lexer_consume_token (parser->lexer); /* Eat '@encode'. */
	cp_parser_require (parser, CPP_OPEN_PAREN, "`('");
	type = complete_type (cp_parser_type_id (parser));
	cp_parser_require (parser, CPP_CLOSE_PAREN, "`)'");

	if (!type)
	{
	error ("%<@encode%> must specify a type as an argument");
	return error_mark_node;
	}

	return objc_build_encode_expr (type);
	}

	/* Parse an Objective-C @defs expression. */

	static tree
	cp_parser_objc_defs_expression (cp_parser *parser)
	{
	tree name;

	cp_lexer_consume_token (parser->lexer); /* Eat '@defs'. */
	cp_parser_require (parser, CPP_OPEN_PAREN, "`('");
	name = cp_parser_identifier (parser);
	cp_parser_require (parser, CPP_CLOSE_PAREN, "`)'");

	return objc_get_class_ivars (name);
	}

	/* Parse an Objective-C protocol expression.

	objc-protocol-expression:
	@protocol ( identifier )

	Returns a representation of the protocol expression. */

	static tree
	cp_parser_objc_protocol_expression (cp_parser* parser)
	{
	tree proto;

	cp_lexer_consume_token (parser->lexer); /* Eat '@protocol'. */
	cp_parser_require (parser, CPP_OPEN_PAREN, "`('");
	proto = cp_parser_identifier (parser);
	cp_parser_require (parser, CPP_CLOSE_PAREN, "`)'");

	return objc_build_protocol_expr (proto);
	}

	/* Parse an Objective-C selector expression.

	objc-selector-expression:
	@selector ( objc-method-signature )

	objc-method-signature:
	objc-selector
	objc-selector-seq

	objc-selector-seq:
	objc-selector :
	objc-selector-seq objc-selector :

	Returns a representation of the method selector. */

	static tree
	cp_parser_objc_selector_expression (cp_parser* parser)
	{
	tree sel_seq = NULL_TREE;
	bool maybe_unary_selector_p = true;
	cp_token *token;

	cp_lexer_consume_token (parser->lexer); /* Eat '@selector'. */
	cp_parser_require (parser, CPP_OPEN_PAREN, "`('");
	token = cp_lexer_peek_token (parser->lexer);

	while (cp_parser_objc_selector_p (token->type) \|\| token->type == CPP_COLON
	\|\| token->type == CPP_SCOPE)
	{
	tree selector = NULL_TREE;

	if (token->type != CPP_COLON
	\|\| token->type == CPP_SCOPE)
	selector = cp_parser_objc_selector (parser);

	if (cp_lexer_next_token_is_not (parser->lexer, CPP_COLON)
	&& cp_lexer_next_token_is_not (parser->lexer, CPP_SCOPE))
	{
	/* Detect if we have a unary selector. */
	if (maybe_unary_selector_p)
	{
	sel_seq = selector;
	goto finish_selector;
	}
	else
	{
	cp_parser_error (parser, "expected %<:%>");
	}
	}
	maybe_unary_selector_p = false;
	token = cp_lexer_consume_token (parser->lexer);

	if (token->type == CPP_SCOPE)
	{
	sel_seq
	= chainon (sel_seq,
	build_tree_list (selector, NULL_TREE));
	sel_seq
	= chainon (sel_seq,
	build_tree_list (NULL_TREE, NULL_TREE));
	}
	else
	sel_seq
	= chainon (sel_seq,
	build_tree_list (selector, NULL_TREE));

	token = cp_lexer_peek_token (parser->lexer);
	}

	finish_selector:
	cp_parser_require (parser, CPP_CLOSE_PAREN, "`)'");

	return objc_build_selector_expr (sel_seq);
	}

	/* Parse a list of identifiers.

	objc-identifier-list:
	identifier
	objc-identifier-list , identifier

	Returns a TREE_LIST of identifier nodes. */

	static tree
	cp_parser_objc_identifier_list (cp_parser* parser)
	{
	tree list = build_tree_list (NULL_TREE, cp_parser_identifier (parser));
	cp_token *sep = cp_lexer_peek_token (parser->lexer);

	while (sep->type == CPP_COMMA)
	{
	cp_lexer_consume_token (parser->lexer); /* Eat ','. */
	list = chainon (list,
	build_tree_list (NULL_TREE,
	cp_parser_identifier (parser)));
	sep = cp_lexer_peek_token (parser->lexer);
	}

	return list;
	}

	/* Parse an Objective-C alias declaration.

	objc-alias-declaration:
	@compatibility_alias identifier identifier ;

	This function registers the alias mapping with the Objective-C front-end.
	It returns nothing. */

	static void
	cp_parser_objc_alias_declaration (cp_parser* parser)
	{
	tree alias, orig;

	cp_lexer_consume_token (parser->lexer); /* Eat '@compatibility_alias'. */
	alias = cp_parser_identifier (parser);
	orig = cp_parser_identifier (parser);
	objc_declare_alias (alias, orig);
	cp_parser_consume_semicolon_at_end_of_statement (parser);
	}

	/* Parse an Objective-C class forward-declaration.

	objc-class-declaration:
	@class objc-identifier-list ;

	The function registers the forward declarations with the Objective-C
	front-end. It returns nothing. */

	static void
	cp_parser_objc_class_declaration (cp_parser* parser)
	{
	cp_lexer_consume_token (parser->lexer); /* Eat '@class'. */
	objc_declare_class (cp_parser_objc_identifier_list (parser));
	cp_parser_consume_semicolon_at_end_of_statement (parser);
	}

	/* Parse a list of Objective-C protocol references.

	objc-protocol-refs-opt:
	objc-protocol-refs [opt]

	objc-protocol-refs:
	< objc-identifier-list >

	Returns a TREE_LIST of identifiers, if any. */

	static tree
	cp_parser_objc_protocol_refs_opt (cp_parser* parser)
	{
	tree protorefs = NULL_TREE;

	if(cp_lexer_next_token_is (parser->lexer, CPP_LESS))
	{
	cp_lexer_consume_token (parser->lexer); /* Eat '<'. */
	protorefs = cp_parser_objc_identifier_list (parser);
	cp_parser_require (parser, CPP_GREATER, "`>'");
	}

	return protorefs;
	}

	/* Parse a Objective-C visibility specification. */

	static void
	cp_parser_objc_visibility_spec (cp_parser* parser)
	{
	cp_token *vis = cp_lexer_peek_token (parser->lexer);

	switch (vis->keyword)
	{
	case RID_AT_PRIVATE:
	objc_set_visibility (2);
	break;
	case RID_AT_PROTECTED:
	objc_set_visibility (0);
	break;
	case RID_AT_PUBLIC:
	objc_set_visibility (1);
	break;
	default:
	return;
	}

	/* Eat '@private'/'@protected'/'@public'. */
	cp_lexer_consume_token (parser->lexer);
	}

	/* Parse an Objective-C method type. */

	static void
	cp_parser_objc_method_type (cp_parser* parser)
	{
	objc_set_method_type
	(cp_lexer_consume_token (parser->lexer)->type == CPP_PLUS
	? PLUS_EXPR
	: MINUS_EXPR);
	}

	/* Parse an Objective-C protocol qualifier. */

	static tree
	cp_parser_objc_protocol_qualifiers (cp_parser* parser)
	{
	tree quals = NULL_TREE, node;
	cp_token *token = cp_lexer_peek_token (parser->lexer);

	node = token->u.value;

	while (node && TREE_CODE (node) == IDENTIFIER_NODE
	&& (node == ridpointers [(int) RID_IN]
	\|\| node == ridpointers [(int) RID_OUT]
	\|\| node == ridpointers [(int) RID_INOUT]
	\|\| node == ridpointers [(int) RID_BYCOPY]
	\|\| node == ridpointers [(int) RID_BYREF]
	\|\| node == ridpointers [(int) RID_ONEWAY]))
	{
	quals = tree_cons (NULL_TREE, node, quals);
	cp_lexer_consume_token (parser->lexer);
	token = cp_lexer_peek_token (parser->lexer);
	node = token->u.value;
	}

	return quals;
	}

	/* Parse an Objective-C typename. */

	static tree
	cp_parser_objc_typename (cp_parser* parser)
	{
	tree typename = NULL_TREE;

	if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_PAREN))
	{
	tree proto_quals, cp_type = NULL_TREE;

	cp_lexer_consume_token (parser->lexer); /* Eat '('. */
	proto_quals = cp_parser_objc_protocol_qualifiers (parser);

	/* An ObjC type name may consist of just protocol qualifiers, in which
	case the type shall default to 'id'. */
	if (cp_lexer_next_token_is_not (parser->lexer, CPP_CLOSE_PAREN))
	cp_type = cp_parser_type_id (parser);

	cp_parser_require (parser, CPP_CLOSE_PAREN, "`)'");
	typename = build_tree_list (proto_quals, cp_type);
	}

	return typename;
	}

	/* Check to see if TYPE refers to an Objective-C selector name. */

	static bool
	cp_parser_objc_selector_p (enum cpp_ttype type)
	{
	return (type == CPP_NAME \|\| type == CPP_KEYWORD
	\|\| type == CPP_AND_AND \|\| type == CPP_AND_EQ \|\| type == CPP_AND
	\|\| type == CPP_OR \|\| type == CPP_COMPL \|\| type == CPP_NOT
	\|\| type == CPP_NOT_EQ \|\| type == CPP_OR_OR \|\| type == CPP_OR_EQ
	\|\| type == CPP_XOR \|\| type == CPP_XOR_EQ);
	}

	/* Parse an Objective-C selector. */

	static tree
	cp_parser_objc_selector (cp_parser* parser)
	{
	cp_token *token = cp_lexer_consume_token (parser->lexer);

	if (!cp_parser_objc_selector_p (token->type))
	{
	error ("invalid Objective-C++ selector name");
	return error_mark_node;
	}

	/* C++ operator names are allowed to appear in ObjC selectors. */
	switch (token->type)
	{
	case CPP_AND_AND: return get_identifier ("and");
	case CPP_AND_EQ: return get_identifier ("and_eq");
	case CPP_AND: return get_identifier ("bitand");
	case CPP_OR: return get_identifier ("bitor");
	case CPP_COMPL: return get_identifier ("compl");
	case CPP_NOT: return get_identifier ("not");
	case CPP_NOT_EQ: return get_identifier ("not_eq");
	case CPP_OR_OR: return get_identifier ("or");
	case CPP_OR_EQ: return get_identifier ("or_eq");
	case CPP_XOR: return get_identifier ("xor");
	case CPP_XOR_EQ: return get_identifier ("xor_eq");
	default: return token->u.value;
	}
	}

	/* Parse an Objective-C params list. */

	static tree
	cp_parser_objc_method_keyword_params (cp_parser* parser)
	{
	tree params = NULL_TREE;
	bool maybe_unary_selector_p = true;
	cp_token *token = cp_lexer_peek_token (parser->lexer);

	while (cp_parser_objc_selector_p (token->type) \|\| token->type == CPP_COLON)
	{
	tree selector = NULL_TREE, typename, identifier;

	if (token->type != CPP_COLON)
	selector = cp_parser_objc_selector (parser);

	/* Detect if we have a unary selector. */
	if (maybe_unary_selector_p
	&& cp_lexer_next_token_is_not (parser->lexer, CPP_COLON))
	return selector;

	maybe_unary_selector_p = false;
	cp_parser_require (parser, CPP_COLON, "`:'");
	typename = cp_parser_objc_typename (parser);
	identifier = cp_parser_identifier (parser);

	params
	= chainon (params,
	objc_build_keyword_decl (selector,
	typename,
	identifier));

	token = cp_lexer_peek_token (parser->lexer);
	}

	return params;
	}

	/* Parse the non-keyword Objective-C params. */

	static tree
	cp_parser_objc_method_tail_params_opt (cp_parser* parser, bool *ellipsisp)
	{
	tree params = make_node (TREE_LIST);
	cp_token *token = cp_lexer_peek_token (parser->lexer);
	ellipsisp = false; / Initially, assume no ellipsis. */

	while (token->type == CPP_COMMA)
	{
	cp_parameter_declarator *parmdecl;
	tree parm;

	cp_lexer_consume_token (parser->lexer); /* Eat ','. */
	token = cp_lexer_peek_token (parser->lexer);

	if (token->type == CPP_ELLIPSIS)
	{
	cp_lexer_consume_token (parser->lexer); /* Eat '...'. */
	*ellipsisp = true;
	break;
	}

	parmdecl = cp_parser_parameter_declaration (parser, false, NULL);
	parm = grokdeclarator (parmdecl->declarator,
	&parmdecl->decl_specifiers,
	PARM, /initialized=/0,
	/attrlist=/NULL);

	chainon (params, build_tree_list (NULL_TREE, parm));
	token = cp_lexer_peek_token (parser->lexer);
	}

	return params;
	}

	/* Parse a linkage specification, a pragma, an extra semicolon or a block. */

	static void
	cp_parser_objc_interstitial_code (cp_parser* parser)
	{
	cp_token *token = cp_lexer_peek_token (parser->lexer);

	/* If the next token is `extern' and the following token is a string
	literal, then we have a linkage specification. */
	if (token->keyword == RID_EXTERN
	&& cp_parser_is_string_literal (cp_lexer_peek_nth_token (parser->lexer, 2)))
	cp_parser_linkage_specification (parser);
	/* Handle #pragma, if any. */
	else if (token->type == CPP_PRAGMA)
	cp_parser_pragma (parser, pragma_external);
	/* Allow stray semicolons. */
	else if (token->type == CPP_SEMICOLON)
	cp_lexer_consume_token (parser->lexer);
	/* Finally, try to parse a block-declaration, or a function-definition. */
	else
	cp_parser_block_declaration (parser, /statement_p=/false);
	}

	/* Parse a method signature. */

	static tree
	cp_parser_objc_method_signature (cp_parser* parser)
	{
	tree rettype, kwdparms, optparms;
	bool ellipsis = false;

	cp_parser_objc_method_type (parser);
	rettype = cp_parser_objc_typename (parser);
	kwdparms = cp_parser_objc_method_keyword_params (parser);
	optparms = cp_parser_objc_method_tail_params_opt (parser, &ellipsis);

	return objc_build_method_signature (rettype, kwdparms, optparms, ellipsis);
	}

	/* Pars an Objective-C method prototype list. */

	static void
	cp_parser_objc_method_prototype_list (cp_parser* parser)
	{
	cp_token *token = cp_lexer_peek_token (parser->lexer);

	while (token->keyword != RID_AT_END)
	{
	if (token->type == CPP_PLUS \|\| token->type == CPP_MINUS)
	{
	objc_add_method_declaration
	(cp_parser_objc_method_signature (parser));
	cp_parser_consume_semicolon_at_end_of_statement (parser);
	}
	else
	/* Allow for interspersed non-ObjC++ code. */
	cp_parser_objc_interstitial_code (parser);

	token = cp_lexer_peek_token (parser->lexer);
	}

	cp_lexer_consume_token (parser->lexer); /* Eat '@end'. */
	objc_finish_interface ();
	}

	/* Parse an Objective-C method definition list. */

	static void
	cp_parser_objc_method_definition_list (cp_parser* parser)
	{
	cp_token *token = cp_lexer_peek_token (parser->lexer);

	while (token->keyword != RID_AT_END)
	{
	tree meth;

	if (token->type == CPP_PLUS \|\| token->type == CPP_MINUS)
	{
	push_deferring_access_checks (dk_deferred);
	objc_start_method_definition
	(cp_parser_objc_method_signature (parser));

	/* For historical reasons, we accept an optional semicolon. */
	if (cp_lexer_next_token_is (parser->lexer, CPP_SEMICOLON))
	cp_lexer_consume_token (parser->lexer);

	perform_deferred_access_checks ();
	stop_deferring_access_checks ();
	meth = cp_parser_function_definition_after_declarator (parser,
	false);
	pop_deferring_access_checks ();
	objc_finish_method_definition (meth);
	}
	else
	/* Allow for interspersed non-ObjC++ code. */
	cp_parser_objc_interstitial_code (parser);

	token = cp_lexer_peek_token (parser->lexer);
	}

	cp_lexer_consume_token (parser->lexer); /* Eat '@end'. */
	objc_finish_implementation ();
	}

	/* Parse Objective-C ivars. */

	static void
	cp_parser_objc_class_ivars (cp_parser* parser)
	{
	cp_token *token = cp_lexer_peek_token (parser->lexer);

	if (token->type != CPP_OPEN_BRACE)
	return; /* No ivars specified. */

	cp_lexer_consume_token (parser->lexer); /* Eat '{'. */
	token = cp_lexer_peek_token (parser->lexer);

	while (token->type != CPP_CLOSE_BRACE)
	{
	cp_decl_specifier_seq declspecs;
	int decl_class_or_enum_p;
	tree prefix_attributes;

	cp_parser_objc_visibility_spec (parser);

	if (cp_lexer_next_token_is (parser->lexer, CPP_CLOSE_BRACE))
	break;

	cp_parser_decl_specifier_seq (parser,
	CP_PARSER_FLAGS_OPTIONAL,
	&declspecs,
	&decl_class_or_enum_p);
	prefix_attributes = declspecs.attributes;
	declspecs.attributes = NULL_TREE;

	/* Keep going until we hit the `;' at the end of the
	declaration. */
	while (cp_lexer_next_token_is_not (parser->lexer, CPP_SEMICOLON))
	{
	tree width = NULL_TREE, attributes, first_attribute, decl;
	cp_declarator *declarator = NULL;
	int ctor_dtor_or_conv_p;

	/* Check for a (possibly unnamed) bitfield declaration. */
	token = cp_lexer_peek_token (parser->lexer);
	if (token->type == CPP_COLON)
	goto eat_colon;

	if (token->type == CPP_NAME
	&& (cp_lexer_peek_nth_token (parser->lexer, 2)->type
	== CPP_COLON))
	{
	/* Get the name of the bitfield. */
	declarator = make_id_declarator (NULL_TREE,
	cp_parser_identifier (parser),
	sfk_none);

	eat_colon:
	cp_lexer_consume_token (parser->lexer); /* Eat ':'. */
	/* Get the width of the bitfield. */
	width
	= cp_parser_constant_expression (parser,
	/allow_non_constant=/false,
	NULL);
	}
	else
	{
	/* Parse the declarator. */
	declarator
	= cp_parser_declarator (parser, CP_PARSER_DECLARATOR_NAMED,
	&ctor_dtor_or_conv_p,
	/parenthesized_p=/NULL,
	/member_p=/false);
	}

	/* Look for attributes that apply to the ivar. */
	attributes = cp_parser_attributes_opt (parser);
	/* Remember which attributes are prefix attributes and
	which are not. */
	first_attribute = attributes;
	/* Combine the attributes. */
	attributes = chainon (prefix_attributes, attributes);

	if (width)
	{
	/* Create the bitfield declaration. */
	decl = grokbitfield (declarator, &declspecs, width);
	cplus_decl_attributes (&decl, attributes, /flags=/0);
	}
	else
	decl = grokfield (declarator, &declspecs,
	NULL_TREE, /init_const_expr_p=/false,
	NULL_TREE, attributes);

	/* Add the instance variable. */
	objc_add_instance_variable (decl);

	/* Reset PREFIX_ATTRIBUTES. */
	while (attributes && TREE_CHAIN (attributes) != first_attribute)
	attributes = TREE_CHAIN (attributes);
	if (attributes)
	TREE_CHAIN (attributes) = NULL_TREE;

	token = cp_lexer_peek_token (parser->lexer);

	if (token->type == CPP_COMMA)
	{
	cp_lexer_consume_token (parser->lexer); /* Eat ','. */
	continue;
	}
	break;
	}

	cp_parser_consume_semicolon_at_end_of_statement (parser);
	token = cp_lexer_peek_token (parser->lexer);
	}

	cp_lexer_consume_token (parser->lexer); /* Eat '}'. */
	/* For historical reasons, we accept an optional semicolon. */
	if (cp_lexer_next_token_is (parser->lexer, CPP_SEMICOLON))
	cp_lexer_consume_token (parser->lexer);
	}

	/* Parse an Objective-C protocol declaration. */

	static void
	cp_parser_objc_protocol_declaration (cp_parser* parser)
	{
	tree proto, protorefs;
	cp_token *tok;

	cp_lexer_consume_token (parser->lexer); /* Eat '@protocol'. */
	if (cp_lexer_next_token_is_not (parser->lexer, CPP_NAME))
	{
	error ("identifier expected after %<@protocol%>");
	goto finish;
	}

	/* See if we have a forward declaration or a definition. */
	tok = cp_lexer_peek_nth_token (parser->lexer, 2);

	/* Try a forward declaration first. */
	if (tok->type == CPP_COMMA \|\| tok->type == CPP_SEMICOLON)
	{
	objc_declare_protocols (cp_parser_objc_identifier_list (parser));
	finish:
	cp_parser_consume_semicolon_at_end_of_statement (parser);
	}

	/* Ok, we got a full-fledged definition (or at least should). */
	else
	{
	proto = cp_parser_identifier (parser);
	protorefs = cp_parser_objc_protocol_refs_opt (parser);
	objc_start_protocol (proto, protorefs);
	cp_parser_objc_method_prototype_list (parser);
	}
	}

	/* Parse an Objective-C superclass or category. */

	static void
	cp_parser_objc_superclass_or_category (cp_parser parser, tree super,
	tree *categ)
	{
	cp_token *next = cp_lexer_peek_token (parser->lexer);

	super = categ = NULL_TREE;
	if (next->type == CPP_COLON)
	{
	cp_lexer_consume_token (parser->lexer); /* Eat ':'. */
	*super = cp_parser_identifier (parser);
	}
	else if (next->type == CPP_OPEN_PAREN)
	{
	cp_lexer_consume_token (parser->lexer); /* Eat '('. */
	*categ = cp_parser_identifier (parser);
	cp_parser_require (parser, CPP_CLOSE_PAREN, "`)'");
	}
	}

	/* Parse an Objective-C class interface. */

	static void
	cp_parser_objc_class_interface (cp_parser* parser)
	{
	tree name, super, categ, protos;

	cp_lexer_consume_token (parser->lexer); /* Eat '@interface'. */
	name = cp_parser_identifier (parser);
	cp_parser_objc_superclass_or_category (parser, &super, &categ);
	protos = cp_parser_objc_protocol_refs_opt (parser);

	/* We have either a class or a category on our hands. */
	if (categ)
	objc_start_category_interface (name, categ, protos);
	else
	{
	objc_start_class_interface (name, super, protos);
	/* Handle instance variable declarations, if any. */
	cp_parser_objc_class_ivars (parser);
	objc_continue_interface ();
	}

	cp_parser_objc_method_prototype_list (parser);
	}

	/* Parse an Objective-C class implementation. */

	static void
	cp_parser_objc_class_implementation (cp_parser* parser)
	{
	tree name, super, categ;

	cp_lexer_consume_token (parser->lexer); /* Eat '@implementation'. */
	name = cp_parser_identifier (parser);
	cp_parser_objc_superclass_or_category (parser, &super, &categ);

	/* We have either a class or a category on our hands. */
	if (categ)
	objc_start_category_implementation (name, categ);
	else
	{
	objc_start_class_implementation (name, super);
	/* Handle instance variable declarations, if any. */
	cp_parser_objc_class_ivars (parser);
	objc_continue_implementation ();
	}

	cp_parser_objc_method_definition_list (parser);
	}

	/* Consume the @end token and finish off the implementation. */

	static void
	cp_parser_objc_end_implementation (cp_parser* parser)
	{
	cp_lexer_consume_token (parser->lexer); /* Eat '@end'. */
	objc_finish_implementation ();
	}

	/* Parse an Objective-C declaration. */

	static void
	cp_parser_objc_declaration (cp_parser* parser)
	{
	/* Try to figure out what kind of declaration is present. */
	cp_token *kwd = cp_lexer_peek_token (parser->lexer);

	switch (kwd->keyword)
	{
	case RID_AT_ALIAS:
	cp_parser_objc_alias_declaration (parser);
	break;
	case RID_AT_CLASS:
	cp_parser_objc_class_declaration (parser);
	break;
	case RID_AT_PROTOCOL:
	cp_parser_objc_protocol_declaration (parser);
	break;
	case RID_AT_INTERFACE:
	cp_parser_objc_class_interface (parser);
	break;
	case RID_AT_IMPLEMENTATION:
	cp_parser_objc_class_implementation (parser);
	break;
	case RID_AT_END:
	cp_parser_objc_end_implementation (parser);
	break;
	default:
	error ("misplaced %<@%D%> Objective-C++ construct", kwd->u.value);
	cp_parser_skip_to_end_of_block_or_statement (parser);
	}
	}

	/* Parse an Objective-C try-catch-finally statement.

	objc-try-catch-finally-stmt:
	@try compound-statement objc-catch-clause-seq [opt]
	objc-finally-clause [opt]

	objc-catch-clause-seq:
	objc-catch-clause objc-catch-clause-seq [opt]

	objc-catch-clause:
	@catch ( exception-declaration ) compound-statement

	objc-finally-clause
	@finally compound-statement

	Returns NULL_TREE. */

	static tree
	cp_parser_objc_try_catch_finally_statement (cp_parser *parser) {
	location_t location;
	tree stmt;

	cp_parser_require_keyword (parser, RID_AT_TRY, "`@try'");
	location = cp_lexer_peek_token (parser->lexer)->location;
	/* NB: The @try block needs to be wrapped in its own STATEMENT_LIST
	node, lest it get absorbed into the surrounding block. */
	stmt = push_stmt_list ();
	cp_parser_compound_statement (parser, NULL, false);
	objc_begin_try_stmt (location, pop_stmt_list (stmt));

	while (cp_lexer_next_token_is_keyword (parser->lexer, RID_AT_CATCH))
	{
	cp_parameter_declarator *parmdecl;
	tree parm;

	cp_lexer_consume_token (parser->lexer);
	cp_parser_require (parser, CPP_OPEN_PAREN, "`('");
	parmdecl = cp_parser_parameter_declaration (parser, false, NULL);
	parm = grokdeclarator (parmdecl->declarator,
	&parmdecl->decl_specifiers,
	PARM, /initialized=/0,
	/attrlist=/NULL);
	cp_parser_require (parser, CPP_CLOSE_PAREN, "`)'");
	objc_begin_catch_clause (parm);
	cp_parser_compound_statement (parser, NULL, false);
	objc_finish_catch_clause ();
	}

	if (cp_lexer_next_token_is_keyword (parser->lexer, RID_AT_FINALLY))
	{
	cp_lexer_consume_token (parser->lexer);
	location = cp_lexer_peek_token (parser->lexer)->location;
	/* NB: The @finally block needs to be wrapped in its own STATEMENT_LIST
	node, lest it get absorbed into the surrounding block. */
	stmt = push_stmt_list ();
	cp_parser_compound_statement (parser, NULL, false);
	objc_build_finally_clause (location, pop_stmt_list (stmt));
	}

	return objc_finish_try_stmt ();
	}

	/* Parse an Objective-C synchronized statement.

	objc-synchronized-stmt:
	@synchronized ( expression ) compound-statement

	Returns NULL_TREE. */

	static tree
	cp_parser_objc_synchronized_statement (cp_parser *parser) {
	location_t location;
	tree lock, stmt;

	cp_parser_require_keyword (parser, RID_AT_SYNCHRONIZED, "`@synchronized'");

	location = cp_lexer_peek_token (parser->lexer)->location;
	cp_parser_require (parser, CPP_OPEN_PAREN, "`('");
	lock = cp_parser_expression (parser, false);
	cp_parser_require (parser, CPP_CLOSE_PAREN, "`)'");

	/* NB: The @synchronized block needs to be wrapped in its own STATEMENT_LIST
	node, lest it get absorbed into the surrounding block. */
	stmt = push_stmt_list ();
	cp_parser_compound_statement (parser, NULL, false);

	return objc_build_synchronized (location, lock, pop_stmt_list (stmt));
	}

	/* Parse an Objective-C throw statement.

	objc-throw-stmt:
	@throw assignment-expression [opt] ;

	Returns a constructed '@throw' statement. */

	static tree
	cp_parser_objc_throw_statement (cp_parser *parser) {
	tree expr = NULL_TREE;

	cp_parser_require_keyword (parser, RID_AT_THROW, "`@throw'");

	if (cp_lexer_next_token_is_not (parser->lexer, CPP_SEMICOLON))
	expr = cp_parser_assignment_expression (parser, false);

	cp_parser_consume_semicolon_at_end_of_statement (parser);

	return objc_build_throw_stmt (expr);
	}

	/* Parse an Objective-C statement. */

	static tree
	cp_parser_objc_statement (cp_parser * parser) {
	/* Try to figure out what kind of declaration is present. */
	cp_token *kwd = cp_lexer_peek_token (parser->lexer);

	switch (kwd->keyword)
	{
	case RID_AT_TRY:
	return cp_parser_objc_try_catch_finally_statement (parser);
	case RID_AT_SYNCHRONIZED:
	return cp_parser_objc_synchronized_statement (parser);
	case RID_AT_THROW:
	return cp_parser_objc_throw_statement (parser);
	default:
	error ("misplaced %<@%D%> Objective-C++ construct", kwd->u.value);
	cp_parser_skip_to_end_of_block_or_statement (parser);
	}

	return error_mark_node;
	}

	/* OpenMP 2.5 parsing routines. */

	/* All OpenMP clauses. OpenMP 2.5. */
	typedef enum pragma_omp_clause {
	PRAGMA_OMP_CLAUSE_NONE = 0,

	PRAGMA_OMP_CLAUSE_COPYIN,
	PRAGMA_OMP_CLAUSE_COPYPRIVATE,
	PRAGMA_OMP_CLAUSE_DEFAULT,
	PRAGMA_OMP_CLAUSE_FIRSTPRIVATE,
	PRAGMA_OMP_CLAUSE_IF,
	PRAGMA_OMP_CLAUSE_LASTPRIVATE,
	PRAGMA_OMP_CLAUSE_NOWAIT,
	PRAGMA_OMP_CLAUSE_NUM_THREADS,
	PRAGMA_OMP_CLAUSE_ORDERED,
	PRAGMA_OMP_CLAUSE_PRIVATE,
	PRAGMA_OMP_CLAUSE_REDUCTION,
	PRAGMA_OMP_CLAUSE_SCHEDULE,
	PRAGMA_OMP_CLAUSE_SHARED
	} pragma_omp_clause;

	/* Returns name of the next clause.
	If the clause is not recognized PRAGMA_OMP_CLAUSE_NONE is returned and
	the token is not consumed. Otherwise appropriate pragma_omp_clause is
	returned and the token is consumed. */

	static pragma_omp_clause
	cp_parser_omp_clause_name (cp_parser *parser)
	{
	pragma_omp_clause result = PRAGMA_OMP_CLAUSE_NONE;

	if (cp_lexer_next_token_is_keyword (parser->lexer, RID_IF))
	result = PRAGMA_OMP_CLAUSE_IF;
	else if (cp_lexer_next_token_is_keyword (parser->lexer, RID_DEFAULT))
	result = PRAGMA_OMP_CLAUSE_DEFAULT;
	else if (cp_lexer_next_token_is_keyword (parser->lexer, RID_PRIVATE))
	result = PRAGMA_OMP_CLAUSE_PRIVATE;
	else if (cp_lexer_next_token_is (parser->lexer, CPP_NAME))
	{
	tree id = cp_lexer_peek_token (parser->lexer)->u.value;
	const char *p = IDENTIFIER_POINTER (id);

	switch (p[0])
	{
	case 'c':
	if (!strcmp ("copyin", p))
	result = PRAGMA_OMP_CLAUSE_COPYIN;
	else if (!strcmp ("copyprivate", p))
	result = PRAGMA_OMP_CLAUSE_COPYPRIVATE;
	break;
	case 'f':
	if (!strcmp ("firstprivate", p))
	result = PRAGMA_OMP_CLAUSE_FIRSTPRIVATE;
	break;
	case 'l':
	if (!strcmp ("lastprivate", p))
	result = PRAGMA_OMP_CLAUSE_LASTPRIVATE;
	break;
	case 'n':
	if (!strcmp ("nowait", p))
	result = PRAGMA_OMP_CLAUSE_NOWAIT;
	else if (!strcmp ("num_threads", p))
	result = PRAGMA_OMP_CLAUSE_NUM_THREADS;
	break;
	case 'o':
	if (!strcmp ("ordered", p))
	result = PRAGMA_OMP_CLAUSE_ORDERED;
	break;
	case 'r':
	if (!strcmp ("reduction", p))
	result = PRAGMA_OMP_CLAUSE_REDUCTION;
	break;
	case 's':
	if (!strcmp ("schedule", p))
	result = PRAGMA_OMP_CLAUSE_SCHEDULE;
	else if (!strcmp ("shared", p))
	result = PRAGMA_OMP_CLAUSE_SHARED;
	break;
	}
	}

	if (result != PRAGMA_OMP_CLAUSE_NONE)
	cp_lexer_consume_token (parser->lexer);

	return result;
	}

	/* Validate that a clause of the given type does not already exist. */

	static void
	check_no_duplicate_clause (tree clauses, enum tree_code code, const char *name)
	{
	tree c;

	for (c = clauses; c ; c = OMP_CLAUSE_CHAIN (c))
	if (OMP_CLAUSE_CODE (c) == code)
	{
	error ("too many %qs clauses", name);
	break;
	}
	}

	/* OpenMP 2.5:
	variable-list:
	identifier
	variable-list , identifier

	In addition, we match a closing parenthesis. An opening parenthesis
	will have been consumed by the caller.

	If KIND is nonzero, create the appropriate node and install the decl
	in OMP_CLAUSE_DECL and add the node to the head of the list.

	If KIND is zero, create a TREE_LIST with the decl in TREE_PURPOSE;
	return the list created. */

	static tree
	cp_parser_omp_var_list_no_open (cp_parser *parser, enum omp_clause_code kind,
	tree list)
	{
	while (1)
	{
	tree name, decl;

	name = cp_parser_id_expression (parser, /template_p=/false,
	/check_dependency_p=/true,
	/template_p=/NULL,
	/declarator_p=/false,
	/optional_p=/false);
	if (name == error_mark_node)
	goto skip_comma;

	decl = cp_parser_lookup_name_simple (parser, name);
	if (decl == error_mark_node)
	cp_parser_name_lookup_error (parser, name, decl, NULL);
	else if (kind != 0)
	{
	tree u = build_omp_clause (kind);
	OMP_CLAUSE_DECL (u) = decl;
	OMP_CLAUSE_CHAIN (u) = list;
	list = u;
	}
	else
	list = tree_cons (decl, NULL_TREE, list);

	get_comma:
	if (cp_lexer_next_token_is_not (parser->lexer, CPP_COMMA))
	break;
	cp_lexer_consume_token (parser->lexer);
	}

	if (!cp_parser_require (parser, CPP_CLOSE_PAREN, "`)'"))
	{
	int ending;

	/* Try to resync to an unnested comma. Copied from
	cp_parser_parenthesized_expression_list. */
	skip_comma:
	ending = cp_parser_skip_to_closing_parenthesis (parser,
	/recovering=/true,
	/or_comma=/true,
	/consume_paren=/true);
	if (ending < 0)
	goto get_comma;
	}

	return list;
	}

	/* Similarly, but expect leading and trailing parenthesis. This is a very
	common case for omp clauses. */

	static tree
	cp_parser_omp_var_list (cp_parser *parser, enum omp_clause_code kind, tree list)
	{
	if (cp_parser_require (parser, CPP_OPEN_PAREN, "`('"))
	return cp_parser_omp_var_list_no_open (parser, kind, list);
	return list;
	}

	/* OpenMP 2.5:
	default ( shared \| none ) */

	static tree
	cp_parser_omp_clause_default (cp_parser *parser, tree list)
	{
	enum omp_clause_default_kind kind = OMP_CLAUSE_DEFAULT_UNSPECIFIED;
	tree c;

	if (!cp_parser_require (parser, CPP_OPEN_PAREN, "`('"))
	return list;
	if (cp_lexer_next_token_is (parser->lexer, CPP_NAME))
	{
	tree id = cp_lexer_peek_token (parser->lexer)->u.value;
	const char *p = IDENTIFIER_POINTER (id);

	switch (p[0])
	{
	case 'n':
	if (strcmp ("none", p) != 0)
	goto invalid_kind;
	kind = OMP_CLAUSE_DEFAULT_NONE;
	break;

	case 's':
	if (strcmp ("shared", p) != 0)
	goto invalid_kind;
	kind = OMP_CLAUSE_DEFAULT_SHARED;
	break;

	default:
	goto invalid_kind;
	}

	cp_lexer_consume_token (parser->lexer);
	}
	else
	{
	invalid_kind:
	cp_parser_error (parser, "expected %<none%> or %<shared%>");
	}

	if (!cp_parser_require (parser, CPP_CLOSE_PAREN, "`)'"))
	cp_parser_skip_to_closing_parenthesis (parser, /recovering=/true,
	/or_comma=/false,
	/consume_paren=/true);

	if (kind == OMP_CLAUSE_DEFAULT_UNSPECIFIED)
	return list;

	check_no_duplicate_clause (list, OMP_CLAUSE_DEFAULT, "default");
	c = build_omp_clause (OMP_CLAUSE_DEFAULT);
	OMP_CLAUSE_CHAIN (c) = list;
	OMP_CLAUSE_DEFAULT_KIND (c) = kind;

	return c;
	}

	/* OpenMP 2.5:
	if ( expression ) */

	static tree
	cp_parser_omp_clause_if (cp_parser *parser, tree list)
	{
	tree t, c;

	if (!cp_parser_require (parser, CPP_OPEN_PAREN, "`('"))
	return list;

	t = cp_parser_condition (parser);

	if (t == error_mark_node
	\|\| !cp_parser_require (parser, CPP_CLOSE_PAREN, "`)'"))
	cp_parser_skip_to_closing_parenthesis (parser, /recovering=/true,
	/or_comma=/false,
	/consume_paren=/true);

	check_no_duplicate_clause (list, OMP_CLAUSE_IF, "if");

	c = build_omp_clause (OMP_CLAUSE_IF);
	OMP_CLAUSE_IF_EXPR (c) = t;
	OMP_CLAUSE_CHAIN (c) = list;

	return c;
	}

	/* OpenMP 2.5:
	nowait */

	static tree
	cp_parser_omp_clause_nowait (cp_parser *parser ATTRIBUTE_UNUSED, tree list)
	{
	tree c;

	check_no_duplicate_clause (list, OMP_CLAUSE_NOWAIT, "nowait");

	c = build_omp_clause (OMP_CLAUSE_NOWAIT);
	OMP_CLAUSE_CHAIN (c) = list;
	return c;
	}

	/* OpenMP 2.5:
	num_threads ( expression ) */

	static tree
	cp_parser_omp_clause_num_threads (cp_parser *parser, tree list)
	{
	tree t, c;

	if (!cp_parser_require (parser, CPP_OPEN_PAREN, "`('"))
	return list;

	t = cp_parser_expression (parser, false);

	if (t == error_mark_node
	\|\| !cp_parser_require (parser, CPP_CLOSE_PAREN, "`)'"))
	cp_parser_skip_to_closing_parenthesis (parser, /recovering=/true,
	/or_comma=/false,
	/consume_paren=/true);

	check_no_duplicate_clause (list, OMP_CLAUSE_NUM_THREADS, "num_threads");

	c = build_omp_clause (OMP_CLAUSE_NUM_THREADS);
	OMP_CLAUSE_NUM_THREADS_EXPR (c) = t;
	OMP_CLAUSE_CHAIN (c) = list;

	return c;
	}

	/* OpenMP 2.5:
	ordered */

	static tree
	cp_parser_omp_clause_ordered (cp_parser *parser ATTRIBUTE_UNUSED, tree list)
	{
	tree c;

	check_no_duplicate_clause (list, OMP_CLAUSE_ORDERED, "ordered");

	c = build_omp_clause (OMP_CLAUSE_ORDERED);
	OMP_CLAUSE_CHAIN (c) = list;
	return c;
	}

	/* OpenMP 2.5:
	reduction ( reduction-operator : variable-list )

	reduction-operator:
	One of: + * - & ^ \| && \|\| */

	static tree
	cp_parser_omp_clause_reduction (cp_parser *parser, tree list)
	{
	enum tree_code code;
	tree nlist, c;

	if (!cp_parser_require (parser, CPP_OPEN_PAREN, "`('"))
	return list;

	switch (cp_lexer_peek_token (parser->lexer)->type)
	{
	case CPP_PLUS:
	code = PLUS_EXPR;
	break;
	case CPP_MULT:
	code = MULT_EXPR;
	break;
	case CPP_MINUS:
	code = MINUS_EXPR;
	break;
	case CPP_AND:
	code = BIT_AND_EXPR;
	break;
	case CPP_XOR:
	code = BIT_XOR_EXPR;
	break;
	case CPP_OR:
	code = BIT_IOR_EXPR;
	break;
	case CPP_AND_AND:
	code = TRUTH_ANDIF_EXPR;
	break;
	case CPP_OR_OR:
	code = TRUTH_ORIF_EXPR;
	break;
	default:
	cp_parser_error (parser, "`+', `*', `-', `&', `^', `\|', `&&', or `\|\|'");
	resync_fail:
	cp_parser_skip_to_closing_parenthesis (parser, /recovering=/true,
	/or_comma=/false,
	/consume_paren=/true);
	return list;
	}
	cp_lexer_consume_token (parser->lexer);

	if (!cp_parser_require (parser, CPP_COLON, "`:'"))
	goto resync_fail;

	nlist = cp_parser_omp_var_list_no_open (parser, OMP_CLAUSE_REDUCTION, list);
	for (c = nlist; c != list; c = OMP_CLAUSE_CHAIN (c))
	OMP_CLAUSE_REDUCTION_CODE (c) = code;

	return nlist;
	}

	/* OpenMP 2.5:
	schedule ( schedule-kind )
	schedule ( schedule-kind , expression )

	schedule-kind:
	static \| dynamic \| guided \| runtime */

	static tree
	cp_parser_omp_clause_schedule (cp_parser *parser, tree list)
	{
	tree c, t;

	if (!cp_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>"))
	return list;

	c = build_omp_clause (OMP_CLAUSE_SCHEDULE);

	if (cp_lexer_next_token_is (parser->lexer, CPP_NAME))
	{
	tree id = cp_lexer_peek_token (parser->lexer)->u.value;
	const char *p = IDENTIFIER_POINTER (id);

	switch (p[0])
	{
	case 'd':
	if (strcmp ("dynamic", p) != 0)
	goto invalid_kind;
	OMP_CLAUSE_SCHEDULE_KIND (c) = OMP_CLAUSE_SCHEDULE_DYNAMIC;
	break;

	case 'g':
	if (strcmp ("guided", p) != 0)
	goto invalid_kind;
	OMP_CLAUSE_SCHEDULE_KIND (c) = OMP_CLAUSE_SCHEDULE_GUIDED;
	break;

	case 'r':
	if (strcmp ("runtime", p) != 0)
	goto invalid_kind;
	OMP_CLAUSE_SCHEDULE_KIND (c) = OMP_CLAUSE_SCHEDULE_RUNTIME;
	break;

	default:
	goto invalid_kind;
	}
	}
	else if (cp_lexer_next_token_is_keyword (parser->lexer, RID_STATIC))
	OMP_CLAUSE_SCHEDULE_KIND (c) = OMP_CLAUSE_SCHEDULE_STATIC;
	else
	goto invalid_kind;
	cp_lexer_consume_token (parser->lexer);

	if (cp_lexer_next_token_is (parser->lexer, CPP_COMMA))
	{
	cp_lexer_consume_token (parser->lexer);

	t = cp_parser_assignment_expression (parser, false);

	if (t == error_mark_node)
	goto resync_fail;
	else if (OMP_CLAUSE_SCHEDULE_KIND (c) == OMP_CLAUSE_SCHEDULE_RUNTIME)
	error ("schedule %<runtime%> does not take "
	"a %<chunk_size%> parameter");
	else
	OMP_CLAUSE_SCHEDULE_CHUNK_EXPR (c) = t;

	if (!cp_parser_require (parser, CPP_CLOSE_PAREN, "`)'"))
	goto resync_fail;
	}
	else if (!cp_parser_require (parser, CPP_CLOSE_PAREN, "`,' or `)'"))
	goto resync_fail;

	check_no_duplicate_clause (list, OMP_CLAUSE_SCHEDULE, "schedule");
	OMP_CLAUSE_CHAIN (c) = list;
	return c;

	invalid_kind:
	cp_parser_error (parser, "invalid schedule kind");
	resync_fail:
	cp_parser_skip_to_closing_parenthesis (parser, /recovering=/true,
	/or_comma=/false,
	/consume_paren=/true);
	return list;
	}

	/* Parse all OpenMP clauses. The set clauses allowed by the directive
	is a bitmask in MASK. Return the list of clauses found; the result
	of clause default goes in pdefault. /

	static tree
	cp_parser_omp_all_clauses (cp_parser *parser, unsigned int mask,
	const char where, cp_token pragma_tok)
	{
	tree clauses = NULL;

	while (cp_lexer_next_token_is_not (parser->lexer, CPP_PRAGMA_EOL))
	{
	pragma_omp_clause c_kind = cp_parser_omp_clause_name (parser);
	const char *c_name;
	tree prev = clauses;

	switch (c_kind)
	{
	case PRAGMA_OMP_CLAUSE_COPYIN:
	clauses = cp_parser_omp_var_list (parser, OMP_CLAUSE_COPYIN, clauses);
	c_name = "copyin";
	break;
	case PRAGMA_OMP_CLAUSE_COPYPRIVATE:
	clauses = cp_parser_omp_var_list (parser, OMP_CLAUSE_COPYPRIVATE,
	clauses);
	c_name = "copyprivate";
	break;
	case PRAGMA_OMP_CLAUSE_DEFAULT:
	clauses = cp_parser_omp_clause_default (parser, clauses);
	c_name = "default";
	break;
	case PRAGMA_OMP_CLAUSE_FIRSTPRIVATE:
	clauses = cp_parser_omp_var_list (parser, OMP_CLAUSE_FIRSTPRIVATE,
	clauses);
	c_name = "firstprivate";
	break;
	case PRAGMA_OMP_CLAUSE_IF:
	clauses = cp_parser_omp_clause_if (parser, clauses);
	c_name = "if";
	break;
	case PRAGMA_OMP_CLAUSE_LASTPRIVATE:
	clauses = cp_parser_omp_var_list (parser, OMP_CLAUSE_LASTPRIVATE,
	clauses);
	c_name = "lastprivate";
	break;
	case PRAGMA_OMP_CLAUSE_NOWAIT:
	clauses = cp_parser_omp_clause_nowait (parser, clauses);
	c_name = "nowait";
	break;
	case PRAGMA_OMP_CLAUSE_NUM_THREADS:
	clauses = cp_parser_omp_clause_num_threads (parser, clauses);
	c_name = "num_threads";
	break;
	case PRAGMA_OMP_CLAUSE_ORDERED:
	clauses = cp_parser_omp_clause_ordered (parser, clauses);
	c_name = "ordered";
	break;
	case PRAGMA_OMP_CLAUSE_PRIVATE:
	clauses = cp_parser_omp_var_list (parser, OMP_CLAUSE_PRIVATE,
	clauses);
	c_name = "private";
	break;
	case PRAGMA_OMP_CLAUSE_REDUCTION:
	clauses = cp_parser_omp_clause_reduction (parser, clauses);
	c_name = "reduction";
	break;
	case PRAGMA_OMP_CLAUSE_SCHEDULE:
	clauses = cp_parser_omp_clause_schedule (parser, clauses);
	c_name = "schedule";
	break;
	case PRAGMA_OMP_CLAUSE_SHARED:
	clauses = cp_parser_omp_var_list (parser, OMP_CLAUSE_SHARED,
	clauses);
	c_name = "shared";
	break;
	default:
	cp_parser_error (parser, "expected %<#pragma omp%> clause");
	goto saw_error;
	}

	if (((mask >> c_kind) & 1) == 0)
	{
	/* Remove the invalid clause(s) from the list to avoid
	confusing the rest of the compiler. */
	clauses = prev;
	error ("%qs is not valid for %qs", c_name, where);
	}
	}
	saw_error:
	cp_parser_skip_to_pragma_eol (parser, pragma_tok);
	return finish_omp_clauses (clauses);
	}

	/* OpenMP 2.5:
	structured-block:
	statement

	In practice, we're also interested in adding the statement to an
	outer node. So it is convenient if we work around the fact that
	cp_parser_statement calls add_stmt. */

	static unsigned
	cp_parser_begin_omp_structured_block (cp_parser *parser)
	{
	unsigned save = parser->in_statement;

	/* Only move the values to IN_OMP_BLOCK if they weren't false.
	This preserves the "not within loop or switch" style error messages
	for nonsense cases like
	void foo() {
	#pragma omp single
	break;
	}
	*/
	if (parser->in_statement)
	parser->in_statement = IN_OMP_BLOCK;

	return save;
	}

	static void
	cp_parser_end_omp_structured_block (cp_parser *parser, unsigned save)
	{
	parser->in_statement = save;
	}

	static tree
	cp_parser_omp_structured_block (cp_parser *parser)
	{
	tree stmt = begin_omp_structured_block ();
	unsigned int save = cp_parser_begin_omp_structured_block (parser);

	cp_parser_statement (parser, NULL_TREE, false, NULL);

	cp_parser_end_omp_structured_block (parser, save);
	return finish_omp_structured_block (stmt);
	}

	/* OpenMP 2.5:
	# pragma omp atomic new-line
	expression-stmt

	expression-stmt:
	x binop= expr \| x++ \| ++x \| x-- \| --x
	binop:
	+, *, -, /, &, ^, \|, <<, >>

	where x is an lvalue expression with scalar type. */

	static void
	cp_parser_omp_atomic (cp_parser parser, cp_token pragma_tok)
	{
	tree lhs, rhs;
	enum tree_code code;

	cp_parser_require_pragma_eol (parser, pragma_tok);

	lhs = cp_parser_unary_expression (parser, /address_p=/false,
	/cast_p=/false);
	switch (TREE_CODE (lhs))
	{
	case ERROR_MARK:
	goto saw_error;

	case PREINCREMENT_EXPR:
	case POSTINCREMENT_EXPR:
	lhs = TREE_OPERAND (lhs, 0);
	code = PLUS_EXPR;
	rhs = integer_one_node;
	break;

	case PREDECREMENT_EXPR:
	case POSTDECREMENT_EXPR:
	lhs = TREE_OPERAND (lhs, 0);
	code = MINUS_EXPR;
	rhs = integer_one_node;
	break;

	default:
	switch (cp_lexer_peek_token (parser->lexer)->type)
	{
	case CPP_MULT_EQ:
	code = MULT_EXPR;
	break;
	case CPP_DIV_EQ:
	code = TRUNC_DIV_EXPR;
	break;
	case CPP_PLUS_EQ:
	code = PLUS_EXPR;
	break;
	case CPP_MINUS_EQ:
	code = MINUS_EXPR;
	break;
	case CPP_LSHIFT_EQ:
	code = LSHIFT_EXPR;
	break;
	case CPP_RSHIFT_EQ:
	code = RSHIFT_EXPR;
	break;
	case CPP_AND_EQ:
	code = BIT_AND_EXPR;
	break;
	case CPP_OR_EQ:
	code = BIT_IOR_EXPR;
	break;
	case CPP_XOR_EQ:
	code = BIT_XOR_EXPR;
	break;
	default:
	cp_parser_error (parser,
	"invalid operator for %<#pragma omp atomic%>");
	goto saw_error;
	}
	cp_lexer_consume_token (parser->lexer);

	rhs = cp_parser_expression (parser, false);
	if (rhs == error_mark_node)
	goto saw_error;
	break;
	}
	finish_omp_atomic (code, lhs, rhs);
	cp_parser_consume_semicolon_at_end_of_statement (parser);
	return;

	saw_error:
	cp_parser_skip_to_end_of_block_or_statement (parser);
	}


	/* OpenMP 2.5:
	# pragma omp barrier new-line */

	static void
	cp_parser_omp_barrier (cp_parser parser, cp_token pragma_tok)
	{
	cp_parser_require_pragma_eol (parser, pragma_tok);
	finish_omp_barrier ();
	}

	/* OpenMP 2.5:
	# pragma omp critical [(name)] new-line
	structured-block */

	static tree
	cp_parser_omp_critical (cp_parser parser, cp_token pragma_tok)
	{
	tree stmt, name = NULL;

	if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_PAREN))
	{
	cp_lexer_consume_token (parser->lexer);

	name = cp_parser_identifier (parser);

	if (name == error_mark_node
	\|\| !cp_parser_require (parser, CPP_CLOSE_PAREN, "`)'"))
	cp_parser_skip_to_closing_parenthesis (parser, /recovering=/true,
	/or_comma=/false,
	/consume_paren=/true);
	if (name == error_mark_node)
	name = NULL;
	}
	cp_parser_require_pragma_eol (parser, pragma_tok);

	stmt = cp_parser_omp_structured_block (parser);
	return c_finish_omp_critical (stmt, name);
	}

	/* OpenMP 2.5:
	# pragma omp flush flush-vars[opt] new-line

	flush-vars:
	( variable-list ) */

	static void
	cp_parser_omp_flush (cp_parser parser, cp_token pragma_tok)
	{
	if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_PAREN))
	(void) cp_parser_omp_var_list (parser, 0, NULL);
	cp_parser_require_pragma_eol (parser, pragma_tok);

	finish_omp_flush ();
	}

	/* Parse the restricted form of the for statment allowed by OpenMP. */

	static tree
	cp_parser_omp_for_loop (cp_parser *parser)
	{
	tree init, cond, incr, body, decl, pre_body;
	location_t loc;

	if (!cp_lexer_next_token_is_keyword (parser->lexer, RID_FOR))
	{
	cp_parser_error (parser, "for statement expected");
	return NULL;
	}
	loc = cp_lexer_consume_token (parser->lexer)->location;
	if (!cp_parser_require (parser, CPP_OPEN_PAREN, "`('"))
	return NULL;

	init = decl = NULL;
	pre_body = push_stmt_list ();
	if (cp_lexer_next_token_is_not (parser->lexer, CPP_SEMICOLON))
	{
	cp_decl_specifier_seq type_specifiers;

	/* First, try to parse as an initialized declaration. See
	cp_parser_condition, from whence the bulk of this is copied. */

	cp_parser_parse_tentatively (parser);
	cp_parser_type_specifier_seq (parser, /is_condition=/false,
	&type_specifiers);
	if (!cp_parser_error_occurred (parser))
	{
	tree asm_specification, attributes;
	cp_declarator *declarator;

	declarator = cp_parser_declarator (parser,
	CP_PARSER_DECLARATOR_NAMED,
	/ctor_dtor_or_conv_p=/NULL,
	/parenthesized_p=/NULL,
	/member_p=/false);
	attributes = cp_parser_attributes_opt (parser);
	asm_specification = cp_parser_asm_specification_opt (parser);

	cp_parser_require (parser, CPP_EQ, "`='");
	if (cp_parser_parse_definitely (parser))
	{
	tree pushed_scope;

	decl = start_decl (declarator, &type_specifiers,
	/initialized_p=/false, attributes,
	/prefix_attributes=/NULL_TREE,
	&pushed_scope);

	init = cp_parser_assignment_expression (parser, false);

	cp_finish_decl (decl, NULL_TREE, /init_const_expr_p=/false,
	asm_specification, LOOKUP_ONLYCONVERTING);

	if (pushed_scope)
	pop_scope (pushed_scope);
	}
	}
	else
	cp_parser_abort_tentative_parse (parser);

	/* If parsing as an initialized declaration failed, try again as
	a simple expression. */
	if (decl == NULL)
	init = cp_parser_expression (parser, false);
	}
	cp_parser_require (parser, CPP_SEMICOLON, "`;'");
	pre_body = pop_stmt_list (pre_body);

	cond = NULL;
	if (cp_lexer_next_token_is_not (parser->lexer, CPP_SEMICOLON))
	cond = cp_parser_condition (parser);
	cp_parser_require (parser, CPP_SEMICOLON, "`;'");

	incr = NULL;
	if (cp_lexer_next_token_is_not (parser->lexer, CPP_CLOSE_PAREN))
	incr = cp_parser_expression (parser, false);

	if (!cp_parser_require (parser, CPP_CLOSE_PAREN, "`)'"))
	cp_parser_skip_to_closing_parenthesis (parser, /recovering=/true,
	/or_comma=/false,
	/consume_paren=/true);

	/* Note that we saved the original contents of this flag when we entered
	the structured block, and so we don't need to re-save it here. */
	parser->in_statement = IN_OMP_FOR;

	/* Note that the grammar doesn't call for a structured block here,
	though the loop as a whole is a structured block. */
	body = push_stmt_list ();
	cp_parser_statement (parser, NULL_TREE, false, NULL);
	body = pop_stmt_list (body);

	return finish_omp_for (loc, decl, init, cond, incr, body, pre_body);
	}

	/* OpenMP 2.5:
	#pragma omp for for-clause[optseq] new-line
	for-loop */

	#define OMP_FOR_CLAUSE_MASK \
	( (1u << PRAGMA_OMP_CLAUSE_PRIVATE) \
	\| (1u << PRAGMA_OMP_CLAUSE_FIRSTPRIVATE) \
	\| (1u << PRAGMA_OMP_CLAUSE_LASTPRIVATE) \
	\| (1u << PRAGMA_OMP_CLAUSE_REDUCTION) \
	\| (1u << PRAGMA_OMP_CLAUSE_ORDERED) \
	\| (1u << PRAGMA_OMP_CLAUSE_SCHEDULE) \
	\| (1u << PRAGMA_OMP_CLAUSE_NOWAIT))

	static tree
	cp_parser_omp_for (cp_parser parser, cp_token pragma_tok)
	{
	tree clauses, sb, ret;
	unsigned int save;

	clauses = cp_parser_omp_all_clauses (parser, OMP_FOR_CLAUSE_MASK,
	"#pragma omp for", pragma_tok);

	sb = begin_omp_structured_block ();
	save = cp_parser_begin_omp_structured_block (parser);

	ret = cp_parser_omp_for_loop (parser);
	if (ret)
	OMP_FOR_CLAUSES (ret) = clauses;

	cp_parser_end_omp_structured_block (parser, save);
	add_stmt (finish_omp_structured_block (sb));

	return ret;
	}

	/* OpenMP 2.5:
	# pragma omp master new-line
	structured-block */

	static tree
	cp_parser_omp_master (cp_parser parser, cp_token pragma_tok)
	{
	cp_parser_require_pragma_eol (parser, pragma_tok);
	return c_finish_omp_master (cp_parser_omp_structured_block (parser));
	}

	/* OpenMP 2.5:
	# pragma omp ordered new-line
	structured-block */

	static tree
	cp_parser_omp_ordered (cp_parser parser, cp_token pragma_tok)
	{
	cp_parser_require_pragma_eol (parser, pragma_tok);
	return c_finish_omp_ordered (cp_parser_omp_structured_block (parser));
	}

	/* OpenMP 2.5:

	section-scope:
	{ section-sequence }

	section-sequence:
	section-directive[opt] structured-block
	section-sequence section-directive structured-block */

	static tree
	cp_parser_omp_sections_scope (cp_parser *parser)
	{
	tree stmt, substmt;
	bool error_suppress = false;
	cp_token *tok;

	if (!cp_parser_require (parser, CPP_OPEN_BRACE, "`{'"))
	return NULL_TREE;

	stmt = push_stmt_list ();

	if (cp_lexer_peek_token (parser->lexer)->pragma_kind != PRAGMA_OMP_SECTION)
	{
	unsigned save;

	substmt = begin_omp_structured_block ();
	save = cp_parser_begin_omp_structured_block (parser);

	while (1)
	{
	cp_parser_statement (parser, NULL_TREE, false, NULL);

	tok = cp_lexer_peek_token (parser->lexer);
	if (tok->pragma_kind == PRAGMA_OMP_SECTION)
	break;
	if (tok->type == CPP_CLOSE_BRACE)
	break;
	if (tok->type == CPP_EOF)
	break;
	}

	cp_parser_end_omp_structured_block (parser, save);
	substmt = finish_omp_structured_block (substmt);
	substmt = build1 (OMP_SECTION, void_type_node, substmt);
	add_stmt (substmt);
	}

	while (1)
	{
	tok = cp_lexer_peek_token (parser->lexer);
	if (tok->type == CPP_CLOSE_BRACE)
	break;
	if (tok->type == CPP_EOF)
	break;

	if (tok->pragma_kind == PRAGMA_OMP_SECTION)
	{
	cp_lexer_consume_token (parser->lexer);
	cp_parser_require_pragma_eol (parser, tok);
	error_suppress = false;
	}
	else if (!error_suppress)
	{
	cp_parser_error (parser, "expected %<#pragma omp section%> or %<}%>");
	error_suppress = true;
	}

	substmt = cp_parser_omp_structured_block (parser);
	substmt = build1 (OMP_SECTION, void_type_node, substmt);
	add_stmt (substmt);
	}
	cp_parser_require (parser, CPP_CLOSE_BRACE, "`}'");

	substmt = pop_stmt_list (stmt);

	stmt = make_node (OMP_SECTIONS);
	TREE_TYPE (stmt) = void_type_node;
	OMP_SECTIONS_BODY (stmt) = substmt;

	add_stmt (stmt);
	return stmt;
	}

	/* OpenMP 2.5:
	# pragma omp sections sections-clause[optseq] newline
	sections-scope */

	#define OMP_SECTIONS_CLAUSE_MASK \
	( (1u << PRAGMA_OMP_CLAUSE_PRIVATE) \
	\| (1u << PRAGMA_OMP_CLAUSE_FIRSTPRIVATE) \
	\| (1u << PRAGMA_OMP_CLAUSE_LASTPRIVATE) \
	\| (1u << PRAGMA_OMP_CLAUSE_REDUCTION) \
	\| (1u << PRAGMA_OMP_CLAUSE_NOWAIT))

	static tree
	cp_parser_omp_sections (cp_parser parser, cp_token pragma_tok)
	{
	tree clauses, ret;

	clauses = cp_parser_omp_all_clauses (parser, OMP_SECTIONS_CLAUSE_MASK,
	"#pragma omp sections", pragma_tok);

	ret = cp_parser_omp_sections_scope (parser);
	if (ret)
	OMP_SECTIONS_CLAUSES (ret) = clauses;

	return ret;
	}

	/* OpenMP 2.5:
	# pragma parallel parallel-clause new-line
	# pragma parallel for parallel-for-clause new-line
	# pragma parallel sections parallel-sections-clause new-line */

	#define OMP_PARALLEL_CLAUSE_MASK \
	( (1u << PRAGMA_OMP_CLAUSE_IF) \
	\| (1u << PRAGMA_OMP_CLAUSE_PRIVATE) \
	\| (1u << PRAGMA_OMP_CLAUSE_FIRSTPRIVATE) \
	\| (1u << PRAGMA_OMP_CLAUSE_DEFAULT) \
	\| (1u << PRAGMA_OMP_CLAUSE_SHARED) \
	\| (1u << PRAGMA_OMP_CLAUSE_COPYIN) \
	\| (1u << PRAGMA_OMP_CLAUSE_REDUCTION) \
	\| (1u << PRAGMA_OMP_CLAUSE_NUM_THREADS))

	static tree
	cp_parser_omp_parallel (cp_parser parser, cp_token pragma_tok)
	{
	enum pragma_kind p_kind = PRAGMA_OMP_PARALLEL;
	const char *p_name = "#pragma omp parallel";
	tree stmt, clauses, par_clause, ws_clause, block;
	unsigned int mask = OMP_PARALLEL_CLAUSE_MASK;
	unsigned int save;

	if (cp_lexer_next_token_is_keyword (parser->lexer, RID_FOR))
	{
	cp_lexer_consume_token (parser->lexer);
	p_kind = PRAGMA_OMP_PARALLEL_FOR;
	p_name = "#pragma omp parallel for";
	mask \|= OMP_FOR_CLAUSE_MASK;
	mask &= ~(1u << PRAGMA_OMP_CLAUSE_NOWAIT);
	}
	else if (cp_lexer_next_token_is (parser->lexer, CPP_NAME))
	{
	tree id = cp_lexer_peek_token (parser->lexer)->u.value;
	const char *p = IDENTIFIER_POINTER (id);
	if (strcmp (p, "sections") == 0)
	{
	cp_lexer_consume_token (parser->lexer);
	p_kind = PRAGMA_OMP_PARALLEL_SECTIONS;
	p_name = "#pragma omp parallel sections";
	mask \|= OMP_SECTIONS_CLAUSE_MASK;
	mask &= ~(1u << PRAGMA_OMP_CLAUSE_NOWAIT);
	}
	}

	clauses = cp_parser_omp_all_clauses (parser, mask, p_name, pragma_tok);
	block = begin_omp_parallel ();
	save = cp_parser_begin_omp_structured_block (parser);

	switch (p_kind)
	{
	case PRAGMA_OMP_PARALLEL:
	cp_parser_already_scoped_statement (parser);
	par_clause = clauses;
	break;

	case PRAGMA_OMP_PARALLEL_FOR:
	c_split_parallel_clauses (clauses, &par_clause, &ws_clause);
	stmt = cp_parser_omp_for_loop (parser);
	if (stmt)
	OMP_FOR_CLAUSES (stmt) = ws_clause;
	break;

	case PRAGMA_OMP_PARALLEL_SECTIONS:
	c_split_parallel_clauses (clauses, &par_clause, &ws_clause);
	stmt = cp_parser_omp_sections_scope (parser);
	if (stmt)
	OMP_SECTIONS_CLAUSES (stmt) = ws_clause;
	break;

	default:
	gcc_unreachable ();
	}

	cp_parser_end_omp_structured_block (parser, save);
	stmt = finish_omp_parallel (par_clause, block);
	if (p_kind != PRAGMA_OMP_PARALLEL)
	OMP_PARALLEL_COMBINED (stmt) = 1;
	return stmt;
	}

	/* OpenMP 2.5:
	# pragma omp single single-clause[optseq] new-line
	structured-block */

	#define OMP_SINGLE_CLAUSE_MASK \
	( (1u << PRAGMA_OMP_CLAUSE_PRIVATE) \
	\| (1u << PRAGMA_OMP_CLAUSE_FIRSTPRIVATE) \
	\| (1u << PRAGMA_OMP_CLAUSE_COPYPRIVATE) \
	\| (1u << PRAGMA_OMP_CLAUSE_NOWAIT))

	static tree
	cp_parser_omp_single (cp_parser parser, cp_token pragma_tok)
	{
	tree stmt = make_node (OMP_SINGLE);
	TREE_TYPE (stmt) = void_type_node;

	OMP_SINGLE_CLAUSES (stmt)
	= cp_parser_omp_all_clauses (parser, OMP_SINGLE_CLAUSE_MASK,
	"#pragma omp single", pragma_tok);
	OMP_SINGLE_BODY (stmt) = cp_parser_omp_structured_block (parser);

	return add_stmt (stmt);
	}

	/* OpenMP 2.5:
	# pragma omp threadprivate (variable-list) */

	static void
	cp_parser_omp_threadprivate (cp_parser parser, cp_token pragma_tok)
	{
	tree vars;

	vars = cp_parser_omp_var_list (parser, 0, NULL);
	cp_parser_require_pragma_eol (parser, pragma_tok);

	if (!targetm.have_tls)
	sorry ("threadprivate variables not supported in this target");

	finish_omp_threadprivate (vars);
	}

	/* Main entry point to OpenMP statement pragmas. */

	static void
	cp_parser_omp_construct (cp_parser parser, cp_token pragma_tok)
	{
	tree stmt;

	switch (pragma_tok->pragma_kind)
	{
	case PRAGMA_OMP_ATOMIC:
	cp_parser_omp_atomic (parser, pragma_tok);
	return;
	case PRAGMA_OMP_CRITICAL:
	stmt = cp_parser_omp_critical (parser, pragma_tok);
	break;
	case PRAGMA_OMP_FOR:
	stmt = cp_parser_omp_for (parser, pragma_tok);
	break;
	case PRAGMA_OMP_MASTER:
	stmt = cp_parser_omp_master (parser, pragma_tok);
	break;
	case PRAGMA_OMP_ORDERED:
	stmt = cp_parser_omp_ordered (parser, pragma_tok);
	break;
	case PRAGMA_OMP_PARALLEL:
	stmt = cp_parser_omp_parallel (parser, pragma_tok);
	break;
	case PRAGMA_OMP_SECTIONS:
	stmt = cp_parser_omp_sections (parser, pragma_tok);
	break;
	case PRAGMA_OMP_SINGLE:
	stmt = cp_parser_omp_single (parser, pragma_tok);
	break;
	default:
	gcc_unreachable ();
	}

	if (stmt)
	SET_EXPR_LOCATION (stmt, pragma_tok->location);
	}

	/* The parser. */

	static GTY (()) cp_parser *the_parser;


	/* Special handling for the first token or line in the file. The first
	thing in the file might be #pragma GCC pch_preprocess, which loads a
	PCH file, which is a GC collection point. So we need to handle this
	first pragma without benefit of an existing lexer structure.

	Always returns one token to the caller in *FIRST_TOKEN. This is
	either the true first token of the file, or the first token after
	the initial pragma. */

	static void
	cp_parser_initial_pragma (cp_token *first_token)
	{
	tree name = NULL;

	cp_lexer_get_preprocessor_token (NULL, first_token);
	if (first_token->pragma_kind != PRAGMA_GCC_PCH_PREPROCESS)
	return;

	cp_lexer_get_preprocessor_token (NULL, first_token);
	if (first_token->type == CPP_STRING)
	{
	name = first_token->u.value;

	cp_lexer_get_preprocessor_token (NULL, first_token);
	if (first_token->type != CPP_PRAGMA_EOL)
	error ("junk at end of %<#pragma GCC pch_preprocess%>");
	}
	else
	error ("expected string literal");

	/* Skip to the end of the pragma. */
	while (first_token->type != CPP_PRAGMA_EOL && first_token->type != CPP_EOF)
	cp_lexer_get_preprocessor_token (NULL, first_token);

	/* Now actually load the PCH file. */
	if (name)
	c_common_pch_pragma (parse_in, TREE_STRING_POINTER (name));

	/* Read one more token to return to our caller. We have to do this
	after reading the PCH file in, since its pointers have to be
	live. */
	cp_lexer_get_preprocessor_token (NULL, first_token);
	}

	/* Normal parsing of a pragma token. Here we can (and must) use the
	regular lexer. */

	static bool
	cp_parser_pragma (cp_parser *parser, enum pragma_context context)
	{
	cp_token *pragma_tok;
	unsigned int id;

	pragma_tok = cp_lexer_consume_token (parser->lexer);
	gcc_assert (pragma_tok->type == CPP_PRAGMA);
	parser->lexer->in_pragma = true;

	id = pragma_tok->pragma_kind;
	switch (id)
	{
	case PRAGMA_GCC_PCH_PREPROCESS:
	error ("%<#pragma GCC pch_preprocess%> must be first");
	break;

	case PRAGMA_OMP_BARRIER:
	switch (context)
	{
	case pragma_compound:
	cp_parser_omp_barrier (parser, pragma_tok);
	return false;
	case pragma_stmt:
	error ("%<#pragma omp barrier%> may only be "
	"used in compound statements");
	break;
	default:
	goto bad_stmt;
	}
	break;

	case PRAGMA_OMP_FLUSH:
	switch (context)
	{
	case pragma_compound:
	cp_parser_omp_flush (parser, pragma_tok);
	return false;
	case pragma_stmt:
	error ("%<#pragma omp flush%> may only be "
	"used in compound statements");
	break;
	default:
	goto bad_stmt;
	}
	break;

	case PRAGMA_OMP_THREADPRIVATE:
	cp_parser_omp_threadprivate (parser, pragma_tok);
	return false;

	case PRAGMA_OMP_ATOMIC:
	case PRAGMA_OMP_CRITICAL:
	case PRAGMA_OMP_FOR:
	case PRAGMA_OMP_MASTER:
	case PRAGMA_OMP_ORDERED:
	case PRAGMA_OMP_PARALLEL:
	case PRAGMA_OMP_SECTIONS:
	case PRAGMA_OMP_SINGLE:
	if (context == pragma_external)
	goto bad_stmt;
	cp_parser_omp_construct (parser, pragma_tok);
	return true;

	case PRAGMA_OMP_SECTION:
	error ("%<#pragma omp section%> may only be used in "
	"%<#pragma omp sections%> construct");
	break;

	default:
	gcc_assert (id >= PRAGMA_FIRST_EXTERNAL);
	c_invoke_pragma_handler (id);
	break;

	bad_stmt:
	cp_parser_error (parser, "expected declaration specifiers");
	break;
	}

	cp_parser_skip_to_pragma_eol (parser, pragma_tok);
	return false;
	}

	/* The interface the pragma parsers have to the lexer. */

	enum cpp_ttype
	pragma_lex (tree *value)
	{
	cp_token *tok;
	enum cpp_ttype ret;

	tok = cp_lexer_peek_token (the_parser->lexer);

	ret = tok->type;
	*value = tok->u.value;

	if (ret == CPP_PRAGMA_EOL \|\| ret == CPP_EOF)
	ret = CPP_EOF;
	else if (ret == CPP_STRING)
	*value = cp_parser_string_literal (the_parser, false, false);
	else
	{
	cp_lexer_consume_token (the_parser->lexer);
	if (ret == CPP_KEYWORD)
	ret = CPP_NAME;
	}

	return ret;
	}


	/* External interface. */

	/* Parse one entire translation unit. */

	void
	c_parse_file (void)
	{
	bool error_occurred;
	static bool already_called = false;

	if (already_called)
	{
	sorry ("inter-module optimizations not implemented for C++");
	return;
	}
	already_called = true;

	the_parser = cp_parser_new ();
	push_deferring_access_checks (flag_access_control
	? dk_no_deferred : dk_no_check);
	error_occurred = cp_parser_translation_unit (the_parser);
	the_parser = NULL;
	}

	/* This variable must be provided by every front end. */

	int yydebug;

	#include "gt-cp-parser.h"
	diff --git a/contrib/gcc/cp/pt.c b/contrib/gcc/cp/pt.c
	index 1a5c20ffac67..008f8f9be3c7 100644
	--- a/contrib/gcc/cp/pt.c
	+++ b/contrib/gcc/cp/pt.c
	@@ -1,13399 +1,13408 @@
	/* Handle parameterized types (templates) for GNU C++.
	Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
	2001, 2002, 2003, 2004, 2005 Free Software Foundation, Inc.
	Written by Ken Raeburn (raeburn@cygnus.com) while at Watchmaker Computing.
	Rewritten by Jason Merrill (jason@cygnus.com).

	This file is part of GCC.

	GCC is free software; you can redistribute it and/or modify
	it under the terms of the GNU General Public License as published by
	the Free Software Foundation; either version 2, or (at your option)
	any later version.

	GCC is distributed in the hope that it will be useful,
	but WITHOUT ANY WARRANTY; without even the implied warranty of
	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	GNU General Public License for more details.

	You should have received a copy of the GNU General Public License
	along with GCC; see the file COPYING. If not, write to
	the Free Software Foundation, 51 Franklin Street, Fifth Floor,
	Boston, MA 02110-1301, USA. */

	/* Known bugs or deficiencies include:

	all methods must be provided in header files; can't use a source
	file that contains only the method templates and "just win". */

	#include "config.h"
	#include "system.h"
	#include "coretypes.h"
	#include "tm.h"
	#include "obstack.h"
	#include "tree.h"
	#include "pointer-set.h"
	#include "flags.h"
	#include "c-common.h"
	#include "cp-tree.h"
	#include "cp-objcp-common.h"
	#include "tree-inline.h"
	#include "decl.h"
	#include "output.h"
	#include "except.h"
	#include "toplev.h"
	#include "rtl.h"
	#include "timevar.h"
	#include "tree-iterator.h"
	#include "vecprim.h"

	/* The type of functions taking a tree, and some additional data, and
	returning an int. */
	typedef int (tree_fn_t) (tree, void);

	/* The PENDING_TEMPLATES is a TREE_LIST of templates whose
	instantiations have been deferred, either because their definitions
	were not yet available, or because we were putting off doing the work.
	The TREE_PURPOSE of each entry is either a DECL (for a function or
	static data member), or a TYPE (for a class) indicating what we are
	hoping to instantiate. The TREE_VALUE is not used. */
	static GTY(()) tree pending_templates;
	static GTY(()) tree last_pending_template;

	int processing_template_parmlist;
	static int template_header_count;

	static GTY(()) tree saved_trees;
	static VEC(int,heap) *inline_parm_levels;

	static GTY(()) tree current_tinst_level;

	static GTY(()) tree saved_access_scope;

	/* Live only within one (recursive) call to tsubst_expr. We use
	this to pass the statement expression node from the STMT_EXPR
	to the EXPR_STMT that is its result. */
	static tree cur_stmt_expr;

	/* A map from local variable declarations in the body of the template
	presently being instantiated to the corresponding instantiated
	local variables. */
	static htab_t local_specializations;

	#define UNIFY_ALLOW_NONE 0
	#define UNIFY_ALLOW_MORE_CV_QUAL 1
	#define UNIFY_ALLOW_LESS_CV_QUAL 2
	#define UNIFY_ALLOW_DERIVED 4
	#define UNIFY_ALLOW_INTEGER 8
	#define UNIFY_ALLOW_OUTER_LEVEL 16
	#define UNIFY_ALLOW_OUTER_MORE_CV_QUAL 32
	#define UNIFY_ALLOW_OUTER_LESS_CV_QUAL 64

	static void push_access_scope (tree);
	static void pop_access_scope (tree);
	static bool resolve_overloaded_unification (tree, tree, tree, tree,
	unification_kind_t, int);
	static int try_one_overload (tree, tree, tree, tree, tree,
	unification_kind_t, int, bool);
	static int unify (tree, tree, tree, tree, int);
	static void add_pending_template (tree);
	static int push_tinst_level (tree);
	static void pop_tinst_level (void);
	static void reopen_tinst_level (tree);
	static tree classtype_mangled_name (tree);
	static char* mangle_class_name_for_template (const char *, tree, tree);
	static tree tsubst_initializer_list (tree, tree);
	static tree get_class_bindings (tree, tree, tree);
	static tree coerce_template_parms (tree, tree, tree, tsubst_flags_t,
	bool, bool);
	static void tsubst_enum (tree, tree, tree);
	static tree add_to_template_args (tree, tree);
	static tree add_outermost_template_args (tree, tree);
	static bool check_instantiated_args (tree, tree, tsubst_flags_t);
	static int maybe_adjust_types_for_deduction (unification_kind_t, tree, tree);
	static int type_unification_real (tree, tree, tree, tree,
	int, unification_kind_t, int);
	static void note_template_header (int);
	static tree convert_nontype_argument_function (tree, tree);
	static tree convert_nontype_argument (tree, tree);
	static tree convert_template_argument (tree, tree, tree,
	tsubst_flags_t, int, tree);
	static int for_each_template_parm (tree, tree_fn_t, void*,
	struct pointer_set_t*);
	static tree build_template_parm_index (int, int, int, tree, tree);
	static int inline_needs_template_parms (tree);
	static void push_inline_template_parms_recursive (tree, int);
	static tree retrieve_local_specialization (tree);
	static void register_local_specialization (tree, tree);
	static tree reduce_template_parm_level (tree, tree, int);
	static int mark_template_parm (tree, void *);
	static int template_parm_this_level_p (tree, void *);
	static tree tsubst_friend_function (tree, tree);
	static tree tsubst_friend_class (tree, tree);
	static int can_complete_type_without_circularity (tree);
	static tree get_bindings (tree, tree, tree, bool);
	static int template_decl_level (tree);
	static int check_cv_quals_for_unify (int, tree, tree);
	static tree tsubst_template_arg (tree, tree, tsubst_flags_t, tree);
	static tree tsubst_template_args (tree, tree, tsubst_flags_t, tree);
	static tree tsubst_template_parms (tree, tree, tsubst_flags_t);
	static void regenerate_decl_from_template (tree, tree);
	static tree most_specialized_class (tree, tree);
	static tree tsubst_aggr_type (tree, tree, tsubst_flags_t, tree, int);
	static tree tsubst_arg_types (tree, tree, tsubst_flags_t, tree);
	static tree tsubst_function_type (tree, tree, tsubst_flags_t, tree);
	static bool check_specialization_scope (void);
	static tree process_partial_specialization (tree);
	static void set_current_access_from_decl (tree);
	static void check_default_tmpl_args (tree, tree, int, int);
	static tree get_template_base (tree, tree, tree, tree);
	static tree try_class_unification (tree, tree, tree, tree);
	static int coerce_template_template_parms (tree, tree, tsubst_flags_t,
	tree, tree);
	static int template_args_equal (tree, tree);
	static void tsubst_default_arguments (tree);
	static tree for_each_template_parm_r (tree , int , void *);
	static tree copy_default_args_to_explicit_spec_1 (tree, tree);
	static void copy_default_args_to_explicit_spec (tree);
	static int invalid_nontype_parm_type_p (tree, tsubst_flags_t);
	static int eq_local_specializations (const void , const void );
	static bool dependent_type_p_r (tree);
	static tree tsubst (tree, tree, tsubst_flags_t, tree);
	static tree tsubst_expr (tree, tree, tsubst_flags_t, tree, bool);
	static tree tsubst_copy (tree, tree, tsubst_flags_t, tree);

	/* Make the current scope suitable for access checking when we are
	processing T. T can be FUNCTION_DECL for instantiated function
	template, or VAR_DECL for static member variable (need by
	instantiate_decl). */

	static void
	push_access_scope (tree t)
	{
	gcc_assert (TREE_CODE (t) == FUNCTION_DECL
	\|\| TREE_CODE (t) == VAR_DECL);

	if (DECL_FRIEND_CONTEXT (t))
	push_nested_class (DECL_FRIEND_CONTEXT (t));
	else if (DECL_CLASS_SCOPE_P (t))
	push_nested_class (DECL_CONTEXT (t));
	else
	push_to_top_level ();

	if (TREE_CODE (t) == FUNCTION_DECL)
	{
	saved_access_scope = tree_cons
	(NULL_TREE, current_function_decl, saved_access_scope);
	current_function_decl = t;
	}
	}

	/* Restore the scope set up by push_access_scope. T is the node we
	are processing. */

	static void
	pop_access_scope (tree t)
	{
	if (TREE_CODE (t) == FUNCTION_DECL)
	{
	current_function_decl = TREE_VALUE (saved_access_scope);
	saved_access_scope = TREE_CHAIN (saved_access_scope);
	}

	if (DECL_FRIEND_CONTEXT (t) \|\| DECL_CLASS_SCOPE_P (t))
	pop_nested_class ();
	else
	pop_from_top_level ();
	}

	/* Do any processing required when DECL (a member template
	declaration) is finished. Returns the TEMPLATE_DECL corresponding
	to DECL, unless it is a specialization, in which case the DECL
	itself is returned. */

	tree
	finish_member_template_decl (tree decl)
	{
	if (decl == error_mark_node)
	return error_mark_node;

	gcc_assert (DECL_P (decl));

	if (TREE_CODE (decl) == TYPE_DECL)
	{
	tree type;

	type = TREE_TYPE (decl);
	if (IS_AGGR_TYPE (type)
	&& CLASSTYPE_TEMPLATE_INFO (type)
	&& !CLASSTYPE_TEMPLATE_SPECIALIZATION (type))
	{
	tree tmpl = CLASSTYPE_TI_TEMPLATE (type);
	check_member_template (tmpl);
	return tmpl;
	}
	return NULL_TREE;
	}
	else if (TREE_CODE (decl) == FIELD_DECL)
	error ("data member %qD cannot be a member template", decl);
	else if (DECL_TEMPLATE_INFO (decl))
	{
	if (!DECL_TEMPLATE_SPECIALIZATION (decl))
	{
	check_member_template (DECL_TI_TEMPLATE (decl));
	return DECL_TI_TEMPLATE (decl);
	}
	else
	return decl;
	}
	else
	error ("invalid member template declaration %qD", decl);

	return error_mark_node;
	}

	/* Returns the template nesting level of the indicated class TYPE.

	For example, in:
	template <class T>
	struct A
	{
	template <class U>
	struct B {};
	};

	A<T>::B<U> has depth two, while A<T> has depth one.
	Both A<T>::B<int> and A<int>::B<U> have depth one, if
	they are instantiations, not specializations.

	This function is guaranteed to return 0 if passed NULL_TREE so
	that, for example, `template_class_depth (current_class_type)' is
	always safe. */

	int
	template_class_depth (tree type)
	{
	int depth;

	for (depth = 0;
	type && TREE_CODE (type) != NAMESPACE_DECL;
	type = (TREE_CODE (type) == FUNCTION_DECL)
	? CP_DECL_CONTEXT (type) : TYPE_CONTEXT (type))
	{
	if (TREE_CODE (type) != FUNCTION_DECL)
	{
	if (CLASSTYPE_TEMPLATE_INFO (type)
	&& PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (type))
	&& uses_template_parms (CLASSTYPE_TI_ARGS (type)))
	++depth;
	}
	else
	{
	if (DECL_TEMPLATE_INFO (type)
	&& PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (type))
	&& uses_template_parms (DECL_TI_ARGS (type)))
	++depth;
	}
	}

	return depth;
	}

	/* Returns 1 if processing DECL as part of do_pending_inlines
	needs us to push template parms. */

	static int
	inline_needs_template_parms (tree decl)
	{
	if (! DECL_TEMPLATE_INFO (decl))
	return 0;

	return (TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (most_general_template (decl)))
	> (processing_template_decl + DECL_TEMPLATE_SPECIALIZATION (decl)));
	}

	/* Subroutine of maybe_begin_member_template_processing.
	Push the template parms in PARMS, starting from LEVELS steps into the
	chain, and ending at the beginning, since template parms are listed
	innermost first. */

	static void
	push_inline_template_parms_recursive (tree parmlist, int levels)
	{
	tree parms = TREE_VALUE (parmlist);
	int i;

	if (levels > 1)
	push_inline_template_parms_recursive (TREE_CHAIN (parmlist), levels - 1);

	++processing_template_decl;
	current_template_parms
	= tree_cons (size_int (processing_template_decl),
	parms, current_template_parms);
	TEMPLATE_PARMS_FOR_INLINE (current_template_parms) = 1;

	begin_scope (TREE_VEC_LENGTH (parms) ? sk_template_parms : sk_template_spec,
	NULL);
	for (i = 0; i < TREE_VEC_LENGTH (parms); ++i)
	{
	tree parm = TREE_VALUE (TREE_VEC_ELT (parms, i));

	if (parm == error_mark_node)
	continue;

	gcc_assert (DECL_P (parm));

	switch (TREE_CODE (parm))
	{
	case TYPE_DECL:
	case TEMPLATE_DECL:
	pushdecl (parm);
	break;

	case PARM_DECL:
	{
	/* Make a CONST_DECL as is done in process_template_parm.
	It is ugly that we recreate this here; the original
	version built in process_template_parm is no longer
	available. */
	tree decl = build_decl (CONST_DECL, DECL_NAME (parm),
	TREE_TYPE (parm));
	DECL_ARTIFICIAL (decl) = 1;
	TREE_CONSTANT (decl) = 1;
	TREE_INVARIANT (decl) = 1;
	TREE_READONLY (decl) = 1;
	DECL_INITIAL (decl) = DECL_INITIAL (parm);
	SET_DECL_TEMPLATE_PARM_P (decl);
	pushdecl (decl);
	}
	break;

	default:
	gcc_unreachable ();
	}
	}
	}

	/* Restore the template parameter context for a member template or
	a friend template defined in a class definition. */

	void
	maybe_begin_member_template_processing (tree decl)
	{
	tree parms;
	int levels = 0;

	if (inline_needs_template_parms (decl))
	{
	parms = DECL_TEMPLATE_PARMS (most_general_template (decl));
	levels = TMPL_PARMS_DEPTH (parms) - processing_template_decl;

	if (DECL_TEMPLATE_SPECIALIZATION (decl))
	{
	--levels;
	parms = TREE_CHAIN (parms);
	}

	push_inline_template_parms_recursive (parms, levels);
	}

	/* Remember how many levels of template parameters we pushed so that
	we can pop them later. */
	VEC_safe_push (int, heap, inline_parm_levels, levels);
	}

	/* Undo the effects of maybe_begin_member_template_processing. */

	void
	maybe_end_member_template_processing (void)
	{
	int i;
	int last;

	if (VEC_length (int, inline_parm_levels) == 0)
	return;

	last = VEC_pop (int, inline_parm_levels);
	for (i = 0; i < last; ++i)
	{
	--processing_template_decl;
	current_template_parms = TREE_CHAIN (current_template_parms);
	poplevel (0, 0, 0);
	}
	}

	/* Return a new template argument vector which contains all of ARGS,
	but has as its innermost set of arguments the EXTRA_ARGS. */

	static tree
	add_to_template_args (tree args, tree extra_args)
	{
	tree new_args;
	int extra_depth;
	int i;
	int j;

	extra_depth = TMPL_ARGS_DEPTH (extra_args);
	new_args = make_tree_vec (TMPL_ARGS_DEPTH (args) + extra_depth);

	for (i = 1; i <= TMPL_ARGS_DEPTH (args); ++i)
	SET_TMPL_ARGS_LEVEL (new_args, i, TMPL_ARGS_LEVEL (args, i));

	for (j = 1; j <= extra_depth; ++j, ++i)
	SET_TMPL_ARGS_LEVEL (new_args, i, TMPL_ARGS_LEVEL (extra_args, j));

	return new_args;
	}

	/* Like add_to_template_args, but only the outermost ARGS are added to
	the EXTRA_ARGS. In particular, all but TMPL_ARGS_DEPTH
	(EXTRA_ARGS) levels are added. This function is used to combine
	the template arguments from a partial instantiation with the
	template arguments used to attain the full instantiation from the
	partial instantiation. */

	static tree
	add_outermost_template_args (tree args, tree extra_args)
	{
	tree new_args;

	/* If there are more levels of EXTRA_ARGS than there are ARGS,
	something very fishy is going on. */
	gcc_assert (TMPL_ARGS_DEPTH (args) >= TMPL_ARGS_DEPTH (extra_args));

	/* If all the new arguments will be the EXTRA_ARGS, just return
	them. */
	if (TMPL_ARGS_DEPTH (args) == TMPL_ARGS_DEPTH (extra_args))
	return extra_args;

	/* For the moment, we make ARGS look like it contains fewer levels. */
	TREE_VEC_LENGTH (args) -= TMPL_ARGS_DEPTH (extra_args);

	new_args = add_to_template_args (args, extra_args);

	/* Now, we restore ARGS to its full dimensions. */
	TREE_VEC_LENGTH (args) += TMPL_ARGS_DEPTH (extra_args);

	return new_args;
	}

	/* Return the N levels of innermost template arguments from the ARGS. */

	tree
	get_innermost_template_args (tree args, int n)
	{
	tree new_args;
	int extra_levels;
	int i;

	gcc_assert (n >= 0);

	/* If N is 1, just return the innermost set of template arguments. */
	if (n == 1)
	return TMPL_ARGS_LEVEL (args, TMPL_ARGS_DEPTH (args));

	/* If we're not removing anything, just return the arguments we were
	given. */
	extra_levels = TMPL_ARGS_DEPTH (args) - n;
	gcc_assert (extra_levels >= 0);
	if (extra_levels == 0)
	return args;

	/* Make a new set of arguments, not containing the outer arguments. */
	new_args = make_tree_vec (n);
	for (i = 1; i <= n; ++i)
	SET_TMPL_ARGS_LEVEL (new_args, i,
	TMPL_ARGS_LEVEL (args, i + extra_levels));

	return new_args;
	}

	/* We've got a template header coming up; push to a new level for storing
	the parms. */

	void
	begin_template_parm_list (void)
	{
	/* We use a non-tag-transparent scope here, which causes pushtag to
	put tags in this scope, rather than in the enclosing class or
	namespace scope. This is the right thing, since we want
	TEMPLATE_DECLS, and not TYPE_DECLS for template classes. For a
	global template class, push_template_decl handles putting the
	TEMPLATE_DECL into top-level scope. For a nested template class,
	e.g.:

	template <class T> struct S1 {
	template <class T> struct S2 {};
	};

	pushtag contains special code to call pushdecl_with_scope on the
	TEMPLATE_DECL for S2. */
	begin_scope (sk_template_parms, NULL);
	++processing_template_decl;
	++processing_template_parmlist;
	note_template_header (0);
	}

	/* This routine is called when a specialization is declared. If it is
	invalid to declare a specialization here, an error is reported and
	false is returned, otherwise this routine will return true. */

	static bool
	check_specialization_scope (void)
	{
	tree scope = current_scope ();

	/* [temp.expl.spec]

	An explicit specialization shall be declared in the namespace of
	which the template is a member, or, for member templates, in the
	namespace of which the enclosing class or enclosing class
	template is a member. An explicit specialization of a member
	function, member class or static data member of a class template
	shall be declared in the namespace of which the class template
	is a member. */
	if (scope && TREE_CODE (scope) != NAMESPACE_DECL)
	{
	error ("explicit specialization in non-namespace scope %qD", scope);
	return false;
	}

	/* [temp.expl.spec]

	In an explicit specialization declaration for a member of a class
	template or a member template that appears in namespace scope,
	the member template and some of its enclosing class templates may
	remain unspecialized, except that the declaration shall not
	explicitly specialize a class member template if its enclosing
	class templates are not explicitly specialized as well. */
	if (current_template_parms)
	{
	error ("enclosing class templates are not explicitly specialized");
	return false;
	}

	return true;
	}

	/* We've just seen template <>. */

	bool
	begin_specialization (void)
	{
	begin_scope (sk_template_spec, NULL);
	note_template_header (1);
	return check_specialization_scope ();
	}

	/* Called at then end of processing a declaration preceded by
	template<>. */

	void
	end_specialization (void)
	{
	finish_scope ();
	reset_specialization ();
	}

	/* Any template <>'s that we have seen thus far are not referring to a
	function specialization. */

	void
	reset_specialization (void)
	{
	processing_specialization = 0;
	template_header_count = 0;
	}

	/* We've just seen a template header. If SPECIALIZATION is nonzero,
	it was of the form template <>. */

	static void
	note_template_header (int specialization)
	{
	processing_specialization = specialization;
	template_header_count++;
	}

	/* We're beginning an explicit instantiation. */

	void
	begin_explicit_instantiation (void)
	{
	gcc_assert (!processing_explicit_instantiation);
	processing_explicit_instantiation = true;
	}


	void
	end_explicit_instantiation (void)
	{
	gcc_assert (processing_explicit_instantiation);
	processing_explicit_instantiation = false;
	}

	/* An explicit specialization or partial specialization TMPL is being
	declared. Check that the namespace in which the specialization is
	occurring is permissible. Returns false iff it is invalid to
	specialize TMPL in the current namespace. */

	static bool
	check_specialization_namespace (tree tmpl)
	{
	tree tpl_ns = decl_namespace_context (tmpl);

	/* [tmpl.expl.spec]

	An explicit specialization shall be declared in the namespace of
	which the template is a member, or, for member templates, in the
	namespace of which the enclosing class or enclosing class
	template is a member. An explicit specialization of a member
	function, member class or static data member of a class template
	shall be declared in the namespace of which the class template is
	a member. */
	if (is_associated_namespace (current_namespace, tpl_ns))
	/* Same or super-using namespace. */
	return true;
	else
	{
	pedwarn ("specialization of %qD in different namespace", tmpl);
	pedwarn (" from definition of %q+#D", tmpl);
	return false;
	}
	}

	/* SPEC is an explicit instantiation. Check that it is valid to
	perform this explicit instantiation in the current namespace. */

	static void
	check_explicit_instantiation_namespace (tree spec)
	{
	tree ns;

	/* DR 275: An explicit instantiation shall appear in an enclosing
	namespace of its template. */
	ns = decl_namespace_context (spec);
	if (!is_ancestor (current_namespace, ns))
	pedwarn ("explicit instantiation of %qD in namespace %qD "
	"(which does not enclose namespace %qD)",
	spec, current_namespace, ns);
	}

	/* The TYPE is being declared. If it is a template type, that means it
	is a partial specialization. Do appropriate error-checking. */

	tree
	maybe_process_partial_specialization (tree type)
	{
	tree context;

	if (type == error_mark_node)
	return error_mark_node;

	if (TREE_CODE (type) == BOUND_TEMPLATE_TEMPLATE_PARM)
	{
	error ("name of class shadows template template parameter %qD",
	TYPE_NAME (type));
	return error_mark_node;
	}

	context = TYPE_CONTEXT (type);

	if (CLASS_TYPE_P (type) && CLASSTYPE_USE_TEMPLATE (type))
	{
	/* This is for ordinary explicit specialization and partial
	specialization of a template class such as:

	template <> class C<int>;

	or:

	template <class T> class C<T*>;

	Make sure that `C<int>' and `C<T>' are implicit instantiations. /

	if (CLASSTYPE_IMPLICIT_INSTANTIATION (type)
	&& !COMPLETE_TYPE_P (type))
	{
	check_specialization_namespace (CLASSTYPE_TI_TEMPLATE (type));
	SET_CLASSTYPE_TEMPLATE_SPECIALIZATION (type);
	if (processing_template_decl)
	push_template_decl (TYPE_MAIN_DECL (type));
	}
	else if (CLASSTYPE_TEMPLATE_INSTANTIATION (type))
	error ("specialization of %qT after instantiation", type);
	}
	else if (CLASS_TYPE_P (type)
	&& !CLASSTYPE_USE_TEMPLATE (type)
	&& CLASSTYPE_TEMPLATE_INFO (type)
	&& context && CLASS_TYPE_P (context)
	&& CLASSTYPE_TEMPLATE_INFO (context))
	{
	/* This is for an explicit specialization of member class
	template according to [temp.expl.spec/18]:

	template <> template <class U> class C<int>::D;

	The context `C<int>' must be an implicit instantiation.
	Otherwise this is just a member class template declared
	earlier like:

	template <> class C<int> { template <class U> class D; };
	template <> template <class U> class C<int>::D;

	In the first case, `C<int>::D' is a specialization of `C<T>::D'
	while in the second case, `C<int>::D' is a primary template
	and `C<T>::D' may not exist. */

	if (CLASSTYPE_IMPLICIT_INSTANTIATION (context)
	&& !COMPLETE_TYPE_P (type))
	{
	tree t;

	if (current_namespace
	!= decl_namespace_context (CLASSTYPE_TI_TEMPLATE (type)))
	{
	pedwarn ("specializing %q#T in different namespace", type);
	pedwarn (" from definition of %q+#D",
	CLASSTYPE_TI_TEMPLATE (type));
	}

	/* Check for invalid specialization after instantiation:

	template <> template <> class C<int>::D<int>;
	template <> template <class U> class C<int>::D; */

	for (t = DECL_TEMPLATE_INSTANTIATIONS
	(most_general_template (CLASSTYPE_TI_TEMPLATE (type)));
	t; t = TREE_CHAIN (t))
	if (TREE_VALUE (t) != type
	&& TYPE_CONTEXT (TREE_VALUE (t)) == context)
	error ("specialization %qT after instantiation %qT",
	type, TREE_VALUE (t));

	/* Mark TYPE as a specialization. And as a result, we only
	have one level of template argument for the innermost
	class template. */
	SET_CLASSTYPE_TEMPLATE_SPECIALIZATION (type);
	CLASSTYPE_TI_ARGS (type)
	= INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (type));
	}
	}
	else if (processing_specialization)
	{
	error ("explicit specialization of non-template %qT", type);
	return error_mark_node;
	}

	return type;
	}

	/* Returns nonzero if we can optimize the retrieval of specializations
	for TMPL, a TEMPLATE_DECL. In particular, for such a template, we
	do not use DECL_TEMPLATE_SPECIALIZATIONS at all. */

	static inline bool
	optimize_specialization_lookup_p (tree tmpl)
	{
	return (DECL_FUNCTION_TEMPLATE_P (tmpl)
	&& DECL_CLASS_SCOPE_P (tmpl)
	/* DECL_CLASS_SCOPE_P holds of T::f even if T is a template
	parameter. */
	&& CLASS_TYPE_P (DECL_CONTEXT (tmpl))
	/* The optimized lookup depends on the fact that the
	template arguments for the member function template apply
	purely to the containing class, which is not true if the
	containing class is an explicit or partial
	specialization. */
	&& !CLASSTYPE_TEMPLATE_SPECIALIZATION (DECL_CONTEXT (tmpl))
	&& !DECL_MEMBER_TEMPLATE_P (tmpl)
	&& !DECL_CONV_FN_P (tmpl)
	/* It is possible to have a template that is not a member
	template and is not a member of a template class:

	template <typename T>
	struct S { friend A::f(); };

	Here, the friend function is a template, but the context does
	not have template information. The optimized lookup relies
	on having ARGS be the template arguments for both the class
	and the function template. */
	&& !DECL_FRIEND_P (DECL_TEMPLATE_RESULT (tmpl)));
	}

	/* Retrieve the specialization (in the sense of [temp.spec] - a
	specialization is either an instantiation or an explicit
	specialization) of TMPL for the given template ARGS. If there is
	no such specialization, return NULL_TREE. The ARGS are a vector of
	arguments, or a vector of vectors of arguments, in the case of
	templates with more than one level of parameters.

	If TMPL is a type template and CLASS_SPECIALIZATIONS_P is true,
	then we search for a partial specialization matching ARGS. This
	parameter is ignored if TMPL is not a class template. */

	static tree
	retrieve_specialization (tree tmpl, tree args,
	bool class_specializations_p)
	{
	if (args == error_mark_node)
	return NULL_TREE;

	gcc_assert (TREE_CODE (tmpl) == TEMPLATE_DECL);

	/* There should be as many levels of arguments as there are
	levels of parameters. */
	gcc_assert (TMPL_ARGS_DEPTH (args)
	== TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (tmpl)));

	if (optimize_specialization_lookup_p (tmpl))
	{
	tree class_template;
	tree class_specialization;
	VEC(tree,gc) *methods;
	tree fns;
	int idx;

	/* The template arguments actually apply to the containing
	class. Find the class specialization with those
	arguments. */
	class_template = CLASSTYPE_TI_TEMPLATE (DECL_CONTEXT (tmpl));
	class_specialization
	= retrieve_specialization (class_template, args,
	/class_specializations_p=/false);
	if (!class_specialization)
	return NULL_TREE;
	/* Now, find the appropriate entry in the CLASSTYPE_METHOD_VEC
	for the specialization. */
	idx = class_method_index_for_fn (class_specialization, tmpl);
	if (idx == -1)
	return NULL_TREE;
	/* Iterate through the methods with the indicated name, looking
	for the one that has an instance of TMPL. */
	methods = CLASSTYPE_METHOD_VEC (class_specialization);
	for (fns = VEC_index (tree, methods, idx); fns; fns = OVL_NEXT (fns))
	{
	tree fn = OVL_CURRENT (fns);
	if (DECL_TEMPLATE_INFO (fn) && DECL_TI_TEMPLATE (fn) == tmpl)
	return fn;
	}
	return NULL_TREE;
	}
	else
	{
	tree *sp;
	tree *head;

	/* Class templates store their instantiations on the
	DECL_TEMPLATE_INSTANTIATIONS list; other templates use the
	DECL_TEMPLATE_SPECIALIZATIONS list. */
	if (!class_specializations_p
	&& TREE_CODE (DECL_TEMPLATE_RESULT (tmpl)) == TYPE_DECL)
	sp = &DECL_TEMPLATE_INSTANTIATIONS (tmpl);
	else
	sp = &DECL_TEMPLATE_SPECIALIZATIONS (tmpl);
	head = sp;
	/* Iterate through the list until we find a matching template. */
	while (*sp != NULL_TREE)
	{
	tree spec = *sp;

	if (comp_template_args (TREE_PURPOSE (spec), args))
	{
	/* Use the move-to-front heuristic to speed up future
	searches. */
	if (spec != *head)
	{
	sp = TREE_CHAIN (sp);
	TREE_CHAIN (spec) = *head;
	*head = spec;
	}
	return TREE_VALUE (spec);
	}
	sp = &TREE_CHAIN (spec);
	}
	}

	return NULL_TREE;
	}

	/* Like retrieve_specialization, but for local declarations. */

	static tree
	retrieve_local_specialization (tree tmpl)
	{
	tree spec = (tree) htab_find_with_hash (local_specializations, tmpl,
	htab_hash_pointer (tmpl));
	return spec ? TREE_PURPOSE (spec) : NULL_TREE;
	}

	/* Returns nonzero iff DECL is a specialization of TMPL. */

	int
	is_specialization_of (tree decl, tree tmpl)
	{
	tree t;

	if (TREE_CODE (decl) == FUNCTION_DECL)
	{
	for (t = decl;
	t != NULL_TREE;
	t = DECL_TEMPLATE_INFO (t) ? DECL_TI_TEMPLATE (t) : NULL_TREE)
	if (t == tmpl)
	return 1;
	}
	else
	{
	gcc_assert (TREE_CODE (decl) == TYPE_DECL);

	for (t = TREE_TYPE (decl);
	t != NULL_TREE;
	t = CLASSTYPE_USE_TEMPLATE (t)
	? TREE_TYPE (CLASSTYPE_TI_TEMPLATE (t)) : NULL_TREE)
	if (same_type_ignoring_top_level_qualifiers_p (t, TREE_TYPE (tmpl)))
	return 1;
	}

	return 0;
	}

	/* Returns nonzero iff DECL is a specialization of friend declaration
	FRIEND according to [temp.friend]. */

	bool
	is_specialization_of_friend (tree decl, tree friend)
	{
	bool need_template = true;
	int template_depth;

	gcc_assert (TREE_CODE (decl) == FUNCTION_DECL
	\|\| TREE_CODE (decl) == TYPE_DECL);

	/* For [temp.friend/6] when FRIEND is an ordinary member function
	of a template class, we want to check if DECL is a specialization
	if this. */
	if (TREE_CODE (friend) == FUNCTION_DECL
	&& DECL_TEMPLATE_INFO (friend)
	&& !DECL_USE_TEMPLATE (friend))
	{
	/* We want a TEMPLATE_DECL for `is_specialization_of'. */
	friend = DECL_TI_TEMPLATE (friend);
	need_template = false;
	}
	else if (TREE_CODE (friend) == TEMPLATE_DECL
	&& !PRIMARY_TEMPLATE_P (friend))
	need_template = false;

	/* There is nothing to do if this is not a template friend. */
	if (TREE_CODE (friend) != TEMPLATE_DECL)
	return false;

	if (is_specialization_of (decl, friend))
	return true;

	/* [temp.friend/6]
	A member of a class template may be declared to be a friend of a
	non-template class. In this case, the corresponding member of
	every specialization of the class template is a friend of the
	class granting friendship.

	For example, given a template friend declaration

	template <class T> friend void A<T>::f();

	the member function below is considered a friend

	template <> struct A<int> {
	void f();
	};

	For this type of template friend, TEMPLATE_DEPTH below will be
	nonzero. To determine if DECL is a friend of FRIEND, we first
	check if the enclosing class is a specialization of another. */

	template_depth = template_class_depth (DECL_CONTEXT (friend));
	if (template_depth
	&& DECL_CLASS_SCOPE_P (decl)
	&& is_specialization_of (TYPE_NAME (DECL_CONTEXT (decl)),
	CLASSTYPE_TI_TEMPLATE (DECL_CONTEXT (friend))))
	{
	/* Next, we check the members themselves. In order to handle
	a few tricky cases, such as when FRIEND's are

	template <class T> friend void A<T>::g(T t);
	template <class T> template <T t> friend void A<T>::h();

	and DECL's are

	void A<int>::g(int);
	template <int> void A<int>::h();

	we need to figure out ARGS, the template arguments from
	the context of DECL. This is required for template substitution
	of `T' in the function parameter of `g' and template parameter
	of `h' in the above examples. Here ARGS corresponds to `int'. */

	tree context = DECL_CONTEXT (decl);
	tree args = NULL_TREE;
	int current_depth = 0;

	while (current_depth < template_depth)
	{
	if (CLASSTYPE_TEMPLATE_INFO (context))
	{
	if (current_depth == 0)
	args = TYPE_TI_ARGS (context);
	else
	args = add_to_template_args (TYPE_TI_ARGS (context), args);
	current_depth++;
	}
	context = TYPE_CONTEXT (context);
	}

	if (TREE_CODE (decl) == FUNCTION_DECL)
	{
	bool is_template;
	tree friend_type;
	tree decl_type;
	tree friend_args_type;
	tree decl_args_type;

	/* Make sure that both DECL and FRIEND are templates or
	non-templates. */
	is_template = DECL_TEMPLATE_INFO (decl)
	&& PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (decl));
	if (need_template ^ is_template)
	return false;
	else if (is_template)
	{
	/* If both are templates, check template parameter list. */
	tree friend_parms
	= tsubst_template_parms (DECL_TEMPLATE_PARMS (friend),
	args, tf_none);
	if (!comp_template_parms
	(DECL_TEMPLATE_PARMS (DECL_TI_TEMPLATE (decl)),
	friend_parms))
	return false;

	decl_type = TREE_TYPE (DECL_TI_TEMPLATE (decl));
	}
	else
	decl_type = TREE_TYPE (decl);

	friend_type = tsubst_function_type (TREE_TYPE (friend), args,
	tf_none, NULL_TREE);
	if (friend_type == error_mark_node)
	return false;

	/* Check if return types match. */
	if (!same_type_p (TREE_TYPE (decl_type), TREE_TYPE (friend_type)))
	return false;

	/* Check if function parameter types match, ignoring the
	`this' parameter. */
	friend_args_type = TYPE_ARG_TYPES (friend_type);
	decl_args_type = TYPE_ARG_TYPES (decl_type);
	if (DECL_NONSTATIC_MEMBER_FUNCTION_P (friend))
	friend_args_type = TREE_CHAIN (friend_args_type);
	if (DECL_NONSTATIC_MEMBER_FUNCTION_P (decl))
	decl_args_type = TREE_CHAIN (decl_args_type);

	return compparms (decl_args_type, friend_args_type);
	}
	else
	{
	/* DECL is a TYPE_DECL */
	bool is_template;
	tree decl_type = TREE_TYPE (decl);

	/* Make sure that both DECL and FRIEND are templates or
	non-templates. */
	is_template
	= CLASSTYPE_TEMPLATE_INFO (decl_type)
	&& PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (decl_type));

	if (need_template ^ is_template)
	return false;
	else if (is_template)
	{
	tree friend_parms;
	/* If both are templates, check the name of the two
	TEMPLATE_DECL's first because is_friend didn't. */
	if (DECL_NAME (CLASSTYPE_TI_TEMPLATE (decl_type))
	!= DECL_NAME (friend))
	return false;

	/* Now check template parameter list. */
	friend_parms
	= tsubst_template_parms (DECL_TEMPLATE_PARMS (friend),
	args, tf_none);
	return comp_template_parms
	(DECL_TEMPLATE_PARMS (CLASSTYPE_TI_TEMPLATE (decl_type)),
	friend_parms);
	}
	else
	return (DECL_NAME (decl)
	== DECL_NAME (friend));
	}
	}
	return false;
	}

	/* Register the specialization SPEC as a specialization of TMPL with
	the indicated ARGS. IS_FRIEND indicates whether the specialization
	is actually just a friend declaration. Returns SPEC, or an
	equivalent prior declaration, if available. */

	static tree
	register_specialization (tree spec, tree tmpl, tree args, bool is_friend)
	{
	tree fn;

	gcc_assert (TREE_CODE (tmpl) == TEMPLATE_DECL);

	if (TREE_CODE (spec) == FUNCTION_DECL
	&& uses_template_parms (DECL_TI_ARGS (spec)))
	/* This is the FUNCTION_DECL for a partial instantiation. Don't
	register it; we want the corresponding TEMPLATE_DECL instead.
	We use `uses_template_parms (DECL_TI_ARGS (spec))' rather than
	the more obvious `uses_template_parms (spec)' to avoid problems
	with default function arguments. In particular, given
	something like this:

	template <class T> void f(T t1, T t = T())

	the default argument expression is not substituted for in an
	instantiation unless and until it is actually needed. */
	return spec;

	fn = retrieve_specialization (tmpl, args,
	/class_specializations_p=/false);
	/* We can sometimes try to re-register a specialization that we've
	already got. In particular, regenerate_decl_from_template calls
	duplicate_decls which will update the specialization list. But,
	we'll still get called again here anyhow. It's more convenient
	to simply allow this than to try to prevent it. */
	if (fn == spec)
	return spec;
	else if (fn && DECL_TEMPLATE_SPECIALIZATION (spec))
	{
	if (DECL_TEMPLATE_INSTANTIATION (fn))
	{
	if (TREE_USED (fn)
	\|\| DECL_EXPLICIT_INSTANTIATION (fn))
	{
	error ("specialization of %qD after instantiation",
	fn);
	return error_mark_node;
	}
	else
	{
	tree clone;
	/* This situation should occur only if the first
	specialization is an implicit instantiation, the
	second is an explicit specialization, and the
	implicit instantiation has not yet been used. That
	situation can occur if we have implicitly
	instantiated a member function and then specialized
	it later.

	We can also wind up here if a friend declaration that
	looked like an instantiation turns out to be a
	specialization:

	template <class T> void foo(T);
	class S { friend void foo<>(int) };
	template <> void foo(int);

	We transform the existing DECL in place so that any
	pointers to it become pointers to the updated
	declaration.

	If there was a definition for the template, but not
	for the specialization, we want this to look as if
	there were no definition, and vice versa. */
	DECL_INITIAL (fn) = NULL_TREE;
	duplicate_decls (spec, fn, is_friend);
	/* The call to duplicate_decls will have applied
	[temp.expl.spec]:

	An explicit specialization of a function template
	is inline only if it is explicitly declared to be,
	and independently of whether its function template
	is.

	to the primary function; now copy the inline bits to
	the various clones. */
	FOR_EACH_CLONE (clone, fn)
	{
	DECL_DECLARED_INLINE_P (clone)
	= DECL_DECLARED_INLINE_P (fn);
	DECL_INLINE (clone)
	= DECL_INLINE (fn);
	}
	check_specialization_namespace (fn);

	return fn;
	}
	}
	else if (DECL_TEMPLATE_SPECIALIZATION (fn))
	{
	if (!duplicate_decls (spec, fn, is_friend) && DECL_INITIAL (spec))
	/* Dup decl failed, but this is a new definition. Set the
	line number so any errors match this new
	definition. */
	DECL_SOURCE_LOCATION (fn) = DECL_SOURCE_LOCATION (spec);

	return fn;
	}
	}

	/* A specialization must be declared in the same namespace as the
	template it is specializing. */
	if (DECL_TEMPLATE_SPECIALIZATION (spec)
	&& !check_specialization_namespace (tmpl))
	DECL_CONTEXT (spec) = FROB_CONTEXT (decl_namespace_context (tmpl));

	if (!optimize_specialization_lookup_p (tmpl))
	DECL_TEMPLATE_SPECIALIZATIONS (tmpl)
	= tree_cons (args, spec, DECL_TEMPLATE_SPECIALIZATIONS (tmpl));

	return spec;
	}

	/* Unregister the specialization SPEC as a specialization of TMPL.
	Replace it with NEW_SPEC, if NEW_SPEC is non-NULL. Returns true
	if the SPEC was listed as a specialization of TMPL. */

	bool
	reregister_specialization (tree spec, tree tmpl, tree new_spec)
	{
	tree* s;

	for (s = &DECL_TEMPLATE_SPECIALIZATIONS (tmpl);
	*s != NULL_TREE;
	s = &TREE_CHAIN (*s))
	if (TREE_VALUE (*s) == spec)
	{
	if (!new_spec)
	s = TREE_CHAIN (s);
	else
	TREE_VALUE (*s) = new_spec;
	return 1;
	}

	return 0;
	}

	/* Compare an entry in the local specializations hash table P1 (which
	is really a pointer to a TREE_LIST) with P2 (which is really a
	DECL). */

	static int
	eq_local_specializations (const void p1, const void p2)
	{
	return TREE_VALUE ((tree) p1) == (tree) p2;
	}

	/* Hash P1, an entry in the local specializations table. */

	static hashval_t
	hash_local_specialization (const void* p1)
	{
	return htab_hash_pointer (TREE_VALUE ((tree) p1));
	}

	/* Like register_specialization, but for local declarations. We are
	registering SPEC, an instantiation of TMPL. */

	static void
	register_local_specialization (tree spec, tree tmpl)
	{
	void **slot;

	slot = htab_find_slot_with_hash (local_specializations, tmpl,
	htab_hash_pointer (tmpl), INSERT);
	*slot = build_tree_list (spec, tmpl);
	}

	/* TYPE is a class type. Returns true if TYPE is an explicitly
	specialized class. */

	bool
	explicit_class_specialization_p (tree type)
	{
	if (!CLASSTYPE_TEMPLATE_SPECIALIZATION (type))
	return false;
	return !uses_template_parms (CLASSTYPE_TI_ARGS (type));
	}

	/* Print the list of candidate FNS in an error message. */

	void
	print_candidates (tree fns)
	{
	tree fn;

	const char *str = "candidates are:";

	for (fn = fns; fn != NULL_TREE; fn = TREE_CHAIN (fn))
	{
	tree f;

	for (f = TREE_VALUE (fn); f; f = OVL_NEXT (f))
	error ("%s %+#D", str, OVL_CURRENT (f));
	str = " ";
	}
	}

	/* Returns the template (one of the functions given by TEMPLATE_ID)
	which can be specialized to match the indicated DECL with the
	explicit template args given in TEMPLATE_ID. The DECL may be
	NULL_TREE if none is available. In that case, the functions in
	TEMPLATE_ID are non-members.

	If NEED_MEMBER_TEMPLATE is nonzero the function is known to be a
	specialization of a member template.

	The TEMPLATE_COUNT is the number of references to qualifying
	template classes that appeared in the name of the function. See
	check_explicit_specialization for a more accurate description.

	TSK indicates what kind of template declaration (if any) is being
	declared. TSK_TEMPLATE indicates that the declaration given by
	DECL, though a FUNCTION_DECL, has template parameters, and is
	therefore a template function.

	The template args (those explicitly specified and those deduced)
	are output in a newly created vector *TARGS_OUT.

	If it is impossible to determine the result, an error message is
	issued. The error_mark_node is returned to indicate failure. */

	static tree
	determine_specialization (tree template_id,
	tree decl,
	tree* targs_out,
	int need_member_template,
	int template_count,
	tmpl_spec_kind tsk)
	{
	tree fns;
	tree targs;
	tree explicit_targs;
	tree candidates = NULL_TREE;
	/* A TREE_LIST of templates of which DECL may be a specialization.
	The TREE_VALUE of each node is a TEMPLATE_DECL. The
	corresponding TREE_PURPOSE is the set of template arguments that,
	when used to instantiate the template, would produce a function
	with the signature of DECL. */
	tree templates = NULL_TREE;
	int header_count;
	struct cp_binding_level *b;

	*targs_out = NULL_TREE;

	if (template_id == error_mark_node \|\| decl == error_mark_node)
	return error_mark_node;

	fns = TREE_OPERAND (template_id, 0);
	explicit_targs = TREE_OPERAND (template_id, 1);

	if (fns == error_mark_node)
	return error_mark_node;

	/* Check for baselinks. */
	if (BASELINK_P (fns))
	fns = BASELINK_FUNCTIONS (fns);

	if (!is_overloaded_fn (fns))
	{
	error ("%qD is not a function template", fns);
	return error_mark_node;
	}

	/* Count the number of template headers specified for this
	specialization. */
	header_count = 0;
	for (b = current_binding_level;
	b->kind == sk_template_parms;
	b = b->level_chain)
	++header_count;

	for (; fns; fns = OVL_NEXT (fns))
	{
	tree fn = OVL_CURRENT (fns);

	if (TREE_CODE (fn) == TEMPLATE_DECL)
	{
	tree decl_arg_types;
	tree fn_arg_types;

	/* In case of explicit specialization, we need to check if
	the number of template headers appearing in the specialization
	is correct. This is usually done in check_explicit_specialization,
	but the check done there cannot be exhaustive when specializing
	member functions. Consider the following code:

	template <> void A<int>::f(int);
	template <> template <> void A<int>::f(int);

	Assuming that A<int> is not itself an explicit specialization
	already, the first line specializes "f" which is a non-template
	member function, whilst the second line specializes "f" which
	is a template member function. So both lines are syntactically
	correct, and check_explicit_specialization does not reject
	them.

	Here, we can do better, as we are matching the specialization
	against the declarations. We count the number of template
	headers, and we check if they match TEMPLATE_COUNT + 1
	(TEMPLATE_COUNT is the number of qualifying template classes,
	plus there must be another header for the member template
	itself).

	Notice that if header_count is zero, this is not a
	specialization but rather a template instantiation, so there
	is no check we can perform here. */
	if (header_count && header_count != template_count + 1)
	continue;

	/* Check that the number of template arguments at the
	innermost level for DECL is the same as for FN. */
	if (current_binding_level->kind == sk_template_parms
	&& !current_binding_level->explicit_spec_p
	&& (TREE_VEC_LENGTH (DECL_INNERMOST_TEMPLATE_PARMS (fn))
	!= TREE_VEC_LENGTH (INNERMOST_TEMPLATE_PARMS
	(current_template_parms))))
	continue;

	/* DECL might be a specialization of FN. */
	decl_arg_types = TYPE_ARG_TYPES (TREE_TYPE (decl));
	fn_arg_types = TYPE_ARG_TYPES (TREE_TYPE (fn));

	/* For a non-static member function, we need to make sure
	that the const qualification is the same. Since
	get_bindings does not try to merge the "this" parameter,
	we must do the comparison explicitly. */
	if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fn)
	&& !same_type_p (TREE_VALUE (fn_arg_types),
	TREE_VALUE (decl_arg_types)))
	continue;

	/* Skip the "this" parameter and, for constructors of
	classes with virtual bases, the VTT parameter. A
	full specialization of a constructor will have a VTT
	parameter, but a template never will. */
	decl_arg_types
	= skip_artificial_parms_for (decl, decl_arg_types);
	fn_arg_types
	= skip_artificial_parms_for (fn, fn_arg_types);

	/* Check that the number of function parameters matches.
	For example,
	template <class T> void f(int i = 0);
	template <> void f<int>();
	The specialization f<int> is invalid but is not caught
	by get_bindings below. */
	if (list_length (fn_arg_types) != list_length (decl_arg_types))
	continue;

	/* Function templates cannot be specializations; there are
	no partial specializations of functions. Therefore, if
	the type of DECL does not match FN, there is no
	match. */
	if (tsk == tsk_template)
	{
	if (compparms (fn_arg_types, decl_arg_types))
	candidates = tree_cons (NULL_TREE, fn, candidates);
	continue;
	}

	/* See whether this function might be a specialization of this
	template. */
	targs = get_bindings (fn, decl, explicit_targs, /check_ret=/true);

	if (!targs)
	/* We cannot deduce template arguments that when used to
	specialize TMPL will produce DECL. */
	continue;

	/* Save this template, and the arguments deduced. */
	templates = tree_cons (targs, fn, templates);
	}
	else if (need_member_template)
	/* FN is an ordinary member function, and we need a
	specialization of a member template. */
	;
	else if (TREE_CODE (fn) != FUNCTION_DECL)
	/* We can get IDENTIFIER_NODEs here in certain erroneous
	cases. */
	;
	else if (!DECL_FUNCTION_MEMBER_P (fn))
	/* This is just an ordinary non-member function. Nothing can
	be a specialization of that. */
	;
	else if (DECL_ARTIFICIAL (fn))
	/* Cannot specialize functions that are created implicitly. */
	;
	else
	{
	tree decl_arg_types;

	/* This is an ordinary member function. However, since
	we're here, we can assume it's enclosing class is a
	template class. For example,

	template <typename T> struct S { void f(); };
	template <> void S<int>::f() {}

	Here, S<int>::f is a non-template, but S<int> is a
	template class. If FN has the same type as DECL, we
	might be in business. */

	if (!DECL_TEMPLATE_INFO (fn))
	/* Its enclosing class is an explicit specialization
	of a template class. This is not a candidate. */
	continue;

	if (!same_type_p (TREE_TYPE (TREE_TYPE (decl)),
	TREE_TYPE (TREE_TYPE (fn))))
	/* The return types differ. */
	continue;

	/* Adjust the type of DECL in case FN is a static member. */
	decl_arg_types = TYPE_ARG_TYPES (TREE_TYPE (decl));
	if (DECL_STATIC_FUNCTION_P (fn)
	&& DECL_NONSTATIC_MEMBER_FUNCTION_P (decl))
	decl_arg_types = TREE_CHAIN (decl_arg_types);

	if (compparms (TYPE_ARG_TYPES (TREE_TYPE (fn)),
	decl_arg_types))
	/* They match! */
	candidates = tree_cons (NULL_TREE, fn, candidates);
	}
	}

	if (templates && TREE_CHAIN (templates))
	{
	/* We have:

	[temp.expl.spec]

	It is possible for a specialization with a given function
	signature to be instantiated from more than one function
	template. In such cases, explicit specification of the
	template arguments must be used to uniquely identify the
	function template specialization being specialized.

	Note that here, there's no suggestion that we're supposed to
	determine which of the candidate templates is most
	specialized. However, we, also have:

	[temp.func.order]

	Partial ordering of overloaded function template
	declarations is used in the following contexts to select
	the function template to which a function template
	specialization refers:

	-- when an explicit specialization refers to a function
	template.

	So, we do use the partial ordering rules, at least for now.
	This extension can only serve to make invalid programs valid,
	so it's safe. And, there is strong anecdotal evidence that
	the committee intended the partial ordering rules to apply;
	the EDG front-end has that behavior, and John Spicer claims
	that the committee simply forgot to delete the wording in
	[temp.expl.spec]. */
	tree tmpl = most_specialized_instantiation (templates);
	if (tmpl != error_mark_node)
	{
	templates = tmpl;
	TREE_CHAIN (templates) = NULL_TREE;
	}
	}

	if (templates == NULL_TREE && candidates == NULL_TREE)
	{
	error ("template-id %qD for %q+D does not match any template "
	"declaration", template_id, decl);
	return error_mark_node;
	}
	else if ((templates && TREE_CHAIN (templates))
	\|\| (candidates && TREE_CHAIN (candidates))
	\|\| (templates && candidates))
	{
	error ("ambiguous template specialization %qD for %q+D",
	template_id, decl);
	chainon (candidates, templates);
	print_candidates (candidates);
	return error_mark_node;
	}

	/* We have one, and exactly one, match. */
	if (candidates)
	{
	tree fn = TREE_VALUE (candidates);
	/* DECL is a re-declaration of a template function. */
	if (TREE_CODE (fn) == TEMPLATE_DECL)
	return fn;
	/* It was a specialization of an ordinary member function in a
	template class. */
	*targs_out = copy_node (DECL_TI_ARGS (fn));
	return DECL_TI_TEMPLATE (fn);
	}

	/* It was a specialization of a template. */
	targs = DECL_TI_ARGS (DECL_TEMPLATE_RESULT (TREE_VALUE (templates)));
	if (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (targs))
	{
	*targs_out = copy_node (targs);
	SET_TMPL_ARGS_LEVEL (*targs_out,
	TMPL_ARGS_DEPTH (*targs_out),
	TREE_PURPOSE (templates));
	}
	else
	*targs_out = TREE_PURPOSE (templates);
	return TREE_VALUE (templates);
	}

	/* Returns a chain of parameter types, exactly like the SPEC_TYPES,
	but with the default argument values filled in from those in the
	TMPL_TYPES. */

	static tree
	copy_default_args_to_explicit_spec_1 (tree spec_types,
	tree tmpl_types)
	{
	tree new_spec_types;

	if (!spec_types)
	return NULL_TREE;

	if (spec_types == void_list_node)
	return void_list_node;

	/* Substitute into the rest of the list. */
	new_spec_types =
	copy_default_args_to_explicit_spec_1 (TREE_CHAIN (spec_types),
	TREE_CHAIN (tmpl_types));

	/* Add the default argument for this parameter. */
	return hash_tree_cons (TREE_PURPOSE (tmpl_types),
	TREE_VALUE (spec_types),
	new_spec_types);
	}

	/* DECL is an explicit specialization. Replicate default arguments
	from the template it specializes. (That way, code like:

	template <class T> void f(T = 3);
	template <> void f(double);
	void g () { f (); }

	works, as required.) An alternative approach would be to look up
	the correct default arguments at the call-site, but this approach
	is consistent with how implicit instantiations are handled. */

	static void
	copy_default_args_to_explicit_spec (tree decl)
	{
	tree tmpl;
	tree spec_types;
	tree tmpl_types;
	tree new_spec_types;
	tree old_type;
	tree new_type;
	tree t;
	tree object_type = NULL_TREE;
	tree in_charge = NULL_TREE;
	tree vtt = NULL_TREE;

	/* See if there's anything we need to do. */
	tmpl = DECL_TI_TEMPLATE (decl);
	tmpl_types = TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (tmpl)));
	for (t = tmpl_types; t; t = TREE_CHAIN (t))
	if (TREE_PURPOSE (t))
	break;
	if (!t)
	return;

	old_type = TREE_TYPE (decl);
	spec_types = TYPE_ARG_TYPES (old_type);

	if (DECL_NONSTATIC_MEMBER_FUNCTION_P (decl))
	{
	/* Remove the this pointer, but remember the object's type for
	CV quals. */
	object_type = TREE_TYPE (TREE_VALUE (spec_types));
	spec_types = TREE_CHAIN (spec_types);
	tmpl_types = TREE_CHAIN (tmpl_types);

	if (DECL_HAS_IN_CHARGE_PARM_P (decl))
	{
	/* DECL may contain more parameters than TMPL due to the extra
	in-charge parameter in constructors and destructors. */
	in_charge = spec_types;
	spec_types = TREE_CHAIN (spec_types);
	}
	if (DECL_HAS_VTT_PARM_P (decl))
	{
	vtt = spec_types;
	spec_types = TREE_CHAIN (spec_types);
	}
	}

	/* Compute the merged default arguments. */
	new_spec_types =
	copy_default_args_to_explicit_spec_1 (spec_types, tmpl_types);

	/* Compute the new FUNCTION_TYPE. */
	if (object_type)
	{
	if (vtt)
	new_spec_types = hash_tree_cons (TREE_PURPOSE (vtt),
	TREE_VALUE (vtt),
	new_spec_types);

	if (in_charge)
	/* Put the in-charge parameter back. */
	new_spec_types = hash_tree_cons (TREE_PURPOSE (in_charge),
	TREE_VALUE (in_charge),
	new_spec_types);

	new_type = build_method_type_directly (object_type,
	TREE_TYPE (old_type),
	new_spec_types);
	}
	else
	new_type = build_function_type (TREE_TYPE (old_type),
	new_spec_types);
	new_type = cp_build_type_attribute_variant (new_type,
	TYPE_ATTRIBUTES (old_type));
	new_type = build_exception_variant (new_type,
	TYPE_RAISES_EXCEPTIONS (old_type));
	TREE_TYPE (decl) = new_type;
	}

	/* Check to see if the function just declared, as indicated in
	DECLARATOR, and in DECL, is a specialization of a function
	template. We may also discover that the declaration is an explicit
	instantiation at this point.

	Returns DECL, or an equivalent declaration that should be used
	instead if all goes well. Issues an error message if something is
	amiss. Returns error_mark_node if the error is not easily
	recoverable.

	FLAGS is a bitmask consisting of the following flags:

	2: The function has a definition.
	4: The function is a friend.

	The TEMPLATE_COUNT is the number of references to qualifying
	template classes that appeared in the name of the function. For
	example, in

	template <class T> struct S { void f(); };
	void S<int>::f();

	the TEMPLATE_COUNT would be 1. However, explicitly specialized
	classes are not counted in the TEMPLATE_COUNT, so that in

	template <class T> struct S {};
	template <> struct S<int> { void f(); }
	template <> void S<int>::f();

	the TEMPLATE_COUNT would be 0. (Note that this declaration is
	invalid; there should be no template <>.)

	If the function is a specialization, it is marked as such via
	DECL_TEMPLATE_SPECIALIZATION. Furthermore, its DECL_TEMPLATE_INFO
	is set up correctly, and it is added to the list of specializations
	for that template. */

	tree
	check_explicit_specialization (tree declarator,
	tree decl,
	int template_count,
	int flags)
	{
	int have_def = flags & 2;
	int is_friend = flags & 4;
	int specialization = 0;
	int explicit_instantiation = 0;
	int member_specialization = 0;
	tree ctype = DECL_CLASS_CONTEXT (decl);
	tree dname = DECL_NAME (decl);
	tmpl_spec_kind tsk;

	if (is_friend)
	{
	if (!processing_specialization)
	tsk = tsk_none;
	else
	tsk = tsk_excessive_parms;
	}
	else
	tsk = current_tmpl_spec_kind (template_count);

	switch (tsk)
	{
	case tsk_none:
	if (processing_specialization)
	{
	specialization = 1;
	SET_DECL_TEMPLATE_SPECIALIZATION (decl);
	}
	else if (TREE_CODE (declarator) == TEMPLATE_ID_EXPR)
	{
	if (is_friend)
	/* This could be something like:

	template <class T> void f(T);
	class S { friend void f<>(int); } */
	specialization = 1;
	else
	{
	/* This case handles bogus declarations like template <>
	template <class T> void f<int>(); */

	error ("template-id %qD in declaration of primary template",
	declarator);
	return decl;
	}
	}
	break;

	case tsk_invalid_member_spec:
	/* The error has already been reported in
	check_specialization_scope. */
	return error_mark_node;

	case tsk_invalid_expl_inst:
	error ("template parameter list used in explicit instantiation");

	/* Fall through. */

	case tsk_expl_inst:
	if (have_def)
	error ("definition provided for explicit instantiation");

	explicit_instantiation = 1;
	break;

	case tsk_excessive_parms:
	case tsk_insufficient_parms:
	if (tsk == tsk_excessive_parms)
	error ("too many template parameter lists in declaration of %qD",
	decl);
	else if (template_header_count)
	error("too few template parameter lists in declaration of %qD", decl);
	else
	error("explicit specialization of %qD must be introduced by "
	"%<template <>%>", decl);

	/* Fall through. */
	case tsk_expl_spec:
	SET_DECL_TEMPLATE_SPECIALIZATION (decl);
	if (ctype)
	member_specialization = 1;
	else
	specialization = 1;
	break;

	case tsk_template:
	if (TREE_CODE (declarator) == TEMPLATE_ID_EXPR)
	{
	/* This case handles bogus declarations like template <>
	template <class T> void f<int>(); */

	if (uses_template_parms (declarator))
	error ("function template partial specialization %qD "
	"is not allowed", declarator);
	else
	error ("template-id %qD in declaration of primary template",
	declarator);
	return decl;
	}

	if (ctype && CLASSTYPE_TEMPLATE_INSTANTIATION (ctype))
	/* This is a specialization of a member template, without
	specialization the containing class. Something like:

	template <class T> struct S {
	template <class U> void f (U);
	};
	template <> template <class U> void S<int>::f(U) {}

	That's a specialization -- but of the entire template. */
	specialization = 1;
	break;

	default:
	gcc_unreachable ();
	}

	if (specialization \|\| member_specialization)
	{
	tree t = TYPE_ARG_TYPES (TREE_TYPE (decl));
	for (; t; t = TREE_CHAIN (t))
	if (TREE_PURPOSE (t))
	{
	pedwarn
	("default argument specified in explicit specialization");
	break;
	}
	}

	if (specialization \|\| member_specialization \|\| explicit_instantiation)
	{
	tree tmpl = NULL_TREE;
	tree targs = NULL_TREE;

	/* Make sure that the declarator is a TEMPLATE_ID_EXPR. */
	if (TREE_CODE (declarator) != TEMPLATE_ID_EXPR)
	{
	tree fns;

	gcc_assert (TREE_CODE (declarator) == IDENTIFIER_NODE);
	if (ctype)
	fns = dname;
	else
	{
	/* If there is no class context, the explicit instantiation
	must be at namespace scope. */
	gcc_assert (DECL_NAMESPACE_SCOPE_P (decl));

	/* Find the namespace binding, using the declaration
	context. */
	fns = lookup_qualified_name (CP_DECL_CONTEXT (decl), dname,
	false, true);
	if (fns == error_mark_node \|\| !is_overloaded_fn (fns))
	{
	error ("%qD is not a template function", dname);
	fns = error_mark_node;
	}
	else
	{
	tree fn = OVL_CURRENT (fns);
	if (!is_associated_namespace (CP_DECL_CONTEXT (decl),
	CP_DECL_CONTEXT (fn)))
	error ("%qD is not declared in %qD",
	decl, current_namespace);
	}
	}

	declarator = lookup_template_function (fns, NULL_TREE);
	}

	if (declarator == error_mark_node)
	return error_mark_node;

	if (ctype != NULL_TREE && TYPE_BEING_DEFINED (ctype))
	{
	if (!explicit_instantiation)
	/* A specialization in class scope. This is invalid,
	but the error will already have been flagged by
	check_specialization_scope. */
	return error_mark_node;
	else
	{
	/* It's not valid to write an explicit instantiation in
	class scope, e.g.:

	class C { template void f(); }

	This case is caught by the parser. However, on
	something like:

	template class C { void f(); };

	(which is invalid) we can get here. The error will be
	issued later. */
	;
	}

	return decl;
	}
	else if (ctype != NULL_TREE
	&& (TREE_CODE (TREE_OPERAND (declarator, 0)) ==
	IDENTIFIER_NODE))
	{
	/* Find the list of functions in ctype that have the same
	name as the declared function. */
	tree name = TREE_OPERAND (declarator, 0);
	tree fns = NULL_TREE;
	int idx;

	if (constructor_name_p (name, ctype))
	{
	int is_constructor = DECL_CONSTRUCTOR_P (decl);

	if (is_constructor ? !TYPE_HAS_CONSTRUCTOR (ctype)
	: !CLASSTYPE_DESTRUCTORS (ctype))
	{
	/* From [temp.expl.spec]:

	If such an explicit specialization for the member
	of a class template names an implicitly-declared
	special member function (clause _special_), the
	program is ill-formed.

	Similar language is found in [temp.explicit]. */
	error ("specialization of implicitly-declared special member function");
	return error_mark_node;
	}

	name = is_constructor ? ctor_identifier : dtor_identifier;
	}

	if (!DECL_CONV_FN_P (decl))
	{
	idx = lookup_fnfields_1 (ctype, name);
	if (idx >= 0)
	fns = VEC_index (tree, CLASSTYPE_METHOD_VEC (ctype), idx);
	}
	else
	{
	VEC(tree,gc) *methods;
	tree ovl;

	/* For a type-conversion operator, we cannot do a
	name-based lookup. We might be looking for `operator
	int' which will be a specialization of `operator T'.
	So, we find all the conversion operators, and then
	select from them. */
	fns = NULL_TREE;

	methods = CLASSTYPE_METHOD_VEC (ctype);
	if (methods)
	for (idx = CLASSTYPE_FIRST_CONVERSION_SLOT;
	VEC_iterate (tree, methods, idx, ovl);
	++idx)
	{
	if (!DECL_CONV_FN_P (OVL_CURRENT (ovl)))
	/* There are no more conversion functions. */
	break;

	/* Glue all these conversion functions together
	with those we already have. */
	for (; ovl; ovl = OVL_NEXT (ovl))
	fns = ovl_cons (OVL_CURRENT (ovl), fns);
	}
	}

	if (fns == NULL_TREE)
	{
	error ("no member function %qD declared in %qT", name, ctype);
	return error_mark_node;
	}
	else
	TREE_OPERAND (declarator, 0) = fns;
	}

	/* Figure out what exactly is being specialized at this point.
	Note that for an explicit instantiation, even one for a
	member function, we cannot tell apriori whether the
	instantiation is for a member template, or just a member
	function of a template class. Even if a member template is
	being instantiated, the member template arguments may be
	elided if they can be deduced from the rest of the
	declaration. */
	tmpl = determine_specialization (declarator, decl,
	&targs,
	member_specialization,
	template_count,
	tsk);

	if (!tmpl \|\| tmpl == error_mark_node)
	/* We couldn't figure out what this declaration was
	specializing. */
	return error_mark_node;
	else
	{
	tree gen_tmpl = most_general_template (tmpl);

	if (explicit_instantiation)
	{
	/* We don't set DECL_EXPLICIT_INSTANTIATION here; that
	is done by do_decl_instantiation later. */

	int arg_depth = TMPL_ARGS_DEPTH (targs);
	int parm_depth = TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (tmpl));

	if (arg_depth > parm_depth)
	{
	/* If TMPL is not the most general template (for
	example, if TMPL is a friend template that is
	injected into namespace scope), then there will
	be too many levels of TARGS. Remove some of them
	here. */
	int i;
	tree new_targs;

	new_targs = make_tree_vec (parm_depth);
	for (i = arg_depth - parm_depth; i < arg_depth; ++i)
	TREE_VEC_ELT (new_targs, i - (arg_depth - parm_depth))
	= TREE_VEC_ELT (targs, i);
	targs = new_targs;
	}

	return instantiate_template (tmpl, targs, tf_error);
	}

	/* If we thought that the DECL was a member function, but it
	turns out to be specializing a static member function,
	make DECL a static member function as well. */
	if (DECL_STATIC_FUNCTION_P (tmpl)
	&& DECL_NONSTATIC_MEMBER_FUNCTION_P (decl))
	revert_static_member_fn (decl);

	/* If this is a specialization of a member template of a
	template class, we want to return the TEMPLATE_DECL, not
	the specialization of it. */
	if (tsk == tsk_template)
	{
	SET_DECL_TEMPLATE_SPECIALIZATION (tmpl);
	DECL_INITIAL (DECL_TEMPLATE_RESULT (tmpl)) = NULL_TREE;
	if (have_def)
	{
	DECL_SOURCE_LOCATION (tmpl) = DECL_SOURCE_LOCATION (decl);
	DECL_SOURCE_LOCATION (DECL_TEMPLATE_RESULT (tmpl))
	= DECL_SOURCE_LOCATION (decl);
	/* We want to use the argument list specified in the
	definition, not in the original declaration. */
	DECL_ARGUMENTS (DECL_TEMPLATE_RESULT (tmpl))
	= DECL_ARGUMENTS (decl);
	}
	return tmpl;
	}

	/* Set up the DECL_TEMPLATE_INFO for DECL. */
	DECL_TEMPLATE_INFO (decl) = tree_cons (tmpl, targs, NULL_TREE);

	/* Inherit default function arguments from the template
	DECL is specializing. */
	copy_default_args_to_explicit_spec (decl);

	/* This specialization has the same protection as the
	template it specializes. */
	TREE_PRIVATE (decl) = TREE_PRIVATE (gen_tmpl);
	TREE_PROTECTED (decl) = TREE_PROTECTED (gen_tmpl);

	/* If DECL is a friend declaration, declared using an
	unqualified name, the namespace associated with DECL may
	have been set incorrectly. For example, in:

	template <typename T> void f(T);
	namespace N {
	struct S { friend void f<int>(int); }
	}

	we will have set the DECL_CONTEXT for the friend
	declaration to N, rather than to the global namespace. */
	if (DECL_NAMESPACE_SCOPE_P (decl))
	DECL_CONTEXT (decl) = DECL_CONTEXT (tmpl);

	if (is_friend && !have_def)
	/* This is not really a declaration of a specialization.
	It's just the name of an instantiation. But, it's not
	a request for an instantiation, either. */
	SET_DECL_IMPLICIT_INSTANTIATION (decl);
	else if (DECL_CONSTRUCTOR_P (decl) \|\| DECL_DESTRUCTOR_P (decl))
	/* This is indeed a specialization. In case of constructors
	and destructors, we need in-charge and not-in-charge
	versions in V3 ABI. */
	clone_function_decl (decl, /update_method_vec_p=/0);

	/* Register this specialization so that we can find it
	again. */
	decl = register_specialization (decl, gen_tmpl, targs, is_friend);
	}
	}

	return decl;
	}

	/* Returns 1 iff PARMS1 and PARMS2 are identical sets of template
	parameters. These are represented in the same format used for
	DECL_TEMPLATE_PARMS. */

	int
	comp_template_parms (tree parms1, tree parms2)
	{
	tree p1;
	tree p2;

	if (parms1 == parms2)
	return 1;

	for (p1 = parms1, p2 = parms2;
	p1 != NULL_TREE && p2 != NULL_TREE;
	p1 = TREE_CHAIN (p1), p2 = TREE_CHAIN (p2))
	{
	tree t1 = TREE_VALUE (p1);
	tree t2 = TREE_VALUE (p2);
	int i;

	gcc_assert (TREE_CODE (t1) == TREE_VEC);
	gcc_assert (TREE_CODE (t2) == TREE_VEC);

	if (TREE_VEC_LENGTH (t1) != TREE_VEC_LENGTH (t2))
	return 0;

	for (i = 0; i < TREE_VEC_LENGTH (t2); ++i)
	{
	tree parm1 = TREE_VALUE (TREE_VEC_ELT (t1, i));
	tree parm2 = TREE_VALUE (TREE_VEC_ELT (t2, i));

	/* If either of the template parameters are invalid, assume
	they match for the sake of error recovery. */
	if (parm1 == error_mark_node \|\| parm2 == error_mark_node)
	return 1;

	if (TREE_CODE (parm1) != TREE_CODE (parm2))
	return 0;

	if (TREE_CODE (parm1) == TEMPLATE_TYPE_PARM)
	continue;
	else if (!same_type_p (TREE_TYPE (parm1), TREE_TYPE (parm2)))
	return 0;
	}
	}

	if ((p1 != NULL_TREE) != (p2 != NULL_TREE))
	/* One set of parameters has more parameters lists than the
	other. */
	return 0;

	return 1;
	}

	/* Complain if DECL shadows a template parameter.

	[temp.local]: A template-parameter shall not be redeclared within its
	scope (including nested scopes). */

	void
	check_template_shadow (tree decl)
	{
	tree olddecl;

	/* If we're not in a template, we can't possibly shadow a template
	parameter. */
	if (!current_template_parms)
	return;

	/* Figure out what we're shadowing. */
	if (TREE_CODE (decl) == OVERLOAD)
	decl = OVL_CURRENT (decl);
	olddecl = innermost_non_namespace_value (DECL_NAME (decl));

	/* If there's no previous binding for this name, we're not shadowing
	anything, let alone a template parameter. */
	if (!olddecl)
	return;

	/* If we're not shadowing a template parameter, we're done. Note
	that OLDDECL might be an OVERLOAD (or perhaps even an
	ERROR_MARK), so we can't just blithely assume it to be a _DECL
	node. */
	if (!DECL_P (olddecl) \|\| !DECL_TEMPLATE_PARM_P (olddecl))
	return;

	/* We check for decl != olddecl to avoid bogus errors for using a
	name inside a class. We check TPFI to avoid duplicate errors for
	inline member templates. */
	if (decl == olddecl
	\|\| TEMPLATE_PARMS_FOR_INLINE (current_template_parms))
	return;

	error ("declaration of %q+#D", decl);
	error (" shadows template parm %q+#D", olddecl);
	}

	/* Return a new TEMPLATE_PARM_INDEX with the indicated INDEX, LEVEL,
	ORIG_LEVEL, DECL, and TYPE. */

	static tree
	build_template_parm_index (int index,
	int level,
	int orig_level,
	tree decl,
	tree type)
	{
	tree t = make_node (TEMPLATE_PARM_INDEX);
	TEMPLATE_PARM_IDX (t) = index;
	TEMPLATE_PARM_LEVEL (t) = level;
	TEMPLATE_PARM_ORIG_LEVEL (t) = orig_level;
	TEMPLATE_PARM_DECL (t) = decl;
	TREE_TYPE (t) = type;
	TREE_CONSTANT (t) = TREE_CONSTANT (decl);
	TREE_INVARIANT (t) = TREE_INVARIANT (decl);
	TREE_READONLY (t) = TREE_READONLY (decl);

	return t;
	}

	/* Return a TEMPLATE_PARM_INDEX, similar to INDEX, but whose
	TEMPLATE_PARM_LEVEL has been decreased by LEVELS. If such a
	TEMPLATE_PARM_INDEX already exists, it is returned; otherwise, a
	new one is created. */

	static tree
	reduce_template_parm_level (tree index, tree type, int levels)
	{
	if (TEMPLATE_PARM_DESCENDANTS (index) == NULL_TREE
	\|\| (TEMPLATE_PARM_LEVEL (TEMPLATE_PARM_DESCENDANTS (index))
	!= TEMPLATE_PARM_LEVEL (index) - levels))
	{
	tree orig_decl = TEMPLATE_PARM_DECL (index);
	tree decl, t;

	decl = build_decl (TREE_CODE (orig_decl), DECL_NAME (orig_decl), type);
	TREE_CONSTANT (decl) = TREE_CONSTANT (orig_decl);
	TREE_INVARIANT (decl) = TREE_INVARIANT (orig_decl);
	TREE_READONLY (decl) = TREE_READONLY (orig_decl);
	DECL_ARTIFICIAL (decl) = 1;
	SET_DECL_TEMPLATE_PARM_P (decl);

	t = build_template_parm_index (TEMPLATE_PARM_IDX (index),
	TEMPLATE_PARM_LEVEL (index) - levels,
	TEMPLATE_PARM_ORIG_LEVEL (index),
	decl, type);
	TEMPLATE_PARM_DESCENDANTS (index) = t;

	/* Template template parameters need this. */
	if (TREE_CODE (decl) != CONST_DECL)
	DECL_TEMPLATE_PARMS (decl)
	= DECL_TEMPLATE_PARMS (TEMPLATE_PARM_DECL (index));
	}

	return TEMPLATE_PARM_DESCENDANTS (index);
	}

	/* Process information from new template parameter PARM and append it to the
	LIST being built. This new parameter is a non-type parameter iff
	IS_NON_TYPE is true. */

	tree
	process_template_parm (tree list, tree parm, bool is_non_type)
	{
	tree decl = 0;
	tree defval;
	tree err_parm_list;
	int idx = 0;

	gcc_assert (TREE_CODE (parm) == TREE_LIST);
	defval = TREE_PURPOSE (parm);

	if (list)
	{
	tree p = tree_last (list);

	if (p && TREE_VALUE (p) != error_mark_node)
	{
	p = TREE_VALUE (p);
	if (TREE_CODE (p) == TYPE_DECL \|\| TREE_CODE (p) == TEMPLATE_DECL)
	idx = TEMPLATE_TYPE_IDX (TREE_TYPE (p));
	else
	idx = TEMPLATE_PARM_IDX (DECL_INITIAL (p));
	}

	++idx;
	}
	else
	idx = 0;

	if (is_non_type)
	{
	parm = TREE_VALUE (parm);

	SET_DECL_TEMPLATE_PARM_P (parm);

	if (TREE_TYPE (parm) == error_mark_node)
	{
	err_parm_list = build_tree_list (defval, parm);
	TREE_VALUE (err_parm_list) = error_mark_node;
	return chainon (list, err_parm_list);
	}
	else
	{
	/* [temp.param]

	The top-level cv-qualifiers on the template-parameter are
	ignored when determining its type. */
	TREE_TYPE (parm) = TYPE_MAIN_VARIANT (TREE_TYPE (parm));
	if (invalid_nontype_parm_type_p (TREE_TYPE (parm), 1))
	{
	err_parm_list = build_tree_list (defval, parm);
	TREE_VALUE (err_parm_list) = error_mark_node;
	return chainon (list, err_parm_list);
	}
	}

	/* A template parameter is not modifiable. */
	TREE_CONSTANT (parm) = 1;
	TREE_INVARIANT (parm) = 1;
	TREE_READONLY (parm) = 1;
	decl = build_decl (CONST_DECL, DECL_NAME (parm), TREE_TYPE (parm));
	TREE_CONSTANT (decl) = 1;
	TREE_INVARIANT (decl) = 1;
	TREE_READONLY (decl) = 1;
	DECL_INITIAL (parm) = DECL_INITIAL (decl)
	= build_template_parm_index (idx, processing_template_decl,
	processing_template_decl,
	decl, TREE_TYPE (parm));
	}
	else
	{
	tree t;
	parm = TREE_VALUE (TREE_VALUE (parm));

	if (parm && TREE_CODE (parm) == TEMPLATE_DECL)
	{
	t = make_aggr_type (TEMPLATE_TEMPLATE_PARM);
	/* This is for distinguishing between real templates and template
	template parameters */
	TREE_TYPE (parm) = t;
	TREE_TYPE (DECL_TEMPLATE_RESULT (parm)) = t;
	decl = parm;
	}
	else
	{
	t = make_aggr_type (TEMPLATE_TYPE_PARM);
	/* parm is either IDENTIFIER_NODE or NULL_TREE. */
	decl = build_decl (TYPE_DECL, parm, t);
	}

	TYPE_NAME (t) = decl;
	TYPE_STUB_DECL (t) = decl;
	parm = decl;
	TEMPLATE_TYPE_PARM_INDEX (t)
	= build_template_parm_index (idx, processing_template_decl,
	processing_template_decl,
	decl, TREE_TYPE (parm));
	}
	DECL_ARTIFICIAL (decl) = 1;
	SET_DECL_TEMPLATE_PARM_P (decl);
	pushdecl (decl);
	parm = build_tree_list (defval, parm);
	return chainon (list, parm);
	}

	/* The end of a template parameter list has been reached. Process the
	tree list into a parameter vector, converting each parameter into a more
	useful form. Type parameters are saved as IDENTIFIER_NODEs, and others
	as PARM_DECLs. */

	tree
	end_template_parm_list (tree parms)
	{
	int nparms;
	tree parm, next;
	tree saved_parmlist = make_tree_vec (list_length (parms));

	current_template_parms
	= tree_cons (size_int (processing_template_decl),
	saved_parmlist, current_template_parms);

	for (parm = parms, nparms = 0; parm; parm = next, nparms++)
	{
	next = TREE_CHAIN (parm);
	TREE_VEC_ELT (saved_parmlist, nparms) = parm;
	TREE_CHAIN (parm) = NULL_TREE;
	}

	--processing_template_parmlist;

	return saved_parmlist;
	}

	/* end_template_decl is called after a template declaration is seen. */

	void
	end_template_decl (void)
	{
	reset_specialization ();

	if (! processing_template_decl)
	return;

	/* This matches the pushlevel in begin_template_parm_list. */
	finish_scope ();

	--processing_template_decl;
	current_template_parms = TREE_CHAIN (current_template_parms);
	}

	/* Given a template argument vector containing the template PARMS.
	The innermost PARMS are given first. */

	static tree
	current_template_args (void)
	{
	tree header;
	tree args = NULL_TREE;
	int length = TMPL_PARMS_DEPTH (current_template_parms);
	int l = length;

	/* If there is only one level of template parameters, we do not
	create a TREE_VEC of TREE_VECs. Instead, we return a single
	TREE_VEC containing the arguments. */
	if (length > 1)
	args = make_tree_vec (length);

	for (header = current_template_parms; header; header = TREE_CHAIN (header))
	{
	tree a = copy_node (TREE_VALUE (header));
	int i;

	TREE_TYPE (a) = NULL_TREE;
	for (i = TREE_VEC_LENGTH (a) - 1; i >= 0; --i)
	{
	tree t = TREE_VEC_ELT (a, i);

	/* T will be a list if we are called from within a
	begin/end_template_parm_list pair, but a vector directly
	if within a begin/end_member_template_processing pair. */
	if (TREE_CODE (t) == TREE_LIST)
	{
	t = TREE_VALUE (t);

	if (t != error_mark_node)
	{
	if (TREE_CODE (t) == TYPE_DECL
	\|\| TREE_CODE (t) == TEMPLATE_DECL)
	t = TREE_TYPE (t);
	else
	t = DECL_INITIAL (t);
	}

	TREE_VEC_ELT (a, i) = t;
	}
	}

	if (length > 1)
	TREE_VEC_ELT (args, --l) = a;
	else
	args = a;
	}

	return args;
	}

	/* Return a TEMPLATE_DECL corresponding to DECL, using the indicated
	template PARMS. If MEMBER_TEMPLATE_P is true, the new template is
	a member template. Used by push_template_decl below. */

	static tree
	build_template_decl (tree decl, tree parms, bool member_template_p)
	{
	tree tmpl = build_lang_decl (TEMPLATE_DECL, DECL_NAME (decl), NULL_TREE);
	DECL_TEMPLATE_PARMS (tmpl) = parms;
	DECL_CONTEXT (tmpl) = DECL_CONTEXT (decl);
	DECL_MEMBER_TEMPLATE_P (tmpl) = member_template_p;
	if (DECL_LANG_SPECIFIC (decl))
	{
	DECL_STATIC_FUNCTION_P (tmpl) = DECL_STATIC_FUNCTION_P (decl);
	DECL_CONSTRUCTOR_P (tmpl) = DECL_CONSTRUCTOR_P (decl);
	DECL_DESTRUCTOR_P (tmpl) = DECL_DESTRUCTOR_P (decl);
	DECL_NONCONVERTING_P (tmpl) = DECL_NONCONVERTING_P (decl);
	DECL_ASSIGNMENT_OPERATOR_P (tmpl) = DECL_ASSIGNMENT_OPERATOR_P (decl);
	if (DECL_OVERLOADED_OPERATOR_P (decl))
	SET_OVERLOADED_OPERATOR_CODE (tmpl,
	DECL_OVERLOADED_OPERATOR_P (decl));
	}

	return tmpl;
	}

	struct template_parm_data
	{
	/* The level of the template parameters we are currently
	processing. */
	int level;

	/* The index of the specialization argument we are currently
	processing. */
	int current_arg;

	/* An array whose size is the number of template parameters. The
	elements are nonzero if the parameter has been used in any one
	of the arguments processed so far. */
	int* parms;

	/* An array whose size is the number of template arguments. The
	elements are nonzero if the argument makes use of template
	parameters of this level. */
	int* arg_uses_template_parms;
	};

	/* Subroutine of push_template_decl used to see if each template
	parameter in a partial specialization is used in the explicit
	argument list. If T is of the LEVEL given in DATA (which is
	treated as a template_parm_data*), then DATA->PARMS is marked
	appropriately. */

	static int
	mark_template_parm (tree t, void* data)
	{
	int level;
	int idx;
	struct template_parm_data* tpd = (struct template_parm_data*) data;

	if (TREE_CODE (t) == TEMPLATE_PARM_INDEX)
	{
	level = TEMPLATE_PARM_LEVEL (t);
	idx = TEMPLATE_PARM_IDX (t);
	}
	else
	{
	level = TEMPLATE_TYPE_LEVEL (t);
	idx = TEMPLATE_TYPE_IDX (t);
	}

	if (level == tpd->level)
	{
	tpd->parms[idx] = 1;
	tpd->arg_uses_template_parms[tpd->current_arg] = 1;
	}

	/* Return zero so that for_each_template_parm will continue the
	traversal of the tree; we want to mark every template parm. */
	return 0;
	}

	/* Process the partial specialization DECL. */

	static tree
	process_partial_specialization (tree decl)
	{
	tree type = TREE_TYPE (decl);
	tree maintmpl = CLASSTYPE_TI_TEMPLATE (type);
	tree specargs = CLASSTYPE_TI_ARGS (type);
	tree inner_args = INNERMOST_TEMPLATE_ARGS (specargs);
	tree inner_parms = INNERMOST_TEMPLATE_PARMS (current_template_parms);
	tree main_inner_parms = DECL_INNERMOST_TEMPLATE_PARMS (maintmpl);
	int nargs = TREE_VEC_LENGTH (inner_args);
	int ntparms = TREE_VEC_LENGTH (inner_parms);
	int i;
	int did_error_intro = 0;
	struct template_parm_data tpd;
	struct template_parm_data tpd2;

	/* We check that each of the template parameters given in the
	partial specialization is used in the argument list to the
	specialization. For example:

	template <class T> struct S;
	template <class T> struct S<T*>;

	The second declaration is OK because `T*' uses the template
	parameter T, whereas

	template <class T> struct S<int>;

	is no good. Even trickier is:

	template <class T>
	struct S1
	{
	template <class U>
	struct S2;
	template <class U>
	struct S2<T>;
	};

	The S2<T> declaration is actually invalid; it is a
	full-specialization. Of course,

	template <class U>
	struct S2<T (*)(U)>;

	or some such would have been OK. */
	tpd.level = TMPL_PARMS_DEPTH (current_template_parms);
	tpd.parms = (int ) alloca (sizeof (int) ntparms);
	memset (tpd.parms, 0, sizeof (int) * ntparms);

	tpd.arg_uses_template_parms = (int ) alloca (sizeof (int) nargs);
	memset (tpd.arg_uses_template_parms, 0, sizeof (int) * nargs);
	for (i = 0; i < nargs; ++i)
	{
	tpd.current_arg = i;
	for_each_template_parm (TREE_VEC_ELT (inner_args, i),
	&mark_template_parm,
	&tpd,
	NULL);
	}
	for (i = 0; i < ntparms; ++i)
	if (tpd.parms[i] == 0)
	{
	/* One of the template parms was not used in the
	specialization. */
	if (!did_error_intro)
	{
	error ("template parameters not used in partial specialization:");
	did_error_intro = 1;
	}

	error (" %qD", TREE_VALUE (TREE_VEC_ELT (inner_parms, i)));
	}

	/* [temp.class.spec]

	The argument list of the specialization shall not be identical to
	the implicit argument list of the primary template. */
	if (comp_template_args
	(inner_args,
	INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (TREE_TYPE
	(maintmpl)))))
	error ("partial specialization %qT does not specialize any template arguments", type);

	/* [temp.class.spec]

	A partially specialized non-type argument expression shall not
	involve template parameters of the partial specialization except
	when the argument expression is a simple identifier.

	The type of a template parameter corresponding to a specialized
	non-type argument shall not be dependent on a parameter of the
	specialization. */
	gcc_assert (nargs == DECL_NTPARMS (maintmpl));
	tpd2.parms = 0;
	for (i = 0; i < nargs; ++i)
	{
	tree arg = TREE_VEC_ELT (inner_args, i);
	if (/* These first two lines are the `non-type' bit. */
	!TYPE_P (arg)
	&& TREE_CODE (arg) != TEMPLATE_DECL
	/* This next line is the `argument expression is not just a
	simple identifier' condition and also the `specialized
	non-type argument' bit. */
	&& TREE_CODE (arg) != TEMPLATE_PARM_INDEX)
	{
	if (tpd.arg_uses_template_parms[i])
	error ("template argument %qE involves template parameter(s)", arg);
	else
	{
	/* Look at the corresponding template parameter,
	marking which template parameters its type depends
	upon. */
	tree type =
	TREE_TYPE (TREE_VALUE (TREE_VEC_ELT (main_inner_parms,
	i)));

	if (!tpd2.parms)
	{
	/* We haven't yet initialized TPD2. Do so now. */
	tpd2.arg_uses_template_parms
	= (int ) alloca (sizeof (int) nargs);
	/* The number of parameters here is the number in the
	main template, which, as checked in the assertion
	above, is NARGS. */
	tpd2.parms = (int ) alloca (sizeof (int) nargs);
	tpd2.level =
	TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (maintmpl));
	}

	/* Mark the template parameters. But this time, we're
	looking for the template parameters of the main
	template, not in the specialization. */
	tpd2.current_arg = i;
	tpd2.arg_uses_template_parms[i] = 0;
	memset (tpd2.parms, 0, sizeof (int) * nargs);
	for_each_template_parm (type,
	&mark_template_parm,
	&tpd2,
	NULL);

	if (tpd2.arg_uses_template_parms [i])
	{
	/* The type depended on some template parameters.
	If they are fully specialized in the
	specialization, that's OK. */
	int j;
	for (j = 0; j < nargs; ++j)
	if (tpd2.parms[j] != 0
	&& tpd.arg_uses_template_parms [j])
	{
	error ("type %qT of template argument %qE depends "
	"on template parameter(s)",
	type,
	arg);
	break;
	}
	}
	}
	}
	}

	if (retrieve_specialization (maintmpl, specargs,
	/class_specializations_p=/true))
	/* We've already got this specialization. */
	return decl;

	DECL_TEMPLATE_SPECIALIZATIONS (maintmpl)
	= tree_cons (specargs, inner_parms,
	DECL_TEMPLATE_SPECIALIZATIONS (maintmpl));
	TREE_TYPE (DECL_TEMPLATE_SPECIALIZATIONS (maintmpl)) = type;
	return decl;
	}

	/* Check that a template declaration's use of default arguments is not
	invalid. Here, PARMS are the template parameters. IS_PRIMARY is
	nonzero if DECL is the thing declared by a primary template.
	IS_PARTIAL is nonzero if DECL is a partial specialization. */

	static void
	check_default_tmpl_args (tree decl, tree parms, int is_primary, int is_partial)
	{
	const char *msg;
	int last_level_to_check;
	tree parm_level;

	/* [temp.param]

	A default template-argument shall not be specified in a
	function template declaration or a function template definition, nor
	in the template-parameter-list of the definition of a member of a
	class template. */

	if (TREE_CODE (CP_DECL_CONTEXT (decl)) == FUNCTION_DECL)
	/* You can't have a function template declaration in a local
	scope, nor you can you define a member of a class template in a
	local scope. */
	return;

	if (current_class_type
	&& !TYPE_BEING_DEFINED (current_class_type)
	&& DECL_LANG_SPECIFIC (decl)
	/* If this is either a friend defined in the scope of the class
	or a member function. */
	&& (DECL_FUNCTION_MEMBER_P (decl)
	? same_type_p (DECL_CONTEXT (decl), current_class_type)
	: DECL_FRIEND_CONTEXT (decl)
	? same_type_p (DECL_FRIEND_CONTEXT (decl), current_class_type)
	: false)
	/* And, if it was a member function, it really was defined in
	the scope of the class. */
	&& (!DECL_FUNCTION_MEMBER_P (decl)
	\|\| DECL_INITIALIZED_IN_CLASS_P (decl)))
	/* We already checked these parameters when the template was
	declared, so there's no need to do it again now. This function
	was defined in class scope, but we're processing it's body now
	that the class is complete. */
	return;

	/* [temp.param]

	If a template-parameter has a default template-argument, all
	subsequent template-parameters shall have a default
	template-argument supplied. */
	for (parm_level = parms; parm_level; parm_level = TREE_CHAIN (parm_level))
	{
	tree inner_parms = TREE_VALUE (parm_level);
	int ntparms = TREE_VEC_LENGTH (inner_parms);
	int seen_def_arg_p = 0;
	int i;

	for (i = 0; i < ntparms; ++i)
	{
	tree parm = TREE_VEC_ELT (inner_parms, i);

	if (parm == error_mark_node)
	continue;

	if (TREE_PURPOSE (parm))
	seen_def_arg_p = 1;
	else if (seen_def_arg_p)
	{
	error ("no default argument for %qD", TREE_VALUE (parm));
	/* For better subsequent error-recovery, we indicate that
	there should have been a default argument. */
	TREE_PURPOSE (parm) = error_mark_node;
	}
	}
	}

	if (TREE_CODE (decl) != TYPE_DECL \|\| is_partial \|\| !is_primary)
	/* For an ordinary class template, default template arguments are
	allowed at the innermost level, e.g.:
	template <class T = int>
	struct S {};
	but, in a partial specialization, they're not allowed even
	there, as we have in [temp.class.spec]:

	The template parameter list of a specialization shall not
	contain default template argument values.

	So, for a partial specialization, or for a function template,
	we look at all of them. */
	;
	else
	/* But, for a primary class template that is not a partial
	specialization we look at all template parameters except the
	innermost ones. */
	parms = TREE_CHAIN (parms);

	/* Figure out what error message to issue. */
	if (TREE_CODE (decl) == FUNCTION_DECL)
	msg = "default template arguments may not be used in function templates";
	else if (is_partial)
	msg = "default template arguments may not be used in partial specializations";
	else
	msg = "default argument for template parameter for class enclosing %qD";

	if (current_class_type && TYPE_BEING_DEFINED (current_class_type))
	/* If we're inside a class definition, there's no need to
	examine the parameters to the class itself. On the one
	hand, they will be checked when the class is defined, and,
	on the other, default arguments are valid in things like:
	template <class T = double>
	struct S { template <class U> void f(U); };
	Here the default argument for `S' has no bearing on the
	declaration of `f'. */
	last_level_to_check = template_class_depth (current_class_type) + 1;
	else
	/* Check everything. */
	last_level_to_check = 0;

	for (parm_level = parms;
	parm_level && TMPL_PARMS_DEPTH (parm_level) >= last_level_to_check;
	parm_level = TREE_CHAIN (parm_level))
	{
	tree inner_parms = TREE_VALUE (parm_level);
	int i;
	int ntparms;

	ntparms = TREE_VEC_LENGTH (inner_parms);
	for (i = 0; i < ntparms; ++i)
	{
	if (TREE_VEC_ELT (inner_parms, i) == error_mark_node)
	continue;

	if (TREE_PURPOSE (TREE_VEC_ELT (inner_parms, i)))
	{
	if (msg)
	{
	error (msg, decl);
	msg = 0;
	}

	/* Clear out the default argument so that we are not
	confused later. */
	TREE_PURPOSE (TREE_VEC_ELT (inner_parms, i)) = NULL_TREE;
	}
	}

	/* At this point, if we're still interested in issuing messages,
	they must apply to classes surrounding the object declared. */
	if (msg)
	msg = "default argument for template parameter for class enclosing %qD";
	}
	}

	/* Worker for push_template_decl_real, called via
	for_each_template_parm. DATA is really an int, indicating the
	level of the parameters we are interested in. If T is a template
	parameter of that level, return nonzero. */

	static int
	template_parm_this_level_p (tree t, void* data)
	{
	int this_level = (int )data;
	int level;

	if (TREE_CODE (t) == TEMPLATE_PARM_INDEX)
	level = TEMPLATE_PARM_LEVEL (t);
	else
	level = TEMPLATE_TYPE_LEVEL (t);
	return level == this_level;
	}

	/* Creates a TEMPLATE_DECL for the indicated DECL using the template
	parameters given by current_template_args, or reuses a
	previously existing one, if appropriate. Returns the DECL, or an
	equivalent one, if it is replaced via a call to duplicate_decls.

	If IS_FRIEND is true, DECL is a friend declaration. */

	tree
	push_template_decl_real (tree decl, bool is_friend)
	{
	tree tmpl;
	tree args;
	tree info;
	tree ctx;
	int primary;
	int is_partial;
	int new_template_p = 0;
	/* True if the template is a member template, in the sense of
	[temp.mem]. */
	bool member_template_p = false;

	if (decl == error_mark_node)
	return decl;

	/* See if this is a partial specialization. */
	is_partial = (DECL_IMPLICIT_TYPEDEF_P (decl)
	&& TREE_CODE (TREE_TYPE (decl)) != ENUMERAL_TYPE
	&& CLASSTYPE_TEMPLATE_SPECIALIZATION (TREE_TYPE (decl)));

	if (TREE_CODE (decl) == FUNCTION_DECL && DECL_FRIEND_P (decl))
	is_friend = true;

	if (is_friend)
	/* For a friend, we want the context of the friend function, not
	the type of which it is a friend. */
	ctx = DECL_CONTEXT (decl);
	else if (CP_DECL_CONTEXT (decl)
	&& TREE_CODE (CP_DECL_CONTEXT (decl)) != NAMESPACE_DECL)
	/* In the case of a virtual function, we want the class in which
	it is defined. */
	ctx = CP_DECL_CONTEXT (decl);
	else
	/* Otherwise, if we're currently defining some class, the DECL
	is assumed to be a member of the class. */
	ctx = current_scope ();

	if (ctx && TREE_CODE (ctx) == NAMESPACE_DECL)
	ctx = NULL_TREE;

	if (!DECL_CONTEXT (decl))
	DECL_CONTEXT (decl) = FROB_CONTEXT (current_namespace);

	/* See if this is a primary template. */
	if (is_friend && ctx)
	/* A friend template that specifies a class context, i.e.
	template <typename T> friend void A<T>::f();
	is not primary. */
	primary = 0;
	else
	primary = template_parm_scope_p ();

	if (primary)
	{
	if (DECL_CLASS_SCOPE_P (decl))
	member_template_p = true;
	if (TREE_CODE (decl) == TYPE_DECL
	&& ANON_AGGRNAME_P (DECL_NAME (decl)))
	error ("template class without a name");
	else if (TREE_CODE (decl) == FUNCTION_DECL)
	{
	if (DECL_DESTRUCTOR_P (decl))
	{
	/* [temp.mem]

	A destructor shall not be a member template. */
	error ("destructor %qD declared as member template", decl);
	return error_mark_node;
	}
	if (NEW_DELETE_OPNAME_P (DECL_NAME (decl))
	&& (!TYPE_ARG_TYPES (TREE_TYPE (decl))
	\|\| TYPE_ARG_TYPES (TREE_TYPE (decl)) == void_list_node
	\|\| !TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (decl)))
	\|\| (TREE_CHAIN (TYPE_ARG_TYPES ((TREE_TYPE (decl))))
	== void_list_node)))
	{
	/* [basic.stc.dynamic.allocation]

	An allocation function can be a function
	template. ... Template allocation functions shall
	have two or more parameters. */
	error ("invalid template declaration of %qD", decl);
	return error_mark_node;
	}
	}
	else if (DECL_IMPLICIT_TYPEDEF_P (decl)
	&& CLASS_TYPE_P (TREE_TYPE (decl)))
	/* OK */;
	else
	{
	error ("template declaration of %q#D", decl);
	return error_mark_node;
	}
	}

	/* Check to see that the rules regarding the use of default
	arguments are not being violated. */
	check_default_tmpl_args (decl, current_template_parms,
	primary, is_partial);

	if (is_partial)
	return process_partial_specialization (decl);

	args = current_template_args ();

	if (!ctx
	\|\| TREE_CODE (ctx) == FUNCTION_DECL
	\|\| (CLASS_TYPE_P (ctx) && TYPE_BEING_DEFINED (ctx))
	\|\| (is_friend && !DECL_TEMPLATE_INFO (decl)))
	{
	if (DECL_LANG_SPECIFIC (decl)
	&& DECL_TEMPLATE_INFO (decl)
	&& DECL_TI_TEMPLATE (decl))
	tmpl = DECL_TI_TEMPLATE (decl);
	/* If DECL is a TYPE_DECL for a class-template, then there won't
	be DECL_LANG_SPECIFIC. The information equivalent to
	DECL_TEMPLATE_INFO is found in TYPE_TEMPLATE_INFO instead. */
	else if (DECL_IMPLICIT_TYPEDEF_P (decl)
	&& TYPE_TEMPLATE_INFO (TREE_TYPE (decl))
	&& TYPE_TI_TEMPLATE (TREE_TYPE (decl)))
	{
	/* Since a template declaration already existed for this
	class-type, we must be redeclaring it here. Make sure
	that the redeclaration is valid. */
	redeclare_class_template (TREE_TYPE (decl),
	current_template_parms);
	/* We don't need to create a new TEMPLATE_DECL; just use the
	one we already had. */
	tmpl = TYPE_TI_TEMPLATE (TREE_TYPE (decl));
	}
	else
	{
	tmpl = build_template_decl (decl, current_template_parms,
	member_template_p);
	new_template_p = 1;

	if (DECL_LANG_SPECIFIC (decl)
	&& DECL_TEMPLATE_SPECIALIZATION (decl))
	{
	/* A specialization of a member template of a template
	class. */
	SET_DECL_TEMPLATE_SPECIALIZATION (tmpl);
	DECL_TEMPLATE_INFO (tmpl) = DECL_TEMPLATE_INFO (decl);
	DECL_TEMPLATE_INFO (decl) = NULL_TREE;
	}
	}
	}
	else
	{
	tree a, t, current, parms;
	int i;

	if (TREE_CODE (decl) == TYPE_DECL)
	{
	if ((IS_AGGR_TYPE_CODE (TREE_CODE (TREE_TYPE (decl)))
	\|\| TREE_CODE (TREE_TYPE (decl)) == ENUMERAL_TYPE)
	&& TYPE_TEMPLATE_INFO (TREE_TYPE (decl))
	&& TYPE_TI_TEMPLATE (TREE_TYPE (decl)))
	tmpl = TYPE_TI_TEMPLATE (TREE_TYPE (decl));
	else
	{
	error ("%qD does not declare a template type", decl);
	return decl;
	}
	}
	else if (!DECL_LANG_SPECIFIC (decl) \|\| !DECL_TEMPLATE_INFO (decl))
	{
	error ("template definition of non-template %q#D", decl);
	return decl;
	}
	else
	tmpl = DECL_TI_TEMPLATE (decl);

	if (DECL_FUNCTION_TEMPLATE_P (tmpl)
	&& DECL_TEMPLATE_INFO (decl) && DECL_TI_ARGS (decl)
	&& DECL_TEMPLATE_SPECIALIZATION (decl)
	&& DECL_MEMBER_TEMPLATE_P (tmpl))
	{
	tree new_tmpl;

	/* The declaration is a specialization of a member
	template, declared outside the class. Therefore, the
	innermost template arguments will be NULL, so we
	replace them with the arguments determined by the
	earlier call to check_explicit_specialization. */
	args = DECL_TI_ARGS (decl);

	new_tmpl
	= build_template_decl (decl, current_template_parms,
	member_template_p);
	DECL_TEMPLATE_RESULT (new_tmpl) = decl;
	TREE_TYPE (new_tmpl) = TREE_TYPE (decl);
	DECL_TI_TEMPLATE (decl) = new_tmpl;
	SET_DECL_TEMPLATE_SPECIALIZATION (new_tmpl);
	DECL_TEMPLATE_INFO (new_tmpl)
	= tree_cons (tmpl, args, NULL_TREE);

	register_specialization (new_tmpl,
	most_general_template (tmpl),
	args,
	is_friend);
	return decl;
	}

	/* Make sure the template headers we got make sense. */

	parms = DECL_TEMPLATE_PARMS (tmpl);
	i = TMPL_PARMS_DEPTH (parms);
	if (TMPL_ARGS_DEPTH (args) != i)
	{
	error ("expected %d levels of template parms for %q#D, got %d",
	i, decl, TMPL_ARGS_DEPTH (args));
	}
	else
	for (current = decl; i > 0; --i, parms = TREE_CHAIN (parms))
	{
	a = TMPL_ARGS_LEVEL (args, i);
	t = INNERMOST_TEMPLATE_PARMS (parms);

	if (TREE_VEC_LENGTH (t) != TREE_VEC_LENGTH (a))
	{
	if (current == decl)
	error ("got %d template parameters for %q#D",
	TREE_VEC_LENGTH (a), decl);
	else
	error ("got %d template parameters for %q#T",
	TREE_VEC_LENGTH (a), current);
	error (" but %d required", TREE_VEC_LENGTH (t));
	return error_mark_node;
	}

	/* Perhaps we should also check that the parms are used in the
	appropriate qualifying scopes in the declarator? */

	if (current == decl)
	current = ctx;
	else
	current = TYPE_CONTEXT (current);
	}
	}

	DECL_TEMPLATE_RESULT (tmpl) = decl;
	TREE_TYPE (tmpl) = TREE_TYPE (decl);

	/* Push template declarations for global functions and types. Note
	that we do not try to push a global template friend declared in a
	template class; such a thing may well depend on the template
	parameters of the class. */
	if (new_template_p && !ctx
	&& !(is_friend && template_class_depth (current_class_type) > 0))
	{
	tmpl = pushdecl_namespace_level (tmpl, is_friend);
	if (tmpl == error_mark_node)
	return error_mark_node;

	/* Hide template friend classes that haven't been declared yet. */
	if (is_friend && TREE_CODE (decl) == TYPE_DECL)
	{
	DECL_ANTICIPATED (tmpl) = 1;
	DECL_FRIEND_P (tmpl) = 1;
	}
	}

	if (primary)
	{
	DECL_PRIMARY_TEMPLATE (tmpl) = tmpl;
	if (DECL_CONV_FN_P (tmpl))
	{
	int depth = TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (tmpl));

	/* It is a conversion operator. See if the type converted to
	depends on innermost template operands. */

	if (uses_template_parms_level (TREE_TYPE (TREE_TYPE (tmpl)),
	depth))
	DECL_TEMPLATE_CONV_FN_P (tmpl) = 1;
	}
	}

	/* The DECL_TI_ARGS of DECL contains full set of arguments referring
	back to its most general template. If TMPL is a specialization,
	ARGS may only have the innermost set of arguments. Add the missing
	argument levels if necessary. */
	if (DECL_TEMPLATE_INFO (tmpl))
	args = add_outermost_template_args (DECL_TI_ARGS (tmpl), args);

	info = tree_cons (tmpl, args, NULL_TREE);

	if (DECL_IMPLICIT_TYPEDEF_P (decl))
	{
	SET_TYPE_TEMPLATE_INFO (TREE_TYPE (tmpl), info);
	if ((!ctx \|\| TREE_CODE (ctx) != FUNCTION_DECL)
	&& TREE_CODE (TREE_TYPE (decl)) != ENUMERAL_TYPE
	/* Don't change the name if we've already set it up. */
	&& !IDENTIFIER_TEMPLATE (DECL_NAME (decl)))
	DECL_NAME (decl) = classtype_mangled_name (TREE_TYPE (decl));
	}
	else if (DECL_LANG_SPECIFIC (decl))
	DECL_TEMPLATE_INFO (decl) = info;

	return DECL_TEMPLATE_RESULT (tmpl);
	}

	tree
	push_template_decl (tree decl)
	{
	return push_template_decl_real (decl, false);
	}

	/* Called when a class template TYPE is redeclared with the indicated
	template PARMS, e.g.:

	template <class T> struct S;
	template <class T> struct S {}; */

	bool
	redeclare_class_template (tree type, tree parms)
	{
	tree tmpl;
	tree tmpl_parms;
	int i;

	if (!TYPE_TEMPLATE_INFO (type))
	{
	error ("%qT is not a template type", type);
	return false;
	}

	tmpl = TYPE_TI_TEMPLATE (type);
	if (!PRIMARY_TEMPLATE_P (tmpl))
	/* The type is nested in some template class. Nothing to worry
	about here; there are no new template parameters for the nested
	type. */
	return true;

	if (!parms)
	{
	error ("template specifiers not specified in declaration of %qD",
	tmpl);
	return false;
	}

	parms = INNERMOST_TEMPLATE_PARMS (parms);
	tmpl_parms = DECL_INNERMOST_TEMPLATE_PARMS (tmpl);

	if (TREE_VEC_LENGTH (parms) != TREE_VEC_LENGTH (tmpl_parms))
	{
	error ("previous declaration %q+D", tmpl);
	error ("used %d template parameter(s) instead of %d",
	TREE_VEC_LENGTH (tmpl_parms),
	TREE_VEC_LENGTH (parms));
	return false;
	}

	for (i = 0; i < TREE_VEC_LENGTH (tmpl_parms); ++i)
	{
	tree tmpl_parm;
	tree parm;
	tree tmpl_default;
	tree parm_default;

	if (TREE_VEC_ELT (tmpl_parms, i) == error_mark_node
	\|\| TREE_VEC_ELT (parms, i) == error_mark_node)
	continue;

	tmpl_parm = TREE_VALUE (TREE_VEC_ELT (tmpl_parms, i));
	parm = TREE_VALUE (TREE_VEC_ELT (parms, i));
	tmpl_default = TREE_PURPOSE (TREE_VEC_ELT (tmpl_parms, i));
	parm_default = TREE_PURPOSE (TREE_VEC_ELT (parms, i));

	/* TMPL_PARM and PARM can be either TYPE_DECL, PARM_DECL, or
	TEMPLATE_DECL. */
	if (tmpl_parm != error_mark_node
	&& (TREE_CODE (tmpl_parm) != TREE_CODE (parm)
	\|\| (TREE_CODE (tmpl_parm) != TYPE_DECL
	&& !same_type_p (TREE_TYPE (tmpl_parm), TREE_TYPE (parm)))))
	{
	error ("template parameter %q+#D", tmpl_parm);
	error ("redeclared here as %q#D", parm);
	return false;
	}

	if (tmpl_default != NULL_TREE && parm_default != NULL_TREE)
	{
	/* We have in [temp.param]:

	A template-parameter may not be given default arguments
	by two different declarations in the same scope. */
	error ("redefinition of default argument for %q#D", parm);
	error ("%J original definition appeared here", tmpl_parm);
	return false;
	}

	if (parm_default != NULL_TREE)
	/* Update the previous template parameters (which are the ones
	that will really count) with the new default value. */
	TREE_PURPOSE (TREE_VEC_ELT (tmpl_parms, i)) = parm_default;
	else if (tmpl_default != NULL_TREE)
	/* Update the new parameters, too; they'll be used as the
	parameters for any members. */
	TREE_PURPOSE (TREE_VEC_ELT (parms, i)) = tmpl_default;
	}

	return true;
	}

	/* Simplify EXPR if it is a non-dependent expression. Returns the
	(possibly simplified) expression. */

	tree
	fold_non_dependent_expr (tree expr)
	{
	if (expr == NULL_TREE)
	return NULL_TREE;

	/* If we're in a template, but EXPR isn't value dependent, simplify
	it. We're supposed to treat:

	template <typename T> void f(T[1 + 1]);
	template <typename T> void f(T[2]);

	as two declarations of the same function, for example. */
	if (processing_template_decl
	&& !type_dependent_expression_p (expr)
	&& !value_dependent_expression_p (expr))
	{
	HOST_WIDE_INT saved_processing_template_decl;

	saved_processing_template_decl = processing_template_decl;
	processing_template_decl = 0;
	expr = tsubst_copy_and_build (expr,
	/args=/NULL_TREE,
	tf_error,
	/in_decl=/NULL_TREE,
	/function_p=/false,
	/integral_constant_expression_p=/true);
	processing_template_decl = saved_processing_template_decl;
	}
	return expr;
	}

	/* EXPR is an expression which is used in a constant-expression context.
	For instance, it could be a VAR_DECL with a constant initializer.
	Extract the innest constant expression.

	This is basically a more powerful version of
	integral_constant_value, which can be used also in templates where
	initializers can maintain a syntactic rather than semantic form
	(even if they are non-dependent, for access-checking purposes). */

	static tree
	fold_decl_constant_value (tree expr)
	{
	tree const_expr = expr;
	do
	{
	expr = fold_non_dependent_expr (const_expr);
	const_expr = integral_constant_value (expr);
	}
	while (expr != const_expr);

	return expr;
	}

	/* Subroutine of convert_nontype_argument. Converts EXPR to TYPE, which
	must be a function or a pointer-to-function type, as specified
	in [temp.arg.nontype]: disambiguate EXPR if it is an overload set,
	and check that the resulting function has external linkage. */

	static tree
	convert_nontype_argument_function (tree type, tree expr)
	{
	tree fns = expr;
	tree fn, fn_no_ptr;

	fn = instantiate_type (type, fns, tf_none);
	if (fn == error_mark_node)
	return error_mark_node;

	fn_no_ptr = fn;
	if (TREE_CODE (fn_no_ptr) == ADDR_EXPR)
	fn_no_ptr = TREE_OPERAND (fn_no_ptr, 0);
	if (TREE_CODE (fn_no_ptr) == BASELINK)
	fn_no_ptr = BASELINK_FUNCTIONS (fn_no_ptr);

	/* [temp.arg.nontype]/1

	A template-argument for a non-type, non-template template-parameter
	shall be one of:
	[...]
	-- the address of an object or function with external linkage. */
	if (!DECL_EXTERNAL_LINKAGE_P (fn_no_ptr))
	{
	error ("%qE is not a valid template argument for type %qT "
	"because function %qD has not external linkage",
	expr, type, fn_no_ptr);
	return NULL_TREE;
	}

	return fn;
	}

	/* Attempt to convert the non-type template parameter EXPR to the
	indicated TYPE. If the conversion is successful, return the
	converted value. If the conversion is unsuccessful, return
	NULL_TREE if we issued an error message, or error_mark_node if we
	did not. We issue error messages for out-and-out bad template
	parameters, but not simply because the conversion failed, since we
	might be just trying to do argument deduction. Both TYPE and EXPR
	must be non-dependent.

	The conversion follows the special rules described in
	[temp.arg.nontype], and it is much more strict than an implicit
	conversion.

	This function is called twice for each template argument (see
	lookup_template_class for a more accurate description of this
	problem). This means that we need to handle expressions which
	are not valid in a C++ source, but can be created from the
	first call (for instance, casts to perform conversions). These
	hacks can go away after we fix the double coercion problem. */

	static tree
	convert_nontype_argument (tree type, tree expr)
	{
	tree expr_type;

	/* Detect immediately string literals as invalid non-type argument.
	This special-case is not needed for correctness (we would easily
	catch this later), but only to provide better diagnostic for this
	common user mistake. As suggested by DR 100, we do not mention
	linkage issues in the diagnostic as this is not the point. */
	if (TREE_CODE (expr) == STRING_CST)
	{
	error ("%qE is not a valid template argument for type %qT "
	"because string literals can never be used in this context",
	expr, type);
	return NULL_TREE;
	}

	/* If we are in a template, EXPR may be non-dependent, but still
	have a syntactic, rather than semantic, form. For example, EXPR
	might be a SCOPE_REF, rather than the VAR_DECL to which the
	SCOPE_REF refers. Preserving the qualifying scope is necessary
	so that access checking can be performed when the template is
	instantiated -- but here we need the resolved form so that we can
	convert the argument. */
	expr = fold_non_dependent_expr (expr);
	if (error_operand_p (expr))
	return error_mark_node;
	expr_type = TREE_TYPE (expr);

	/* HACK: Due to double coercion, we can get a
	NOP_EXPR<REFERENCE_TYPE>(ADDR_EXPR<POINTER_TYPE> (arg)) here,
	which is the tree that we built on the first call (see
	below when coercing to reference to object or to reference to
	function). We just strip everything and get to the arg.
	See g++.old-deja/g++.oliva/template4.C and g++.dg/template/nontype9.C
	for examples. */
	if (TREE_CODE (expr) == NOP_EXPR)
	{
	if (TYPE_REF_OBJ_P (type) \|\| TYPE_REFFN_P (type))
	{
	/* ??? Maybe we could use convert_from_reference here, but we
	would need to relax its constraints because the NOP_EXPR
	could actually change the type to something more cv-qualified,
	and this is not folded by convert_from_reference. */
	tree addr = TREE_OPERAND (expr, 0);
	gcc_assert (TREE_CODE (expr_type) == REFERENCE_TYPE);
	gcc_assert (TREE_CODE (addr) == ADDR_EXPR);
	gcc_assert (TREE_CODE (TREE_TYPE (addr)) == POINTER_TYPE);
	gcc_assert (same_type_ignoring_top_level_qualifiers_p
	(TREE_TYPE (expr_type),
	TREE_TYPE (TREE_TYPE (addr))));

	expr = TREE_OPERAND (addr, 0);
	expr_type = TREE_TYPE (expr);
	}

	/* We could also generate a NOP_EXPR(ADDR_EXPR()) when the
	parameter is a pointer to object, through decay and
	qualification conversion. Let's strip everything. */
	else if (TYPE_PTROBV_P (type))
	{
	STRIP_NOPS (expr);
	gcc_assert (TREE_CODE (expr) == ADDR_EXPR);
	gcc_assert (TREE_CODE (TREE_TYPE (expr)) == POINTER_TYPE);
	/* Skip the ADDR_EXPR only if it is part of the decay for
	an array. Otherwise, it is part of the original argument
	in the source code. */
	if (TREE_CODE (TREE_TYPE (TREE_OPERAND (expr, 0))) == ARRAY_TYPE)
	expr = TREE_OPERAND (expr, 0);
	expr_type = TREE_TYPE (expr);
	}
	}

	/* [temp.arg.nontype]/5, bullet 1

	For a non-type template-parameter of integral or enumeration type,
	integral promotions (_conv.prom_) and integral conversions
	(_conv.integral_) are applied. */
	if (INTEGRAL_TYPE_P (type))
	{
	if (!INTEGRAL_TYPE_P (expr_type))
	return error_mark_node;

	expr = fold_decl_constant_value (expr);
	/* Notice that there are constant expressions like '4 % 0' which
	do not fold into integer constants. */
	if (TREE_CODE (expr) != INTEGER_CST)
	{
	error ("%qE is not a valid template argument for type %qT "
	"because it is a non-constant expression", expr, type);
	return NULL_TREE;
	}

	/* At this point, an implicit conversion does what we want,
	because we already know that the expression is of integral
	type. */
	expr = ocp_convert (type, expr, CONV_IMPLICIT, LOOKUP_PROTECT);
	if (expr == error_mark_node)
	return error_mark_node;

	/* Conversion was allowed: fold it to a bare integer constant. */
	expr = fold (expr);
	}
	/* [temp.arg.nontype]/5, bullet 2

	For a non-type template-parameter of type pointer to object,
	qualification conversions (_conv.qual_) and the array-to-pointer
	conversion (_conv.array_) are applied. */
	else if (TYPE_PTROBV_P (type))
	{
	/* [temp.arg.nontype]/1 (TC1 version, DR 49):

	A template-argument for a non-type, non-template template-parameter
	shall be one of: [...]

	-- the name of a non-type template-parameter;
	-- the address of an object or function with external linkage, [...]
	expressed as "& id-expression" where the & is optional if the name
	refers to a function or array, or if the corresponding
	template-parameter is a reference.

	Here, we do not care about functions, as they are invalid anyway
	for a parameter of type pointer-to-object. */

	if (DECL_P (expr) && DECL_TEMPLATE_PARM_P (expr))
	/* Non-type template parameters are OK. */
	;
	else if (TREE_CODE (expr) != ADDR_EXPR
	&& TREE_CODE (expr_type) != ARRAY_TYPE)
	{
	if (TREE_CODE (expr) == VAR_DECL)
	{
	error ("%qD is not a valid template argument "
	"because %qD is a variable, not the address of "
	"a variable",
	expr, expr);
	return NULL_TREE;
	}
	/* Other values, like integer constants, might be valid
	non-type arguments of some other type. */
	return error_mark_node;
	}
	else
	{
	tree decl;

	decl = ((TREE_CODE (expr) == ADDR_EXPR)
	? TREE_OPERAND (expr, 0) : expr);
	if (TREE_CODE (decl) != VAR_DECL)
	{
	error ("%qE is not a valid template argument of type %qT "
	"because %qE is not a variable",
	expr, type, decl);
	return NULL_TREE;
	}
	else if (!DECL_EXTERNAL_LINKAGE_P (decl))
	{
	error ("%qE is not a valid template argument of type %qT "
	"because %qD does not have external linkage",
	expr, type, decl);
	return NULL_TREE;
	}
	}

	expr = decay_conversion (expr);
	if (expr == error_mark_node)
	return error_mark_node;

	expr = perform_qualification_conversions (type, expr);
	if (expr == error_mark_node)
	return error_mark_node;
	}
	/* [temp.arg.nontype]/5, bullet 3

	For a non-type template-parameter of type reference to object, no
	conversions apply. The type referred to by the reference may be more
	cv-qualified than the (otherwise identical) type of the
	template-argument. The template-parameter is bound directly to the
	template-argument, which must be an lvalue. */
	else if (TYPE_REF_OBJ_P (type))
	{
	if (!same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (type),
	expr_type))
	return error_mark_node;

	if (!at_least_as_qualified_p (TREE_TYPE (type), expr_type))
	{
	error ("%qE is not a valid template argument for type %qT "
	"because of conflicts in cv-qualification", expr, type);
	return NULL_TREE;
	}

	if (!real_lvalue_p (expr))
	{
	error ("%qE is not a valid template argument for type %qT "
	"because it is not an lvalue", expr, type);
	return NULL_TREE;
	}

	/* [temp.arg.nontype]/1

	A template-argument for a non-type, non-template template-parameter
	shall be one of: [...]

	-- the address of an object or function with external linkage. */
	if (!DECL_EXTERNAL_LINKAGE_P (expr))
	{
	error ("%qE is not a valid template argument for type %qT "
	"because object %qD has not external linkage",
	expr, type, expr);
	return NULL_TREE;
	}

	expr = build_nop (type, build_address (expr));
	}
	/* [temp.arg.nontype]/5, bullet 4

	For a non-type template-parameter of type pointer to function, only
	the function-to-pointer conversion (_conv.func_) is applied. If the
	template-argument represents a set of overloaded functions (or a
	pointer to such), the matching function is selected from the set
	(_over.over_). */
	else if (TYPE_PTRFN_P (type))
	{
	/* If the argument is a template-id, we might not have enough
	context information to decay the pointer. */
	if (!type_unknown_p (expr_type))
	{
	expr = decay_conversion (expr);
	if (expr == error_mark_node)
	return error_mark_node;
	}

	expr = convert_nontype_argument_function (type, expr);
	if (!expr \|\| expr == error_mark_node)
	return expr;
	}
	/* [temp.arg.nontype]/5, bullet 5

	For a non-type template-parameter of type reference to function, no
	conversions apply. If the template-argument represents a set of
	overloaded functions, the matching function is selected from the set
	(_over.over_). */
	else if (TYPE_REFFN_P (type))
	{
	if (TREE_CODE (expr) == ADDR_EXPR)
	{
	error ("%qE is not a valid template argument for type %qT "
	"because it is a pointer", expr, type);
	inform ("try using %qE instead", TREE_OPERAND (expr, 0));
	return NULL_TREE;
	}

	expr = convert_nontype_argument_function (TREE_TYPE (type), expr);
	if (!expr \|\| expr == error_mark_node)
	return expr;

	expr = build_nop (type, build_address (expr));
	}
	/* [temp.arg.nontype]/5, bullet 6

	For a non-type template-parameter of type pointer to member function,
	no conversions apply. If the template-argument represents a set of
	overloaded member functions, the matching member function is selected
	from the set (_over.over_). */
	else if (TYPE_PTRMEMFUNC_P (type))
	{
	expr = instantiate_type (type, expr, tf_none);
	if (expr == error_mark_node)
	return error_mark_node;

	/* There is no way to disable standard conversions in
	resolve_address_of_overloaded_function (called by
	instantiate_type). It is possible that the call succeeded by
	converting &B::I to &D::I (where B is a base of D), so we need
	to reject this conversion here.

	Actually, even if there was a way to disable standard conversions,
	it would still be better to reject them here so that we can
	provide a superior diagnostic. */
	if (!same_type_p (TREE_TYPE (expr), type))
	{
	/* Make sure we are just one standard conversion off. */
	gcc_assert (can_convert (type, TREE_TYPE (expr)));
	error ("%qE is not a valid template argument for type %qT "
	"because it is of type %qT", expr, type,
	TREE_TYPE (expr));
	inform ("standard conversions are not allowed in this context");
	return NULL_TREE;
	}
	}
	/* [temp.arg.nontype]/5, bullet 7

	For a non-type template-parameter of type pointer to data member,
	qualification conversions (_conv.qual_) are applied. */
	else if (TYPE_PTRMEM_P (type))
	{
	expr = perform_qualification_conversions (type, expr);
	if (expr == error_mark_node)
	return expr;
	}
	/* A template non-type parameter must be one of the above. */
	else
	gcc_unreachable ();

	/* Sanity check: did we actually convert the argument to the
	right type? */
	gcc_assert (same_type_p (type, TREE_TYPE (expr)));
	return expr;
	}


	/* Return 1 if PARM_PARMS and ARG_PARMS matches using rule for
	template template parameters. Both PARM_PARMS and ARG_PARMS are
	vectors of TREE_LIST nodes containing TYPE_DECL, TEMPLATE_DECL
	or PARM_DECL.

	Consider the example:
	template <class T> class A;
	template<template <class U> class TT> class B;

	For B<A>, PARM_PARMS are the parameters to TT, while ARG_PARMS are
	the parameters to A, and OUTER_ARGS contains A. */

	static int
	coerce_template_template_parms (tree parm_parms,
	tree arg_parms,
	tsubst_flags_t complain,
	tree in_decl,
	tree outer_args)
	{
	int nparms, nargs, i;
	tree parm, arg;

	gcc_assert (TREE_CODE (parm_parms) == TREE_VEC);
	gcc_assert (TREE_CODE (arg_parms) == TREE_VEC);

	nparms = TREE_VEC_LENGTH (parm_parms);
	nargs = TREE_VEC_LENGTH (arg_parms);

	if (nargs != nparms)
	return 0;

	for (i = 0; i < nparms; ++i)
	{
	if (TREE_VEC_ELT (parm_parms, i) == error_mark_node
	\|\| TREE_VEC_ELT (arg_parms, i) == error_mark_node)
	continue;

	parm = TREE_VALUE (TREE_VEC_ELT (parm_parms, i));
	arg = TREE_VALUE (TREE_VEC_ELT (arg_parms, i));

	if (arg == NULL_TREE \|\| arg == error_mark_node
	\|\| parm == NULL_TREE \|\| parm == error_mark_node)
	return 0;

	if (TREE_CODE (arg) != TREE_CODE (parm))
	return 0;

	switch (TREE_CODE (parm))
	{
	case TYPE_DECL:
	break;

	case TEMPLATE_DECL:
	/* We encounter instantiations of templates like
	template <template <template <class> class> class TT>
	class C; */
	{
	tree parmparm = DECL_INNERMOST_TEMPLATE_PARMS (parm);
	tree argparm = DECL_INNERMOST_TEMPLATE_PARMS (arg);

	if (!coerce_template_template_parms
	(parmparm, argparm, complain, in_decl, outer_args))
	return 0;
	}
	break;

	case PARM_DECL:
	/* The tsubst call is used to handle cases such as

	template <int> class C {};
	template <class T, template <T> class TT> class D {};
	D<int, C> d;

	i.e. the parameter list of TT depends on earlier parameters. */
	if (!dependent_type_p (TREE_TYPE (arg))
	&& !same_type_p
	(tsubst (TREE_TYPE (parm), outer_args, complain, in_decl),
	TREE_TYPE (arg)))
	return 0;
	break;

	default:
	gcc_unreachable ();
	}
	}
	return 1;
	}

	/* Convert the indicated template ARG as necessary to match the
	indicated template PARM. Returns the converted ARG, or
	error_mark_node if the conversion was unsuccessful. Error and
	warning messages are issued under control of COMPLAIN. This
	conversion is for the Ith parameter in the parameter list. ARGS is
	the full set of template arguments deduced so far. */

	static tree
	convert_template_argument (tree parm,
	tree arg,
	tree args,
	tsubst_flags_t complain,
	int i,
	tree in_decl)
	{
	tree val;
	int is_type, requires_type, is_tmpl_type, requires_tmpl_type;

	if (TREE_CODE (arg) == TREE_LIST
	&& TREE_CODE (TREE_VALUE (arg)) == OFFSET_REF)
	{
	/* The template argument was the name of some
	member function. That's usually
	invalid, but static members are OK. In any
	case, grab the underlying fields/functions
	and issue an error later if required. */
	arg = TREE_VALUE (arg);
	TREE_TYPE (arg) = unknown_type_node;
	}

	requires_tmpl_type = TREE_CODE (parm) == TEMPLATE_DECL;
	requires_type = (TREE_CODE (parm) == TYPE_DECL
	\|\| requires_tmpl_type);

	is_tmpl_type = ((TREE_CODE (arg) == TEMPLATE_DECL
	&& TREE_CODE (DECL_TEMPLATE_RESULT (arg)) == TYPE_DECL)
	\|\| TREE_CODE (arg) == TEMPLATE_TEMPLATE_PARM
	\|\| TREE_CODE (arg) == UNBOUND_CLASS_TEMPLATE);

	if (is_tmpl_type
	&& (TREE_CODE (arg) == TEMPLATE_TEMPLATE_PARM
	\|\| TREE_CODE (arg) == UNBOUND_CLASS_TEMPLATE))
	arg = TYPE_STUB_DECL (arg);

	is_type = TYPE_P (arg) \|\| is_tmpl_type;

	if (requires_type && ! is_type && TREE_CODE (arg) == SCOPE_REF
	&& TREE_CODE (TREE_OPERAND (arg, 0)) == TEMPLATE_TYPE_PARM)
	{
	pedwarn ("to refer to a type member of a template parameter, "
	"use %<typename %E%>", arg);

	arg = make_typename_type (TREE_OPERAND (arg, 0),
	TREE_OPERAND (arg, 1),
	typename_type,
	complain & tf_error);
	is_type = 1;
	}
	if (is_type != requires_type)
	{
	if (in_decl)
	{
	if (complain & tf_error)
	{
	error ("type/value mismatch at argument %d in template "
	"parameter list for %qD",
	i + 1, in_decl);
	if (is_type)
	error (" expected a constant of type %qT, got %qT",
	TREE_TYPE (parm),
	(is_tmpl_type ? DECL_NAME (arg) : arg));
	else if (requires_tmpl_type)
	error (" expected a class template, got %qE", arg);
	else
	error (" expected a type, got %qE", arg);
	}
	}
	return error_mark_node;
	}
	if (is_tmpl_type ^ requires_tmpl_type)
	{
	if (in_decl && (complain & tf_error))
	{
	error ("type/value mismatch at argument %d in template "
	"parameter list for %qD",
	i + 1, in_decl);
	if (is_tmpl_type)
	error (" expected a type, got %qT", DECL_NAME (arg));
	else
	error (" expected a class template, got %qT", arg);
	}
	return error_mark_node;
	}

	if (is_type)
	{
	if (requires_tmpl_type)
	{
	if (TREE_CODE (TREE_TYPE (arg)) == UNBOUND_CLASS_TEMPLATE)
	/* The number of argument required is not known yet.
	Just accept it for now. */
	val = TREE_TYPE (arg);
	else
	{
	tree parmparm = DECL_INNERMOST_TEMPLATE_PARMS (parm);
	tree argparm = DECL_INNERMOST_TEMPLATE_PARMS (arg);

	if (coerce_template_template_parms (parmparm, argparm,
	complain, in_decl,
	args))
	{
	val = arg;

	/* TEMPLATE_TEMPLATE_PARM node is preferred over
	TEMPLATE_DECL. */
	if (val != error_mark_node
	&& DECL_TEMPLATE_TEMPLATE_PARM_P (val))
	val = TREE_TYPE (val);
	}
	else
	{
	if (in_decl && (complain & tf_error))
	{
	error ("type/value mismatch at argument %d in "
	"template parameter list for %qD",
	i + 1, in_decl);
	error (" expected a template of type %qD, got %qD",
	parm, arg);
	}

	val = error_mark_node;
	}
	}
	}
	else
	val = arg;
	/* We only form one instance of each template specialization.
	Therefore, if we use a non-canonical variant (i.e., a
	typedef), any future messages referring to the type will use
	the typedef, which is confusing if those future uses do not
	themselves also use the typedef. */
	if (TYPE_P (val))
	val = canonical_type_variant (val);
	}
	else
	{
	tree t = tsubst (TREE_TYPE (parm), args, complain, in_decl);

	if (invalid_nontype_parm_type_p (t, complain))
	return error_mark_node;

	if (!uses_template_parms (arg) && !uses_template_parms (t))
	/* We used to call digest_init here. However, digest_init
	will report errors, which we don't want when complain
	is zero. More importantly, digest_init will try too
	hard to convert things: for example, `0' should not be
	converted to pointer type at this point according to
	the standard. Accepting this is not merely an
	extension, since deciding whether or not these
	conversions can occur is part of determining which
	function template to call, or whether a given explicit
	argument specification is valid. */
	val = convert_nontype_argument (t, arg);
	else
	val = arg;

	if (val == NULL_TREE)
	val = error_mark_node;
	else if (val == error_mark_node && (complain & tf_error))
	error ("could not convert template argument %qE to %qT", arg, t);
	}

	return val;
	}

	/* Convert all template arguments to their appropriate types, and
	return a vector containing the innermost resulting template
	arguments. If any error occurs, return error_mark_node. Error and
	warning messages are issued under control of COMPLAIN.

	If REQUIRE_ALL_ARGS is false, argument deduction will be performed
	for arguments not specified in ARGS. Otherwise, if
	USE_DEFAULT_ARGS is true, default arguments will be used to fill in
	unspecified arguments. If REQUIRE_ALL_ARGS is true, but
	USE_DEFAULT_ARGS is false, then all arguments must be specified in
	ARGS. */

	static tree
	coerce_template_parms (tree parms,
	tree args,
	tree in_decl,
	tsubst_flags_t complain,
	bool require_all_args,
	bool use_default_args)
	{
	int nparms, nargs, i, lost = 0;
	tree inner_args;
	tree new_args;
	tree new_inner_args;
	bool saved_skip_evaluation;

	inner_args = INNERMOST_TEMPLATE_ARGS (args);
	nargs = inner_args ? NUM_TMPL_ARGS (inner_args) : 0;
	nparms = TREE_VEC_LENGTH (parms);

	if (nargs > nparms
	\|\| (nargs < nparms
	&& require_all_args
	&& (!use_default_args
	\|\| (TREE_VEC_ELT (parms, nargs) != error_mark_node
	&& !TREE_PURPOSE (TREE_VEC_ELT (parms, nargs))))))
	{
	if (complain & tf_error)
	{
	error ("wrong number of template arguments (%d, should be %d)",
	nargs, nparms);

	if (in_decl)
	error ("provided for %q+D", in_decl);
	}

	return error_mark_node;
	}

	/* We need to evaluate the template arguments, even though this
	template-id may be nested within a "sizeof". */
	saved_skip_evaluation = skip_evaluation;
	skip_evaluation = false;
	new_inner_args = make_tree_vec (nparms);
	new_args = add_outermost_template_args (args, new_inner_args);
	for (i = 0; i < nparms; i++)
	{
	tree arg;
	tree parm;

	/* Get the Ith template parameter. */
	parm = TREE_VEC_ELT (parms, i);

	if (parm == error_mark_node)
	{
	TREE_VEC_ELT (new_inner_args, i) = error_mark_node;
	continue;
	}

	/* Calculate the Ith argument. */
	if (i < nargs)
	arg = TREE_VEC_ELT (inner_args, i);
	else if (require_all_args)
	/* There must be a default arg in this case. */
	arg = tsubst_template_arg (TREE_PURPOSE (parm), new_args,
	complain, in_decl);
	else
	break;

	gcc_assert (arg);
	if (arg == error_mark_node)
	{
	if (complain & tf_error)
	error ("template argument %d is invalid", i + 1);
	}
	else
	arg = convert_template_argument (TREE_VALUE (parm),
	arg, new_args, complain, i,
	in_decl);

	if (arg == error_mark_node)
	lost++;
	TREE_VEC_ELT (new_inner_args, i) = arg;
	}
	skip_evaluation = saved_skip_evaluation;

	if (lost)
	return error_mark_node;

	return new_inner_args;
	}

	/* Returns 1 if template args OT and NT are equivalent. */

	static int
	template_args_equal (tree ot, tree nt)
	{
	if (nt == ot)
	return 1;

	if (TREE_CODE (nt) == TREE_VEC)
	/* For member templates */
	return TREE_CODE (ot) == TREE_VEC && comp_template_args (ot, nt);
	else if (TYPE_P (nt))
	return TYPE_P (ot) && same_type_p (ot, nt);
	else if (TREE_CODE (ot) == TREE_VEC \|\| TYPE_P (ot))
	return 0;
	else
	return cp_tree_equal (ot, nt);
	}

	/* Returns 1 iff the OLDARGS and NEWARGS are in fact identical sets
	of template arguments. Returns 0 otherwise. */

	int
	comp_template_args (tree oldargs, tree newargs)
	{
	int i;

	if (TREE_VEC_LENGTH (oldargs) != TREE_VEC_LENGTH (newargs))
	return 0;

	for (i = 0; i < TREE_VEC_LENGTH (oldargs); ++i)
	{
	tree nt = TREE_VEC_ELT (newargs, i);
	tree ot = TREE_VEC_ELT (oldargs, i);

	if (! template_args_equal (ot, nt))
	return 0;
	}
	return 1;
	}

	/* Given class template name and parameter list, produce a user-friendly name
	for the instantiation. */

	static char *
	mangle_class_name_for_template (const char* name, tree parms, tree arglist)
	{
	static struct obstack scratch_obstack;
	static char *scratch_firstobj;
	int i, nparms;

	if (!scratch_firstobj)
	gcc_obstack_init (&scratch_obstack);
	else
	obstack_free (&scratch_obstack, scratch_firstobj);
	scratch_firstobj = (char *) obstack_alloc (&scratch_obstack, 1);

	#define ccat(C) obstack_1grow (&scratch_obstack, (C));
	#define cat(S) obstack_grow (&scratch_obstack, (S), strlen (S))

	cat (name);
	ccat ('<');
	nparms = TREE_VEC_LENGTH (parms);
	arglist = INNERMOST_TEMPLATE_ARGS (arglist);
	gcc_assert (nparms == TREE_VEC_LENGTH (arglist));
	for (i = 0; i < nparms; i++)
	{
	tree parm;
	tree arg;

	parm = TREE_VALUE (TREE_VEC_ELT (parms, i));
	arg = TREE_VEC_ELT (arglist, i);

	if (parm == error_mark_node)
	continue;

	if (i)
	ccat (',');

	if (TREE_CODE (parm) == TYPE_DECL)
	{
	cat (type_as_string (arg, TFF_CHASE_TYPEDEF));
	continue;
	}
	else if (TREE_CODE (parm) == TEMPLATE_DECL)
	{
	if (TREE_CODE (arg) == TEMPLATE_DECL)
	{
	/* Already substituted with real template. Just output
	the template name here */
	tree context = DECL_CONTEXT (arg);
	if (context)
	{
	/* The template may be defined in a namespace, or
	may be a member template. */
	gcc_assert (TREE_CODE (context) == NAMESPACE_DECL
	\|\| CLASS_TYPE_P (context));
	cat (decl_as_string (DECL_CONTEXT (arg),
	TFF_PLAIN_IDENTIFIER));
	cat ("::");
	}
	cat (IDENTIFIER_POINTER (DECL_NAME (arg)));
	}
	else
	/* Output the parameter declaration. */
	cat (type_as_string (arg, TFF_CHASE_TYPEDEF));
	continue;
	}
	else
	gcc_assert (TREE_CODE (parm) == PARM_DECL);

	/* No need to check arglist against parmlist here; we did that
	in coerce_template_parms, called from lookup_template_class. */
	cat (expr_as_string (arg, TFF_PLAIN_IDENTIFIER));
	}
	{
	char *bufp = obstack_next_free (&scratch_obstack);
	int offset = 0;
	while (bufp[offset - 1] == ' ')
	offset--;
	obstack_blank_fast (&scratch_obstack, offset);

	/* B<C<char> >, not B<C<char>> */
	if (bufp[offset - 1] == '>')
	ccat (' ');
	}
	ccat ('>');
	ccat ('\0');
	return (char *) obstack_base (&scratch_obstack);
	}

	static tree
	classtype_mangled_name (tree t)
	{
	if (CLASSTYPE_TEMPLATE_INFO (t)
	/* Specializations have already had their names set up in
	lookup_template_class. */
	&& !CLASSTYPE_TEMPLATE_SPECIALIZATION (t))
	{
	tree tmpl = most_general_template (CLASSTYPE_TI_TEMPLATE (t));

	/* For non-primary templates, the template parameters are
	implicit from their surrounding context. */
	if (PRIMARY_TEMPLATE_P (tmpl))
	{
	tree name = DECL_NAME (tmpl);
	char *mangled_name = mangle_class_name_for_template
	(IDENTIFIER_POINTER (name),
	DECL_INNERMOST_TEMPLATE_PARMS (tmpl),
	CLASSTYPE_TI_ARGS (t));
	tree id = get_identifier (mangled_name);
	IDENTIFIER_TEMPLATE (id) = name;
	return id;
	}
	}

	return TYPE_IDENTIFIER (t);
	}

	static void
	add_pending_template (tree d)
	{
	tree ti = (TYPE_P (d)
	? CLASSTYPE_TEMPLATE_INFO (d)
	: DECL_TEMPLATE_INFO (d));
	tree pt;
	int level;

	if (TI_PENDING_TEMPLATE_FLAG (ti))
	return;

	/* We are called both from instantiate_decl, where we've already had a
	tinst_level pushed, and instantiate_template, where we haven't.
	Compensate. */
	level = !(current_tinst_level && TINST_DECL (current_tinst_level) == d);

	if (level)
	push_tinst_level (d);

	pt = tree_cons (current_tinst_level, d, NULL_TREE);
	if (last_pending_template)
	TREE_CHAIN (last_pending_template) = pt;
	else
	pending_templates = pt;

	last_pending_template = pt;

	TI_PENDING_TEMPLATE_FLAG (ti) = 1;

	if (level)
	pop_tinst_level ();
	}


	/* Return a TEMPLATE_ID_EXPR corresponding to the indicated FNS and
	ARGLIST. Valid choices for FNS are given in the cp-tree.def
	documentation for TEMPLATE_ID_EXPR. */

	tree
	lookup_template_function (tree fns, tree arglist)
	{
	tree type;

	if (fns == error_mark_node \|\| arglist == error_mark_node)
	return error_mark_node;

	gcc_assert (!arglist \|\| TREE_CODE (arglist) == TREE_VEC);
	gcc_assert (fns && (is_overloaded_fn (fns)
	\|\| TREE_CODE (fns) == IDENTIFIER_NODE));

	if (BASELINK_P (fns))
	{
	BASELINK_FUNCTIONS (fns) = build2 (TEMPLATE_ID_EXPR,
	unknown_type_node,
	BASELINK_FUNCTIONS (fns),
	arglist);
	return fns;
	}

	type = TREE_TYPE (fns);
	if (TREE_CODE (fns) == OVERLOAD \|\| !type)
	type = unknown_type_node;

	return build2 (TEMPLATE_ID_EXPR, type, fns, arglist);
	}

	/* Within the scope of a template class S<T>, the name S gets bound
	(in build_self_reference) to a TYPE_DECL for the class, not a
	TEMPLATE_DECL. If DECL is a TYPE_DECL for current_class_type,
	or one of its enclosing classes, and that type is a template,
	return the associated TEMPLATE_DECL. Otherwise, the original
	DECL is returned. */

	tree
	maybe_get_template_decl_from_type_decl (tree decl)
	{
	return (decl != NULL_TREE
	&& TREE_CODE (decl) == TYPE_DECL
	&& DECL_ARTIFICIAL (decl)
	&& CLASS_TYPE_P (TREE_TYPE (decl))
	&& CLASSTYPE_TEMPLATE_INFO (TREE_TYPE (decl)))
	? CLASSTYPE_TI_TEMPLATE (TREE_TYPE (decl)) : decl;
	}

	/* Given an IDENTIFIER_NODE (type TEMPLATE_DECL) and a chain of
	parameters, find the desired type.

	D1 is the PTYPENAME terminal, and ARGLIST is the list of arguments.

	IN_DECL, if non-NULL, is the template declaration we are trying to
	instantiate.

	If ENTERING_SCOPE is nonzero, we are about to enter the scope of
	the class we are looking up.

	Issue error and warning messages under control of COMPLAIN.

	If the template class is really a local class in a template
	function, then the FUNCTION_CONTEXT is the function in which it is
	being instantiated.

	??? Note that this function is currently called twice for each
	template-id: the first time from the parser, while creating the
	incomplete type (finish_template_type), and the second type during the
	real instantiation (instantiate_template_class). This is surely something
	that we want to avoid. It also causes some problems with argument
	coercion (see convert_nontype_argument for more information on this). */

	tree
	lookup_template_class (tree d1,
	tree arglist,
	tree in_decl,
	tree context,
	int entering_scope,
	tsubst_flags_t complain)
	{
	tree template = NULL_TREE, parmlist;
	tree t;

	timevar_push (TV_NAME_LOOKUP);

	if (TREE_CODE (d1) == IDENTIFIER_NODE)
	{
	tree value = innermost_non_namespace_value (d1);
	if (value && DECL_TEMPLATE_TEMPLATE_PARM_P (value))
	template = value;
	else
	{
	if (context)
	push_decl_namespace (context);
	template = lookup_name (d1);
	template = maybe_get_template_decl_from_type_decl (template);
	if (context)
	pop_decl_namespace ();
	}
	if (template)
	context = DECL_CONTEXT (template);
	}
	else if (TREE_CODE (d1) == TYPE_DECL && IS_AGGR_TYPE (TREE_TYPE (d1)))
	{
	tree type = TREE_TYPE (d1);

	/* If we are declaring a constructor, say A<T>::A<T>, we will get
	an implicit typename for the second A. Deal with it. */
	if (TREE_CODE (type) == TYPENAME_TYPE && TREE_TYPE (type))
	type = TREE_TYPE (type);

	if (CLASSTYPE_TEMPLATE_INFO (type))
	{
	template = CLASSTYPE_TI_TEMPLATE (type);
	d1 = DECL_NAME (template);
	}
	}
	else if (TREE_CODE (d1) == ENUMERAL_TYPE
	\|\| (TYPE_P (d1) && IS_AGGR_TYPE (d1)))
	{
	template = TYPE_TI_TEMPLATE (d1);
	d1 = DECL_NAME (template);
	}
	else if (TREE_CODE (d1) == TEMPLATE_DECL
	&& TREE_CODE (DECL_TEMPLATE_RESULT (d1)) == TYPE_DECL)
	{
	template = d1;
	d1 = DECL_NAME (template);
	context = DECL_CONTEXT (template);
	}

	/* Issue an error message if we didn't find a template. */
	if (! template)
	{
	if (complain & tf_error)
	error ("%qT is not a template", d1);
	POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
	}

	if (TREE_CODE (template) != TEMPLATE_DECL
	/* Make sure it's a user visible template, if it was named by
	the user. */
	\|\| ((complain & tf_user) && !DECL_TEMPLATE_PARM_P (template)
	&& !PRIMARY_TEMPLATE_P (template)))
	{
	if (complain & tf_error)
	{
	error ("non-template type %qT used as a template", d1);
	if (in_decl)
	error ("for template declaration %q+D", in_decl);
	}
	POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
	}

	complain &= ~tf_user;

	if (DECL_TEMPLATE_TEMPLATE_PARM_P (template))
	{
	/* Create a new TEMPLATE_DECL and TEMPLATE_TEMPLATE_PARM node to store
	template arguments */

	tree parm;
	tree arglist2;

	parmlist = DECL_INNERMOST_TEMPLATE_PARMS (template);

	/* Consider an example where a template template parameter declared as

	template <class T, class U = std::allocator<T> > class TT

	The template parameter level of T and U are one level larger than
	of TT. To proper process the default argument of U, say when an
	instantiation `TT<int>' is seen, we need to build the full
	arguments containing {int} as the innermost level. Outer levels,
	available when not appearing as default template argument, can be
	obtained from `current_template_args ()'.

	Suppose that TT is later substituted with std::vector. The above
	instantiation is `TT<int, std::allocator<T> >' with TT at
	level 1, and T at level 2, while the template arguments at level 1
	becomes {std::vector} and the inner level 2 is {int}. */

	if (current_template_parms)
	arglist = add_to_template_args (current_template_args (), arglist);

	arglist2 = coerce_template_parms (parmlist, arglist, template,
	complain,
	/require_all_args=/true,
	/use_default_args=/true);
	if (arglist2 == error_mark_node
	\|\| (!uses_template_parms (arglist2)
	&& check_instantiated_args (template, arglist2, complain)))
	POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);

	parm = bind_template_template_parm (TREE_TYPE (template), arglist2);
	POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, parm);
	}
	else
	{
	tree template_type = TREE_TYPE (template);
	tree gen_tmpl;
	tree type_decl;
	tree found = NULL_TREE;
	int arg_depth;
	int parm_depth;
	int is_partial_instantiation;

	gen_tmpl = most_general_template (template);
	parmlist = DECL_TEMPLATE_PARMS (gen_tmpl);
	parm_depth = TMPL_PARMS_DEPTH (parmlist);
	arg_depth = TMPL_ARGS_DEPTH (arglist);

	if (arg_depth == 1 && parm_depth > 1)
	{
	/* We've been given an incomplete set of template arguments.
	For example, given:

	template <class T> struct S1 {
	template <class U> struct S2 {};
	template <class U> struct S2<U*> {};
	};

	we will be called with an ARGLIST of `U*', but the
	TEMPLATE will be `template <class T> template
	<class U> struct S1<T>::S2'. We must fill in the missing
	arguments. */
	arglist
	= add_outermost_template_args (TYPE_TI_ARGS (TREE_TYPE (template)),
	arglist);
	arg_depth = TMPL_ARGS_DEPTH (arglist);
	}

	/* Now we should have enough arguments. */
	gcc_assert (parm_depth == arg_depth);

	/* From here on, we're only interested in the most general
	template. */
	template = gen_tmpl;

	/* Calculate the BOUND_ARGS. These will be the args that are
	actually tsubst'd into the definition to create the
	instantiation. */
	if (parm_depth > 1)
	{
	/* We have multiple levels of arguments to coerce, at once. */
	int i;
	int saved_depth = TMPL_ARGS_DEPTH (arglist);

	tree bound_args = make_tree_vec (parm_depth);

	for (i = saved_depth,
	t = DECL_TEMPLATE_PARMS (template);
	i > 0 && t != NULL_TREE;
	--i, t = TREE_CHAIN (t))
	{
	tree a = coerce_template_parms (TREE_VALUE (t),
	arglist, template,
	complain,
	/require_all_args=/true,
	/use_default_args=/true);

	/* Don't process further if one of the levels fails. */
	if (a == error_mark_node)
	{
	/* Restore the ARGLIST to its full size. */
	TREE_VEC_LENGTH (arglist) = saved_depth;
	POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
	}

	SET_TMPL_ARGS_LEVEL (bound_args, i, a);

	/* We temporarily reduce the length of the ARGLIST so
	that coerce_template_parms will see only the arguments
	corresponding to the template parameters it is
	examining. */
	TREE_VEC_LENGTH (arglist)--;
	}

	/* Restore the ARGLIST to its full size. */
	TREE_VEC_LENGTH (arglist) = saved_depth;

	arglist = bound_args;
	}
	else
	arglist
	= coerce_template_parms (INNERMOST_TEMPLATE_PARMS (parmlist),
	INNERMOST_TEMPLATE_ARGS (arglist),
	template,
	complain,
	/require_all_args=/true,
	/use_default_args=/true);

	if (arglist == error_mark_node)
	/* We were unable to bind the arguments. */
	POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);

	/* In the scope of a template class, explicit references to the
	template class refer to the type of the template, not any
	instantiation of it. For example, in:

	template <class T> class C { void f(C<T>); }

	the `C<T>' is just the same as `C'. Outside of the
	class, however, such a reference is an instantiation. */
	if (comp_template_args (TYPE_TI_ARGS (template_type),
	arglist))
	{
	found = template_type;

	if (!entering_scope && PRIMARY_TEMPLATE_P (template))
	{
	tree ctx;

	for (ctx = current_class_type;
	ctx && TREE_CODE (ctx) != NAMESPACE_DECL;
	ctx = (TYPE_P (ctx)
	? TYPE_CONTEXT (ctx)
	: DECL_CONTEXT (ctx)))
	if (TYPE_P (ctx) && same_type_p (ctx, template_type))
	goto found_ctx;

	/* We're not in the scope of the class, so the
	TEMPLATE_TYPE is not the type we want after all. */
	found = NULL_TREE;
	found_ctx:;
	}
	}
	if (found)
	POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, found);

	/* If we already have this specialization, return it. */
	found = retrieve_specialization (template, arglist,
	/class_specializations_p=/false);
	if (found)
	POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, found);

	/* This type is a "partial instantiation" if any of the template
	arguments still involve template parameters. Note that we set
	IS_PARTIAL_INSTANTIATION for partial specializations as
	well. */
	is_partial_instantiation = uses_template_parms (arglist);

	/* If the deduced arguments are invalid, then the binding
	failed. */
	if (!is_partial_instantiation
	&& check_instantiated_args (template,
	INNERMOST_TEMPLATE_ARGS (arglist),
	complain))
	POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);

	if (!is_partial_instantiation
	&& !PRIMARY_TEMPLATE_P (template)
	&& TREE_CODE (CP_DECL_CONTEXT (template)) == NAMESPACE_DECL)
	{
	found = xref_tag_from_type (TREE_TYPE (template),
	DECL_NAME (template),
	/tag_scope=/ts_global);
	POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, found);
	}

	context = tsubst (DECL_CONTEXT (template), arglist,
	complain, in_decl);
	if (!context)
	context = global_namespace;

	/* Create the type. */
	if (TREE_CODE (template_type) == ENUMERAL_TYPE)
	{
	if (!is_partial_instantiation)
	{
	set_current_access_from_decl (TYPE_NAME (template_type));
	t = start_enum (TYPE_IDENTIFIER (template_type));
	}
	else
	/* We don't want to call start_enum for this type, since
	the values for the enumeration constants may involve
	template parameters. And, no one should be interested
	in the enumeration constants for such a type. */
	t = make_node (ENUMERAL_TYPE);
	}
	else
	{
	t = make_aggr_type (TREE_CODE (template_type));
	CLASSTYPE_DECLARED_CLASS (t)
	= CLASSTYPE_DECLARED_CLASS (template_type);
	SET_CLASSTYPE_IMPLICIT_INSTANTIATION (t);
	TYPE_FOR_JAVA (t) = TYPE_FOR_JAVA (template_type);

	/* A local class. Make sure the decl gets registered properly. */
	if (context == current_function_decl)
	pushtag (DECL_NAME (template), t, /tag_scope=/ts_current);
	}

	/* If we called start_enum or pushtag above, this information
	will already be set up. */
	if (!TYPE_NAME (t))
	{
	TYPE_CONTEXT (t) = FROB_CONTEXT (context);

	type_decl = create_implicit_typedef (DECL_NAME (template), t);
	DECL_CONTEXT (type_decl) = TYPE_CONTEXT (t);
	TYPE_STUB_DECL (t) = type_decl;
	DECL_SOURCE_LOCATION (type_decl)
	= DECL_SOURCE_LOCATION (TYPE_STUB_DECL (template_type));
	}
	else
	type_decl = TYPE_NAME (t);

	TREE_PRIVATE (type_decl)
	= TREE_PRIVATE (TYPE_STUB_DECL (template_type));
	TREE_PROTECTED (type_decl)
	= TREE_PROTECTED (TYPE_STUB_DECL (template_type));
	DECL_IN_SYSTEM_HEADER (type_decl)
	= DECL_IN_SYSTEM_HEADER (template);
	if (CLASSTYPE_VISIBILITY_SPECIFIED (template_type))
	{
	DECL_VISIBILITY_SPECIFIED (type_decl) = 1;
	DECL_VISIBILITY (type_decl) = CLASSTYPE_VISIBILITY (template_type);
	}

	/* Set up the template information. We have to figure out which
	template is the immediate parent if this is a full
	instantiation. */
	if (parm_depth == 1 \|\| is_partial_instantiation
	\|\| !PRIMARY_TEMPLATE_P (template))
	/* This case is easy; there are no member templates involved. */
	found = template;
	else
	{
	/* This is a full instantiation of a member template. Look
	for a partial instantiation of which this is an instance. */

	for (found = DECL_TEMPLATE_INSTANTIATIONS (template);
	found; found = TREE_CHAIN (found))
	{
	int success;
	tree tmpl = CLASSTYPE_TI_TEMPLATE (TREE_VALUE (found));

	/* We only want partial instantiations, here, not
	specializations or full instantiations. */
	if (CLASSTYPE_TEMPLATE_SPECIALIZATION (TREE_VALUE (found))
	\|\| !uses_template_parms (TREE_VALUE (found)))
	continue;

	/* Temporarily reduce by one the number of levels in the
	ARGLIST and in FOUND so as to avoid comparing the
	last set of arguments. */
	TREE_VEC_LENGTH (arglist)--;
	TREE_VEC_LENGTH (TREE_PURPOSE (found)) --;

	/* See if the arguments match. If they do, then TMPL is
	the partial instantiation we want. */
	success = comp_template_args (TREE_PURPOSE (found), arglist);

	/* Restore the argument vectors to their full size. */
	TREE_VEC_LENGTH (arglist)++;
	TREE_VEC_LENGTH (TREE_PURPOSE (found))++;

	if (success)
	{
	found = tmpl;
	break;
	}
	}

	if (!found)
	{
	/* There was no partial instantiation. This happens
	where C<T> is a member template of A<T> and it's used
	in something like

	template <typename T> struct B { A<T>::C<int> m; };
	B<float>;

	Create the partial instantiation.
	*/
	TREE_VEC_LENGTH (arglist)--;
	found = tsubst (template, arglist, complain, NULL_TREE);
	TREE_VEC_LENGTH (arglist)++;
	}
	}

	SET_TYPE_TEMPLATE_INFO (t, tree_cons (found, arglist, NULL_TREE));
	DECL_TEMPLATE_INSTANTIATIONS (template)
	= tree_cons (arglist, t,
	DECL_TEMPLATE_INSTANTIATIONS (template));

	if (TREE_CODE (t) == ENUMERAL_TYPE
	&& !is_partial_instantiation)
	/* Now that the type has been registered on the instantiations
	list, we set up the enumerators. Because the enumeration
	constants may involve the enumeration type itself, we make
	sure to register the type first, and then create the
	constants. That way, doing tsubst_expr for the enumeration
	constants won't result in recursive calls here; we'll find
	the instantiation and exit above. */
	tsubst_enum (template_type, t, arglist);

	/* Reset the name of the type, now that CLASSTYPE_TEMPLATE_INFO
	is set up. */
	if (TREE_CODE (t) != ENUMERAL_TYPE)
	DECL_NAME (type_decl) = classtype_mangled_name (t);
	if (is_partial_instantiation)
	/* If the type makes use of template parameters, the
	code that generates debugging information will crash. */
	DECL_IGNORED_P (TYPE_STUB_DECL (t)) = 1;

	/* Possibly limit visibility based on template args. */
	TREE_PUBLIC (type_decl) = 1;
	determine_visibility (type_decl);

	POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
	}
	timevar_pop (TV_NAME_LOOKUP);
	}

	struct pair_fn_data
	{
	tree_fn_t fn;
	void *data;
	struct pointer_set_t *visited;
	};

	/* Called from for_each_template_parm via walk_tree. */

	static tree
	for_each_template_parm_r (tree tp, int walk_subtrees, void *d)
	{
	tree t = *tp;
	struct pair_fn_data pfd = (struct pair_fn_data ) d;
	tree_fn_t fn = pfd->fn;
	void *data = pfd->data;

	if (TYPE_P (t)
	&& for_each_template_parm (TYPE_CONTEXT (t), fn, data, pfd->visited))
	return error_mark_node;

	switch (TREE_CODE (t))
	{
	case RECORD_TYPE:
	if (TYPE_PTRMEMFUNC_P (t))
	break;
	/* Fall through. */

	case UNION_TYPE:
	case ENUMERAL_TYPE:
	if (!TYPE_TEMPLATE_INFO (t))
	*walk_subtrees = 0;
	else if (for_each_template_parm (TREE_VALUE (TYPE_TEMPLATE_INFO (t)),
	fn, data, pfd->visited))
	return error_mark_node;
	break;

	case METHOD_TYPE:
	/* Since we're not going to walk subtrees, we have to do this
	explicitly here. */
	if (for_each_template_parm (TYPE_METHOD_BASETYPE (t), fn, data,
	pfd->visited))
	return error_mark_node;
	/* Fall through. */

	case FUNCTION_TYPE:
	/* Check the return type. */
	if (for_each_template_parm (TREE_TYPE (t), fn, data, pfd->visited))
	return error_mark_node;

	/* Check the parameter types. Since default arguments are not
	instantiated until they are needed, the TYPE_ARG_TYPES may
	contain expressions that involve template parameters. But,
	no-one should be looking at them yet. And, once they're
	instantiated, they don't contain template parameters, so
	there's no point in looking at them then, either. */
	{
	tree parm;

	for (parm = TYPE_ARG_TYPES (t); parm; parm = TREE_CHAIN (parm))
	if (for_each_template_parm (TREE_VALUE (parm), fn, data,
	pfd->visited))
	return error_mark_node;

	/* Since we've already handled the TYPE_ARG_TYPES, we don't
	want walk_tree walking into them itself. */
	*walk_subtrees = 0;
	}
	break;

	case TYPEOF_TYPE:
	if (for_each_template_parm (TYPE_FIELDS (t), fn, data,
	pfd->visited))
	return error_mark_node;
	break;

	case FUNCTION_DECL:
	case VAR_DECL:
	if (DECL_LANG_SPECIFIC (t) && DECL_TEMPLATE_INFO (t)
	&& for_each_template_parm (DECL_TI_ARGS (t), fn, data,
	pfd->visited))
	return error_mark_node;
	/* Fall through. */

	case PARM_DECL:
	case CONST_DECL:
	if (TREE_CODE (t) == CONST_DECL && DECL_TEMPLATE_PARM_P (t)
	&& for_each_template_parm (DECL_INITIAL (t), fn, data,
	pfd->visited))
	return error_mark_node;
	if (DECL_CONTEXT (t)
	&& for_each_template_parm (DECL_CONTEXT (t), fn, data,
	pfd->visited))
	return error_mark_node;
	break;

	case BOUND_TEMPLATE_TEMPLATE_PARM:
	/* Record template parameters such as `T' inside `TT<T>'. */
	if (for_each_template_parm (TYPE_TI_ARGS (t), fn, data, pfd->visited))
	return error_mark_node;
	/* Fall through. */

	case TEMPLATE_TEMPLATE_PARM:
	case TEMPLATE_TYPE_PARM:
	case TEMPLATE_PARM_INDEX:
	if (fn && (*fn)(t, data))
	return error_mark_node;
	else if (!fn)
	return error_mark_node;
	break;

	case TEMPLATE_DECL:
	/* A template template parameter is encountered. */
	if (DECL_TEMPLATE_TEMPLATE_PARM_P (t)
	&& for_each_template_parm (TREE_TYPE (t), fn, data, pfd->visited))
	return error_mark_node;

	/* Already substituted template template parameter */
	*walk_subtrees = 0;
	break;

	case TYPENAME_TYPE:
	if (!fn
	\|\| for_each_template_parm (TYPENAME_TYPE_FULLNAME (t), fn,
	data, pfd->visited))
	return error_mark_node;
	break;

	case CONSTRUCTOR:
	if (TREE_TYPE (t) && TYPE_PTRMEMFUNC_P (TREE_TYPE (t))
	&& for_each_template_parm (TYPE_PTRMEMFUNC_FN_TYPE
	(TREE_TYPE (t)), fn, data,
	pfd->visited))
	return error_mark_node;
	break;

	case INDIRECT_REF:
	case COMPONENT_REF:
	/* If there's no type, then this thing must be some expression
	involving template parameters. */
	if (!fn && !TREE_TYPE (t))
	return error_mark_node;
	break;

	case MODOP_EXPR:
	case CAST_EXPR:
	case REINTERPRET_CAST_EXPR:
	case CONST_CAST_EXPR:
	case STATIC_CAST_EXPR:
	case DYNAMIC_CAST_EXPR:
	case ARROW_EXPR:
	case DOTSTAR_EXPR:
	case TYPEID_EXPR:
	case PSEUDO_DTOR_EXPR:
	if (!fn)
	return error_mark_node;
	break;

	case BASELINK:
	/* If we do not handle this case specially, we end up walking
	the BINFO hierarchy, which is circular, and therefore
	confuses walk_tree. */
	*walk_subtrees = 0;
	if (for_each_template_parm (BASELINK_FUNCTIONS (*tp), fn, data,
	pfd->visited))
	return error_mark_node;
	break;

	default:
	break;
	}

	/* We didn't find any template parameters we liked. */
	return NULL_TREE;
	}

	/* For each TEMPLATE_TYPE_PARM, TEMPLATE_TEMPLATE_PARM,
	BOUND_TEMPLATE_TEMPLATE_PARM or TEMPLATE_PARM_INDEX in T,
	call FN with the parameter and the DATA.
	If FN returns nonzero, the iteration is terminated, and
	for_each_template_parm returns 1. Otherwise, the iteration
	continues. If FN never returns a nonzero value, the value
	returned by for_each_template_parm is 0. If FN is NULL, it is
	considered to be the function which always returns 1. */

	static int
	for_each_template_parm (tree t, tree_fn_t fn, void* data,
	struct pointer_set_t *visited)
	{
	struct pair_fn_data pfd;
	int result;

	/* Set up. */
	pfd.fn = fn;
	pfd.data = data;

	/* Walk the tree. (Conceptually, we would like to walk without
	duplicates, but for_each_template_parm_r recursively calls
	for_each_template_parm, so we would need to reorganize a fair
	bit to use walk_tree_without_duplicates, so we keep our own
	visited list.) */
	if (visited)
	pfd.visited = visited;
	else
	pfd.visited = pointer_set_create ();
	result = walk_tree (&t,
	for_each_template_parm_r,
	&pfd,
	pfd.visited) != NULL_TREE;

	/* Clean up. */
	if (!visited)
	{
	pointer_set_destroy (pfd.visited);
	pfd.visited = 0;
	}

	return result;
	}

	/* Returns true if T depends on any template parameter. */

	int
	uses_template_parms (tree t)
	{
	bool dependent_p;
	int saved_processing_template_decl;

	saved_processing_template_decl = processing_template_decl;
	if (!saved_processing_template_decl)
	processing_template_decl = 1;
	if (TYPE_P (t))
	dependent_p = dependent_type_p (t);
	else if (TREE_CODE (t) == TREE_VEC)
	dependent_p = any_dependent_template_arguments_p (t);
	else if (TREE_CODE (t) == TREE_LIST)
	dependent_p = (uses_template_parms (TREE_VALUE (t))
	\|\| uses_template_parms (TREE_CHAIN (t)));
	else if (TREE_CODE (t) == TYPE_DECL)
	dependent_p = dependent_type_p (TREE_TYPE (t));
	else if (DECL_P (t)
	\|\| EXPR_P (t)
	\|\| TREE_CODE (t) == TEMPLATE_PARM_INDEX
	\|\| TREE_CODE (t) == OVERLOAD
	\|\| TREE_CODE (t) == BASELINK
	\|\| TREE_CODE (t) == IDENTIFIER_NODE
	\|\| CONSTANT_CLASS_P (t))
	dependent_p = (type_dependent_expression_p (t)
	\|\| value_dependent_expression_p (t));
	else
	{
	gcc_assert (t == error_mark_node);
	dependent_p = false;
	}

	processing_template_decl = saved_processing_template_decl;

	return dependent_p;
	}

	/* Returns true if T depends on any template parameter with level LEVEL. */

	int
	uses_template_parms_level (tree t, int level)
	{
	return for_each_template_parm (t, template_parm_this_level_p, &level, NULL);
	}

	static int tinst_depth;
	extern int max_tinst_depth;
	#ifdef GATHER_STATISTICS
	int depth_reached;
	#endif
	static int tinst_level_tick;
	static int last_template_error_tick;

	/* We're starting to instantiate D; record the template instantiation context
	for diagnostics and to restore it later. */

	static int
	push_tinst_level (tree d)
	{
	tree new;

	if (tinst_depth >= max_tinst_depth)
	{
	/* If the instantiation in question still has unbound template parms,
	we don't really care if we can't instantiate it, so just return.
	This happens with base instantiation for implicit `typename'. */
	if (uses_template_parms (d))
	return 0;

	last_template_error_tick = tinst_level_tick;
	error ("template instantiation depth exceeds maximum of %d (use "
	"-ftemplate-depth-NN to increase the maximum) instantiating %qD",
	max_tinst_depth, d);

	print_instantiation_context ();

	return 0;
	}

	new = make_node (TINST_LEVEL);
	TINST_DECL (new) = d;
	TINST_LOCATION (new) = input_location;
	TINST_IN_SYSTEM_HEADER_P (new) = in_system_header;
	TREE_CHAIN (new) = current_tinst_level;
	current_tinst_level = new;

	++tinst_depth;
	#ifdef GATHER_STATISTICS
	if (tinst_depth > depth_reached)
	depth_reached = tinst_depth;
	#endif

	++tinst_level_tick;
	return 1;
	}

	/* We're done instantiating this template; return to the instantiation
	context. */

	static void
	pop_tinst_level (void)
	{
	tree old = current_tinst_level;

	/* Restore the filename and line number stashed away when we started
	this instantiation. */
	input_location = TINST_LOCATION (old);
	in_system_header = TINST_IN_SYSTEM_HEADER_P (old);
	current_tinst_level = TREE_CHAIN (old);
	--tinst_depth;
	++tinst_level_tick;
	}

	/* We're instantiating a deferred template; restore the template
	instantiation context in which the instantiation was requested, which
	is one step out from LEVEL. */

	static void
	reopen_tinst_level (tree level)
	{
	tree t;

	tinst_depth = 0;
	for (t = level; t; t = TREE_CHAIN (t))
	++tinst_depth;

	current_tinst_level = level;
	pop_tinst_level ();
	}

	/* Returns the TINST_LEVEL which gives the original instantiation
	context. */

	tree
	outermost_tinst_level (void)
	{
	return tree_last (current_tinst_level);
	}

	/* DECL is a friend FUNCTION_DECL or TEMPLATE_DECL. ARGS is the
	vector of template arguments, as for tsubst.

	Returns an appropriate tsubst'd friend declaration. */

	static tree
	tsubst_friend_function (tree decl, tree args)
	{
	tree new_friend;

	if (TREE_CODE (decl) == FUNCTION_DECL
	&& DECL_TEMPLATE_INSTANTIATION (decl)
	&& TREE_CODE (DECL_TI_TEMPLATE (decl)) != TEMPLATE_DECL)
	/* This was a friend declared with an explicit template
	argument list, e.g.:

	friend void f<>(T);

	to indicate that f was a template instantiation, not a new
	function declaration. Now, we have to figure out what
	instantiation of what template. */
	{
	tree template_id, arglist, fns;
	tree new_args;
	tree tmpl;
	tree ns = decl_namespace_context (TYPE_MAIN_DECL (current_class_type));

	/* Friend functions are looked up in the containing namespace scope.
	We must enter that scope, to avoid finding member functions of the
	current cless with same name. */
	push_nested_namespace (ns);
	fns = tsubst_expr (DECL_TI_TEMPLATE (decl), args,
	tf_warning_or_error, NULL_TREE,
	/integral_constant_expression_p=/false);
	pop_nested_namespace (ns);
	arglist = tsubst (DECL_TI_ARGS (decl), args,
	tf_warning_or_error, NULL_TREE);
	template_id = lookup_template_function (fns, arglist);

	new_friend = tsubst (decl, args, tf_warning_or_error, NULL_TREE);
	tmpl = determine_specialization (template_id, new_friend,
	&new_args,
	/need_member_template=/0,
	TREE_VEC_LENGTH (args),
	tsk_none);
	return instantiate_template (tmpl, new_args, tf_error);
	}

	new_friend = tsubst (decl, args, tf_warning_or_error, NULL_TREE);

	/* The NEW_FRIEND will look like an instantiation, to the
	compiler, but is not an instantiation from the point of view of
	the language. For example, we might have had:

	template <class T> struct S {
	template <class U> friend void f(T, U);
	};

	Then, in S<int>, template <class U> void f(int, U) is not an
	instantiation of anything. */
	if (new_friend == error_mark_node)
	return error_mark_node;

	DECL_USE_TEMPLATE (new_friend) = 0;
	if (TREE_CODE (decl) == TEMPLATE_DECL)
	{
	DECL_USE_TEMPLATE (DECL_TEMPLATE_RESULT (new_friend)) = 0;
	DECL_SAVED_TREE (DECL_TEMPLATE_RESULT (new_friend))
	= DECL_SAVED_TREE (DECL_TEMPLATE_RESULT (decl));
	}

	/* The mangled name for the NEW_FRIEND is incorrect. The function
	is not a template instantiation and should not be mangled like
	one. Therefore, we forget the mangling here; we'll recompute it
	later if we need it. */
	if (TREE_CODE (new_friend) != TEMPLATE_DECL)
	{
	SET_DECL_RTL (new_friend, NULL_RTX);
	SET_DECL_ASSEMBLER_NAME (new_friend, NULL_TREE);
	}

	if (DECL_NAMESPACE_SCOPE_P (new_friend))
	{
	tree old_decl;
	tree new_friend_template_info;
	tree new_friend_result_template_info;
	tree ns;
	int new_friend_is_defn;

	/* We must save some information from NEW_FRIEND before calling
	duplicate decls since that function will free NEW_FRIEND if
	possible. */
	new_friend_template_info = DECL_TEMPLATE_INFO (new_friend);
	new_friend_is_defn =
	(DECL_INITIAL (DECL_TEMPLATE_RESULT
	(template_for_substitution (new_friend)))
	!= NULL_TREE);
	if (TREE_CODE (new_friend) == TEMPLATE_DECL)
	{
	/* This declaration is a `primary' template. */
	DECL_PRIMARY_TEMPLATE (new_friend) = new_friend;

	new_friend_result_template_info
	= DECL_TEMPLATE_INFO (DECL_TEMPLATE_RESULT (new_friend));
	}
	else
	new_friend_result_template_info = NULL_TREE;

	/* Make the init_value nonzero so pushdecl knows this is a defn. */
	if (new_friend_is_defn)
	DECL_INITIAL (new_friend) = error_mark_node;

	/* Inside pushdecl_namespace_level, we will push into the
	current namespace. However, the friend function should go
	into the namespace of the template. */
	ns = decl_namespace_context (new_friend);
	push_nested_namespace (ns);
	old_decl = pushdecl_namespace_level (new_friend, /is_friend=/true);
	pop_nested_namespace (ns);

	if (old_decl == error_mark_node)
	return error_mark_node;

	if (old_decl != new_friend)
	{
	/* This new friend declaration matched an existing
	declaration. For example, given:

	template <class T> void f(T);
	template <class U> class C {
	template <class T> friend void f(T) {}
	};

	the friend declaration actually provides the definition
	of `f', once C has been instantiated for some type. So,
	old_decl will be the out-of-class template declaration,
	while new_friend is the in-class definition.

	But, if `f' was called before this point, the
	instantiation of `f' will have DECL_TI_ARGS corresponding
	to `T' but not to `U', references to which might appear
	in the definition of `f'. Previously, the most general
	template for an instantiation of `f' was the out-of-class
	version; now it is the in-class version. Therefore, we
	run through all specialization of `f', adding to their
	DECL_TI_ARGS appropriately. In particular, they need a
	new set of outer arguments, corresponding to the
	arguments for this class instantiation.

	The same situation can arise with something like this:

	friend void f(int);
	template <class T> class C {
	friend void f(T) {}
	};

	when `C<int>' is instantiated. Now, `f(int)' is defined
	in the class. */

	if (!new_friend_is_defn)
	/* On the other hand, if the in-class declaration does
	not provide a definition, then we don't want to alter
	existing definitions. We can just leave everything
	alone. */
	;
	else
	{
	/* Overwrite whatever template info was there before, if
	any, with the new template information pertaining to
	the declaration. */
	DECL_TEMPLATE_INFO (old_decl) = new_friend_template_info;

	if (TREE_CODE (old_decl) != TEMPLATE_DECL)
	reregister_specialization (new_friend,
	most_general_template (old_decl),
	old_decl);
	else
	{
	tree t;
	tree new_friend_args;

	DECL_TEMPLATE_INFO (DECL_TEMPLATE_RESULT (old_decl))
	= new_friend_result_template_info;

	new_friend_args = TI_ARGS (new_friend_template_info);
	for (t = DECL_TEMPLATE_SPECIALIZATIONS (old_decl);
	t != NULL_TREE;
	t = TREE_CHAIN (t))
	{
	tree spec = TREE_VALUE (t);

	DECL_TI_ARGS (spec)
	= add_outermost_template_args (new_friend_args,
	DECL_TI_ARGS (spec));
	}

	/* Now, since specializations are always supposed to
	hang off of the most general template, we must move
	them. */
	t = most_general_template (old_decl);
	if (t != old_decl)
	{
	DECL_TEMPLATE_SPECIALIZATIONS (t)
	= chainon (DECL_TEMPLATE_SPECIALIZATIONS (t),
	DECL_TEMPLATE_SPECIALIZATIONS (old_decl));
	DECL_TEMPLATE_SPECIALIZATIONS (old_decl) = NULL_TREE;
	}
	}
	}

	/* The information from NEW_FRIEND has been merged into OLD_DECL
	by duplicate_decls. */
	new_friend = old_decl;
	}
	}
	else
	{
	tree context = DECL_CONTEXT (new_friend);
	bool dependent_p;

	/* In the code
	template <class T> class C {
	template <class U> friend void C1<U>::f (); // case 1
	friend void C2<T>::f (); // case 2
	};
	we only need to make sure CONTEXT is a complete type for
	case 2. To distinguish between the two cases, we note that
	CONTEXT of case 1 remains dependent type after tsubst while
	this isn't true for case 2. */
	++processing_template_decl;
	dependent_p = dependent_type_p (context);
	--processing_template_decl;

	if (!dependent_p
	&& !complete_type_or_else (context, NULL_TREE))
	return error_mark_node;

	if (COMPLETE_TYPE_P (context))
	{
	/* Check to see that the declaration is really present, and,
	possibly obtain an improved declaration. */
	tree fn = check_classfn (context,
	new_friend, NULL_TREE);

	if (fn)
	new_friend = fn;
	}
	}

	return new_friend;
	}

	/* FRIEND_TMPL is a friend TEMPLATE_DECL. ARGS is the vector of
	template arguments, as for tsubst.

	Returns an appropriate tsubst'd friend type or error_mark_node on
	failure. */

	static tree
	tsubst_friend_class (tree friend_tmpl, tree args)
	{
	tree friend_type;
	tree tmpl;
	tree context;

	context = DECL_CONTEXT (friend_tmpl);

	if (context)
	{
	if (TREE_CODE (context) == NAMESPACE_DECL)
	push_nested_namespace (context);
	else
	push_nested_class (tsubst (context, args, tf_none, NULL_TREE));
	}

	/* Look for a class template declaration. We look for hidden names
	because two friend declarations of the same template are the
	same. For example, in:

	struct A {
	template <typename> friend class F;
	};
	template <typename> struct B {
	template <typename> friend class F;
	};

	both F templates are the same. */
	tmpl = lookup_name_real (DECL_NAME (friend_tmpl), 0, 0,
	/block_p=/true, 0,
	LOOKUP_COMPLAIN \| LOOKUP_HIDDEN);

	/* But, if we don't find one, it might be because we're in a
	situation like this:

	template <class T>
	struct S {
	template <class U>
	friend struct S;
	};

	Here, in the scope of (say) S<int>, `S' is bound to a TYPE_DECL
	for `S<int>', not the TEMPLATE_DECL. */
	if (!tmpl \|\| !DECL_CLASS_TEMPLATE_P (tmpl))
	{
	tmpl = lookup_name_prefer_type (DECL_NAME (friend_tmpl), 1);
	tmpl = maybe_get_template_decl_from_type_decl (tmpl);
	}

	if (tmpl && DECL_CLASS_TEMPLATE_P (tmpl))
	{
	/* The friend template has already been declared. Just
	check to see that the declarations match, and install any new
	default parameters. We must tsubst the default parameters,
	of course. We only need the innermost template parameters
	because that is all that redeclare_class_template will look
	at. */
	if (TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (friend_tmpl))
	> TMPL_ARGS_DEPTH (args))
	{
	tree parms;
	parms = tsubst_template_parms (DECL_TEMPLATE_PARMS (friend_tmpl),
	args, tf_warning_or_error);
	redeclare_class_template (TREE_TYPE (tmpl), parms);
	}

	friend_type = TREE_TYPE (tmpl);
	}
	else
	{
	/* The friend template has not already been declared. In this
	case, the instantiation of the template class will cause the
	injection of this template into the global scope. */
	tmpl = tsubst (friend_tmpl, args, tf_warning_or_error, NULL_TREE);
	if (tmpl == error_mark_node)
	return error_mark_node;

	/* The new TMPL is not an instantiation of anything, so we
	forget its origins. We don't reset CLASSTYPE_TI_TEMPLATE for
	the new type because that is supposed to be the corresponding
	template decl, i.e., TMPL. */
	DECL_USE_TEMPLATE (tmpl) = 0;
	DECL_TEMPLATE_INFO (tmpl) = NULL_TREE;
	CLASSTYPE_USE_TEMPLATE (TREE_TYPE (tmpl)) = 0;
	CLASSTYPE_TI_ARGS (TREE_TYPE (tmpl))
	= INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (TREE_TYPE (tmpl)));

	/* Inject this template into the global scope. */
	friend_type = TREE_TYPE (pushdecl_top_level_maybe_friend (tmpl, true));
	}

	if (context)
	{
	if (TREE_CODE (context) == NAMESPACE_DECL)
	pop_nested_namespace (context);
	else
	pop_nested_class ();
	}

	return friend_type;
	}

	/* Returns zero if TYPE cannot be completed later due to circularity.
	Otherwise returns one. */

	static int
	can_complete_type_without_circularity (tree type)
	{
	if (type == NULL_TREE \|\| type == error_mark_node)
	return 0;
	else if (COMPLETE_TYPE_P (type))
	return 1;
	else if (TREE_CODE (type) == ARRAY_TYPE && TYPE_DOMAIN (type))
	return can_complete_type_without_circularity (TREE_TYPE (type));
	else if (CLASS_TYPE_P (type)
	&& TYPE_BEING_DEFINED (TYPE_MAIN_VARIANT (type)))
	return 0;
	else
	return 1;
	}

	tree
	instantiate_class_template (tree type)
	{
	tree template, args, pattern, t, member;
	tree typedecl;
	tree pbinfo;
	tree base_list;

	if (type == error_mark_node)
	return error_mark_node;

	if (TYPE_BEING_DEFINED (type)
	\|\| COMPLETE_TYPE_P (type)
	\|\| dependent_type_p (type))
	return type;

	/* Figure out which template is being instantiated. */
	template = most_general_template (CLASSTYPE_TI_TEMPLATE (type));
	gcc_assert (TREE_CODE (template) == TEMPLATE_DECL);

	/* Determine what specialization of the original template to
	instantiate. */
	t = most_specialized_class (type, template);
	if (t == error_mark_node)
	{
	TYPE_BEING_DEFINED (type) = 1;
	return error_mark_node;
	}
	else if (t)
	{
	/* This TYPE is actually an instantiation of a partial
	specialization. We replace the innermost set of ARGS with
	the arguments appropriate for substitution. For example,
	given:

	template <class T> struct S {};
	template <class T> struct S<T*> {};

	and supposing that we are instantiating S<int*>, ARGS will
	presently be {int} -- but we need {int}. /
	pattern = TREE_TYPE (t);
	args = TREE_PURPOSE (t);
	}
	else
	{
	pattern = TREE_TYPE (template);
	args = CLASSTYPE_TI_ARGS (type);
	}

	/* If the template we're instantiating is incomplete, then clearly
	there's nothing we can do. */
	if (!COMPLETE_TYPE_P (pattern))
	return type;

	/* If we've recursively instantiated too many templates, stop. */
	if (! push_tinst_level (type))
	return type;

	/* Now we're really doing the instantiation. Mark the type as in
	the process of being defined. */
	TYPE_BEING_DEFINED (type) = 1;

	/* We may be in the middle of deferred access check. Disable
	it now. */
	push_deferring_access_checks (dk_no_deferred);

	push_to_top_level ();

	SET_CLASSTYPE_INTERFACE_UNKNOWN (type);

	/* Set the input location to the template definition. This is needed
	if tsubsting causes an error. */
	typedecl = TYPE_MAIN_DECL (type);
	input_location = DECL_SOURCE_LOCATION (typedecl);
	in_system_header = DECL_IN_SYSTEM_HEADER (typedecl);

	TYPE_HAS_CONSTRUCTOR (type) = TYPE_HAS_CONSTRUCTOR (pattern);
	TYPE_HAS_NEW_OPERATOR (type) = TYPE_HAS_NEW_OPERATOR (pattern);
	TYPE_HAS_ARRAY_NEW_OPERATOR (type) = TYPE_HAS_ARRAY_NEW_OPERATOR (pattern);
	TYPE_GETS_DELETE (type) = TYPE_GETS_DELETE (pattern);
	TYPE_HAS_ASSIGN_REF (type) = TYPE_HAS_ASSIGN_REF (pattern);
	TYPE_HAS_CONST_ASSIGN_REF (type) = TYPE_HAS_CONST_ASSIGN_REF (pattern);
	TYPE_HAS_INIT_REF (type) = TYPE_HAS_INIT_REF (pattern);
	TYPE_HAS_CONST_INIT_REF (type) = TYPE_HAS_CONST_INIT_REF (pattern);
	TYPE_HAS_DEFAULT_CONSTRUCTOR (type) = TYPE_HAS_DEFAULT_CONSTRUCTOR (pattern);
	TYPE_HAS_CONVERSION (type) = TYPE_HAS_CONVERSION (pattern);
	TYPE_PACKED (type) = TYPE_PACKED (pattern);
	TYPE_ALIGN (type) = TYPE_ALIGN (pattern);
	TYPE_USER_ALIGN (type) = TYPE_USER_ALIGN (pattern);
	TYPE_FOR_JAVA (type) = TYPE_FOR_JAVA (pattern); /* For libjava's JArray<T> */
	if (ANON_AGGR_TYPE_P (pattern))
	SET_ANON_AGGR_TYPE_P (type);
	if (CLASSTYPE_VISIBILITY_SPECIFIED (pattern))
	{
	CLASSTYPE_VISIBILITY_SPECIFIED (type) = 1;
	CLASSTYPE_VISIBILITY (type) = CLASSTYPE_VISIBILITY (pattern);
	}

	pbinfo = TYPE_BINFO (pattern);

	/* We should never instantiate a nested class before its enclosing
	class; we need to look up the nested class by name before we can
	instantiate it, and that lookup should instantiate the enclosing
	class. */
	gcc_assert (!DECL_CLASS_SCOPE_P (TYPE_MAIN_DECL (pattern))
	\|\| COMPLETE_TYPE_P (TYPE_CONTEXT (type))
	\|\| TYPE_BEING_DEFINED (TYPE_CONTEXT (type)));

	base_list = NULL_TREE;
	if (BINFO_N_BASE_BINFOS (pbinfo))
	{
	tree pbase_binfo;
	tree context = TYPE_CONTEXT (type);
	tree pushed_scope;
	int i;

	/* We must enter the scope containing the type, as that is where
	the accessibility of types named in dependent bases are
	looked up from. */
	pushed_scope = push_scope (context ? context : global_namespace);

	/* Substitute into each of the bases to determine the actual
	basetypes. */
	for (i = 0; BINFO_BASE_ITERATE (pbinfo, i, pbase_binfo); i++)
	{
	tree base;
	tree access = BINFO_BASE_ACCESS (pbinfo, i);

	/* Substitute to figure out the base class. */
	base = tsubst (BINFO_TYPE (pbase_binfo), args, tf_error, NULL_TREE);
	if (base == error_mark_node)
	continue;

	base_list = tree_cons (access, base, base_list);
	if (BINFO_VIRTUAL_P (pbase_binfo))
	TREE_TYPE (base_list) = integer_type_node;
	}

	/* The list is now in reverse order; correct that. */
	base_list = nreverse (base_list);

	if (pushed_scope)
	pop_scope (pushed_scope);
	}
	/* Now call xref_basetypes to set up all the base-class
	information. */
	xref_basetypes (type, base_list);


	/* Now that our base classes are set up, enter the scope of the
	class, so that name lookups into base classes, etc. will work
	correctly. This is precisely analogous to what we do in
	begin_class_definition when defining an ordinary non-template
	class. */
	pushclass (type);

	/* Now members are processed in the order of declaration. */
	for (member = CLASSTYPE_DECL_LIST (pattern);
	member; member = TREE_CHAIN (member))
	{
	tree t = TREE_VALUE (member);

	if (TREE_PURPOSE (member))
	{
	if (TYPE_P (t))
	{
	/* Build new CLASSTYPE_NESTED_UTDS. */

	tree newtag;
	bool class_template_p;

	class_template_p = (TREE_CODE (t) != ENUMERAL_TYPE
	&& TYPE_LANG_SPECIFIC (t)
	&& CLASSTYPE_IS_TEMPLATE (t));
	/* If the member is a class template, then -- even after
	substitution -- there may be dependent types in the
	template argument list for the class. We increment
	PROCESSING_TEMPLATE_DECL so that dependent_type_p, as
	that function will assume that no types are dependent
	when outside of a template. */
	if (class_template_p)
	++processing_template_decl;
	newtag = tsubst (t, args, tf_error, NULL_TREE);
	if (class_template_p)
	--processing_template_decl;
	if (newtag == error_mark_node)
	continue;

	if (TREE_CODE (newtag) != ENUMERAL_TYPE)
	{
	tree name = TYPE_IDENTIFIER (t);

	if (class_template_p)
	/* Unfortunately, lookup_template_class sets
	CLASSTYPE_IMPLICIT_INSTANTIATION for a partial
	instantiation (i.e., for the type of a member
	template class nested within a template class.)
	This behavior is required for
	maybe_process_partial_specialization to work
	correctly, but is not accurate in this case;
	the TAG is not an instantiation of anything.
	(The corresponding TEMPLATE_DECL is an
	instantiation, but the TYPE is not.) */
	CLASSTYPE_USE_TEMPLATE (newtag) = 0;

	/* Now, we call pushtag to put this NEWTAG into the scope of
	TYPE. We first set up the IDENTIFIER_TYPE_VALUE to avoid
	pushtag calling push_template_decl. We don't have to do
	this for enums because it will already have been done in
	tsubst_enum. */
	if (name)
	SET_IDENTIFIER_TYPE_VALUE (name, newtag);
	pushtag (name, newtag, /tag_scope=/ts_current);
	}
	}
	else if (TREE_CODE (t) == FUNCTION_DECL
	\|\| DECL_FUNCTION_TEMPLATE_P (t))
	{
	/* Build new TYPE_METHODS. */
	tree r;

	if (TREE_CODE (t) == TEMPLATE_DECL)
	++processing_template_decl;
	r = tsubst (t, args, tf_error, NULL_TREE);
	if (TREE_CODE (t) == TEMPLATE_DECL)
	--processing_template_decl;
	set_current_access_from_decl (r);
	finish_member_declaration (r);
	}
	else
	{
	/* Build new TYPE_FIELDS. */

	if (TREE_CODE (t) != CONST_DECL)
	{
	tree r;

	/* The the file and line for this declaration, to
	assist in error message reporting. Since we
	called push_tinst_level above, we don't need to
	restore these. */
	input_location = DECL_SOURCE_LOCATION (t);

	if (TREE_CODE (t) == TEMPLATE_DECL)
	++processing_template_decl;
	r = tsubst (t, args, tf_warning_or_error, NULL_TREE);
	if (TREE_CODE (t) == TEMPLATE_DECL)
	--processing_template_decl;
	if (TREE_CODE (r) == VAR_DECL)
	{
	/* In [temp.inst]:

	[t]he initialization (and any associated
	side-effects) of a static data member does
	not occur unless the static data member is
	itself used in a way that requires the
	definition of the static data member to
	exist.

	Therefore, we do not substitute into the
	initialized for the static data member here. */
	finish_static_data_member_decl
	(r,
	/init=/NULL_TREE,
	/init_const_expr_p=/false,
	/asmspec_tree=/NULL_TREE,
	/flags=/0);
	if (DECL_INITIALIZED_IN_CLASS_P (r))
	check_static_variable_definition (r, TREE_TYPE (r));
	}
	else if (TREE_CODE (r) == FIELD_DECL)
	{
	/* Determine whether R has a valid type and can be
	completed later. If R is invalid, then it is
	replaced by error_mark_node so that it will not be
	added to TYPE_FIELDS. */
	tree rtype = TREE_TYPE (r);
	if (can_complete_type_without_circularity (rtype))
	complete_type (rtype);

	if (!COMPLETE_TYPE_P (rtype))
	{
	cxx_incomplete_type_error (r, rtype);
	r = error_mark_node;
	}
	}

	/* If it is a TYPE_DECL for a class-scoped ENUMERAL_TYPE,
	such a thing will already have been added to the field
	list by tsubst_enum in finish_member_declaration in the
	CLASSTYPE_NESTED_UTDS case above. */
	if (!(TREE_CODE (r) == TYPE_DECL
	&& TREE_CODE (TREE_TYPE (r)) == ENUMERAL_TYPE
	&& DECL_ARTIFICIAL (r)))
	{
	set_current_access_from_decl (r);
	finish_member_declaration (r);
	}
	}
	}
	}
	else
	{
	if (TYPE_P (t) \|\| DECL_CLASS_TEMPLATE_P (t))
	{
	/* Build new CLASSTYPE_FRIEND_CLASSES. */

	tree friend_type = t;
	bool adjust_processing_template_decl = false;

	if (TREE_CODE (friend_type) == TEMPLATE_DECL)
	{
	/* template <class T> friend class C; */
	friend_type = tsubst_friend_class (friend_type, args);
	adjust_processing_template_decl = true;
	}
	else if (TREE_CODE (friend_type) == UNBOUND_CLASS_TEMPLATE)
	{
	/* template <class T> friend class C::D; */
	friend_type = tsubst (friend_type, args,
	tf_warning_or_error, NULL_TREE);
	if (TREE_CODE (friend_type) == TEMPLATE_DECL)
	friend_type = TREE_TYPE (friend_type);
	adjust_processing_template_decl = true;
	}
	else if (TREE_CODE (friend_type) == TYPENAME_TYPE)
	{
	/* This could be either

	friend class T::C;

	when dependent_type_p is false or

	template <class U> friend class T::C;

	otherwise. */
	friend_type = tsubst (friend_type, args,
	tf_warning_or_error, NULL_TREE);
	/* Bump processing_template_decl for correct
	dependent_type_p calculation. */
	++processing_template_decl;
	if (dependent_type_p (friend_type))
	adjust_processing_template_decl = true;
	--processing_template_decl;
	}
	else if (!CLASSTYPE_USE_TEMPLATE (friend_type)
	&& hidden_name_p (TYPE_NAME (friend_type)))
	{
	/* friend class C;

	where C hasn't been declared yet. Let's lookup name
	from namespace scope directly, bypassing any name that
	come from dependent base class. */
	tree ns = decl_namespace_context (TYPE_MAIN_DECL (friend_type));

	/* The call to xref_tag_from_type does injection for friend
	classes. */
	push_nested_namespace (ns);
	friend_type =
	xref_tag_from_type (friend_type, NULL_TREE,
	/tag_scope=/ts_current);
	pop_nested_namespace (ns);
	}
	else if (uses_template_parms (friend_type))
	/* friend class C<T>; */
	friend_type = tsubst (friend_type, args,
	tf_warning_or_error, NULL_TREE);
	/* Otherwise it's

	friend class C;

	where C is already declared or

	friend class C<int>;

	We don't have to do anything in these cases. */

	if (adjust_processing_template_decl)
	/* Trick make_friend_class into realizing that the friend
	we're adding is a template, not an ordinary class. It's
	important that we use make_friend_class since it will
	perform some error-checking and output cross-reference
	information. */
	++processing_template_decl;

	if (friend_type != error_mark_node)
	make_friend_class (type, friend_type, /complain=/false);

	if (adjust_processing_template_decl)
	--processing_template_decl;
	}
	else
	{
	/* Build new DECL_FRIENDLIST. */
	tree r;

	/* The the file and line for this declaration, to
	assist in error message reporting. Since we
	called push_tinst_level above, we don't need to
	restore these. */
	input_location = DECL_SOURCE_LOCATION (t);

	if (TREE_CODE (t) == TEMPLATE_DECL)
	{
	++processing_template_decl;
	push_deferring_access_checks (dk_no_check);
	}

	r = tsubst_friend_function (t, args);
	add_friend (type, r, /complain=/false);
	if (TREE_CODE (t) == TEMPLATE_DECL)
	{
	pop_deferring_access_checks ();
	--processing_template_decl;
	}
	}
	}
	}

	/* Set the file and line number information to whatever is given for
	the class itself. This puts error messages involving generated
	implicit functions at a predictable point, and the same point
	that would be used for non-template classes. */
	input_location = DECL_SOURCE_LOCATION (typedecl);

	unreverse_member_declarations (type);
	finish_struct_1 (type);
	TYPE_BEING_DEFINED (type) = 0;

	/* Now that the class is complete, instantiate default arguments for
	any member functions. We don't do this earlier because the
	default arguments may reference members of the class. */
	if (!PRIMARY_TEMPLATE_P (template))
	for (t = TYPE_METHODS (type); t; t = TREE_CHAIN (t))
	if (TREE_CODE (t) == FUNCTION_DECL
	/* Implicitly generated member functions will not have template
	information; they are not instantiations, but instead are
	created "fresh" for each instantiation. */
	&& DECL_TEMPLATE_INFO (t))
	tsubst_default_arguments (t);

	popclass ();
	pop_from_top_level ();
	pop_deferring_access_checks ();
	pop_tinst_level ();

	/* The vtable for a template class can be emitted in any translation
	unit in which the class is instantiated. When there is no key
	method, however, finish_struct_1 will already have added TYPE to
	the keyed_classes list. */
	if (TYPE_CONTAINS_VPTR_P (type) && CLASSTYPE_KEY_METHOD (type))
	keyed_classes = tree_cons (NULL_TREE, type, keyed_classes);

	return type;
	}

	static tree
	tsubst_template_arg (tree t, tree args, tsubst_flags_t complain, tree in_decl)
	{
	tree r;

	if (!t)
	r = t;
	else if (TYPE_P (t))
	r = tsubst (t, args, complain, in_decl);
	else
	{
	r = tsubst_expr (t, args, complain, in_decl,
	/integral_constant_expression_p=/true);
	r = fold_non_dependent_expr (r);
	}
	return r;
	}

	/* Substitute ARGS into the vector or list of template arguments T. */

	static tree
	tsubst_template_args (tree t, tree args, tsubst_flags_t complain, tree in_decl)
	{
	int len = TREE_VEC_LENGTH (t);
	int need_new = 0, i;
	tree elts = (tree ) alloca (len * sizeof (tree));

	for (i = 0; i < len; i++)
	{
	tree orig_arg = TREE_VEC_ELT (t, i);
	tree new_arg;

	if (TREE_CODE (orig_arg) == TREE_VEC)
	new_arg = tsubst_template_args (orig_arg, args, complain, in_decl);
	else
	new_arg = tsubst_template_arg (orig_arg, args, complain, in_decl);

	if (new_arg == error_mark_node)
	return error_mark_node;

	elts[i] = new_arg;
	if (new_arg != orig_arg)
	need_new = 1;
	}

	if (!need_new)
	return t;

	t = make_tree_vec (len);
	for (i = 0; i < len; i++)
	TREE_VEC_ELT (t, i) = elts[i];

	return t;
	}

	/* Return the result of substituting ARGS into the template parameters
	given by PARMS. If there are m levels of ARGS and m + n levels of
	PARMS, then the result will contain n levels of PARMS. For
	example, if PARMS is `template <class T> template <class U>
	template <T*, U, class V>' and ARGS is {{int}, {double}} then the
	result will be `template <int, double, class V>'. /

	static tree
	tsubst_template_parms (tree parms, tree args, tsubst_flags_t complain)
	{
	tree r = NULL_TREE;
	tree* new_parms;

	/* When substituting into a template, we must set
	PROCESSING_TEMPLATE_DECL as the template parameters may be
	dependent if they are based on one-another, and the dependency
	predicates are short-circuit outside of templates. */
	++processing_template_decl;

	for (new_parms = &r;
	TMPL_PARMS_DEPTH (parms) > TMPL_ARGS_DEPTH (args);
	new_parms = &(TREE_CHAIN (*new_parms)),
	parms = TREE_CHAIN (parms))
	{
	tree new_vec =
	make_tree_vec (TREE_VEC_LENGTH (TREE_VALUE (parms)));
	int i;

	for (i = 0; i < TREE_VEC_LENGTH (new_vec); ++i)
	{
	tree tuple;
	tree default_value;
	tree parm_decl;

	if (parms == error_mark_node)
	continue;

	tuple = TREE_VEC_ELT (TREE_VALUE (parms), i);

	if (tuple == error_mark_node)
	continue;

	default_value = TREE_PURPOSE (tuple);
	parm_decl = TREE_VALUE (tuple);

	parm_decl = tsubst (parm_decl, args, complain, NULL_TREE);
	if (TREE_CODE (parm_decl) == PARM_DECL
	&& invalid_nontype_parm_type_p (TREE_TYPE (parm_decl), complain))
	parm_decl = error_mark_node;
	default_value = tsubst_template_arg (default_value, args,
	complain, NULL_TREE);

	tuple = build_tree_list (default_value, parm_decl);
	TREE_VEC_ELT (new_vec, i) = tuple;
	}

	*new_parms =
	tree_cons (size_int (TMPL_PARMS_DEPTH (parms)
	- TMPL_ARGS_DEPTH (args)),
	new_vec, NULL_TREE);
	}

	--processing_template_decl;

	return r;
	}

	/* Substitute the ARGS into the indicated aggregate (or enumeration)
	type T. If T is not an aggregate or enumeration type, it is
	handled as if by tsubst. IN_DECL is as for tsubst. If
	ENTERING_SCOPE is nonzero, T is the context for a template which
	we are presently tsubst'ing. Return the substituted value. */

	static tree
	tsubst_aggr_type (tree t,
	tree args,
	tsubst_flags_t complain,
	tree in_decl,
	int entering_scope)
	{
	if (t == NULL_TREE)
	return NULL_TREE;

	switch (TREE_CODE (t))
	{
	case RECORD_TYPE:
	if (TYPE_PTRMEMFUNC_P (t))
	return tsubst (TYPE_PTRMEMFUNC_FN_TYPE (t), args, complain, in_decl);

	/* Else fall through. */
	case ENUMERAL_TYPE:
	case UNION_TYPE:
	if (TYPE_TEMPLATE_INFO (t))
	{
	tree argvec;
	tree context;
	tree r;
	bool saved_skip_evaluation;

	/* In "sizeof(X<I>)" we need to evaluate "I". */
	saved_skip_evaluation = skip_evaluation;
	skip_evaluation = false;

	/* First, determine the context for the type we are looking
	up. */
	context = TYPE_CONTEXT (t);
	if (context)
	context = tsubst_aggr_type (context, args, complain,
	in_decl, /entering_scope=/1);

	/* Then, figure out what arguments are appropriate for the
	type we are trying to find. For example, given:

	template <class T> struct S;
	template <class T, class U> void f(T, U) { S<U> su; }

	and supposing that we are instantiating f<int, double>,
	then our ARGS will be {int, double}, but, when looking up
	S we only want {double}. */
	argvec = tsubst_template_args (TYPE_TI_ARGS (t), args,
	complain, in_decl);
	if (argvec == error_mark_node)
	r = error_mark_node;
	else
	{
	r = lookup_template_class (t, argvec, in_decl, context,
	entering_scope, complain);
	r = cp_build_qualified_type_real (r, TYPE_QUALS (t), complain);
	}

	skip_evaluation = saved_skip_evaluation;

	return r;
	}
	else
	/* This is not a template type, so there's nothing to do. */
	return t;

	default:
	return tsubst (t, args, complain, in_decl);
	}
	}

	/* Substitute into the default argument ARG (a default argument for
	FN), which has the indicated TYPE. */

	tree
	tsubst_default_argument (tree fn, tree type, tree arg)
	{
	tree saved_class_ptr = NULL_TREE;
	tree saved_class_ref = NULL_TREE;

	/* This default argument came from a template. Instantiate the
	default argument here, not in tsubst. In the case of
	something like:

	template <class T>
	struct S {
	static T t();
	void f(T = t());
	};

	we must be careful to do name lookup in the scope of S<T>,
	rather than in the current class. */
	push_access_scope (fn);
	/* The "this" pointer is not valid in a default argument. */
	if (cfun)
	{
	saved_class_ptr = current_class_ptr;
	cp_function_chain->x_current_class_ptr = NULL_TREE;
	saved_class_ref = current_class_ref;
	cp_function_chain->x_current_class_ref = NULL_TREE;
	}

	push_deferring_access_checks(dk_no_deferred);
	/* The default argument expression may cause implicitly defined
	member functions to be synthesized, which will result in garbage
	collection. We must treat this situation as if we were within
	the body of function so as to avoid collecting live data on the
	stack. */
	++function_depth;
	arg = tsubst_expr (arg, DECL_TI_ARGS (fn),
	tf_warning_or_error, NULL_TREE,
	/integral_constant_expression_p=/false);
	--function_depth;
	pop_deferring_access_checks();

	/* Restore the "this" pointer. */
	if (cfun)
	{
	cp_function_chain->x_current_class_ptr = saved_class_ptr;
	cp_function_chain->x_current_class_ref = saved_class_ref;
	}

	pop_access_scope (fn);

	/* Make sure the default argument is reasonable. */
	arg = check_default_argument (type, arg);

	return arg;
	}

	/* Substitute into all the default arguments for FN. */

	static void
	tsubst_default_arguments (tree fn)
	{
	tree arg;
	tree tmpl_args;

	tmpl_args = DECL_TI_ARGS (fn);

	/* If this function is not yet instantiated, we certainly don't need
	its default arguments. */
	if (uses_template_parms (tmpl_args))
	return;

	for (arg = TYPE_ARG_TYPES (TREE_TYPE (fn));
	arg;
	arg = TREE_CHAIN (arg))
	if (TREE_PURPOSE (arg))
	TREE_PURPOSE (arg) = tsubst_default_argument (fn,
	TREE_VALUE (arg),
	TREE_PURPOSE (arg));
	}

	/* Substitute the ARGS into the T, which is a _DECL. Return the
	result of the substitution. Issue error and warning messages under
	control of COMPLAIN. */

	static tree
	tsubst_decl (tree t, tree args, tsubst_flags_t complain)
	{
	location_t saved_loc;
	tree r = NULL_TREE;
	tree in_decl = t;

	/* Set the filename and linenumber to improve error-reporting. */
	saved_loc = input_location;
	input_location = DECL_SOURCE_LOCATION (t);

	switch (TREE_CODE (t))
	{
	case TEMPLATE_DECL:
	{
	/* We can get here when processing a member function template,
	member class template, and template template parameter of
	a template class. */
	tree decl = DECL_TEMPLATE_RESULT (t);
	tree spec;
	tree tmpl_args;
	tree full_args;

	if (DECL_TEMPLATE_TEMPLATE_PARM_P (t))
	{
	/* Template template parameter is treated here. */
	tree new_type = tsubst (TREE_TYPE (t), args, complain, in_decl);
	if (new_type == error_mark_node)
	return error_mark_node;

	r = copy_decl (t);
	TREE_CHAIN (r) = NULL_TREE;
	TREE_TYPE (r) = new_type;
	DECL_TEMPLATE_RESULT (r)
	= build_decl (TYPE_DECL, DECL_NAME (decl), new_type);
	DECL_TEMPLATE_PARMS (r)
	= tsubst_template_parms (DECL_TEMPLATE_PARMS (t), args,
	complain);
	TYPE_NAME (new_type) = r;
	break;
	}

	/* We might already have an instance of this template.
	The ARGS are for the surrounding class type, so the
	full args contain the tsubst'd args for the context,
	plus the innermost args from the template decl. */
	tmpl_args = DECL_CLASS_TEMPLATE_P (t)
	? CLASSTYPE_TI_ARGS (TREE_TYPE (t))
	: DECL_TI_ARGS (DECL_TEMPLATE_RESULT (t));
	/* Because this is a template, the arguments will still be
	dependent, even after substitution. If
	PROCESSING_TEMPLATE_DECL is not set, the dependency
	predicates will short-circuit. */
	++processing_template_decl;
	full_args = tsubst_template_args (tmpl_args, args,
	complain, in_decl);
	--processing_template_decl;
	if (full_args == error_mark_node)
	return error_mark_node;

	/* tsubst_template_args doesn't copy the vector if
	nothing changed. But, something should have
	changed. */
	gcc_assert (full_args != tmpl_args);

	spec = retrieve_specialization (t, full_args,
	/class_specializations_p=/true);
	if (spec != NULL_TREE)
	{
	r = spec;
	break;
	}

	/* Make a new template decl. It will be similar to the
	original, but will record the current template arguments.
	We also create a new function declaration, which is just
	like the old one, but points to this new template, rather
	than the old one. */
	r = copy_decl (t);
	gcc_assert (DECL_LANG_SPECIFIC (r) != 0);
	TREE_CHAIN (r) = NULL_TREE;

	DECL_TEMPLATE_INFO (r) = build_tree_list (t, args);

	if (TREE_CODE (decl) == TYPE_DECL)
	{
	tree new_type;
	++processing_template_decl;
	new_type = tsubst (TREE_TYPE (t), args, complain, in_decl);
	--processing_template_decl;
	if (new_type == error_mark_node)
	return error_mark_node;

	TREE_TYPE (r) = new_type;
	CLASSTYPE_TI_TEMPLATE (new_type) = r;
	DECL_TEMPLATE_RESULT (r) = TYPE_MAIN_DECL (new_type);
	DECL_TI_ARGS (r) = CLASSTYPE_TI_ARGS (new_type);
	DECL_CONTEXT (r) = TYPE_CONTEXT (new_type);
	}
	else
	{
	tree new_decl;
	++processing_template_decl;
	new_decl = tsubst (decl, args, complain, in_decl);
	--processing_template_decl;
	if (new_decl == error_mark_node)
	return error_mark_node;

	DECL_TEMPLATE_RESULT (r) = new_decl;
	DECL_TI_TEMPLATE (new_decl) = r;
	TREE_TYPE (r) = TREE_TYPE (new_decl);
	DECL_TI_ARGS (r) = DECL_TI_ARGS (new_decl);
	DECL_CONTEXT (r) = DECL_CONTEXT (new_decl);
	}

	SET_DECL_IMPLICIT_INSTANTIATION (r);
	DECL_TEMPLATE_INSTANTIATIONS (r) = NULL_TREE;
	DECL_TEMPLATE_SPECIALIZATIONS (r) = NULL_TREE;

	/* The template parameters for this new template are all the
	template parameters for the old template, except the
	outermost level of parameters. */
	DECL_TEMPLATE_PARMS (r)
	= tsubst_template_parms (DECL_TEMPLATE_PARMS (t), args,
	complain);

	if (PRIMARY_TEMPLATE_P (t))
	DECL_PRIMARY_TEMPLATE (r) = r;

	if (TREE_CODE (decl) != TYPE_DECL)
	/* Record this non-type partial instantiation. */
	register_specialization (r, t,
	DECL_TI_ARGS (DECL_TEMPLATE_RESULT (r)),
	false);
	}
	break;

	case FUNCTION_DECL:
	{
	tree ctx;
	tree argvec = NULL_TREE;
	tree *friends;
	tree gen_tmpl;
	tree type;
	int member;
	int args_depth;
	int parms_depth;

	/* Nobody should be tsubst'ing into non-template functions. */
	gcc_assert (DECL_TEMPLATE_INFO (t) != NULL_TREE);

	if (TREE_CODE (DECL_TI_TEMPLATE (t)) == TEMPLATE_DECL)
	{
	tree spec;
	bool dependent_p;

	/* If T is not dependent, just return it. We have to
	increment PROCESSING_TEMPLATE_DECL because
	value_dependent_expression_p assumes that nothing is
	dependent when PROCESSING_TEMPLATE_DECL is zero. */
	++processing_template_decl;
	dependent_p = value_dependent_expression_p (t);
	--processing_template_decl;
	if (!dependent_p)
	return t;

	/* Calculate the most general template of which R is a
	specialization, and the complete set of arguments used to
	specialize R. */
	gen_tmpl = most_general_template (DECL_TI_TEMPLATE (t));
	argvec = tsubst_template_args (DECL_TI_ARGS
	(DECL_TEMPLATE_RESULT (gen_tmpl)),
	args, complain, in_decl);

	/* Check to see if we already have this specialization. */
	spec = retrieve_specialization (gen_tmpl, argvec,
	/class_specializations_p=/false);

	if (spec)
	{
	r = spec;
	break;
	}

	/* We can see more levels of arguments than parameters if
	there was a specialization of a member template, like
	this:

	template <class T> struct S { template <class U> void f(); }
	template <> template <class U> void S<int>::f(U);

	Here, we'll be substituting into the specialization,
	because that's where we can find the code we actually
	want to generate, but we'll have enough arguments for
	the most general template.

	We also deal with the peculiar case:

	template <class T> struct S {
	template <class U> friend void f();
	};
	template <class U> void f() {}
	template S<int>;
	template void f<double>();

	Here, the ARGS for the instantiation of will be {int,
	double}. But, we only need as many ARGS as there are
	levels of template parameters in CODE_PATTERN. We are
	careful not to get fooled into reducing the ARGS in
	situations like:

	template <class T> struct S { template <class U> void f(U); }
	template <class T> template <> void S<T>::f(int) {}

	which we can spot because the pattern will be a
	specialization in this case. */
	args_depth = TMPL_ARGS_DEPTH (args);
	parms_depth =
	TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (DECL_TI_TEMPLATE (t)));
	if (args_depth > parms_depth
	&& !DECL_TEMPLATE_SPECIALIZATION (t))
	args = get_innermost_template_args (args, parms_depth);
	}
	else
	{
	/* This special case arises when we have something like this:

	template <class T> struct S {
	friend void f<int>(int, double);
	};

	Here, the DECL_TI_TEMPLATE for the friend declaration
	will be an IDENTIFIER_NODE. We are being called from
	tsubst_friend_function, and we want only to create a
	new decl (R) with appropriate types so that we can call
	determine_specialization. */
	gen_tmpl = NULL_TREE;
	}

	if (DECL_CLASS_SCOPE_P (t))
	{
	if (DECL_NAME (t) == constructor_name (DECL_CONTEXT (t)))
	member = 2;
	else
	member = 1;
	ctx = tsubst_aggr_type (DECL_CONTEXT (t), args,
	complain, t, /entering_scope=/1);
	}
	else
	{
	member = 0;
	ctx = DECL_CONTEXT (t);
	}
	type = tsubst (TREE_TYPE (t), args, complain, in_decl);
	if (type == error_mark_node)
	return error_mark_node;

	/* We do NOT check for matching decls pushed separately at this
	point, as they may not represent instantiations of this
	template, and in any case are considered separate under the
	discrete model. */
	r = copy_decl (t);
	DECL_USE_TEMPLATE (r) = 0;
	TREE_TYPE (r) = type;
	/* Clear out the mangled name and RTL for the instantiation. */
	SET_DECL_ASSEMBLER_NAME (r, NULL_TREE);
	SET_DECL_RTL (r, NULL_RTX);
	DECL_INITIAL (r) = NULL_TREE;
	DECL_CONTEXT (r) = ctx;

	if (member && DECL_CONV_FN_P (r))
	/* Type-conversion operator. Reconstruct the name, in
	case it's the name of one of the template's parameters. */
	DECL_NAME (r) = mangle_conv_op_name_for_type (TREE_TYPE (type));

	DECL_ARGUMENTS (r) = tsubst (DECL_ARGUMENTS (t), args,
	complain, t);
	DECL_RESULT (r) = NULL_TREE;

	TREE_STATIC (r) = 0;
	TREE_PUBLIC (r) = TREE_PUBLIC (t);
	DECL_EXTERNAL (r) = 1;
	/* If this is an instantiation of a function with internal
	linkage, we already know what object file linkage will be
	assigned to the instantiation. */
	DECL_INTERFACE_KNOWN (r) = !TREE_PUBLIC (r);
	DECL_DEFER_OUTPUT (r) = 0;
	TREE_CHAIN (r) = NULL_TREE;
	DECL_PENDING_INLINE_INFO (r) = 0;
	DECL_PENDING_INLINE_P (r) = 0;
	DECL_SAVED_TREE (r) = NULL_TREE;
	TREE_USED (r) = 0;
	if (DECL_CLONED_FUNCTION (r))
	{
	DECL_CLONED_FUNCTION (r) = tsubst (DECL_CLONED_FUNCTION (t),
	args, complain, t);
	TREE_CHAIN (r) = TREE_CHAIN (DECL_CLONED_FUNCTION (r));
	TREE_CHAIN (DECL_CLONED_FUNCTION (r)) = r;
	}

	/* Set up the DECL_TEMPLATE_INFO for R. There's no need to do
	this in the special friend case mentioned above where
	GEN_TMPL is NULL. */
	if (gen_tmpl)
	{
	DECL_TEMPLATE_INFO (r)
	= tree_cons (gen_tmpl, argvec, NULL_TREE);
	SET_DECL_IMPLICIT_INSTANTIATION (r);
	register_specialization (r, gen_tmpl, argvec, false);

	/* We're not supposed to instantiate default arguments
	until they are called, for a template. But, for a
	declaration like:

	template <class T> void f ()
	{ extern void g(int i = T()); }

	we should do the substitution when the template is
	instantiated. We handle the member function case in
	instantiate_class_template since the default arguments
	might refer to other members of the class. */
	if (!member
	&& !PRIMARY_TEMPLATE_P (gen_tmpl)
	&& !uses_template_parms (argvec))
	tsubst_default_arguments (r);
	}
	else
	DECL_TEMPLATE_INFO (r) = NULL_TREE;

	/* Copy the list of befriending classes. */
	for (friends = &DECL_BEFRIENDING_CLASSES (r);
	*friends;
	friends = &TREE_CHAIN (*friends))
	{
	friends = copy_node (friends);
	TREE_VALUE (friends) = tsubst (TREE_VALUE (friends),
	args, complain,
	in_decl);
	}

	if (DECL_CONSTRUCTOR_P (r) \|\| DECL_DESTRUCTOR_P (r))
	{
	maybe_retrofit_in_chrg (r);
	if (DECL_CONSTRUCTOR_P (r))
	grok_ctor_properties (ctx, r);
	/* If this is an instantiation of a member template, clone it.
	If it isn't, that'll be handled by
	clone_constructors_and_destructors. */
	if (PRIMARY_TEMPLATE_P (gen_tmpl))
	clone_function_decl (r, /update_method_vec_p=/0);
	}
	else if (IDENTIFIER_OPNAME_P (DECL_NAME (r))
	&& !grok_op_properties (r, (complain & tf_error) != 0))
	return error_mark_node;

	if (DECL_FRIEND_P (t) && DECL_FRIEND_CONTEXT (t))
	SET_DECL_FRIEND_CONTEXT (r,
	tsubst (DECL_FRIEND_CONTEXT (t),
	args, complain, in_decl));

	/* Possibly limit visibility based on template args. */
	DECL_VISIBILITY (r) = VISIBILITY_DEFAULT;
	if (DECL_VISIBILITY_SPECIFIED (t))
	{
	DECL_VISIBILITY_SPECIFIED (r) = 0;
	DECL_ATTRIBUTES (r)
	= remove_attribute ("visibility", DECL_ATTRIBUTES (r));
	}
	determine_visibility (r);
	}
	break;

	case PARM_DECL:
	{
	tree type;

	r = copy_node (t);
	if (DECL_TEMPLATE_PARM_P (t))
	SET_DECL_TEMPLATE_PARM_P (r);

	type = tsubst (TREE_TYPE (t), args, complain, in_decl);
	type = type_decays_to (type);
	TREE_TYPE (r) = type;
	cp_apply_type_quals_to_decl (cp_type_quals (type), r);

	if (DECL_INITIAL (r))
	{
	if (TREE_CODE (DECL_INITIAL (r)) != TEMPLATE_PARM_INDEX)
	DECL_INITIAL (r) = TREE_TYPE (r);
	else
	DECL_INITIAL (r) = tsubst (DECL_INITIAL (r), args,
	complain, in_decl);
	}

	DECL_CONTEXT (r) = NULL_TREE;

	if (!DECL_TEMPLATE_PARM_P (r))
	DECL_ARG_TYPE (r) = type_passed_as (type);
	if (TREE_CHAIN (t))
	TREE_CHAIN (r) = tsubst (TREE_CHAIN (t), args,
	complain, TREE_CHAIN (t));
	}
	break;

	case FIELD_DECL:
	{
	tree type;

	r = copy_decl (t);
	type = tsubst (TREE_TYPE (t), args, complain, in_decl);
	if (type == error_mark_node)
	return error_mark_node;
	TREE_TYPE (r) = type;
	cp_apply_type_quals_to_decl (cp_type_quals (type), r);

	/* DECL_INITIAL gives the number of bits in a bit-field. */
	DECL_INITIAL (r)
	= tsubst_expr (DECL_INITIAL (t), args,
	complain, in_decl,
	/integral_constant_expression_p=/true);
	/* We don't have to set DECL_CONTEXT here; it is set by
	finish_member_declaration. */
	TREE_CHAIN (r) = NULL_TREE;
	if (VOID_TYPE_P (type))
	error ("instantiation of %q+D as type %qT", r, type);
	}
	break;

	case USING_DECL:
	/* We reach here only for member using decls. */
	if (DECL_DEPENDENT_P (t))
	{
	r = do_class_using_decl
	(tsubst_copy (USING_DECL_SCOPE (t), args, complain, in_decl),
	tsubst_copy (DECL_NAME (t), args, complain, in_decl));
	if (!r)
	r = error_mark_node;
	}
	else
	{
	r = copy_node (t);
	TREE_CHAIN (r) = NULL_TREE;
	}
	break;

	case TYPE_DECL:
	case VAR_DECL:
	{
	tree argvec = NULL_TREE;
	tree gen_tmpl = NULL_TREE;
	tree spec;
	tree tmpl = NULL_TREE;
	tree ctx;
	tree type = NULL_TREE;
	bool local_p;

	if (TREE_CODE (t) == TYPE_DECL)
	{
	type = tsubst (TREE_TYPE (t), args, complain, in_decl);
	if (TREE_CODE (type) == TEMPLATE_TEMPLATE_PARM
	\|\| t == TYPE_MAIN_DECL (TREE_TYPE (t)))
	{
	/* If this is the canonical decl, we don't have to
	mess with instantiations, and often we can't (for
	typename, template type parms and such). Note that
	TYPE_NAME is not correct for the above test if
	we've copied the type for a typedef. */
	r = TYPE_NAME (type);
	break;
	}
	}

	/* Check to see if we already have the specialization we
	need. */
	spec = NULL_TREE;
	if (DECL_CLASS_SCOPE_P (t) \|\| DECL_NAMESPACE_SCOPE_P (t))
	{
	/* T is a static data member or namespace-scope entity.
	We have to substitute into namespace-scope variables
	(even though such entities are never templates) because
	of cases like:

	template <class T> void f() { extern T t; }

	where the entity referenced is not known until
	instantiation time. */
	local_p = false;
	ctx = DECL_CONTEXT (t);
	if (DECL_CLASS_SCOPE_P (t))
	{
	ctx = tsubst_aggr_type (ctx, args,
	complain,
	in_decl, /entering_scope=/1);
	/* If CTX is unchanged, then T is in fact the
	specialization we want. That situation occurs when
	referencing a static data member within in its own
	class. We can use pointer equality, rather than
	same_type_p, because DECL_CONTEXT is always
	canonical. */
	if (ctx == DECL_CONTEXT (t))
	spec = t;
	}

	if (!spec)
	{
	tmpl = DECL_TI_TEMPLATE (t);
	gen_tmpl = most_general_template (tmpl);
	argvec = tsubst (DECL_TI_ARGS (t), args, complain, in_decl);
	spec = (retrieve_specialization
	(gen_tmpl, argvec,
	/class_specializations_p=/false));
	}
	}
	else
	{
	/* A local variable. */
	local_p = true;
	/* Subsequent calls to pushdecl will fill this in. */
	ctx = NULL_TREE;
	spec = retrieve_local_specialization (t);
	}
	/* If we already have the specialization we need, there is
	nothing more to do. */
	if (spec)
	{
	r = spec;
	break;
	}

	/* Create a new node for the specialization we need. */
	r = copy_decl (t);
	if (TREE_CODE (r) == VAR_DECL)
	{
	/* Even if the original location is out of scope, the
	newly substituted one is not. */
	DECL_DEAD_FOR_LOCAL (r) = 0;
	DECL_INITIALIZED_P (r) = 0;
	DECL_TEMPLATE_INSTANTIATED (r) = 0;
	type = tsubst (TREE_TYPE (t), args, complain, in_decl);
	if (type == error_mark_node)
	return error_mark_node;
	if (TREE_CODE (type) == FUNCTION_TYPE)
	{
	/* It may seem that this case cannot occur, since:

	typedef void f();
	void g() { f x; }

	declares a function, not a variable. However:

	typedef void f();
	template <typename T> void g() { T t; }
	template void g<f>();

	is an attempt to declare a variable with function
	type. */
	error ("variable %qD has function type",
	/* R is not yet sufficiently initialized, so we
	just use its name. */
	DECL_NAME (r));
	return error_mark_node;
	}
	type = complete_type (type);
	DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (r)
	= DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (t);
	type = check_var_type (DECL_NAME (r), type);

	if (DECL_HAS_VALUE_EXPR_P (t))
	{
	tree ve = DECL_VALUE_EXPR (t);
	ve = tsubst_expr (ve, args, complain, in_decl,
	/constant_expression_p=/false);
	SET_DECL_VALUE_EXPR (r, ve);
	}
	}
	else if (DECL_SELF_REFERENCE_P (t))
	SET_DECL_SELF_REFERENCE_P (r);
	TREE_TYPE (r) = type;
	cp_apply_type_quals_to_decl (cp_type_quals (type), r);
	DECL_CONTEXT (r) = ctx;
	/* Clear out the mangled name and RTL for the instantiation. */
	SET_DECL_ASSEMBLER_NAME (r, NULL_TREE);
	if (CODE_CONTAINS_STRUCT (TREE_CODE (t), TS_DECL_WRTL))
	SET_DECL_RTL (r, NULL_RTX);
	/* The initializer must not be expanded until it is required;
	see [temp.inst]. */
	DECL_INITIAL (r) = NULL_TREE;
	if (CODE_CONTAINS_STRUCT (TREE_CODE (t), TS_DECL_WRTL))
	SET_DECL_RTL (r, NULL_RTX);
	DECL_SIZE (r) = DECL_SIZE_UNIT (r) = 0;
	if (TREE_CODE (r) == VAR_DECL)
	{
	/* Possibly limit visibility based on template args. */
	DECL_VISIBILITY (r) = VISIBILITY_DEFAULT;
	if (DECL_VISIBILITY_SPECIFIED (t))
	{
	DECL_VISIBILITY_SPECIFIED (r) = 0;
	DECL_ATTRIBUTES (r)
	= remove_attribute ("visibility", DECL_ATTRIBUTES (r));
	}
	determine_visibility (r);
	}

	if (!local_p)
	{
	/* A static data member declaration is always marked
	external when it is declared in-class, even if an
	initializer is present. We mimic the non-template
	processing here. */
	DECL_EXTERNAL (r) = 1;

	register_specialization (r, gen_tmpl, argvec, false);
	DECL_TEMPLATE_INFO (r) = tree_cons (tmpl, argvec, NULL_TREE);
	SET_DECL_IMPLICIT_INSTANTIATION (r);
	}
	else
	register_local_specialization (r, t);

	TREE_CHAIN (r) = NULL_TREE;
	layout_decl (r, 0);
	}
	break;

	default:
	gcc_unreachable ();
	}

	/* Restore the file and line information. */
	input_location = saved_loc;

	return r;
	}

	/* Substitute into the ARG_TYPES of a function type. */

	static tree
	tsubst_arg_types (tree arg_types,
	tree args,
	tsubst_flags_t complain,
	tree in_decl)
	{
	tree remaining_arg_types;
	tree type;
	tree default_arg;
	tree result = NULL_TREE;

	if (!arg_types \|\| arg_types == void_list_node)
	return arg_types;

	remaining_arg_types = tsubst_arg_types (TREE_CHAIN (arg_types),
	args, complain, in_decl);
	if (remaining_arg_types == error_mark_node)
	return error_mark_node;

	type = tsubst (TREE_VALUE (arg_types), args, complain, in_decl);
	if (type == error_mark_node)
	return error_mark_node;
	if (VOID_TYPE_P (type))
	{
	if (complain & tf_error)
	{
	error ("invalid parameter type %qT", type);
	if (in_decl)
	error ("in declaration %q+D", in_decl);
	}
	return error_mark_node;
	}

	/* Do array-to-pointer, function-to-pointer conversion, and ignore
	top-level qualifiers as required. */
	type = TYPE_MAIN_VARIANT (type_decays_to (type));

	/* We do not substitute into default arguments here. The standard
	mandates that they be instantiated only when needed, which is
	done in build_over_call. */
	default_arg = TREE_PURPOSE (arg_types);

	if (default_arg && TREE_CODE (default_arg) == DEFAULT_ARG)
	{
	/* We've instantiated a template before its default arguments
	have been parsed. This can happen for a nested template
	class, and is not an error unless we require the default
	argument in a call of this function. */
	result = tree_cons (default_arg, type, remaining_arg_types);
	VEC_safe_push (tree, gc, DEFARG_INSTANTIATIONS (default_arg), result);
	}
	else
	result = hash_tree_cons (default_arg, type, remaining_arg_types);

	return result;
	}

	/* Substitute into a FUNCTION_TYPE or METHOD_TYPE. This routine does
	not handle the exception-specification for FNTYPE, because the
	initial substitution of explicitly provided template parameters
	during argument deduction forbids substitution into the
	exception-specification:

	[temp.deduct]

	All references in the function type of the function template to the
	corresponding template parameters are replaced by the specified tem-
	plate argument values. If a substitution in a template parameter or
	in the function type of the function template results in an invalid
	type, type deduction fails. [Note: The equivalent substitution in
	exception specifications is done only when the function is instanti-
	ated, at which point a program is ill-formed if the substitution
	results in an invalid type.] */

	static tree
	tsubst_function_type (tree t,
	tree args,
	tsubst_flags_t complain,
	tree in_decl)
	{
	tree return_type;
	tree arg_types;
	tree fntype;

	/* The TYPE_CONTEXT is not used for function/method types. */
	gcc_assert (TYPE_CONTEXT (t) == NULL_TREE);

	/* Substitute the return type. */
	return_type = tsubst (TREE_TYPE (t), args, complain, in_decl);
	if (return_type == error_mark_node)
	return error_mark_node;
	/* The standard does not presently indicate that creation of a
	function type with an invalid return type is a deduction failure.
	However, that is clearly analogous to creating an array of "void"
	or a reference to a reference. This is core issue #486. */
	if (TREE_CODE (return_type) == ARRAY_TYPE
	\|\| TREE_CODE (return_type) == FUNCTION_TYPE)
	{
	if (complain & tf_error)
	{
	if (TREE_CODE (return_type) == ARRAY_TYPE)
	error ("function returning an array");
	else
	error ("function returning a function");
	}
	return error_mark_node;
	}

	/* Substitute the argument types. */
	arg_types = tsubst_arg_types (TYPE_ARG_TYPES (t), args,
	complain, in_decl);
	if (arg_types == error_mark_node)
	return error_mark_node;

	/* Construct a new type node and return it. */
	if (TREE_CODE (t) == FUNCTION_TYPE)
	fntype = build_function_type (return_type, arg_types);
	else
	{
	tree r = TREE_TYPE (TREE_VALUE (arg_types));
	if (! IS_AGGR_TYPE (r))
	{
	/* [temp.deduct]

	Type deduction may fail for any of the following
	reasons:

	-- Attempting to create "pointer to member of T" when T
	is not a class type. */
	if (complain & tf_error)
	error ("creating pointer to member function of non-class type %qT",
	r);
	return error_mark_node;
	}

	fntype = build_method_type_directly (r, return_type,
	TREE_CHAIN (arg_types));
	}
	fntype = cp_build_qualified_type_real (fntype, TYPE_QUALS (t), complain);
	fntype = cp_build_type_attribute_variant (fntype, TYPE_ATTRIBUTES (t));

	return fntype;
	}

	/* FNTYPE is a FUNCTION_TYPE or METHOD_TYPE. Substitute the template
	ARGS into that specification, and return the substituted
	specification. If there is no specification, return NULL_TREE. */

	static tree
	tsubst_exception_specification (tree fntype,
	tree args,
	tsubst_flags_t complain,
	tree in_decl)
	{
	tree specs;
	tree new_specs;

	specs = TYPE_RAISES_EXCEPTIONS (fntype);
	new_specs = NULL_TREE;
	if (specs)
	{
	if (! TREE_VALUE (specs))
	new_specs = specs;
	else
	while (specs)
	{
	tree spec;
	spec = tsubst (TREE_VALUE (specs), args, complain, in_decl);
	if (spec == error_mark_node)
	return spec;
	new_specs = add_exception_specifier (new_specs, spec, complain);
	specs = TREE_CHAIN (specs);
	}
	}
	return new_specs;
	}

	/* Take the tree structure T and replace template parameters used
	therein with the argument vector ARGS. IN_DECL is an associated
	decl for diagnostics. If an error occurs, returns ERROR_MARK_NODE.
	Issue error and warning messages under control of COMPLAIN. Note
	that we must be relatively non-tolerant of extensions here, in
	order to preserve conformance; if we allow substitutions that
	should not be allowed, we may allow argument deductions that should
	not succeed, and therefore report ambiguous overload situations
	where there are none. In theory, we could allow the substitution,
	but indicate that it should have failed, and allow our caller to
	make sure that the right thing happens, but we don't try to do this
	yet.

	This function is used for dealing with types, decls and the like;
	for expressions, use tsubst_expr or tsubst_copy. */

	static tree
	tsubst (tree t, tree args, tsubst_flags_t complain, tree in_decl)
	{
	tree type, r;

	if (t == NULL_TREE \|\| t == error_mark_node
	\|\| t == integer_type_node
	\|\| t == void_type_node
	\|\| t == char_type_node
	\|\| t == unknown_type_node
	\|\| TREE_CODE (t) == NAMESPACE_DECL)
	return t;

	if (DECL_P (t))
	return tsubst_decl (t, args, complain);

	if (TREE_CODE (t) == IDENTIFIER_NODE)
	type = IDENTIFIER_TYPE_VALUE (t);
	else
	type = TREE_TYPE (t);

	gcc_assert (type != unknown_type_node);

	if (type
	&& TREE_CODE (t) != TYPENAME_TYPE
	&& TREE_CODE (t) != IDENTIFIER_NODE
	&& TREE_CODE (t) != FUNCTION_TYPE
	&& TREE_CODE (t) != METHOD_TYPE)
	type = tsubst (type, args, complain, in_decl);
	if (type == error_mark_node)
	return error_mark_node;

	switch (TREE_CODE (t))
	{
	case RECORD_TYPE:
	case UNION_TYPE:
	case ENUMERAL_TYPE:
	return tsubst_aggr_type (t, args, complain, in_decl,
	/entering_scope=/0);

	case ERROR_MARK:
	case IDENTIFIER_NODE:
	case VOID_TYPE:
	case REAL_TYPE:
	case COMPLEX_TYPE:
	case VECTOR_TYPE:
	case BOOLEAN_TYPE:
	case INTEGER_CST:
	case REAL_CST:
	case STRING_CST:
	return t;

	case INTEGER_TYPE:
	if (t == integer_type_node)
	return t;

	if (TREE_CODE (TYPE_MIN_VALUE (t)) == INTEGER_CST
	&& TREE_CODE (TYPE_MAX_VALUE (t)) == INTEGER_CST)
	return t;

	{
	tree max, omax = TREE_OPERAND (TYPE_MAX_VALUE (t), 0);

	max = tsubst_expr (omax, args, complain, in_decl,
	/integral_constant_expression_p=/false);
	max = fold_decl_constant_value (max);

	if (TREE_CODE (max) != INTEGER_CST
	&& TREE_CODE (max) != TEMPLATE_PARM_INDEX
	&& !at_function_scope_p ())
	{
	if (complain & tf_error)
	error ("array bound is not an integer constant");
	return error_mark_node;
	}

	/* [temp.deduct]

	Type deduction may fail for any of the following
	reasons:

	Attempting to create an array with a size that is
	zero or negative. */
	if (integer_zerop (max) && !(complain & tf_error))
	/* We must fail if performing argument deduction (as
	indicated by the state of complain), so that
	another substitution can be found. */
	return error_mark_node;
	else if (TREE_CODE (max) == INTEGER_CST
	&& INT_CST_LT (max, integer_zero_node))
	{
	if (complain & tf_error)
	error ("creating array with negative size (%qE)", max);

	return error_mark_node;
	}

	return compute_array_index_type (NULL_TREE, max);
	}

	case TEMPLATE_TYPE_PARM:
	case TEMPLATE_TEMPLATE_PARM:
	case BOUND_TEMPLATE_TEMPLATE_PARM:
	case TEMPLATE_PARM_INDEX:
	{
	int idx;
	int level;
	int levels;
	tree arg = NULL_TREE;

	r = NULL_TREE;

	gcc_assert (TREE_VEC_LENGTH (args) > 0);
	if (TREE_CODE (t) == TEMPLATE_TYPE_PARM
	\|\| TREE_CODE (t) == TEMPLATE_TEMPLATE_PARM
	\|\| TREE_CODE (t) == BOUND_TEMPLATE_TEMPLATE_PARM)
	{
	idx = TEMPLATE_TYPE_IDX (t);
	level = TEMPLATE_TYPE_LEVEL (t);
	}
	else
	{
	idx = TEMPLATE_PARM_IDX (t);
	level = TEMPLATE_PARM_LEVEL (t);
	}

	levels = TMPL_ARGS_DEPTH (args);
	if (level <= levels)
	arg = TMPL_ARG (args, level, idx);

	if (arg == error_mark_node)
	return error_mark_node;
	else if (arg != NULL_TREE)
	{
	if (TREE_CODE (t) == TEMPLATE_TYPE_PARM)
	{
	int quals;
	gcc_assert (TYPE_P (arg));

	/* cv-quals from the template are discarded when
	substituting in a function or reference type. */
	if (TREE_CODE (arg) == FUNCTION_TYPE
	\|\| TREE_CODE (arg) == METHOD_TYPE
	\|\| TREE_CODE (arg) == REFERENCE_TYPE)
	quals = cp_type_quals (arg);
	else
	quals = cp_type_quals (arg) \| cp_type_quals (t);

	return cp_build_qualified_type_real
	(arg, quals, complain \| tf_ignore_bad_quals);
	}
	else if (TREE_CODE (t) == BOUND_TEMPLATE_TEMPLATE_PARM)
	{
	/* We are processing a type constructed from a
	template template parameter. */
	tree argvec = tsubst (TYPE_TI_ARGS (t),
	args, complain, in_decl);
	if (argvec == error_mark_node)
	return error_mark_node;

	/* We can get a TEMPLATE_TEMPLATE_PARM here when we
	are resolving nested-types in the signature of a
	member function templates. Otherwise ARG is a
	TEMPLATE_DECL and is the real template to be
	instantiated. */
	if (TREE_CODE (arg) == TEMPLATE_TEMPLATE_PARM)
	arg = TYPE_NAME (arg);

	r = lookup_template_class (arg,
	argvec, in_decl,
	DECL_CONTEXT (arg),
	/entering_scope=/0,
	complain);
	return cp_build_qualified_type_real
	(r, TYPE_QUALS (t), complain);
	}
	else
	/* TEMPLATE_TEMPLATE_PARM or TEMPLATE_PARM_INDEX. */
	return arg;
	}

	if (level == 1)
	/* This can happen during the attempted tsubst'ing in
	unify. This means that we don't yet have any information
	about the template parameter in question. */
	return t;

	/* If we get here, we must have been looking at a parm for a
	more deeply nested template. Make a new version of this
	template parameter, but with a lower level. */
	switch (TREE_CODE (t))
	{
	case TEMPLATE_TYPE_PARM:
	case TEMPLATE_TEMPLATE_PARM:
	case BOUND_TEMPLATE_TEMPLATE_PARM:
	if (cp_type_quals (t))
	{
	r = tsubst (TYPE_MAIN_VARIANT (t), args, complain, in_decl);
	r = cp_build_qualified_type_real
	(r, cp_type_quals (t),
	complain \| (TREE_CODE (t) == TEMPLATE_TYPE_PARM
	? tf_ignore_bad_quals : 0));
	}
	else
	{
	r = copy_type (t);
	TEMPLATE_TYPE_PARM_INDEX (r)
	= reduce_template_parm_level (TEMPLATE_TYPE_PARM_INDEX (t),
	r, levels);
	TYPE_STUB_DECL (r) = TYPE_NAME (r) = TEMPLATE_TYPE_DECL (r);
	TYPE_MAIN_VARIANT (r) = r;
	TYPE_POINTER_TO (r) = NULL_TREE;
	TYPE_REFERENCE_TO (r) = NULL_TREE;

	if (TREE_CODE (t) == BOUND_TEMPLATE_TEMPLATE_PARM)
	{
	tree argvec = tsubst (TYPE_TI_ARGS (t), args,
	complain, in_decl);
	if (argvec == error_mark_node)
	return error_mark_node;

	TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (r)
	= tree_cons (TYPE_TI_TEMPLATE (t), argvec, NULL_TREE);
	}
	}
	break;

	case TEMPLATE_PARM_INDEX:
	r = reduce_template_parm_level (t, type, levels);
	break;

	default:
	gcc_unreachable ();
	}

	return r;
	}

	case TREE_LIST:
	{
	tree purpose, value, chain;

	if (t == void_list_node)
	return t;

	purpose = TREE_PURPOSE (t);
	if (purpose)
	{
	purpose = tsubst (purpose, args, complain, in_decl);
	if (purpose == error_mark_node)
	return error_mark_node;
	}
	value = TREE_VALUE (t);
	if (value)
	{
	value = tsubst (value, args, complain, in_decl);
	if (value == error_mark_node)
	return error_mark_node;
	}
	chain = TREE_CHAIN (t);
	if (chain && chain != void_type_node)
	{
	chain = tsubst (chain, args, complain, in_decl);
	if (chain == error_mark_node)
	return error_mark_node;
	}
	if (purpose == TREE_PURPOSE (t)
	&& value == TREE_VALUE (t)
	&& chain == TREE_CHAIN (t))
	return t;
	return hash_tree_cons (purpose, value, chain);
	}

	case TREE_BINFO:
	/* We should never be tsubsting a binfo. */
	gcc_unreachable ();

	case TREE_VEC:
	/* A vector of template arguments. */
	gcc_assert (!type);
	return tsubst_template_args (t, args, complain, in_decl);

	case POINTER_TYPE:
	case REFERENCE_TYPE:
	{
	enum tree_code code;

	if (type == TREE_TYPE (t) && TREE_CODE (type) != METHOD_TYPE)
	return t;

	code = TREE_CODE (t);


	/* [temp.deduct]

	Type deduction may fail for any of the following
	reasons:

	-- Attempting to create a pointer to reference type.
	-- Attempting to create a reference to a reference type or
	a reference to void. */
	if (TREE_CODE (type) == REFERENCE_TYPE
	\|\| (code == REFERENCE_TYPE && TREE_CODE (type) == VOID_TYPE))
	{
	static location_t last_loc;

	/* We keep track of the last time we issued this error
	message to avoid spewing a ton of messages during a
	single bad template instantiation. */
	if (complain & tf_error
	#ifdef USE_MAPPED_LOCATION
	&& last_loc != input_location
	#else
	&& (last_loc.line != input_line
	\|\| last_loc.file != input_filename)
	#endif
	)
	{
	if (TREE_CODE (type) == VOID_TYPE)
	error ("forming reference to void");
	else
	error ("forming %s to reference type %qT",
	(code == POINTER_TYPE) ? "pointer" : "reference",
	type);
	last_loc = input_location;
	}

	return error_mark_node;
	}
	else if (code == POINTER_TYPE)
	{
	r = build_pointer_type (type);
	if (TREE_CODE (type) == METHOD_TYPE)
	r = build_ptrmemfunc_type (r);
	}
	else
	r = build_reference_type (type);
	r = cp_build_qualified_type_real (r, TYPE_QUALS (t), complain);

	if (r != error_mark_node)
	/* Will this ever be needed for TYPE_..._TO values? */
	layout_type (r);

	return r;
	}
	case OFFSET_TYPE:
	{
	r = tsubst (TYPE_OFFSET_BASETYPE (t), args, complain, in_decl);
	if (r == error_mark_node \|\| !IS_AGGR_TYPE (r))
	{
	/* [temp.deduct]

	Type deduction may fail for any of the following
	reasons:

	-- Attempting to create "pointer to member of T" when T
	is not a class type. */
	if (complain & tf_error)
	error ("creating pointer to member of non-class type %qT", r);
	return error_mark_node;
	}
	if (TREE_CODE (type) == REFERENCE_TYPE)
	{
	if (complain & tf_error)
	error ("creating pointer to member reference type %qT", type);
	return error_mark_node;
	}
	if (TREE_CODE (type) == VOID_TYPE)
	{
	if (complain & tf_error)
	error ("creating pointer to member of type void");
	return error_mark_node;
	}
	gcc_assert (TREE_CODE (type) != METHOD_TYPE);
	if (TREE_CODE (type) == FUNCTION_TYPE)
	{
	/* The type of the implicit object parameter gets its
	cv-qualifiers from the FUNCTION_TYPE. */
	tree method_type;
	tree this_type = cp_build_qualified_type (TYPE_MAIN_VARIANT (r),
	cp_type_quals (type));
	tree memptr;
	method_type = build_method_type_directly (this_type,
	TREE_TYPE (type),
	TYPE_ARG_TYPES (type));
	memptr = build_ptrmemfunc_type (build_pointer_type (method_type));
	return cp_build_qualified_type_real (memptr, cp_type_quals (t),
	complain);
	}
	else
	return cp_build_qualified_type_real (build_ptrmem_type (r, type),
	TYPE_QUALS (t),
	complain);
	}
	case FUNCTION_TYPE:
	case METHOD_TYPE:
	{
	tree fntype;
	tree specs;
	fntype = tsubst_function_type (t, args, complain, in_decl);
	if (fntype == error_mark_node)
	return error_mark_node;

	/* Substitute the exception specification. */
	specs = tsubst_exception_specification (t, args, complain,
	in_decl);
	if (specs == error_mark_node)
	return error_mark_node;
	if (specs)
	fntype = build_exception_variant (fntype, specs);
	return fntype;
	}
	case ARRAY_TYPE:
	{
	tree domain = tsubst (TYPE_DOMAIN (t), args, complain, in_decl);
	if (domain == error_mark_node)
	return error_mark_node;

	/* As an optimization, we avoid regenerating the array type if
	it will obviously be the same as T. */
	if (type == TREE_TYPE (t) && domain == TYPE_DOMAIN (t))
	return t;

	/* These checks should match the ones in grokdeclarator.

	[temp.deduct]

	The deduction may fail for any of the following reasons:

	-- Attempting to create an array with an element type that
	is void, a function type, or a reference type, or [DR337]
	an abstract class type. */
	if (TREE_CODE (type) == VOID_TYPE
	\|\| TREE_CODE (type) == FUNCTION_TYPE
	\|\| TREE_CODE (type) == REFERENCE_TYPE)
	{
	if (complain & tf_error)
	error ("creating array of %qT", type);
	return error_mark_node;
	}
	if (CLASS_TYPE_P (type) && CLASSTYPE_PURE_VIRTUALS (type))
	{
	if (complain & tf_error)
	error ("creating array of %qT, which is an abstract class type",
	type);
	return error_mark_node;
	}

	r = build_cplus_array_type (type, domain);
	return r;
	}

	case PLUS_EXPR:
	case MINUS_EXPR:
	{
	tree e1 = tsubst (TREE_OPERAND (t, 0), args, complain, in_decl);
	tree e2 = tsubst (TREE_OPERAND (t, 1), args, complain, in_decl);

	if (e1 == error_mark_node \|\| e2 == error_mark_node)
	return error_mark_node;

	return fold_build2 (TREE_CODE (t), TREE_TYPE (t), e1, e2);
	}

	case NEGATE_EXPR:
	case NOP_EXPR:
	{
	tree e = tsubst (TREE_OPERAND (t, 0), args, complain, in_decl);
	if (e == error_mark_node)
	return error_mark_node;

	return fold_build1 (TREE_CODE (t), TREE_TYPE (t), e);
	}

	case TYPENAME_TYPE:
	{
	tree ctx = tsubst_aggr_type (TYPE_CONTEXT (t), args, complain,
	in_decl, /entering_scope=/1);
	tree f = tsubst_copy (TYPENAME_TYPE_FULLNAME (t), args,
	complain, in_decl);

	if (ctx == error_mark_node \|\| f == error_mark_node)
	return error_mark_node;

	if (!IS_AGGR_TYPE (ctx))
	{
	if (complain & tf_error)
	error ("%qT is not a class, struct, or union type", ctx);
	return error_mark_node;
	}
	else if (!uses_template_parms (ctx) && !TYPE_BEING_DEFINED (ctx))
	{
	/* Normally, make_typename_type does not require that the CTX
	have complete type in order to allow things like:

	template <class T> struct S { typename S<T>::X Y; };

	But, such constructs have already been resolved by this
	point, so here CTX really should have complete type, unless
	it's a partial instantiation. */
	ctx = complete_type (ctx);
	if (!COMPLETE_TYPE_P (ctx))
	{
	if (complain & tf_error)
	cxx_incomplete_type_error (NULL_TREE, ctx);
	return error_mark_node;
	}
	}

	f = make_typename_type (ctx, f, typename_type,
	(complain & tf_error) \| tf_keep_type_decl);
	if (f == error_mark_node)
	return f;
	if (TREE_CODE (f) == TYPE_DECL)
	{
	complain \|= tf_ignore_bad_quals;
	f = TREE_TYPE (f);
	}

	if (TREE_CODE (f) != TYPENAME_TYPE)
	{
	if (TYPENAME_IS_ENUM_P (t) && TREE_CODE (f) != ENUMERAL_TYPE)
	error ("%qT resolves to %qT, which is not an enumeration type",
	t, f);
	else if (TYPENAME_IS_CLASS_P (t) && !CLASS_TYPE_P (f))
	error ("%qT resolves to %qT, which is is not a class type",
	t, f);
	}

	return cp_build_qualified_type_real
	(f, cp_type_quals (f) \| cp_type_quals (t), complain);
	}

	case UNBOUND_CLASS_TEMPLATE:
	{
	tree ctx = tsubst_aggr_type (TYPE_CONTEXT (t), args, complain,
	in_decl, /entering_scope=/1);
	tree name = TYPE_IDENTIFIER (t);
	tree parm_list = DECL_TEMPLATE_PARMS (TYPE_NAME (t));

	if (ctx == error_mark_node \|\| name == error_mark_node)
	return error_mark_node;

	if (parm_list)
	parm_list = tsubst_template_parms (parm_list, args, complain);
	return make_unbound_class_template (ctx, name, parm_list, complain);
	}

	case INDIRECT_REF:
	case ADDR_EXPR:
	case CALL_EXPR:
	gcc_unreachable ();

	case ARRAY_REF:
	{
	tree e1 = tsubst (TREE_OPERAND (t, 0), args, complain, in_decl);
	tree e2 = tsubst_expr (TREE_OPERAND (t, 1), args, complain, in_decl,
	/integral_constant_expression_p=/false);
	if (e1 == error_mark_node \|\| e2 == error_mark_node)
	return error_mark_node;

	return build_nt (ARRAY_REF, e1, e2, NULL_TREE, NULL_TREE);
	}

	case SCOPE_REF:
	{
	tree e1 = tsubst (TREE_OPERAND (t, 0), args, complain, in_decl);
	tree e2 = tsubst (TREE_OPERAND (t, 1), args, complain, in_decl);
	if (e1 == error_mark_node \|\| e2 == error_mark_node)
	return error_mark_node;

	return build_qualified_name (/type=/NULL_TREE,
	e1, e2, QUALIFIED_NAME_IS_TEMPLATE (t));
	}

	case TYPEOF_TYPE:
	{
	tree type;

	type = finish_typeof (tsubst_expr
	(TYPEOF_TYPE_EXPR (t), args,
	complain, in_decl,
	/integral_constant_expression_p=/false));
	return cp_build_qualified_type_real (type,
	cp_type_quals (t)
	\| cp_type_quals (type),
	complain);
	}

	default:
	sorry ("use of %qs in template",
	tree_code_name [(int) TREE_CODE (t)]);
	return error_mark_node;
	}
	}

	/* Like tsubst_expr for a BASELINK. OBJECT_TYPE, if non-NULL, is the
	type of the expression on the left-hand side of the "." or "->"
	operator. */

	static tree
	tsubst_baselink (tree baselink, tree object_type,
	tree args, tsubst_flags_t complain, tree in_decl)
	{
	tree name;
	tree qualifying_scope;
	tree fns;
	tree optype;
	tree template_args = 0;
	bool template_id_p = false;

	/* A baselink indicates a function from a base class. Both the
	BASELINK_ACCESS_BINFO and the base class referenced may
	indicate bases of the template class, rather than the
	instantiated class. In addition, lookups that were not
	ambiguous before may be ambiguous now. Therefore, we perform
	the lookup again. */
	qualifying_scope = BINFO_TYPE (BASELINK_ACCESS_BINFO (baselink));
	qualifying_scope = tsubst (qualifying_scope, args,
	complain, in_decl);
	fns = BASELINK_FUNCTIONS (baselink);
	optype = BASELINK_OPTYPE (baselink);
	if (TREE_CODE (fns) == TEMPLATE_ID_EXPR)
	{
	template_id_p = true;
	template_args = TREE_OPERAND (fns, 1);
	fns = TREE_OPERAND (fns, 0);
	if (template_args)
	template_args = tsubst_template_args (template_args, args,
	complain, in_decl);
	}
	name = DECL_NAME (get_first_fn (fns));
	baselink = lookup_fnfields (qualifying_scope, name, /protect=/1);

	/* If lookup found a single function, mark it as used at this
	point. (If it lookup found multiple functions the one selected
	later by overload resolution will be marked as used at that
	point.) */
	if (BASELINK_P (baselink))
	fns = BASELINK_FUNCTIONS (baselink);
	if (!template_id_p && !really_overloaded_fn (fns))
	mark_used (OVL_CURRENT (fns));

	/* Add back the template arguments, if present. */
	if (BASELINK_P (baselink) && template_id_p)
	BASELINK_FUNCTIONS (baselink)
	= build_nt (TEMPLATE_ID_EXPR,
	BASELINK_FUNCTIONS (baselink),
	template_args);
	/* Update the conversion operator type. */
	BASELINK_OPTYPE (baselink)
	= tsubst (optype, args, complain, in_decl);

	if (!object_type)
	object_type = current_class_type;
	return adjust_result_of_qualified_name_lookup (baselink,
	qualifying_scope,
	object_type);
	}

	/* Like tsubst_expr for a SCOPE_REF, given by QUALIFIED_ID. DONE is
	true if the qualified-id will be a postfix-expression in-and-of
	itself; false if more of the postfix-expression follows the
	QUALIFIED_ID. ADDRESS_P is true if the qualified-id is the operand
	of "&". */

	static tree
	tsubst_qualified_id (tree qualified_id, tree args,
	tsubst_flags_t complain, tree in_decl,
	bool done, bool address_p)
	{
	tree expr;
	tree scope;
	tree name;
	bool is_template;
	tree template_args;

	gcc_assert (TREE_CODE (qualified_id) == SCOPE_REF);

	/* Figure out what name to look up. */
	name = TREE_OPERAND (qualified_id, 1);
	if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
	{
	is_template = true;
	template_args = TREE_OPERAND (name, 1);
	if (template_args)
	template_args = tsubst_template_args (template_args, args,
	complain, in_decl);
	name = TREE_OPERAND (name, 0);
	}
	else
	{
	is_template = false;
	template_args = NULL_TREE;
	}

	/* Substitute into the qualifying scope. When there are no ARGS, we
	are just trying to simplify a non-dependent expression. In that
	case the qualifying scope may be dependent, and, in any case,
	substituting will not help. */
	scope = TREE_OPERAND (qualified_id, 0);
	if (args)
	{
	scope = tsubst (scope, args, complain, in_decl);
	expr = tsubst_copy (name, args, complain, in_decl);
	}
	else
	expr = name;

	if (dependent_type_p (scope))
	return build_qualified_name (/type=/NULL_TREE,
	scope, expr,
	QUALIFIED_NAME_IS_TEMPLATE (qualified_id));

	if (!BASELINK_P (name) && !DECL_P (expr))
	{
	if (TREE_CODE (expr) == BIT_NOT_EXPR)
	/* If this were actually a destructor call, it would have been
	parsed as such by the parser. */
	expr = error_mark_node;
	else
	expr = lookup_qualified_name (scope, expr, /is_type_p=/0, false);
	if (TREE_CODE (TREE_CODE (expr) == TEMPLATE_DECL
	? DECL_TEMPLATE_RESULT (expr) : expr) == TYPE_DECL)
	{
	if (complain & tf_error)
	{
	error ("dependent-name %qE is parsed as a non-type, but "
	"instantiation yields a type", qualified_id);
	inform ("say %<typename %E%> if a type is meant", qualified_id);
	}
	return error_mark_node;
	}
	}

	if (DECL_P (expr))
	{
	check_accessibility_of_qualified_id (expr, /object_type=/NULL_TREE,
	scope);
	/* Remember that there was a reference to this entity. */
	mark_used (expr);
	}

	if (expr == error_mark_node \|\| TREE_CODE (expr) == TREE_LIST)
	{
	if (complain & tf_error)
	qualified_name_lookup_error (scope,
	TREE_OPERAND (qualified_id, 1),
	expr);
	return error_mark_node;
	}

	if (is_template)
	expr = lookup_template_function (expr, template_args);

	if (expr == error_mark_node && complain & tf_error)
	qualified_name_lookup_error (scope, TREE_OPERAND (qualified_id, 1),
	expr);
	else if (TYPE_P (scope))
	{
	expr = (adjust_result_of_qualified_name_lookup
	(expr, scope, current_class_type));
	expr = (finish_qualified_id_expr
	(scope, expr, done, address_p,
	QUALIFIED_NAME_IS_TEMPLATE (qualified_id),
	/template_arg_p=/false));
	}

	/* Expressions do not generally have reference type. */
	if (TREE_CODE (expr) != SCOPE_REF
	/* However, if we're about to form a pointer-to-member, we just
	want the referenced member referenced. */
	&& TREE_CODE (expr) != OFFSET_REF)
	expr = convert_from_reference (expr);

	return expr;
	}

	/* Like tsubst, but deals with expressions. This function just replaces
	template parms; to finish processing the resultant expression, use
	tsubst_expr. */

	static tree
	tsubst_copy (tree t, tree args, tsubst_flags_t complain, tree in_decl)
	{
	enum tree_code code;
	tree r;

	if (t == NULL_TREE \|\| t == error_mark_node)
	return t;

	code = TREE_CODE (t);

	switch (code)
	{
	case PARM_DECL:
	r = retrieve_local_specialization (t);
	gcc_assert (r != NULL);
	mark_used (r);
	return r;

	case CONST_DECL:
	{
	tree enum_type;
	tree v;

	if (DECL_TEMPLATE_PARM_P (t))
	return tsubst_copy (DECL_INITIAL (t), args, complain, in_decl);
	/* There is no need to substitute into namespace-scope
	enumerators. */
	if (DECL_NAMESPACE_SCOPE_P (t))
	return t;
	/* If ARGS is NULL, then T is known to be non-dependent. */
	if (args == NULL_TREE)
	return integral_constant_value (t);

	/* Unfortunately, we cannot just call lookup_name here.
	Consider:

	template <int I> int f() {
	enum E { a = I };
	struct S { void g() { E e = a; } };
	};

	When we instantiate f<7>::S::g(), say, lookup_name is not
	clever enough to find f<7>::a. */
	enum_type
	= tsubst_aggr_type (TREE_TYPE (t), args, complain, in_decl,
	/entering_scope=/0);

	for (v = TYPE_VALUES (enum_type);
	v != NULL_TREE;
	v = TREE_CHAIN (v))
	if (TREE_PURPOSE (v) == DECL_NAME (t))
	return TREE_VALUE (v);

	/* We didn't find the name. That should never happen; if
	name-lookup found it during preliminary parsing, we
	should find it again here during instantiation. */
	gcc_unreachable ();
	}
	return t;

	case FIELD_DECL:
	if (DECL_CONTEXT (t))
	{
	tree ctx;

	ctx = tsubst_aggr_type (DECL_CONTEXT (t), args, complain, in_decl,
	/entering_scope=/1);
	if (ctx != DECL_CONTEXT (t))
	{
	tree r = lookup_field (ctx, DECL_NAME (t), 0, false);
	if (!r)
	{
	if (complain & tf_error)
	error ("using invalid field %qD", t);
	return error_mark_node;
	}
	return r;
	}
	}

	return t;

	case VAR_DECL:
	case FUNCTION_DECL:
	if ((DECL_LANG_SPECIFIC (t) && DECL_TEMPLATE_INFO (t))
	\|\| local_variable_p (t))
	t = tsubst (t, args, complain, in_decl);
	mark_used (t);
	return t;

	case BASELINK:
	return tsubst_baselink (t, current_class_type, args, complain, in_decl);

	case TEMPLATE_DECL:
	if (DECL_TEMPLATE_TEMPLATE_PARM_P (t))
	return tsubst (TREE_TYPE (DECL_TEMPLATE_RESULT (t)),
	args, complain, in_decl);
	else if (DECL_FUNCTION_TEMPLATE_P (t) && DECL_MEMBER_TEMPLATE_P (t))
	return tsubst (t, args, complain, in_decl);
	else if (DECL_CLASS_SCOPE_P (t)
	&& uses_template_parms (DECL_CONTEXT (t)))
	{
	/* Template template argument like the following example need
	special treatment:

	template <template <class> class TT> struct C {};
	template <class T> struct D {
	template <class U> struct E {};
	C<E> c; // #1
	};
	D<int> d; // #2

	We are processing the template argument `E' in #1 for
	the template instantiation #2. Originally, `E' is a
	TEMPLATE_DECL with `D<T>' as its DECL_CONTEXT. Now we
	have to substitute this with one having context `D<int>'. */

	tree context = tsubst (DECL_CONTEXT (t), args, complain, in_decl);
	return lookup_field (context, DECL_NAME(t), 0, false);
	}
	else
	/* Ordinary template template argument. */
	return t;

	case CAST_EXPR:
	case REINTERPRET_CAST_EXPR:
	case CONST_CAST_EXPR:
	case STATIC_CAST_EXPR:
	case DYNAMIC_CAST_EXPR:
	case NOP_EXPR:
	return build1
	(code, tsubst (TREE_TYPE (t), args, complain, in_decl),
	tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl));

	case INDIRECT_REF:
	case NEGATE_EXPR:
	case TRUTH_NOT_EXPR:
	case BIT_NOT_EXPR:
	case ADDR_EXPR:
	case UNARY_PLUS_EXPR: /* Unary + */
	case SIZEOF_EXPR:
	case ALIGNOF_EXPR:
	case ARROW_EXPR:
	case THROW_EXPR:
	case TYPEID_EXPR:
	case REALPART_EXPR:
	case IMAGPART_EXPR:
	return build1
	(code, tsubst (TREE_TYPE (t), args, complain, in_decl),
	tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl));

	case COMPONENT_REF:
	{
	tree object;
	tree name;

	object = tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl);
	name = TREE_OPERAND (t, 1);
	if (TREE_CODE (name) == BIT_NOT_EXPR)
	{
	name = tsubst_copy (TREE_OPERAND (name, 0), args,
	complain, in_decl);
	name = build1 (BIT_NOT_EXPR, NULL_TREE, name);
	}
	else if (TREE_CODE (name) == SCOPE_REF
	&& TREE_CODE (TREE_OPERAND (name, 1)) == BIT_NOT_EXPR)
	{
	tree base = tsubst_copy (TREE_OPERAND (name, 0), args,
	complain, in_decl);
	name = TREE_OPERAND (name, 1);
	name = tsubst_copy (TREE_OPERAND (name, 0), args,
	complain, in_decl);
	name = build1 (BIT_NOT_EXPR, NULL_TREE, name);
	name = build_qualified_name (/type=/NULL_TREE,
	base, name,
	/template_p=/false);
	}
	else if (TREE_CODE (name) == BASELINK)
	name = tsubst_baselink (name,
	non_reference (TREE_TYPE (object)),
	args, complain,
	in_decl);
	else
	name = tsubst_copy (name, args, complain, in_decl);
	return build_nt (COMPONENT_REF, object, name, NULL_TREE);
	}

	case PLUS_EXPR:
	case MINUS_EXPR:
	case MULT_EXPR:
	case TRUNC_DIV_EXPR:
	case CEIL_DIV_EXPR:
	case FLOOR_DIV_EXPR:
	case ROUND_DIV_EXPR:
	case EXACT_DIV_EXPR:
	case BIT_AND_EXPR:
	case BIT_IOR_EXPR:
	case BIT_XOR_EXPR:
	case TRUNC_MOD_EXPR:
	case FLOOR_MOD_EXPR:
	case TRUTH_ANDIF_EXPR:
	case TRUTH_ORIF_EXPR:
	case TRUTH_AND_EXPR:
	case TRUTH_OR_EXPR:
	case RSHIFT_EXPR:
	case LSHIFT_EXPR:
	case RROTATE_EXPR:
	case LROTATE_EXPR:
	case EQ_EXPR:
	case NE_EXPR:
	case MAX_EXPR:
	case MIN_EXPR:
	case LE_EXPR:
	case GE_EXPR:
	case LT_EXPR:
	case GT_EXPR:
	case COMPOUND_EXPR:
	case DOTSTAR_EXPR:
	case MEMBER_REF:
	case PREDECREMENT_EXPR:
	case PREINCREMENT_EXPR:
	case POSTDECREMENT_EXPR:
	case POSTINCREMENT_EXPR:
	return build_nt
	(code, tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl),
	tsubst_copy (TREE_OPERAND (t, 1), args, complain, in_decl));

	case SCOPE_REF:
	return build_qualified_name (/type=/NULL_TREE,
	tsubst_copy (TREE_OPERAND (t, 0),
	args, complain, in_decl),
	tsubst_copy (TREE_OPERAND (t, 1),
	args, complain, in_decl),
	QUALIFIED_NAME_IS_TEMPLATE (t));

	case ARRAY_REF:
	return build_nt
	(ARRAY_REF,
	tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl),
	tsubst_copy (TREE_OPERAND (t, 1), args, complain, in_decl),
	NULL_TREE, NULL_TREE);

	case CALL_EXPR:
	return build_nt (code,
	tsubst_copy (TREE_OPERAND (t, 0), args,
	complain, in_decl),
	tsubst_copy (TREE_OPERAND (t, 1), args, complain,
	in_decl),
	NULL_TREE);

	case COND_EXPR:
	case MODOP_EXPR:
	case PSEUDO_DTOR_EXPR:
	{
	r = build_nt
	(code, tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl),
	tsubst_copy (TREE_OPERAND (t, 1), args, complain, in_decl),
	tsubst_copy (TREE_OPERAND (t, 2), args, complain, in_decl));
	TREE_NO_WARNING (r) = TREE_NO_WARNING (t);
	return r;
	}

	case NEW_EXPR:
	{
	r = build_nt
	(code, tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl),
	tsubst_copy (TREE_OPERAND (t, 1), args, complain, in_decl),
	tsubst_copy (TREE_OPERAND (t, 2), args, complain, in_decl));
	NEW_EXPR_USE_GLOBAL (r) = NEW_EXPR_USE_GLOBAL (t);
	return r;
	}

	case DELETE_EXPR:
	{
	r = build_nt
	(code, tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl),
	tsubst_copy (TREE_OPERAND (t, 1), args, complain, in_decl));
	DELETE_EXPR_USE_GLOBAL (r) = DELETE_EXPR_USE_GLOBAL (t);
	DELETE_EXPR_USE_VEC (r) = DELETE_EXPR_USE_VEC (t);
	return r;
	}

	case TEMPLATE_ID_EXPR:
	{
	/* Substituted template arguments */
	tree fn = TREE_OPERAND (t, 0);
	tree targs = TREE_OPERAND (t, 1);

	fn = tsubst_copy (fn, args, complain, in_decl);
	if (targs)
	targs = tsubst_template_args (targs, args, complain, in_decl);

	return lookup_template_function (fn, targs);
	}

	case TREE_LIST:
	{
	tree purpose, value, chain;

	if (t == void_list_node)
	return t;

	purpose = TREE_PURPOSE (t);
	if (purpose)
	purpose = tsubst_copy (purpose, args, complain, in_decl);
	value = TREE_VALUE (t);
	if (value)
	value = tsubst_copy (value, args, complain, in_decl);
	chain = TREE_CHAIN (t);
	if (chain && chain != void_type_node)
	chain = tsubst_copy (chain, args, complain, in_decl);
	if (purpose == TREE_PURPOSE (t)
	&& value == TREE_VALUE (t)
	&& chain == TREE_CHAIN (t))
	return t;
	return tree_cons (purpose, value, chain);
	}

	case RECORD_TYPE:
	case UNION_TYPE:
	case ENUMERAL_TYPE:
	case INTEGER_TYPE:
	case TEMPLATE_TYPE_PARM:
	case TEMPLATE_TEMPLATE_PARM:
	case BOUND_TEMPLATE_TEMPLATE_PARM:
	case TEMPLATE_PARM_INDEX:
	case POINTER_TYPE:
	case REFERENCE_TYPE:
	case OFFSET_TYPE:
	case FUNCTION_TYPE:
	case METHOD_TYPE:
	case ARRAY_TYPE:
	case TYPENAME_TYPE:
	case UNBOUND_CLASS_TEMPLATE:
	case TYPEOF_TYPE:
	case TYPE_DECL:
	return tsubst (t, args, complain, in_decl);

	case IDENTIFIER_NODE:
	if (IDENTIFIER_TYPENAME_P (t))
	{
	tree new_type = tsubst (TREE_TYPE (t), args, complain, in_decl);
	return mangle_conv_op_name_for_type (new_type);
	}
	else
	return t;

	case CONSTRUCTOR:
	/* This is handled by tsubst_copy_and_build. */
	gcc_unreachable ();

	case VA_ARG_EXPR:
	return build_x_va_arg (tsubst_copy (TREE_OPERAND (t, 0), args, complain,
	in_decl),
	tsubst (TREE_TYPE (t), args, complain, in_decl));

	case CLEANUP_POINT_EXPR:
	/* We shouldn't have built any of these during initial template
	generation. Instead, they should be built during instantiation
	in response to the saved STMT_IS_FULL_EXPR_P setting. */
	gcc_unreachable ();

	case OFFSET_REF:
	mark_used (TREE_OPERAND (t, 1));
	return t;

	default:
	return t;
	}
	}

	/* Like tsubst_copy, but specifically for OpenMP clauses. */

	static tree
	tsubst_omp_clauses (tree clauses, tree args, tsubst_flags_t complain,
	tree in_decl)
	{
	tree new_clauses = NULL, nc, oc;

	for (oc = clauses; oc ; oc = OMP_CLAUSE_CHAIN (oc))
	{
	nc = copy_node (oc);
	OMP_CLAUSE_CHAIN (nc) = new_clauses;
	new_clauses = nc;

	switch (OMP_CLAUSE_CODE (nc))
	{
	case OMP_CLAUSE_PRIVATE:
	case OMP_CLAUSE_SHARED:
	case OMP_CLAUSE_FIRSTPRIVATE:
	case OMP_CLAUSE_LASTPRIVATE:
	case OMP_CLAUSE_REDUCTION:
	case OMP_CLAUSE_COPYIN:
	case OMP_CLAUSE_COPYPRIVATE:
	case OMP_CLAUSE_IF:
	case OMP_CLAUSE_NUM_THREADS:
	case OMP_CLAUSE_SCHEDULE:
	OMP_CLAUSE_OPERAND (nc, 0)
	= tsubst_expr (OMP_CLAUSE_OPERAND (oc, 0), args, complain,
	in_decl, /integral_constant_expression_p=/false);
	break;
	case OMP_CLAUSE_NOWAIT:
	case OMP_CLAUSE_ORDERED:
	case OMP_CLAUSE_DEFAULT:
	break;
	default:
	gcc_unreachable ();
	}
	}

	return finish_omp_clauses (nreverse (new_clauses));
	}

	/* Like tsubst_copy_and_build, but unshare TREE_LIST nodes. */

	static tree
	tsubst_copy_asm_operands (tree t, tree args, tsubst_flags_t complain,
	tree in_decl)
	{
	#define RECUR(t) tsubst_copy_asm_operands (t, args, complain, in_decl)

	tree purpose, value, chain;

	if (t == NULL)
	return t;

	if (TREE_CODE (t) != TREE_LIST)
	return tsubst_copy_and_build (t, args, complain, in_decl,
	/function_p=/false,
	/integral_constant_expression_p=/false);

	if (t == void_list_node)
	return t;

	purpose = TREE_PURPOSE (t);
	if (purpose)
	purpose = RECUR (purpose);
	value = TREE_VALUE (t);
	if (value)
	value = RECUR (value);
	chain = TREE_CHAIN (t);
	if (chain && chain != void_type_node)
	chain = RECUR (chain);
	return tree_cons (purpose, value, chain);
	#undef RECUR
	}

	/* Like tsubst_copy for expressions, etc. but also does semantic
	processing. */

	static tree
	tsubst_expr (tree t, tree args, tsubst_flags_t complain, tree in_decl,
	bool integral_constant_expression_p)
	{
	#define RECUR(NODE) \
	tsubst_expr ((NODE), args, complain, in_decl, \
	integral_constant_expression_p)

	tree stmt, tmp;

	if (t == NULL_TREE \|\| t == error_mark_node)
	return t;

	if (EXPR_HAS_LOCATION (t))
	input_location = EXPR_LOCATION (t);
	if (STATEMENT_CODE_P (TREE_CODE (t)))
	current_stmt_tree ()->stmts_are_full_exprs_p = STMT_IS_FULL_EXPR_P (t);

	switch (TREE_CODE (t))
	{
	case STATEMENT_LIST:
	{
	tree_stmt_iterator i;
	for (i = tsi_start (t); !tsi_end_p (i); tsi_next (&i))
	RECUR (tsi_stmt (i));
	break;
	}

	case CTOR_INITIALIZER:
	finish_mem_initializers (tsubst_initializer_list
	(TREE_OPERAND (t, 0), args));
	break;

	case RETURN_EXPR:
	finish_return_stmt (RECUR (TREE_OPERAND (t, 0)));
	break;

	case EXPR_STMT:
	tmp = RECUR (EXPR_STMT_EXPR (t));
	if (EXPR_STMT_STMT_EXPR_RESULT (t))
	finish_stmt_expr_expr (tmp, cur_stmt_expr);
	else
	finish_expr_stmt (tmp);
	break;

	case USING_STMT:
	do_using_directive (RECUR (USING_STMT_NAMESPACE (t)));
	break;

	case DECL_EXPR:
	{
	tree decl;
	tree init;

	decl = DECL_EXPR_DECL (t);
	if (TREE_CODE (decl) == LABEL_DECL)
	finish_label_decl (DECL_NAME (decl));
	else if (TREE_CODE (decl) == USING_DECL)
	{
	tree scope = USING_DECL_SCOPE (decl);
	tree name = DECL_NAME (decl);
	tree decl;

	scope = RECUR (scope);
	decl = lookup_qualified_name (scope, name,
	/is_type_p=/false,
	/complain=/false);
	if (decl == error_mark_node \|\| TREE_CODE (decl) == TREE_LIST)
	qualified_name_lookup_error (scope, name, decl);
	else
	do_local_using_decl (decl, scope, name);
	}
	else
	{
	init = DECL_INITIAL (decl);
	decl = tsubst (decl, args, complain, in_decl);
	if (decl != error_mark_node)
	{
	/* By marking the declaration as instantiated, we avoid
	trying to instantiate it. Since instantiate_decl can't
	handle local variables, and since we've already done
	all that needs to be done, that's the right thing to
	do. */
	if (TREE_CODE (decl) == VAR_DECL)
	DECL_TEMPLATE_INSTANTIATED (decl) = 1;
	if (TREE_CODE (decl) == VAR_DECL
	&& ANON_AGGR_TYPE_P (TREE_TYPE (decl)))
	/* Anonymous aggregates are a special case. */
	finish_anon_union (decl);
	else
	{
	maybe_push_decl (decl);
	if (TREE_CODE (decl) == VAR_DECL
	&& DECL_PRETTY_FUNCTION_P (decl))
	{
	/* For __PRETTY_FUNCTION__ we have to adjust the
	initializer. */
	const char *const name
	= cxx_printable_name (current_function_decl, 2);
	init = cp_fname_init (name, &TREE_TYPE (decl));
	}
	else
	init = RECUR (init);
	finish_decl (decl, init, NULL_TREE);
	}
	}
	}

	/* A DECL_EXPR can also be used as an expression, in the condition
	clause of an if/for/while construct. */
	return decl;
	}

	case FOR_STMT:
	- stmt = begin_for_stmt ();
	- RECUR (FOR_INIT_STMT (t));
	+/* APPLE LOCAL begin for-fsf-4_4 3274130 5295549 */ \
	+ tmp = RECUR (FOR_ATTRIBUTES (t));
	+ stmt = begin_for_stmt (tmp);
	+ RECUR (FOR_INIT_STMT (t));
	+/* APPLE LOCAL end for-fsf-4_4 3274130 5295549 */ \
	finish_for_init_stmt (stmt);
	tmp = RECUR (FOR_COND (t));
	finish_for_cond (tmp, stmt);
	tmp = RECUR (FOR_EXPR (t));
	finish_for_expr (tmp, stmt);
	RECUR (FOR_BODY (t));
	finish_for_stmt (stmt);
	break;

	case WHILE_STMT:
	- stmt = begin_while_stmt ();
	+/* APPLE LOCAL begin for-fsf-4_4 3274130 5295549 */ \
	+ tmp = RECUR (WHILE_ATTRIBUTES (t));
	+ stmt = begin_while_stmt (tmp);
	+/* APPLE LOCAL end for-fsf-4_4 3274130 5295549 */ \
	tmp = RECUR (WHILE_COND (t));
	finish_while_stmt_cond (tmp, stmt);
	RECUR (WHILE_BODY (t));
	finish_while_stmt (stmt);
	break;

	case DO_STMT:
	- stmt = begin_do_stmt ();
	+/* APPLE LOCAL begin for-fsf-4_4 3274130 5295549 */ \
	+ tmp = RECUR (DO_ATTRIBUTES (t));
	+ stmt = begin_do_stmt (tmp);
	+/* APPLE LOCAL end for-fsf-4_4 3274130 5295549 */ \
	RECUR (DO_BODY (t));
	finish_do_body (stmt);
	tmp = RECUR (DO_COND (t));
	finish_do_stmt (tmp, stmt);
	break;

	case IF_STMT:
	stmt = begin_if_stmt ();
	tmp = RECUR (IF_COND (t));
	finish_if_stmt_cond (tmp, stmt);
	RECUR (THEN_CLAUSE (t));
	finish_then_clause (stmt);

	if (ELSE_CLAUSE (t))
	{
	begin_else_clause (stmt);
	RECUR (ELSE_CLAUSE (t));
	finish_else_clause (stmt);
	}

	finish_if_stmt (stmt);
	break;

	case BIND_EXPR:
	if (BIND_EXPR_BODY_BLOCK (t))
	stmt = begin_function_body ();
	else
	stmt = begin_compound_stmt (BIND_EXPR_TRY_BLOCK (t)
	? BCS_TRY_BLOCK : 0);

	RECUR (BIND_EXPR_BODY (t));

	if (BIND_EXPR_BODY_BLOCK (t))
	finish_function_body (stmt);
	else
	finish_compound_stmt (stmt);
	break;

	case BREAK_STMT:
	finish_break_stmt ();
	break;

	case CONTINUE_STMT:
	finish_continue_stmt ();
	break;

	case SWITCH_STMT:
	stmt = begin_switch_stmt ();
	tmp = RECUR (SWITCH_STMT_COND (t));
	finish_switch_cond (tmp, stmt);
	RECUR (SWITCH_STMT_BODY (t));
	finish_switch_stmt (stmt);
	break;

	case CASE_LABEL_EXPR:
	finish_case_label (RECUR (CASE_LOW (t)),
	RECUR (CASE_HIGH (t)));
	break;

	case LABEL_EXPR:
	finish_label_stmt (DECL_NAME (LABEL_EXPR_LABEL (t)));
	break;

	case GOTO_EXPR:
	tmp = GOTO_DESTINATION (t);
	if (TREE_CODE (tmp) != LABEL_DECL)
	/* Computed goto's must be tsubst'd into. On the other hand,
	non-computed gotos must not be; the identifier in question
	will have no binding. */
	tmp = RECUR (tmp);
	else
	tmp = DECL_NAME (tmp);
	finish_goto_stmt (tmp);
	break;

	case ASM_EXPR:
	tmp = finish_asm_stmt
	(ASM_VOLATILE_P (t),
	RECUR (ASM_STRING (t)),
	tsubst_copy_asm_operands (ASM_OUTPUTS (t), args, complain, in_decl),
	tsubst_copy_asm_operands (ASM_INPUTS (t), args, complain, in_decl),
	tsubst_copy_asm_operands (ASM_CLOBBERS (t), args, complain, in_decl));
	{
	tree asm_expr = tmp;
	if (TREE_CODE (asm_expr) == CLEANUP_POINT_EXPR)
	asm_expr = TREE_OPERAND (asm_expr, 0);
	ASM_INPUT_P (asm_expr) = ASM_INPUT_P (t);
	}
	break;

	case TRY_BLOCK:
	if (CLEANUP_P (t))
	{
	stmt = begin_try_block ();
	RECUR (TRY_STMTS (t));
	finish_cleanup_try_block (stmt);
	finish_cleanup (RECUR (TRY_HANDLERS (t)), stmt);
	}
	else
	{
	tree compound_stmt = NULL_TREE;

	if (FN_TRY_BLOCK_P (t))
	stmt = begin_function_try_block (&compound_stmt);
	else
	stmt = begin_try_block ();

	RECUR (TRY_STMTS (t));

	if (FN_TRY_BLOCK_P (t))
	finish_function_try_block (stmt);
	else
	finish_try_block (stmt);

	RECUR (TRY_HANDLERS (t));
	if (FN_TRY_BLOCK_P (t))
	finish_function_handler_sequence (stmt, compound_stmt);
	else
	finish_handler_sequence (stmt);
	}
	break;

	case HANDLER:
	{
	tree decl = HANDLER_PARMS (t);

	if (decl)
	{
	decl = tsubst (decl, args, complain, in_decl);
	/* Prevent instantiate_decl from trying to instantiate
	this variable. We've already done all that needs to be
	done. */
	if (decl != error_mark_node)
	DECL_TEMPLATE_INSTANTIATED (decl) = 1;
	}
	stmt = begin_handler ();
	finish_handler_parms (decl, stmt);
	RECUR (HANDLER_BODY (t));
	finish_handler (stmt);
	}
	break;

	case TAG_DEFN:
	tsubst (TREE_TYPE (t), args, complain, NULL_TREE);
	break;

	case OMP_PARALLEL:
	tmp = tsubst_omp_clauses (OMP_PARALLEL_CLAUSES (t),
	args, complain, in_decl);
	stmt = begin_omp_parallel ();
	RECUR (OMP_PARALLEL_BODY (t));
	OMP_PARALLEL_COMBINED (finish_omp_parallel (tmp, stmt))
	= OMP_PARALLEL_COMBINED (t);
	break;

	case OMP_FOR:
	{
	tree clauses, decl, init, cond, incr, body, pre_body;

	clauses = tsubst_omp_clauses (OMP_FOR_CLAUSES (t),
	args, complain, in_decl);
	init = OMP_FOR_INIT (t);
	gcc_assert (TREE_CODE (init) == MODIFY_EXPR);
	decl = RECUR (TREE_OPERAND (init, 0));
	init = RECUR (TREE_OPERAND (init, 1));
	cond = RECUR (OMP_FOR_COND (t));
	incr = RECUR (OMP_FOR_INCR (t));

	stmt = begin_omp_structured_block ();

	pre_body = push_stmt_list ();
	RECUR (OMP_FOR_PRE_BODY (t));
	pre_body = pop_stmt_list (pre_body);

	body = push_stmt_list ();
	RECUR (OMP_FOR_BODY (t));
	body = pop_stmt_list (body);

	t = finish_omp_for (EXPR_LOCATION (t), decl, init, cond, incr, body,
	pre_body);
	if (t)
	OMP_FOR_CLAUSES (t) = clauses;

	add_stmt (finish_omp_structured_block (stmt));
	}
	break;

	case OMP_SECTIONS:
	case OMP_SINGLE:
	tmp = tsubst_omp_clauses (OMP_CLAUSES (t), args, complain, in_decl);
	stmt = push_stmt_list ();
	RECUR (OMP_BODY (t));
	stmt = pop_stmt_list (stmt);

	t = copy_node (t);
	OMP_BODY (t) = stmt;
	OMP_CLAUSES (t) = tmp;
	add_stmt (t);
	break;

	case OMP_SECTION:
	case OMP_CRITICAL:
	case OMP_MASTER:
	case OMP_ORDERED:
	stmt = push_stmt_list ();
	RECUR (OMP_BODY (t));
	stmt = pop_stmt_list (stmt);

	t = copy_node (t);
	OMP_BODY (t) = stmt;
	add_stmt (t);
	break;

	case OMP_ATOMIC:
	{
	tree op0, op1;
	op0 = RECUR (TREE_OPERAND (t, 0));
	op1 = RECUR (TREE_OPERAND (t, 1));
	finish_omp_atomic (OMP_ATOMIC_CODE (t), op0, op1);
	}
	break;

	default:
	gcc_assert (!STATEMENT_CODE_P (TREE_CODE (t)));

	return tsubst_copy_and_build (t, args, complain, in_decl,
	/function_p=/false,
	integral_constant_expression_p);
	}

	return NULL_TREE;
	#undef RECUR
	}

	/* T is a postfix-expression that is not being used in a function
	call. Return the substituted version of T. */

	static tree
	tsubst_non_call_postfix_expression (tree t, tree args,
	tsubst_flags_t complain,
	tree in_decl)
	{
	if (TREE_CODE (t) == SCOPE_REF)
	t = tsubst_qualified_id (t, args, complain, in_decl,
	/done=/false, /address_p=/false);
	else
	t = tsubst_copy_and_build (t, args, complain, in_decl,
	/function_p=/false,
	/integral_constant_expression_p=/false);

	return t;
	}

	/* Like tsubst but deals with expressions and performs semantic
	analysis. FUNCTION_P is true if T is the "F" in "F (ARGS)". */

	tree
	tsubst_copy_and_build (tree t,
	tree args,
	tsubst_flags_t complain,
	tree in_decl,
	bool function_p,
	bool integral_constant_expression_p)
	{
	#define RECUR(NODE) \
	tsubst_copy_and_build (NODE, args, complain, in_decl, \
	/function_p=/false, \
	integral_constant_expression_p)

	tree op1;

	if (t == NULL_TREE \|\| t == error_mark_node)
	return t;

	switch (TREE_CODE (t))
	{
	case USING_DECL:
	t = DECL_NAME (t);
	/* Fall through. */
	case IDENTIFIER_NODE:
	{
	tree decl;
	cp_id_kind idk;
	bool non_integral_constant_expression_p;
	const char *error_msg;

	if (IDENTIFIER_TYPENAME_P (t))
	{
	tree new_type = tsubst (TREE_TYPE (t), args, complain, in_decl);
	t = mangle_conv_op_name_for_type (new_type);
	}

	/* Look up the name. */
	decl = lookup_name (t);

	/* By convention, expressions use ERROR_MARK_NODE to indicate
	failure, not NULL_TREE. */
	if (decl == NULL_TREE)
	decl = error_mark_node;

	decl = finish_id_expression (t, decl, NULL_TREE,
	&idk,
	integral_constant_expression_p,
	/allow_non_integral_constant_expression_p=/false,
	&non_integral_constant_expression_p,
	/template_p=/false,
	/done=/true,
	/address_p=/false,
	/template_arg_p=/false,
	&error_msg);
	if (error_msg)
	error ("%s", error_msg);
	if (!function_p && TREE_CODE (decl) == IDENTIFIER_NODE)
	decl = unqualified_name_lookup_error (decl);
	return decl;
	}

	case TEMPLATE_ID_EXPR:
	{
	tree object;
	tree template = RECUR (TREE_OPERAND (t, 0));
	tree targs = TREE_OPERAND (t, 1);

	if (targs)
	targs = tsubst_template_args (targs, args, complain, in_decl);

	if (TREE_CODE (template) == COMPONENT_REF)
	{
	object = TREE_OPERAND (template, 0);
	template = TREE_OPERAND (template, 1);
	}
	else
	object = NULL_TREE;
	template = lookup_template_function (template, targs);

	if (object)
	return build3 (COMPONENT_REF, TREE_TYPE (template),
	object, template, NULL_TREE);
	else
	return baselink_for_fns (template);
	}

	case INDIRECT_REF:
	{
	tree r = RECUR (TREE_OPERAND (t, 0));

	if (REFERENCE_REF_P (t))
	{
	/* A type conversion to reference type will be enclosed in
	such an indirect ref, but the substitution of the cast
	will have also added such an indirect ref. */
	if (TREE_CODE (TREE_TYPE (r)) == REFERENCE_TYPE)
	r = convert_from_reference (r);
	}
	else
	r = build_x_indirect_ref (r, "unary *");
	return r;
	}

	case NOP_EXPR:
	return build_nop
	(tsubst (TREE_TYPE (t), args, complain, in_decl),
	RECUR (TREE_OPERAND (t, 0)));

	case CAST_EXPR:
	case REINTERPRET_CAST_EXPR:
	case CONST_CAST_EXPR:
	case DYNAMIC_CAST_EXPR:
	case STATIC_CAST_EXPR:
	{
	tree type;
	tree op;

	type = tsubst (TREE_TYPE (t), args, complain, in_decl);
	if (integral_constant_expression_p
	&& !cast_valid_in_integral_constant_expression_p (type))
	{
	error ("a cast to a type other than an integral or "
	"enumeration type cannot appear in a constant-expression");
	return error_mark_node;
	}

	op = RECUR (TREE_OPERAND (t, 0));

	switch (TREE_CODE (t))
	{
	case CAST_EXPR:
	return build_functional_cast (type, op);
	case REINTERPRET_CAST_EXPR:
	return build_reinterpret_cast (type, op);
	case CONST_CAST_EXPR:
	return build_const_cast (type, op);
	case DYNAMIC_CAST_EXPR:
	return build_dynamic_cast (type, op);
	case STATIC_CAST_EXPR:
	return build_static_cast (type, op);
	default:
	gcc_unreachable ();
	}
	}

	case POSTDECREMENT_EXPR:
	case POSTINCREMENT_EXPR:
	op1 = tsubst_non_call_postfix_expression (TREE_OPERAND (t, 0),
	args, complain, in_decl);
	return build_x_unary_op (TREE_CODE (t), op1);

	case PREDECREMENT_EXPR:
	case PREINCREMENT_EXPR:
	case NEGATE_EXPR:
	case BIT_NOT_EXPR:
	case ABS_EXPR:
	case TRUTH_NOT_EXPR:
	case UNARY_PLUS_EXPR: /* Unary + */
	case REALPART_EXPR:
	case IMAGPART_EXPR:
	return build_x_unary_op (TREE_CODE (t), RECUR (TREE_OPERAND (t, 0)));

	case ADDR_EXPR:
	op1 = TREE_OPERAND (t, 0);
	if (TREE_CODE (op1) == SCOPE_REF)
	op1 = tsubst_qualified_id (op1, args, complain, in_decl,
	/done=/true, /address_p=/true);
	else
	op1 = tsubst_non_call_postfix_expression (op1, args, complain,
	in_decl);
	if (TREE_CODE (op1) == LABEL_DECL)
	return finish_label_address_expr (DECL_NAME (op1));
	return build_x_unary_op (ADDR_EXPR, op1);

	case PLUS_EXPR:
	case MINUS_EXPR:
	case MULT_EXPR:
	case TRUNC_DIV_EXPR:
	case CEIL_DIV_EXPR:
	case FLOOR_DIV_EXPR:
	case ROUND_DIV_EXPR:
	case EXACT_DIV_EXPR:
	case BIT_AND_EXPR:
	case BIT_IOR_EXPR:
	case BIT_XOR_EXPR:
	case TRUNC_MOD_EXPR:
	case FLOOR_MOD_EXPR:
	case TRUTH_ANDIF_EXPR:
	case TRUTH_ORIF_EXPR:
	case TRUTH_AND_EXPR:
	case TRUTH_OR_EXPR:
	case RSHIFT_EXPR:
	case LSHIFT_EXPR:
	case RROTATE_EXPR:
	case LROTATE_EXPR:
	case EQ_EXPR:
	case NE_EXPR:
	case MAX_EXPR:
	case MIN_EXPR:
	case LE_EXPR:
	case GE_EXPR:
	case LT_EXPR:
	case GT_EXPR:
	case MEMBER_REF:
	case DOTSTAR_EXPR:
	return build_x_binary_op
	(TREE_CODE (t),
	RECUR (TREE_OPERAND (t, 0)),
	(TREE_NO_WARNING (TREE_OPERAND (t, 0))
	? ERROR_MARK
	: TREE_CODE (TREE_OPERAND (t, 0))),
	RECUR (TREE_OPERAND (t, 1)),
	(TREE_NO_WARNING (TREE_OPERAND (t, 1))
	? ERROR_MARK
	: TREE_CODE (TREE_OPERAND (t, 1))),
	/overloaded_p=/NULL);

	case SCOPE_REF:
	return tsubst_qualified_id (t, args, complain, in_decl, /done=/true,
	/address_p=/false);
	case ARRAY_REF:
	op1 = tsubst_non_call_postfix_expression (TREE_OPERAND (t, 0),
	args, complain, in_decl);
	return build_x_binary_op (ARRAY_REF, op1,
	(TREE_NO_WARNING (TREE_OPERAND (t, 0))
	? ERROR_MARK
	: TREE_CODE (TREE_OPERAND (t, 0))),
	RECUR (TREE_OPERAND (t, 1)),
	(TREE_NO_WARNING (TREE_OPERAND (t, 1))
	? ERROR_MARK
	: TREE_CODE (TREE_OPERAND (t, 1))),
	/overloaded_p=/NULL);

	case SIZEOF_EXPR:
	case ALIGNOF_EXPR:
	op1 = TREE_OPERAND (t, 0);
	if (!args)
	{
	/* When there are no ARGS, we are trying to evaluate a
	non-dependent expression from the parser. Trying to do
	the substitutions may not work. */
	if (!TYPE_P (op1))
	op1 = TREE_TYPE (op1);
	}
	else
	{
	++skip_evaluation;
	op1 = tsubst_copy_and_build (op1, args, complain, in_decl,
	/function_p=/false,
	/integral_constant_expression_p=/false);
	--skip_evaluation;
	}
	if (TYPE_P (op1))
	return cxx_sizeof_or_alignof_type (op1, TREE_CODE (t), true);
	else
	return cxx_sizeof_or_alignof_expr (op1, TREE_CODE (t));

	case MODOP_EXPR:
	{
	tree r = build_x_modify_expr
	(RECUR (TREE_OPERAND (t, 0)),
	TREE_CODE (TREE_OPERAND (t, 1)),
	RECUR (TREE_OPERAND (t, 2)));
	/* TREE_NO_WARNING must be set if either the expression was
	parenthesized or it uses an operator such as >>= rather
	than plain assignment. In the former case, it was already
	set and must be copied. In the latter case,
	build_x_modify_expr sets it and it must not be reset
	here. */
	if (TREE_NO_WARNING (t))
	TREE_NO_WARNING (r) = TREE_NO_WARNING (t);
	return r;
	}

	case ARROW_EXPR:
	op1 = tsubst_non_call_postfix_expression (TREE_OPERAND (t, 0),
	args, complain, in_decl);
	/* Remember that there was a reference to this entity. */
	if (DECL_P (op1))
	mark_used (op1);
	return build_x_arrow (op1);

	case NEW_EXPR:
	return build_new
	(RECUR (TREE_OPERAND (t, 0)),
	RECUR (TREE_OPERAND (t, 1)),
	RECUR (TREE_OPERAND (t, 2)),
	RECUR (TREE_OPERAND (t, 3)),
	NEW_EXPR_USE_GLOBAL (t));

	case DELETE_EXPR:
	return delete_sanity
	(RECUR (TREE_OPERAND (t, 0)),
	RECUR (TREE_OPERAND (t, 1)),
	DELETE_EXPR_USE_VEC (t),
	DELETE_EXPR_USE_GLOBAL (t));

	case COMPOUND_EXPR:
	return build_x_compound_expr (RECUR (TREE_OPERAND (t, 0)),
	RECUR (TREE_OPERAND (t, 1)));

	case CALL_EXPR:
	{
	tree function;
	tree call_args;
	bool qualified_p;
	bool koenig_p;

	function = TREE_OPERAND (t, 0);
	/* When we parsed the expression, we determined whether or
	not Koenig lookup should be performed. */
	koenig_p = KOENIG_LOOKUP_P (t);
	if (TREE_CODE (function) == SCOPE_REF)
	{
	qualified_p = true;
	function = tsubst_qualified_id (function, args, complain, in_decl,
	/done=/false,
	/address_p=/false);
	}
	else
	{
	if (TREE_CODE (function) == COMPONENT_REF)
	{
	tree op = TREE_OPERAND (function, 1);

	qualified_p = (TREE_CODE (op) == SCOPE_REF
	\|\| (BASELINK_P (op)
	&& BASELINK_QUALIFIED_P (op)));
	}
	else
	qualified_p = false;

	function = tsubst_copy_and_build (function, args, complain,
	in_decl,
	!qualified_p,
	integral_constant_expression_p);

	if (BASELINK_P (function))
	qualified_p = true;
	}

	call_args = RECUR (TREE_OPERAND (t, 1));

	/* We do not perform argument-dependent lookup if normal
	lookup finds a non-function, in accordance with the
	expected resolution of DR 218. */
	if (koenig_p
	&& ((is_overloaded_fn (function)
	/* If lookup found a member function, the Koenig lookup is
	not appropriate, even if an unqualified-name was used
	to denote the function. */
	&& !DECL_FUNCTION_MEMBER_P (get_first_fn (function)))
	\|\| TREE_CODE (function) == IDENTIFIER_NODE))
	function = perform_koenig_lookup (function, call_args);

	if (TREE_CODE (function) == IDENTIFIER_NODE)
	{
	unqualified_name_lookup_error (function);
	return error_mark_node;
	}

	/* Remember that there was a reference to this entity. */
	if (DECL_P (function))
	mark_used (function);

	if (TREE_CODE (function) == OFFSET_REF)
	return build_offset_ref_call_from_tree (function, call_args);
	if (TREE_CODE (function) == COMPONENT_REF)
	{
	if (!BASELINK_P (TREE_OPERAND (function, 1)))
	return finish_call_expr (function, call_args,
	/disallow_virtual=/false,
	/koenig_p=/false);
	else
	return (build_new_method_call
	(TREE_OPERAND (function, 0),
	TREE_OPERAND (function, 1),
	call_args, NULL_TREE,
	qualified_p ? LOOKUP_NONVIRTUAL : LOOKUP_NORMAL,
	/fn_p=/NULL));
	}
	return finish_call_expr (function, call_args,
	/disallow_virtual=/qualified_p,
	koenig_p);
	}

	case COND_EXPR:
	return build_x_conditional_expr
	(RECUR (TREE_OPERAND (t, 0)),
	RECUR (TREE_OPERAND (t, 1)),
	RECUR (TREE_OPERAND (t, 2)));

	case PSEUDO_DTOR_EXPR:
	return finish_pseudo_destructor_expr
	(RECUR (TREE_OPERAND (t, 0)),
	RECUR (TREE_OPERAND (t, 1)),
	RECUR (TREE_OPERAND (t, 2)));

	case TREE_LIST:
	{
	tree purpose, value, chain;

	if (t == void_list_node)
	return t;

	purpose = TREE_PURPOSE (t);
	if (purpose)
	purpose = RECUR (purpose);
	value = TREE_VALUE (t);
	if (value)
	value = RECUR (value);
	chain = TREE_CHAIN (t);
	if (chain && chain != void_type_node)
	chain = RECUR (chain);
	if (purpose == TREE_PURPOSE (t)
	&& value == TREE_VALUE (t)
	&& chain == TREE_CHAIN (t))
	return t;
	return tree_cons (purpose, value, chain);
	}

	case COMPONENT_REF:
	{
	tree object;
	tree object_type;
	tree member;

	object = tsubst_non_call_postfix_expression (TREE_OPERAND (t, 0),
	args, complain, in_decl);
	/* Remember that there was a reference to this entity. */
	if (DECL_P (object))
	mark_used (object);
	object_type = TREE_TYPE (object);

	member = TREE_OPERAND (t, 1);
	if (BASELINK_P (member))
	member = tsubst_baselink (member,
	non_reference (TREE_TYPE (object)),
	args, complain, in_decl);
	else
	member = tsubst_copy (member, args, complain, in_decl);
	if (member == error_mark_node)
	return error_mark_node;

	if (object_type && !CLASS_TYPE_P (object_type))
	{
	if (TREE_CODE (member) == BIT_NOT_EXPR)
	return finish_pseudo_destructor_expr (object,
	NULL_TREE,
	object_type);
	else if (TREE_CODE (member) == SCOPE_REF
	&& (TREE_CODE (TREE_OPERAND (member, 1)) == BIT_NOT_EXPR))
	return finish_pseudo_destructor_expr (object,
	object,
	object_type);
	}
	else if (TREE_CODE (member) == SCOPE_REF
	&& TREE_CODE (TREE_OPERAND (member, 1)) == TEMPLATE_ID_EXPR)
	{
	tree tmpl;
	tree args;

	/* Lookup the template functions now that we know what the
	scope is. */
	tmpl = TREE_OPERAND (TREE_OPERAND (member, 1), 0);
	args = TREE_OPERAND (TREE_OPERAND (member, 1), 1);
	member = lookup_qualified_name (TREE_OPERAND (member, 0), tmpl,
	/is_type_p=/false,
	/complain=/false);
	if (BASELINK_P (member))
	{
	BASELINK_FUNCTIONS (member)
	= build_nt (TEMPLATE_ID_EXPR, BASELINK_FUNCTIONS (member),
	args);
	member = (adjust_result_of_qualified_name_lookup
	(member, BINFO_TYPE (BASELINK_BINFO (member)),
	object_type));
	}
	else
	{
	qualified_name_lookup_error (object_type, tmpl, member);
	return error_mark_node;
	}
	}
	else if (TREE_CODE (member) == SCOPE_REF
	&& !CLASS_TYPE_P (TREE_OPERAND (member, 0))
	&& TREE_CODE (TREE_OPERAND (member, 0)) != NAMESPACE_DECL)
	{
	if (complain & tf_error)
	{
	if (TYPE_P (TREE_OPERAND (member, 0)))
	error ("%qT is not a class or namespace",
	TREE_OPERAND (member, 0));
	else
	error ("%qD is not a class or namespace",
	TREE_OPERAND (member, 0));
	}
	return error_mark_node;
	}
	else if (TREE_CODE (member) == FIELD_DECL)
	return finish_non_static_data_member (member, object, NULL_TREE);

	return finish_class_member_access_expr (object, member,
	/template_p=/false);
	}

	case THROW_EXPR:
	return build_throw
	(RECUR (TREE_OPERAND (t, 0)));

	case CONSTRUCTOR:
	{
	VEC(constructor_elt,gc) *n;
	constructor_elt *ce;
	unsigned HOST_WIDE_INT idx;
	tree type = tsubst (TREE_TYPE (t), args, complain, in_decl);
	bool process_index_p;

	if (type == error_mark_node)
	return error_mark_node;

	/* digest_init will do the wrong thing if we let it. */
	if (type && TYPE_PTRMEMFUNC_P (type))
	return t;

	/* We do not want to process the index of aggregate
	initializers as they are identifier nodes which will be
	looked up by digest_init. */
	process_index_p = !(type && IS_AGGR_TYPE (type));

	n = VEC_copy (constructor_elt, gc, CONSTRUCTOR_ELTS (t));
	for (idx = 0; VEC_iterate (constructor_elt, n, idx, ce); idx++)
	{
	if (ce->index && process_index_p)
	ce->index = RECUR (ce->index);
	ce->value = RECUR (ce->value);
	}

	if (TREE_HAS_CONSTRUCTOR (t))
	return finish_compound_literal (type, n);

	return build_constructor (NULL_TREE, n);
	}

	case TYPEID_EXPR:
	{
	tree operand_0 = RECUR (TREE_OPERAND (t, 0));
	if (TYPE_P (operand_0))
	return get_typeid (operand_0);
	return build_typeid (operand_0);
	}

	case VAR_DECL:
	if (!args)
	return t;
	/* Fall through */

	case PARM_DECL:
	{
	tree r = tsubst_copy (t, args, complain, in_decl);

	if (TREE_CODE (TREE_TYPE (t)) != REFERENCE_TYPE)
	/* If the original type was a reference, we'll be wrapped in
	the appropriate INDIRECT_REF. */
	r = convert_from_reference (r);
	return r;
	}

	case VA_ARG_EXPR:
	return build_x_va_arg (RECUR (TREE_OPERAND (t, 0)),
	tsubst_copy (TREE_TYPE (t), args, complain,
	in_decl));

	case OFFSETOF_EXPR:
	return finish_offsetof (RECUR (TREE_OPERAND (t, 0)));

	case STMT_EXPR:
	{
	tree old_stmt_expr = cur_stmt_expr;
	tree stmt_expr = begin_stmt_expr ();

	cur_stmt_expr = stmt_expr;
	tsubst_expr (STMT_EXPR_STMT (t), args, complain, in_decl,
	integral_constant_expression_p);
	stmt_expr = finish_stmt_expr (stmt_expr, false);
	cur_stmt_expr = old_stmt_expr;

	return stmt_expr;
	}

	case CONST_DECL:
	t = tsubst_copy (t, args, complain, in_decl);
	/* As in finish_id_expression, we resolve enumeration constants
	to their underlying values. */
	if (TREE_CODE (t) == CONST_DECL)
	{
	used_types_insert (TREE_TYPE (t));
	return DECL_INITIAL (t);
	}
	return t;

	default:
	/* Handle Objective-C++ constructs, if appropriate. */
	{
	tree subst
	= objcp_tsubst_copy_and_build (t, args, complain,
	in_decl, /function_p=/false);
	if (subst)
	return subst;
	}
	return tsubst_copy (t, args, complain, in_decl);
	}

	#undef RECUR
	}

	/* Verify that the instantiated ARGS are valid. For type arguments,
	make sure that the type's linkage is ok. For non-type arguments,
	make sure they are constants if they are integral or enumerations.
	Emit an error under control of COMPLAIN, and return TRUE on error. */

	static bool
	check_instantiated_args (tree tmpl, tree args, tsubst_flags_t complain)
	{
	int ix, len = DECL_NTPARMS (tmpl);
	bool result = false;

	for (ix = 0; ix != len; ix++)
	{
	tree t = TREE_VEC_ELT (args, ix);

	if (TYPE_P (t))
	{
	/* [basic.link]: A name with no linkage (notably, the name
	of a class or enumeration declared in a local scope)
	shall not be used to declare an entity with linkage.
	This implies that names with no linkage cannot be used as
	template arguments. */
	tree nt = no_linkage_check (t, /relaxed_p=/false);

	if (nt)
	{
	/* DR 488 makes use of a type with no linkage cause
	type deduction to fail. */
	if (complain & tf_error)
	{
	if (TYPE_ANONYMOUS_P (nt))
	error ("%qT is/uses anonymous type", t);
	else
	error ("template argument for %qD uses local type %qT",
	tmpl, t);
	}
	result = true;
	}
	/* In order to avoid all sorts of complications, we do not
	allow variably-modified types as template arguments. */
	else if (variably_modified_type_p (t, NULL_TREE))
	{
	if (complain & tf_error)
	error ("%qT is a variably modified type", t);
	result = true;
	}
	}
	/* A non-type argument of integral or enumerated type must be a
	constant. */
	else if (TREE_TYPE (t)
	&& INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (t))
	&& !TREE_CONSTANT (t))
	{
	if (complain & tf_error)
	error ("integral expression %qE is not constant", t);
	result = true;
	}
	}
	if (result && (complain & tf_error))
	error (" trying to instantiate %qD", tmpl);
	return result;
	}

	/* Instantiate the indicated variable or function template TMPL with
	the template arguments in TARG_PTR. */

	tree
	instantiate_template (tree tmpl, tree targ_ptr, tsubst_flags_t complain)
	{
	tree fndecl;
	tree gen_tmpl;
	tree spec;
	HOST_WIDE_INT saved_processing_template_decl;

	if (tmpl == error_mark_node)
	return error_mark_node;

	gcc_assert (TREE_CODE (tmpl) == TEMPLATE_DECL);

	/* If this function is a clone, handle it specially. */
	if (DECL_CLONED_FUNCTION_P (tmpl))
	{
	tree spec;
	tree clone;

	spec = instantiate_template (DECL_CLONED_FUNCTION (tmpl), targ_ptr,
	complain);
	if (spec == error_mark_node)
	return error_mark_node;

	/* Look for the clone. */
	FOR_EACH_CLONE (clone, spec)
	if (DECL_NAME (clone) == DECL_NAME (tmpl))
	return clone;
	/* We should always have found the clone by now. */
	gcc_unreachable ();
	return NULL_TREE;
	}

	/* Check to see if we already have this specialization. */
	spec = retrieve_specialization (tmpl, targ_ptr,
	/class_specializations_p=/false);
	if (spec != NULL_TREE)
	return spec;

	gen_tmpl = most_general_template (tmpl);
	if (tmpl != gen_tmpl)
	{
	/* The TMPL is a partial instantiation. To get a full set of
	arguments we must add the arguments used to perform the
	partial instantiation. */
	targ_ptr = add_outermost_template_args (DECL_TI_ARGS (tmpl),
	targ_ptr);

	/* Check to see if we already have this specialization. */
	spec = retrieve_specialization (gen_tmpl, targ_ptr,
	/class_specializations_p=/false);
	if (spec != NULL_TREE)
	return spec;
	}

	if (check_instantiated_args (gen_tmpl, INNERMOST_TEMPLATE_ARGS (targ_ptr),
	complain))
	return error_mark_node;

	/* We are building a FUNCTION_DECL, during which the access of its
	parameters and return types have to be checked. However this
	FUNCTION_DECL which is the desired context for access checking
	is not built yet. We solve this chicken-and-egg problem by
	deferring all checks until we have the FUNCTION_DECL. */
	push_deferring_access_checks (dk_deferred);

	/* Although PROCESSING_TEMPLATE_DECL may be true at this point
	(because, for example, we have encountered a non-dependent
	function call in the body of a template function and must now
	determine which of several overloaded functions will be called),
	within the instantiation itself we are not processing a
	template. */
	saved_processing_template_decl = processing_template_decl;
	processing_template_decl = 0;
	/* Substitute template parameters to obtain the specialization. */
	fndecl = tsubst (DECL_TEMPLATE_RESULT (gen_tmpl),
	targ_ptr, complain, gen_tmpl);
	processing_template_decl = saved_processing_template_decl;
	if (fndecl == error_mark_node)
	return error_mark_node;

	/* Now we know the specialization, compute access previously
	deferred. */
	push_access_scope (fndecl);
	perform_deferred_access_checks ();
	pop_access_scope (fndecl);
	pop_deferring_access_checks ();

	/* The DECL_TI_TEMPLATE should always be the immediate parent
	template, not the most general template. */
	DECL_TI_TEMPLATE (fndecl) = tmpl;

	/* If we've just instantiated the main entry point for a function,
	instantiate all the alternate entry points as well. We do this
	by cloning the instantiation of the main entry point, not by
	instantiating the template clones. */
	if (TREE_CHAIN (gen_tmpl) && DECL_CLONED_FUNCTION_P (TREE_CHAIN (gen_tmpl)))
	clone_function_decl (fndecl, /update_method_vec_p=/0);

	return fndecl;
	}

	/* The FN is a TEMPLATE_DECL for a function. The ARGS are the
	arguments that are being used when calling it. TARGS is a vector
	into which the deduced template arguments are placed.

	Return zero for success, 2 for an incomplete match that doesn't resolve
	all the types, and 1 for complete failure. An error message will be
	printed only for an incomplete match.

	If FN is a conversion operator, or we are trying to produce a specific
	specialization, RETURN_TYPE is the return type desired.

	The EXPLICIT_TARGS are explicit template arguments provided via a
	template-id.

	The parameter STRICT is one of:

	DEDUCE_CALL:
	We are deducing arguments for a function call, as in
	[temp.deduct.call].

	DEDUCE_CONV:
	We are deducing arguments for a conversion function, as in
	[temp.deduct.conv].

	DEDUCE_EXACT:
	We are deducing arguments when doing an explicit instantiation
	as in [temp.explicit], when determining an explicit specialization
	as in [temp.expl.spec], or when taking the address of a function
	template, as in [temp.deduct.funcaddr]. */

	int
	fn_type_unification (tree fn,
	tree explicit_targs,
	tree targs,
	tree args,
	tree return_type,
	unification_kind_t strict,
	int flags)
	{
	tree parms;
	tree fntype;
	int result;

	gcc_assert (TREE_CODE (fn) == TEMPLATE_DECL);

	fntype = TREE_TYPE (fn);
	if (explicit_targs)
	{
	/* [temp.deduct]

	The specified template arguments must match the template
	parameters in kind (i.e., type, nontype, template), and there
	must not be more arguments than there are parameters;
	otherwise type deduction fails.

	Nontype arguments must match the types of the corresponding
	nontype template parameters, or must be convertible to the
	types of the corresponding nontype parameters as specified in
	_temp.arg.nontype_, otherwise type deduction fails.

	All references in the function type of the function template
	to the corresponding template parameters are replaced by the
	specified template argument values. If a substitution in a
	template parameter or in the function type of the function
	template results in an invalid type, type deduction fails. */
	int i;
	tree converted_args;
	bool incomplete;

	if (explicit_targs == error_mark_node)
	return 1;

	converted_args
	= (coerce_template_parms (DECL_INNERMOST_TEMPLATE_PARMS (fn),
	explicit_targs, NULL_TREE, tf_none,
	/require_all_args=/false,
	/use_default_args=/false));
	if (converted_args == error_mark_node)
	return 1;

	/* Substitute the explicit args into the function type. This is
	necessary so that, for instance, explicitly declared function
	arguments can match null pointed constants. If we were given
	an incomplete set of explicit args, we must not do semantic
	processing during substitution as we could create partial
	instantiations. */
	incomplete = NUM_TMPL_ARGS (explicit_targs) != NUM_TMPL_ARGS (targs);
	processing_template_decl += incomplete;
	fntype = tsubst (fntype, converted_args, tf_none, NULL_TREE);
	processing_template_decl -= incomplete;

	if (fntype == error_mark_node)
	return 1;

	/* Place the explicitly specified arguments in TARGS. */
	for (i = NUM_TMPL_ARGS (converted_args); i--;)
	TREE_VEC_ELT (targs, i) = TREE_VEC_ELT (converted_args, i);
	}

	/* Never do unification on the 'this' parameter. */
	parms = skip_artificial_parms_for (fn, TYPE_ARG_TYPES (fntype));

	if (return_type)
	{
	parms = tree_cons (NULL_TREE, TREE_TYPE (fntype), parms);
	args = tree_cons (NULL_TREE, return_type, args);
	}

	/* We allow incomplete unification without an error message here
	because the standard doesn't seem to explicitly prohibit it. Our
	callers must be ready to deal with unification failures in any
	event. */
	result = type_unification_real (DECL_INNERMOST_TEMPLATE_PARMS (fn),
	targs, parms, args, /subr=/0,
	strict, flags);

	if (result == 0)
	/* All is well so far. Now, check:

	[temp.deduct]

	When all template arguments have been deduced, all uses of
	template parameters in nondeduced contexts are replaced with
	the corresponding deduced argument values. If the
	substitution results in an invalid type, as described above,
	type deduction fails. */
	if (tsubst (TREE_TYPE (fn), targs, tf_none, NULL_TREE)
	== error_mark_node)
	return 1;

	return result;
	}

	/* Adjust types before performing type deduction, as described in
	[temp.deduct.call] and [temp.deduct.conv]. The rules in these two
	sections are symmetric. PARM is the type of a function parameter
	or the return type of the conversion function. ARG is the type of
	the argument passed to the call, or the type of the value
	initialized with the result of the conversion function. */

	static int
	maybe_adjust_types_for_deduction (unification_kind_t strict,
	tree* parm,
	tree* arg)
	{
	int result = 0;

	switch (strict)
	{
	case DEDUCE_CALL:
	break;

	case DEDUCE_CONV:
	{
	/* Swap PARM and ARG throughout the remainder of this
	function; the handling is precisely symmetric since PARM
	will initialize ARG rather than vice versa. */
	tree* temp = parm;
	parm = arg;
	arg = temp;
	break;
	}

	case DEDUCE_EXACT:
	/* There is nothing to do in this case. */
	return 0;

	default:
	gcc_unreachable ();
	}

	if (TREE_CODE (*parm) != REFERENCE_TYPE)
	{
	/* [temp.deduct.call]

	If P is not a reference type:

	--If A is an array type, the pointer type produced by the
	array-to-pointer standard conversion (_conv.array_) is
	used in place of A for type deduction; otherwise,

	--If A is a function type, the pointer type produced by
	the function-to-pointer standard conversion
	(_conv.func_) is used in place of A for type deduction;
	otherwise,

	--If A is a cv-qualified type, the top level
	cv-qualifiers of A's type are ignored for type
	deduction. */
	if (TREE_CODE (*arg) == ARRAY_TYPE)
	arg = build_pointer_type (TREE_TYPE (arg));
	else if (TREE_CODE (*arg) == FUNCTION_TYPE)
	arg = build_pointer_type (arg);
	else
	arg = TYPE_MAIN_VARIANT (arg);
	}

	/* [temp.deduct.call]

	If P is a cv-qualified type, the top level cv-qualifiers
	of P's type are ignored for type deduction. If P is a
	reference type, the type referred to by P is used for
	type deduction. */
	parm = TYPE_MAIN_VARIANT (parm);
	if (TREE_CODE (*parm) == REFERENCE_TYPE)
	{
	parm = TREE_TYPE (parm);
	result \|= UNIFY_ALLOW_OUTER_MORE_CV_QUAL;
	}

	/* DR 322. For conversion deduction, remove a reference type on parm
	too (which has been swapped into ARG). */
	if (strict == DEDUCE_CONV && TREE_CODE (*arg) == REFERENCE_TYPE)
	arg = TREE_TYPE (arg);

	return result;
	}

	/* Most parms like fn_type_unification.

	If SUBR is 1, we're being called recursively (to unify the
	arguments of a function or method parameter of a function
	template). */

	static int
	type_unification_real (tree tparms,
	tree targs,
	tree xparms,
	tree xargs,
	int subr,
	unification_kind_t strict,
	int flags)
	{
	tree parm, arg;
	int i;
	int ntparms = TREE_VEC_LENGTH (tparms);
	int sub_strict;
	int saw_undeduced = 0;
	tree parms, args;

	gcc_assert (TREE_CODE (tparms) == TREE_VEC);
	gcc_assert (xparms == NULL_TREE \|\| TREE_CODE (xparms) == TREE_LIST);
	gcc_assert (!xargs \|\| TREE_CODE (xargs) == TREE_LIST);
	gcc_assert (ntparms > 0);

	switch (strict)
	{
	case DEDUCE_CALL:
	sub_strict = (UNIFY_ALLOW_OUTER_LEVEL \| UNIFY_ALLOW_MORE_CV_QUAL
	\| UNIFY_ALLOW_DERIVED);
	break;

	case DEDUCE_CONV:
	sub_strict = UNIFY_ALLOW_LESS_CV_QUAL;
	break;

	case DEDUCE_EXACT:
	sub_strict = UNIFY_ALLOW_NONE;
	break;

	default:
	gcc_unreachable ();
	}

	again:
	parms = xparms;
	args = xargs;

	while (parms && parms != void_list_node
	&& args && args != void_list_node)
	{
	parm = TREE_VALUE (parms);
	parms = TREE_CHAIN (parms);
	arg = TREE_VALUE (args);
	args = TREE_CHAIN (args);

	if (arg == error_mark_node)
	return 1;
	if (arg == unknown_type_node)
	/* We can't deduce anything from this, but we might get all the
	template args from other function args. */
	continue;

	/* Conversions will be performed on a function argument that
	corresponds with a function parameter that contains only
	non-deducible template parameters and explicitly specified
	template parameters. */
	if (!uses_template_parms (parm))
	{
	tree type;

	if (!TYPE_P (arg))
	type = TREE_TYPE (arg);
	else
	type = arg;

	if (same_type_p (parm, type))
	continue;
	if (strict != DEDUCE_EXACT
	&& can_convert_arg (parm, type, TYPE_P (arg) ? NULL_TREE : arg,
	flags))
	continue;

	return 1;
	}

	if (!TYPE_P (arg))
	{
	gcc_assert (TREE_TYPE (arg) != NULL_TREE);
	if (type_unknown_p (arg))
	{
	/* [temp.deduct.type]

	A template-argument can be deduced from a pointer to
	function or pointer to member function argument if
	the set of overloaded functions does not contain
	function templates and at most one of a set of
	overloaded functions provides a unique match. */
	if (resolve_overloaded_unification
	(tparms, targs, parm, arg, strict, sub_strict))
	continue;

	return 1;
	}
	arg = unlowered_expr_type (arg);
	if (arg == error_mark_node)
	return 1;
	}

	{
	int arg_strict = sub_strict;

	if (!subr)
	arg_strict \|= maybe_adjust_types_for_deduction (strict, &parm, &arg);

	if (unify (tparms, targs, parm, arg, arg_strict))
	return 1;
	}
	}

	/* Fail if we've reached the end of the parm list, and more args
	are present, and the parm list isn't variadic. */
	if (args && args != void_list_node && parms == void_list_node)
	return 1;
	/* Fail if parms are left and they don't have default values. */
	if (parms && parms != void_list_node
	&& TREE_PURPOSE (parms) == NULL_TREE)
	return 1;

	if (!subr)
	for (i = 0; i < ntparms; i++)
	if (!TREE_VEC_ELT (targs, i))
	{
	tree tparm;

	if (TREE_VEC_ELT (tparms, i) == error_mark_node)
	continue;

	tparm = TREE_VALUE (TREE_VEC_ELT (tparms, i));

	/* If this is an undeduced nontype parameter that depends on
	a type parameter, try another pass; its type may have been
	deduced from a later argument than the one from which
	this parameter can be deduced. */
	if (TREE_CODE (tparm) == PARM_DECL
	&& uses_template_parms (TREE_TYPE (tparm))
	&& !saw_undeduced++)
	goto again;

	return 2;
	}

	return 0;
	}

	/* Subroutine of type_unification_real. Args are like the variables
	at the call site. ARG is an overloaded function (or template-id);
	we try deducing template args from each of the overloads, and if
	only one succeeds, we go with that. Modifies TARGS and returns
	true on success. */

	static bool
	resolve_overloaded_unification (tree tparms,
	tree targs,
	tree parm,
	tree arg,
	unification_kind_t strict,
	int sub_strict)
	{
	tree tempargs = copy_node (targs);
	int good = 0;
	bool addr_p;

	if (TREE_CODE (arg) == ADDR_EXPR)
	{
	arg = TREE_OPERAND (arg, 0);
	addr_p = true;
	}
	else
	addr_p = false;

	if (TREE_CODE (arg) == COMPONENT_REF)
	/* Handle `&x' where `x' is some static or non-static member
	function name. */
	arg = TREE_OPERAND (arg, 1);

	if (TREE_CODE (arg) == OFFSET_REF)
	arg = TREE_OPERAND (arg, 1);

	/* Strip baselink information. */
	if (BASELINK_P (arg))
	arg = BASELINK_FUNCTIONS (arg);

	if (TREE_CODE (arg) == TEMPLATE_ID_EXPR)
	{
	/* If we got some explicit template args, we need to plug them into
	the affected templates before we try to unify, in case the
	explicit args will completely resolve the templates in question. */

	tree expl_subargs = TREE_OPERAND (arg, 1);
	arg = TREE_OPERAND (arg, 0);

	for (; arg; arg = OVL_NEXT (arg))
	{
	tree fn = OVL_CURRENT (arg);
	tree subargs, elem;

	if (TREE_CODE (fn) != TEMPLATE_DECL)
	continue;

	subargs = get_bindings (fn, DECL_TEMPLATE_RESULT (fn),
	expl_subargs, /check_ret=/false);
	if (subargs)
	{
	elem = tsubst (TREE_TYPE (fn), subargs, tf_none, NULL_TREE);
	good += try_one_overload (tparms, targs, tempargs, parm,
	elem, strict, sub_strict, addr_p);
	}
	}
	}
	else if (TREE_CODE (arg) != OVERLOAD
	&& TREE_CODE (arg) != FUNCTION_DECL)
	/* If ARG is, for example, "(0, &f)" then its type will be unknown
	-- but the deduction does not succeed because the expression is
	not just the function on its own. */
	return false;
	else
	for (; arg; arg = OVL_NEXT (arg))
	good += try_one_overload (tparms, targs, tempargs, parm,
	TREE_TYPE (OVL_CURRENT (arg)),
	strict, sub_strict, addr_p);

	/* [temp.deduct.type] A template-argument can be deduced from a pointer
	to function or pointer to member function argument if the set of
	overloaded functions does not contain function templates and at most
	one of a set of overloaded functions provides a unique match.

	So if we found multiple possibilities, we return success but don't
	deduce anything. */

	if (good == 1)
	{
	int i = TREE_VEC_LENGTH (targs);
	for (; i--; )
	if (TREE_VEC_ELT (tempargs, i))
	TREE_VEC_ELT (targs, i) = TREE_VEC_ELT (tempargs, i);
	}
	if (good)
	return true;

	return false;
	}

	/* Subroutine of resolve_overloaded_unification; does deduction for a single
	overload. Fills TARGS with any deduced arguments, or error_mark_node if
	different overloads deduce different arguments for a given parm.
	ADDR_P is true if the expression for which deduction is being
	performed was of the form "& fn" rather than simply "fn".

	Returns 1 on success. */

	static int
	try_one_overload (tree tparms,
	tree orig_targs,
	tree targs,
	tree parm,
	tree arg,
	unification_kind_t strict,
	int sub_strict,
	bool addr_p)
	{
	int nargs;
	tree tempargs;
	int i;

	/* [temp.deduct.type] A template-argument can be deduced from a pointer
	to function or pointer to member function argument if the set of
	overloaded functions does not contain function templates and at most
	one of a set of overloaded functions provides a unique match.

	So if this is a template, just return success. */

	if (uses_template_parms (arg))
	return 1;

	if (TREE_CODE (arg) == METHOD_TYPE)
	arg = build_ptrmemfunc_type (build_pointer_type (arg));
	else if (addr_p)
	arg = build_pointer_type (arg);

	sub_strict \|= maybe_adjust_types_for_deduction (strict, &parm, &arg);

	/* We don't copy orig_targs for this because if we have already deduced
	some template args from previous args, unify would complain when we
	try to deduce a template parameter for the same argument, even though
	there isn't really a conflict. */
	nargs = TREE_VEC_LENGTH (targs);
	tempargs = make_tree_vec (nargs);

	if (unify (tparms, tempargs, parm, arg, sub_strict) != 0)
	return 0;

	/* First make sure we didn't deduce anything that conflicts with
	explicitly specified args. */
	for (i = nargs; i--; )
	{
	tree elt = TREE_VEC_ELT (tempargs, i);
	tree oldelt = TREE_VEC_ELT (orig_targs, i);

	if (!elt)
	/NOP/;
	else if (uses_template_parms (elt))
	/* Since we're unifying against ourselves, we will fill in
	template args used in the function parm list with our own
	template parms. Discard them. */
	TREE_VEC_ELT (tempargs, i) = NULL_TREE;
	else if (oldelt && !template_args_equal (oldelt, elt))
	return 0;
	}

	for (i = nargs; i--; )
	{
	tree elt = TREE_VEC_ELT (tempargs, i);

	if (elt)
	TREE_VEC_ELT (targs, i) = elt;
	}

	return 1;
	}

	/* PARM is a template class (perhaps with unbound template
	parameters). ARG is a fully instantiated type. If ARG can be
	bound to PARM, return ARG, otherwise return NULL_TREE. TPARMS and
	TARGS are as for unify. */

	static tree
	try_class_unification (tree tparms, tree targs, tree parm, tree arg)
	{
	tree copy_of_targs;

	if (!CLASSTYPE_TEMPLATE_INFO (arg)
	\|\| (most_general_template (CLASSTYPE_TI_TEMPLATE (arg))
	!= most_general_template (CLASSTYPE_TI_TEMPLATE (parm))))
	return NULL_TREE;

	/* We need to make a new template argument vector for the call to
	unify. If we used TARGS, we'd clutter it up with the result of
	the attempted unification, even if this class didn't work out.
	We also don't want to commit ourselves to all the unifications
	we've already done, since unification is supposed to be done on
	an argument-by-argument basis. In other words, consider the
	following pathological case:

	template <int I, int J, int K>
	struct S {};

	template <int I, int J>
	struct S<I, J, 2> : public S<I, I, I>, S<J, J, J> {};

	template <int I, int J, int K>
	void f(S<I, J, K>, S<I, I, I>);

	void g() {
	S<0, 0, 0> s0;
	S<0, 1, 2> s2;

	f(s0, s2);
	}

	Now, by the time we consider the unification involving `s2', we
	already know that we must have `f<0, 0, 0>'. But, even though
	`S<0, 1, 2>' is derived from `S<0, 0, 0>', the code is invalid
	because there are two ways to unify base classes of S<0, 1, 2>
	with S<I, I, I>. If we kept the already deduced knowledge, we
	would reject the possibility I=1. */
	copy_of_targs = make_tree_vec (TREE_VEC_LENGTH (targs));

	/* If unification failed, we're done. */
	if (unify (tparms, copy_of_targs, CLASSTYPE_TI_ARGS (parm),
	CLASSTYPE_TI_ARGS (arg), UNIFY_ALLOW_NONE))
	return NULL_TREE;

	return arg;
	}

	/* Given a template type PARM and a class type ARG, find the unique
	base type in ARG that is an instance of PARM. We do not examine
	ARG itself; only its base-classes. If there is not exactly one
	appropriate base class, return NULL_TREE. PARM may be the type of
	a partial specialization, as well as a plain template type. Used
	by unify. */

	static tree
	get_template_base (tree tparms, tree targs, tree parm, tree arg)
	{
	tree rval = NULL_TREE;
	tree binfo;

	gcc_assert (IS_AGGR_TYPE_CODE (TREE_CODE (arg)));

	binfo = TYPE_BINFO (complete_type (arg));
	if (!binfo)
	/* The type could not be completed. */
	return NULL_TREE;

	/* Walk in inheritance graph order. The search order is not
	important, and this avoids multiple walks of virtual bases. */
	for (binfo = TREE_CHAIN (binfo); binfo; binfo = TREE_CHAIN (binfo))
	{
	tree r = try_class_unification (tparms, targs, parm, BINFO_TYPE (binfo));

	if (r)
	{
	/* If there is more than one satisfactory baseclass, then:

	[temp.deduct.call]

	If they yield more than one possible deduced A, the type
	deduction fails.

	applies. */
	if (rval && !same_type_p (r, rval))
	return NULL_TREE;

	rval = r;
	}
	}

	return rval;
	}

	/* Returns the level of DECL, which declares a template parameter. */

	static int
	template_decl_level (tree decl)
	{
	switch (TREE_CODE (decl))
	{
	case TYPE_DECL:
	case TEMPLATE_DECL:
	return TEMPLATE_TYPE_LEVEL (TREE_TYPE (decl));

	case PARM_DECL:
	return TEMPLATE_PARM_LEVEL (DECL_INITIAL (decl));

	default:
	gcc_unreachable ();
	}
	return 0;
	}

	/* Decide whether ARG can be unified with PARM, considering only the
	cv-qualifiers of each type, given STRICT as documented for unify.
	Returns nonzero iff the unification is OK on that basis. */

	static int
	check_cv_quals_for_unify (int strict, tree arg, tree parm)
	{
	int arg_quals = cp_type_quals (arg);
	int parm_quals = cp_type_quals (parm);

	if (TREE_CODE (parm) == TEMPLATE_TYPE_PARM
	&& !(strict & UNIFY_ALLOW_OUTER_MORE_CV_QUAL))
	{
	/* Although a CVR qualifier is ignored when being applied to a
	substituted template parameter ([8.3.2]/1 for example), that
	does not apply during deduction [14.8.2.4]/1, (even though
	that is not explicitly mentioned, [14.8.2.4]/9 indicates
	this). Except when we're allowing additional CV qualifiers
	at the outer level [14.8.2.1]/3,1st bullet. */
	if ((TREE_CODE (arg) == REFERENCE_TYPE
	\|\| TREE_CODE (arg) == FUNCTION_TYPE
	\|\| TREE_CODE (arg) == METHOD_TYPE)
	&& (parm_quals & (TYPE_QUAL_CONST \| TYPE_QUAL_VOLATILE)))
	return 0;

	if ((!POINTER_TYPE_P (arg) && TREE_CODE (arg) != TEMPLATE_TYPE_PARM)
	&& (parm_quals & TYPE_QUAL_RESTRICT))
	return 0;
	}

	if (!(strict & (UNIFY_ALLOW_MORE_CV_QUAL \| UNIFY_ALLOW_OUTER_MORE_CV_QUAL))
	&& (arg_quals & parm_quals) != parm_quals)
	return 0;

	if (!(strict & (UNIFY_ALLOW_LESS_CV_QUAL \| UNIFY_ALLOW_OUTER_LESS_CV_QUAL))
	&& (parm_quals & arg_quals) != arg_quals)
	return 0;

	return 1;
	}

	/* Deduce the value of template parameters. TPARMS is the (innermost)
	set of template parameters to a template. TARGS is the bindings
	for those template parameters, as determined thus far; TARGS may
	include template arguments for outer levels of template parameters
	as well. PARM is a parameter to a template function, or a
	subcomponent of that parameter; ARG is the corresponding argument.
	This function attempts to match PARM with ARG in a manner
	consistent with the existing assignments in TARGS. If more values
	are deduced, then TARGS is updated.

	Returns 0 if the type deduction succeeds, 1 otherwise. The
	parameter STRICT is a bitwise or of the following flags:

	UNIFY_ALLOW_NONE:
	Require an exact match between PARM and ARG.
	UNIFY_ALLOW_MORE_CV_QUAL:
	Allow the deduced ARG to be more cv-qualified (by qualification
	conversion) than ARG.
	UNIFY_ALLOW_LESS_CV_QUAL:
	Allow the deduced ARG to be less cv-qualified than ARG.
	UNIFY_ALLOW_DERIVED:
	Allow the deduced ARG to be a template base class of ARG,
	or a pointer to a template base class of the type pointed to by
	ARG.
	UNIFY_ALLOW_INTEGER:
	Allow any integral type to be deduced. See the TEMPLATE_PARM_INDEX
	case for more information.
	UNIFY_ALLOW_OUTER_LEVEL:
	This is the outermost level of a deduction. Used to determine validity
	of qualification conversions. A valid qualification conversion must
	have const qualified pointers leading up to the inner type which
	requires additional CV quals, except at the outer level, where const
	is not required [conv.qual]. It would be normal to set this flag in
	addition to setting UNIFY_ALLOW_MORE_CV_QUAL.
	UNIFY_ALLOW_OUTER_MORE_CV_QUAL:
	This is the outermost level of a deduction, and PARM can be more CV
	qualified at this point.
	UNIFY_ALLOW_OUTER_LESS_CV_QUAL:
	This is the outermost level of a deduction, and PARM can be less CV
	qualified at this point. */

	static int
	unify (tree tparms, tree targs, tree parm, tree arg, int strict)
	{
	int idx;
	tree targ;
	tree tparm;
	int strict_in = strict;

	/* I don't think this will do the right thing with respect to types.
	But the only case I've seen it in so far has been array bounds, where
	signedness is the only information lost, and I think that will be
	okay. */
	while (TREE_CODE (parm) == NOP_EXPR)
	parm = TREE_OPERAND (parm, 0);

	if (arg == error_mark_node)
	return 1;
	if (arg == unknown_type_node)
	/* We can't deduce anything from this, but we might get all the
	template args from other function args. */
	return 0;

	/* If PARM uses template parameters, then we can't bail out here,
	even if ARG == PARM, since we won't record unifications for the
	template parameters. We might need them if we're trying to
	figure out which of two things is more specialized. */
	if (arg == parm && !uses_template_parms (parm))
	return 0;

	/* Immediately reject some pairs that won't unify because of
	cv-qualification mismatches. */
	if (TREE_CODE (arg) == TREE_CODE (parm)
	&& TYPE_P (arg)
	/* It is the elements of the array which hold the cv quals of an array
	type, and the elements might be template type parms. We'll check
	when we recurse. */
	&& TREE_CODE (arg) != ARRAY_TYPE
	/* We check the cv-qualifiers when unifying with template type
	parameters below. We want to allow ARG `const T' to unify with
	PARM `T' for example, when computing which of two templates
	is more specialized, for example. */
	&& TREE_CODE (arg) != TEMPLATE_TYPE_PARM
	&& !check_cv_quals_for_unify (strict_in, arg, parm))
	return 1;

	if (!(strict & UNIFY_ALLOW_OUTER_LEVEL)
	&& TYPE_P (parm) && !CP_TYPE_CONST_P (parm))
	strict &= ~UNIFY_ALLOW_MORE_CV_QUAL;
	strict &= ~UNIFY_ALLOW_OUTER_LEVEL;
	strict &= ~UNIFY_ALLOW_DERIVED;
	strict &= ~UNIFY_ALLOW_OUTER_MORE_CV_QUAL;
	strict &= ~UNIFY_ALLOW_OUTER_LESS_CV_QUAL;

	switch (TREE_CODE (parm))
	{
	case TYPENAME_TYPE:
	case SCOPE_REF:
	case UNBOUND_CLASS_TEMPLATE:
	/* In a type which contains a nested-name-specifier, template
	argument values cannot be deduced for template parameters used
	within the nested-name-specifier. */
	return 0;

	case TEMPLATE_TYPE_PARM:
	case TEMPLATE_TEMPLATE_PARM:
	case BOUND_TEMPLATE_TEMPLATE_PARM:
	tparm = TREE_VALUE (TREE_VEC_ELT (tparms, 0));
	if (tparm == error_mark_node)
	return 1;

	if (TEMPLATE_TYPE_LEVEL (parm)
	!= template_decl_level (tparm))
	/* The PARM is not one we're trying to unify. Just check
	to see if it matches ARG. */
	return (TREE_CODE (arg) == TREE_CODE (parm)
	&& same_type_p (parm, arg)) ? 0 : 1;
	idx = TEMPLATE_TYPE_IDX (parm);
	targ = TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs), idx);
	tparm = TREE_VALUE (TREE_VEC_ELT (tparms, idx));

	/* Check for mixed types and values. */
	if ((TREE_CODE (parm) == TEMPLATE_TYPE_PARM
	&& TREE_CODE (tparm) != TYPE_DECL)
	\|\| (TREE_CODE (parm) == TEMPLATE_TEMPLATE_PARM
	&& TREE_CODE (tparm) != TEMPLATE_DECL))
	return 1;

	if (TREE_CODE (parm) == BOUND_TEMPLATE_TEMPLATE_PARM)
	{
	/* ARG must be constructed from a template class or a template
	template parameter. */
	if (TREE_CODE (arg) != BOUND_TEMPLATE_TEMPLATE_PARM
	&& !CLASSTYPE_SPECIALIZATION_OF_PRIMARY_TEMPLATE_P (arg))
	return 1;

	{
	tree parmvec = TYPE_TI_ARGS (parm);
	tree argvec = INNERMOST_TEMPLATE_ARGS (TYPE_TI_ARGS (arg));
	tree argtmplvec
	= DECL_INNERMOST_TEMPLATE_PARMS (TYPE_TI_TEMPLATE (arg));
	int i;

	/* The resolution to DR150 makes clear that default
	arguments for an N-argument may not be used to bind T
	to a template template parameter with fewer than N
	parameters. It is not safe to permit the binding of
	default arguments as an extension, as that may change
	the meaning of a conforming program. Consider:

	struct Dense { static const unsigned int dim = 1; };

	template <template <typename> class View,
	typename Block>
	void operator+(float, View<Block> const&);

	template <typename Block,
	unsigned int Dim = Block::dim>
	struct Lvalue_proxy { operator float() const; };

	void
	test_1d (void) {
	Lvalue_proxy<Dense> p;
	float b;
	b + p;
	}

	Here, if Lvalue_proxy is permitted to bind to View, then
	the global operator+ will be used; if they are not, the
	Lvalue_proxy will be converted to float. */
	if (coerce_template_parms (argtmplvec, parmvec,
	TYPE_TI_TEMPLATE (parm),
	tf_none,
	/require_all_args=/true,
	/use_default_args=/false)
	== error_mark_node)
	return 1;

	/* Deduce arguments T, i from TT<T> or TT<i>.
	We check each element of PARMVEC and ARGVEC individually
	rather than the whole TREE_VEC since they can have
	different number of elements. */

	for (i = 0; i < TREE_VEC_LENGTH (parmvec); ++i)
	{
	if (unify (tparms, targs,
	TREE_VEC_ELT (parmvec, i),
	TREE_VEC_ELT (argvec, i),
	UNIFY_ALLOW_NONE))
	return 1;
	}
	}
	arg = TYPE_TI_TEMPLATE (arg);

	/* Fall through to deduce template name. */
	}

	if (TREE_CODE (parm) == TEMPLATE_TEMPLATE_PARM
	\|\| TREE_CODE (parm) == BOUND_TEMPLATE_TEMPLATE_PARM)
	{
	/* Deduce template name TT from TT, TT<>, TT<T> and TT<i>. */

	/* Simple cases: Value already set, does match or doesn't. */
	if (targ != NULL_TREE && template_args_equal (targ, arg))
	return 0;
	else if (targ)
	return 1;
	}
	else
	{
	/* If PARM is `const T' and ARG is only `int', we don't have
	a match unless we are allowing additional qualification.
	If ARG is `const int' and PARM is just `T' that's OK;
	that binds `const int' to `T'. */
	if (!check_cv_quals_for_unify (strict_in \| UNIFY_ALLOW_LESS_CV_QUAL,
	arg, parm))
	return 1;

	/* Consider the case where ARG is `const volatile int' and
	PARM is `const T'. Then, T should be `volatile int'. */
	arg = cp_build_qualified_type_real
	(arg, cp_type_quals (arg) & ~cp_type_quals (parm), tf_none);
	if (arg == error_mark_node)
	return 1;

	/* Simple cases: Value already set, does match or doesn't. */
	if (targ != NULL_TREE && same_type_p (targ, arg))
	return 0;
	else if (targ)
	return 1;

	/* Make sure that ARG is not a variable-sized array. (Note
	that were talking about variable-sized arrays (like
	`int[n]'), rather than arrays of unknown size (like
	`int[]').) We'll get very confused by such a type since
	the bound of the array will not be computable in an
	instantiation. Besides, such types are not allowed in
	ISO C++, so we can do as we please here. */
	if (variably_modified_type_p (arg, NULL_TREE))
	return 1;
	}

	TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs), idx) = arg;
	return 0;

	case TEMPLATE_PARM_INDEX:
	tparm = TREE_VALUE (TREE_VEC_ELT (tparms, 0));
	if (tparm == error_mark_node)
	return 1;

	if (TEMPLATE_PARM_LEVEL (parm)
	!= template_decl_level (tparm))
	/* The PARM is not one we're trying to unify. Just check
	to see if it matches ARG. */
	return !(TREE_CODE (arg) == TREE_CODE (parm)
	&& cp_tree_equal (parm, arg));

	idx = TEMPLATE_PARM_IDX (parm);
	targ = TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs), idx);

	if (targ)
	return !cp_tree_equal (targ, arg);

	/* [temp.deduct.type] If, in the declaration of a function template
	with a non-type template-parameter, the non-type
	template-parameter is used in an expression in the function
	parameter-list and, if the corresponding template-argument is
	deduced, the template-argument type shall match the type of the
	template-parameter exactly, except that a template-argument
	deduced from an array bound may be of any integral type.
	The non-type parameter might use already deduced type parameters. */
	tparm = tsubst (TREE_TYPE (parm), targs, 0, NULL_TREE);
	if (!TREE_TYPE (arg))
	/* Template-parameter dependent expression. Just accept it for now.
	It will later be processed in convert_template_argument. */
	;
	else if (same_type_p (TREE_TYPE (arg), tparm))
	/* OK */;
	else if ((strict & UNIFY_ALLOW_INTEGER)
	&& (TREE_CODE (tparm) == INTEGER_TYPE
	\|\| TREE_CODE (tparm) == BOOLEAN_TYPE))
	/* Convert the ARG to the type of PARM; the deduced non-type
	template argument must exactly match the types of the
	corresponding parameter. */
	arg = fold (build_nop (TREE_TYPE (parm), arg));
	else if (uses_template_parms (tparm))
	/* We haven't deduced the type of this parameter yet. Try again
	later. */
	return 0;
	else
	return 1;

	TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs), idx) = arg;
	return 0;

	case PTRMEM_CST:
	{
	/* A pointer-to-member constant can be unified only with
	another constant. */
	if (TREE_CODE (arg) != PTRMEM_CST)
	return 1;

	/* Just unify the class member. It would be useless (and possibly
	wrong, depending on the strict flags) to unify also
	PTRMEM_CST_CLASS, because we want to be sure that both parm and
	arg refer to the same variable, even if through different
	classes. For instance:

	struct A { int x; };
	struct B : A { };

	Unification of &A::x and &B::x must succeed. */
	return unify (tparms, targs, PTRMEM_CST_MEMBER (parm),
	PTRMEM_CST_MEMBER (arg), strict);
	}

	case POINTER_TYPE:
	{
	if (TREE_CODE (arg) != POINTER_TYPE)
	return 1;

	/* [temp.deduct.call]

	A can be another pointer or pointer to member type that can
	be converted to the deduced A via a qualification
	conversion (_conv.qual_).

	We pass down STRICT here rather than UNIFY_ALLOW_NONE.
	This will allow for additional cv-qualification of the
	pointed-to types if appropriate. */

	if (TREE_CODE (TREE_TYPE (arg)) == RECORD_TYPE)
	/* The derived-to-base conversion only persists through one
	level of pointers. */
	strict \|= (strict_in & UNIFY_ALLOW_DERIVED);

	return unify (tparms, targs, TREE_TYPE (parm),
	TREE_TYPE (arg), strict);
	}

	case REFERENCE_TYPE:
	if (TREE_CODE (arg) != REFERENCE_TYPE)
	return 1;
	return unify (tparms, targs, TREE_TYPE (parm), TREE_TYPE (arg),
	strict & UNIFY_ALLOW_MORE_CV_QUAL);

	case ARRAY_TYPE:
	if (TREE_CODE (arg) != ARRAY_TYPE)
	return 1;
	if ((TYPE_DOMAIN (parm) == NULL_TREE)
	!= (TYPE_DOMAIN (arg) == NULL_TREE))
	return 1;
	if (TYPE_DOMAIN (parm) != NULL_TREE)
	{
	tree parm_max;
	tree arg_max;
	bool parm_cst;
	bool arg_cst;

	/* Our representation of array types uses "N - 1" as the
	TYPE_MAX_VALUE for an array with "N" elements, if "N" is
	not an integer constant. We cannot unify arbitrarily
	complex expressions, so we eliminate the MINUS_EXPRs
	here. */
	parm_max = TYPE_MAX_VALUE (TYPE_DOMAIN (parm));
	parm_cst = TREE_CODE (parm_max) == INTEGER_CST;
	if (!parm_cst)
	{
	gcc_assert (TREE_CODE (parm_max) == MINUS_EXPR);
	parm_max = TREE_OPERAND (parm_max, 0);
	}
	arg_max = TYPE_MAX_VALUE (TYPE_DOMAIN (arg));
	arg_cst = TREE_CODE (arg_max) == INTEGER_CST;
	if (!arg_cst)
	{
	/* The ARG_MAX may not be a simple MINUS_EXPR, if we are
	trying to unify the type of a variable with the type
	of a template parameter. For example:

	template <unsigned int N>
	void f (char (&) [N]);
	int g();
	void h(int i) {
	char a[g(i)];
	f(a);
	}

	Here, the type of the ARG will be "int [g(i)]", and
	may be a SAVE_EXPR, etc. */
	if (TREE_CODE (arg_max) != MINUS_EXPR)
	return 1;
	arg_max = TREE_OPERAND (arg_max, 0);
	}

	/* If only one of the bounds used a MINUS_EXPR, compensate
	by adding one to the other bound. */
	if (parm_cst && !arg_cst)
	parm_max = fold_build2 (PLUS_EXPR,
	integer_type_node,
	parm_max,
	integer_one_node);
	else if (arg_cst && !parm_cst)
	arg_max = fold_build2 (PLUS_EXPR,
	integer_type_node,
	arg_max,
	integer_one_node);

	if (unify (tparms, targs, parm_max, arg_max, UNIFY_ALLOW_INTEGER))
	return 1;
	}
	return unify (tparms, targs, TREE_TYPE (parm), TREE_TYPE (arg),
	strict & UNIFY_ALLOW_MORE_CV_QUAL);

	case REAL_TYPE:
	case COMPLEX_TYPE:
	case VECTOR_TYPE:
	case INTEGER_TYPE:
	case BOOLEAN_TYPE:
	case ENUMERAL_TYPE:
	case VOID_TYPE:
	if (TREE_CODE (arg) != TREE_CODE (parm))
	return 1;

	/* We have already checked cv-qualification at the top of the
	function. */
	if (!same_type_ignoring_top_level_qualifiers_p (arg, parm))
	return 1;

	/* As far as unification is concerned, this wins. Later checks
	will invalidate it if necessary. */
	return 0;

	/* Types INTEGER_CST and MINUS_EXPR can come from array bounds. */
	/* Type INTEGER_CST can come from ordinary constant template args. */
	case INTEGER_CST:
	while (TREE_CODE (arg) == NOP_EXPR)
	arg = TREE_OPERAND (arg, 0);

	if (TREE_CODE (arg) != INTEGER_CST)
	return 1;
	return !tree_int_cst_equal (parm, arg);

	case TREE_VEC:
	{
	int i;
	if (TREE_CODE (arg) != TREE_VEC)
	return 1;
	if (TREE_VEC_LENGTH (parm) != TREE_VEC_LENGTH (arg))
	return 1;
	for (i = 0; i < TREE_VEC_LENGTH (parm); ++i)
	if (unify (tparms, targs,
	TREE_VEC_ELT (parm, i), TREE_VEC_ELT (arg, i),
	UNIFY_ALLOW_NONE))
	return 1;
	return 0;
	}

	case RECORD_TYPE:
	case UNION_TYPE:
	if (TREE_CODE (arg) != TREE_CODE (parm))
	return 1;

	if (TYPE_PTRMEMFUNC_P (parm))
	{
	if (!TYPE_PTRMEMFUNC_P (arg))
	return 1;

	return unify (tparms, targs,
	TYPE_PTRMEMFUNC_FN_TYPE (parm),
	TYPE_PTRMEMFUNC_FN_TYPE (arg),
	strict);
	}

	if (CLASSTYPE_TEMPLATE_INFO (parm))
	{
	tree t = NULL_TREE;

	if (strict_in & UNIFY_ALLOW_DERIVED)
	{
	/* First, we try to unify the PARM and ARG directly. */
	t = try_class_unification (tparms, targs,
	parm, arg);

	if (!t)
	{
	/* Fallback to the special case allowed in
	[temp.deduct.call]:

	If P is a class, and P has the form
	template-id, then A can be a derived class of
	the deduced A. Likewise, if P is a pointer to
	a class of the form template-id, A can be a
	pointer to a derived class pointed to by the
	deduced A. */
	t = get_template_base (tparms, targs, parm, arg);

	if (!t)
	return 1;
	}
	}
	else if (CLASSTYPE_TEMPLATE_INFO (arg)
	&& (CLASSTYPE_TI_TEMPLATE (parm)
	== CLASSTYPE_TI_TEMPLATE (arg)))
	/* Perhaps PARM is something like S<U> and ARG is S<int>.
	Then, we should unify `int' and `U'. */
	t = arg;
	else
	/* There's no chance of unification succeeding. */
	return 1;

	return unify (tparms, targs, CLASSTYPE_TI_ARGS (parm),
	CLASSTYPE_TI_ARGS (t), UNIFY_ALLOW_NONE);
	}
	else if (!same_type_ignoring_top_level_qualifiers_p (parm, arg))
	return 1;
	return 0;

	case METHOD_TYPE:
	case FUNCTION_TYPE:
	if (TREE_CODE (arg) != TREE_CODE (parm))
	return 1;

	/* CV qualifications for methods can never be deduced, they must
	match exactly. We need to check them explicitly here,
	because type_unification_real treats them as any other
	cvqualified parameter. */
	if (TREE_CODE (parm) == METHOD_TYPE
	&& (!check_cv_quals_for_unify
	(UNIFY_ALLOW_NONE,
	TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (arg))),
	TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (parm))))))
	return 1;

	if (unify (tparms, targs, TREE_TYPE (parm),
	TREE_TYPE (arg), UNIFY_ALLOW_NONE))
	return 1;
	return type_unification_real (tparms, targs, TYPE_ARG_TYPES (parm),
	TYPE_ARG_TYPES (arg), 1, DEDUCE_EXACT,
	LOOKUP_NORMAL);

	case OFFSET_TYPE:
	/* Unify a pointer to member with a pointer to member function, which
	deduces the type of the member as a function type. */
	if (TYPE_PTRMEMFUNC_P (arg))
	{
	tree method_type;
	tree fntype;
	cp_cv_quals cv_quals;

	/* Check top-level cv qualifiers */
	if (!check_cv_quals_for_unify (UNIFY_ALLOW_NONE, arg, parm))
	return 1;

	if (unify (tparms, targs, TYPE_OFFSET_BASETYPE (parm),
	TYPE_PTRMEMFUNC_OBJECT_TYPE (arg), UNIFY_ALLOW_NONE))
	return 1;

	/* Determine the type of the function we are unifying against. */
	method_type = TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (arg));
	fntype =
	build_function_type (TREE_TYPE (method_type),
	TREE_CHAIN (TYPE_ARG_TYPES (method_type)));

	/* Extract the cv-qualifiers of the member function from the
	implicit object parameter and place them on the function
	type to be restored later. */
	cv_quals =
	cp_type_quals(TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (method_type))));
	fntype = build_qualified_type (fntype, cv_quals);
	return unify (tparms, targs, TREE_TYPE (parm), fntype, strict);
	}

	if (TREE_CODE (arg) != OFFSET_TYPE)
	return 1;
	if (unify (tparms, targs, TYPE_OFFSET_BASETYPE (parm),
	TYPE_OFFSET_BASETYPE (arg), UNIFY_ALLOW_NONE))
	return 1;
	return unify (tparms, targs, TREE_TYPE (parm), TREE_TYPE (arg),
	strict);

	case CONST_DECL:
	if (DECL_TEMPLATE_PARM_P (parm))
	return unify (tparms, targs, DECL_INITIAL (parm), arg, strict);
	if (arg != integral_constant_value (parm))
	return 1;
	return 0;

	case FIELD_DECL:
	case TEMPLATE_DECL:
	/* Matched cases are handled by the ARG == PARM test above. */
	return 1;

	default:
	gcc_assert (EXPR_P (parm));

	/* We must be looking at an expression. This can happen with
	something like:

	template <int I>
	void foo(S<I>, S<I + 2>);

	This is a "nondeduced context":

	[deduct.type]

	The nondeduced contexts are:

	--A type that is a template-id in which one or more of
	the template-arguments is an expression that references
	a template-parameter.

	In these cases, we assume deduction succeeded, but don't
	actually infer any unifications. */

	if (!uses_template_parms (parm)
	&& !template_args_equal (parm, arg))
	return 1;
	else
	return 0;
	}
	}

	/* Note that DECL can be defined in this translation unit, if
	required. */

	static void
	mark_definable (tree decl)
	{
	tree clone;
	DECL_NOT_REALLY_EXTERN (decl) = 1;
	FOR_EACH_CLONE (clone, decl)
	DECL_NOT_REALLY_EXTERN (clone) = 1;
	}

	/* Called if RESULT is explicitly instantiated, or is a member of an
	explicitly instantiated class. */

	void
	mark_decl_instantiated (tree result, int extern_p)
	{
	SET_DECL_EXPLICIT_INSTANTIATION (result);

	/* If this entity has already been written out, it's too late to
	make any modifications. */
	if (TREE_ASM_WRITTEN (result))
	return;

	if (TREE_CODE (result) != FUNCTION_DECL)
	/* The TREE_PUBLIC flag for function declarations will have been
	set correctly by tsubst. */
	TREE_PUBLIC (result) = 1;

	/* This might have been set by an earlier implicit instantiation. */
	DECL_COMDAT (result) = 0;

	if (extern_p)
	DECL_NOT_REALLY_EXTERN (result) = 0;
	else
	{
	mark_definable (result);
	/* Always make artificials weak. */
	if (DECL_ARTIFICIAL (result) && flag_weak)
	comdat_linkage (result);
	/* For WIN32 we also want to put explicit instantiations in
	linkonce sections. */
	else if (TREE_PUBLIC (result))
	maybe_make_one_only (result);
	}

	/* If EXTERN_P, then this function will not be emitted -- unless
	followed by an explicit instantiation, at which point its linkage
	will be adjusted. If !EXTERN_P, then this function will be
	emitted here. In neither circumstance do we want
	import_export_decl to adjust the linkage. */
	DECL_INTERFACE_KNOWN (result) = 1;
	}

	/* Given two function templates PAT1 and PAT2, return:

	1 if PAT1 is more specialized than PAT2 as described in [temp.func.order].
	-1 if PAT2 is more specialized than PAT1.
	0 if neither is more specialized.

	LEN indicates the number of parameters we should consider
	(defaulted parameters should not be considered).

	The 1998 std underspecified function template partial ordering, and
	DR214 addresses the issue. We take pairs of arguments, one from
	each of the templates, and deduce them against each other. One of
	the templates will be more specialized if all the other
	template's arguments deduce against its arguments and at least one
	of its arguments does not deduce against the other template's
	corresponding argument. Deduction is done as for class templates.
	The arguments used in deduction have reference and top level cv
	qualifiers removed. Iff both arguments were originally reference
	types and deduction succeeds in both directions, the template
	with the more cv-qualified argument wins for that pairing (if
	neither is more cv-qualified, they both are equal). Unlike regular
	deduction, after all the arguments have been deduced in this way,
	we do not verify the deduced template argument values can be
	substituted into non-deduced contexts, nor do we have to verify
	that all template arguments have been deduced. */

	int
	more_specialized_fn (tree pat1, tree pat2, int len)
	{
	tree decl1 = DECL_TEMPLATE_RESULT (pat1);
	tree decl2 = DECL_TEMPLATE_RESULT (pat2);
	tree targs1 = make_tree_vec (DECL_NTPARMS (pat1));
	tree targs2 = make_tree_vec (DECL_NTPARMS (pat2));
	tree tparms1 = DECL_INNERMOST_TEMPLATE_PARMS (pat1);
	tree tparms2 = DECL_INNERMOST_TEMPLATE_PARMS (pat2);
	tree args1 = TYPE_ARG_TYPES (TREE_TYPE (decl1));
	tree args2 = TYPE_ARG_TYPES (TREE_TYPE (decl2));
	int better1 = 0;
	int better2 = 0;

	/* Remove the this parameter from non-static member functions. If
	one is a non-static member function and the other is not a static
	member function, remove the first parameter from that function
	also. This situation occurs for operator functions where we
	locate both a member function (with this pointer) and non-member
	operator (with explicit first operand). */
	if (DECL_NONSTATIC_MEMBER_FUNCTION_P (decl1))
	{
	len--; /* LEN is the number of significant arguments for DECL1 */
	args1 = TREE_CHAIN (args1);
	if (!DECL_STATIC_FUNCTION_P (decl2))
	args2 = TREE_CHAIN (args2);
	}
	else if (DECL_NONSTATIC_MEMBER_FUNCTION_P (decl2))
	{
	args2 = TREE_CHAIN (args2);
	if (!DECL_STATIC_FUNCTION_P (decl1))
	{
	len--;
	args1 = TREE_CHAIN (args1);
	}
	}

	/* If only one is a conversion operator, they are unordered. */
	if (DECL_CONV_FN_P (decl1) != DECL_CONV_FN_P (decl2))
	return 0;

	/* Consider the return type for a conversion function */
	if (DECL_CONV_FN_P (decl1))
	{
	args1 = tree_cons (NULL_TREE, TREE_TYPE (TREE_TYPE (decl1)), args1);
	args2 = tree_cons (NULL_TREE, TREE_TYPE (TREE_TYPE (decl2)), args2);
	len++;
	}

	processing_template_decl++;

	while (len--)
	{
	tree arg1 = TREE_VALUE (args1);
	tree arg2 = TREE_VALUE (args2);
	int deduce1, deduce2;
	int quals1 = -1;
	int quals2 = -1;

	if (TREE_CODE (arg1) == REFERENCE_TYPE)
	{
	arg1 = TREE_TYPE (arg1);
	quals1 = cp_type_quals (arg1);
	}

	if (TREE_CODE (arg2) == REFERENCE_TYPE)
	{
	arg2 = TREE_TYPE (arg2);
	quals2 = cp_type_quals (arg2);
	}

	if ((quals1 < 0) != (quals2 < 0))
	{
	/* Only of the args is a reference, see if we should apply
	array/function pointer decay to it. This is not part of
	DR214, but is, IMHO, consistent with the deduction rules
	for the function call itself, and with our earlier
	implementation of the underspecified partial ordering
	rules. (nathan). */
	if (quals1 >= 0)
	{
	switch (TREE_CODE (arg1))
	{
	case ARRAY_TYPE:
	arg1 = TREE_TYPE (arg1);
	/* FALLTHROUGH. */
	case FUNCTION_TYPE:
	arg1 = build_pointer_type (arg1);
	break;

	default:
	break;
	}
	}
	else
	{
	switch (TREE_CODE (arg2))
	{
	case ARRAY_TYPE:
	arg2 = TREE_TYPE (arg2);
	/* FALLTHROUGH. */
	case FUNCTION_TYPE:
	arg2 = build_pointer_type (arg2);
	break;

	default:
	break;
	}
	}
	}

	arg1 = TYPE_MAIN_VARIANT (arg1);
	arg2 = TYPE_MAIN_VARIANT (arg2);

	deduce1 = !unify (tparms1, targs1, arg1, arg2, UNIFY_ALLOW_NONE);
	deduce2 = !unify (tparms2, targs2, arg2, arg1, UNIFY_ALLOW_NONE);

	if (!deduce1)
	better2 = -1;
	if (!deduce2)
	better1 = -1;
	if (better1 < 0 && better2 < 0)
	/* We've failed to deduce something in either direction.
	These must be unordered. */
	break;

	if (deduce1 && deduce2 && quals1 >= 0 && quals2 >= 0)
	{
	/* Deduces in both directions, see if quals can
	disambiguate. Pretend the worse one failed to deduce. */
	if ((quals1 & quals2) == quals2)
	deduce1 = 0;
	if ((quals1 & quals2) == quals1)
	deduce2 = 0;
	}
	if (deduce1 && !deduce2 && !better2)
	better2 = 1;
	if (deduce2 && !deduce1 && !better1)
	better1 = 1;

	args1 = TREE_CHAIN (args1);
	args2 = TREE_CHAIN (args2);
	}

	processing_template_decl--;

	return (better1 > 0) - (better2 > 0);
	}

	/* Determine which of two partial specializations is more specialized.

	PAT1 is a TREE_LIST whose TREE_TYPE is the _TYPE node corresponding
	to the first partial specialization. The TREE_VALUE is the
	innermost set of template parameters for the partial
	specialization. PAT2 is similar, but for the second template.

	Return 1 if the first partial specialization is more specialized;
	-1 if the second is more specialized; 0 if neither is more
	specialized.

	See [temp.class.order] for information about determining which of
	two templates is more specialized. */

	static int
	more_specialized_class (tree pat1, tree pat2)
	{
	tree targs;
	tree tmpl1, tmpl2;
	int winner = 0;

	tmpl1 = TREE_TYPE (pat1);
	tmpl2 = TREE_TYPE (pat2);

	/* Just like what happens for functions, if we are ordering between
	different class template specializations, we may encounter dependent
	types in the arguments, and we need our dependency check functions
	to behave correctly. */
	++processing_template_decl;
	targs = get_class_bindings (TREE_VALUE (pat1),
	CLASSTYPE_TI_ARGS (tmpl1),
	CLASSTYPE_TI_ARGS (tmpl2));
	if (targs)
	--winner;

	targs = get_class_bindings (TREE_VALUE (pat2),
	CLASSTYPE_TI_ARGS (tmpl2),
	CLASSTYPE_TI_ARGS (tmpl1));
	if (targs)
	++winner;
	--processing_template_decl;

	return winner;
	}

	/* Return the template arguments that will produce the function signature
	DECL from the function template FN, with the explicit template
	arguments EXPLICIT_ARGS. If CHECK_RETTYPE is true, the return type must
	also match. Return NULL_TREE if no satisfactory arguments could be
	found. */

	static tree
	get_bindings (tree fn, tree decl, tree explicit_args, bool check_rettype)
	{
	int ntparms = DECL_NTPARMS (fn);
	tree targs = make_tree_vec (ntparms);
	tree decl_type;
	tree decl_arg_types;

	/* Substitute the explicit template arguments into the type of DECL.
	The call to fn_type_unification will handle substitution into the
	FN. */
	decl_type = TREE_TYPE (decl);
	if (explicit_args && uses_template_parms (decl_type))
	{
	tree tmpl;
	tree converted_args;

	if (DECL_TEMPLATE_INFO (decl))
	tmpl = DECL_TI_TEMPLATE (decl);
	else
	/* We can get here for some invalid specializations. */
	return NULL_TREE;

	converted_args
	= coerce_template_parms (DECL_INNERMOST_TEMPLATE_PARMS (tmpl),
	explicit_args, NULL_TREE,
	tf_none,
	/require_all_args=/false,
	/use_default_args=/false);
	if (converted_args == error_mark_node)
	return NULL_TREE;

	decl_type = tsubst (decl_type, converted_args, tf_none, NULL_TREE);
	if (decl_type == error_mark_node)
	return NULL_TREE;
	}

	/* Never do unification on the 'this' parameter. */
	decl_arg_types = skip_artificial_parms_for (decl,
	TYPE_ARG_TYPES (decl_type));

	if (fn_type_unification (fn, explicit_args, targs,
	decl_arg_types,
	(check_rettype \|\| DECL_CONV_FN_P (fn)
	? TREE_TYPE (decl_type) : NULL_TREE),
	DEDUCE_EXACT, LOOKUP_NORMAL))
	return NULL_TREE;

	return targs;
	}

	/* Return the innermost template arguments that, when applied to a
	template specialization whose innermost template parameters are
	TPARMS, and whose specialization arguments are PARMS, yield the
	ARGS.

	For example, suppose we have:

	template <class T, class U> struct S {};
	template <class T> struct S<T*, int> {};

	Then, suppose we want to get `S<double*, int>'. The TPARMS will be
	{T}, the SPEC_ARGS will be {T, int} and the ARGS will be {double,
	int}. The resulting vector will be {double}, indicating that `T'
	is bound to `double'. */

	static tree
	get_class_bindings (tree tparms, tree spec_args, tree args)
	{
	int i, ntparms = TREE_VEC_LENGTH (tparms);
	tree deduced_args;
	tree innermost_deduced_args;

	innermost_deduced_args = make_tree_vec (ntparms);
	if (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (args))
	{
	deduced_args = copy_node (args);
	SET_TMPL_ARGS_LEVEL (deduced_args,
	TMPL_ARGS_DEPTH (deduced_args),
	innermost_deduced_args);
	}
	else
	deduced_args = innermost_deduced_args;

	if (unify (tparms, deduced_args,
	INNERMOST_TEMPLATE_ARGS (spec_args),
	INNERMOST_TEMPLATE_ARGS (args),
	UNIFY_ALLOW_NONE))
	return NULL_TREE;

	for (i = 0; i < ntparms; ++i)
	if (! TREE_VEC_ELT (innermost_deduced_args, i))
	return NULL_TREE;

	/* Verify that nondeduced template arguments agree with the type
	obtained from argument deduction.

	For example:

	struct A { typedef int X; };
	template <class T, class U> struct C {};
	template <class T> struct C<T, typename T::X> {};

	Then with the instantiation `C<A, int>', we can deduce that
	`T' is `A' but unify () does not check whether `typename T::X'
	is `int'. */
	spec_args = tsubst (spec_args, deduced_args, tf_none, NULL_TREE);
	if (spec_args == error_mark_node
	/* We only need to check the innermost arguments; the other
	arguments will always agree. */
	\|\| !comp_template_args (INNERMOST_TEMPLATE_ARGS (spec_args),
	INNERMOST_TEMPLATE_ARGS (args)))
	return NULL_TREE;

	return deduced_args;
	}

	/* TEMPLATES is a TREE_LIST. Each TREE_VALUE is a TEMPLATE_DECL.
	Return the TREE_LIST node with the most specialized template, if
	any. If there is no most specialized template, the error_mark_node
	is returned.

	Note that this function does not look at, or modify, the
	TREE_PURPOSE or TREE_TYPE of any of the nodes. Since the node
	returned is one of the elements of INSTANTIATIONS, callers may
	store information in the TREE_PURPOSE or TREE_TYPE of the nodes,
	and retrieve it from the value returned. */

	tree
	most_specialized_instantiation (tree templates)
	{
	tree fn, champ;

	++processing_template_decl;

	champ = templates;
	for (fn = TREE_CHAIN (templates); fn; fn = TREE_CHAIN (fn))
	{
	int fate = 0;

	if (get_bindings (TREE_VALUE (champ),
	DECL_TEMPLATE_RESULT (TREE_VALUE (fn)),
	NULL_TREE, /check_ret=/false))
	fate--;

	if (get_bindings (TREE_VALUE (fn),
	DECL_TEMPLATE_RESULT (TREE_VALUE (champ)),
	NULL_TREE, /check_ret=/false))
	fate++;

	if (fate == -1)
	champ = fn;
	else if (!fate)
	{
	/* Equally specialized, move to next function. If there
	is no next function, nothing's most specialized. */
	fn = TREE_CHAIN (fn);
	champ = fn;
	if (!fn)
	break;
	}
	}

	if (champ)
	/* Now verify that champ is better than everything earlier in the
	instantiation list. */
	for (fn = templates; fn != champ; fn = TREE_CHAIN (fn))
	if (get_bindings (TREE_VALUE (champ),
	DECL_TEMPLATE_RESULT (TREE_VALUE (fn)),
	NULL_TREE, /check_ret=/false)
	\|\| !get_bindings (TREE_VALUE (fn),
	DECL_TEMPLATE_RESULT (TREE_VALUE (champ)),
	NULL_TREE, /check_ret=/false))
	{
	champ = NULL_TREE;
	break;
	}

	processing_template_decl--;

	if (!champ)
	return error_mark_node;

	return champ;
	}

	/* If DECL is a specialization of some template, return the most
	general such template. Otherwise, returns NULL_TREE.

	For example, given:

	template <class T> struct S { template <class U> void f(U); };

	if TMPL is `template <class U> void S<int>::f(U)' this will return
	the full template. This function will not trace past partial
	specializations, however. For example, given in addition:

	template <class T> struct S<T*> { template <class U> void f(U); };

	if TMPL is `template <class U> void S<int*>::f(U)' this will return
	`template <class T> template <class U> S<T>::f(U)'. /

	tree
	most_general_template (tree decl)
	{
	/* If DECL is a FUNCTION_DECL, find the TEMPLATE_DECL of which it is
	an immediate specialization. */
	if (TREE_CODE (decl) == FUNCTION_DECL)
	{
	if (DECL_TEMPLATE_INFO (decl)) {
	decl = DECL_TI_TEMPLATE (decl);

	/* The DECL_TI_TEMPLATE can be an IDENTIFIER_NODE for a
	template friend. */
	if (TREE_CODE (decl) != TEMPLATE_DECL)
	return NULL_TREE;
	} else
	return NULL_TREE;
	}

	/* Look for more and more general templates. */
	while (DECL_TEMPLATE_INFO (decl))
	{
	/* The DECL_TI_TEMPLATE can be an IDENTIFIER_NODE in some cases.
	(See cp-tree.h for details.) */
	if (TREE_CODE (DECL_TI_TEMPLATE (decl)) != TEMPLATE_DECL)
	break;

	if (CLASS_TYPE_P (TREE_TYPE (decl))
	&& CLASSTYPE_TEMPLATE_SPECIALIZATION (TREE_TYPE (decl)))
	break;

	/* Stop if we run into an explicitly specialized class template. */
	if (!DECL_NAMESPACE_SCOPE_P (decl)
	&& DECL_CONTEXT (decl)
	&& CLASSTYPE_TEMPLATE_SPECIALIZATION (DECL_CONTEXT (decl)))
	break;

	decl = DECL_TI_TEMPLATE (decl);
	}

	return decl;
	}

	/* Return the most specialized of the class template partial
	specializations of TMPL which can produce TYPE, a specialization of
	TMPL. The value returned is actually a TREE_LIST; the TREE_TYPE is
	a _TYPE node corresponding to the partial specialization, while the
	TREE_PURPOSE is the set of template arguments that must be
	substituted into the TREE_TYPE in order to generate TYPE.

	If the choice of partial specialization is ambiguous, a diagnostic
	is issued, and the error_mark_node is returned. If there are no
	partial specializations of TMPL matching TYPE, then NULL_TREE is
	returned. */

	static tree
	most_specialized_class (tree type, tree tmpl)
	{
	tree list = NULL_TREE;
	tree t;
	tree champ;
	int fate;
	bool ambiguous_p;
	tree args;

	tmpl = most_general_template (tmpl);
	args = CLASSTYPE_TI_ARGS (type);
	for (t = DECL_TEMPLATE_SPECIALIZATIONS (tmpl); t; t = TREE_CHAIN (t))
	{
	tree partial_spec_args;
	tree spec_args;

	partial_spec_args = CLASSTYPE_TI_ARGS (TREE_TYPE (t));
	spec_args = get_class_bindings (TREE_VALUE (t),
	partial_spec_args,
	args);
	if (spec_args)
	{
	list = tree_cons (spec_args, TREE_VALUE (t), list);
	TREE_TYPE (list) = TREE_TYPE (t);
	}
	}

	if (! list)
	return NULL_TREE;

	ambiguous_p = false;
	t = list;
	champ = t;
	t = TREE_CHAIN (t);
	for (; t; t = TREE_CHAIN (t))
	{
	fate = more_specialized_class (champ, t);
	if (fate == 1)
	;
	else
	{
	if (fate == 0)
	{
	t = TREE_CHAIN (t);
	if (! t)
	{
	ambiguous_p = true;
	break;
	}
	}
	champ = t;
	}
	}

	if (!ambiguous_p)
	for (t = list; t && t != champ; t = TREE_CHAIN (t))
	{
	fate = more_specialized_class (champ, t);
	if (fate != 1)
	{
	ambiguous_p = true;
	break;
	}
	}

	if (ambiguous_p)
	{
	const char *str = "candidates are:";
	error ("ambiguous class template instantiation for %q#T", type);
	for (t = list; t; t = TREE_CHAIN (t))
	{
	error ("%s %+#T", str, TREE_TYPE (t));
	str = " ";
	}
	return error_mark_node;
	}

	return champ;
	}

	/* Explicitly instantiate DECL. */

	void
	do_decl_instantiation (tree decl, tree storage)
	{
	tree result = NULL_TREE;
	int extern_p = 0;

	if (!decl \|\| decl == error_mark_node)
	/* An error occurred, for which grokdeclarator has already issued
	an appropriate message. */
	return;
	else if (! DECL_LANG_SPECIFIC (decl))
	{
	error ("explicit instantiation of non-template %q#D", decl);
	return;
	}
	else if (TREE_CODE (decl) == VAR_DECL)
	{
	/* There is an asymmetry here in the way VAR_DECLs and
	FUNCTION_DECLs are handled by grokdeclarator. In the case of
	the latter, the DECL we get back will be marked as a
	template instantiation, and the appropriate
	DECL_TEMPLATE_INFO will be set up. This does not happen for
	VAR_DECLs so we do the lookup here. Probably, grokdeclarator
	should handle VAR_DECLs as it currently handles
	FUNCTION_DECLs. */
	result = lookup_field (DECL_CONTEXT (decl), DECL_NAME (decl), 0, false);
	if (!result \|\| TREE_CODE (result) != VAR_DECL)
	{
	error ("no matching template for %qD found", decl);
	return;
	}
	}
	else if (TREE_CODE (decl) != FUNCTION_DECL)
	{
	error ("explicit instantiation of %q#D", decl);
	return;
	}
	else
	result = decl;

	/* Check for various error cases. Note that if the explicit
	instantiation is valid the RESULT will currently be marked as an
	implicit instantiation; DECL_EXPLICIT_INSTANTIATION is not set
	until we get here. */

	if (DECL_TEMPLATE_SPECIALIZATION (result))
	{
	/* DR 259 [temp.spec].

	Both an explicit instantiation and a declaration of an explicit
	specialization shall not appear in a program unless the explicit
	instantiation follows a declaration of the explicit specialization.

	For a given set of template parameters, if an explicit
	instantiation of a template appears after a declaration of an
	explicit specialization for that template, the explicit
	instantiation has no effect. */
	return;
	}
	else if (DECL_EXPLICIT_INSTANTIATION (result))
	{
	/* [temp.spec]

	No program shall explicitly instantiate any template more
	than once.

	We check DECL_NOT_REALLY_EXTERN so as not to complain when
	the first instantiation was `extern' and the second is not,
	and EXTERN_P for the opposite case. */
	if (DECL_NOT_REALLY_EXTERN (result) && !extern_p)
	pedwarn ("duplicate explicit instantiation of %q#D", result);
	/* If an "extern" explicit instantiation follows an ordinary
	explicit instantiation, the template is instantiated. */
	if (extern_p)
	return;
	}
	else if (!DECL_IMPLICIT_INSTANTIATION (result))
	{
	error ("no matching template for %qD found", result);
	return;
	}
	else if (!DECL_TEMPLATE_INFO (result))
	{
	pedwarn ("explicit instantiation of non-template %q#D", result);
	return;
	}

	if (storage == NULL_TREE)
	;
	else if (storage == ridpointers[(int) RID_EXTERN])
	{
	if (pedantic && !in_system_header)
	pedwarn ("ISO C++ forbids the use of %<extern%> on explicit "
	"instantiations");
	extern_p = 1;
	}
	else
	error ("storage class %qD applied to template instantiation", storage);

	check_explicit_instantiation_namespace (result);
	mark_decl_instantiated (result, extern_p);
	if (! extern_p)
	instantiate_decl (result, /defer_ok=/1,
	/expl_inst_class_mem_p=/false);
	}

	static void
	mark_class_instantiated (tree t, int extern_p)
	{
	SET_CLASSTYPE_EXPLICIT_INSTANTIATION (t);
	SET_CLASSTYPE_INTERFACE_KNOWN (t);
	CLASSTYPE_INTERFACE_ONLY (t) = extern_p;
	TYPE_DECL_SUPPRESS_DEBUG (TYPE_NAME (t)) = extern_p;
	if (! extern_p)
	{
	CLASSTYPE_DEBUG_REQUESTED (t) = 1;
	rest_of_type_compilation (t, 1);
	}
	}

	/* Called from do_type_instantiation through binding_table_foreach to
	do recursive instantiation for the type bound in ENTRY. */
	static void
	bt_instantiate_type_proc (binding_entry entry, void *data)
	{
	tree storage = (tree ) data;

	if (IS_AGGR_TYPE (entry->type)
	&& !uses_template_parms (CLASSTYPE_TI_ARGS (entry->type)))
	do_type_instantiation (TYPE_MAIN_DECL (entry->type), storage, 0);
	}

	/* Called from do_type_instantiation to instantiate a member
	(a member function or a static member variable) of an
	explicitly instantiated class template. */
	static void
	instantiate_class_member (tree decl, int extern_p)
	{
	mark_decl_instantiated (decl, extern_p);
	if (! extern_p)
	instantiate_decl (decl, /defer_ok=/1,
	/expl_inst_class_mem_p=/true);
	}

	/* Perform an explicit instantiation of template class T. STORAGE, if
	non-null, is the RID for extern, inline or static. COMPLAIN is
	nonzero if this is called from the parser, zero if called recursively,
	since the standard is unclear (as detailed below). */

	void
	do_type_instantiation (tree t, tree storage, tsubst_flags_t complain)
	{
	int extern_p = 0;
	int nomem_p = 0;
	int static_p = 0;
	int previous_instantiation_extern_p = 0;

	if (TREE_CODE (t) == TYPE_DECL)
	t = TREE_TYPE (t);

	if (! CLASS_TYPE_P (t) \|\| ! CLASSTYPE_TEMPLATE_INFO (t))
	{
	error ("explicit instantiation of non-template type %qT", t);
	return;
	}

	complete_type (t);

	if (!COMPLETE_TYPE_P (t))
	{
	if (complain & tf_error)
	error ("explicit instantiation of %q#T before definition of template",
	t);
	return;
	}

	if (storage != NULL_TREE)
	{
	if (pedantic && !in_system_header)
	pedwarn("ISO C++ forbids the use of %qE on explicit instantiations",
	storage);

	if (storage == ridpointers[(int) RID_INLINE])
	nomem_p = 1;
	else if (storage == ridpointers[(int) RID_EXTERN])
	extern_p = 1;
	else if (storage == ridpointers[(int) RID_STATIC])
	static_p = 1;
	else
	{
	error ("storage class %qD applied to template instantiation",
	storage);
	extern_p = 0;
	}
	}

	if (CLASSTYPE_TEMPLATE_SPECIALIZATION (t))
	{
	/* DR 259 [temp.spec].

	Both an explicit instantiation and a declaration of an explicit
	specialization shall not appear in a program unless the explicit
	instantiation follows a declaration of the explicit specialization.

	For a given set of template parameters, if an explicit
	instantiation of a template appears after a declaration of an
	explicit specialization for that template, the explicit
	instantiation has no effect. */
	return;
	}
	else if (CLASSTYPE_EXPLICIT_INSTANTIATION (t))
	{
	/* [temp.spec]

	No program shall explicitly instantiate any template more
	than once.

	If PREVIOUS_INSTANTIATION_EXTERN_P, then the first explicit
	instantiation was `extern'. If EXTERN_P then the second is.
	These cases are OK. */
	previous_instantiation_extern_p = CLASSTYPE_INTERFACE_ONLY (t);

	if (!previous_instantiation_extern_p && !extern_p
	&& (complain & tf_error))
	pedwarn ("duplicate explicit instantiation of %q#T", t);

	/* If we've already instantiated the template, just return now. */
	if (!CLASSTYPE_INTERFACE_ONLY (t))
	return;
	}

	check_explicit_instantiation_namespace (TYPE_NAME (t));
	mark_class_instantiated (t, extern_p);

	if (nomem_p)
	return;

	{
	tree tmp;

	/* In contrast to implicit instantiation, where only the
	declarations, and not the definitions, of members are
	instantiated, we have here:

	[temp.explicit]

	The explicit instantiation of a class template specialization
	implies the instantiation of all of its members not
	previously explicitly specialized in the translation unit
	containing the explicit instantiation.

	Of course, we can't instantiate member template classes, since
	we don't have any arguments for them. Note that the standard
	is unclear on whether the instantiation of the members are
	explicit instantiations or not. However, the most natural
	interpretation is that it should be an explicit instantiation. */

	if (! static_p)
	for (tmp = TYPE_METHODS (t); tmp; tmp = TREE_CHAIN (tmp))
	if (TREE_CODE (tmp) == FUNCTION_DECL
	&& DECL_TEMPLATE_INSTANTIATION (tmp))
	instantiate_class_member (tmp, extern_p);

	for (tmp = TYPE_FIELDS (t); tmp; tmp = TREE_CHAIN (tmp))
	if (TREE_CODE (tmp) == VAR_DECL && DECL_TEMPLATE_INSTANTIATION (tmp))
	instantiate_class_member (tmp, extern_p);

	if (CLASSTYPE_NESTED_UTDS (t))
	binding_table_foreach (CLASSTYPE_NESTED_UTDS (t),
	bt_instantiate_type_proc, &storage);
	}
	}

	/* Given a function DECL, which is a specialization of TMPL, modify
	DECL to be a re-instantiation of TMPL with the same template
	arguments. TMPL should be the template into which tsubst'ing
	should occur for DECL, not the most general template.

	One reason for doing this is a scenario like this:

	template <class T>
	void f(const T&, int i);

	void g() { f(3, 7); }

	template <class T>
	void f(const T& t, const int i) { }

	Note that when the template is first instantiated, with
	instantiate_template, the resulting DECL will have no name for the
	first parameter, and the wrong type for the second. So, when we go
	to instantiate the DECL, we regenerate it. */

	static void
	regenerate_decl_from_template (tree decl, tree tmpl)
	{
	/* The arguments used to instantiate DECL, from the most general
	template. */
	tree args;
	tree code_pattern;

	args = DECL_TI_ARGS (decl);
	code_pattern = DECL_TEMPLATE_RESULT (tmpl);

	/* Make sure that we can see identifiers, and compute access
	correctly. */
	push_access_scope (decl);

	if (TREE_CODE (decl) == FUNCTION_DECL)
	{
	tree decl_parm;
	tree pattern_parm;
	tree specs;
	int args_depth;
	int parms_depth;

	args_depth = TMPL_ARGS_DEPTH (args);
	parms_depth = TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (tmpl));
	if (args_depth > parms_depth)
	args = get_innermost_template_args (args, parms_depth);

	specs = tsubst_exception_specification (TREE_TYPE (code_pattern),
	args, tf_error, NULL_TREE);
	if (specs)
	TREE_TYPE (decl) = build_exception_variant (TREE_TYPE (decl),
	specs);

	/* Merge parameter declarations. */
	decl_parm = skip_artificial_parms_for (decl,
	DECL_ARGUMENTS (decl));
	pattern_parm
	= skip_artificial_parms_for (code_pattern,
	DECL_ARGUMENTS (code_pattern));
	while (decl_parm)
	{
	tree parm_type;
	tree attributes;

	if (DECL_NAME (decl_parm) != DECL_NAME (pattern_parm))
	DECL_NAME (decl_parm) = DECL_NAME (pattern_parm);
	parm_type = tsubst (TREE_TYPE (pattern_parm), args, tf_error,
	NULL_TREE);
	parm_type = type_decays_to (parm_type);
	if (!same_type_p (TREE_TYPE (decl_parm), parm_type))
	TREE_TYPE (decl_parm) = parm_type;
	attributes = DECL_ATTRIBUTES (pattern_parm);
	if (DECL_ATTRIBUTES (decl_parm) != attributes)
	{
	DECL_ATTRIBUTES (decl_parm) = attributes;
	cplus_decl_attributes (&decl_parm, attributes, /flags=/0);
	}
	decl_parm = TREE_CHAIN (decl_parm);
	pattern_parm = TREE_CHAIN (pattern_parm);
	}

	/* Merge additional specifiers from the CODE_PATTERN. */
	if (DECL_DECLARED_INLINE_P (code_pattern)
	&& !DECL_DECLARED_INLINE_P (decl))
	DECL_DECLARED_INLINE_P (decl) = 1;
	if (DECL_INLINE (code_pattern) && !DECL_INLINE (decl))
	DECL_INLINE (decl) = 1;
	}
	else if (TREE_CODE (decl) == VAR_DECL)
	DECL_INITIAL (decl) =
	tsubst_expr (DECL_INITIAL (code_pattern), args,
	tf_error, DECL_TI_TEMPLATE (decl),
	/integral_constant_expression_p=/false);
	else
	gcc_unreachable ();

	pop_access_scope (decl);
	}

	/* Return the TEMPLATE_DECL into which DECL_TI_ARGS(DECL) should be
	substituted to get DECL. */

	tree
	template_for_substitution (tree decl)
	{
	tree tmpl = DECL_TI_TEMPLATE (decl);

	/* Set TMPL to the template whose DECL_TEMPLATE_RESULT is the pattern
	for the instantiation. This is not always the most general
	template. Consider, for example:

	template <class T>
	struct S { template <class U> void f();
	template <> void f<int>(); };

	and an instantiation of S<double>::f<int>. We want TD to be the
	specialization S<T>::f<int>, not the more general S<T>::f<U>. */
	while (/* An instantiation cannot have a definition, so we need a
	more general template. */
	DECL_TEMPLATE_INSTANTIATION (tmpl)
	/* We must also deal with friend templates. Given:

	template <class T> struct S {
	template <class U> friend void f() {};
	};

	S<int>::f<U> say, is not an instantiation of S<T>::f<U>,
	so far as the language is concerned, but that's still
	where we get the pattern for the instantiation from. On
	other hand, if the definition comes outside the class, say:

	template <class T> struct S {
	template <class U> friend void f();
	};
	template <class U> friend void f() {}

	we don't need to look any further. That's what the check for
	DECL_INITIAL is for. */
	\|\| (TREE_CODE (decl) == FUNCTION_DECL
	&& DECL_FRIEND_PSEUDO_TEMPLATE_INSTANTIATION (tmpl)
	&& !DECL_INITIAL (DECL_TEMPLATE_RESULT (tmpl))))
	{
	/* The present template, TD, should not be a definition. If it
	were a definition, we should be using it! Note that we
	cannot restructure the loop to just keep going until we find
	a template with a definition, since that might go too far if
	a specialization was declared, but not defined. */
	gcc_assert (TREE_CODE (decl) != VAR_DECL
	\|\| DECL_IN_AGGR_P (DECL_TEMPLATE_RESULT (tmpl)));

	/* Fetch the more general template. */
	tmpl = DECL_TI_TEMPLATE (tmpl);
	}

	return tmpl;
	}

	/* Produce the definition of D, a _DECL generated from a template. If
	DEFER_OK is nonzero, then we don't have to actually do the
	instantiation now; we just have to do it sometime. Normally it is
	an error if this is an explicit instantiation but D is undefined.
	EXPL_INST_CLASS_MEM_P is true iff D is a member of an
	explicitly instantiated class template. */

	tree
	instantiate_decl (tree d, int defer_ok,
	bool expl_inst_class_mem_p)
	{
	tree tmpl = DECL_TI_TEMPLATE (d);
	tree gen_args;
	tree args;
	tree td;
	tree code_pattern;
	tree spec;
	tree gen_tmpl;
	bool pattern_defined;
	int need_push;
	location_t saved_loc = input_location;
	int saved_in_system_header = in_system_header;
	bool external_p;

	/* This function should only be used to instantiate templates for
	functions and static member variables. */
	gcc_assert (TREE_CODE (d) == FUNCTION_DECL
	\|\| TREE_CODE (d) == VAR_DECL);

	/* Variables are never deferred; if instantiation is required, they
	are instantiated right away. That allows for better code in the
	case that an expression refers to the value of the variable --
	if the variable has a constant value the referring expression can
	take advantage of that fact. */
	if (TREE_CODE (d) == VAR_DECL)
	defer_ok = 0;

	/* Don't instantiate cloned functions. Instead, instantiate the
	functions they cloned. */
	if (TREE_CODE (d) == FUNCTION_DECL && DECL_CLONED_FUNCTION_P (d))
	d = DECL_CLONED_FUNCTION (d);

	if (DECL_TEMPLATE_INSTANTIATED (d))
	/* D has already been instantiated. It might seem reasonable to
	check whether or not D is an explicit instantiation, and, if so,
	stop here. But when an explicit instantiation is deferred
	until the end of the compilation, DECL_EXPLICIT_INSTANTIATION
	is set, even though we still need to do the instantiation. */
	return d;

	/* If we already have a specialization of this declaration, then
	there's no reason to instantiate it. Note that
	retrieve_specialization gives us both instantiations and
	specializations, so we must explicitly check
	DECL_TEMPLATE_SPECIALIZATION. */
	gen_tmpl = most_general_template (tmpl);
	gen_args = DECL_TI_ARGS (d);
	spec = retrieve_specialization (gen_tmpl, gen_args,
	/class_specializations_p=/false);
	if (spec != NULL_TREE && DECL_TEMPLATE_SPECIALIZATION (spec))
	return spec;

	/* This needs to happen before any tsubsting. */
	if (! push_tinst_level (d))
	return d;

	timevar_push (TV_PARSE);

	/* Set TD to the template whose DECL_TEMPLATE_RESULT is the pattern
	for the instantiation. */
	td = template_for_substitution (d);
	code_pattern = DECL_TEMPLATE_RESULT (td);

	/* We should never be trying to instantiate a member of a class
	template or partial specialization. */
	gcc_assert (d != code_pattern);

	if ((DECL_NAMESPACE_SCOPE_P (d) && !DECL_INITIALIZED_IN_CLASS_P (d))
	\|\| DECL_TEMPLATE_SPECIALIZATION (td))
	/* In the case of a friend template whose definition is provided
	outside the class, we may have too many arguments. Drop the
	ones we don't need. The same is true for specializations. */
	args = get_innermost_template_args
	(gen_args, TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (td)));
	else
	args = gen_args;

	if (TREE_CODE (d) == FUNCTION_DECL)
	pattern_defined = (DECL_SAVED_TREE (code_pattern) != NULL_TREE);
	else
	pattern_defined = ! DECL_IN_AGGR_P (code_pattern);

	/* We may be in the middle of deferred access check. Disable it now. */
	push_deferring_access_checks (dk_no_deferred);

	/* Unless an explicit instantiation directive has already determined
	the linkage of D, remember that a definition is available for
	this entity. */
	if (pattern_defined
	&& !DECL_INTERFACE_KNOWN (d)
	&& !DECL_NOT_REALLY_EXTERN (d))
	mark_definable (d);

	input_location = DECL_SOURCE_LOCATION (d);
	in_system_header = DECL_IN_SYSTEM_HEADER (d);

	/* If D is a member of an explicitly instantiated class template,
	and no definition is available, treat it like an implicit
	instantiation. */
	if (!pattern_defined && expl_inst_class_mem_p
	&& DECL_EXPLICIT_INSTANTIATION (d))
	{
	DECL_NOT_REALLY_EXTERN (d) = 0;
	DECL_INTERFACE_KNOWN (d) = 0;
	SET_DECL_IMPLICIT_INSTANTIATION (d);
	}

	if (!defer_ok)
	{
	/* Recheck the substitutions to obtain any warning messages
	about ignoring cv qualifiers. */
	tree gen = DECL_TEMPLATE_RESULT (gen_tmpl);
	tree type = TREE_TYPE (gen);

	/* Make sure that we can see identifiers, and compute access
	correctly. D is already the target FUNCTION_DECL with the
	right context. */
	push_access_scope (d);

	if (TREE_CODE (gen) == FUNCTION_DECL)
	{
	tsubst (DECL_ARGUMENTS (gen), gen_args, tf_warning_or_error, d);
	tsubst (TYPE_RAISES_EXCEPTIONS (type), gen_args,
	tf_warning_or_error, d);
	/* Don't simply tsubst the function type, as that will give
	duplicate warnings about poor parameter qualifications.
	The function arguments are the same as the decl_arguments
	without the top level cv qualifiers. */
	type = TREE_TYPE (type);
	}
	tsubst (type, gen_args, tf_warning_or_error, d);

	pop_access_scope (d);
	}

	/* Check to see whether we know that this template will be
	instantiated in some other file, as with "extern template"
	extension. */
	external_p = (DECL_INTERFACE_KNOWN (d) && DECL_REALLY_EXTERN (d));
	/* In general, we do not instantiate such templates... */
	if (external_p
	/* ... but we instantiate inline functions so that we can inline
	them and ... */
	&& ! (TREE_CODE (d) == FUNCTION_DECL && DECL_INLINE (d))
	/* ... we instantiate static data members whose values are
	needed in integral constant expressions. */
	&& ! (TREE_CODE (d) == VAR_DECL
	&& DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (d)))
	goto out;
	/* Defer all other templates, unless we have been explicitly
	forbidden from doing so. */
	if (/* If there is no definition, we cannot instantiate the
	template. */
	! pattern_defined
	/* If it's OK to postpone instantiation, do so. */
	\|\| defer_ok
	/* If this is a static data member that will be defined
	elsewhere, we don't want to instantiate the entire data
	member, but we do want to instantiate the initializer so that
	we can substitute that elsewhere. */
	\|\| (external_p && TREE_CODE (d) == VAR_DECL))
	{
	/* The definition of the static data member is now required so
	we must substitute the initializer. */
	if (TREE_CODE (d) == VAR_DECL
	&& !DECL_INITIAL (d)
	&& DECL_INITIAL (code_pattern))
	{
	tree ns;
	tree init;

	ns = decl_namespace_context (d);
	push_nested_namespace (ns);
	push_nested_class (DECL_CONTEXT (d));
	init = tsubst_expr (DECL_INITIAL (code_pattern),
	args,
	tf_warning_or_error, NULL_TREE,
	/integral_constant_expression_p=/false);
	cp_finish_decl (d, init, /init_const_expr_p=/false,
	/asmspec_tree=/NULL_TREE,
	LOOKUP_ONLYCONVERTING);
	pop_nested_class ();
	pop_nested_namespace (ns);
	}

	/* We restore the source position here because it's used by
	add_pending_template. */
	input_location = saved_loc;

	if (at_eof && !pattern_defined
	&& DECL_EXPLICIT_INSTANTIATION (d))
	/* [temp.explicit]

	The definition of a non-exported function template, a
	non-exported member function template, or a non-exported
	member function or static data member of a class template
	shall be present in every translation unit in which it is
	explicitly instantiated. */
	pedwarn
	("explicit instantiation of %qD but no definition available", d);

	/* ??? Historically, we have instantiated inline functions, even
	when marked as "extern template". */
	if (!(external_p && TREE_CODE (d) == VAR_DECL))
	add_pending_template (d);
	goto out;
	}
	/* Tell the repository that D is available in this translation unit
	-- and see if it is supposed to be instantiated here. */
	if (TREE_PUBLIC (d) && !DECL_REALLY_EXTERN (d) && !repo_emit_p (d))
	{
	/* In a PCH file, despite the fact that the repository hasn't
	requested instantiation in the PCH it is still possible that
	an instantiation will be required in a file that includes the
	PCH. */
	if (pch_file)
	add_pending_template (d);
	/* Instantiate inline functions so that the inliner can do its
	job, even though we'll not be emitting a copy of this
	function. */
	if (!(TREE_CODE (d) == FUNCTION_DECL
	&& flag_inline_trees
	&& DECL_DECLARED_INLINE_P (d)))
	goto out;
	}

	need_push = !cfun \|\| !global_bindings_p ();
	if (need_push)
	push_to_top_level ();

	/* Mark D as instantiated so that recursive calls to
	instantiate_decl do not try to instantiate it again. */
	DECL_TEMPLATE_INSTANTIATED (d) = 1;

	/* Regenerate the declaration in case the template has been modified
	by a subsequent redeclaration. */
	regenerate_decl_from_template (d, td);

	/* We already set the file and line above. Reset them now in case
	they changed as a result of calling regenerate_decl_from_template. */
	input_location = DECL_SOURCE_LOCATION (d);

	if (TREE_CODE (d) == VAR_DECL)
	{
	tree init;

	/* Clear out DECL_RTL; whatever was there before may not be right
	since we've reset the type of the declaration. */
	SET_DECL_RTL (d, NULL_RTX);
	DECL_IN_AGGR_P (d) = 0;

	/* The initializer is placed in DECL_INITIAL by
	regenerate_decl_from_template. Pull it out so that
	finish_decl can process it. */
	init = DECL_INITIAL (d);
	DECL_INITIAL (d) = NULL_TREE;
	DECL_INITIALIZED_P (d) = 0;

	/* Clear DECL_EXTERNAL so that cp_finish_decl will process the
	initializer. That function will defer actual emission until
	we have a chance to determine linkage. */
	DECL_EXTERNAL (d) = 0;

	/* Enter the scope of D so that access-checking works correctly. */
	push_nested_class (DECL_CONTEXT (d));
	finish_decl (d, init, NULL_TREE);
	pop_nested_class ();
	}
	else if (TREE_CODE (d) == FUNCTION_DECL)
	{
	htab_t saved_local_specializations;
	tree subst_decl;
	tree tmpl_parm;
	tree spec_parm;

	/* Save away the current list, in case we are instantiating one
	template from within the body of another. */
	saved_local_specializations = local_specializations;

	/* Set up the list of local specializations. */
	local_specializations = htab_create (37,
	hash_local_specialization,
	eq_local_specializations,
	NULL);

	/* Set up context. */
	start_preparsed_function (d, NULL_TREE, SF_PRE_PARSED);

	/* Create substitution entries for the parameters. */
	subst_decl = DECL_TEMPLATE_RESULT (template_for_substitution (d));
	tmpl_parm = DECL_ARGUMENTS (subst_decl);
	spec_parm = DECL_ARGUMENTS (d);
	if (DECL_NONSTATIC_MEMBER_FUNCTION_P (d))
	{
	register_local_specialization (spec_parm, tmpl_parm);
	spec_parm = skip_artificial_parms_for (d, spec_parm);
	tmpl_parm = skip_artificial_parms_for (subst_decl, tmpl_parm);
	}
	while (tmpl_parm)
	{
	register_local_specialization (spec_parm, tmpl_parm);
	tmpl_parm = TREE_CHAIN (tmpl_parm);
	spec_parm = TREE_CHAIN (spec_parm);
	}
	gcc_assert (!spec_parm);

	/* Substitute into the body of the function. */
	tsubst_expr (DECL_SAVED_TREE (code_pattern), args,
	tf_warning_or_error, tmpl,
	/integral_constant_expression_p=/false);

	/* We don't need the local specializations any more. */
	htab_delete (local_specializations);
	local_specializations = saved_local_specializations;

	/* Finish the function. */
	d = finish_function (0);
	expand_or_defer_fn (d);
	}

	/* We're not deferring instantiation any more. */
	TI_PENDING_TEMPLATE_FLAG (DECL_TEMPLATE_INFO (d)) = 0;

	if (need_push)
	pop_from_top_level ();

	out:
	input_location = saved_loc;
	in_system_header = saved_in_system_header;
	pop_deferring_access_checks ();
	pop_tinst_level ();

	timevar_pop (TV_PARSE);

	return d;
	}

	/* Run through the list of templates that we wish we could
	instantiate, and instantiate any we can. RETRIES is the
	number of times we retry pending template instantiation. */

	void
	instantiate_pending_templates (int retries)
	{
	tree *t;
	tree last = NULL_TREE;
	int reconsider;
	location_t saved_loc = input_location;
	int saved_in_system_header = in_system_header;

	/* Instantiating templates may trigger vtable generation. This in turn
	may require further template instantiations. We place a limit here
	to avoid infinite loop. */
	if (pending_templates && retries >= max_tinst_depth)
	{
	tree decl = TREE_VALUE (pending_templates);

	error ("template instantiation depth exceeds maximum of %d"
	" instantiating %q+D, possibly from virtual table generation"
	" (use -ftemplate-depth-NN to increase the maximum)",
	max_tinst_depth, decl);
	if (TREE_CODE (decl) == FUNCTION_DECL)
	/* Pretend that we defined it. */
	DECL_INITIAL (decl) = error_mark_node;
	return;
	}

	do
	{
	reconsider = 0;

	t = &pending_templates;
	while (*t)
	{
	tree instantiation = TREE_VALUE (*t);

	reopen_tinst_level (TREE_PURPOSE (*t));

	if (TYPE_P (instantiation))
	{
	tree fn;

	if (!COMPLETE_TYPE_P (instantiation))
	{
	instantiate_class_template (instantiation);
	if (CLASSTYPE_TEMPLATE_INSTANTIATION (instantiation))
	for (fn = TYPE_METHODS (instantiation);
	fn;
	fn = TREE_CHAIN (fn))
	if (! DECL_ARTIFICIAL (fn))
	instantiate_decl (fn,
	/defer_ok=/0,
	/expl_inst_class_mem_p=/false);
	if (COMPLETE_TYPE_P (instantiation))
	reconsider = 1;
	}

	if (COMPLETE_TYPE_P (instantiation))
	/* If INSTANTIATION has been instantiated, then we don't
	need to consider it again in the future. */
	t = TREE_CHAIN (t);
	else
	{
	last = *t;
	t = &TREE_CHAIN (*t);
	}
	}
	else
	{
	if (!DECL_TEMPLATE_SPECIALIZATION (instantiation)
	&& !DECL_TEMPLATE_INSTANTIATED (instantiation))
	{
	instantiation
	= instantiate_decl (instantiation,
	/defer_ok=/0,
	/expl_inst_class_mem_p=/false);
	if (DECL_TEMPLATE_INSTANTIATED (instantiation))
	reconsider = 1;
	}

	if (DECL_TEMPLATE_SPECIALIZATION (instantiation)
	\|\| DECL_TEMPLATE_INSTANTIATED (instantiation))
	/* If INSTANTIATION has been instantiated, then we don't
	need to consider it again in the future. */
	t = TREE_CHAIN (t);
	else
	{
	last = *t;
	t = &TREE_CHAIN (*t);
	}
	}
	tinst_depth = 0;
	current_tinst_level = NULL_TREE;
	}
	last_pending_template = last;
	}
	while (reconsider);

	input_location = saved_loc;
	in_system_header = saved_in_system_header;
	}

	/* Substitute ARGVEC into T, which is a list of initializers for
	either base class or a non-static data member. The TREE_PURPOSEs
	are DECLs, and the TREE_VALUEs are the initializer values. Used by
	instantiate_decl. */

	static tree
	tsubst_initializer_list (tree t, tree argvec)
	{
	tree inits = NULL_TREE;

	for (; t; t = TREE_CHAIN (t))
	{
	tree decl;
	tree init;

	decl = tsubst_copy (TREE_PURPOSE (t), argvec, tf_warning_or_error,
	NULL_TREE);
	decl = expand_member_init (decl);
	if (decl && !DECL_P (decl))
	in_base_initializer = 1;

	init = tsubst_expr (TREE_VALUE (t), argvec, tf_warning_or_error,
	NULL_TREE,
	/integral_constant_expression_p=/false);
	in_base_initializer = 0;

	if (decl)
	{
	init = build_tree_list (decl, init);
	TREE_CHAIN (init) = inits;
	inits = init;
	}
	}
	return inits;
	}

	/* Set CURRENT_ACCESS_SPECIFIER based on the protection of DECL. */

	static void
	set_current_access_from_decl (tree decl)
	{
	if (TREE_PRIVATE (decl))
	current_access_specifier = access_private_node;
	else if (TREE_PROTECTED (decl))
	current_access_specifier = access_protected_node;
	else
	current_access_specifier = access_public_node;
	}

	/* Instantiate an enumerated type. TAG is the template type, NEWTAG
	is the instantiation (which should have been created with
	start_enum) and ARGS are the template arguments to use. */

	static void
	tsubst_enum (tree tag, tree newtag, tree args)
	{
	tree e;

	for (e = TYPE_VALUES (tag); e; e = TREE_CHAIN (e))
	{
	tree value;
	tree decl;

	decl = TREE_VALUE (e);
	/* Note that in a template enum, the TREE_VALUE is the
	CONST_DECL, not the corresponding INTEGER_CST. */
	value = tsubst_expr (DECL_INITIAL (decl),
	args, tf_warning_or_error, NULL_TREE,
	/integral_constant_expression_p=/true);

	/* Give this enumeration constant the correct access. */
	set_current_access_from_decl (decl);

	/* Actually build the enumerator itself. */
	build_enumerator (DECL_NAME (decl), value, newtag);
	}

	finish_enum (newtag);
	DECL_SOURCE_LOCATION (TYPE_NAME (newtag))
	= DECL_SOURCE_LOCATION (TYPE_NAME (tag));
	}

	/* DECL is a FUNCTION_DECL that is a template specialization. Return
	its type -- but without substituting the innermost set of template
	arguments. So, innermost set of template parameters will appear in
	the type. */

	tree
	get_mostly_instantiated_function_type (tree decl)
	{
	tree fn_type;
	tree tmpl;
	tree targs;
	tree tparms;
	int parm_depth;

	tmpl = most_general_template (DECL_TI_TEMPLATE (decl));
	targs = DECL_TI_ARGS (decl);
	tparms = DECL_TEMPLATE_PARMS (tmpl);
	parm_depth = TMPL_PARMS_DEPTH (tparms);

	/* There should be as many levels of arguments as there are levels
	of parameters. */
	gcc_assert (parm_depth == TMPL_ARGS_DEPTH (targs));

	fn_type = TREE_TYPE (tmpl);

	if (parm_depth == 1)
	/* No substitution is necessary. */
	;
	else
	{
	int i, save_access_control;
	tree partial_args;

	/* Replace the innermost level of the TARGS with NULL_TREEs to
	let tsubst know not to substitute for those parameters. */
	partial_args = make_tree_vec (TREE_VEC_LENGTH (targs));
	for (i = 1; i < TMPL_ARGS_DEPTH (targs); ++i)
	SET_TMPL_ARGS_LEVEL (partial_args, i,
	TMPL_ARGS_LEVEL (targs, i));
	SET_TMPL_ARGS_LEVEL (partial_args,
	TMPL_ARGS_DEPTH (targs),
	make_tree_vec (DECL_NTPARMS (tmpl)));

	/* Disable access control as this function is used only during
	name-mangling. */
	save_access_control = flag_access_control;
	flag_access_control = 0;

	++processing_template_decl;
	/* Now, do the (partial) substitution to figure out the
	appropriate function type. */
	fn_type = tsubst (fn_type, partial_args, tf_error, NULL_TREE);
	--processing_template_decl;

	/* Substitute into the template parameters to obtain the real
	innermost set of parameters. This step is important if the
	innermost set of template parameters contains value
	parameters whose types depend on outer template parameters. */
	TREE_VEC_LENGTH (partial_args)--;
	tparms = tsubst_template_parms (tparms, partial_args, tf_error);

	flag_access_control = save_access_control;
	}

	return fn_type;
	}

	/* Return truthvalue if we're processing a template different from
	the last one involved in diagnostics. */
	int
	problematic_instantiation_changed (void)
	{
	return last_template_error_tick != tinst_level_tick;
	}

	/* Remember current template involved in diagnostics. */
	void
	record_last_problematic_instantiation (void)
	{
	last_template_error_tick = tinst_level_tick;
	}

	tree
	current_instantiation (void)
	{
	return current_tinst_level;
	}

	/* [temp.param] Check that template non-type parm TYPE is of an allowable
	type. Return zero for ok, nonzero for disallowed. Issue error and
	warning messages under control of COMPLAIN. */

	static int
	invalid_nontype_parm_type_p (tree type, tsubst_flags_t complain)
	{
	if (INTEGRAL_TYPE_P (type))
	return 0;
	else if (POINTER_TYPE_P (type))
	return 0;
	else if (TYPE_PTR_TO_MEMBER_P (type))
	return 0;
	else if (TREE_CODE (type) == TEMPLATE_TYPE_PARM)
	return 0;
	else if (TREE_CODE (type) == TYPENAME_TYPE)
	return 0;

	if (complain & tf_error)
	error ("%q#T is not a valid type for a template constant parameter", type);
	return 1;
	}

	/* Returns TRUE if TYPE is dependent, in the sense of [temp.dep.type].
	Assumes that TYPE really is a type, and not the ERROR_MARK_NODE.*/

	static bool
	dependent_type_p_r (tree type)
	{
	tree scope;

	/* [temp.dep.type]

	A type is dependent if it is:

	-- a template parameter. Template template parameters are types
	for us (since TYPE_P holds true for them) so we handle
	them here. */
	if (TREE_CODE (type) == TEMPLATE_TYPE_PARM
	\|\| TREE_CODE (type) == TEMPLATE_TEMPLATE_PARM)
	return true;
	/* -- a qualified-id with a nested-name-specifier which contains a
	class-name that names a dependent type or whose unqualified-id
	names a dependent type. */
	if (TREE_CODE (type) == TYPENAME_TYPE)
	return true;
	/* -- a cv-qualified type where the cv-unqualified type is
	dependent. */
	type = TYPE_MAIN_VARIANT (type);
	/* -- a compound type constructed from any dependent type. */
	if (TYPE_PTR_TO_MEMBER_P (type))
	return (dependent_type_p (TYPE_PTRMEM_CLASS_TYPE (type))
	\|\| dependent_type_p (TYPE_PTRMEM_POINTED_TO_TYPE
	(type)));
	else if (TREE_CODE (type) == POINTER_TYPE
	\|\| TREE_CODE (type) == REFERENCE_TYPE)
	return dependent_type_p (TREE_TYPE (type));
	else if (TREE_CODE (type) == FUNCTION_TYPE
	\|\| TREE_CODE (type) == METHOD_TYPE)
	{
	tree arg_type;

	if (dependent_type_p (TREE_TYPE (type)))
	return true;
	for (arg_type = TYPE_ARG_TYPES (type);
	arg_type;
	arg_type = TREE_CHAIN (arg_type))
	if (dependent_type_p (TREE_VALUE (arg_type)))
	return true;
	return false;
	}
	/* -- an array type constructed from any dependent type or whose
	size is specified by a constant expression that is
	value-dependent. */
	if (TREE_CODE (type) == ARRAY_TYPE)
	{
	if (TYPE_DOMAIN (type)
	&& ((value_dependent_expression_p
	(TYPE_MAX_VALUE (TYPE_DOMAIN (type))))
	\|\| (type_dependent_expression_p
	(TYPE_MAX_VALUE (TYPE_DOMAIN (type))))))
	return true;
	return dependent_type_p (TREE_TYPE (type));
	}

	/* -- a template-id in which either the template name is a template
	parameter ... */
	if (TREE_CODE (type) == BOUND_TEMPLATE_TEMPLATE_PARM)
	return true;
	/* ... or any of the template arguments is a dependent type or
	an expression that is type-dependent or value-dependent. */
	else if (CLASS_TYPE_P (type) && CLASSTYPE_TEMPLATE_INFO (type)
	&& (any_dependent_template_arguments_p
	(INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (type)))))
	return true;

	/* All TYPEOF_TYPEs are dependent; if the argument of the `typeof'
	expression is not type-dependent, then it should already been
	have resolved. */
	if (TREE_CODE (type) == TYPEOF_TYPE)
	return true;

	/* The standard does not specifically mention types that are local
	to template functions or local classes, but they should be
	considered dependent too. For example:

	template <int I> void f() {
	enum E { a = I };
	S<sizeof (E)> s;
	}

	The size of `E' cannot be known until the value of `I' has been
	determined. Therefore, `E' must be considered dependent. */
	scope = TYPE_CONTEXT (type);
	if (scope && TYPE_P (scope))
	return dependent_type_p (scope);
	else if (scope && TREE_CODE (scope) == FUNCTION_DECL)
	return type_dependent_expression_p (scope);

	/* Other types are non-dependent. */
	return false;
	}

	/* Returns TRUE if TYPE is dependent, in the sense of
	[temp.dep.type]. */

	bool
	dependent_type_p (tree type)
	{
	/* If there are no template parameters in scope, then there can't be
	any dependent types. */
	if (!processing_template_decl)
	{
	/* If we are not processing a template, then nobody should be
	providing us with a dependent type. */
	gcc_assert (type);
	gcc_assert (TREE_CODE (type) != TEMPLATE_TYPE_PARM);
	return false;
	}

	/* If the type is NULL, we have not computed a type for the entity
	in question; in that case, the type is dependent. */
	if (!type)
	return true;

	/* Erroneous types can be considered non-dependent. */
	if (type == error_mark_node)
	return false;

	/* If we have not already computed the appropriate value for TYPE,
	do so now. */
	if (!TYPE_DEPENDENT_P_VALID (type))
	{
	TYPE_DEPENDENT_P (type) = dependent_type_p_r (type);
	TYPE_DEPENDENT_P_VALID (type) = 1;
	}

	return TYPE_DEPENDENT_P (type);
	}

	/* Returns TRUE if EXPRESSION is dependent, according to CRITERION. */

	static bool
	dependent_scope_ref_p (tree expression, bool criterion (tree))
	{
	tree scope;
	tree name;

	gcc_assert (TREE_CODE (expression) == SCOPE_REF);

	if (!TYPE_P (TREE_OPERAND (expression, 0)))
	return true;

	scope = TREE_OPERAND (expression, 0);
	name = TREE_OPERAND (expression, 1);

	/* [temp.dep.expr]

	An id-expression is type-dependent if it contains a
	nested-name-specifier that contains a class-name that names a
	dependent type. */
	/* The suggested resolution to Core Issue 2 implies that if the
	qualifying type is the current class, then we must peek
	inside it. */
	if (DECL_P (name)
	&& currently_open_class (scope)
	&& !criterion (name))
	return false;
	if (dependent_type_p (scope))
	return true;

	return false;
	}

	/* Returns TRUE if the EXPRESSION is value-dependent, in the sense of
	[temp.dep.constexpr]. EXPRESSION is already known to be a constant
	expression. */

	bool
	value_dependent_expression_p (tree expression)
	{
	if (!processing_template_decl)
	return false;

	/* A name declared with a dependent type. */
	if (DECL_P (expression) && type_dependent_expression_p (expression))
	return true;

	switch (TREE_CODE (expression))
	{
	case IDENTIFIER_NODE:
	/* A name that has not been looked up -- must be dependent. */
	return true;

	case TEMPLATE_PARM_INDEX:
	/* A non-type template parm. */
	return true;

	case CONST_DECL:
	/* A non-type template parm. */
	if (DECL_TEMPLATE_PARM_P (expression))
	return true;
	return false;

	case VAR_DECL:
	/* A constant with integral or enumeration type and is initialized
	with an expression that is value-dependent. */
	if (DECL_INITIAL (expression)
	&& INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (expression))
	&& value_dependent_expression_p (DECL_INITIAL (expression)))
	return true;
	return false;

	case DYNAMIC_CAST_EXPR:
	case STATIC_CAST_EXPR:
	case CONST_CAST_EXPR:
	case REINTERPRET_CAST_EXPR:
	case CAST_EXPR:
	/* These expressions are value-dependent if the type to which
	the cast occurs is dependent or the expression being casted
	is value-dependent. */
	{
	tree type = TREE_TYPE (expression);

	if (dependent_type_p (type))
	return true;

	/* A functional cast has a list of operands. */
	expression = TREE_OPERAND (expression, 0);
	if (!expression)
	{
	/* If there are no operands, it must be an expression such
	as "int()". This should not happen for aggregate types
	because it would form non-constant expressions. */
	gcc_assert (INTEGRAL_OR_ENUMERATION_TYPE_P (type));

	return false;
	}

	if (TREE_CODE (expression) == TREE_LIST)
	return any_value_dependent_elements_p (expression);

	return value_dependent_expression_p (expression);
	}

	case SIZEOF_EXPR:
	case ALIGNOF_EXPR:
	/* A `sizeof' expression is value-dependent if the operand is
	type-dependent. */
	expression = TREE_OPERAND (expression, 0);
	if (TYPE_P (expression))
	return dependent_type_p (expression);
	return type_dependent_expression_p (expression);

	case SCOPE_REF:
	return dependent_scope_ref_p (expression, value_dependent_expression_p);

	case COMPONENT_REF:
	return (value_dependent_expression_p (TREE_OPERAND (expression, 0))
	\|\| value_dependent_expression_p (TREE_OPERAND (expression, 1)));

	case CALL_EXPR:
	/* A CALL_EXPR may appear in a constant expression if it is a
	call to a builtin function, e.g., __builtin_constant_p. All
	such calls are value-dependent. */
	return true;

	case MODOP_EXPR:
	return ((value_dependent_expression_p (TREE_OPERAND (expression, 0)))
	\|\| (value_dependent_expression_p (TREE_OPERAND (expression, 2))));

	default:
	/* A constant expression is value-dependent if any subexpression is
	value-dependent. */
	switch (TREE_CODE_CLASS (TREE_CODE (expression)))
	{
	case tcc_reference:
	case tcc_unary:
	return (value_dependent_expression_p
	(TREE_OPERAND (expression, 0)));

	case tcc_comparison:
	case tcc_binary:
	return ((value_dependent_expression_p
	(TREE_OPERAND (expression, 0)))
	\|\| (value_dependent_expression_p
	(TREE_OPERAND (expression, 1))));

	case tcc_expression:
	{
	int i;
	for (i = 0; i < TREE_CODE_LENGTH (TREE_CODE (expression)); ++i)
	/* In some cases, some of the operands may be missing.
	(For example, in the case of PREDECREMENT_EXPR, the
	amount to increment by may be missing.) That doesn't
	make the expression dependent. */
	if (TREE_OPERAND (expression, i)
	&& (value_dependent_expression_p
	(TREE_OPERAND (expression, i))))
	return true;
	return false;
	}

	default:
	break;
	}
	}

	/* The expression is not value-dependent. */
	return false;
	}

	/* Returns TRUE if the EXPRESSION is type-dependent, in the sense of
	[temp.dep.expr]. */

	bool
	type_dependent_expression_p (tree expression)
	{
	if (!processing_template_decl)
	return false;

	if (expression == error_mark_node)
	return false;

	/* An unresolved name is always dependent. */
	if (TREE_CODE (expression) == IDENTIFIER_NODE
	\|\| TREE_CODE (expression) == USING_DECL)
	return true;

	/* Some expression forms are never type-dependent. */
	if (TREE_CODE (expression) == PSEUDO_DTOR_EXPR
	\|\| TREE_CODE (expression) == SIZEOF_EXPR
	\|\| TREE_CODE (expression) == ALIGNOF_EXPR
	\|\| TREE_CODE (expression) == TYPEID_EXPR
	\|\| TREE_CODE (expression) == DELETE_EXPR
	\|\| TREE_CODE (expression) == VEC_DELETE_EXPR
	\|\| TREE_CODE (expression) == THROW_EXPR)
	return false;

	/* The types of these expressions depends only on the type to which
	the cast occurs. */
	if (TREE_CODE (expression) == DYNAMIC_CAST_EXPR
	\|\| TREE_CODE (expression) == STATIC_CAST_EXPR
	\|\| TREE_CODE (expression) == CONST_CAST_EXPR
	\|\| TREE_CODE (expression) == REINTERPRET_CAST_EXPR
	\|\| TREE_CODE (expression) == CAST_EXPR)
	return dependent_type_p (TREE_TYPE (expression));

	/* The types of these expressions depends only on the type created
	by the expression. */
	if (TREE_CODE (expression) == NEW_EXPR
	\|\| TREE_CODE (expression) == VEC_NEW_EXPR)
	{
	/* For NEW_EXPR tree nodes created inside a template, either
	the object type itself or a TREE_LIST may appear as the
	operand 1. */
	tree type = TREE_OPERAND (expression, 1);
	if (TREE_CODE (type) == TREE_LIST)
	/* This is an array type. We need to check array dimensions
	as well. */
	return dependent_type_p (TREE_VALUE (TREE_PURPOSE (type)))
	\|\| value_dependent_expression_p
	(TREE_OPERAND (TREE_VALUE (type), 1));
	else
	return dependent_type_p (type);
	}

	if (TREE_CODE (expression) == SCOPE_REF
	&& dependent_scope_ref_p (expression,
	type_dependent_expression_p))
	return true;

	if (TREE_CODE (expression) == FUNCTION_DECL
	&& DECL_LANG_SPECIFIC (expression)
	&& DECL_TEMPLATE_INFO (expression)
	&& (any_dependent_template_arguments_p
	(INNERMOST_TEMPLATE_ARGS (DECL_TI_ARGS (expression)))))
	return true;

	if (TREE_CODE (expression) == TEMPLATE_DECL
	&& !DECL_TEMPLATE_TEMPLATE_PARM_P (expression))
	return false;

	if (TREE_TYPE (expression) == unknown_type_node)
	{
	if (TREE_CODE (expression) == ADDR_EXPR)
	return type_dependent_expression_p (TREE_OPERAND (expression, 0));
	if (TREE_CODE (expression) == COMPONENT_REF
	\|\| TREE_CODE (expression) == OFFSET_REF)
	{
	if (type_dependent_expression_p (TREE_OPERAND (expression, 0)))
	return true;
	expression = TREE_OPERAND (expression, 1);
	if (TREE_CODE (expression) == IDENTIFIER_NODE)
	return false;
	}
	/* SCOPE_REF with non-null TREE_TYPE is always non-dependent. */
	if (TREE_CODE (expression) == SCOPE_REF)
	return false;

	if (TREE_CODE (expression) == BASELINK)
	expression = BASELINK_FUNCTIONS (expression);

	if (TREE_CODE (expression) == TEMPLATE_ID_EXPR)
	{
	if (any_dependent_template_arguments_p
	(TREE_OPERAND (expression, 1)))
	return true;
	expression = TREE_OPERAND (expression, 0);
	}
	gcc_assert (TREE_CODE (expression) == OVERLOAD
	\|\| TREE_CODE (expression) == FUNCTION_DECL);

	while (expression)
	{
	if (type_dependent_expression_p (OVL_CURRENT (expression)))
	return true;
	expression = OVL_NEXT (expression);
	}
	return false;
	}

	gcc_assert (TREE_CODE (expression) != TYPE_DECL);

	return (dependent_type_p (TREE_TYPE (expression)));
	}

	/* Returns TRUE if ARGS (a TREE_LIST of arguments to a function call)
	contains a type-dependent expression. */

	bool
	any_type_dependent_arguments_p (tree args)
	{
	while (args)
	{
	tree arg = TREE_VALUE (args);

	if (type_dependent_expression_p (arg))
	return true;
	args = TREE_CHAIN (args);
	}
	return false;
	}

	/* Returns TRUE if LIST (a TREE_LIST whose TREE_VALUEs are
	expressions) contains any value-dependent expressions. */

	bool
	any_value_dependent_elements_p (tree list)
	{
	for (; list; list = TREE_CHAIN (list))
	if (value_dependent_expression_p (TREE_VALUE (list)))
	return true;

	return false;
	}

	/* Returns TRUE if the ARG (a template argument) is dependent. */

	static bool
	dependent_template_arg_p (tree arg)
	{
	if (!processing_template_decl)
	return false;

	if (TREE_CODE (arg) == TEMPLATE_DECL
	\|\| TREE_CODE (arg) == TEMPLATE_TEMPLATE_PARM)
	return dependent_template_p (arg);
	else if (TYPE_P (arg))
	return dependent_type_p (arg);
	else
	return (type_dependent_expression_p (arg)
	\|\| value_dependent_expression_p (arg));
	}

	/* Returns true if ARGS (a collection of template arguments) contains
	any dependent arguments. */

	bool
	any_dependent_template_arguments_p (tree args)
	{
	int i;
	int j;

	if (!args)
	return false;
	if (args == error_mark_node)
	return true;

	for (i = 0; i < TMPL_ARGS_DEPTH (args); ++i)
	{
	tree level = TMPL_ARGS_LEVEL (args, i + 1);
	for (j = 0; j < TREE_VEC_LENGTH (level); ++j)
	if (dependent_template_arg_p (TREE_VEC_ELT (level, j)))
	return true;
	}

	return false;
	}

	/* Returns TRUE if the template TMPL is dependent. */

	bool
	dependent_template_p (tree tmpl)
	{
	if (TREE_CODE (tmpl) == OVERLOAD)
	{
	while (tmpl)
	{
	if (dependent_template_p (OVL_FUNCTION (tmpl)))
	return true;
	tmpl = OVL_CHAIN (tmpl);
	}
	return false;
	}

	/* Template template parameters are dependent. */
	if (DECL_TEMPLATE_TEMPLATE_PARM_P (tmpl)
	\|\| TREE_CODE (tmpl) == TEMPLATE_TEMPLATE_PARM)
	return true;
	/* So are names that have not been looked up. */
	if (TREE_CODE (tmpl) == SCOPE_REF
	\|\| TREE_CODE (tmpl) == IDENTIFIER_NODE)
	return true;
	/* So are member templates of dependent classes. */
	if (TYPE_P (CP_DECL_CONTEXT (tmpl)))
	return dependent_type_p (DECL_CONTEXT (tmpl));
	return false;
	}

	/* Returns TRUE if the specialization TMPL<ARGS> is dependent. */

	bool
	dependent_template_id_p (tree tmpl, tree args)
	{
	return (dependent_template_p (tmpl)
	\|\| any_dependent_template_arguments_p (args));
	}

	/* TYPE is a TYPENAME_TYPE. Returns the ordinary TYPE to which the
	TYPENAME_TYPE corresponds. Returns ERROR_MARK_NODE if no such TYPE
	can be found. Note that this function peers inside uninstantiated
	templates and therefore should be used only in extremely limited
	situations. ONLY_CURRENT_P restricts this peering to the currently
	open classes hierarchy (which is required when comparing types). */

	tree
	resolve_typename_type (tree type, bool only_current_p)
	{
	tree scope;
	tree name;
	tree decl;
	int quals;
	tree pushed_scope;

	gcc_assert (TREE_CODE (type) == TYPENAME_TYPE);

	scope = TYPE_CONTEXT (type);
	name = TYPE_IDENTIFIER (type);

	/* If the SCOPE is itself a TYPENAME_TYPE, then we need to resolve
	it first before we can figure out what NAME refers to. */
	if (TREE_CODE (scope) == TYPENAME_TYPE)
	scope = resolve_typename_type (scope, only_current_p);
	/* If we don't know what SCOPE refers to, then we cannot resolve the
	TYPENAME_TYPE. */
	if (scope == error_mark_node \|\| TREE_CODE (scope) == TYPENAME_TYPE)
	return error_mark_node;
	/* If the SCOPE is a template type parameter, we have no way of
	resolving the name. */
	if (TREE_CODE (scope) == TEMPLATE_TYPE_PARM)
	return type;
	/* If the SCOPE is not the current instantiation, there's no reason
	to look inside it. */
	if (only_current_p && !currently_open_class (scope))
	return error_mark_node;
	/* If SCOPE is a partial instantiation, it will not have a valid
	TYPE_FIELDS list, so use the original template. */
	scope = CLASSTYPE_PRIMARY_TEMPLATE_TYPE (scope);
	/* Enter the SCOPE so that name lookup will be resolved as if we
	were in the class definition. In particular, SCOPE will no
	longer be considered a dependent type. */
	pushed_scope = push_scope (scope);
	/* Look up the declaration. */
	decl = lookup_member (scope, name, /protect=/0, /want_type=/true);
	/* Obtain the set of qualifiers applied to the TYPE. */
	quals = cp_type_quals (type);
	/* For a TYPENAME_TYPE like "typename X::template Y<T>", we want to
	find a TEMPLATE_DECL. Otherwise, we want to find a TYPE_DECL. */
	if (!decl)
	type = error_mark_node;
	else if (TREE_CODE (TYPENAME_TYPE_FULLNAME (type)) == IDENTIFIER_NODE
	&& TREE_CODE (decl) == TYPE_DECL)
	type = TREE_TYPE (decl);
	else if (TREE_CODE (TYPENAME_TYPE_FULLNAME (type)) == TEMPLATE_ID_EXPR
	&& DECL_CLASS_TEMPLATE_P (decl))
	{
	tree tmpl;
	tree args;
	/* Obtain the template and the arguments. */
	tmpl = TREE_OPERAND (TYPENAME_TYPE_FULLNAME (type), 0);
	args = TREE_OPERAND (TYPENAME_TYPE_FULLNAME (type), 1);
	/* Instantiate the template. */
	type = lookup_template_class (tmpl, args, NULL_TREE, NULL_TREE,
	/entering_scope=/0, tf_error \| tf_user);
	}
	else
	type = error_mark_node;
	/* Qualify the resulting type. */
	if (type != error_mark_node && quals)
	type = cp_build_qualified_type (type, quals);
	/* Leave the SCOPE. */
	if (pushed_scope)
	pop_scope (pushed_scope);

	return type;
	}

	/* EXPR is an expression which is not type-dependent. Return a proxy
	for EXPR that can be used to compute the types of larger
	expressions containing EXPR. */

	tree
	build_non_dependent_expr (tree expr)
	{
	tree inner_expr;

	/* Preserve null pointer constants so that the type of things like
	"p == 0" where "p" is a pointer can be determined. */
	if (null_ptr_cst_p (expr))
	return expr;
	/* Preserve OVERLOADs; the functions must be available to resolve
	types. */
	inner_expr = expr;
	if (TREE_CODE (inner_expr) == ADDR_EXPR)
	inner_expr = TREE_OPERAND (inner_expr, 0);
	if (TREE_CODE (inner_expr) == COMPONENT_REF)
	inner_expr = TREE_OPERAND (inner_expr, 1);
	if (is_overloaded_fn (inner_expr)
	\|\| TREE_CODE (inner_expr) == OFFSET_REF)
	return expr;
	/* There is no need to return a proxy for a variable. */
	if (TREE_CODE (expr) == VAR_DECL)
	return expr;
	/* Preserve string constants; conversions from string constants to
	"char " are allowed, even though normally a "const char "
	cannot be used to initialize a "char ". /
	if (TREE_CODE (expr) == STRING_CST)
	return expr;
	/* Preserve arithmetic constants, as an optimization -- there is no
	reason to create a new node. */
	if (TREE_CODE (expr) == INTEGER_CST \|\| TREE_CODE (expr) == REAL_CST)
	return expr;
	/* Preserve THROW_EXPRs -- all throw-expressions have type "void".
	There is at least one place where we want to know that a
	particular expression is a throw-expression: when checking a ?:
	expression, there are special rules if the second or third
	argument is a throw-expression. */
	if (TREE_CODE (expr) == THROW_EXPR)
	return expr;

	if (TREE_CODE (expr) == COND_EXPR)
	return build3 (COND_EXPR,
	TREE_TYPE (expr),
	TREE_OPERAND (expr, 0),
	(TREE_OPERAND (expr, 1)
	? build_non_dependent_expr (TREE_OPERAND (expr, 1))
	: build_non_dependent_expr (TREE_OPERAND (expr, 0))),
	build_non_dependent_expr (TREE_OPERAND (expr, 2)));
	if (TREE_CODE (expr) == COMPOUND_EXPR
	&& !COMPOUND_EXPR_OVERLOADED (expr))
	return build2 (COMPOUND_EXPR,
	TREE_TYPE (expr),
	TREE_OPERAND (expr, 0),
	build_non_dependent_expr (TREE_OPERAND (expr, 1)));

	/* If the type is unknown, it can't really be non-dependent */
	gcc_assert (TREE_TYPE (expr) != unknown_type_node);

	/* Otherwise, build a NON_DEPENDENT_EXPR.

	REFERENCE_TYPEs are not stripped for expressions in templates
	because doing so would play havoc with mangling. Consider, for
	example:

	template <typename T> void f<T& g>() { g(); }

	In the body of "f", the expression for "g" will have
	REFERENCE_TYPE, even though the standard says that it should
	not. The reason is that we must preserve the syntactic form of
	the expression so that mangling (say) "f<g>" inside the body of
	"f" works out correctly. Therefore, the REFERENCE_TYPE is
	stripped here. */
	return build1 (NON_DEPENDENT_EXPR, non_reference (TREE_TYPE (expr)), expr);
	}

	/* ARGS is a TREE_LIST of expressions as arguments to a function call.
	Return a new TREE_LIST with the various arguments replaced with
	equivalent non-dependent expressions. */

	tree
	build_non_dependent_args (tree args)
	{
	tree a;
	tree new_args;

	new_args = NULL_TREE;
	for (a = args; a; a = TREE_CHAIN (a))
	new_args = tree_cons (NULL_TREE,
	build_non_dependent_expr (TREE_VALUE (a)),
	new_args);
	return nreverse (new_args);
	}

	#include "gt-cp-pt.h"
	diff --git a/contrib/gcc/cp/semantics.c b/contrib/gcc/cp/semantics.c
	index 547859b07c41..c234e250142b 100644
	--- a/contrib/gcc/cp/semantics.c
	+++ b/contrib/gcc/cp/semantics.c
	@@ -1,3960 +1,3974 @@
	/* Perform the semantic phase of parsing, i.e., the process of
	building tree structure, checking semantic consistency, and
	building RTL. These routines are used both during actual parsing
	and during the instantiation of template functions.

	Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005
	Free Software Foundation, Inc.
	Written by Mark Mitchell (mmitchell@usa.net) based on code found
	formerly in parse.y and pt.c.

	This file is part of GCC.

	GCC is free software; you can redistribute it and/or modify it
	under the terms of the GNU General Public License as published by
	the Free Software Foundation; either version 2, or (at your option)
	any later version.

	GCC is distributed in the hope that it will be useful, but
	WITHOUT ANY WARRANTY; without even the implied warranty of
	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	General Public License for more details.

	You should have received a copy of the GNU General Public License
	along with GCC; see the file COPYING. If not, write to the Free
	Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
	02110-1301, USA. */

	#include "config.h"
	#include "system.h"
	#include "coretypes.h"
	#include "tm.h"
	#include "tree.h"
	#include "cp-tree.h"
	#include "c-common.h"
	#include "tree-inline.h"
	#include "tree-mudflap.h"
	#include "except.h"
	#include "toplev.h"
	#include "flags.h"
	#include "rtl.h"
	#include "expr.h"
	#include "output.h"
	#include "timevar.h"
	#include "debug.h"
	#include "diagnostic.h"
	#include "cgraph.h"
	#include "tree-iterator.h"
	#include "vec.h"
	#include "target.h"

	/* There routines provide a modular interface to perform many parsing
	operations. They may therefore be used during actual parsing, or
	during template instantiation, which may be regarded as a
	degenerate form of parsing. */

	static tree maybe_convert_cond (tree);
	static tree simplify_aggr_init_exprs_r (tree , int , void *);
	static void emit_associated_thunks (tree);
	static tree finalize_nrv_r (tree , int , void *);


	/* Deferred Access Checking Overview
	---------------------------------

	Most C++ expressions and declarations require access checking
	to be performed during parsing. However, in several cases,
	this has to be treated differently.

	For member declarations, access checking has to be deferred
	until more information about the declaration is known. For
	example:

	class A {
	typedef int X;
	public:
	X f();
	};

	A::X A::f();
	A::X g();

	When we are parsing the function return type `A::X', we don't
	really know if this is allowed until we parse the function name.

	Furthermore, some contexts require that access checking is
	never performed at all. These include class heads, and template
	instantiations.

	Typical use of access checking functions is described here:

	1. When we enter a context that requires certain access checking
	mode, the function `push_deferring_access_checks' is called with
	DEFERRING argument specifying the desired mode. Access checking
	may be performed immediately (dk_no_deferred), deferred
	(dk_deferred), or not performed (dk_no_check).

	2. When a declaration such as a type, or a variable, is encountered,
	the function `perform_or_defer_access_check' is called. It
	maintains a VEC of all deferred checks.

	3. The global `current_class_type' or `current_function_decl' is then
	setup by the parser. `enforce_access' relies on these information
	to check access.

	4. Upon exiting the context mentioned in step 1,
	`perform_deferred_access_checks' is called to check all declaration
	stored in the VEC. `pop_deferring_access_checks' is then
	called to restore the previous access checking mode.

	In case of parsing error, we simply call `pop_deferring_access_checks'
	without `perform_deferred_access_checks'. */

	typedef struct deferred_access GTY(())
	{
	/* A VEC representing name-lookups for which we have deferred
	checking access controls. We cannot check the accessibility of
	names used in a decl-specifier-seq until we know what is being
	declared because code like:

	class A {
	class B {};
	B* f();
	}

	A::B* A::f() { return 0; }

	is valid, even though `A::B' is not generally accessible. */
	VEC (deferred_access_check,gc)* GTY(()) deferred_access_checks;

	/* The current mode of access checks. */
	enum deferring_kind deferring_access_checks_kind;

	} deferred_access;
	DEF_VEC_O (deferred_access);
	DEF_VEC_ALLOC_O (deferred_access,gc);

	/* Data for deferred access checking. */
	static GTY(()) VEC(deferred_access,gc) *deferred_access_stack;
	static GTY(()) unsigned deferred_access_no_check;

	/* Save the current deferred access states and start deferred
	access checking iff DEFER_P is true. */

	void
	push_deferring_access_checks (deferring_kind deferring)
	{
	/* For context like template instantiation, access checking
	disabling applies to all nested context. */
	if (deferred_access_no_check \|\| deferring == dk_no_check)
	deferred_access_no_check++;
	else
	{
	deferred_access *ptr;

	ptr = VEC_safe_push (deferred_access, gc, deferred_access_stack, NULL);
	ptr->deferred_access_checks = NULL;
	ptr->deferring_access_checks_kind = deferring;
	}
	}

	/* Resume deferring access checks again after we stopped doing
	this previously. */

	void
	resume_deferring_access_checks (void)
	{
	if (!deferred_access_no_check)
	VEC_last (deferred_access, deferred_access_stack)
	->deferring_access_checks_kind = dk_deferred;
	}

	/* Stop deferring access checks. */

	void
	stop_deferring_access_checks (void)
	{
	if (!deferred_access_no_check)
	VEC_last (deferred_access, deferred_access_stack)
	->deferring_access_checks_kind = dk_no_deferred;
	}

	/* Discard the current deferred access checks and restore the
	previous states. */

	void
	pop_deferring_access_checks (void)
	{
	if (deferred_access_no_check)
	deferred_access_no_check--;
	else
	VEC_pop (deferred_access, deferred_access_stack);
	}

	/* Returns a TREE_LIST representing the deferred checks.
	The TREE_PURPOSE of each node is the type through which the
	access occurred; the TREE_VALUE is the declaration named.
	*/

	VEC (deferred_access_check,gc)*
	get_deferred_access_checks (void)
	{
	if (deferred_access_no_check)
	return NULL;
	else
	return (VEC_last (deferred_access, deferred_access_stack)
	->deferred_access_checks);
	}

	/* Take current deferred checks and combine with the
	previous states if we also defer checks previously.
	Otherwise perform checks now. */

	void
	pop_to_parent_deferring_access_checks (void)
	{
	if (deferred_access_no_check)
	deferred_access_no_check--;
	else
	{
	VEC (deferred_access_check,gc) *checks;
	deferred_access *ptr;

	checks = (VEC_last (deferred_access, deferred_access_stack)
	->deferred_access_checks);

	VEC_pop (deferred_access, deferred_access_stack);
	ptr = VEC_last (deferred_access, deferred_access_stack);
	if (ptr->deferring_access_checks_kind == dk_no_deferred)
	{
	/* Check access. */
	perform_access_checks (checks);
	}
	else
	{
	/* Merge with parent. */
	int i, j;
	deferred_access_check chk, probe;

	for (i = 0 ;
	VEC_iterate (deferred_access_check, checks, i, chk) ;
	++i)
	{
	for (j = 0 ;
	VEC_iterate (deferred_access_check,
	ptr->deferred_access_checks, j, probe) ;
	++j)
	{
	if (probe->binfo == chk->binfo &&
	probe->decl == chk->decl &&
	probe->diag_decl == chk->diag_decl)
	goto found;
	}
	/* Insert into parent's checks. */
	VEC_safe_push (deferred_access_check, gc,
	ptr->deferred_access_checks, chk);
	found:;
	}
	}
	}
	}

	/* Perform the access checks in CHECKS. The TREE_PURPOSE of each node
	is the BINFO indicating the qualifying scope used to access the
	DECL node stored in the TREE_VALUE of the node. */

	void
	perform_access_checks (VEC (deferred_access_check,gc)* checks)
	{
	int i;
	deferred_access_check *chk;

	if (!checks)
	return;

	for (i = 0 ; VEC_iterate (deferred_access_check, checks, i, chk) ; ++i)
	enforce_access (chk->binfo, chk->decl, chk->diag_decl);
	}

	/* Perform the deferred access checks.

	After performing the checks, we still have to keep the list
	`deferred_access_stack->deferred_access_checks' since we may want
	to check access for them again later in a different context.
	For example:

	class A {
	typedef int X;
	static X a;
	};
	A::X A::a, x; // No error for `A::a', error for `x'

	We have to perform deferred access of `A::X', first with `A::a',
	next with `x'. */

	void
	perform_deferred_access_checks (void)
	{
	perform_access_checks (get_deferred_access_checks ());
	}

	/* Defer checking the accessibility of DECL, when looked up in
	BINFO. DIAG_DECL is the declaration to use to print diagnostics. */

	void
	perform_or_defer_access_check (tree binfo, tree decl, tree diag_decl)
	{
	int i;
	deferred_access *ptr;
	deferred_access_check *chk;
	deferred_access_check *new_access;


	/* Exit if we are in a context that no access checking is performed.
	*/
	if (deferred_access_no_check)
	return;

	gcc_assert (TREE_CODE (binfo) == TREE_BINFO);

	ptr = VEC_last (deferred_access, deferred_access_stack);

	/* If we are not supposed to defer access checks, just check now. */
	if (ptr->deferring_access_checks_kind == dk_no_deferred)
	{
	enforce_access (binfo, decl, diag_decl);
	return;
	}

	/* See if we are already going to perform this check. */
	for (i = 0 ;
	VEC_iterate (deferred_access_check,
	ptr->deferred_access_checks, i, chk) ;
	++i)
	{
	if (chk->decl == decl && chk->binfo == binfo &&
	chk->diag_decl == diag_decl)
	{
	return;
	}
	}
	/* If not, record the check. */
	new_access =
	VEC_safe_push (deferred_access_check, gc,
	ptr->deferred_access_checks, 0);
	new_access->binfo = binfo;
	new_access->decl = decl;
	new_access->diag_decl = diag_decl;
	}

	/* Returns nonzero if the current statement is a full expression,
	i.e. temporaries created during that statement should be destroyed
	at the end of the statement. */

	int
	stmts_are_full_exprs_p (void)
	{
	return current_stmt_tree ()->stmts_are_full_exprs_p;
	}

	/* T is a statement. Add it to the statement-tree. This is the C++
	version. The C/ObjC frontends have a slightly different version of
	this function. */

	tree
	add_stmt (tree t)
	{
	enum tree_code code = TREE_CODE (t);

	if (EXPR_P (t) && code != LABEL_EXPR)
	{
	if (!EXPR_HAS_LOCATION (t))
	SET_EXPR_LOCATION (t, input_location);

	/* When we expand a statement-tree, we must know whether or not the
	statements are full-expressions. We record that fact here. */
	STMT_IS_FULL_EXPR_P (t) = stmts_are_full_exprs_p ();
	}

	/* Add T to the statement-tree. Non-side-effect statements need to be
	recorded during statement expressions. */
	append_to_statement_list_force (t, &cur_stmt_list);

	return t;
	}

	/* Returns the stmt_tree (if any) to which statements are currently
	being added. If there is no active statement-tree, NULL is
	returned. */

	stmt_tree
	current_stmt_tree (void)
	{
	return (cfun
	? &cfun->language->base.x_stmt_tree
	: &scope_chain->x_stmt_tree);
	}

	/* If statements are full expressions, wrap STMT in a CLEANUP_POINT_EXPR. */

	static tree
	maybe_cleanup_point_expr (tree expr)
	{
	if (!processing_template_decl && stmts_are_full_exprs_p ())
	expr = fold_build_cleanup_point_expr (TREE_TYPE (expr), expr);
	return expr;
	}

	/* Like maybe_cleanup_point_expr except have the type of the new expression be
	void so we don't need to create a temporary variable to hold the inner
	expression. The reason why we do this is because the original type might be
	an aggregate and we cannot create a temporary variable for that type. */

	static tree
	maybe_cleanup_point_expr_void (tree expr)
	{
	if (!processing_template_decl && stmts_are_full_exprs_p ())
	expr = fold_build_cleanup_point_expr (void_type_node, expr);
	return expr;
	}



	/* Create a declaration statement for the declaration given by the DECL. */

	void
	add_decl_expr (tree decl)
	{
	tree r = build_stmt (DECL_EXPR, decl);
	if (DECL_INITIAL (decl)
	\|\| (DECL_SIZE (decl) && TREE_SIDE_EFFECTS (DECL_SIZE (decl))))
	r = maybe_cleanup_point_expr_void (r);
	add_stmt (r);
	}

	/* Nonzero if TYPE is an anonymous union or struct type. We have to use a
	flag for this because "A union for which objects or pointers are
	declared is not an anonymous union" [class.union]. */

	int
	anon_aggr_type_p (tree node)
	{
	return ANON_AGGR_TYPE_P (node);
	}

	/* Finish a scope. */

	tree
	do_poplevel (tree stmt_list)
	{
	tree block = NULL;

	if (stmts_are_full_exprs_p ())
	block = poplevel (kept_level_p (), 1, 0);

	stmt_list = pop_stmt_list (stmt_list);

	if (!processing_template_decl)
	{
	stmt_list = c_build_bind_expr (block, stmt_list);
	/* ??? See c_end_compound_stmt re statement expressions. */
	}

	return stmt_list;
	}

	/* Begin a new scope. */

	static tree
	do_pushlevel (scope_kind sk)
	{
	tree ret = push_stmt_list ();
	if (stmts_are_full_exprs_p ())
	begin_scope (sk, NULL);
	return ret;
	}

	/* Queue a cleanup. CLEANUP is an expression/statement to be executed
	when the current scope is exited. EH_ONLY is true when this is not
	meant to apply to normal control flow transfer. */

	void
	push_cleanup (tree decl, tree cleanup, bool eh_only)
	{
	tree stmt = build_stmt (CLEANUP_STMT, NULL, cleanup, decl);
	CLEANUP_EH_ONLY (stmt) = eh_only;
	add_stmt (stmt);
	CLEANUP_BODY (stmt) = push_stmt_list ();
	}

	/* Begin a conditional that might contain a declaration. When generating
	normal code, we want the declaration to appear before the statement
	containing the conditional. When generating template code, we want the
	conditional to be rendered as the raw DECL_EXPR. */

	static void
	begin_cond (tree *cond_p)
	{
	if (processing_template_decl)
	*cond_p = push_stmt_list ();
	}

	/* Finish such a conditional. */

	static void
	finish_cond (tree *cond_p, tree expr)
	{
	if (processing_template_decl)
	{
	tree cond = pop_stmt_list (*cond_p);
	if (TREE_CODE (cond) == DECL_EXPR)
	expr = cond;
	}
	*cond_p = expr;
	}

	/* If *COND_P specifies a conditional with a declaration, transform the
	loop such that
	while (A x = 42) { }
	for (; A x = 42;) { }
	becomes
	while (true) { A x = 42; if (!x) break; }
	for (;;) { A x = 42; if (!x) break; }
	The statement list for BODY will be empty if the conditional did
	not declare anything. */

	static void
	simplify_loop_decl_cond (tree *cond_p, tree body)
	{
	tree cond, if_stmt;

	if (!TREE_SIDE_EFFECTS (body))
	return;

	cond = *cond_p;
	*cond_p = boolean_true_node;

	if_stmt = begin_if_stmt ();
	cond = build_unary_op (TRUTH_NOT_EXPR, cond, 0);
	finish_if_stmt_cond (cond, if_stmt);
	finish_break_stmt ();
	finish_then_clause (if_stmt);
	finish_if_stmt (if_stmt);
	}

	/* Finish a goto-statement. */

	tree
	finish_goto_stmt (tree destination)
	{
	if (TREE_CODE (destination) == IDENTIFIER_NODE)
	destination = lookup_label (destination);

	/* We warn about unused labels with -Wunused. That means we have to
	mark the used labels as used. */
	if (TREE_CODE (destination) == LABEL_DECL)
	TREE_USED (destination) = 1;
	else
	{
	/* The DESTINATION is being used as an rvalue. */
	if (!processing_template_decl)
	destination = decay_conversion (destination);
	/* We don't inline calls to functions with computed gotos.
	Those functions are typically up to some funny business,
	and may be depending on the labels being at particular
	addresses, or some such. */
	DECL_UNINLINABLE (current_function_decl) = 1;
	}

	check_goto (destination);

	return add_stmt (build_stmt (GOTO_EXPR, destination));
	}

	/* COND is the condition-expression for an if, while, etc.,
	statement. Convert it to a boolean value, if appropriate. */

	static tree
	maybe_convert_cond (tree cond)
	{
	/* Empty conditions remain empty. */
	if (!cond)
	return NULL_TREE;

	/* Wait until we instantiate templates before doing conversion. */
	if (processing_template_decl)
	return cond;

	/* Do the conversion. */
	cond = convert_from_reference (cond);

	if (TREE_CODE (cond) == MODIFY_EXPR
	&& !TREE_NO_WARNING (cond)
	&& warn_parentheses)
	{
	warning (OPT_Wparentheses,
	"suggest parentheses around assignment used as truth value");
	TREE_NO_WARNING (cond) = 1;
	}

	return condition_conversion (cond);
	}

	/* Finish an expression-statement, whose EXPRESSION is as indicated. */

	tree
	finish_expr_stmt (tree expr)
	{
	tree r = NULL_TREE;

	if (expr != NULL_TREE)
	{
	if (!processing_template_decl)
	{
	if (warn_sequence_point)
	verify_sequence_points (expr);
	expr = convert_to_void (expr, "statement");
	}
	else if (!type_dependent_expression_p (expr))
	convert_to_void (build_non_dependent_expr (expr), "statement");

	/* Simplification of inner statement expressions, compound exprs,
	etc can result in us already having an EXPR_STMT. */
	if (TREE_CODE (expr) != CLEANUP_POINT_EXPR)
	{
	if (TREE_CODE (expr) != EXPR_STMT)
	expr = build_stmt (EXPR_STMT, expr);
	expr = maybe_cleanup_point_expr_void (expr);
	}

	r = add_stmt (expr);
	}

	finish_stmt ();

	return r;
	}


	/* Begin an if-statement. Returns a newly created IF_STMT if
	appropriate. */

	tree
	begin_if_stmt (void)
	{
	tree r, scope;
	scope = do_pushlevel (sk_block);
	r = build_stmt (IF_STMT, NULL_TREE, NULL_TREE, NULL_TREE);
	TREE_CHAIN (r) = scope;
	begin_cond (&IF_COND (r));
	return r;
	}

	/* Process the COND of an if-statement, which may be given by
	IF_STMT. */

	void
	finish_if_stmt_cond (tree cond, tree if_stmt)
	{
	finish_cond (&IF_COND (if_stmt), maybe_convert_cond (cond));
	add_stmt (if_stmt);
	THEN_CLAUSE (if_stmt) = push_stmt_list ();
	}

	/* Finish the then-clause of an if-statement, which may be given by
	IF_STMT. */

	tree
	finish_then_clause (tree if_stmt)
	{
	THEN_CLAUSE (if_stmt) = pop_stmt_list (THEN_CLAUSE (if_stmt));
	return if_stmt;
	}

	/* Begin the else-clause of an if-statement. */

	void
	begin_else_clause (tree if_stmt)
	{
	ELSE_CLAUSE (if_stmt) = push_stmt_list ();
	}

	/* Finish the else-clause of an if-statement, which may be given by
	IF_STMT. */

	void
	finish_else_clause (tree if_stmt)
	{
	ELSE_CLAUSE (if_stmt) = pop_stmt_list (ELSE_CLAUSE (if_stmt));
	}

	/* Finish an if-statement. */

	void
	finish_if_stmt (tree if_stmt)
	{
	tree scope = TREE_CHAIN (if_stmt);
	TREE_CHAIN (if_stmt) = NULL;
	add_stmt (do_poplevel (scope));
	finish_stmt ();
	empty_body_warning (THEN_CLAUSE (if_stmt), ELSE_CLAUSE (if_stmt));
	}

	/* Begin a while-statement. Returns a newly created WHILE_STMT if
	appropriate. */

	tree
	-begin_while_stmt (void)
	+/* APPLE LOCAL begin for-fsf-4_4 3274130 5295549 */ \
	+begin_while_stmt (tree attribs)
	+/* APPLE LOCAL end for-fsf-4_4 3274130 5295549 */ \
	{
	tree r;
	- r = build_stmt (WHILE_STMT, NULL_TREE, NULL_TREE);
	+/* APPLE LOCAL begin for-fsf-4_4 3274130 5295549 */ \
	+ r = build_stmt (WHILE_STMT, NULL_TREE, NULL_TREE, attribs);
	+/* APPLE LOCAL end for-fsf-4_4 3274130 5295549 */ \
	add_stmt (r);
	WHILE_BODY (r) = do_pushlevel (sk_block);
	begin_cond (&WHILE_COND (r));
	return r;
	}

	/* Process the COND of a while-statement, which may be given by
	WHILE_STMT. */

	void
	finish_while_stmt_cond (tree cond, tree while_stmt)
	{
	finish_cond (&WHILE_COND (while_stmt), maybe_convert_cond (cond));
	simplify_loop_decl_cond (&WHILE_COND (while_stmt), WHILE_BODY (while_stmt));
	}

	/* Finish a while-statement, which may be given by WHILE_STMT. */

	void
	finish_while_stmt (tree while_stmt)
	{
	WHILE_BODY (while_stmt) = do_poplevel (WHILE_BODY (while_stmt));
	finish_stmt ();
	}

	/* Begin a do-statement. Returns a newly created DO_STMT if
	appropriate. */

	tree
	-begin_do_stmt (void)
	-{
	- tree r = build_stmt (DO_STMT, NULL_TREE, NULL_TREE);
	+/* APPLE LOCAL begin for-fsf-4_4 3274130 5295549 */ \
	+begin_do_stmt (tree attribs)
	+/* APPLE LOCAL end for-fsf-4_4 3274130 5295549 */ \
	+{
	+ /* APPLE LOCAL radar 4445586 */
	+/* APPLE LOCAL begin for-fsf-4_4 3274130 5295549 */ \
	+ tree r = build_stmt (DO_STMT, NULL_TREE, NULL_TREE, attribs, NULL_TREE);
	+/* APPLE LOCAL end for-fsf-4_4 3274130 5295549 */ \
	add_stmt (r);
	DO_BODY (r) = push_stmt_list ();
	return r;
	}

	/* Finish the body of a do-statement, which may be given by DO_STMT. */

	void
	finish_do_body (tree do_stmt)
	{
	DO_BODY (do_stmt) = pop_stmt_list (DO_BODY (do_stmt));
	}

	/* Finish a do-statement, which may be given by DO_STMT, and whose
	COND is as indicated. */

	void
	finish_do_stmt (tree cond, tree do_stmt)
	{
	cond = maybe_convert_cond (cond);
	DO_COND (do_stmt) = cond;
	finish_stmt ();
	}

	/* Finish a return-statement. The EXPRESSION returned, if any, is as
	indicated. */

	tree
	finish_return_stmt (tree expr)
	{
	tree r;
	bool no_warning;

	expr = check_return_expr (expr, &no_warning);

	if (flag_openmp && !check_omp_return ())
	return error_mark_node;
	if (!processing_template_decl)
	{
	if (DECL_DESTRUCTOR_P (current_function_decl)
	\|\| (DECL_CONSTRUCTOR_P (current_function_decl)
	&& targetm.cxx.cdtor_returns_this ()))
	{
	/* Similarly, all destructors must run destructors for
	base-classes before returning. So, all returns in a
	destructor get sent to the DTOR_LABEL; finish_function emits
	code to return a value there. */
	return finish_goto_stmt (cdtor_label);
	}
	}

	r = build_stmt (RETURN_EXPR, expr);
	TREE_NO_WARNING (r) \|= no_warning;
	r = maybe_cleanup_point_expr_void (r);
	r = add_stmt (r);
	finish_stmt ();

	return r;
	}

	/* Begin a for-statement. Returns a new FOR_STMT if appropriate. */

	tree
	-begin_for_stmt (void)
	+/* APPLE LOCAL begin for-fsf-4_4 3274130 5295549 */ \
	+begin_for_stmt (tree attribs)
	+/* APPLE LOCAL end for-fsf-4_4 3274130 5295549 */ \
	{
	tree r;

	r = build_stmt (FOR_STMT, NULL_TREE, NULL_TREE,
	- NULL_TREE, NULL_TREE);
	+/* APPLE LOCAL begin for-fsf-4_4 3274130 5295549 */ \
	+ NULL_TREE, NULL_TREE, attribs);
	+
	+/* APPLE LOCAL end for-fsf-4_4 3274130 5295549 */ \

	if (flag_new_for_scope > 0)
	TREE_CHAIN (r) = do_pushlevel (sk_for);

	if (processing_template_decl)
	FOR_INIT_STMT (r) = push_stmt_list ();

	return r;
	}

	/* Finish the for-init-statement of a for-statement, which may be
	given by FOR_STMT. */

	void
	finish_for_init_stmt (tree for_stmt)
	{
	if (processing_template_decl)
	FOR_INIT_STMT (for_stmt) = pop_stmt_list (FOR_INIT_STMT (for_stmt));
	add_stmt (for_stmt);
	FOR_BODY (for_stmt) = do_pushlevel (sk_block);
	begin_cond (&FOR_COND (for_stmt));
	}

	/* Finish the COND of a for-statement, which may be given by
	FOR_STMT. */

	void
	finish_for_cond (tree cond, tree for_stmt)
	{
	finish_cond (&FOR_COND (for_stmt), maybe_convert_cond (cond));
	simplify_loop_decl_cond (&FOR_COND (for_stmt), FOR_BODY (for_stmt));
	}

	/* Finish the increment-EXPRESSION in a for-statement, which may be
	given by FOR_STMT. */

	void
	finish_for_expr (tree expr, tree for_stmt)
	{
	if (!expr)
	return;
	/* If EXPR is an overloaded function, issue an error; there is no
	context available to use to perform overload resolution. */
	if (type_unknown_p (expr))
	{
	cxx_incomplete_type_error (expr, TREE_TYPE (expr));
	expr = error_mark_node;
	}
	if (!processing_template_decl)
	{
	if (warn_sequence_point)
	verify_sequence_points (expr);
	expr = convert_to_void (expr, "3rd expression in for");
	}
	else if (!type_dependent_expression_p (expr))
	convert_to_void (build_non_dependent_expr (expr), "3rd expression in for");
	expr = maybe_cleanup_point_expr_void (expr);
	FOR_EXPR (for_stmt) = expr;
	}

	/* Finish the body of a for-statement, which may be given by
	FOR_STMT. The increment-EXPR for the loop must be
	provided. */

	void
	finish_for_stmt (tree for_stmt)
	{
	FOR_BODY (for_stmt) = do_poplevel (FOR_BODY (for_stmt));

	/* Pop the scope for the body of the loop. */
	if (flag_new_for_scope > 0)
	{
	tree scope = TREE_CHAIN (for_stmt);
	TREE_CHAIN (for_stmt) = NULL;
	add_stmt (do_poplevel (scope));
	}

	finish_stmt ();
	}

	/* Finish a break-statement. */

	tree
	finish_break_stmt (void)
	{
	return add_stmt (build_stmt (BREAK_STMT));
	}

	/* Finish a continue-statement. */

	tree
	finish_continue_stmt (void)
	{
	return add_stmt (build_stmt (CONTINUE_STMT));
	}

	/* Begin a switch-statement. Returns a new SWITCH_STMT if
	appropriate. */

	tree
	begin_switch_stmt (void)
	{
	tree r, scope;

	r = build_stmt (SWITCH_STMT, NULL_TREE, NULL_TREE, NULL_TREE);

	scope = do_pushlevel (sk_block);
	TREE_CHAIN (r) = scope;
	begin_cond (&SWITCH_STMT_COND (r));

	return r;
	}

	/* Finish the cond of a switch-statement. */

	void
	finish_switch_cond (tree cond, tree switch_stmt)
	{
	tree orig_type = NULL;
	if (!processing_template_decl)
	{
	tree index;

	/* Convert the condition to an integer or enumeration type. */
	cond = build_expr_type_conversion (WANT_INT \| WANT_ENUM, cond, true);
	if (cond == NULL_TREE)
	{
	error ("switch quantity not an integer");
	cond = error_mark_node;
	}
	orig_type = TREE_TYPE (cond);
	if (cond != error_mark_node)
	{
	/* [stmt.switch]

	Integral promotions are performed. */
	cond = perform_integral_promotions (cond);
	cond = maybe_cleanup_point_expr (cond);
	}

	if (cond != error_mark_node)
	{
	index = get_unwidened (cond, NULL_TREE);
	/* We can't strip a conversion from a signed type to an unsigned,
	because if we did, int_fits_type_p would do the wrong thing
	when checking case values for being in range,
	and it's too hard to do the right thing. */
	if (TYPE_UNSIGNED (TREE_TYPE (cond))
	== TYPE_UNSIGNED (TREE_TYPE (index)))
	cond = index;
	}
	}
	finish_cond (&SWITCH_STMT_COND (switch_stmt), cond);
	SWITCH_STMT_TYPE (switch_stmt) = orig_type;
	add_stmt (switch_stmt);
	push_switch (switch_stmt);
	SWITCH_STMT_BODY (switch_stmt) = push_stmt_list ();
	}

	/* Finish the body of a switch-statement, which may be given by
	SWITCH_STMT. The COND to switch on is indicated. */

	void
	finish_switch_stmt (tree switch_stmt)
	{
	tree scope;

	SWITCH_STMT_BODY (switch_stmt) =
	pop_stmt_list (SWITCH_STMT_BODY (switch_stmt));
	pop_switch ();
	finish_stmt ();

	scope = TREE_CHAIN (switch_stmt);
	TREE_CHAIN (switch_stmt) = NULL;
	add_stmt (do_poplevel (scope));
	}

	/* Begin a try-block. Returns a newly-created TRY_BLOCK if
	appropriate. */

	tree
	begin_try_block (void)
	{
	tree r = build_stmt (TRY_BLOCK, NULL_TREE, NULL_TREE);
	add_stmt (r);
	TRY_STMTS (r) = push_stmt_list ();
	return r;
	}

	/* Likewise, for a function-try-block. The block returned in
	*COMPOUND_STMT is an artificial outer scope, containing the
	function-try-block. */

	tree
	begin_function_try_block (tree *compound_stmt)
	{
	tree r;
	/* This outer scope does not exist in the C++ standard, but we need
	a place to put __FUNCTION__ and similar variables. */
	*compound_stmt = begin_compound_stmt (0);
	r = begin_try_block ();
	FN_TRY_BLOCK_P (r) = 1;
	return r;
	}

	/* Finish a try-block, which may be given by TRY_BLOCK. */

	void
	finish_try_block (tree try_block)
	{
	TRY_STMTS (try_block) = pop_stmt_list (TRY_STMTS (try_block));
	TRY_HANDLERS (try_block) = push_stmt_list ();
	}

	/* Finish the body of a cleanup try-block, which may be given by
	TRY_BLOCK. */

	void
	finish_cleanup_try_block (tree try_block)
	{
	TRY_STMTS (try_block) = pop_stmt_list (TRY_STMTS (try_block));
	}

	/* Finish an implicitly generated try-block, with a cleanup is given
	by CLEANUP. */

	void
	finish_cleanup (tree cleanup, tree try_block)
	{
	TRY_HANDLERS (try_block) = cleanup;
	CLEANUP_P (try_block) = 1;
	}

	/* Likewise, for a function-try-block. */

	void
	finish_function_try_block (tree try_block)
	{
	finish_try_block (try_block);
	/* FIXME : something queer about CTOR_INITIALIZER somehow following
	the try block, but moving it inside. */
	in_function_try_handler = 1;
	}

	/* Finish a handler-sequence for a try-block, which may be given by
	TRY_BLOCK. */

	void
	finish_handler_sequence (tree try_block)
	{
	TRY_HANDLERS (try_block) = pop_stmt_list (TRY_HANDLERS (try_block));
	check_handlers (TRY_HANDLERS (try_block));
	}

	/* Finish the handler-seq for a function-try-block, given by
	TRY_BLOCK. COMPOUND_STMT is the outer block created by
	begin_function_try_block. */

	void
	finish_function_handler_sequence (tree try_block, tree compound_stmt)
	{
	in_function_try_handler = 0;
	finish_handler_sequence (try_block);
	finish_compound_stmt (compound_stmt);
	}

	/* Begin a handler. Returns a HANDLER if appropriate. */

	tree
	begin_handler (void)
	{
	tree r;

	r = build_stmt (HANDLER, NULL_TREE, NULL_TREE);
	add_stmt (r);

	/* Create a binding level for the eh_info and the exception object
	cleanup. */
	HANDLER_BODY (r) = do_pushlevel (sk_catch);

	return r;
	}

	/* Finish the handler-parameters for a handler, which may be given by
	HANDLER. DECL is the declaration for the catch parameter, or NULL
	if this is a `catch (...)' clause. */

	void
	finish_handler_parms (tree decl, tree handler)
	{
	tree type = NULL_TREE;
	if (processing_template_decl)
	{
	if (decl)
	{
	decl = pushdecl (decl);
	decl = push_template_decl (decl);
	HANDLER_PARMS (handler) = decl;
	type = TREE_TYPE (decl);
	}
	}
	else
	type = expand_start_catch_block (decl);
	HANDLER_TYPE (handler) = type;
	if (!processing_template_decl && type)
	mark_used (eh_type_info (type));
	}

	/* Finish a handler, which may be given by HANDLER. The BLOCKs are
	the return value from the matching call to finish_handler_parms. */

	void
	finish_handler (tree handler)
	{
	if (!processing_template_decl)
	expand_end_catch_block ();
	HANDLER_BODY (handler) = do_poplevel (HANDLER_BODY (handler));
	}

	/* Begin a compound statement. FLAGS contains some bits that control the
	behavior and context. If BCS_NO_SCOPE is set, the compound statement
	does not define a scope. If BCS_FN_BODY is set, this is the outermost
	block of a function. If BCS_TRY_BLOCK is set, this is the block
	created on behalf of a TRY statement. Returns a token to be passed to
	finish_compound_stmt. */

	tree
	begin_compound_stmt (unsigned int flags)
	{
	tree r;

	if (flags & BCS_NO_SCOPE)
	{
	r = push_stmt_list ();
	STATEMENT_LIST_NO_SCOPE (r) = 1;

	/* Normally, we try hard to keep the BLOCK for a statement-expression.
	But, if it's a statement-expression with a scopeless block, there's
	nothing to keep, and we don't want to accidentally keep a block
	inside the scopeless block. */
	keep_next_level (false);
	}
	else
	r = do_pushlevel (flags & BCS_TRY_BLOCK ? sk_try : sk_block);

	/* When processing a template, we need to remember where the braces were,
	so that we can set up identical scopes when instantiating the template
	later. BIND_EXPR is a handy candidate for this.
	Note that do_poplevel won't create a BIND_EXPR itself here (and thus
	result in nested BIND_EXPRs), since we don't build BLOCK nodes when
	processing templates. */
	if (processing_template_decl)
	{
	r = build3 (BIND_EXPR, NULL, NULL, r, NULL);
	BIND_EXPR_TRY_BLOCK (r) = (flags & BCS_TRY_BLOCK) != 0;
	BIND_EXPR_BODY_BLOCK (r) = (flags & BCS_FN_BODY) != 0;
	TREE_SIDE_EFFECTS (r) = 1;
	}

	return r;
	}

	/* Finish a compound-statement, which is given by STMT. */

	void
	finish_compound_stmt (tree stmt)
	{
	if (TREE_CODE (stmt) == BIND_EXPR)
	BIND_EXPR_BODY (stmt) = do_poplevel (BIND_EXPR_BODY (stmt));
	else if (STATEMENT_LIST_NO_SCOPE (stmt))
	stmt = pop_stmt_list (stmt);
	else
	{
	/* Destroy any ObjC "super" receivers that may have been
	created. */
	objc_clear_super_receiver ();

	stmt = do_poplevel (stmt);
	}

	/* ??? See c_end_compound_stmt wrt statement expressions. */
	add_stmt (stmt);
	finish_stmt ();
	}

	/* Finish an asm-statement, whose components are a STRING, some
	OUTPUT_OPERANDS, some INPUT_OPERANDS, and some CLOBBERS. Also note
	whether the asm-statement should be considered volatile. */

	tree
	finish_asm_stmt (int volatile_p, tree string, tree output_operands,
	tree input_operands, tree clobbers)
	{
	tree r;
	tree t;
	int ninputs = list_length (input_operands);
	int noutputs = list_length (output_operands);

	if (!processing_template_decl)
	{
	const char *constraint;
	const char **oconstraints;
	bool allows_mem, allows_reg, is_inout;
	tree operand;
	int i;

	oconstraints = (const char *) alloca (noutputs sizeof (char *));

	string = resolve_asm_operand_names (string, output_operands,
	input_operands);

	for (i = 0, t = output_operands; t; t = TREE_CHAIN (t), ++i)
	{
	operand = TREE_VALUE (t);

	/* ??? Really, this should not be here. Users should be using a
	proper lvalue, dammit. But there's a long history of using
	casts in the output operands. In cases like longlong.h, this
	becomes a primitive form of typechecking -- if the cast can be
	removed, then the output operand had a type of the proper width;
	otherwise we'll get an error. Gross, but ... */
	STRIP_NOPS (operand);

	if (!lvalue_or_else (operand, lv_asm))
	operand = error_mark_node;

	if (operand != error_mark_node
	&& (TREE_READONLY (operand)
	\|\| CP_TYPE_CONST_P (TREE_TYPE (operand))
	/* Functions are not modifiable, even though they are
	lvalues. */
	\|\| TREE_CODE (TREE_TYPE (operand)) == FUNCTION_TYPE
	\|\| TREE_CODE (TREE_TYPE (operand)) == METHOD_TYPE
	/* If it's an aggregate and any field is const, then it is
	effectively const. */
	\|\| (CLASS_TYPE_P (TREE_TYPE (operand))
	&& C_TYPE_FIELDS_READONLY (TREE_TYPE (operand)))))
	readonly_error (operand, "assignment (via 'asm' output)", 0);

	constraint = TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (t)));
	oconstraints[i] = constraint;

	if (parse_output_constraint (&constraint, i, ninputs, noutputs,
	&allows_mem, &allows_reg, &is_inout))
	{
	/* If the operand is going to end up in memory,
	mark it addressable. */
	if (!allows_reg && !cxx_mark_addressable (operand))
	operand = error_mark_node;
	}
	else
	operand = error_mark_node;

	TREE_VALUE (t) = operand;
	}

	for (i = 0, t = input_operands; t; ++i, t = TREE_CHAIN (t))
	{
	constraint = TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (t)));
	operand = decay_conversion (TREE_VALUE (t));

	/* If the type of the operand hasn't been determined (e.g.,
	because it involves an overloaded function), then issue
	an error message. There's no context available to
	resolve the overloading. */
	if (TREE_TYPE (operand) == unknown_type_node)
	{
	error ("type of asm operand %qE could not be determined",
	TREE_VALUE (t));
	operand = error_mark_node;
	}

	if (parse_input_constraint (&constraint, i, ninputs, noutputs, 0,
	oconstraints, &allows_mem, &allows_reg))
	{
	/* If the operand is going to end up in memory,
	mark it addressable. */
	if (!allows_reg && allows_mem)
	{
	/* Strip the nops as we allow this case. FIXME, this really
	should be rejected or made deprecated. */
	STRIP_NOPS (operand);
	if (!cxx_mark_addressable (operand))
	operand = error_mark_node;
	}
	}
	else
	operand = error_mark_node;

	TREE_VALUE (t) = operand;
	}
	}

	r = build_stmt (ASM_EXPR, string,
	output_operands, input_operands,
	clobbers);
	ASM_VOLATILE_P (r) = volatile_p \|\| noutputs == 0;
	r = maybe_cleanup_point_expr_void (r);
	return add_stmt (r);
	}

	/* Finish a label with the indicated NAME. */

	tree
	finish_label_stmt (tree name)
	{
	tree decl = define_label (input_location, name);

	if (decl == error_mark_node)
	return error_mark_node;

	return add_stmt (build_stmt (LABEL_EXPR, decl));
	}

	/* Finish a series of declarations for local labels. G++ allows users
	to declare "local" labels, i.e., labels with scope. This extension
	is useful when writing code involving statement-expressions. */

	void
	finish_label_decl (tree name)
	{
	if (!at_function_scope_p ())
	{
	error ("__label__ declarations are only allowed in function scopes");
	return;
	}

	add_decl_expr (declare_local_label (name));
	}

	/* When DECL goes out of scope, make sure that CLEANUP is executed. */

	void
	finish_decl_cleanup (tree decl, tree cleanup)
	{
	push_cleanup (decl, cleanup, false);
	}

	/* If the current scope exits with an exception, run CLEANUP. */

	void
	finish_eh_cleanup (tree cleanup)
	{
	push_cleanup (NULL, cleanup, true);
	}

	/* The MEM_INITS is a list of mem-initializers, in reverse of the
	order they were written by the user. Each node is as for
	emit_mem_initializers. */

	void
	finish_mem_initializers (tree mem_inits)
	{
	/* Reorder the MEM_INITS so that they are in the order they appeared
	in the source program. */
	mem_inits = nreverse (mem_inits);

	if (processing_template_decl)
	add_stmt (build_min_nt (CTOR_INITIALIZER, mem_inits));
	else
	emit_mem_initializers (mem_inits);
	}

	/* Finish a parenthesized expression EXPR. */

	tree
	finish_parenthesized_expr (tree expr)
	{
	if (EXPR_P (expr))
	/* This inhibits warnings in c_common_truthvalue_conversion. */
	TREE_NO_WARNING (expr) = 1;

	if (TREE_CODE (expr) == OFFSET_REF)
	/* [expr.unary.op]/3 The qualified id of a pointer-to-member must not be
	enclosed in parentheses. */
	PTRMEM_OK_P (expr) = 0;

	if (TREE_CODE (expr) == STRING_CST)
	PAREN_STRING_LITERAL_P (expr) = 1;

	return expr;
	}

	/* Finish a reference to a non-static data member (DECL) that is not
	preceded by `.' or `->'. */

	tree
	finish_non_static_data_member (tree decl, tree object, tree qualifying_scope)
	{
	gcc_assert (TREE_CODE (decl) == FIELD_DECL);

	if (!object)
	{
	if (current_function_decl
	&& DECL_STATIC_FUNCTION_P (current_function_decl))
	error ("invalid use of member %q+D in static member function", decl);
	else
	error ("invalid use of non-static data member %q+D", decl);
	error ("from this location");

	return error_mark_node;
	}
	TREE_USED (current_class_ptr) = 1;
	if (processing_template_decl && !qualifying_scope)
	{
	tree type = TREE_TYPE (decl);

	if (TREE_CODE (type) == REFERENCE_TYPE)
	type = TREE_TYPE (type);
	else
	{
	/* Set the cv qualifiers. */
	int quals = cp_type_quals (TREE_TYPE (current_class_ref));

	if (DECL_MUTABLE_P (decl))
	quals &= ~TYPE_QUAL_CONST;

	quals \|= cp_type_quals (TREE_TYPE (decl));
	type = cp_build_qualified_type (type, quals);
	}

	return build_min (COMPONENT_REF, type, object, decl, NULL_TREE);
	}
	else
	{
	tree access_type = TREE_TYPE (object);
	tree lookup_context = context_for_name_lookup (decl);

	while (!DERIVED_FROM_P (lookup_context, access_type))
	{
	access_type = TYPE_CONTEXT (access_type);
	while (access_type && DECL_P (access_type))
	access_type = DECL_CONTEXT (access_type);

	if (!access_type)
	{
	error ("object missing in reference to %q+D", decl);
	error ("from this location");
	return error_mark_node;
	}
	}

	/* If PROCESSING_TEMPLATE_DECL is nonzero here, then
	QUALIFYING_SCOPE is also non-null. Wrap this in a SCOPE_REF
	for now. */
	if (processing_template_decl)
	return build_qualified_name (TREE_TYPE (decl),
	qualifying_scope,
	DECL_NAME (decl),
	/template_p=/false);

	perform_or_defer_access_check (TYPE_BINFO (access_type), decl,
	decl);

	/* If the data member was named `C::M', convert `*this' to `C'
	first. */
	if (qualifying_scope)
	{
	tree binfo = NULL_TREE;
	object = build_scoped_ref (object, qualifying_scope,
	&binfo);
	}

	return build_class_member_access_expr (object, decl,
	/access_path=/NULL_TREE,
	/preserve_reference=/false);
	}
	}

	/* DECL was the declaration to which a qualified-id resolved. Issue
	an error message if it is not accessible. If OBJECT_TYPE is
	non-NULL, we have just seen `x->' or `x.' and OBJECT_TYPE is the
	type of `*x', or `x', respectively. If the DECL was named as
	`A::B' then NESTED_NAME_SPECIFIER is `A'. */

	void
	check_accessibility_of_qualified_id (tree decl,
	tree object_type,
	tree nested_name_specifier)
	{
	tree scope;
	tree qualifying_type = NULL_TREE;

	/* If we're not checking, return immediately. */
	if (deferred_access_no_check)
	return;

	/* Determine the SCOPE of DECL. */
	scope = context_for_name_lookup (decl);
	/* If the SCOPE is not a type, then DECL is not a member. */
	if (!TYPE_P (scope))
	return;
	/* Compute the scope through which DECL is being accessed. */
	if (object_type
	/* OBJECT_TYPE might not be a class type; consider:

	class A { typedef int I; };
	I *p;
	p->A::I::~I();

	In this case, we will have "A::I" as the DECL, but "I" as the
	OBJECT_TYPE. */
	&& CLASS_TYPE_P (object_type)
	&& DERIVED_FROM_P (scope, object_type))
	/* If we are processing a `->' or `.' expression, use the type of the
	left-hand side. */
	qualifying_type = object_type;
	else if (nested_name_specifier)
	{
	/* If the reference is to a non-static member of the
	current class, treat it as if it were referenced through
	`this'. */
	if (DECL_NONSTATIC_MEMBER_P (decl)
	&& current_class_ptr
	&& DERIVED_FROM_P (scope, current_class_type))
	qualifying_type = current_class_type;
	/* Otherwise, use the type indicated by the
	nested-name-specifier. */
	else
	qualifying_type = nested_name_specifier;
	}
	else
	/* Otherwise, the name must be from the current class or one of
	its bases. */
	qualifying_type = currently_open_derived_class (scope);

	if (qualifying_type
	/* It is possible for qualifying type to be a TEMPLATE_TYPE_PARM
	or similar in a default argument value. */
	&& CLASS_TYPE_P (qualifying_type)
	&& !dependent_type_p (qualifying_type))
	perform_or_defer_access_check (TYPE_BINFO (qualifying_type), decl,
	decl);
	}

	/* EXPR is the result of a qualified-id. The QUALIFYING_CLASS was the
	class named to the left of the "::" operator. DONE is true if this
	expression is a complete postfix-expression; it is false if this
	expression is followed by '->', '[', '(', etc. ADDRESS_P is true
	iff this expression is the operand of '&'. TEMPLATE_P is true iff
	the qualified-id was of the form "A::template B". TEMPLATE_ARG_P
	is true iff this qualified name appears as a template argument. */

	tree
	finish_qualified_id_expr (tree qualifying_class,
	tree expr,
	bool done,
	bool address_p,
	bool template_p,
	bool template_arg_p)
	{
	gcc_assert (TYPE_P (qualifying_class));

	if (error_operand_p (expr))
	return error_mark_node;

	if (DECL_P (expr) \|\| BASELINK_P (expr))
	mark_used (expr);

	if (template_p)
	check_template_keyword (expr);

	/* If EXPR occurs as the operand of '&', use special handling that
	permits a pointer-to-member. */
	if (address_p && done)
	{
	if (TREE_CODE (expr) == SCOPE_REF)
	expr = TREE_OPERAND (expr, 1);
	expr = build_offset_ref (qualifying_class, expr,
	/address_p=/true);
	return expr;
	}

	/* Within the scope of a class, turn references to non-static
	members into expression of the form "this->...". */
	if (template_arg_p)
	/* But, within a template argument, we do not want make the
	transformation, as there is no "this" pointer. */
	;
	else if (TREE_CODE (expr) == FIELD_DECL)
	expr = finish_non_static_data_member (expr, current_class_ref,
	qualifying_class);
	else if (BASELINK_P (expr) && !processing_template_decl)
	{
	tree fns;

	/* See if any of the functions are non-static members. */
	fns = BASELINK_FUNCTIONS (expr);
	if (TREE_CODE (fns) == TEMPLATE_ID_EXPR)
	fns = TREE_OPERAND (fns, 0);
	/* If so, the expression may be relative to the current
	class. */
	if (!shared_member_p (fns)
	&& current_class_type
	&& DERIVED_FROM_P (qualifying_class, current_class_type))
	expr = (build_class_member_access_expr
	(maybe_dummy_object (qualifying_class, NULL),
	expr,
	BASELINK_ACCESS_BINFO (expr),
	/preserve_reference=/false));
	else if (done)
	/* The expression is a qualified name whose address is not
	being taken. */
	expr = build_offset_ref (qualifying_class, expr, /address_p=/false);
	}

	return expr;
	}

	/* Begin a statement-expression. The value returned must be passed to
	finish_stmt_expr. */

	tree
	begin_stmt_expr (void)
	{
	return push_stmt_list ();
	}

	/* Process the final expression of a statement expression. EXPR can be
	NULL, if the final expression is empty. Return a STATEMENT_LIST
	containing all the statements in the statement-expression, or
	ERROR_MARK_NODE if there was an error. */

	tree
	finish_stmt_expr_expr (tree expr, tree stmt_expr)
	{
	if (error_operand_p (expr))
	return error_mark_node;

	/* If the last statement does not have "void" type, then the value
	of the last statement is the value of the entire expression. */
	if (expr)
	{
	tree type = TREE_TYPE (expr);

	if (processing_template_decl)
	{
	expr = build_stmt (EXPR_STMT, expr);
	expr = add_stmt (expr);
	/* Mark the last statement so that we can recognize it as such at
	template-instantiation time. */
	EXPR_STMT_STMT_EXPR_RESULT (expr) = 1;
	}
	else if (VOID_TYPE_P (type))
	{
	/* Just treat this like an ordinary statement. */
	expr = finish_expr_stmt (expr);
	}
	else
	{
	/* It actually has a value we need to deal with. First, force it
	to be an rvalue so that we won't need to build up a copy
	constructor call later when we try to assign it to something. */
	expr = force_rvalue (expr);
	if (error_operand_p (expr))
	return error_mark_node;

	/* Update for array-to-pointer decay. */
	type = TREE_TYPE (expr);

	/* Wrap it in a CLEANUP_POINT_EXPR and add it to the list like a
	normal statement, but don't convert to void or actually add
	the EXPR_STMT. */
	if (TREE_CODE (expr) != CLEANUP_POINT_EXPR)
	expr = maybe_cleanup_point_expr (expr);
	add_stmt (expr);
	}

	/* The type of the statement-expression is the type of the last
	expression. */
	TREE_TYPE (stmt_expr) = type;
	}

	return stmt_expr;
	}

	/* Finish a statement-expression. EXPR should be the value returned
	by the previous begin_stmt_expr. Returns an expression
	representing the statement-expression. */

	tree
	finish_stmt_expr (tree stmt_expr, bool has_no_scope)
	{
	tree type;
	tree result;

	if (error_operand_p (stmt_expr))
	return error_mark_node;

	gcc_assert (TREE_CODE (stmt_expr) == STATEMENT_LIST);

	type = TREE_TYPE (stmt_expr);
	result = pop_stmt_list (stmt_expr);
	TREE_TYPE (result) = type;

	if (processing_template_decl)
	{
	result = build_min (STMT_EXPR, type, result);
	TREE_SIDE_EFFECTS (result) = 1;
	STMT_EXPR_NO_SCOPE (result) = has_no_scope;
	}
	else if (CLASS_TYPE_P (type))
	{
	/* Wrap the statement-expression in a TARGET_EXPR so that the
	temporary object created by the final expression is destroyed at
	the end of the full-expression containing the
	statement-expression. */
	result = force_target_expr (type, result);
	}

	return result;
	}

	/* Perform Koenig lookup. FN is the postfix-expression representing
	the function (or functions) to call; ARGS are the arguments to the
	call. Returns the functions to be considered by overload
	resolution. */

	tree
	perform_koenig_lookup (tree fn, tree args)
	{
	tree identifier = NULL_TREE;
	tree functions = NULL_TREE;

	/* Find the name of the overloaded function. */
	if (TREE_CODE (fn) == IDENTIFIER_NODE)
	identifier = fn;
	else if (is_overloaded_fn (fn))
	{
	functions = fn;
	identifier = DECL_NAME (get_first_fn (functions));
	}
	else if (DECL_P (fn))
	{
	functions = fn;
	identifier = DECL_NAME (fn);
	}

	/* A call to a namespace-scope function using an unqualified name.

	Do Koenig lookup -- unless any of the arguments are
	type-dependent. */
	if (!any_type_dependent_arguments_p (args))
	{
	fn = lookup_arg_dependent (identifier, functions, args);
	if (!fn)
	/* The unqualified name could not be resolved. */
	fn = unqualified_fn_lookup_error (identifier);
	}

	return fn;
	}

	/* Generate an expression for `FN (ARGS)'.

	If DISALLOW_VIRTUAL is true, the call to FN will be not generated
	as a virtual call, even if FN is virtual. (This flag is set when
	encountering an expression where the function name is explicitly
	qualified. For example a call to `X::f' never generates a virtual
	call.)

	Returns code for the call. */

	tree
	finish_call_expr (tree fn, tree args, bool disallow_virtual, bool koenig_p)
	{
	tree result;
	tree orig_fn;
	tree orig_args;

	if (fn == error_mark_node \|\| args == error_mark_node)
	return error_mark_node;

	/* ARGS should be a list of arguments. */
	gcc_assert (!args \|\| TREE_CODE (args) == TREE_LIST);
	gcc_assert (!TYPE_P (fn));

	orig_fn = fn;
	orig_args = args;

	if (processing_template_decl)
	{
	if (type_dependent_expression_p (fn)
	\|\| any_type_dependent_arguments_p (args))
	{
	result = build_nt (CALL_EXPR, fn, args, NULL_TREE);
	KOENIG_LOOKUP_P (result) = koenig_p;
	return result;
	}
	if (!BASELINK_P (fn)
	&& TREE_CODE (fn) != PSEUDO_DTOR_EXPR
	&& TREE_TYPE (fn) != unknown_type_node)
	fn = build_non_dependent_expr (fn);
	args = build_non_dependent_args (orig_args);
	}

	if (is_overloaded_fn (fn))
	fn = baselink_for_fns (fn);

	result = NULL_TREE;
	if (BASELINK_P (fn))
	{
	tree object;

	/* A call to a member function. From [over.call.func]:

	If the keyword this is in scope and refers to the class of
	that member function, or a derived class thereof, then the
	function call is transformed into a qualified function call
	using (*this) as the postfix-expression to the left of the
	. operator.... [Otherwise] a contrived object of type T
	becomes the implied object argument.

	This paragraph is unclear about this situation:

	struct A { void f(); };
	struct B : public A {};
	struct C : public A { void g() { B::f(); }};

	In particular, for `B::f', this paragraph does not make clear
	whether "the class of that member function" refers to `A' or
	to `B'. We believe it refers to `B'. */
	if (current_class_type
	&& DERIVED_FROM_P (BINFO_TYPE (BASELINK_ACCESS_BINFO (fn)),
	current_class_type)
	&& current_class_ref)
	object = maybe_dummy_object (BINFO_TYPE (BASELINK_ACCESS_BINFO (fn)),
	NULL);
	else
	{
	tree representative_fn;

	representative_fn = BASELINK_FUNCTIONS (fn);
	if (TREE_CODE (representative_fn) == TEMPLATE_ID_EXPR)
	representative_fn = TREE_OPERAND (representative_fn, 0);
	representative_fn = get_first_fn (representative_fn);
	object = build_dummy_object (DECL_CONTEXT (representative_fn));
	}

	if (processing_template_decl)
	{
	if (type_dependent_expression_p (object))
	return build_nt (CALL_EXPR, orig_fn, orig_args, NULL_TREE);
	object = build_non_dependent_expr (object);
	}

	result = build_new_method_call (object, fn, args, NULL_TREE,
	(disallow_virtual
	? LOOKUP_NONVIRTUAL : 0),
	/fn_p=/NULL);
	}
	else if (is_overloaded_fn (fn))
	{
	/* If the function is an overloaded builtin, resolve it. */
	if (TREE_CODE (fn) == FUNCTION_DECL
	&& (DECL_BUILT_IN_CLASS (fn) == BUILT_IN_NORMAL
	\|\| DECL_BUILT_IN_CLASS (fn) == BUILT_IN_MD))
	result = resolve_overloaded_builtin (fn, args);

	if (!result)
	/* A call to a namespace-scope function. */
	result = build_new_function_call (fn, args, koenig_p);
	}
	else if (TREE_CODE (fn) == PSEUDO_DTOR_EXPR)
	{
	if (args)
	error ("arguments to destructor are not allowed");
	/* Mark the pseudo-destructor call as having side-effects so
	that we do not issue warnings about its use. */
	result = build1 (NOP_EXPR,
	void_type_node,
	TREE_OPERAND (fn, 0));
	TREE_SIDE_EFFECTS (result) = 1;
	}
	else if (CLASS_TYPE_P (TREE_TYPE (fn)))
	/* If the "function" is really an object of class type, it might
	have an overloaded `operator ()'. */
	result = build_new_op (CALL_EXPR, LOOKUP_NORMAL, fn, args, NULL_TREE,
	/overloaded_p=/NULL);

	if (!result)
	/* A call where the function is unknown. */
	result = build_function_call (fn, args);

	if (processing_template_decl)
	{
	result = build3 (CALL_EXPR, TREE_TYPE (result), orig_fn,
	orig_args, NULL_TREE);
	KOENIG_LOOKUP_P (result) = koenig_p;
	}
	return result;
	}

	/* Finish a call to a postfix increment or decrement or EXPR. (Which
	is indicated by CODE, which should be POSTINCREMENT_EXPR or
	POSTDECREMENT_EXPR.) */

	tree
	finish_increment_expr (tree expr, enum tree_code code)
	{
	return build_x_unary_op (code, expr);
	}

	/* Finish a use of `this'. Returns an expression for `this'. */

	tree
	finish_this_expr (void)
	{
	tree result;

	if (current_class_ptr)
	{
	result = current_class_ptr;
	}
	else if (current_function_decl
	&& DECL_STATIC_FUNCTION_P (current_function_decl))
	{
	error ("%<this%> is unavailable for static member functions");
	result = error_mark_node;
	}
	else
	{
	if (current_function_decl)
	error ("invalid use of %<this%> in non-member function");
	else
	error ("invalid use of %<this%> at top level");
	result = error_mark_node;
	}

	return result;
	}

	/* Finish a pseudo-destructor expression. If SCOPE is NULL, the
	expression was of the form `OBJECT.~DESTRUCTOR' where DESTRUCTOR is
	the TYPE for the type given. If SCOPE is non-NULL, the expression
	was of the form `OBJECT.SCOPE::~DESTRUCTOR'. */

	tree
	finish_pseudo_destructor_expr (tree object, tree scope, tree destructor)
	{
	if (destructor == error_mark_node)
	return error_mark_node;

	gcc_assert (TYPE_P (destructor));

	if (!processing_template_decl)
	{
	if (scope == error_mark_node)
	{
	error ("invalid qualifying scope in pseudo-destructor name");
	return error_mark_node;
	}
	if (scope && TYPE_P (scope) && !check_dtor_name (scope, destructor))
	{
	error ("qualified type %qT does not match destructor name ~%qT",
	scope, destructor);
	return error_mark_node;
	}


	/* [expr.pseudo] says both:

	The type designated by the pseudo-destructor-name shall be
	the same as the object type.

	and:

	The cv-unqualified versions of the object type and of the
	type designated by the pseudo-destructor-name shall be the
	same type.

	We implement the more generous second sentence, since that is
	what most other compilers do. */
	if (!same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (object),
	destructor))
	{
	error ("%qE is not of type %qT", object, destructor);
	return error_mark_node;
	}
	}

	return build3 (PSEUDO_DTOR_EXPR, void_type_node, object, scope, destructor);
	}

	/* Finish an expression of the form CODE EXPR. */

	tree
	finish_unary_op_expr (enum tree_code code, tree expr)
	{
	tree result = build_x_unary_op (code, expr);
	/* Inside a template, build_x_unary_op does not fold the
	expression. So check whether the result is folded before
	setting TREE_NEGATED_INT. */
	if (code == NEGATE_EXPR && TREE_CODE (expr) == INTEGER_CST
	&& TREE_CODE (result) == INTEGER_CST
	&& !TYPE_UNSIGNED (TREE_TYPE (result))
	&& INT_CST_LT (result, integer_zero_node))
	{
	/* RESULT may be a cached INTEGER_CST, so we must copy it before
	setting TREE_NEGATED_INT. */
	result = copy_node (result);
	TREE_NEGATED_INT (result) = 1;
	}
	if (TREE_OVERFLOW_P (result) && !TREE_OVERFLOW_P (expr))
	overflow_warning (result);

	return result;
	}

	/* Finish a compound-literal expression. TYPE is the type to which
	the INITIALIZER_LIST is being cast. */

	tree
	finish_compound_literal (tree type, VEC(constructor_elt,gc) *initializer_list)
	{
	tree var;
	tree compound_literal;

	if (!TYPE_OBJ_P (type))
	{
	error ("compound literal of non-object type %qT", type);
	return error_mark_node;
	}

	/* Build a CONSTRUCTOR for the INITIALIZER_LIST. */
	compound_literal = build_constructor (NULL_TREE, initializer_list);
	if (processing_template_decl)
	{
	TREE_TYPE (compound_literal) = type;
	/* Mark the expression as a compound literal. */
	TREE_HAS_CONSTRUCTOR (compound_literal) = 1;
	return compound_literal;
	}

	/* Create a temporary variable to represent the compound literal. */
	var = create_temporary_var (type);
	if (!current_function_decl)
	{
	/* If this compound-literal appears outside of a function, then
	the corresponding variable has static storage duration, just
	like the variable in whose initializer it appears. */
	TREE_STATIC (var) = 1;
	/* The variable has internal linkage, since there is no need to
	reference it from another translation unit. */
	TREE_PUBLIC (var) = 0;
	/* It must have a name, so that the name mangler can mangle it. */
	DECL_NAME (var) = make_anon_name ();
	}
	/* We must call pushdecl, since the gimplifier complains if the
	variable has not been declared via a BIND_EXPR. */
	pushdecl (var);
	/* Initialize the variable as we would any other variable with a
	brace-enclosed initializer. */
	cp_finish_decl (var, compound_literal,
	/init_const_expr_p=/false,
	/asmspec_tree=/NULL_TREE,
	LOOKUP_ONLYCONVERTING);
	return var;
	}

	/* Return the declaration for the function-name variable indicated by
	ID. */

	tree
	finish_fname (tree id)
	{
	tree decl;

	decl = fname_decl (C_RID_CODE (id), id);
	if (processing_template_decl)
	decl = DECL_NAME (decl);
	return decl;
	}

	/* Finish a translation unit. */

	void
	finish_translation_unit (void)
	{
	/* In case there were missing closebraces,
	get us back to the global binding level. */
	pop_everything ();
	while (current_namespace != global_namespace)
	pop_namespace ();

	/* Do file scope __FUNCTION__ et al. */
	finish_fname_decls ();
	}

	/* Finish a template type parameter, specified as AGGR IDENTIFIER.
	Returns the parameter. */

	tree
	finish_template_type_parm (tree aggr, tree identifier)
	{
	if (aggr != class_type_node)
	{
	pedwarn ("template type parameters must use the keyword %<class%> or %<typename%>");
	aggr = class_type_node;
	}

	return build_tree_list (aggr, identifier);
	}

	/* Finish a template template parameter, specified as AGGR IDENTIFIER.
	Returns the parameter. */

	tree
	finish_template_template_parm (tree aggr, tree identifier)
	{
	tree decl = build_decl (TYPE_DECL, identifier, NULL_TREE);
	tree tmpl = build_lang_decl (TEMPLATE_DECL, identifier, NULL_TREE);
	DECL_TEMPLATE_PARMS (tmpl) = current_template_parms;
	DECL_TEMPLATE_RESULT (tmpl) = decl;
	DECL_ARTIFICIAL (decl) = 1;
	end_template_decl ();

	gcc_assert (DECL_TEMPLATE_PARMS (tmpl));

	return finish_template_type_parm (aggr, tmpl);
	}

	/* ARGUMENT is the default-argument value for a template template
	parameter. If ARGUMENT is invalid, issue error messages and return
	the ERROR_MARK_NODE. Otherwise, ARGUMENT itself is returned. */

	tree
	check_template_template_default_arg (tree argument)
	{
	if (TREE_CODE (argument) != TEMPLATE_DECL
	&& TREE_CODE (argument) != TEMPLATE_TEMPLATE_PARM
	&& TREE_CODE (argument) != UNBOUND_CLASS_TEMPLATE)
	{
	if (TREE_CODE (argument) == TYPE_DECL)
	error ("invalid use of type %qT as a default value for a template "
	"template-parameter", TREE_TYPE (argument));
	else
	error ("invalid default argument for a template template parameter");
	return error_mark_node;
	}

	return argument;
	}

	/* Begin a class definition, as indicated by T. */

	tree
	begin_class_definition (tree t, tree attributes)
	{
	if (t == error_mark_node)
	return error_mark_node;

	if (processing_template_parmlist)
	{
	error ("definition of %q#T inside template parameter list", t);
	return error_mark_node;
	}
	/* A non-implicit typename comes from code like:

	template <typename T> struct A {
	template <typename U> struct A<T>::B ...

	This is erroneous. */
	else if (TREE_CODE (t) == TYPENAME_TYPE)
	{
	error ("invalid definition of qualified type %qT", t);
	t = error_mark_node;
	}

	if (t == error_mark_node \|\| ! IS_AGGR_TYPE (t))
	{
	t = make_aggr_type (RECORD_TYPE);
	pushtag (make_anon_name (), t, /tag_scope=/ts_current);
	}

	/* Update the location of the decl. */
	DECL_SOURCE_LOCATION (TYPE_NAME (t)) = input_location;

	if (TYPE_BEING_DEFINED (t))
	{
	t = make_aggr_type (TREE_CODE (t));
	pushtag (TYPE_IDENTIFIER (t), t, /tag_scope=/ts_current);
	}
	maybe_process_partial_specialization (t);
	pushclass (t);
	TYPE_BEING_DEFINED (t) = 1;

	cplus_decl_attributes (&t, attributes, (int) ATTR_FLAG_TYPE_IN_PLACE);

	if (flag_pack_struct)
	{
	tree v;
	TYPE_PACKED (t) = 1;
	/* Even though the type is being defined for the first time
	here, there might have been a forward declaration, so there
	might be cv-qualified variants of T. */
	for (v = TYPE_NEXT_VARIANT (t); v; v = TYPE_NEXT_VARIANT (v))
	TYPE_PACKED (v) = 1;
	}
	/* Reset the interface data, at the earliest possible
	moment, as it might have been set via a class foo;
	before. */
	if (! TYPE_ANONYMOUS_P (t))
	{
	struct c_fileinfo *finfo = get_fileinfo (input_filename);
	CLASSTYPE_INTERFACE_ONLY (t) = finfo->interface_only;
	SET_CLASSTYPE_INTERFACE_UNKNOWN_X
	(t, finfo->interface_unknown);
	}
	reset_specialization();

	/* Make a declaration for this class in its own scope. */
	build_self_reference ();

	return t;
	}

	/* Finish the member declaration given by DECL. */

	void
	finish_member_declaration (tree decl)
	{
	if (decl == error_mark_node \|\| decl == NULL_TREE)
	return;

	if (decl == void_type_node)
	/* The COMPONENT was a friend, not a member, and so there's
	nothing for us to do. */
	return;

	/* We should see only one DECL at a time. */
	gcc_assert (TREE_CHAIN (decl) == NULL_TREE);

	/* Set up access control for DECL. */
	TREE_PRIVATE (decl)
	= (current_access_specifier == access_private_node);
	TREE_PROTECTED (decl)
	= (current_access_specifier == access_protected_node);
	if (TREE_CODE (decl) == TEMPLATE_DECL)
	{
	TREE_PRIVATE (DECL_TEMPLATE_RESULT (decl)) = TREE_PRIVATE (decl);
	TREE_PROTECTED (DECL_TEMPLATE_RESULT (decl)) = TREE_PROTECTED (decl);
	}

	/* Mark the DECL as a member of the current class. */
	DECL_CONTEXT (decl) = current_class_type;

	/* [dcl.link]

	A C language linkage is ignored for the names of class members
	and the member function type of class member functions. */
	if (DECL_LANG_SPECIFIC (decl) && DECL_LANGUAGE (decl) == lang_c)
	SET_DECL_LANGUAGE (decl, lang_cplusplus);

	/* Put functions on the TYPE_METHODS list and everything else on the
	TYPE_FIELDS list. Note that these are built up in reverse order.
	We reverse them (to obtain declaration order) in finish_struct. */
	if (TREE_CODE (decl) == FUNCTION_DECL
	\|\| DECL_FUNCTION_TEMPLATE_P (decl))
	{
	/* We also need to add this function to the
	CLASSTYPE_METHOD_VEC. */
	if (add_method (current_class_type, decl, NULL_TREE))
	{
	TREE_CHAIN (decl) = TYPE_METHODS (current_class_type);
	TYPE_METHODS (current_class_type) = decl;

	maybe_add_class_template_decl_list (current_class_type, decl,
	/friend_p=/0);
	}
	}
	/* Enter the DECL into the scope of the class. */
	else if ((TREE_CODE (decl) == USING_DECL && !DECL_DEPENDENT_P (decl))
	\|\| pushdecl_class_level (decl))
	{
	/* All TYPE_DECLs go at the end of TYPE_FIELDS. Ordinary fields
	go at the beginning. The reason is that lookup_field_1
	searches the list in order, and we want a field name to
	override a type name so that the "struct stat hack" will
	work. In particular:

	struct S { enum E { }; int E } s;
	s.E = 3;

	is valid. In addition, the FIELD_DECLs must be maintained in
	declaration order so that class layout works as expected.
	However, we don't need that order until class layout, so we
	save a little time by putting FIELD_DECLs on in reverse order
	here, and then reversing them in finish_struct_1. (We could
	also keep a pointer to the correct insertion points in the
	list.) */

	if (TREE_CODE (decl) == TYPE_DECL)
	TYPE_FIELDS (current_class_type)
	= chainon (TYPE_FIELDS (current_class_type), decl);
	else
	{
	TREE_CHAIN (decl) = TYPE_FIELDS (current_class_type);
	TYPE_FIELDS (current_class_type) = decl;
	}

	maybe_add_class_template_decl_list (current_class_type, decl,
	/friend_p=/0);
	}

	if (pch_file)
	note_decl_for_pch (decl);
	}

	/* DECL has been declared while we are building a PCH file. Perform
	actions that we might normally undertake lazily, but which can be
	performed now so that they do not have to be performed in
	translation units which include the PCH file. */

	void
	note_decl_for_pch (tree decl)
	{
	gcc_assert (pch_file);

	/* There's a good chance that we'll have to mangle names at some
	point, even if only for emission in debugging information. */
	if ((TREE_CODE (decl) == VAR_DECL
	\|\| TREE_CODE (decl) == FUNCTION_DECL)
	&& !processing_template_decl)
	mangle_decl (decl);
	}

	/* Finish processing a complete template declaration. The PARMS are
	the template parameters. */

	void
	finish_template_decl (tree parms)
	{
	if (parms)
	end_template_decl ();
	else
	end_specialization ();
	}

	/* Finish processing a template-id (which names a type) of the form
	NAME < ARGS >. Return the TYPE_DECL for the type named by the
	template-id. If ENTERING_SCOPE is nonzero we are about to enter
	the scope of template-id indicated. */

	tree
	finish_template_type (tree name, tree args, int entering_scope)
	{
	tree decl;

	decl = lookup_template_class (name, args,
	NULL_TREE, NULL_TREE, entering_scope,
	tf_warning_or_error \| tf_user);
	if (decl != error_mark_node)
	decl = TYPE_STUB_DECL (decl);

	return decl;
	}

	/* Finish processing a BASE_CLASS with the indicated ACCESS_SPECIFIER.
	Return a TREE_LIST containing the ACCESS_SPECIFIER and the
	BASE_CLASS, or NULL_TREE if an error occurred. The
	ACCESS_SPECIFIER is one of
	access_{default,public,protected_private}_node. For a virtual base
	we set TREE_TYPE. */

	tree
	finish_base_specifier (tree base, tree access, bool virtual_p)
	{
	tree result;

	if (base == error_mark_node)
	{
	error ("invalid base-class specification");
	result = NULL_TREE;
	}
	else if (! is_aggr_type (base, 1))
	result = NULL_TREE;
	else
	{
	if (cp_type_quals (base) != 0)
	{
	error ("base class %qT has cv qualifiers", base);
	base = TYPE_MAIN_VARIANT (base);
	}
	result = build_tree_list (access, base);
	if (virtual_p)
	TREE_TYPE (result) = integer_type_node;
	}

	return result;
	}

	/* Issue a diagnostic that NAME cannot be found in SCOPE. DECL is
	what we found when we tried to do the lookup. */

	void
	qualified_name_lookup_error (tree scope, tree name, tree decl)
	{
	if (scope == error_mark_node)
	; /* We already complained. */
	else if (TYPE_P (scope))
	{
	if (!COMPLETE_TYPE_P (scope))
	error ("incomplete type %qT used in nested name specifier", scope);
	else if (TREE_CODE (decl) == TREE_LIST)
	{
	error ("reference to %<%T::%D%> is ambiguous", scope, name);
	print_candidates (decl);
	}
	else
	error ("%qD is not a member of %qT", name, scope);
	}
	else if (scope != global_namespace)
	error ("%qD is not a member of %qD", name, scope);
	else
	error ("%<::%D%> has not been declared", name);
	}

	/* If FNS is a member function, a set of member functions, or a
	template-id referring to one or more member functions, return a
	BASELINK for FNS, incorporating the current access context.
	Otherwise, return FNS unchanged. */

	tree
	baselink_for_fns (tree fns)
	{
	tree fn;
	tree cl;

	if (BASELINK_P (fns)
	\|\| error_operand_p (fns))
	return fns;

	fn = fns;
	if (TREE_CODE (fn) == TEMPLATE_ID_EXPR)
	fn = TREE_OPERAND (fn, 0);
	fn = get_first_fn (fn);
	if (!DECL_FUNCTION_MEMBER_P (fn))
	return fns;

	cl = currently_open_derived_class (DECL_CONTEXT (fn));
	if (!cl)
	cl = DECL_CONTEXT (fn);
	cl = TYPE_BINFO (cl);
	return build_baselink (cl, cl, fns, /optype=/NULL_TREE);
	}

	/* ID_EXPRESSION is a representation of parsed, but unprocessed,
	id-expression. (See cp_parser_id_expression for details.) SCOPE,
	if non-NULL, is the type or namespace used to explicitly qualify
	ID_EXPRESSION. DECL is the entity to which that name has been
	resolved.

	*CONSTANT_EXPRESSION_P is true if we are presently parsing a
	constant-expression. In that case, *NON_CONSTANT_EXPRESSION_P will
	be set to true if this expression isn't permitted in a
	constant-expression, but it is otherwise not set by this function.
	*ALLOW_NON_CONSTANT_EXPRESSION_P is true if we are parsing a
	constant-expression, but a non-constant expression is also
	permissible.

	DONE is true if this expression is a complete postfix-expression;
	it is false if this expression is followed by '->', '[', '(', etc.
	ADDRESS_P is true iff this expression is the operand of '&'.
	TEMPLATE_P is true iff the qualified-id was of the form
	"A::template B". TEMPLATE_ARG_P is true iff this qualified name
	appears as a template argument.

	If an error occurs, and it is the kind of error that might cause
	the parser to abort a tentative parse, *ERROR_MSG is filled in. It
	is the caller's responsibility to issue the message. *ERROR_MSG
	will be a string with static storage duration, so the caller need
	not "free" it.

	Return an expression for the entity, after issuing appropriate
	diagnostics. This function is also responsible for transforming a
	reference to a non-static member into a COMPONENT_REF that makes
	the use of "this" explicit.

	Upon return, IDK will be filled in appropriately. /

	tree
	finish_id_expression (tree id_expression,
	tree decl,
	tree scope,
	cp_id_kind *idk,
	bool integral_constant_expression_p,
	bool allow_non_integral_constant_expression_p,
	bool *non_integral_constant_expression_p,
	bool template_p,
	bool done,
	bool address_p,
	bool template_arg_p,
	const char **error_msg)
	{
	/* Initialize the output parameters. */
	*idk = CP_ID_KIND_NONE;
	*error_msg = NULL;

	if (id_expression == error_mark_node)
	return error_mark_node;
	/* If we have a template-id, then no further lookup is
	required. If the template-id was for a template-class, we
	will sometimes have a TYPE_DECL at this point. */
	else if (TREE_CODE (decl) == TEMPLATE_ID_EXPR
	\|\| TREE_CODE (decl) == TYPE_DECL)
	;
	/* Look up the name. */
	else
	{
	if (decl == error_mark_node)
	{
	/* Name lookup failed. */
	if (scope
	&& (!TYPE_P (scope)
	\|\| (!dependent_type_p (scope)
	&& !(TREE_CODE (id_expression) == IDENTIFIER_NODE
	&& IDENTIFIER_TYPENAME_P (id_expression)
	&& dependent_type_p (TREE_TYPE (id_expression))))))
	{
	/* If the qualifying type is non-dependent (and the name
	does not name a conversion operator to a dependent
	type), issue an error. */
	qualified_name_lookup_error (scope, id_expression, decl);
	return error_mark_node;
	}
	else if (!scope)
	{
	/* It may be resolved via Koenig lookup. */
	*idk = CP_ID_KIND_UNQUALIFIED;
	return id_expression;
	}
	else
	decl = id_expression;
	}
	/* If DECL is a variable that would be out of scope under
	ANSI/ISO rules, but in scope in the ARM, name lookup
	will succeed. Issue a diagnostic here. */
	else
	decl = check_for_out_of_scope_variable (decl);

	/* Remember that the name was used in the definition of
	the current class so that we can check later to see if
	the meaning would have been different after the class
	was entirely defined. */
	if (!scope && decl != error_mark_node)
	maybe_note_name_used_in_class (id_expression, decl);

	/* Disallow uses of local variables from containing functions. */
	if (TREE_CODE (decl) == VAR_DECL \|\| TREE_CODE (decl) == PARM_DECL)
	{
	tree context = decl_function_context (decl);
	if (context != NULL_TREE && context != current_function_decl
	&& ! TREE_STATIC (decl))
	{
	error (TREE_CODE (decl) == VAR_DECL
	? "use of %<auto%> variable from containing function"
	: "use of parameter from containing function");
	error (" %q+#D declared here", decl);
	return error_mark_node;
	}
	}
	}

	/* If we didn't find anything, or what we found was a type,
	then this wasn't really an id-expression. */
	if (TREE_CODE (decl) == TEMPLATE_DECL
	&& !DECL_FUNCTION_TEMPLATE_P (decl))
	{
	*error_msg = "missing template arguments";
	return error_mark_node;
	}
	else if (TREE_CODE (decl) == TYPE_DECL
	\|\| TREE_CODE (decl) == NAMESPACE_DECL)
	{
	*error_msg = "expected primary-expression";
	return error_mark_node;
	}

	/* If the name resolved to a template parameter, there is no
	need to look it up again later. */
	if ((TREE_CODE (decl) == CONST_DECL && DECL_TEMPLATE_PARM_P (decl))
	\|\| TREE_CODE (decl) == TEMPLATE_PARM_INDEX)
	{
	tree r;

	*idk = CP_ID_KIND_NONE;
	if (TREE_CODE (decl) == TEMPLATE_PARM_INDEX)
	decl = TEMPLATE_PARM_DECL (decl);
	r = convert_from_reference (DECL_INITIAL (decl));

	if (integral_constant_expression_p
	&& !dependent_type_p (TREE_TYPE (decl))
	&& !(INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (r))))
	{
	if (!allow_non_integral_constant_expression_p)
	error ("template parameter %qD of type %qT is not allowed in "
	"an integral constant expression because it is not of "
	"integral or enumeration type", decl, TREE_TYPE (decl));
	*non_integral_constant_expression_p = true;
	}
	return r;
	}
	/* Similarly, we resolve enumeration constants to their
	underlying values. */
	else if (TREE_CODE (decl) == CONST_DECL)
	{
	*idk = CP_ID_KIND_NONE;
	if (!processing_template_decl)
	{
	used_types_insert (TREE_TYPE (decl));
	return DECL_INITIAL (decl);
	}
	return decl;
	}
	else
	{
	bool dependent_p;

	/* If the declaration was explicitly qualified indicate
	that. The semantics of `A::f(3)' are different than
	`f(3)' if `f' is virtual. */
	*idk = (scope
	? CP_ID_KIND_QUALIFIED
	: (TREE_CODE (decl) == TEMPLATE_ID_EXPR
	? CP_ID_KIND_TEMPLATE_ID
	: CP_ID_KIND_UNQUALIFIED));


	/* [temp.dep.expr]

	An id-expression is type-dependent if it contains an
	identifier that was declared with a dependent type.

	The standard is not very specific about an id-expression that
	names a set of overloaded functions. What if some of them
	have dependent types and some of them do not? Presumably,
	such a name should be treated as a dependent name. */
	/* Assume the name is not dependent. */
	dependent_p = false;
	if (!processing_template_decl)
	/* No names are dependent outside a template. */
	;
	/* A template-id where the name of the template was not resolved
	is definitely dependent. */
	else if (TREE_CODE (decl) == TEMPLATE_ID_EXPR
	&& (TREE_CODE (TREE_OPERAND (decl, 0))
	== IDENTIFIER_NODE))
	dependent_p = true;
	/* For anything except an overloaded function, just check its
	type. */
	else if (!is_overloaded_fn (decl))
	dependent_p
	= dependent_type_p (TREE_TYPE (decl));
	/* For a set of overloaded functions, check each of the
	functions. */
	else
	{
	tree fns = decl;

	if (BASELINK_P (fns))
	fns = BASELINK_FUNCTIONS (fns);

	/* For a template-id, check to see if the template
	arguments are dependent. */
	if (TREE_CODE (fns) == TEMPLATE_ID_EXPR)
	{
	tree args = TREE_OPERAND (fns, 1);
	dependent_p = any_dependent_template_arguments_p (args);
	/* The functions are those referred to by the
	template-id. */
	fns = TREE_OPERAND (fns, 0);
	}

	/* If there are no dependent template arguments, go through
	the overloaded functions. */
	while (fns && !dependent_p)
	{
	tree fn = OVL_CURRENT (fns);

	/* Member functions of dependent classes are
	dependent. */
	if (TREE_CODE (fn) == FUNCTION_DECL
	&& type_dependent_expression_p (fn))
	dependent_p = true;
	else if (TREE_CODE (fn) == TEMPLATE_DECL
	&& dependent_template_p (fn))
	dependent_p = true;

	fns = OVL_NEXT (fns);
	}
	}

	/* If the name was dependent on a template parameter, we will
	resolve the name at instantiation time. */
	if (dependent_p)
	{
	/* Create a SCOPE_REF for qualified names, if the scope is
	dependent. */
	if (scope)
	{
	/* Since this name was dependent, the expression isn't
	constant -- yet. No error is issued because it might
	be constant when things are instantiated. */
	if (integral_constant_expression_p)
	*non_integral_constant_expression_p = true;
	if (TYPE_P (scope))
	{
	if (address_p && done)
	decl = finish_qualified_id_expr (scope, decl,
	done, address_p,
	template_p,
	template_arg_p);
	else if (dependent_type_p (scope))
	decl = build_qualified_name (/type=/NULL_TREE,
	scope,
	id_expression,
	template_p);
	else if (DECL_P (decl))
	decl = build_qualified_name (TREE_TYPE (decl),
	scope,
	id_expression,
	template_p);
	}
	if (TREE_TYPE (decl))
	decl = convert_from_reference (decl);
	return decl;
	}
	/* A TEMPLATE_ID already contains all the information we
	need. */
	if (TREE_CODE (id_expression) == TEMPLATE_ID_EXPR)
	return id_expression;
	*idk = CP_ID_KIND_UNQUALIFIED_DEPENDENT;
	/* If we found a variable, then name lookup during the
	instantiation will always resolve to the same VAR_DECL
	(or an instantiation thereof). */
	if (TREE_CODE (decl) == VAR_DECL
	\|\| TREE_CODE (decl) == PARM_DECL)
	return convert_from_reference (decl);
	/* The same is true for FIELD_DECL, but we also need to
	make sure that the syntax is correct. */
	else if (TREE_CODE (decl) == FIELD_DECL)
	{
	/* Since SCOPE is NULL here, this is an unqualified name.
	Access checking has been performed during name lookup
	already. Turn off checking to avoid duplicate errors. */
	push_deferring_access_checks (dk_no_check);
	decl = finish_non_static_data_member
	(decl, current_class_ref,
	/qualifying_scope=/NULL_TREE);
	pop_deferring_access_checks ();
	return decl;
	}
	return id_expression;
	}

	/* Only certain kinds of names are allowed in constant
	expression. Enumerators and template parameters have already
	been handled above. */
	if (integral_constant_expression_p
	&& ! DECL_INTEGRAL_CONSTANT_VAR_P (decl)
	&& ! builtin_valid_in_constant_expr_p (decl))
	{
	if (!allow_non_integral_constant_expression_p)
	{
	error ("%qD cannot appear in a constant-expression", decl);
	return error_mark_node;
	}
	*non_integral_constant_expression_p = true;
	}

	if (TREE_CODE (decl) == NAMESPACE_DECL)
	{
	error ("use of namespace %qD as expression", decl);
	return error_mark_node;
	}
	else if (DECL_CLASS_TEMPLATE_P (decl))
	{
	error ("use of class template %qT as expression", decl);
	return error_mark_node;
	}
	else if (TREE_CODE (decl) == TREE_LIST)
	{
	/* Ambiguous reference to base members. */
	error ("request for member %qD is ambiguous in "
	"multiple inheritance lattice", id_expression);
	print_candidates (decl);
	return error_mark_node;
	}

	/* Mark variable-like entities as used. Functions are similarly
	marked either below or after overload resolution. */
	if (TREE_CODE (decl) == VAR_DECL
	\|\| TREE_CODE (decl) == PARM_DECL
	\|\| TREE_CODE (decl) == RESULT_DECL)
	mark_used (decl);

	if (scope)
	{
	decl = (adjust_result_of_qualified_name_lookup
	(decl, scope, current_class_type));

	if (TREE_CODE (decl) == FUNCTION_DECL)
	mark_used (decl);

	if (TREE_CODE (decl) == FIELD_DECL \|\| BASELINK_P (decl))
	decl = finish_qualified_id_expr (scope,
	decl,
	done,
	address_p,
	template_p,
	template_arg_p);
	else
	{
	tree r = convert_from_reference (decl);

	if (processing_template_decl && TYPE_P (scope))
	r = build_qualified_name (TREE_TYPE (r),
	scope, decl,
	template_p);
	decl = r;
	}
	}
	else if (TREE_CODE (decl) == FIELD_DECL)
	{
	/* Since SCOPE is NULL here, this is an unqualified name.
	Access checking has been performed during name lookup
	already. Turn off checking to avoid duplicate errors. */
	push_deferring_access_checks (dk_no_check);
	decl = finish_non_static_data_member (decl, current_class_ref,
	/qualifying_scope=/NULL_TREE);
	pop_deferring_access_checks ();
	}
	else if (is_overloaded_fn (decl))
	{
	tree first_fn;

	first_fn = decl;
	if (TREE_CODE (first_fn) == TEMPLATE_ID_EXPR)
	first_fn = TREE_OPERAND (first_fn, 0);
	first_fn = get_first_fn (first_fn);
	if (TREE_CODE (first_fn) == TEMPLATE_DECL)
	first_fn = DECL_TEMPLATE_RESULT (first_fn);

	if (!really_overloaded_fn (decl))
	mark_used (first_fn);

	if (!template_arg_p
	&& TREE_CODE (first_fn) == FUNCTION_DECL
	&& DECL_FUNCTION_MEMBER_P (first_fn)
	&& !shared_member_p (decl))
	{
	/* A set of member functions. */
	decl = maybe_dummy_object (DECL_CONTEXT (first_fn), 0);
	return finish_class_member_access_expr (decl, id_expression,
	/template_p=/false);
	}

	decl = baselink_for_fns (decl);
	}
	else
	{
	if (DECL_P (decl) && DECL_NONLOCAL (decl)
	&& DECL_CLASS_SCOPE_P (decl)
	&& DECL_CONTEXT (decl) != current_class_type)
	{
	tree path;

	path = currently_open_derived_class (DECL_CONTEXT (decl));
	perform_or_defer_access_check (TYPE_BINFO (path), decl, decl);
	}

	decl = convert_from_reference (decl);
	}
	}

	if (TREE_DEPRECATED (decl))
	warn_deprecated_use (decl);

	return decl;
	}

	/* Implement the __typeof keyword: Return the type of EXPR, suitable for
	use as a type-specifier. */

	tree
	finish_typeof (tree expr)
	{
	tree type;

	if (type_dependent_expression_p (expr))
	{
	type = make_aggr_type (TYPEOF_TYPE);
	TYPEOF_TYPE_EXPR (type) = expr;

	return type;
	}

	type = unlowered_expr_type (expr);

	if (!type \|\| type == unknown_type_node)
	{
	error ("type of %qE is unknown", expr);
	return error_mark_node;
	}

	return type;
	}

	/* Perform C++-specific checks for __builtin_offsetof before calling
	fold_offsetof. */

	tree
	finish_offsetof (tree expr)
	{
	if (TREE_CODE (expr) == PSEUDO_DTOR_EXPR)
	{
	error ("cannot apply %<offsetof%> to destructor %<~%T%>",
	TREE_OPERAND (expr, 2));
	return error_mark_node;
	}
	if (TREE_CODE (TREE_TYPE (expr)) == FUNCTION_TYPE
	\|\| TREE_CODE (TREE_TYPE (expr)) == METHOD_TYPE
	\|\| TREE_CODE (TREE_TYPE (expr)) == UNKNOWN_TYPE)
	{
	if (TREE_CODE (expr) == COMPONENT_REF
	\|\| TREE_CODE (expr) == COMPOUND_EXPR)
	expr = TREE_OPERAND (expr, 1);
	error ("cannot apply %<offsetof%> to member function %qD", expr);
	return error_mark_node;
	}
	return fold_offsetof (expr, NULL_TREE);
	}

	/* Called from expand_body via walk_tree. Replace all AGGR_INIT_EXPRs
	with equivalent CALL_EXPRs. */

	static tree
	simplify_aggr_init_exprs_r (tree* tp,
	int* walk_subtrees,
	void* data ATTRIBUTE_UNUSED)
	{
	/* We don't need to walk into types; there's nothing in a type that
	needs simplification. (And, furthermore, there are places we
	actively don't want to go. For example, we don't want to wander
	into the default arguments for a FUNCTION_DECL that appears in a
	CALL_EXPR.) */
	if (TYPE_P (*tp))
	{
	*walk_subtrees = 0;
	return NULL_TREE;
	}
	/* Only AGGR_INIT_EXPRs are interesting. */
	else if (TREE_CODE (*tp) != AGGR_INIT_EXPR)
	return NULL_TREE;

	simplify_aggr_init_expr (tp);

	/* Keep iterating. */
	return NULL_TREE;
	}

	/* Replace the AGGR_INIT_EXPR at *TP with an equivalent CALL_EXPR. This
	function is broken out from the above for the benefit of the tree-ssa
	project. */

	void
	simplify_aggr_init_expr (tree *tp)
	{
	tree aggr_init_expr = *tp;

	/* Form an appropriate CALL_EXPR. */
	tree fn = TREE_OPERAND (aggr_init_expr, 0);
	tree args = TREE_OPERAND (aggr_init_expr, 1);
	tree slot = TREE_OPERAND (aggr_init_expr, 2);
	tree type = TREE_TYPE (slot);

	tree call_expr;
	enum style_t { ctor, arg, pcc } style;

	if (AGGR_INIT_VIA_CTOR_P (aggr_init_expr))
	style = ctor;
	#ifdef PCC_STATIC_STRUCT_RETURN
	else if (1)
	style = pcc;
	#endif
	else
	{
	gcc_assert (TREE_ADDRESSABLE (type));
	style = arg;
	}

	if (style == ctor)
	{
	/* Replace the first argument to the ctor with the address of the
	slot. */
	tree addr;

	args = TREE_CHAIN (args);
	cxx_mark_addressable (slot);
	addr = build1 (ADDR_EXPR, build_pointer_type (type), slot);
	args = tree_cons (NULL_TREE, addr, args);
	}

	call_expr = build3 (CALL_EXPR,
	TREE_TYPE (TREE_TYPE (TREE_TYPE (fn))),
	fn, args, NULL_TREE);

	if (style == arg)
	{
	/* Just mark it addressable here, and leave the rest to
	expand_call{,_inline}. */
	cxx_mark_addressable (slot);
	CALL_EXPR_RETURN_SLOT_OPT (call_expr) = true;
	call_expr = build2 (MODIFY_EXPR, TREE_TYPE (call_expr), slot, call_expr);
	}
	else if (style == pcc)
	{
	/* If we're using the non-reentrant PCC calling convention, then we
	need to copy the returned value out of the static buffer into the
	SLOT. */
	push_deferring_access_checks (dk_no_check);
	call_expr = build_aggr_init (slot, call_expr,
	DIRECT_BIND \| LOOKUP_ONLYCONVERTING);
	pop_deferring_access_checks ();
	call_expr = build2 (COMPOUND_EXPR, TREE_TYPE (slot), call_expr, slot);
	}

	*tp = call_expr;
	}

	/* Emit all thunks to FN that should be emitted when FN is emitted. */

	static void
	emit_associated_thunks (tree fn)
	{
	/* When we use vcall offsets, we emit thunks with the virtual
	functions to which they thunk. The whole point of vcall offsets
	is so that you can know statically the entire set of thunks that
	will ever be needed for a given virtual function, thereby
	enabling you to output all the thunks with the function itself. */
	if (DECL_VIRTUAL_P (fn))
	{
	tree thunk;

	for (thunk = DECL_THUNKS (fn); thunk; thunk = TREE_CHAIN (thunk))
	{
	if (!THUNK_ALIAS (thunk))
	{
	use_thunk (thunk, /emit_p=/1);
	if (DECL_RESULT_THUNK_P (thunk))
	{
	tree probe;

	for (probe = DECL_THUNKS (thunk);
	probe; probe = TREE_CHAIN (probe))
	use_thunk (probe, /emit_p=/1);
	}
	}
	else
	gcc_assert (!DECL_THUNKS (thunk));
	}
	}
	}

	/* Generate RTL for FN. */

	void
	expand_body (tree fn)
	{
	tree saved_function;

	/* Compute the appropriate object-file linkage for inline
	functions. */
	if (DECL_DECLARED_INLINE_P (fn))
	import_export_decl (fn);

	/* If FN is external, then there's no point in generating RTL for
	it. This situation can arise with an inline function under
	`-fexternal-templates'; we instantiate the function, even though
	we're not planning on emitting it, in case we get a chance to
	inline it. */
	if (DECL_EXTERNAL (fn))
	return;

	/* ??? When is this needed? */
	saved_function = current_function_decl;

	/* Emit any thunks that should be emitted at the same time as FN. */
	emit_associated_thunks (fn);

	/* This function is only called from cgraph, or recursively from
	emit_associated_thunks. In neither case should we be currently
	generating trees for a function. */
	gcc_assert (function_depth == 0);

	tree_rest_of_compilation (fn);

	current_function_decl = saved_function;

	if (DECL_CLONED_FUNCTION_P (fn))
	{
	/* If this is a clone, go through the other clones now and mark
	their parameters used. We have to do that here, as we don't
	know whether any particular clone will be expanded, and
	therefore cannot pick one arbitrarily. */
	tree probe;

	for (probe = TREE_CHAIN (DECL_CLONED_FUNCTION (fn));
	probe && DECL_CLONED_FUNCTION_P (probe);
	probe = TREE_CHAIN (probe))
	{
	tree parms;

	for (parms = DECL_ARGUMENTS (probe);
	parms; parms = TREE_CHAIN (parms))
	TREE_USED (parms) = 1;
	}
	}
	}

	/* Generate RTL for FN. */

	void
	expand_or_defer_fn (tree fn)
	{
	/* When the parser calls us after finishing the body of a template
	function, we don't really want to expand the body. */
	if (processing_template_decl)
	{
	/* Normally, collection only occurs in rest_of_compilation. So,
	if we don't collect here, we never collect junk generated
	during the processing of templates until we hit a
	non-template function. It's not safe to do this inside a
	nested class, though, as the parser may have local state that
	is not a GC root. */
	if (!function_depth)
	ggc_collect ();
	return;
	}

	/* Replace AGGR_INIT_EXPRs with appropriate CALL_EXPRs. */
	walk_tree_without_duplicates (&DECL_SAVED_TREE (fn),
	simplify_aggr_init_exprs_r,
	NULL);

	/* If this is a constructor or destructor body, we have to clone
	it. */
	if (maybe_clone_body (fn))
	{
	/* We don't want to process FN again, so pretend we've written
	it out, even though we haven't. */
	TREE_ASM_WRITTEN (fn) = 1;
	return;
	}

	/* If this function is marked with the constructor attribute, add it
	to the list of functions to be called along with constructors
	from static duration objects. */
	if (DECL_STATIC_CONSTRUCTOR (fn))
	static_ctors = tree_cons (NULL_TREE, fn, static_ctors);

	/* If this function is marked with the destructor attribute, add it
	to the list of functions to be called along with destructors from
	static duration objects. */
	if (DECL_STATIC_DESTRUCTOR (fn))
	static_dtors = tree_cons (NULL_TREE, fn, static_dtors);

	/* We make a decision about linkage for these functions at the end
	of the compilation. Until that point, we do not want the back
	end to output them -- but we do want it to see the bodies of
	these functions so that it can inline them as appropriate. */
	if (DECL_DECLARED_INLINE_P (fn) \|\| DECL_IMPLICIT_INSTANTIATION (fn))
	{
	if (DECL_INTERFACE_KNOWN (fn))
	/* We've already made a decision as to how this function will
	be handled. */;
	else if (!at_eof)
	{
	DECL_EXTERNAL (fn) = 1;
	DECL_NOT_REALLY_EXTERN (fn) = 1;
	note_vague_linkage_fn (fn);
	/* A non-template inline function with external linkage will
	always be COMDAT. As we must eventually determine the
	linkage of all functions, and as that causes writes to
	the data mapped in from the PCH file, it's advantageous
	to mark the functions at this point. */
	if (!DECL_IMPLICIT_INSTANTIATION (fn))
	{
	/* This function must have external linkage, as
	otherwise DECL_INTERFACE_KNOWN would have been
	set. */
	gcc_assert (TREE_PUBLIC (fn));
	comdat_linkage (fn);
	DECL_INTERFACE_KNOWN (fn) = 1;
	}
	}
	else
	import_export_decl (fn);

	/* If the user wants us to keep all inline functions, then mark
	this function as needed so that finish_file will make sure to
	output it later. */
	if (flag_keep_inline_functions && DECL_DECLARED_INLINE_P (fn))
	mark_needed (fn);
	}

	/* There's no reason to do any of the work here if we're only doing
	semantic analysis; this code just generates RTL. */
	if (flag_syntax_only)
	return;

	function_depth++;

	/* Expand or defer, at the whim of the compilation unit manager. */
	cgraph_finalize_function (fn, function_depth > 1);

	function_depth--;
	}

	struct nrv_data
	{
	tree var;
	tree result;
	htab_t visited;
	};

	/* Helper function for walk_tree, used by finalize_nrv below. */

	static tree
	finalize_nrv_r (tree* tp, int* walk_subtrees, void* data)
	{
	struct nrv_data dp = (struct nrv_data )data;
	void **slot;

	/* No need to walk into types. There wouldn't be any need to walk into
	non-statements, except that we have to consider STMT_EXPRs. */
	if (TYPE_P (*tp))
	*walk_subtrees = 0;
	/* Change all returns to just refer to the RESULT_DECL; this is a nop,
	but differs from using NULL_TREE in that it indicates that we care
	about the value of the RESULT_DECL. */
	else if (TREE_CODE (*tp) == RETURN_EXPR)
	TREE_OPERAND (*tp, 0) = dp->result;
	/* Change all cleanups for the NRV to only run when an exception is
	thrown. */
	else if (TREE_CODE (*tp) == CLEANUP_STMT
	&& CLEANUP_DECL (*tp) == dp->var)
	CLEANUP_EH_ONLY (*tp) = 1;
	/* Replace the DECL_EXPR for the NRV with an initialization of the
	RESULT_DECL, if needed. */
	else if (TREE_CODE (*tp) == DECL_EXPR
	&& DECL_EXPR_DECL (*tp) == dp->var)
	{
	tree init;
	if (DECL_INITIAL (dp->var)
	&& DECL_INITIAL (dp->var) != error_mark_node)
	{
	init = build2 (INIT_EXPR, void_type_node, dp->result,
	DECL_INITIAL (dp->var));
	DECL_INITIAL (dp->var) = error_mark_node;
	}
	else
	init = build_empty_stmt ();
	SET_EXPR_LOCUS (init, EXPR_LOCUS (*tp));
	*tp = init;
	}
	/* And replace all uses of the NRV with the RESULT_DECL. */
	else if (*tp == dp->var)
	*tp = dp->result;

	/* Avoid walking into the same tree more than once. Unfortunately, we
	can't just use walk_tree_without duplicates because it would only call
	us for the first occurrence of dp->var in the function body. */
	slot = htab_find_slot (dp->visited, *tp, INSERT);
	if (*slot)
	*walk_subtrees = 0;
	else
	slot = tp;

	/* Keep iterating. */
	return NULL_TREE;
	}

	/* Called from finish_function to implement the named return value
	optimization by overriding all the RETURN_EXPRs and pertinent
	CLEANUP_STMTs and replacing all occurrences of VAR with RESULT, the
	RESULT_DECL for the function. */

	void
	finalize_nrv (tree *tp, tree var, tree result)
	{
	struct nrv_data data;

	/* Copy debugging information from VAR to RESULT. */
	DECL_NAME (result) = DECL_NAME (var);
	DECL_ARTIFICIAL (result) = DECL_ARTIFICIAL (var);
	DECL_IGNORED_P (result) = DECL_IGNORED_P (var);
	DECL_SOURCE_LOCATION (result) = DECL_SOURCE_LOCATION (var);
	DECL_ABSTRACT_ORIGIN (result) = DECL_ABSTRACT_ORIGIN (var);
	/* Don't forget that we take its address. */
	TREE_ADDRESSABLE (result) = TREE_ADDRESSABLE (var);

	data.var = var;
	data.result = result;
	data.visited = htab_create (37, htab_hash_pointer, htab_eq_pointer, NULL);
	walk_tree (tp, finalize_nrv_r, &data, 0);
	htab_delete (data.visited);
	}

	/* For all elements of CLAUSES, validate them vs OpenMP constraints.
	Remove any elements from the list that are invalid. */

	tree
	finish_omp_clauses (tree clauses)
	{
	bitmap_head generic_head, firstprivate_head, lastprivate_head;
	tree c, t, *pc = &clauses;
	const char *name;

	bitmap_obstack_initialize (NULL);
	bitmap_initialize (&generic_head, &bitmap_default_obstack);
	bitmap_initialize (&firstprivate_head, &bitmap_default_obstack);
	bitmap_initialize (&lastprivate_head, &bitmap_default_obstack);

	for (pc = &clauses, c = clauses; c ; c = *pc)
	{
	bool remove = false;

	switch (OMP_CLAUSE_CODE (c))
	{
	case OMP_CLAUSE_SHARED:
	name = "shared";
	goto check_dup_generic;
	case OMP_CLAUSE_PRIVATE:
	name = "private";
	goto check_dup_generic;
	case OMP_CLAUSE_REDUCTION:
	name = "reduction";
	goto check_dup_generic;
	case OMP_CLAUSE_COPYPRIVATE:
	name = "copyprivate";
	goto check_dup_generic;
	case OMP_CLAUSE_COPYIN:
	name = "copyin";
	goto check_dup_generic;
	check_dup_generic:
	t = OMP_CLAUSE_DECL (c);
	if (TREE_CODE (t) != VAR_DECL && TREE_CODE (t) != PARM_DECL)
	{
	if (processing_template_decl)
	break;
	if (DECL_P (t))
	error ("%qD is not a variable in clause %qs", t, name);
	else
	error ("%qE is not a variable in clause %qs", t, name);
	remove = true;
	}
	else if (bitmap_bit_p (&generic_head, DECL_UID (t))
	\|\| bitmap_bit_p (&firstprivate_head, DECL_UID (t))
	\|\| bitmap_bit_p (&lastprivate_head, DECL_UID (t)))
	{
	error ("%qD appears more than once in data clauses", t);
	remove = true;
	}
	else
	bitmap_set_bit (&generic_head, DECL_UID (t));
	break;

	case OMP_CLAUSE_FIRSTPRIVATE:
	t = OMP_CLAUSE_DECL (c);
	if (TREE_CODE (t) != VAR_DECL && TREE_CODE (t) != PARM_DECL)
	{
	if (processing_template_decl)
	break;
	error ("%qE is not a variable in clause %<firstprivate%>", t);
	remove = true;
	}
	else if (bitmap_bit_p (&generic_head, DECL_UID (t))
	\|\| bitmap_bit_p (&firstprivate_head, DECL_UID (t)))
	{
	error ("%qE appears more than once in data clauses", t);
	remove = true;
	}
	else
	bitmap_set_bit (&firstprivate_head, DECL_UID (t));
	break;

	case OMP_CLAUSE_LASTPRIVATE:
	t = OMP_CLAUSE_DECL (c);
	if (TREE_CODE (t) != VAR_DECL && TREE_CODE (t) != PARM_DECL)
	{
	if (processing_template_decl)
	break;
	error ("%qE is not a variable in clause %<lastprivate%>", t);
	remove = true;
	}
	else if (bitmap_bit_p (&generic_head, DECL_UID (t))
	\|\| bitmap_bit_p (&lastprivate_head, DECL_UID (t)))
	{
	error ("%qE appears more than once in data clauses", t);
	remove = true;
	}
	else
	bitmap_set_bit (&lastprivate_head, DECL_UID (t));
	break;

	case OMP_CLAUSE_IF:
	t = OMP_CLAUSE_IF_EXPR (c);
	t = maybe_convert_cond (t);
	if (t == error_mark_node)
	remove = true;
	OMP_CLAUSE_IF_EXPR (c) = t;
	break;

	case OMP_CLAUSE_NUM_THREADS:
	t = OMP_CLAUSE_NUM_THREADS_EXPR (c);
	if (t == error_mark_node)
	remove = true;
	else if (!INTEGRAL_TYPE_P (TREE_TYPE (t))
	&& !type_dependent_expression_p (t))
	{
	error ("num_threads expression must be integral");
	remove = true;
	}
	break;

	case OMP_CLAUSE_SCHEDULE:
	t = OMP_CLAUSE_SCHEDULE_CHUNK_EXPR (c);
	if (t == NULL)
	;
	else if (t == error_mark_node)
	remove = true;
	else if (!INTEGRAL_TYPE_P (TREE_TYPE (t))
	&& !type_dependent_expression_p (t))
	{
	error ("schedule chunk size expression must be integral");
	remove = true;
	}
	break;

	case OMP_CLAUSE_NOWAIT:
	case OMP_CLAUSE_ORDERED:
	case OMP_CLAUSE_DEFAULT:
	break;

	default:
	gcc_unreachable ();
	}

	if (remove)
	*pc = OMP_CLAUSE_CHAIN (c);
	else
	pc = &OMP_CLAUSE_CHAIN (c);
	}

	for (pc = &clauses, c = clauses; c ; c = *pc)
	{
	enum tree_code c_kind = OMP_CLAUSE_CODE (c);
	bool remove = false;
	bool need_complete_non_reference = false;
	bool need_default_ctor = false;
	bool need_copy_ctor = false;
	bool need_copy_assignment = false;
	bool need_implicitly_determined = false;
	tree type, inner_type;

	switch (c_kind)
	{
	case OMP_CLAUSE_SHARED:
	name = "shared";
	need_implicitly_determined = true;
	break;
	case OMP_CLAUSE_PRIVATE:
	name = "private";
	need_complete_non_reference = true;
	need_default_ctor = true;
	need_implicitly_determined = true;
	break;
	case OMP_CLAUSE_FIRSTPRIVATE:
	name = "firstprivate";
	need_complete_non_reference = true;
	need_copy_ctor = true;
	need_implicitly_determined = true;
	break;
	case OMP_CLAUSE_LASTPRIVATE:
	name = "lastprivate";
	need_complete_non_reference = true;
	need_copy_assignment = true;
	need_implicitly_determined = true;
	break;
	case OMP_CLAUSE_REDUCTION:
	name = "reduction";
	need_implicitly_determined = true;
	break;
	case OMP_CLAUSE_COPYPRIVATE:
	name = "copyprivate";
	need_copy_assignment = true;
	break;
	case OMP_CLAUSE_COPYIN:
	name = "copyin";
	need_copy_assignment = true;
	break;
	default:
	pc = &OMP_CLAUSE_CHAIN (c);
	continue;
	}

	t = OMP_CLAUSE_DECL (c);
	if (processing_template_decl
	&& TREE_CODE (t) != VAR_DECL && TREE_CODE (t) != PARM_DECL)
	{
	pc = &OMP_CLAUSE_CHAIN (c);
	continue;
	}

	switch (c_kind)
	{
	case OMP_CLAUSE_LASTPRIVATE:
	if (!bitmap_bit_p (&firstprivate_head, DECL_UID (t)))
	need_default_ctor = true;
	break;

	case OMP_CLAUSE_REDUCTION:
	if (AGGREGATE_TYPE_P (TREE_TYPE (t))
	\|\| POINTER_TYPE_P (TREE_TYPE (t)))
	{
	error ("%qE has invalid type for %<reduction%>", t);
	remove = true;
	}
	else if (FLOAT_TYPE_P (TREE_TYPE (t)))
	{
	enum tree_code r_code = OMP_CLAUSE_REDUCTION_CODE (c);
	switch (r_code)
	{
	case PLUS_EXPR:
	case MULT_EXPR:
	case MINUS_EXPR:
	break;
	default:
	error ("%qE has invalid type for %<reduction(%s)%>",
	t, operator_name_info[r_code].name);
	remove = true;
	}
	}
	break;

	case OMP_CLAUSE_COPYIN:
	if (TREE_CODE (t) != VAR_DECL \|\| !DECL_THREAD_LOCAL_P (t))
	{
	error ("%qE must be %<threadprivate%> for %<copyin%>", t);
	remove = true;
	}
	break;

	default:
	break;
	}

	if (need_complete_non_reference)
	{
	t = require_complete_type (t);
	if (t == error_mark_node)
	remove = true;
	else if (TREE_CODE (TREE_TYPE (t)) == REFERENCE_TYPE)
	{
	error ("%qE has reference type for %qs", t, name);
	remove = true;
	}
	}
	if (need_implicitly_determined)
	{
	const char *share_name = NULL;

	if (TREE_CODE (t) == VAR_DECL && DECL_THREAD_LOCAL_P (t))
	share_name = "threadprivate";
	else switch (cxx_omp_predetermined_sharing (t))
	{
	case OMP_CLAUSE_DEFAULT_UNSPECIFIED:
	break;
	case OMP_CLAUSE_DEFAULT_SHARED:
	share_name = "shared";
	break;
	case OMP_CLAUSE_DEFAULT_PRIVATE:
	share_name = "private";
	break;
	default:
	gcc_unreachable ();
	}
	if (share_name)
	{
	error ("%qE is predetermined %qs for %qs",
	t, share_name, name);
	remove = true;
	}
	}

	/* We're interested in the base element, not arrays. */
	inner_type = type = TREE_TYPE (t);
	while (TREE_CODE (inner_type) == ARRAY_TYPE)
	inner_type = TREE_TYPE (inner_type);

	/* Check for special function availability by building a call to one.
	Save the results, because later we won't be in the right context
	for making these queries. */
	if (CLASS_TYPE_P (inner_type)
	&& (need_default_ctor \|\| need_copy_ctor \|\| need_copy_assignment)
	&& !type_dependent_expression_p (t))
	{
	int save_errorcount = errorcount;
	tree info;

	/* Always allocate 3 elements for simplicity. These are the
	function decls for the ctor, dtor, and assignment op.
	This layout is known to the three lang hooks,
	cxx_omp_clause_default_init, cxx_omp_clause_copy_init,
	and cxx_omp_clause_assign_op. */
	info = make_tree_vec (3);
	CP_OMP_CLAUSE_INFO (c) = info;

	if (need_default_ctor
	\|\| (need_copy_ctor
	&& !TYPE_HAS_TRIVIAL_INIT_REF (inner_type)))
	{
	if (need_default_ctor)
	t = NULL;
	else
	{
	t = build_int_cst (build_pointer_type (inner_type), 0);
	t = build1 (INDIRECT_REF, inner_type, t);
	t = build_tree_list (NULL, t);
	}
	t = build_special_member_call (NULL_TREE,
	complete_ctor_identifier,
	t, inner_type, LOOKUP_NORMAL);
	t = get_callee_fndecl (t);
	TREE_VEC_ELT (info, 0) = t;
	}

	if ((need_default_ctor \|\| need_copy_ctor)
	&& TYPE_HAS_NONTRIVIAL_DESTRUCTOR (inner_type))
	{
	t = build_int_cst (build_pointer_type (inner_type), 0);
	t = build1 (INDIRECT_REF, inner_type, t);
	t = build_special_member_call (t, complete_dtor_identifier,
	NULL, inner_type, LOOKUP_NORMAL);
	t = get_callee_fndecl (t);
	TREE_VEC_ELT (info, 1) = t;
	}

	if (need_copy_assignment
	&& !TYPE_HAS_TRIVIAL_ASSIGN_REF (inner_type))
	{
	t = build_int_cst (build_pointer_type (inner_type), 0);
	t = build1 (INDIRECT_REF, inner_type, t);
	t = build_special_member_call (t, ansi_assopname (NOP_EXPR),
	build_tree_list (NULL, t),
	inner_type, LOOKUP_NORMAL);

	/* We'll have called convert_from_reference on the call, which
	may well have added an indirect_ref. It's unneeded here,
	and in the way, so kill it. */
	if (TREE_CODE (t) == INDIRECT_REF)
	t = TREE_OPERAND (t, 0);

	t = get_callee_fndecl (t);
	TREE_VEC_ELT (info, 2) = t;
	}

	if (errorcount != save_errorcount)
	remove = true;
	}

	if (remove)
	*pc = OMP_CLAUSE_CHAIN (c);
	else
	pc = &OMP_CLAUSE_CHAIN (c);
	}

	bitmap_obstack_release (NULL);
	return clauses;
	}

	/* For all variables in the tree_list VARS, mark them as thread local. */

	void
	finish_omp_threadprivate (tree vars)
	{
	tree t;

	/* Mark every variable in VARS to be assigned thread local storage. */
	for (t = vars; t; t = TREE_CHAIN (t))
	{
	tree v = TREE_PURPOSE (t);

	/* If V had already been marked threadprivate, it doesn't matter
	whether it had been used prior to this point. */
	if (TREE_USED (v)
	&& (DECL_LANG_SPECIFIC (v) == NULL
	\|\| !CP_DECL_THREADPRIVATE_P (v)))
	error ("%qE declared %<threadprivate%> after first use", v);
	else if (! TREE_STATIC (v) && ! DECL_EXTERNAL (v))
	error ("automatic variable %qE cannot be %<threadprivate%>", v);
	else if (! COMPLETE_TYPE_P (TREE_TYPE (v)))
	error ("%<threadprivate%> %qE has incomplete type", v);
	else if (TREE_STATIC (v) && TYPE_P (CP_DECL_CONTEXT (v)))
	error ("%<threadprivate%> %qE is not file, namespace "
	"or block scope variable", v);
	else
	{
	/* Allocate a LANG_SPECIFIC structure for V, if needed. */
	if (DECL_LANG_SPECIFIC (v) == NULL)
	{
	retrofit_lang_decl (v);

	/* Make sure that DECL_DISCRIMINATOR_P continues to be true
	after the allocation of the lang_decl structure. */
	if (DECL_DISCRIMINATOR_P (v))
	DECL_LANG_SPECIFIC (v)->decl_flags.u2sel = 1;
	}

	if (! DECL_THREAD_LOCAL_P (v))
	{
	DECL_TLS_MODEL (v) = decl_default_tls_model (v);
	/* If rtl has been already set for this var, call
	make_decl_rtl once again, so that encode_section_info
	has a chance to look at the new decl flags. */
	if (DECL_RTL_SET_P (v))
	make_decl_rtl (v);
	}
	CP_DECL_THREADPRIVATE_P (v) = 1;
	}
	}
	}

	/* Build an OpenMP structured block. */

	tree
	begin_omp_structured_block (void)
	{
	return do_pushlevel (sk_omp);
	}

	tree
	finish_omp_structured_block (tree block)
	{
	return do_poplevel (block);
	}

	/* Similarly, except force the retention of the BLOCK. */

	tree
	begin_omp_parallel (void)
	{
	keep_next_level (true);
	return begin_omp_structured_block ();
	}

	tree
	finish_omp_parallel (tree clauses, tree body)
	{
	tree stmt;

	body = finish_omp_structured_block (body);

	stmt = make_node (OMP_PARALLEL);
	TREE_TYPE (stmt) = void_type_node;
	OMP_PARALLEL_CLAUSES (stmt) = clauses;
	OMP_PARALLEL_BODY (stmt) = body;

	return add_stmt (stmt);
	}

	/* Build and validate an OMP_FOR statement. CLAUSES, BODY, COND, INCR
	are directly for their associated operands in the statement. DECL
	and INIT are a combo; if DECL is NULL then INIT ought to be a
	MODIFY_EXPR, and the DECL should be extracted. PRE_BODY are
	optional statements that need to go before the loop into its
	sk_omp scope. */

	tree
	finish_omp_for (location_t locus, tree decl, tree init, tree cond,
	tree incr, tree body, tree pre_body)
	{
	if (decl == NULL)
	{
	if (init != NULL)
	switch (TREE_CODE (init))
	{
	case MODIFY_EXPR:
	decl = TREE_OPERAND (init, 0);
	init = TREE_OPERAND (init, 1);
	break;
	case MODOP_EXPR:
	if (TREE_CODE (TREE_OPERAND (init, 1)) == NOP_EXPR)
	{
	decl = TREE_OPERAND (init, 0);
	init = TREE_OPERAND (init, 2);
	}
	break;
	default:
	break;
	}

	if (decl == NULL)
	{
	error ("expected iteration declaration or initialization");
	return NULL;
	}
	}

	if (type_dependent_expression_p (decl)
	\|\| type_dependent_expression_p (init)
	\|\| (cond && type_dependent_expression_p (cond))
	\|\| (incr && type_dependent_expression_p (incr)))
	{
	tree stmt;

	if (cond == NULL)
	{
	error ("%Hmissing controlling predicate", &locus);
	return NULL;
	}

	if (incr == NULL)
	{
	error ("%Hmissing increment expression", &locus);
	return NULL;
	}

	stmt = make_node (OMP_FOR);

	/* This is really just a place-holder. We'll be decomposing this
	again and going through the build_modify_expr path below when
	we instantiate the thing. */
	init = build2 (MODIFY_EXPR, void_type_node, decl, init);

	TREE_TYPE (stmt) = void_type_node;
	OMP_FOR_INIT (stmt) = init;
	OMP_FOR_COND (stmt) = cond;
	OMP_FOR_INCR (stmt) = incr;
	OMP_FOR_BODY (stmt) = body;
	OMP_FOR_PRE_BODY (stmt) = pre_body;

	SET_EXPR_LOCATION (stmt, locus);
	return add_stmt (stmt);
	}

	if (!DECL_P (decl))
	{
	error ("expected iteration declaration or initialization");
	return NULL;
	}

	if (pre_body == NULL \|\| IS_EMPTY_STMT (pre_body))
	pre_body = NULL;
	else if (! processing_template_decl)
	{
	add_stmt (pre_body);
	pre_body = NULL;
	}
	init = build_modify_expr (decl, NOP_EXPR, init);
	return c_finish_omp_for (locus, decl, init, cond, incr, body, pre_body);
	}

	void
	finish_omp_atomic (enum tree_code code, tree lhs, tree rhs)
	{
	tree orig_lhs;
	tree orig_rhs;
	bool dependent_p;
	tree stmt;

	orig_lhs = lhs;
	orig_rhs = rhs;
	dependent_p = false;
	stmt = NULL_TREE;

	/* Even in a template, we can detect invalid uses of the atomic
	pragma if neither LHS nor RHS is type-dependent. */
	if (processing_template_decl)
	{
	dependent_p = (type_dependent_expression_p (lhs)
	\|\| type_dependent_expression_p (rhs));
	if (!dependent_p)
	{
	lhs = build_non_dependent_expr (lhs);
	rhs = build_non_dependent_expr (rhs);
	}
	}
	if (!dependent_p)
	{
	stmt = c_finish_omp_atomic (code, lhs, rhs);
	if (stmt == error_mark_node)
	return;
	}
	if (processing_template_decl)
	{
	stmt = build2 (OMP_ATOMIC, void_type_node, orig_lhs, orig_rhs);
	OMP_ATOMIC_DEPENDENT_P (stmt) = 1;
	OMP_ATOMIC_CODE (stmt) = code;
	}
	add_stmt (stmt);
	}

	void
	finish_omp_barrier (void)
	{
	tree fn = built_in_decls[BUILT_IN_GOMP_BARRIER];
	tree stmt = finish_call_expr (fn, NULL, false, false);
	finish_expr_stmt (stmt);
	}

	void
	finish_omp_flush (void)
	{
	tree fn = built_in_decls[BUILT_IN_SYNCHRONIZE];
	tree stmt = finish_call_expr (fn, NULL, false, false);
	finish_expr_stmt (stmt);
	}

	/* True if OpenMP sharing attribute of DECL is predetermined. */

	enum omp_clause_default_kind
	cxx_omp_predetermined_sharing (tree decl)
	{
	enum omp_clause_default_kind kind;

	kind = c_omp_predetermined_sharing (decl);
	if (kind != OMP_CLAUSE_DEFAULT_UNSPECIFIED)
	return kind;

	/* Static data members are predetermined as shared. */
	if (TREE_STATIC (decl))
	{
	tree ctx = CP_DECL_CONTEXT (decl);
	if (TYPE_P (ctx) && IS_AGGR_TYPE (ctx))
	return OMP_CLAUSE_DEFAULT_SHARED;
	}

	return OMP_CLAUSE_DEFAULT_UNSPECIFIED;
	}

	void
	init_cp_semantics (void)
	{
	}

	#include "gt-cp-semantics.h"
	diff --git a/contrib/gcc/doc/extend.texi b/contrib/gcc/doc/extend.texi
	index c6bd57d1dea2..db6f1bd892a1 100644
	--- a/contrib/gcc/doc/extend.texi
	+++ b/contrib/gcc/doc/extend.texi
	@@ -1,11195 +1,11269 @@
	@c Copyright (C) 1988, 1989, 1992, 1993, 1994, 1996, 1998, 1999, 2000,
	@c 2001, 2002, 2003, 2004, 2005, 2006 Free Software Foundation, Inc.

	@c This is part of the GCC manual.
	@c For copying conditions, see the file gcc.texi.

	@node C Extensions
	@chapter Extensions to the C Language Family
	@cindex extensions, C language
	@cindex C language extensions

	@opindex pedantic
	GNU C provides several language features not found in ISO standard C@.
	(The @option{-pedantic} option directs GCC to print a warning message if
	any of these features is used.) To test for the availability of these
	features in conditional compilation, check for a predefined macro
	@code{__GNUC__}, which is always defined under GCC@.

	These extensions are available in C. Most of them are also available
	in C++. @xref{C++ Extensions,,Extensions to the C++ Language}, for
	extensions that apply @emph{only} to C++.

	Some features that are in ISO C99 but not C89 or C++ are also, as
	extensions, accepted by GCC in C89 mode and in C++.

	@menu
	* Statement Exprs:: Putting statements and declarations inside expressions.
	* Local Labels:: Labels local to a block.
	* Labels as Values:: Getting pointers to labels, and computed gotos.
	* Nested Functions:: As in Algol and Pascal, lexical scoping of functions.
	* Constructing Calls:: Dispatching a call to another function.
	* Typeof:: @code{typeof}: referring to the type of an expression.
	* Conditionals:: Omitting the middle operand of a @samp{?:} expression.
	* Long Long:: Double-word integers---@code{long long int}.
	* Complex:: Data types for complex numbers.
	* Decimal Float:: Decimal Floating Types.
	* Hex Floats:: Hexadecimal floating-point constants.
	* Zero Length:: Zero-length arrays.
	* Variable Length:: Arrays whose length is computed at run time.
	* Empty Structures:: Structures with no members.
	* Variadic Macros:: Macros with a variable number of arguments.
	* Escaped Newlines:: Slightly looser rules for escaped newlines.
	* Subscripting:: Any array can be subscripted, even if not an lvalue.
	* Pointer Arith:: Arithmetic on @code{void}-pointers and function pointers.
	* Initializers:: Non-constant initializers.
	* Compound Literals:: Compound literals give structures, unions
	or arrays as values.
	* Designated Inits:: Labeling elements of initializers.
	* Cast to Union:: Casting to union type from any member of the union.
	* Case Ranges:: `case 1 ... 9' and such.
	* Mixed Declarations:: Mixing declarations and code.
	* Function Attributes:: Declaring that functions have no side effects,
	or that they can never return.
	* Attribute Syntax:: Formal syntax for attributes.
	* Function Prototypes:: Prototype declarations and old-style definitions.
	* C++ Comments:: C++ comments are recognized.
	* Dollar Signs:: Dollar sign is allowed in identifiers.
	* Character Escapes:: @samp{\e} stands for the character @key{ESC}.
	* Variable Attributes:: Specifying attributes of variables.
	* Type Attributes:: Specifying attributes of types.
	+@c APPLE LOCAL begin for-fsf-4_4 3274130 5295549
	+* Label Attributes:: Specifying attributes of labels and statements.
	+@c APPLE LOCAL end for-fsf-4_4 3274130 5295549
	* Alignment:: Inquiring about the alignment of a type or variable.
	* Inline:: Defining inline functions (as fast as macros).
	* Extended Asm:: Assembler instructions with C expressions as operands.
	(With them you can define ``built-in'' functions.)
	* Constraints:: Constraints for asm operands
	* Asm Labels:: Specifying the assembler name to use for a C symbol.
	* Explicit Reg Vars:: Defining variables residing in specified registers.
	* Alternate Keywords:: @code{__const__}, @code{__asm__}, etc., for header files.
	* Incomplete Enums:: @code{enum foo;}, with details to follow.
	* Function Names:: Printable strings which are the name of the current
	function.
	* Return Address:: Getting the return or frame address of a function.
	* Vector Extensions:: Using vector instructions through built-in functions.
	* Offsetof:: Special syntax for implementing @code{offsetof}.
	* Atomic Builtins:: Built-in functions for atomic memory access.
	* Object Size Checking:: Built-in functions for limited buffer overflow
	checking.
	* Other Builtins:: Other built-in functions.
	* Target Builtins:: Built-in functions specific to particular targets.
	* Target Format Checks:: Format checks specific to particular targets.
	* Pragmas:: Pragmas accepted by GCC.
	* Unnamed Fields:: Unnamed struct/union fields within structs/unions.
	* Thread-Local:: Per-thread variables.
	* Binary constants:: Binary constants using the @samp{0b} prefix.
	@end menu

	@node Statement Exprs
	@section Statements and Declarations in Expressions
	@cindex statements inside expressions
	@cindex declarations inside expressions
	@cindex expressions containing statements
	@cindex macros, statements in expressions

	@c the above section title wrapped and causes an underfull hbox.. i
	@c changed it from "within" to "in". --mew 4feb93
	A compound statement enclosed in parentheses may appear as an expression
	in GNU C@. This allows you to use loops, switches, and local variables
	within an expression.

	Recall that a compound statement is a sequence of statements surrounded
	by braces; in this construct, parentheses go around the braces. For
	example:

	@smallexample
	(@{ int y = foo (); int z;
	if (y > 0) z = y;
	else z = - y;
	z; @})
	@end smallexample

	@noindent
	is a valid (though slightly more complex than necessary) expression
	for the absolute value of @code{foo ()}.

	The last thing in the compound statement should be an expression
	followed by a semicolon; the value of this subexpression serves as the
	value of the entire construct. (If you use some other kind of statement
	last within the braces, the construct has type @code{void}, and thus
	effectively no value.)

	This feature is especially useful in making macro definitions ``safe'' (so
	that they evaluate each operand exactly once). For example, the
	``maximum'' function is commonly defined as a macro in standard C as
	follows:

	@smallexample
	#define max(a,b) ((a) > (b) ? (a) : (b))
	@end smallexample

	@noindent
	@cindex side effects, macro argument
	But this definition computes either @var{a} or @var{b} twice, with bad
	results if the operand has side effects. In GNU C, if you know the
	type of the operands (here taken as @code{int}), you can define
	the macro safely as follows:

	@smallexample
	#define maxint(a,b) \
	(@{int _a = (a), _b = (b); _a > _b ? _a : _b; @})
	@end smallexample

	Embedded statements are not allowed in constant expressions, such as
	the value of an enumeration constant, the width of a bit-field, or
	the initial value of a static variable.

	If you don't know the type of the operand, you can still do this, but you
	must use @code{typeof} (@pxref{Typeof}).

	In G++, the result value of a statement expression undergoes array and
	function pointer decay, and is returned by value to the enclosing
	expression. For instance, if @code{A} is a class, then

	@smallexample
	A a;

	(@{a;@}).Foo ()
	@end smallexample

	@noindent
	will construct a temporary @code{A} object to hold the result of the
	statement expression, and that will be used to invoke @code{Foo}.
	Therefore the @code{this} pointer observed by @code{Foo} will not be the
	address of @code{a}.

	Any temporaries created within a statement within a statement expression
	will be destroyed at the statement's end. This makes statement
	expressions inside macros slightly different from function calls. In
	the latter case temporaries introduced during argument evaluation will
	be destroyed at the end of the statement that includes the function
	call. In the statement expression case they will be destroyed during
	the statement expression. For instance,

	@smallexample
	#define macro(a) (@{__typeof__(a) b = (a); b + 3; @})
	template<typename T> T function(T a) @{ T b = a; return b + 3; @}

	void foo ()
	@{
	macro (X ());
	function (X ());
	@}
	@end smallexample

	@noindent
	will have different places where temporaries are destroyed. For the
	@code{macro} case, the temporary @code{X} will be destroyed just after
	the initialization of @code{b}. In the @code{function} case that
	temporary will be destroyed when the function returns.

	These considerations mean that it is probably a bad idea to use
	statement-expressions of this form in header files that are designed to
	work with C++. (Note that some versions of the GNU C Library contained
	header files using statement-expression that lead to precisely this
	bug.)

	Jumping into a statement expression with @code{goto} or using a
	@code{switch} statement outside the statement expression with a
	@code{case} or @code{default} label inside the statement expression is
	not permitted. Jumping into a statement expression with a computed
	@code{goto} (@pxref{Labels as Values}) yields undefined behavior.
	Jumping out of a statement expression is permitted, but if the
	statement expression is part of a larger expression then it is
	unspecified which other subexpressions of that expression have been
	evaluated except where the language definition requires certain
	subexpressions to be evaluated before or after the statement
	expression. In any case, as with a function call the evaluation of a
	statement expression is not interleaved with the evaluation of other
	parts of the containing expression. For example,

	@smallexample
	foo (), ((@{ bar1 (); goto a; 0; @}) + bar2 ()), baz();
	@end smallexample

	@noindent
	will call @code{foo} and @code{bar1} and will not call @code{baz} but
	may or may not call @code{bar2}. If @code{bar2} is called, it will be
	called after @code{foo} and before @code{bar1}

	@node Local Labels
	@section Locally Declared Labels
	@cindex local labels
	@cindex macros, local labels

	GCC allows you to declare @dfn{local labels} in any nested block
	scope. A local label is just like an ordinary label, but you can
	only reference it (with a @code{goto} statement, or by taking its
	address) within the block in which it was declared.

	A local label declaration looks like this:

	@smallexample
	__label__ @var{label};
	@end smallexample

	@noindent
	or

	@smallexample
	__label__ @var{label1}, @var{label2}, /* @r{@dots{}} */;
	@end smallexample

	Local label declarations must come at the beginning of the block,
	before any ordinary declarations or statements.

	The label declaration defines the label @emph{name}, but does not define
	the label itself. You must do this in the usual way, with
	@code{@var{label}:}, within the statements of the statement expression.

	The local label feature is useful for complex macros. If a macro
	contains nested loops, a @code{goto} can be useful for breaking out of
	them. However, an ordinary label whose scope is the whole function
	cannot be used: if the macro can be expanded several times in one
	function, the label will be multiply defined in that function. A
	local label avoids this problem. For example:

	@smallexample
	#define SEARCH(value, array, target) \
	do @{ \
	__label__ found; \
	typeof (target) _SEARCH_target = (target); \
	typeof ((array)) _SEARCH_array = (array); \
	int i, j; \
	int value; \
	for (i = 0; i < max; i++) \
	for (j = 0; j < max; j++) \
	if (_SEARCH_array[i][j] == _SEARCH_target) \
	@{ (value) = i; goto found; @} \
	(value) = -1; \
	found:; \
	@} while (0)
	@end smallexample

	This could also be written using a statement-expression:

	@smallexample
	#define SEARCH(array, target) \
	(@{ \
	__label__ found; \
	typeof (target) _SEARCH_target = (target); \
	typeof ((array)) _SEARCH_array = (array); \
	int i, j; \
	int value; \
	for (i = 0; i < max; i++) \
	for (j = 0; j < max; j++) \
	if (_SEARCH_array[i][j] == _SEARCH_target) \
	@{ value = i; goto found; @} \
	value = -1; \
	found: \
	value; \
	@})
	@end smallexample

	Local label declarations also make the labels they declare visible to
	nested functions, if there are any. @xref{Nested Functions}, for details.

	@node Labels as Values
	@section Labels as Values
	@cindex labels as values
	@cindex computed gotos
	@cindex goto with computed label
	@cindex address of a label

	You can get the address of a label defined in the current function
	(or a containing function) with the unary operator @samp{&&}. The
	value has type @code{void *}. This value is a constant and can be used
	wherever a constant of that type is valid. For example:

	@smallexample
	void *ptr;
	/* @r{@dots{}} */
	ptr = &&foo;
	@end smallexample

	To use these values, you need to be able to jump to one. This is done
	with the computed goto statement@footnote{The analogous feature in
	Fortran is called an assigned goto, but that name seems inappropriate in
	C, where one can do more than simply store label addresses in label
	variables.}, @code{goto *@var{exp};}. For example,

	@smallexample
	goto *ptr;
	@end smallexample

	@noindent
	Any expression of type @code{void *} is allowed.

	One way of using these constants is in initializing a static array that
	will serve as a jump table:

	@smallexample
	static void *array[] = @{ &&foo, &&bar, &&hack @};
	@end smallexample

	Then you can select a label with indexing, like this:

	@smallexample
	goto *array[i];
	@end smallexample

	@noindent
	Note that this does not check whether the subscript is in bounds---array
	indexing in C never does that.

	Such an array of label values serves a purpose much like that of the
	@code{switch} statement. The @code{switch} statement is cleaner, so
	use that rather than an array unless the problem does not fit a
	@code{switch} statement very well.

	Another use of label values is in an interpreter for threaded code.
	The labels within the interpreter function can be stored in the
	threaded code for super-fast dispatching.

	You may not use this mechanism to jump to code in a different function.
	If you do that, totally unpredictable things will happen. The best way to
	avoid this is to store the label address only in automatic variables and
	never pass it as an argument.

	An alternate way to write the above example is

	@smallexample
	static const int array[] = @{ &&foo - &&foo, &&bar - &&foo,
	&&hack - &&foo @};
	goto *(&&foo + array[i]);
	@end smallexample

	@noindent
	This is more friendly to code living in shared libraries, as it reduces
	the number of dynamic relocations that are needed, and by consequence,
	allows the data to be read-only.

	@node Nested Functions
	@section Nested Functions
	@cindex nested functions
	@cindex downward funargs
	@cindex thunks

	A @dfn{nested function} is a function defined inside another function.
	(Nested functions are not supported for GNU C++.) The nested function's
	name is local to the block where it is defined. For example, here we
	define a nested function named @code{square}, and call it twice:

	@smallexample
	@group
	foo (double a, double b)
	@{
	double square (double z) @{ return z * z; @}

	return square (a) + square (b);
	@}
	@end group
	@end smallexample

	The nested function can access all the variables of the containing
	function that are visible at the point of its definition. This is
	called @dfn{lexical scoping}. For example, here we show a nested
	function which uses an inherited variable named @code{offset}:

	@smallexample
	@group
	bar (int *array, int offset, int size)
	@{
	int access (int *array, int index)
	@{ return array[index + offset]; @}
	int i;
	/* @r{@dots{}} */
	for (i = 0; i < size; i++)
	/* @r{@dots{}} / access (array, i) / @r{@dots{}} */
	@}
	@end group
	@end smallexample

	Nested function definitions are permitted within functions in the places
	where variable definitions are allowed; that is, in any block, mixed
	with the other declarations and statements in the block.

	It is possible to call the nested function from outside the scope of its
	name by storing its address or passing the address to another function:

	@smallexample
	hack (int *array, int size)
	@{
	void store (int index, int value)
	@{ array[index] = value; @}

	intermediate (store, size);
	@}
	@end smallexample

	Here, the function @code{intermediate} receives the address of
	@code{store} as an argument. If @code{intermediate} calls @code{store},
	the arguments given to @code{store} are used to store into @code{array}.
	But this technique works only so long as the containing function
	(@code{hack}, in this example) does not exit.

	If you try to call the nested function through its address after the
	containing function has exited, all hell will break loose. If you try
	to call it after a containing scope level has exited, and if it refers
	to some of the variables that are no longer in scope, you may be lucky,
	but it's not wise to take the risk. If, however, the nested function
	does not refer to anything that has gone out of scope, you should be
	safe.

	GCC implements taking the address of a nested function using a technique
	called @dfn{trampolines}. A paper describing them is available as

	@noindent
	@uref{http://people.debian.org/~aaronl/Usenix88-lexic.pdf}.

	A nested function can jump to a label inherited from a containing
	function, provided the label was explicitly declared in the containing
	function (@pxref{Local Labels}). Such a jump returns instantly to the
	containing function, exiting the nested function which did the
	@code{goto} and any intermediate functions as well. Here is an example:

	@smallexample
	@group
	bar (int *array, int offset, int size)
	@{
	__label__ failure;
	int access (int *array, int index)
	@{
	if (index > size)
	goto failure;
	return array[index + offset];
	@}
	int i;
	/* @r{@dots{}} */
	for (i = 0; i < size; i++)
	/* @r{@dots{}} / access (array, i) / @r{@dots{}} */
	/* @r{@dots{}} */
	return 0;

	/* @r{Control comes here from @code{access}
	if it detects an error.} */
	failure:
	return -1;
	@}
	@end group
	@end smallexample

	A nested function always has no linkage. Declaring one with
	@code{extern} or @code{static} is erroneous. If you need to declare the nested function
	before its definition, use @code{auto} (which is otherwise meaningless
	for function declarations).

	@smallexample
	bar (int *array, int offset, int size)
	@{
	__label__ failure;
	auto int access (int *, int);
	/* @r{@dots{}} */
	int access (int *array, int index)
	@{
	if (index > size)
	goto failure;
	return array[index + offset];
	@}
	/* @r{@dots{}} */
	@}
	@end smallexample

	@node Constructing Calls
	@section Constructing Function Calls
	@cindex constructing calls
	@cindex forwarding calls

	Using the built-in functions described below, you can record
	the arguments a function received, and call another function
	with the same arguments, without knowing the number or types
	of the arguments.

	You can also record the return value of that function call,
	and later return that value, without knowing what data type
	the function tried to return (as long as your caller expects
	that data type).

	However, these built-in functions may interact badly with some
	sophisticated features or other extensions of the language. It
	is, therefore, not recommended to use them outside very simple
	functions acting as mere forwarders for their arguments.

	@deftypefn {Built-in Function} {void *} __builtin_apply_args ()
	This built-in function returns a pointer to data
	describing how to perform a call with the same arguments as were passed
	to the current function.

	The function saves the arg pointer register, structure value address,
	and all registers that might be used to pass arguments to a function
	into a block of memory allocated on the stack. Then it returns the
	address of that block.
	@end deftypefn

	@deftypefn {Built-in Function} {void } __builtin_apply (void (@var{function})(), void *@var{arguments}, size_t @var{size})
	This built-in function invokes @var{function}
	with a copy of the parameters described by @var{arguments}
	and @var{size}.

	The value of @var{arguments} should be the value returned by
	@code{__builtin_apply_args}. The argument @var{size} specifies the size
	of the stack argument data, in bytes.

	This function returns a pointer to data describing
	how to return whatever value was returned by @var{function}. The data
	is saved in a block of memory allocated on the stack.

	It is not always simple to compute the proper value for @var{size}. The
	value is used by @code{__builtin_apply} to compute the amount of data
	that should be pushed on the stack and copied from the incoming argument
	area.
	@end deftypefn

	@deftypefn {Built-in Function} {void} __builtin_return (void *@var{result})
	This built-in function returns the value described by @var{result} from
	the containing function. You should specify, for @var{result}, a value
	returned by @code{__builtin_apply}.
	@end deftypefn

	@node Typeof
	@section Referring to a Type with @code{typeof}
	@findex typeof
	@findex sizeof
	@cindex macros, types of arguments

	Another way to refer to the type of an expression is with @code{typeof}.
	The syntax of using of this keyword looks like @code{sizeof}, but the
	construct acts semantically like a type name defined with @code{typedef}.

	There are two ways of writing the argument to @code{typeof}: with an
	expression or with a type. Here is an example with an expression:

	@smallexample
	typeof (x[0](1))
	@end smallexample

	@noindent
	This assumes that @code{x} is an array of pointers to functions;
	the type described is that of the values of the functions.

	Here is an example with a typename as the argument:

	@smallexample
	typeof (int *)
	@end smallexample

	@noindent
	Here the type described is that of pointers to @code{int}.

	If you are writing a header file that must work when included in ISO C
	programs, write @code{__typeof__} instead of @code{typeof}.
	@xref{Alternate Keywords}.

	A @code{typeof}-construct can be used anywhere a typedef name could be
	used. For example, you can use it in a declaration, in a cast, or inside
	of @code{sizeof} or @code{typeof}.

	@code{typeof} is often useful in conjunction with the
	statements-within-expressions feature. Here is how the two together can
	be used to define a safe ``maximum'' macro that operates on any
	arithmetic type and evaluates each of its arguments exactly once:

	@smallexample
	#define max(a,b) \
	(@{ typeof (a) _a = (a); \
	typeof (b) _b = (b); \
	_a > _b ? _a : _b; @})
	@end smallexample

	@cindex underscores in variables in macros
	@cindex @samp{_} in variables in macros
	@cindex local variables in macros
	@cindex variables, local, in macros
	@cindex macros, local variables in

	The reason for using names that start with underscores for the local
	variables is to avoid conflicts with variable names that occur within the
	expressions that are substituted for @code{a} and @code{b}. Eventually we
	hope to design a new form of declaration syntax that allows you to declare
	variables whose scopes start only after their initializers; this will be a
	more reliable way to prevent such conflicts.

	@noindent
	Some more examples of the use of @code{typeof}:

	@itemize @bullet
	@item
	This declares @code{y} with the type of what @code{x} points to.

	@smallexample
	typeof (*x) y;
	@end smallexample

	@item
	This declares @code{y} as an array of such values.

	@smallexample
	typeof (*x) y[4];
	@end smallexample

	@item
	This declares @code{y} as an array of pointers to characters:

	@smallexample
	typeof (typeof (char *)[4]) y;
	@end smallexample

	@noindent
	It is equivalent to the following traditional C declaration:

	@smallexample
	char *y[4];
	@end smallexample

	To see the meaning of the declaration using @code{typeof}, and why it
	might be a useful way to write, rewrite it with these macros:

	@smallexample
	#define pointer(T) typeof(T *)
	#define array(T, N) typeof(T [N])
	@end smallexample

	@noindent
	Now the declaration can be rewritten this way:

	@smallexample
	array (pointer (char), 4) y;
	@end smallexample

	@noindent
	Thus, @code{array (pointer (char), 4)} is the type of arrays of 4
	pointers to @code{char}.
	@end itemize

	@emph{Compatibility Note:} In addition to @code{typeof}, GCC 2 supported
	a more limited extension which permitted one to write

	@smallexample
	typedef @var{T} = @var{expr};
	@end smallexample

	@noindent
	with the effect of declaring @var{T} to have the type of the expression
	@var{expr}. This extension does not work with GCC 3 (versions between
	3.0 and 3.2 will crash; 3.2.1 and later give an error). Code which
	relies on it should be rewritten to use @code{typeof}:

	@smallexample
	typedef typeof(@var{expr}) @var{T};
	@end smallexample

	@noindent
	This will work with all versions of GCC@.

	@node Conditionals
	@section Conditionals with Omitted Operands
	@cindex conditional expressions, extensions
	@cindex omitted middle-operands
	@cindex middle-operands, omitted
	@cindex extensions, @code{?:}
	@cindex @code{?:} extensions

	The middle operand in a conditional expression may be omitted. Then
	if the first operand is nonzero, its value is the value of the conditional
	expression.

	Therefore, the expression

	@smallexample
	x ? : y
	@end smallexample

	@noindent
	has the value of @code{x} if that is nonzero; otherwise, the value of
	@code{y}.

	This example is perfectly equivalent to

	@smallexample
	x ? x : y
	@end smallexample

	@cindex side effect in ?:
	@cindex ?: side effect
	@noindent
	In this simple case, the ability to omit the middle operand is not
	especially useful. When it becomes useful is when the first operand does,
	or may (if it is a macro argument), contain a side effect. Then repeating
	the operand in the middle would perform the side effect twice. Omitting
	the middle operand uses the value already computed without the undesirable
	effects of recomputing it.

	@node Long Long
	@section Double-Word Integers
	@cindex @code{long long} data types
	@cindex double-word arithmetic
	@cindex multiprecision arithmetic
	@cindex @code{LL} integer suffix
	@cindex @code{ULL} integer suffix

	ISO C99 supports data types for integers that are at least 64 bits wide,
	and as an extension GCC supports them in C89 mode and in C++.
	Simply write @code{long long int} for a signed integer, or
	@code{unsigned long long int} for an unsigned integer. To make an
	integer constant of type @code{long long int}, add the suffix @samp{LL}
	to the integer. To make an integer constant of type @code{unsigned long
	long int}, add the suffix @samp{ULL} to the integer.

	You can use these types in arithmetic like any other integer types.
	Addition, subtraction, and bitwise boolean operations on these types
	are open-coded on all types of machines. Multiplication is open-coded
	if the machine supports fullword-to-doubleword a widening multiply
	instruction. Division and shifts are open-coded only on machines that
	provide special support. The operations that are not open-coded use
	special library routines that come with GCC@.

	There may be pitfalls when you use @code{long long} types for function
	arguments, unless you declare function prototypes. If a function
	expects type @code{int} for its argument, and you pass a value of type
	@code{long long int}, confusion will result because the caller and the
	subroutine will disagree about the number of bytes for the argument.
	Likewise, if the function expects @code{long long int} and you pass
	@code{int}. The best way to avoid such problems is to use prototypes.

	@node Complex
	@section Complex Numbers
	@cindex complex numbers
	@cindex @code{_Complex} keyword
	@cindex @code{__complex__} keyword

	ISO C99 supports complex floating data types, and as an extension GCC
	supports them in C89 mode and in C++, and supports complex integer data
	types which are not part of ISO C99. You can declare complex types
	using the keyword @code{_Complex}. As an extension, the older GNU
	keyword @code{__complex__} is also supported.

	For example, @samp{_Complex double x;} declares @code{x} as a
	variable whose real part and imaginary part are both of type
	@code{double}. @samp{_Complex short int y;} declares @code{y} to
	have real and imaginary parts of type @code{short int}; this is not
	likely to be useful, but it shows that the set of complex types is
	complete.

	To write a constant with a complex data type, use the suffix @samp{i} or
	@samp{j} (either one; they are equivalent). For example, @code{2.5fi}
	has type @code{_Complex float} and @code{3i} has type
	@code{_Complex int}. Such a constant always has a pure imaginary
	value, but you can form any complex value you like by adding one to a
	real constant. This is a GNU extension; if you have an ISO C99
	conforming C library (such as GNU libc), and want to construct complex
	constants of floating type, you should include @code{<complex.h>} and
	use the macros @code{I} or @code{_Complex_I} instead.

	@cindex @code{__real__} keyword
	@cindex @code{__imag__} keyword
	To extract the real part of a complex-valued expression @var{exp}, write
	@code{__real__ @var{exp}}. Likewise, use @code{__imag__} to
	extract the imaginary part. This is a GNU extension; for values of
	floating type, you should use the ISO C99 functions @code{crealf},
	@code{creal}, @code{creall}, @code{cimagf}, @code{cimag} and
	@code{cimagl}, declared in @code{<complex.h>} and also provided as
	built-in functions by GCC@.

	@cindex complex conjugation
	The operator @samp{~} performs complex conjugation when used on a value
	with a complex type. This is a GNU extension; for values of
	floating type, you should use the ISO C99 functions @code{conjf},
	@code{conj} and @code{conjl}, declared in @code{<complex.h>} and also
	provided as built-in functions by GCC@.

	GCC can allocate complex automatic variables in a noncontiguous
	fashion; it's even possible for the real part to be in a register while
	the imaginary part is on the stack (or vice-versa). Only the DWARF2
	debug info format can represent this, so use of DWARF2 is recommended.
	If you are using the stabs debug info format, GCC describes a noncontiguous
	complex variable as if it were two separate variables of noncomplex type.
	If the variable's actual name is @code{foo}, the two fictitious
	variables are named @code{foo$real} and @code{foo$imag}. You can
	examine and set these two fictitious variables with your debugger.

	@node Decimal Float
	@section Decimal Floating Types
	@cindex decimal floating types
	@cindex @code{_Decimal32} data type
	@cindex @code{_Decimal64} data type
	@cindex @code{_Decimal128} data type
	@cindex @code{df} integer suffix
	@cindex @code{dd} integer suffix
	@cindex @code{dl} integer suffix
	@cindex @code{DF} integer suffix
	@cindex @code{DD} integer suffix
	@cindex @code{DL} integer suffix

	As an extension, the GNU C compiler supports decimal floating types as
	defined in the N1176 draft of ISO/IEC WDTR24732. Support for decimal
	floating types in GCC will evolve as the draft technical report changes.
	Calling conventions for any target might also change. Not all targets
	support decimal floating types.

	The decimal floating types are @code{_Decimal32}, @code{_Decimal64}, and
	@code{_Decimal128}. They use a radix of ten, unlike the floating types
	@code{float}, @code{double}, and @code{long double} whose radix is not
	specified by the C standard but is usually two.

	Support for decimal floating types includes the arithmetic operators
	add, subtract, multiply, divide; unary arithmetic operators;
	relational operators; equality operators; and conversions to and from
	integer and other floating types. Use a suffix @samp{df} or
	@samp{DF} in a literal constant of type @code{_Decimal32}, @samp{dd}
	or @samp{DD} for @code{_Decimal64}, and @samp{dl} or @samp{DL} for
	@code{_Decimal128}.

	GCC support of decimal float as specified by the draft technical report
	is incomplete:

	@itemize @bullet
	@item
	Translation time data type (TTDT) is not supported.

	@item
	Characteristics of decimal floating types are defined in header file
	@file{decfloat.h} rather than @file{float.h}.

	@item
	When the value of a decimal floating type cannot be represented in the
	integer type to which it is being converted, the result is undefined
	rather than the result value specified by the draft technical report.
	@end itemize

	Types @code{_Decimal32}, @code{_Decimal64}, and @code{_Decimal128}
	are supported by the DWARF2 debug information format.

	@node Hex Floats
	@section Hex Floats
	@cindex hex floats

	ISO C99 supports floating-point numbers written not only in the usual
	decimal notation, such as @code{1.55e1}, but also numbers such as
	@code{0x1.fp3} written in hexadecimal format. As a GNU extension, GCC
	supports this in C89 mode (except in some cases when strictly
	conforming) and in C++. In that format the
	@samp{0x} hex introducer and the @samp{p} or @samp{P} exponent field are
	mandatory. The exponent is a decimal number that indicates the power of
	2 by which the significant part will be multiplied. Thus @samp{0x1.f} is
	@tex
	$1 {15\over16}$,
	@end tex
	@ifnottex
	1 15/16,
	@end ifnottex
	@samp{p3} multiplies it by 8, and the value of @code{0x1.fp3}
	is the same as @code{1.55e1}.

	Unlike for floating-point numbers in the decimal notation the exponent
	is always required in the hexadecimal notation. Otherwise the compiler
	would not be able to resolve the ambiguity of, e.g., @code{0x1.f}. This
	could mean @code{1.0f} or @code{1.9375} since @samp{f} is also the
	extension for floating-point constants of type @code{float}.

	@node Zero Length
	@section Arrays of Length Zero
	@cindex arrays of length zero
	@cindex zero-length arrays
	@cindex length-zero arrays
	@cindex flexible array members

	Zero-length arrays are allowed in GNU C@. They are very useful as the
	last element of a structure which is really a header for a variable-length
	object:

	@smallexample
	struct line @{
	int length;
	char contents[0];
	@};

	struct line thisline = (struct line )
	malloc (sizeof (struct line) + this_length);
	thisline->length = this_length;
	@end smallexample

	In ISO C90, you would have to give @code{contents} a length of 1, which
	means either you waste space or complicate the argument to @code{malloc}.

	In ISO C99, you would use a @dfn{flexible array member}, which is
	slightly different in syntax and semantics:

	@itemize @bullet
	@item
	Flexible array members are written as @code{contents[]} without
	the @code{0}.

	@item
	Flexible array members have incomplete type, and so the @code{sizeof}
	operator may not be applied. As a quirk of the original implementation
	of zero-length arrays, @code{sizeof} evaluates to zero.

	@item
	Flexible array members may only appear as the last member of a
	@code{struct} that is otherwise non-empty.

	@item
	A structure containing a flexible array member, or a union containing
	such a structure (possibly recursively), may not be a member of a
	structure or an element of an array. (However, these uses are
	permitted by GCC as extensions.)
	@end itemize

	GCC versions before 3.0 allowed zero-length arrays to be statically
	initialized, as if they were flexible arrays. In addition to those
	cases that were useful, it also allowed initializations in situations
	that would corrupt later data. Non-empty initialization of zero-length
	arrays is now treated like any case where there are more initializer
	elements than the array holds, in that a suitable warning about "excess
	elements in array" is given, and the excess elements (all of them, in
	this case) are ignored.

	Instead GCC allows static initialization of flexible array members.
	This is equivalent to defining a new structure containing the original
	structure followed by an array of sufficient size to contain the data.
	I.e.@: in the following, @code{f1} is constructed as if it were declared
	like @code{f2}.

	@smallexample
	struct f1 @{
	int x; int y[];
	@} f1 = @{ 1, @{ 2, 3, 4 @} @};

	struct f2 @{
	struct f1 f1; int data[3];
	@} f2 = @{ @{ 1 @}, @{ 2, 3, 4 @} @};
	@end smallexample

	@noindent
	The convenience of this extension is that @code{f1} has the desired
	type, eliminating the need to consistently refer to @code{f2.f1}.

	This has symmetry with normal static arrays, in that an array of
	unknown size is also written with @code{[]}.

	Of course, this extension only makes sense if the extra data comes at
	the end of a top-level object, as otherwise we would be overwriting
	data at subsequent offsets. To avoid undue complication and confusion
	with initialization of deeply nested arrays, we simply disallow any
	non-empty initialization except when the structure is the top-level
	object. For example:

	@smallexample
	struct foo @{ int x; int y[]; @};
	struct bar @{ struct foo z; @};

	struct foo a = @{ 1, @{ 2, 3, 4 @} @}; // @r{Valid.}
	struct bar b = @{ @{ 1, @{ 2, 3, 4 @} @} @}; // @r{Invalid.}
	struct bar c = @{ @{ 1, @{ @} @} @}; // @r{Valid.}
	struct foo d[1] = @{ @{ 1 @{ 2, 3, 4 @} @} @}; // @r{Invalid.}
	@end smallexample

	@node Empty Structures
	@section Structures With No Members
	@cindex empty structures
	@cindex zero-size structures

	GCC permits a C structure to have no members:

	@smallexample
	struct empty @{
	@};
	@end smallexample

	The structure will have size zero. In C++, empty structures are part
	of the language. G++ treats empty structures as if they had a single
	member of type @code{char}.

	@node Variable Length
	@section Arrays of Variable Length
	@cindex variable-length arrays
	@cindex arrays of variable length
	@cindex VLAs

	Variable-length automatic arrays are allowed in ISO C99, and as an
	extension GCC accepts them in C89 mode and in C++. (However, GCC's
	implementation of variable-length arrays does not yet conform in detail
	to the ISO C99 standard.) These arrays are
	declared like any other automatic arrays, but with a length that is not
	a constant expression. The storage is allocated at the point of
	declaration and deallocated when the brace-level is exited. For
	example:

	@smallexample
	FILE *
	concat_fopen (char s1, char s2, char *mode)
	@{
	char str[strlen (s1) + strlen (s2) + 1];
	strcpy (str, s1);
	strcat (str, s2);
	return fopen (str, mode);
	@}
	@end smallexample

	@cindex scope of a variable length array
	@cindex variable-length array scope
	@cindex deallocating variable length arrays
	Jumping or breaking out of the scope of the array name deallocates the
	storage. Jumping into the scope is not allowed; you get an error
	message for it.

	@cindex @code{alloca} vs variable-length arrays
	You can use the function @code{alloca} to get an effect much like
	variable-length arrays. The function @code{alloca} is available in
	many other C implementations (but not in all). On the other hand,
	variable-length arrays are more elegant.

	There are other differences between these two methods. Space allocated
	with @code{alloca} exists until the containing @emph{function} returns.
	The space for a variable-length array is deallocated as soon as the array
	name's scope ends. (If you use both variable-length arrays and
	@code{alloca} in the same function, deallocation of a variable-length array
	will also deallocate anything more recently allocated with @code{alloca}.)

	You can also use variable-length arrays as arguments to functions:

	@smallexample
	struct entry
	tester (int len, char data[len][len])
	@{
	/* @r{@dots{}} */
	@}
	@end smallexample

	The length of an array is computed once when the storage is allocated
	and is remembered for the scope of the array in case you access it with
	@code{sizeof}.

	If you want to pass the array first and the length afterward, you can
	use a forward declaration in the parameter list---another GNU extension.

	@smallexample
	struct entry
	tester (int len; char data[len][len], int len)
	@{
	/* @r{@dots{}} */
	@}
	@end smallexample

	@cindex parameter forward declaration
	The @samp{int len} before the semicolon is a @dfn{parameter forward
	declaration}, and it serves the purpose of making the name @code{len}
	known when the declaration of @code{data} is parsed.

	You can write any number of such parameter forward declarations in the
	parameter list. They can be separated by commas or semicolons, but the
	last one must end with a semicolon, which is followed by the ``real''
	parameter declarations. Each forward declaration must match a ``real''
	declaration in parameter name and data type. ISO C99 does not support
	parameter forward declarations.

	@node Variadic Macros
	@section Macros with a Variable Number of Arguments.
	@cindex variable number of arguments
	@cindex macro with variable arguments
	@cindex rest argument (in macro)
	@cindex variadic macros

	In the ISO C standard of 1999, a macro can be declared to accept a
	variable number of arguments much as a function can. The syntax for
	defining the macro is similar to that of a function. Here is an
	example:

	@smallexample
	#define debug(format, ...) fprintf (stderr, format, __VA_ARGS__)
	@end smallexample

	Here @samp{@dots{}} is a @dfn{variable argument}. In the invocation of
	such a macro, it represents the zero or more tokens until the closing
	parenthesis that ends the invocation, including any commas. This set of
	tokens replaces the identifier @code{__VA_ARGS__} in the macro body
	wherever it appears. See the CPP manual for more information.

	GCC has long supported variadic macros, and used a different syntax that
	allowed you to give a name to the variable arguments just like any other
	argument. Here is an example:

	@smallexample
	#define debug(format, args...) fprintf (stderr, format, args)
	@end smallexample

	This is in all ways equivalent to the ISO C example above, but arguably
	more readable and descriptive.

	GNU CPP has two further variadic macro extensions, and permits them to
	be used with either of the above forms of macro definition.

	In standard C, you are not allowed to leave the variable argument out
	entirely; but you are allowed to pass an empty argument. For example,
	this invocation is invalid in ISO C, because there is no comma after
	the string:

	@smallexample
	debug ("A message")
	@end smallexample

	GNU CPP permits you to completely omit the variable arguments in this
	way. In the above examples, the compiler would complain, though since
	the expansion of the macro still has the extra comma after the format
	string.

	To help solve this problem, CPP behaves specially for variable arguments
	used with the token paste operator, @samp{##}. If instead you write

	@smallexample
	#define debug(format, ...) fprintf (stderr, format, ## __VA_ARGS__)
	@end smallexample

	and if the variable arguments are omitted or empty, the @samp{##}
	operator causes the preprocessor to remove the comma before it. If you
	do provide some variable arguments in your macro invocation, GNU CPP
	does not complain about the paste operation and instead places the
	variable arguments after the comma. Just like any other pasted macro
	argument, these arguments are not macro expanded.

	@node Escaped Newlines
	@section Slightly Looser Rules for Escaped Newlines
	@cindex escaped newlines
	@cindex newlines (escaped)

	Recently, the preprocessor has relaxed its treatment of escaped
	newlines. Previously, the newline had to immediately follow a
	backslash. The current implementation allows whitespace in the form
	of spaces, horizontal and vertical tabs, and form feeds between the
	backslash and the subsequent newline. The preprocessor issues a
	warning, but treats it as a valid escaped newline and combines the two
	lines to form a single logical line. This works within comments and
	tokens, as well as between tokens. Comments are @emph{not} treated as
	whitespace for the purposes of this relaxation, since they have not
	yet been replaced with spaces.

	@node Subscripting
	@section Non-Lvalue Arrays May Have Subscripts
	@cindex subscripting
	@cindex arrays, non-lvalue

	@cindex subscripting and function values
	In ISO C99, arrays that are not lvalues still decay to pointers, and
	may be subscripted, although they may not be modified or used after
	the next sequence point and the unary @samp{&} operator may not be
	applied to them. As an extension, GCC allows such arrays to be
	subscripted in C89 mode, though otherwise they do not decay to
	pointers outside C99 mode. For example,
	this is valid in GNU C though not valid in C89:

	@smallexample
	@group
	struct foo @{int a[4];@};

	struct foo f();

	bar (int index)
	@{
	return f().a[index];
	@}
	@end group
	@end smallexample

	@node Pointer Arith
	@section Arithmetic on @code{void}- and Function-Pointers
	@cindex void pointers, arithmetic
	@cindex void, size of pointer to
	@cindex function pointers, arithmetic
	@cindex function, size of pointer to

	In GNU C, addition and subtraction operations are supported on pointers to
	@code{void} and on pointers to functions. This is done by treating the
	size of a @code{void} or of a function as 1.

	A consequence of this is that @code{sizeof} is also allowed on @code{void}
	and on function types, and returns 1.

	@opindex Wpointer-arith
	The option @option{-Wpointer-arith} requests a warning if these extensions
	are used.

	@node Initializers
	@section Non-Constant Initializers
	@cindex initializers, non-constant
	@cindex non-constant initializers

	As in standard C++ and ISO C99, the elements of an aggregate initializer for an
	automatic variable are not required to be constant expressions in GNU C@.
	Here is an example of an initializer with run-time varying elements:

	@smallexample
	foo (float f, float g)
	@{
	float beat_freqs[2] = @{ f-g, f+g @};
	/* @r{@dots{}} */
	@}
	@end smallexample

	@node Compound Literals
	@section Compound Literals
	@cindex constructor expressions
	@cindex initializations in expressions
	@cindex structures, constructor expression
	@cindex expressions, constructor
	@cindex compound literals
	@c The GNU C name for what C99 calls compound literals was "constructor expressions".

	ISO C99 supports compound literals. A compound literal looks like
	a cast containing an initializer. Its value is an object of the
	type specified in the cast, containing the elements specified in
	the initializer; it is an lvalue. As an extension, GCC supports
	compound literals in C89 mode and in C++.

	Usually, the specified type is a structure. Assume that
	@code{struct foo} and @code{structure} are declared as shown:

	@smallexample
	struct foo @{int a; char b[2];@} structure;
	@end smallexample

	@noindent
	Here is an example of constructing a @code{struct foo} with a compound literal:

	@smallexample
	structure = ((struct foo) @{x + y, 'a', 0@});
	@end smallexample

	@noindent
	This is equivalent to writing the following:

	@smallexample
	@{
	struct foo temp = @{x + y, 'a', 0@};
	structure = temp;
	@}
	@end smallexample

	You can also construct an array. If all the elements of the compound literal
	are (made up of) simple constant expressions, suitable for use in
	initializers of objects of static storage duration, then the compound
	literal can be coerced to a pointer to its first element and used in
	such an initializer, as shown here:

	@smallexample
	char *foo = (char []) @{ "x", "y", "z" @};
	@end smallexample

	Compound literals for scalar types and union types are is
	also allowed, but then the compound literal is equivalent
	to a cast.

	As a GNU extension, GCC allows initialization of objects with static storage
	duration by compound literals (which is not possible in ISO C99, because
	the initializer is not a constant).
	It is handled as if the object was initialized only with the bracket
	enclosed list if the types of the compound literal and the object match.
	The initializer list of the compound literal must be constant.
	If the object being initialized has array type of unknown size, the size is
	determined by compound literal size.

	@smallexample
	static struct foo x = (struct foo) @{1, 'a', 'b'@};
	static int y[] = (int []) @{1, 2, 3@};
	static int z[] = (int [3]) @{1@};
	@end smallexample

	@noindent
	The above lines are equivalent to the following:
	@smallexample
	static struct foo x = @{1, 'a', 'b'@};
	static int y[] = @{1, 2, 3@};
	static int z[] = @{1, 0, 0@};
	@end smallexample

	@node Designated Inits
	@section Designated Initializers
	@cindex initializers with labeled elements
	@cindex labeled elements in initializers
	@cindex case labels in initializers
	@cindex designated initializers

	Standard C89 requires the elements of an initializer to appear in a fixed
	order, the same as the order of the elements in the array or structure
	being initialized.

	In ISO C99 you can give the elements in any order, specifying the array
	indices or structure field names they apply to, and GNU C allows this as
	an extension in C89 mode as well. This extension is not
	implemented in GNU C++.

	To specify an array index, write
	@samp{[@var{index}] =} before the element value. For example,

	@smallexample
	int a[6] = @{ [4] = 29, [2] = 15 @};
	@end smallexample

	@noindent
	is equivalent to

	@smallexample
	int a[6] = @{ 0, 0, 15, 0, 29, 0 @};
	@end smallexample

	@noindent
	The index values must be constant expressions, even if the array being
	initialized is automatic.

	An alternative syntax for this which has been obsolete since GCC 2.5 but
	GCC still accepts is to write @samp{[@var{index}]} before the element
	value, with no @samp{=}.

	To initialize a range of elements to the same value, write
	@samp{[@var{first} ... @var{last}] = @var{value}}. This is a GNU
	extension. For example,

	@smallexample
	int widths[] = @{ [0 ... 9] = 1, [10 ... 99] = 2, [100] = 3 @};
	@end smallexample

	@noindent
	If the value in it has side-effects, the side-effects will happen only once,
	not for each initialized field by the range initializer.

	@noindent
	Note that the length of the array is the highest value specified
	plus one.

	In a structure initializer, specify the name of a field to initialize
	with @samp{.@var{fieldname} =} before the element value. For example,
	given the following structure,

	@smallexample
	struct point @{ int x, y; @};
	@end smallexample

	@noindent
	the following initialization

	@smallexample
	struct point p = @{ .y = yvalue, .x = xvalue @};
	@end smallexample

	@noindent
	is equivalent to

	@smallexample
	struct point p = @{ xvalue, yvalue @};
	@end smallexample

	Another syntax which has the same meaning, obsolete since GCC 2.5, is
	@samp{@var{fieldname}:}, as shown here:

	@smallexample
	struct point p = @{ y: yvalue, x: xvalue @};
	@end smallexample

	@cindex designators
	The @samp{[@var{index}]} or @samp{.@var{fieldname}} is known as a
	@dfn{designator}. You can also use a designator (or the obsolete colon
	syntax) when initializing a union, to specify which element of the union
	should be used. For example,

	@smallexample
	union foo @{ int i; double d; @};

	union foo f = @{ .d = 4 @};
	@end smallexample

	@noindent
	will convert 4 to a @code{double} to store it in the union using
	the second element. By contrast, casting 4 to type @code{union foo}
	would store it into the union as the integer @code{i}, since it is
	an integer. (@xref{Cast to Union}.)

	You can combine this technique of naming elements with ordinary C
	initialization of successive elements. Each initializer element that
	does not have a designator applies to the next consecutive element of the
	array or structure. For example,

	@smallexample
	int a[6] = @{ [1] = v1, v2, [4] = v4 @};
	@end smallexample

	@noindent
	is equivalent to

	@smallexample
	int a[6] = @{ 0, v1, v2, 0, v4, 0 @};
	@end smallexample

	Labeling the elements of an array initializer is especially useful
	when the indices are characters or belong to an @code{enum} type.
	For example:

	@smallexample
	int whitespace[256]
	= @{ [' '] = 1, ['\t'] = 1, ['\h'] = 1,
	['\f'] = 1, ['\n'] = 1, ['\r'] = 1 @};
	@end smallexample

	@cindex designator lists
	You can also write a series of @samp{.@var{fieldname}} and
	@samp{[@var{index}]} designators before an @samp{=} to specify a
	nested subobject to initialize; the list is taken relative to the
	subobject corresponding to the closest surrounding brace pair. For
	example, with the @samp{struct point} declaration above:

	@smallexample
	struct point ptarray[10] = @{ [2].y = yv2, [2].x = xv2, [0].x = xv0 @};
	@end smallexample

	@noindent
	If the same field is initialized multiple times, it will have value from
	the last initialization. If any such overridden initialization has
	side-effect, it is unspecified whether the side-effect happens or not.
	Currently, GCC will discard them and issue a warning.

	@node Case Ranges
	@section Case Ranges
	@cindex case ranges
	@cindex ranges in case statements

	You can specify a range of consecutive values in a single @code{case} label,
	like this:

	@smallexample
	case @var{low} ... @var{high}:
	@end smallexample

	@noindent
	This has the same effect as the proper number of individual @code{case}
	labels, one for each integer value from @var{low} to @var{high}, inclusive.

	This feature is especially useful for ranges of ASCII character codes:

	@smallexample
	case 'A' ... 'Z':
	@end smallexample

	@strong{Be careful:} Write spaces around the @code{...}, for otherwise
	it may be parsed wrong when you use it with integer values. For example,
	write this:

	@smallexample
	case 1 ... 5:
	@end smallexample

	@noindent
	rather than this:

	@smallexample
	case 1...5:
	@end smallexample

	@node Cast to Union
	@section Cast to a Union Type
	@cindex cast to a union
	@cindex union, casting to a

	A cast to union type is similar to other casts, except that the type
	specified is a union type. You can specify the type either with
	@code{union @var{tag}} or with a typedef name. A cast to union is actually
	a constructor though, not a cast, and hence does not yield an lvalue like
	normal casts. (@xref{Compound Literals}.)

	The types that may be cast to the union type are those of the members
	of the union. Thus, given the following union and variables:

	@smallexample
	union foo @{ int i; double d; @};
	int x;
	double y;
	@end smallexample

	@noindent
	both @code{x} and @code{y} can be cast to type @code{union foo}.

	Using the cast as the right-hand side of an assignment to a variable of
	union type is equivalent to storing in a member of the union:

	@smallexample
	union foo u;
	/* @r{@dots{}} */
	u = (union foo) x @equiv{} u.i = x
	u = (union foo) y @equiv{} u.d = y
	@end smallexample

	You can also use the union cast as a function argument:

	@smallexample
	void hack (union foo);
	/* @r{@dots{}} */
	hack ((union foo) x);
	@end smallexample

	@node Mixed Declarations
	@section Mixed Declarations and Code
	@cindex mixed declarations and code
	@cindex declarations, mixed with code
	@cindex code, mixed with declarations

	ISO C99 and ISO C++ allow declarations and code to be freely mixed
	within compound statements. As an extension, GCC also allows this in
	C89 mode. For example, you could do:

	@smallexample
	int i;
	/* @r{@dots{}} */
	i++;
	int j = i + 2;
	@end smallexample

	Each identifier is visible from where it is declared until the end of
	the enclosing block.

	@node Function Attributes
	@section Declaring Attributes of Functions
	@cindex function attributes
	@cindex declaring attributes of functions
	@cindex functions that never return
	@cindex functions that return more than once
	@cindex functions that have no side effects
	@cindex functions in arbitrary sections
	@cindex functions that behave like malloc
	@cindex @code{volatile} applied to function
	@cindex @code{const} applied to function
	@cindex functions with @code{printf}, @code{scanf}, @code{strftime} or @code{strfmon} style arguments
	@cindex functions with non-null pointer arguments
	@cindex functions that are passed arguments in registers on the 386
	@cindex functions that pop the argument stack on the 386
	@cindex functions that do not pop the argument stack on the 386

	In GNU C, you declare certain things about functions called in your program
	which help the compiler optimize function calls and check your code more
	carefully.

	The keyword @code{__attribute__} allows you to specify special
	attributes when making a declaration. This keyword is followed by an
	attribute specification inside double parentheses. The following
	attributes are currently defined for functions on all targets:
	@code{aligned},
	@code{noreturn}, @code{returns_twice}, @code{noinline}, @code{always_inline},
	@code{flatten}, @code{pure}, @code{const}, @code{nothrow}, @code{sentinel},
	@code{format}, @code{format_arg}, @code{no_instrument_function},
	@code{section}, @code{constructor}, @code{destructor}, @code{used},
	@code{unused}, @code{deprecated}, @code{weak}, @code{malloc},
	@code{alias}, @code{warn_unused_result}, @code{nonnull},
	@code{gnu_inline} and @code{externally_visible}. Several other
	attributes are defined for functions on particular target systems. Other
	attributes, including @code{section} are supported for variables declarations
	-(@pxref{Variable Attributes}) and for types (@pxref{Type Attributes}).
	+@c APPLE LOCAL begin for-fsf-4_4 3274130 5295549
	+(@pxref{Variable Attributes}), for types (@pxref{Type Attributes}),
	+and labels (@pxref{Label Attributes}).

	+@c APPLE LOCAL end for-fsf-4_4 3274130 5295549
	You may also specify attributes with @samp{__} preceding and following
	each keyword. This allows you to use them in header files without
	being concerned about a possible macro of the same name. For example,
	you may use @code{__noreturn__} instead of @code{noreturn}.

	@xref{Attribute Syntax}, for details of the exact syntax for using
	attributes.

	@table @code
	@c Keep this table alphabetized by attribute name. Treat _ as space.

	@item alias ("@var{target}")
	@cindex @code{alias} attribute
	The @code{alias} attribute causes the declaration to be emitted as an
	alias for another symbol, which must be specified. For instance,

	@smallexample
	void __f () @{ /* @r{Do something.} */; @}
	void f () __attribute__ ((weak, alias ("__f")));
	@end smallexample

	defines @samp{f} to be a weak alias for @samp{__f}. In C++, the
	mangled name for the target must be used. It is an error if @samp{__f}
	is not defined in the same translation unit.

	Not all target machines support this attribute.

	@item aligned (@var{alignment})
	@cindex @code{aligned} attribute
	This attribute specifies a minimum alignment for the function,
	measured in bytes.

	You cannot use this attribute to decrease the alignment of a function,
	only to increase it. However, when you explicitly specify a function
	alignment this will override the effect of the
	@option{-falign-functions} (@pxref{Optimize Options}) option for this
	function.

	Note that the effectiveness of @code{aligned} attributes may be
	limited by inherent limitations in your linker. On many systems, the
	linker is only able to arrange for functions to be aligned up to a
	certain maximum alignment. (For some linkers, the maximum supported
	alignment may be very very small.) See your linker documentation for
	further information.

	The @code{aligned} attribute can also be used for variables and fields
	(@pxref{Variable Attributes}.)

	@item always_inline
	@cindex @code{always_inline} function attribute
	Generally, functions are not inlined unless optimization is specified.
	For functions declared inline, this attribute inlines the function even
	if no optimization level was specified.

	@item gnu_inline
	@cindex @code{gnu_inline} function attribute
	This attribute should be used with a function which is also declared
	with the @code{inline} keyword. It directs GCC to treat the function
	as if it were defined in gnu89 mode even when compiling in C99 or
	gnu99 mode.

	If the function is declared @code{extern}, then this definition of the
	function is used only for inlining. In no case is the function
	compiled as a standalone function, not even if you take its address
	explicitly. Such an address becomes an external reference, as if you
	had only declared the function, and had not defined it. This has
	almost the effect of a macro. The way to use this is to put a
	function definition in a header file with this attribute, and put
	another copy of the function, without @code{extern}, in a library
	file. The definition in the header file will cause most calls to the
	function to be inlined. If any uses of the function remain, they will
	refer to the single copy in the library. Note that the two
	definitions of the functions need not be precisely the same, although
	if they do not have the same effect your program may behave oddly.

	If the function is neither @code{extern} nor @code{static}, then the
	function is compiled as a standalone function, as well as being
	inlined where possible.

	This is how GCC traditionally handled functions declared
	@code{inline}. Since ISO C99 specifies a different semantics for
	@code{inline}, this function attribute is provided as a transition
	measure and as a useful feature in its own right. This attribute is
	available in GCC 4.1.3 and later. It is available if either of the
	preprocessor macros @code{__GNUC_GNU_INLINE__} or
	@code{__GNUC_STDC_INLINE__} are defined. @xref{Inline,,An Inline
	Function is As Fast As a Macro}.

	Note that since the first version of GCC to support C99 inline semantics
	is 4.3, earlier versions of GCC which accept this attribute effectively
	assume that it is always present, whether or not it is given explicitly.
	In versions prior to 4.3, the only effect of explicitly including it is
	to disable warnings about using inline functions in C99 mode.

	@cindex @code{flatten} function attribute
	@item flatten
	Generally, inlining into a function is limited. For a function marked with
	this attribute, every call inside this function will be inlined, if possible.
	Whether the function itself is considered for inlining depends on its size and
	the current inlining parameters. The @code{flatten} attribute only works
	reliably in unit-at-a-time mode.

	@item cdecl
	@cindex functions that do pop the argument stack on the 386
	@opindex mrtd
	On the Intel 386, the @code{cdecl} attribute causes the compiler to
	assume that the calling function will pop off the stack space used to
	pass arguments. This is
	useful to override the effects of the @option{-mrtd} switch.

	@item const
	@cindex @code{const} function attribute
	Many functions do not examine any values except their arguments, and
	have no effects except the return value. Basically this is just slightly
	more strict class than the @code{pure} attribute below, since function is not
	allowed to read global memory.

	@cindex pointer arguments
	Note that a function that has pointer arguments and examines the data
	pointed to must @emph{not} be declared @code{const}. Likewise, a
	function that calls a non-@code{const} function usually must not be
	@code{const}. It does not make sense for a @code{const} function to
	return @code{void}.

	The attribute @code{const} is not implemented in GCC versions earlier
	than 2.5. An alternative way to declare that a function has no side
	effects, which works in the current version and in some older versions,
	is as follows:

	@smallexample
	typedef int intfn ();

	extern const intfn square;
	@end smallexample

	This approach does not work in GNU C++ from 2.6.0 on, since the language
	specifies that the @samp{const} must be attached to the return value.

	@item constructor
	@itemx destructor
	@cindex @code{constructor} function attribute
	@cindex @code{destructor} function attribute
	The @code{constructor} attribute causes the function to be called
	automatically before execution enters @code{main ()}. Similarly, the
	@code{destructor} attribute causes the function to be called
	automatically after @code{main ()} has completed or @code{exit ()} has
	been called. Functions with these attributes are useful for
	initializing data that will be used implicitly during the execution of
	the program.

	@item deprecated
	@cindex @code{deprecated} attribute.
	The @code{deprecated} attribute results in a warning if the function
	is used anywhere in the source file. This is useful when identifying
	functions that are expected to be removed in a future version of a
	program. The warning also includes the location of the declaration
	of the deprecated function, to enable users to easily find further
	information about why the function is deprecated, or what they should
	do instead. Note that the warnings only occurs for uses:

	@smallexample
	int old_fn () __attribute__ ((deprecated));
	int old_fn ();
	int (*fn_ptr)() = old_fn;
	@end smallexample

	results in a warning on line 3 but not line 2.

	The @code{deprecated} attribute can also be used for variables and
	types (@pxref{Variable Attributes}, @pxref{Type Attributes}.)

	@item dllexport
	@cindex @code{__declspec(dllexport)}
	On Microsoft Windows targets and Symbian OS targets the
	@code{dllexport} attribute causes the compiler to provide a global
	pointer to a pointer in a DLL, so that it can be referenced with the
	@code{dllimport} attribute. On Microsoft Windows targets, the pointer
	name is formed by combining @code{_imp__} and the function or variable
	name.

	You can use @code{__declspec(dllexport)} as a synonym for
	@code{__attribute__ ((dllexport))} for compatibility with other
	compilers.

	On systems that support the @code{visibility} attribute, this
	attribute also implies ``default'' visibility, unless a
	@code{visibility} attribute is explicitly specified. You should avoid
	the use of @code{dllexport} with ``hidden'' or ``internal''
	visibility; in the future GCC may issue an error for those cases.

	Currently, the @code{dllexport} attribute is ignored for inlined
	functions, unless the @option{-fkeep-inline-functions} flag has been
	used. The attribute is also ignored for undefined symbols.

	When applied to C++ classes, the attribute marks defined non-inlined
	member functions and static data members as exports. Static consts
	initialized in-class are not marked unless they are also defined
	out-of-class.

	For Microsoft Windows targets there are alternative methods for
	including the symbol in the DLL's export table such as using a
	@file{.def} file with an @code{EXPORTS} section or, with GNU ld, using
	the @option{--export-all} linker flag.

	@item dllimport
	@cindex @code{__declspec(dllimport)}
	On Microsoft Windows and Symbian OS targets, the @code{dllimport}
	attribute causes the compiler to reference a function or variable via
	a global pointer to a pointer that is set up by the DLL exporting the
	symbol. The attribute implies @code{extern} storage. On Microsoft
	Windows targets, the pointer name is formed by combining @code{_imp__}
	and the function or variable name.

	You can use @code{__declspec(dllimport)} as a synonym for
	@code{__attribute__ ((dllimport))} for compatibility with other
	compilers.

	Currently, the attribute is ignored for inlined functions. If the
	attribute is applied to a symbol @emph{definition}, an error is reported.
	If a symbol previously declared @code{dllimport} is later defined, the
	attribute is ignored in subsequent references, and a warning is emitted.
	The attribute is also overridden by a subsequent declaration as
	@code{dllexport}.

	When applied to C++ classes, the attribute marks non-inlined
	member functions and static data members as imports. However, the
	attribute is ignored for virtual methods to allow creation of vtables
	using thunks.

	On the SH Symbian OS target the @code{dllimport} attribute also has
	another affect---it can cause the vtable and run-time type information
	for a class to be exported. This happens when the class has a
	dllimport'ed constructor or a non-inline, non-pure virtual function
	and, for either of those two conditions, the class also has a inline
	constructor or destructor and has a key function that is defined in
	the current translation unit.

	For Microsoft Windows based targets the use of the @code{dllimport}
	attribute on functions is not necessary, but provides a small
	performance benefit by eliminating a thunk in the DLL@. The use of the
	@code{dllimport} attribute on imported variables was required on older
	versions of the GNU linker, but can now be avoided by passing the
	@option{--enable-auto-import} switch to the GNU linker. As with
	functions, using the attribute for a variable eliminates a thunk in
	the DLL@.

	One drawback to using this attribute is that a pointer to a function
	or variable marked as @code{dllimport} cannot be used as a constant
	address. On Microsoft Windows targets, the attribute can be disabled
	for functions by setting the @option{-mnop-fun-dllimport} flag.

	@item eightbit_data
	@cindex eight bit data on the H8/300, H8/300H, and H8S
	Use this attribute on the H8/300, H8/300H, and H8S to indicate that the specified
	variable should be placed into the eight bit data section.
	The compiler will generate more efficient code for certain operations
	on data in the eight bit data area. Note the eight bit data area is limited to
	256 bytes of data.

	You must use GAS and GLD from GNU binutils version 2.7 or later for
	this attribute to work correctly.

	@item exception_handler
	@cindex exception handler functions on the Blackfin processor
	Use this attribute on the Blackfin to indicate that the specified function
	is an exception handler. The compiler will generate function entry and
	exit sequences suitable for use in an exception handler when this
	attribute is present.

	@item far
	@cindex functions which handle memory bank switching
	On 68HC11 and 68HC12 the @code{far} attribute causes the compiler to
	use a calling convention that takes care of switching memory banks when
	entering and leaving a function. This calling convention is also the
	default when using the @option{-mlong-calls} option.

	On 68HC12 the compiler will use the @code{call} and @code{rtc} instructions
	to call and return from a function.

	On 68HC11 the compiler will generate a sequence of instructions
	to invoke a board-specific routine to switch the memory bank and call the
	real function. The board-specific routine simulates a @code{call}.
	At the end of a function, it will jump to a board-specific routine
	instead of using @code{rts}. The board-specific return routine simulates
	the @code{rtc}.

	@item fastcall
	@cindex functions that pop the argument stack on the 386
	On the Intel 386, the @code{fastcall} attribute causes the compiler to
	pass the first argument (if of integral type) in the register ECX and
	the second argument (if of integral type) in the register EDX@. Subsequent
	and other typed arguments are passed on the stack. The called function will
	pop the arguments off the stack. If the number of arguments is variable all
	arguments are pushed on the stack.

	@item format (@var{archetype}, @var{string-index}, @var{first-to-check})
	@cindex @code{format} function attribute
	@opindex Wformat
	The @code{format} attribute specifies that a function takes @code{printf},
	@code{scanf}, @code{strftime} or @code{strfmon} style arguments which
	should be type-checked against a format string. For example, the
	declaration:

	@smallexample
	extern int
	my_printf (void my_object, const char my_format, ...)
	__attribute__ ((format (printf, 2, 3)));
	@end smallexample

	@noindent
	causes the compiler to check the arguments in calls to @code{my_printf}
	for consistency with the @code{printf} style format string argument
	@code{my_format}.

	The parameter @var{archetype} determines how the format string is
	interpreted, and should be @code{printf}, @code{scanf}, @code{strftime}
	or @code{strfmon}. (You can also use @code{__printf__},
	@code{__scanf__}, @code{__strftime__} or @code{__strfmon__}.) The
	parameter @var{string-index} specifies which argument is the format
	string argument (starting from 1), while @var{first-to-check} is the
	number of the first argument to check against the format string. For
	functions where the arguments are not available to be checked (such as
	@code{vprintf}), specify the third parameter as zero. In this case the
	compiler only checks the format string for consistency. For
	@code{strftime} formats, the third parameter is required to be zero.
	Since non-static C++ methods have an implicit @code{this} argument, the
	arguments of such methods should be counted from two, not one, when
	giving values for @var{string-index} and @var{first-to-check}.

	In the example above, the format string (@code{my_format}) is the second
	argument of the function @code{my_print}, and the arguments to check
	start with the third argument, so the correct parameters for the format
	attribute are 2 and 3.

	@opindex ffreestanding
	@opindex fno-builtin
	The @code{format} attribute allows you to identify your own functions
	which take format strings as arguments, so that GCC can check the
	calls to these functions for errors. The compiler always (unless
	@option{-ffreestanding} or @option{-fno-builtin} is used) checks formats
	for the standard library functions @code{printf}, @code{fprintf},
	@code{sprintf}, @code{scanf}, @code{fscanf}, @code{sscanf}, @code{strftime},
	@code{vprintf}, @code{vfprintf} and @code{vsprintf} whenever such
	warnings are requested (using @option{-Wformat}), so there is no need to
	modify the header file @file{stdio.h}. In C99 mode, the functions
	@code{snprintf}, @code{vsnprintf}, @code{vscanf}, @code{vfscanf} and
	@code{vsscanf} are also checked. Except in strictly conforming C
	standard modes, the X/Open function @code{strfmon} is also checked as
	are @code{printf_unlocked} and @code{fprintf_unlocked}.
	@xref{C Dialect Options,,Options Controlling C Dialect}.

	The target may provide additional types of format checks.
	@xref{Target Format Checks,,Format Checks Specific to Particular
	Target Machines}.

	@item format_arg (@var{string-index})
	@cindex @code{format_arg} function attribute
	@opindex Wformat-nonliteral
	The @code{format_arg} attribute specifies that a function takes a format
	string for a @code{printf}, @code{scanf}, @code{strftime} or
	@code{strfmon} style function and modifies it (for example, to translate
	it into another language), so the result can be passed to a
	@code{printf}, @code{scanf}, @code{strftime} or @code{strfmon} style
	function (with the remaining arguments to the format function the same
	as they would have been for the unmodified string). For example, the
	declaration:

	@smallexample
	extern char *
	my_dgettext (char my_domain, const char my_format)
	__attribute__ ((format_arg (2)));
	@end smallexample

	@noindent
	causes the compiler to check the arguments in calls to a @code{printf},
	@code{scanf}, @code{strftime} or @code{strfmon} type function, whose
	format string argument is a call to the @code{my_dgettext} function, for
	consistency with the format string argument @code{my_format}. If the
	@code{format_arg} attribute had not been specified, all the compiler
	could tell in such calls to format functions would be that the format
	string argument is not constant; this would generate a warning when
	@option{-Wformat-nonliteral} is used, but the calls could not be checked
	without the attribute.

	The parameter @var{string-index} specifies which argument is the format
	string argument (starting from one). Since non-static C++ methods have
	an implicit @code{this} argument, the arguments of such methods should
	be counted from two.

	The @code{format-arg} attribute allows you to identify your own
	functions which modify format strings, so that GCC can check the
	calls to @code{printf}, @code{scanf}, @code{strftime} or @code{strfmon}
	type function whose operands are a call to one of your own function.
	The compiler always treats @code{gettext}, @code{dgettext}, and
	@code{dcgettext} in this manner except when strict ISO C support is
	requested by @option{-ansi} or an appropriate @option{-std} option, or
	@option{-ffreestanding} or @option{-fno-builtin}
	is used. @xref{C Dialect Options,,Options
	Controlling C Dialect}.

	@item function_vector
	@cindex calling functions through the function vector on the H8/300 processors
	Use this attribute on the H8/300, H8/300H, and H8S to indicate that the specified
	function should be called through the function vector. Calling a
	function through the function vector will reduce code size, however;
	the function vector has a limited size (maximum 128 entries on the H8/300
	and 64 entries on the H8/300H and H8S) and shares space with the interrupt vector.

	You must use GAS and GLD from GNU binutils version 2.7 or later for
	this attribute to work correctly.

	@item interrupt
	@cindex interrupt handler functions
	Use this attribute on the ARM, AVR, C4x, CRX, M32C, M32R/D, MS1, and Xstormy16
	ports to indicate that the specified function is an interrupt handler.
	The compiler will generate function entry and exit sequences suitable
	for use in an interrupt handler when this attribute is present.

	Note, interrupt handlers for the Blackfin, m68k, H8/300, H8/300H, H8S, and
	SH processors can be specified via the @code{interrupt_handler} attribute.

	Note, on the AVR, interrupts will be enabled inside the function.

	Note, for the ARM, you can specify the kind of interrupt to be handled by
	adding an optional parameter to the interrupt attribute like this:

	@smallexample
	void f () __attribute__ ((interrupt ("IRQ")));
	@end smallexample

	Permissible values for this parameter are: IRQ, FIQ, SWI, ABORT and UNDEF@.

	@item interrupt_handler
	@cindex interrupt handler functions on the Blackfin, m68k, H8/300 and SH processors
	Use this attribute on the Blackfin, m68k, H8/300, H8/300H, H8S, and SH to
	indicate that the specified function is an interrupt handler. The compiler
	will generate function entry and exit sequences suitable for use in an
	interrupt handler when this attribute is present.

	@item kspisusp
	@cindex User stack pointer in interrupts on the Blackfin
	When used together with @code{interrupt_handler}, @code{exception_handler}
	or @code{nmi_handler}, code will be generated to load the stack pointer
	from the USP register in the function prologue.

	@item long_call/short_call
	@cindex indirect calls on ARM
	This attribute specifies how a particular function is called on
	ARM@. Both attributes override the @option{-mlong-calls} (@pxref{ARM Options})
	command line switch and @code{#pragma long_calls} settings. The
	@code{long_call} attribute indicates that the function might be far
	away from the call site and require a different (more expensive)
	calling sequence. The @code{short_call} attribute always places
	the offset to the function from the call site into the @samp{BL}
	instruction directly.

	@item longcall/shortcall
	@cindex functions called via pointer on the RS/6000 and PowerPC
	On the Blackfin, RS/6000 and PowerPC, the @code{longcall} attribute
	indicates that the function might be far away from the call site and
	require a different (more expensive) calling sequence. The
	@code{shortcall} attribute indicates that the function is always close
	enough for the shorter calling sequence to be used. These attributes
	override both the @option{-mlongcall} switch and, on the RS/6000 and
	PowerPC, the @code{#pragma longcall} setting.

	@xref{RS/6000 and PowerPC Options}, for more information on whether long
	calls are necessary.

	@item long_call
	@cindex indirect calls on MIPS
	This attribute specifies how a particular function is called on MIPS@.
	The attribute overrides the @option{-mlong-calls} (@pxref{MIPS Options})
	command line switch. This attribute causes the compiler to always call
	the function by first loading its address into a register, and then using
	the contents of that register.

	@item malloc
	@cindex @code{malloc} attribute
	The @code{malloc} attribute is used to tell the compiler that a function
	may be treated as if any non-@code{NULL} pointer it returns cannot
	alias any other pointer valid when the function returns.
	This will often improve optimization.
	Standard functions with this property include @code{malloc} and
	@code{calloc}. @code{realloc}-like functions have this property as
	long as the old pointer is never referred to (including comparing it
	to the new pointer) after the function returns a non-@code{NULL}
	value.

	@item model (@var{model-name})
	@cindex function addressability on the M32R/D
	@cindex variable addressability on the IA-64

	On the M32R/D, use this attribute to set the addressability of an
	object, and of the code generated for a function. The identifier
	@var{model-name} is one of @code{small}, @code{medium}, or
	@code{large}, representing each of the code models.

	Small model objects live in the lower 16MB of memory (so that their
	addresses can be loaded with the @code{ld24} instruction), and are
	callable with the @code{bl} instruction.

	Medium model objects may live anywhere in the 32-bit address space (the
	compiler will generate @code{seth/add3} instructions to load their addresses),
	and are callable with the @code{bl} instruction.

	Large model objects may live anywhere in the 32-bit address space (the
	compiler will generate @code{seth/add3} instructions to load their addresses),
	and may not be reachable with the @code{bl} instruction (the compiler will
	generate the much slower @code{seth/add3/jl} instruction sequence).

	On IA-64, use this attribute to set the addressability of an object.
	At present, the only supported identifier for @var{model-name} is
	@code{small}, indicating addressability via ``small'' (22-bit)
	addresses (so that their addresses can be loaded with the @code{addl}
	instruction). Caveat: such addressing is by definition not position
	independent and hence this attribute must not be used for objects
	defined by shared libraries.

	@item naked
	@cindex function without a prologue/epilogue code
	Use this attribute on the ARM, AVR, C4x and IP2K ports to indicate that the
	specified function does not need prologue/epilogue sequences generated by
	the compiler. It is up to the programmer to provide these sequences.

	@item near
	@cindex functions which do not handle memory bank switching on 68HC11/68HC12
	On 68HC11 and 68HC12 the @code{near} attribute causes the compiler to
	use the normal calling convention based on @code{jsr} and @code{rts}.
	This attribute can be used to cancel the effect of the @option{-mlong-calls}
	option.

	@item nesting
	@cindex Allow nesting in an interrupt handler on the Blackfin processor.
	Use this attribute together with @code{interrupt_handler},
	@code{exception_handler} or @code{nmi_handler} to indicate that the function
	entry code should enable nested interrupts or exceptions.

	@item nmi_handler
	@cindex NMI handler functions on the Blackfin processor
	Use this attribute on the Blackfin to indicate that the specified function
	is an NMI handler. The compiler will generate function entry and
	exit sequences suitable for use in an NMI handler when this
	attribute is present.

	@item no_instrument_function
	@cindex @code{no_instrument_function} function attribute
	@opindex finstrument-functions
	If @option{-finstrument-functions} is given, profiling function calls will
	be generated at entry and exit of most user-compiled functions.
	Functions with this attribute will not be so instrumented.

	@item noinline
	@cindex @code{noinline} function attribute
	This function attribute prevents a function from being considered for
	inlining.

	@item nonnull (@var{arg-index}, @dots{})
	@cindex @code{nonnull} function attribute
	The @code{nonnull} attribute specifies that some function parameters should
	be non-null pointers. For instance, the declaration:

	@smallexample
	extern void *
	my_memcpy (void dest, const void src, size_t len)
	__attribute__((nonnull (1, 2)));
	@end smallexample

	@noindent
	causes the compiler to check that, in calls to @code{my_memcpy},
	arguments @var{dest} and @var{src} are non-null. If the compiler
	determines that a null pointer is passed in an argument slot marked
	as non-null, and the @option{-Wnonnull} option is enabled, a warning
	is issued. The compiler may also choose to make optimizations based
	on the knowledge that certain function arguments will not be null.

	If no argument index list is given to the @code{nonnull} attribute,
	all pointer arguments are marked as non-null. To illustrate, the
	following declaration is equivalent to the previous example:

	@smallexample
	extern void *
	my_memcpy (void dest, const void src, size_t len)
	__attribute__((nonnull));
	@end smallexample

	@item noreturn
	@cindex @code{noreturn} function attribute
	A few standard library functions, such as @code{abort} and @code{exit},
	cannot return. GCC knows this automatically. Some programs define
	their own functions that never return. You can declare them
	@code{noreturn} to tell the compiler this fact. For example,

	@smallexample
	@group
	void fatal () __attribute__ ((noreturn));

	void
	fatal (/* @r{@dots{}} */)
	@{
	/* @r{@dots{}} / / @r{Print error message.} / / @r{@dots{}} */
	exit (1);
	@}
	@end group
	@end smallexample

	The @code{noreturn} keyword tells the compiler to assume that
	@code{fatal} cannot return. It can then optimize without regard to what
	would happen if @code{fatal} ever did return. This makes slightly
	better code. More importantly, it helps avoid spurious warnings of
	uninitialized variables.

	The @code{noreturn} keyword does not affect the exceptional path when that
	applies: a @code{noreturn}-marked function may still return to the caller
	by throwing an exception or calling @code{longjmp}.

	Do not assume that registers saved by the calling function are
	restored before calling the @code{noreturn} function.

	It does not make sense for a @code{noreturn} function to have a return
	type other than @code{void}.

	The attribute @code{noreturn} is not implemented in GCC versions
	earlier than 2.5. An alternative way to declare that a function does
	not return, which works in the current version and in some older
	versions, is as follows:

	@smallexample
	typedef void voidfn ();

	volatile voidfn fatal;
	@end smallexample

	This approach does not work in GNU C++.

	@item nothrow
	@cindex @code{nothrow} function attribute
	The @code{nothrow} attribute is used to inform the compiler that a
	function cannot throw an exception. For example, most functions in
	the standard C library can be guaranteed not to throw an exception
	with the notable exceptions of @code{qsort} and @code{bsearch} that
	take function pointer arguments. The @code{nothrow} attribute is not
	implemented in GCC versions earlier than 3.3.

	@item pure
	@cindex @code{pure} function attribute
	Many functions have no effects except the return value and their
	return value depends only on the parameters and/or global variables.
	Such a function can be subject
	to common subexpression elimination and loop optimization just as an
	arithmetic operator would be. These functions should be declared
	with the attribute @code{pure}. For example,

	@smallexample
	int square (int) __attribute__ ((pure));
	@end smallexample

	@noindent
	says that the hypothetical function @code{square} is safe to call
	fewer times than the program says.

	Some of common examples of pure functions are @code{strlen} or @code{memcmp}.
	Interesting non-pure functions are functions with infinite loops or those
	depending on volatile memory or other system resource, that may change between
	two consecutive calls (such as @code{feof} in a multithreading environment).

	The attribute @code{pure} is not implemented in GCC versions earlier
	than 2.96.

	@item regparm (@var{number})
	@cindex @code{regparm} attribute
	@cindex functions that are passed arguments in registers on the 386
	On the Intel 386, the @code{regparm} attribute causes the compiler to
	pass arguments number one to @var{number} if they are of integral type
	in registers EAX, EDX, and ECX instead of on the stack. Functions that
	take a variable number of arguments will continue to be passed all of their
	arguments on the stack.

	Beware that on some ELF systems this attribute is unsuitable for
	global functions in shared libraries with lazy binding (which is the
	default). Lazy binding will send the first call via resolving code in
	the loader, which might assume EAX, EDX and ECX can be clobbered, as
	per the standard calling conventions. Solaris 8 is affected by this.
	GNU systems with GLIBC 2.1 or higher, and FreeBSD, are believed to be
	safe since the loaders there save all registers. (Lazy binding can be
	disabled with the linker or the loader if desired, to avoid the
	problem.)

	@item sseregparm
	@cindex @code{sseregparm} attribute
	On the Intel 386 with SSE support, the @code{sseregparm} attribute
	causes the compiler to pass up to 3 floating point arguments in
	SSE registers instead of on the stack. Functions that take a
	variable number of arguments will continue to pass all of their
	floating point arguments on the stack.

	@item force_align_arg_pointer
	@cindex @code{force_align_arg_pointer} attribute
	On the Intel x86, the @code{force_align_arg_pointer} attribute may be
	applied to individual function definitions, generating an alternate
	prologue and epilogue that realigns the runtime stack. This supports
	mixing legacy codes that run with a 4-byte aligned stack with modern
	codes that keep a 16-byte stack for SSE compatibility. The alternate
	prologue and epilogue are slower and bigger than the regular ones, and
	the alternate prologue requires a scratch register; this lowers the
	number of registers available if used in conjunction with the
	@code{regparm} attribute. The @code{force_align_arg_pointer}
	attribute is incompatible with nested functions; this is considered a
	hard error.

	@item returns_twice
	@cindex @code{returns_twice} attribute
	The @code{returns_twice} attribute tells the compiler that a function may
	return more than one time. The compiler will ensure that all registers
	are dead before calling such a function and will emit a warning about
	the variables that may be clobbered after the second return from the
	function. Examples of such functions are @code{setjmp} and @code{vfork}.
	The @code{longjmp}-like counterpart of such function, if any, might need
	to be marked with the @code{noreturn} attribute.

	@item saveall
	@cindex save all registers on the Blackfin, H8/300, H8/300H, and H8S
	Use this attribute on the Blackfin, H8/300, H8/300H, and H8S to indicate that
	all registers except the stack pointer should be saved in the prologue
	regardless of whether they are used or not.

	@item section ("@var{section-name}")
	@cindex @code{section} function attribute
	Normally, the compiler places the code it generates in the @code{text} section.
	Sometimes, however, you need additional sections, or you need certain
	particular functions to appear in special sections. The @code{section}
	attribute specifies that a function lives in a particular section.
	For example, the declaration:

	@smallexample
	extern void foobar (void) __attribute__ ((section ("bar")));
	@end smallexample

	@noindent
	puts the function @code{foobar} in the @code{bar} section.

	Some file formats do not support arbitrary sections so the @code{section}
	attribute is not available on all platforms.
	If you need to map the entire contents of a module to a particular
	section, consider using the facilities of the linker instead.

	@item sentinel
	@cindex @code{sentinel} function attribute
	This function attribute ensures that a parameter in a function call is
	an explicit @code{NULL}. The attribute is only valid on variadic
	functions. By default, the sentinel is located at position zero, the
	last parameter of the function call. If an optional integer position
	argument P is supplied to the attribute, the sentinel must be located at
	position P counting backwards from the end of the argument list.

	@smallexample
	__attribute__ ((sentinel))
	is equivalent to
	__attribute__ ((sentinel(0)))
	@end smallexample

	The attribute is automatically set with a position of 0 for the built-in
	functions @code{execl} and @code{execlp}. The built-in function
	@code{execle} has the attribute set with a position of 1.

	A valid @code{NULL} in this context is defined as zero with any pointer
	type. If your system defines the @code{NULL} macro with an integer type
	then you need to add an explicit cast. GCC replaces @code{stddef.h}
	with a copy that redefines NULL appropriately.

	The warnings for missing or incorrect sentinels are enabled with
	@option{-Wformat}.

	@item short_call
	See long_call/short_call.

	@item shortcall
	See longcall/shortcall.

	@item signal
	@cindex signal handler functions on the AVR processors
	Use this attribute on the AVR to indicate that the specified
	function is a signal handler. The compiler will generate function
	entry and exit sequences suitable for use in a signal handler when this
	attribute is present. Interrupts will be disabled inside the function.

	@item sp_switch
	Use this attribute on the SH to indicate an @code{interrupt_handler}
	function should switch to an alternate stack. It expects a string
	argument that names a global variable holding the address of the
	alternate stack.

	@smallexample
	void *alt_stack;
	void f () __attribute__ ((interrupt_handler,
	sp_switch ("alt_stack")));
	@end smallexample

	@item stdcall
	@cindex functions that pop the argument stack on the 386
	On the Intel 386, the @code{stdcall} attribute causes the compiler to
	assume that the called function will pop off the stack space used to
	pass arguments, unless it takes a variable number of arguments.

	@item tiny_data
	@cindex tiny data section on the H8/300H and H8S
	Use this attribute on the H8/300H and H8S to indicate that the specified
	variable should be placed into the tiny data section.
	The compiler will generate more efficient code for loads and stores
	on data in the tiny data section. Note the tiny data area is limited to
	slightly under 32kbytes of data.

	@item trap_exit
	Use this attribute on the SH for an @code{interrupt_handler} to return using
	@code{trapa} instead of @code{rte}. This attribute expects an integer
	argument specifying the trap number to be used.

	@item unused
	@cindex @code{unused} attribute.
	This attribute, attached to a function, means that the function is meant
	to be possibly unused. GCC will not produce a warning for this
	function.

	@item used
	@cindex @code{used} attribute.
	This attribute, attached to a function, means that code must be emitted
	for the function even if it appears that the function is not referenced.
	This is useful, for example, when the function is referenced only in
	inline assembly.

	@item visibility ("@var{visibility_type}")
	@cindex @code{visibility} attribute
	This attribute affects the linkage of the declaration to which it is attached.
	There are four supported @var{visibility_type} values: default,
	hidden, protected or internal visibility.

	@smallexample
	void __attribute__ ((visibility ("protected")))
	f () @{ /* @r{Do something.} */; @}
	int i __attribute__ ((visibility ("hidden")));
	@end smallexample

	The possible values of @var{visibility_type} correspond to the
	visibility settings in the ELF gABI.

	@table @dfn
	@c keep this list of visibilities in alphabetical order.

	@item default
	Default visibility is the normal case for the object file format.
	This value is available for the visibility attribute to override other
	options that may change the assumed visibility of entities.

	On ELF, default visibility means that the declaration is visible to other
	modules and, in shared libraries, means that the declared entity may be
	overridden.

	On Darwin, default visibility means that the declaration is visible to
	other modules.

	Default visibility corresponds to ``external linkage'' in the language.

	@item hidden
	Hidden visibility indicates that the entity declared will have a new
	form of linkage, which we'll call ``hidden linkage''. Two
	declarations of an object with hidden linkage refer to the same object
	if they are in the same shared object.

	@item internal
	Internal visibility is like hidden visibility, but with additional
	processor specific semantics. Unless otherwise specified by the
	psABI, GCC defines internal visibility to mean that a function is
	@emph{never} called from another module. Compare this with hidden
	functions which, while they cannot be referenced directly by other
	modules, can be referenced indirectly via function pointers. By
	indicating that a function cannot be called from outside the module,
	GCC may for instance omit the load of a PIC register since it is known
	that the calling function loaded the correct value.

	@item protected
	Protected visibility is like default visibility except that it
	indicates that references within the defining module will bind to the
	definition in that module. That is, the declared entity cannot be
	overridden by another module.

	@end table

	All visibilities are supported on many, but not all, ELF targets
	(supported when the assembler supports the @samp{.visibility}
	pseudo-op). Default visibility is supported everywhere. Hidden
	visibility is supported on Darwin targets.

	The visibility attribute should be applied only to declarations which
	would otherwise have external linkage. The attribute should be applied
	consistently, so that the same entity should not be declared with
	different settings of the attribute.

	In C++, the visibility attribute applies to types as well as functions
	and objects, because in C++ types have linkage. A class must not have
	greater visibility than its non-static data member types and bases,
	and class members default to the visibility of their class. Also, a
	declaration without explicit visibility is limited to the visibility
	of its type.

	In C++, you can mark member functions and static member variables of a
	class with the visibility attribute. This is useful if if you know a
	particular method or static member variable should only be used from
	one shared object; then you can mark it hidden while the rest of the
	class has default visibility. Care must be taken to avoid breaking
	the One Definition Rule; for example, it is usually not useful to mark
	an inline method as hidden without marking the whole class as hidden.

	A C++ namespace declaration can also have the visibility attribute.
	This attribute applies only to the particular namespace body, not to
	other definitions of the same namespace; it is equivalent to using
	@samp{#pragma GCC visibility} before and after the namespace
	definition (@pxref{Visibility Pragmas}).

	In C++, if a template argument has limited visibility, this
	restriction is implicitly propagated to the template instantiation.
	Otherwise, template instantiations and specializations default to the
	visibility of their template.

	If both the template and enclosing class have explicit visibility, the
	visibility from the template is used.

	@item warn_unused_result
	@cindex @code{warn_unused_result} attribute
	The @code{warn_unused_result} attribute causes a warning to be emitted
	if a caller of the function with this attribute does not use its
	return value. This is useful for functions where not checking
	the result is either a security problem or always a bug, such as
	@code{realloc}.

	@smallexample
	int fn () __attribute__ ((warn_unused_result));
	int foo ()
	@{
	if (fn () < 0) return -1;
	fn ();
	return 0;
	@}
	@end smallexample

	results in warning on line 5.

	@item weak
	@cindex @code{weak} attribute
	The @code{weak} attribute causes the declaration to be emitted as a weak
	symbol rather than a global. This is primarily useful in defining
	library functions which can be overridden in user code, though it can
	also be used with non-function declarations. Weak symbols are supported
	for ELF targets, and also for a.out targets when using the GNU assembler
	and linker.

	@item weakref
	@itemx weakref ("@var{target}")
	@cindex @code{weakref} attribute
	The @code{weakref} attribute marks a declaration as a weak reference.
	Without arguments, it should be accompanied by an @code{alias} attribute
	naming the target symbol. Optionally, the @var{target} may be given as
	an argument to @code{weakref} itself. In either case, @code{weakref}
	implicitly marks the declaration as @code{weak}. Without a
	@var{target}, given as an argument to @code{weakref} or to @code{alias},
	@code{weakref} is equivalent to @code{weak}.

	@smallexample
	static int x() __attribute__ ((weakref ("y")));
	/* is equivalent to... */
	static int x() __attribute__ ((weak, weakref, alias ("y")));
	/* and to... */
	static int x() __attribute__ ((weakref));
	static int x() __attribute__ ((alias ("y")));
	@end smallexample

	A weak reference is an alias that does not by itself require a
	definition to be given for the target symbol. If the target symbol is
	only referenced through weak references, then the becomes a @code{weak}
	undefined symbol. If it is directly referenced, however, then such
	strong references prevail, and a definition will be required for the
	symbol, not necessarily in the same translation unit.

	The effect is equivalent to moving all references to the alias to a
	separate translation unit, renaming the alias to the aliased symbol,
	declaring it as weak, compiling the two separate translation units and
	performing a reloadable link on them.

	At present, a declaration to which @code{weakref} is attached can
	only be @code{static}.

	@item externally_visible
	@cindex @code{externally_visible} attribute.
	This attribute, attached to a global variable or function nullify
	effect of @option{-fwhole-program} command line option, so the object
	remain visible outside the current compilation unit

	@end table

	You can specify multiple attributes in a declaration by separating them
	by commas within the double parentheses or by immediately following an
	attribute declaration with another attribute declaration.

	@cindex @code{#pragma}, reason for not using
	@cindex pragma, reason for not using
	Some people object to the @code{__attribute__} feature, suggesting that
	ISO C's @code{#pragma} should be used instead. At the time
	@code{__attribute__} was designed, there were two reasons for not doing
	this.

	@enumerate
	@item
	It is impossible to generate @code{#pragma} commands from a macro.

	@item
	There is no telling what the same @code{#pragma} might mean in another
	compiler.
	@end enumerate

	These two reasons applied to almost any application that might have been
	proposed for @code{#pragma}. It was basically a mistake to use
	@code{#pragma} for @emph{anything}.

	The ISO C99 standard includes @code{_Pragma}, which now allows pragmas
	to be generated from macros. In addition, a @code{#pragma GCC}
	namespace is now in use for GCC-specific pragmas. However, it has been
	found convenient to use @code{__attribute__} to achieve a natural
	attachment of attributes to their corresponding declarations, whereas
	@code{#pragma GCC} is of use for constructs that do not naturally form
	part of the grammar. @xref{Other Directives,,Miscellaneous
	Preprocessing Directives, cpp, The GNU C Preprocessor}.

	@node Attribute Syntax
	@section Attribute Syntax
	@cindex attribute syntax

	This section describes the syntax with which @code{__attribute__} may be
	used, and the constructs to which attribute specifiers bind, for the C
	language. Some details may vary for C++. Because of infelicities in
	the grammar for attributes, some forms described here may not be
	successfully parsed in all cases.

	There are some problems with the semantics of attributes in C++. For
	example, there are no manglings for attributes, although they may affect
	code generation, so problems may arise when attributed types are used in
	conjunction with templates or overloading. Similarly, @code{typeid}
	does not distinguish between types with different attributes. Support
	for attributes in C++ may be restricted in future to attributes on
	declarations only, but not on nested declarators.

	@xref{Function Attributes}, for details of the semantics of attributes
	applying to functions. @xref{Variable Attributes}, for details of the
	-semantics of attributes applying to variables. @xref{Type Attributes},
	-for details of the semantics of attributes applying to structure, union
	-and enumerated types.
	-
	+@c APPLE LOCAL begin for-fsf-4_4 3274130 5295549
	+semantics of attributes applying to variables. @xref{Type
	+Attributes}, for details of the semantics of attributes applying to
	+structure, union and enumerated types. @xref{Label Attributes}, for
	+details of the semantics of attributes applying to labels and
	+statements.
	+
	+@c APPLE LOCAL end for-fsf-4_4 3274130 5295549
	An @dfn{attribute specifier} is of the form
	@code{__attribute__ ((@var{attribute-list}))}. An @dfn{attribute list}
	is a possibly empty comma-separated sequence of @dfn{attributes}, where
	each attribute is one of the following:

	@itemize @bullet
	@item
	Empty. Empty attributes are ignored.

	@item
	A word (which may be an identifier such as @code{unused}, or a reserved
	word such as @code{const}).

	@item
	A word, followed by, in parentheses, parameters for the attribute.
	These parameters take one of the following forms:

	@itemize @bullet
	@item
	An identifier. For example, @code{mode} attributes use this form.

	@item
	An identifier followed by a comma and a non-empty comma-separated list
	of expressions. For example, @code{format} attributes use this form.

	@item
	A possibly empty comma-separated list of expressions. For example,
	@code{format_arg} attributes use this form with the list being a single
	integer constant expression, and @code{alias} attributes use this form
	with the list being a single string constant.
	@end itemize
	@end itemize

	An @dfn{attribute specifier list} is a sequence of one or more attribute
	specifiers, not separated by any other tokens.

	-In GNU C, an attribute specifier list may appear after the colon following a
	-label, other than a @code{case} or @code{default} label. The only
	-attribute it makes sense to use after a label is @code{unused}. This
	-feature is intended for code generated by programs which contains labels
	-that may be unused but which is compiled with @option{-Wall}. It would
	-not normally be appropriate to use in it human-written code, though it
	-could be useful in cases where the code that jumps to the label is
	-contained within an @code{#ifdef} conditional. GNU C++ does not permit
	-such placement of attribute lists, as it is permissible for a
	-declaration, which could begin with an attribute list, to be labelled in
	-C++. Declarations cannot be labelled in C90 or C99, so the ambiguity
	-does not arise there.
	+@c APPLE LOCAL begin for-fsf-4_4 3274130 5295549
	+In GNU C, an attribute specifier list may appear after the colon
	+following a label, other than a @code{case} or @code{default} label.
	+GNU C++ does not permit such placement of attribute lists, as it is
	+permissible for a declaration, which could begin with an attribute
	+list, to be labelled in C++. Declarations cannot be labelled in C90
	+or C99, so the ambiguity does not arise there.
	+
	+In GNU C an attribute specifier list may also appear after the keyword
	+@code{while} in a while loop, after @code{do} and after @code{for}.

	+@c APPLE LOCAL end for-fsf-4_4 3274130 5295549
	An attribute specifier list may appear as part of a @code{struct},
	@code{union} or @code{enum} specifier. It may go either immediately
	after the @code{struct}, @code{union} or @code{enum} keyword, or after
	the closing brace. The former syntax is preferred.
	Where attribute specifiers follow the closing brace, they are considered
	to relate to the structure, union or enumerated type defined, not to any
	enclosing declaration the type specifier appears in, and the type
	defined is not complete until after the attribute specifiers.
	@c Otherwise, there would be the following problems: a shift/reduce
	@c conflict between attributes binding the struct/union/enum and
	@c binding to the list of specifiers/qualifiers; and "aligned"
	@c attributes could use sizeof for the structure, but the size could be
	@c changed later by "packed" attributes.

	Otherwise, an attribute specifier appears as part of a declaration,
	counting declarations of unnamed parameters and type names, and relates
	to that declaration (which may be nested in another declaration, for
	example in the case of a parameter declaration), or to a particular declarator
	within a declaration. Where an
	attribute specifier is applied to a parameter declared as a function or
	an array, it should apply to the function or array rather than the
	pointer to which the parameter is implicitly converted, but this is not
	yet correctly implemented.

	Any list of specifiers and qualifiers at the start of a declaration may
	contain attribute specifiers, whether or not such a list may in that
	context contain storage class specifiers. (Some attributes, however,
	are essentially in the nature of storage class specifiers, and only make
	sense where storage class specifiers may be used; for example,
	@code{section}.) There is one necessary limitation to this syntax: the
	first old-style parameter declaration in a function definition cannot
	begin with an attribute specifier, because such an attribute applies to
	the function instead by syntax described below (which, however, is not
	yet implemented in this case). In some other cases, attribute
	specifiers are permitted by this grammar but not yet supported by the
	compiler. All attribute specifiers in this place relate to the
	declaration as a whole. In the obsolescent usage where a type of
	@code{int} is implied by the absence of type specifiers, such a list of
	specifiers and qualifiers may be an attribute specifier list with no
	other specifiers or qualifiers.

	At present, the first parameter in a function prototype must have some
	type specifier which is not an attribute specifier; this resolves an
	ambiguity in the interpretation of @code{void f(int
	(__attribute__((foo)) x))}, but is subject to change. At present, if
	the parentheses of a function declarator contain only attributes then
	those attributes are ignored, rather than yielding an error or warning
	or implying a single parameter of type int, but this is subject to
	change.

	An attribute specifier list may appear immediately before a declarator
	(other than the first) in a comma-separated list of declarators in a
	declaration of more than one identifier using a single list of
	specifiers and qualifiers. Such attribute specifiers apply
	only to the identifier before whose declarator they appear. For
	example, in

	@smallexample
	__attribute__((noreturn)) void d0 (void),
	__attribute__((format(printf, 1, 2))) d1 (const char *, ...),
	d2 (void)
	@end smallexample

	@noindent
	the @code{noreturn} attribute applies to all the functions
	declared; the @code{format} attribute only applies to @code{d1}.

	An attribute specifier list may appear immediately before the comma,
	@code{=} or semicolon terminating the declaration of an identifier other
	than a function definition. At present, such attribute specifiers apply
	to the declared object or function, but in future they may attach to the
	outermost adjacent declarator. In simple cases there is no difference,
	but, for example, in

	@smallexample
	void (****f)(void) __attribute__((noreturn));
	@end smallexample

	@noindent
	at present the @code{noreturn} attribute applies to @code{f}, which
	causes a warning since @code{f} is not a function, but in future it may
	apply to the function @code{****f}. The precise semantics of what
	attributes in such cases will apply to are not yet specified. Where an
	assembler name for an object or function is specified (@pxref{Asm
	Labels}), at present the attribute must follow the @code{asm}
	specification; in future, attributes before the @code{asm} specification
	may apply to the adjacent declarator, and those after it to the declared
	object or function.

	An attribute specifier list may, in future, be permitted to appear after
	the declarator in a function definition (before any old-style parameter
	declarations or the function body).

	Attribute specifiers may be mixed with type qualifiers appearing inside
	the @code{[]} of a parameter array declarator, in the C99 construct by
	which such qualifiers are applied to the pointer to which the array is
	implicitly converted. Such attribute specifiers apply to the pointer,
	not to the array, but at present this is not implemented and they are
	ignored.

	An attribute specifier list may appear at the start of a nested
	declarator. At present, there are some limitations in this usage: the
	attributes correctly apply to the declarator, but for most individual
	attributes the semantics this implies are not implemented.
	When attribute specifiers follow the @code{*} of a pointer
	declarator, they may be mixed with any type qualifiers present.
	The following describes the formal semantics of this syntax. It will make the
	most sense if you are familiar with the formal specification of
	declarators in the ISO C standard.

	Consider (as in C99 subclause 6.7.5 paragraph 4) a declaration @code{T
	D1}, where @code{T} contains declaration specifiers that specify a type
	@var{Type} (such as @code{int}) and @code{D1} is a declarator that
	contains an identifier @var{ident}. The type specified for @var{ident}
	for derived declarators whose type does not include an attribute
	specifier is as in the ISO C standard.

	If @code{D1} has the form @code{( @var{attribute-specifier-list} D )},
	and the declaration @code{T D} specifies the type
	``@var{derived-declarator-type-list} @var{Type}'' for @var{ident}, then
	@code{T D1} specifies the type ``@var{derived-declarator-type-list}
	@var{attribute-specifier-list} @var{Type}'' for @var{ident}.

	If @code{D1} has the form @code{*
	@var{type-qualifier-and-attribute-specifier-list} D}, and the
	declaration @code{T D} specifies the type
	``@var{derived-declarator-type-list} @var{Type}'' for @var{ident}, then
	@code{T D1} specifies the type ``@var{derived-declarator-type-list}
	@var{type-qualifier-and-attribute-specifier-list} @var{Type}'' for
	@var{ident}.

	For example,

	@smallexample
	void (__attribute__((noreturn)) ****f) (void);
	@end smallexample

	@noindent
	specifies the type ``pointer to pointer to pointer to pointer to
	non-returning function returning @code{void}''. As another example,

	@smallexample
	char __attribute__((aligned(8))) f;
	@end smallexample

	@noindent
	specifies the type ``pointer to 8-byte-aligned pointer to @code{char}''.
	Note again that this does not work with most attributes; for example,
	the usage of @samp{aligned} and @samp{noreturn} attributes given above
	is not yet supported.

	For compatibility with existing code written for compiler versions that
	did not implement attributes on nested declarators, some laxity is
	allowed in the placing of attributes. If an attribute that only applies
	to types is applied to a declaration, it will be treated as applying to
	the type of that declaration. If an attribute that only applies to
	declarations is applied to the type of a declaration, it will be treated
	as applying to that declaration; and, for compatibility with code
	placing the attributes immediately before the identifier declared, such
	an attribute applied to a function return type will be treated as
	applying to the function type, and such an attribute applied to an array
	element type will be treated as applying to the array type. If an
	attribute that only applies to function types is applied to a
	pointer-to-function type, it will be treated as applying to the pointer
	target type; if such an attribute is applied to a function return type
	that is not a pointer-to-function type, it will be treated as applying
	to the function type.

	@node Function Prototypes
	@section Prototypes and Old-Style Function Definitions
	@cindex function prototype declarations
	@cindex old-style function definitions
	@cindex promotion of formal parameters

	GNU C extends ISO C to allow a function prototype to override a later
	old-style non-prototype definition. Consider the following example:

	@smallexample
	/* @r{Use prototypes unless the compiler is old-fashioned.} */
	#ifdef __STDC__
	#define P(x) x
	#else
	#define P(x) ()
	#endif

	/* @r{Prototype function declaration.} */
	int isroot P((uid_t));

	/* @r{Old-style function definition.} */
	int
	isroot (x) /* @r{??? lossage here ???} */
	uid_t x;
	@{
	return x == 0;
	@}
	@end smallexample

	Suppose the type @code{uid_t} happens to be @code{short}. ISO C does
	not allow this example, because subword arguments in old-style
	non-prototype definitions are promoted. Therefore in this example the
	function definition's argument is really an @code{int}, which does not
	match the prototype argument type of @code{short}.

	This restriction of ISO C makes it hard to write code that is portable
	to traditional C compilers, because the programmer does not know
	whether the @code{uid_t} type is @code{short}, @code{int}, or
	@code{long}. Therefore, in cases like these GNU C allows a prototype
	to override a later old-style definition. More precisely, in GNU C, a
	function prototype argument type overrides the argument type specified
	by a later old-style definition if the former type is the same as the
	latter type before promotion. Thus in GNU C the above example is
	equivalent to the following:

	@smallexample
	int isroot (uid_t);

	int
	isroot (uid_t x)
	@{
	return x == 0;
	@}
	@end smallexample

	@noindent
	GNU C++ does not support old-style function definitions, so this
	extension is irrelevant.

	@node C++ Comments
	@section C++ Style Comments
	@cindex //
	@cindex C++ comments
	@cindex comments, C++ style

	In GNU C, you may use C++ style comments, which start with @samp{//} and
	continue until the end of the line. Many other C implementations allow
	such comments, and they are included in the 1999 C standard. However,
	C++ style comments are not recognized if you specify an @option{-std}
	option specifying a version of ISO C before C99, or @option{-ansi}
	(equivalent to @option{-std=c89}).

	@node Dollar Signs
	@section Dollar Signs in Identifier Names
	@cindex $
	@cindex dollar signs in identifier names
	@cindex identifier names, dollar signs in

	In GNU C, you may normally use dollar signs in identifier names.
	This is because many traditional C implementations allow such identifiers.
	However, dollar signs in identifiers are not supported on a few target
	machines, typically because the target assembler does not allow them.

	@node Character Escapes
	@section The Character @key{ESC} in Constants

	You can use the sequence @samp{\e} in a string or character constant to
	stand for the ASCII character @key{ESC}.

	@node Alignment
	@section Inquiring on Alignment of Types or Variables
	@cindex alignment
	@cindex type alignment
	@cindex variable alignment

	The keyword @code{__alignof__} allows you to inquire about how an object
	is aligned, or the minimum alignment usually required by a type. Its
	syntax is just like @code{sizeof}.

	For example, if the target machine requires a @code{double} value to be
	aligned on an 8-byte boundary, then @code{__alignof__ (double)} is 8.
	This is true on many RISC machines. On more traditional machine
	designs, @code{__alignof__ (double)} is 4 or even 2.

	Some machines never actually require alignment; they allow reference to any
	data type even at an odd address. For these machines, @code{__alignof__}
	reports the @emph{recommended} alignment of a type.

	If the operand of @code{__alignof__} is an lvalue rather than a type,
	its value is the required alignment for its type, taking into account
	any minimum alignment specified with GCC's @code{__attribute__}
	extension (@pxref{Variable Attributes}). For example, after this
	declaration:

	@smallexample
	struct foo @{ int x; char y; @} foo1;
	@end smallexample

	@noindent
	the value of @code{__alignof__ (foo1.y)} is 1, even though its actual
	alignment is probably 2 or 4, the same as @code{__alignof__ (int)}.

	It is an error to ask for the alignment of an incomplete type.

	@node Variable Attributes
	@section Specifying Attributes of Variables
	@cindex attribute of variables
	@cindex variable attributes

	The keyword @code{__attribute__} allows you to specify special
	attributes of variables or structure fields. This keyword is followed
	by an attribute specification inside double parentheses. Some
	attributes are currently defined generically for variables.
	Other attributes are defined for variables on particular target
	systems. Other attributes are available for functions
	-(@pxref{Function Attributes}) and for types (@pxref{Type Attributes}).
	-Other front ends might define more attributes
	-(@pxref{C++ Extensions,,Extensions to the C++ Language}).
	+@c APPLE LOCAL begin for-fsf-4_4 3274130 5295549
	+(@pxref{Function Attributes}), types (@pxref{Type Attributes}) and
	+labels (@pxref{Label Attributes}). Other front ends might define
	+more attributes (@pxref{C++ Extensions,,Extensions to the C++ Language}).

	+@c APPLE LOCAL end for-fsf-4_4 3274130 5295549
	You may also specify attributes with @samp{__} preceding and following
	each keyword. This allows you to use them in header files without
	being concerned about a possible macro of the same name. For example,
	you may use @code{__aligned__} instead of @code{aligned}.

	@xref{Attribute Syntax}, for details of the exact syntax for using
	attributes.

	@table @code
	@cindex @code{aligned} attribute
	@item aligned (@var{alignment})
	This attribute specifies a minimum alignment for the variable or
	structure field, measured in bytes. For example, the declaration:

	@smallexample
	int x __attribute__ ((aligned (16))) = 0;
	@end smallexample

	@noindent
	causes the compiler to allocate the global variable @code{x} on a
	16-byte boundary. On a 68040, this could be used in conjunction with
	an @code{asm} expression to access the @code{move16} instruction which
	requires 16-byte aligned operands.

	You can also specify the alignment of structure fields. For example, to
	create a double-word aligned @code{int} pair, you could write:

	@smallexample
	struct foo @{ int x[2] __attribute__ ((aligned (8))); @};
	@end smallexample

	@noindent
	This is an alternative to creating a union with a @code{double} member
	that forces the union to be double-word aligned.

	As in the preceding examples, you can explicitly specify the alignment
	(in bytes) that you wish the compiler to use for a given variable or
	structure field. Alternatively, you can leave out the alignment factor
	and just ask the compiler to align a variable or field to the maximum
	useful alignment for the target machine you are compiling for. For
	example, you could write:

	@smallexample
	short array[3] __attribute__ ((aligned));
	@end smallexample

	Whenever you leave out the alignment factor in an @code{aligned} attribute
	specification, the compiler automatically sets the alignment for the declared
	variable or field to the largest alignment which is ever used for any data
	type on the target machine you are compiling for. Doing this can often make
	copy operations more efficient, because the compiler can use whatever
	instructions copy the biggest chunks of memory when performing copies to
	or from the variables or fields that you have aligned this way.

	The @code{aligned} attribute can only increase the alignment; but you
	can decrease it by specifying @code{packed} as well. See below.

	Note that the effectiveness of @code{aligned} attributes may be limited
	by inherent limitations in your linker. On many systems, the linker is
	only able to arrange for variables to be aligned up to a certain maximum
	alignment. (For some linkers, the maximum supported alignment may
	be very very small.) If your linker is only able to align variables
	up to a maximum of 8 byte alignment, then specifying @code{aligned(16)}
	in an @code{__attribute__} will still only provide you with 8 byte
	alignment. See your linker documentation for further information.

	The @code{aligned} attribute can also be used for functions
	(@pxref{Function Attributes}.)

	@item cleanup (@var{cleanup_function})
	@cindex @code{cleanup} attribute
	The @code{cleanup} attribute runs a function when the variable goes
	out of scope. This attribute can only be applied to auto function
	scope variables; it may not be applied to parameters or variables
	with static storage duration. The function must take one parameter,
	a pointer to a type compatible with the variable. The return value
	of the function (if any) is ignored.

	If @option{-fexceptions} is enabled, then @var{cleanup_function}
	will be run during the stack unwinding that happens during the
	processing of the exception. Note that the @code{cleanup} attribute
	does not allow the exception to be caught, only to perform an action.
	It is undefined what happens if @var{cleanup_function} does not
	return normally.

	@item common
	@itemx nocommon
	@cindex @code{common} attribute
	@cindex @code{nocommon} attribute
	@opindex fcommon
	@opindex fno-common
	The @code{common} attribute requests GCC to place a variable in
	``common'' storage. The @code{nocommon} attribute requests the
	opposite---to allocate space for it directly.

	These attributes override the default chosen by the
	@option{-fno-common} and @option{-fcommon} flags respectively.

	@item deprecated
	@cindex @code{deprecated} attribute
	The @code{deprecated} attribute results in a warning if the variable
	is used anywhere in the source file. This is useful when identifying
	variables that are expected to be removed in a future version of a
	program. The warning also includes the location of the declaration
	of the deprecated variable, to enable users to easily find further
	information about why the variable is deprecated, or what they should
	do instead. Note that the warning only occurs for uses:

	@smallexample
	extern int old_var __attribute__ ((deprecated));
	extern int old_var;
	int new_fn () @{ return old_var; @}
	@end smallexample

	results in a warning on line 3 but not line 2.

	The @code{deprecated} attribute can also be used for functions and
	types (@pxref{Function Attributes}, @pxref{Type Attributes}.)

	@item mode (@var{mode})
	@cindex @code{mode} attribute
	This attribute specifies the data type for the declaration---whichever
	type corresponds to the mode @var{mode}. This in effect lets you
	request an integer or floating point type according to its width.

	You may also specify a mode of @samp{byte} or @samp{__byte__} to
	indicate the mode corresponding to a one-byte integer, @samp{word} or
	@samp{__word__} for the mode of a one-word integer, and @samp{pointer}
	or @samp{__pointer__} for the mode used to represent pointers.

	@item packed
	@cindex @code{packed} attribute
	The @code{packed} attribute specifies that a variable or structure field
	should have the smallest possible alignment---one byte for a variable,
	and one bit for a field, unless you specify a larger value with the
	@code{aligned} attribute.

	Here is a structure in which the field @code{x} is packed, so that it
	immediately follows @code{a}:

	@smallexample
	struct foo
	@{
	char a;
	int x[2] __attribute__ ((packed));
	@};
	@end smallexample

	@item section ("@var{section-name}")
	@cindex @code{section} variable attribute
	Normally, the compiler places the objects it generates in sections like
	@code{data} and @code{bss}. Sometimes, however, you need additional sections,
	or you need certain particular variables to appear in special sections,
	for example to map to special hardware. The @code{section}
	attribute specifies that a variable (or function) lives in a particular
	section. For example, this small program uses several specific section names:

	@smallexample
	struct duart a __attribute__ ((section ("DUART_A"))) = @{ 0 @};
	struct duart b __attribute__ ((section ("DUART_B"))) = @{ 0 @};
	char stack[10000] __attribute__ ((section ("STACK"))) = @{ 0 @};
	int init_data __attribute__ ((section ("INITDATA"))) = 0;

	main()
	@{
	/* @r{Initialize stack pointer} */
	init_sp (stack + sizeof (stack));

	/* @r{Initialize initialized data} */
	memcpy (&init_data, &data, &edata - &data);

	/* @r{Turn on the serial ports} */
	init_duart (&a);
	init_duart (&b);
	@}
	@end smallexample

	@noindent
	Use the @code{section} attribute with an @emph{initialized} definition
	of a @emph{global} variable, as shown in the example. GCC issues
	a warning and otherwise ignores the @code{section} attribute in
	uninitialized variable declarations.

	You may only use the @code{section} attribute with a fully initialized
	global definition because of the way linkers work. The linker requires
	each object be defined once, with the exception that uninitialized
	variables tentatively go in the @code{common} (or @code{bss}) section
	and can be multiply ``defined''. You can force a variable to be
	initialized with the @option{-fno-common} flag or the @code{nocommon}
	attribute.

	Some file formats do not support arbitrary sections so the @code{section}
	attribute is not available on all platforms.
	If you need to map the entire contents of a module to a particular
	section, consider using the facilities of the linker instead.

	@item shared
	@cindex @code{shared} variable attribute
	On Microsoft Windows, in addition to putting variable definitions in a named
	section, the section can also be shared among all running copies of an
	executable or DLL@. For example, this small program defines shared data
	by putting it in a named section @code{shared} and marking the section
	shareable:

	@smallexample
	int foo __attribute__((section ("shared"), shared)) = 0;

	int
	main()
	@{
	/* @r{Read and write foo. All running
	copies see the same value.} */
	return 0;
	@}
	@end smallexample

	@noindent
	You may only use the @code{shared} attribute along with @code{section}
	attribute with a fully initialized global definition because of the way
	linkers work. See @code{section} attribute for more information.

	The @code{shared} attribute is only available on Microsoft Windows@.

	@item tls_model ("@var{tls_model}")
	@cindex @code{tls_model} attribute
	The @code{tls_model} attribute sets thread-local storage model
	(@pxref{Thread-Local}) of a particular @code{__thread} variable,
	overriding @option{-ftls-model=} command line switch on a per-variable
	basis.
	The @var{tls_model} argument should be one of @code{global-dynamic},
	@code{local-dynamic}, @code{initial-exec} or @code{local-exec}.

	Not all targets support this attribute.

	@item unused
	This attribute, attached to a variable, means that the variable is meant
	to be possibly unused. GCC will not produce a warning for this
	variable.

	@item used
	This attribute, attached to a variable, means that the variable must be
	emitted even if it appears that the variable is not referenced.

	@item vector_size (@var{bytes})
	This attribute specifies the vector size for the variable, measured in
	bytes. For example, the declaration:

	@smallexample
	int foo __attribute__ ((vector_size (16)));
	@end smallexample

	@noindent
	causes the compiler to set the mode for @code{foo}, to be 16 bytes,
	divided into @code{int} sized units. Assuming a 32-bit int (a vector of
	4 units of 4 bytes), the corresponding mode of @code{foo} will be V4SI@.

	This attribute is only applicable to integral and float scalars,
	although arrays, pointers, and function return values are allowed in
	conjunction with this construct.

	Aggregates with this attribute are invalid, even if they are of the same
	size as a corresponding scalar. For example, the declaration:

	@smallexample
	struct S @{ int a; @};
	struct S __attribute__ ((vector_size (16))) foo;
	@end smallexample

	@noindent
	is invalid even if the size of the structure is the same as the size of
	the @code{int}.

	@item selectany
	The @code{selectany} attribute causes an initialized global variable to
	have link-once semantics. When multiple definitions of the variable are
	encountered by the linker, the first is selected and the remainder are
	discarded. Following usage by the Microsoft compiler, the linker is told
	@emph{not} to warn about size or content differences of the multiple
	definitions.

	Although the primary usage of this attribute is for POD types, the
	attribute can also be applied to global C++ objects that are initialized
	by a constructor. In this case, the static initialization and destruction
	code for the object is emitted in each translation defining the object,
	but the calls to the constructor and destructor are protected by a
	link-once guard variable.

	The @code{selectany} attribute is only available on Microsoft Windows
	targets. You can use @code{__declspec (selectany)} as a synonym for
	@code{__attribute__ ((selectany))} for compatibility with other
	compilers.

	@item weak
	The @code{weak} attribute is described in @xref{Function Attributes}.

	@item dllimport
	The @code{dllimport} attribute is described in @xref{Function Attributes}.

	@item dllexport
	The @code{dllexport} attribute is described in @xref{Function Attributes}.

	@end table

	@subsection M32R/D Variable Attributes

	One attribute is currently defined for the M32R/D@.

	@table @code
	@item model (@var{model-name})
	@cindex variable addressability on the M32R/D
	Use this attribute on the M32R/D to set the addressability of an object.
	The identifier @var{model-name} is one of @code{small}, @code{medium},
	or @code{large}, representing each of the code models.

	Small model objects live in the lower 16MB of memory (so that their
	addresses can be loaded with the @code{ld24} instruction).

	Medium and large model objects may live anywhere in the 32-bit address space
	(the compiler will generate @code{seth/add3} instructions to load their
	addresses).
	@end table

	@anchor{i386 Variable Attributes}
	@subsection i386 Variable Attributes

	Two attributes are currently defined for i386 configurations:
	@code{ms_struct} and @code{gcc_struct}

	@table @code
	@item ms_struct
	@itemx gcc_struct
	@cindex @code{ms_struct} attribute
	@cindex @code{gcc_struct} attribute

	If @code{packed} is used on a structure, or if bit-fields are used
	it may be that the Microsoft ABI packs them differently
	than GCC would normally pack them. Particularly when moving packed
	data between functions compiled with GCC and the native Microsoft compiler
	(either via function call or as data in a file), it may be necessary to access
	either format.

	Currently @option{-m[no-]ms-bitfields} is provided for the Microsoft Windows X86
	compilers to match the native Microsoft compiler.

	The Microsoft structure layout algorithm is fairly simple with the exception
	of the bitfield packing:

	The padding and alignment of members of structures and whether a bit field
	can straddle a storage-unit boundary

	@enumerate
	@item Structure members are stored sequentially in the order in which they are
	declared: the first member has the lowest memory address and the last member
	the highest.

	@item Every data object has an alignment-requirement. The alignment-requirement
	for all data except structures, unions, and arrays is either the size of the
	object or the current packing size (specified with either the aligned attribute
	or the pack pragma), whichever is less. For structures, unions, and arrays,
	the alignment-requirement is the largest alignment-requirement of its members.
	Every object is allocated an offset so that:

	offset % alignment-requirement == 0

	@item Adjacent bit fields are packed into the same 1-, 2-, or 4-byte allocation
	unit if the integral types are the same size and if the next bit field fits
	into the current allocation unit without crossing the boundary imposed by the
	common alignment requirements of the bit fields.
	@end enumerate

	Handling of zero-length bitfields:

	MSVC interprets zero-length bitfields in the following ways:

	@enumerate
	@item If a zero-length bitfield is inserted between two bitfields that would
	normally be coalesced, the bitfields will not be coalesced.

	For example:

	@smallexample
	struct
	@{
	unsigned long bf_1 : 12;
	unsigned long : 0;
	unsigned long bf_2 : 12;
	@} t1;
	@end smallexample

	The size of @code{t1} would be 8 bytes with the zero-length bitfield. If the
	zero-length bitfield were removed, @code{t1}'s size would be 4 bytes.

	@item If a zero-length bitfield is inserted after a bitfield, @code{foo}, and the
	alignment of the zero-length bitfield is greater than the member that follows it,
	@code{bar}, @code{bar} will be aligned as the type of the zero-length bitfield.

	For example:

	@smallexample
	struct
	@{
	char foo : 4;
	short : 0;
	char bar;
	@} t2;

	struct
	@{
	char foo : 4;
	short : 0;
	double bar;
	@} t3;
	@end smallexample

	For @code{t2}, @code{bar} will be placed at offset 2, rather than offset 1.
	Accordingly, the size of @code{t2} will be 4. For @code{t3}, the zero-length
	bitfield will not affect the alignment of @code{bar} or, as a result, the size
	of the structure.

	Taking this into account, it is important to note the following:

	@enumerate
	@item If a zero-length bitfield follows a normal bitfield, the type of the
	zero-length bitfield may affect the alignment of the structure as whole. For
	example, @code{t2} has a size of 4 bytes, since the zero-length bitfield follows a
	normal bitfield, and is of type short.

	@item Even if a zero-length bitfield is not followed by a normal bitfield, it may
	still affect the alignment of the structure:

	@smallexample
	struct
	@{
	char foo : 6;
	long : 0;
	@} t4;
	@end smallexample

	Here, @code{t4} will take up 4 bytes.
	@end enumerate

	@item Zero-length bitfields following non-bitfield members are ignored:

	@smallexample
	struct
	@{
	char foo;
	long : 0;
	char bar;
	@} t5;
	@end smallexample

	Here, @code{t5} will take up 2 bytes.
	@end enumerate
	@end table

	@subsection PowerPC Variable Attributes

	Three attributes currently are defined for PowerPC configurations:
	@code{altivec}, @code{ms_struct} and @code{gcc_struct}.

	For full documentation of the struct attributes please see the
	documentation in the @xref{i386 Variable Attributes}, section.

	For documentation of @code{altivec} attribute please see the
	documentation in the @xref{PowerPC Type Attributes}, section.

	@subsection Xstormy16 Variable Attributes

	One attribute is currently defined for xstormy16 configurations:
	@code{below100}

	@table @code
	@item below100
	@cindex @code{below100} attribute

	If a variable has the @code{below100} attribute (@code{BELOW100} is
	allowed also), GCC will place the variable in the first 0x100 bytes of
	memory and use special opcodes to access it. Such variables will be
	placed in either the @code{.bss_below100} section or the
	@code{.data_below100} section.

	@end table

	@node Type Attributes
	@section Specifying Attributes of Types
	@cindex attribute of types
	@cindex type attributes

	The keyword @code{__attribute__} allows you to specify special
	attributes of @code{struct} and @code{union} types when you define
	such types. This keyword is followed by an attribute specification
	inside double parentheses. Seven attributes are currently defined for
	types: @code{aligned}, @code{packed}, @code{transparent_union},
	@code{unused}, @code{deprecated}, @code{visibility}, and
	@code{may_alias}. Other attributes are defined for functions
	-(@pxref{Function Attributes}) and for variables (@pxref{Variable
	-Attributes}).
	+@c APPLE LOCAL begin for-fsf-4_4 3274130 5295549
	+(@pxref{Function Attributes}), variables (@pxref{Variable
	+Attributes}), and labels (@pxref{Label Attributes}).

	+@c APPLE LOCAL end for-fsf-4_4 3274130 5295549
	You may also specify any one of these attributes with @samp{__}
	preceding and following its keyword. This allows you to use these
	attributes in header files without being concerned about a possible
	macro of the same name. For example, you may use @code{__aligned__}
	instead of @code{aligned}.

	You may specify type attributes either in a @code{typedef} declaration
	or in an enum, struct or union type declaration or definition.

	For an enum, struct or union type, you may specify attributes either
	between the enum, struct or union tag and the name of the type, or
	just past the closing curly brace of the @emph{definition}. The
	former syntax is preferred.

	@xref{Attribute Syntax}, for details of the exact syntax for using
	attributes.

	@table @code
	@cindex @code{aligned} attribute
	@item aligned (@var{alignment})
	This attribute specifies a minimum alignment (in bytes) for variables
	of the specified type. For example, the declarations:

	@smallexample
	struct S @{ short f[3]; @} __attribute__ ((aligned (8)));
	typedef int more_aligned_int __attribute__ ((aligned (8)));
	@end smallexample

	@noindent
	force the compiler to insure (as far as it can) that each variable whose
	type is @code{struct S} or @code{more_aligned_int} will be allocated and
	aligned @emph{at least} on a 8-byte boundary. On a SPARC, having all
	variables of type @code{struct S} aligned to 8-byte boundaries allows
	the compiler to use the @code{ldd} and @code{std} (doubleword load and
	store) instructions when copying one variable of type @code{struct S} to
	another, thus improving run-time efficiency.

	Note that the alignment of any given @code{struct} or @code{union} type
	is required by the ISO C standard to be at least a perfect multiple of
	the lowest common multiple of the alignments of all of the members of
	the @code{struct} or @code{union} in question. This means that you @emph{can}
	effectively adjust the alignment of a @code{struct} or @code{union}
	type by attaching an @code{aligned} attribute to any one of the members
	of such a type, but the notation illustrated in the example above is a
	more obvious, intuitive, and readable way to request the compiler to
	adjust the alignment of an entire @code{struct} or @code{union} type.

	As in the preceding example, you can explicitly specify the alignment
	(in bytes) that you wish the compiler to use for a given @code{struct}
	or @code{union} type. Alternatively, you can leave out the alignment factor
	and just ask the compiler to align a type to the maximum
	useful alignment for the target machine you are compiling for. For
	example, you could write:

	@smallexample
	struct S @{ short f[3]; @} __attribute__ ((aligned));
	@end smallexample

	Whenever you leave out the alignment factor in an @code{aligned}
	attribute specification, the compiler automatically sets the alignment
	for the type to the largest alignment which is ever used for any data
	type on the target machine you are compiling for. Doing this can often
	make copy operations more efficient, because the compiler can use
	whatever instructions copy the biggest chunks of memory when performing
	copies to or from the variables which have types that you have aligned
	this way.

	In the example above, if the size of each @code{short} is 2 bytes, then
	the size of the entire @code{struct S} type is 6 bytes. The smallest
	power of two which is greater than or equal to that is 8, so the
	compiler sets the alignment for the entire @code{struct S} type to 8
	bytes.

	Note that although you can ask the compiler to select a time-efficient
	alignment for a given type and then declare only individual stand-alone
	objects of that type, the compiler's ability to select a time-efficient
	alignment is primarily useful only when you plan to create arrays of
	variables having the relevant (efficiently aligned) type. If you
	declare or use arrays of variables of an efficiently-aligned type, then
	it is likely that your program will also be doing pointer arithmetic (or
	subscripting, which amounts to the same thing) on pointers to the
	relevant type, and the code that the compiler generates for these
	pointer arithmetic operations will often be more efficient for
	efficiently-aligned types than for other types.

	The @code{aligned} attribute can only increase the alignment; but you
	can decrease it by specifying @code{packed} as well. See below.

	Note that the effectiveness of @code{aligned} attributes may be limited
	by inherent limitations in your linker. On many systems, the linker is
	only able to arrange for variables to be aligned up to a certain maximum
	alignment. (For some linkers, the maximum supported alignment may
	be very very small.) If your linker is only able to align variables
	up to a maximum of 8 byte alignment, then specifying @code{aligned(16)}
	in an @code{__attribute__} will still only provide you with 8 byte
	alignment. See your linker documentation for further information.

	@item packed
	This attribute, attached to @code{struct} or @code{union} type
	definition, specifies that each member (other than zero-width bitfields)
	of the structure or union is placed to minimize the memory required. When
	attached to an @code{enum} definition, it indicates that the smallest
	integral type should be used.

	@opindex fshort-enums
	Specifying this attribute for @code{struct} and @code{union} types is
	equivalent to specifying the @code{packed} attribute on each of the
	structure or union members. Specifying the @option{-fshort-enums}
	flag on the line is equivalent to specifying the @code{packed}
	attribute on all @code{enum} definitions.

	In the following example @code{struct my_packed_struct}'s members are
	packed closely together, but the internal layout of its @code{s} member
	is not packed---to do that, @code{struct my_unpacked_struct} would need to
	be packed too.

	@smallexample
	struct my_unpacked_struct
	@{
	char c;
	int i;
	@};

	struct __attribute__ ((__packed__)) my_packed_struct
	@{
	char c;
	int i;
	struct my_unpacked_struct s;
	@};
	@end smallexample

	You may only specify this attribute on the definition of a @code{enum},
	@code{struct} or @code{union}, not on a @code{typedef} which does not
	also define the enumerated type, structure or union.

	@item transparent_union
	This attribute, attached to a @code{union} type definition, indicates
	that any function parameter having that union type causes calls to that
	function to be treated in a special way.

	First, the argument corresponding to a transparent union type can be of
	any type in the union; no cast is required. Also, if the union contains
	a pointer type, the corresponding argument can be a null pointer
	constant or a void pointer expression; and if the union contains a void
	pointer type, the corresponding argument can be any pointer expression.
	If the union member type is a pointer, qualifiers like @code{const} on
	the referenced type must be respected, just as with normal pointer
	conversions.

	Second, the argument is passed to the function using the calling
	conventions of the first member of the transparent union, not the calling
	conventions of the union itself. All members of the union must have the
	same machine representation; this is necessary for this argument passing
	to work properly.

	Transparent unions are designed for library functions that have multiple
	interfaces for compatibility reasons. For example, suppose the
	@code{wait} function must accept either a value of type @code{int *} to
	comply with Posix, or a value of type @code{union wait *} to comply with
	the 4.1BSD interface. If @code{wait}'s parameter were @code{void *},
	@code{wait} would accept both kinds of arguments, but it would also
	accept any other pointer type and this would make argument type checking
	less useful. Instead, @code{<sys/wait.h>} might define the interface
	as follows:

	@smallexample
	typedef union
	@{
	int *__ip;
	union wait *__up;
	@} wait_status_ptr_t __attribute__ ((__transparent_union__));

	pid_t wait (wait_status_ptr_t);
	@end smallexample

	This interface allows either @code{int } or @code{union wait }
	arguments to be passed, using the @code{int *} calling convention.
	The program can call @code{wait} with arguments of either type:

	@smallexample
	int w1 () @{ int w; return wait (&w); @}
	int w2 () @{ union wait w; return wait (&w); @}
	@end smallexample

	With this interface, @code{wait}'s implementation might look like this:

	@smallexample
	pid_t wait (wait_status_ptr_t p)
	@{
	return waitpid (-1, p.__ip, 0);
	@}
	@end smallexample

	@item unused
	When attached to a type (including a @code{union} or a @code{struct}),
	this attribute means that variables of that type are meant to appear
	possibly unused. GCC will not produce a warning for any variables of
	that type, even if the variable appears to do nothing. This is often
	the case with lock or thread classes, which are usually defined and then
	not referenced, but contain constructors and destructors that have
	nontrivial bookkeeping functions.

	@item deprecated
	The @code{deprecated} attribute results in a warning if the type
	is used anywhere in the source file. This is useful when identifying
	types that are expected to be removed in a future version of a program.
	If possible, the warning also includes the location of the declaration
	of the deprecated type, to enable users to easily find further
	information about why the type is deprecated, or what they should do
	instead. Note that the warnings only occur for uses and then only
	if the type is being applied to an identifier that itself is not being
	declared as deprecated.

	@smallexample
	typedef int T1 __attribute__ ((deprecated));
	T1 x;
	typedef T1 T2;
	T2 y;
	typedef T1 T3 __attribute__ ((deprecated));
	T3 z __attribute__ ((deprecated));
	@end smallexample

	results in a warning on line 2 and 3 but not lines 4, 5, or 6. No
	warning is issued for line 4 because T2 is not explicitly
	deprecated. Line 5 has no warning because T3 is explicitly
	deprecated. Similarly for line 6.

	The @code{deprecated} attribute can also be used for functions and
	variables (@pxref{Function Attributes}, @pxref{Variable Attributes}.)

	@item may_alias
	Accesses to objects with types with this attribute are not subjected to
	type-based alias analysis, but are instead assumed to be able to alias
	any other type of objects, just like the @code{char} type. See
	@option{-fstrict-aliasing} for more information on aliasing issues.

	Example of use:

	@smallexample
	typedef short __attribute__((__may_alias__)) short_a;

	int
	main (void)
	@{
	int a = 0x12345678;
	short_a b = (short_a ) &a;

	b[1] = 0;

	if (a == 0x12345678)
	abort();

	exit(0);
	@}
	@end smallexample

	If you replaced @code{short_a} with @code{short} in the variable
	declaration, the above program would abort when compiled with
	@option{-fstrict-aliasing}, which is on by default at @option{-O2} or
	above in recent GCC versions.

	@item visibility
	In C++, attribute visibility (@pxref{Function Attributes}) can also be
	applied to class, struct, union and enum types. Unlike other type
	attributes, the attribute must appear between the initial keyword and
	the name of the type; it cannot appear after the body of the type.

	Note that the type visibility is applied to vague linkage entities
	associated with the class (vtable, typeinfo node, etc.). In
	particular, if a class is thrown as an exception in one shared object
	and caught in another, the class must have default visibility.
	Otherwise the two shared objects will be unable to use the same
	typeinfo node and exception handling will break.

	@subsection ARM Type Attributes

	On those ARM targets that support @code{dllimport} (such as Symbian
	OS), you can use the @code{notshared} attribute to indicate that the
	virtual table and other similar data for a class should not be
	exported from a DLL@. For example:

	@smallexample
	class __declspec(notshared) C @{
	public:
	__declspec(dllimport) C();
	virtual void f();
	@}

	__declspec(dllexport)
	C::C() @{@}
	@end smallexample

	In this code, @code{C::C} is exported from the current DLL, but the
	virtual table for @code{C} is not exported. (You can use
	@code{__attribute__} instead of @code{__declspec} if you prefer, but
	most Symbian OS code uses @code{__declspec}.)

	@anchor{i386 Type Attributes}
	@subsection i386 Type Attributes

	Two attributes are currently defined for i386 configurations:
	@code{ms_struct} and @code{gcc_struct}

	@item ms_struct
	@itemx gcc_struct
	@cindex @code{ms_struct}
	@cindex @code{gcc_struct}

	If @code{packed} is used on a structure, or if bit-fields are used
	it may be that the Microsoft ABI packs them differently
	than GCC would normally pack them. Particularly when moving packed
	data between functions compiled with GCC and the native Microsoft compiler
	(either via function call or as data in a file), it may be necessary to access
	either format.

	Currently @option{-m[no-]ms-bitfields} is provided for the Microsoft Windows X86
	compilers to match the native Microsoft compiler.
	@end table

	To specify multiple attributes, separate them by commas within the
	double parentheses: for example, @samp{__attribute__ ((aligned (16),
	packed))}.

	@anchor{PowerPC Type Attributes}
	@subsection PowerPC Type Attributes

	Three attributes currently are defined for PowerPC configurations:
	@code{altivec}, @code{ms_struct} and @code{gcc_struct}.

	For full documentation of the struct attributes please see the
	documentation in the @xref{i386 Type Attributes}, section.

	The @code{altivec} attribute allows one to declare AltiVec vector data
	types supported by the AltiVec Programming Interface Manual. The
	attribute requires an argument to specify one of three vector types:
	@code{vector__}, @code{pixel__} (always followed by unsigned short),
	and @code{bool__} (always followed by unsigned).

	@smallexample
	__attribute__((altivec(vector__)))
	__attribute__((altivec(pixel__))) unsigned short
	__attribute__((altivec(bool__))) unsigned
	@end smallexample

	These attributes mainly are intended to support the @code{__vector},
	@code{__pixel}, and @code{__bool} AltiVec keywords.

	+@c APPLE LOCAL begin for-fsf-4_4 3274130 5295549
	+@node Label Attributes
	+@section Specifying Attributes of Labels and Statements
	+@cindex attribute of labels
	+@cindex label attributes
	+@cindex attribute of statements
	+@cindex statement attributes
	+
	+The keyword @code{__attribute__} allows you to specify special
	+attributes of labels and statements.
	+
	+Some attributes are currently defined generically for variables.
	+Other attributes are defined for variables on particular target
	+systems. Other attributes are available for functions
	+(@pxref{Function Attributes}), types (@pxref{Type Attributes}) and
	+variables (@pxref{Variable Attributes}).
	+
	+You may also specify attributes with @samp{__} preceding and following
	+each keyword. This allows you to use them in header files without
	+being concerned about a possible macro of the same name. For example,
	+you may use @code{__aligned__} instead of @code{aligned}.
	+
	+@xref{Attribute Syntax}, for details of the exact syntax for using
	+attributes.
	+
	+@table @code
	+@cindex @code{aligned} attribute
	+@item aligned (@var{alignment})
	+This attribute specifies a minimum alignment for the label,
	+measured in bytes. For example, the declaration:
	+
	+@smallexample
	+ some_label: __attribute__((aligned(16)))
	+@end smallexample
	+
	+@noindent
	+requests the compiler to align the label, inserting @code{nop}s as necessary,
	+to a 16-byte boundary.
	+
	+The alignment is only a request. The compiler will usually be able to
	+honour it but sometimes the label will be eliminated by the compiler,
	+in which case its alignment will be eliminated too.
	+
	+When applied to loops, the @code{aligned} attribute causes the loop to
	+be aligned.
	+
	+@item unused
	+When attached to a label this attribute means that the label might not
	+be used. GCC will not produce a warning for the label, even if the
	+label doesn't seem to be referenced. This feature is intended for
	+code generated by programs which contains labels that may be unused
	+but which is compiled with @option{-Wall}. It would not normally be
	+appropriate to use in it human-written code, though it could be useful
	+in cases where the code that jumps to the label is contained within an
	+@code{#ifdef} conditional.
	+
	+This attribute can only be applied to labels, not statements, because
	+there is no warning if a statement is removed.
	+@end table
	+
	+@c APPLE LOCAL end for-fsf-4_4 3274130 5295549
	@node Inline
	@section An Inline Function is As Fast As a Macro
	@cindex inline functions
	@cindex integrating function code
	@cindex open coding
	@cindex macros, inline alternative

	By declaring a function inline, you can direct GCC to make
	calls to that function faster. One way GCC can achieve this is to
	integrate that function's code into the code for its callers. This
	makes execution faster by eliminating the function-call overhead; in
	addition, if any of the actual argument values are constant, their
	known values may permit simplifications at compile time so that not
	all of the inline function's code needs to be included. The effect on
	code size is less predictable; object code may be larger or smaller
	with function inlining, depending on the particular case. You can
	also direct GCC to try to integrate all ``simple enough'' functions
	into their callers with the option @option{-finline-functions}.

	GCC implements three different semantics of declaring a function
	inline. One is available with @option{-std=gnu89}, another when
	@option{-std=c99} or @option{-std=gnu99}, and the third is used when
	compiling C++.

	To declare a function inline, use the @code{inline} keyword in its
	declaration, like this:

	@smallexample
	static inline int
	inc (int *a)
	@{
	(*a)++;
	@}
	@end smallexample

	If you are writing a header file to be included in ISO C89 programs, write
	@code{__inline__} instead of @code{inline}. @xref{Alternate Keywords}.

	The three types of inlining behave similarly in two important cases:
	when the @code{inline} keyword is used on a @code{static} function,
	like the example above, and when a function is first declared without
	using the @code{inline} keyword and then is defined with
	@code{inline}, like this:

	@smallexample
	extern int inc (int *a);
	inline int
	inc (int *a)
	@{
	(*a)++;
	@}
	@end smallexample

	In both of these common cases, the program behaves the same as if you
	had not used the @code{inline} keyword, except for its speed.

	@cindex inline functions, omission of
	@opindex fkeep-inline-functions
	When a function is both inline and @code{static}, if all calls to the
	function are integrated into the caller, and the function's address is
	never used, then the function's own assembler code is never referenced.
	In this case, GCC does not actually output assembler code for the
	function, unless you specify the option @option{-fkeep-inline-functions}.
	Some calls cannot be integrated for various reasons (in particular,
	calls that precede the function's definition cannot be integrated, and
	neither can recursive calls within the definition). If there is a
	nonintegrated call, then the function is compiled to assembler code as
	usual. The function must also be compiled as usual if the program
	refers to its address, because that can't be inlined.

	@cindex automatic @code{inline} for C++ member fns
	@cindex @code{inline} automatic for C++ member fns
	@cindex member fns, automatically @code{inline}
	@cindex C++ member fns, automatically @code{inline}
	@opindex fno-default-inline
	As required by ISO C++, GCC considers member functions defined within
	the body of a class to be marked inline even if they are
	not explicitly declared with the @code{inline} keyword. You can
	override this with @option{-fno-default-inline}; @pxref{C++ Dialect
	Options,,Options Controlling C++ Dialect}.

	GCC does not inline any functions when not optimizing unless you specify
	the @samp{always_inline} attribute for the function, like this:

	@smallexample
	/* @r{Prototype.} */
	inline void foo (const char) __attribute__((always_inline));
	@end smallexample

	The remainder of this section is specific to GNU C89 inlining.

	@cindex non-static inline function
	When an inline function is not @code{static}, then the compiler must assume
	that there may be calls from other source files; since a global symbol can
	be defined only once in any program, the function must not be defined in
	the other source files, so the calls therein cannot be integrated.
	Therefore, a non-@code{static} inline function is always compiled on its
	own in the usual fashion.

	If you specify both @code{inline} and @code{extern} in the function
	definition, then the definition is used only for inlining. In no case
	is the function compiled on its own, not even if you refer to its
	address explicitly. Such an address becomes an external reference, as
	if you had only declared the function, and had not defined it.

	This combination of @code{inline} and @code{extern} has almost the
	effect of a macro. The way to use it is to put a function definition in
	a header file with these keywords, and put another copy of the
	definition (lacking @code{inline} and @code{extern}) in a library file.
	The definition in the header file will cause most calls to the function
	to be inlined. If any uses of the function remain, they will refer to
	the single copy in the library.

	@node Extended Asm
	@section Assembler Instructions with C Expression Operands
	@cindex extended @code{asm}
	@cindex @code{asm} expressions
	@cindex assembler instructions
	@cindex registers

	In an assembler instruction using @code{asm}, you can specify the
	operands of the instruction using C expressions. This means you need not
	guess which registers or memory locations will contain the data you want
	to use.

	You must specify an assembler instruction template much like what
	appears in a machine description, plus an operand constraint string for
	each operand.

	For example, here is how to use the 68881's @code{fsinx} instruction:

	@smallexample
	asm ("fsinx %1,%0" : "=f" (result) : "f" (angle));
	@end smallexample

	@noindent
	Here @code{angle} is the C expression for the input operand while
	@code{result} is that of the output operand. Each has @samp{"f"} as its
	operand constraint, saying that a floating point register is required.
	The @samp{=} in @samp{=f} indicates that the operand is an output; all
	output operands' constraints must use @samp{=}. The constraints use the
	same language used in the machine description (@pxref{Constraints}).

	Each operand is described by an operand-constraint string followed by
	the C expression in parentheses. A colon separates the assembler
	template from the first output operand and another separates the last
	output operand from the first input, if any. Commas separate the
	operands within each group. The total number of operands is currently
	limited to 30; this limitation may be lifted in some future version of
	GCC@.

	If there are no output operands but there are input operands, you must
	place two consecutive colons surrounding the place where the output
	operands would go.

	As of GCC version 3.1, it is also possible to specify input and output
	operands using symbolic names which can be referenced within the
	assembler code. These names are specified inside square brackets
	preceding the constraint string, and can be referenced inside the
	assembler code using @code{%[@var{name}]} instead of a percentage sign
	followed by the operand number. Using named operands the above example
	could look like:

	@smallexample
	asm ("fsinx %[angle],%[output]"
	: [output] "=f" (result)
	: [angle] "f" (angle));
	@end smallexample

	@noindent
	Note that the symbolic operand names have no relation whatsoever to
	other C identifiers. You may use any name you like, even those of
	existing C symbols, but you must ensure that no two operands within the same
	assembler construct use the same symbolic name.

	Output operand expressions must be lvalues; the compiler can check this.
	The input operands need not be lvalues. The compiler cannot check
	whether the operands have data types that are reasonable for the
	instruction being executed. It does not parse the assembler instruction
	template and does not know what it means or even whether it is valid
	assembler input. The extended @code{asm} feature is most often used for
	machine instructions the compiler itself does not know exist. If
	the output expression cannot be directly addressed (for example, it is a
	bit-field), your constraint must allow a register. In that case, GCC
	will use the register as the output of the @code{asm}, and then store
	that register into the output.

	The ordinary output operands must be write-only; GCC will assume that
	the values in these operands before the instruction are dead and need
	not be generated. Extended asm supports input-output or read-write
	operands. Use the constraint character @samp{+} to indicate such an
	operand and list it with the output operands. You should only use
	read-write operands when the constraints for the operand (or the
	operand in which only some of the bits are to be changed) allow a
	register.

	You may, as an alternative, logically split its function into two
	separate operands, one input operand and one write-only output
	operand. The connection between them is expressed by constraints
	which say they need to be in the same location when the instruction
	executes. You can use the same C expression for both operands, or
	different expressions. For example, here we write the (fictitious)
	@samp{combine} instruction with @code{bar} as its read-only source
	operand and @code{foo} as its read-write destination:

	@smallexample
	asm ("combine %2,%0" : "=r" (foo) : "0" (foo), "g" (bar));
	@end smallexample

	@noindent
	The constraint @samp{"0"} for operand 1 says that it must occupy the
	same location as operand 0. A number in constraint is allowed only in
	an input operand and it must refer to an output operand.

	Only a number in the constraint can guarantee that one operand will be in
	the same place as another. The mere fact that @code{foo} is the value
	of both operands is not enough to guarantee that they will be in the
	same place in the generated assembler code. The following would not
	work reliably:

	@smallexample
	asm ("combine %2,%0" : "=r" (foo) : "r" (foo), "g" (bar));
	@end smallexample

	Various optimizations or reloading could cause operands 0 and 1 to be in
	different registers; GCC knows no reason not to do so. For example, the
	compiler might find a copy of the value of @code{foo} in one register and
	use it for operand 1, but generate the output operand 0 in a different
	register (copying it afterward to @code{foo}'s own address). Of course,
	since the register for operand 1 is not even mentioned in the assembler
	code, the result will not work, but GCC can't tell that.

	As of GCC version 3.1, one may write @code{[@var{name}]} instead of
	the operand number for a matching constraint. For example:

	@smallexample
	asm ("cmoveq %1,%2,%[result]"
	: [result] "=r"(result)
	: "r" (test), "r"(new), "[result]"(old));
	@end smallexample

	Sometimes you need to make an @code{asm} operand be a specific register,
	but there's no matching constraint letter for that register @emph{by
	itself}. To force the operand into that register, use a local variable
	for the operand and specify the register in the variable declaration.
	@xref{Explicit Reg Vars}. Then for the @code{asm} operand, use any
	register constraint letter that matches the register:

	@smallexample
	register int *p1 asm ("r0") = @dots{};
	register int *p2 asm ("r1") = @dots{};
	register int *result asm ("r0");
	asm ("sysint" : "=r" (result) : "0" (p1), "r" (p2));
	@end smallexample

	@anchor{Example of asm with clobbered asm reg}
	In the above example, beware that a register that is call-clobbered by
	the target ABI will be overwritten by any function call in the
	assignment, including library calls for arithmetic operators.
	Assuming it is a call-clobbered register, this may happen to @code{r0}
	above by the assignment to @code{p2}. If you have to use such a
	register, use temporary variables for expressions between the register
	assignment and use:

	@smallexample
	int t1 = @dots{};
	register int *p1 asm ("r0") = @dots{};
	register int *p2 asm ("r1") = t1;
	register int *result asm ("r0");
	asm ("sysint" : "=r" (result) : "0" (p1), "r" (p2));
	@end smallexample

	Some instructions clobber specific hard registers. To describe this,
	write a third colon after the input operands, followed by the names of
	the clobbered hard registers (given as strings). Here is a realistic
	example for the VAX:

	@smallexample
	asm volatile ("movc3 %0,%1,%2"
	: /* @r{no outputs} */
	: "g" (from), "g" (to), "g" (count)
	: "r0", "r1", "r2", "r3", "r4", "r5");
	@end smallexample

	You may not write a clobber description in a way that overlaps with an
	input or output operand. For example, you may not have an operand
	describing a register class with one member if you mention that register
	in the clobber list. Variables declared to live in specific registers
	(@pxref{Explicit Reg Vars}), and used as asm input or output operands must
	have no part mentioned in the clobber description.
	There is no way for you to specify that an input
	operand is modified without also specifying it as an output
	operand. Note that if all the output operands you specify are for this
	purpose (and hence unused), you will then also need to specify
	@code{volatile} for the @code{asm} construct, as described below, to
	prevent GCC from deleting the @code{asm} statement as unused.

	If you refer to a particular hardware register from the assembler code,
	you will probably have to list the register after the third colon to
	tell the compiler the register's value is modified. In some assemblers,
	the register names begin with @samp{%}; to produce one @samp{%} in the
	assembler code, you must write @samp{%%} in the input.

	If your assembler instruction can alter the condition code register, add
	@samp{cc} to the list of clobbered registers. GCC on some machines
	represents the condition codes as a specific hardware register;
	@samp{cc} serves to name this register. On other machines, the
	condition code is handled differently, and specifying @samp{cc} has no
	effect. But it is valid no matter what the machine.

	If your assembler instructions access memory in an unpredictable
	fashion, add @samp{memory} to the list of clobbered registers. This
	will cause GCC to not keep memory values cached in registers across the
	assembler instruction and not optimize stores or loads to that memory.
	You will also want to add the @code{volatile} keyword if the memory
	affected is not listed in the inputs or outputs of the @code{asm}, as
	the @samp{memory} clobber does not count as a side-effect of the
	@code{asm}. If you know how large the accessed memory is, you can add
	it as input or output but if this is not known, you should add
	@samp{memory}. As an example, if you access ten bytes of a string, you
	can use a memory input like:

	@smallexample
	@{"m"( (@{ struct @{ char x[10]; @} p = (void )ptr ; *p; @}) )@}.
	@end smallexample

	Note that in the following example the memory input is necessary,
	otherwise GCC might optimize the store to @code{x} away:
	@smallexample
	int foo ()
	@{
	int x = 42;
	int *y = &x;
	int result;
	asm ("magic stuff accessing an 'int' pointed to by '%1'"
	"=&d" (r) : "a" (y), "m" (*y));
	return result;
	@}
	@end smallexample

	You can put multiple assembler instructions together in a single
	@code{asm} template, separated by the characters normally used in assembly
	code for the system. A combination that works in most places is a newline
	to break the line, plus a tab character to move to the instruction field
	(written as @samp{\n\t}). Sometimes semicolons can be used, if the
	assembler allows semicolons as a line-breaking character. Note that some
	assembler dialects use semicolons to start a comment.
	The input operands are guaranteed not to use any of the clobbered
	registers, and neither will the output operands' addresses, so you can
	read and write the clobbered registers as many times as you like. Here
	is an example of multiple instructions in a template; it assumes the
	subroutine @code{_foo} accepts arguments in registers 9 and 10:

	@smallexample
	asm ("movl %0,r9\n\tmovl %1,r10\n\tcall _foo"
	: /* no outputs */
	: "g" (from), "g" (to)
	: "r9", "r10");
	@end smallexample

	Unless an output operand has the @samp{&} constraint modifier, GCC
	may allocate it in the same register as an unrelated input operand, on
	the assumption the inputs are consumed before the outputs are produced.
	This assumption may be false if the assembler code actually consists of
	more than one instruction. In such a case, use @samp{&} for each output
	operand that may not overlap an input. @xref{Modifiers}.

	If you want to test the condition code produced by an assembler
	instruction, you must include a branch and a label in the @code{asm}
	construct, as follows:

	@smallexample
	asm ("clr %0\n\tfrob %1\n\tbeq 0f\n\tmov #1,%0\n0:"
	: "g" (result)
	: "g" (input));
	@end smallexample

	@noindent
	This assumes your assembler supports local labels, as the GNU assembler
	and most Unix assemblers do.

	Speaking of labels, jumps from one @code{asm} to another are not
	supported. The compiler's optimizers do not know about these jumps, and
	therefore they cannot take account of them when deciding how to
	optimize.

	@cindex macros containing @code{asm}
	Usually the most convenient way to use these @code{asm} instructions is to
	encapsulate them in macros that look like functions. For example,

	@smallexample
	#define sin(x) \
	(@{ double __value, __arg = (x); \
	asm ("fsinx %1,%0": "=f" (__value): "f" (__arg)); \
	__value; @})
	@end smallexample

	@noindent
	Here the variable @code{__arg} is used to make sure that the instruction
	operates on a proper @code{double} value, and to accept only those
	arguments @code{x} which can convert automatically to a @code{double}.

	Another way to make sure the instruction operates on the correct data
	type is to use a cast in the @code{asm}. This is different from using a
	variable @code{__arg} in that it converts more different types. For
	example, if the desired type were @code{int}, casting the argument to
	@code{int} would accept a pointer with no complaint, while assigning the
	argument to an @code{int} variable named @code{__arg} would warn about
	using a pointer unless the caller explicitly casts it.

	If an @code{asm} has output operands, GCC assumes for optimization
	purposes the instruction has no side effects except to change the output
	operands. This does not mean instructions with a side effect cannot be
	used, but you must be careful, because the compiler may eliminate them
	if the output operands aren't used, or move them out of loops, or
	replace two with one if they constitute a common subexpression. Also,
	if your instruction does have a side effect on a variable that otherwise
	appears not to change, the old value of the variable may be reused later
	if it happens to be found in a register.

	You can prevent an @code{asm} instruction from being deleted
	by writing the keyword @code{volatile} after
	the @code{asm}. For example:

	@smallexample
	#define get_and_set_priority(new) \
	(@{ int __old; \
	asm volatile ("get_and_set_priority %0, %1" \
	: "=g" (__old) : "g" (new)); \
	__old; @})
	@end smallexample

	@noindent
	The @code{volatile} keyword indicates that the instruction has
	important side-effects. GCC will not delete a volatile @code{asm} if
	it is reachable. (The instruction can still be deleted if GCC can
	prove that control-flow will never reach the location of the
	instruction.) Note that even a volatile @code{asm} instruction
	can be moved relative to other code, including across jump
	instructions. For example, on many targets there is a system
	register which can be set to control the rounding mode of
	floating point operations. You might try
	setting it with a volatile @code{asm}, like this PowerPC example:

	@smallexample
	asm volatile("mtfsf 255,%0" : : "f" (fpenv));
	sum = x + y;
	@end smallexample

	@noindent
	This will not work reliably, as the compiler may move the addition back
	before the volatile @code{asm}. To make it work you need to add an
	artificial dependency to the @code{asm} referencing a variable in the code
	you don't want moved, for example:

	@smallexample
	asm volatile ("mtfsf 255,%1" : "=X"(sum): "f"(fpenv));
	sum = x + y;
	@end smallexample

	Similarly, you can't expect a
	sequence of volatile @code{asm} instructions to remain perfectly
	consecutive. If you want consecutive output, use a single @code{asm}.
	Also, GCC will perform some optimizations across a volatile @code{asm}
	instruction; GCC does not ``forget everything'' when it encounters
	a volatile @code{asm} instruction the way some other compilers do.

	An @code{asm} instruction without any output operands will be treated
	identically to a volatile @code{asm} instruction.

	It is a natural idea to look for a way to give access to the condition
	code left by the assembler instruction. However, when we attempted to
	implement this, we found no way to make it work reliably. The problem
	is that output operands might need reloading, which would result in
	additional following ``store'' instructions. On most machines, these
	instructions would alter the condition code before there was time to
	test it. This problem doesn't arise for ordinary ``test'' and
	``compare'' instructions because they don't have any output operands.

	For reasons similar to those described above, it is not possible to give
	an assembler instruction access to the condition code left by previous
	instructions.

	If you are writing a header file that should be includable in ISO C
	programs, write @code{__asm__} instead of @code{asm}. @xref{Alternate
	Keywords}.

	@subsection Size of an @code{asm}

	Some targets require that GCC track the size of each instruction used in
	order to generate correct code. Because the final length of an
	@code{asm} is only known by the assembler, GCC must make an estimate as
	to how big it will be. The estimate is formed by counting the number of
	statements in the pattern of the @code{asm} and multiplying that by the
	length of the longest instruction on that processor. Statements in the
	@code{asm} are identified by newline characters and whatever statement
	separator characters are supported by the assembler; on most processors
	this is the `@code{;}' character.

	Normally, GCC's estimate is perfectly adequate to ensure that correct
	code is generated, but it is possible to confuse the compiler if you use
	pseudo instructions or assembler macros that expand into multiple real
	instructions or if you use assembler directives that expand to more
	space in the object file than would be needed for a single instruction.
	If this happens then the assembler will produce a diagnostic saying that
	a label is unreachable.

	@subsection i386 floating point asm operands

	There are several rules on the usage of stack-like regs in
	asm_operands insns. These rules apply only to the operands that are
	stack-like regs:

	@enumerate
	@item
	Given a set of input regs that die in an asm_operands, it is
	necessary to know which are implicitly popped by the asm, and
	which must be explicitly popped by gcc.

	An input reg that is implicitly popped by the asm must be
	explicitly clobbered, unless it is constrained to match an
	output operand.

	@item
	For any input reg that is implicitly popped by an asm, it is
	necessary to know how to adjust the stack to compensate for the pop.
	If any non-popped input is closer to the top of the reg-stack than
	the implicitly popped reg, it would not be possible to know what the
	stack looked like---it's not clear how the rest of the stack ``slides
	up''.

	All implicitly popped input regs must be closer to the top of
	the reg-stack than any input that is not implicitly popped.

	It is possible that if an input dies in an insn, reload might
	use the input reg for an output reload. Consider this example:

	@smallexample
	asm ("foo" : "=t" (a) : "f" (b));
	@end smallexample

	This asm says that input B is not popped by the asm, and that
	the asm pushes a result onto the reg-stack, i.e., the stack is one
	deeper after the asm than it was before. But, it is possible that
	reload will think that it can use the same reg for both the input and
	the output, if input B dies in this insn.

	If any input operand uses the @code{f} constraint, all output reg
	constraints must use the @code{&} earlyclobber.

	The asm above would be written as

	@smallexample
	asm ("foo" : "=&t" (a) : "f" (b));
	@end smallexample

	@item
	Some operands need to be in particular places on the stack. All
	output operands fall in this category---there is no other way to
	know which regs the outputs appear in unless the user indicates
	this in the constraints.

	Output operands must specifically indicate which reg an output
	appears in after an asm. @code{=f} is not allowed: the operand
	constraints must select a class with a single reg.

	@item
	Output operands may not be ``inserted'' between existing stack regs.
	Since no 387 opcode uses a read/write operand, all output operands
	are dead before the asm_operands, and are pushed by the asm_operands.
	It makes no sense to push anywhere but the top of the reg-stack.

	Output operands must start at the top of the reg-stack: output
	operands may not ``skip'' a reg.

	@item
	Some asm statements may need extra stack space for internal
	calculations. This can be guaranteed by clobbering stack registers
	unrelated to the inputs and outputs.

	@end enumerate

	Here are a couple of reasonable asms to want to write. This asm
	takes one input, which is internally popped, and produces two outputs.

	@smallexample
	asm ("fsincos" : "=t" (cos), "=u" (sin) : "0" (inp));
	@end smallexample

	This asm takes two inputs, which are popped by the @code{fyl2xp1} opcode,
	and replaces them with one output. The user must code the @code{st(1)}
	clobber for reg-stack.c to know that @code{fyl2xp1} pops both inputs.

	@smallexample
	asm ("fyl2xp1" : "=t" (result) : "0" (x), "u" (y) : "st(1)");
	@end smallexample

	@include md.texi

	@node Asm Labels
	@section Controlling Names Used in Assembler Code
	@cindex assembler names for identifiers
	@cindex names used in assembler code
	@cindex identifiers, names in assembler code

	You can specify the name to be used in the assembler code for a C
	function or variable by writing the @code{asm} (or @code{__asm__})
	keyword after the declarator as follows:

	@smallexample
	int foo asm ("myfoo") = 2;
	@end smallexample

	@noindent
	This specifies that the name to be used for the variable @code{foo} in
	the assembler code should be @samp{myfoo} rather than the usual
	@samp{_foo}.

	On systems where an underscore is normally prepended to the name of a C
	function or variable, this feature allows you to define names for the
	linker that do not start with an underscore.

	It does not make sense to use this feature with a non-static local
	variable since such variables do not have assembler names. If you are
	trying to put the variable in a particular register, see @ref{Explicit
	Reg Vars}. GCC presently accepts such code with a warning, but will
	probably be changed to issue an error, rather than a warning, in the
	future.

	You cannot use @code{asm} in this way in a function @emph{definition}; but
	you can get the same effect by writing a declaration for the function
	before its definition and putting @code{asm} there, like this:

	@smallexample
	extern func () asm ("FUNC");

	func (x, y)
	int x, y;
	/* @r{@dots{}} */
	@end smallexample

	It is up to you to make sure that the assembler names you choose do not
	conflict with any other assembler symbols. Also, you must not use a
	register name; that would produce completely invalid assembler code. GCC
	does not as yet have the ability to store static variables in registers.
	Perhaps that will be added.

	@node Explicit Reg Vars
	@section Variables in Specified Registers
	@cindex explicit register variables
	@cindex variables in specified registers
	@cindex specified registers
	@cindex registers, global allocation

	GNU C allows you to put a few global variables into specified hardware
	registers. You can also specify the register in which an ordinary
	register variable should be allocated.

	@itemize @bullet
	@item
	Global register variables reserve registers throughout the program.
	This may be useful in programs such as programming language
	interpreters which have a couple of global variables that are accessed
	very often.

	@item
	Local register variables in specific registers do not reserve the
	registers, except at the point where they are used as input or output
	operands in an @code{asm} statement and the @code{asm} statement itself is
	not deleted. The compiler's data flow analysis is capable of determining
	where the specified registers contain live values, and where they are
	available for other uses. Stores into local register variables may be deleted
	when they appear to be dead according to dataflow analysis. References
	to local register variables may be deleted or moved or simplified.

	These local variables are sometimes convenient for use with the extended
	@code{asm} feature (@pxref{Extended Asm}), if you want to write one
	output of the assembler instruction directly into a particular register.
	(This will work provided the register you specify fits the constraints
	specified for that operand in the @code{asm}.)
	@end itemize

	@menu
	* Global Reg Vars::
	* Local Reg Vars::
	@end menu

	@node Global Reg Vars
	@subsection Defining Global Register Variables
	@cindex global register variables
	@cindex registers, global variables in

	You can define a global register variable in GNU C like this:

	@smallexample
	register int *foo asm ("a5");
	@end smallexample

	@noindent
	Here @code{a5} is the name of the register which should be used. Choose a
	register which is normally saved and restored by function calls on your
	machine, so that library routines will not clobber it.

	Naturally the register name is cpu-dependent, so you would need to
	conditionalize your program according to cpu type. The register
	@code{a5} would be a good choice on a 68000 for a variable of pointer
	type. On machines with register windows, be sure to choose a ``global''
	register that is not affected magically by the function call mechanism.

	In addition, operating systems on one type of cpu may differ in how they
	name the registers; then you would need additional conditionals. For
	example, some 68000 operating systems call this register @code{%a5}.

	Eventually there may be a way of asking the compiler to choose a register
	automatically, but first we need to figure out how it should choose and
	how to enable you to guide the choice. No solution is evident.

	Defining a global register variable in a certain register reserves that
	register entirely for this use, at least within the current compilation.
	The register will not be allocated for any other purpose in the functions
	in the current compilation. The register will not be saved and restored by
	these functions. Stores into this register are never deleted even if they
	would appear to be dead, but references may be deleted or moved or
	simplified.

	It is not safe to access the global register variables from signal
	handlers, or from more than one thread of control, because the system
	library routines may temporarily use the register for other things (unless
	you recompile them specially for the task at hand).

	@cindex @code{qsort}, and global register variables
	It is not safe for one function that uses a global register variable to
	call another such function @code{foo} by way of a third function
	@code{lose} that was compiled without knowledge of this variable (i.e.@: in a
	different source file in which the variable wasn't declared). This is
	because @code{lose} might save the register and put some other value there.
	For example, you can't expect a global register variable to be available in
	the comparison-function that you pass to @code{qsort}, since @code{qsort}
	might have put something else in that register. (If you are prepared to
	recompile @code{qsort} with the same global register variable, you can
	solve this problem.)

	If you want to recompile @code{qsort} or other source files which do not
	actually use your global register variable, so that they will not use that
	register for any other purpose, then it suffices to specify the compiler
	option @option{-ffixed-@var{reg}}. You need not actually add a global
	register declaration to their source code.

	A function which can alter the value of a global register variable cannot
	safely be called from a function compiled without this variable, because it
	could clobber the value the caller expects to find there on return.
	Therefore, the function which is the entry point into the part of the
	program that uses the global register variable must explicitly save and
	restore the value which belongs to its caller.

	@cindex register variable after @code{longjmp}
	@cindex global register after @code{longjmp}
	@cindex value after @code{longjmp}
	@findex longjmp
	@findex setjmp
	On most machines, @code{longjmp} will restore to each global register
	variable the value it had at the time of the @code{setjmp}. On some
	machines, however, @code{longjmp} will not change the value of global
	register variables. To be portable, the function that called @code{setjmp}
	should make other arrangements to save the values of the global register
	variables, and to restore them in a @code{longjmp}. This way, the same
	thing will happen regardless of what @code{longjmp} does.

	All global register variable declarations must precede all function
	definitions. If such a declaration could appear after function
	definitions, the declaration would be too late to prevent the register from
	being used for other purposes in the preceding functions.

	Global register variables may not have initial values, because an
	executable file has no means to supply initial contents for a register.

	On the SPARC, there are reports that g3 @dots{} g7 are suitable
	registers, but certain library functions, such as @code{getwd}, as well
	as the subroutines for division and remainder, modify g3 and g4. g1 and
	g2 are local temporaries.

	On the 68000, a2 @dots{} a5 should be suitable, as should d2 @dots{} d7.
	Of course, it will not do to use more than a few of those.

	@node Local Reg Vars
	@subsection Specifying Registers for Local Variables
	@cindex local variables, specifying registers
	@cindex specifying registers for local variables
	@cindex registers for local variables

	You can define a local register variable with a specified register
	like this:

	@smallexample
	register int *foo asm ("a5");
	@end smallexample

	@noindent
	Here @code{a5} is the name of the register which should be used. Note
	that this is the same syntax used for defining global register
	variables, but for a local variable it would appear within a function.

	Naturally the register name is cpu-dependent, but this is not a
	problem, since specific registers are most often useful with explicit
	assembler instructions (@pxref{Extended Asm}). Both of these things
	generally require that you conditionalize your program according to
	cpu type.

	In addition, operating systems on one type of cpu may differ in how they
	name the registers; then you would need additional conditionals. For
	example, some 68000 operating systems call this register @code{%a5}.

	Defining such a register variable does not reserve the register; it
	remains available for other uses in places where flow control determines
	the variable's value is not live.

	This option does not guarantee that GCC will generate code that has
	this variable in the register you specify at all times. You may not
	code an explicit reference to this register in the @emph{assembler
	instruction template} part of an @code{asm} statement and assume it will
	always refer to this variable. However, using the variable as an
	@code{asm} @emph{operand} guarantees that the specified register is used
	for the operand.

	Stores into local register variables may be deleted when they appear to be dead
	according to dataflow analysis. References to local register variables may
	be deleted or moved or simplified.

	As for global register variables, it's recommended that you choose a
	register which is normally saved and restored by function calls on
	your machine, so that library routines will not clobber it. A common
	pitfall is to initialize multiple call-clobbered registers with
	arbitrary expressions, where a function call or library call for an
	arithmetic operator will overwrite a register value from a previous
	assignment, for example @code{r0} below:
	@smallexample
	register int *p1 asm ("r0") = @dots{};
	register int *p2 asm ("r1") = @dots{};
	@end smallexample
	In those cases, a solution is to use a temporary variable for
	each arbitrary expression. @xref{Example of asm with clobbered asm reg}.

	@node Alternate Keywords
	@section Alternate Keywords
	@cindex alternate keywords
	@cindex keywords, alternate

	@option{-ansi} and the various @option{-std} options disable certain
	keywords. This causes trouble when you want to use GNU C extensions, or
	a general-purpose header file that should be usable by all programs,
	including ISO C programs. The keywords @code{asm}, @code{typeof} and
	@code{inline} are not available in programs compiled with
	@option{-ansi} or @option{-std} (although @code{inline} can be used in a
	program compiled with @option{-std=c99}). The ISO C99 keyword
	@code{restrict} is only available when @option{-std=gnu99} (which will
	eventually be the default) or @option{-std=c99} (or the equivalent
	@option{-std=iso9899:1999}) is used.

	The way to solve these problems is to put @samp{__} at the beginning and
	end of each problematical keyword. For example, use @code{__asm__}
	instead of @code{asm}, and @code{__inline__} instead of @code{inline}.

	Other C compilers won't accept these alternative keywords; if you want to
	compile with another compiler, you can define the alternate keywords as
	macros to replace them with the customary keywords. It looks like this:

	@smallexample
	#ifndef __GNUC__
	#define __asm__ asm
	#endif
	@end smallexample

	@findex __extension__
	@opindex pedantic
	@option{-pedantic} and other options cause warnings for many GNU C extensions.
	You can
	prevent such warnings within one expression by writing
	@code{__extension__} before the expression. @code{__extension__} has no
	effect aside from this.

	@node Incomplete Enums
	@section Incomplete @code{enum} Types

	You can define an @code{enum} tag without specifying its possible values.
	This results in an incomplete type, much like what you get if you write
	@code{struct foo} without describing the elements. A later declaration
	which does specify the possible values completes the type.

	You can't allocate variables or storage using the type while it is
	incomplete. However, you can work with pointers to that type.

	This extension may not be very useful, but it makes the handling of
	@code{enum} more consistent with the way @code{struct} and @code{union}
	are handled.

	This extension is not supported by GNU C++.

	@node Function Names
	@section Function Names as Strings
	@cindex @code{__func__} identifier
	@cindex @code{__FUNCTION__} identifier
	@cindex @code{__PRETTY_FUNCTION__} identifier

	GCC provides three magic variables which hold the name of the current
	function, as a string. The first of these is @code{__func__}, which
	is part of the C99 standard:

	@display
	The identifier @code{__func__} is implicitly declared by the translator
	as if, immediately following the opening brace of each function
	definition, the declaration

	@smallexample
	static const char __func__[] = "function-name";
	@end smallexample

	appeared, where function-name is the name of the lexically-enclosing
	function. This name is the unadorned name of the function.
	@end display

	@code{__FUNCTION__} is another name for @code{__func__}. Older
	versions of GCC recognize only this name. However, it is not
	standardized. For maximum portability, we recommend you use
	@code{__func__}, but provide a fallback definition with the
	preprocessor:

	@smallexample
	#if __STDC_VERSION__ < 199901L
	# if __GNUC__ >= 2
	# define __func__ __FUNCTION__
	# else
	# define __func__ "<unknown>"
	# endif
	#endif
	@end smallexample

	In C, @code{__PRETTY_FUNCTION__} is yet another name for
	@code{__func__}. However, in C++, @code{__PRETTY_FUNCTION__} contains
	the type signature of the function as well as its bare name. For
	example, this program:

	@smallexample
	extern "C" @{
	extern int printf (char *, ...);
	@}

	class a @{
	public:
	void sub (int i)
	@{
	printf ("__FUNCTION__ = %s\n", __FUNCTION__);
	printf ("__PRETTY_FUNCTION__ = %s\n", __PRETTY_FUNCTION__);
	@}
	@};

	int
	main (void)
	@{
	a ax;
	ax.sub (0);
	return 0;
	@}
	@end smallexample

	@noindent
	gives this output:

	@smallexample
	__FUNCTION__ = sub
	__PRETTY_FUNCTION__ = void a::sub(int)
	@end smallexample

	These identifiers are not preprocessor macros. In GCC 3.3 and
	earlier, in C only, @code{__FUNCTION__} and @code{__PRETTY_FUNCTION__}
	were treated as string literals; they could be used to initialize
	@code{char} arrays, and they could be concatenated with other string
	literals. GCC 3.4 and later treat them as variables, like
	@code{__func__}. In C++, @code{__FUNCTION__} and
	@code{__PRETTY_FUNCTION__} have always been variables.

	@node Return Address
	@section Getting the Return or Frame Address of a Function

	These functions may be used to get information about the callers of a
	function.

	@deftypefn {Built-in Function} {void *} __builtin_return_address (unsigned int @var{level})
	This function returns the return address of the current function, or of
	one of its callers. The @var{level} argument is number of frames to
	scan up the call stack. A value of @code{0} yields the return address
	of the current function, a value of @code{1} yields the return address
	of the caller of the current function, and so forth. When inlining
	the expected behavior is that the function will return the address of
	the function that will be returned to. To work around this behavior use
	the @code{noinline} function attribute.

	The @var{level} argument must be a constant integer.

	On some machines it may be impossible to determine the return address of
	any function other than the current one; in such cases, or when the top
	of the stack has been reached, this function will return @code{0} or a
	random value. In addition, @code{__builtin_frame_address} may be used
	to determine if the top of the stack has been reached.

	This function should only be used with a nonzero argument for debugging
	purposes.
	@end deftypefn

	@deftypefn {Built-in Function} {void *} __builtin_frame_address (unsigned int @var{level})
	This function is similar to @code{__builtin_return_address}, but it
	returns the address of the function frame rather than the return address
	of the function. Calling @code{__builtin_frame_address} with a value of
	@code{0} yields the frame address of the current function, a value of
	@code{1} yields the frame address of the caller of the current function,
	and so forth.

	The frame is the area on the stack which holds local variables and saved
	registers. The frame address is normally the address of the first word
	pushed on to the stack by the function. However, the exact definition
	depends upon the processor and the calling convention. If the processor
	has a dedicated frame pointer register, and the function has a frame,
	then @code{__builtin_frame_address} will return the value of the frame
	pointer register.

	On some machines it may be impossible to determine the frame address of
	any function other than the current one; in such cases, or when the top
	of the stack has been reached, this function will return @code{0} if
	the first frame pointer is properly initialized by the startup code.

	This function should only be used with a nonzero argument for debugging
	purposes.
	@end deftypefn

	@node Vector Extensions
	@section Using vector instructions through built-in functions

	On some targets, the instruction set contains SIMD vector instructions that
	operate on multiple values contained in one large register at the same time.
	For example, on the i386 the MMX, 3Dnow! and SSE extensions can be used
	this way.

	The first step in using these extensions is to provide the necessary data
	types. This should be done using an appropriate @code{typedef}:

	@smallexample
	typedef int v4si __attribute__ ((vector_size (16)));
	@end smallexample

	The @code{int} type specifies the base type, while the attribute specifies
	the vector size for the variable, measured in bytes. For example, the
	declaration above causes the compiler to set the mode for the @code{v4si}
	type to be 16 bytes wide and divided into @code{int} sized units. For
	a 32-bit @code{int} this means a vector of 4 units of 4 bytes, and the
	corresponding mode of @code{foo} will be @acronym{V4SI}.

	The @code{vector_size} attribute is only applicable to integral and
	float scalars, although arrays, pointers, and function return values
	are allowed in conjunction with this construct.

	All the basic integer types can be used as base types, both as signed
	and as unsigned: @code{char}, @code{short}, @code{int}, @code{long},
	@code{long long}. In addition, @code{float} and @code{double} can be
	used to build floating-point vector types.

	Specifying a combination that is not valid for the current architecture
	will cause GCC to synthesize the instructions using a narrower mode.
	For example, if you specify a variable of type @code{V4SI} and your
	architecture does not allow for this specific SIMD type, GCC will
	produce code that uses 4 @code{SIs}.

	The types defined in this manner can be used with a subset of normal C
	operations. Currently, GCC will allow using the following operators
	on these types: @code{+, -, *, /, unary minus, ^, \|, &, ~}@.

	The operations behave like C++ @code{valarrays}. Addition is defined as
	the addition of the corresponding elements of the operands. For
	example, in the code below, each of the 4 elements in @var{a} will be
	added to the corresponding 4 elements in @var{b} and the resulting
	vector will be stored in @var{c}.

	@smallexample
	typedef int v4si __attribute__ ((vector_size (16)));

	v4si a, b, c;

	c = a + b;
	@end smallexample

	Subtraction, multiplication, division, and the logical operations
	operate in a similar manner. Likewise, the result of using the unary
	minus or complement operators on a vector type is a vector whose
	elements are the negative or complemented values of the corresponding
	elements in the operand.

	You can declare variables and use them in function calls and returns, as
	well as in assignments and some casts. You can specify a vector type as
	a return type for a function. Vector types can also be used as function
	arguments. It is possible to cast from one vector type to another,
	provided they are of the same size (in fact, you can also cast vectors
	to and from other datatypes of the same size).

	You cannot operate between vectors of different lengths or different
	signedness without a cast.

	A port that supports hardware vector operations, usually provides a set
	of built-in functions that can be used to operate on vectors. For
	example, a function to add two vectors and multiply the result by a
	third could look like this:

	@smallexample
	v4si f (v4si a, v4si b, v4si c)
	@{
	v4si tmp = __builtin_addv4si (a, b);
	return __builtin_mulv4si (tmp, c);
	@}

	@end smallexample

	@node Offsetof
	@section Offsetof
	@findex __builtin_offsetof

	GCC implements for both C and C++ a syntactic extension to implement
	the @code{offsetof} macro.

	@smallexample
	primary:
	"__builtin_offsetof" "(" @code{typename} "," offsetof_member_designator ")"

	offsetof_member_designator:
	@code{identifier}
	\| offsetof_member_designator "." @code{identifier}
	\| offsetof_member_designator "[" @code{expr} "]"
	@end smallexample

	This extension is sufficient such that

	@smallexample
	#define offsetof(@var{type}, @var{member}) __builtin_offsetof (@var{type}, @var{member})
	@end smallexample

	is a suitable definition of the @code{offsetof} macro. In C++, @var{type}
	may be dependent. In either case, @var{member} may consist of a single
	identifier, or a sequence of member accesses and array references.

	@node Atomic Builtins
	@section Built-in functions for atomic memory access

	The following builtins are intended to be compatible with those described
	in the @cite{Intel Itanium Processor-specific Application Binary Interface},
	section 7.4. As such, they depart from the normal GCC practice of using
	the ``__builtin_'' prefix, and further that they are overloaded such that
	they work on multiple types.

	The definition given in the Intel documentation allows only for the use of
	the types @code{int}, @code{long}, @code{long long} as well as their unsigned
	counterparts. GCC will allow any integral scalar or pointer type that is
	1, 2, 4 or 8 bytes in length.

	Not all operations are supported by all target processors. If a particular
	operation cannot be implemented on the target processor, a warning will be
	generated and a call an external function will be generated. The external
	function will carry the same name as the builtin, with an additional suffix
	@samp{_@var{n}} where @var{n} is the size of the data type.

	@c ??? Should we have a mechanism to suppress this warning? This is almost
	@c useful for implementing the operation under the control of an external
	@c mutex.

	In most cases, these builtins are considered a @dfn{full barrier}. That is,
	no memory operand will be moved across the operation, either forward or
	backward. Further, instructions will be issued as necessary to prevent the
	processor from speculating loads across the operation and from queuing stores
	after the operation.

	All of the routines are are described in the Intel documentation to take
	``an optional list of variables protected by the memory barrier''. It's
	not clear what is meant by that; it could mean that @emph{only} the
	following variables are protected, or it could mean that these variables
	should in addition be protected. At present GCC ignores this list and
	protects all variables which are globally accessible. If in the future
	we make some use of this list, an empty list will continue to mean all
	globally accessible variables.

	@table @code
	@item @var{type} __sync_fetch_and_add (@var{type} *ptr, @var{type} value, ...)
	@itemx @var{type} __sync_fetch_and_sub (@var{type} *ptr, @var{type} value, ...)
	@itemx @var{type} __sync_fetch_and_or (@var{type} *ptr, @var{type} value, ...)
	@itemx @var{type} __sync_fetch_and_and (@var{type} *ptr, @var{type} value, ...)
	@itemx @var{type} __sync_fetch_and_xor (@var{type} *ptr, @var{type} value, ...)
	@itemx @var{type} __sync_fetch_and_nand (@var{type} *ptr, @var{type} value, ...)
	@findex __sync_fetch_and_add
	@findex __sync_fetch_and_sub
	@findex __sync_fetch_and_or
	@findex __sync_fetch_and_and
	@findex __sync_fetch_and_xor
	@findex __sync_fetch_and_nand
	These builtins perform the operation suggested by the name, and
	returns the value that had previously been in memory. That is,

	@smallexample
	@{ tmp = ptr; ptr @var{op}= value; return tmp; @}
	@{ tmp = ptr; ptr = ~tmp & value; return tmp; @} // nand
	@end smallexample

	@item @var{type} __sync_add_and_fetch (@var{type} *ptr, @var{type} value, ...)
	@itemx @var{type} __sync_sub_and_fetch (@var{type} *ptr, @var{type} value, ...)
	@itemx @var{type} __sync_or_and_fetch (@var{type} *ptr, @var{type} value, ...)
	@itemx @var{type} __sync_and_and_fetch (@var{type} *ptr, @var{type} value, ...)
	@itemx @var{type} __sync_xor_and_fetch (@var{type} *ptr, @var{type} value, ...)
	@itemx @var{type} __sync_nand_and_fetch (@var{type} *ptr, @var{type} value, ...)
	@findex __sync_add_and_fetch
	@findex __sync_sub_and_fetch
	@findex __sync_or_and_fetch
	@findex __sync_and_and_fetch
	@findex __sync_xor_and_fetch
	@findex __sync_nand_and_fetch
	These builtins perform the operation suggested by the name, and
	return the new value. That is,

	@smallexample
	@{ ptr @var{op}= value; return ptr; @}
	@{ ptr = ~ptr & value; return *ptr; @} // nand
	@end smallexample

	@item bool __sync_bool_compare_and_swap (@var{type} *ptr, @var{type} oldval @var{type} newval, ...)
	@itemx @var{type} __sync_val_compare_and_swap (@var{type} *ptr, @var{type} oldval @var{type} newval, ...)
	@findex __sync_bool_compare_and_swap
	@findex __sync_val_compare_and_swap
	These builtins perform an atomic compare and swap. That is, if the current
	value of @code{*@var{ptr}} is @var{oldval}, then write @var{newval} into
	@code{*@var{ptr}}.

	The ``bool'' version returns true if the comparison is successful and
	@var{newval} was written. The ``val'' version returns the contents
	of @code{*@var{ptr}} before the operation.

	@item __sync_synchronize (...)
	@findex __sync_synchronize
	This builtin issues a full memory barrier.

	@item @var{type} __sync_lock_test_and_set (@var{type} *ptr, @var{type} value, ...)
	@findex __sync_lock_test_and_set
	This builtin, as described by Intel, is not a traditional test-and-set
	operation, but rather an atomic exchange operation. It writes @var{value}
	into @code{*@var{ptr}}, and returns the previous contents of
	@code{*@var{ptr}}.

	Many targets have only minimal support for such locks, and do not support
	a full exchange operation. In this case, a target may support reduced
	functionality here by which the @emph{only} valid value to store is the
	immediate constant 1. The exact value actually stored in @code{*@var{ptr}}
	is implementation defined.

	This builtin is not a full barrier, but rather an @dfn{acquire barrier}.
	This means that references after the builtin cannot move to (or be
	speculated to) before the builtin, but previous memory stores may not
	be globally visible yet, and previous memory loads may not yet be
	satisfied.

	@item void __sync_lock_release (@var{type} *ptr, ...)
	@findex __sync_lock_release
	This builtin releases the lock acquired by @code{__sync_lock_test_and_set}.
	Normally this means writing the constant 0 to @code{*@var{ptr}}.

	This builtin is not a full barrier, but rather a @dfn{release barrier}.
	This means that all previous memory stores are globally visible, and all
	previous memory loads have been satisfied, but following memory reads
	are not prevented from being speculated to before the barrier.
	@end table

	@node Object Size Checking
	@section Object Size Checking Builtins
	@findex __builtin_object_size
	@findex __builtin___memcpy_chk
	@findex __builtin___mempcpy_chk
	@findex __builtin___memmove_chk
	@findex __builtin___memset_chk
	@findex __builtin___strcpy_chk
	@findex __builtin___stpcpy_chk
	@findex __builtin___strncpy_chk
	@findex __builtin___strcat_chk
	@findex __builtin___strncat_chk
	@findex __builtin___sprintf_chk
	@findex __builtin___snprintf_chk
	@findex __builtin___vsprintf_chk
	@findex __builtin___vsnprintf_chk
	@findex __builtin___printf_chk
	@findex __builtin___vprintf_chk
	@findex __builtin___fprintf_chk
	@findex __builtin___vfprintf_chk

	GCC implements a limited buffer overflow protection mechanism
	that can prevent some buffer overflow attacks.

	@deftypefn {Built-in Function} {size_t} __builtin_object_size (void * @var{ptr}, int @var{type})
	is a built-in construct that returns a constant number of bytes from
	@var{ptr} to the end of the object @var{ptr} pointer points to
	(if known at compile time). @code{__builtin_object_size} never evaluates
	its arguments for side-effects. If there are any side-effects in them, it
	returns @code{(size_t) -1} for @var{type} 0 or 1 and @code{(size_t) 0}
	for @var{type} 2 or 3. If there are multiple objects @var{ptr} can
	point to and all of them are known at compile time, the returned number
	is the maximum of remaining byte counts in those objects if @var{type} & 2 is
	0 and minimum if nonzero. If it is not possible to determine which objects
	@var{ptr} points to at compile time, @code{__builtin_object_size} should
	return @code{(size_t) -1} for @var{type} 0 or 1 and @code{(size_t) 0}
	for @var{type} 2 or 3.

	@var{type} is an integer constant from 0 to 3. If the least significant
	bit is clear, objects are whole variables, if it is set, a closest
	surrounding subobject is considered the object a pointer points to.
	The second bit determines if maximum or minimum of remaining bytes
	is computed.

	@smallexample
	struct V @{ char buf1[10]; int b; char buf2[10]; @} var;
	char p = &var.buf1[1], q = &var.b;

	/* Here the object p points to is var. */
	assert (__builtin_object_size (p, 0) == sizeof (var) - 1);
	/* The subobject p points to is var.buf1. */
	assert (__builtin_object_size (p, 1) == sizeof (var.buf1) - 1);
	/* The object q points to is var. */
	assert (__builtin_object_size (q, 0)
	== (char ) (&var + 1) - (char ) &var.b);
	/* The subobject q points to is var.b. */
	assert (__builtin_object_size (q, 1) == sizeof (var.b));
	@end smallexample
	@end deftypefn

	There are built-in functions added for many common string operation
	functions, e.g. for @code{memcpy} @code{__builtin___memcpy_chk}
	built-in is provided. This built-in has an additional last argument,
	which is the number of bytes remaining in object the @var{dest}
	argument points to or @code{(size_t) -1} if the size is not known.

	The built-in functions are optimized into the normal string functions
	like @code{memcpy} if the last argument is @code{(size_t) -1} or if
	it is known at compile time that the destination object will not
	be overflown. If the compiler can determine at compile time the
	object will be always overflown, it issues a warning.

	The intended use can be e.g.

	@smallexample
	#undef memcpy
	#define bos0(dest) __builtin_object_size (dest, 0)
	#define memcpy(dest, src, n) \
	__builtin___memcpy_chk (dest, src, n, bos0 (dest))

	char *volatile p;
	char buf[10];
	/* It is unknown what object p points to, so this is optimized
	into plain memcpy - no checking is possible. */
	memcpy (p, "abcde", n);
	/* Destination is known and length too. It is known at compile
	time there will be no overflow. */
	memcpy (&buf[5], "abcde", 5);
	/* Destination is known, but the length is not known at compile time.
	This will result in __memcpy_chk call that can check for overflow
	at runtime. */
	memcpy (&buf[5], "abcde", n);
	/* Destination is known and it is known at compile time there will
	be overflow. There will be a warning and __memcpy_chk call that
	will abort the program at runtime. */
	memcpy (&buf[6], "abcde", 5);
	@end smallexample

	Such built-in functions are provided for @code{memcpy}, @code{mempcpy},
	@code{memmove}, @code{memset}, @code{strcpy}, @code{stpcpy}, @code{strncpy},
	@code{strcat} and @code{strncat}.

	There are also checking built-in functions for formatted output functions.
	@smallexample
	int __builtin___sprintf_chk (char s, int flag, size_t os, const char fmt, ...);
	int __builtin___snprintf_chk (char *s, size_t maxlen, int flag, size_t os,
	const char *fmt, ...);
	int __builtin___vsprintf_chk (char s, int flag, size_t os, const char fmt,
	va_list ap);
	int __builtin___vsnprintf_chk (char *s, size_t maxlen, int flag, size_t os,
	const char *fmt, va_list ap);
	@end smallexample

	The added @var{flag} argument is passed unchanged to @code{__sprintf_chk}
	etc. functions and can contain implementation specific flags on what
	additional security measures the checking function might take, such as
	handling @code{%n} differently.

	The @var{os} argument is the object size @var{s} points to, like in the
	other built-in functions. There is a small difference in the behavior
	though, if @var{os} is @code{(size_t) -1}, the built-in functions are
	optimized into the non-checking functions only if @var{flag} is 0, otherwise
	the checking function is called with @var{os} argument set to
	@code{(size_t) -1}.

	In addition to this, there are checking built-in functions
	@code{__builtin___printf_chk}, @code{__builtin___vprintf_chk},
	@code{__builtin___fprintf_chk} and @code{__builtin___vfprintf_chk}.
	These have just one additional argument, @var{flag}, right before
	format string @var{fmt}. If the compiler is able to optimize them to
	@code{fputc} etc. functions, it will, otherwise the checking function
	should be called and the @var{flag} argument passed to it.

	@node Other Builtins
	@section Other built-in functions provided by GCC
	@cindex built-in functions
	@findex __builtin_isgreater
	@findex __builtin_isgreaterequal
	@findex __builtin_isless
	@findex __builtin_islessequal
	@findex __builtin_islessgreater
	@findex __builtin_isunordered
	@findex __builtin_powi
	@findex __builtin_powif
	@findex __builtin_powil
	@findex _Exit
	@findex _exit
	@findex abort
	@findex abs
	@findex acos
	@findex acosf
	@findex acosh
	@findex acoshf
	@findex acoshl
	@findex acosl
	@findex alloca
	@findex asin
	@findex asinf
	@findex asinh
	@findex asinhf
	@findex asinhl
	@findex asinl
	@findex atan
	@findex atan2
	@findex atan2f
	@findex atan2l
	@findex atanf
	@findex atanh
	@findex atanhf
	@findex atanhl
	@findex atanl
	@findex bcmp
	@findex bzero
	@findex cabs
	@findex cabsf
	@findex cabsl
	@findex cacos
	@findex cacosf
	@findex cacosh
	@findex cacoshf
	@findex cacoshl
	@findex cacosl
	@findex calloc
	@findex carg
	@findex cargf
	@findex cargl
	@findex casin
	@findex casinf
	@findex casinh
	@findex casinhf
	@findex casinhl
	@findex casinl
	@findex catan
	@findex catanf
	@findex catanh
	@findex catanhf
	@findex catanhl
	@findex catanl
	@findex cbrt
	@findex cbrtf
	@findex cbrtl
	@findex ccos
	@findex ccosf
	@findex ccosh
	@findex ccoshf
	@findex ccoshl
	@findex ccosl
	@findex ceil
	@findex ceilf
	@findex ceill
	@findex cexp
	@findex cexpf
	@findex cexpl
	@findex cimag
	@findex cimagf
	@findex cimagl
	@findex clog
	@findex clogf
	@findex clogl
	@findex conj
	@findex conjf
	@findex conjl
	@findex copysign
	@findex copysignf
	@findex copysignl
	@findex cos
	@findex cosf
	@findex cosh
	@findex coshf
	@findex coshl
	@findex cosl
	@findex cpow
	@findex cpowf
	@findex cpowl
	@findex cproj
	@findex cprojf
	@findex cprojl
	@findex creal
	@findex crealf
	@findex creall
	@findex csin
	@findex csinf
	@findex csinh
	@findex csinhf
	@findex csinhl
	@findex csinl
	@findex csqrt
	@findex csqrtf
	@findex csqrtl
	@findex ctan
	@findex ctanf
	@findex ctanh
	@findex ctanhf
	@findex ctanhl
	@findex ctanl
	@findex dcgettext
	@findex dgettext
	@findex drem
	@findex dremf
	@findex dreml
	@findex erf
	@findex erfc
	@findex erfcf
	@findex erfcl
	@findex erff
	@findex erfl
	@findex exit
	@findex exp
	@findex exp10
	@findex exp10f
	@findex exp10l
	@findex exp2
	@findex exp2f
	@findex exp2l
	@findex expf
	@findex expl
	@findex expm1
	@findex expm1f
	@findex expm1l
	@findex fabs
	@findex fabsf
	@findex fabsl
	@findex fdim
	@findex fdimf
	@findex fdiml
	@findex ffs
	@findex floor
	@findex floorf
	@findex floorl
	@findex fma
	@findex fmaf
	@findex fmal
	@findex fmax
	@findex fmaxf
	@findex fmaxl
	@findex fmin
	@findex fminf
	@findex fminl
	@findex fmod
	@findex fmodf
	@findex fmodl
	@findex fprintf
	@findex fprintf_unlocked
	@findex fputs
	@findex fputs_unlocked
	@findex frexp
	@findex frexpf
	@findex frexpl
	@findex fscanf
	@findex gamma
	@findex gammaf
	@findex gammal
	@findex gettext
	@findex hypot
	@findex hypotf
	@findex hypotl
	@findex ilogb
	@findex ilogbf
	@findex ilogbl
	@findex imaxabs
	@findex index
	@findex isalnum
	@findex isalpha
	@findex isascii
	@findex isblank
	@findex iscntrl
	@findex isdigit
	@findex isgraph
	@findex islower
	@findex isprint
	@findex ispunct
	@findex isspace
	@findex isupper
	@findex iswalnum
	@findex iswalpha
	@findex iswblank
	@findex iswcntrl
	@findex iswdigit
	@findex iswgraph
	@findex iswlower
	@findex iswprint
	@findex iswpunct
	@findex iswspace
	@findex iswupper
	@findex iswxdigit
	@findex isxdigit
	@findex j0
	@findex j0f
	@findex j0l
	@findex j1
	@findex j1f
	@findex j1l
	@findex jn
	@findex jnf
	@findex jnl
	@findex labs
	@findex ldexp
	@findex ldexpf
	@findex ldexpl
	@findex lgamma
	@findex lgammaf
	@findex lgammal
	@findex llabs
	@findex llrint
	@findex llrintf
	@findex llrintl
	@findex llround
	@findex llroundf
	@findex llroundl
	@findex log
	@findex log10
	@findex log10f
	@findex log10l
	@findex log1p
	@findex log1pf
	@findex log1pl
	@findex log2
	@findex log2f
	@findex log2l
	@findex logb
	@findex logbf
	@findex logbl
	@findex logf
	@findex logl
	@findex lrint
	@findex lrintf
	@findex lrintl
	@findex lround
	@findex lroundf
	@findex lroundl
	@findex malloc
	@findex memcmp
	@findex memcpy
	@findex mempcpy
	@findex memset
	@findex modf
	@findex modff
	@findex modfl
	@findex nearbyint
	@findex nearbyintf
	@findex nearbyintl
	@findex nextafter
	@findex nextafterf
	@findex nextafterl
	@findex nexttoward
	@findex nexttowardf
	@findex nexttowardl
	@findex pow
	@findex pow10
	@findex pow10f
	@findex pow10l
	@findex powf
	@findex powl
	@findex printf
	@findex printf_unlocked
	@findex putchar
	@findex puts
	@findex remainder
	@findex remainderf
	@findex remainderl
	@findex remquo
	@findex remquof
	@findex remquol
	@findex rindex
	@findex rint
	@findex rintf
	@findex rintl
	@findex round
	@findex roundf
	@findex roundl
	@findex scalb
	@findex scalbf
	@findex scalbl
	@findex scalbln
	@findex scalblnf
	@findex scalblnf
	@findex scalbn
	@findex scalbnf
	@findex scanfnl
	@findex signbit
	@findex signbitf
	@findex signbitl
	@findex significand
	@findex significandf
	@findex significandl
	@findex sin
	@findex sincos
	@findex sincosf
	@findex sincosl
	@findex sinf
	@findex sinh
	@findex sinhf
	@findex sinhl
	@findex sinl
	@findex snprintf
	@findex sprintf
	@findex sqrt
	@findex sqrtf
	@findex sqrtl
	@findex sscanf
	@findex stpcpy
	@findex stpncpy
	@findex strcasecmp
	@findex strcat
	@findex strchr
	@findex strcmp
	@findex strcpy
	@findex strcspn
	@findex strdup
	@findex strfmon
	@findex strftime
	@findex strlen
	@findex strncasecmp
	@findex strncat
	@findex strncmp
	@findex strncpy
	@findex strndup
	@findex strpbrk
	@findex strrchr
	@findex strspn
	@findex strstr
	@findex tan
	@findex tanf
	@findex tanh
	@findex tanhf
	@findex tanhl
	@findex tanl
	@findex tgamma
	@findex tgammaf
	@findex tgammal
	@findex toascii
	@findex tolower
	@findex toupper
	@findex towlower
	@findex towupper
	@findex trunc
	@findex truncf
	@findex truncl
	@findex vfprintf
	@findex vfscanf
	@findex vprintf
	@findex vscanf
	@findex vsnprintf
	@findex vsprintf
	@findex vsscanf
	@findex y0
	@findex y0f
	@findex y0l
	@findex y1
	@findex y1f
	@findex y1l
	@findex yn
	@findex ynf
	@findex ynl

	GCC provides a large number of built-in functions other than the ones
	mentioned above. Some of these are for internal use in the processing
	of exceptions or variable-length argument lists and will not be
	documented here because they may change from time to time; we do not
	recommend general use of these functions.

	The remaining functions are provided for optimization purposes.

	@opindex fno-builtin
	GCC includes built-in versions of many of the functions in the standard
	C library. The versions prefixed with @code{__builtin_} will always be
	treated as having the same meaning as the C library function even if you
	specify the @option{-fno-builtin} option. (@pxref{C Dialect Options})
	Many of these functions are only optimized in certain cases; if they are
	not optimized in a particular case, a call to the library function will
	be emitted.

	@opindex ansi
	@opindex std
	Outside strict ISO C mode (@option{-ansi}, @option{-std=c89} or
	@option{-std=c99}), the functions
	@code{_exit}, @code{alloca}, @code{bcmp}, @code{bzero},
	@code{dcgettext}, @code{dgettext}, @code{dremf}, @code{dreml},
	@code{drem}, @code{exp10f}, @code{exp10l}, @code{exp10}, @code{ffsll},
	@code{ffsl}, @code{ffs}, @code{fprintf_unlocked}, @code{fputs_unlocked},
	@code{gammaf}, @code{gammal}, @code{gamma}, @code{gettext},
	@code{index}, @code{isascii}, @code{j0f}, @code{j0l}, @code{j0},
	@code{j1f}, @code{j1l}, @code{j1}, @code{jnf}, @code{jnl}, @code{jn},
	@code{mempcpy}, @code{pow10f}, @code{pow10l}, @code{pow10},
	@code{printf_unlocked}, @code{rindex}, @code{scalbf}, @code{scalbl},
	@code{scalb}, @code{signbit}, @code{signbitf}, @code{signbitl},
	@code{significandf}, @code{significandl}, @code{significand},
	@code{sincosf}, @code{sincosl}, @code{sincos}, @code{stpcpy},
	@code{stpncpy}, @code{strcasecmp}, @code{strdup}, @code{strfmon},
	@code{strncasecmp}, @code{strndup}, @code{toascii}, @code{y0f},
	@code{y0l}, @code{y0}, @code{y1f}, @code{y1l}, @code{y1}, @code{ynf},
	@code{ynl} and @code{yn}
	may be handled as built-in functions.
	All these functions have corresponding versions
	prefixed with @code{__builtin_}, which may be used even in strict C89
	mode.

	The ISO C99 functions
	@code{_Exit}, @code{acoshf}, @code{acoshl}, @code{acosh}, @code{asinhf},
	@code{asinhl}, @code{asinh}, @code{atanhf}, @code{atanhl}, @code{atanh},
	@code{cabsf}, @code{cabsl}, @code{cabs}, @code{cacosf}, @code{cacoshf},
	@code{cacoshl}, @code{cacosh}, @code{cacosl}, @code{cacos},
	@code{cargf}, @code{cargl}, @code{carg}, @code{casinf}, @code{casinhf},
	@code{casinhl}, @code{casinh}, @code{casinl}, @code{casin},
	@code{catanf}, @code{catanhf}, @code{catanhl}, @code{catanh},
	@code{catanl}, @code{catan}, @code{cbrtf}, @code{cbrtl}, @code{cbrt},
	@code{ccosf}, @code{ccoshf}, @code{ccoshl}, @code{ccosh}, @code{ccosl},
	@code{ccos}, @code{cexpf}, @code{cexpl}, @code{cexp}, @code{cimagf},
	@code{cimagl}, @code{cimag}, @code{clogf}, @code{clogl}, @code{clog},
	@code{conjf}, @code{conjl}, @code{conj}, @code{copysignf}, @code{copysignl},
	@code{copysign}, @code{cpowf}, @code{cpowl}, @code{cpow}, @code{cprojf},
	@code{cprojl}, @code{cproj}, @code{crealf}, @code{creall}, @code{creal},
	@code{csinf}, @code{csinhf}, @code{csinhl}, @code{csinh}, @code{csinl},
	@code{csin}, @code{csqrtf}, @code{csqrtl}, @code{csqrt}, @code{ctanf},
	@code{ctanhf}, @code{ctanhl}, @code{ctanh}, @code{ctanl}, @code{ctan},
	@code{erfcf}, @code{erfcl}, @code{erfc}, @code{erff}, @code{erfl},
	@code{erf}, @code{exp2f}, @code{exp2l}, @code{exp2}, @code{expm1f},
	@code{expm1l}, @code{expm1}, @code{fdimf}, @code{fdiml}, @code{fdim},
	@code{fmaf}, @code{fmal}, @code{fmaxf}, @code{fmaxl}, @code{fmax},
	@code{fma}, @code{fminf}, @code{fminl}, @code{fmin}, @code{hypotf},
	@code{hypotl}, @code{hypot}, @code{ilogbf}, @code{ilogbl}, @code{ilogb},
	@code{imaxabs}, @code{isblank}, @code{iswblank}, @code{lgammaf},
	@code{lgammal}, @code{lgamma}, @code{llabs}, @code{llrintf}, @code{llrintl},
	@code{llrint}, @code{llroundf}, @code{llroundl}, @code{llround},
	@code{log1pf}, @code{log1pl}, @code{log1p}, @code{log2f}, @code{log2l},
	@code{log2}, @code{logbf}, @code{logbl}, @code{logb}, @code{lrintf},
	@code{lrintl}, @code{lrint}, @code{lroundf}, @code{lroundl},
	@code{lround}, @code{nearbyintf}, @code{nearbyintl}, @code{nearbyint},
	@code{nextafterf}, @code{nextafterl}, @code{nextafter},
	@code{nexttowardf}, @code{nexttowardl}, @code{nexttoward},
	@code{remainderf}, @code{remainderl}, @code{remainder}, @code{remquof},
	@code{remquol}, @code{remquo}, @code{rintf}, @code{rintl}, @code{rint},
	@code{roundf}, @code{roundl}, @code{round}, @code{scalblnf},
	@code{scalblnl}, @code{scalbln}, @code{scalbnf}, @code{scalbnl},
	@code{scalbn}, @code{snprintf}, @code{tgammaf}, @code{tgammal},
	@code{tgamma}, @code{truncf}, @code{truncl}, @code{trunc},
	@code{vfscanf}, @code{vscanf}, @code{vsnprintf} and @code{vsscanf}
	are handled as built-in functions
	except in strict ISO C90 mode (@option{-ansi} or @option{-std=c89}).

	There are also built-in versions of the ISO C99 functions
	@code{acosf}, @code{acosl}, @code{asinf}, @code{asinl}, @code{atan2f},
	@code{atan2l}, @code{atanf}, @code{atanl}, @code{ceilf}, @code{ceill},
	@code{cosf}, @code{coshf}, @code{coshl}, @code{cosl}, @code{expf},
	@code{expl}, @code{fabsf}, @code{fabsl}, @code{floorf}, @code{floorl},
	@code{fmodf}, @code{fmodl}, @code{frexpf}, @code{frexpl}, @code{ldexpf},
	@code{ldexpl}, @code{log10f}, @code{log10l}, @code{logf}, @code{logl},
	@code{modfl}, @code{modf}, @code{powf}, @code{powl}, @code{sinf},
	@code{sinhf}, @code{sinhl}, @code{sinl}, @code{sqrtf}, @code{sqrtl},
	@code{tanf}, @code{tanhf}, @code{tanhl} and @code{tanl}
	that are recognized in any mode since ISO C90 reserves these names for
	the purpose to which ISO C99 puts them. All these functions have
	corresponding versions prefixed with @code{__builtin_}.

	The ISO C94 functions
	@code{iswalnum}, @code{iswalpha}, @code{iswcntrl}, @code{iswdigit},
	@code{iswgraph}, @code{iswlower}, @code{iswprint}, @code{iswpunct},
	@code{iswspace}, @code{iswupper}, @code{iswxdigit}, @code{towlower} and
	@code{towupper}
	are handled as built-in functions
	except in strict ISO C90 mode (@option{-ansi} or @option{-std=c89}).

	The ISO C90 functions
	@code{abort}, @code{abs}, @code{acos}, @code{asin}, @code{atan2},
	@code{atan}, @code{calloc}, @code{ceil}, @code{cosh}, @code{cos},
	@code{exit}, @code{exp}, @code{fabs}, @code{floor}, @code{fmod},
	@code{fprintf}, @code{fputs}, @code{frexp}, @code{fscanf},
	@code{isalnum}, @code{isalpha}, @code{iscntrl}, @code{isdigit},
	@code{isgraph}, @code{islower}, @code{isprint}, @code{ispunct},
	@code{isspace}, @code{isupper}, @code{isxdigit}, @code{tolower},
	@code{toupper}, @code{labs}, @code{ldexp}, @code{log10}, @code{log},
	@code{malloc}, @code{memcmp}, @code{memcpy}, @code{memset}, @code{modf},
	@code{pow}, @code{printf}, @code{putchar}, @code{puts}, @code{scanf},
	@code{sinh}, @code{sin}, @code{snprintf}, @code{sprintf}, @code{sqrt},
	@code{sscanf}, @code{strcat}, @code{strchr}, @code{strcmp},
	@code{strcpy}, @code{strcspn}, @code{strlen}, @code{strncat},
	@code{strncmp}, @code{strncpy}, @code{strpbrk}, @code{strrchr},
	@code{strspn}, @code{strstr}, @code{tanh}, @code{tan}, @code{vfprintf},
	@code{vprintf} and @code{vsprintf}
	are all recognized as built-in functions unless
	@option{-fno-builtin} is specified (or @option{-fno-builtin-@var{function}}
	is specified for an individual function). All of these functions have
	corresponding versions prefixed with @code{__builtin_}.

	GCC provides built-in versions of the ISO C99 floating point comparison
	macros that avoid raising exceptions for unordered operands. They have
	the same names as the standard macros ( @code{isgreater},
	@code{isgreaterequal}, @code{isless}, @code{islessequal},
	@code{islessgreater}, and @code{isunordered}) , with @code{__builtin_}
	prefixed. We intend for a library implementor to be able to simply
	@code{#define} each standard macro to its built-in equivalent.

	@deftypefn {Built-in Function} int __builtin_types_compatible_p (@var{type1}, @var{type2})

	You can use the built-in function @code{__builtin_types_compatible_p} to
	determine whether two types are the same.

	This built-in function returns 1 if the unqualified versions of the
	types @var{type1} and @var{type2} (which are types, not expressions) are
	compatible, 0 otherwise. The result of this built-in function can be
	used in integer constant expressions.

	This built-in function ignores top level qualifiers (e.g., @code{const},
	@code{volatile}). For example, @code{int} is equivalent to @code{const
	int}.

	The type @code{int[]} and @code{int[5]} are compatible. On the other
	hand, @code{int} and @code{char *} are not compatible, even if the size
	of their types, on the particular architecture are the same. Also, the
	amount of pointer indirection is taken into account when determining
	similarity. Consequently, @code{short *} is not similar to
	@code{short **}. Furthermore, two types that are typedefed are
	considered compatible if their underlying types are compatible.

	An @code{enum} type is not considered to be compatible with another
	@code{enum} type even if both are compatible with the same integer
	type; this is what the C standard specifies.
	For example, @code{enum @{foo, bar@}} is not similar to
	@code{enum @{hot, dog@}}.

	You would typically use this function in code whose execution varies
	depending on the arguments' types. For example:

	@smallexample
	#define foo(x) \
	(@{ \
	typeof (x) tmp = (x); \
	if (__builtin_types_compatible_p (typeof (x), long double)) \
	tmp = foo_long_double (tmp); \
	else if (__builtin_types_compatible_p (typeof (x), double)) \
	tmp = foo_double (tmp); \
	else if (__builtin_types_compatible_p (typeof (x), float)) \
	tmp = foo_float (tmp); \
	else \
	abort (); \
	tmp; \
	@})
	@end smallexample

	@emph{Note:} This construct is only available for C@.

	@end deftypefn

	@deftypefn {Built-in Function} @var{type} __builtin_choose_expr (@var{const_exp}, @var{exp1}, @var{exp2})

	You can use the built-in function @code{__builtin_choose_expr} to
	evaluate code depending on the value of a constant expression. This
	built-in function returns @var{exp1} if @var{const_exp}, which is a
	constant expression that must be able to be determined at compile time,
	is nonzero. Otherwise it returns 0.

	This built-in function is analogous to the @samp{? :} operator in C,
	except that the expression returned has its type unaltered by promotion
	rules. Also, the built-in function does not evaluate the expression
	that was not chosen. For example, if @var{const_exp} evaluates to true,
	@var{exp2} is not evaluated even if it has side-effects.

	This built-in function can return an lvalue if the chosen argument is an
	lvalue.

	If @var{exp1} is returned, the return type is the same as @var{exp1}'s
	type. Similarly, if @var{exp2} is returned, its return type is the same
	as @var{exp2}.

	Example:

	@smallexample
	#define foo(x) \
	__builtin_choose_expr ( \
	__builtin_types_compatible_p (typeof (x), double), \
	foo_double (x), \
	__builtin_choose_expr ( \
	__builtin_types_compatible_p (typeof (x), float), \
	foo_float (x), \
	/* @r{The void expression results in a compile-time error} \
	@r{when assigning the result to something.} */ \
	(void)0))
	@end smallexample

	@emph{Note:} This construct is only available for C@. Furthermore, the
	unused expression (@var{exp1} or @var{exp2} depending on the value of
	@var{const_exp}) may still generate syntax errors. This may change in
	future revisions.

	@end deftypefn

	@deftypefn {Built-in Function} int __builtin_constant_p (@var{exp})
	You can use the built-in function @code{__builtin_constant_p} to
	determine if a value is known to be constant at compile-time and hence
	that GCC can perform constant-folding on expressions involving that
	value. The argument of the function is the value to test. The function
	returns the integer 1 if the argument is known to be a compile-time
	constant and 0 if it is not known to be a compile-time constant. A
	return of 0 does not indicate that the value is @emph{not} a constant,
	but merely that GCC cannot prove it is a constant with the specified
	value of the @option{-O} option.

	You would typically use this function in an embedded application where
	memory was a critical resource. If you have some complex calculation,
	you may want it to be folded if it involves constants, but need to call
	a function if it does not. For example:

	@smallexample
	#define Scale_Value(X) \
	(__builtin_constant_p (X) \
	? ((X) * SCALE + OFFSET) : Scale (X))
	@end smallexample

	You may use this built-in function in either a macro or an inline
	function. However, if you use it in an inlined function and pass an
	argument of the function as the argument to the built-in, GCC will
	never return 1 when you call the inline function with a string constant
	or compound literal (@pxref{Compound Literals}) and will not return 1
	when you pass a constant numeric value to the inline function unless you
	specify the @option{-O} option.

	You may also use @code{__builtin_constant_p} in initializers for static
	data. For instance, you can write

	@smallexample
	static const int table[] = @{
	__builtin_constant_p (EXPRESSION) ? (EXPRESSION) : -1,
	/* @r{@dots{}} */
	@};
	@end smallexample

	@noindent
	This is an acceptable initializer even if @var{EXPRESSION} is not a
	constant expression. GCC must be more conservative about evaluating the
	built-in in this case, because it has no opportunity to perform
	optimization.

	Previous versions of GCC did not accept this built-in in data
	initializers. The earliest version where it is completely safe is
	3.0.1.
	@end deftypefn

	@deftypefn {Built-in Function} long __builtin_expect (long @var{exp}, long @var{c})
	@opindex fprofile-arcs
	You may use @code{__builtin_expect} to provide the compiler with
	branch prediction information. In general, you should prefer to
	use actual profile feedback for this (@option{-fprofile-arcs}), as
	programmers are notoriously bad at predicting how their programs
	actually perform. However, there are applications in which this
	data is hard to collect.

	The return value is the value of @var{exp}, which should be an
	integral expression. The value of @var{c} must be a compile-time
	constant. The semantics of the built-in are that it is expected
	that @var{exp} == @var{c}. For example:

	@smallexample
	if (__builtin_expect (x, 0))
	foo ();
	@end smallexample

	@noindent
	would indicate that we do not expect to call @code{foo}, since
	we expect @code{x} to be zero. Since you are limited to integral
	expressions for @var{exp}, you should use constructions such as

	@smallexample
	if (__builtin_expect (ptr != NULL, 1))
	error ();
	@end smallexample

	@noindent
	when testing pointer or floating-point values.
	@end deftypefn

	@deftypefn {Built-in Function} void __builtin_prefetch (const void *@var{addr}, ...)
	This function is used to minimize cache-miss latency by moving data into
	a cache before it is accessed.
	You can insert calls to @code{__builtin_prefetch} into code for which
	you know addresses of data in memory that is likely to be accessed soon.
	If the target supports them, data prefetch instructions will be generated.
	If the prefetch is done early enough before the access then the data will
	be in the cache by the time it is accessed.

	The value of @var{addr} is the address of the memory to prefetch.
	There are two optional arguments, @var{rw} and @var{locality}.
	The value of @var{rw} is a compile-time constant one or zero; one
	means that the prefetch is preparing for a write to the memory address
	and zero, the default, means that the prefetch is preparing for a read.
	The value @var{locality} must be a compile-time constant integer between
	zero and three. A value of zero means that the data has no temporal
	locality, so it need not be left in the cache after the access. A value
	of three means that the data has a high degree of temporal locality and
	should be left in all levels of cache possible. Values of one and two
	mean, respectively, a low or moderate degree of temporal locality. The
	default is three.

	@smallexample
	for (i = 0; i < n; i++)
	@{
	a[i] = a[i] + b[i];
	__builtin_prefetch (&a[i+j], 1, 1);
	__builtin_prefetch (&b[i+j], 0, 1);
	/* @r{@dots{}} */
	@}
	@end smallexample

	Data prefetch does not generate faults if @var{addr} is invalid, but
	the address expression itself must be valid. For example, a prefetch
	of @code{p->next} will not fault if @code{p->next} is not a valid
	address, but evaluation will fault if @code{p} is not a valid address.

	If the target does not support data prefetch, the address expression
	is evaluated if it includes side effects but no other code is generated
	and GCC does not issue a warning.
	@end deftypefn

	@deftypefn {Built-in Function} double __builtin_huge_val (void)
	Returns a positive infinity, if supported by the floating-point format,
	else @code{DBL_MAX}. This function is suitable for implementing the
	ISO C macro @code{HUGE_VAL}.
	@end deftypefn

	@deftypefn {Built-in Function} float __builtin_huge_valf (void)
	Similar to @code{__builtin_huge_val}, except the return type is @code{float}.
	@end deftypefn

	@deftypefn {Built-in Function} {long double} __builtin_huge_vall (void)
	Similar to @code{__builtin_huge_val}, except the return
	type is @code{long double}.
	@end deftypefn

	@deftypefn {Built-in Function} double __builtin_inf (void)
	Similar to @code{__builtin_huge_val}, except a warning is generated
	if the target floating-point format does not support infinities.
	@end deftypefn

	@deftypefn {Built-in Function} _Decimal32 __builtin_infd32 (void)
	Similar to @code{__builtin_inf}, except the return type is @code{_Decimal32}.
	@end deftypefn

	@deftypefn {Built-in Function} _Decimal64 __builtin_infd64 (void)
	Similar to @code{__builtin_inf}, except the return type is @code{_Decimal64}.
	@end deftypefn

	@deftypefn {Built-in Function} _Decimal128 __builtin_infd128 (void)
	Similar to @code{__builtin_inf}, except the return type is @code{_Decimal128}.
	@end deftypefn

	@deftypefn {Built-in Function} float __builtin_inff (void)
	Similar to @code{__builtin_inf}, except the return type is @code{float}.
	This function is suitable for implementing the ISO C99 macro @code{INFINITY}.
	@end deftypefn

	@deftypefn {Built-in Function} {long double} __builtin_infl (void)
	Similar to @code{__builtin_inf}, except the return
	type is @code{long double}.
	@end deftypefn

	@deftypefn {Built-in Function} double __builtin_nan (const char *str)
	This is an implementation of the ISO C99 function @code{nan}.

	Since ISO C99 defines this function in terms of @code{strtod}, which we
	do not implement, a description of the parsing is in order. The string
	is parsed as by @code{strtol}; that is, the base is recognized by
	leading @samp{0} or @samp{0x} prefixes. The number parsed is placed
	in the significand such that the least significant bit of the number
	is at the least significant bit of the significand. The number is
	truncated to fit the significand field provided. The significand is
	forced to be a quiet NaN@.

	This function, if given a string literal all of which would have been
	consumed by strtol, is evaluated early enough that it is considered a
	compile-time constant.
	@end deftypefn

	@deftypefn {Built-in Function} _Decimal32 __builtin_nand32 (const char *str)
	Similar to @code{__builtin_nan}, except the return type is @code{_Decimal32}.
	@end deftypefn

	@deftypefn {Built-in Function} _Decimal64 __builtin_nand64 (const char *str)
	Similar to @code{__builtin_nan}, except the return type is @code{_Decimal64}.
	@end deftypefn

	@deftypefn {Built-in Function} _Decimal128 __builtin_nand128 (const char *str)
	Similar to @code{__builtin_nan}, except the return type is @code{_Decimal128}.
	@end deftypefn

	@deftypefn {Built-in Function} float __builtin_nanf (const char *str)
	Similar to @code{__builtin_nan}, except the return type is @code{float}.
	@end deftypefn

	@deftypefn {Built-in Function} {long double} __builtin_nanl (const char *str)
	Similar to @code{__builtin_nan}, except the return type is @code{long double}.
	@end deftypefn

	@deftypefn {Built-in Function} double __builtin_nans (const char *str)
	Similar to @code{__builtin_nan}, except the significand is forced
	to be a signaling NaN@. The @code{nans} function is proposed by
	@uref{http://www.open-std.org/jtc1/sc22/wg14/www/docs/n965.htm,,WG14 N965}.
	@end deftypefn

	@deftypefn {Built-in Function} float __builtin_nansf (const char *str)
	Similar to @code{__builtin_nans}, except the return type is @code{float}.
	@end deftypefn

	@deftypefn {Built-in Function} {long double} __builtin_nansl (const char *str)
	Similar to @code{__builtin_nans}, except the return type is @code{long double}.
	@end deftypefn

	@deftypefn {Built-in Function} int __builtin_ffs (unsigned int x)
	Returns one plus the index of the least significant 1-bit of @var{x}, or
	if @var{x} is zero, returns zero.
	@end deftypefn

	@deftypefn {Built-in Function} int __builtin_clz (unsigned int x)
	Returns the number of leading 0-bits in @var{x}, starting at the most
	significant bit position. If @var{x} is 0, the result is undefined.
	@end deftypefn

	@deftypefn {Built-in Function} int __builtin_ctz (unsigned int x)
	Returns the number of trailing 0-bits in @var{x}, starting at the least
	significant bit position. If @var{x} is 0, the result is undefined.
	@end deftypefn

	@deftypefn {Built-in Function} int __builtin_popcount (unsigned int x)
	Returns the number of 1-bits in @var{x}.
	@end deftypefn

	@deftypefn {Built-in Function} int __builtin_parity (unsigned int x)
	Returns the parity of @var{x}, i.e.@: the number of 1-bits in @var{x}
	modulo 2.
	@end deftypefn

	@deftypefn {Built-in Function} int __builtin_ffsl (unsigned long)
	Similar to @code{__builtin_ffs}, except the argument type is
	@code{unsigned long}.
	@end deftypefn

	@deftypefn {Built-in Function} int __builtin_clzl (unsigned long)
	Similar to @code{__builtin_clz}, except the argument type is
	@code{unsigned long}.
	@end deftypefn

	@deftypefn {Built-in Function} int __builtin_ctzl (unsigned long)
	Similar to @code{__builtin_ctz}, except the argument type is
	@code{unsigned long}.
	@end deftypefn

	@deftypefn {Built-in Function} int __builtin_popcountl (unsigned long)
	Similar to @code{__builtin_popcount}, except the argument type is
	@code{unsigned long}.
	@end deftypefn

	@deftypefn {Built-in Function} int __builtin_parityl (unsigned long)
	Similar to @code{__builtin_parity}, except the argument type is
	@code{unsigned long}.
	@end deftypefn

	@deftypefn {Built-in Function} int __builtin_ffsll (unsigned long long)
	Similar to @code{__builtin_ffs}, except the argument type is
	@code{unsigned long long}.
	@end deftypefn

	@deftypefn {Built-in Function} int __builtin_clzll (unsigned long long)
	Similar to @code{__builtin_clz}, except the argument type is
	@code{unsigned long long}.
	@end deftypefn

	@deftypefn {Built-in Function} int __builtin_ctzll (unsigned long long)
	Similar to @code{__builtin_ctz}, except the argument type is
	@code{unsigned long long}.
	@end deftypefn

	@deftypefn {Built-in Function} int __builtin_popcountll (unsigned long long)
	Similar to @code{__builtin_popcount}, except the argument type is
	@code{unsigned long long}.
	@end deftypefn

	@deftypefn {Built-in Function} int __builtin_parityll (unsigned long long)
	Similar to @code{__builtin_parity}, except the argument type is
	@code{unsigned long long}.
	@end deftypefn

	@deftypefn {Built-in Function} double __builtin_powi (double, int)
	Returns the first argument raised to the power of the second. Unlike the
	@code{pow} function no guarantees about precision and rounding are made.
	@end deftypefn

	@deftypefn {Built-in Function} float __builtin_powif (float, int)
	Similar to @code{__builtin_powi}, except the argument and return types
	are @code{float}.
	@end deftypefn

	@deftypefn {Built-in Function} {long double} __builtin_powil (long double, int)
	Similar to @code{__builtin_powi}, except the argument and return types
	are @code{long double}.
	@end deftypefn

	@deftypefn {Built-in Function} int32_t __builtin_bswap32 (int32_t x)
	Returns @var{x} with the order of the bytes reversed; for example,
	@code{0xaabbccdd} becomes @code{0xddccbbaa}. Byte here always means
	exactly 8 bits.
	@end deftypefn

	@deftypefn {Built-in Function} int64_t __builtin_bswap64 (int64_t x)
	Similar to @code{__builtin_bswap32}, except the argument and return types
	are 64-bit.
	@end deftypefn

	@node Target Builtins
	@section Built-in Functions Specific to Particular Target Machines

	On some target machines, GCC supports many built-in functions specific
	to those machines. Generally these generate calls to specific machine
	instructions, but allow the compiler to schedule those calls.

	@menu
	* Alpha Built-in Functions::
	* ARM Built-in Functions::
	* Blackfin Built-in Functions::
	* FR-V Built-in Functions::
	* X86 Built-in Functions::
	* MIPS DSP Built-in Functions::
	* MIPS Paired-Single Support::
	* PowerPC AltiVec Built-in Functions::
	* SPARC VIS Built-in Functions::
	@end menu

	@node Alpha Built-in Functions
	@subsection Alpha Built-in Functions

	These built-in functions are available for the Alpha family of
	processors, depending on the command-line switches used.

	The following built-in functions are always available. They
	all generate the machine instruction that is part of the name.

	@smallexample
	long __builtin_alpha_implver (void)
	long __builtin_alpha_rpcc (void)
	long __builtin_alpha_amask (long)
	long __builtin_alpha_cmpbge (long, long)
	long __builtin_alpha_extbl (long, long)
	long __builtin_alpha_extwl (long, long)
	long __builtin_alpha_extll (long, long)
	long __builtin_alpha_extql (long, long)
	long __builtin_alpha_extwh (long, long)
	long __builtin_alpha_extlh (long, long)
	long __builtin_alpha_extqh (long, long)
	long __builtin_alpha_insbl (long, long)
	long __builtin_alpha_inswl (long, long)
	long __builtin_alpha_insll (long, long)
	long __builtin_alpha_insql (long, long)
	long __builtin_alpha_inswh (long, long)
	long __builtin_alpha_inslh (long, long)
	long __builtin_alpha_insqh (long, long)
	long __builtin_alpha_mskbl (long, long)
	long __builtin_alpha_mskwl (long, long)
	long __builtin_alpha_mskll (long, long)
	long __builtin_alpha_mskql (long, long)
	long __builtin_alpha_mskwh (long, long)
	long __builtin_alpha_msklh (long, long)
	long __builtin_alpha_mskqh (long, long)
	long __builtin_alpha_umulh (long, long)
	long __builtin_alpha_zap (long, long)
	long __builtin_alpha_zapnot (long, long)
	@end smallexample

	The following built-in functions are always with @option{-mmax}
	or @option{-mcpu=@var{cpu}} where @var{cpu} is @code{pca56} or
	later. They all generate the machine instruction that is part
	of the name.

	@smallexample
	long __builtin_alpha_pklb (long)
	long __builtin_alpha_pkwb (long)
	long __builtin_alpha_unpkbl (long)
	long __builtin_alpha_unpkbw (long)
	long __builtin_alpha_minub8 (long, long)
	long __builtin_alpha_minsb8 (long, long)
	long __builtin_alpha_minuw4 (long, long)
	long __builtin_alpha_minsw4 (long, long)
	long __builtin_alpha_maxub8 (long, long)
	long __builtin_alpha_maxsb8 (long, long)
	long __builtin_alpha_maxuw4 (long, long)
	long __builtin_alpha_maxsw4 (long, long)
	long __builtin_alpha_perr (long, long)
	@end smallexample

	The following built-in functions are always with @option{-mcix}
	or @option{-mcpu=@var{cpu}} where @var{cpu} is @code{ev67} or
	later. They all generate the machine instruction that is part
	of the name.

	@smallexample
	long __builtin_alpha_cttz (long)
	long __builtin_alpha_ctlz (long)
	long __builtin_alpha_ctpop (long)
	@end smallexample

	The following builtins are available on systems that use the OSF/1
	PALcode. Normally they invoke the @code{rduniq} and @code{wruniq}
	PAL calls, but when invoked with @option{-mtls-kernel}, they invoke
	@code{rdval} and @code{wrval}.

	@smallexample
	void *__builtin_thread_pointer (void)
	void __builtin_set_thread_pointer (void *)
	@end smallexample

	@node ARM Built-in Functions
	@subsection ARM Built-in Functions

	These built-in functions are available for the ARM family of
	processors, when the @option{-mcpu=iwmmxt} switch is used:

	@smallexample
	typedef int v2si __attribute__ ((vector_size (8)));
	typedef short v4hi __attribute__ ((vector_size (8)));
	typedef char v8qi __attribute__ ((vector_size (8)));

	int __builtin_arm_getwcx (int)
	void __builtin_arm_setwcx (int, int)
	int __builtin_arm_textrmsb (v8qi, int)
	int __builtin_arm_textrmsh (v4hi, int)
	int __builtin_arm_textrmsw (v2si, int)
	int __builtin_arm_textrmub (v8qi, int)
	int __builtin_arm_textrmuh (v4hi, int)
	int __builtin_arm_textrmuw (v2si, int)
	v8qi __builtin_arm_tinsrb (v8qi, int)
	v4hi __builtin_arm_tinsrh (v4hi, int)
	v2si __builtin_arm_tinsrw (v2si, int)
	long long __builtin_arm_tmia (long long, int, int)
	long long __builtin_arm_tmiabb (long long, int, int)
	long long __builtin_arm_tmiabt (long long, int, int)
	long long __builtin_arm_tmiaph (long long, int, int)
	long long __builtin_arm_tmiatb (long long, int, int)
	long long __builtin_arm_tmiatt (long long, int, int)
	int __builtin_arm_tmovmskb (v8qi)
	int __builtin_arm_tmovmskh (v4hi)
	int __builtin_arm_tmovmskw (v2si)
	long long __builtin_arm_waccb (v8qi)
	long long __builtin_arm_wacch (v4hi)
	long long __builtin_arm_waccw (v2si)
	v8qi __builtin_arm_waddb (v8qi, v8qi)
	v8qi __builtin_arm_waddbss (v8qi, v8qi)
	v8qi __builtin_arm_waddbus (v8qi, v8qi)
	v4hi __builtin_arm_waddh (v4hi, v4hi)
	v4hi __builtin_arm_waddhss (v4hi, v4hi)
	v4hi __builtin_arm_waddhus (v4hi, v4hi)
	v2si __builtin_arm_waddw (v2si, v2si)
	v2si __builtin_arm_waddwss (v2si, v2si)
	v2si __builtin_arm_waddwus (v2si, v2si)
	v8qi __builtin_arm_walign (v8qi, v8qi, int)
	long long __builtin_arm_wand(long long, long long)
	long long __builtin_arm_wandn (long long, long long)
	v8qi __builtin_arm_wavg2b (v8qi, v8qi)
	v8qi __builtin_arm_wavg2br (v8qi, v8qi)
	v4hi __builtin_arm_wavg2h (v4hi, v4hi)
	v4hi __builtin_arm_wavg2hr (v4hi, v4hi)
	v8qi __builtin_arm_wcmpeqb (v8qi, v8qi)
	v4hi __builtin_arm_wcmpeqh (v4hi, v4hi)
	v2si __builtin_arm_wcmpeqw (v2si, v2si)
	v8qi __builtin_arm_wcmpgtsb (v8qi, v8qi)
	v4hi __builtin_arm_wcmpgtsh (v4hi, v4hi)
	v2si __builtin_arm_wcmpgtsw (v2si, v2si)
	v8qi __builtin_arm_wcmpgtub (v8qi, v8qi)
	v4hi __builtin_arm_wcmpgtuh (v4hi, v4hi)
	v2si __builtin_arm_wcmpgtuw (v2si, v2si)
	long long __builtin_arm_wmacs (long long, v4hi, v4hi)
	long long __builtin_arm_wmacsz (v4hi, v4hi)
	long long __builtin_arm_wmacu (long long, v4hi, v4hi)
	long long __builtin_arm_wmacuz (v4hi, v4hi)
	v4hi __builtin_arm_wmadds (v4hi, v4hi)
	v4hi __builtin_arm_wmaddu (v4hi, v4hi)
	v8qi __builtin_arm_wmaxsb (v8qi, v8qi)
	v4hi __builtin_arm_wmaxsh (v4hi, v4hi)
	v2si __builtin_arm_wmaxsw (v2si, v2si)
	v8qi __builtin_arm_wmaxub (v8qi, v8qi)
	v4hi __builtin_arm_wmaxuh (v4hi, v4hi)
	v2si __builtin_arm_wmaxuw (v2si, v2si)
	v8qi __builtin_arm_wminsb (v8qi, v8qi)
	v4hi __builtin_arm_wminsh (v4hi, v4hi)
	v2si __builtin_arm_wminsw (v2si, v2si)
	v8qi __builtin_arm_wminub (v8qi, v8qi)
	v4hi __builtin_arm_wminuh (v4hi, v4hi)
	v2si __builtin_arm_wminuw (v2si, v2si)
	v4hi __builtin_arm_wmulsm (v4hi, v4hi)
	v4hi __builtin_arm_wmulul (v4hi, v4hi)
	v4hi __builtin_arm_wmulum (v4hi, v4hi)
	long long __builtin_arm_wor (long long, long long)
	v2si __builtin_arm_wpackdss (long long, long long)
	v2si __builtin_arm_wpackdus (long long, long long)
	v8qi __builtin_arm_wpackhss (v4hi, v4hi)
	v8qi __builtin_arm_wpackhus (v4hi, v4hi)
	v4hi __builtin_arm_wpackwss (v2si, v2si)
	v4hi __builtin_arm_wpackwus (v2si, v2si)
	long long __builtin_arm_wrord (long long, long long)
	long long __builtin_arm_wrordi (long long, int)
	v4hi __builtin_arm_wrorh (v4hi, long long)
	v4hi __builtin_arm_wrorhi (v4hi, int)
	v2si __builtin_arm_wrorw (v2si, long long)
	v2si __builtin_arm_wrorwi (v2si, int)
	v2si __builtin_arm_wsadb (v8qi, v8qi)
	v2si __builtin_arm_wsadbz (v8qi, v8qi)
	v2si __builtin_arm_wsadh (v4hi, v4hi)
	v2si __builtin_arm_wsadhz (v4hi, v4hi)
	v4hi __builtin_arm_wshufh (v4hi, int)
	long long __builtin_arm_wslld (long long, long long)
	long long __builtin_arm_wslldi (long long, int)
	v4hi __builtin_arm_wsllh (v4hi, long long)
	v4hi __builtin_arm_wsllhi (v4hi, int)
	v2si __builtin_arm_wsllw (v2si, long long)
	v2si __builtin_arm_wsllwi (v2si, int)
	long long __builtin_arm_wsrad (long long, long long)
	long long __builtin_arm_wsradi (long long, int)
	v4hi __builtin_arm_wsrah (v4hi, long long)
	v4hi __builtin_arm_wsrahi (v4hi, int)
	v2si __builtin_arm_wsraw (v2si, long long)
	v2si __builtin_arm_wsrawi (v2si, int)
	long long __builtin_arm_wsrld (long long, long long)
	long long __builtin_arm_wsrldi (long long, int)
	v4hi __builtin_arm_wsrlh (v4hi, long long)
	v4hi __builtin_arm_wsrlhi (v4hi, int)
	v2si __builtin_arm_wsrlw (v2si, long long)
	v2si __builtin_arm_wsrlwi (v2si, int)
	v8qi __builtin_arm_wsubb (v8qi, v8qi)
	v8qi __builtin_arm_wsubbss (v8qi, v8qi)
	v8qi __builtin_arm_wsubbus (v8qi, v8qi)
	v4hi __builtin_arm_wsubh (v4hi, v4hi)
	v4hi __builtin_arm_wsubhss (v4hi, v4hi)
	v4hi __builtin_arm_wsubhus (v4hi, v4hi)
	v2si __builtin_arm_wsubw (v2si, v2si)
	v2si __builtin_arm_wsubwss (v2si, v2si)
	v2si __builtin_arm_wsubwus (v2si, v2si)
	v4hi __builtin_arm_wunpckehsb (v8qi)
	v2si __builtin_arm_wunpckehsh (v4hi)
	long long __builtin_arm_wunpckehsw (v2si)
	v4hi __builtin_arm_wunpckehub (v8qi)
	v2si __builtin_arm_wunpckehuh (v4hi)
	long long __builtin_arm_wunpckehuw (v2si)
	v4hi __builtin_arm_wunpckelsb (v8qi)
	v2si __builtin_arm_wunpckelsh (v4hi)
	long long __builtin_arm_wunpckelsw (v2si)
	v4hi __builtin_arm_wunpckelub (v8qi)
	v2si __builtin_arm_wunpckeluh (v4hi)
	long long __builtin_arm_wunpckeluw (v2si)
	v8qi __builtin_arm_wunpckihb (v8qi, v8qi)
	v4hi __builtin_arm_wunpckihh (v4hi, v4hi)
	v2si __builtin_arm_wunpckihw (v2si, v2si)
	v8qi __builtin_arm_wunpckilb (v8qi, v8qi)
	v4hi __builtin_arm_wunpckilh (v4hi, v4hi)
	v2si __builtin_arm_wunpckilw (v2si, v2si)
	long long __builtin_arm_wxor (long long, long long)
	long long __builtin_arm_wzero ()
	@end smallexample

	@node Blackfin Built-in Functions
	@subsection Blackfin Built-in Functions

	Currently, there are two Blackfin-specific built-in functions. These are
	used for generating @code{CSYNC} and @code{SSYNC} machine insns without
	using inline assembly; by using these built-in functions the compiler can
	automatically add workarounds for hardware errata involving these
	instructions. These functions are named as follows:

	@smallexample
	void __builtin_bfin_csync (void)
	void __builtin_bfin_ssync (void)
	@end smallexample

	@node FR-V Built-in Functions
	@subsection FR-V Built-in Functions

	GCC provides many FR-V-specific built-in functions. In general,
	these functions are intended to be compatible with those described
	by @cite{FR-V Family, Softune C/C++ Compiler Manual (V6), Fujitsu
	Semiconductor}. The two exceptions are @code{__MDUNPACKH} and
	@code{__MBTOHE}, the gcc forms of which pass 128-bit values by
	pointer rather than by value.

	Most of the functions are named after specific FR-V instructions.
	Such functions are said to be ``directly mapped'' and are summarized
	here in tabular form.

	@menu
	* Argument Types::
	* Directly-mapped Integer Functions::
	* Directly-mapped Media Functions::
	* Raw read/write Functions::
	* Other Built-in Functions::
	@end menu

	@node Argument Types
	@subsubsection Argument Types

	The arguments to the built-in functions can be divided into three groups:
	register numbers, compile-time constants and run-time values. In order
	to make this classification clear at a glance, the arguments and return
	values are given the following pseudo types:

	@multitable @columnfractions .20 .30 .15 .35
	@item Pseudo type @tab Real C type @tab Constant? @tab Description
	@item @code{uh} @tab @code{unsigned short} @tab No @tab an unsigned halfword
	@item @code{uw1} @tab @code{unsigned int} @tab No @tab an unsigned word
	@item @code{sw1} @tab @code{int} @tab No @tab a signed word
	@item @code{uw2} @tab @code{unsigned long long} @tab No
	@tab an unsigned doubleword
	@item @code{sw2} @tab @code{long long} @tab No @tab a signed doubleword
	@item @code{const} @tab @code{int} @tab Yes @tab an integer constant
	@item @code{acc} @tab @code{int} @tab Yes @tab an ACC register number
	@item @code{iacc} @tab @code{int} @tab Yes @tab an IACC register number
	@end multitable

	These pseudo types are not defined by GCC, they are simply a notational
	convenience used in this manual.

	Arguments of type @code{uh}, @code{uw1}, @code{sw1}, @code{uw2}
	and @code{sw2} are evaluated at run time. They correspond to
	register operands in the underlying FR-V instructions.

	@code{const} arguments represent immediate operands in the underlying
	FR-V instructions. They must be compile-time constants.

	@code{acc} arguments are evaluated at compile time and specify the number
	of an accumulator register. For example, an @code{acc} argument of 2
	will select the ACC2 register.

	@code{iacc} arguments are similar to @code{acc} arguments but specify the
	number of an IACC register. See @pxref{Other Built-in Functions}
	for more details.

	@node Directly-mapped Integer Functions
	@subsubsection Directly-mapped Integer Functions

	The functions listed below map directly to FR-V I-type instructions.

	@multitable @columnfractions .45 .32 .23
	@item Function prototype @tab Example usage @tab Assembly output
	@item @code{sw1 __ADDSS (sw1, sw1)}
	@tab @code{@var{c} = __ADDSS (@var{a}, @var{b})}
	@tab @code{ADDSS @var{a},@var{b},@var{c}}
	@item @code{sw1 __SCAN (sw1, sw1)}
	@tab @code{@var{c} = __SCAN (@var{a}, @var{b})}
	@tab @code{SCAN @var{a},@var{b},@var{c}}
	@item @code{sw1 __SCUTSS (sw1)}
	@tab @code{@var{b} = __SCUTSS (@var{a})}
	@tab @code{SCUTSS @var{a},@var{b}}
	@item @code{sw1 __SLASS (sw1, sw1)}
	@tab @code{@var{c} = __SLASS (@var{a}, @var{b})}
	@tab @code{SLASS @var{a},@var{b},@var{c}}
	@item @code{void __SMASS (sw1, sw1)}
	@tab @code{__SMASS (@var{a}, @var{b})}
	@tab @code{SMASS @var{a},@var{b}}
	@item @code{void __SMSSS (sw1, sw1)}
	@tab @code{__SMSSS (@var{a}, @var{b})}
	@tab @code{SMSSS @var{a},@var{b}}
	@item @code{void __SMU (sw1, sw1)}
	@tab @code{__SMU (@var{a}, @var{b})}
	@tab @code{SMU @var{a},@var{b}}
	@item @code{sw2 __SMUL (sw1, sw1)}
	@tab @code{@var{c} = __SMUL (@var{a}, @var{b})}
	@tab @code{SMUL @var{a},@var{b},@var{c}}
	@item @code{sw1 __SUBSS (sw1, sw1)}
	@tab @code{@var{c} = __SUBSS (@var{a}, @var{b})}
	@tab @code{SUBSS @var{a},@var{b},@var{c}}
	@item @code{uw2 __UMUL (uw1, uw1)}
	@tab @code{@var{c} = __UMUL (@var{a}, @var{b})}
	@tab @code{UMUL @var{a},@var{b},@var{c}}
	@end multitable

	@node Directly-mapped Media Functions
	@subsubsection Directly-mapped Media Functions

	The functions listed below map directly to FR-V M-type instructions.

	@multitable @columnfractions .45 .32 .23
	@item Function prototype @tab Example usage @tab Assembly output
	@item @code{uw1 __MABSHS (sw1)}
	@tab @code{@var{b} = __MABSHS (@var{a})}
	@tab @code{MABSHS @var{a},@var{b}}
	@item @code{void __MADDACCS (acc, acc)}
	@tab @code{__MADDACCS (@var{b}, @var{a})}
	@tab @code{MADDACCS @var{a},@var{b}}
	@item @code{sw1 __MADDHSS (sw1, sw1)}
	@tab @code{@var{c} = __MADDHSS (@var{a}, @var{b})}
	@tab @code{MADDHSS @var{a},@var{b},@var{c}}
	@item @code{uw1 __MADDHUS (uw1, uw1)}
	@tab @code{@var{c} = __MADDHUS (@var{a}, @var{b})}
	@tab @code{MADDHUS @var{a},@var{b},@var{c}}
	@item @code{uw1 __MAND (uw1, uw1)}
	@tab @code{@var{c} = __MAND (@var{a}, @var{b})}
	@tab @code{MAND @var{a},@var{b},@var{c}}
	@item @code{void __MASACCS (acc, acc)}
	@tab @code{__MASACCS (@var{b}, @var{a})}
	@tab @code{MASACCS @var{a},@var{b}}
	@item @code{uw1 __MAVEH (uw1, uw1)}
	@tab @code{@var{c} = __MAVEH (@var{a}, @var{b})}
	@tab @code{MAVEH @var{a},@var{b},@var{c}}
	@item @code{uw2 __MBTOH (uw1)}
	@tab @code{@var{b} = __MBTOH (@var{a})}
	@tab @code{MBTOH @var{a},@var{b}}
	@item @code{void __MBTOHE (uw1 *, uw1)}
	@tab @code{__MBTOHE (&@var{b}, @var{a})}
	@tab @code{MBTOHE @var{a},@var{b}}
	@item @code{void __MCLRACC (acc)}
	@tab @code{__MCLRACC (@var{a})}
	@tab @code{MCLRACC @var{a}}
	@item @code{void __MCLRACCA (void)}
	@tab @code{__MCLRACCA ()}
	@tab @code{MCLRACCA}
	@item @code{uw1 __Mcop1 (uw1, uw1)}
	@tab @code{@var{c} = __Mcop1 (@var{a}, @var{b})}
	@tab @code{Mcop1 @var{a},@var{b},@var{c}}
	@item @code{uw1 __Mcop2 (uw1, uw1)}
	@tab @code{@var{c} = __Mcop2 (@var{a}, @var{b})}
	@tab @code{Mcop2 @var{a},@var{b},@var{c}}
	@item @code{uw1 __MCPLHI (uw2, const)}
	@tab @code{@var{c} = __MCPLHI (@var{a}, @var{b})}
	@tab @code{MCPLHI @var{a},#@var{b},@var{c}}
	@item @code{uw1 __MCPLI (uw2, const)}
	@tab @code{@var{c} = __MCPLI (@var{a}, @var{b})}
	@tab @code{MCPLI @var{a},#@var{b},@var{c}}
	@item @code{void __MCPXIS (acc, sw1, sw1)}
	@tab @code{__MCPXIS (@var{c}, @var{a}, @var{b})}
	@tab @code{MCPXIS @var{a},@var{b},@var{c}}
	@item @code{void __MCPXIU (acc, uw1, uw1)}
	@tab @code{__MCPXIU (@var{c}, @var{a}, @var{b})}
	@tab @code{MCPXIU @var{a},@var{b},@var{c}}
	@item @code{void __MCPXRS (acc, sw1, sw1)}
	@tab @code{__MCPXRS (@var{c}, @var{a}, @var{b})}
	@tab @code{MCPXRS @var{a},@var{b},@var{c}}
	@item @code{void __MCPXRU (acc, uw1, uw1)}
	@tab @code{__MCPXRU (@var{c}, @var{a}, @var{b})}
	@tab @code{MCPXRU @var{a},@var{b},@var{c}}
	@item @code{uw1 __MCUT (acc, uw1)}
	@tab @code{@var{c} = __MCUT (@var{a}, @var{b})}
	@tab @code{MCUT @var{a},@var{b},@var{c}}
	@item @code{uw1 __MCUTSS (acc, sw1)}
	@tab @code{@var{c} = __MCUTSS (@var{a}, @var{b})}
	@tab @code{MCUTSS @var{a},@var{b},@var{c}}
	@item @code{void __MDADDACCS (acc, acc)}
	@tab @code{__MDADDACCS (@var{b}, @var{a})}
	@tab @code{MDADDACCS @var{a},@var{b}}
	@item @code{void __MDASACCS (acc, acc)}
	@tab @code{__MDASACCS (@var{b}, @var{a})}
	@tab @code{MDASACCS @var{a},@var{b}}
	@item @code{uw2 __MDCUTSSI (acc, const)}
	@tab @code{@var{c} = __MDCUTSSI (@var{a}, @var{b})}
	@tab @code{MDCUTSSI @var{a},#@var{b},@var{c}}
	@item @code{uw2 __MDPACKH (uw2, uw2)}
	@tab @code{@var{c} = __MDPACKH (@var{a}, @var{b})}
	@tab @code{MDPACKH @var{a},@var{b},@var{c}}
	@item @code{uw2 __MDROTLI (uw2, const)}
	@tab @code{@var{c} = __MDROTLI (@var{a}, @var{b})}
	@tab @code{MDROTLI @var{a},#@var{b},@var{c}}
	@item @code{void __MDSUBACCS (acc, acc)}
	@tab @code{__MDSUBACCS (@var{b}, @var{a})}
	@tab @code{MDSUBACCS @var{a},@var{b}}
	@item @code{void __MDUNPACKH (uw1 *, uw2)}
	@tab @code{__MDUNPACKH (&@var{b}, @var{a})}
	@tab @code{MDUNPACKH @var{a},@var{b}}
	@item @code{uw2 __MEXPDHD (uw1, const)}
	@tab @code{@var{c} = __MEXPDHD (@var{a}, @var{b})}
	@tab @code{MEXPDHD @var{a},#@var{b},@var{c}}
	@item @code{uw1 __MEXPDHW (uw1, const)}
	@tab @code{@var{c} = __MEXPDHW (@var{a}, @var{b})}
	@tab @code{MEXPDHW @var{a},#@var{b},@var{c}}
	@item @code{uw1 __MHDSETH (uw1, const)}
	@tab @code{@var{c} = __MHDSETH (@var{a}, @var{b})}
	@tab @code{MHDSETH @var{a},#@var{b},@var{c}}
	@item @code{sw1 __MHDSETS (const)}
	@tab @code{@var{b} = __MHDSETS (@var{a})}
	@tab @code{MHDSETS #@var{a},@var{b}}
	@item @code{uw1 __MHSETHIH (uw1, const)}
	@tab @code{@var{b} = __MHSETHIH (@var{b}, @var{a})}
	@tab @code{MHSETHIH #@var{a},@var{b}}
	@item @code{sw1 __MHSETHIS (sw1, const)}
	@tab @code{@var{b} = __MHSETHIS (@var{b}, @var{a})}
	@tab @code{MHSETHIS #@var{a},@var{b}}
	@item @code{uw1 __MHSETLOH (uw1, const)}
	@tab @code{@var{b} = __MHSETLOH (@var{b}, @var{a})}
	@tab @code{MHSETLOH #@var{a},@var{b}}
	@item @code{sw1 __MHSETLOS (sw1, const)}
	@tab @code{@var{b} = __MHSETLOS (@var{b}, @var{a})}
	@tab @code{MHSETLOS #@var{a},@var{b}}
	@item @code{uw1 __MHTOB (uw2)}
	@tab @code{@var{b} = __MHTOB (@var{a})}
	@tab @code{MHTOB @var{a},@var{b}}
	@item @code{void __MMACHS (acc, sw1, sw1)}
	@tab @code{__MMACHS (@var{c}, @var{a}, @var{b})}
	@tab @code{MMACHS @var{a},@var{b},@var{c}}
	@item @code{void __MMACHU (acc, uw1, uw1)}
	@tab @code{__MMACHU (@var{c}, @var{a}, @var{b})}
	@tab @code{MMACHU @var{a},@var{b},@var{c}}
	@item @code{void __MMRDHS (acc, sw1, sw1)}
	@tab @code{__MMRDHS (@var{c}, @var{a}, @var{b})}
	@tab @code{MMRDHS @var{a},@var{b},@var{c}}
	@item @code{void __MMRDHU (acc, uw1, uw1)}
	@tab @code{__MMRDHU (@var{c}, @var{a}, @var{b})}
	@tab @code{MMRDHU @var{a},@var{b},@var{c}}
	@item @code{void __MMULHS (acc, sw1, sw1)}
	@tab @code{__MMULHS (@var{c}, @var{a}, @var{b})}
	@tab @code{MMULHS @var{a},@var{b},@var{c}}
	@item @code{void __MMULHU (acc, uw1, uw1)}
	@tab @code{__MMULHU (@var{c}, @var{a}, @var{b})}
	@tab @code{MMULHU @var{a},@var{b},@var{c}}
	@item @code{void __MMULXHS (acc, sw1, sw1)}
	@tab @code{__MMULXHS (@var{c}, @var{a}, @var{b})}
	@tab @code{MMULXHS @var{a},@var{b},@var{c}}
	@item @code{void __MMULXHU (acc, uw1, uw1)}
	@tab @code{__MMULXHU (@var{c}, @var{a}, @var{b})}
	@tab @code{MMULXHU @var{a},@var{b},@var{c}}
	@item @code{uw1 __MNOT (uw1)}
	@tab @code{@var{b} = __MNOT (@var{a})}
	@tab @code{MNOT @var{a},@var{b}}
	@item @code{uw1 __MOR (uw1, uw1)}
	@tab @code{@var{c} = __MOR (@var{a}, @var{b})}
	@tab @code{MOR @var{a},@var{b},@var{c}}
	@item @code{uw1 __MPACKH (uh, uh)}
	@tab @code{@var{c} = __MPACKH (@var{a}, @var{b})}
	@tab @code{MPACKH @var{a},@var{b},@var{c}}
	@item @code{sw2 __MQADDHSS (sw2, sw2)}
	@tab @code{@var{c} = __MQADDHSS (@var{a}, @var{b})}
	@tab @code{MQADDHSS @var{a},@var{b},@var{c}}
	@item @code{uw2 __MQADDHUS (uw2, uw2)}
	@tab @code{@var{c} = __MQADDHUS (@var{a}, @var{b})}
	@tab @code{MQADDHUS @var{a},@var{b},@var{c}}
	@item @code{void __MQCPXIS (acc, sw2, sw2)}
	@tab @code{__MQCPXIS (@var{c}, @var{a}, @var{b})}
	@tab @code{MQCPXIS @var{a},@var{b},@var{c}}
	@item @code{void __MQCPXIU (acc, uw2, uw2)}
	@tab @code{__MQCPXIU (@var{c}, @var{a}, @var{b})}
	@tab @code{MQCPXIU @var{a},@var{b},@var{c}}
	@item @code{void __MQCPXRS (acc, sw2, sw2)}
	@tab @code{__MQCPXRS (@var{c}, @var{a}, @var{b})}
	@tab @code{MQCPXRS @var{a},@var{b},@var{c}}
	@item @code{void __MQCPXRU (acc, uw2, uw2)}
	@tab @code{__MQCPXRU (@var{c}, @var{a}, @var{b})}
	@tab @code{MQCPXRU @var{a},@var{b},@var{c}}
	@item @code{sw2 __MQLCLRHS (sw2, sw2)}
	@tab @code{@var{c} = __MQLCLRHS (@var{a}, @var{b})}
	@tab @code{MQLCLRHS @var{a},@var{b},@var{c}}
	@item @code{sw2 __MQLMTHS (sw2, sw2)}
	@tab @code{@var{c} = __MQLMTHS (@var{a}, @var{b})}
	@tab @code{MQLMTHS @var{a},@var{b},@var{c}}
	@item @code{void __MQMACHS (acc, sw2, sw2)}
	@tab @code{__MQMACHS (@var{c}, @var{a}, @var{b})}
	@tab @code{MQMACHS @var{a},@var{b},@var{c}}
	@item @code{void __MQMACHU (acc, uw2, uw2)}
	@tab @code{__MQMACHU (@var{c}, @var{a}, @var{b})}
	@tab @code{MQMACHU @var{a},@var{b},@var{c}}
	@item @code{void __MQMACXHS (acc, sw2, sw2)}
	@tab @code{__MQMACXHS (@var{c}, @var{a}, @var{b})}
	@tab @code{MQMACXHS @var{a},@var{b},@var{c}}
	@item @code{void __MQMULHS (acc, sw2, sw2)}
	@tab @code{__MQMULHS (@var{c}, @var{a}, @var{b})}
	@tab @code{MQMULHS @var{a},@var{b},@var{c}}
	@item @code{void __MQMULHU (acc, uw2, uw2)}
	@tab @code{__MQMULHU (@var{c}, @var{a}, @var{b})}
	@tab @code{MQMULHU @var{a},@var{b},@var{c}}
	@item @code{void __MQMULXHS (acc, sw2, sw2)}
	@tab @code{__MQMULXHS (@var{c}, @var{a}, @var{b})}
	@tab @code{MQMULXHS @var{a},@var{b},@var{c}}
	@item @code{void __MQMULXHU (acc, uw2, uw2)}
	@tab @code{__MQMULXHU (@var{c}, @var{a}, @var{b})}
	@tab @code{MQMULXHU @var{a},@var{b},@var{c}}
	@item @code{sw2 __MQSATHS (sw2, sw2)}
	@tab @code{@var{c} = __MQSATHS (@var{a}, @var{b})}
	@tab @code{MQSATHS @var{a},@var{b},@var{c}}
	@item @code{uw2 __MQSLLHI (uw2, int)}
	@tab @code{@var{c} = __MQSLLHI (@var{a}, @var{b})}
	@tab @code{MQSLLHI @var{a},@var{b},@var{c}}
	@item @code{sw2 __MQSRAHI (sw2, int)}
	@tab @code{@var{c} = __MQSRAHI (@var{a}, @var{b})}
	@tab @code{MQSRAHI @var{a},@var{b},@var{c}}
	@item @code{sw2 __MQSUBHSS (sw2, sw2)}
	@tab @code{@var{c} = __MQSUBHSS (@var{a}, @var{b})}
	@tab @code{MQSUBHSS @var{a},@var{b},@var{c}}
	@item @code{uw2 __MQSUBHUS (uw2, uw2)}
	@tab @code{@var{c} = __MQSUBHUS (@var{a}, @var{b})}
	@tab @code{MQSUBHUS @var{a},@var{b},@var{c}}
	@item @code{void __MQXMACHS (acc, sw2, sw2)}
	@tab @code{__MQXMACHS (@var{c}, @var{a}, @var{b})}
	@tab @code{MQXMACHS @var{a},@var{b},@var{c}}
	@item @code{void __MQXMACXHS (acc, sw2, sw2)}
	@tab @code{__MQXMACXHS (@var{c}, @var{a}, @var{b})}
	@tab @code{MQXMACXHS @var{a},@var{b},@var{c}}
	@item @code{uw1 __MRDACC (acc)}
	@tab @code{@var{b} = __MRDACC (@var{a})}
	@tab @code{MRDACC @var{a},@var{b}}
	@item @code{uw1 __MRDACCG (acc)}
	@tab @code{@var{b} = __MRDACCG (@var{a})}
	@tab @code{MRDACCG @var{a},@var{b}}
	@item @code{uw1 __MROTLI (uw1, const)}
	@tab @code{@var{c} = __MROTLI (@var{a}, @var{b})}
	@tab @code{MROTLI @var{a},#@var{b},@var{c}}
	@item @code{uw1 __MROTRI (uw1, const)}
	@tab @code{@var{c} = __MROTRI (@var{a}, @var{b})}
	@tab @code{MROTRI @var{a},#@var{b},@var{c}}
	@item @code{sw1 __MSATHS (sw1, sw1)}
	@tab @code{@var{c} = __MSATHS (@var{a}, @var{b})}
	@tab @code{MSATHS @var{a},@var{b},@var{c}}
	@item @code{uw1 __MSATHU (uw1, uw1)}
	@tab @code{@var{c} = __MSATHU (@var{a}, @var{b})}
	@tab @code{MSATHU @var{a},@var{b},@var{c}}
	@item @code{uw1 __MSLLHI (uw1, const)}
	@tab @code{@var{c} = __MSLLHI (@var{a}, @var{b})}
	@tab @code{MSLLHI @var{a},#@var{b},@var{c}}
	@item @code{sw1 __MSRAHI (sw1, const)}
	@tab @code{@var{c} = __MSRAHI (@var{a}, @var{b})}
	@tab @code{MSRAHI @var{a},#@var{b},@var{c}}
	@item @code{uw1 __MSRLHI (uw1, const)}
	@tab @code{@var{c} = __MSRLHI (@var{a}, @var{b})}
	@tab @code{MSRLHI @var{a},#@var{b},@var{c}}
	@item @code{void __MSUBACCS (acc, acc)}
	@tab @code{__MSUBACCS (@var{b}, @var{a})}
	@tab @code{MSUBACCS @var{a},@var{b}}
	@item @code{sw1 __MSUBHSS (sw1, sw1)}
	@tab @code{@var{c} = __MSUBHSS (@var{a}, @var{b})}
	@tab @code{MSUBHSS @var{a},@var{b},@var{c}}
	@item @code{uw1 __MSUBHUS (uw1, uw1)}
	@tab @code{@var{c} = __MSUBHUS (@var{a}, @var{b})}
	@tab @code{MSUBHUS @var{a},@var{b},@var{c}}
	@item @code{void __MTRAP (void)}
	@tab @code{__MTRAP ()}
	@tab @code{MTRAP}
	@item @code{uw2 __MUNPACKH (uw1)}
	@tab @code{@var{b} = __MUNPACKH (@var{a})}
	@tab @code{MUNPACKH @var{a},@var{b}}
	@item @code{uw1 __MWCUT (uw2, uw1)}
	@tab @code{@var{c} = __MWCUT (@var{a}, @var{b})}
	@tab @code{MWCUT @var{a},@var{b},@var{c}}
	@item @code{void __MWTACC (acc, uw1)}
	@tab @code{__MWTACC (@var{b}, @var{a})}
	@tab @code{MWTACC @var{a},@var{b}}
	@item @code{void __MWTACCG (acc, uw1)}
	@tab @code{__MWTACCG (@var{b}, @var{a})}
	@tab @code{MWTACCG @var{a},@var{b}}
	@item @code{uw1 __MXOR (uw1, uw1)}
	@tab @code{@var{c} = __MXOR (@var{a}, @var{b})}
	@tab @code{MXOR @var{a},@var{b},@var{c}}
	@end multitable

	@node Raw read/write Functions
	@subsubsection Raw read/write Functions

	This sections describes built-in functions related to read and write
	instructions to access memory. These functions generate
	@code{membar} instructions to flush the I/O load and stores where
	appropriate, as described in Fujitsu's manual described above.

	@table @code

	@item unsigned char __builtin_read8 (void *@var{data})
	@item unsigned short __builtin_read16 (void *@var{data})
	@item unsigned long __builtin_read32 (void *@var{data})
	@item unsigned long long __builtin_read64 (void *@var{data})

	@item void __builtin_write8 (void *@var{data}, unsigned char @var{datum})
	@item void __builtin_write16 (void *@var{data}, unsigned short @var{datum})
	@item void __builtin_write32 (void *@var{data}, unsigned long @var{datum})
	@item void __builtin_write64 (void *@var{data}, unsigned long long @var{datum})
	@end table

	@node Other Built-in Functions
	@subsubsection Other Built-in Functions

	This section describes built-in functions that are not named after
	a specific FR-V instruction.

	@table @code
	@item sw2 __IACCreadll (iacc @var{reg})
	Return the full 64-bit value of IACC0@. The @var{reg} argument is reserved
	for future expansion and must be 0.

	@item sw1 __IACCreadl (iacc @var{reg})
	Return the value of IACC0H if @var{reg} is 0 and IACC0L if @var{reg} is 1.
	Other values of @var{reg} are rejected as invalid.

	@item void __IACCsetll (iacc @var{reg}, sw2 @var{x})
	Set the full 64-bit value of IACC0 to @var{x}. The @var{reg} argument
	is reserved for future expansion and must be 0.

	@item void __IACCsetl (iacc @var{reg}, sw1 @var{x})
	Set IACC0H to @var{x} if @var{reg} is 0 and IACC0L to @var{x} if @var{reg}
	is 1. Other values of @var{reg} are rejected as invalid.

	@item void __data_prefetch0 (const void *@var{x})
	Use the @code{dcpl} instruction to load the contents of address @var{x}
	into the data cache.

	@item void __data_prefetch (const void *@var{x})
	Use the @code{nldub} instruction to load the contents of address @var{x}
	into the data cache. The instruction will be issued in slot I1@.
	@end table

	@node X86 Built-in Functions
	@subsection X86 Built-in Functions

	These built-in functions are available for the i386 and x86-64 family
	of computers, depending on the command-line switches used.

	Note that, if you specify command-line switches such as @option{-msse},
	the compiler could use the extended instruction sets even if the built-ins
	are not used explicitly in the program. For this reason, applications
	which perform runtime CPU detection must compile separate files for each
	supported architecture, using the appropriate flags. In particular,
	the file containing the CPU detection code should be compiled without
	these options.

	The following machine modes are available for use with MMX built-in functions
	(@pxref{Vector Extensions}): @code{V2SI} for a vector of two 32-bit integers,
	@code{V4HI} for a vector of four 16-bit integers, and @code{V8QI} for a
	vector of eight 8-bit integers. Some of the built-in functions operate on
	MMX registers as a whole 64-bit entity, these use @code{DI} as their mode.

	If 3Dnow extensions are enabled, @code{V2SF} is used as a mode for a vector
	of two 32-bit floating point values.

	If SSE extensions are enabled, @code{V4SF} is used for a vector of four 32-bit
	floating point values. Some instructions use a vector of four 32-bit
	integers, these use @code{V4SI}. Finally, some instructions operate on an
	entire vector register, interpreting it as a 128-bit integer, these use mode
	@code{TI}.

	The following built-in functions are made available by @option{-mmmx}.
	All of them generate the machine instruction that is part of the name.

	@smallexample
	v8qi __builtin_ia32_paddb (v8qi, v8qi)
	v4hi __builtin_ia32_paddw (v4hi, v4hi)
	v2si __builtin_ia32_paddd (v2si, v2si)
	v8qi __builtin_ia32_psubb (v8qi, v8qi)
	v4hi __builtin_ia32_psubw (v4hi, v4hi)
	v2si __builtin_ia32_psubd (v2si, v2si)
	v8qi __builtin_ia32_paddsb (v8qi, v8qi)
	v4hi __builtin_ia32_paddsw (v4hi, v4hi)
	v8qi __builtin_ia32_psubsb (v8qi, v8qi)
	v4hi __builtin_ia32_psubsw (v4hi, v4hi)
	v8qi __builtin_ia32_paddusb (v8qi, v8qi)
	v4hi __builtin_ia32_paddusw (v4hi, v4hi)
	v8qi __builtin_ia32_psubusb (v8qi, v8qi)
	v4hi __builtin_ia32_psubusw (v4hi, v4hi)
	v4hi __builtin_ia32_pmullw (v4hi, v4hi)
	v4hi __builtin_ia32_pmulhw (v4hi, v4hi)
	di __builtin_ia32_pand (di, di)
	di __builtin_ia32_pandn (di,di)
	di __builtin_ia32_por (di, di)
	di __builtin_ia32_pxor (di, di)
	v8qi __builtin_ia32_pcmpeqb (v8qi, v8qi)
	v4hi __builtin_ia32_pcmpeqw (v4hi, v4hi)
	v2si __builtin_ia32_pcmpeqd (v2si, v2si)
	v8qi __builtin_ia32_pcmpgtb (v8qi, v8qi)
	v4hi __builtin_ia32_pcmpgtw (v4hi, v4hi)
	v2si __builtin_ia32_pcmpgtd (v2si, v2si)
	v8qi __builtin_ia32_punpckhbw (v8qi, v8qi)
	v4hi __builtin_ia32_punpckhwd (v4hi, v4hi)
	v2si __builtin_ia32_punpckhdq (v2si, v2si)
	v8qi __builtin_ia32_punpcklbw (v8qi, v8qi)
	v4hi __builtin_ia32_punpcklwd (v4hi, v4hi)
	v2si __builtin_ia32_punpckldq (v2si, v2si)
	v8qi __builtin_ia32_packsswb (v4hi, v4hi)
	v4hi __builtin_ia32_packssdw (v2si, v2si)
	v8qi __builtin_ia32_packuswb (v4hi, v4hi)
	@end smallexample

	The following built-in functions are made available either with
	@option{-msse}, or with a combination of @option{-m3dnow} and
	@option{-march=athlon}. All of them generate the machine
	instruction that is part of the name.

	@smallexample
	v4hi __builtin_ia32_pmulhuw (v4hi, v4hi)
	v8qi __builtin_ia32_pavgb (v8qi, v8qi)
	v4hi __builtin_ia32_pavgw (v4hi, v4hi)
	v4hi __builtin_ia32_psadbw (v8qi, v8qi)
	v8qi __builtin_ia32_pmaxub (v8qi, v8qi)
	v4hi __builtin_ia32_pmaxsw (v4hi, v4hi)
	v8qi __builtin_ia32_pminub (v8qi, v8qi)
	v4hi __builtin_ia32_pminsw (v4hi, v4hi)
	int __builtin_ia32_pextrw (v4hi, int)
	v4hi __builtin_ia32_pinsrw (v4hi, int, int)
	int __builtin_ia32_pmovmskb (v8qi)
	void __builtin_ia32_maskmovq (v8qi, v8qi, char *)
	void __builtin_ia32_movntq (di *, di)
	void __builtin_ia32_sfence (void)
	@end smallexample

	The following built-in functions are available when @option{-msse} is used.
	All of them generate the machine instruction that is part of the name.

	@smallexample
	int __builtin_ia32_comieq (v4sf, v4sf)
	int __builtin_ia32_comineq (v4sf, v4sf)
	int __builtin_ia32_comilt (v4sf, v4sf)
	int __builtin_ia32_comile (v4sf, v4sf)
	int __builtin_ia32_comigt (v4sf, v4sf)
	int __builtin_ia32_comige (v4sf, v4sf)
	int __builtin_ia32_ucomieq (v4sf, v4sf)
	int __builtin_ia32_ucomineq (v4sf, v4sf)
	int __builtin_ia32_ucomilt (v4sf, v4sf)
	int __builtin_ia32_ucomile (v4sf, v4sf)
	int __builtin_ia32_ucomigt (v4sf, v4sf)
	int __builtin_ia32_ucomige (v4sf, v4sf)
	v4sf __builtin_ia32_addps (v4sf, v4sf)
	v4sf __builtin_ia32_subps (v4sf, v4sf)
	v4sf __builtin_ia32_mulps (v4sf, v4sf)
	v4sf __builtin_ia32_divps (v4sf, v4sf)
	v4sf __builtin_ia32_addss (v4sf, v4sf)
	v4sf __builtin_ia32_subss (v4sf, v4sf)
	v4sf __builtin_ia32_mulss (v4sf, v4sf)
	v4sf __builtin_ia32_divss (v4sf, v4sf)
	v4si __builtin_ia32_cmpeqps (v4sf, v4sf)
	v4si __builtin_ia32_cmpltps (v4sf, v4sf)
	v4si __builtin_ia32_cmpleps (v4sf, v4sf)
	v4si __builtin_ia32_cmpgtps (v4sf, v4sf)
	v4si __builtin_ia32_cmpgeps (v4sf, v4sf)
	v4si __builtin_ia32_cmpunordps (v4sf, v4sf)
	v4si __builtin_ia32_cmpneqps (v4sf, v4sf)
	v4si __builtin_ia32_cmpnltps (v4sf, v4sf)
	v4si __builtin_ia32_cmpnleps (v4sf, v4sf)
	v4si __builtin_ia32_cmpngtps (v4sf, v4sf)
	v4si __builtin_ia32_cmpngeps (v4sf, v4sf)
	v4si __builtin_ia32_cmpordps (v4sf, v4sf)
	v4si __builtin_ia32_cmpeqss (v4sf, v4sf)
	v4si __builtin_ia32_cmpltss (v4sf, v4sf)
	v4si __builtin_ia32_cmpless (v4sf, v4sf)
	v4si __builtin_ia32_cmpunordss (v4sf, v4sf)
	v4si __builtin_ia32_cmpneqss (v4sf, v4sf)
	v4si __builtin_ia32_cmpnlts (v4sf, v4sf)
	v4si __builtin_ia32_cmpnless (v4sf, v4sf)
	v4si __builtin_ia32_cmpordss (v4sf, v4sf)
	v4sf __builtin_ia32_maxps (v4sf, v4sf)
	v4sf __builtin_ia32_maxss (v4sf, v4sf)
	v4sf __builtin_ia32_minps (v4sf, v4sf)
	v4sf __builtin_ia32_minss (v4sf, v4sf)
	v4sf __builtin_ia32_andps (v4sf, v4sf)
	v4sf __builtin_ia32_andnps (v4sf, v4sf)
	v4sf __builtin_ia32_orps (v4sf, v4sf)
	v4sf __builtin_ia32_xorps (v4sf, v4sf)
	v4sf __builtin_ia32_movss (v4sf, v4sf)
	v4sf __builtin_ia32_movhlps (v4sf, v4sf)
	v4sf __builtin_ia32_movlhps (v4sf, v4sf)
	v4sf __builtin_ia32_unpckhps (v4sf, v4sf)
	v4sf __builtin_ia32_unpcklps (v4sf, v4sf)
	v4sf __builtin_ia32_cvtpi2ps (v4sf, v2si)
	v4sf __builtin_ia32_cvtsi2ss (v4sf, int)
	v2si __builtin_ia32_cvtps2pi (v4sf)
	int __builtin_ia32_cvtss2si (v4sf)
	v2si __builtin_ia32_cvttps2pi (v4sf)
	int __builtin_ia32_cvttss2si (v4sf)
	v4sf __builtin_ia32_rcpps (v4sf)
	v4sf __builtin_ia32_rsqrtps (v4sf)
	v4sf __builtin_ia32_sqrtps (v4sf)
	v4sf __builtin_ia32_rcpss (v4sf)
	v4sf __builtin_ia32_rsqrtss (v4sf)
	v4sf __builtin_ia32_sqrtss (v4sf)
	v4sf __builtin_ia32_shufps (v4sf, v4sf, int)
	void __builtin_ia32_movntps (float *, v4sf)
	int __builtin_ia32_movmskps (v4sf)
	@end smallexample

	The following built-in functions are available when @option{-msse} is used.

	@table @code
	@item v4sf __builtin_ia32_loadaps (float *)
	Generates the @code{movaps} machine instruction as a load from memory.
	@item void __builtin_ia32_storeaps (float *, v4sf)
	Generates the @code{movaps} machine instruction as a store to memory.
	@item v4sf __builtin_ia32_loadups (float *)
	Generates the @code{movups} machine instruction as a load from memory.
	@item void __builtin_ia32_storeups (float *, v4sf)
	Generates the @code{movups} machine instruction as a store to memory.
	@item v4sf __builtin_ia32_loadsss (float *)
	Generates the @code{movss} machine instruction as a load from memory.
	@item void __builtin_ia32_storess (float *, v4sf)
	Generates the @code{movss} machine instruction as a store to memory.
	@item v4sf __builtin_ia32_loadhps (v4sf, v2si *)
	Generates the @code{movhps} machine instruction as a load from memory.
	@item v4sf __builtin_ia32_loadlps (v4sf, v2si *)
	Generates the @code{movlps} machine instruction as a load from memory
	@item void __builtin_ia32_storehps (v4sf, v2si *)
	Generates the @code{movhps} machine instruction as a store to memory.
	@item void __builtin_ia32_storelps (v4sf, v2si *)
	Generates the @code{movlps} machine instruction as a store to memory.
	@end table

	The following built-in functions are available when @option{-msse2} is used.
	All of them generate the machine instruction that is part of the name.

	@smallexample
	int __builtin_ia32_comisdeq (v2df, v2df)
	int __builtin_ia32_comisdlt (v2df, v2df)
	int __builtin_ia32_comisdle (v2df, v2df)
	int __builtin_ia32_comisdgt (v2df, v2df)
	int __builtin_ia32_comisdge (v2df, v2df)
	int __builtin_ia32_comisdneq (v2df, v2df)
	int __builtin_ia32_ucomisdeq (v2df, v2df)
	int __builtin_ia32_ucomisdlt (v2df, v2df)
	int __builtin_ia32_ucomisdle (v2df, v2df)
	int __builtin_ia32_ucomisdgt (v2df, v2df)
	int __builtin_ia32_ucomisdge (v2df, v2df)
	int __builtin_ia32_ucomisdneq (v2df, v2df)
	v2df __builtin_ia32_cmpeqpd (v2df, v2df)
	v2df __builtin_ia32_cmpltpd (v2df, v2df)
	v2df __builtin_ia32_cmplepd (v2df, v2df)
	v2df __builtin_ia32_cmpgtpd (v2df, v2df)
	v2df __builtin_ia32_cmpgepd (v2df, v2df)
	v2df __builtin_ia32_cmpunordpd (v2df, v2df)
	v2df __builtin_ia32_cmpneqpd (v2df, v2df)
	v2df __builtin_ia32_cmpnltpd (v2df, v2df)
	v2df __builtin_ia32_cmpnlepd (v2df, v2df)
	v2df __builtin_ia32_cmpngtpd (v2df, v2df)
	v2df __builtin_ia32_cmpngepd (v2df, v2df)
	v2df __builtin_ia32_cmpordpd (v2df, v2df)
	v2df __builtin_ia32_cmpeqsd (v2df, v2df)
	v2df __builtin_ia32_cmpltsd (v2df, v2df)
	v2df __builtin_ia32_cmplesd (v2df, v2df)
	v2df __builtin_ia32_cmpunordsd (v2df, v2df)
	v2df __builtin_ia32_cmpneqsd (v2df, v2df)
	v2df __builtin_ia32_cmpnltsd (v2df, v2df)
	v2df __builtin_ia32_cmpnlesd (v2df, v2df)
	v2df __builtin_ia32_cmpordsd (v2df, v2df)
	v2di __builtin_ia32_paddq (v2di, v2di)
	v2di __builtin_ia32_psubq (v2di, v2di)
	v2df __builtin_ia32_addpd (v2df, v2df)
	v2df __builtin_ia32_subpd (v2df, v2df)
	v2df __builtin_ia32_mulpd (v2df, v2df)
	v2df __builtin_ia32_divpd (v2df, v2df)
	v2df __builtin_ia32_addsd (v2df, v2df)
	v2df __builtin_ia32_subsd (v2df, v2df)
	v2df __builtin_ia32_mulsd (v2df, v2df)
	v2df __builtin_ia32_divsd (v2df, v2df)
	v2df __builtin_ia32_minpd (v2df, v2df)
	v2df __builtin_ia32_maxpd (v2df, v2df)
	v2df __builtin_ia32_minsd (v2df, v2df)
	v2df __builtin_ia32_maxsd (v2df, v2df)
	v2df __builtin_ia32_andpd (v2df, v2df)
	v2df __builtin_ia32_andnpd (v2df, v2df)
	v2df __builtin_ia32_orpd (v2df, v2df)
	v2df __builtin_ia32_xorpd (v2df, v2df)
	v2df __builtin_ia32_movsd (v2df, v2df)
	v2df __builtin_ia32_unpckhpd (v2df, v2df)
	v2df __builtin_ia32_unpcklpd (v2df, v2df)
	v16qi __builtin_ia32_paddb128 (v16qi, v16qi)
	v8hi __builtin_ia32_paddw128 (v8hi, v8hi)
	v4si __builtin_ia32_paddd128 (v4si, v4si)
	v2di __builtin_ia32_paddq128 (v2di, v2di)
	v16qi __builtin_ia32_psubb128 (v16qi, v16qi)
	v8hi __builtin_ia32_psubw128 (v8hi, v8hi)
	v4si __builtin_ia32_psubd128 (v4si, v4si)
	v2di __builtin_ia32_psubq128 (v2di, v2di)
	v8hi __builtin_ia32_pmullw128 (v8hi, v8hi)
	v8hi __builtin_ia32_pmulhw128 (v8hi, v8hi)
	v2di __builtin_ia32_pand128 (v2di, v2di)
	v2di __builtin_ia32_pandn128 (v2di, v2di)
	v2di __builtin_ia32_por128 (v2di, v2di)
	v2di __builtin_ia32_pxor128 (v2di, v2di)
	v16qi __builtin_ia32_pavgb128 (v16qi, v16qi)
	v8hi __builtin_ia32_pavgw128 (v8hi, v8hi)
	v16qi __builtin_ia32_pcmpeqb128 (v16qi, v16qi)
	v8hi __builtin_ia32_pcmpeqw128 (v8hi, v8hi)
	v4si __builtin_ia32_pcmpeqd128 (v4si, v4si)
	v16qi __builtin_ia32_pcmpgtb128 (v16qi, v16qi)
	v8hi __builtin_ia32_pcmpgtw128 (v8hi, v8hi)
	v4si __builtin_ia32_pcmpgtd128 (v4si, v4si)
	v16qi __builtin_ia32_pmaxub128 (v16qi, v16qi)
	v8hi __builtin_ia32_pmaxsw128 (v8hi, v8hi)
	v16qi __builtin_ia32_pminub128 (v16qi, v16qi)
	v8hi __builtin_ia32_pminsw128 (v8hi, v8hi)
	v16qi __builtin_ia32_punpckhbw128 (v16qi, v16qi)
	v8hi __builtin_ia32_punpckhwd128 (v8hi, v8hi)
	v4si __builtin_ia32_punpckhdq128 (v4si, v4si)
	v2di __builtin_ia32_punpckhqdq128 (v2di, v2di)
	v16qi __builtin_ia32_punpcklbw128 (v16qi, v16qi)
	v8hi __builtin_ia32_punpcklwd128 (v8hi, v8hi)
	v4si __builtin_ia32_punpckldq128 (v4si, v4si)
	v2di __builtin_ia32_punpcklqdq128 (v2di, v2di)
	v16qi __builtin_ia32_packsswb128 (v16qi, v16qi)
	v8hi __builtin_ia32_packssdw128 (v8hi, v8hi)
	v16qi __builtin_ia32_packuswb128 (v16qi, v16qi)
	v8hi __builtin_ia32_pmulhuw128 (v8hi, v8hi)
	void __builtin_ia32_maskmovdqu (v16qi, v16qi)
	v2df __builtin_ia32_loadupd (double *)
	void __builtin_ia32_storeupd (double *, v2df)
	v2df __builtin_ia32_loadhpd (v2df, double *)
	v2df __builtin_ia32_loadlpd (v2df, double *)
	int __builtin_ia32_movmskpd (v2df)
	int __builtin_ia32_pmovmskb128 (v16qi)
	void __builtin_ia32_movnti (int *, int)
	void __builtin_ia32_movntpd (double *, v2df)
	void __builtin_ia32_movntdq (v2df *, v2df)
	v4si __builtin_ia32_pshufd (v4si, int)
	v8hi __builtin_ia32_pshuflw (v8hi, int)
	v8hi __builtin_ia32_pshufhw (v8hi, int)
	v2di __builtin_ia32_psadbw128 (v16qi, v16qi)
	v2df __builtin_ia32_sqrtpd (v2df)
	v2df __builtin_ia32_sqrtsd (v2df)
	v2df __builtin_ia32_shufpd (v2df, v2df, int)
	v2df __builtin_ia32_cvtdq2pd (v4si)
	v4sf __builtin_ia32_cvtdq2ps (v4si)
	v4si __builtin_ia32_cvtpd2dq (v2df)
	v2si __builtin_ia32_cvtpd2pi (v2df)
	v4sf __builtin_ia32_cvtpd2ps (v2df)
	v4si __builtin_ia32_cvttpd2dq (v2df)
	v2si __builtin_ia32_cvttpd2pi (v2df)
	v2df __builtin_ia32_cvtpi2pd (v2si)
	int __builtin_ia32_cvtsd2si (v2df)
	int __builtin_ia32_cvttsd2si (v2df)
	long long __builtin_ia32_cvtsd2si64 (v2df)
	long long __builtin_ia32_cvttsd2si64 (v2df)
	v4si __builtin_ia32_cvtps2dq (v4sf)
	v2df __builtin_ia32_cvtps2pd (v4sf)
	v4si __builtin_ia32_cvttps2dq (v4sf)
	v2df __builtin_ia32_cvtsi2sd (v2df, int)
	v2df __builtin_ia32_cvtsi642sd (v2df, long long)
	v4sf __builtin_ia32_cvtsd2ss (v4sf, v2df)
	v2df __builtin_ia32_cvtss2sd (v2df, v4sf)
	void __builtin_ia32_clflush (const void *)
	void __builtin_ia32_lfence (void)
	void __builtin_ia32_mfence (void)
	v16qi __builtin_ia32_loaddqu (const char *)
	void __builtin_ia32_storedqu (char *, v16qi)
	unsigned long long __builtin_ia32_pmuludq (v2si, v2si)
	v2di __builtin_ia32_pmuludq128 (v4si, v4si)
	v8hi __builtin_ia32_psllw128 (v8hi, v2di)
	v4si __builtin_ia32_pslld128 (v4si, v2di)
	v2di __builtin_ia32_psllq128 (v4si, v2di)
	v8hi __builtin_ia32_psrlw128 (v8hi, v2di)
	v4si __builtin_ia32_psrld128 (v4si, v2di)
	v2di __builtin_ia32_psrlq128 (v2di, v2di)
	v8hi __builtin_ia32_psraw128 (v8hi, v2di)
	v4si __builtin_ia32_psrad128 (v4si, v2di)
	v2di __builtin_ia32_pslldqi128 (v2di, int)
	v8hi __builtin_ia32_psllwi128 (v8hi, int)
	v4si __builtin_ia32_pslldi128 (v4si, int)
	v2di __builtin_ia32_psllqi128 (v2di, int)
	v2di __builtin_ia32_psrldqi128 (v2di, int)
	v8hi __builtin_ia32_psrlwi128 (v8hi, int)
	v4si __builtin_ia32_psrldi128 (v4si, int)
	v2di __builtin_ia32_psrlqi128 (v2di, int)
	v8hi __builtin_ia32_psrawi128 (v8hi, int)
	v4si __builtin_ia32_psradi128 (v4si, int)
	v4si __builtin_ia32_pmaddwd128 (v8hi, v8hi)
	@end smallexample

	The following built-in functions are available when @option{-msse3} is used.
	All of them generate the machine instruction that is part of the name.

	@smallexample
	v2df __builtin_ia32_addsubpd (v2df, v2df)
	v4sf __builtin_ia32_addsubps (v4sf, v4sf)
	v2df __builtin_ia32_haddpd (v2df, v2df)
	v4sf __builtin_ia32_haddps (v4sf, v4sf)
	v2df __builtin_ia32_hsubpd (v2df, v2df)
	v4sf __builtin_ia32_hsubps (v4sf, v4sf)
	v16qi __builtin_ia32_lddqu (char const *)
	void __builtin_ia32_monitor (void *, unsigned int, unsigned int)
	v2df __builtin_ia32_movddup (v2df)
	v4sf __builtin_ia32_movshdup (v4sf)
	v4sf __builtin_ia32_movsldup (v4sf)
	void __builtin_ia32_mwait (unsigned int, unsigned int)
	@end smallexample

	The following built-in functions are available when @option{-msse3} is used.

	@table @code
	@item v2df __builtin_ia32_loadddup (double const *)
	Generates the @code{movddup} machine instruction as a load from memory.
	@end table

	The following built-in functions are available when @option{-mssse3} is used.
	All of them generate the machine instruction that is part of the name
	with MMX registers.

	@smallexample
	v2si __builtin_ia32_phaddd (v2si, v2si)
	v4hi __builtin_ia32_phaddw (v4hi, v4hi)
	v4hi __builtin_ia32_phaddsw (v4hi, v4hi)
	v2si __builtin_ia32_phsubd (v2si, v2si)
	v4hi __builtin_ia32_phsubw (v4hi, v4hi)
	v4hi __builtin_ia32_phsubsw (v4hi, v4hi)
	v8qi __builtin_ia32_pmaddubsw (v8qi, v8qi)
	v4hi __builtin_ia32_pmulhrsw (v4hi, v4hi)
	v8qi __builtin_ia32_pshufb (v8qi, v8qi)
	v8qi __builtin_ia32_psignb (v8qi, v8qi)
	v2si __builtin_ia32_psignd (v2si, v2si)
	v4hi __builtin_ia32_psignw (v4hi, v4hi)
	long long __builtin_ia32_palignr (long long, long long, int)
	v8qi __builtin_ia32_pabsb (v8qi)
	v2si __builtin_ia32_pabsd (v2si)
	v4hi __builtin_ia32_pabsw (v4hi)
	@end smallexample

	The following built-in functions are available when @option{-mssse3} is used.
	All of them generate the machine instruction that is part of the name
	with SSE registers.

	@smallexample
	v4si __builtin_ia32_phaddd128 (v4si, v4si)
	v8hi __builtin_ia32_phaddw128 (v8hi, v8hi)
	v8hi __builtin_ia32_phaddsw128 (v8hi, v8hi)
	v4si __builtin_ia32_phsubd128 (v4si, v4si)
	v8hi __builtin_ia32_phsubw128 (v8hi, v8hi)
	v8hi __builtin_ia32_phsubsw128 (v8hi, v8hi)
	v16qi __builtin_ia32_pmaddubsw128 (v16qi, v16qi)
	v8hi __builtin_ia32_pmulhrsw128 (v8hi, v8hi)
	v16qi __builtin_ia32_pshufb128 (v16qi, v16qi)
	v16qi __builtin_ia32_psignb128 (v16qi, v16qi)
	v4si __builtin_ia32_psignd128 (v4si, v4si)
	v8hi __builtin_ia32_psignw128 (v8hi, v8hi)
	v2di __builtin_ia32_palignr (v2di, v2di, int)
	v16qi __builtin_ia32_pabsb128 (v16qi)
	v4si __builtin_ia32_pabsd128 (v4si)
	v8hi __builtin_ia32_pabsw128 (v8hi)
	@end smallexample

	The following built-in functions are available when @option{-msse4a} is used.

	@smallexample
	void _mm_stream_sd (double*,__m128d);
	Generates the @code{movntsd} machine instruction.
	void _mm_stream_ss (float*,__m128);
	Generates the @code{movntss} machine instruction.
	__m128i _mm_extract_si64 (__m128i, __m128i);
	Generates the @code{extrq} machine instruction with only SSE register operands.
	__m128i _mm_extracti_si64 (__m128i, int, int);
	Generates the @code{extrq} machine instruction with SSE register and immediate operands.
	__m128i _mm_insert_si64 (__m128i, __m128i);
	Generates the @code{insertq} machine instruction with only SSE register operands.
	__m128i _mm_inserti_si64 (__m128i, __m128i, int, int);
	Generates the @code{insertq} machine instruction with SSE register and immediate operands.
	@end smallexample

	The following built-in functions are available when @option{-m3dnow} is used.
	All of them generate the machine instruction that is part of the name.

	@smallexample
	void __builtin_ia32_femms (void)
	v8qi __builtin_ia32_pavgusb (v8qi, v8qi)
	v2si __builtin_ia32_pf2id (v2sf)
	v2sf __builtin_ia32_pfacc (v2sf, v2sf)
	v2sf __builtin_ia32_pfadd (v2sf, v2sf)
	v2si __builtin_ia32_pfcmpeq (v2sf, v2sf)
	v2si __builtin_ia32_pfcmpge (v2sf, v2sf)
	v2si __builtin_ia32_pfcmpgt (v2sf, v2sf)
	v2sf __builtin_ia32_pfmax (v2sf, v2sf)
	v2sf __builtin_ia32_pfmin (v2sf, v2sf)
	v2sf __builtin_ia32_pfmul (v2sf, v2sf)
	v2sf __builtin_ia32_pfrcp (v2sf)
	v2sf __builtin_ia32_pfrcpit1 (v2sf, v2sf)
	v2sf __builtin_ia32_pfrcpit2 (v2sf, v2sf)
	v2sf __builtin_ia32_pfrsqrt (v2sf)
	v2sf __builtin_ia32_pfrsqrtit1 (v2sf, v2sf)
	v2sf __builtin_ia32_pfsub (v2sf, v2sf)
	v2sf __builtin_ia32_pfsubr (v2sf, v2sf)
	v2sf __builtin_ia32_pi2fd (v2si)
	v4hi __builtin_ia32_pmulhrw (v4hi, v4hi)
	@end smallexample

	The following built-in functions are available when both @option{-m3dnow}
	and @option{-march=athlon} are used. All of them generate the machine
	instruction that is part of the name.

	@smallexample
	v2si __builtin_ia32_pf2iw (v2sf)
	v2sf __builtin_ia32_pfnacc (v2sf, v2sf)
	v2sf __builtin_ia32_pfpnacc (v2sf, v2sf)
	v2sf __builtin_ia32_pi2fw (v2si)
	v2sf __builtin_ia32_pswapdsf (v2sf)
	v2si __builtin_ia32_pswapdsi (v2si)
	@end smallexample

	@node MIPS DSP Built-in Functions
	@subsection MIPS DSP Built-in Functions

	The MIPS DSP Application-Specific Extension (ASE) includes new
	instructions that are designed to improve the performance of DSP and
	media applications. It provides instructions that operate on packed
	8-bit integer data, Q15 fractional data and Q31 fractional data.

	GCC supports MIPS DSP operations using both the generic
	vector extensions (@pxref{Vector Extensions}) and a collection of
	MIPS-specific built-in functions. Both kinds of support are
	enabled by the @option{-mdsp} command-line option.

	At present, GCC only provides support for operations on 32-bit
	vectors. The vector type associated with 8-bit integer data is
	usually called @code{v4i8} and the vector type associated with Q15 is
	usually called @code{v2q15}. They can be defined in C as follows:

	@smallexample
	typedef char v4i8 __attribute__ ((vector_size(4)));
	typedef short v2q15 __attribute__ ((vector_size(4)));
	@end smallexample

	@code{v4i8} and @code{v2q15} values are initialized in the same way as
	aggregates. For example:

	@smallexample
	v4i8 a = @{1, 2, 3, 4@};
	v4i8 b;
	b = (v4i8) @{5, 6, 7, 8@};

	v2q15 c = @{0x0fcb, 0x3a75@};
	v2q15 d;
	d = (v2q15) @{0.1234 * 0x1.0p15, 0.4567 * 0x1.0p15@};
	@end smallexample

	@emph{Note:} The CPU's endianness determines the order in which values
	are packed. On little-endian targets, the first value is the least
	significant and the last value is the most significant. The opposite
	order applies to big-endian targets. For example, the code above will
	set the lowest byte of @code{a} to @code{1} on little-endian targets
	and @code{4} on big-endian targets.

	@emph{Note:} Q15 and Q31 values must be initialized with their integer
	representation. As shown in this example, the integer representation
	of a Q15 value can be obtained by multiplying the fractional value by
	@code{0x1.0p15}. The equivalent for Q31 values is to multiply by
	@code{0x1.0p31}.

	The table below lists the @code{v4i8} and @code{v2q15} operations for which
	hardware support exists. @code{a} and @code{b} are @code{v4i8} values,
	and @code{c} and @code{d} are @code{v2q15} values.

	@multitable @columnfractions .50 .50
	@item C code @tab MIPS instruction
	@item @code{a + b} @tab @code{addu.qb}
	@item @code{c + d} @tab @code{addq.ph}
	@item @code{a - b} @tab @code{subu.qb}
	@item @code{c - d} @tab @code{subq.ph}
	@end multitable

	It is easier to describe the DSP built-in functions if we first define
	the following types:

	@smallexample
	typedef int q31;
	typedef int i32;
	typedef long long a64;
	@end smallexample

	@code{q31} and @code{i32} are actually the same as @code{int}, but we
	use @code{q31} to indicate a Q31 fractional value and @code{i32} to
	indicate a 32-bit integer value. Similarly, @code{a64} is the same as
	@code{long long}, but we use @code{a64} to indicate values that will
	be placed in one of the four DSP accumulators (@code{$ac0},
	@code{$ac1}, @code{$ac2} or @code{$ac3}).

	Also, some built-in functions prefer or require immediate numbers as
	parameters, because the corresponding DSP instructions accept both immediate
	numbers and register operands, or accept immediate numbers only. The
	immediate parameters are listed as follows.

	@smallexample
	imm0_7: 0 to 7.
	imm0_15: 0 to 15.
	imm0_31: 0 to 31.
	imm0_63: 0 to 63.
	imm0_255: 0 to 255.
	imm_n32_31: -32 to 31.
	imm_n512_511: -512 to 511.
	@end smallexample

	The following built-in functions map directly to a particular MIPS DSP
	instruction. Please refer to the architecture specification
	for details on what each instruction does.

	@smallexample
	v2q15 __builtin_mips_addq_ph (v2q15, v2q15)
	v2q15 __builtin_mips_addq_s_ph (v2q15, v2q15)
	q31 __builtin_mips_addq_s_w (q31, q31)
	v4i8 __builtin_mips_addu_qb (v4i8, v4i8)
	v4i8 __builtin_mips_addu_s_qb (v4i8, v4i8)
	v2q15 __builtin_mips_subq_ph (v2q15, v2q15)
	v2q15 __builtin_mips_subq_s_ph (v2q15, v2q15)
	q31 __builtin_mips_subq_s_w (q31, q31)
	v4i8 __builtin_mips_subu_qb (v4i8, v4i8)
	v4i8 __builtin_mips_subu_s_qb (v4i8, v4i8)
	i32 __builtin_mips_addsc (i32, i32)
	i32 __builtin_mips_addwc (i32, i32)
	i32 __builtin_mips_modsub (i32, i32)
	i32 __builtin_mips_raddu_w_qb (v4i8)
	v2q15 __builtin_mips_absq_s_ph (v2q15)
	q31 __builtin_mips_absq_s_w (q31)
	v4i8 __builtin_mips_precrq_qb_ph (v2q15, v2q15)
	v2q15 __builtin_mips_precrq_ph_w (q31, q31)
	v2q15 __builtin_mips_precrq_rs_ph_w (q31, q31)
	v4i8 __builtin_mips_precrqu_s_qb_ph (v2q15, v2q15)
	q31 __builtin_mips_preceq_w_phl (v2q15)
	q31 __builtin_mips_preceq_w_phr (v2q15)
	v2q15 __builtin_mips_precequ_ph_qbl (v4i8)
	v2q15 __builtin_mips_precequ_ph_qbr (v4i8)
	v2q15 __builtin_mips_precequ_ph_qbla (v4i8)
	v2q15 __builtin_mips_precequ_ph_qbra (v4i8)
	v2q15 __builtin_mips_preceu_ph_qbl (v4i8)
	v2q15 __builtin_mips_preceu_ph_qbr (v4i8)
	v2q15 __builtin_mips_preceu_ph_qbla (v4i8)
	v2q15 __builtin_mips_preceu_ph_qbra (v4i8)
	v4i8 __builtin_mips_shll_qb (v4i8, imm0_7)
	v4i8 __builtin_mips_shll_qb (v4i8, i32)
	v2q15 __builtin_mips_shll_ph (v2q15, imm0_15)
	v2q15 __builtin_mips_shll_ph (v2q15, i32)
	v2q15 __builtin_mips_shll_s_ph (v2q15, imm0_15)
	v2q15 __builtin_mips_shll_s_ph (v2q15, i32)
	q31 __builtin_mips_shll_s_w (q31, imm0_31)
	q31 __builtin_mips_shll_s_w (q31, i32)
	v4i8 __builtin_mips_shrl_qb (v4i8, imm0_7)
	v4i8 __builtin_mips_shrl_qb (v4i8, i32)
	v2q15 __builtin_mips_shra_ph (v2q15, imm0_15)
	v2q15 __builtin_mips_shra_ph (v2q15, i32)
	v2q15 __builtin_mips_shra_r_ph (v2q15, imm0_15)
	v2q15 __builtin_mips_shra_r_ph (v2q15, i32)
	q31 __builtin_mips_shra_r_w (q31, imm0_31)
	q31 __builtin_mips_shra_r_w (q31, i32)
	v2q15 __builtin_mips_muleu_s_ph_qbl (v4i8, v2q15)
	v2q15 __builtin_mips_muleu_s_ph_qbr (v4i8, v2q15)
	v2q15 __builtin_mips_mulq_rs_ph (v2q15, v2q15)
	q31 __builtin_mips_muleq_s_w_phl (v2q15, v2q15)
	q31 __builtin_mips_muleq_s_w_phr (v2q15, v2q15)
	a64 __builtin_mips_dpau_h_qbl (a64, v4i8, v4i8)
	a64 __builtin_mips_dpau_h_qbr (a64, v4i8, v4i8)
	a64 __builtin_mips_dpsu_h_qbl (a64, v4i8, v4i8)
	a64 __builtin_mips_dpsu_h_qbr (a64, v4i8, v4i8)
	a64 __builtin_mips_dpaq_s_w_ph (a64, v2q15, v2q15)
	a64 __builtin_mips_dpaq_sa_l_w (a64, q31, q31)
	a64 __builtin_mips_dpsq_s_w_ph (a64, v2q15, v2q15)
	a64 __builtin_mips_dpsq_sa_l_w (a64, q31, q31)
	a64 __builtin_mips_mulsaq_s_w_ph (a64, v2q15, v2q15)
	a64 __builtin_mips_maq_s_w_phl (a64, v2q15, v2q15)
	a64 __builtin_mips_maq_s_w_phr (a64, v2q15, v2q15)
	a64 __builtin_mips_maq_sa_w_phl (a64, v2q15, v2q15)
	a64 __builtin_mips_maq_sa_w_phr (a64, v2q15, v2q15)
	i32 __builtin_mips_bitrev (i32)
	i32 __builtin_mips_insv (i32, i32)
	v4i8 __builtin_mips_repl_qb (imm0_255)
	v4i8 __builtin_mips_repl_qb (i32)
	v2q15 __builtin_mips_repl_ph (imm_n512_511)
	v2q15 __builtin_mips_repl_ph (i32)
	void __builtin_mips_cmpu_eq_qb (v4i8, v4i8)
	void __builtin_mips_cmpu_lt_qb (v4i8, v4i8)
	void __builtin_mips_cmpu_le_qb (v4i8, v4i8)
	i32 __builtin_mips_cmpgu_eq_qb (v4i8, v4i8)
	i32 __builtin_mips_cmpgu_lt_qb (v4i8, v4i8)
	i32 __builtin_mips_cmpgu_le_qb (v4i8, v4i8)
	void __builtin_mips_cmp_eq_ph (v2q15, v2q15)
	void __builtin_mips_cmp_lt_ph (v2q15, v2q15)
	void __builtin_mips_cmp_le_ph (v2q15, v2q15)
	v4i8 __builtin_mips_pick_qb (v4i8, v4i8)
	v2q15 __builtin_mips_pick_ph (v2q15, v2q15)
	v2q15 __builtin_mips_packrl_ph (v2q15, v2q15)
	i32 __builtin_mips_extr_w (a64, imm0_31)
	i32 __builtin_mips_extr_w (a64, i32)
	i32 __builtin_mips_extr_r_w (a64, imm0_31)
	i32 __builtin_mips_extr_s_h (a64, i32)
	i32 __builtin_mips_extr_rs_w (a64, imm0_31)
	i32 __builtin_mips_extr_rs_w (a64, i32)
	i32 __builtin_mips_extr_s_h (a64, imm0_31)
	i32 __builtin_mips_extr_r_w (a64, i32)
	i32 __builtin_mips_extp (a64, imm0_31)
	i32 __builtin_mips_extp (a64, i32)
	i32 __builtin_mips_extpdp (a64, imm0_31)
	i32 __builtin_mips_extpdp (a64, i32)
	a64 __builtin_mips_shilo (a64, imm_n32_31)
	a64 __builtin_mips_shilo (a64, i32)
	a64 __builtin_mips_mthlip (a64, i32)
	void __builtin_mips_wrdsp (i32, imm0_63)
	i32 __builtin_mips_rddsp (imm0_63)
	i32 __builtin_mips_lbux (void *, i32)
	i32 __builtin_mips_lhx (void *, i32)
	i32 __builtin_mips_lwx (void *, i32)
	i32 __builtin_mips_bposge32 (void)
	@end smallexample

	@node MIPS Paired-Single Support
	@subsection MIPS Paired-Single Support

	The MIPS64 architecture includes a number of instructions that
	operate on pairs of single-precision floating-point values.
	Each pair is packed into a 64-bit floating-point register,
	with one element being designated the ``upper half'' and
	the other being designated the ``lower half''.

	GCC supports paired-single operations using both the generic
	vector extensions (@pxref{Vector Extensions}) and a collection of
	MIPS-specific built-in functions. Both kinds of support are
	enabled by the @option{-mpaired-single} command-line option.

	The vector type associated with paired-single values is usually
	called @code{v2sf}. It can be defined in C as follows:

	@smallexample
	typedef float v2sf __attribute__ ((vector_size (8)));
	@end smallexample

	@code{v2sf} values are initialized in the same way as aggregates.
	For example:

	@smallexample
	v2sf a = @{1.5, 9.1@};
	v2sf b;
	float e, f;
	b = (v2sf) @{e, f@};
	@end smallexample

	@emph{Note:} The CPU's endianness determines which value is stored in
	the upper half of a register and which value is stored in the lower half.
	On little-endian targets, the first value is the lower one and the second
	value is the upper one. The opposite order applies to big-endian targets.
	For example, the code above will set the lower half of @code{a} to
	@code{1.5} on little-endian targets and @code{9.1} on big-endian targets.

	@menu
	* Paired-Single Arithmetic::
	* Paired-Single Built-in Functions::
	* MIPS-3D Built-in Functions::
	@end menu

	@node Paired-Single Arithmetic
	@subsubsection Paired-Single Arithmetic

	The table below lists the @code{v2sf} operations for which hardware
	support exists. @code{a}, @code{b} and @code{c} are @code{v2sf}
	values and @code{x} is an integral value.

	@multitable @columnfractions .50 .50
	@item C code @tab MIPS instruction
	@item @code{a + b} @tab @code{add.ps}
	@item @code{a - b} @tab @code{sub.ps}
	@item @code{-a} @tab @code{neg.ps}
	@item @code{a * b} @tab @code{mul.ps}
	@item @code{a * b + c} @tab @code{madd.ps}
	@item @code{a * b - c} @tab @code{msub.ps}
	@item @code{-(a * b + c)} @tab @code{nmadd.ps}
	@item @code{-(a * b - c)} @tab @code{nmsub.ps}
	@item @code{x ? a : b} @tab @code{movn.ps}/@code{movz.ps}
	@end multitable

	Note that the multiply-accumulate instructions can be disabled
	using the command-line option @code{-mno-fused-madd}.

	@node Paired-Single Built-in Functions
	@subsubsection Paired-Single Built-in Functions

	The following paired-single functions map directly to a particular
	MIPS instruction. Please refer to the architecture specification
	for details on what each instruction does.

	@table @code
	@item v2sf __builtin_mips_pll_ps (v2sf, v2sf)
	Pair lower lower (@code{pll.ps}).

	@item v2sf __builtin_mips_pul_ps (v2sf, v2sf)
	Pair upper lower (@code{pul.ps}).

	@item v2sf __builtin_mips_plu_ps (v2sf, v2sf)
	Pair lower upper (@code{plu.ps}).

	@item v2sf __builtin_mips_puu_ps (v2sf, v2sf)
	Pair upper upper (@code{puu.ps}).

	@item v2sf __builtin_mips_cvt_ps_s (float, float)
	Convert pair to paired single (@code{cvt.ps.s}).

	@item float __builtin_mips_cvt_s_pl (v2sf)
	Convert pair lower to single (@code{cvt.s.pl}).

	@item float __builtin_mips_cvt_s_pu (v2sf)
	Convert pair upper to single (@code{cvt.s.pu}).

	@item v2sf __builtin_mips_abs_ps (v2sf)
	Absolute value (@code{abs.ps}).

	@item v2sf __builtin_mips_alnv_ps (v2sf, v2sf, int)
	Align variable (@code{alnv.ps}).

	@emph{Note:} The value of the third parameter must be 0 or 4
	modulo 8, otherwise the result will be unpredictable. Please read the
	instruction description for details.
	@end table

	The following multi-instruction functions are also available.
	In each case, @var{cond} can be any of the 16 floating-point conditions:
	@code{f}, @code{un}, @code{eq}, @code{ueq}, @code{olt}, @code{ult},
	@code{ole}, @code{ule}, @code{sf}, @code{ngle}, @code{seq}, @code{ngl},
	@code{lt}, @code{nge}, @code{le} or @code{ngt}.

	@table @code
	@item v2sf __builtin_mips_movt_c_@var{cond}_ps (v2sf @var{a}, v2sf @var{b}, v2sf @var{c}, v2sf @var{d})
	@itemx v2sf __builtin_mips_movf_c_@var{cond}_ps (v2sf @var{a}, v2sf @var{b}, v2sf @var{c}, v2sf @var{d})
	Conditional move based on floating point comparison (@code{c.@var{cond}.ps},
	@code{movt.ps}/@code{movf.ps}).

	The @code{movt} functions return the value @var{x} computed by:

	@smallexample
	c.@var{cond}.ps @var{cc},@var{a},@var{b}
	mov.ps @var{x},@var{c}
	movt.ps @var{x},@var{d},@var{cc}
	@end smallexample

	The @code{movf} functions are similar but use @code{movf.ps} instead
	of @code{movt.ps}.

	@item int __builtin_mips_upper_c_@var{cond}_ps (v2sf @var{a}, v2sf @var{b})
	@itemx int __builtin_mips_lower_c_@var{cond}_ps (v2sf @var{a}, v2sf @var{b})
	Comparison of two paired-single values (@code{c.@var{cond}.ps},
	@code{bc1t}/@code{bc1f}).

	These functions compare @var{a} and @var{b} using @code{c.@var{cond}.ps}
	and return either the upper or lower half of the result. For example:

	@smallexample
	v2sf a, b;
	if (__builtin_mips_upper_c_eq_ps (a, b))
	upper_halves_are_equal ();
	else
	upper_halves_are_unequal ();

	if (__builtin_mips_lower_c_eq_ps (a, b))
	lower_halves_are_equal ();
	else
	lower_halves_are_unequal ();
	@end smallexample
	@end table

	@node MIPS-3D Built-in Functions
	@subsubsection MIPS-3D Built-in Functions

	The MIPS-3D Application-Specific Extension (ASE) includes additional
	paired-single instructions that are designed to improve the performance
	of 3D graphics operations. Support for these instructions is controlled
	by the @option{-mips3d} command-line option.

	The functions listed below map directly to a particular MIPS-3D
	instruction. Please refer to the architecture specification for
	more details on what each instruction does.

	@table @code
	@item v2sf __builtin_mips_addr_ps (v2sf, v2sf)
	Reduction add (@code{addr.ps}).

	@item v2sf __builtin_mips_mulr_ps (v2sf, v2sf)
	Reduction multiply (@code{mulr.ps}).

	@item v2sf __builtin_mips_cvt_pw_ps (v2sf)
	Convert paired single to paired word (@code{cvt.pw.ps}).

	@item v2sf __builtin_mips_cvt_ps_pw (v2sf)
	Convert paired word to paired single (@code{cvt.ps.pw}).

	@item float __builtin_mips_recip1_s (float)
	@itemx double __builtin_mips_recip1_d (double)
	@itemx v2sf __builtin_mips_recip1_ps (v2sf)
	Reduced precision reciprocal (sequence step 1) (@code{recip1.@var{fmt}}).

	@item float __builtin_mips_recip2_s (float, float)
	@itemx double __builtin_mips_recip2_d (double, double)
	@itemx v2sf __builtin_mips_recip2_ps (v2sf, v2sf)
	Reduced precision reciprocal (sequence step 2) (@code{recip2.@var{fmt}}).

	@item float __builtin_mips_rsqrt1_s (float)
	@itemx double __builtin_mips_rsqrt1_d (double)
	@itemx v2sf __builtin_mips_rsqrt1_ps (v2sf)
	Reduced precision reciprocal square root (sequence step 1)
	(@code{rsqrt1.@var{fmt}}).

	@item float __builtin_mips_rsqrt2_s (float, float)
	@itemx double __builtin_mips_rsqrt2_d (double, double)
	@itemx v2sf __builtin_mips_rsqrt2_ps (v2sf, v2sf)
	Reduced precision reciprocal square root (sequence step 2)
	(@code{rsqrt2.@var{fmt}}).
	@end table

	The following multi-instruction functions are also available.
	In each case, @var{cond} can be any of the 16 floating-point conditions:
	@code{f}, @code{un}, @code{eq}, @code{ueq}, @code{olt}, @code{ult},
	@code{ole}, @code{ule}, @code{sf}, @code{ngle}, @code{seq},
	@code{ngl}, @code{lt}, @code{nge}, @code{le} or @code{ngt}.

	@table @code
	@item int __builtin_mips_cabs_@var{cond}_s (float @var{a}, float @var{b})
	@itemx int __builtin_mips_cabs_@var{cond}_d (double @var{a}, double @var{b})
	Absolute comparison of two scalar values (@code{cabs.@var{cond}.@var{fmt}},
	@code{bc1t}/@code{bc1f}).

	These functions compare @var{a} and @var{b} using @code{cabs.@var{cond}.s}
	or @code{cabs.@var{cond}.d} and return the result as a boolean value.
	For example:

	@smallexample
	float a, b;
	if (__builtin_mips_cabs_eq_s (a, b))
	true ();
	else
	false ();
	@end smallexample

	@item int __builtin_mips_upper_cabs_@var{cond}_ps (v2sf @var{a}, v2sf @var{b})
	@itemx int __builtin_mips_lower_cabs_@var{cond}_ps (v2sf @var{a}, v2sf @var{b})
	Absolute comparison of two paired-single values (@code{cabs.@var{cond}.ps},
	@code{bc1t}/@code{bc1f}).

	These functions compare @var{a} and @var{b} using @code{cabs.@var{cond}.ps}
	and return either the upper or lower half of the result. For example:

	@smallexample
	v2sf a, b;
	if (__builtin_mips_upper_cabs_eq_ps (a, b))
	upper_halves_are_equal ();
	else
	upper_halves_are_unequal ();

	if (__builtin_mips_lower_cabs_eq_ps (a, b))
	lower_halves_are_equal ();
	else
	lower_halves_are_unequal ();
	@end smallexample

	@item v2sf __builtin_mips_movt_cabs_@var{cond}_ps (v2sf @var{a}, v2sf @var{b}, v2sf @var{c}, v2sf @var{d})
	@itemx v2sf __builtin_mips_movf_cabs_@var{cond}_ps (v2sf @var{a}, v2sf @var{b}, v2sf @var{c}, v2sf @var{d})
	Conditional move based on absolute comparison (@code{cabs.@var{cond}.ps},
	@code{movt.ps}/@code{movf.ps}).

	The @code{movt} functions return the value @var{x} computed by:

	@smallexample
	cabs.@var{cond}.ps @var{cc},@var{a},@var{b}
	mov.ps @var{x},@var{c}
	movt.ps @var{x},@var{d},@var{cc}
	@end smallexample

	The @code{movf} functions are similar but use @code{movf.ps} instead
	of @code{movt.ps}.

	@item int __builtin_mips_any_c_@var{cond}_ps (v2sf @var{a}, v2sf @var{b})
	@itemx int __builtin_mips_all_c_@var{cond}_ps (v2sf @var{a}, v2sf @var{b})
	@itemx int __builtin_mips_any_cabs_@var{cond}_ps (v2sf @var{a}, v2sf @var{b})
	@itemx int __builtin_mips_all_cabs_@var{cond}_ps (v2sf @var{a}, v2sf @var{b})
	Comparison of two paired-single values
	(@code{c.@var{cond}.ps}/@code{cabs.@var{cond}.ps},
	@code{bc1any2t}/@code{bc1any2f}).

	These functions compare @var{a} and @var{b} using @code{c.@var{cond}.ps}
	or @code{cabs.@var{cond}.ps}. The @code{any} forms return true if either
	result is true and the @code{all} forms return true if both results are true.
	For example:

	@smallexample
	v2sf a, b;
	if (__builtin_mips_any_c_eq_ps (a, b))
	one_is_true ();
	else
	both_are_false ();

	if (__builtin_mips_all_c_eq_ps (a, b))
	both_are_true ();
	else
	one_is_false ();
	@end smallexample

	@item int __builtin_mips_any_c_@var{cond}_4s (v2sf @var{a}, v2sf @var{b}, v2sf @var{c}, v2sf @var{d})
	@itemx int __builtin_mips_all_c_@var{cond}_4s (v2sf @var{a}, v2sf @var{b}, v2sf @var{c}, v2sf @var{d})
	@itemx int __builtin_mips_any_cabs_@var{cond}_4s (v2sf @var{a}, v2sf @var{b}, v2sf @var{c}, v2sf @var{d})
	@itemx int __builtin_mips_all_cabs_@var{cond}_4s (v2sf @var{a}, v2sf @var{b}, v2sf @var{c}, v2sf @var{d})
	Comparison of four paired-single values
	(@code{c.@var{cond}.ps}/@code{cabs.@var{cond}.ps},
	@code{bc1any4t}/@code{bc1any4f}).

	These functions use @code{c.@var{cond}.ps} or @code{cabs.@var{cond}.ps}
	to compare @var{a} with @var{b} and to compare @var{c} with @var{d}.
	The @code{any} forms return true if any of the four results are true
	and the @code{all} forms return true if all four results are true.
	For example:

	@smallexample
	v2sf a, b, c, d;
	if (__builtin_mips_any_c_eq_4s (a, b, c, d))
	some_are_true ();
	else
	all_are_false ();

	if (__builtin_mips_all_c_eq_4s (a, b, c, d))
	all_are_true ();
	else
	some_are_false ();
	@end smallexample
	@end table

	@node PowerPC AltiVec Built-in Functions
	@subsection PowerPC AltiVec Built-in Functions

	GCC provides an interface for the PowerPC family of processors to access
	the AltiVec operations described in Motorola's AltiVec Programming
	Interface Manual. The interface is made available by including
	@code{<altivec.h>} and using @option{-maltivec} and
	@option{-mabi=altivec}. The interface supports the following vector
	types.

	@smallexample
	vector unsigned char
	vector signed char
	vector bool char

	vector unsigned short
	vector signed short
	vector bool short
	vector pixel

	vector unsigned int
	vector signed int
	vector bool int
	vector float
	@end smallexample

	GCC's implementation of the high-level language interface available from
	C and C++ code differs from Motorola's documentation in several ways.

	@itemize @bullet

	@item
	A vector constant is a list of constant expressions within curly braces.

	@item
	A vector initializer requires no cast if the vector constant is of the
	same type as the variable it is initializing.

	@item
	If @code{signed} or @code{unsigned} is omitted, the signedness of the
	vector type is the default signedness of the base type. The default
	varies depending on the operating system, so a portable program should
	always specify the signedness.

	@item
	Compiling with @option{-maltivec} adds keywords @code{__vector},
	@code{__pixel}, and @code{__bool}. Macros @option{vector},
	@code{pixel}, and @code{bool} are defined in @code{<altivec.h>} and can
	be undefined.

	@item
	GCC allows using a @code{typedef} name as the type specifier for a
	vector type.

	@item
	For C, overloaded functions are implemented with macros so the following
	does not work:

	@smallexample
	vec_add ((vector signed int)@{1, 2, 3, 4@}, foo);
	@end smallexample

	Since @code{vec_add} is a macro, the vector constant in the example
	is treated as four separate arguments. Wrap the entire argument in
	parentheses for this to work.
	@end itemize

	@emph{Note:} Only the @code{<altivec.h>} interface is supported.
	Internally, GCC uses built-in functions to achieve the functionality in
	the aforementioned header file, but they are not supported and are
	subject to change without notice.

	The following interfaces are supported for the generic and specific
	AltiVec operations and the AltiVec predicates. In cases where there
	is a direct mapping between generic and specific operations, only the
	generic names are shown here, although the specific operations can also
	be used.

	Arguments that are documented as @code{const int} require literal
	integral values within the range required for that operation.

	@smallexample
	vector signed char vec_abs (vector signed char);
	vector signed short vec_abs (vector signed short);
	vector signed int vec_abs (vector signed int);
	vector float vec_abs (vector float);

	vector signed char vec_abss (vector signed char);
	vector signed short vec_abss (vector signed short);
	vector signed int vec_abss (vector signed int);

	vector signed char vec_add (vector bool char, vector signed char);
	vector signed char vec_add (vector signed char, vector bool char);
	vector signed char vec_add (vector signed char, vector signed char);
	vector unsigned char vec_add (vector bool char, vector unsigned char);
	vector unsigned char vec_add (vector unsigned char, vector bool char);
	vector unsigned char vec_add (vector unsigned char,
	vector unsigned char);
	vector signed short vec_add (vector bool short, vector signed short);
	vector signed short vec_add (vector signed short, vector bool short);
	vector signed short vec_add (vector signed short, vector signed short);
	vector unsigned short vec_add (vector bool short,
	vector unsigned short);
	vector unsigned short vec_add (vector unsigned short,
	vector bool short);
	vector unsigned short vec_add (vector unsigned short,
	vector unsigned short);
	vector signed int vec_add (vector bool int, vector signed int);
	vector signed int vec_add (vector signed int, vector bool int);
	vector signed int vec_add (vector signed int, vector signed int);
	vector unsigned int vec_add (vector bool int, vector unsigned int);
	vector unsigned int vec_add (vector unsigned int, vector bool int);
	vector unsigned int vec_add (vector unsigned int, vector unsigned int);
	vector float vec_add (vector float, vector float);

	vector float vec_vaddfp (vector float, vector float);

	vector signed int vec_vadduwm (vector bool int, vector signed int);
	vector signed int vec_vadduwm (vector signed int, vector bool int);
	vector signed int vec_vadduwm (vector signed int, vector signed int);
	vector unsigned int vec_vadduwm (vector bool int, vector unsigned int);
	vector unsigned int vec_vadduwm (vector unsigned int, vector bool int);
	vector unsigned int vec_vadduwm (vector unsigned int,
	vector unsigned int);

	vector signed short vec_vadduhm (vector bool short,
	vector signed short);
	vector signed short vec_vadduhm (vector signed short,
	vector bool short);
	vector signed short vec_vadduhm (vector signed short,
	vector signed short);
	vector unsigned short vec_vadduhm (vector bool short,
	vector unsigned short);
	vector unsigned short vec_vadduhm (vector unsigned short,
	vector bool short);
	vector unsigned short vec_vadduhm (vector unsigned short,
	vector unsigned short);

	vector signed char vec_vaddubm (vector bool char, vector signed char);
	vector signed char vec_vaddubm (vector signed char, vector bool char);
	vector signed char vec_vaddubm (vector signed char, vector signed char);
	vector unsigned char vec_vaddubm (vector bool char,
	vector unsigned char);
	vector unsigned char vec_vaddubm (vector unsigned char,
	vector bool char);
	vector unsigned char vec_vaddubm (vector unsigned char,
	vector unsigned char);

	vector unsigned int vec_addc (vector unsigned int, vector unsigned int);

	vector unsigned char vec_adds (vector bool char, vector unsigned char);
	vector unsigned char vec_adds (vector unsigned char, vector bool char);
	vector unsigned char vec_adds (vector unsigned char,
	vector unsigned char);
	vector signed char vec_adds (vector bool char, vector signed char);
	vector signed char vec_adds (vector signed char, vector bool char);
	vector signed char vec_adds (vector signed char, vector signed char);
	vector unsigned short vec_adds (vector bool short,
	vector unsigned short);
	vector unsigned short vec_adds (vector unsigned short,
	vector bool short);
	vector unsigned short vec_adds (vector unsigned short,
	vector unsigned short);
	vector signed short vec_adds (vector bool short, vector signed short);
	vector signed short vec_adds (vector signed short, vector bool short);
	vector signed short vec_adds (vector signed short, vector signed short);
	vector unsigned int vec_adds (vector bool int, vector unsigned int);
	vector unsigned int vec_adds (vector unsigned int, vector bool int);
	vector unsigned int vec_adds (vector unsigned int, vector unsigned int);
	vector signed int vec_adds (vector bool int, vector signed int);
	vector signed int vec_adds (vector signed int, vector bool int);
	vector signed int vec_adds (vector signed int, vector signed int);

	vector signed int vec_vaddsws (vector bool int, vector signed int);
	vector signed int vec_vaddsws (vector signed int, vector bool int);
	vector signed int vec_vaddsws (vector signed int, vector signed int);

	vector unsigned int vec_vadduws (vector bool int, vector unsigned int);
	vector unsigned int vec_vadduws (vector unsigned int, vector bool int);
	vector unsigned int vec_vadduws (vector unsigned int,
	vector unsigned int);

	vector signed short vec_vaddshs (vector bool short,
	vector signed short);
	vector signed short vec_vaddshs (vector signed short,
	vector bool short);
	vector signed short vec_vaddshs (vector signed short,
	vector signed short);

	vector unsigned short vec_vadduhs (vector bool short,
	vector unsigned short);
	vector unsigned short vec_vadduhs (vector unsigned short,
	vector bool short);
	vector unsigned short vec_vadduhs (vector unsigned short,
	vector unsigned short);

	vector signed char vec_vaddsbs (vector bool char, vector signed char);
	vector signed char vec_vaddsbs (vector signed char, vector bool char);
	vector signed char vec_vaddsbs (vector signed char, vector signed char);

	vector unsigned char vec_vaddubs (vector bool char,
	vector unsigned char);
	vector unsigned char vec_vaddubs (vector unsigned char,
	vector bool char);
	vector unsigned char vec_vaddubs (vector unsigned char,
	vector unsigned char);

	vector float vec_and (vector float, vector float);
	vector float vec_and (vector float, vector bool int);
	vector float vec_and (vector bool int, vector float);
	vector bool int vec_and (vector bool int, vector bool int);
	vector signed int vec_and (vector bool int, vector signed int);
	vector signed int vec_and (vector signed int, vector bool int);
	vector signed int vec_and (vector signed int, vector signed int);
	vector unsigned int vec_and (vector bool int, vector unsigned int);
	vector unsigned int vec_and (vector unsigned int, vector bool int);
	vector unsigned int vec_and (vector unsigned int, vector unsigned int);
	vector bool short vec_and (vector bool short, vector bool short);
	vector signed short vec_and (vector bool short, vector signed short);
	vector signed short vec_and (vector signed short, vector bool short);
	vector signed short vec_and (vector signed short, vector signed short);
	vector unsigned short vec_and (vector bool short,
	vector unsigned short);
	vector unsigned short vec_and (vector unsigned short,
	vector bool short);
	vector unsigned short vec_and (vector unsigned short,
	vector unsigned short);
	vector signed char vec_and (vector bool char, vector signed char);
	vector bool char vec_and (vector bool char, vector bool char);
	vector signed char vec_and (vector signed char, vector bool char);
	vector signed char vec_and (vector signed char, vector signed char);
	vector unsigned char vec_and (vector bool char, vector unsigned char);
	vector unsigned char vec_and (vector unsigned char, vector bool char);
	vector unsigned char vec_and (vector unsigned char,
	vector unsigned char);

	vector float vec_andc (vector float, vector float);
	vector float vec_andc (vector float, vector bool int);
	vector float vec_andc (vector bool int, vector float);
	vector bool int vec_andc (vector bool int, vector bool int);
	vector signed int vec_andc (vector bool int, vector signed int);
	vector signed int vec_andc (vector signed int, vector bool int);
	vector signed int vec_andc (vector signed int, vector signed int);
	vector unsigned int vec_andc (vector bool int, vector unsigned int);
	vector unsigned int vec_andc (vector unsigned int, vector bool int);
	vector unsigned int vec_andc (vector unsigned int, vector unsigned int);
	vector bool short vec_andc (vector bool short, vector bool short);
	vector signed short vec_andc (vector bool short, vector signed short);
	vector signed short vec_andc (vector signed short, vector bool short);
	vector signed short vec_andc (vector signed short, vector signed short);
	vector unsigned short vec_andc (vector bool short,
	vector unsigned short);
	vector unsigned short vec_andc (vector unsigned short,
	vector bool short);
	vector unsigned short vec_andc (vector unsigned short,
	vector unsigned short);
	vector signed char vec_andc (vector bool char, vector signed char);
	vector bool char vec_andc (vector bool char, vector bool char);
	vector signed char vec_andc (vector signed char, vector bool char);
	vector signed char vec_andc (vector signed char, vector signed char);
	vector unsigned char vec_andc (vector bool char, vector unsigned char);
	vector unsigned char vec_andc (vector unsigned char, vector bool char);
	vector unsigned char vec_andc (vector unsigned char,
	vector unsigned char);

	vector unsigned char vec_avg (vector unsigned char,
	vector unsigned char);
	vector signed char vec_avg (vector signed char, vector signed char);
	vector unsigned short vec_avg (vector unsigned short,
	vector unsigned short);
	vector signed short vec_avg (vector signed short, vector signed short);
	vector unsigned int vec_avg (vector unsigned int, vector unsigned int);
	vector signed int vec_avg (vector signed int, vector signed int);

	vector signed int vec_vavgsw (vector signed int, vector signed int);

	vector unsigned int vec_vavguw (vector unsigned int,
	vector unsigned int);

	vector signed short vec_vavgsh (vector signed short,
	vector signed short);

	vector unsigned short vec_vavguh (vector unsigned short,
	vector unsigned short);

	vector signed char vec_vavgsb (vector signed char, vector signed char);

	vector unsigned char vec_vavgub (vector unsigned char,
	vector unsigned char);

	vector float vec_ceil (vector float);

	vector signed int vec_cmpb (vector float, vector float);

	vector bool char vec_cmpeq (vector signed char, vector signed char);
	vector bool char vec_cmpeq (vector unsigned char, vector unsigned char);
	vector bool short vec_cmpeq (vector signed short, vector signed short);
	vector bool short vec_cmpeq (vector unsigned short,
	vector unsigned short);
	vector bool int vec_cmpeq (vector signed int, vector signed int);
	vector bool int vec_cmpeq (vector unsigned int, vector unsigned int);
	vector bool int vec_cmpeq (vector float, vector float);

	vector bool int vec_vcmpeqfp (vector float, vector float);

	vector bool int vec_vcmpequw (vector signed int, vector signed int);
	vector bool int vec_vcmpequw (vector unsigned int, vector unsigned int);

	vector bool short vec_vcmpequh (vector signed short,
	vector signed short);
	vector bool short vec_vcmpequh (vector unsigned short,
	vector unsigned short);

	vector bool char vec_vcmpequb (vector signed char, vector signed char);
	vector bool char vec_vcmpequb (vector unsigned char,
	vector unsigned char);

	vector bool int vec_cmpge (vector float, vector float);

	vector bool char vec_cmpgt (vector unsigned char, vector unsigned char);
	vector bool char vec_cmpgt (vector signed char, vector signed char);
	vector bool short vec_cmpgt (vector unsigned short,
	vector unsigned short);
	vector bool short vec_cmpgt (vector signed short, vector signed short);
	vector bool int vec_cmpgt (vector unsigned int, vector unsigned int);
	vector bool int vec_cmpgt (vector signed int, vector signed int);
	vector bool int vec_cmpgt (vector float, vector float);

	vector bool int vec_vcmpgtfp (vector float, vector float);

	vector bool int vec_vcmpgtsw (vector signed int, vector signed int);

	vector bool int vec_vcmpgtuw (vector unsigned int, vector unsigned int);

	vector bool short vec_vcmpgtsh (vector signed short,
	vector signed short);

	vector bool short vec_vcmpgtuh (vector unsigned short,
	vector unsigned short);

	vector bool char vec_vcmpgtsb (vector signed char, vector signed char);

	vector bool char vec_vcmpgtub (vector unsigned char,
	vector unsigned char);

	vector bool int vec_cmple (vector float, vector float);

	vector bool char vec_cmplt (vector unsigned char, vector unsigned char);
	vector bool char vec_cmplt (vector signed char, vector signed char);
	vector bool short vec_cmplt (vector unsigned short,
	vector unsigned short);
	vector bool short vec_cmplt (vector signed short, vector signed short);
	vector bool int vec_cmplt (vector unsigned int, vector unsigned int);
	vector bool int vec_cmplt (vector signed int, vector signed int);
	vector bool int vec_cmplt (vector float, vector float);

	vector float vec_ctf (vector unsigned int, const int);
	vector float vec_ctf (vector signed int, const int);

	vector float vec_vcfsx (vector signed int, const int);

	vector float vec_vcfux (vector unsigned int, const int);

	vector signed int vec_cts (vector float, const int);

	vector unsigned int vec_ctu (vector float, const int);

	void vec_dss (const int);

	void vec_dssall (void);

	void vec_dst (const vector unsigned char *, int, const int);
	void vec_dst (const vector signed char *, int, const int);
	void vec_dst (const vector bool char *, int, const int);
	void vec_dst (const vector unsigned short *, int, const int);
	void vec_dst (const vector signed short *, int, const int);
	void vec_dst (const vector bool short *, int, const int);
	void vec_dst (const vector pixel *, int, const int);
	void vec_dst (const vector unsigned int *, int, const int);
	void vec_dst (const vector signed int *, int, const int);
	void vec_dst (const vector bool int *, int, const int);
	void vec_dst (const vector float *, int, const int);
	void vec_dst (const unsigned char *, int, const int);
	void vec_dst (const signed char *, int, const int);
	void vec_dst (const unsigned short *, int, const int);
	void vec_dst (const short *, int, const int);
	void vec_dst (const unsigned int *, int, const int);
	void vec_dst (const int *, int, const int);
	void vec_dst (const unsigned long *, int, const int);
	void vec_dst (const long *, int, const int);
	void vec_dst (const float *, int, const int);

	void vec_dstst (const vector unsigned char *, int, const int);
	void vec_dstst (const vector signed char *, int, const int);
	void vec_dstst (const vector bool char *, int, const int);
	void vec_dstst (const vector unsigned short *, int, const int);
	void vec_dstst (const vector signed short *, int, const int);
	void vec_dstst (const vector bool short *, int, const int);
	void vec_dstst (const vector pixel *, int, const int);
	void vec_dstst (const vector unsigned int *, int, const int);
	void vec_dstst (const vector signed int *, int, const int);
	void vec_dstst (const vector bool int *, int, const int);
	void vec_dstst (const vector float *, int, const int);
	void vec_dstst (const unsigned char *, int, const int);
	void vec_dstst (const signed char *, int, const int);
	void vec_dstst (const unsigned short *, int, const int);
	void vec_dstst (const short *, int, const int);
	void vec_dstst (const unsigned int *, int, const int);
	void vec_dstst (const int *, int, const int);
	void vec_dstst (const unsigned long *, int, const int);
	void vec_dstst (const long *, int, const int);
	void vec_dstst (const float *, int, const int);

	void vec_dststt (const vector unsigned char *, int, const int);
	void vec_dststt (const vector signed char *, int, const int);
	void vec_dststt (const vector bool char *, int, const int);
	void vec_dststt (const vector unsigned short *, int, const int);
	void vec_dststt (const vector signed short *, int, const int);
	void vec_dststt (const vector bool short *, int, const int);
	void vec_dststt (const vector pixel *, int, const int);
	void vec_dststt (const vector unsigned int *, int, const int);
	void vec_dststt (const vector signed int *, int, const int);
	void vec_dststt (const vector bool int *, int, const int);
	void vec_dststt (const vector float *, int, const int);
	void vec_dststt (const unsigned char *, int, const int);
	void vec_dststt (const signed char *, int, const int);
	void vec_dststt (const unsigned short *, int, const int);
	void vec_dststt (const short *, int, const int);
	void vec_dststt (const unsigned int *, int, const int);
	void vec_dststt (const int *, int, const int);
	void vec_dststt (const unsigned long *, int, const int);
	void vec_dststt (const long *, int, const int);
	void vec_dststt (const float *, int, const int);

	void vec_dstt (const vector unsigned char *, int, const int);
	void vec_dstt (const vector signed char *, int, const int);
	void vec_dstt (const vector bool char *, int, const int);
	void vec_dstt (const vector unsigned short *, int, const int);
	void vec_dstt (const vector signed short *, int, const int);
	void vec_dstt (const vector bool short *, int, const int);
	void vec_dstt (const vector pixel *, int, const int);
	void vec_dstt (const vector unsigned int *, int, const int);
	void vec_dstt (const vector signed int *, int, const int);
	void vec_dstt (const vector bool int *, int, const int);
	void vec_dstt (const vector float *, int, const int);
	void vec_dstt (const unsigned char *, int, const int);
	void vec_dstt (const signed char *, int, const int);
	void vec_dstt (const unsigned short *, int, const int);
	void vec_dstt (const short *, int, const int);
	void vec_dstt (const unsigned int *, int, const int);
	void vec_dstt (const int *, int, const int);
	void vec_dstt (const unsigned long *, int, const int);
	void vec_dstt (const long *, int, const int);
	void vec_dstt (const float *, int, const int);

	vector float vec_expte (vector float);

	vector float vec_floor (vector float);

	vector float vec_ld (int, const vector float *);
	vector float vec_ld (int, const float *);
	vector bool int vec_ld (int, const vector bool int *);
	vector signed int vec_ld (int, const vector signed int *);
	vector signed int vec_ld (int, const int *);
	vector signed int vec_ld (int, const long *);
	vector unsigned int vec_ld (int, const vector unsigned int *);
	vector unsigned int vec_ld (int, const unsigned int *);
	vector unsigned int vec_ld (int, const unsigned long *);
	vector bool short vec_ld (int, const vector bool short *);
	vector pixel vec_ld (int, const vector pixel *);
	vector signed short vec_ld (int, const vector signed short *);
	vector signed short vec_ld (int, const short *);
	vector unsigned short vec_ld (int, const vector unsigned short *);
	vector unsigned short vec_ld (int, const unsigned short *);
	vector bool char vec_ld (int, const vector bool char *);
	vector signed char vec_ld (int, const vector signed char *);
	vector signed char vec_ld (int, const signed char *);
	vector unsigned char vec_ld (int, const vector unsigned char *);
	vector unsigned char vec_ld (int, const unsigned char *);

	vector signed char vec_lde (int, const signed char *);
	vector unsigned char vec_lde (int, const unsigned char *);
	vector signed short vec_lde (int, const short *);
	vector unsigned short vec_lde (int, const unsigned short *);
	vector float vec_lde (int, const float *);
	vector signed int vec_lde (int, const int *);
	vector unsigned int vec_lde (int, const unsigned int *);
	vector signed int vec_lde (int, const long *);
	vector unsigned int vec_lde (int, const unsigned long *);

	vector float vec_lvewx (int, float *);
	vector signed int vec_lvewx (int, int *);
	vector unsigned int vec_lvewx (int, unsigned int *);
	vector signed int vec_lvewx (int, long *);
	vector unsigned int vec_lvewx (int, unsigned long *);

	vector signed short vec_lvehx (int, short *);
	vector unsigned short vec_lvehx (int, unsigned short *);

	vector signed char vec_lvebx (int, char *);
	vector unsigned char vec_lvebx (int, unsigned char *);

	vector float vec_ldl (int, const vector float *);
	vector float vec_ldl (int, const float *);
	vector bool int vec_ldl (int, const vector bool int *);
	vector signed int vec_ldl (int, const vector signed int *);
	vector signed int vec_ldl (int, const int *);
	vector signed int vec_ldl (int, const long *);
	vector unsigned int vec_ldl (int, const vector unsigned int *);
	vector unsigned int vec_ldl (int, const unsigned int *);
	vector unsigned int vec_ldl (int, const unsigned long *);
	vector bool short vec_ldl (int, const vector bool short *);
	vector pixel vec_ldl (int, const vector pixel *);
	vector signed short vec_ldl (int, const vector signed short *);
	vector signed short vec_ldl (int, const short *);
	vector unsigned short vec_ldl (int, const vector unsigned short *);
	vector unsigned short vec_ldl (int, const unsigned short *);
	vector bool char vec_ldl (int, const vector bool char *);
	vector signed char vec_ldl (int, const vector signed char *);
	vector signed char vec_ldl (int, const signed char *);
	vector unsigned char vec_ldl (int, const vector unsigned char *);
	vector unsigned char vec_ldl (int, const unsigned char *);

	vector float vec_loge (vector float);

	vector unsigned char vec_lvsl (int, const volatile unsigned char *);
	vector unsigned char vec_lvsl (int, const volatile signed char *);
	vector unsigned char vec_lvsl (int, const volatile unsigned short *);
	vector unsigned char vec_lvsl (int, const volatile short *);
	vector unsigned char vec_lvsl (int, const volatile unsigned int *);
	vector unsigned char vec_lvsl (int, const volatile int *);
	vector unsigned char vec_lvsl (int, const volatile unsigned long *);
	vector unsigned char vec_lvsl (int, const volatile long *);
	vector unsigned char vec_lvsl (int, const volatile float *);

	vector unsigned char vec_lvsr (int, const volatile unsigned char *);
	vector unsigned char vec_lvsr (int, const volatile signed char *);
	vector unsigned char vec_lvsr (int, const volatile unsigned short *);
	vector unsigned char vec_lvsr (int, const volatile short *);
	vector unsigned char vec_lvsr (int, const volatile unsigned int *);
	vector unsigned char vec_lvsr (int, const volatile int *);
	vector unsigned char vec_lvsr (int, const volatile unsigned long *);
	vector unsigned char vec_lvsr (int, const volatile long *);
	vector unsigned char vec_lvsr (int, const volatile float *);

	vector float vec_madd (vector float, vector float, vector float);

	vector signed short vec_madds (vector signed short,
	vector signed short,
	vector signed short);

	vector unsigned char vec_max (vector bool char, vector unsigned char);
	vector unsigned char vec_max (vector unsigned char, vector bool char);
	vector unsigned char vec_max (vector unsigned char,
	vector unsigned char);
	vector signed char vec_max (vector bool char, vector signed char);
	vector signed char vec_max (vector signed char, vector bool char);
	vector signed char vec_max (vector signed char, vector signed char);
	vector unsigned short vec_max (vector bool short,
	vector unsigned short);
	vector unsigned short vec_max (vector unsigned short,
	vector bool short);
	vector unsigned short vec_max (vector unsigned short,
	vector unsigned short);
	vector signed short vec_max (vector bool short, vector signed short);
	vector signed short vec_max (vector signed short, vector bool short);
	vector signed short vec_max (vector signed short, vector signed short);
	vector unsigned int vec_max (vector bool int, vector unsigned int);
	vector unsigned int vec_max (vector unsigned int, vector bool int);
	vector unsigned int vec_max (vector unsigned int, vector unsigned int);
	vector signed int vec_max (vector bool int, vector signed int);
	vector signed int vec_max (vector signed int, vector bool int);
	vector signed int vec_max (vector signed int, vector signed int);
	vector float vec_max (vector float, vector float);

	vector float vec_vmaxfp (vector float, vector float);

	vector signed int vec_vmaxsw (vector bool int, vector signed int);
	vector signed int vec_vmaxsw (vector signed int, vector bool int);
	vector signed int vec_vmaxsw (vector signed int, vector signed int);

	vector unsigned int vec_vmaxuw (vector bool int, vector unsigned int);
	vector unsigned int vec_vmaxuw (vector unsigned int, vector bool int);
	vector unsigned int vec_vmaxuw (vector unsigned int,
	vector unsigned int);

	vector signed short vec_vmaxsh (vector bool short, vector signed short);
	vector signed short vec_vmaxsh (vector signed short, vector bool short);
	vector signed short vec_vmaxsh (vector signed short,
	vector signed short);

	vector unsigned short vec_vmaxuh (vector bool short,
	vector unsigned short);
	vector unsigned short vec_vmaxuh (vector unsigned short,
	vector bool short);
	vector unsigned short vec_vmaxuh (vector unsigned short,
	vector unsigned short);

	vector signed char vec_vmaxsb (vector bool char, vector signed char);
	vector signed char vec_vmaxsb (vector signed char, vector bool char);
	vector signed char vec_vmaxsb (vector signed char, vector signed char);

	vector unsigned char vec_vmaxub (vector bool char,
	vector unsigned char);
	vector unsigned char vec_vmaxub (vector unsigned char,
	vector bool char);
	vector unsigned char vec_vmaxub (vector unsigned char,
	vector unsigned char);

	vector bool char vec_mergeh (vector bool char, vector bool char);
	vector signed char vec_mergeh (vector signed char, vector signed char);
	vector unsigned char vec_mergeh (vector unsigned char,
	vector unsigned char);
	vector bool short vec_mergeh (vector bool short, vector bool short);
	vector pixel vec_mergeh (vector pixel, vector pixel);
	vector signed short vec_mergeh (vector signed short,
	vector signed short);
	vector unsigned short vec_mergeh (vector unsigned short,
	vector unsigned short);
	vector float vec_mergeh (vector float, vector float);
	vector bool int vec_mergeh (vector bool int, vector bool int);
	vector signed int vec_mergeh (vector signed int, vector signed int);
	vector unsigned int vec_mergeh (vector unsigned int,
	vector unsigned int);

	vector float vec_vmrghw (vector float, vector float);
	vector bool int vec_vmrghw (vector bool int, vector bool int);
	vector signed int vec_vmrghw (vector signed int, vector signed int);
	vector unsigned int vec_vmrghw (vector unsigned int,
	vector unsigned int);

	vector bool short vec_vmrghh (vector bool short, vector bool short);
	vector signed short vec_vmrghh (vector signed short,
	vector signed short);
	vector unsigned short vec_vmrghh (vector unsigned short,
	vector unsigned short);
	vector pixel vec_vmrghh (vector pixel, vector pixel);

	vector bool char vec_vmrghb (vector bool char, vector bool char);
	vector signed char vec_vmrghb (vector signed char, vector signed char);
	vector unsigned char vec_vmrghb (vector unsigned char,
	vector unsigned char);

	vector bool char vec_mergel (vector bool char, vector bool char);
	vector signed char vec_mergel (vector signed char, vector signed char);
	vector unsigned char vec_mergel (vector unsigned char,
	vector unsigned char);
	vector bool short vec_mergel (vector bool short, vector bool short);
	vector pixel vec_mergel (vector pixel, vector pixel);
	vector signed short vec_mergel (vector signed short,
	vector signed short);
	vector unsigned short vec_mergel (vector unsigned short,
	vector unsigned short);
	vector float vec_mergel (vector float, vector float);
	vector bool int vec_mergel (vector bool int, vector bool int);
	vector signed int vec_mergel (vector signed int, vector signed int);
	vector unsigned int vec_mergel (vector unsigned int,
	vector unsigned int);

	vector float vec_vmrglw (vector float, vector float);
	vector signed int vec_vmrglw (vector signed int, vector signed int);
	vector unsigned int vec_vmrglw (vector unsigned int,
	vector unsigned int);
	vector bool int vec_vmrglw (vector bool int, vector bool int);

	vector bool short vec_vmrglh (vector bool short, vector bool short);
	vector signed short vec_vmrglh (vector signed short,
	vector signed short);
	vector unsigned short vec_vmrglh (vector unsigned short,
	vector unsigned short);
	vector pixel vec_vmrglh (vector pixel, vector pixel);

	vector bool char vec_vmrglb (vector bool char, vector bool char);
	vector signed char vec_vmrglb (vector signed char, vector signed char);
	vector unsigned char vec_vmrglb (vector unsigned char,
	vector unsigned char);

	vector unsigned short vec_mfvscr (void);

	vector unsigned char vec_min (vector bool char, vector unsigned char);
	vector unsigned char vec_min (vector unsigned char, vector bool char);
	vector unsigned char vec_min (vector unsigned char,
	vector unsigned char);
	vector signed char vec_min (vector bool char, vector signed char);
	vector signed char vec_min (vector signed char, vector bool char);
	vector signed char vec_min (vector signed char, vector signed char);
	vector unsigned short vec_min (vector bool short,
	vector unsigned short);
	vector unsigned short vec_min (vector unsigned short,
	vector bool short);
	vector unsigned short vec_min (vector unsigned short,
	vector unsigned short);
	vector signed short vec_min (vector bool short, vector signed short);
	vector signed short vec_min (vector signed short, vector bool short);
	vector signed short vec_min (vector signed short, vector signed short);
	vector unsigned int vec_min (vector bool int, vector unsigned int);
	vector unsigned int vec_min (vector unsigned int, vector bool int);
	vector unsigned int vec_min (vector unsigned int, vector unsigned int);
	vector signed int vec_min (vector bool int, vector signed int);
	vector signed int vec_min (vector signed int, vector bool int);
	vector signed int vec_min (vector signed int, vector signed int);
	vector float vec_min (vector float, vector float);

	vector float vec_vminfp (vector float, vector float);

	vector signed int vec_vminsw (vector bool int, vector signed int);
	vector signed int vec_vminsw (vector signed int, vector bool int);
	vector signed int vec_vminsw (vector signed int, vector signed int);

	vector unsigned int vec_vminuw (vector bool int, vector unsigned int);
	vector unsigned int vec_vminuw (vector unsigned int, vector bool int);
	vector unsigned int vec_vminuw (vector unsigned int,
	vector unsigned int);

	vector signed short vec_vminsh (vector bool short, vector signed short);
	vector signed short vec_vminsh (vector signed short, vector bool short);
	vector signed short vec_vminsh (vector signed short,
	vector signed short);

	vector unsigned short vec_vminuh (vector bool short,
	vector unsigned short);
	vector unsigned short vec_vminuh (vector unsigned short,
	vector bool short);
	vector unsigned short vec_vminuh (vector unsigned short,
	vector unsigned short);

	vector signed char vec_vminsb (vector bool char, vector signed char);
	vector signed char vec_vminsb (vector signed char, vector bool char);
	vector signed char vec_vminsb (vector signed char, vector signed char);

	vector unsigned char vec_vminub (vector bool char,
	vector unsigned char);
	vector unsigned char vec_vminub (vector unsigned char,
	vector bool char);
	vector unsigned char vec_vminub (vector unsigned char,
	vector unsigned char);

	vector signed short vec_mladd (vector signed short,
	vector signed short,
	vector signed short);
	vector signed short vec_mladd (vector signed short,
	vector unsigned short,
	vector unsigned short);
	vector signed short vec_mladd (vector unsigned short,
	vector signed short,
	vector signed short);
	vector unsigned short vec_mladd (vector unsigned short,
	vector unsigned short,
	vector unsigned short);

	vector signed short vec_mradds (vector signed short,
	vector signed short,
	vector signed short);

	vector unsigned int vec_msum (vector unsigned char,
	vector unsigned char,
	vector unsigned int);
	vector signed int vec_msum (vector signed char,
	vector unsigned char,
	vector signed int);
	vector unsigned int vec_msum (vector unsigned short,
	vector unsigned short,
	vector unsigned int);
	vector signed int vec_msum (vector signed short,
	vector signed short,
	vector signed int);

	vector signed int vec_vmsumshm (vector signed short,
	vector signed short,
	vector signed int);

	vector unsigned int vec_vmsumuhm (vector unsigned short,
	vector unsigned short,
	vector unsigned int);

	vector signed int vec_vmsummbm (vector signed char,
	vector unsigned char,
	vector signed int);

	vector unsigned int vec_vmsumubm (vector unsigned char,
	vector unsigned char,
	vector unsigned int);

	vector unsigned int vec_msums (vector unsigned short,
	vector unsigned short,
	vector unsigned int);
	vector signed int vec_msums (vector signed short,
	vector signed short,
	vector signed int);

	vector signed int vec_vmsumshs (vector signed short,
	vector signed short,
	vector signed int);

	vector unsigned int vec_vmsumuhs (vector unsigned short,
	vector unsigned short,
	vector unsigned int);

	void vec_mtvscr (vector signed int);
	void vec_mtvscr (vector unsigned int);
	void vec_mtvscr (vector bool int);
	void vec_mtvscr (vector signed short);
	void vec_mtvscr (vector unsigned short);
	void vec_mtvscr (vector bool short);
	void vec_mtvscr (vector pixel);
	void vec_mtvscr (vector signed char);
	void vec_mtvscr (vector unsigned char);
	void vec_mtvscr (vector bool char);

	vector unsigned short vec_mule (vector unsigned char,
	vector unsigned char);
	vector signed short vec_mule (vector signed char,
	vector signed char);
	vector unsigned int vec_mule (vector unsigned short,
	vector unsigned short);
	vector signed int vec_mule (vector signed short, vector signed short);

	vector signed int vec_vmulesh (vector signed short,
	vector signed short);

	vector unsigned int vec_vmuleuh (vector unsigned short,
	vector unsigned short);

	vector signed short vec_vmulesb (vector signed char,
	vector signed char);

	vector unsigned short vec_vmuleub (vector unsigned char,
	vector unsigned char);

	vector unsigned short vec_mulo (vector unsigned char,
	vector unsigned char);
	vector signed short vec_mulo (vector signed char, vector signed char);
	vector unsigned int vec_mulo (vector unsigned short,
	vector unsigned short);
	vector signed int vec_mulo (vector signed short, vector signed short);

	vector signed int vec_vmulosh (vector signed short,
	vector signed short);

	vector unsigned int vec_vmulouh (vector unsigned short,
	vector unsigned short);

	vector signed short vec_vmulosb (vector signed char,
	vector signed char);

	vector unsigned short vec_vmuloub (vector unsigned char,
	vector unsigned char);

	vector float vec_nmsub (vector float, vector float, vector float);

	vector float vec_nor (vector float, vector float);
	vector signed int vec_nor (vector signed int, vector signed int);
	vector unsigned int vec_nor (vector unsigned int, vector unsigned int);
	vector bool int vec_nor (vector bool int, vector bool int);
	vector signed short vec_nor (vector signed short, vector signed short);
	vector unsigned short vec_nor (vector unsigned short,
	vector unsigned short);
	vector bool short vec_nor (vector bool short, vector bool short);
	vector signed char vec_nor (vector signed char, vector signed char);
	vector unsigned char vec_nor (vector unsigned char,
	vector unsigned char);
	vector bool char vec_nor (vector bool char, vector bool char);

	vector float vec_or (vector float, vector float);
	vector float vec_or (vector float, vector bool int);
	vector float vec_or (vector bool int, vector float);
	vector bool int vec_or (vector bool int, vector bool int);
	vector signed int vec_or (vector bool int, vector signed int);
	vector signed int vec_or (vector signed int, vector bool int);
	vector signed int vec_or (vector signed int, vector signed int);
	vector unsigned int vec_or (vector bool int, vector unsigned int);
	vector unsigned int vec_or (vector unsigned int, vector bool int);
	vector unsigned int vec_or (vector unsigned int, vector unsigned int);
	vector bool short vec_or (vector bool short, vector bool short);
	vector signed short vec_or (vector bool short, vector signed short);
	vector signed short vec_or (vector signed short, vector bool short);
	vector signed short vec_or (vector signed short, vector signed short);
	vector unsigned short vec_or (vector bool short, vector unsigned short);
	vector unsigned short vec_or (vector unsigned short, vector bool short);
	vector unsigned short vec_or (vector unsigned short,
	vector unsigned short);
	vector signed char vec_or (vector bool char, vector signed char);
	vector bool char vec_or (vector bool char, vector bool char);
	vector signed char vec_or (vector signed char, vector bool char);
	vector signed char vec_or (vector signed char, vector signed char);
	vector unsigned char vec_or (vector bool char, vector unsigned char);
	vector unsigned char vec_or (vector unsigned char, vector bool char);
	vector unsigned char vec_or (vector unsigned char,
	vector unsigned char);

	vector signed char vec_pack (vector signed short, vector signed short);
	vector unsigned char vec_pack (vector unsigned short,
	vector unsigned short);
	vector bool char vec_pack (vector bool short, vector bool short);
	vector signed short vec_pack (vector signed int, vector signed int);
	vector unsigned short vec_pack (vector unsigned int,
	vector unsigned int);
	vector bool short vec_pack (vector bool int, vector bool int);

	vector bool short vec_vpkuwum (vector bool int, vector bool int);
	vector signed short vec_vpkuwum (vector signed int, vector signed int);
	vector unsigned short vec_vpkuwum (vector unsigned int,
	vector unsigned int);

	vector bool char vec_vpkuhum (vector bool short, vector bool short);
	vector signed char vec_vpkuhum (vector signed short,
	vector signed short);
	vector unsigned char vec_vpkuhum (vector unsigned short,
	vector unsigned short);

	vector pixel vec_packpx (vector unsigned int, vector unsigned int);

	vector unsigned char vec_packs (vector unsigned short,
	vector unsigned short);
	vector signed char vec_packs (vector signed short, vector signed short);
	vector unsigned short vec_packs (vector unsigned int,
	vector unsigned int);
	vector signed short vec_packs (vector signed int, vector signed int);

	vector signed short vec_vpkswss (vector signed int, vector signed int);

	vector unsigned short vec_vpkuwus (vector unsigned int,
	vector unsigned int);

	vector signed char vec_vpkshss (vector signed short,
	vector signed short);

	vector unsigned char vec_vpkuhus (vector unsigned short,
	vector unsigned short);

	vector unsigned char vec_packsu (vector unsigned short,
	vector unsigned short);
	vector unsigned char vec_packsu (vector signed short,
	vector signed short);
	vector unsigned short vec_packsu (vector unsigned int,
	vector unsigned int);
	vector unsigned short vec_packsu (vector signed int, vector signed int);

	vector unsigned short vec_vpkswus (vector signed int,
	vector signed int);

	vector unsigned char vec_vpkshus (vector signed short,
	vector signed short);

	vector float vec_perm (vector float,
	vector float,
	vector unsigned char);
	vector signed int vec_perm (vector signed int,
	vector signed int,
	vector unsigned char);
	vector unsigned int vec_perm (vector unsigned int,
	vector unsigned int,
	vector unsigned char);
	vector bool int vec_perm (vector bool int,
	vector bool int,
	vector unsigned char);
	vector signed short vec_perm (vector signed short,
	vector signed short,
	vector unsigned char);
	vector unsigned short vec_perm (vector unsigned short,
	vector unsigned short,
	vector unsigned char);
	vector bool short vec_perm (vector bool short,
	vector bool short,
	vector unsigned char);
	vector pixel vec_perm (vector pixel,
	vector pixel,
	vector unsigned char);
	vector signed char vec_perm (vector signed char,
	vector signed char,
	vector unsigned char);
	vector unsigned char vec_perm (vector unsigned char,
	vector unsigned char,
	vector unsigned char);
	vector bool char vec_perm (vector bool char,
	vector bool char,
	vector unsigned char);

	vector float vec_re (vector float);

	vector signed char vec_rl (vector signed char,
	vector unsigned char);
	vector unsigned char vec_rl (vector unsigned char,
	vector unsigned char);
	vector signed short vec_rl (vector signed short, vector unsigned short);
	vector unsigned short vec_rl (vector unsigned short,
	vector unsigned short);
	vector signed int vec_rl (vector signed int, vector unsigned int);
	vector unsigned int vec_rl (vector unsigned int, vector unsigned int);

	vector signed int vec_vrlw (vector signed int, vector unsigned int);
	vector unsigned int vec_vrlw (vector unsigned int, vector unsigned int);

	vector signed short vec_vrlh (vector signed short,
	vector unsigned short);
	vector unsigned short vec_vrlh (vector unsigned short,
	vector unsigned short);

	vector signed char vec_vrlb (vector signed char, vector unsigned char);
	vector unsigned char vec_vrlb (vector unsigned char,
	vector unsigned char);

	vector float vec_round (vector float);

	vector float vec_rsqrte (vector float);

	vector float vec_sel (vector float, vector float, vector bool int);
	vector float vec_sel (vector float, vector float, vector unsigned int);
	vector signed int vec_sel (vector signed int,
	vector signed int,
	vector bool int);
	vector signed int vec_sel (vector signed int,
	vector signed int,
	vector unsigned int);
	vector unsigned int vec_sel (vector unsigned int,
	vector unsigned int,
	vector bool int);
	vector unsigned int vec_sel (vector unsigned int,
	vector unsigned int,
	vector unsigned int);
	vector bool int vec_sel (vector bool int,
	vector bool int,
	vector bool int);
	vector bool int vec_sel (vector bool int,
	vector bool int,
	vector unsigned int);
	vector signed short vec_sel (vector signed short,
	vector signed short,
	vector bool short);
	vector signed short vec_sel (vector signed short,
	vector signed short,
	vector unsigned short);
	vector unsigned short vec_sel (vector unsigned short,
	vector unsigned short,
	vector bool short);
	vector unsigned short vec_sel (vector unsigned short,
	vector unsigned short,
	vector unsigned short);
	vector bool short vec_sel (vector bool short,
	vector bool short,
	vector bool short);
	vector bool short vec_sel (vector bool short,
	vector bool short,
	vector unsigned short);
	vector signed char vec_sel (vector signed char,
	vector signed char,
	vector bool char);
	vector signed char vec_sel (vector signed char,
	vector signed char,
	vector unsigned char);
	vector unsigned char vec_sel (vector unsigned char,
	vector unsigned char,
	vector bool char);
	vector unsigned char vec_sel (vector unsigned char,
	vector unsigned char,
	vector unsigned char);
	vector bool char vec_sel (vector bool char,
	vector bool char,
	vector bool char);
	vector bool char vec_sel (vector bool char,
	vector bool char,
	vector unsigned char);

	vector signed char vec_sl (vector signed char,
	vector unsigned char);
	vector unsigned char vec_sl (vector unsigned char,
	vector unsigned char);
	vector signed short vec_sl (vector signed short, vector unsigned short);
	vector unsigned short vec_sl (vector unsigned short,
	vector unsigned short);
	vector signed int vec_sl (vector signed int, vector unsigned int);
	vector unsigned int vec_sl (vector unsigned int, vector unsigned int);

	vector signed int vec_vslw (vector signed int, vector unsigned int);
	vector unsigned int vec_vslw (vector unsigned int, vector unsigned int);

	vector signed short vec_vslh (vector signed short,
	vector unsigned short);
	vector unsigned short vec_vslh (vector unsigned short,
	vector unsigned short);

	vector signed char vec_vslb (vector signed char, vector unsigned char);
	vector unsigned char vec_vslb (vector unsigned char,
	vector unsigned char);

	vector float vec_sld (vector float, vector float, const int);
	vector signed int vec_sld (vector signed int,
	vector signed int,
	const int);
	vector unsigned int vec_sld (vector unsigned int,
	vector unsigned int,
	const int);
	vector bool int vec_sld (vector bool int,
	vector bool int,
	const int);
	vector signed short vec_sld (vector signed short,
	vector signed short,
	const int);
	vector unsigned short vec_sld (vector unsigned short,
	vector unsigned short,
	const int);
	vector bool short vec_sld (vector bool short,
	vector bool short,
	const int);
	vector pixel vec_sld (vector pixel,
	vector pixel,
	const int);
	vector signed char vec_sld (vector signed char,
	vector signed char,
	const int);
	vector unsigned char vec_sld (vector unsigned char,
	vector unsigned char,
	const int);
	vector bool char vec_sld (vector bool char,
	vector bool char,
	const int);

	vector signed int vec_sll (vector signed int,
	vector unsigned int);
	vector signed int vec_sll (vector signed int,
	vector unsigned short);
	vector signed int vec_sll (vector signed int,
	vector unsigned char);
	vector unsigned int vec_sll (vector unsigned int,
	vector unsigned int);
	vector unsigned int vec_sll (vector unsigned int,
	vector unsigned short);
	vector unsigned int vec_sll (vector unsigned int,
	vector unsigned char);
	vector bool int vec_sll (vector bool int,
	vector unsigned int);
	vector bool int vec_sll (vector bool int,
	vector unsigned short);
	vector bool int vec_sll (vector bool int,
	vector unsigned char);
	vector signed short vec_sll (vector signed short,
	vector unsigned int);
	vector signed short vec_sll (vector signed short,
	vector unsigned short);
	vector signed short vec_sll (vector signed short,
	vector unsigned char);
	vector unsigned short vec_sll (vector unsigned short,
	vector unsigned int);
	vector unsigned short vec_sll (vector unsigned short,
	vector unsigned short);
	vector unsigned short vec_sll (vector unsigned short,
	vector unsigned char);
	vector bool short vec_sll (vector bool short, vector unsigned int);
	vector bool short vec_sll (vector bool short, vector unsigned short);
	vector bool short vec_sll (vector bool short, vector unsigned char);
	vector pixel vec_sll (vector pixel, vector unsigned int);
	vector pixel vec_sll (vector pixel, vector unsigned short);
	vector pixel vec_sll (vector pixel, vector unsigned char);
	vector signed char vec_sll (vector signed char, vector unsigned int);
	vector signed char vec_sll (vector signed char, vector unsigned short);
	vector signed char vec_sll (vector signed char, vector unsigned char);
	vector unsigned char vec_sll (vector unsigned char,
	vector unsigned int);
	vector unsigned char vec_sll (vector unsigned char,
	vector unsigned short);
	vector unsigned char vec_sll (vector unsigned char,
	vector unsigned char);
	vector bool char vec_sll (vector bool char, vector unsigned int);
	vector bool char vec_sll (vector bool char, vector unsigned short);
	vector bool char vec_sll (vector bool char, vector unsigned char);

	vector float vec_slo (vector float, vector signed char);
	vector float vec_slo (vector float, vector unsigned char);
	vector signed int vec_slo (vector signed int, vector signed char);
	vector signed int vec_slo (vector signed int, vector unsigned char);
	vector unsigned int vec_slo (vector unsigned int, vector signed char);
	vector unsigned int vec_slo (vector unsigned int, vector unsigned char);
	vector signed short vec_slo (vector signed short, vector signed char);
	vector signed short vec_slo (vector signed short, vector unsigned char);
	vector unsigned short vec_slo (vector unsigned short,
	vector signed char);
	vector unsigned short vec_slo (vector unsigned short,
	vector unsigned char);
	vector pixel vec_slo (vector pixel, vector signed char);
	vector pixel vec_slo (vector pixel, vector unsigned char);
	vector signed char vec_slo (vector signed char, vector signed char);
	vector signed char vec_slo (vector signed char, vector unsigned char);
	vector unsigned char vec_slo (vector unsigned char, vector signed char);
	vector unsigned char vec_slo (vector unsigned char,
	vector unsigned char);

	vector signed char vec_splat (vector signed char, const int);
	vector unsigned char vec_splat (vector unsigned char, const int);
	vector bool char vec_splat (vector bool char, const int);
	vector signed short vec_splat (vector signed short, const int);
	vector unsigned short vec_splat (vector unsigned short, const int);
	vector bool short vec_splat (vector bool short, const int);
	vector pixel vec_splat (vector pixel, const int);
	vector float vec_splat (vector float, const int);
	vector signed int vec_splat (vector signed int, const int);
	vector unsigned int vec_splat (vector unsigned int, const int);
	vector bool int vec_splat (vector bool int, const int);

	vector float vec_vspltw (vector float, const int);
	vector signed int vec_vspltw (vector signed int, const int);
	vector unsigned int vec_vspltw (vector unsigned int, const int);
	vector bool int vec_vspltw (vector bool int, const int);

	vector bool short vec_vsplth (vector bool short, const int);
	vector signed short vec_vsplth (vector signed short, const int);
	vector unsigned short vec_vsplth (vector unsigned short, const int);
	vector pixel vec_vsplth (vector pixel, const int);

	vector signed char vec_vspltb (vector signed char, const int);
	vector unsigned char vec_vspltb (vector unsigned char, const int);
	vector bool char vec_vspltb (vector bool char, const int);

	vector signed char vec_splat_s8 (const int);

	vector signed short vec_splat_s16 (const int);

	vector signed int vec_splat_s32 (const int);

	vector unsigned char vec_splat_u8 (const int);

	vector unsigned short vec_splat_u16 (const int);

	vector unsigned int vec_splat_u32 (const int);

	vector signed char vec_sr (vector signed char, vector unsigned char);
	vector unsigned char vec_sr (vector unsigned char,
	vector unsigned char);
	vector signed short vec_sr (vector signed short,
	vector unsigned short);
	vector unsigned short vec_sr (vector unsigned short,
	vector unsigned short);
	vector signed int vec_sr (vector signed int, vector unsigned int);
	vector unsigned int vec_sr (vector unsigned int, vector unsigned int);

	vector signed int vec_vsrw (vector signed int, vector unsigned int);
	vector unsigned int vec_vsrw (vector unsigned int, vector unsigned int);

	vector signed short vec_vsrh (vector signed short,
	vector unsigned short);
	vector unsigned short vec_vsrh (vector unsigned short,
	vector unsigned short);

	vector signed char vec_vsrb (vector signed char, vector unsigned char);
	vector unsigned char vec_vsrb (vector unsigned char,
	vector unsigned char);

	vector signed char vec_sra (vector signed char, vector unsigned char);
	vector unsigned char vec_sra (vector unsigned char,
	vector unsigned char);
	vector signed short vec_sra (vector signed short,
	vector unsigned short);
	vector unsigned short vec_sra (vector unsigned short,
	vector unsigned short);
	vector signed int vec_sra (vector signed int, vector unsigned int);
	vector unsigned int vec_sra (vector unsigned int, vector unsigned int);

	vector signed int vec_vsraw (vector signed int, vector unsigned int);
	vector unsigned int vec_vsraw (vector unsigned int,
	vector unsigned int);

	vector signed short vec_vsrah (vector signed short,
	vector unsigned short);
	vector unsigned short vec_vsrah (vector unsigned short,
	vector unsigned short);

	vector signed char vec_vsrab (vector signed char, vector unsigned char);
	vector unsigned char vec_vsrab (vector unsigned char,
	vector unsigned char);

	vector signed int vec_srl (vector signed int, vector unsigned int);
	vector signed int vec_srl (vector signed int, vector unsigned short);
	vector signed int vec_srl (vector signed int, vector unsigned char);
	vector unsigned int vec_srl (vector unsigned int, vector unsigned int);
	vector unsigned int vec_srl (vector unsigned int,
	vector unsigned short);
	vector unsigned int vec_srl (vector unsigned int, vector unsigned char);
	vector bool int vec_srl (vector bool int, vector unsigned int);
	vector bool int vec_srl (vector bool int, vector unsigned short);
	vector bool int vec_srl (vector bool int, vector unsigned char);
	vector signed short vec_srl (vector signed short, vector unsigned int);
	vector signed short vec_srl (vector signed short,
	vector unsigned short);
	vector signed short vec_srl (vector signed short, vector unsigned char);
	vector unsigned short vec_srl (vector unsigned short,
	vector unsigned int);
	vector unsigned short vec_srl (vector unsigned short,
	vector unsigned short);
	vector unsigned short vec_srl (vector unsigned short,
	vector unsigned char);
	vector bool short vec_srl (vector bool short, vector unsigned int);
	vector bool short vec_srl (vector bool short, vector unsigned short);
	vector bool short vec_srl (vector bool short, vector unsigned char);
	vector pixel vec_srl (vector pixel, vector unsigned int);
	vector pixel vec_srl (vector pixel, vector unsigned short);
	vector pixel vec_srl (vector pixel, vector unsigned char);
	vector signed char vec_srl (vector signed char, vector unsigned int);
	vector signed char vec_srl (vector signed char, vector unsigned short);
	vector signed char vec_srl (vector signed char, vector unsigned char);
	vector unsigned char vec_srl (vector unsigned char,
	vector unsigned int);
	vector unsigned char vec_srl (vector unsigned char,
	vector unsigned short);
	vector unsigned char vec_srl (vector unsigned char,
	vector unsigned char);
	vector bool char vec_srl (vector bool char, vector unsigned int);
	vector bool char vec_srl (vector bool char, vector unsigned short);
	vector bool char vec_srl (vector bool char, vector unsigned char);

	vector float vec_sro (vector float, vector signed char);
	vector float vec_sro (vector float, vector unsigned char);
	vector signed int vec_sro (vector signed int, vector signed char);
	vector signed int vec_sro (vector signed int, vector unsigned char);
	vector unsigned int vec_sro (vector unsigned int, vector signed char);
	vector unsigned int vec_sro (vector unsigned int, vector unsigned char);
	vector signed short vec_sro (vector signed short, vector signed char);
	vector signed short vec_sro (vector signed short, vector unsigned char);
	vector unsigned short vec_sro (vector unsigned short,
	vector signed char);
	vector unsigned short vec_sro (vector unsigned short,
	vector unsigned char);
	vector pixel vec_sro (vector pixel, vector signed char);
	vector pixel vec_sro (vector pixel, vector unsigned char);
	vector signed char vec_sro (vector signed char, vector signed char);
	vector signed char vec_sro (vector signed char, vector unsigned char);
	vector unsigned char vec_sro (vector unsigned char, vector signed char);
	vector unsigned char vec_sro (vector unsigned char,
	vector unsigned char);

	void vec_st (vector float, int, vector float *);
	void vec_st (vector float, int, float *);
	void vec_st (vector signed int, int, vector signed int *);
	void vec_st (vector signed int, int, int *);
	void vec_st (vector unsigned int, int, vector unsigned int *);
	void vec_st (vector unsigned int, int, unsigned int *);
	void vec_st (vector bool int, int, vector bool int *);
	void vec_st (vector bool int, int, unsigned int *);
	void vec_st (vector bool int, int, int *);
	void vec_st (vector signed short, int, vector signed short *);
	void vec_st (vector signed short, int, short *);
	void vec_st (vector unsigned short, int, vector unsigned short *);
	void vec_st (vector unsigned short, int, unsigned short *);
	void vec_st (vector bool short, int, vector bool short *);
	void vec_st (vector bool short, int, unsigned short *);
	void vec_st (vector pixel, int, vector pixel *);
	void vec_st (vector pixel, int, unsigned short *);
	void vec_st (vector pixel, int, short *);
	void vec_st (vector bool short, int, short *);
	void vec_st (vector signed char, int, vector signed char *);
	void vec_st (vector signed char, int, signed char *);
	void vec_st (vector unsigned char, int, vector unsigned char *);
	void vec_st (vector unsigned char, int, unsigned char *);
	void vec_st (vector bool char, int, vector bool char *);
	void vec_st (vector bool char, int, unsigned char *);
	void vec_st (vector bool char, int, signed char *);

	void vec_ste (vector signed char, int, signed char *);
	void vec_ste (vector unsigned char, int, unsigned char *);
	void vec_ste (vector bool char, int, signed char *);
	void vec_ste (vector bool char, int, unsigned char *);
	void vec_ste (vector signed short, int, short *);
	void vec_ste (vector unsigned short, int, unsigned short *);
	void vec_ste (vector bool short, int, short *);
	void vec_ste (vector bool short, int, unsigned short *);
	void vec_ste (vector pixel, int, short *);
	void vec_ste (vector pixel, int, unsigned short *);
	void vec_ste (vector float, int, float *);
	void vec_ste (vector signed int, int, int *);
	void vec_ste (vector unsigned int, int, unsigned int *);
	void vec_ste (vector bool int, int, int *);
	void vec_ste (vector bool int, int, unsigned int *);

	void vec_stvewx (vector float, int, float *);
	void vec_stvewx (vector signed int, int, int *);
	void vec_stvewx (vector unsigned int, int, unsigned int *);
	void vec_stvewx (vector bool int, int, int *);
	void vec_stvewx (vector bool int, int, unsigned int *);

	void vec_stvehx (vector signed short, int, short *);
	void vec_stvehx (vector unsigned short, int, unsigned short *);
	void vec_stvehx (vector bool short, int, short *);
	void vec_stvehx (vector bool short, int, unsigned short *);
	void vec_stvehx (vector pixel, int, short *);
	void vec_stvehx (vector pixel, int, unsigned short *);

	void vec_stvebx (vector signed char, int, signed char *);
	void vec_stvebx (vector unsigned char, int, unsigned char *);
	void vec_stvebx (vector bool char, int, signed char *);
	void vec_stvebx (vector bool char, int, unsigned char *);

	void vec_stl (vector float, int, vector float *);
	void vec_stl (vector float, int, float *);
	void vec_stl (vector signed int, int, vector signed int *);
	void vec_stl (vector signed int, int, int *);
	void vec_stl (vector unsigned int, int, vector unsigned int *);
	void vec_stl (vector unsigned int, int, unsigned int *);
	void vec_stl (vector bool int, int, vector bool int *);
	void vec_stl (vector bool int, int, unsigned int *);
	void vec_stl (vector bool int, int, int *);
	void vec_stl (vector signed short, int, vector signed short *);
	void vec_stl (vector signed short, int, short *);
	void vec_stl (vector unsigned short, int, vector unsigned short *);
	void vec_stl (vector unsigned short, int, unsigned short *);
	void vec_stl (vector bool short, int, vector bool short *);
	void vec_stl (vector bool short, int, unsigned short *);
	void vec_stl (vector bool short, int, short *);
	void vec_stl (vector pixel, int, vector pixel *);
	void vec_stl (vector pixel, int, unsigned short *);
	void vec_stl (vector pixel, int, short *);
	void vec_stl (vector signed char, int, vector signed char *);
	void vec_stl (vector signed char, int, signed char *);
	void vec_stl (vector unsigned char, int, vector unsigned char *);
	void vec_stl (vector unsigned char, int, unsigned char *);
	void vec_stl (vector bool char, int, vector bool char *);
	void vec_stl (vector bool char, int, unsigned char *);
	void vec_stl (vector bool char, int, signed char *);

	vector signed char vec_sub (vector bool char, vector signed char);
	vector signed char vec_sub (vector signed char, vector bool char);
	vector signed char vec_sub (vector signed char, vector signed char);
	vector unsigned char vec_sub (vector bool char, vector unsigned char);
	vector unsigned char vec_sub (vector unsigned char, vector bool char);
	vector unsigned char vec_sub (vector unsigned char,
	vector unsigned char);
	vector signed short vec_sub (vector bool short, vector signed short);
	vector signed short vec_sub (vector signed short, vector bool short);
	vector signed short vec_sub (vector signed short, vector signed short);
	vector unsigned short vec_sub (vector bool short,
	vector unsigned short);
	vector unsigned short vec_sub (vector unsigned short,
	vector bool short);
	vector unsigned short vec_sub (vector unsigned short,
	vector unsigned short);
	vector signed int vec_sub (vector bool int, vector signed int);
	vector signed int vec_sub (vector signed int, vector bool int);
	vector signed int vec_sub (vector signed int, vector signed int);
	vector unsigned int vec_sub (vector bool int, vector unsigned int);
	vector unsigned int vec_sub (vector unsigned int, vector bool int);
	vector unsigned int vec_sub (vector unsigned int, vector unsigned int);
	vector float vec_sub (vector float, vector float);

	vector float vec_vsubfp (vector float, vector float);

	vector signed int vec_vsubuwm (vector bool int, vector signed int);
	vector signed int vec_vsubuwm (vector signed int, vector bool int);
	vector signed int vec_vsubuwm (vector signed int, vector signed int);
	vector unsigned int vec_vsubuwm (vector bool int, vector unsigned int);
	vector unsigned int vec_vsubuwm (vector unsigned int, vector bool int);
	vector unsigned int vec_vsubuwm (vector unsigned int,
	vector unsigned int);

	vector signed short vec_vsubuhm (vector bool short,
	vector signed short);
	vector signed short vec_vsubuhm (vector signed short,
	vector bool short);
	vector signed short vec_vsubuhm (vector signed short,
	vector signed short);
	vector unsigned short vec_vsubuhm (vector bool short,
	vector unsigned short);
	vector unsigned short vec_vsubuhm (vector unsigned short,
	vector bool short);
	vector unsigned short vec_vsubuhm (vector unsigned short,
	vector unsigned short);

	vector signed char vec_vsububm (vector bool char, vector signed char);
	vector signed char vec_vsububm (vector signed char, vector bool char);
	vector signed char vec_vsububm (vector signed char, vector signed char);
	vector unsigned char vec_vsububm (vector bool char,
	vector unsigned char);
	vector unsigned char vec_vsububm (vector unsigned char,
	vector bool char);
	vector unsigned char vec_vsububm (vector unsigned char,
	vector unsigned char);

	vector unsigned int vec_subc (vector unsigned int, vector unsigned int);

	vector unsigned char vec_subs (vector bool char, vector unsigned char);
	vector unsigned char vec_subs (vector unsigned char, vector bool char);
	vector unsigned char vec_subs (vector unsigned char,
	vector unsigned char);
	vector signed char vec_subs (vector bool char, vector signed char);
	vector signed char vec_subs (vector signed char, vector bool char);
	vector signed char vec_subs (vector signed char, vector signed char);
	vector unsigned short vec_subs (vector bool short,
	vector unsigned short);
	vector unsigned short vec_subs (vector unsigned short,
	vector bool short);
	vector unsigned short vec_subs (vector unsigned short,
	vector unsigned short);
	vector signed short vec_subs (vector bool short, vector signed short);
	vector signed short vec_subs (vector signed short, vector bool short);
	vector signed short vec_subs (vector signed short, vector signed short);
	vector unsigned int vec_subs (vector bool int, vector unsigned int);
	vector unsigned int vec_subs (vector unsigned int, vector bool int);
	vector unsigned int vec_subs (vector unsigned int, vector unsigned int);
	vector signed int vec_subs (vector bool int, vector signed int);
	vector signed int vec_subs (vector signed int, vector bool int);
	vector signed int vec_subs (vector signed int, vector signed int);

	vector signed int vec_vsubsws (vector bool int, vector signed int);
	vector signed int vec_vsubsws (vector signed int, vector bool int);
	vector signed int vec_vsubsws (vector signed int, vector signed int);

	vector unsigned int vec_vsubuws (vector bool int, vector unsigned int);
	vector unsigned int vec_vsubuws (vector unsigned int, vector bool int);
	vector unsigned int vec_vsubuws (vector unsigned int,
	vector unsigned int);

	vector signed short vec_vsubshs (vector bool short,
	vector signed short);
	vector signed short vec_vsubshs (vector signed short,
	vector bool short);
	vector signed short vec_vsubshs (vector signed short,
	vector signed short);

	vector unsigned short vec_vsubuhs (vector bool short,
	vector unsigned short);
	vector unsigned short vec_vsubuhs (vector unsigned short,
	vector bool short);
	vector unsigned short vec_vsubuhs (vector unsigned short,
	vector unsigned short);

	vector signed char vec_vsubsbs (vector bool char, vector signed char);
	vector signed char vec_vsubsbs (vector signed char, vector bool char);
	vector signed char vec_vsubsbs (vector signed char, vector signed char);

	vector unsigned char vec_vsububs (vector bool char,
	vector unsigned char);
	vector unsigned char vec_vsububs (vector unsigned char,
	vector bool char);
	vector unsigned char vec_vsububs (vector unsigned char,
	vector unsigned char);

	vector unsigned int vec_sum4s (vector unsigned char,
	vector unsigned int);
	vector signed int vec_sum4s (vector signed char, vector signed int);
	vector signed int vec_sum4s (vector signed short, vector signed int);

	vector signed int vec_vsum4shs (vector signed short, vector signed int);

	vector signed int vec_vsum4sbs (vector signed char, vector signed int);

	vector unsigned int vec_vsum4ubs (vector unsigned char,
	vector unsigned int);

	vector signed int vec_sum2s (vector signed int, vector signed int);

	vector signed int vec_sums (vector signed int, vector signed int);

	vector float vec_trunc (vector float);

	vector signed short vec_unpackh (vector signed char);
	vector bool short vec_unpackh (vector bool char);
	vector signed int vec_unpackh (vector signed short);
	vector bool int vec_unpackh (vector bool short);
	vector unsigned int vec_unpackh (vector pixel);

	vector bool int vec_vupkhsh (vector bool short);
	vector signed int vec_vupkhsh (vector signed short);

	vector unsigned int vec_vupkhpx (vector pixel);

	vector bool short vec_vupkhsb (vector bool char);
	vector signed short vec_vupkhsb (vector signed char);

	vector signed short vec_unpackl (vector signed char);
	vector bool short vec_unpackl (vector bool char);
	vector unsigned int vec_unpackl (vector pixel);
	vector signed int vec_unpackl (vector signed short);
	vector bool int vec_unpackl (vector bool short);

	vector unsigned int vec_vupklpx (vector pixel);

	vector bool int vec_vupklsh (vector bool short);
	vector signed int vec_vupklsh (vector signed short);

	vector bool short vec_vupklsb (vector bool char);
	vector signed short vec_vupklsb (vector signed char);

	vector float vec_xor (vector float, vector float);
	vector float vec_xor (vector float, vector bool int);
	vector float vec_xor (vector bool int, vector float);
	vector bool int vec_xor (vector bool int, vector bool int);
	vector signed int vec_xor (vector bool int, vector signed int);
	vector signed int vec_xor (vector signed int, vector bool int);
	vector signed int vec_xor (vector signed int, vector signed int);
	vector unsigned int vec_xor (vector bool int, vector unsigned int);
	vector unsigned int vec_xor (vector unsigned int, vector bool int);
	vector unsigned int vec_xor (vector unsigned int, vector unsigned int);
	vector bool short vec_xor (vector bool short, vector bool short);
	vector signed short vec_xor (vector bool short, vector signed short);
	vector signed short vec_xor (vector signed short, vector bool short);
	vector signed short vec_xor (vector signed short, vector signed short);
	vector unsigned short vec_xor (vector bool short,
	vector unsigned short);
	vector unsigned short vec_xor (vector unsigned short,
	vector bool short);
	vector unsigned short vec_xor (vector unsigned short,
	vector unsigned short);
	vector signed char vec_xor (vector bool char, vector signed char);
	vector bool char vec_xor (vector bool char, vector bool char);
	vector signed char vec_xor (vector signed char, vector bool char);
	vector signed char vec_xor (vector signed char, vector signed char);
	vector unsigned char vec_xor (vector bool char, vector unsigned char);
	vector unsigned char vec_xor (vector unsigned char, vector bool char);
	vector unsigned char vec_xor (vector unsigned char,
	vector unsigned char);

	int vec_all_eq (vector signed char, vector bool char);
	int vec_all_eq (vector signed char, vector signed char);
	int vec_all_eq (vector unsigned char, vector bool char);
	int vec_all_eq (vector unsigned char, vector unsigned char);
	int vec_all_eq (vector bool char, vector bool char);
	int vec_all_eq (vector bool char, vector unsigned char);
	int vec_all_eq (vector bool char, vector signed char);
	int vec_all_eq (vector signed short, vector bool short);
	int vec_all_eq (vector signed short, vector signed short);
	int vec_all_eq (vector unsigned short, vector bool short);
	int vec_all_eq (vector unsigned short, vector unsigned short);
	int vec_all_eq (vector bool short, vector bool short);
	int vec_all_eq (vector bool short, vector unsigned short);
	int vec_all_eq (vector bool short, vector signed short);
	int vec_all_eq (vector pixel, vector pixel);
	int vec_all_eq (vector signed int, vector bool int);
	int vec_all_eq (vector signed int, vector signed int);
	int vec_all_eq (vector unsigned int, vector bool int);
	int vec_all_eq (vector unsigned int, vector unsigned int);
	int vec_all_eq (vector bool int, vector bool int);
	int vec_all_eq (vector bool int, vector unsigned int);
	int vec_all_eq (vector bool int, vector signed int);
	int vec_all_eq (vector float, vector float);

	int vec_all_ge (vector bool char, vector unsigned char);
	int vec_all_ge (vector unsigned char, vector bool char);
	int vec_all_ge (vector unsigned char, vector unsigned char);
	int vec_all_ge (vector bool char, vector signed char);
	int vec_all_ge (vector signed char, vector bool char);
	int vec_all_ge (vector signed char, vector signed char);
	int vec_all_ge (vector bool short, vector unsigned short);
	int vec_all_ge (vector unsigned short, vector bool short);
	int vec_all_ge (vector unsigned short, vector unsigned short);
	int vec_all_ge (vector signed short, vector signed short);
	int vec_all_ge (vector bool short, vector signed short);
	int vec_all_ge (vector signed short, vector bool short);
	int vec_all_ge (vector bool int, vector unsigned int);
	int vec_all_ge (vector unsigned int, vector bool int);
	int vec_all_ge (vector unsigned int, vector unsigned int);
	int vec_all_ge (vector bool int, vector signed int);
	int vec_all_ge (vector signed int, vector bool int);
	int vec_all_ge (vector signed int, vector signed int);
	int vec_all_ge (vector float, vector float);

	int vec_all_gt (vector bool char, vector unsigned char);
	int vec_all_gt (vector unsigned char, vector bool char);
	int vec_all_gt (vector unsigned char, vector unsigned char);
	int vec_all_gt (vector bool char, vector signed char);
	int vec_all_gt (vector signed char, vector bool char);
	int vec_all_gt (vector signed char, vector signed char);
	int vec_all_gt (vector bool short, vector unsigned short);
	int vec_all_gt (vector unsigned short, vector bool short);
	int vec_all_gt (vector unsigned short, vector unsigned short);
	int vec_all_gt (vector bool short, vector signed short);
	int vec_all_gt (vector signed short, vector bool short);
	int vec_all_gt (vector signed short, vector signed short);
	int vec_all_gt (vector bool int, vector unsigned int);
	int vec_all_gt (vector unsigned int, vector bool int);
	int vec_all_gt (vector unsigned int, vector unsigned int);
	int vec_all_gt (vector bool int, vector signed int);
	int vec_all_gt (vector signed int, vector bool int);
	int vec_all_gt (vector signed int, vector signed int);
	int vec_all_gt (vector float, vector float);

	int vec_all_in (vector float, vector float);

	int vec_all_le (vector bool char, vector unsigned char);
	int vec_all_le (vector unsigned char, vector bool char);
	int vec_all_le (vector unsigned char, vector unsigned char);
	int vec_all_le (vector bool char, vector signed char);
	int vec_all_le (vector signed char, vector bool char);
	int vec_all_le (vector signed char, vector signed char);
	int vec_all_le (vector bool short, vector unsigned short);
	int vec_all_le (vector unsigned short, vector bool short);
	int vec_all_le (vector unsigned short, vector unsigned short);
	int vec_all_le (vector bool short, vector signed short);
	int vec_all_le (vector signed short, vector bool short);
	int vec_all_le (vector signed short, vector signed short);
	int vec_all_le (vector bool int, vector unsigned int);
	int vec_all_le (vector unsigned int, vector bool int);
	int vec_all_le (vector unsigned int, vector unsigned int);
	int vec_all_le (vector bool int, vector signed int);
	int vec_all_le (vector signed int, vector bool int);
	int vec_all_le (vector signed int, vector signed int);
	int vec_all_le (vector float, vector float);

	int vec_all_lt (vector bool char, vector unsigned char);
	int vec_all_lt (vector unsigned char, vector bool char);
	int vec_all_lt (vector unsigned char, vector unsigned char);
	int vec_all_lt (vector bool char, vector signed char);
	int vec_all_lt (vector signed char, vector bool char);
	int vec_all_lt (vector signed char, vector signed char);
	int vec_all_lt (vector bool short, vector unsigned short);
	int vec_all_lt (vector unsigned short, vector bool short);
	int vec_all_lt (vector unsigned short, vector unsigned short);
	int vec_all_lt (vector bool short, vector signed short);
	int vec_all_lt (vector signed short, vector bool short);
	int vec_all_lt (vector signed short, vector signed short);
	int vec_all_lt (vector bool int, vector unsigned int);
	int vec_all_lt (vector unsigned int, vector bool int);
	int vec_all_lt (vector unsigned int, vector unsigned int);
	int vec_all_lt (vector bool int, vector signed int);
	int vec_all_lt (vector signed int, vector bool int);
	int vec_all_lt (vector signed int, vector signed int);
	int vec_all_lt (vector float, vector float);

	int vec_all_nan (vector float);

	int vec_all_ne (vector signed char, vector bool char);
	int vec_all_ne (vector signed char, vector signed char);
	int vec_all_ne (vector unsigned char, vector bool char);
	int vec_all_ne (vector unsigned char, vector unsigned char);
	int vec_all_ne (vector bool char, vector bool char);
	int vec_all_ne (vector bool char, vector unsigned char);
	int vec_all_ne (vector bool char, vector signed char);
	int vec_all_ne (vector signed short, vector bool short);
	int vec_all_ne (vector signed short, vector signed short);
	int vec_all_ne (vector unsigned short, vector bool short);
	int vec_all_ne (vector unsigned short, vector unsigned short);
	int vec_all_ne (vector bool short, vector bool short);
	int vec_all_ne (vector bool short, vector unsigned short);
	int vec_all_ne (vector bool short, vector signed short);
	int vec_all_ne (vector pixel, vector pixel);
	int vec_all_ne (vector signed int, vector bool int);
	int vec_all_ne (vector signed int, vector signed int);
	int vec_all_ne (vector unsigned int, vector bool int);
	int vec_all_ne (vector unsigned int, vector unsigned int);
	int vec_all_ne (vector bool int, vector bool int);
	int vec_all_ne (vector bool int, vector unsigned int);
	int vec_all_ne (vector bool int, vector signed int);
	int vec_all_ne (vector float, vector float);

	int vec_all_nge (vector float, vector float);

	int vec_all_ngt (vector float, vector float);

	int vec_all_nle (vector float, vector float);

	int vec_all_nlt (vector float, vector float);

	int vec_all_numeric (vector float);

	int vec_any_eq (vector signed char, vector bool char);
	int vec_any_eq (vector signed char, vector signed char);
	int vec_any_eq (vector unsigned char, vector bool char);
	int vec_any_eq (vector unsigned char, vector unsigned char);
	int vec_any_eq (vector bool char, vector bool char);
	int vec_any_eq (vector bool char, vector unsigned char);
	int vec_any_eq (vector bool char, vector signed char);
	int vec_any_eq (vector signed short, vector bool short);
	int vec_any_eq (vector signed short, vector signed short);
	int vec_any_eq (vector unsigned short, vector bool short);
	int vec_any_eq (vector unsigned short, vector unsigned short);
	int vec_any_eq (vector bool short, vector bool short);
	int vec_any_eq (vector bool short, vector unsigned short);
	int vec_any_eq (vector bool short, vector signed short);
	int vec_any_eq (vector pixel, vector pixel);
	int vec_any_eq (vector signed int, vector bool int);
	int vec_any_eq (vector signed int, vector signed int);
	int vec_any_eq (vector unsigned int, vector bool int);
	int vec_any_eq (vector unsigned int, vector unsigned int);
	int vec_any_eq (vector bool int, vector bool int);
	int vec_any_eq (vector bool int, vector unsigned int);
	int vec_any_eq (vector bool int, vector signed int);
	int vec_any_eq (vector float, vector float);

	int vec_any_ge (vector signed char, vector bool char);
	int vec_any_ge (vector unsigned char, vector bool char);
	int vec_any_ge (vector unsigned char, vector unsigned char);
	int vec_any_ge (vector signed char, vector signed char);
	int vec_any_ge (vector bool char, vector unsigned char);
	int vec_any_ge (vector bool char, vector signed char);
	int vec_any_ge (vector unsigned short, vector bool short);
	int vec_any_ge (vector unsigned short, vector unsigned short);
	int vec_any_ge (vector signed short, vector signed short);
	int vec_any_ge (vector signed short, vector bool short);
	int vec_any_ge (vector bool short, vector unsigned short);
	int vec_any_ge (vector bool short, vector signed short);
	int vec_any_ge (vector signed int, vector bool int);
	int vec_any_ge (vector unsigned int, vector bool int);
	int vec_any_ge (vector unsigned int, vector unsigned int);
	int vec_any_ge (vector signed int, vector signed int);
	int vec_any_ge (vector bool int, vector unsigned int);
	int vec_any_ge (vector bool int, vector signed int);
	int vec_any_ge (vector float, vector float);

	int vec_any_gt (vector bool char, vector unsigned char);
	int vec_any_gt (vector unsigned char, vector bool char);
	int vec_any_gt (vector unsigned char, vector unsigned char);
	int vec_any_gt (vector bool char, vector signed char);
	int vec_any_gt (vector signed char, vector bool char);
	int vec_any_gt (vector signed char, vector signed char);
	int vec_any_gt (vector bool short, vector unsigned short);
	int vec_any_gt (vector unsigned short, vector bool short);
	int vec_any_gt (vector unsigned short, vector unsigned short);
	int vec_any_gt (vector bool short, vector signed short);
	int vec_any_gt (vector signed short, vector bool short);
	int vec_any_gt (vector signed short, vector signed short);
	int vec_any_gt (vector bool int, vector unsigned int);
	int vec_any_gt (vector unsigned int, vector bool int);
	int vec_any_gt (vector unsigned int, vector unsigned int);
	int vec_any_gt (vector bool int, vector signed int);
	int vec_any_gt (vector signed int, vector bool int);
	int vec_any_gt (vector signed int, vector signed int);
	int vec_any_gt (vector float, vector float);

	int vec_any_le (vector bool char, vector unsigned char);
	int vec_any_le (vector unsigned char, vector bool char);
	int vec_any_le (vector unsigned char, vector unsigned char);
	int vec_any_le (vector bool char, vector signed char);
	int vec_any_le (vector signed char, vector bool char);
	int vec_any_le (vector signed char, vector signed char);
	int vec_any_le (vector bool short, vector unsigned short);
	int vec_any_le (vector unsigned short, vector bool short);
	int vec_any_le (vector unsigned short, vector unsigned short);
	int vec_any_le (vector bool short, vector signed short);
	int vec_any_le (vector signed short, vector bool short);
	int vec_any_le (vector signed short, vector signed short);
	int vec_any_le (vector bool int, vector unsigned int);
	int vec_any_le (vector unsigned int, vector bool int);
	int vec_any_le (vector unsigned int, vector unsigned int);
	int vec_any_le (vector bool int, vector signed int);
	int vec_any_le (vector signed int, vector bool int);
	int vec_any_le (vector signed int, vector signed int);
	int vec_any_le (vector float, vector float);

	int vec_any_lt (vector bool char, vector unsigned char);
	int vec_any_lt (vector unsigned char, vector bool char);
	int vec_any_lt (vector unsigned char, vector unsigned char);
	int vec_any_lt (vector bool char, vector signed char);
	int vec_any_lt (vector signed char, vector bool char);
	int vec_any_lt (vector signed char, vector signed char);
	int vec_any_lt (vector bool short, vector unsigned short);
	int vec_any_lt (vector unsigned short, vector bool short);
	int vec_any_lt (vector unsigned short, vector unsigned short);
	int vec_any_lt (vector bool short, vector signed short);
	int vec_any_lt (vector signed short, vector bool short);
	int vec_any_lt (vector signed short, vector signed short);
	int vec_any_lt (vector bool int, vector unsigned int);
	int vec_any_lt (vector unsigned int, vector bool int);
	int vec_any_lt (vector unsigned int, vector unsigned int);
	int vec_any_lt (vector bool int, vector signed int);
	int vec_any_lt (vector signed int, vector bool int);
	int vec_any_lt (vector signed int, vector signed int);
	int vec_any_lt (vector float, vector float);

	int vec_any_nan (vector float);

	int vec_any_ne (vector signed char, vector bool char);
	int vec_any_ne (vector signed char, vector signed char);
	int vec_any_ne (vector unsigned char, vector bool char);
	int vec_any_ne (vector unsigned char, vector unsigned char);
	int vec_any_ne (vector bool char, vector bool char);
	int vec_any_ne (vector bool char, vector unsigned char);
	int vec_any_ne (vector bool char, vector signed char);
	int vec_any_ne (vector signed short, vector bool short);
	int vec_any_ne (vector signed short, vector signed short);
	int vec_any_ne (vector unsigned short, vector bool short);
	int vec_any_ne (vector unsigned short, vector unsigned short);
	int vec_any_ne (vector bool short, vector bool short);
	int vec_any_ne (vector bool short, vector unsigned short);
	int vec_any_ne (vector bool short, vector signed short);
	int vec_any_ne (vector pixel, vector pixel);
	int vec_any_ne (vector signed int, vector bool int);
	int vec_any_ne (vector signed int, vector signed int);
	int vec_any_ne (vector unsigned int, vector bool int);
	int vec_any_ne (vector unsigned int, vector unsigned int);
	int vec_any_ne (vector bool int, vector bool int);
	int vec_any_ne (vector bool int, vector unsigned int);
	int vec_any_ne (vector bool int, vector signed int);
	int vec_any_ne (vector float, vector float);

	int vec_any_nge (vector float, vector float);

	int vec_any_ngt (vector float, vector float);

	int vec_any_nle (vector float, vector float);

	int vec_any_nlt (vector float, vector float);

	int vec_any_numeric (vector float);

	int vec_any_out (vector float, vector float);
	@end smallexample

	@node SPARC VIS Built-in Functions
	@subsection SPARC VIS Built-in Functions

	GCC supports SIMD operations on the SPARC using both the generic vector
	extensions (@pxref{Vector Extensions}) as well as built-in functions for
	the SPARC Visual Instruction Set (VIS). When you use the @option{-mvis}
	switch, the VIS extension is exposed as the following built-in functions:

	@smallexample
	typedef int v2si __attribute__ ((vector_size (8)));
	typedef short v4hi __attribute__ ((vector_size (8)));
	typedef short v2hi __attribute__ ((vector_size (4)));
	typedef char v8qi __attribute__ ((vector_size (8)));
	typedef char v4qi __attribute__ ((vector_size (4)));

	void * __builtin_vis_alignaddr (void *, long);
	int64_t __builtin_vis_faligndatadi (int64_t, int64_t);
	v2si __builtin_vis_faligndatav2si (v2si, v2si);
	v4hi __builtin_vis_faligndatav4hi (v4si, v4si);
	v8qi __builtin_vis_faligndatav8qi (v8qi, v8qi);

	v4hi __builtin_vis_fexpand (v4qi);

	v4hi __builtin_vis_fmul8x16 (v4qi, v4hi);
	v4hi __builtin_vis_fmul8x16au (v4qi, v4hi);
	v4hi __builtin_vis_fmul8x16al (v4qi, v4hi);
	v4hi __builtin_vis_fmul8sux16 (v8qi, v4hi);
	v4hi __builtin_vis_fmul8ulx16 (v8qi, v4hi);
	v2si __builtin_vis_fmuld8sux16 (v4qi, v2hi);
	v2si __builtin_vis_fmuld8ulx16 (v4qi, v2hi);

	v4qi __builtin_vis_fpack16 (v4hi);
	v8qi __builtin_vis_fpack32 (v2si, v2si);
	v2hi __builtin_vis_fpackfix (v2si);
	v8qi __builtin_vis_fpmerge (v4qi, v4qi);

	int64_t __builtin_vis_pdist (v8qi, v8qi, int64_t);
	@end smallexample

	@node Target Format Checks
	@section Format Checks Specific to Particular Target Machines

	For some target machines, GCC supports additional options to the
	format attribute
	(@pxref{Function Attributes,,Declaring Attributes of Functions}).

	@menu
	* Solaris Format Checks::
	@end menu

	@node Solaris Format Checks
	@subsection Solaris Format Checks

	Solaris targets support the @code{cmn_err} (or @code{__cmn_err__}) format
	check. @code{cmn_err} accepts a subset of the standard @code{printf}
	conversions, and the two-argument @code{%b} conversion for displaying
	bit-fields. See the Solaris man page for @code{cmn_err} for more information.

	@node Pragmas
	@section Pragmas Accepted by GCC
	@cindex pragmas
	@cindex #pragma

	GCC supports several types of pragmas, primarily in order to compile
	code originally written for other compilers. Note that in general
	we do not recommend the use of pragmas; @xref{Function Attributes},
	for further explanation.

	@menu
	* ARM Pragmas::
	* M32C Pragmas::
	* RS/6000 and PowerPC Pragmas::
	* Darwin Pragmas::
	* Solaris Pragmas::
	* Symbol-Renaming Pragmas::
	* Structure-Packing Pragmas::
	* Weak Pragmas::
	* Diagnostic Pragmas::
	* Visibility Pragmas::
	@end menu

	@node ARM Pragmas
	@subsection ARM Pragmas

	The ARM target defines pragmas for controlling the default addition of
	@code{long_call} and @code{short_call} attributes to functions.
	@xref{Function Attributes}, for information about the effects of these
	attributes.

	@table @code
	@item long_calls
	@cindex pragma, long_calls
	Set all subsequent functions to have the @code{long_call} attribute.

	@item no_long_calls
	@cindex pragma, no_long_calls
	Set all subsequent functions to have the @code{short_call} attribute.

	@item long_calls_off
	@cindex pragma, long_calls_off
	Do not affect the @code{long_call} or @code{short_call} attributes of
	subsequent functions.
	@end table

	@node M32C Pragmas
	@subsection M32C Pragmas

	@table @code
	@item memregs @var{number}
	@cindex pragma, memregs
	Overrides the command line option @code{-memregs=} for the current
	file. Use with care! This pragma must be before any function in the
	file, and mixing different memregs values in different objects may
	make them incompatible. This pragma is useful when a
	performance-critical function uses a memreg for temporary values,
	as it may allow you to reduce the number of memregs used.

	@end table

	@node RS/6000 and PowerPC Pragmas
	@subsection RS/6000 and PowerPC Pragmas

	The RS/6000 and PowerPC targets define one pragma for controlling
	whether or not the @code{longcall} attribute is added to function
	declarations by default. This pragma overrides the @option{-mlongcall}
	option, but not the @code{longcall} and @code{shortcall} attributes.
	@xref{RS/6000 and PowerPC Options}, for more information about when long
	calls are and are not necessary.

	@table @code
	@item longcall (1)
	@cindex pragma, longcall
	Apply the @code{longcall} attribute to all subsequent function
	declarations.

	@item longcall (0)
	Do not apply the @code{longcall} attribute to subsequent function
	declarations.
	@end table

	@c Describe c4x pragmas here.
	@c Describe h8300 pragmas here.
	@c Describe sh pragmas here.
	@c Describe v850 pragmas here.

	@node Darwin Pragmas
	@subsection Darwin Pragmas

	The following pragmas are available for all architectures running the
	Darwin operating system. These are useful for compatibility with other
	Mac OS compilers.

	@table @code
	@item mark @var{tokens}@dots{}
	@cindex pragma, mark
	This pragma is accepted, but has no effect.

	@item options align=@var{alignment}
	@cindex pragma, options align
	This pragma sets the alignment of fields in structures. The values of
	@var{alignment} may be @code{mac68k}, to emulate m68k alignment, or
	@code{power}, to emulate PowerPC alignment. Uses of this pragma nest
	properly; to restore the previous setting, use @code{reset} for the
	@var{alignment}.

	@item segment @var{tokens}@dots{}
	@cindex pragma, segment
	This pragma is accepted, but has no effect.

	@item unused (@var{var} [, @var{var}]@dots{})
	@cindex pragma, unused
	This pragma declares variables to be possibly unused. GCC will not
	produce warnings for the listed variables. The effect is similar to
	that of the @code{unused} attribute, except that this pragma may appear
	anywhere within the variables' scopes.
	@end table

	@node Solaris Pragmas
	@subsection Solaris Pragmas

	The Solaris target supports @code{#pragma redefine_extname}
	(@pxref{Symbol-Renaming Pragmas}). It also supports additional
	@code{#pragma} directives for compatibility with the system compiler.

	@table @code
	@item align @var{alignment} (@var{variable} [, @var{variable}]...)
	@cindex pragma, align

	Increase the minimum alignment of each @var{variable} to @var{alignment}.
	This is the same as GCC's @code{aligned} attribute @pxref{Variable
	Attributes}). Macro expansion occurs on the arguments to this pragma
	when compiling C. It does not currently occur when compiling C++, but
	this is a bug which may be fixed in a future release.

	@item fini (@var{function} [, @var{function}]...)
	@cindex pragma, fini

	This pragma causes each listed @var{function} to be called after
	main, or during shared module unloading, by adding a call to the
	@code{.fini} section.

	@item init (@var{function} [, @var{function}]...)
	@cindex pragma, init

	This pragma causes each listed @var{function} to be called during
	initialization (before @code{main}) or during shared module loading, by
	adding a call to the @code{.init} section.

	@end table

	@node Symbol-Renaming Pragmas
	@subsection Symbol-Renaming Pragmas

	For compatibility with the Solaris and Tru64 UNIX system headers, GCC
	supports two @code{#pragma} directives which change the name used in
	assembly for a given declaration. These pragmas are only available on
	platforms whose system headers need them. To get this effect on all
	platforms supported by GCC, use the asm labels extension (@pxref{Asm
	Labels}).

	@table @code
	@item redefine_extname @var{oldname} @var{newname}
	@cindex pragma, redefine_extname

	This pragma gives the C function @var{oldname} the assembly symbol
	@var{newname}. The preprocessor macro @code{__PRAGMA_REDEFINE_EXTNAME}
	will be defined if this pragma is available (currently only on
	Solaris).

	@item extern_prefix @var{string}
	@cindex pragma, extern_prefix

	This pragma causes all subsequent external function and variable
	declarations to have @var{string} prepended to their assembly symbols.
	This effect may be terminated with another @code{extern_prefix} pragma
	whose argument is an empty string. The preprocessor macro
	@code{__PRAGMA_EXTERN_PREFIX} will be defined if this pragma is
	available (currently only on Tru64 UNIX)@.
	@end table

	These pragmas and the asm labels extension interact in a complicated
	manner. Here are some corner cases you may want to be aware of.

	@enumerate
	@item Both pragmas silently apply only to declarations with external
	linkage. Asm labels do not have this restriction.

	@item In C++, both pragmas silently apply only to declarations with
	``C'' linkage. Again, asm labels do not have this restriction.

	@item If any of the three ways of changing the assembly name of a
	declaration is applied to a declaration whose assembly name has
	already been determined (either by a previous use of one of these
	features, or because the compiler needed the assembly name in order to
	generate code), and the new name is different, a warning issues and
	the name does not change.

	@item The @var{oldname} used by @code{#pragma redefine_extname} is
	always the C-language name.

	@item If @code{#pragma extern_prefix} is in effect, and a declaration
	occurs with an asm label attached, the prefix is silently ignored for
	that declaration.

	@item If @code{#pragma extern_prefix} and @code{#pragma redefine_extname}
	apply to the same declaration, whichever triggered first wins, and a
	warning issues if they contradict each other. (We would like to have
	@code{#pragma redefine_extname} always win, for consistency with asm
	labels, but if @code{#pragma extern_prefix} triggers first we have no
	way of knowing that that happened.)
	@end enumerate

	@node Structure-Packing Pragmas
	@subsection Structure-Packing Pragmas

	For compatibility with Win32, GCC supports a set of @code{#pragma}
	directives which change the maximum alignment of members of structures
	(other than zero-width bitfields), unions, and classes subsequently
	defined. The @var{n} value below always is required to be a small power
	of two and specifies the new alignment in bytes.

	@enumerate
	@item @code{#pragma pack(@var{n})} simply sets the new alignment.
	@item @code{#pragma pack()} sets the alignment to the one that was in
	effect when compilation started (see also command line option
	@option{-fpack-struct[=<n>]} @pxref{Code Gen Options}).
	@item @code{#pragma pack(push[,@var{n}])} pushes the current alignment
	setting on an internal stack and then optionally sets the new alignment.
	@item @code{#pragma pack(pop)} restores the alignment setting to the one
	saved at the top of the internal stack (and removes that stack entry).
	Note that @code{#pragma pack([@var{n}])} does not influence this internal
	stack; thus it is possible to have @code{#pragma pack(push)} followed by
	multiple @code{#pragma pack(@var{n})} instances and finalized by a single
	@code{#pragma pack(pop)}.
	@end enumerate

	Some targets, e.g. i386 and powerpc, support the @code{ms_struct}
	@code{#pragma} which lays out a structure as the documented
	@code{__attribute__ ((ms_struct))}.
	@enumerate
	@item @code{#pragma ms_struct on} turns on the layout for structures
	declared.
	@item @code{#pragma ms_struct off} turns off the layout for structures
	declared.
	@item @code{#pragma ms_struct reset} goes back to the default layout.
	@end enumerate

	@node Weak Pragmas
	@subsection Weak Pragmas

	For compatibility with SVR4, GCC supports a set of @code{#pragma}
	directives for declaring symbols to be weak, and defining weak
	aliases.

	@table @code
	@item #pragma weak @var{symbol}
	@cindex pragma, weak
	This pragma declares @var{symbol} to be weak, as if the declaration
	had the attribute of the same name. The pragma may appear before
	or after the declaration of @var{symbol}, but must appear before
	either its first use or its definition. It is not an error for
	@var{symbol} to never be defined at all.

	@item #pragma weak @var{symbol1} = @var{symbol2}
	This pragma declares @var{symbol1} to be a weak alias of @var{symbol2}.
	It is an error if @var{symbol2} is not defined in the current
	translation unit.
	@end table

	@node Diagnostic Pragmas
	@subsection Diagnostic Pragmas

	GCC allows the user to selectively enable or disable certain types of
	diagnostics, and change the kind of the diagnostic. For example, a
	project's policy might require that all sources compile with
	@option{-Werror} but certain files might have exceptions allowing
	specific types of warnings. Or, a project might selectively enable
	diagnostics and treat them as errors depending on which preprocessor
	macros are defined.

	@table @code
	@item #pragma GCC diagnostic @var{kind} @var{option}
	@cindex pragma, diagnostic

	Modifies the disposition of a diagnostic. Note that not all
	diagnostics are modifiable; at the moment only warnings (normally
	controlled by @samp{-W...}) can be controlled, and not all of them.
	Use @option{-fdiagnostics-show-option} to determine which diagnostics
	are controllable and which option controls them.

	@var{kind} is @samp{error} to treat this diagnostic as an error,
	@samp{warning} to treat it like a warning (even if @option{-Werror} is
	in effect), or @samp{ignored} if the diagnostic is to be ignored.
	@var{option} is a double quoted string which matches the command line
	option.

	@example
	#pragma GCC diagnostic warning "-Wformat"
	#pragma GCC diagnostic error "-Wformat"
	#pragma GCC diagnostic ignored "-Wformat"
	@end example

	Note that these pragmas override any command line options. Also,
	while it is syntactically valid to put these pragmas anywhere in your
	sources, the only supported location for them is before any data or
	functions are defined. Doing otherwise may result in unpredictable
	results depending on how the optimizer manages your sources. If the
	same option is listed multiple times, the last one specified is the
	one that is in effect. This pragma is not intended to be a general
	purpose replacement for command line options, but for implementing
	strict control over project policies.

	@end table

	@node Visibility Pragmas
	@subsection Visibility Pragmas

	@table @code
	@item #pragma GCC visibility push(@var{visibility})
	@itemx #pragma GCC visibility pop
	@cindex pragma, visibility

	This pragma allows the user to set the visibility for multiple
	declarations without having to give each a visibility attribute
	@xref{Function Attributes}, for more information about visibility and
	the attribute syntax.

	In C++, @samp{#pragma GCC visibility} affects only namespace-scope
	declarations. Class members and template specializations are not
	affected; if you want to override the visibility for a particular
	member or instantiation, you must use an attribute.

	@end table

	@node Unnamed Fields
	@section Unnamed struct/union fields within structs/unions
	@cindex struct
	@cindex union

	For compatibility with other compilers, GCC allows you to define
	a structure or union that contains, as fields, structures and unions
	without names. For example:

	@smallexample
	struct @{
	int a;
	union @{
	int b;
	float c;
	@};
	int d;
	@} foo;
	@end smallexample

	In this example, the user would be able to access members of the unnamed
	union with code like @samp{foo.b}. Note that only unnamed structs and
	unions are allowed, you may not have, for example, an unnamed
	@code{int}.

	You must never create such structures that cause ambiguous field definitions.
	For example, this structure:

	@smallexample
	struct @{
	int a;
	struct @{
	int a;
	@};
	@} foo;
	@end smallexample

	It is ambiguous which @code{a} is being referred to with @samp{foo.a}.
	Such constructs are not supported and must be avoided. In the future,
	such constructs may be detected and treated as compilation errors.

	@opindex fms-extensions
	Unless @option{-fms-extensions} is used, the unnamed field must be a
	structure or union definition without a tag (for example, @samp{struct
	@{ int a; @};}). If @option{-fms-extensions} is used, the field may
	also be a definition with a tag such as @samp{struct foo @{ int a;
	@};}, a reference to a previously defined structure or union such as
	@samp{struct foo;}, or a reference to a @code{typedef} name for a
	previously defined structure or union type.

	@node Thread-Local
	@section Thread-Local Storage
	@cindex Thread-Local Storage
	@cindex @acronym{TLS}
	@cindex __thread

	Thread-local storage (@acronym{TLS}) is a mechanism by which variables
	are allocated such that there is one instance of the variable per extant
	thread. The run-time model GCC uses to implement this originates
	in the IA-64 processor-specific ABI, but has since been migrated
	to other processors as well. It requires significant support from
	the linker (@command{ld}), dynamic linker (@command{ld.so}), and
	system libraries (@file{libc.so} and @file{libpthread.so}), so it
	is not available everywhere.

	At the user level, the extension is visible with a new storage
	class keyword: @code{__thread}. For example:

	@smallexample
	__thread int i;
	extern __thread struct state s;
	static __thread char *p;
	@end smallexample

	The @code{__thread} specifier may be used alone, with the @code{extern}
	or @code{static} specifiers, but with no other storage class specifier.
	When used with @code{extern} or @code{static}, @code{__thread} must appear
	immediately after the other storage class specifier.

	The @code{__thread} specifier may be applied to any global, file-scoped
	static, function-scoped static, or static data member of a class. It may
	not be applied to block-scoped automatic or non-static data member.

	When the address-of operator is applied to a thread-local variable, it is
	evaluated at run-time and returns the address of the current thread's
	instance of that variable. An address so obtained may be used by any
	thread. When a thread terminates, any pointers to thread-local variables
	in that thread become invalid.

	No static initialization may refer to the address of a thread-local variable.

	In C++, if an initializer is present for a thread-local variable, it must
	be a @var{constant-expression}, as defined in 5.19.2 of the ANSI/ISO C++
	standard.

	See @uref{http://people.redhat.com/drepper/tls.pdf,
	ELF Handling For Thread-Local Storage} for a detailed explanation of
	the four thread-local storage addressing models, and how the run-time
	is expected to function.

	@menu
	* C99 Thread-Local Edits::
	* C++98 Thread-Local Edits::
	@end menu

	@node C99 Thread-Local Edits
	@subsection ISO/IEC 9899:1999 Edits for Thread-Local Storage

	The following are a set of changes to ISO/IEC 9899:1999 (aka C99)
	that document the exact semantics of the language extension.

	@itemize @bullet
	@item
	@cite{5.1.2 Execution environments}

	Add new text after paragraph 1

	@quotation
	Within either execution environment, a @dfn{thread} is a flow of
	control within a program. It is implementation defined whether
	or not there may be more than one thread associated with a program.
	It is implementation defined how threads beyond the first are
	created, the name and type of the function called at thread
	startup, and how threads may be terminated. However, objects
	with thread storage duration shall be initialized before thread
	startup.
	@end quotation

	@item
	@cite{6.2.4 Storage durations of objects}

	Add new text before paragraph 3

	@quotation
	An object whose identifier is declared with the storage-class
	specifier @w{@code{__thread}} has @dfn{thread storage duration}.
	Its lifetime is the entire execution of the thread, and its
	stored value is initialized only once, prior to thread startup.
	@end quotation

	@item
	@cite{6.4.1 Keywords}

	Add @code{__thread}.

	@item
	@cite{6.7.1 Storage-class specifiers}

	Add @code{__thread} to the list of storage class specifiers in
	paragraph 1.

	Change paragraph 2 to

	@quotation
	With the exception of @code{__thread}, at most one storage-class
	specifier may be given [@dots{}]. The @code{__thread} specifier may
	be used alone, or immediately following @code{extern} or
	@code{static}.
	@end quotation

	Add new text after paragraph 6

	@quotation
	The declaration of an identifier for a variable that has
	block scope that specifies @code{__thread} shall also
	specify either @code{extern} or @code{static}.

	The @code{__thread} specifier shall be used only with
	variables.
	@end quotation
	@end itemize

	@node C++98 Thread-Local Edits
	@subsection ISO/IEC 14882:1998 Edits for Thread-Local Storage

	The following are a set of changes to ISO/IEC 14882:1998 (aka C++98)
	that document the exact semantics of the language extension.

	@itemize @bullet
	@item
	@b{[intro.execution]}

	New text after paragraph 4

	@quotation
	A @dfn{thread} is a flow of control within the abstract machine.
	It is implementation defined whether or not there may be more than
	one thread.
	@end quotation

	New text after paragraph 7

	@quotation
	It is unspecified whether additional action must be taken to
	ensure when and whether side effects are visible to other threads.
	@end quotation

	@item
	@b{[lex.key]}

	Add @code{__thread}.

	@item
	@b{[basic.start.main]}

	Add after paragraph 5

	@quotation
	The thread that begins execution at the @code{main} function is called
	the @dfn{main thread}. It is implementation defined how functions
	beginning threads other than the main thread are designated or typed.
	A function so designated, as well as the @code{main} function, is called
	a @dfn{thread startup function}. It is implementation defined what
	happens if a thread startup function returns. It is implementation
	defined what happens to other threads when any thread calls @code{exit}.
	@end quotation

	@item
	@b{[basic.start.init]}

	Add after paragraph 4

	@quotation
	The storage for an object of thread storage duration shall be
	statically initialized before the first statement of the thread startup
	function. An object of thread storage duration shall not require
	dynamic initialization.
	@end quotation

	@item
	@b{[basic.start.term]}

	Add after paragraph 3

	@quotation
	The type of an object with thread storage duration shall not have a
	non-trivial destructor, nor shall it be an array type whose elements
	(directly or indirectly) have non-trivial destructors.
	@end quotation

	@item
	@b{[basic.stc]}

	Add ``thread storage duration'' to the list in paragraph 1.

	Change paragraph 2

	@quotation
	Thread, static, and automatic storage durations are associated with
	objects introduced by declarations [@dots{}].
	@end quotation

	Add @code{__thread} to the list of specifiers in paragraph 3.

	@item
	@b{[basic.stc.thread]}

	New section before @b{[basic.stc.static]}

	@quotation
	The keyword @code{__thread} applied to a non-local object gives the
	object thread storage duration.

	A local variable or class data member declared both @code{static}
	and @code{__thread} gives the variable or member thread storage
	duration.
	@end quotation

	@item
	@b{[basic.stc.static]}

	Change paragraph 1

	@quotation
	All objects which have neither thread storage duration, dynamic
	storage duration nor are local [@dots{}].
	@end quotation

	@item
	@b{[dcl.stc]}

	Add @code{__thread} to the list in paragraph 1.

	Change paragraph 1

	@quotation
	With the exception of @code{__thread}, at most one
	@var{storage-class-specifier} shall appear in a given
	@var{decl-specifier-seq}. The @code{__thread} specifier may
	be used alone, or immediately following the @code{extern} or
	@code{static} specifiers. [@dots{}]
	@end quotation

	Add after paragraph 5

	@quotation
	The @code{__thread} specifier can be applied only to the names of objects
	and to anonymous unions.
	@end quotation

	@item
	@b{[class.mem]}

	Add after paragraph 6

	@quotation
	Non-@code{static} members shall not be @code{__thread}.
	@end quotation
	@end itemize

	@node Binary constants
	@section Binary constants using the @samp{0b} prefix
	@cindex Binary constants using the @samp{0b} prefix

	Integer constants can be written as binary constants, consisting of a
	sequence of @samp{0} and @samp{1} digits, prefixed by @samp{0b} or
	@samp{0B}. This is particularly useful in environments that operate a
	lot on the bit-level (like microcontrollers).

	The following statements are identical:

	@smallexample
	i = 42;
	i = 0x2a;
	i = 052;
	i = 0b101010;
	@end smallexample

	The type of these constants follows the same rules as for octal or
	hexadecimal integer constants, so suffixes like @samp{L} or @samp{UL}
	can be applied.

	@node C++ Extensions
	@chapter Extensions to the C++ Language
	@cindex extensions, C++ language
	@cindex C++ language extensions

	The GNU compiler provides these extensions to the C++ language (and you
	can also use most of the C language extensions in your C++ programs). If you
	want to write code that checks whether these features are available, you can
	test for the GNU compiler the same way as for C programs: check for a
	predefined macro @code{__GNUC__}. You can also use @code{__GNUG__} to
	test specifically for GNU C++ (@pxref{Common Predefined Macros,,
	Predefined Macros,cpp,The GNU C Preprocessor}).

	@menu
	* Volatiles:: What constitutes an access to a volatile object.
	* Restricted Pointers:: C99 restricted pointers and references.
	* Vague Linkage:: Where G++ puts inlines, vtables and such.
	* C++ Interface:: You can use a single C++ header file for both
	declarations and definitions.
	* Template Instantiation:: Methods for ensuring that exactly one copy of
	each needed template instantiation is emitted.
	* Bound member functions:: You can extract a function pointer to the
	method denoted by a @samp{->} or @samp{.} expression.
	* C++ Attributes:: Variable, function, and type attributes for C++ only.
	* Namespace Association:: Strong using-directives for namespace association.
	* Java Exceptions:: Tweaking exception handling to work with Java.
	* Deprecated Features:: Things will disappear from g++.
	* Backwards Compatibility:: Compatibilities with earlier definitions of C++.
	@end menu

	@node Volatiles
	@section When is a Volatile Object Accessed?
	@cindex accessing volatiles
	@cindex volatile read
	@cindex volatile write
	@cindex volatile access

	Both the C and C++ standard have the concept of volatile objects. These
	are normally accessed by pointers and used for accessing hardware. The
	standards encourage compilers to refrain from optimizations concerning
	accesses to volatile objects. The C standard leaves it implementation
	defined as to what constitutes a volatile access. The C++ standard omits
	to specify this, except to say that C++ should behave in a similar manner
	to C with respect to volatiles, where possible. The minimum either
	standard specifies is that at a sequence point all previous accesses to
	volatile objects have stabilized and no subsequent accesses have
	occurred. Thus an implementation is free to reorder and combine
	volatile accesses which occur between sequence points, but cannot do so
	for accesses across a sequence point. The use of volatiles does not
	allow you to violate the restriction on updating objects multiple times
	within a sequence point.

	@xref{Qualifiers implementation, , Volatile qualifier and the C compiler}.

	The behavior differs slightly between C and C++ in the non-obvious cases:

	@smallexample
	volatile int *src = @var{somevalue};
	*src;
	@end smallexample

	With C, such expressions are rvalues, and GCC interprets this either as a
	read of the volatile object being pointed to or only as request to evaluate
	the side-effects. The C++ standard specifies that such expressions do not
	undergo lvalue to rvalue conversion, and that the type of the dereferenced
	object may be incomplete. The C++ standard does not specify explicitly
	that it is this lvalue to rvalue conversion which may be responsible for
	causing an access. However, there is reason to believe that it is,
	because otherwise certain simple expressions become undefined. However,
	because it would surprise most programmers, G++ treats dereferencing a
	pointer to volatile object of complete type when the value is unused as
	GCC would do for an equivalent type in C. When the object has incomplete
	type, G++ issues a warning; if you wish to force an error, you must
	force a conversion to rvalue with, for instance, a static cast.

	When using a reference to volatile, G++ does not treat equivalent
	expressions as accesses to volatiles, but instead issues a warning that
	no volatile is accessed. The rationale for this is that otherwise it
	becomes difficult to determine where volatile access occur, and not
	possible to ignore the return value from functions returning volatile
	references. Again, if you wish to force a read, cast the reference to
	an rvalue.

	@node Restricted Pointers
	@section Restricting Pointer Aliasing
	@cindex restricted pointers
	@cindex restricted references
	@cindex restricted this pointer

	As with the C front end, G++ understands the C99 feature of restricted pointers,
	specified with the @code{__restrict__}, or @code{__restrict} type
	qualifier. Because you cannot compile C++ by specifying the @option{-std=c99}
	language flag, @code{restrict} is not a keyword in C++.

	In addition to allowing restricted pointers, you can specify restricted
	references, which indicate that the reference is not aliased in the local
	context.

	@smallexample
	void fn (int *__restrict__ rptr, int &__restrict__ rref)
	@{
	/* @r{@dots{}} */
	@}
	@end smallexample

	@noindent
	In the body of @code{fn}, @var{rptr} points to an unaliased integer and
	@var{rref} refers to a (different) unaliased integer.

	You may also specify whether a member function's @var{this} pointer is
	unaliased by using @code{__restrict__} as a member function qualifier.

	@smallexample
	void T::fn () __restrict__
	@{
	/* @r{@dots{}} */
	@}
	@end smallexample

	@noindent
	Within the body of @code{T::fn}, @var{this} will have the effective
	definition @code{T *__restrict__ const this}. Notice that the
	interpretation of a @code{__restrict__} member function qualifier is
	different to that of @code{const} or @code{volatile} qualifier, in that it
	is applied to the pointer rather than the object. This is consistent with
	other compilers which implement restricted pointers.

	As with all outermost parameter qualifiers, @code{__restrict__} is
	ignored in function definition matching. This means you only need to
	specify @code{__restrict__} in a function definition, rather than
	in a function prototype as well.

	@node Vague Linkage
	@section Vague Linkage
	@cindex vague linkage

	There are several constructs in C++ which require space in the object
	file but are not clearly tied to a single translation unit. We say that
	these constructs have ``vague linkage''. Typically such constructs are
	emitted wherever they are needed, though sometimes we can be more
	clever.

	@table @asis
	@item Inline Functions
	Inline functions are typically defined in a header file which can be
	included in many different compilations. Hopefully they can usually be
	inlined, but sometimes an out-of-line copy is necessary, if the address
	of the function is taken or if inlining fails. In general, we emit an
	out-of-line copy in all translation units where one is needed. As an
	exception, we only emit inline virtual functions with the vtable, since
	it will always require a copy.

	Local static variables and string constants used in an inline function
	are also considered to have vague linkage, since they must be shared
	between all inlined and out-of-line instances of the function.

	@item VTables
	@cindex vtable
	C++ virtual functions are implemented in most compilers using a lookup
	table, known as a vtable. The vtable contains pointers to the virtual
	functions provided by a class, and each object of the class contains a
	pointer to its vtable (or vtables, in some multiple-inheritance
	situations). If the class declares any non-inline, non-pure virtual
	functions, the first one is chosen as the ``key method'' for the class,
	and the vtable is only emitted in the translation unit where the key
	method is defined.

	@emph{Note:} If the chosen key method is later defined as inline, the
	vtable will still be emitted in every translation unit which defines it.
	Make sure that any inline virtuals are declared inline in the class
	body, even if they are not defined there.

	@item type_info objects
	@cindex type_info
	@cindex RTTI
	C++ requires information about types to be written out in order to
	implement @samp{dynamic_cast}, @samp{typeid} and exception handling.
	For polymorphic classes (classes with virtual functions), the type_info
	object is written out along with the vtable so that @samp{dynamic_cast}
	can determine the dynamic type of a class object at runtime. For all
	other types, we write out the type_info object when it is used: when
	applying @samp{typeid} to an expression, throwing an object, or
	referring to a type in a catch clause or exception specification.

	@item Template Instantiations
	Most everything in this section also applies to template instantiations,
	but there are other options as well.
	@xref{Template Instantiation,,Where's the Template?}.

	@end table

	When used with GNU ld version 2.8 or later on an ELF system such as
	GNU/Linux or Solaris 2, or on Microsoft Windows, duplicate copies of
	these constructs will be discarded at link time. This is known as
	COMDAT support.

	On targets that don't support COMDAT, but do support weak symbols, GCC
	will use them. This way one copy will override all the others, but
	the unused copies will still take up space in the executable.

	For targets which do not support either COMDAT or weak symbols,
	most entities with vague linkage will be emitted as local symbols to
	avoid duplicate definition errors from the linker. This will not happen
	for local statics in inlines, however, as having multiple copies will
	almost certainly break things.

	@xref{C++ Interface,,Declarations and Definitions in One Header}, for
	another way to control placement of these constructs.

	@node C++ Interface
	@section #pragma interface and implementation

	@cindex interface and implementation headers, C++
	@cindex C++ interface and implementation headers
	@cindex pragmas, interface and implementation

	@code{#pragma interface} and @code{#pragma implementation} provide the
	user with a way of explicitly directing the compiler to emit entities
	with vague linkage (and debugging information) in a particular
	translation unit.

	@emph{Note:} As of GCC 2.7.2, these @code{#pragma}s are not useful in
	most cases, because of COMDAT support and the ``key method'' heuristic
	mentioned in @ref{Vague Linkage}. Using them can actually cause your
	program to grow due to unnecessary out-of-line copies of inline
	functions. Currently (3.4) the only benefit of these
	@code{#pragma}s is reduced duplication of debugging information, and
	that should be addressed soon on DWARF 2 targets with the use of
	COMDAT groups.

	@table @code
	@item #pragma interface
	@itemx #pragma interface "@var{subdir}/@var{objects}.h"
	@kindex #pragma interface
	Use this directive in @emph{header files} that define object classes, to save
	space in most of the object files that use those classes. Normally,
	local copies of certain information (backup copies of inline member
	functions, debugging information, and the internal tables that implement
	virtual functions) must be kept in each object file that includes class
	definitions. You can use this pragma to avoid such duplication. When a
	header file containing @samp{#pragma interface} is included in a
	compilation, this auxiliary information will not be generated (unless
	the main input source file itself uses @samp{#pragma implementation}).
	Instead, the object files will contain references to be resolved at link
	time.

	The second form of this directive is useful for the case where you have
	multiple headers with the same name in different directories. If you
	use this form, you must specify the same string to @samp{#pragma
	implementation}.

	@item #pragma implementation
	@itemx #pragma implementation "@var{objects}.h"
	@kindex #pragma implementation
	Use this pragma in a @emph{main input file}, when you want full output from
	included header files to be generated (and made globally visible). The
	included header file, in turn, should use @samp{#pragma interface}.
	Backup copies of inline member functions, debugging information, and the
	internal tables used to implement virtual functions are all generated in
	implementation files.

	@cindex implied @code{#pragma implementation}
	@cindex @code{#pragma implementation}, implied
	@cindex naming convention, implementation headers
	If you use @samp{#pragma implementation} with no argument, it applies to
	an include file with the same basename@footnote{A file's @dfn{basename}
	was the name stripped of all leading path information and of trailing
	suffixes, such as @samp{.h} or @samp{.C} or @samp{.cc}.} as your source
	file. For example, in @file{allclass.cc}, giving just
	@samp{#pragma implementation}
	by itself is equivalent to @samp{#pragma implementation "allclass.h"}.

	In versions of GNU C++ prior to 2.6.0 @file{allclass.h} was treated as
	an implementation file whenever you would include it from
	@file{allclass.cc} even if you never specified @samp{#pragma
	implementation}. This was deemed to be more trouble than it was worth,
	however, and disabled.

	Use the string argument if you want a single implementation file to
	include code from multiple header files. (You must also use
	@samp{#include} to include the header file; @samp{#pragma
	implementation} only specifies how to use the file---it doesn't actually
	include it.)

	There is no way to split up the contents of a single header file into
	multiple implementation files.
	@end table

	@cindex inlining and C++ pragmas
	@cindex C++ pragmas, effect on inlining
	@cindex pragmas in C++, effect on inlining
	@samp{#pragma implementation} and @samp{#pragma interface} also have an
	effect on function inlining.

	If you define a class in a header file marked with @samp{#pragma
	interface}, the effect on an inline function defined in that class is
	similar to an explicit @code{extern} declaration---the compiler emits
	no code at all to define an independent version of the function. Its
	definition is used only for inlining with its callers.

	@opindex fno-implement-inlines
	Conversely, when you include the same header file in a main source file
	that declares it as @samp{#pragma implementation}, the compiler emits
	code for the function itself; this defines a version of the function
	that can be found via pointers (or by callers compiled without
	inlining). If all calls to the function can be inlined, you can avoid
	emitting the function by compiling with @option{-fno-implement-inlines}.
	If any calls were not inlined, you will get linker errors.

	@node Template Instantiation
	@section Where's the Template?
	@cindex template instantiation

	C++ templates are the first language feature to require more
	intelligence from the environment than one usually finds on a UNIX
	system. Somehow the compiler and linker have to make sure that each
	template instance occurs exactly once in the executable if it is needed,
	and not at all otherwise. There are two basic approaches to this
	problem, which are referred to as the Borland model and the Cfront model.

	@table @asis
	@item Borland model
	Borland C++ solved the template instantiation problem by adding the code
	equivalent of common blocks to their linker; the compiler emits template
	instances in each translation unit that uses them, and the linker
	collapses them together. The advantage of this model is that the linker
	only has to consider the object files themselves; there is no external
	complexity to worry about. This disadvantage is that compilation time
	is increased because the template code is being compiled repeatedly.
	Code written for this model tends to include definitions of all
	templates in the header file, since they must be seen to be
	instantiated.

	@item Cfront model
	The AT&T C++ translator, Cfront, solved the template instantiation
	problem by creating the notion of a template repository, an
	automatically maintained place where template instances are stored. A
	more modern version of the repository works as follows: As individual
	object files are built, the compiler places any template definitions and
	instantiations encountered in the repository. At link time, the link
	wrapper adds in the objects in the repository and compiles any needed
	instances that were not previously emitted. The advantages of this
	model are more optimal compilation speed and the ability to use the
	system linker; to implement the Borland model a compiler vendor also
	needs to replace the linker. The disadvantages are vastly increased
	complexity, and thus potential for error; for some code this can be
	just as transparent, but in practice it can been very difficult to build
	multiple programs in one directory and one program in multiple
	directories. Code written for this model tends to separate definitions
	of non-inline member templates into a separate file, which should be
	compiled separately.
	@end table

	When used with GNU ld version 2.8 or later on an ELF system such as
	GNU/Linux or Solaris 2, or on Microsoft Windows, G++ supports the
	Borland model. On other systems, G++ implements neither automatic
	model.

	A future version of G++ will support a hybrid model whereby the compiler
	will emit any instantiations for which the template definition is
	included in the compile, and store template definitions and
	instantiation context information into the object file for the rest.
	The link wrapper will extract that information as necessary and invoke
	the compiler to produce the remaining instantiations. The linker will
	then combine duplicate instantiations.

	In the mean time, you have the following options for dealing with
	template instantiations:

	@enumerate
	@item
	@opindex frepo
	Compile your template-using code with @option{-frepo}. The compiler will
	generate files with the extension @samp{.rpo} listing all of the
	template instantiations used in the corresponding object files which
	could be instantiated there; the link wrapper, @samp{collect2}, will
	then update the @samp{.rpo} files to tell the compiler where to place
	those instantiations and rebuild any affected object files. The
	link-time overhead is negligible after the first pass, as the compiler
	will continue to place the instantiations in the same files.

	This is your best option for application code written for the Borland
	model, as it will just work. Code written for the Cfront model will
	need to be modified so that the template definitions are available at
	one or more points of instantiation; usually this is as simple as adding
	@code{#include <tmethods.cc>} to the end of each template header.

	For library code, if you want the library to provide all of the template
	instantiations it needs, just try to link all of its object files
	together; the link will fail, but cause the instantiations to be
	generated as a side effect. Be warned, however, that this may cause
	conflicts if multiple libraries try to provide the same instantiations.
	For greater control, use explicit instantiation as described in the next
	option.

	@item
	@opindex fno-implicit-templates
	Compile your code with @option{-fno-implicit-templates} to disable the
	implicit generation of template instances, and explicitly instantiate
	all the ones you use. This approach requires more knowledge of exactly
	which instances you need than do the others, but it's less
	mysterious and allows greater control. You can scatter the explicit
	instantiations throughout your program, perhaps putting them in the
	translation units where the instances are used or the translation units
	that define the templates themselves; you can put all of the explicit
	instantiations you need into one big file; or you can create small files
	like

	@smallexample
	#include "Foo.h"
	#include "Foo.cc"

	template class Foo<int>;
	template ostream& operator <<
	(ostream&, const Foo<int>&);
	@end smallexample

	for each of the instances you need, and create a template instantiation
	library from those.

	If you are using Cfront-model code, you can probably get away with not
	using @option{-fno-implicit-templates} when compiling files that don't
	@samp{#include} the member template definitions.

	If you use one big file to do the instantiations, you may want to
	compile it without @option{-fno-implicit-templates} so you get all of the
	instances required by your explicit instantiations (but not by any
	other files) without having to specify them as well.

	G++ has extended the template instantiation syntax given in the ISO
	standard to allow forward declaration of explicit instantiations
	(with @code{extern}), instantiation of the compiler support data for a
	template class (i.e.@: the vtable) without instantiating any of its
	members (with @code{inline}), and instantiation of only the static data
	members of a template class, without the support data or member
	functions (with (@code{static}):

	@smallexample
	extern template int max (int, int);
	inline template class Foo<int>;
	static template class Foo<int>;
	@end smallexample

	@item
	Do nothing. Pretend G++ does implement automatic instantiation
	management. Code written for the Borland model will work fine, but
	each translation unit will contain instances of each of the templates it
	uses. In a large program, this can lead to an unacceptable amount of code
	duplication.
	@end enumerate

	@node Bound member functions
	@section Extracting the function pointer from a bound pointer to member function
	@cindex pmf
	@cindex pointer to member function
	@cindex bound pointer to member function

	In C++, pointer to member functions (PMFs) are implemented using a wide
	pointer of sorts to handle all the possible call mechanisms; the PMF
	needs to store information about how to adjust the @samp{this} pointer,
	and if the function pointed to is virtual, where to find the vtable, and
	where in the vtable to look for the member function. If you are using
	PMFs in an inner loop, you should really reconsider that decision. If
	that is not an option, you can extract the pointer to the function that
	would be called for a given object/PMF pair and call it directly inside
	the inner loop, to save a bit of time.

	Note that you will still be paying the penalty for the call through a
	function pointer; on most modern architectures, such a call defeats the
	branch prediction features of the CPU@. This is also true of normal
	virtual function calls.

	The syntax for this extension is

	@smallexample
	extern A a;
	extern int (A::*fp)();
	typedef int (fptr)(A );

	fptr p = (fptr)(a.*fp);
	@end smallexample

	For PMF constants (i.e.@: expressions of the form @samp{&Klasse::Member}),
	no object is needed to obtain the address of the function. They can be
	converted to function pointers directly:

	@smallexample
	fptr p1 = (fptr)(&A::foo);
	@end smallexample

	@opindex Wno-pmf-conversions
	You must specify @option{-Wno-pmf-conversions} to use this extension.

	@node C++ Attributes
	@section C++-Specific Variable, Function, and Type Attributes

	Some attributes only make sense for C++ programs.

	@table @code
	@item init_priority (@var{priority})
	@cindex init_priority attribute


	In Standard C++, objects defined at namespace scope are guaranteed to be
	initialized in an order in strict accordance with that of their definitions
	@emph{in a given translation unit}. No guarantee is made for initializations
	across translation units. However, GNU C++ allows users to control the
	order of initialization of objects defined at namespace scope with the
	@code{init_priority} attribute by specifying a relative @var{priority},
	a constant integral expression currently bounded between 101 and 65535
	inclusive. Lower numbers indicate a higher priority.

	In the following example, @code{A} would normally be created before
	@code{B}, but the @code{init_priority} attribute has reversed that order:

	@smallexample
	Some_Class A __attribute__ ((init_priority (2000)));
	Some_Class B __attribute__ ((init_priority (543)));
	@end smallexample

	@noindent
	Note that the particular values of @var{priority} do not matter; only their
	relative ordering.

	@item java_interface
	@cindex java_interface attribute

	This type attribute informs C++ that the class is a Java interface. It may
	only be applied to classes declared within an @code{extern "Java"} block.
	Calls to methods declared in this interface will be dispatched using GCJ's
	interface table mechanism, instead of regular virtual table dispatch.

	@end table

	See also @xref{Namespace Association}.

	@node Namespace Association
	@section Namespace Association

	@strong{Caution:} The semantics of this extension are not fully
	defined. Users should refrain from using this extension as its
	semantics may change subtly over time. It is possible that this
	extension will be removed in future versions of G++.

	A using-directive with @code{__attribute ((strong))} is stronger
	than a normal using-directive in two ways:

	@itemize @bullet
	@item
	Templates from the used namespace can be specialized and explicitly
	instantiated as though they were members of the using namespace.

	@item
	The using namespace is considered an associated namespace of all
	templates in the used namespace for purposes of argument-dependent
	name lookup.
	@end itemize

	The used namespace must be nested within the using namespace so that
	normal unqualified lookup works properly.

	This is useful for composing a namespace transparently from
	implementation namespaces. For example:

	@smallexample
	namespace std @{
	namespace debug @{
	template <class T> struct A @{ @};
	@}
	using namespace debug __attribute ((__strong__));
	template <> struct A<int> @{ @}; // @r{ok to specialize}

	template <class T> void f (A<T>);
	@}

	int main()
	@{
	f (std::A<float>()); // @r{lookup finds} std::f
	f (std::A<int>());
	@}
	@end smallexample

	@node Java Exceptions
	@section Java Exceptions

	The Java language uses a slightly different exception handling model
	from C++. Normally, GNU C++ will automatically detect when you are
	writing C++ code that uses Java exceptions, and handle them
	appropriately. However, if C++ code only needs to execute destructors
	when Java exceptions are thrown through it, GCC will guess incorrectly.
	Sample problematic code is:

	@smallexample
	struct S @{ ~S(); @};
	extern void bar(); // @r{is written in Java, and may throw exceptions}
	void foo()
	@{
	S s;
	bar();
	@}
	@end smallexample

	@noindent
	The usual effect of an incorrect guess is a link failure, complaining of
	a missing routine called @samp{__gxx_personality_v0}.

	You can inform the compiler that Java exceptions are to be used in a
	translation unit, irrespective of what it might think, by writing
	@samp{@w{#pragma GCC java_exceptions}} at the head of the file. This
	@samp{#pragma} must appear before any functions that throw or catch
	exceptions, or run destructors when exceptions are thrown through them.

	You cannot mix Java and C++ exceptions in the same translation unit. It
	is believed to be safe to throw a C++ exception from one file through
	another file compiled for the Java exception model, or vice versa, but
	there may be bugs in this area.

	@node Deprecated Features
	@section Deprecated Features

	In the past, the GNU C++ compiler was extended to experiment with new
	features, at a time when the C++ language was still evolving. Now that
	the C++ standard is complete, some of those features are superseded by
	superior alternatives. Using the old features might cause a warning in
	some cases that the feature will be dropped in the future. In other
	cases, the feature might be gone already.

	While the list below is not exhaustive, it documents some of the options
	that are now deprecated:

	@table @code
	@item -fexternal-templates
	@itemx -falt-external-templates
	These are two of the many ways for G++ to implement template
	instantiation. @xref{Template Instantiation}. The C++ standard clearly
	defines how template definitions have to be organized across
	implementation units. G++ has an implicit instantiation mechanism that
	should work just fine for standard-conforming code.

	@item -fstrict-prototype
	@itemx -fno-strict-prototype
	Previously it was possible to use an empty prototype parameter list to
	indicate an unspecified number of parameters (like C), rather than no
	parameters, as C++ demands. This feature has been removed, except where
	it is required for backwards compatibility @xref{Backwards Compatibility}.
	@end table

	G++ allows a virtual function returning @samp{void *} to be overridden
	by one returning a different pointer type. This extension to the
	covariant return type rules is now deprecated and will be removed from a
	future version.

	The G++ minimum and maximum operators (@samp{<?} and @samp{>?}) and
	their compound forms (@samp{<?=}) and @samp{>?=}) have been deprecated
	and will be removed in a future version. Code using these operators
	should be modified to use @code{std::min} and @code{std::max} instead.

	The named return value extension has been deprecated, and is now
	removed from G++.

	The use of initializer lists with new expressions has been deprecated,
	and is now removed from G++.

	Floating and complex non-type template parameters have been deprecated,
	and are now removed from G++.

	The implicit typename extension has been deprecated and is now
	removed from G++.

	The use of default arguments in function pointers, function typedefs
	and other places where they are not permitted by the standard is
	deprecated and will be removed from a future version of G++.

	G++ allows floating-point literals to appear in integral constant expressions,
	e.g. @samp{ enum E @{ e = int(2.2 * 3.7) @} }
	This extension is deprecated and will be removed from a future version.

	G++ allows static data members of const floating-point type to be declared
	with an initializer in a class definition. The standard only allows
	initializers for static members of const integral types and const
	enumeration types so this extension has been deprecated and will be removed
	from a future version.

	@node Backwards Compatibility
	@section Backwards Compatibility
	@cindex Backwards Compatibility
	@cindex ARM [Annotated C++ Reference Manual]

	Now that there is a definitive ISO standard C++, G++ has a specification
	to adhere to. The C++ language evolved over time, and features that
	used to be acceptable in previous drafts of the standard, such as the ARM
	[Annotated C++ Reference Manual], are no longer accepted. In order to allow
	compilation of C++ written to such drafts, G++ contains some backwards
	compatibilities. @emph{All such backwards compatibility features are
	liable to disappear in future versions of G++.} They should be considered
	deprecated @xref{Deprecated Features}.

	@table @code
	@item For scope
	If a variable is declared at for scope, it used to remain in scope until
	the end of the scope which contained the for statement (rather than just
	within the for scope). G++ retains this, but issues a warning, if such a
	variable is accessed outside the for scope.

	@item Implicit C language
	Old C system header files did not contain an @code{extern "C" @{@dots{}@}}
	scope to set the language. On such systems, all header files are
	implicitly scoped inside a C language scope. Also, an empty prototype
	@code{()} will be treated as an unspecified number of arguments, rather
	than no arguments, as C++ demands.
	@end table
	diff --git a/contrib/gcc/dwarf2out.c b/contrib/gcc/dwarf2out.c
	index ad61de4f04fd..81fd0227f927 100644
	--- a/contrib/gcc/dwarf2out.c
	+++ b/contrib/gcc/dwarf2out.c
	@@ -1,14562 +1,14565 @@
	/* Output Dwarf2 format symbol table information from GCC.
	Copyright (C) 1992, 1993, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002,
	2003, 2004, 2005, 2006 Free Software Foundation, Inc.
	Contributed by Gary Funck (gary@intrepid.com).
	Derived from DWARF 1 implementation of Ron Guilmette (rfg@monkeys.com).
	Extensively modified by Jason Merrill (jason@cygnus.com).

	This file is part of GCC.

	GCC is free software; you can redistribute it and/or modify it under
	the terms of the GNU General Public License as published by the Free
	Software Foundation; either version 2, or (at your option) any later
	version.

	GCC is distributed in the hope that it will be useful, but WITHOUT ANY
	WARRANTY; without even the implied warranty of MERCHANTABILITY or
	FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	for more details.

	You should have received a copy of the GNU General Public License
	along with GCC; see the file COPYING. If not, write to the Free
	Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
	02110-1301, USA. */

	/* TODO: Emit .debug_line header even when there are no functions, since
	the file numbers are used by .debug_info. Alternately, leave
	out locations for types and decls.
	Avoid talking about ctors and op= for PODs.
	Factor out common prologue sequences into multiple CIEs. */

	/* The first part of this file deals with the DWARF 2 frame unwind
	information, which is also used by the GCC efficient exception handling
	mechanism. The second part, controlled only by an #ifdef
	DWARF2_DEBUGGING_INFO, deals with the other DWARF 2 debugging
	information. */

	#include "config.h"
	#include "system.h"
	#include "coretypes.h"
	#include "tm.h"
	#include "tree.h"
	#include "version.h"
	#include "flags.h"
	#include "real.h"
	#include "rtl.h"
	#include "hard-reg-set.h"
	#include "regs.h"
	#include "insn-config.h"
	#include "reload.h"
	#include "function.h"
	#include "output.h"
	#include "expr.h"
	#include "libfuncs.h"
	#include "except.h"
	#include "dwarf2.h"
	#include "dwarf2out.h"
	#include "dwarf2asm.h"
	#include "toplev.h"
	#include "varray.h"
	#include "ggc.h"
	#include "md5.h"
	#include "tm_p.h"
	#include "diagnostic.h"
	#include "debug.h"
	#include "target.h"
	#include "langhooks.h"
	#include "hashtab.h"
	#include "cgraph.h"
	#include "input.h"

	#ifdef DWARF2_DEBUGGING_INFO
	static void dwarf2out_source_line (unsigned int, const char *);
	#endif

	/* DWARF2 Abbreviation Glossary:
	CFA = Canonical Frame Address
	a fixed address on the stack which identifies a call frame.
	We define it to be the value of SP just before the call insn.
	The CFA register and offset, which may change during the course
	of the function, are used to calculate its value at runtime.
	CFI = Call Frame Instruction
	an instruction for the DWARF2 abstract machine
	CIE = Common Information Entry
	information describing information common to one or more FDEs
	DIE = Debugging Information Entry
	FDE = Frame Description Entry
	information describing the stack call frame, in particular,
	how to restore registers

	DW_CFA_... = DWARF2 CFA call frame instruction
	DW_TAG_... = DWARF2 DIE tag */

	#ifndef DWARF2_FRAME_INFO
	# ifdef DWARF2_DEBUGGING_INFO
	# define DWARF2_FRAME_INFO \
	(write_symbols == DWARF2_DEBUG \|\| write_symbols == VMS_AND_DWARF2_DEBUG)
	# else
	# define DWARF2_FRAME_INFO 0
	# endif
	#endif

	/* Map register numbers held in the call frame info that gcc has
	collected using DWARF_FRAME_REGNUM to those that should be output in
	.debug_frame and .eh_frame. */
	#ifndef DWARF2_FRAME_REG_OUT
	#define DWARF2_FRAME_REG_OUT(REGNO, FOR_EH) (REGNO)
	#endif

	/* Decide whether we want to emit frame unwind information for the current
	translation unit. */

	int
	dwarf2out_do_frame (void)
	{
	/* We want to emit correct CFA location expressions or lists, so we
	have to return true if we're going to output debug info, even if
	we're not going to output frame or unwind info. */
	return (write_symbols == DWARF2_DEBUG
	\|\| write_symbols == VMS_AND_DWARF2_DEBUG
	\|\| DWARF2_FRAME_INFO
	#ifdef DWARF2_UNWIND_INFO
	\|\| (DWARF2_UNWIND_INFO
	&& (flag_unwind_tables
	\|\| (flag_exceptions && ! USING_SJLJ_EXCEPTIONS)))
	#endif
	);
	}

	/* The size of the target's pointer type. */
	#ifndef PTR_SIZE
	#define PTR_SIZE (POINTER_SIZE / BITS_PER_UNIT)
	#endif

	/* Array of RTXes referenced by the debugging information, which therefore
	must be kept around forever. */
	static GTY(()) VEC(rtx,gc) *used_rtx_array;

	/* A pointer to the base of a list of incomplete types which might be
	completed at some later time. incomplete_types_list needs to be a
	VEC(tree,gc) because we want to tell the garbage collector about
	it. */
	static GTY(()) VEC(tree,gc) *incomplete_types;

	/* A pointer to the base of a table of references to declaration
	scopes. This table is a display which tracks the nesting
	of declaration scopes at the current scope and containing
	scopes. This table is used to find the proper place to
	define type declaration DIE's. */
	static GTY(()) VEC(tree,gc) *decl_scope_table;

	/* Pointers to various DWARF2 sections. */
	static GTY(()) section *debug_info_section;
	static GTY(()) section *debug_abbrev_section;
	static GTY(()) section *debug_aranges_section;
	static GTY(()) section *debug_macinfo_section;
	static GTY(()) section *debug_line_section;
	static GTY(()) section *debug_loc_section;
	static GTY(()) section *debug_pubnames_section;
	static GTY(()) section *debug_pubtypes_section;
	static GTY(()) section *debug_str_section;
	static GTY(()) section *debug_ranges_section;
	static GTY(()) section *debug_frame_section;

	/* How to start an assembler comment. */
	#ifndef ASM_COMMENT_START
	#define ASM_COMMENT_START ";#"
	#endif

	typedef struct dw_cfi_struct *dw_cfi_ref;
	typedef struct dw_fde_struct *dw_fde_ref;
	typedef union dw_cfi_oprnd_struct *dw_cfi_oprnd_ref;

	/* Call frames are described using a sequence of Call Frame
	Information instructions. The register number, offset
	and address fields are provided as possible operands;
	their use is selected by the opcode field. */

	enum dw_cfi_oprnd_type {
	dw_cfi_oprnd_unused,
	dw_cfi_oprnd_reg_num,
	dw_cfi_oprnd_offset,
	dw_cfi_oprnd_addr,
	dw_cfi_oprnd_loc
	};

	typedef union dw_cfi_oprnd_struct GTY(())
	{
	unsigned int GTY ((tag ("dw_cfi_oprnd_reg_num"))) dw_cfi_reg_num;
	HOST_WIDE_INT GTY ((tag ("dw_cfi_oprnd_offset"))) dw_cfi_offset;
	const char * GTY ((tag ("dw_cfi_oprnd_addr"))) dw_cfi_addr;
	struct dw_loc_descr_struct * GTY ((tag ("dw_cfi_oprnd_loc"))) dw_cfi_loc;
	}
	dw_cfi_oprnd;

	typedef struct dw_cfi_struct GTY(())
	{
	dw_cfi_ref dw_cfi_next;
	enum dwarf_call_frame_info dw_cfi_opc;
	dw_cfi_oprnd GTY ((desc ("dw_cfi_oprnd1_desc (%1.dw_cfi_opc)")))
	dw_cfi_oprnd1;
	dw_cfi_oprnd GTY ((desc ("dw_cfi_oprnd2_desc (%1.dw_cfi_opc)")))
	dw_cfi_oprnd2;
	}
	dw_cfi_node;

	/* This is how we define the location of the CFA. We use to handle it
	as REG + OFFSET all the time, but now it can be more complex.
	It can now be either REG + CFA_OFFSET or *(REG + BASE_OFFSET) + CFA_OFFSET.
	Instead of passing around REG and OFFSET, we pass a copy
	of this structure. */
	typedef struct cfa_loc GTY(())
	{
	HOST_WIDE_INT offset;
	HOST_WIDE_INT base_offset;
	unsigned int reg;
	int indirect; /* 1 if CFA is accessed via a dereference. */
	} dw_cfa_location;

	/* All call frame descriptions (FDE's) in the GCC generated DWARF
	refer to a single Common Information Entry (CIE), defined at
	the beginning of the .debug_frame section. This use of a single
	CIE obviates the need to keep track of multiple CIE's
	in the DWARF generation routines below. */

	typedef struct dw_fde_struct GTY(())
	{
	tree decl;
	const char *dw_fde_begin;
	const char *dw_fde_current_label;
	const char *dw_fde_end;
	const char *dw_fde_hot_section_label;
	const char *dw_fde_hot_section_end_label;
	const char *dw_fde_unlikely_section_label;
	const char *dw_fde_unlikely_section_end_label;
	bool dw_fde_switched_sections;
	dw_cfi_ref dw_fde_cfi;
	unsigned funcdef_number;
	unsigned all_throwers_are_sibcalls : 1;
	unsigned nothrow : 1;
	unsigned uses_eh_lsda : 1;
	}
	dw_fde_node;

	/* Maximum size (in bytes) of an artificially generated label. */
	#define MAX_ARTIFICIAL_LABEL_BYTES 30

	/* The size of addresses as they appear in the Dwarf 2 data.
	Some architectures use word addresses to refer to code locations,
	but Dwarf 2 info always uses byte addresses. On such machines,
	Dwarf 2 addresses need to be larger than the architecture's
	pointers. */
	#ifndef DWARF2_ADDR_SIZE
	#define DWARF2_ADDR_SIZE (POINTER_SIZE / BITS_PER_UNIT)
	#endif

	/* The size in bytes of a DWARF field indicating an offset or length
	relative to a debug info section, specified to be 4 bytes in the
	DWARF-2 specification. The SGI/MIPS ABI defines it to be the same
	as PTR_SIZE. */

	#ifndef DWARF_OFFSET_SIZE
	#define DWARF_OFFSET_SIZE 4
	#endif

	/* According to the (draft) DWARF 3 specification, the initial length
	should either be 4 or 12 bytes. When it's 12 bytes, the first 4
	bytes are 0xffffffff, followed by the length stored in the next 8
	bytes.

	However, the SGI/MIPS ABI uses an initial length which is equal to
	DWARF_OFFSET_SIZE. It is defined (elsewhere) accordingly. */

	#ifndef DWARF_INITIAL_LENGTH_SIZE
	#define DWARF_INITIAL_LENGTH_SIZE (DWARF_OFFSET_SIZE == 4 ? 4 : 12)
	#endif

	#define DWARF_VERSION 2

	/* Round SIZE up to the nearest BOUNDARY. */
	#define DWARF_ROUND(SIZE,BOUNDARY) \
	((((SIZE) + (BOUNDARY) - 1) / (BOUNDARY)) * (BOUNDARY))

	/* Offsets recorded in opcodes are a multiple of this alignment factor. */
	#ifndef DWARF_CIE_DATA_ALIGNMENT
	#ifdef STACK_GROWS_DOWNWARD
	#define DWARF_CIE_DATA_ALIGNMENT (-((int) UNITS_PER_WORD))
	#else
	#define DWARF_CIE_DATA_ALIGNMENT ((int) UNITS_PER_WORD)
	#endif
	#endif

	/* CIE identifier. */
	#if HOST_BITS_PER_WIDE_INT >= 64
	#define DWARF_CIE_ID \
	(unsigned HOST_WIDE_INT) (DWARF_OFFSET_SIZE == 4 ? DW_CIE_ID : DW64_CIE_ID)
	#else
	#define DWARF_CIE_ID DW_CIE_ID
	#endif

	/* A pointer to the base of a table that contains frame description
	information for each routine. */
	static GTY((length ("fde_table_allocated"))) dw_fde_ref fde_table;

	/* Number of elements currently allocated for fde_table. */
	static GTY(()) unsigned fde_table_allocated;

	/* Number of elements in fde_table currently in use. */
	static GTY(()) unsigned fde_table_in_use;

	/* Size (in elements) of increments by which we may expand the
	fde_table. */
	#define FDE_TABLE_INCREMENT 256

	/* A list of call frame insns for the CIE. */
	static GTY(()) dw_cfi_ref cie_cfi_head;

	#if defined (DWARF2_DEBUGGING_INFO) \|\| defined (DWARF2_UNWIND_INFO)
	/* Some DWARF extensions (e.g., MIPS/SGI) implement a subprogram
	attribute that accelerates the lookup of the FDE associated
	with the subprogram. This variable holds the table index of the FDE
	associated with the current function (body) definition. */
	static unsigned current_funcdef_fde;
	#endif

	struct indirect_string_node GTY(())
	{
	const char *str;
	unsigned int refcount;
	unsigned int form;
	char *label;
	};

	static GTY ((param_is (struct indirect_string_node))) htab_t debug_str_hash;

	static GTY(()) int dw2_string_counter;
	static GTY(()) unsigned long dwarf2out_cfi_label_num;

	#if defined (DWARF2_DEBUGGING_INFO) \|\| defined (DWARF2_UNWIND_INFO)

	/* Forward declarations for functions defined in this file. */

	static char stripattributes (const char );
	static const char *dwarf_cfi_name (unsigned);
	static dw_cfi_ref new_cfi (void);
	static void add_cfi (dw_cfi_ref *, dw_cfi_ref);
	static void add_fde_cfi (const char *, dw_cfi_ref);
	static void lookup_cfa_1 (dw_cfi_ref, dw_cfa_location *);
	static void lookup_cfa (dw_cfa_location *);
	static void reg_save (const char *, unsigned, unsigned, HOST_WIDE_INT);
	static void initial_return_save (rtx);
	static HOST_WIDE_INT stack_adjust_offset (rtx);
	static void output_cfi (dw_cfi_ref, dw_fde_ref, int);
	static void output_call_frame_info (int);
	static void dwarf2out_stack_adjust (rtx, bool);
	static void flush_queued_reg_saves (void);
	static bool clobbers_queued_reg_save (rtx);
	static void dwarf2out_frame_debug_expr (rtx, const char *);

	/* Support for complex CFA locations. */
	static void output_cfa_loc (dw_cfi_ref);
	static void get_cfa_from_loc_descr (dw_cfa_location *,
	struct dw_loc_descr_struct *);
	static struct dw_loc_descr_struct *build_cfa_loc
	(dw_cfa_location *, HOST_WIDE_INT);
	static void def_cfa_1 (const char , dw_cfa_location );

	/* How to start an assembler comment. */
	#ifndef ASM_COMMENT_START
	#define ASM_COMMENT_START ";#"
	#endif

	/* Data and reference forms for relocatable data. */
	#define DW_FORM_data (DWARF_OFFSET_SIZE == 8 ? DW_FORM_data8 : DW_FORM_data4)
	#define DW_FORM_ref (DWARF_OFFSET_SIZE == 8 ? DW_FORM_ref8 : DW_FORM_ref4)

	#ifndef DEBUG_FRAME_SECTION
	#define DEBUG_FRAME_SECTION ".debug_frame"
	#endif

	#ifndef FUNC_BEGIN_LABEL
	#define FUNC_BEGIN_LABEL "LFB"
	#endif

	#ifndef FUNC_END_LABEL
	#define FUNC_END_LABEL "LFE"
	#endif

	#ifndef FRAME_BEGIN_LABEL
	#define FRAME_BEGIN_LABEL "Lframe"
	#endif
	#define CIE_AFTER_SIZE_LABEL "LSCIE"
	#define CIE_END_LABEL "LECIE"
	#define FDE_LABEL "LSFDE"
	#define FDE_AFTER_SIZE_LABEL "LASFDE"
	#define FDE_END_LABEL "LEFDE"
	#define LINE_NUMBER_BEGIN_LABEL "LSLT"
	#define LINE_NUMBER_END_LABEL "LELT"
	#define LN_PROLOG_AS_LABEL "LASLTP"
	#define LN_PROLOG_END_LABEL "LELTP"
	#define DIE_LABEL_PREFIX "DW"

	/* The DWARF 2 CFA column which tracks the return address. Normally this
	is the column for PC, or the first column after all of the hard
	registers. */
	#ifndef DWARF_FRAME_RETURN_COLUMN
	#ifdef PC_REGNUM
	#define DWARF_FRAME_RETURN_COLUMN DWARF_FRAME_REGNUM (PC_REGNUM)
	#else
	#define DWARF_FRAME_RETURN_COLUMN DWARF_FRAME_REGISTERS
	#endif
	#endif

	/* The mapping from gcc register number to DWARF 2 CFA column number. By
	default, we just provide columns for all registers. */
	#ifndef DWARF_FRAME_REGNUM
	#define DWARF_FRAME_REGNUM(REG) DBX_REGISTER_NUMBER (REG)
	#endif

	/* Hook used by __throw. */

	rtx
	expand_builtin_dwarf_sp_column (void)
	{
	unsigned int dwarf_regnum = DWARF_FRAME_REGNUM (STACK_POINTER_REGNUM);
	return GEN_INT (DWARF2_FRAME_REG_OUT (dwarf_regnum, 1));
	}

	/* Return a pointer to a copy of the section string name S with all
	attributes stripped off, and an asterisk prepended (for assemble_name). */

	static inline char *
	stripattributes (const char *s)
	{
	char *stripped = XNEWVEC (char, strlen (s) + 2);
	char *p = stripped;

	p++ = '';

	while (s && s != ',')
	p++ = s++;

	*p = '\0';
	return stripped;
	}

	/* Generate code to initialize the register size table. */

	void
	expand_builtin_init_dwarf_reg_sizes (tree address)
	{
	unsigned int i;
	enum machine_mode mode = TYPE_MODE (char_type_node);
	rtx addr = expand_normal (address);
	rtx mem = gen_rtx_MEM (BLKmode, addr);
	bool wrote_return_column = false;

	for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
	{
	int rnum = DWARF2_FRAME_REG_OUT (DWARF_FRAME_REGNUM (i), 1);

	if (rnum < DWARF_FRAME_REGISTERS)
	{
	HOST_WIDE_INT offset = rnum * GET_MODE_SIZE (mode);
	enum machine_mode save_mode = reg_raw_mode[i];
	HOST_WIDE_INT size;

	if (HARD_REGNO_CALL_PART_CLOBBERED (i, save_mode))
	save_mode = choose_hard_reg_mode (i, 1, true);
	if (DWARF_FRAME_REGNUM (i) == DWARF_FRAME_RETURN_COLUMN)
	{
	if (save_mode == VOIDmode)
	continue;
	wrote_return_column = true;
	}
	size = GET_MODE_SIZE (save_mode);
	if (offset < 0)
	continue;

	emit_move_insn (adjust_address (mem, mode, offset),
	gen_int_mode (size, mode));
	}
	}

	#ifdef DWARF_ALT_FRAME_RETURN_COLUMN
	gcc_assert (wrote_return_column);
	i = DWARF_ALT_FRAME_RETURN_COLUMN;
	wrote_return_column = false;
	#else
	i = DWARF_FRAME_RETURN_COLUMN;
	#endif

	if (! wrote_return_column)
	{
	enum machine_mode save_mode = Pmode;
	HOST_WIDE_INT offset = i * GET_MODE_SIZE (mode);
	HOST_WIDE_INT size = GET_MODE_SIZE (save_mode);
	emit_move_insn (adjust_address (mem, mode, offset), GEN_INT (size));
	}
	}

	/* Convert a DWARF call frame info. operation to its string name */

	static const char *
	dwarf_cfi_name (unsigned int cfi_opc)
	{
	switch (cfi_opc)
	{
	case DW_CFA_advance_loc:
	return "DW_CFA_advance_loc";
	case DW_CFA_offset:
	return "DW_CFA_offset";
	case DW_CFA_restore:
	return "DW_CFA_restore";
	case DW_CFA_nop:
	return "DW_CFA_nop";
	case DW_CFA_set_loc:
	return "DW_CFA_set_loc";
	case DW_CFA_advance_loc1:
	return "DW_CFA_advance_loc1";
	case DW_CFA_advance_loc2:
	return "DW_CFA_advance_loc2";
	case DW_CFA_advance_loc4:
	return "DW_CFA_advance_loc4";
	case DW_CFA_offset_extended:
	return "DW_CFA_offset_extended";
	case DW_CFA_restore_extended:
	return "DW_CFA_restore_extended";
	case DW_CFA_undefined:
	return "DW_CFA_undefined";
	case DW_CFA_same_value:
	return "DW_CFA_same_value";
	case DW_CFA_register:
	return "DW_CFA_register";
	case DW_CFA_remember_state:
	return "DW_CFA_remember_state";
	case DW_CFA_restore_state:
	return "DW_CFA_restore_state";
	case DW_CFA_def_cfa:
	return "DW_CFA_def_cfa";
	case DW_CFA_def_cfa_register:
	return "DW_CFA_def_cfa_register";
	case DW_CFA_def_cfa_offset:
	return "DW_CFA_def_cfa_offset";

	/* DWARF 3 */
	case DW_CFA_def_cfa_expression:
	return "DW_CFA_def_cfa_expression";
	case DW_CFA_expression:
	return "DW_CFA_expression";
	case DW_CFA_offset_extended_sf:
	return "DW_CFA_offset_extended_sf";
	case DW_CFA_def_cfa_sf:
	return "DW_CFA_def_cfa_sf";
	case DW_CFA_def_cfa_offset_sf:
	return "DW_CFA_def_cfa_offset_sf";

	/* SGI/MIPS specific */
	case DW_CFA_MIPS_advance_loc8:
	return "DW_CFA_MIPS_advance_loc8";

	/* GNU extensions */
	case DW_CFA_GNU_window_save:
	return "DW_CFA_GNU_window_save";
	case DW_CFA_GNU_args_size:
	return "DW_CFA_GNU_args_size";
	case DW_CFA_GNU_negative_offset_extended:
	return "DW_CFA_GNU_negative_offset_extended";

	default:
	return "DW_CFA_<unknown>";
	}
	}

	/* Return a pointer to a newly allocated Call Frame Instruction. */

	static inline dw_cfi_ref
	new_cfi (void)
	{
	dw_cfi_ref cfi = ggc_alloc (sizeof (dw_cfi_node));

	cfi->dw_cfi_next = NULL;
	cfi->dw_cfi_oprnd1.dw_cfi_reg_num = 0;
	cfi->dw_cfi_oprnd2.dw_cfi_reg_num = 0;

	return cfi;
	}

	/* Add a Call Frame Instruction to list of instructions. */

	static inline void
	add_cfi (dw_cfi_ref *list_head, dw_cfi_ref cfi)
	{
	dw_cfi_ref *p;

	/* Find the end of the chain. */
	for (p = list_head; (p) != NULL; p = &(p)->dw_cfi_next)
	;

	*p = cfi;
	}

	/* Generate a new label for the CFI info to refer to. */

	char *
	dwarf2out_cfi_label (void)
	{
	static char label[20];

	ASM_GENERATE_INTERNAL_LABEL (label, "LCFI", dwarf2out_cfi_label_num++);
	ASM_OUTPUT_LABEL (asm_out_file, label);
	return label;
	}

	/* Add CFI to the current fde at the PC value indicated by LABEL if specified,
	or to the CIE if LABEL is NULL. */

	static void
	add_fde_cfi (const char *label, dw_cfi_ref cfi)
	{
	if (label)
	{
	dw_fde_ref fde = &fde_table[fde_table_in_use - 1];

	if (*label == 0)
	label = dwarf2out_cfi_label ();

	if (fde->dw_fde_current_label == NULL
	\|\| strcmp (label, fde->dw_fde_current_label) != 0)
	{
	dw_cfi_ref xcfi;

	label = xstrdup (label);

	/* Set the location counter to the new label. */
	xcfi = new_cfi ();
	/* If we have a current label, advance from there, otherwise
	set the location directly using set_loc. */
	xcfi->dw_cfi_opc = fde->dw_fde_current_label
	? DW_CFA_advance_loc4
	: DW_CFA_set_loc;
	xcfi->dw_cfi_oprnd1.dw_cfi_addr = label;
	add_cfi (&fde->dw_fde_cfi, xcfi);

	fde->dw_fde_current_label = label;
	}

	add_cfi (&fde->dw_fde_cfi, cfi);
	}

	else
	add_cfi (&cie_cfi_head, cfi);
	}

	/* Subroutine of lookup_cfa. */

	static void
	lookup_cfa_1 (dw_cfi_ref cfi, dw_cfa_location *loc)
	{
	switch (cfi->dw_cfi_opc)
	{
	case DW_CFA_def_cfa_offset:
	loc->offset = cfi->dw_cfi_oprnd1.dw_cfi_offset;
	break;
	case DW_CFA_def_cfa_offset_sf:
	loc->offset
	= cfi->dw_cfi_oprnd1.dw_cfi_offset * DWARF_CIE_DATA_ALIGNMENT;
	break;
	case DW_CFA_def_cfa_register:
	loc->reg = cfi->dw_cfi_oprnd1.dw_cfi_reg_num;
	break;
	case DW_CFA_def_cfa:
	loc->reg = cfi->dw_cfi_oprnd1.dw_cfi_reg_num;
	loc->offset = cfi->dw_cfi_oprnd2.dw_cfi_offset;
	break;
	case DW_CFA_def_cfa_sf:
	loc->reg = cfi->dw_cfi_oprnd1.dw_cfi_reg_num;
	loc->offset
	= cfi->dw_cfi_oprnd2.dw_cfi_offset * DWARF_CIE_DATA_ALIGNMENT;
	break;
	case DW_CFA_def_cfa_expression:
	get_cfa_from_loc_descr (loc, cfi->dw_cfi_oprnd1.dw_cfi_loc);
	break;
	default:
	break;
	}
	}

	/* Find the previous value for the CFA. */

	static void
	lookup_cfa (dw_cfa_location *loc)
	{
	dw_cfi_ref cfi;

	loc->reg = INVALID_REGNUM;
	loc->offset = 0;
	loc->indirect = 0;
	loc->base_offset = 0;

	for (cfi = cie_cfi_head; cfi; cfi = cfi->dw_cfi_next)
	lookup_cfa_1 (cfi, loc);

	if (fde_table_in_use)
	{
	dw_fde_ref fde = &fde_table[fde_table_in_use - 1];
	for (cfi = fde->dw_fde_cfi; cfi; cfi = cfi->dw_cfi_next)
	lookup_cfa_1 (cfi, loc);
	}
	}

	/* The current rule for calculating the DWARF2 canonical frame address. */
	static dw_cfa_location cfa;

	/* The register used for saving registers to the stack, and its offset
	from the CFA. */
	static dw_cfa_location cfa_store;

	/* The running total of the size of arguments pushed onto the stack. */
	static HOST_WIDE_INT args_size;

	/* The last args_size we actually output. */
	static HOST_WIDE_INT old_args_size;

	/* Entry point to update the canonical frame address (CFA).
	LABEL is passed to add_fde_cfi. The value of CFA is now to be
	calculated from REG+OFFSET. */

	void
	dwarf2out_def_cfa (const char *label, unsigned int reg, HOST_WIDE_INT offset)
	{
	dw_cfa_location loc;
	loc.indirect = 0;
	loc.base_offset = 0;
	loc.reg = reg;
	loc.offset = offset;
	def_cfa_1 (label, &loc);
	}

	/* Determine if two dw_cfa_location structures define the same data. */

	static bool
	cfa_equal_p (const dw_cfa_location loc1, const dw_cfa_location loc2)
	{
	return (loc1->reg == loc2->reg
	&& loc1->offset == loc2->offset
	&& loc1->indirect == loc2->indirect
	&& (loc1->indirect == 0
	\|\| loc1->base_offset == loc2->base_offset));
	}

	/* This routine does the actual work. The CFA is now calculated from
	the dw_cfa_location structure. */

	static void
	def_cfa_1 (const char label, dw_cfa_location loc_p)
	{
	dw_cfi_ref cfi;
	dw_cfa_location old_cfa, loc;

	cfa = *loc_p;
	loc = *loc_p;

	if (cfa_store.reg == loc.reg && loc.indirect == 0)
	cfa_store.offset = loc.offset;

	loc.reg = DWARF_FRAME_REGNUM (loc.reg);
	lookup_cfa (&old_cfa);

	/* If nothing changed, no need to issue any call frame instructions. */
	if (cfa_equal_p (&loc, &old_cfa))
	return;

	cfi = new_cfi ();

	if (loc.reg == old_cfa.reg && !loc.indirect)
	{
	/* Construct a "DW_CFA_def_cfa_offset <offset>" instruction, indicating
	the CFA register did not change but the offset did. */
	if (loc.offset < 0)
	{
	HOST_WIDE_INT f_offset = loc.offset / DWARF_CIE_DATA_ALIGNMENT;
	gcc_assert (f_offset * DWARF_CIE_DATA_ALIGNMENT == loc.offset);

	cfi->dw_cfi_opc = DW_CFA_def_cfa_offset_sf;
	cfi->dw_cfi_oprnd1.dw_cfi_offset = f_offset;
	}
	else
	{
	cfi->dw_cfi_opc = DW_CFA_def_cfa_offset;
	cfi->dw_cfi_oprnd1.dw_cfi_offset = loc.offset;
	}
	}

	#ifndef MIPS_DEBUGGING_INFO /* SGI dbx thinks this means no offset. */
	else if (loc.offset == old_cfa.offset
	&& old_cfa.reg != INVALID_REGNUM
	&& !loc.indirect)
	{
	/* Construct a "DW_CFA_def_cfa_register <register>" instruction,
	indicating the CFA register has changed to <register> but the
	offset has not changed. */
	cfi->dw_cfi_opc = DW_CFA_def_cfa_register;
	cfi->dw_cfi_oprnd1.dw_cfi_reg_num = loc.reg;
	}
	#endif

	else if (loc.indirect == 0)
	{
	/* Construct a "DW_CFA_def_cfa <register> <offset>" instruction,
	indicating the CFA register has changed to <register> with
	the specified offset. */
	if (loc.offset < 0)
	{
	HOST_WIDE_INT f_offset = loc.offset / DWARF_CIE_DATA_ALIGNMENT;
	gcc_assert (f_offset * DWARF_CIE_DATA_ALIGNMENT == loc.offset);

	cfi->dw_cfi_opc = DW_CFA_def_cfa_sf;
	cfi->dw_cfi_oprnd1.dw_cfi_reg_num = loc.reg;
	cfi->dw_cfi_oprnd2.dw_cfi_offset = f_offset;
	}
	else
	{
	cfi->dw_cfi_opc = DW_CFA_def_cfa;
	cfi->dw_cfi_oprnd1.dw_cfi_reg_num = loc.reg;
	cfi->dw_cfi_oprnd2.dw_cfi_offset = loc.offset;
	}
	}
	else
	{
	/* Construct a DW_CFA_def_cfa_expression instruction to
	calculate the CFA using a full location expression since no
	register-offset pair is available. */
	struct dw_loc_descr_struct *loc_list;

	cfi->dw_cfi_opc = DW_CFA_def_cfa_expression;
	loc_list = build_cfa_loc (&loc, 0);
	cfi->dw_cfi_oprnd1.dw_cfi_loc = loc_list;
	}

	add_fde_cfi (label, cfi);
	}

	/* Add the CFI for saving a register. REG is the CFA column number.
	LABEL is passed to add_fde_cfi.
	If SREG is -1, the register is saved at OFFSET from the CFA;
	otherwise it is saved in SREG. */

	static void
	reg_save (const char *label, unsigned int reg, unsigned int sreg, HOST_WIDE_INT offset)
	{
	dw_cfi_ref cfi = new_cfi ();

	cfi->dw_cfi_oprnd1.dw_cfi_reg_num = reg;

	if (sreg == INVALID_REGNUM)
	{
	if (reg & ~0x3f)
	/* The register number won't fit in 6 bits, so we have to use
	the long form. */
	cfi->dw_cfi_opc = DW_CFA_offset_extended;
	else
	cfi->dw_cfi_opc = DW_CFA_offset;

	#ifdef ENABLE_CHECKING
	{
	/* If we get an offset that is not a multiple of
	DWARF_CIE_DATA_ALIGNMENT, there is either a bug in the
	definition of DWARF_CIE_DATA_ALIGNMENT, or a bug in the machine
	description. */
	HOST_WIDE_INT check_offset = offset / DWARF_CIE_DATA_ALIGNMENT;

	gcc_assert (check_offset * DWARF_CIE_DATA_ALIGNMENT == offset);
	}
	#endif
	offset /= DWARF_CIE_DATA_ALIGNMENT;
	if (offset < 0)
	cfi->dw_cfi_opc = DW_CFA_offset_extended_sf;

	cfi->dw_cfi_oprnd2.dw_cfi_offset = offset;
	}
	else if (sreg == reg)
	cfi->dw_cfi_opc = DW_CFA_same_value;
	else
	{
	cfi->dw_cfi_opc = DW_CFA_register;
	cfi->dw_cfi_oprnd2.dw_cfi_reg_num = sreg;
	}

	add_fde_cfi (label, cfi);
	}

	/* Add the CFI for saving a register window. LABEL is passed to reg_save.
	This CFI tells the unwinder that it needs to restore the window registers
	from the previous frame's window save area.

	??? Perhaps we should note in the CIE where windows are saved (instead of
	assuming 0(cfa)) and what registers are in the window. */

	void
	dwarf2out_window_save (const char *label)
	{
	dw_cfi_ref cfi = new_cfi ();

	cfi->dw_cfi_opc = DW_CFA_GNU_window_save;
	add_fde_cfi (label, cfi);
	}

	/* Add a CFI to update the running total of the size of arguments
	pushed onto the stack. */

	void
	dwarf2out_args_size (const char *label, HOST_WIDE_INT size)
	{
	dw_cfi_ref cfi;

	if (size == old_args_size)
	return;

	old_args_size = size;

	cfi = new_cfi ();
	cfi->dw_cfi_opc = DW_CFA_GNU_args_size;
	cfi->dw_cfi_oprnd1.dw_cfi_offset = size;
	add_fde_cfi (label, cfi);
	}

	/* Entry point for saving a register to the stack. REG is the GCC register
	number. LABEL and OFFSET are passed to reg_save. */

	void
	dwarf2out_reg_save (const char *label, unsigned int reg, HOST_WIDE_INT offset)
	{
	reg_save (label, DWARF_FRAME_REGNUM (reg), INVALID_REGNUM, offset);
	}

	/* Entry point for saving the return address in the stack.
	LABEL and OFFSET are passed to reg_save. */

	void
	dwarf2out_return_save (const char *label, HOST_WIDE_INT offset)
	{
	reg_save (label, DWARF_FRAME_RETURN_COLUMN, INVALID_REGNUM, offset);
	}

	/* Entry point for saving the return address in a register.
	LABEL and SREG are passed to reg_save. */

	void
	dwarf2out_return_reg (const char *label, unsigned int sreg)
	{
	reg_save (label, DWARF_FRAME_RETURN_COLUMN, DWARF_FRAME_REGNUM (sreg), 0);
	}

	/* Record the initial position of the return address. RTL is
	INCOMING_RETURN_ADDR_RTX. */

	static void
	initial_return_save (rtx rtl)
	{
	unsigned int reg = INVALID_REGNUM;
	HOST_WIDE_INT offset = 0;

	switch (GET_CODE (rtl))
	{
	case REG:
	/* RA is in a register. */
	reg = DWARF_FRAME_REGNUM (REGNO (rtl));
	break;

	case MEM:
	/* RA is on the stack. */
	rtl = XEXP (rtl, 0);
	switch (GET_CODE (rtl))
	{
	case REG:
	gcc_assert (REGNO (rtl) == STACK_POINTER_REGNUM);
	offset = 0;
	break;

	case PLUS:
	gcc_assert (REGNO (XEXP (rtl, 0)) == STACK_POINTER_REGNUM);
	offset = INTVAL (XEXP (rtl, 1));
	break;

	case MINUS:
	gcc_assert (REGNO (XEXP (rtl, 0)) == STACK_POINTER_REGNUM);
	offset = -INTVAL (XEXP (rtl, 1));
	break;

	default:
	gcc_unreachable ();
	}

	break;

	case PLUS:
	/* The return address is at some offset from any value we can
	actually load. For instance, on the SPARC it is in %i7+8. Just
	ignore the offset for now; it doesn't matter for unwinding frames. */
	gcc_assert (GET_CODE (XEXP (rtl, 1)) == CONST_INT);
	initial_return_save (XEXP (rtl, 0));
	return;

	default:
	gcc_unreachable ();
	}

	if (reg != DWARF_FRAME_RETURN_COLUMN)
	reg_save (NULL, DWARF_FRAME_RETURN_COLUMN, reg, offset - cfa.offset);
	}

	/* Given a SET, calculate the amount of stack adjustment it
	contains. */

	static HOST_WIDE_INT
	stack_adjust_offset (rtx pattern)
	{
	rtx src = SET_SRC (pattern);
	rtx dest = SET_DEST (pattern);
	HOST_WIDE_INT offset = 0;
	enum rtx_code code;

	if (dest == stack_pointer_rtx)
	{
	/* (set (reg sp) (plus (reg sp) (const_int))) */
	code = GET_CODE (src);
	if (! (code == PLUS \|\| code == MINUS)
	\|\| XEXP (src, 0) != stack_pointer_rtx
	\|\| GET_CODE (XEXP (src, 1)) != CONST_INT)
	return 0;

	offset = INTVAL (XEXP (src, 1));
	if (code == PLUS)
	offset = -offset;
	}
	else if (MEM_P (dest))
	{
	/* (set (mem (pre_dec (reg sp))) (foo)) */
	src = XEXP (dest, 0);
	code = GET_CODE (src);

	switch (code)
	{
	case PRE_MODIFY:
	case POST_MODIFY:
	if (XEXP (src, 0) == stack_pointer_rtx)
	{
	rtx val = XEXP (XEXP (src, 1), 1);
	/* We handle only adjustments by constant amount. */
	gcc_assert (GET_CODE (XEXP (src, 1)) == PLUS
	&& GET_CODE (val) == CONST_INT);
	offset = -INTVAL (val);
	break;
	}
	return 0;

	case PRE_DEC:
	case POST_DEC:
	if (XEXP (src, 0) == stack_pointer_rtx)
	{
	offset = GET_MODE_SIZE (GET_MODE (dest));
	break;
	}
	return 0;

	case PRE_INC:
	case POST_INC:
	if (XEXP (src, 0) == stack_pointer_rtx)
	{
	offset = -GET_MODE_SIZE (GET_MODE (dest));
	break;
	}
	return 0;

	default:
	return 0;
	}
	}
	else
	return 0;

	return offset;
	}

	/* Check INSN to see if it looks like a push or a stack adjustment, and
	make a note of it if it does. EH uses this information to find out how
	much extra space it needs to pop off the stack. */

	static void
	dwarf2out_stack_adjust (rtx insn, bool after_p)
	{
	HOST_WIDE_INT offset;
	const char *label;
	int i;

	/* Don't handle epilogues at all. Certainly it would be wrong to do so
	with this function. Proper support would require all frame-related
	insns to be marked, and to be able to handle saving state around
	epilogues textually in the middle of the function. */
	if (prologue_epilogue_contains (insn) \|\| sibcall_epilogue_contains (insn))
	return;

	/* If only calls can throw, and we have a frame pointer,
	save up adjustments until we see the CALL_INSN. */
	if (!flag_asynchronous_unwind_tables && cfa.reg != STACK_POINTER_REGNUM)
	{
	if (CALL_P (insn) && !after_p)
	{
	/* Extract the size of the args from the CALL rtx itself. */
	insn = PATTERN (insn);
	if (GET_CODE (insn) == PARALLEL)
	insn = XVECEXP (insn, 0, 0);
	if (GET_CODE (insn) == SET)
	insn = SET_SRC (insn);
	gcc_assert (GET_CODE (insn) == CALL);
	dwarf2out_args_size ("", INTVAL (XEXP (insn, 1)));
	}
	return;
	}

	if (CALL_P (insn) && !after_p)
	{
	if (!flag_asynchronous_unwind_tables)
	dwarf2out_args_size ("", args_size);
	return;
	}
	else if (BARRIER_P (insn))
	{
	/* When we see a BARRIER, we know to reset args_size to 0. Usually
	the compiler will have already emitted a stack adjustment, but
	doesn't bother for calls to noreturn functions. */
	#ifdef STACK_GROWS_DOWNWARD
	offset = -args_size;
	#else
	offset = args_size;
	#endif
	}
	else if (GET_CODE (PATTERN (insn)) == SET)
	offset = stack_adjust_offset (PATTERN (insn));
	else if (GET_CODE (PATTERN (insn)) == PARALLEL
	\|\| GET_CODE (PATTERN (insn)) == SEQUENCE)
	{
	/* There may be stack adjustments inside compound insns. Search
	for them. */
	for (offset = 0, i = XVECLEN (PATTERN (insn), 0) - 1; i >= 0; i--)
	if (GET_CODE (XVECEXP (PATTERN (insn), 0, i)) == SET)
	offset += stack_adjust_offset (XVECEXP (PATTERN (insn), 0, i));
	}
	else
	return;

	if (offset == 0)
	return;

	if (cfa.reg == STACK_POINTER_REGNUM)
	cfa.offset += offset;

	#ifndef STACK_GROWS_DOWNWARD
	offset = -offset;
	#endif

	args_size += offset;
	if (args_size < 0)
	args_size = 0;

	label = dwarf2out_cfi_label ();
	def_cfa_1 (label, &cfa);
	if (flag_asynchronous_unwind_tables)
	dwarf2out_args_size (label, args_size);
	}

	#endif

	/* We delay emitting a register save until either (a) we reach the end
	of the prologue or (b) the register is clobbered. This clusters
	register saves so that there are fewer pc advances. */

	struct queued_reg_save GTY(())
	{
	struct queued_reg_save *next;
	rtx reg;
	HOST_WIDE_INT cfa_offset;
	rtx saved_reg;
	};

	static GTY(()) struct queued_reg_save *queued_reg_saves;

	/* The caller's ORIG_REG is saved in SAVED_IN_REG. */
	struct reg_saved_in_data GTY(()) {
	rtx orig_reg;
	rtx saved_in_reg;
	};

	/* A list of registers saved in other registers.
	The list intentionally has a small maximum capacity of 4; if your
	port needs more than that, you might consider implementing a
	more efficient data structure. */
	static GTY(()) struct reg_saved_in_data regs_saved_in_regs[4];
	static GTY(()) size_t num_regs_saved_in_regs;

	#if defined (DWARF2_DEBUGGING_INFO) \|\| defined (DWARF2_UNWIND_INFO)
	static const char *last_reg_save_label;

	/* Add an entry to QUEUED_REG_SAVES saying that REG is now saved at
	SREG, or if SREG is NULL then it is saved at OFFSET to the CFA. */

	static void
	queue_reg_save (const char *label, rtx reg, rtx sreg, HOST_WIDE_INT offset)
	{
	struct queued_reg_save *q;

	/* Duplicates waste space, but it's also necessary to remove them
	for correctness, since the queue gets output in reverse
	order. */
	for (q = queued_reg_saves; q != NULL; q = q->next)
	if (REGNO (q->reg) == REGNO (reg))
	break;

	if (q == NULL)
	{
	q = ggc_alloc (sizeof (*q));
	q->next = queued_reg_saves;
	queued_reg_saves = q;
	}

	q->reg = reg;
	q->cfa_offset = offset;
	q->saved_reg = sreg;

	last_reg_save_label = label;
	}

	/* Output all the entries in QUEUED_REG_SAVES. */

	static void
	flush_queued_reg_saves (void)
	{
	struct queued_reg_save *q;

	for (q = queued_reg_saves; q; q = q->next)
	{
	size_t i;
	unsigned int reg, sreg;

	for (i = 0; i < num_regs_saved_in_regs; i++)
	if (REGNO (regs_saved_in_regs[i].orig_reg) == REGNO (q->reg))
	break;
	if (q->saved_reg && i == num_regs_saved_in_regs)
	{
	gcc_assert (i != ARRAY_SIZE (regs_saved_in_regs));
	num_regs_saved_in_regs++;
	}
	if (i != num_regs_saved_in_regs)
	{
	regs_saved_in_regs[i].orig_reg = q->reg;
	regs_saved_in_regs[i].saved_in_reg = q->saved_reg;
	}

	reg = DWARF_FRAME_REGNUM (REGNO (q->reg));
	if (q->saved_reg)
	sreg = DWARF_FRAME_REGNUM (REGNO (q->saved_reg));
	else
	sreg = INVALID_REGNUM;
	reg_save (last_reg_save_label, reg, sreg, q->cfa_offset);
	}

	queued_reg_saves = NULL;
	last_reg_save_label = NULL;
	}

	/* Does INSN clobber any register which QUEUED_REG_SAVES lists a saved
	location for? Or, does it clobber a register which we've previously
	said that some other register is saved in, and for which we now
	have a new location for? */

	static bool
	clobbers_queued_reg_save (rtx insn)
	{
	struct queued_reg_save *q;

	for (q = queued_reg_saves; q; q = q->next)
	{
	size_t i;
	if (modified_in_p (q->reg, insn))
	return true;
	for (i = 0; i < num_regs_saved_in_regs; i++)
	if (REGNO (q->reg) == REGNO (regs_saved_in_regs[i].orig_reg)
	&& modified_in_p (regs_saved_in_regs[i].saved_in_reg, insn))
	return true;
	}

	return false;
	}

	/* Entry point for saving the first register into the second. */

	void
	dwarf2out_reg_save_reg (const char *label, rtx reg, rtx sreg)
	{
	size_t i;
	unsigned int regno, sregno;

	for (i = 0; i < num_regs_saved_in_regs; i++)
	if (REGNO (regs_saved_in_regs[i].orig_reg) == REGNO (reg))
	break;
	if (i == num_regs_saved_in_regs)
	{
	gcc_assert (i != ARRAY_SIZE (regs_saved_in_regs));
	num_regs_saved_in_regs++;
	}
	regs_saved_in_regs[i].orig_reg = reg;
	regs_saved_in_regs[i].saved_in_reg = sreg;

	regno = DWARF_FRAME_REGNUM (REGNO (reg));
	sregno = DWARF_FRAME_REGNUM (REGNO (sreg));
	reg_save (label, regno, sregno, 0);
	}

	/* What register, if any, is currently saved in REG? */

	static rtx
	reg_saved_in (rtx reg)
	{
	unsigned int regn = REGNO (reg);
	size_t i;
	struct queued_reg_save *q;

	for (q = queued_reg_saves; q; q = q->next)
	if (q->saved_reg && regn == REGNO (q->saved_reg))
	return q->reg;

	for (i = 0; i < num_regs_saved_in_regs; i++)
	if (regs_saved_in_regs[i].saved_in_reg
	&& regn == REGNO (regs_saved_in_regs[i].saved_in_reg))
	return regs_saved_in_regs[i].orig_reg;

	return NULL_RTX;
	}


	/* A temporary register holding an integral value used in adjusting SP
	or setting up the store_reg. The "offset" field holds the integer
	value, not an offset. */
	static dw_cfa_location cfa_temp;

	/* Record call frame debugging information for an expression EXPR,
	which either sets SP or FP (adjusting how we calculate the frame
	address) or saves a register to the stack or another register.
	LABEL indicates the address of EXPR.

	This function encodes a state machine mapping rtxes to actions on
	cfa, cfa_store, and cfa_temp.reg. We describe these rules so
	users need not read the source code.

	The High-Level Picture

	Changes in the register we use to calculate the CFA: Currently we
	assume that if you copy the CFA register into another register, we
	should take the other one as the new CFA register; this seems to
	work pretty well. If it's wrong for some target, it's simple
	enough not to set RTX_FRAME_RELATED_P on the insn in question.

	Changes in the register we use for saving registers to the stack:
	This is usually SP, but not always. Again, we deduce that if you
	copy SP into another register (and SP is not the CFA register),
	then the new register is the one we will be using for register
	saves. This also seems to work.

	Register saves: There's not much guesswork about this one; if
	RTX_FRAME_RELATED_P is set on an insn which modifies memory, it's a
	register save, and the register used to calculate the destination
	had better be the one we think we're using for this purpose.
	It's also assumed that a copy from a call-saved register to another
	register is saving that register if RTX_FRAME_RELATED_P is set on
	that instruction. If the copy is from a call-saved register to
	the same register, that means that the register is now the same
	value as in the caller.

	Except: If the register being saved is the CFA register, and the
	offset is nonzero, we are saving the CFA, so we assume we have to
	use DW_CFA_def_cfa_expression. If the offset is 0, we assume that
	the intent is to save the value of SP from the previous frame.

	In addition, if a register has previously been saved to a different
	register,

	Invariants / Summaries of Rules

	cfa current rule for calculating the CFA. It usually
	consists of a register and an offset.
	cfa_store register used by prologue code to save things to the stack
	cfa_store.offset is the offset from the value of
	cfa_store.reg to the actual CFA
	cfa_temp register holding an integral value. cfa_temp.offset
	stores the value, which will be used to adjust the
	stack pointer. cfa_temp is also used like cfa_store,
	to track stores to the stack via fp or a temp reg.

	Rules 1- 4: Setting a register's value to cfa.reg or an expression
	with cfa.reg as the first operand changes the cfa.reg and its
	cfa.offset. Rule 1 and 4 also set cfa_temp.reg and
	cfa_temp.offset.

	Rules 6- 9: Set a non-cfa.reg register value to a constant or an
	expression yielding a constant. This sets cfa_temp.reg
	and cfa_temp.offset.

	Rule 5: Create a new register cfa_store used to save items to the
	stack.

	Rules 10-14: Save a register to the stack. Define offset as the
	difference of the original location and cfa_store's
	location (or cfa_temp's location if cfa_temp is used).

	The Rules

	"{a,b}" indicates a choice of a xor b.
	"<reg>:cfa.reg" indicates that <reg> must equal cfa.reg.

	Rule 1:
	(set <reg1> <reg2>:cfa.reg)
	effects: cfa.reg = <reg1>
	cfa.offset unchanged
	cfa_temp.reg = <reg1>
	cfa_temp.offset = cfa.offset

	Rule 2:
	(set sp ({minus,plus,losum} {sp,fp}:cfa.reg
	{<const_int>,<reg>:cfa_temp.reg}))
	effects: cfa.reg = sp if fp used
	cfa.offset += {+/- <const_int>, cfa_temp.offset} if cfa.reg==sp
	cfa_store.offset += {+/- <const_int>, cfa_temp.offset}
	if cfa_store.reg==sp

	Rule 3:
	(set fp ({minus,plus,losum} <reg>:cfa.reg <const_int>))
	effects: cfa.reg = fp
	cfa_offset += +/- <const_int>

	Rule 4:
	(set <reg1> ({plus,losum} <reg2>:cfa.reg <const_int>))
	constraints: <reg1> != fp
	<reg1> != sp
	effects: cfa.reg = <reg1>
	cfa_temp.reg = <reg1>
	cfa_temp.offset = cfa.offset

	Rule 5:
	(set <reg1> (plus <reg2>:cfa_temp.reg sp:cfa.reg))
	constraints: <reg1> != fp
	<reg1> != sp
	effects: cfa_store.reg = <reg1>
	cfa_store.offset = cfa.offset - cfa_temp.offset

	Rule 6:
	(set <reg> <const_int>)
	effects: cfa_temp.reg = <reg>
	cfa_temp.offset = <const_int>

	Rule 7:
	(set <reg1>:cfa_temp.reg (ior <reg2>:cfa_temp.reg <const_int>))
	effects: cfa_temp.reg = <reg1>
	cfa_temp.offset \|= <const_int>

	Rule 8:
	(set <reg> (high <exp>))
	effects: none

	Rule 9:
	(set <reg> (lo_sum <exp> <const_int>))
	effects: cfa_temp.reg = <reg>
	cfa_temp.offset = <const_int>

	Rule 10:
	(set (mem (pre_modify sp:cfa_store (???? <reg1> <const_int>))) <reg2>)
	effects: cfa_store.offset -= <const_int>
	cfa.offset = cfa_store.offset if cfa.reg == sp
	cfa.reg = sp
	cfa.base_offset = -cfa_store.offset

	Rule 11:
	(set (mem ({pre_inc,pre_dec} sp:cfa_store.reg)) <reg>)
	effects: cfa_store.offset += -/+ mode_size(mem)
	cfa.offset = cfa_store.offset if cfa.reg == sp
	cfa.reg = sp
	cfa.base_offset = -cfa_store.offset

	Rule 12:
	(set (mem ({minus,plus,losum} <reg1>:{cfa_store,cfa_temp} <const_int>))

	<reg2>)
	effects: cfa.reg = <reg1>
	cfa.base_offset = -/+ <const_int> - {cfa_store,cfa_temp}.offset

	Rule 13:
	(set (mem <reg1>:{cfa_store,cfa_temp}) <reg2>)
	effects: cfa.reg = <reg1>
	cfa.base_offset = -{cfa_store,cfa_temp}.offset

	Rule 14:
	(set (mem (postinc <reg1>:cfa_temp <const_int>)) <reg2>)
	effects: cfa.reg = <reg1>
	cfa.base_offset = -cfa_temp.offset
	cfa_temp.offset -= mode_size(mem)

	Rule 15:
	(set <reg> {unspec, unspec_volatile})
	effects: target-dependent */

	static void
	dwarf2out_frame_debug_expr (rtx expr, const char *label)
	{
	rtx src, dest;
	HOST_WIDE_INT offset;

	/* If RTX_FRAME_RELATED_P is set on a PARALLEL, process each member of
	the PARALLEL independently. The first element is always processed if
	it is a SET. This is for backward compatibility. Other elements
	are processed only if they are SETs and the RTX_FRAME_RELATED_P
	flag is set in them. */
	if (GET_CODE (expr) == PARALLEL \|\| GET_CODE (expr) == SEQUENCE)
	{
	int par_index;
	int limit = XVECLEN (expr, 0);

	for (par_index = 0; par_index < limit; par_index++)
	if (GET_CODE (XVECEXP (expr, 0, par_index)) == SET
	&& (RTX_FRAME_RELATED_P (XVECEXP (expr, 0, par_index))
	\|\| par_index == 0))
	dwarf2out_frame_debug_expr (XVECEXP (expr, 0, par_index), label);

	return;
	}

	gcc_assert (GET_CODE (expr) == SET);

	src = SET_SRC (expr);
	dest = SET_DEST (expr);

	if (REG_P (src))
	{
	rtx rsi = reg_saved_in (src);
	if (rsi)
	src = rsi;
	}

	switch (GET_CODE (dest))
	{
	case REG:
	switch (GET_CODE (src))
	{
	/* Setting FP from SP. */
	case REG:
	if (cfa.reg == (unsigned) REGNO (src))
	{
	/* Rule 1 */
	/* Update the CFA rule wrt SP or FP. Make sure src is
	relative to the current CFA register.

	We used to require that dest be either SP or FP, but the
	ARM copies SP to a temporary register, and from there to
	FP. So we just rely on the backends to only set
	RTX_FRAME_RELATED_P on appropriate insns. */
	cfa.reg = REGNO (dest);
	cfa_temp.reg = cfa.reg;
	cfa_temp.offset = cfa.offset;
	}
	else
	{
	/* Saving a register in a register. */
	gcc_assert (!fixed_regs [REGNO (dest)]
	/* For the SPARC and its register window. */
	\|\| (DWARF_FRAME_REGNUM (REGNO (src))
	== DWARF_FRAME_RETURN_COLUMN));
	queue_reg_save (label, src, dest, 0);
	}
	break;

	case PLUS:
	case MINUS:
	case LO_SUM:
	if (dest == stack_pointer_rtx)
	{
	/* Rule 2 */
	/* Adjusting SP. */
	switch (GET_CODE (XEXP (src, 1)))
	{
	case CONST_INT:
	offset = INTVAL (XEXP (src, 1));
	break;
	case REG:
	gcc_assert ((unsigned) REGNO (XEXP (src, 1))
	== cfa_temp.reg);
	offset = cfa_temp.offset;
	break;
	default:
	gcc_unreachable ();
	}

	if (XEXP (src, 0) == hard_frame_pointer_rtx)
	{
	/* Restoring SP from FP in the epilogue. */
	gcc_assert (cfa.reg == (unsigned) HARD_FRAME_POINTER_REGNUM);
	cfa.reg = STACK_POINTER_REGNUM;
	}
	else if (GET_CODE (src) == LO_SUM)
	/* Assume we've set the source reg of the LO_SUM from sp. */
	;
	else
	gcc_assert (XEXP (src, 0) == stack_pointer_rtx);

	if (GET_CODE (src) != MINUS)
	offset = -offset;
	if (cfa.reg == STACK_POINTER_REGNUM)
	cfa.offset += offset;
	if (cfa_store.reg == STACK_POINTER_REGNUM)
	cfa_store.offset += offset;
	}
	else if (dest == hard_frame_pointer_rtx)
	{
	/* Rule 3 */
	/* Either setting the FP from an offset of the SP,
	or adjusting the FP */
	gcc_assert (frame_pointer_needed);

	gcc_assert (REG_P (XEXP (src, 0))
	&& (unsigned) REGNO (XEXP (src, 0)) == cfa.reg
	&& GET_CODE (XEXP (src, 1)) == CONST_INT);
	offset = INTVAL (XEXP (src, 1));
	if (GET_CODE (src) != MINUS)
	offset = -offset;
	cfa.offset += offset;
	cfa.reg = HARD_FRAME_POINTER_REGNUM;
	}
	else
	{
	gcc_assert (GET_CODE (src) != MINUS);

	/* Rule 4 */
	if (REG_P (XEXP (src, 0))
	&& REGNO (XEXP (src, 0)) == cfa.reg
	&& GET_CODE (XEXP (src, 1)) == CONST_INT)
	{
	/* Setting a temporary CFA register that will be copied
	into the FP later on. */
	offset = - INTVAL (XEXP (src, 1));
	cfa.offset += offset;
	cfa.reg = REGNO (dest);
	/* Or used to save regs to the stack. */
	cfa_temp.reg = cfa.reg;
	cfa_temp.offset = cfa.offset;
	}

	/* Rule 5 */
	else if (REG_P (XEXP (src, 0))
	&& REGNO (XEXP (src, 0)) == cfa_temp.reg
	&& XEXP (src, 1) == stack_pointer_rtx)
	{
	/* Setting a scratch register that we will use instead
	of SP for saving registers to the stack. */
	gcc_assert (cfa.reg == STACK_POINTER_REGNUM);
	cfa_store.reg = REGNO (dest);
	cfa_store.offset = cfa.offset - cfa_temp.offset;
	}

	/* Rule 9 */
	else if (GET_CODE (src) == LO_SUM
	&& GET_CODE (XEXP (src, 1)) == CONST_INT)
	{
	cfa_temp.reg = REGNO (dest);
	cfa_temp.offset = INTVAL (XEXP (src, 1));
	}
	else
	gcc_unreachable ();
	}
	break;

	/* Rule 6 */
	case CONST_INT:
	cfa_temp.reg = REGNO (dest);
	cfa_temp.offset = INTVAL (src);
	break;

	/* Rule 7 */
	case IOR:
	gcc_assert (REG_P (XEXP (src, 0))
	&& (unsigned) REGNO (XEXP (src, 0)) == cfa_temp.reg
	&& GET_CODE (XEXP (src, 1)) == CONST_INT);

	if ((unsigned) REGNO (dest) != cfa_temp.reg)
	cfa_temp.reg = REGNO (dest);
	cfa_temp.offset \|= INTVAL (XEXP (src, 1));
	break;

	/* Skip over HIGH, assuming it will be followed by a LO_SUM,
	which will fill in all of the bits. */
	/* Rule 8 */
	case HIGH:
	break;

	/* Rule 15 */
	case UNSPEC:
	case UNSPEC_VOLATILE:
	gcc_assert (targetm.dwarf_handle_frame_unspec);
	targetm.dwarf_handle_frame_unspec (label, expr, XINT (src, 1));
	return;

	default:
	gcc_unreachable ();
	}

	def_cfa_1 (label, &cfa);
	break;

	case MEM:
	gcc_assert (REG_P (src));

	/* Saving a register to the stack. Make sure dest is relative to the
	CFA register. */
	switch (GET_CODE (XEXP (dest, 0)))
	{
	/* Rule 10 */
	/* With a push. */
	case PRE_MODIFY:
	/* We can't handle variable size modifications. */
	gcc_assert (GET_CODE (XEXP (XEXP (XEXP (dest, 0), 1), 1))
	== CONST_INT);
	offset = -INTVAL (XEXP (XEXP (XEXP (dest, 0), 1), 1));

	gcc_assert (REGNO (XEXP (XEXP (dest, 0), 0)) == STACK_POINTER_REGNUM
	&& cfa_store.reg == STACK_POINTER_REGNUM);

	cfa_store.offset += offset;
	if (cfa.reg == STACK_POINTER_REGNUM)
	cfa.offset = cfa_store.offset;

	offset = -cfa_store.offset;
	break;

	/* Rule 11 */
	case PRE_INC:
	case PRE_DEC:
	offset = GET_MODE_SIZE (GET_MODE (dest));
	if (GET_CODE (XEXP (dest, 0)) == PRE_INC)
	offset = -offset;

	gcc_assert (REGNO (XEXP (XEXP (dest, 0), 0)) == STACK_POINTER_REGNUM
	&& cfa_store.reg == STACK_POINTER_REGNUM);

	cfa_store.offset += offset;
	if (cfa.reg == STACK_POINTER_REGNUM)
	cfa.offset = cfa_store.offset;

	offset = -cfa_store.offset;
	break;

	/* Rule 12 */
	/* With an offset. */
	case PLUS:
	case MINUS:
	case LO_SUM:
	{
	int regno;

	gcc_assert (GET_CODE (XEXP (XEXP (dest, 0), 1)) == CONST_INT
	&& REG_P (XEXP (XEXP (dest, 0), 0)));
	offset = INTVAL (XEXP (XEXP (dest, 0), 1));
	if (GET_CODE (XEXP (dest, 0)) == MINUS)
	offset = -offset;

	regno = REGNO (XEXP (XEXP (dest, 0), 0));

	if (cfa_store.reg == (unsigned) regno)
	offset -= cfa_store.offset;
	else
	{
	gcc_assert (cfa_temp.reg == (unsigned) regno);
	offset -= cfa_temp.offset;
	}
	}
	break;

	/* Rule 13 */
	/* Without an offset. */
	case REG:
	{
	int regno = REGNO (XEXP (dest, 0));

	if (cfa_store.reg == (unsigned) regno)
	offset = -cfa_store.offset;
	else
	{
	gcc_assert (cfa_temp.reg == (unsigned) regno);
	offset = -cfa_temp.offset;
	}
	}
	break;

	/* Rule 14 */
	case POST_INC:
	gcc_assert (cfa_temp.reg
	== (unsigned) REGNO (XEXP (XEXP (dest, 0), 0)));
	offset = -cfa_temp.offset;
	cfa_temp.offset -= GET_MODE_SIZE (GET_MODE (dest));
	break;

	default:
	gcc_unreachable ();
	}

	if (REGNO (src) != STACK_POINTER_REGNUM
	&& REGNO (src) != HARD_FRAME_POINTER_REGNUM
	&& (unsigned) REGNO (src) == cfa.reg)
	{
	/* We're storing the current CFA reg into the stack. */

	if (cfa.offset == 0)
	{
	/* If the source register is exactly the CFA, assume
	we're saving SP like any other register; this happens
	on the ARM. */
	def_cfa_1 (label, &cfa);
	queue_reg_save (label, stack_pointer_rtx, NULL_RTX, offset);
	break;
	}
	else
	{
	/* Otherwise, we'll need to look in the stack to
	calculate the CFA. */
	rtx x = XEXP (dest, 0);

	if (!REG_P (x))
	x = XEXP (x, 0);
	gcc_assert (REG_P (x));

	cfa.reg = REGNO (x);
	cfa.base_offset = offset;
	cfa.indirect = 1;
	def_cfa_1 (label, &cfa);
	break;
	}
	}

	def_cfa_1 (label, &cfa);
	queue_reg_save (label, src, NULL_RTX, offset);
	break;

	default:
	gcc_unreachable ();
	}
	}

	/* Record call frame debugging information for INSN, which either
	sets SP or FP (adjusting how we calculate the frame address) or saves a
	register to the stack. If INSN is NULL_RTX, initialize our state.

	If AFTER_P is false, we're being called before the insn is emitted,
	otherwise after. Call instructions get invoked twice. */

	void
	dwarf2out_frame_debug (rtx insn, bool after_p)
	{
	const char *label;
	rtx src;

	if (insn == NULL_RTX)
	{
	size_t i;

	/* Flush any queued register saves. */
	flush_queued_reg_saves ();

	/* Set up state for generating call frame debug info. */
	lookup_cfa (&cfa);
	gcc_assert (cfa.reg
	== (unsigned long)DWARF_FRAME_REGNUM (STACK_POINTER_REGNUM));

	cfa.reg = STACK_POINTER_REGNUM;
	cfa_store = cfa;
	cfa_temp.reg = -1;
	cfa_temp.offset = 0;

	for (i = 0; i < num_regs_saved_in_regs; i++)
	{
	regs_saved_in_regs[i].orig_reg = NULL_RTX;
	regs_saved_in_regs[i].saved_in_reg = NULL_RTX;
	}
	num_regs_saved_in_regs = 0;
	return;
	}

	if (!NONJUMP_INSN_P (insn) \|\| clobbers_queued_reg_save (insn))
	flush_queued_reg_saves ();

	if (! RTX_FRAME_RELATED_P (insn))
	{
	if (!ACCUMULATE_OUTGOING_ARGS)
	dwarf2out_stack_adjust (insn, after_p);
	return;
	}

	label = dwarf2out_cfi_label ();
	src = find_reg_note (insn, REG_FRAME_RELATED_EXPR, NULL_RTX);
	if (src)
	insn = XEXP (src, 0);
	else
	insn = PATTERN (insn);

	dwarf2out_frame_debug_expr (insn, label);
	}

	#endif

	/* Describe for the GTY machinery what parts of dw_cfi_oprnd1 are used. */
	static enum dw_cfi_oprnd_type dw_cfi_oprnd1_desc
	(enum dwarf_call_frame_info cfi);

	static enum dw_cfi_oprnd_type
	dw_cfi_oprnd1_desc (enum dwarf_call_frame_info cfi)
	{
	switch (cfi)
	{
	case DW_CFA_nop:
	case DW_CFA_GNU_window_save:
	return dw_cfi_oprnd_unused;

	case DW_CFA_set_loc:
	case DW_CFA_advance_loc1:
	case DW_CFA_advance_loc2:
	case DW_CFA_advance_loc4:
	case DW_CFA_MIPS_advance_loc8:
	return dw_cfi_oprnd_addr;

	case DW_CFA_offset:
	case DW_CFA_offset_extended:
	case DW_CFA_def_cfa:
	case DW_CFA_offset_extended_sf:
	case DW_CFA_def_cfa_sf:
	case DW_CFA_restore_extended:
	case DW_CFA_undefined:
	case DW_CFA_same_value:
	case DW_CFA_def_cfa_register:
	case DW_CFA_register:
	return dw_cfi_oprnd_reg_num;

	case DW_CFA_def_cfa_offset:
	case DW_CFA_GNU_args_size:
	case DW_CFA_def_cfa_offset_sf:
	return dw_cfi_oprnd_offset;

	case DW_CFA_def_cfa_expression:
	case DW_CFA_expression:
	return dw_cfi_oprnd_loc;

	default:
	gcc_unreachable ();
	}
	}

	/* Describe for the GTY machinery what parts of dw_cfi_oprnd2 are used. */
	static enum dw_cfi_oprnd_type dw_cfi_oprnd2_desc
	(enum dwarf_call_frame_info cfi);

	static enum dw_cfi_oprnd_type
	dw_cfi_oprnd2_desc (enum dwarf_call_frame_info cfi)
	{
	switch (cfi)
	{
	case DW_CFA_def_cfa:
	case DW_CFA_def_cfa_sf:
	case DW_CFA_offset:
	case DW_CFA_offset_extended_sf:
	case DW_CFA_offset_extended:
	return dw_cfi_oprnd_offset;

	case DW_CFA_register:
	return dw_cfi_oprnd_reg_num;

	default:
	return dw_cfi_oprnd_unused;
	}
	}

	#if defined (DWARF2_DEBUGGING_INFO) \|\| defined (DWARF2_UNWIND_INFO)

	/* Switch to eh_frame_section. If we don't have an eh_frame_section,
	switch to the data section instead, and write out a synthetic label
	for collect2. */

	static void
	switch_to_eh_frame_section (void)
	{
	tree label;

	#ifdef EH_FRAME_SECTION_NAME
	if (eh_frame_section == 0)
	{
	int flags;

	if (EH_TABLES_CAN_BE_READ_ONLY)
	{
	int fde_encoding;
	int per_encoding;
	int lsda_encoding;

	fde_encoding = ASM_PREFERRED_EH_DATA_FORMAT (/code=/1,
	/global=/0);
	per_encoding = ASM_PREFERRED_EH_DATA_FORMAT (/code=/2,
	/global=/1);
	lsda_encoding = ASM_PREFERRED_EH_DATA_FORMAT (/code=/0,
	/global=/0);
	flags = ((! flag_pic
	\|\| ((fde_encoding & 0x70) != DW_EH_PE_absptr
	&& (fde_encoding & 0x70) != DW_EH_PE_aligned
	&& (per_encoding & 0x70) != DW_EH_PE_absptr
	&& (per_encoding & 0x70) != DW_EH_PE_aligned
	&& (lsda_encoding & 0x70) != DW_EH_PE_absptr
	&& (lsda_encoding & 0x70) != DW_EH_PE_aligned))
	? 0 : SECTION_WRITE);
	}
	else
	flags = SECTION_WRITE;
	eh_frame_section = get_section (EH_FRAME_SECTION_NAME, flags, NULL);
	}
	#endif

	if (eh_frame_section)
	switch_to_section (eh_frame_section);
	else
	{
	/* We have no special eh_frame section. Put the information in
	the data section and emit special labels to guide collect2. */
	switch_to_section (data_section);
	label = get_file_function_name ("F");
	ASM_OUTPUT_ALIGN (asm_out_file, floor_log2 (PTR_SIZE));
	targetm.asm_out.globalize_label (asm_out_file,
	IDENTIFIER_POINTER (label));
	ASM_OUTPUT_LABEL (asm_out_file, IDENTIFIER_POINTER (label));
	}
	}

	/* Output a Call Frame Information opcode and its operand(s). */

	static void
	output_cfi (dw_cfi_ref cfi, dw_fde_ref fde, int for_eh)
	{
	unsigned long r;
	if (cfi->dw_cfi_opc == DW_CFA_advance_loc)
	dw2_asm_output_data (1, (cfi->dw_cfi_opc
	\| (cfi->dw_cfi_oprnd1.dw_cfi_offset & 0x3f)),
	"DW_CFA_advance_loc " HOST_WIDE_INT_PRINT_HEX,
	cfi->dw_cfi_oprnd1.dw_cfi_offset);
	else if (cfi->dw_cfi_opc == DW_CFA_offset)
	{
	r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, for_eh);
	dw2_asm_output_data (1, (cfi->dw_cfi_opc \| (r & 0x3f)),
	"DW_CFA_offset, column 0x%lx", r);
	dw2_asm_output_data_uleb128 (cfi->dw_cfi_oprnd2.dw_cfi_offset, NULL);
	}
	else if (cfi->dw_cfi_opc == DW_CFA_restore)
	{
	r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, for_eh);
	dw2_asm_output_data (1, (cfi->dw_cfi_opc \| (r & 0x3f)),
	"DW_CFA_restore, column 0x%lx", r);
	}
	else
	{
	dw2_asm_output_data (1, cfi->dw_cfi_opc,
	"%s", dwarf_cfi_name (cfi->dw_cfi_opc));

	switch (cfi->dw_cfi_opc)
	{
	case DW_CFA_set_loc:
	if (for_eh)
	dw2_asm_output_encoded_addr_rtx (
	ASM_PREFERRED_EH_DATA_FORMAT (/code=/1, /global=/0),
	gen_rtx_SYMBOL_REF (Pmode, cfi->dw_cfi_oprnd1.dw_cfi_addr),
	false, NULL);
	else
	dw2_asm_output_addr (DWARF2_ADDR_SIZE,
	cfi->dw_cfi_oprnd1.dw_cfi_addr, NULL);
	fde->dw_fde_current_label = cfi->dw_cfi_oprnd1.dw_cfi_addr;
	break;

	case DW_CFA_advance_loc1:
	dw2_asm_output_delta (1, cfi->dw_cfi_oprnd1.dw_cfi_addr,
	fde->dw_fde_current_label, NULL);
	fde->dw_fde_current_label = cfi->dw_cfi_oprnd1.dw_cfi_addr;
	break;

	case DW_CFA_advance_loc2:
	dw2_asm_output_delta (2, cfi->dw_cfi_oprnd1.dw_cfi_addr,
	fde->dw_fde_current_label, NULL);
	fde->dw_fde_current_label = cfi->dw_cfi_oprnd1.dw_cfi_addr;
	break;

	case DW_CFA_advance_loc4:
	dw2_asm_output_delta (4, cfi->dw_cfi_oprnd1.dw_cfi_addr,
	fde->dw_fde_current_label, NULL);
	fde->dw_fde_current_label = cfi->dw_cfi_oprnd1.dw_cfi_addr;
	break;

	case DW_CFA_MIPS_advance_loc8:
	dw2_asm_output_delta (8, cfi->dw_cfi_oprnd1.dw_cfi_addr,
	fde->dw_fde_current_label, NULL);
	fde->dw_fde_current_label = cfi->dw_cfi_oprnd1.dw_cfi_addr;
	break;

	case DW_CFA_offset_extended:
	case DW_CFA_def_cfa:
	r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, for_eh);
	dw2_asm_output_data_uleb128 (r, NULL);
	dw2_asm_output_data_uleb128 (cfi->dw_cfi_oprnd2.dw_cfi_offset, NULL);
	break;

	case DW_CFA_offset_extended_sf:
	case DW_CFA_def_cfa_sf:
	r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, for_eh);
	dw2_asm_output_data_uleb128 (r, NULL);
	dw2_asm_output_data_sleb128 (cfi->dw_cfi_oprnd2.dw_cfi_offset, NULL);
	break;

	case DW_CFA_restore_extended:
	case DW_CFA_undefined:
	case DW_CFA_same_value:
	case DW_CFA_def_cfa_register:
	r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, for_eh);
	dw2_asm_output_data_uleb128 (r, NULL);
	break;

	case DW_CFA_register:
	r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, for_eh);
	dw2_asm_output_data_uleb128 (r, NULL);
	r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd2.dw_cfi_reg_num, for_eh);
	dw2_asm_output_data_uleb128 (r, NULL);
	break;

	case DW_CFA_def_cfa_offset:
	case DW_CFA_GNU_args_size:
	dw2_asm_output_data_uleb128 (cfi->dw_cfi_oprnd1.dw_cfi_offset, NULL);
	break;

	case DW_CFA_def_cfa_offset_sf:
	dw2_asm_output_data_sleb128 (cfi->dw_cfi_oprnd1.dw_cfi_offset, NULL);
	break;

	case DW_CFA_GNU_window_save:
	break;

	case DW_CFA_def_cfa_expression:
	case DW_CFA_expression:
	output_cfa_loc (cfi);
	break;

	case DW_CFA_GNU_negative_offset_extended:
	/* Obsoleted by DW_CFA_offset_extended_sf. */
	gcc_unreachable ();

	default:
	break;
	}
	}
	}

	/* Output the call frame information used to record information
	that relates to calculating the frame pointer, and records the
	location of saved registers. */

	static void
	output_call_frame_info (int for_eh)
	{
	unsigned int i;
	dw_fde_ref fde;
	dw_cfi_ref cfi;
	char l1[20], l2[20], section_start_label[20];
	bool any_lsda_needed = false;
	char augmentation[6];
	int augmentation_size;
	int fde_encoding = DW_EH_PE_absptr;
	int per_encoding = DW_EH_PE_absptr;
	int lsda_encoding = DW_EH_PE_absptr;
	int return_reg;

	/* Don't emit a CIE if there won't be any FDEs. */
	if (fde_table_in_use == 0)
	return;

	/* If we make FDEs linkonce, we may have to emit an empty label for
	an FDE that wouldn't otherwise be emitted. We want to avoid
	having an FDE kept around when the function it refers to is
	discarded. Example where this matters: a primary function
	template in C++ requires EH information, but an explicit
	specialization doesn't. */
	if (TARGET_USES_WEAK_UNWIND_INFO
	&& ! flag_asynchronous_unwind_tables
	+/* APPLE LOCAL begin for-fsf-4_4 5480287 */ \
	+ && flag_exceptions
	+/* APPLE LOCAL end for-fsf-4_4 5480287 */ \
	&& for_eh)
	for (i = 0; i < fde_table_in_use; i++)
	if ((fde_table[i].nothrow \|\| fde_table[i].all_throwers_are_sibcalls)
	&& !fde_table[i].uses_eh_lsda
	&& ! DECL_WEAK (fde_table[i].decl))
	targetm.asm_out.unwind_label (asm_out_file, fde_table[i].decl,
	for_eh, /* empty */ 1);

	/* If we don't have any functions we'll want to unwind out of, don't
	emit any EH unwind information. Note that if exceptions aren't
	enabled, we won't have collected nothrow information, and if we
	asked for asynchronous tables, we always want this info. */
	if (for_eh)
	{
	bool any_eh_needed = !flag_exceptions \|\| flag_asynchronous_unwind_tables;

	for (i = 0; i < fde_table_in_use; i++)
	if (fde_table[i].uses_eh_lsda)
	any_eh_needed = any_lsda_needed = true;
	else if (TARGET_USES_WEAK_UNWIND_INFO && DECL_WEAK (fde_table[i].decl))
	any_eh_needed = true;
	else if (! fde_table[i].nothrow
	&& ! fde_table[i].all_throwers_are_sibcalls)
	any_eh_needed = true;

	if (! any_eh_needed)
	return;
	}

	/* We're going to be generating comments, so turn on app. */
	if (flag_debug_asm)
	app_enable ();

	if (for_eh)
	switch_to_eh_frame_section ();
	else
	{
	if (!debug_frame_section)
	debug_frame_section = get_section (DEBUG_FRAME_SECTION,
	SECTION_DEBUG, NULL);
	switch_to_section (debug_frame_section);
	}

	ASM_GENERATE_INTERNAL_LABEL (section_start_label, FRAME_BEGIN_LABEL, for_eh);
	ASM_OUTPUT_LABEL (asm_out_file, section_start_label);

	/* Output the CIE. */
	ASM_GENERATE_INTERNAL_LABEL (l1, CIE_AFTER_SIZE_LABEL, for_eh);
	ASM_GENERATE_INTERNAL_LABEL (l2, CIE_END_LABEL, for_eh);
	if (DWARF_INITIAL_LENGTH_SIZE - DWARF_OFFSET_SIZE == 4 && !for_eh)
	dw2_asm_output_data (4, 0xffffffff,
	"Initial length escape value indicating 64-bit DWARF extension");
	dw2_asm_output_delta (for_eh ? 4 : DWARF_OFFSET_SIZE, l2, l1,
	"Length of Common Information Entry");
	ASM_OUTPUT_LABEL (asm_out_file, l1);

	/* Now that the CIE pointer is PC-relative for EH,
	use 0 to identify the CIE. */
	dw2_asm_output_data ((for_eh ? 4 : DWARF_OFFSET_SIZE),
	(for_eh ? 0 : DWARF_CIE_ID),
	"CIE Identifier Tag");

	dw2_asm_output_data (1, DW_CIE_VERSION, "CIE Version");

	augmentation[0] = 0;
	augmentation_size = 0;
	if (for_eh)
	{
	char *p;

	/* Augmentation:
	z Indicates that a uleb128 is present to size the
	augmentation section.
	L Indicates the encoding (and thus presence) of
	an LSDA pointer in the FDE augmentation.
	R Indicates a non-default pointer encoding for
	FDE code pointers.
	P Indicates the presence of an encoding + language
	personality routine in the CIE augmentation. */

	fde_encoding = ASM_PREFERRED_EH_DATA_FORMAT (/code=/1, /global=/0);
	per_encoding = ASM_PREFERRED_EH_DATA_FORMAT (/code=/2, /global=/1);
	lsda_encoding = ASM_PREFERRED_EH_DATA_FORMAT (/code=/0, /global=/0);

	p = augmentation + 1;
	if (eh_personality_libfunc)
	{
	*p++ = 'P';
	augmentation_size += 1 + size_of_encoded_value (per_encoding);
	}
	if (any_lsda_needed)
	{
	*p++ = 'L';
	augmentation_size += 1;
	}
	if (fde_encoding != DW_EH_PE_absptr)
	{
	*p++ = 'R';
	augmentation_size += 1;
	}
	if (p > augmentation + 1)
	{
	augmentation[0] = 'z';
	*p = '\0';
	}

	/* Ug. Some platforms can't do unaligned dynamic relocations at all. */
	if (eh_personality_libfunc && per_encoding == DW_EH_PE_aligned)
	{
	int offset = ( 4 /* Length */
	+ 4 /* CIE Id */
	+ 1 /* CIE version */
	+ strlen (augmentation) + 1 /* Augmentation */
	+ size_of_uleb128 (1) /* Code alignment */
	+ size_of_sleb128 (DWARF_CIE_DATA_ALIGNMENT)
	+ 1 /* RA column */
	+ 1 /* Augmentation size */
	+ 1 /* Personality encoding */ );
	int pad = -offset & (PTR_SIZE - 1);

	augmentation_size += pad;

	/* Augmentations should be small, so there's scarce need to
	iterate for a solution. Die if we exceed one uleb128 byte. */
	gcc_assert (size_of_uleb128 (augmentation_size) == 1);
	}
	}

	dw2_asm_output_nstring (augmentation, -1, "CIE Augmentation");
	dw2_asm_output_data_uleb128 (1, "CIE Code Alignment Factor");
	dw2_asm_output_data_sleb128 (DWARF_CIE_DATA_ALIGNMENT,
	"CIE Data Alignment Factor");

	return_reg = DWARF2_FRAME_REG_OUT (DWARF_FRAME_RETURN_COLUMN, for_eh);
	if (DW_CIE_VERSION == 1)
	dw2_asm_output_data (1, return_reg, "CIE RA Column");
	else
	dw2_asm_output_data_uleb128 (return_reg, "CIE RA Column");

	if (augmentation[0])
	{
	dw2_asm_output_data_uleb128 (augmentation_size, "Augmentation size");
	if (eh_personality_libfunc)
	{
	dw2_asm_output_data (1, per_encoding, "Personality (%s)",
	eh_data_format_name (per_encoding));
	dw2_asm_output_encoded_addr_rtx (per_encoding,
	eh_personality_libfunc,
	true, NULL);
	}

	if (any_lsda_needed)
	dw2_asm_output_data (1, lsda_encoding, "LSDA Encoding (%s)",
	eh_data_format_name (lsda_encoding));

	if (fde_encoding != DW_EH_PE_absptr)
	dw2_asm_output_data (1, fde_encoding, "FDE Encoding (%s)",
	eh_data_format_name (fde_encoding));
	}

	for (cfi = cie_cfi_head; cfi != NULL; cfi = cfi->dw_cfi_next)
	output_cfi (cfi, NULL, for_eh);

	/* Pad the CIE out to an address sized boundary. */
	ASM_OUTPUT_ALIGN (asm_out_file,
	floor_log2 (for_eh ? PTR_SIZE : DWARF2_ADDR_SIZE));
	ASM_OUTPUT_LABEL (asm_out_file, l2);

	/* Loop through all of the FDE's. */
	for (i = 0; i < fde_table_in_use; i++)
	{
	fde = &fde_table[i];

	/* Don't emit EH unwind info for leaf functions that don't need it. */
	if (for_eh && !flag_asynchronous_unwind_tables && flag_exceptions
	&& (fde->nothrow \|\| fde->all_throwers_are_sibcalls)
	&& ! (TARGET_USES_WEAK_UNWIND_INFO && DECL_WEAK (fde_table[i].decl))
	&& !fde->uses_eh_lsda)
	continue;

	targetm.asm_out.unwind_label (asm_out_file, fde->decl, for_eh, /* empty */ 0);
	targetm.asm_out.internal_label (asm_out_file, FDE_LABEL, for_eh + i * 2);
	ASM_GENERATE_INTERNAL_LABEL (l1, FDE_AFTER_SIZE_LABEL, for_eh + i * 2);
	ASM_GENERATE_INTERNAL_LABEL (l2, FDE_END_LABEL, for_eh + i * 2);
	if (DWARF_INITIAL_LENGTH_SIZE - DWARF_OFFSET_SIZE == 4 && !for_eh)
	dw2_asm_output_data (4, 0xffffffff,
	"Initial length escape value indicating 64-bit DWARF extension");
	dw2_asm_output_delta (for_eh ? 4 : DWARF_OFFSET_SIZE, l2, l1,
	"FDE Length");
	ASM_OUTPUT_LABEL (asm_out_file, l1);

	if (for_eh)
	dw2_asm_output_delta (4, l1, section_start_label, "FDE CIE offset");
	else
	dw2_asm_output_offset (DWARF_OFFSET_SIZE, section_start_label,
	debug_frame_section, "FDE CIE offset");

	if (for_eh)
	{
	rtx sym_ref = gen_rtx_SYMBOL_REF (Pmode, fde->dw_fde_begin);
	SYMBOL_REF_FLAGS (sym_ref) \|= SYMBOL_FLAG_LOCAL;
	dw2_asm_output_encoded_addr_rtx (fde_encoding,
	sym_ref,
	false,
	"FDE initial location");
	if (fde->dw_fde_switched_sections)
	{
	rtx sym_ref2 = gen_rtx_SYMBOL_REF (Pmode,
	fde->dw_fde_unlikely_section_label);
	rtx sym_ref3= gen_rtx_SYMBOL_REF (Pmode,
	fde->dw_fde_hot_section_label);
	SYMBOL_REF_FLAGS (sym_ref2) \|= SYMBOL_FLAG_LOCAL;
	SYMBOL_REF_FLAGS (sym_ref3) \|= SYMBOL_FLAG_LOCAL;
	dw2_asm_output_encoded_addr_rtx (fde_encoding, sym_ref3, false,
	"FDE initial location");
	dw2_asm_output_delta (size_of_encoded_value (fde_encoding),
	fde->dw_fde_hot_section_end_label,
	fde->dw_fde_hot_section_label,
	"FDE address range");
	dw2_asm_output_encoded_addr_rtx (fde_encoding, sym_ref2, false,
	"FDE initial location");
	dw2_asm_output_delta (size_of_encoded_value (fde_encoding),
	fde->dw_fde_unlikely_section_end_label,
	fde->dw_fde_unlikely_section_label,
	"FDE address range");
	}
	else
	dw2_asm_output_delta (size_of_encoded_value (fde_encoding),
	fde->dw_fde_end, fde->dw_fde_begin,
	"FDE address range");
	}
	else
	{
	dw2_asm_output_addr (DWARF2_ADDR_SIZE, fde->dw_fde_begin,
	"FDE initial location");
	if (fde->dw_fde_switched_sections)
	{
	dw2_asm_output_addr (DWARF2_ADDR_SIZE,
	fde->dw_fde_hot_section_label,
	"FDE initial location");
	dw2_asm_output_delta (DWARF2_ADDR_SIZE,
	fde->dw_fde_hot_section_end_label,
	fde->dw_fde_hot_section_label,
	"FDE address range");
	dw2_asm_output_addr (DWARF2_ADDR_SIZE,
	fde->dw_fde_unlikely_section_label,
	"FDE initial location");
	dw2_asm_output_delta (DWARF2_ADDR_SIZE,
	fde->dw_fde_unlikely_section_end_label,
	fde->dw_fde_unlikely_section_label,
	"FDE address range");
	}
	else
	dw2_asm_output_delta (DWARF2_ADDR_SIZE,
	fde->dw_fde_end, fde->dw_fde_begin,
	"FDE address range");
	}

	if (augmentation[0])
	{
	if (any_lsda_needed)
	{
	int size = size_of_encoded_value (lsda_encoding);

	if (lsda_encoding == DW_EH_PE_aligned)
	{
	int offset = ( 4 /* Length */
	+ 4 /* CIE offset */
	+ 2 * size_of_encoded_value (fde_encoding)
	+ 1 /* Augmentation size */ );
	int pad = -offset & (PTR_SIZE - 1);

	size += pad;
	gcc_assert (size_of_uleb128 (size) == 1);
	}

	dw2_asm_output_data_uleb128 (size, "Augmentation size");

	if (fde->uses_eh_lsda)
	{
	ASM_GENERATE_INTERNAL_LABEL (l1, "LLSDA",
	fde->funcdef_number);
	dw2_asm_output_encoded_addr_rtx (
	lsda_encoding, gen_rtx_SYMBOL_REF (Pmode, l1),
	false, "Language Specific Data Area");
	}
	else
	{
	if (lsda_encoding == DW_EH_PE_aligned)
	ASM_OUTPUT_ALIGN (asm_out_file, floor_log2 (PTR_SIZE));
	dw2_asm_output_data
	(size_of_encoded_value (lsda_encoding), 0,
	"Language Specific Data Area (none)");
	}
	}
	else
	dw2_asm_output_data_uleb128 (0, "Augmentation size");
	}

	/* Loop through the Call Frame Instructions associated with
	this FDE. */
	fde->dw_fde_current_label = fde->dw_fde_begin;
	for (cfi = fde->dw_fde_cfi; cfi != NULL; cfi = cfi->dw_cfi_next)
	output_cfi (cfi, fde, for_eh);

	/* Pad the FDE out to an address sized boundary. */
	ASM_OUTPUT_ALIGN (asm_out_file,
	floor_log2 ((for_eh ? PTR_SIZE : DWARF2_ADDR_SIZE)));
	ASM_OUTPUT_LABEL (asm_out_file, l2);
	}

	if (for_eh && targetm.terminate_dw2_eh_frame_info)
	dw2_asm_output_data (4, 0, "End of Table");
	#ifdef MIPS_DEBUGGING_INFO
	/* Work around Irix 6 assembler bug whereby labels at the end of a section
	get a value of 0. Putting .align 0 after the label fixes it. */
	ASM_OUTPUT_ALIGN (asm_out_file, 0);
	#endif

	/* Turn off app to make assembly quicker. */
	if (flag_debug_asm)
	app_disable ();
	}

	/* Output a marker (i.e. a label) for the beginning of a function, before
	the prologue. */

	void
	dwarf2out_begin_prologue (unsigned int line ATTRIBUTE_UNUSED,
	const char *file ATTRIBUTE_UNUSED)
	{
	char label[MAX_ARTIFICIAL_LABEL_BYTES];
	char * dup_label;
	dw_fde_ref fde;

	current_function_func_begin_label = NULL;

	#ifdef TARGET_UNWIND_INFO
	/* ??? current_function_func_begin_label is also used by except.c
	for call-site information. We must emit this label if it might
	be used. */
	if ((! flag_exceptions \|\| USING_SJLJ_EXCEPTIONS)
	&& ! dwarf2out_do_frame ())
	return;
	#else
	if (! dwarf2out_do_frame ())
	return;
	#endif

	switch_to_section (function_section (current_function_decl));
	ASM_GENERATE_INTERNAL_LABEL (label, FUNC_BEGIN_LABEL,
	current_function_funcdef_no);
	ASM_OUTPUT_DEBUG_LABEL (asm_out_file, FUNC_BEGIN_LABEL,
	current_function_funcdef_no);
	dup_label = xstrdup (label);
	current_function_func_begin_label = dup_label;

	#ifdef TARGET_UNWIND_INFO
	/* We can elide the fde allocation if we're not emitting debug info. */
	if (! dwarf2out_do_frame ())
	return;
	#endif

	/* Expand the fde table if necessary. */
	if (fde_table_in_use == fde_table_allocated)
	{
	fde_table_allocated += FDE_TABLE_INCREMENT;
	fde_table = ggc_realloc (fde_table,
	fde_table_allocated * sizeof (dw_fde_node));
	memset (fde_table + fde_table_in_use, 0,
	FDE_TABLE_INCREMENT * sizeof (dw_fde_node));
	}

	/* Record the FDE associated with this function. */
	current_funcdef_fde = fde_table_in_use;

	/* Add the new FDE at the end of the fde_table. */
	fde = &fde_table[fde_table_in_use++];
	fde->decl = current_function_decl;
	fde->dw_fde_begin = dup_label;
	fde->dw_fde_current_label = dup_label;
	fde->dw_fde_hot_section_label = NULL;
	fde->dw_fde_hot_section_end_label = NULL;
	fde->dw_fde_unlikely_section_label = NULL;
	fde->dw_fde_unlikely_section_end_label = NULL;
	fde->dw_fde_switched_sections = false;
	fde->dw_fde_end = NULL;
	fde->dw_fde_cfi = NULL;
	fde->funcdef_number = current_function_funcdef_no;
	fde->nothrow = TREE_NOTHROW (current_function_decl);
	fde->uses_eh_lsda = cfun->uses_eh_lsda;
	fde->all_throwers_are_sibcalls = cfun->all_throwers_are_sibcalls;

	args_size = old_args_size = 0;

	/* We only want to output line number information for the genuine dwarf2
	prologue case, not the eh frame case. */
	#ifdef DWARF2_DEBUGGING_INFO
	if (file)
	dwarf2out_source_line (line, file);
	#endif
	}

	/* Output a marker (i.e. a label) for the absolute end of the generated code
	for a function definition. This gets called after the epilogue code has
	been generated. */

	void
	dwarf2out_end_epilogue (unsigned int line ATTRIBUTE_UNUSED,
	const char *file ATTRIBUTE_UNUSED)
	{
	dw_fde_ref fde;
	char label[MAX_ARTIFICIAL_LABEL_BYTES];

	/* Output a label to mark the endpoint of the code generated for this
	function. */
	ASM_GENERATE_INTERNAL_LABEL (label, FUNC_END_LABEL,
	current_function_funcdef_no);
	ASM_OUTPUT_LABEL (asm_out_file, label);
	fde = &fde_table[fde_table_in_use - 1];
	fde->dw_fde_end = xstrdup (label);
	}

	void
	dwarf2out_frame_init (void)
	{
	/* Allocate the initial hunk of the fde_table. */
	fde_table = ggc_alloc_cleared (FDE_TABLE_INCREMENT * sizeof (dw_fde_node));
	fde_table_allocated = FDE_TABLE_INCREMENT;
	fde_table_in_use = 0;

	/* Generate the CFA instructions common to all FDE's. Do it now for the
	sake of lookup_cfa. */

	/* On entry, the Canonical Frame Address is at SP. */
	dwarf2out_def_cfa (NULL, STACK_POINTER_REGNUM, INCOMING_FRAME_SP_OFFSET);

	#ifdef DWARF2_UNWIND_INFO
	if (DWARF2_UNWIND_INFO)
	initial_return_save (INCOMING_RETURN_ADDR_RTX);
	#endif
	}

	void
	dwarf2out_frame_finish (void)
	{
	/* Output call frame information. */
	if (DWARF2_FRAME_INFO)
	output_call_frame_info (0);

	#ifndef TARGET_UNWIND_INFO
	/* Output another copy for the unwinder. */
	if (! USING_SJLJ_EXCEPTIONS && (flag_unwind_tables \|\| flag_exceptions))
	output_call_frame_info (1);
	#endif
	}
	#endif

	/* And now, the subset of the debugging information support code necessary
	for emitting location expressions. */

	/* Data about a single source file. */
	struct dwarf_file_data GTY(())
	{
	const char * filename;
	int emitted_number;
	};

	/* We need some way to distinguish DW_OP_addr with a direct symbol
	relocation from DW_OP_addr with a dtp-relative symbol relocation. */
	#define INTERNAL_DW_OP_tls_addr (0x100 + DW_OP_addr)


	typedef struct dw_val_struct *dw_val_ref;
	typedef struct die_struct *dw_die_ref;
	typedef struct dw_loc_descr_struct *dw_loc_descr_ref;
	typedef struct dw_loc_list_struct *dw_loc_list_ref;

	/* Each DIE may have a series of attribute/value pairs. Values
	can take on several forms. The forms that are used in this
	implementation are listed below. */

	enum dw_val_class
	{
	dw_val_class_addr,
	dw_val_class_offset,
	dw_val_class_loc,
	dw_val_class_loc_list,
	dw_val_class_range_list,
	dw_val_class_const,
	dw_val_class_unsigned_const,
	dw_val_class_long_long,
	dw_val_class_vec,
	dw_val_class_flag,
	dw_val_class_die_ref,
	dw_val_class_fde_ref,
	dw_val_class_lbl_id,
	dw_val_class_lineptr,
	dw_val_class_str,
	dw_val_class_macptr,
	dw_val_class_file
	};

	/* Describe a double word constant value. */
	/* ??? Every instance of long_long in the code really means CONST_DOUBLE. */

	typedef struct dw_long_long_struct GTY(())
	{
	unsigned long hi;
	unsigned long low;
	}
	dw_long_long_const;

	/* Describe a floating point constant value, or a vector constant value. */

	typedef struct dw_vec_struct GTY(())
	{
	unsigned char * GTY((length ("%h.length"))) array;
	unsigned length;
	unsigned elt_size;
	}
	dw_vec_const;

	/* The dw_val_node describes an attribute's value, as it is
	represented internally. */

	typedef struct dw_val_struct GTY(())
	{
	enum dw_val_class val_class;
	union dw_val_struct_union
	{
	rtx GTY ((tag ("dw_val_class_addr"))) val_addr;
	unsigned HOST_WIDE_INT GTY ((tag ("dw_val_class_offset"))) val_offset;
	dw_loc_list_ref GTY ((tag ("dw_val_class_loc_list"))) val_loc_list;
	dw_loc_descr_ref GTY ((tag ("dw_val_class_loc"))) val_loc;
	HOST_WIDE_INT GTY ((default)) val_int;
	unsigned HOST_WIDE_INT GTY ((tag ("dw_val_class_unsigned_const"))) val_unsigned;
	dw_long_long_const GTY ((tag ("dw_val_class_long_long"))) val_long_long;
	dw_vec_const GTY ((tag ("dw_val_class_vec"))) val_vec;
	struct dw_val_die_union
	{
	dw_die_ref die;
	int external;
	} GTY ((tag ("dw_val_class_die_ref"))) val_die_ref;
	unsigned GTY ((tag ("dw_val_class_fde_ref"))) val_fde_index;
	struct indirect_string_node * GTY ((tag ("dw_val_class_str"))) val_str;
	char * GTY ((tag ("dw_val_class_lbl_id"))) val_lbl_id;
	unsigned char GTY ((tag ("dw_val_class_flag"))) val_flag;
	struct dwarf_file_data * GTY ((tag ("dw_val_class_file"))) val_file;
	}
	GTY ((desc ("%1.val_class"))) v;
	}
	dw_val_node;

	/* Locations in memory are described using a sequence of stack machine
	operations. */

	typedef struct dw_loc_descr_struct GTY(())
	{
	dw_loc_descr_ref dw_loc_next;
	enum dwarf_location_atom dw_loc_opc;
	dw_val_node dw_loc_oprnd1;
	dw_val_node dw_loc_oprnd2;
	int dw_loc_addr;
	}
	dw_loc_descr_node;

	/* Location lists are ranges + location descriptions for that range,
	so you can track variables that are in different places over
	their entire life. */
	typedef struct dw_loc_list_struct GTY(())
	{
	dw_loc_list_ref dw_loc_next;
	const char begin; / Label for begin address of range */
	const char end; / Label for end address of range */
	char ll_symbol; / Label for beginning of location list.
	Only on head of list */
	const char section; / Section this loclist is relative to */
	dw_loc_descr_ref expr;
	} dw_loc_list_node;

	#if defined (DWARF2_DEBUGGING_INFO) \|\| defined (DWARF2_UNWIND_INFO)

	static const char *dwarf_stack_op_name (unsigned);
	static dw_loc_descr_ref new_loc_descr (enum dwarf_location_atom,
	unsigned HOST_WIDE_INT, unsigned HOST_WIDE_INT);
	static void add_loc_descr (dw_loc_descr_ref *, dw_loc_descr_ref);
	static unsigned long size_of_loc_descr (dw_loc_descr_ref);
	static unsigned long size_of_locs (dw_loc_descr_ref);
	static void output_loc_operands (dw_loc_descr_ref);
	static void output_loc_sequence (dw_loc_descr_ref);

	/* Convert a DWARF stack opcode into its string name. */

	static const char *
	dwarf_stack_op_name (unsigned int op)
	{
	switch (op)
	{
	case DW_OP_addr:
	case INTERNAL_DW_OP_tls_addr:
	return "DW_OP_addr";
	case DW_OP_deref:
	return "DW_OP_deref";
	case DW_OP_const1u:
	return "DW_OP_const1u";
	case DW_OP_const1s:
	return "DW_OP_const1s";
	case DW_OP_const2u:
	return "DW_OP_const2u";
	case DW_OP_const2s:
	return "DW_OP_const2s";
	case DW_OP_const4u:
	return "DW_OP_const4u";
	case DW_OP_const4s:
	return "DW_OP_const4s";
	case DW_OP_const8u:
	return "DW_OP_const8u";
	case DW_OP_const8s:
	return "DW_OP_const8s";
	case DW_OP_constu:
	return "DW_OP_constu";
	case DW_OP_consts:
	return "DW_OP_consts";
	case DW_OP_dup:
	return "DW_OP_dup";
	case DW_OP_drop:
	return "DW_OP_drop";
	case DW_OP_over:
	return "DW_OP_over";
	case DW_OP_pick:
	return "DW_OP_pick";
	case DW_OP_swap:
	return "DW_OP_swap";
	case DW_OP_rot:
	return "DW_OP_rot";
	case DW_OP_xderef:
	return "DW_OP_xderef";
	case DW_OP_abs:
	return "DW_OP_abs";
	case DW_OP_and:
	return "DW_OP_and";
	case DW_OP_div:
	return "DW_OP_div";
	case DW_OP_minus:
	return "DW_OP_minus";
	case DW_OP_mod:
	return "DW_OP_mod";
	case DW_OP_mul:
	return "DW_OP_mul";
	case DW_OP_neg:
	return "DW_OP_neg";
	case DW_OP_not:
	return "DW_OP_not";
	case DW_OP_or:
	return "DW_OP_or";
	case DW_OP_plus:
	return "DW_OP_plus";
	case DW_OP_plus_uconst:
	return "DW_OP_plus_uconst";
	case DW_OP_shl:
	return "DW_OP_shl";
	case DW_OP_shr:
	return "DW_OP_shr";
	case DW_OP_shra:
	return "DW_OP_shra";
	case DW_OP_xor:
	return "DW_OP_xor";
	case DW_OP_bra:
	return "DW_OP_bra";
	case DW_OP_eq:
	return "DW_OP_eq";
	case DW_OP_ge:
	return "DW_OP_ge";
	case DW_OP_gt:
	return "DW_OP_gt";
	case DW_OP_le:
	return "DW_OP_le";
	case DW_OP_lt:
	return "DW_OP_lt";
	case DW_OP_ne:
	return "DW_OP_ne";
	case DW_OP_skip:
	return "DW_OP_skip";
	case DW_OP_lit0:
	return "DW_OP_lit0";
	case DW_OP_lit1:
	return "DW_OP_lit1";
	case DW_OP_lit2:
	return "DW_OP_lit2";
	case DW_OP_lit3:
	return "DW_OP_lit3";
	case DW_OP_lit4:
	return "DW_OP_lit4";
	case DW_OP_lit5:
	return "DW_OP_lit5";
	case DW_OP_lit6:
	return "DW_OP_lit6";
	case DW_OP_lit7:
	return "DW_OP_lit7";
	case DW_OP_lit8:
	return "DW_OP_lit8";
	case DW_OP_lit9:
	return "DW_OP_lit9";
	case DW_OP_lit10:
	return "DW_OP_lit10";
	case DW_OP_lit11:
	return "DW_OP_lit11";
	case DW_OP_lit12:
	return "DW_OP_lit12";
	case DW_OP_lit13:
	return "DW_OP_lit13";
	case DW_OP_lit14:
	return "DW_OP_lit14";
	case DW_OP_lit15:
	return "DW_OP_lit15";
	case DW_OP_lit16:
	return "DW_OP_lit16";
	case DW_OP_lit17:
	return "DW_OP_lit17";
	case DW_OP_lit18:
	return "DW_OP_lit18";
	case DW_OP_lit19:
	return "DW_OP_lit19";
	case DW_OP_lit20:
	return "DW_OP_lit20";
	case DW_OP_lit21:
	return "DW_OP_lit21";
	case DW_OP_lit22:
	return "DW_OP_lit22";
	case DW_OP_lit23:
	return "DW_OP_lit23";
	case DW_OP_lit24:
	return "DW_OP_lit24";
	case DW_OP_lit25:
	return "DW_OP_lit25";
	case DW_OP_lit26:
	return "DW_OP_lit26";
	case DW_OP_lit27:
	return "DW_OP_lit27";
	case DW_OP_lit28:
	return "DW_OP_lit28";
	case DW_OP_lit29:
	return "DW_OP_lit29";
	case DW_OP_lit30:
	return "DW_OP_lit30";
	case DW_OP_lit31:
	return "DW_OP_lit31";
	case DW_OP_reg0:
	return "DW_OP_reg0";
	case DW_OP_reg1:
	return "DW_OP_reg1";
	case DW_OP_reg2:
	return "DW_OP_reg2";
	case DW_OP_reg3:
	return "DW_OP_reg3";
	case DW_OP_reg4:
	return "DW_OP_reg4";
	case DW_OP_reg5:
	return "DW_OP_reg5";
	case DW_OP_reg6:
	return "DW_OP_reg6";
	case DW_OP_reg7:
	return "DW_OP_reg7";
	case DW_OP_reg8:
	return "DW_OP_reg8";
	case DW_OP_reg9:
	return "DW_OP_reg9";
	case DW_OP_reg10:
	return "DW_OP_reg10";
	case DW_OP_reg11:
	return "DW_OP_reg11";
	case DW_OP_reg12:
	return "DW_OP_reg12";
	case DW_OP_reg13:
	return "DW_OP_reg13";
	case DW_OP_reg14:
	return "DW_OP_reg14";
	case DW_OP_reg15:
	return "DW_OP_reg15";
	case DW_OP_reg16:
	return "DW_OP_reg16";
	case DW_OP_reg17:
	return "DW_OP_reg17";
	case DW_OP_reg18:
	return "DW_OP_reg18";
	case DW_OP_reg19:
	return "DW_OP_reg19";
	case DW_OP_reg20:
	return "DW_OP_reg20";
	case DW_OP_reg21:
	return "DW_OP_reg21";
	case DW_OP_reg22:
	return "DW_OP_reg22";
	case DW_OP_reg23:
	return "DW_OP_reg23";
	case DW_OP_reg24:
	return "DW_OP_reg24";
	case DW_OP_reg25:
	return "DW_OP_reg25";
	case DW_OP_reg26:
	return "DW_OP_reg26";
	case DW_OP_reg27:
	return "DW_OP_reg27";
	case DW_OP_reg28:
	return "DW_OP_reg28";
	case DW_OP_reg29:
	return "DW_OP_reg29";
	case DW_OP_reg30:
	return "DW_OP_reg30";
	case DW_OP_reg31:
	return "DW_OP_reg31";
	case DW_OP_breg0:
	return "DW_OP_breg0";
	case DW_OP_breg1:
	return "DW_OP_breg1";
	case DW_OP_breg2:
	return "DW_OP_breg2";
	case DW_OP_breg3:
	return "DW_OP_breg3";
	case DW_OP_breg4:
	return "DW_OP_breg4";
	case DW_OP_breg5:
	return "DW_OP_breg5";
	case DW_OP_breg6:
	return "DW_OP_breg6";
	case DW_OP_breg7:
	return "DW_OP_breg7";
	case DW_OP_breg8:
	return "DW_OP_breg8";
	case DW_OP_breg9:
	return "DW_OP_breg9";
	case DW_OP_breg10:
	return "DW_OP_breg10";
	case DW_OP_breg11:
	return "DW_OP_breg11";
	case DW_OP_breg12:
	return "DW_OP_breg12";
	case DW_OP_breg13:
	return "DW_OP_breg13";
	case DW_OP_breg14:
	return "DW_OP_breg14";
	case DW_OP_breg15:
	return "DW_OP_breg15";
	case DW_OP_breg16:
	return "DW_OP_breg16";
	case DW_OP_breg17:
	return "DW_OP_breg17";
	case DW_OP_breg18:
	return "DW_OP_breg18";
	case DW_OP_breg19:
	return "DW_OP_breg19";
	case DW_OP_breg20:
	return "DW_OP_breg20";
	case DW_OP_breg21:
	return "DW_OP_breg21";
	case DW_OP_breg22:
	return "DW_OP_breg22";
	case DW_OP_breg23:
	return "DW_OP_breg23";
	case DW_OP_breg24:
	return "DW_OP_breg24";
	case DW_OP_breg25:
	return "DW_OP_breg25";
	case DW_OP_breg26:
	return "DW_OP_breg26";
	case DW_OP_breg27:
	return "DW_OP_breg27";
	case DW_OP_breg28:
	return "DW_OP_breg28";
	case DW_OP_breg29:
	return "DW_OP_breg29";
	case DW_OP_breg30:
	return "DW_OP_breg30";
	case DW_OP_breg31:
	return "DW_OP_breg31";
	case DW_OP_regx:
	return "DW_OP_regx";
	case DW_OP_fbreg:
	return "DW_OP_fbreg";
	case DW_OP_bregx:
	return "DW_OP_bregx";
	case DW_OP_piece:
	return "DW_OP_piece";
	case DW_OP_deref_size:
	return "DW_OP_deref_size";
	case DW_OP_xderef_size:
	return "DW_OP_xderef_size";
	case DW_OP_nop:
	return "DW_OP_nop";
	case DW_OP_push_object_address:
	return "DW_OP_push_object_address";
	case DW_OP_call2:
	return "DW_OP_call2";
	case DW_OP_call4:
	return "DW_OP_call4";
	case DW_OP_call_ref:
	return "DW_OP_call_ref";
	case DW_OP_GNU_push_tls_address:
	return "DW_OP_GNU_push_tls_address";
	default:
	return "OP_<unknown>";
	}
	}

	/* Return a pointer to a newly allocated location description. Location
	descriptions are simple expression terms that can be strung
	together to form more complicated location (address) descriptions. */

	static inline dw_loc_descr_ref
	new_loc_descr (enum dwarf_location_atom op, unsigned HOST_WIDE_INT oprnd1,
	unsigned HOST_WIDE_INT oprnd2)
	{
	dw_loc_descr_ref descr = ggc_alloc_cleared (sizeof (dw_loc_descr_node));

	descr->dw_loc_opc = op;
	descr->dw_loc_oprnd1.val_class = dw_val_class_unsigned_const;
	descr->dw_loc_oprnd1.v.val_unsigned = oprnd1;
	descr->dw_loc_oprnd2.val_class = dw_val_class_unsigned_const;
	descr->dw_loc_oprnd2.v.val_unsigned = oprnd2;

	return descr;
	}

	/* Add a location description term to a location description expression. */

	static inline void
	add_loc_descr (dw_loc_descr_ref *list_head, dw_loc_descr_ref descr)
	{
	dw_loc_descr_ref *d;

	/* Find the end of the chain. */
	for (d = list_head; (d) != NULL; d = &(d)->dw_loc_next)
	;

	*d = descr;
	}

	/* Return the size of a location descriptor. */

	static unsigned long
	size_of_loc_descr (dw_loc_descr_ref loc)
	{
	unsigned long size = 1;

	switch (loc->dw_loc_opc)
	{
	case DW_OP_addr:
	case INTERNAL_DW_OP_tls_addr:
	size += DWARF2_ADDR_SIZE;
	break;
	case DW_OP_const1u:
	case DW_OP_const1s:
	size += 1;
	break;
	case DW_OP_const2u:
	case DW_OP_const2s:
	size += 2;
	break;
	case DW_OP_const4u:
	case DW_OP_const4s:
	size += 4;
	break;
	case DW_OP_const8u:
	case DW_OP_const8s:
	size += 8;
	break;
	case DW_OP_constu:
	size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned);
	break;
	case DW_OP_consts:
	size += size_of_sleb128 (loc->dw_loc_oprnd1.v.val_int);
	break;
	case DW_OP_pick:
	size += 1;
	break;
	case DW_OP_plus_uconst:
	size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned);
	break;
	case DW_OP_skip:
	case DW_OP_bra:
	size += 2;
	break;
	case DW_OP_breg0:
	case DW_OP_breg1:
	case DW_OP_breg2:
	case DW_OP_breg3:
	case DW_OP_breg4:
	case DW_OP_breg5:
	case DW_OP_breg6:
	case DW_OP_breg7:
	case DW_OP_breg8:
	case DW_OP_breg9:
	case DW_OP_breg10:
	case DW_OP_breg11:
	case DW_OP_breg12:
	case DW_OP_breg13:
	case DW_OP_breg14:
	case DW_OP_breg15:
	case DW_OP_breg16:
	case DW_OP_breg17:
	case DW_OP_breg18:
	case DW_OP_breg19:
	case DW_OP_breg20:
	case DW_OP_breg21:
	case DW_OP_breg22:
	case DW_OP_breg23:
	case DW_OP_breg24:
	case DW_OP_breg25:
	case DW_OP_breg26:
	case DW_OP_breg27:
	case DW_OP_breg28:
	case DW_OP_breg29:
	case DW_OP_breg30:
	case DW_OP_breg31:
	size += size_of_sleb128 (loc->dw_loc_oprnd1.v.val_int);
	break;
	case DW_OP_regx:
	size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned);
	break;
	case DW_OP_fbreg:
	size += size_of_sleb128 (loc->dw_loc_oprnd1.v.val_int);
	break;
	case DW_OP_bregx:
	size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned);
	size += size_of_sleb128 (loc->dw_loc_oprnd2.v.val_int);
	break;
	case DW_OP_piece:
	size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned);
	break;
	case DW_OP_deref_size:
	case DW_OP_xderef_size:
	size += 1;
	break;
	case DW_OP_call2:
	size += 2;
	break;
	case DW_OP_call4:
	size += 4;
	break;
	case DW_OP_call_ref:
	size += DWARF2_ADDR_SIZE;
	break;
	default:
	break;
	}

	return size;
	}

	/* Return the size of a series of location descriptors. */

	static unsigned long
	size_of_locs (dw_loc_descr_ref loc)
	{
	dw_loc_descr_ref l;
	unsigned long size;

	/* If there are no skip or bra opcodes, don't fill in the dw_loc_addr
	field, to avoid writing to a PCH file. */
	for (size = 0, l = loc; l != NULL; l = l->dw_loc_next)
	{
	if (l->dw_loc_opc == DW_OP_skip \|\| l->dw_loc_opc == DW_OP_bra)
	break;
	size += size_of_loc_descr (l);
	}
	if (! l)
	return size;

	for (size = 0, l = loc; l != NULL; l = l->dw_loc_next)
	{
	l->dw_loc_addr = size;
	size += size_of_loc_descr (l);
	}

	return size;
	}

	/* Output location description stack opcode's operands (if any). */

	static void
	output_loc_operands (dw_loc_descr_ref loc)
	{
	dw_val_ref val1 = &loc->dw_loc_oprnd1;
	dw_val_ref val2 = &loc->dw_loc_oprnd2;

	switch (loc->dw_loc_opc)
	{
	#ifdef DWARF2_DEBUGGING_INFO
	case DW_OP_addr:
	dw2_asm_output_addr_rtx (DWARF2_ADDR_SIZE, val1->v.val_addr, NULL);
	break;
	case DW_OP_const2u:
	case DW_OP_const2s:
	dw2_asm_output_data (2, val1->v.val_int, NULL);
	break;
	case DW_OP_const4u:
	case DW_OP_const4s:
	dw2_asm_output_data (4, val1->v.val_int, NULL);
	break;
	case DW_OP_const8u:
	case DW_OP_const8s:
	gcc_assert (HOST_BITS_PER_LONG >= 64);
	dw2_asm_output_data (8, val1->v.val_int, NULL);
	break;
	case DW_OP_skip:
	case DW_OP_bra:
	{
	int offset;

	gcc_assert (val1->val_class == dw_val_class_loc);
	offset = val1->v.val_loc->dw_loc_addr - (loc->dw_loc_addr + 3);

	dw2_asm_output_data (2, offset, NULL);
	}
	break;
	#else
	case DW_OP_addr:
	case DW_OP_const2u:
	case DW_OP_const2s:
	case DW_OP_const4u:
	case DW_OP_const4s:
	case DW_OP_const8u:
	case DW_OP_const8s:
	case DW_OP_skip:
	case DW_OP_bra:
	/* We currently don't make any attempt to make sure these are
	aligned properly like we do for the main unwind info, so
	don't support emitting things larger than a byte if we're
	only doing unwinding. */
	gcc_unreachable ();
	#endif
	case DW_OP_const1u:
	case DW_OP_const1s:
	dw2_asm_output_data (1, val1->v.val_int, NULL);
	break;
	case DW_OP_constu:
	dw2_asm_output_data_uleb128 (val1->v.val_unsigned, NULL);
	break;
	case DW_OP_consts:
	dw2_asm_output_data_sleb128 (val1->v.val_int, NULL);
	break;
	case DW_OP_pick:
	dw2_asm_output_data (1, val1->v.val_int, NULL);
	break;
	case DW_OP_plus_uconst:
	dw2_asm_output_data_uleb128 (val1->v.val_unsigned, NULL);
	break;
	case DW_OP_breg0:
	case DW_OP_breg1:
	case DW_OP_breg2:
	case DW_OP_breg3:
	case DW_OP_breg4:
	case DW_OP_breg5:
	case DW_OP_breg6:
	case DW_OP_breg7:
	case DW_OP_breg8:
	case DW_OP_breg9:
	case DW_OP_breg10:
	case DW_OP_breg11:
	case DW_OP_breg12:
	case DW_OP_breg13:
	case DW_OP_breg14:
	case DW_OP_breg15:
	case DW_OP_breg16:
	case DW_OP_breg17:
	case DW_OP_breg18:
	case DW_OP_breg19:
	case DW_OP_breg20:
	case DW_OP_breg21:
	case DW_OP_breg22:
	case DW_OP_breg23:
	case DW_OP_breg24:
	case DW_OP_breg25:
	case DW_OP_breg26:
	case DW_OP_breg27:
	case DW_OP_breg28:
	case DW_OP_breg29:
	case DW_OP_breg30:
	case DW_OP_breg31:
	dw2_asm_output_data_sleb128 (val1->v.val_int, NULL);
	break;
	case DW_OP_regx:
	dw2_asm_output_data_uleb128 (val1->v.val_unsigned, NULL);
	break;
	case DW_OP_fbreg:
	dw2_asm_output_data_sleb128 (val1->v.val_int, NULL);
	break;
	case DW_OP_bregx:
	dw2_asm_output_data_uleb128 (val1->v.val_unsigned, NULL);
	dw2_asm_output_data_sleb128 (val2->v.val_int, NULL);
	break;
	case DW_OP_piece:
	dw2_asm_output_data_uleb128 (val1->v.val_unsigned, NULL);
	break;
	case DW_OP_deref_size:
	case DW_OP_xderef_size:
	dw2_asm_output_data (1, val1->v.val_int, NULL);
	break;

	case INTERNAL_DW_OP_tls_addr:
	if (targetm.asm_out.output_dwarf_dtprel)
	{
	targetm.asm_out.output_dwarf_dtprel (asm_out_file,
	DWARF2_ADDR_SIZE,
	val1->v.val_addr);
	fputc ('\n', asm_out_file);
	}
	else
	gcc_unreachable ();
	break;

	default:
	/* Other codes have no operands. */
	break;
	}
	}

	/* Output a sequence of location operations. */

	static void
	output_loc_sequence (dw_loc_descr_ref loc)
	{
	for (; loc != NULL; loc = loc->dw_loc_next)
	{
	/* Output the opcode. */
	dw2_asm_output_data (1, loc->dw_loc_opc,
	"%s", dwarf_stack_op_name (loc->dw_loc_opc));

	/* Output the operand(s) (if any). */
	output_loc_operands (loc);
	}
	}

	/* This routine will generate the correct assembly data for a location
	description based on a cfi entry with a complex address. */

	static void
	output_cfa_loc (dw_cfi_ref cfi)
	{
	dw_loc_descr_ref loc;
	unsigned long size;

	/* Output the size of the block. */
	loc = cfi->dw_cfi_oprnd1.dw_cfi_loc;
	size = size_of_locs (loc);
	dw2_asm_output_data_uleb128 (size, NULL);

	/* Now output the operations themselves. */
	output_loc_sequence (loc);
	}

	/* This function builds a dwarf location descriptor sequence from a
	dw_cfa_location, adding the given OFFSET to the result of the
	expression. */

	static struct dw_loc_descr_struct *
	build_cfa_loc (dw_cfa_location *cfa, HOST_WIDE_INT offset)
	{
	struct dw_loc_descr_struct head, tmp;

	offset += cfa->offset;

	if (cfa->indirect)
	{
	if (cfa->base_offset)
	{
	if (cfa->reg <= 31)
	head = new_loc_descr (DW_OP_breg0 + cfa->reg, cfa->base_offset, 0);
	else
	head = new_loc_descr (DW_OP_bregx, cfa->reg, cfa->base_offset);
	}
	else if (cfa->reg <= 31)
	head = new_loc_descr (DW_OP_reg0 + cfa->reg, 0, 0);
	else
	head = new_loc_descr (DW_OP_regx, cfa->reg, 0);

	head->dw_loc_oprnd1.val_class = dw_val_class_const;
	tmp = new_loc_descr (DW_OP_deref, 0, 0);
	add_loc_descr (&head, tmp);
	if (offset != 0)
	{
	tmp = new_loc_descr (DW_OP_plus_uconst, offset, 0);
	add_loc_descr (&head, tmp);
	}
	}
	else
	{
	if (offset == 0)
	if (cfa->reg <= 31)
	head = new_loc_descr (DW_OP_reg0 + cfa->reg, 0, 0);
	else
	head = new_loc_descr (DW_OP_regx, cfa->reg, 0);
	else if (cfa->reg <= 31)
	head = new_loc_descr (DW_OP_breg0 + cfa->reg, offset, 0);
	else
	head = new_loc_descr (DW_OP_bregx, cfa->reg, offset);
	}

	return head;
	}

	/* This function fills in aa dw_cfa_location structure from a dwarf location
	descriptor sequence. */

	static void
	get_cfa_from_loc_descr (dw_cfa_location cfa, struct dw_loc_descr_struct loc)
	{
	struct dw_loc_descr_struct *ptr;
	cfa->offset = 0;
	cfa->base_offset = 0;
	cfa->indirect = 0;
	cfa->reg = -1;

	for (ptr = loc; ptr != NULL; ptr = ptr->dw_loc_next)
	{
	enum dwarf_location_atom op = ptr->dw_loc_opc;

	switch (op)
	{
	case DW_OP_reg0:
	case DW_OP_reg1:
	case DW_OP_reg2:
	case DW_OP_reg3:
	case DW_OP_reg4:
	case DW_OP_reg5:
	case DW_OP_reg6:
	case DW_OP_reg7:
	case DW_OP_reg8:
	case DW_OP_reg9:
	case DW_OP_reg10:
	case DW_OP_reg11:
	case DW_OP_reg12:
	case DW_OP_reg13:
	case DW_OP_reg14:
	case DW_OP_reg15:
	case DW_OP_reg16:
	case DW_OP_reg17:
	case DW_OP_reg18:
	case DW_OP_reg19:
	case DW_OP_reg20:
	case DW_OP_reg21:
	case DW_OP_reg22:
	case DW_OP_reg23:
	case DW_OP_reg24:
	case DW_OP_reg25:
	case DW_OP_reg26:
	case DW_OP_reg27:
	case DW_OP_reg28:
	case DW_OP_reg29:
	case DW_OP_reg30:
	case DW_OP_reg31:
	cfa->reg = op - DW_OP_reg0;
	break;
	case DW_OP_regx:
	cfa->reg = ptr->dw_loc_oprnd1.v.val_int;
	break;
	case DW_OP_breg0:
	case DW_OP_breg1:
	case DW_OP_breg2:
	case DW_OP_breg3:
	case DW_OP_breg4:
	case DW_OP_breg5:
	case DW_OP_breg6:
	case DW_OP_breg7:
	case DW_OP_breg8:
	case DW_OP_breg9:
	case DW_OP_breg10:
	case DW_OP_breg11:
	case DW_OP_breg12:
	case DW_OP_breg13:
	case DW_OP_breg14:
	case DW_OP_breg15:
	case DW_OP_breg16:
	case DW_OP_breg17:
	case DW_OP_breg18:
	case DW_OP_breg19:
	case DW_OP_breg20:
	case DW_OP_breg21:
	case DW_OP_breg22:
	case DW_OP_breg23:
	case DW_OP_breg24:
	case DW_OP_breg25:
	case DW_OP_breg26:
	case DW_OP_breg27:
	case DW_OP_breg28:
	case DW_OP_breg29:
	case DW_OP_breg30:
	case DW_OP_breg31:
	cfa->reg = op - DW_OP_breg0;
	cfa->base_offset = ptr->dw_loc_oprnd1.v.val_int;
	break;
	case DW_OP_bregx:
	cfa->reg = ptr->dw_loc_oprnd1.v.val_int;
	cfa->base_offset = ptr->dw_loc_oprnd2.v.val_int;
	break;
	case DW_OP_deref:
	cfa->indirect = 1;
	break;
	case DW_OP_plus_uconst:
	cfa->offset = ptr->dw_loc_oprnd1.v.val_unsigned;
	break;
	default:
	internal_error ("DW_LOC_OP %s not implemented",
	dwarf_stack_op_name (ptr->dw_loc_opc));
	}
	}
	}
	#endif /* .debug_frame support */

	/* And now, the support for symbolic debugging information. */
	#ifdef DWARF2_DEBUGGING_INFO

	/* .debug_str support. */
	static int output_indirect_string (void *, void );

	static void dwarf2out_init (const char *);
	static void dwarf2out_finish (const char *);
	static void dwarf2out_define (unsigned int, const char *);
	static void dwarf2out_undef (unsigned int, const char *);
	static void dwarf2out_start_source_file (unsigned, const char *);
	static void dwarf2out_end_source_file (unsigned);
	static void dwarf2out_begin_block (unsigned, unsigned);
	static void dwarf2out_end_block (unsigned, unsigned);
	static bool dwarf2out_ignore_block (tree);
	static void dwarf2out_global_decl (tree);
	static void dwarf2out_type_decl (tree, int);
	static void dwarf2out_imported_module_or_decl (tree, tree);
	static void dwarf2out_abstract_function (tree);
	static void dwarf2out_var_location (rtx);
	static void dwarf2out_begin_function (tree);
	static void dwarf2out_switch_text_section (void);

	/* The debug hooks structure. */

	const struct gcc_debug_hooks dwarf2_debug_hooks =
	{
	dwarf2out_init,
	dwarf2out_finish,
	dwarf2out_define,
	dwarf2out_undef,
	dwarf2out_start_source_file,
	dwarf2out_end_source_file,
	dwarf2out_begin_block,
	dwarf2out_end_block,
	dwarf2out_ignore_block,
	dwarf2out_source_line,
	dwarf2out_begin_prologue,
	debug_nothing_int_charstar, /* end_prologue */
	dwarf2out_end_epilogue,
	dwarf2out_begin_function,
	debug_nothing_int, /* end_function */
	dwarf2out_decl, /* function_decl */
	dwarf2out_global_decl,
	dwarf2out_type_decl, /* type_decl */
	dwarf2out_imported_module_or_decl,
	debug_nothing_tree, /* deferred_inline_function */
	/* The DWARF 2 backend tries to reduce debugging bloat by not
	emitting the abstract description of inline functions until
	something tries to reference them. */
	dwarf2out_abstract_function, /* outlining_inline_function */
	debug_nothing_rtx, /* label */
	debug_nothing_int, /* handle_pch */
	dwarf2out_var_location,
	dwarf2out_switch_text_section,
	1 /* start_end_main_source_file */
	};
	#endif

	/* NOTE: In the comments in this file, many references are made to
	"Debugging Information Entries". This term is abbreviated as `DIE'
	throughout the remainder of this file. */

	/* An internal representation of the DWARF output is built, and then
	walked to generate the DWARF debugging info. The walk of the internal
	representation is done after the entire program has been compiled.
	The types below are used to describe the internal representation. */

	/* Various DIE's use offsets relative to the beginning of the
	.debug_info section to refer to each other. */

	typedef long int dw_offset;

	/* Define typedefs here to avoid circular dependencies. */

	typedef struct dw_attr_struct *dw_attr_ref;
	typedef struct dw_line_info_struct *dw_line_info_ref;
	typedef struct dw_separate_line_info_struct *dw_separate_line_info_ref;
	typedef struct pubname_struct *pubname_ref;
	typedef struct dw_ranges_struct *dw_ranges_ref;

	/* Each entry in the line_info_table maintains the file and
	line number associated with the label generated for that
	entry. The label gives the PC value associated with
	the line number entry. */

	typedef struct dw_line_info_struct GTY(())
	{
	unsigned long dw_file_num;
	unsigned long dw_line_num;
	}
	dw_line_info_entry;

	/* Line information for functions in separate sections; each one gets its
	own sequence. */
	typedef struct dw_separate_line_info_struct GTY(())
	{
	unsigned long dw_file_num;
	unsigned long dw_line_num;
	unsigned long function;
	}
	dw_separate_line_info_entry;

	/* Each DIE attribute has a field specifying the attribute kind,
	a link to the next attribute in the chain, and an attribute value.
	Attributes are typically linked below the DIE they modify. */

	typedef struct dw_attr_struct GTY(())
	{
	enum dwarf_attribute dw_attr;
	dw_val_node dw_attr_val;
	}
	dw_attr_node;

	DEF_VEC_O(dw_attr_node);
	DEF_VEC_ALLOC_O(dw_attr_node,gc);

	/* The Debugging Information Entry (DIE) structure. DIEs form a tree.
	The children of each node form a circular list linked by
	die_sib. die_child points to the node before the "first" child node. */

	typedef struct die_struct GTY(())
	{
	enum dwarf_tag die_tag;
	char *die_symbol;
	VEC(dw_attr_node,gc) * die_attr;
	dw_die_ref die_parent;
	dw_die_ref die_child;
	dw_die_ref die_sib;
	dw_die_ref die_definition; /* ref from a specification to its definition */
	dw_offset die_offset;
	unsigned long die_abbrev;
	int die_mark;
	/* Die is used and must not be pruned as unused. */
	int die_perennial_p;
	unsigned int decl_id;
	}
	die_node;

	/* Evaluate 'expr' while 'c' is set to each child of DIE in order. */
	#define FOR_EACH_CHILD(die, c, expr) do { \
	c = die->die_child; \
	if (c) do { \
	c = c->die_sib; \
	expr; \
	} while (c != die->die_child); \
	} while (0)

	/* The pubname structure */

	typedef struct pubname_struct GTY(())
	{
	dw_die_ref die;
	char *name;
	}
	pubname_entry;

	DEF_VEC_O(pubname_entry);
	DEF_VEC_ALLOC_O(pubname_entry, gc);

	struct dw_ranges_struct GTY(())
	{
	int block_num;
	};

	/* The limbo die list structure. */
	typedef struct limbo_die_struct GTY(())
	{
	dw_die_ref die;
	tree created_for;
	struct limbo_die_struct *next;
	}
	limbo_die_node;

	/* How to start an assembler comment. */
	#ifndef ASM_COMMENT_START
	#define ASM_COMMENT_START ";#"
	#endif

	/* Define a macro which returns nonzero for a TYPE_DECL which was
	implicitly generated for a tagged type.

	Note that unlike the gcc front end (which generates a NULL named
	TYPE_DECL node for each complete tagged type, each array type, and
	each function type node created) the g++ front end generates a
	_named_ TYPE_DECL node for each tagged type node created.
	These TYPE_DECLs have DECL_ARTIFICIAL set, so we know not to
	generate a DW_TAG_typedef DIE for them. */

	#define TYPE_DECL_IS_STUB(decl) \
	(DECL_NAME (decl) == NULL_TREE \
	\|\| (DECL_ARTIFICIAL (decl) \
	&& is_tagged_type (TREE_TYPE (decl)) \
	&& ((decl == TYPE_STUB_DECL (TREE_TYPE (decl))) \
	/* This is necessary for stub decls that \
	appear in nested inline functions. */ \
	\|\| (DECL_ABSTRACT_ORIGIN (decl) != NULL_TREE \
	&& (decl_ultimate_origin (decl) \
	== TYPE_STUB_DECL (TREE_TYPE (decl)))))))

	/* Information concerning the compilation unit's programming
	language, and compiler version. */

	/* Fixed size portion of the DWARF compilation unit header. */
	#define DWARF_COMPILE_UNIT_HEADER_SIZE \
	(DWARF_INITIAL_LENGTH_SIZE + DWARF_OFFSET_SIZE + 3)

	/* Fixed size portion of public names info. */
	#define DWARF_PUBNAMES_HEADER_SIZE (2 * DWARF_OFFSET_SIZE + 2)

	/* Fixed size portion of the address range info. */
	#define DWARF_ARANGES_HEADER_SIZE \
	(DWARF_ROUND (DWARF_INITIAL_LENGTH_SIZE + DWARF_OFFSET_SIZE + 4, \
	DWARF2_ADDR_SIZE * 2) \
	- DWARF_INITIAL_LENGTH_SIZE)

	/* Size of padding portion in the address range info. It must be
	aligned to twice the pointer size. */
	#define DWARF_ARANGES_PAD_SIZE \
	(DWARF_ROUND (DWARF_INITIAL_LENGTH_SIZE + DWARF_OFFSET_SIZE + 4, \
	DWARF2_ADDR_SIZE * 2) \
	- (DWARF_INITIAL_LENGTH_SIZE + DWARF_OFFSET_SIZE + 4))

	/* Use assembler line directives if available. */
	#ifndef DWARF2_ASM_LINE_DEBUG_INFO
	#ifdef HAVE_AS_DWARF2_DEBUG_LINE
	#define DWARF2_ASM_LINE_DEBUG_INFO 1
	#else
	#define DWARF2_ASM_LINE_DEBUG_INFO 0
	#endif
	#endif

	/* Minimum line offset in a special line info. opcode.
	This value was chosen to give a reasonable range of values. */
	#define DWARF_LINE_BASE -10

	/* First special line opcode - leave room for the standard opcodes. */
	#define DWARF_LINE_OPCODE_BASE 10

	/* Range of line offsets in a special line info. opcode. */
	#define DWARF_LINE_RANGE (254-DWARF_LINE_OPCODE_BASE+1)

	/* Flag that indicates the initial value of the is_stmt_start flag.
	In the present implementation, we do not mark any lines as
	the beginning of a source statement, because that information
	is not made available by the GCC front-end. */
	#define DWARF_LINE_DEFAULT_IS_STMT_START 1

	#ifdef DWARF2_DEBUGGING_INFO
	/* This location is used by calc_die_sizes() to keep track
	the offset of each DIE within the .debug_info section. */
	static unsigned long next_die_offset;
	#endif

	/* Record the root of the DIE's built for the current compilation unit. */
	static GTY(()) dw_die_ref comp_unit_die;

	/* A list of DIEs with a NULL parent waiting to be relocated. */
	static GTY(()) limbo_die_node *limbo_die_list;

	/* Filenames referenced by this compilation unit. */
	static GTY((param_is (struct dwarf_file_data))) htab_t file_table;

	/* A hash table of references to DIE's that describe declarations.
	The key is a DECL_UID() which is a unique number identifying each decl. */
	static GTY ((param_is (struct die_struct))) htab_t decl_die_table;

	/* Node of the variable location list. */
	struct var_loc_node GTY ((chain_next ("%h.next")))
	{
	rtx GTY (()) var_loc_note;
	const char * GTY (()) label;
	const char * GTY (()) section_label;
	struct var_loc_node * GTY (()) next;
	};

	/* Variable location list. */
	struct var_loc_list_def GTY (())
	{
	struct var_loc_node * GTY (()) first;

	/* Do not mark the last element of the chained list because
	it is marked through the chain. */
	struct var_loc_node * GTY ((skip ("%h"))) last;

	/* DECL_UID of the variable decl. */
	unsigned int decl_id;
	};
	typedef struct var_loc_list_def var_loc_list;


	/* Table of decl location linked lists. */
	static GTY ((param_is (var_loc_list))) htab_t decl_loc_table;

	/* A pointer to the base of a list of references to DIE's that
	are uniquely identified by their tag, presence/absence of
	children DIE's, and list of attribute/value pairs. */
	static GTY((length ("abbrev_die_table_allocated")))
	dw_die_ref *abbrev_die_table;

	/* Number of elements currently allocated for abbrev_die_table. */
	static GTY(()) unsigned abbrev_die_table_allocated;

	/* Number of elements in type_die_table currently in use. */
	static GTY(()) unsigned abbrev_die_table_in_use;

	/* Size (in elements) of increments by which we may expand the
	abbrev_die_table. */
	#define ABBREV_DIE_TABLE_INCREMENT 256

	/* A pointer to the base of a table that contains line information
	for each source code line in .text in the compilation unit. */
	static GTY((length ("line_info_table_allocated")))
	dw_line_info_ref line_info_table;

	/* Number of elements currently allocated for line_info_table. */
	static GTY(()) unsigned line_info_table_allocated;

	/* Number of elements in line_info_table currently in use. */
	static GTY(()) unsigned line_info_table_in_use;

	/* True if the compilation unit places functions in more than one section. */
	static GTY(()) bool have_multiple_function_sections = false;

	/* A pointer to the base of a table that contains line information
	for each source code line outside of .text in the compilation unit. */
	static GTY ((length ("separate_line_info_table_allocated")))
	dw_separate_line_info_ref separate_line_info_table;

	/* Number of elements currently allocated for separate_line_info_table. */
	static GTY(()) unsigned separate_line_info_table_allocated;

	/* Number of elements in separate_line_info_table currently in use. */
	static GTY(()) unsigned separate_line_info_table_in_use;

	/* Size (in elements) of increments by which we may expand the
	line_info_table. */
	#define LINE_INFO_TABLE_INCREMENT 1024

	/* A pointer to the base of a table that contains a list of publicly
	accessible names. */
	static GTY (()) VEC (pubname_entry, gc) * pubname_table;

	/* A pointer to the base of a table that contains a list of publicly
	accessible types. */
	static GTY (()) VEC (pubname_entry, gc) * pubtype_table;

	/* Array of dies for which we should generate .debug_arange info. */
	static GTY((length ("arange_table_allocated"))) dw_die_ref *arange_table;

	/* Number of elements currently allocated for arange_table. */
	static GTY(()) unsigned arange_table_allocated;

	/* Number of elements in arange_table currently in use. */
	static GTY(()) unsigned arange_table_in_use;

	/* Size (in elements) of increments by which we may expand the
	arange_table. */
	#define ARANGE_TABLE_INCREMENT 64

	/* Array of dies for which we should generate .debug_ranges info. */
	static GTY ((length ("ranges_table_allocated"))) dw_ranges_ref ranges_table;

	/* Number of elements currently allocated for ranges_table. */
	static GTY(()) unsigned ranges_table_allocated;

	/* Number of elements in ranges_table currently in use. */
	static GTY(()) unsigned ranges_table_in_use;

	/* Size (in elements) of increments by which we may expand the
	ranges_table. */
	#define RANGES_TABLE_INCREMENT 64

	/* Whether we have location lists that need outputting */
	static GTY(()) bool have_location_lists;

	/* Unique label counter. */
	static GTY(()) unsigned int loclabel_num;

	#ifdef DWARF2_DEBUGGING_INFO
	/* Record whether the function being analyzed contains inlined functions. */
	static int current_function_has_inlines;
	#endif
	#if 0 && defined (MIPS_DEBUGGING_INFO)
	static int comp_unit_has_inlines;
	#endif

	/* The last file entry emitted by maybe_emit_file(). */
	static GTY(()) struct dwarf_file_data * last_emitted_file;

	/* Number of internal labels generated by gen_internal_sym(). */
	static GTY(()) int label_num;

	/* Cached result of previous call to lookup_filename. */
	static GTY(()) struct dwarf_file_data * file_table_last_lookup;

	#ifdef DWARF2_DEBUGGING_INFO

	/* Offset from the "steady-state frame pointer" to the frame base,
	within the current function. */
	static HOST_WIDE_INT frame_pointer_fb_offset;

	/* Forward declarations for functions defined in this file. */

	static int is_pseudo_reg (rtx);
	static tree type_main_variant (tree);
	static int is_tagged_type (tree);
	static const char *dwarf_tag_name (unsigned);
	static const char *dwarf_attr_name (unsigned);
	static const char *dwarf_form_name (unsigned);
	static tree decl_ultimate_origin (tree);
	static tree block_ultimate_origin (tree);
	static tree decl_class_context (tree);
	static void add_dwarf_attr (dw_die_ref, dw_attr_ref);
	static inline enum dw_val_class AT_class (dw_attr_ref);
	static void add_AT_flag (dw_die_ref, enum dwarf_attribute, unsigned);
	static inline unsigned AT_flag (dw_attr_ref);
	static void add_AT_int (dw_die_ref, enum dwarf_attribute, HOST_WIDE_INT);
	static inline HOST_WIDE_INT AT_int (dw_attr_ref);
	static void add_AT_unsigned (dw_die_ref, enum dwarf_attribute, unsigned HOST_WIDE_INT);
	static inline unsigned HOST_WIDE_INT AT_unsigned (dw_attr_ref);
	static void add_AT_long_long (dw_die_ref, enum dwarf_attribute, unsigned long,
	unsigned long);
	static inline void add_AT_vec (dw_die_ref, enum dwarf_attribute, unsigned int,
	unsigned int, unsigned char *);
	static hashval_t debug_str_do_hash (const void *);
	static int debug_str_eq (const void , const void );
	static void add_AT_string (dw_die_ref, enum dwarf_attribute, const char *);
	static inline const char *AT_string (dw_attr_ref);
	static int AT_string_form (dw_attr_ref);
	static void add_AT_die_ref (dw_die_ref, enum dwarf_attribute, dw_die_ref);
	static void add_AT_specification (dw_die_ref, dw_die_ref);
	static inline dw_die_ref AT_ref (dw_attr_ref);
	static inline int AT_ref_external (dw_attr_ref);
	static inline void set_AT_ref_external (dw_attr_ref, int);
	static void add_AT_fde_ref (dw_die_ref, enum dwarf_attribute, unsigned);
	static void add_AT_loc (dw_die_ref, enum dwarf_attribute, dw_loc_descr_ref);
	static inline dw_loc_descr_ref AT_loc (dw_attr_ref);
	static void add_AT_loc_list (dw_die_ref, enum dwarf_attribute,
	dw_loc_list_ref);
	static inline dw_loc_list_ref AT_loc_list (dw_attr_ref);
	static void add_AT_addr (dw_die_ref, enum dwarf_attribute, rtx);
	static inline rtx AT_addr (dw_attr_ref);
	static void add_AT_lbl_id (dw_die_ref, enum dwarf_attribute, const char *);
	static void add_AT_lineptr (dw_die_ref, enum dwarf_attribute, const char *);
	static void add_AT_macptr (dw_die_ref, enum dwarf_attribute, const char *);
	static void add_AT_offset (dw_die_ref, enum dwarf_attribute,
	unsigned HOST_WIDE_INT);
	static void add_AT_range_list (dw_die_ref, enum dwarf_attribute,
	unsigned long);
	static inline const char *AT_lbl (dw_attr_ref);
	static dw_attr_ref get_AT (dw_die_ref, enum dwarf_attribute);
	static const char *get_AT_low_pc (dw_die_ref);
	static const char *get_AT_hi_pc (dw_die_ref);
	static const char *get_AT_string (dw_die_ref, enum dwarf_attribute);
	static int get_AT_flag (dw_die_ref, enum dwarf_attribute);
	static unsigned get_AT_unsigned (dw_die_ref, enum dwarf_attribute);
	static inline dw_die_ref get_AT_ref (dw_die_ref, enum dwarf_attribute);
	static bool is_c_family (void);
	static bool is_cxx (void);
	static bool is_java (void);
	static bool is_fortran (void);
	static bool is_ada (void);
	static void remove_AT (dw_die_ref, enum dwarf_attribute);
	static void remove_child_TAG (dw_die_ref, enum dwarf_tag);
	static void add_child_die (dw_die_ref, dw_die_ref);
	static dw_die_ref new_die (enum dwarf_tag, dw_die_ref, tree);
	static dw_die_ref lookup_type_die (tree);
	static void equate_type_number_to_die (tree, dw_die_ref);
	static hashval_t decl_die_table_hash (const void *);
	static int decl_die_table_eq (const void , const void );
	static dw_die_ref lookup_decl_die (tree);
	static hashval_t decl_loc_table_hash (const void *);
	static int decl_loc_table_eq (const void , const void );
	static var_loc_list *lookup_decl_loc (tree);
	static void equate_decl_number_to_die (tree, dw_die_ref);
	static void add_var_loc_to_decl (tree, struct var_loc_node *);
	static void print_spaces (FILE *);
	static void print_die (dw_die_ref, FILE *);
	static void print_dwarf_line_table (FILE *);
	static dw_die_ref push_new_compile_unit (dw_die_ref, dw_die_ref);
	static dw_die_ref pop_compile_unit (dw_die_ref);
	static void loc_checksum (dw_loc_descr_ref, struct md5_ctx *);
	static void attr_checksum (dw_attr_ref, struct md5_ctx , int );
	static void die_checksum (dw_die_ref, struct md5_ctx , int );
	static int same_loc_p (dw_loc_descr_ref, dw_loc_descr_ref, int *);
	static int same_dw_val_p (dw_val_node , dw_val_node , int *);
	static int same_attr_p (dw_attr_ref, dw_attr_ref, int *);
	static int same_die_p (dw_die_ref, dw_die_ref, int *);
	static int same_die_p_wrap (dw_die_ref, dw_die_ref);
	static void compute_section_prefix (dw_die_ref);
	static int is_type_die (dw_die_ref);
	static int is_comdat_die (dw_die_ref);
	static int is_symbol_die (dw_die_ref);
	static void assign_symbol_names (dw_die_ref);
	static void break_out_includes (dw_die_ref);
	static hashval_t htab_cu_hash (const void *);
	static int htab_cu_eq (const void , const void );
	static void htab_cu_del (void *);
	static int check_duplicate_cu (dw_die_ref, htab_t, unsigned *);
	static void record_comdat_symbol_number (dw_die_ref, htab_t, unsigned);
	static void add_sibling_attributes (dw_die_ref);
	static void build_abbrev_table (dw_die_ref);
	static void output_location_lists (dw_die_ref);
	static int constant_size (long unsigned);
	static unsigned long size_of_die (dw_die_ref);
	static void calc_die_sizes (dw_die_ref);
	static void mark_dies (dw_die_ref);
	static void unmark_dies (dw_die_ref);
	static void unmark_all_dies (dw_die_ref);
	static unsigned long size_of_pubnames (VEC (pubname_entry,gc) *);
	static unsigned long size_of_aranges (void);
	static enum dwarf_form value_format (dw_attr_ref);
	static void output_value_format (dw_attr_ref);
	static void output_abbrev_section (void);
	static void output_die_symbol (dw_die_ref);
	static void output_die (dw_die_ref);
	static void output_compilation_unit_header (void);
	static void output_comp_unit (dw_die_ref, int);
	static const char *dwarf2_name (tree, int);
	static void add_pubname (tree, dw_die_ref);
	static void add_pubtype (tree, dw_die_ref);
	static void output_pubnames (VEC (pubname_entry,gc) *);
	static void add_arange (tree, dw_die_ref);
	static void output_aranges (void);
	static unsigned int add_ranges (tree);
	static void output_ranges (void);
	static void output_line_info (void);
	static void output_file_names (void);
	static dw_die_ref base_type_die (tree);
	static tree root_type (tree);
	static int is_base_type (tree);
	static bool is_subrange_type (tree);
	static dw_die_ref subrange_type_die (tree, dw_die_ref);
	static dw_die_ref modified_type_die (tree, int, int, dw_die_ref);
	static int type_is_enum (tree);
	static unsigned int dbx_reg_number (rtx);
	static void add_loc_descr_op_piece (dw_loc_descr_ref *, int);
	static dw_loc_descr_ref reg_loc_descriptor (rtx);
	static dw_loc_descr_ref one_reg_loc_descriptor (unsigned int);
	static dw_loc_descr_ref multiple_reg_loc_descriptor (rtx, rtx);
	static dw_loc_descr_ref int_loc_descriptor (HOST_WIDE_INT);
	static dw_loc_descr_ref based_loc_descr (rtx, HOST_WIDE_INT);
	static int is_based_loc (rtx);
	static dw_loc_descr_ref mem_loc_descriptor (rtx, enum machine_mode mode);
	static dw_loc_descr_ref concat_loc_descriptor (rtx, rtx);
	static dw_loc_descr_ref loc_descriptor (rtx);
	static dw_loc_descr_ref loc_descriptor_from_tree_1 (tree, int);
	static dw_loc_descr_ref loc_descriptor_from_tree (tree);
	static HOST_WIDE_INT ceiling (HOST_WIDE_INT, unsigned int);
	static tree field_type (tree);
	static unsigned int simple_type_align_in_bits (tree);
	static unsigned int simple_decl_align_in_bits (tree);
	static unsigned HOST_WIDE_INT simple_type_size_in_bits (tree);
	static HOST_WIDE_INT field_byte_offset (tree);
	static void add_AT_location_description (dw_die_ref, enum dwarf_attribute,
	dw_loc_descr_ref);
	static void add_data_member_location_attribute (dw_die_ref, tree);
	static void add_const_value_attribute (dw_die_ref, rtx);
	static void insert_int (HOST_WIDE_INT, unsigned, unsigned char *);
	static HOST_WIDE_INT extract_int (const unsigned char *, unsigned);
	static void insert_float (rtx, unsigned char *);
	static rtx rtl_for_decl_location (tree);
	static void add_location_or_const_value_attribute (dw_die_ref, tree,
	enum dwarf_attribute);
	static void tree_add_const_value_attribute (dw_die_ref, tree);
	static void add_name_attribute (dw_die_ref, const char *);
	static void add_comp_dir_attribute (dw_die_ref);
	static void add_bound_info (dw_die_ref, enum dwarf_attribute, tree);
	static void add_subscript_info (dw_die_ref, tree);
	static void add_byte_size_attribute (dw_die_ref, tree);
	static void add_bit_offset_attribute (dw_die_ref, tree);
	static void add_bit_size_attribute (dw_die_ref, tree);
	static void add_prototyped_attribute (dw_die_ref, tree);
	static void add_abstract_origin_attribute (dw_die_ref, tree);
	static void add_pure_or_virtual_attribute (dw_die_ref, tree);
	static void add_src_coords_attributes (dw_die_ref, tree);
	static void add_name_and_src_coords_attributes (dw_die_ref, tree);
	static void push_decl_scope (tree);
	static void pop_decl_scope (void);
	static dw_die_ref scope_die_for (tree, dw_die_ref);
	static inline int local_scope_p (dw_die_ref);
	static inline int class_or_namespace_scope_p (dw_die_ref);
	static void add_type_attribute (dw_die_ref, tree, int, int, dw_die_ref);
	static void add_calling_convention_attribute (dw_die_ref, tree);
	static const char *type_tag (tree);
	static tree member_declared_type (tree);
	#if 0
	static const char *decl_start_label (tree);
	#endif
	static void gen_array_type_die (tree, dw_die_ref);
	#if 0
	static void gen_entry_point_die (tree, dw_die_ref);
	#endif
	static void gen_inlined_enumeration_type_die (tree, dw_die_ref);
	static void gen_inlined_structure_type_die (tree, dw_die_ref);
	static void gen_inlined_union_type_die (tree, dw_die_ref);
	static dw_die_ref gen_enumeration_type_die (tree, dw_die_ref);
	static dw_die_ref gen_formal_parameter_die (tree, dw_die_ref);
	static void gen_unspecified_parameters_die (tree, dw_die_ref);
	static void gen_formal_types_die (tree, dw_die_ref);
	static void gen_subprogram_die (tree, dw_die_ref);
	static void gen_variable_die (tree, dw_die_ref);
	static void gen_label_die (tree, dw_die_ref);
	static void gen_lexical_block_die (tree, dw_die_ref, int);
	static void gen_inlined_subroutine_die (tree, dw_die_ref, int);
	static void gen_field_die (tree, dw_die_ref);
	static void gen_ptr_to_mbr_type_die (tree, dw_die_ref);
	static dw_die_ref gen_compile_unit_die (const char *);
	static void gen_inheritance_die (tree, tree, dw_die_ref);
	static void gen_member_die (tree, dw_die_ref);
	static void gen_struct_or_union_type_die (tree, dw_die_ref,
	enum debug_info_usage);
	static void gen_subroutine_type_die (tree, dw_die_ref);
	static void gen_typedef_die (tree, dw_die_ref);
	static void gen_type_die (tree, dw_die_ref);
	static void gen_tagged_type_instantiation_die (tree, dw_die_ref);
	static void gen_block_die (tree, dw_die_ref, int);
	static void decls_for_scope (tree, dw_die_ref, int);
	static int is_redundant_typedef (tree);
	static void gen_namespace_die (tree);
	static void gen_decl_die (tree, dw_die_ref);
	static dw_die_ref force_decl_die (tree);
	static dw_die_ref force_type_die (tree);
	static dw_die_ref setup_namespace_context (tree, dw_die_ref);
	static void declare_in_namespace (tree, dw_die_ref);
	static struct dwarf_file_data * lookup_filename (const char *);
	static void retry_incomplete_types (void);
	static void gen_type_die_for_member (tree, tree, dw_die_ref);
	static void splice_child_die (dw_die_ref, dw_die_ref);
	static int file_info_cmp (const void , const void );
	static dw_loc_list_ref new_loc_list (dw_loc_descr_ref, const char *,
	const char , const char , unsigned);
	static void add_loc_descr_to_loc_list (dw_loc_list_ref *, dw_loc_descr_ref,
	const char , const char ,
	const char *);
	static void output_loc_list (dw_loc_list_ref);
	static char gen_internal_sym (const char );

	static void prune_unmark_dies (dw_die_ref);
	static void prune_unused_types_mark (dw_die_ref, int);
	static void prune_unused_types_walk (dw_die_ref);
	static void prune_unused_types_walk_attribs (dw_die_ref);
	static void prune_unused_types_prune (dw_die_ref);
	static void prune_unused_types (void);
	static int maybe_emit_file (struct dwarf_file_data *fd);

	/* Section names used to hold DWARF debugging information. */
	#ifndef DEBUG_INFO_SECTION
	#define DEBUG_INFO_SECTION ".debug_info"
	#endif
	#ifndef DEBUG_ABBREV_SECTION
	#define DEBUG_ABBREV_SECTION ".debug_abbrev"
	#endif
	#ifndef DEBUG_ARANGES_SECTION
	#define DEBUG_ARANGES_SECTION ".debug_aranges"
	#endif
	#ifndef DEBUG_MACINFO_SECTION
	#define DEBUG_MACINFO_SECTION ".debug_macinfo"
	#endif
	#ifndef DEBUG_LINE_SECTION
	#define DEBUG_LINE_SECTION ".debug_line"
	#endif
	#ifndef DEBUG_LOC_SECTION
	#define DEBUG_LOC_SECTION ".debug_loc"
	#endif
	#ifndef DEBUG_PUBNAMES_SECTION
	#define DEBUG_PUBNAMES_SECTION ".debug_pubnames"
	#endif
	#ifndef DEBUG_STR_SECTION
	#define DEBUG_STR_SECTION ".debug_str"
	#endif
	#ifndef DEBUG_RANGES_SECTION
	#define DEBUG_RANGES_SECTION ".debug_ranges"
	#endif

	/* Standard ELF section names for compiled code and data. */
	#ifndef TEXT_SECTION_NAME
	#define TEXT_SECTION_NAME ".text"
	#endif

	/* Section flags for .debug_str section. */
	#define DEBUG_STR_SECTION_FLAGS \
	(HAVE_GAS_SHF_MERGE && flag_merge_constants \
	? SECTION_DEBUG \| SECTION_MERGE \| SECTION_STRINGS \| 1 \
	: SECTION_DEBUG)

	/* Labels we insert at beginning sections we can reference instead of
	the section names themselves. */

	#ifndef TEXT_SECTION_LABEL
	#define TEXT_SECTION_LABEL "Ltext"
	#endif
	#ifndef COLD_TEXT_SECTION_LABEL
	#define COLD_TEXT_SECTION_LABEL "Ltext_cold"
	#endif
	#ifndef DEBUG_LINE_SECTION_LABEL
	#define DEBUG_LINE_SECTION_LABEL "Ldebug_line"
	#endif
	#ifndef DEBUG_INFO_SECTION_LABEL
	#define DEBUG_INFO_SECTION_LABEL "Ldebug_info"
	#endif
	#ifndef DEBUG_ABBREV_SECTION_LABEL
	#define DEBUG_ABBREV_SECTION_LABEL "Ldebug_abbrev"
	#endif
	#ifndef DEBUG_LOC_SECTION_LABEL
	#define DEBUG_LOC_SECTION_LABEL "Ldebug_loc"
	#endif
	#ifndef DEBUG_RANGES_SECTION_LABEL
	#define DEBUG_RANGES_SECTION_LABEL "Ldebug_ranges"
	#endif
	#ifndef DEBUG_MACINFO_SECTION_LABEL
	#define DEBUG_MACINFO_SECTION_LABEL "Ldebug_macinfo"
	#endif

	/* Definitions of defaults for formats and names of various special
	(artificial) labels which may be generated within this file (when the -g
	options is used and DWARF2_DEBUGGING_INFO is in effect.
	If necessary, these may be overridden from within the tm.h file, but
	typically, overriding these defaults is unnecessary. */

	static char text_end_label[MAX_ARTIFICIAL_LABEL_BYTES];
	static char text_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
	static char cold_text_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
	static char cold_end_label[MAX_ARTIFICIAL_LABEL_BYTES];
	static char abbrev_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
	static char debug_info_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
	static char debug_line_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
	static char macinfo_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
	static char loc_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
	static char ranges_section_label[2 * MAX_ARTIFICIAL_LABEL_BYTES];

	#ifndef TEXT_END_LABEL
	#define TEXT_END_LABEL "Letext"
	#endif
	#ifndef COLD_END_LABEL
	#define COLD_END_LABEL "Letext_cold"
	#endif
	#ifndef BLOCK_BEGIN_LABEL
	#define BLOCK_BEGIN_LABEL "LBB"
	#endif
	#ifndef BLOCK_END_LABEL
	#define BLOCK_END_LABEL "LBE"
	#endif
	#ifndef LINE_CODE_LABEL
	#define LINE_CODE_LABEL "LM"
	#endif
	#ifndef SEPARATE_LINE_CODE_LABEL
	#define SEPARATE_LINE_CODE_LABEL "LSM"
	#endif

	/* We allow a language front-end to designate a function that is to be
	called to "demangle" any name before it is put into a DIE. */

	static const char (demangle_name_func) (const char *);

	void
	dwarf2out_set_demangle_name_func (const char (func) (const char *))
	{
	demangle_name_func = func;
	}

	/* Test if rtl node points to a pseudo register. */

	static inline int
	is_pseudo_reg (rtx rtl)
	{
	return ((REG_P (rtl) && REGNO (rtl) >= FIRST_PSEUDO_REGISTER)
	\|\| (GET_CODE (rtl) == SUBREG
	&& REGNO (SUBREG_REG (rtl)) >= FIRST_PSEUDO_REGISTER));
	}

	/* Return a reference to a type, with its const and volatile qualifiers
	removed. */

	static inline tree
	type_main_variant (tree type)
	{
	type = TYPE_MAIN_VARIANT (type);

	/* ??? There really should be only one main variant among any group of
	variants of a given type (and all of the MAIN_VARIANT values for all
	members of the group should point to that one type) but sometimes the C
	front-end messes this up for array types, so we work around that bug
	here. */
	if (TREE_CODE (type) == ARRAY_TYPE)
	while (type != TYPE_MAIN_VARIANT (type))
	type = TYPE_MAIN_VARIANT (type);

	return type;
	}

	/* Return nonzero if the given type node represents a tagged type. */

	static inline int
	is_tagged_type (tree type)
	{
	enum tree_code code = TREE_CODE (type);

	return (code == RECORD_TYPE \|\| code == UNION_TYPE
	\|\| code == QUAL_UNION_TYPE \|\| code == ENUMERAL_TYPE);
	}

	/* Convert a DIE tag into its string name. */

	static const char *
	dwarf_tag_name (unsigned int tag)
	{
	switch (tag)
	{
	case DW_TAG_padding:
	return "DW_TAG_padding";
	case DW_TAG_array_type:
	return "DW_TAG_array_type";
	case DW_TAG_class_type:
	return "DW_TAG_class_type";
	case DW_TAG_entry_point:
	return "DW_TAG_entry_point";
	case DW_TAG_enumeration_type:
	return "DW_TAG_enumeration_type";
	case DW_TAG_formal_parameter:
	return "DW_TAG_formal_parameter";
	case DW_TAG_imported_declaration:
	return "DW_TAG_imported_declaration";
	case DW_TAG_label:
	return "DW_TAG_label";
	case DW_TAG_lexical_block:
	return "DW_TAG_lexical_block";
	case DW_TAG_member:
	return "DW_TAG_member";
	case DW_TAG_pointer_type:
	return "DW_TAG_pointer_type";
	case DW_TAG_reference_type:
	return "DW_TAG_reference_type";
	case DW_TAG_compile_unit:
	return "DW_TAG_compile_unit";
	case DW_TAG_string_type:
	return "DW_TAG_string_type";
	case DW_TAG_structure_type:
	return "DW_TAG_structure_type";
	case DW_TAG_subroutine_type:
	return "DW_TAG_subroutine_type";
	case DW_TAG_typedef:
	return "DW_TAG_typedef";
	case DW_TAG_union_type:
	return "DW_TAG_union_type";
	case DW_TAG_unspecified_parameters:
	return "DW_TAG_unspecified_parameters";
	case DW_TAG_variant:
	return "DW_TAG_variant";
	case DW_TAG_common_block:
	return "DW_TAG_common_block";
	case DW_TAG_common_inclusion:
	return "DW_TAG_common_inclusion";
	case DW_TAG_inheritance:
	return "DW_TAG_inheritance";
	case DW_TAG_inlined_subroutine:
	return "DW_TAG_inlined_subroutine";
	case DW_TAG_module:
	return "DW_TAG_module";
	case DW_TAG_ptr_to_member_type:
	return "DW_TAG_ptr_to_member_type";
	case DW_TAG_set_type:
	return "DW_TAG_set_type";
	case DW_TAG_subrange_type:
	return "DW_TAG_subrange_type";
	case DW_TAG_with_stmt:
	return "DW_TAG_with_stmt";
	case DW_TAG_access_declaration:
	return "DW_TAG_access_declaration";
	case DW_TAG_base_type:
	return "DW_TAG_base_type";
	case DW_TAG_catch_block:
	return "DW_TAG_catch_block";
	case DW_TAG_const_type:
	return "DW_TAG_const_type";
	case DW_TAG_constant:
	return "DW_TAG_constant";
	case DW_TAG_enumerator:
	return "DW_TAG_enumerator";
	case DW_TAG_file_type:
	return "DW_TAG_file_type";
	case DW_TAG_friend:
	return "DW_TAG_friend";
	case DW_TAG_namelist:
	return "DW_TAG_namelist";
	case DW_TAG_namelist_item:
	return "DW_TAG_namelist_item";
	case DW_TAG_namespace:
	return "DW_TAG_namespace";
	case DW_TAG_packed_type:
	return "DW_TAG_packed_type";
	case DW_TAG_subprogram:
	return "DW_TAG_subprogram";
	case DW_TAG_template_type_param:
	return "DW_TAG_template_type_param";
	case DW_TAG_template_value_param:
	return "DW_TAG_template_value_param";
	case DW_TAG_thrown_type:
	return "DW_TAG_thrown_type";
	case DW_TAG_try_block:
	return "DW_TAG_try_block";
	case DW_TAG_variant_part:
	return "DW_TAG_variant_part";
	case DW_TAG_variable:
	return "DW_TAG_variable";
	case DW_TAG_volatile_type:
	return "DW_TAG_volatile_type";
	case DW_TAG_imported_module:
	return "DW_TAG_imported_module";
	case DW_TAG_MIPS_loop:
	return "DW_TAG_MIPS_loop";
	case DW_TAG_format_label:
	return "DW_TAG_format_label";
	case DW_TAG_function_template:
	return "DW_TAG_function_template";
	case DW_TAG_class_template:
	return "DW_TAG_class_template";
	case DW_TAG_GNU_BINCL:
	return "DW_TAG_GNU_BINCL";
	case DW_TAG_GNU_EINCL:
	return "DW_TAG_GNU_EINCL";
	default:
	return "DW_TAG_<unknown>";
	}
	}

	/* Convert a DWARF attribute code into its string name. */

	static const char *
	dwarf_attr_name (unsigned int attr)
	{
	switch (attr)
	{
	case DW_AT_sibling:
	return "DW_AT_sibling";
	case DW_AT_location:
	return "DW_AT_location";
	case DW_AT_name:
	return "DW_AT_name";
	case DW_AT_ordering:
	return "DW_AT_ordering";
	case DW_AT_subscr_data:
	return "DW_AT_subscr_data";
	case DW_AT_byte_size:
	return "DW_AT_byte_size";
	case DW_AT_bit_offset:
	return "DW_AT_bit_offset";
	case DW_AT_bit_size:
	return "DW_AT_bit_size";
	case DW_AT_element_list:
	return "DW_AT_element_list";
	case DW_AT_stmt_list:
	return "DW_AT_stmt_list";
	case DW_AT_low_pc:
	return "DW_AT_low_pc";
	case DW_AT_high_pc:
	return "DW_AT_high_pc";
	case DW_AT_language:
	return "DW_AT_language";
	case DW_AT_member:
	return "DW_AT_member";
	case DW_AT_discr:
	return "DW_AT_discr";
	case DW_AT_discr_value:
	return "DW_AT_discr_value";
	case DW_AT_visibility:
	return "DW_AT_visibility";
	case DW_AT_import:
	return "DW_AT_import";
	case DW_AT_string_length:
	return "DW_AT_string_length";
	case DW_AT_common_reference:
	return "DW_AT_common_reference";
	case DW_AT_comp_dir:
	return "DW_AT_comp_dir";
	case DW_AT_const_value:
	return "DW_AT_const_value";
	case DW_AT_containing_type:
	return "DW_AT_containing_type";
	case DW_AT_default_value:
	return "DW_AT_default_value";
	case DW_AT_inline:
	return "DW_AT_inline";
	case DW_AT_is_optional:
	return "DW_AT_is_optional";
	case DW_AT_lower_bound:
	return "DW_AT_lower_bound";
	case DW_AT_producer:
	return "DW_AT_producer";
	case DW_AT_prototyped:
	return "DW_AT_prototyped";
	case DW_AT_return_addr:
	return "DW_AT_return_addr";
	case DW_AT_start_scope:
	return "DW_AT_start_scope";
	case DW_AT_stride_size:
	return "DW_AT_stride_size";
	case DW_AT_upper_bound:
	return "DW_AT_upper_bound";
	case DW_AT_abstract_origin:
	return "DW_AT_abstract_origin";
	case DW_AT_accessibility:
	return "DW_AT_accessibility";
	case DW_AT_address_class:
	return "DW_AT_address_class";
	case DW_AT_artificial:
	return "DW_AT_artificial";
	case DW_AT_base_types:
	return "DW_AT_base_types";
	case DW_AT_calling_convention:
	return "DW_AT_calling_convention";
	case DW_AT_count:
	return "DW_AT_count";
	case DW_AT_data_member_location:
	return "DW_AT_data_member_location";
	case DW_AT_decl_column:
	return "DW_AT_decl_column";
	case DW_AT_decl_file:
	return "DW_AT_decl_file";
	case DW_AT_decl_line:
	return "DW_AT_decl_line";
	case DW_AT_declaration:
	return "DW_AT_declaration";
	case DW_AT_discr_list:
	return "DW_AT_discr_list";
	case DW_AT_encoding:
	return "DW_AT_encoding";
	case DW_AT_external:
	return "DW_AT_external";
	case DW_AT_frame_base:
	return "DW_AT_frame_base";
	case DW_AT_friend:
	return "DW_AT_friend";
	case DW_AT_identifier_case:
	return "DW_AT_identifier_case";
	case DW_AT_macro_info:
	return "DW_AT_macro_info";
	case DW_AT_namelist_items:
	return "DW_AT_namelist_items";
	case DW_AT_priority:
	return "DW_AT_priority";
	case DW_AT_segment:
	return "DW_AT_segment";
	case DW_AT_specification:
	return "DW_AT_specification";
	case DW_AT_static_link:
	return "DW_AT_static_link";
	case DW_AT_type:
	return "DW_AT_type";
	case DW_AT_use_location:
	return "DW_AT_use_location";
	case DW_AT_variable_parameter:
	return "DW_AT_variable_parameter";
	case DW_AT_virtuality:
	return "DW_AT_virtuality";
	case DW_AT_vtable_elem_location:
	return "DW_AT_vtable_elem_location";

	case DW_AT_allocated:
	return "DW_AT_allocated";
	case DW_AT_associated:
	return "DW_AT_associated";
	case DW_AT_data_location:
	return "DW_AT_data_location";
	case DW_AT_stride:
	return "DW_AT_stride";
	case DW_AT_entry_pc:
	return "DW_AT_entry_pc";
	case DW_AT_use_UTF8:
	return "DW_AT_use_UTF8";
	case DW_AT_extension:
	return "DW_AT_extension";
	case DW_AT_ranges:
	return "DW_AT_ranges";
	case DW_AT_trampoline:
	return "DW_AT_trampoline";
	case DW_AT_call_column:
	return "DW_AT_call_column";
	case DW_AT_call_file:
	return "DW_AT_call_file";
	case DW_AT_call_line:
	return "DW_AT_call_line";

	case DW_AT_MIPS_fde:
	return "DW_AT_MIPS_fde";
	case DW_AT_MIPS_loop_begin:
	return "DW_AT_MIPS_loop_begin";
	case DW_AT_MIPS_tail_loop_begin:
	return "DW_AT_MIPS_tail_loop_begin";
	case DW_AT_MIPS_epilog_begin:
	return "DW_AT_MIPS_epilog_begin";
	case DW_AT_MIPS_loop_unroll_factor:
	return "DW_AT_MIPS_loop_unroll_factor";
	case DW_AT_MIPS_software_pipeline_depth:
	return "DW_AT_MIPS_software_pipeline_depth";
	case DW_AT_MIPS_linkage_name:
	return "DW_AT_MIPS_linkage_name";
	case DW_AT_MIPS_stride:
	return "DW_AT_MIPS_stride";
	case DW_AT_MIPS_abstract_name:
	return "DW_AT_MIPS_abstract_name";
	case DW_AT_MIPS_clone_origin:
	return "DW_AT_MIPS_clone_origin";
	case DW_AT_MIPS_has_inlines:
	return "DW_AT_MIPS_has_inlines";

	case DW_AT_sf_names:
	return "DW_AT_sf_names";
	case DW_AT_src_info:
	return "DW_AT_src_info";
	case DW_AT_mac_info:
	return "DW_AT_mac_info";
	case DW_AT_src_coords:
	return "DW_AT_src_coords";
	case DW_AT_body_begin:
	return "DW_AT_body_begin";
	case DW_AT_body_end:
	return "DW_AT_body_end";
	case DW_AT_GNU_vector:
	return "DW_AT_GNU_vector";

	case DW_AT_VMS_rtnbeg_pd_address:
	return "DW_AT_VMS_rtnbeg_pd_address";

	default:
	return "DW_AT_<unknown>";
	}
	}

	/* Convert a DWARF value form code into its string name. */

	static const char *
	dwarf_form_name (unsigned int form)
	{
	switch (form)
	{
	case DW_FORM_addr:
	return "DW_FORM_addr";
	case DW_FORM_block2:
	return "DW_FORM_block2";
	case DW_FORM_block4:
	return "DW_FORM_block4";
	case DW_FORM_data2:
	return "DW_FORM_data2";
	case DW_FORM_data4:
	return "DW_FORM_data4";
	case DW_FORM_data8:
	return "DW_FORM_data8";
	case DW_FORM_string:
	return "DW_FORM_string";
	case DW_FORM_block:
	return "DW_FORM_block";
	case DW_FORM_block1:
	return "DW_FORM_block1";
	case DW_FORM_data1:
	return "DW_FORM_data1";
	case DW_FORM_flag:
	return "DW_FORM_flag";
	case DW_FORM_sdata:
	return "DW_FORM_sdata";
	case DW_FORM_strp:
	return "DW_FORM_strp";
	case DW_FORM_udata:
	return "DW_FORM_udata";
	case DW_FORM_ref_addr:
	return "DW_FORM_ref_addr";
	case DW_FORM_ref1:
	return "DW_FORM_ref1";
	case DW_FORM_ref2:
	return "DW_FORM_ref2";
	case DW_FORM_ref4:
	return "DW_FORM_ref4";
	case DW_FORM_ref8:
	return "DW_FORM_ref8";
	case DW_FORM_ref_udata:
	return "DW_FORM_ref_udata";
	case DW_FORM_indirect:
	return "DW_FORM_indirect";
	default:
	return "DW_FORM_<unknown>";
	}
	}

	/* Determine the "ultimate origin" of a decl. The decl may be an inlined
	instance of an inlined instance of a decl which is local to an inline
	function, so we have to trace all of the way back through the origin chain
	to find out what sort of node actually served as the original seed for the
	given block. */

	static tree
	decl_ultimate_origin (tree decl)
	{
	if (!CODE_CONTAINS_STRUCT (TREE_CODE (decl), TS_DECL_COMMON))
	return NULL_TREE;

	/* output_inline_function sets DECL_ABSTRACT_ORIGIN for all the
	nodes in the function to point to themselves; ignore that if
	we're trying to output the abstract instance of this function. */
	if (DECL_ABSTRACT (decl) && DECL_ABSTRACT_ORIGIN (decl) == decl)
	return NULL_TREE;

	/* Since the DECL_ABSTRACT_ORIGIN for a DECL is supposed to be the
	most distant ancestor, this should never happen. */
	gcc_assert (!DECL_FROM_INLINE (DECL_ORIGIN (decl)));

	return DECL_ABSTRACT_ORIGIN (decl);
	}

	/* Determine the "ultimate origin" of a block. The block may be an inlined
	instance of an inlined instance of a block which is local to an inline
	function, so we have to trace all of the way back through the origin chain
	to find out what sort of node actually served as the original seed for the
	given block. */

	static tree
	block_ultimate_origin (tree block)
	{
	tree immediate_origin = BLOCK_ABSTRACT_ORIGIN (block);

	/* output_inline_function sets BLOCK_ABSTRACT_ORIGIN for all the
	nodes in the function to point to themselves; ignore that if
	we're trying to output the abstract instance of this function. */
	if (BLOCK_ABSTRACT (block) && immediate_origin == block)
	return NULL_TREE;

	if (immediate_origin == NULL_TREE)
	return NULL_TREE;
	else
	{
	tree ret_val;
	tree lookahead = immediate_origin;

	do
	{
	ret_val = lookahead;
	lookahead = (TREE_CODE (ret_val) == BLOCK
	? BLOCK_ABSTRACT_ORIGIN (ret_val) : NULL);
	}
	while (lookahead != NULL && lookahead != ret_val);

	/* The block's abstract origin chain may not be the ultimate origin of
	the block. It could lead to a DECL that has an abstract origin set.
	If so, we want that DECL's abstract origin (which is what DECL_ORIGIN
	will give us if it has one). Note that DECL's abstract origins are
	supposed to be the most distant ancestor (or so decl_ultimate_origin
	claims), so we don't need to loop following the DECL origins. */
	if (DECL_P (ret_val))
	return DECL_ORIGIN (ret_val);

	return ret_val;
	}
	}

	/* Get the class to which DECL belongs, if any. In g++, the DECL_CONTEXT
	of a virtual function may refer to a base class, so we check the 'this'
	parameter. */

	static tree
	decl_class_context (tree decl)
	{
	tree context = NULL_TREE;

	if (TREE_CODE (decl) != FUNCTION_DECL \|\| ! DECL_VINDEX (decl))
	context = DECL_CONTEXT (decl);
	else
	context = TYPE_MAIN_VARIANT
	(TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (decl)))));

	if (context && !TYPE_P (context))
	context = NULL_TREE;

	return context;
	}

	/* Add an attribute/value pair to a DIE. */

	static inline void
	add_dwarf_attr (dw_die_ref die, dw_attr_ref attr)
	{
	/* Maybe this should be an assert? */
	if (die == NULL)
	return;

	if (die->die_attr == NULL)
	die->die_attr = VEC_alloc (dw_attr_node, gc, 1);
	VEC_safe_push (dw_attr_node, gc, die->die_attr, attr);
	}

	static inline enum dw_val_class
	AT_class (dw_attr_ref a)
	{
	return a->dw_attr_val.val_class;
	}

	/* Add a flag value attribute to a DIE. */

	static inline void
	add_AT_flag (dw_die_ref die, enum dwarf_attribute attr_kind, unsigned int flag)
	{
	dw_attr_node attr;

	attr.dw_attr = attr_kind;
	attr.dw_attr_val.val_class = dw_val_class_flag;
	attr.dw_attr_val.v.val_flag = flag;
	add_dwarf_attr (die, &attr);
	}

	static inline unsigned
	AT_flag (dw_attr_ref a)
	{
	gcc_assert (a && AT_class (a) == dw_val_class_flag);
	return a->dw_attr_val.v.val_flag;
	}

	/* Add a signed integer attribute value to a DIE. */

	static inline void
	add_AT_int (dw_die_ref die, enum dwarf_attribute attr_kind, HOST_WIDE_INT int_val)
	{
	dw_attr_node attr;

	attr.dw_attr = attr_kind;
	attr.dw_attr_val.val_class = dw_val_class_const;
	attr.dw_attr_val.v.val_int = int_val;
	add_dwarf_attr (die, &attr);
	}

	static inline HOST_WIDE_INT
	AT_int (dw_attr_ref a)
	{
	gcc_assert (a && AT_class (a) == dw_val_class_const);
	return a->dw_attr_val.v.val_int;
	}

	/* Add an unsigned integer attribute value to a DIE. */

	static inline void
	add_AT_unsigned (dw_die_ref die, enum dwarf_attribute attr_kind,
	unsigned HOST_WIDE_INT unsigned_val)
	{
	dw_attr_node attr;

	attr.dw_attr = attr_kind;
	attr.dw_attr_val.val_class = dw_val_class_unsigned_const;
	attr.dw_attr_val.v.val_unsigned = unsigned_val;
	add_dwarf_attr (die, &attr);
	}

	static inline unsigned HOST_WIDE_INT
	AT_unsigned (dw_attr_ref a)
	{
	gcc_assert (a && AT_class (a) == dw_val_class_unsigned_const);
	return a->dw_attr_val.v.val_unsigned;
	}

	/* Add an unsigned double integer attribute value to a DIE. */

	static inline void
	add_AT_long_long (dw_die_ref die, enum dwarf_attribute attr_kind,
	long unsigned int val_hi, long unsigned int val_low)
	{
	dw_attr_node attr;

	attr.dw_attr = attr_kind;
	attr.dw_attr_val.val_class = dw_val_class_long_long;
	attr.dw_attr_val.v.val_long_long.hi = val_hi;
	attr.dw_attr_val.v.val_long_long.low = val_low;
	add_dwarf_attr (die, &attr);
	}

	/* Add a floating point attribute value to a DIE and return it. */

	static inline void
	add_AT_vec (dw_die_ref die, enum dwarf_attribute attr_kind,
	unsigned int length, unsigned int elt_size, unsigned char *array)
	{
	dw_attr_node attr;

	attr.dw_attr = attr_kind;
	attr.dw_attr_val.val_class = dw_val_class_vec;
	attr.dw_attr_val.v.val_vec.length = length;
	attr.dw_attr_val.v.val_vec.elt_size = elt_size;
	attr.dw_attr_val.v.val_vec.array = array;
	add_dwarf_attr (die, &attr);
	}

	/* Hash and equality functions for debug_str_hash. */

	static hashval_t
	debug_str_do_hash (const void *x)
	{
	return htab_hash_string (((const struct indirect_string_node *)x)->str);
	}

	static int
	debug_str_eq (const void x1, const void x2)
	{
	return strcmp ((((const struct indirect_string_node *)x1)->str),
	(const char *)x2) == 0;
	}

	/* Add a string attribute value to a DIE. */

	static inline void
	add_AT_string (dw_die_ref die, enum dwarf_attribute attr_kind, const char *str)
	{
	dw_attr_node attr;
	struct indirect_string_node *node;
	void **slot;

	if (! debug_str_hash)
	debug_str_hash = htab_create_ggc (10, debug_str_do_hash,
	debug_str_eq, NULL);

	slot = htab_find_slot_with_hash (debug_str_hash, str,
	htab_hash_string (str), INSERT);
	if (*slot == NULL)
	*slot = ggc_alloc_cleared (sizeof (struct indirect_string_node));
	node = (struct indirect_string_node ) slot;
	node->str = ggc_strdup (str);
	node->refcount++;

	attr.dw_attr = attr_kind;
	attr.dw_attr_val.val_class = dw_val_class_str;
	attr.dw_attr_val.v.val_str = node;
	add_dwarf_attr (die, &attr);
	}

	static inline const char *
	AT_string (dw_attr_ref a)
	{
	gcc_assert (a && AT_class (a) == dw_val_class_str);
	return a->dw_attr_val.v.val_str->str;
	}

	/* Find out whether a string should be output inline in DIE
	or out-of-line in .debug_str section. */

	static int
	AT_string_form (dw_attr_ref a)
	{
	struct indirect_string_node *node;
	unsigned int len;
	char label[32];

	gcc_assert (a && AT_class (a) == dw_val_class_str);

	node = a->dw_attr_val.v.val_str;
	if (node->form)
	return node->form;

	len = strlen (node->str) + 1;

	/* If the string is shorter or equal to the size of the reference, it is
	always better to put it inline. */
	if (len <= DWARF_OFFSET_SIZE \|\| node->refcount == 0)
	return node->form = DW_FORM_string;

	/* If we cannot expect the linker to merge strings in .debug_str
	section, only put it into .debug_str if it is worth even in this
	single module. */
	if ((debug_str_section->common.flags & SECTION_MERGE) == 0
	&& (len - DWARF_OFFSET_SIZE) * node->refcount <= len)
	return node->form = DW_FORM_string;

	ASM_GENERATE_INTERNAL_LABEL (label, "LASF", dw2_string_counter);
	++dw2_string_counter;
	node->label = xstrdup (label);

	return node->form = DW_FORM_strp;
	}

	/* Add a DIE reference attribute value to a DIE. */

	static inline void
	add_AT_die_ref (dw_die_ref die, enum dwarf_attribute attr_kind, dw_die_ref targ_die)
	{
	dw_attr_node attr;

	attr.dw_attr = attr_kind;
	attr.dw_attr_val.val_class = dw_val_class_die_ref;
	attr.dw_attr_val.v.val_die_ref.die = targ_die;
	attr.dw_attr_val.v.val_die_ref.external = 0;
	add_dwarf_attr (die, &attr);
	}

	/* Add an AT_specification attribute to a DIE, and also make the back
	pointer from the specification to the definition. */

	static inline void
	add_AT_specification (dw_die_ref die, dw_die_ref targ_die)
	{
	add_AT_die_ref (die, DW_AT_specification, targ_die);
	gcc_assert (!targ_die->die_definition);
	targ_die->die_definition = die;
	}

	static inline dw_die_ref
	AT_ref (dw_attr_ref a)
	{
	gcc_assert (a && AT_class (a) == dw_val_class_die_ref);
	return a->dw_attr_val.v.val_die_ref.die;
	}

	static inline int
	AT_ref_external (dw_attr_ref a)
	{
	if (a && AT_class (a) == dw_val_class_die_ref)
	return a->dw_attr_val.v.val_die_ref.external;

	return 0;
	}

	static inline void
	set_AT_ref_external (dw_attr_ref a, int i)
	{
	gcc_assert (a && AT_class (a) == dw_val_class_die_ref);
	a->dw_attr_val.v.val_die_ref.external = i;
	}

	/* Add an FDE reference attribute value to a DIE. */

	static inline void
	add_AT_fde_ref (dw_die_ref die, enum dwarf_attribute attr_kind, unsigned int targ_fde)
	{
	dw_attr_node attr;

	attr.dw_attr = attr_kind;
	attr.dw_attr_val.val_class = dw_val_class_fde_ref;
	attr.dw_attr_val.v.val_fde_index = targ_fde;
	add_dwarf_attr (die, &attr);
	}

	/* Add a location description attribute value to a DIE. */

	static inline void
	add_AT_loc (dw_die_ref die, enum dwarf_attribute attr_kind, dw_loc_descr_ref loc)
	{
	dw_attr_node attr;

	attr.dw_attr = attr_kind;
	attr.dw_attr_val.val_class = dw_val_class_loc;
	attr.dw_attr_val.v.val_loc = loc;
	add_dwarf_attr (die, &attr);
	}

	static inline dw_loc_descr_ref
	AT_loc (dw_attr_ref a)
	{
	gcc_assert (a && AT_class (a) == dw_val_class_loc);
	return a->dw_attr_val.v.val_loc;
	}

	static inline void
	add_AT_loc_list (dw_die_ref die, enum dwarf_attribute attr_kind, dw_loc_list_ref loc_list)
	{
	dw_attr_node attr;

	attr.dw_attr = attr_kind;
	attr.dw_attr_val.val_class = dw_val_class_loc_list;
	attr.dw_attr_val.v.val_loc_list = loc_list;
	add_dwarf_attr (die, &attr);
	have_location_lists = true;
	}

	static inline dw_loc_list_ref
	AT_loc_list (dw_attr_ref a)
	{
	gcc_assert (a && AT_class (a) == dw_val_class_loc_list);
	return a->dw_attr_val.v.val_loc_list;
	}

	/* Add an address constant attribute value to a DIE. */

	static inline void
	add_AT_addr (dw_die_ref die, enum dwarf_attribute attr_kind, rtx addr)
	{
	dw_attr_node attr;

	attr.dw_attr = attr_kind;
	attr.dw_attr_val.val_class = dw_val_class_addr;
	attr.dw_attr_val.v.val_addr = addr;
	add_dwarf_attr (die, &attr);
	}

	/* Get the RTX from to an address DIE attribute. */

	static inline rtx
	AT_addr (dw_attr_ref a)
	{
	gcc_assert (a && AT_class (a) == dw_val_class_addr);
	return a->dw_attr_val.v.val_addr;
	}

	/* Add a file attribute value to a DIE. */

	static inline void
	add_AT_file (dw_die_ref die, enum dwarf_attribute attr_kind,
	struct dwarf_file_data *fd)
	{
	dw_attr_node attr;

	attr.dw_attr = attr_kind;
	attr.dw_attr_val.val_class = dw_val_class_file;
	attr.dw_attr_val.v.val_file = fd;
	add_dwarf_attr (die, &attr);
	}

	/* Get the dwarf_file_data from a file DIE attribute. */

	static inline struct dwarf_file_data *
	AT_file (dw_attr_ref a)
	{
	gcc_assert (a && AT_class (a) == dw_val_class_file);
	return a->dw_attr_val.v.val_file;
	}

	/* Add a label identifier attribute value to a DIE. */

	static inline void
	add_AT_lbl_id (dw_die_ref die, enum dwarf_attribute attr_kind, const char *lbl_id)
	{
	dw_attr_node attr;

	attr.dw_attr = attr_kind;
	attr.dw_attr_val.val_class = dw_val_class_lbl_id;
	attr.dw_attr_val.v.val_lbl_id = xstrdup (lbl_id);
	add_dwarf_attr (die, &attr);
	}

	/* Add a section offset attribute value to a DIE, an offset into the
	debug_line section. */

	static inline void
	add_AT_lineptr (dw_die_ref die, enum dwarf_attribute attr_kind,
	const char *label)
	{
	dw_attr_node attr;

	attr.dw_attr = attr_kind;
	attr.dw_attr_val.val_class = dw_val_class_lineptr;
	attr.dw_attr_val.v.val_lbl_id = xstrdup (label);
	add_dwarf_attr (die, &attr);
	}

	/* Add a section offset attribute value to a DIE, an offset into the
	debug_macinfo section. */

	static inline void
	add_AT_macptr (dw_die_ref die, enum dwarf_attribute attr_kind,
	const char *label)
	{
	dw_attr_node attr;

	attr.dw_attr = attr_kind;
	attr.dw_attr_val.val_class = dw_val_class_macptr;
	attr.dw_attr_val.v.val_lbl_id = xstrdup (label);
	add_dwarf_attr (die, &attr);
	}

	/* Add an offset attribute value to a DIE. */

	static inline void
	add_AT_offset (dw_die_ref die, enum dwarf_attribute attr_kind,
	unsigned HOST_WIDE_INT offset)
	{
	dw_attr_node attr;

	attr.dw_attr = attr_kind;
	attr.dw_attr_val.val_class = dw_val_class_offset;
	attr.dw_attr_val.v.val_offset = offset;
	add_dwarf_attr (die, &attr);
	}

	/* Add an range_list attribute value to a DIE. */

	static void
	add_AT_range_list (dw_die_ref die, enum dwarf_attribute attr_kind,
	long unsigned int offset)
	{
	dw_attr_node attr;

	attr.dw_attr = attr_kind;
	attr.dw_attr_val.val_class = dw_val_class_range_list;
	attr.dw_attr_val.v.val_offset = offset;
	add_dwarf_attr (die, &attr);
	}

	static inline const char *
	AT_lbl (dw_attr_ref a)
	{
	gcc_assert (a && (AT_class (a) == dw_val_class_lbl_id
	\|\| AT_class (a) == dw_val_class_lineptr
	\|\| AT_class (a) == dw_val_class_macptr));
	return a->dw_attr_val.v.val_lbl_id;
	}

	/* Get the attribute of type attr_kind. */

	static dw_attr_ref
	get_AT (dw_die_ref die, enum dwarf_attribute attr_kind)
	{
	dw_attr_ref a;
	unsigned ix;
	dw_die_ref spec = NULL;

	if (! die)
	return NULL;

	for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, a); ix++)
	if (a->dw_attr == attr_kind)
	return a;
	else if (a->dw_attr == DW_AT_specification
	\|\| a->dw_attr == DW_AT_abstract_origin)
	spec = AT_ref (a);

	if (spec)
	return get_AT (spec, attr_kind);

	return NULL;
	}

	/* Return the "low pc" attribute value, typically associated with a subprogram
	DIE. Return null if the "low pc" attribute is either not present, or if it
	cannot be represented as an assembler label identifier. */

	static inline const char *
	get_AT_low_pc (dw_die_ref die)
	{
	dw_attr_ref a = get_AT (die, DW_AT_low_pc);

	return a ? AT_lbl (a) : NULL;
	}

	/* Return the "high pc" attribute value, typically associated with a subprogram
	DIE. Return null if the "high pc" attribute is either not present, or if it
	cannot be represented as an assembler label identifier. */

	static inline const char *
	get_AT_hi_pc (dw_die_ref die)
	{
	dw_attr_ref a = get_AT (die, DW_AT_high_pc);

	return a ? AT_lbl (a) : NULL;
	}

	/* Return the value of the string attribute designated by ATTR_KIND, or
	NULL if it is not present. */

	static inline const char *
	get_AT_string (dw_die_ref die, enum dwarf_attribute attr_kind)
	{
	dw_attr_ref a = get_AT (die, attr_kind);

	return a ? AT_string (a) : NULL;
	}

	/* Return the value of the flag attribute designated by ATTR_KIND, or -1
	if it is not present. */

	static inline int
	get_AT_flag (dw_die_ref die, enum dwarf_attribute attr_kind)
	{
	dw_attr_ref a = get_AT (die, attr_kind);

	return a ? AT_flag (a) : 0;
	}

	/* Return the value of the unsigned attribute designated by ATTR_KIND, or 0
	if it is not present. */

	static inline unsigned
	get_AT_unsigned (dw_die_ref die, enum dwarf_attribute attr_kind)
	{
	dw_attr_ref a = get_AT (die, attr_kind);

	return a ? AT_unsigned (a) : 0;
	}

	static inline dw_die_ref
	get_AT_ref (dw_die_ref die, enum dwarf_attribute attr_kind)
	{
	dw_attr_ref a = get_AT (die, attr_kind);

	return a ? AT_ref (a) : NULL;
	}

	static inline struct dwarf_file_data *
	get_AT_file (dw_die_ref die, enum dwarf_attribute attr_kind)
	{
	dw_attr_ref a = get_AT (die, attr_kind);

	return a ? AT_file (a) : NULL;
	}

	/* Return TRUE if the language is C or C++. */

	static inline bool
	is_c_family (void)
	{
	unsigned int lang = get_AT_unsigned (comp_unit_die, DW_AT_language);

	return (lang == DW_LANG_C \|\| lang == DW_LANG_C89 \|\| lang == DW_LANG_ObjC
	\|\| lang == DW_LANG_C99
	\|\| lang == DW_LANG_C_plus_plus \|\| lang == DW_LANG_ObjC_plus_plus);
	}

	/* Return TRUE if the language is C++. */

	static inline bool
	is_cxx (void)
	{
	unsigned int lang = get_AT_unsigned (comp_unit_die, DW_AT_language);

	return lang == DW_LANG_C_plus_plus \|\| lang == DW_LANG_ObjC_plus_plus;
	}

	/* Return TRUE if the language is Fortran. */

	static inline bool
	is_fortran (void)
	{
	unsigned int lang = get_AT_unsigned (comp_unit_die, DW_AT_language);

	return (lang == DW_LANG_Fortran77
	\|\| lang == DW_LANG_Fortran90
	\|\| lang == DW_LANG_Fortran95);
	}

	/* Return TRUE if the language is Java. */

	static inline bool
	is_java (void)
	{
	unsigned int lang = get_AT_unsigned (comp_unit_die, DW_AT_language);

	return lang == DW_LANG_Java;
	}

	/* Return TRUE if the language is Ada. */

	static inline bool
	is_ada (void)
	{
	unsigned int lang = get_AT_unsigned (comp_unit_die, DW_AT_language);

	return lang == DW_LANG_Ada95 \|\| lang == DW_LANG_Ada83;
	}

	/* Remove the specified attribute if present. */

	static void
	remove_AT (dw_die_ref die, enum dwarf_attribute attr_kind)
	{
	dw_attr_ref a;
	unsigned ix;

	if (! die)
	return;

	for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, a); ix++)
	if (a->dw_attr == attr_kind)
	{
	if (AT_class (a) == dw_val_class_str)
	if (a->dw_attr_val.v.val_str->refcount)
	a->dw_attr_val.v.val_str->refcount--;

	/* VEC_ordered_remove should help reduce the number of abbrevs
	that are needed. */
	VEC_ordered_remove (dw_attr_node, die->die_attr, ix);
	return;
	}
	}

	/* Remove CHILD from its parent. PREV must have the property that
	PREV->DIE_SIB == CHILD. Does not alter CHILD. */

	static void
	remove_child_with_prev (dw_die_ref child, dw_die_ref prev)
	{
	gcc_assert (child->die_parent == prev->die_parent);
	gcc_assert (prev->die_sib == child);
	if (prev == child)
	{
	gcc_assert (child->die_parent->die_child == child);
	prev = NULL;
	}
	else
	prev->die_sib = child->die_sib;
	if (child->die_parent->die_child == child)
	child->die_parent->die_child = prev;
	}

	/* Remove child DIE whose die_tag is TAG. Do nothing if no child
	matches TAG. */

	static void
	remove_child_TAG (dw_die_ref die, enum dwarf_tag tag)
	{
	dw_die_ref c;

	c = die->die_child;
	if (c) do {
	dw_die_ref prev = c;
	c = c->die_sib;
	while (c->die_tag == tag)
	{
	remove_child_with_prev (c, prev);
	/* Might have removed every child. */
	if (c == c->die_sib)
	return;
	c = c->die_sib;
	}
	} while (c != die->die_child);
	}

	/* Add a CHILD_DIE as the last child of DIE. */

	static void
	add_child_die (dw_die_ref die, dw_die_ref child_die)
	{
	/* FIXME this should probably be an assert. */
	if (! die \|\| ! child_die)
	return;
	gcc_assert (die != child_die);

	child_die->die_parent = die;
	if (die->die_child)
	{
	child_die->die_sib = die->die_child->die_sib;
	die->die_child->die_sib = child_die;
	}
	else
	child_die->die_sib = child_die;
	die->die_child = child_die;
	}

	/* Move CHILD, which must be a child of PARENT or the DIE for which PARENT
	is the specification, to the end of PARENT's list of children.
	This is done by removing and re-adding it. */

	static void
	splice_child_die (dw_die_ref parent, dw_die_ref child)
	{
	dw_die_ref p;

	/* We want the declaration DIE from inside the class, not the
	specification DIE at toplevel. */
	if (child->die_parent != parent)
	{
	dw_die_ref tmp = get_AT_ref (child, DW_AT_specification);

	if (tmp)
	child = tmp;
	}

	gcc_assert (child->die_parent == parent
	\|\| (child->die_parent
	== get_AT_ref (parent, DW_AT_specification)));

	for (p = child->die_parent->die_child; ; p = p->die_sib)
	if (p->die_sib == child)
	{
	remove_child_with_prev (child, p);
	break;
	}

	add_child_die (parent, child);
	}

	/* Return a pointer to a newly created DIE node. */

	static inline dw_die_ref
	new_die (enum dwarf_tag tag_value, dw_die_ref parent_die, tree t)
	{
	dw_die_ref die = ggc_alloc_cleared (sizeof (die_node));

	die->die_tag = tag_value;

	if (parent_die != NULL)
	add_child_die (parent_die, die);
	else
	{
	limbo_die_node *limbo_node;

	limbo_node = ggc_alloc_cleared (sizeof (limbo_die_node));
	limbo_node->die = die;
	limbo_node->created_for = t;
	limbo_node->next = limbo_die_list;
	limbo_die_list = limbo_node;
	}

	return die;
	}

	/* Return the DIE associated with the given type specifier. */

	static inline dw_die_ref
	lookup_type_die (tree type)
	{
	return TYPE_SYMTAB_DIE (type);
	}

	/* Equate a DIE to a given type specifier. */

	static inline void
	equate_type_number_to_die (tree type, dw_die_ref type_die)
	{
	TYPE_SYMTAB_DIE (type) = type_die;
	}

	/* Returns a hash value for X (which really is a die_struct). */

	static hashval_t
	decl_die_table_hash (const void *x)
	{
	return (hashval_t) ((const dw_die_ref) x)->decl_id;
	}

	/* Return nonzero if decl_id of die_struct X is the same as UID of decl Y. /

	static int
	decl_die_table_eq (const void x, const void y)
	{
	return (((const dw_die_ref) x)->decl_id == DECL_UID ((const tree) y));
	}

	/* Return the DIE associated with a given declaration. */

	static inline dw_die_ref
	lookup_decl_die (tree decl)
	{
	return htab_find_with_hash (decl_die_table, decl, DECL_UID (decl));
	}

	/* Returns a hash value for X (which really is a var_loc_list). */

	static hashval_t
	decl_loc_table_hash (const void *x)
	{
	return (hashval_t) ((const var_loc_list *) x)->decl_id;
	}

	/* Return nonzero if decl_id of var_loc_list X is the same as
	UID of decl Y. /

	static int
	decl_loc_table_eq (const void x, const void y)
	{
	return (((const var_loc_list *) x)->decl_id == DECL_UID ((const tree) y));
	}

	/* Return the var_loc list associated with a given declaration. */

	static inline var_loc_list *
	lookup_decl_loc (tree decl)
	{
	return htab_find_with_hash (decl_loc_table, decl, DECL_UID (decl));
	}

	/* Equate a DIE to a particular declaration. */

	static void
	equate_decl_number_to_die (tree decl, dw_die_ref decl_die)
	{
	unsigned int decl_id = DECL_UID (decl);
	void **slot;

	slot = htab_find_slot_with_hash (decl_die_table, decl, decl_id, INSERT);
	*slot = decl_die;
	decl_die->decl_id = decl_id;
	}

	/* Add a variable location node to the linked list for DECL. */

	static void
	add_var_loc_to_decl (tree decl, struct var_loc_node *loc)
	{
	unsigned int decl_id = DECL_UID (decl);
	var_loc_list *temp;
	void **slot;

	slot = htab_find_slot_with_hash (decl_loc_table, decl, decl_id, INSERT);
	if (*slot == NULL)
	{
	temp = ggc_alloc_cleared (sizeof (var_loc_list));
	temp->decl_id = decl_id;
	*slot = temp;
	}
	else
	temp = *slot;

	if (temp->last)
	{
	/* If the current location is the same as the end of the list,
	we have nothing to do. */
	if (!rtx_equal_p (NOTE_VAR_LOCATION_LOC (temp->last->var_loc_note),
	NOTE_VAR_LOCATION_LOC (loc->var_loc_note)))
	{
	/* Add LOC to the end of list and update LAST. */
	temp->last->next = loc;
	temp->last = loc;
	}
	}
	/* Do not add empty location to the beginning of the list. */
	else if (NOTE_VAR_LOCATION_LOC (loc->var_loc_note) != NULL_RTX)
	{
	temp->first = loc;
	temp->last = loc;
	}
	}

	/* Keep track of the number of spaces used to indent the
	output of the debugging routines that print the structure of
	the DIE internal representation. */
	static int print_indent;

	/* Indent the line the number of spaces given by print_indent. */

	static inline void
	print_spaces (FILE *outfile)
	{
	fprintf (outfile, "%*s", print_indent, "");
	}

	/* Print the information associated with a given DIE, and its children.
	This routine is a debugging aid only. */

	static void
	print_die (dw_die_ref die, FILE *outfile)
	{
	dw_attr_ref a;
	dw_die_ref c;
	unsigned ix;

	print_spaces (outfile);
	fprintf (outfile, "DIE %4ld: %s\n",
	die->die_offset, dwarf_tag_name (die->die_tag));
	print_spaces (outfile);
	fprintf (outfile, " abbrev id: %lu", die->die_abbrev);
	fprintf (outfile, " offset: %ld\n", die->die_offset);

	for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, a); ix++)
	{
	print_spaces (outfile);
	fprintf (outfile, " %s: ", dwarf_attr_name (a->dw_attr));

	switch (AT_class (a))
	{
	case dw_val_class_addr:
	fprintf (outfile, "address");
	break;
	case dw_val_class_offset:
	fprintf (outfile, "offset");
	break;
	case dw_val_class_loc:
	fprintf (outfile, "location descriptor");
	break;
	case dw_val_class_loc_list:
	fprintf (outfile, "location list -> label:%s",
	AT_loc_list (a)->ll_symbol);
	break;
	case dw_val_class_range_list:
	fprintf (outfile, "range list");
	break;
	case dw_val_class_const:
	fprintf (outfile, HOST_WIDE_INT_PRINT_DEC, AT_int (a));
	break;
	case dw_val_class_unsigned_const:
	fprintf (outfile, HOST_WIDE_INT_PRINT_UNSIGNED, AT_unsigned (a));
	break;
	case dw_val_class_long_long:
	fprintf (outfile, "constant (%lu,%lu)",
	a->dw_attr_val.v.val_long_long.hi,
	a->dw_attr_val.v.val_long_long.low);
	break;
	case dw_val_class_vec:
	fprintf (outfile, "floating-point or vector constant");
	break;
	case dw_val_class_flag:
	fprintf (outfile, "%u", AT_flag (a));
	break;
	case dw_val_class_die_ref:
	if (AT_ref (a) != NULL)
	{
	if (AT_ref (a)->die_symbol)
	fprintf (outfile, "die -> label: %s", AT_ref (a)->die_symbol);
	else
	fprintf (outfile, "die -> %ld", AT_ref (a)->die_offset);
	}
	else
	fprintf (outfile, "die -> <null>");
	break;
	case dw_val_class_lbl_id:
	case dw_val_class_lineptr:
	case dw_val_class_macptr:
	fprintf (outfile, "label: %s", AT_lbl (a));
	break;
	case dw_val_class_str:
	if (AT_string (a) != NULL)
	fprintf (outfile, "\"%s\"", AT_string (a));
	else
	fprintf (outfile, "<null>");
	break;
	case dw_val_class_file:
	fprintf (outfile, "\"%s\" (%d)", AT_file (a)->filename,
	AT_file (a)->emitted_number);
	break;
	default:
	break;
	}

	fprintf (outfile, "\n");
	}

	if (die->die_child != NULL)
	{
	print_indent += 4;
	FOR_EACH_CHILD (die, c, print_die (c, outfile));
	print_indent -= 4;
	}
	if (print_indent == 0)
	fprintf (outfile, "\n");
	}

	/* Print the contents of the source code line number correspondence table.
	This routine is a debugging aid only. */

	static void
	print_dwarf_line_table (FILE *outfile)
	{
	unsigned i;
	dw_line_info_ref line_info;

	fprintf (outfile, "\n\nDWARF source line information\n");
	for (i = 1; i < line_info_table_in_use; i++)
	{
	line_info = &line_info_table[i];
	fprintf (outfile, "%5d: %4ld %6ld\n", i,
	line_info->dw_file_num,
	line_info->dw_line_num);
	}

	fprintf (outfile, "\n\n");
	}

	/* Print the information collected for a given DIE. */

	void
	debug_dwarf_die (dw_die_ref die)
	{
	print_die (die, stderr);
	}

	/* Print all DWARF information collected for the compilation unit.
	This routine is a debugging aid only. */

	void
	debug_dwarf (void)
	{
	print_indent = 0;
	print_die (comp_unit_die, stderr);
	if (! DWARF2_ASM_LINE_DEBUG_INFO)
	print_dwarf_line_table (stderr);
	}

	/* Start a new compilation unit DIE for an include file. OLD_UNIT is the CU
	for the enclosing include file, if any. BINCL_DIE is the DW_TAG_GNU_BINCL
	DIE that marks the start of the DIEs for this include file. */

	static dw_die_ref
	push_new_compile_unit (dw_die_ref old_unit, dw_die_ref bincl_die)
	{
	const char *filename = get_AT_string (bincl_die, DW_AT_name);
	dw_die_ref new_unit = gen_compile_unit_die (filename);

	new_unit->die_sib = old_unit;
	return new_unit;
	}

	/* Close an include-file CU and reopen the enclosing one. */

	static dw_die_ref
	pop_compile_unit (dw_die_ref old_unit)
	{
	dw_die_ref new_unit = old_unit->die_sib;

	old_unit->die_sib = NULL;
	return new_unit;
	}

	#define CHECKSUM(FOO) md5_process_bytes (&(FOO), sizeof (FOO), ctx)
	#define CHECKSUM_STRING(FOO) md5_process_bytes ((FOO), strlen (FOO), ctx)

	/* Calculate the checksum of a location expression. */

	static inline void
	loc_checksum (dw_loc_descr_ref loc, struct md5_ctx *ctx)
	{
	CHECKSUM (loc->dw_loc_opc);
	CHECKSUM (loc->dw_loc_oprnd1);
	CHECKSUM (loc->dw_loc_oprnd2);
	}

	/* Calculate the checksum of an attribute. */

	static void
	attr_checksum (dw_attr_ref at, struct md5_ctx ctx, int mark)
	{
	dw_loc_descr_ref loc;
	rtx r;

	CHECKSUM (at->dw_attr);

	/* We don't care that this was compiled with a different compiler
	snapshot; if the output is the same, that's what matters. */
	if (at->dw_attr == DW_AT_producer)
	return;

	switch (AT_class (at))
	{
	case dw_val_class_const:
	CHECKSUM (at->dw_attr_val.v.val_int);
	break;
	case dw_val_class_unsigned_const:
	CHECKSUM (at->dw_attr_val.v.val_unsigned);
	break;
	case dw_val_class_long_long:
	CHECKSUM (at->dw_attr_val.v.val_long_long);
	break;
	case dw_val_class_vec:
	CHECKSUM (at->dw_attr_val.v.val_vec);
	break;
	case dw_val_class_flag:
	CHECKSUM (at->dw_attr_val.v.val_flag);
	break;
	case dw_val_class_str:
	CHECKSUM_STRING (AT_string (at));
	break;

	case dw_val_class_addr:
	r = AT_addr (at);
	gcc_assert (GET_CODE (r) == SYMBOL_REF);
	CHECKSUM_STRING (XSTR (r, 0));
	break;

	case dw_val_class_offset:
	CHECKSUM (at->dw_attr_val.v.val_offset);
	break;

	case dw_val_class_loc:
	for (loc = AT_loc (at); loc; loc = loc->dw_loc_next)
	loc_checksum (loc, ctx);
	break;

	case dw_val_class_die_ref:
	die_checksum (AT_ref (at), ctx, mark);
	break;

	case dw_val_class_fde_ref:
	case dw_val_class_lbl_id:
	case dw_val_class_lineptr:
	case dw_val_class_macptr:
	break;

	case dw_val_class_file:
	CHECKSUM_STRING (AT_file (at)->filename);
	break;

	default:
	break;
	}
	}

	/* Calculate the checksum of a DIE. */

	static void
	die_checksum (dw_die_ref die, struct md5_ctx ctx, int mark)
	{
	dw_die_ref c;
	dw_attr_ref a;
	unsigned ix;

	/* To avoid infinite recursion. */
	if (die->die_mark)
	{
	CHECKSUM (die->die_mark);
	return;
	}
	die->die_mark = ++(*mark);

	CHECKSUM (die->die_tag);

	for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, a); ix++)
	attr_checksum (a, ctx, mark);

	FOR_EACH_CHILD (die, c, die_checksum (c, ctx, mark));
	}

	#undef CHECKSUM
	#undef CHECKSUM_STRING

	/* Do the location expressions look same? */
	static inline int
	same_loc_p (dw_loc_descr_ref loc1, dw_loc_descr_ref loc2, int *mark)
	{
	return loc1->dw_loc_opc == loc2->dw_loc_opc
	&& same_dw_val_p (&loc1->dw_loc_oprnd1, &loc2->dw_loc_oprnd1, mark)
	&& same_dw_val_p (&loc1->dw_loc_oprnd2, &loc2->dw_loc_oprnd2, mark);
	}

	/* Do the values look the same? */
	static int
	same_dw_val_p (dw_val_node v1, dw_val_node v2, int *mark)
	{
	dw_loc_descr_ref loc1, loc2;
	rtx r1, r2;

	if (v1->val_class != v2->val_class)
	return 0;

	switch (v1->val_class)
	{
	case dw_val_class_const:
	return v1->v.val_int == v2->v.val_int;
	case dw_val_class_unsigned_const:
	return v1->v.val_unsigned == v2->v.val_unsigned;
	case dw_val_class_long_long:
	return v1->v.val_long_long.hi == v2->v.val_long_long.hi
	&& v1->v.val_long_long.low == v2->v.val_long_long.low;
	case dw_val_class_vec:
	if (v1->v.val_vec.length != v2->v.val_vec.length
	\|\| v1->v.val_vec.elt_size != v2->v.val_vec.elt_size)
	return 0;
	if (memcmp (v1->v.val_vec.array, v2->v.val_vec.array,
	v1->v.val_vec.length * v1->v.val_vec.elt_size))
	return 0;
	return 1;
	case dw_val_class_flag:
	return v1->v.val_flag == v2->v.val_flag;
	case dw_val_class_str:
	return !strcmp(v1->v.val_str->str, v2->v.val_str->str);

	case dw_val_class_addr:
	r1 = v1->v.val_addr;
	r2 = v2->v.val_addr;
	if (GET_CODE (r1) != GET_CODE (r2))
	return 0;
	gcc_assert (GET_CODE (r1) == SYMBOL_REF);
	return !strcmp (XSTR (r1, 0), XSTR (r2, 0));

	case dw_val_class_offset:
	return v1->v.val_offset == v2->v.val_offset;

	case dw_val_class_loc:
	for (loc1 = v1->v.val_loc, loc2 = v2->v.val_loc;
	loc1 && loc2;
	loc1 = loc1->dw_loc_next, loc2 = loc2->dw_loc_next)
	if (!same_loc_p (loc1, loc2, mark))
	return 0;
	return !loc1 && !loc2;

	case dw_val_class_die_ref:
	return same_die_p (v1->v.val_die_ref.die, v2->v.val_die_ref.die, mark);

	case dw_val_class_fde_ref:
	case dw_val_class_lbl_id:
	case dw_val_class_lineptr:
	case dw_val_class_macptr:
	return 1;

	case dw_val_class_file:
	return v1->v.val_file == v2->v.val_file;

	default:
	return 1;
	}
	}

	/* Do the attributes look the same? */

	static int
	same_attr_p (dw_attr_ref at1, dw_attr_ref at2, int *mark)
	{
	if (at1->dw_attr != at2->dw_attr)
	return 0;

	/* We don't care that this was compiled with a different compiler
	snapshot; if the output is the same, that's what matters. */
	if (at1->dw_attr == DW_AT_producer)
	return 1;

	return same_dw_val_p (&at1->dw_attr_val, &at2->dw_attr_val, mark);
	}

	/* Do the dies look the same? */

	static int
	same_die_p (dw_die_ref die1, dw_die_ref die2, int *mark)
	{
	dw_die_ref c1, c2;
	dw_attr_ref a1;
	unsigned ix;

	/* To avoid infinite recursion. */
	if (die1->die_mark)
	return die1->die_mark == die2->die_mark;
	die1->die_mark = die2->die_mark = ++(*mark);

	if (die1->die_tag != die2->die_tag)
	return 0;

	if (VEC_length (dw_attr_node, die1->die_attr)
	!= VEC_length (dw_attr_node, die2->die_attr))
	return 0;

	for (ix = 0; VEC_iterate (dw_attr_node, die1->die_attr, ix, a1); ix++)
	if (!same_attr_p (a1, VEC_index (dw_attr_node, die2->die_attr, ix), mark))
	return 0;

	c1 = die1->die_child;
	c2 = die2->die_child;
	if (! c1)
	{
	if (c2)
	return 0;
	}
	else
	for (;;)
	{
	if (!same_die_p (c1, c2, mark))
	return 0;
	c1 = c1->die_sib;
	c2 = c2->die_sib;
	if (c1 == die1->die_child)
	{
	if (c2 == die2->die_child)
	break;
	else
	return 0;
	}
	}

	return 1;
	}

	/* Do the dies look the same? Wrapper around same_die_p. */

	static int
	same_die_p_wrap (dw_die_ref die1, dw_die_ref die2)
	{
	int mark = 0;
	int ret = same_die_p (die1, die2, &mark);

	unmark_all_dies (die1);
	unmark_all_dies (die2);

	return ret;
	}

	/* The prefix to attach to symbols on DIEs in the current comdat debug
	info section. */
	static char *comdat_symbol_id;

	/* The index of the current symbol within the current comdat CU. */
	static unsigned int comdat_symbol_number;

	/* Calculate the MD5 checksum of the compilation unit DIE UNIT_DIE and its
	children, and set comdat_symbol_id accordingly. */

	static void
	compute_section_prefix (dw_die_ref unit_die)
	{
	const char *die_name = get_AT_string (unit_die, DW_AT_name);
	const char *base = die_name ? lbasename (die_name) : "anonymous";
	char *name = alloca (strlen (base) + 64);
	char *p;
	int i, mark;
	unsigned char checksum[16];
	struct md5_ctx ctx;

	/* Compute the checksum of the DIE, then append part of it as hex digits to
	the name filename of the unit. */

	md5_init_ctx (&ctx);
	mark = 0;
	die_checksum (unit_die, &ctx, &mark);
	unmark_all_dies (unit_die);
	md5_finish_ctx (&ctx, checksum);

	sprintf (name, "%s.", base);
	clean_symbol_name (name);

	p = name + strlen (name);
	for (i = 0; i < 4; i++)
	{
	sprintf (p, "%.2x", checksum[i]);
	p += 2;
	}

	comdat_symbol_id = unit_die->die_symbol = xstrdup (name);
	comdat_symbol_number = 0;
	}

	/* Returns nonzero if DIE represents a type, in the sense of TYPE_P. */

	static int
	is_type_die (dw_die_ref die)
	{
	switch (die->die_tag)
	{
	case DW_TAG_array_type:
	case DW_TAG_class_type:
	case DW_TAG_enumeration_type:
	case DW_TAG_pointer_type:
	case DW_TAG_reference_type:
	case DW_TAG_string_type:
	case DW_TAG_structure_type:
	case DW_TAG_subroutine_type:
	case DW_TAG_union_type:
	case DW_TAG_ptr_to_member_type:
	case DW_TAG_set_type:
	case DW_TAG_subrange_type:
	case DW_TAG_base_type:
	case DW_TAG_const_type:
	case DW_TAG_file_type:
	case DW_TAG_packed_type:
	case DW_TAG_volatile_type:
	case DW_TAG_typedef:
	return 1;
	default:
	return 0;
	}
	}

	/* Returns 1 iff C is the sort of DIE that should go into a COMDAT CU.
	Basically, we want to choose the bits that are likely to be shared between
	compilations (types) and leave out the bits that are specific to individual
	compilations (functions). */

	static int
	is_comdat_die (dw_die_ref c)
	{
	/* I think we want to leave base types and __vtbl_ptr_type in the main CU, as
	we do for stabs. The advantage is a greater likelihood of sharing between
	objects that don't include headers in the same order (and therefore would
	put the base types in a different comdat). jason 8/28/00 */

	if (c->die_tag == DW_TAG_base_type)
	return 0;

	if (c->die_tag == DW_TAG_pointer_type
	\|\| c->die_tag == DW_TAG_reference_type
	\|\| c->die_tag == DW_TAG_const_type
	\|\| c->die_tag == DW_TAG_volatile_type)
	{
	dw_die_ref t = get_AT_ref (c, DW_AT_type);

	return t ? is_comdat_die (t) : 0;
	}

	return is_type_die (c);
	}

	/* Returns 1 iff C is the sort of DIE that might be referred to from another
	compilation unit. */

	static int
	is_symbol_die (dw_die_ref c)
	{
	return (is_type_die (c)
	\|\| (get_AT (c, DW_AT_declaration)
	&& !get_AT (c, DW_AT_specification))
	\|\| c->die_tag == DW_TAG_namespace);
	}

	static char *
	gen_internal_sym (const char *prefix)
	{
	char buf[256];

	ASM_GENERATE_INTERNAL_LABEL (buf, prefix, label_num++);
	return xstrdup (buf);
	}

	/* Assign symbols to all worthy DIEs under DIE. */

	static void
	assign_symbol_names (dw_die_ref die)
	{
	dw_die_ref c;

	if (is_symbol_die (die))
	{
	if (comdat_symbol_id)
	{
	char *p = alloca (strlen (comdat_symbol_id) + 64);

	sprintf (p, "%s.%s.%x", DIE_LABEL_PREFIX,
	comdat_symbol_id, comdat_symbol_number++);
	die->die_symbol = xstrdup (p);
	}
	else
	die->die_symbol = gen_internal_sym ("LDIE");
	}

	FOR_EACH_CHILD (die, c, assign_symbol_names (c));
	}

	struct cu_hash_table_entry
	{
	dw_die_ref cu;
	unsigned min_comdat_num, max_comdat_num;
	struct cu_hash_table_entry *next;
	};

	/* Routines to manipulate hash table of CUs. */
	static hashval_t
	htab_cu_hash (const void *of)
	{
	const struct cu_hash_table_entry *entry = of;

	return htab_hash_string (entry->cu->die_symbol);
	}

	static int
	htab_cu_eq (const void of1, const void of2)
	{
	const struct cu_hash_table_entry *entry1 = of1;
	const struct die_struct *entry2 = of2;

	return !strcmp (entry1->cu->die_symbol, entry2->die_symbol);
	}

	static void
	htab_cu_del (void *what)
	{
	struct cu_hash_table_entry next, entry = what;

	while (entry)
	{
	next = entry->next;
	free (entry);
	entry = next;
	}
	}

	/* Check whether we have already seen this CU and set up SYM_NUM
	accordingly. */
	static int
	check_duplicate_cu (dw_die_ref cu, htab_t htable, unsigned int *sym_num)
	{
	struct cu_hash_table_entry dummy;
	struct cu_hash_table_entry *slot, entry, *last = &dummy;

	dummy.max_comdat_num = 0;

	slot = (struct cu_hash_table_entry **)
	htab_find_slot_with_hash (htable, cu, htab_hash_string (cu->die_symbol),
	INSERT);
	entry = *slot;

	for (; entry; last = entry, entry = entry->next)
	{
	if (same_die_p_wrap (cu, entry->cu))
	break;
	}

	if (entry)
	{
	*sym_num = entry->min_comdat_num;
	return 1;
	}

	entry = XCNEW (struct cu_hash_table_entry);
	entry->cu = cu;
	entry->min_comdat_num = *sym_num = last->max_comdat_num;
	entry->next = *slot;
	*slot = entry;

	return 0;
	}

	/* Record SYM_NUM to record of CU in HTABLE. */
	static void
	record_comdat_symbol_number (dw_die_ref cu, htab_t htable, unsigned int sym_num)
	{
	struct cu_hash_table_entry *slot, entry;

	slot = (struct cu_hash_table_entry **)
	htab_find_slot_with_hash (htable, cu, htab_hash_string (cu->die_symbol),
	NO_INSERT);
	entry = *slot;

	entry->max_comdat_num = sym_num;
	}

	/* Traverse the DIE (which is always comp_unit_die), and set up
	additional compilation units for each of the include files we see
	bracketed by BINCL/EINCL. */

	static void
	break_out_includes (dw_die_ref die)
	{
	dw_die_ref c;
	dw_die_ref unit = NULL;
	limbo_die_node node, *pnode;
	htab_t cu_hash_table;

	c = die->die_child;
	if (c) do {
	dw_die_ref prev = c;
	c = c->die_sib;
	while (c->die_tag == DW_TAG_GNU_BINCL \|\| c->die_tag == DW_TAG_GNU_EINCL
	\|\| (unit && is_comdat_die (c)))
	{
	dw_die_ref next = c->die_sib;

	/* This DIE is for a secondary CU; remove it from the main one. */
	remove_child_with_prev (c, prev);

	if (c->die_tag == DW_TAG_GNU_BINCL)
	unit = push_new_compile_unit (unit, c);
	else if (c->die_tag == DW_TAG_GNU_EINCL)
	unit = pop_compile_unit (unit);
	else
	add_child_die (unit, c);
	c = next;
	if (c == die->die_child)
	break;
	}
	} while (c != die->die_child);

	#if 0
	/* We can only use this in debugging, since the frontend doesn't check
	to make sure that we leave every include file we enter. */
	gcc_assert (!unit);
	#endif

	assign_symbol_names (die);
	cu_hash_table = htab_create (10, htab_cu_hash, htab_cu_eq, htab_cu_del);
	for (node = limbo_die_list, pnode = &limbo_die_list;
	node;
	node = node->next)
	{
	int is_dupl;

	compute_section_prefix (node->die);
	is_dupl = check_duplicate_cu (node->die, cu_hash_table,
	&comdat_symbol_number);
	assign_symbol_names (node->die);
	if (is_dupl)
	*pnode = node->next;
	else
	{
	pnode = &node->next;
	record_comdat_symbol_number (node->die, cu_hash_table,
	comdat_symbol_number);
	}
	}
	htab_delete (cu_hash_table);
	}

	/* Traverse the DIE and add a sibling attribute if it may have the
	effect of speeding up access to siblings. To save some space,
	avoid generating sibling attributes for DIE's without children. */

	static void
	add_sibling_attributes (dw_die_ref die)
	{
	dw_die_ref c;

	if (! die->die_child)
	return;

	if (die->die_parent && die != die->die_parent->die_child)
	add_AT_die_ref (die, DW_AT_sibling, die->die_sib);

	FOR_EACH_CHILD (die, c, add_sibling_attributes (c));
	}

	/* Output all location lists for the DIE and its children. */

	static void
	output_location_lists (dw_die_ref die)
	{
	dw_die_ref c;
	dw_attr_ref a;
	unsigned ix;

	for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, a); ix++)
	if (AT_class (a) == dw_val_class_loc_list)
	output_loc_list (AT_loc_list (a));

	FOR_EACH_CHILD (die, c, output_location_lists (c));
	}

	/* The format of each DIE (and its attribute value pairs) is encoded in an
	abbreviation table. This routine builds the abbreviation table and assigns
	a unique abbreviation id for each abbreviation entry. The children of each
	die are visited recursively. */

	static void
	build_abbrev_table (dw_die_ref die)
	{
	unsigned long abbrev_id;
	unsigned int n_alloc;
	dw_die_ref c;
	dw_attr_ref a;
	unsigned ix;

	/* Scan the DIE references, and mark as external any that refer to
	DIEs from other CUs (i.e. those which are not marked). */
	for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, a); ix++)
	if (AT_class (a) == dw_val_class_die_ref
	&& AT_ref (a)->die_mark == 0)
	{
	gcc_assert (AT_ref (a)->die_symbol);

	set_AT_ref_external (a, 1);
	}

	for (abbrev_id = 1; abbrev_id < abbrev_die_table_in_use; ++abbrev_id)
	{
	dw_die_ref abbrev = abbrev_die_table[abbrev_id];
	dw_attr_ref die_a, abbrev_a;
	unsigned ix;
	bool ok = true;

	if (abbrev->die_tag != die->die_tag)
	continue;
	if ((abbrev->die_child != NULL) != (die->die_child != NULL))
	continue;

	if (VEC_length (dw_attr_node, abbrev->die_attr)
	!= VEC_length (dw_attr_node, die->die_attr))
	continue;

	for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, die_a); ix++)
	{
	abbrev_a = VEC_index (dw_attr_node, abbrev->die_attr, ix);
	if ((abbrev_a->dw_attr != die_a->dw_attr)
	\|\| (value_format (abbrev_a) != value_format (die_a)))
	{
	ok = false;
	break;
	}
	}
	if (ok)
	break;
	}

	if (abbrev_id >= abbrev_die_table_in_use)
	{
	if (abbrev_die_table_in_use >= abbrev_die_table_allocated)
	{
	n_alloc = abbrev_die_table_allocated + ABBREV_DIE_TABLE_INCREMENT;
	abbrev_die_table = ggc_realloc (abbrev_die_table,
	sizeof (dw_die_ref) * n_alloc);

	memset (&abbrev_die_table[abbrev_die_table_allocated], 0,
	(n_alloc - abbrev_die_table_allocated) * sizeof (dw_die_ref));
	abbrev_die_table_allocated = n_alloc;
	}

	++abbrev_die_table_in_use;
	abbrev_die_table[abbrev_id] = die;
	}

	die->die_abbrev = abbrev_id;
	FOR_EACH_CHILD (die, c, build_abbrev_table (c));
	}

	/* Return the power-of-two number of bytes necessary to represent VALUE. */

	static int
	constant_size (long unsigned int value)
	{
	int log;

	if (value == 0)
	log = 0;
	else
	log = floor_log2 (value);

	log = log / 8;
	log = 1 << (floor_log2 (log) + 1);

	return log;
	}

	/* Return the size of a DIE as it is represented in the
	.debug_info section. */

	static unsigned long
	size_of_die (dw_die_ref die)
	{
	unsigned long size = 0;
	dw_attr_ref a;
	unsigned ix;

	size += size_of_uleb128 (die->die_abbrev);
	for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, a); ix++)
	{
	switch (AT_class (a))
	{
	case dw_val_class_addr:
	size += DWARF2_ADDR_SIZE;
	break;
	case dw_val_class_offset:
	size += DWARF_OFFSET_SIZE;
	break;
	case dw_val_class_loc:
	{
	unsigned long lsize = size_of_locs (AT_loc (a));

	/* Block length. */
	size += constant_size (lsize);
	size += lsize;
	}
	break;
	case dw_val_class_loc_list:
	size += DWARF_OFFSET_SIZE;
	break;
	case dw_val_class_range_list:
	size += DWARF_OFFSET_SIZE;
	break;
	case dw_val_class_const:
	size += size_of_sleb128 (AT_int (a));
	break;
	case dw_val_class_unsigned_const:
	size += constant_size (AT_unsigned (a));
	break;
	case dw_val_class_long_long:
	size += 1 + 2HOST_BITS_PER_LONG/HOST_BITS_PER_CHAR; / block */
	break;
	case dw_val_class_vec:
	size += 1 + (a->dw_attr_val.v.val_vec.length
	* a->dw_attr_val.v.val_vec.elt_size); /* block */
	break;
	case dw_val_class_flag:
	size += 1;
	break;
	case dw_val_class_die_ref:
	if (AT_ref_external (a))
	size += DWARF2_ADDR_SIZE;
	else
	size += DWARF_OFFSET_SIZE;
	break;
	case dw_val_class_fde_ref:
	size += DWARF_OFFSET_SIZE;
	break;
	case dw_val_class_lbl_id:
	size += DWARF2_ADDR_SIZE;
	break;
	case dw_val_class_lineptr:
	case dw_val_class_macptr:
	size += DWARF_OFFSET_SIZE;
	break;
	case dw_val_class_str:
	if (AT_string_form (a) == DW_FORM_strp)
	size += DWARF_OFFSET_SIZE;
	else
	size += strlen (a->dw_attr_val.v.val_str->str) + 1;
	break;
	case dw_val_class_file:
	size += constant_size (maybe_emit_file (a->dw_attr_val.v.val_file));
	break;
	default:
	gcc_unreachable ();
	}
	}

	return size;
	}

	/* Size the debugging information associated with a given DIE. Visits the
	DIE's children recursively. Updates the global variable next_die_offset, on
	each time through. Uses the current value of next_die_offset to update the
	die_offset field in each DIE. */

	static void
	calc_die_sizes (dw_die_ref die)
	{
	dw_die_ref c;

	die->die_offset = next_die_offset;
	next_die_offset += size_of_die (die);

	FOR_EACH_CHILD (die, c, calc_die_sizes (c));

	if (die->die_child != NULL)
	/* Count the null byte used to terminate sibling lists. */
	next_die_offset += 1;
	}

	/* Set the marks for a die and its children. We do this so
	that we know whether or not a reference needs to use FORM_ref_addr; only
	DIEs in the same CU will be marked. We used to clear out the offset
	and use that as the flag, but ran into ordering problems. */

	static void
	mark_dies (dw_die_ref die)
	{
	dw_die_ref c;

	gcc_assert (!die->die_mark);

	die->die_mark = 1;
	FOR_EACH_CHILD (die, c, mark_dies (c));
	}

	/* Clear the marks for a die and its children. */

	static void
	unmark_dies (dw_die_ref die)
	{
	dw_die_ref c;

	gcc_assert (die->die_mark);

	die->die_mark = 0;
	FOR_EACH_CHILD (die, c, unmark_dies (c));
	}

	/* Clear the marks for a die, its children and referred dies. */

	static void
	unmark_all_dies (dw_die_ref die)
	{
	dw_die_ref c;
	dw_attr_ref a;
	unsigned ix;

	if (!die->die_mark)
	return;
	die->die_mark = 0;

	FOR_EACH_CHILD (die, c, unmark_all_dies (c));

	for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, a); ix++)
	if (AT_class (a) == dw_val_class_die_ref)
	unmark_all_dies (AT_ref (a));
	}

	/* Return the size of the .debug_pubnames or .debug_pubtypes table
	generated for the compilation unit. */

	static unsigned long
	size_of_pubnames (VEC (pubname_entry, gc) * names)
	{
	unsigned long size;
	unsigned i;
	pubname_ref p;

	size = DWARF_PUBNAMES_HEADER_SIZE;
	for (i = 0; VEC_iterate (pubname_entry, names, i, p); i++)
	if (names != pubtype_table
	\|\| p->die->die_offset != 0
	\|\| !flag_eliminate_unused_debug_types)
	size += strlen (p->name) + DWARF_OFFSET_SIZE + 1;

	size += DWARF_OFFSET_SIZE;
	return size;
	}

	/* Return the size of the information in the .debug_aranges section. */

	static unsigned long
	size_of_aranges (void)
	{
	unsigned long size;

	size = DWARF_ARANGES_HEADER_SIZE;

	/* Count the address/length pair for this compilation unit. */
	size += 2 * DWARF2_ADDR_SIZE;
	size += 2 * DWARF2_ADDR_SIZE * arange_table_in_use;

	/* Count the two zero words used to terminated the address range table. */
	size += 2 * DWARF2_ADDR_SIZE;
	return size;
	}

	/* Select the encoding of an attribute value. */

	static enum dwarf_form
	value_format (dw_attr_ref a)
	{
	switch (a->dw_attr_val.val_class)
	{
	case dw_val_class_addr:
	return DW_FORM_addr;
	case dw_val_class_range_list:
	case dw_val_class_offset:
	case dw_val_class_loc_list:
	switch (DWARF_OFFSET_SIZE)
	{
	case 4:
	return DW_FORM_data4;
	case 8:
	return DW_FORM_data8;
	default:
	gcc_unreachable ();
	}
	case dw_val_class_loc:
	switch (constant_size (size_of_locs (AT_loc (a))))
	{
	case 1:
	return DW_FORM_block1;
	case 2:
	return DW_FORM_block2;
	default:
	gcc_unreachable ();
	}
	case dw_val_class_const:
	return DW_FORM_sdata;
	case dw_val_class_unsigned_const:
	switch (constant_size (AT_unsigned (a)))
	{
	case 1:
	return DW_FORM_data1;
	case 2:
	return DW_FORM_data2;
	case 4:
	return DW_FORM_data4;
	case 8:
	return DW_FORM_data8;
	default:
	gcc_unreachable ();
	}
	case dw_val_class_long_long:
	return DW_FORM_block1;
	case dw_val_class_vec:
	return DW_FORM_block1;
	case dw_val_class_flag:
	return DW_FORM_flag;
	case dw_val_class_die_ref:
	if (AT_ref_external (a))
	return DW_FORM_ref_addr;
	else
	return DW_FORM_ref;
	case dw_val_class_fde_ref:
	return DW_FORM_data;
	case dw_val_class_lbl_id:
	return DW_FORM_addr;
	case dw_val_class_lineptr:
	case dw_val_class_macptr:
	return DW_FORM_data;
	case dw_val_class_str:
	return AT_string_form (a);
	case dw_val_class_file:
	switch (constant_size (maybe_emit_file (a->dw_attr_val.v.val_file)))
	{
	case 1:
	return DW_FORM_data1;
	case 2:
	return DW_FORM_data2;
	case 4:
	return DW_FORM_data4;
	default:
	gcc_unreachable ();
	}

	default:
	gcc_unreachable ();
	}
	}

	/* Output the encoding of an attribute value. */

	static void
	output_value_format (dw_attr_ref a)
	{
	enum dwarf_form form = value_format (a);

	dw2_asm_output_data_uleb128 (form, "(%s)", dwarf_form_name (form));
	}

	/* Output the .debug_abbrev section which defines the DIE abbreviation
	table. */

	static void
	output_abbrev_section (void)
	{
	unsigned long abbrev_id;

	for (abbrev_id = 1; abbrev_id < abbrev_die_table_in_use; ++abbrev_id)
	{
	dw_die_ref abbrev = abbrev_die_table[abbrev_id];
	unsigned ix;
	dw_attr_ref a_attr;

	dw2_asm_output_data_uleb128 (abbrev_id, "(abbrev code)");
	dw2_asm_output_data_uleb128 (abbrev->die_tag, "(TAG: %s)",
	dwarf_tag_name (abbrev->die_tag));

	if (abbrev->die_child != NULL)
	dw2_asm_output_data (1, DW_children_yes, "DW_children_yes");
	else
	dw2_asm_output_data (1, DW_children_no, "DW_children_no");

	for (ix = 0; VEC_iterate (dw_attr_node, abbrev->die_attr, ix, a_attr);
	ix++)
	{
	dw2_asm_output_data_uleb128 (a_attr->dw_attr, "(%s)",
	dwarf_attr_name (a_attr->dw_attr));
	output_value_format (a_attr);
	}

	dw2_asm_output_data (1, 0, NULL);
	dw2_asm_output_data (1, 0, NULL);
	}

	/* Terminate the table. */
	dw2_asm_output_data (1, 0, NULL);
	}

	/* Output a symbol we can use to refer to this DIE from another CU. */

	static inline void
	output_die_symbol (dw_die_ref die)
	{
	char *sym = die->die_symbol;

	if (sym == 0)
	return;

	if (strncmp (sym, DIE_LABEL_PREFIX, sizeof (DIE_LABEL_PREFIX) - 1) == 0)
	/* We make these global, not weak; if the target doesn't support
	.linkonce, it doesn't support combining the sections, so debugging
	will break. */
	targetm.asm_out.globalize_label (asm_out_file, sym);

	ASM_OUTPUT_LABEL (asm_out_file, sym);
	}

	/* Return a new location list, given the begin and end range, and the
	expression. gensym tells us whether to generate a new internal symbol for
	this location list node, which is done for the head of the list only. */

	static inline dw_loc_list_ref
	new_loc_list (dw_loc_descr_ref expr, const char begin, const char end,
	const char *section, unsigned int gensym)
	{
	dw_loc_list_ref retlist = ggc_alloc_cleared (sizeof (dw_loc_list_node));

	retlist->begin = begin;
	retlist->end = end;
	retlist->expr = expr;
	retlist->section = section;
	if (gensym)
	retlist->ll_symbol = gen_internal_sym ("LLST");

	return retlist;
	}

	/* Add a location description expression to a location list. */

	static inline void
	add_loc_descr_to_loc_list (dw_loc_list_ref *list_head, dw_loc_descr_ref descr,
	const char begin, const char end,
	const char *section)
	{
	dw_loc_list_ref *d;

	/* Find the end of the chain. */
	for (d = list_head; (d) != NULL; d = &(d)->dw_loc_next)
	;

	/* Add a new location list node to the list. */
	*d = new_loc_list (descr, begin, end, section, 0);
	}

	static void
	dwarf2out_switch_text_section (void)
	{
	dw_fde_ref fde;

	gcc_assert (cfun);

	fde = &fde_table[fde_table_in_use - 1];
	fde->dw_fde_switched_sections = true;
	fde->dw_fde_hot_section_label = cfun->hot_section_label;
	fde->dw_fde_hot_section_end_label = cfun->hot_section_end_label;
	fde->dw_fde_unlikely_section_label = cfun->cold_section_label;
	fde->dw_fde_unlikely_section_end_label = cfun->cold_section_end_label;
	have_multiple_function_sections = true;

	/* Reset the current label on switching text sections, so that we
	don't attempt to advance_loc4 between labels in different sections. */
	fde->dw_fde_current_label = NULL;
	}

	/* Output the location list given to us. */

	static void
	output_loc_list (dw_loc_list_ref list_head)
	{
	dw_loc_list_ref curr = list_head;

	ASM_OUTPUT_LABEL (asm_out_file, list_head->ll_symbol);

	/* Walk the location list, and output each range + expression. */
	for (curr = list_head; curr != NULL; curr = curr->dw_loc_next)
	{
	unsigned long size;
	if (!have_multiple_function_sections)
	{
	dw2_asm_output_delta (DWARF2_ADDR_SIZE, curr->begin, curr->section,
	"Location list begin address (%s)",
	list_head->ll_symbol);
	dw2_asm_output_delta (DWARF2_ADDR_SIZE, curr->end, curr->section,
	"Location list end address (%s)",
	list_head->ll_symbol);
	}
	else
	{
	dw2_asm_output_addr (DWARF2_ADDR_SIZE, curr->begin,
	"Location list begin address (%s)",
	list_head->ll_symbol);
	dw2_asm_output_addr (DWARF2_ADDR_SIZE, curr->end,
	"Location list end address (%s)",
	list_head->ll_symbol);
	}
	size = size_of_locs (curr->expr);

	/* Output the block length for this list of location operations. */
	gcc_assert (size <= 0xffff);
	dw2_asm_output_data (2, size, "%s", "Location expression size");

	output_loc_sequence (curr->expr);
	}

	dw2_asm_output_data (DWARF2_ADDR_SIZE, 0,
	"Location list terminator begin (%s)",
	list_head->ll_symbol);
	dw2_asm_output_data (DWARF2_ADDR_SIZE, 0,
	"Location list terminator end (%s)",
	list_head->ll_symbol);
	}

	/* Output the DIE and its attributes. Called recursively to generate
	the definitions of each child DIE. */

	static void
	output_die (dw_die_ref die)
	{
	dw_attr_ref a;
	dw_die_ref c;
	unsigned long size;
	unsigned ix;

	/* If someone in another CU might refer to us, set up a symbol for
	them to point to. */
	if (die->die_symbol)
	output_die_symbol (die);

	dw2_asm_output_data_uleb128 (die->die_abbrev, "(DIE (0x%lx) %s)",
	(unsigned long)die->die_offset,
	dwarf_tag_name (die->die_tag));

	for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, a); ix++)
	{
	const char *name = dwarf_attr_name (a->dw_attr);

	switch (AT_class (a))
	{
	case dw_val_class_addr:
	dw2_asm_output_addr_rtx (DWARF2_ADDR_SIZE, AT_addr (a), "%s", name);
	break;

	case dw_val_class_offset:
	dw2_asm_output_data (DWARF_OFFSET_SIZE, a->dw_attr_val.v.val_offset,
	"%s", name);
	break;

	case dw_val_class_range_list:
	{
	char *p = strchr (ranges_section_label, '\0');

	sprintf (p, "+" HOST_WIDE_INT_PRINT_HEX,
	a->dw_attr_val.v.val_offset);
	dw2_asm_output_offset (DWARF_OFFSET_SIZE, ranges_section_label,
	debug_ranges_section, "%s", name);
	*p = '\0';
	}
	break;

	case dw_val_class_loc:
	size = size_of_locs (AT_loc (a));

	/* Output the block length for this list of location operations. */
	dw2_asm_output_data (constant_size (size), size, "%s", name);

	output_loc_sequence (AT_loc (a));
	break;

	case dw_val_class_const:
	/* ??? It would be slightly more efficient to use a scheme like is
	used for unsigned constants below, but gdb 4.x does not sign
	extend. Gdb 5.x does sign extend. */
	dw2_asm_output_data_sleb128 (AT_int (a), "%s", name);
	break;

	case dw_val_class_unsigned_const:
	dw2_asm_output_data (constant_size (AT_unsigned (a)),
	AT_unsigned (a), "%s", name);
	break;

	case dw_val_class_long_long:
	{
	unsigned HOST_WIDE_INT first, second;

	dw2_asm_output_data (1,
	2 * HOST_BITS_PER_LONG / HOST_BITS_PER_CHAR,
	"%s", name);

	if (WORDS_BIG_ENDIAN)
	{
	first = a->dw_attr_val.v.val_long_long.hi;
	second = a->dw_attr_val.v.val_long_long.low;
	}
	else
	{
	first = a->dw_attr_val.v.val_long_long.low;
	second = a->dw_attr_val.v.val_long_long.hi;
	}

	dw2_asm_output_data (HOST_BITS_PER_LONG / HOST_BITS_PER_CHAR,
	first, "long long constant");
	dw2_asm_output_data (HOST_BITS_PER_LONG / HOST_BITS_PER_CHAR,
	second, NULL);
	}
	break;

	case dw_val_class_vec:
	{
	unsigned int elt_size = a->dw_attr_val.v.val_vec.elt_size;
	unsigned int len = a->dw_attr_val.v.val_vec.length;
	unsigned int i;
	unsigned char *p;

	dw2_asm_output_data (1, len * elt_size, "%s", name);
	if (elt_size > sizeof (HOST_WIDE_INT))
	{
	elt_size /= 2;
	len *= 2;
	}
	for (i = 0, p = a->dw_attr_val.v.val_vec.array;
	i < len;
	i++, p += elt_size)
	dw2_asm_output_data (elt_size, extract_int (p, elt_size),
	"fp or vector constant word %u", i);
	break;
	}

	case dw_val_class_flag:
	dw2_asm_output_data (1, AT_flag (a), "%s", name);
	break;

	case dw_val_class_loc_list:
	{
	char *sym = AT_loc_list (a)->ll_symbol;

	gcc_assert (sym);
	dw2_asm_output_offset (DWARF_OFFSET_SIZE, sym, debug_loc_section,
	"%s", name);
	}
	break;

	case dw_val_class_die_ref:
	if (AT_ref_external (a))
	{
	char *sym = AT_ref (a)->die_symbol;

	gcc_assert (sym);
	dw2_asm_output_offset (DWARF2_ADDR_SIZE, sym, debug_info_section,
	"%s", name);
	}
	else
	{
	gcc_assert (AT_ref (a)->die_offset);
	dw2_asm_output_data (DWARF_OFFSET_SIZE, AT_ref (a)->die_offset,
	"%s", name);
	}
	break;

	case dw_val_class_fde_ref:
	{
	char l1[20];

	ASM_GENERATE_INTERNAL_LABEL (l1, FDE_LABEL,
	a->dw_attr_val.v.val_fde_index * 2);
	dw2_asm_output_offset (DWARF_OFFSET_SIZE, l1, debug_frame_section,
	"%s", name);
	}
	break;

	case dw_val_class_lbl_id:
	dw2_asm_output_addr (DWARF2_ADDR_SIZE, AT_lbl (a), "%s", name);
	break;

	case dw_val_class_lineptr:
	dw2_asm_output_offset (DWARF_OFFSET_SIZE, AT_lbl (a),
	debug_line_section, "%s", name);
	break;

	case dw_val_class_macptr:
	dw2_asm_output_offset (DWARF_OFFSET_SIZE, AT_lbl (a),
	debug_macinfo_section, "%s", name);
	break;

	case dw_val_class_str:
	if (AT_string_form (a) == DW_FORM_strp)
	dw2_asm_output_offset (DWARF_OFFSET_SIZE,
	a->dw_attr_val.v.val_str->label,
	debug_str_section,
	"%s: \"%s\"", name, AT_string (a));
	else
	dw2_asm_output_nstring (AT_string (a), -1, "%s", name);
	break;

	case dw_val_class_file:
	{
	int f = maybe_emit_file (a->dw_attr_val.v.val_file);

	dw2_asm_output_data (constant_size (f), f, "%s (%s)", name,
	a->dw_attr_val.v.val_file->filename);
	break;
	}

	default:
	gcc_unreachable ();
	}
	}

	FOR_EACH_CHILD (die, c, output_die (c));

	/* Add null byte to terminate sibling list. */
	if (die->die_child != NULL)
	dw2_asm_output_data (1, 0, "end of children of DIE 0x%lx",
	(unsigned long) die->die_offset);
	}

	/* Output the compilation unit that appears at the beginning of the
	.debug_info section, and precedes the DIE descriptions. */

	static void
	output_compilation_unit_header (void)
	{
	if (DWARF_INITIAL_LENGTH_SIZE - DWARF_OFFSET_SIZE == 4)
	dw2_asm_output_data (4, 0xffffffff,
	"Initial length escape value indicating 64-bit DWARF extension");
	dw2_asm_output_data (DWARF_OFFSET_SIZE,
	next_die_offset - DWARF_INITIAL_LENGTH_SIZE,
	"Length of Compilation Unit Info");
	dw2_asm_output_data (2, DWARF_VERSION, "DWARF version number");
	dw2_asm_output_offset (DWARF_OFFSET_SIZE, abbrev_section_label,
	debug_abbrev_section,
	"Offset Into Abbrev. Section");
	dw2_asm_output_data (1, DWARF2_ADDR_SIZE, "Pointer Size (in bytes)");
	}

	/* Output the compilation unit DIE and its children. */

	static void
	output_comp_unit (dw_die_ref die, int output_if_empty)
	{
	const char *secname;
	char oldsym, tmp;

	/* Unless we are outputting main CU, we may throw away empty ones. */
	if (!output_if_empty && die->die_child == NULL)
	return;

	/* Even if there are no children of this DIE, we must output the information
	about the compilation unit. Otherwise, on an empty translation unit, we
	will generate a present, but empty, .debug_info section. IRIX 6.5 `nm'
	will then complain when examining the file. First mark all the DIEs in
	this CU so we know which get local refs. */
	mark_dies (die);

	build_abbrev_table (die);

	/* Initialize the beginning DIE offset - and calculate sizes/offsets. */
	next_die_offset = DWARF_COMPILE_UNIT_HEADER_SIZE;
	calc_die_sizes (die);

	oldsym = die->die_symbol;
	if (oldsym)
	{
	tmp = alloca (strlen (oldsym) + 24);

	sprintf (tmp, ".gnu.linkonce.wi.%s", oldsym);
	secname = tmp;
	die->die_symbol = NULL;
	switch_to_section (get_section (secname, SECTION_DEBUG, NULL));
	}
	else
	switch_to_section (debug_info_section);

	/* Output debugging information. */
	output_compilation_unit_header ();
	output_die (die);

	/* Leave the marks on the main CU, so we can check them in
	output_pubnames. */
	if (oldsym)
	{
	unmark_dies (die);
	die->die_symbol = oldsym;
	}
	}

	/* Return the DWARF2/3 pubname associated with a decl. */

	static const char *
	dwarf2_name (tree decl, int scope)
	{
	return lang_hooks.dwarf_name (decl, scope ? 1 : 0);
	}

	/* Add a new entry to .debug_pubnames if appropriate. */

	static void
	add_pubname (tree decl, dw_die_ref die)
	{
	pubname_entry e;

	if (! TREE_PUBLIC (decl))
	return;

	e.die = die;
	e.name = xstrdup (dwarf2_name (decl, 1));
	VEC_safe_push (pubname_entry, gc, pubname_table, &e);
	}

	/* Add a new entry to .debug_pubtypes if appropriate. */

	static void
	add_pubtype (tree decl, dw_die_ref die)
	{
	pubname_entry e;

	e.name = NULL;
	if ((TREE_PUBLIC (decl)
	\|\| die->die_parent == comp_unit_die)
	&& (die->die_tag == DW_TAG_typedef \|\| COMPLETE_TYPE_P (decl)))
	{
	e.die = die;
	if (TYPE_P (decl))
	{
	if (TYPE_NAME (decl))
	{
	if (TREE_CODE (TYPE_NAME (decl)) == IDENTIFIER_NODE)
	e.name = xstrdup ((const char *) IDENTIFIER_POINTER
	(TYPE_NAME (decl)));
	else if (TREE_CODE (TYPE_NAME (decl)) == TYPE_DECL
	&& DECL_NAME (TYPE_NAME (decl)))
	e.name = xstrdup ((const char *) IDENTIFIER_POINTER
	(DECL_NAME (TYPE_NAME (decl))));
	else
	e.name = xstrdup ((const char *) get_AT_string (die, DW_AT_name));
	}
	}
	else
	e.name = xstrdup (dwarf2_name (decl, 1));

	/* If we don't have a name for the type, there's no point in adding
	it to the table. */
	if (e.name && e.name[0] != '\0')
	VEC_safe_push (pubname_entry, gc, pubtype_table, &e);
	}
	}

	/* Output the public names table used to speed up access to externally
	visible names; or the public types table used to find type definitions. */

	static void
	output_pubnames (VEC (pubname_entry, gc) * names)
	{
	unsigned i;
	unsigned long pubnames_length = size_of_pubnames (names);
	pubname_ref pub;

	if (DWARF_INITIAL_LENGTH_SIZE - DWARF_OFFSET_SIZE == 4)
	dw2_asm_output_data (4, 0xffffffff,
	"Initial length escape value indicating 64-bit DWARF extension");
	if (names == pubname_table)
	dw2_asm_output_data (DWARF_OFFSET_SIZE, pubnames_length,
	"Length of Public Names Info");
	else
	dw2_asm_output_data (DWARF_OFFSET_SIZE, pubnames_length,
	"Length of Public Type Names Info");
	dw2_asm_output_data (2, DWARF_VERSION, "DWARF Version");
	dw2_asm_output_offset (DWARF_OFFSET_SIZE, debug_info_section_label,
	debug_info_section,
	"Offset of Compilation Unit Info");
	dw2_asm_output_data (DWARF_OFFSET_SIZE, next_die_offset,
	"Compilation Unit Length");

	for (i = 0; VEC_iterate (pubname_entry, names, i, pub); i++)
	{
	/* We shouldn't see pubnames for DIEs outside of the main CU. */
	if (names == pubname_table)
	gcc_assert (pub->die->die_mark);

	if (names != pubtype_table
	\|\| pub->die->die_offset != 0
	\|\| !flag_eliminate_unused_debug_types)
	{
	dw2_asm_output_data (DWARF_OFFSET_SIZE, pub->die->die_offset,
	"DIE offset");

	dw2_asm_output_nstring (pub->name, -1, "external name");
	}
	}

	dw2_asm_output_data (DWARF_OFFSET_SIZE, 0, NULL);
	}

	/* Add a new entry to .debug_aranges if appropriate. */

	static void
	add_arange (tree decl, dw_die_ref die)
	{
	if (! DECL_SECTION_NAME (decl))
	return;

	if (arange_table_in_use == arange_table_allocated)
	{
	arange_table_allocated += ARANGE_TABLE_INCREMENT;
	arange_table = ggc_realloc (arange_table,
	(arange_table_allocated
	* sizeof (dw_die_ref)));
	memset (arange_table + arange_table_in_use, 0,
	ARANGE_TABLE_INCREMENT * sizeof (dw_die_ref));
	}

	arange_table[arange_table_in_use++] = die;
	}

	/* Output the information that goes into the .debug_aranges table.
	Namely, define the beginning and ending address range of the
	text section generated for this compilation unit. */

	static void
	output_aranges (void)
	{
	unsigned i;
	unsigned long aranges_length = size_of_aranges ();

	if (DWARF_INITIAL_LENGTH_SIZE - DWARF_OFFSET_SIZE == 4)
	dw2_asm_output_data (4, 0xffffffff,
	"Initial length escape value indicating 64-bit DWARF extension");
	dw2_asm_output_data (DWARF_OFFSET_SIZE, aranges_length,
	"Length of Address Ranges Info");
	dw2_asm_output_data (2, DWARF_VERSION, "DWARF Version");
	dw2_asm_output_offset (DWARF_OFFSET_SIZE, debug_info_section_label,
	debug_info_section,
	"Offset of Compilation Unit Info");
	dw2_asm_output_data (1, DWARF2_ADDR_SIZE, "Size of Address");
	dw2_asm_output_data (1, 0, "Size of Segment Descriptor");

	/* We need to align to twice the pointer size here. */
	if (DWARF_ARANGES_PAD_SIZE)
	{
	/* Pad using a 2 byte words so that padding is correct for any
	pointer size. */
	dw2_asm_output_data (2, 0, "Pad to %d byte boundary",
	2 * DWARF2_ADDR_SIZE);
	for (i = 2; i < (unsigned) DWARF_ARANGES_PAD_SIZE; i += 2)
	dw2_asm_output_data (2, 0, NULL);
	}

	dw2_asm_output_addr (DWARF2_ADDR_SIZE, text_section_label, "Address");
	dw2_asm_output_delta (DWARF2_ADDR_SIZE, text_end_label,
	text_section_label, "Length");
	if (flag_reorder_blocks_and_partition)
	{
	dw2_asm_output_addr (DWARF2_ADDR_SIZE, cold_text_section_label,
	"Address");
	dw2_asm_output_delta (DWARF2_ADDR_SIZE, cold_end_label,
	cold_text_section_label, "Length");
	}

	for (i = 0; i < arange_table_in_use; i++)
	{
	dw_die_ref die = arange_table[i];

	/* We shouldn't see aranges for DIEs outside of the main CU. */
	gcc_assert (die->die_mark);

	if (die->die_tag == DW_TAG_subprogram)
	{
	dw2_asm_output_addr (DWARF2_ADDR_SIZE, get_AT_low_pc (die),
	"Address");
	dw2_asm_output_delta (DWARF2_ADDR_SIZE, get_AT_hi_pc (die),
	get_AT_low_pc (die), "Length");
	}
	else
	{
	/* A static variable; extract the symbol from DW_AT_location.
	Note that this code isn't currently hit, as we only emit
	aranges for functions (jason 9/23/99). */
	dw_attr_ref a = get_AT (die, DW_AT_location);
	dw_loc_descr_ref loc;

	gcc_assert (a && AT_class (a) == dw_val_class_loc);

	loc = AT_loc (a);
	gcc_assert (loc->dw_loc_opc == DW_OP_addr);

	dw2_asm_output_addr_rtx (DWARF2_ADDR_SIZE,
	loc->dw_loc_oprnd1.v.val_addr, "Address");
	dw2_asm_output_data (DWARF2_ADDR_SIZE,
	get_AT_unsigned (die, DW_AT_byte_size),
	"Length");
	}
	}

	/* Output the terminator words. */
	dw2_asm_output_data (DWARF2_ADDR_SIZE, 0, NULL);
	dw2_asm_output_data (DWARF2_ADDR_SIZE, 0, NULL);
	}

	/* Add a new entry to .debug_ranges. Return the offset at which it
	was placed. */

	static unsigned int
	add_ranges (tree block)
	{
	unsigned int in_use = ranges_table_in_use;

	if (in_use == ranges_table_allocated)
	{
	ranges_table_allocated += RANGES_TABLE_INCREMENT;
	ranges_table
	= ggc_realloc (ranges_table, (ranges_table_allocated
	* sizeof (struct dw_ranges_struct)));
	memset (ranges_table + ranges_table_in_use, 0,
	RANGES_TABLE_INCREMENT * sizeof (struct dw_ranges_struct));
	}

	ranges_table[in_use].block_num = (block ? BLOCK_NUMBER (block) : 0);
	ranges_table_in_use = in_use + 1;

	return in_use * 2 * DWARF2_ADDR_SIZE;
	}

	static void
	output_ranges (void)
	{
	unsigned i;
	static const char *const start_fmt = "Offset 0x%x";
	const char *fmt = start_fmt;

	for (i = 0; i < ranges_table_in_use; i++)
	{
	int block_num = ranges_table[i].block_num;

	if (block_num)
	{
	char blabel[MAX_ARTIFICIAL_LABEL_BYTES];
	char elabel[MAX_ARTIFICIAL_LABEL_BYTES];

	ASM_GENERATE_INTERNAL_LABEL (blabel, BLOCK_BEGIN_LABEL, block_num);
	ASM_GENERATE_INTERNAL_LABEL (elabel, BLOCK_END_LABEL, block_num);

	/* If all code is in the text section, then the compilation
	unit base address defaults to DW_AT_low_pc, which is the
	base of the text section. */
	if (!have_multiple_function_sections)
	{
	dw2_asm_output_delta (DWARF2_ADDR_SIZE, blabel,
	text_section_label,
	fmt, i * 2 * DWARF2_ADDR_SIZE);
	dw2_asm_output_delta (DWARF2_ADDR_SIZE, elabel,
	text_section_label, NULL);
	}

	/* Otherwise, we add a DW_AT_entry_pc attribute to force the
	compilation unit base address to zero, which allows us to
	use absolute addresses, and not worry about whether the
	target supports cross-section arithmetic. */
	else
	{
	dw2_asm_output_addr (DWARF2_ADDR_SIZE, blabel,
	fmt, i * 2 * DWARF2_ADDR_SIZE);
	dw2_asm_output_addr (DWARF2_ADDR_SIZE, elabel, NULL);
	}

	fmt = NULL;
	}
	else
	{
	dw2_asm_output_data (DWARF2_ADDR_SIZE, 0, NULL);
	dw2_asm_output_data (DWARF2_ADDR_SIZE, 0, NULL);
	fmt = start_fmt;
	}
	}
	}

	/* Data structure containing information about input files. */
	struct file_info
	{
	const char path; / Complete file name. */
	const char fname; / File name part. */
	int length; /* Length of entire string. */
	struct dwarf_file_data * file_idx; /* Index in input file table. */
	int dir_idx; /* Index in directory table. */
	};

	/* Data structure containing information about directories with source
	files. */
	struct dir_info
	{
	const char path; / Path including directory name. */
	int length; /* Path length. */
	int prefix; /* Index of directory entry which is a prefix. */
	int count; /* Number of files in this directory. */
	int dir_idx; /* Index of directory used as base. */
	};

	/* Callback function for file_info comparison. We sort by looking at
	the directories in the path. */

	static int
	file_info_cmp (const void p1, const void p2)
	{
	const struct file_info *s1 = p1;
	const struct file_info *s2 = p2;
	unsigned char *cp1;
	unsigned char *cp2;

	/* Take care of file names without directories. We need to make sure that
	we return consistent values to qsort since some will get confused if
	we return the same value when identical operands are passed in opposite
	orders. So if neither has a directory, return 0 and otherwise return
	1 or -1 depending on which one has the directory. */
	if ((s1->path == s1->fname \|\| s2->path == s2->fname))
	return (s2->path == s2->fname) - (s1->path == s1->fname);

	cp1 = (unsigned char *) s1->path;
	cp2 = (unsigned char *) s2->path;

	while (1)
	{
	++cp1;
	++cp2;
	/* Reached the end of the first path? If so, handle like above. */
	if ((cp1 == (unsigned char *) s1->fname)
	\|\| (cp2 == (unsigned char *) s2->fname))
	return ((cp2 == (unsigned char *) s2->fname)
	- (cp1 == (unsigned char *) s1->fname));

	/* Character of current path component the same? */
	else if (cp1 != cp2)
	return cp1 - cp2;
	}
	}

	struct file_name_acquire_data
	{
	struct file_info *files;
	int used_files;
	int max_files;
	};

	/* Traversal function for the hash table. */

	static int
	file_name_acquire (void ** slot, void *data)
	{
	struct file_name_acquire_data *fnad = data;
	struct dwarf_file_data d = slot;
	struct file_info *fi;
	const char *f;

	gcc_assert (fnad->max_files >= d->emitted_number);

	if (! d->emitted_number)
	return 1;

	gcc_assert (fnad->max_files != fnad->used_files);

	fi = fnad->files + fnad->used_files++;

	/* Skip all leading "./". */
	f = d->filename;
	while (f[0] == '.' && f[1] == '/')
	f += 2;

	/* Create a new array entry. */
	fi->path = f;
	fi->length = strlen (f);
	fi->file_idx = d;

	/* Search for the file name part. */
	f = strrchr (f, '/');
	fi->fname = f == NULL ? fi->path : f + 1;
	return 1;
	}

	/* Output the directory table and the file name table. We try to minimize
	the total amount of memory needed. A heuristic is used to avoid large
	slowdowns with many input files. */

	static void
	output_file_names (void)
	{
	struct file_name_acquire_data fnad;
	int numfiles;
	struct file_info *files;
	struct dir_info *dirs;
	int *saved;
	int *savehere;
	int *backmap;
	int ndirs;
	int idx_offset;
	int i;
	int idx;

	if (!last_emitted_file)
	{
	dw2_asm_output_data (1, 0, "End directory table");
	dw2_asm_output_data (1, 0, "End file name table");
	return;
	}

	numfiles = last_emitted_file->emitted_number;

	/* Allocate the various arrays we need. */
	files = alloca (numfiles * sizeof (struct file_info));
	dirs = alloca (numfiles * sizeof (struct dir_info));

	fnad.files = files;
	fnad.used_files = 0;
	fnad.max_files = numfiles;
	htab_traverse (file_table, file_name_acquire, &fnad);
	gcc_assert (fnad.used_files == fnad.max_files);

	qsort (files, numfiles, sizeof (files[0]), file_info_cmp);

	/* Find all the different directories used. */
	dirs[0].path = files[0].path;
	dirs[0].length = files[0].fname - files[0].path;
	dirs[0].prefix = -1;
	dirs[0].count = 1;
	dirs[0].dir_idx = 0;
	files[0].dir_idx = 0;
	ndirs = 1;

	for (i = 1; i < numfiles; i++)
	if (files[i].fname - files[i].path == dirs[ndirs - 1].length
	&& memcmp (dirs[ndirs - 1].path, files[i].path,
	dirs[ndirs - 1].length) == 0)
	{
	/* Same directory as last entry. */
	files[i].dir_idx = ndirs - 1;
	++dirs[ndirs - 1].count;
	}
	else
	{
	int j;

	/* This is a new directory. */
	dirs[ndirs].path = files[i].path;
	dirs[ndirs].length = files[i].fname - files[i].path;
	dirs[ndirs].count = 1;
	dirs[ndirs].dir_idx = ndirs;
	files[i].dir_idx = ndirs;

	/* Search for a prefix. */
	dirs[ndirs].prefix = -1;
	for (j = 0; j < ndirs; j++)
	if (dirs[j].length < dirs[ndirs].length
	&& dirs[j].length > 1
	&& (dirs[ndirs].prefix == -1
	\|\| dirs[j].length > dirs[dirs[ndirs].prefix].length)
	&& memcmp (dirs[j].path, dirs[ndirs].path, dirs[j].length) == 0)
	dirs[ndirs].prefix = j;

	++ndirs;
	}

	/* Now to the actual work. We have to find a subset of the directories which
	allow expressing the file name using references to the directory table
	with the least amount of characters. We do not do an exhaustive search
	where we would have to check out every combination of every single
	possible prefix. Instead we use a heuristic which provides nearly optimal
	results in most cases and never is much off. */
	saved = alloca (ndirs * sizeof (int));
	savehere = alloca (ndirs * sizeof (int));

	memset (saved, '\0', ndirs * sizeof (saved[0]));
	for (i = 0; i < ndirs; i++)
	{
	int j;
	int total;

	/* We can always save some space for the current directory. But this
	does not mean it will be enough to justify adding the directory. */
	savehere[i] = dirs[i].length;
	total = (savehere[i] - saved[i]) * dirs[i].count;

	for (j = i + 1; j < ndirs; j++)
	{
	savehere[j] = 0;
	if (saved[j] < dirs[i].length)
	{
	/* Determine whether the dirs[i] path is a prefix of the
	dirs[j] path. */
	int k;

	k = dirs[j].prefix;
	while (k != -1 && k != (int) i)
	k = dirs[k].prefix;

	if (k == (int) i)
	{
	/* Yes it is. We can possibly save some memory by
	writing the filenames in dirs[j] relative to
	dirs[i]. */
	savehere[j] = dirs[i].length;
	total += (savehere[j] - saved[j]) * dirs[j].count;
	}
	}
	}

	/* Check whether we can save enough to justify adding the dirs[i]
	directory. */
	if (total > dirs[i].length + 1)
	{
	/* It's worthwhile adding. */
	for (j = i; j < ndirs; j++)
	if (savehere[j] > 0)
	{
	/* Remember how much we saved for this directory so far. */
	saved[j] = savehere[j];

	/* Remember the prefix directory. */
	dirs[j].dir_idx = i;
	}
	}
	}

	/* Emit the directory name table. */
	idx = 1;
	idx_offset = dirs[0].length > 0 ? 1 : 0;
	for (i = 1 - idx_offset; i < ndirs; i++)
	dw2_asm_output_nstring (dirs[i].path, dirs[i].length - 1,
	"Directory Entry: 0x%x", i + idx_offset);

	dw2_asm_output_data (1, 0, "End directory table");

	/* We have to emit them in the order of emitted_number since that's
	used in the debug info generation. To do this efficiently we
	generate a back-mapping of the indices first. */
	backmap = alloca (numfiles * sizeof (int));
	for (i = 0; i < numfiles; i++)
	backmap[files[i].file_idx->emitted_number - 1] = i;

	/* Now write all the file names. */
	for (i = 0; i < numfiles; i++)
	{
	int file_idx = backmap[i];
	int dir_idx = dirs[files[file_idx].dir_idx].dir_idx;

	dw2_asm_output_nstring (files[file_idx].path + dirs[dir_idx].length, -1,
	"File Entry: 0x%x", (unsigned) i + 1);

	/* Include directory index. */
	dw2_asm_output_data_uleb128 (dir_idx + idx_offset, NULL);

	/* Modification time. */
	dw2_asm_output_data_uleb128 (0, NULL);

	/* File length in bytes. */
	dw2_asm_output_data_uleb128 (0, NULL);
	}

	dw2_asm_output_data (1, 0, "End file name table");
	}


	/* Output the source line number correspondence information. This
	information goes into the .debug_line section. */

	static void
	output_line_info (void)
	{
	char l1[20], l2[20], p1[20], p2[20];
	char line_label[MAX_ARTIFICIAL_LABEL_BYTES];
	char prev_line_label[MAX_ARTIFICIAL_LABEL_BYTES];
	unsigned opc;
	unsigned n_op_args;
	unsigned long lt_index;
	unsigned long current_line;
	long line_offset;
	long line_delta;
	unsigned long current_file;
	unsigned long function;

	ASM_GENERATE_INTERNAL_LABEL (l1, LINE_NUMBER_BEGIN_LABEL, 0);
	ASM_GENERATE_INTERNAL_LABEL (l2, LINE_NUMBER_END_LABEL, 0);
	ASM_GENERATE_INTERNAL_LABEL (p1, LN_PROLOG_AS_LABEL, 0);
	ASM_GENERATE_INTERNAL_LABEL (p2, LN_PROLOG_END_LABEL, 0);

	if (DWARF_INITIAL_LENGTH_SIZE - DWARF_OFFSET_SIZE == 4)
	dw2_asm_output_data (4, 0xffffffff,
	"Initial length escape value indicating 64-bit DWARF extension");
	dw2_asm_output_delta (DWARF_OFFSET_SIZE, l2, l1,
	"Length of Source Line Info");
	ASM_OUTPUT_LABEL (asm_out_file, l1);

	dw2_asm_output_data (2, DWARF_VERSION, "DWARF Version");
	dw2_asm_output_delta (DWARF_OFFSET_SIZE, p2, p1, "Prolog Length");
	ASM_OUTPUT_LABEL (asm_out_file, p1);

	/* Define the architecture-dependent minimum instruction length (in
	bytes). In this implementation of DWARF, this field is used for
	information purposes only. Since GCC generates assembly language,
	we have no a priori knowledge of how many instruction bytes are
	generated for each source line, and therefore can use only the
	DW_LNE_set_address and DW_LNS_fixed_advance_pc line information
	commands. Accordingly, we fix this as `1', which is "correct
	enough" for all architectures, and don't let the target override. */
	dw2_asm_output_data (1, 1,
	"Minimum Instruction Length");

	dw2_asm_output_data (1, DWARF_LINE_DEFAULT_IS_STMT_START,
	"Default is_stmt_start flag");
	dw2_asm_output_data (1, DWARF_LINE_BASE,
	"Line Base Value (Special Opcodes)");
	dw2_asm_output_data (1, DWARF_LINE_RANGE,
	"Line Range Value (Special Opcodes)");
	dw2_asm_output_data (1, DWARF_LINE_OPCODE_BASE,
	"Special Opcode Base");

	for (opc = 1; opc < DWARF_LINE_OPCODE_BASE; opc++)
	{
	switch (opc)
	{
	case DW_LNS_advance_pc:
	case DW_LNS_advance_line:
	case DW_LNS_set_file:
	case DW_LNS_set_column:
	case DW_LNS_fixed_advance_pc:
	n_op_args = 1;
	break;
	default:
	n_op_args = 0;
	break;
	}

	dw2_asm_output_data (1, n_op_args, "opcode: 0x%x has %d args",
	opc, n_op_args);
	}

	/* Write out the information about the files we use. */
	output_file_names ();
	ASM_OUTPUT_LABEL (asm_out_file, p2);

	/* We used to set the address register to the first location in the text
	section here, but that didn't accomplish anything since we already
	have a line note for the opening brace of the first function. */

	/* Generate the line number to PC correspondence table, encoded as
	a series of state machine operations. */
	current_file = 1;
	current_line = 1;

	if (cfun && in_cold_section_p)
	strcpy (prev_line_label, cfun->cold_section_label);
	else
	strcpy (prev_line_label, text_section_label);
	for (lt_index = 1; lt_index < line_info_table_in_use; ++lt_index)
	{
	dw_line_info_ref line_info = &line_info_table[lt_index];

	#if 0
	/* Disable this optimization for now; GDB wants to see two line notes
	at the beginning of a function so it can find the end of the
	prologue. */

	/* Don't emit anything for redundant notes. Just updating the
	address doesn't accomplish anything, because we already assume
	that anything after the last address is this line. */
	if (line_info->dw_line_num == current_line
	&& line_info->dw_file_num == current_file)
	continue;
	#endif

	/* Emit debug info for the address of the current line.

	Unfortunately, we have little choice here currently, and must always
	use the most general form. GCC does not know the address delta
	itself, so we can't use DW_LNS_advance_pc. Many ports do have length
	attributes which will give an upper bound on the address range. We
	could perhaps use length attributes to determine when it is safe to
	use DW_LNS_fixed_advance_pc. */

	ASM_GENERATE_INTERNAL_LABEL (line_label, LINE_CODE_LABEL, lt_index);
	if (0)
	{
	/* This can handle deltas up to 0xffff. This takes 3 bytes. */
	dw2_asm_output_data (1, DW_LNS_fixed_advance_pc,
	"DW_LNS_fixed_advance_pc");
	dw2_asm_output_delta (2, line_label, prev_line_label, NULL);
	}
	else
	{
	/* This can handle any delta. This takes
	4+DWARF2_ADDR_SIZE bytes. */
	dw2_asm_output_data (1, 0, "DW_LNE_set_address");
	dw2_asm_output_data_uleb128 (1 + DWARF2_ADDR_SIZE, NULL);
	dw2_asm_output_data (1, DW_LNE_set_address, NULL);
	dw2_asm_output_addr (DWARF2_ADDR_SIZE, line_label, NULL);
	}

	strcpy (prev_line_label, line_label);

	/* Emit debug info for the source file of the current line, if
	different from the previous line. */
	if (line_info->dw_file_num != current_file)
	{
	current_file = line_info->dw_file_num;
	dw2_asm_output_data (1, DW_LNS_set_file, "DW_LNS_set_file");
	dw2_asm_output_data_uleb128 (current_file, "%lu", current_file);
	}

	/* Emit debug info for the current line number, choosing the encoding
	that uses the least amount of space. */
	if (line_info->dw_line_num != current_line)
	{
	line_offset = line_info->dw_line_num - current_line;
	line_delta = line_offset - DWARF_LINE_BASE;
	current_line = line_info->dw_line_num;
	if (line_delta >= 0 && line_delta < (DWARF_LINE_RANGE - 1))
	/* This can handle deltas from -10 to 234, using the current
	definitions of DWARF_LINE_BASE and DWARF_LINE_RANGE. This
	takes 1 byte. */
	dw2_asm_output_data (1, DWARF_LINE_OPCODE_BASE + line_delta,
	"line %lu", current_line);
	else
	{
	/* This can handle any delta. This takes at least 4 bytes,
	depending on the value being encoded. */
	dw2_asm_output_data (1, DW_LNS_advance_line,
	"advance to line %lu", current_line);
	dw2_asm_output_data_sleb128 (line_offset, NULL);
	dw2_asm_output_data (1, DW_LNS_copy, "DW_LNS_copy");
	}
	}
	else
	/* We still need to start a new row, so output a copy insn. */
	dw2_asm_output_data (1, DW_LNS_copy, "DW_LNS_copy");
	}

	/* Emit debug info for the address of the end of the function. */
	if (0)
	{
	dw2_asm_output_data (1, DW_LNS_fixed_advance_pc,
	"DW_LNS_fixed_advance_pc");
	dw2_asm_output_delta (2, text_end_label, prev_line_label, NULL);
	}
	else
	{
	dw2_asm_output_data (1, 0, "DW_LNE_set_address");
	dw2_asm_output_data_uleb128 (1 + DWARF2_ADDR_SIZE, NULL);
	dw2_asm_output_data (1, DW_LNE_set_address, NULL);
	dw2_asm_output_addr (DWARF2_ADDR_SIZE, text_end_label, NULL);
	}

	dw2_asm_output_data (1, 0, "DW_LNE_end_sequence");
	dw2_asm_output_data_uleb128 (1, NULL);
	dw2_asm_output_data (1, DW_LNE_end_sequence, NULL);

	function = 0;
	current_file = 1;
	current_line = 1;
	for (lt_index = 0; lt_index < separate_line_info_table_in_use;)
	{
	dw_separate_line_info_ref line_info
	= &separate_line_info_table[lt_index];

	#if 0
	/* Don't emit anything for redundant notes. */
	if (line_info->dw_line_num == current_line
	&& line_info->dw_file_num == current_file
	&& line_info->function == function)
	goto cont;
	#endif

	/* Emit debug info for the address of the current line. If this is
	a new function, or the first line of a function, then we need
	to handle it differently. */
	ASM_GENERATE_INTERNAL_LABEL (line_label, SEPARATE_LINE_CODE_LABEL,
	lt_index);
	if (function != line_info->function)
	{
	function = line_info->function;

	/* Set the address register to the first line in the function. */
	dw2_asm_output_data (1, 0, "DW_LNE_set_address");
	dw2_asm_output_data_uleb128 (1 + DWARF2_ADDR_SIZE, NULL);
	dw2_asm_output_data (1, DW_LNE_set_address, NULL);
	dw2_asm_output_addr (DWARF2_ADDR_SIZE, line_label, NULL);
	}
	else
	{
	/* ??? See the DW_LNS_advance_pc comment above. */
	if (0)
	{
	dw2_asm_output_data (1, DW_LNS_fixed_advance_pc,
	"DW_LNS_fixed_advance_pc");
	dw2_asm_output_delta (2, line_label, prev_line_label, NULL);
	}
	else
	{
	dw2_asm_output_data (1, 0, "DW_LNE_set_address");
	dw2_asm_output_data_uleb128 (1 + DWARF2_ADDR_SIZE, NULL);
	dw2_asm_output_data (1, DW_LNE_set_address, NULL);
	dw2_asm_output_addr (DWARF2_ADDR_SIZE, line_label, NULL);
	}
	}

	strcpy (prev_line_label, line_label);

	/* Emit debug info for the source file of the current line, if
	different from the previous line. */
	if (line_info->dw_file_num != current_file)
	{
	current_file = line_info->dw_file_num;
	dw2_asm_output_data (1, DW_LNS_set_file, "DW_LNS_set_file");
	dw2_asm_output_data_uleb128 (current_file, "%lu", current_file);
	}

	/* Emit debug info for the current line number, choosing the encoding
	that uses the least amount of space. */
	if (line_info->dw_line_num != current_line)
	{
	line_offset = line_info->dw_line_num - current_line;
	line_delta = line_offset - DWARF_LINE_BASE;
	current_line = line_info->dw_line_num;
	if (line_delta >= 0 && line_delta < (DWARF_LINE_RANGE - 1))
	dw2_asm_output_data (1, DWARF_LINE_OPCODE_BASE + line_delta,
	"line %lu", current_line);
	else
	{
	dw2_asm_output_data (1, DW_LNS_advance_line,
	"advance to line %lu", current_line);
	dw2_asm_output_data_sleb128 (line_offset, NULL);
	dw2_asm_output_data (1, DW_LNS_copy, "DW_LNS_copy");
	}
	}
	else
	dw2_asm_output_data (1, DW_LNS_copy, "DW_LNS_copy");

	#if 0
	cont:
	#endif

	lt_index++;

	/* If we're done with a function, end its sequence. */
	if (lt_index == separate_line_info_table_in_use
	\|\| separate_line_info_table[lt_index].function != function)
	{
	current_file = 1;
	current_line = 1;

	/* Emit debug info for the address of the end of the function. */
	ASM_GENERATE_INTERNAL_LABEL (line_label, FUNC_END_LABEL, function);
	if (0)
	{
	dw2_asm_output_data (1, DW_LNS_fixed_advance_pc,
	"DW_LNS_fixed_advance_pc");
	dw2_asm_output_delta (2, line_label, prev_line_label, NULL);
	}
	else
	{
	dw2_asm_output_data (1, 0, "DW_LNE_set_address");
	dw2_asm_output_data_uleb128 (1 + DWARF2_ADDR_SIZE, NULL);
	dw2_asm_output_data (1, DW_LNE_set_address, NULL);
	dw2_asm_output_addr (DWARF2_ADDR_SIZE, line_label, NULL);
	}

	/* Output the marker for the end of this sequence. */
	dw2_asm_output_data (1, 0, "DW_LNE_end_sequence");
	dw2_asm_output_data_uleb128 (1, NULL);
	dw2_asm_output_data (1, DW_LNE_end_sequence, NULL);
	}
	}

	/* Output the marker for the end of the line number info. */
	ASM_OUTPUT_LABEL (asm_out_file, l2);
	}

	/* Given a pointer to a tree node for some base type, return a pointer to
	a DIE that describes the given type.

	This routine must only be called for GCC type nodes that correspond to
	Dwarf base (fundamental) types. */

	static dw_die_ref
	base_type_die (tree type)
	{
	dw_die_ref base_type_result;
	enum dwarf_type encoding;

	if (TREE_CODE (type) == ERROR_MARK \|\| TREE_CODE (type) == VOID_TYPE)
	return 0;

	switch (TREE_CODE (type))
	{
	case INTEGER_TYPE:
	if (TYPE_STRING_FLAG (type))
	{
	if (TYPE_UNSIGNED (type))
	encoding = DW_ATE_unsigned_char;
	else
	encoding = DW_ATE_signed_char;
	}
	else if (TYPE_UNSIGNED (type))
	encoding = DW_ATE_unsigned;
	else
	encoding = DW_ATE_signed;
	break;

	case REAL_TYPE:
	if (DECIMAL_FLOAT_MODE_P (TYPE_MODE (type)))
	encoding = DW_ATE_decimal_float;
	else
	encoding = DW_ATE_float;
	break;

	/* Dwarf2 doesn't know anything about complex ints, so use
	a user defined type for it. */
	case COMPLEX_TYPE:
	if (TREE_CODE (TREE_TYPE (type)) == REAL_TYPE)
	encoding = DW_ATE_complex_float;
	else
	encoding = DW_ATE_lo_user;
	break;

	case BOOLEAN_TYPE:
	/* GNU FORTRAN/Ada/C++ BOOLEAN type. */
	encoding = DW_ATE_boolean;
	break;

	default:
	/* No other TREE_CODEs are Dwarf fundamental types. */
	gcc_unreachable ();
	}

	base_type_result = new_die (DW_TAG_base_type, comp_unit_die, type);

	/* This probably indicates a bug. */
	if (! TYPE_NAME (type))
	add_name_attribute (base_type_result, "__unknown__");

	add_AT_unsigned (base_type_result, DW_AT_byte_size,
	int_size_in_bytes (type));
	add_AT_unsigned (base_type_result, DW_AT_encoding, encoding);

	return base_type_result;
	}

	/* Given a pointer to an arbitrary ..._TYPE tree node, return a pointer to
	the Dwarf "root" type for the given input type. The Dwarf "root" type of
	a given type is generally the same as the given type, except that if the
	given type is a pointer or reference type, then the root type of the given
	type is the root type of the "basis" type for the pointer or reference
	type. (This definition of the "root" type is recursive.) Also, the root
	type of a `const' qualified type or a `volatile' qualified type is the
	root type of the given type without the qualifiers. */

	static tree
	root_type (tree type)
	{
	if (TREE_CODE (type) == ERROR_MARK)
	return error_mark_node;

	switch (TREE_CODE (type))
	{
	case ERROR_MARK:
	return error_mark_node;

	case POINTER_TYPE:
	case REFERENCE_TYPE:
	return type_main_variant (root_type (TREE_TYPE (type)));

	default:
	return type_main_variant (type);
	}
	}

	/* Given a pointer to an arbitrary ..._TYPE tree node, return nonzero if the
	given input type is a Dwarf "fundamental" type. Otherwise return null. */

	static inline int
	is_base_type (tree type)
	{
	switch (TREE_CODE (type))
	{
	case ERROR_MARK:
	case VOID_TYPE:
	case INTEGER_TYPE:
	case REAL_TYPE:
	case COMPLEX_TYPE:
	case BOOLEAN_TYPE:
	return 1;

	case ARRAY_TYPE:
	case RECORD_TYPE:
	case UNION_TYPE:
	case QUAL_UNION_TYPE:
	case ENUMERAL_TYPE:
	case FUNCTION_TYPE:
	case METHOD_TYPE:
	case POINTER_TYPE:
	case REFERENCE_TYPE:
	case OFFSET_TYPE:
	case LANG_TYPE:
	case VECTOR_TYPE:
	return 0;

	default:
	gcc_unreachable ();
	}

	return 0;
	}

	/* Given a pointer to a tree node, assumed to be some kind of a ..._TYPE
	node, return the size in bits for the type if it is a constant, or else
	return the alignment for the type if the type's size is not constant, or
	else return BITS_PER_WORD if the type actually turns out to be an
	ERROR_MARK node. */

	static inline unsigned HOST_WIDE_INT
	simple_type_size_in_bits (tree type)
	{
	if (TREE_CODE (type) == ERROR_MARK)
	return BITS_PER_WORD;
	else if (TYPE_SIZE (type) == NULL_TREE)
	return 0;
	else if (host_integerp (TYPE_SIZE (type), 1))
	return tree_low_cst (TYPE_SIZE (type), 1);
	else
	return TYPE_ALIGN (type);
	}

	/* Return true if the debug information for the given type should be
	emitted as a subrange type. */

	static inline bool
	is_subrange_type (tree type)
	{
	tree subtype = TREE_TYPE (type);

	/* Subrange types are identified by the fact that they are integer
	types, and that they have a subtype which is either an integer type
	or an enumeral type. */

	if (TREE_CODE (type) != INTEGER_TYPE
	\|\| subtype == NULL_TREE)
	return false;

	if (TREE_CODE (subtype) != INTEGER_TYPE
	&& TREE_CODE (subtype) != ENUMERAL_TYPE)
	return false;

	if (TREE_CODE (type) == TREE_CODE (subtype)
	&& int_size_in_bytes (type) == int_size_in_bytes (subtype)
	&& TYPE_MIN_VALUE (type) != NULL
	&& TYPE_MIN_VALUE (subtype) != NULL
	&& tree_int_cst_equal (TYPE_MIN_VALUE (type), TYPE_MIN_VALUE (subtype))
	&& TYPE_MAX_VALUE (type) != NULL
	&& TYPE_MAX_VALUE (subtype) != NULL
	&& tree_int_cst_equal (TYPE_MAX_VALUE (type), TYPE_MAX_VALUE (subtype)))
	{
	/* The type and its subtype have the same representation. If in
	addition the two types also have the same name, then the given
	type is not a subrange type, but rather a plain base type. */
	/* FIXME: brobecker/2004-03-22:
	Sizetype INTEGER_CSTs nodes are canonicalized. It should
	therefore be sufficient to check the TYPE_SIZE node pointers
	rather than checking the actual size. Unfortunately, we have
	found some cases, such as in the Ada "integer" type, where
	this is not the case. Until this problem is solved, we need to
	keep checking the actual size. */
	tree type_name = TYPE_NAME (type);
	tree subtype_name = TYPE_NAME (subtype);

	if (type_name != NULL && TREE_CODE (type_name) == TYPE_DECL)
	type_name = DECL_NAME (type_name);

	if (subtype_name != NULL && TREE_CODE (subtype_name) == TYPE_DECL)
	subtype_name = DECL_NAME (subtype_name);

	if (type_name == subtype_name)
	return false;
	}

	return true;
	}

	/* Given a pointer to a tree node for a subrange type, return a pointer
	to a DIE that describes the given type. */

	static dw_die_ref
	subrange_type_die (tree type, dw_die_ref context_die)
	{
	dw_die_ref subrange_die;
	const HOST_WIDE_INT size_in_bytes = int_size_in_bytes (type);

	if (context_die == NULL)
	context_die = comp_unit_die;

	subrange_die = new_die (DW_TAG_subrange_type, context_die, type);

	if (int_size_in_bytes (TREE_TYPE (type)) != size_in_bytes)
	{
	/* The size of the subrange type and its base type do not match,
	so we need to generate a size attribute for the subrange type. */
	add_AT_unsigned (subrange_die, DW_AT_byte_size, size_in_bytes);
	}

	if (TYPE_MIN_VALUE (type) != NULL)
	add_bound_info (subrange_die, DW_AT_lower_bound,
	TYPE_MIN_VALUE (type));
	if (TYPE_MAX_VALUE (type) != NULL)
	add_bound_info (subrange_die, DW_AT_upper_bound,
	TYPE_MAX_VALUE (type));

	return subrange_die;
	}

	/* Given a pointer to an arbitrary ..._TYPE tree node, return a debugging
	entry that chains various modifiers in front of the given type. */

	static dw_die_ref
	modified_type_die (tree type, int is_const_type, int is_volatile_type,
	dw_die_ref context_die)
	{
	enum tree_code code = TREE_CODE (type);
	dw_die_ref mod_type_die;
	dw_die_ref sub_die = NULL;
	tree item_type = NULL;
	tree qualified_type;
	tree name;

	if (code == ERROR_MARK)
	return NULL;

	/* See if we already have the appropriately qualified variant of
	this type. */
	qualified_type
	= get_qualified_type (type,
	((is_const_type ? TYPE_QUAL_CONST : 0)
	\| (is_volatile_type ? TYPE_QUAL_VOLATILE : 0)));

	/* If we do, then we can just use its DIE, if it exists. */
	if (qualified_type)
	{
	mod_type_die = lookup_type_die (qualified_type);
	if (mod_type_die)
	return mod_type_die;
	}

	name = qualified_type ? TYPE_NAME (qualified_type) : NULL;

	/* Handle C typedef types. */
	if (name && TREE_CODE (name) == TYPE_DECL && DECL_ORIGINAL_TYPE (name))
	{
	tree dtype = TREE_TYPE (name);

	if (qualified_type == dtype)
	{
	/* For a named type, use the typedef. */
	gen_type_die (qualified_type, context_die);
	return lookup_type_die (qualified_type);
	}
	else if (is_const_type < TYPE_READONLY (dtype)
	\|\| is_volatile_type < TYPE_VOLATILE (dtype)
	\|\| (is_const_type <= TYPE_READONLY (dtype)
	&& is_volatile_type <= TYPE_VOLATILE (dtype)
	&& DECL_ORIGINAL_TYPE (name) != type))
	/* cv-unqualified version of named type. Just use the unnamed
	type to which it refers. */
	return modified_type_die (DECL_ORIGINAL_TYPE (name),
	is_const_type, is_volatile_type,
	context_die);
	/* Else cv-qualified version of named type; fall through. */
	}

	if (is_const_type)
	{
	mod_type_die = new_die (DW_TAG_const_type, comp_unit_die, type);
	sub_die = modified_type_die (type, 0, is_volatile_type, context_die);
	}
	else if (is_volatile_type)
	{
	mod_type_die = new_die (DW_TAG_volatile_type, comp_unit_die, type);
	sub_die = modified_type_die (type, 0, 0, context_die);
	}
	else if (code == POINTER_TYPE)
	{
	mod_type_die = new_die (DW_TAG_pointer_type, comp_unit_die, type);
	add_AT_unsigned (mod_type_die, DW_AT_byte_size,
	simple_type_size_in_bits (type) / BITS_PER_UNIT);
	item_type = TREE_TYPE (type);
	}
	else if (code == REFERENCE_TYPE)
	{
	mod_type_die = new_die (DW_TAG_reference_type, comp_unit_die, type);
	add_AT_unsigned (mod_type_die, DW_AT_byte_size,
	simple_type_size_in_bits (type) / BITS_PER_UNIT);
	item_type = TREE_TYPE (type);
	}
	else if (is_subrange_type (type))
	{
	mod_type_die = subrange_type_die (type, context_die);
	item_type = TREE_TYPE (type);
	}
	else if (is_base_type (type))
	mod_type_die = base_type_die (type);
	else
	{
	gen_type_die (type, context_die);

	/* We have to get the type_main_variant here (and pass that to the
	`lookup_type_die' routine) because the ..._TYPE node we have
	might simply be a copy of some original type node (where the
	copy was created to help us keep track of typedef names) and
	that copy might have a different TYPE_UID from the original
	..._TYPE node. */
	if (TREE_CODE (type) != VECTOR_TYPE)
	return lookup_type_die (type_main_variant (type));
	else
	/* Vectors have the debugging information in the type,
	not the main variant. */
	return lookup_type_die (type);
	}

	/* Builtin types don't have a DECL_ORIGINAL_TYPE. For those,
	don't output a DW_TAG_typedef, since there isn't one in the
	user's program; just attach a DW_AT_name to the type. */
	if (name
	&& (TREE_CODE (name) != TYPE_DECL \|\| TREE_TYPE (name) == qualified_type))
	{
	if (TREE_CODE (name) == TYPE_DECL)
	/* Could just call add_name_and_src_coords_attributes here,
	but since this is a builtin type it doesn't have any
	useful source coordinates anyway. */
	name = DECL_NAME (name);
	add_name_attribute (mod_type_die, IDENTIFIER_POINTER (name));
	}

	if (qualified_type)
	equate_type_number_to_die (qualified_type, mod_type_die);

	if (item_type)
	/* We must do this after the equate_type_number_to_die call, in case
	this is a recursive type. This ensures that the modified_type_die
	recursion will terminate even if the type is recursive. Recursive
	types are possible in Ada. */
	sub_die = modified_type_die (item_type,
	TYPE_READONLY (item_type),
	TYPE_VOLATILE (item_type),
	context_die);

	if (sub_die != NULL)
	add_AT_die_ref (mod_type_die, DW_AT_type, sub_die);

	return mod_type_die;
	}

	/* Given a pointer to an arbitrary ..._TYPE tree node, return true if it is
	an enumerated type. */

	static inline int
	type_is_enum (tree type)
	{
	return TREE_CODE (type) == ENUMERAL_TYPE;
	}

	/* Return the DBX register number described by a given RTL node. */

	static unsigned int
	dbx_reg_number (rtx rtl)
	{
	unsigned regno = REGNO (rtl);

	gcc_assert (regno < FIRST_PSEUDO_REGISTER);

	#ifdef LEAF_REG_REMAP
	if (current_function_uses_only_leaf_regs)
	{
	int leaf_reg = LEAF_REG_REMAP (regno);
	if (leaf_reg != -1)
	regno = (unsigned) leaf_reg;
	}
	#endif

	return DBX_REGISTER_NUMBER (regno);
	}

	/* Optionally add a DW_OP_piece term to a location description expression.
	DW_OP_piece is only added if the location description expression already
	doesn't end with DW_OP_piece. */

	static void
	add_loc_descr_op_piece (dw_loc_descr_ref *list_head, int size)
	{
	dw_loc_descr_ref loc;

	if (*list_head != NULL)
	{
	/* Find the end of the chain. */
	for (loc = *list_head; loc->dw_loc_next != NULL; loc = loc->dw_loc_next)
	;

	if (loc->dw_loc_opc != DW_OP_piece)
	loc->dw_loc_next = new_loc_descr (DW_OP_piece, size, 0);
	}
	}

	/* Return a location descriptor that designates a machine register or
	zero if there is none. */

	static dw_loc_descr_ref
	reg_loc_descriptor (rtx rtl)
	{
	rtx regs;

	if (REGNO (rtl) >= FIRST_PSEUDO_REGISTER)
	return 0;

	regs = targetm.dwarf_register_span (rtl);

	if (hard_regno_nregs[REGNO (rtl)][GET_MODE (rtl)] > 1 \|\| regs)
	return multiple_reg_loc_descriptor (rtl, regs);
	else
	return one_reg_loc_descriptor (dbx_reg_number (rtl));
	}

	/* Return a location descriptor that designates a machine register for
	a given hard register number. */

	static dw_loc_descr_ref
	one_reg_loc_descriptor (unsigned int regno)
	{
	if (regno <= 31)
	return new_loc_descr (DW_OP_reg0 + regno, 0, 0);
	else
	return new_loc_descr (DW_OP_regx, regno, 0);
	}

	/* Given an RTL of a register, return a location descriptor that
	designates a value that spans more than one register. */

	static dw_loc_descr_ref
	multiple_reg_loc_descriptor (rtx rtl, rtx regs)
	{
	int nregs, size, i;
	unsigned reg;
	dw_loc_descr_ref loc_result = NULL;

	reg = REGNO (rtl);
	#ifdef LEAF_REG_REMAP
	if (current_function_uses_only_leaf_regs)
	{
	int leaf_reg = LEAF_REG_REMAP (reg);
	if (leaf_reg != -1)
	reg = (unsigned) leaf_reg;
	}
	#endif
	gcc_assert ((unsigned) DBX_REGISTER_NUMBER (reg) == dbx_reg_number (rtl));
	nregs = hard_regno_nregs[REGNO (rtl)][GET_MODE (rtl)];

	/* Simple, contiguous registers. */
	if (regs == NULL_RTX)
	{
	size = GET_MODE_SIZE (GET_MODE (rtl)) / nregs;

	loc_result = NULL;
	while (nregs--)
	{
	dw_loc_descr_ref t;

	t = one_reg_loc_descriptor (DBX_REGISTER_NUMBER (reg));
	add_loc_descr (&loc_result, t);
	add_loc_descr_op_piece (&loc_result, size);
	++reg;
	}
	return loc_result;
	}

	/* Now onto stupid register sets in non contiguous locations. */

	gcc_assert (GET_CODE (regs) == PARALLEL);

	size = GET_MODE_SIZE (GET_MODE (XVECEXP (regs, 0, 0)));
	loc_result = NULL;

	for (i = 0; i < XVECLEN (regs, 0); ++i)
	{
	dw_loc_descr_ref t;

	t = one_reg_loc_descriptor (REGNO (XVECEXP (regs, 0, i)));
	add_loc_descr (&loc_result, t);
	size = GET_MODE_SIZE (GET_MODE (XVECEXP (regs, 0, 0)));
	add_loc_descr_op_piece (&loc_result, size);
	}
	return loc_result;
	}

	/* Return a location descriptor that designates a constant. */

	static dw_loc_descr_ref
	int_loc_descriptor (HOST_WIDE_INT i)
	{
	enum dwarf_location_atom op;

	/* Pick the smallest representation of a constant, rather than just
	defaulting to the LEB encoding. */
	if (i >= 0)
	{
	if (i <= 31)
	op = DW_OP_lit0 + i;
	else if (i <= 0xff)
	op = DW_OP_const1u;
	else if (i <= 0xffff)
	op = DW_OP_const2u;
	else if (HOST_BITS_PER_WIDE_INT == 32
	\|\| i <= 0xffffffff)
	op = DW_OP_const4u;
	else
	op = DW_OP_constu;
	}
	else
	{
	if (i >= -0x80)
	op = DW_OP_const1s;
	else if (i >= -0x8000)
	op = DW_OP_const2s;
	else if (HOST_BITS_PER_WIDE_INT == 32
	\|\| i >= -0x80000000)
	op = DW_OP_const4s;
	else
	op = DW_OP_consts;
	}

	return new_loc_descr (op, i, 0);
	}

	/* Return a location descriptor that designates a base+offset location. */

	static dw_loc_descr_ref
	based_loc_descr (rtx reg, HOST_WIDE_INT offset)
	{
	unsigned int regno;

	/* We only use "frame base" when we're sure we're talking about the
	post-prologue local stack frame. We do this by not running
	register elimination until this point, and recognizing the special
	argument pointer and soft frame pointer rtx's. */
	if (reg == arg_pointer_rtx \|\| reg == frame_pointer_rtx)
	{
	rtx elim = eliminate_regs (reg, VOIDmode, NULL_RTX);

	if (elim != reg)
	{
	if (GET_CODE (elim) == PLUS)
	{
	offset += INTVAL (XEXP (elim, 1));
	elim = XEXP (elim, 0);
	}
	gcc_assert (elim == (frame_pointer_needed ? hard_frame_pointer_rtx
	: stack_pointer_rtx));
	offset += frame_pointer_fb_offset;

	return new_loc_descr (DW_OP_fbreg, offset, 0);
	}
	}

	regno = dbx_reg_number (reg);
	if (regno <= 31)
	return new_loc_descr (DW_OP_breg0 + regno, offset, 0);
	else
	return new_loc_descr (DW_OP_bregx, regno, offset);
	}

	/* Return true if this RTL expression describes a base+offset calculation. */

	static inline int
	is_based_loc (rtx rtl)
	{
	return (GET_CODE (rtl) == PLUS
	&& ((REG_P (XEXP (rtl, 0))
	&& REGNO (XEXP (rtl, 0)) < FIRST_PSEUDO_REGISTER
	&& GET_CODE (XEXP (rtl, 1)) == CONST_INT)));
	}

	/* The following routine converts the RTL for a variable or parameter
	(resident in memory) into an equivalent Dwarf representation of a
	mechanism for getting the address of that same variable onto the top of a
	hypothetical "address evaluation" stack.

	When creating memory location descriptors, we are effectively transforming
	the RTL for a memory-resident object into its Dwarf postfix expression
	equivalent. This routine recursively descends an RTL tree, turning
	it into Dwarf postfix code as it goes.

	MODE is the mode of the memory reference, needed to handle some
	autoincrement addressing modes.

	CAN_USE_FBREG is a flag whether we can use DW_AT_frame_base in the
	location list for RTL.

	Return 0 if we can't represent the location. */

	static dw_loc_descr_ref
	mem_loc_descriptor (rtx rtl, enum machine_mode mode)
	{
	dw_loc_descr_ref mem_loc_result = NULL;
	enum dwarf_location_atom op;

	/* Note that for a dynamically sized array, the location we will generate a
	description of here will be the lowest numbered location which is
	actually within the array. That's not necessarily the same as the
	zeroth element of the array. */

	rtl = targetm.delegitimize_address (rtl);

	switch (GET_CODE (rtl))
	{
	case POST_INC:
	case POST_DEC:
	case POST_MODIFY:
	/* POST_INC and POST_DEC can be handled just like a SUBREG. So we
	just fall into the SUBREG code. */

	/* ... fall through ... */

	case SUBREG:
	/* The case of a subreg may arise when we have a local (register)
	variable or a formal (register) parameter which doesn't quite fill
	up an entire register. For now, just assume that it is
	legitimate to make the Dwarf info refer to the whole register which
	contains the given subreg. */
	rtl = XEXP (rtl, 0);

	/* ... fall through ... */

	case REG:
	/* Whenever a register number forms a part of the description of the
	method for calculating the (dynamic) address of a memory resident
	object, DWARF rules require the register number be referred to as
	a "base register". This distinction is not based in any way upon
	what category of register the hardware believes the given register
	belongs to. This is strictly DWARF terminology we're dealing with
	here. Note that in cases where the location of a memory-resident
	data object could be expressed as: OP_ADD (OP_BASEREG (basereg),
	OP_CONST (0)) the actual DWARF location descriptor that we generate
	may just be OP_BASEREG (basereg). This may look deceptively like
	the object in question was allocated to a register (rather than in
	memory) so DWARF consumers need to be aware of the subtle
	distinction between OP_REG and OP_BASEREG. */
	if (REGNO (rtl) < FIRST_PSEUDO_REGISTER)
	mem_loc_result = based_loc_descr (rtl, 0);
	break;

	case MEM:
	mem_loc_result = mem_loc_descriptor (XEXP (rtl, 0), GET_MODE (rtl));
	if (mem_loc_result != 0)
	add_loc_descr (&mem_loc_result, new_loc_descr (DW_OP_deref, 0, 0));
	break;

	case LO_SUM:
	rtl = XEXP (rtl, 1);

	/* ... fall through ... */

	case LABEL_REF:
	/* Some ports can transform a symbol ref into a label ref, because
	the symbol ref is too far away and has to be dumped into a constant
	pool. */
	case CONST:
	case SYMBOL_REF:
	/* Alternatively, the symbol in the constant pool might be referenced
	by a different symbol. */
	if (GET_CODE (rtl) == SYMBOL_REF && CONSTANT_POOL_ADDRESS_P (rtl))
	{
	bool marked;
	rtx tmp = get_pool_constant_mark (rtl, &marked);

	if (GET_CODE (tmp) == SYMBOL_REF)
	{
	rtl = tmp;
	if (CONSTANT_POOL_ADDRESS_P (tmp))
	get_pool_constant_mark (tmp, &marked);
	else
	marked = true;
	}

	/* If all references to this pool constant were optimized away,
	it was not output and thus we can't represent it.
	FIXME: might try to use DW_OP_const_value here, though
	DW_OP_piece complicates it. */
	if (!marked)
	return 0;
	}

	mem_loc_result = new_loc_descr (DW_OP_addr, 0, 0);
	mem_loc_result->dw_loc_oprnd1.val_class = dw_val_class_addr;
	mem_loc_result->dw_loc_oprnd1.v.val_addr = rtl;
	VEC_safe_push (rtx, gc, used_rtx_array, rtl);
	break;

	case PRE_MODIFY:
	/* Extract the PLUS expression nested inside and fall into
	PLUS code below. */
	rtl = XEXP (rtl, 1);
	goto plus;

	case PRE_INC:
	case PRE_DEC:
	/* Turn these into a PLUS expression and fall into the PLUS code
	below. */
	rtl = gen_rtx_PLUS (word_mode, XEXP (rtl, 0),
	GEN_INT (GET_CODE (rtl) == PRE_INC
	? GET_MODE_UNIT_SIZE (mode)
	: -GET_MODE_UNIT_SIZE (mode)));

	/* ... fall through ... */

	case PLUS:
	plus:
	if (is_based_loc (rtl))
	mem_loc_result = based_loc_descr (XEXP (rtl, 0),
	INTVAL (XEXP (rtl, 1)));
	else
	{
	mem_loc_result = mem_loc_descriptor (XEXP (rtl, 0), mode);
	if (mem_loc_result == 0)
	break;

	if (GET_CODE (XEXP (rtl, 1)) == CONST_INT
	&& INTVAL (XEXP (rtl, 1)) >= 0)
	add_loc_descr (&mem_loc_result,
	new_loc_descr (DW_OP_plus_uconst,
	INTVAL (XEXP (rtl, 1)), 0));
	else
	{
	add_loc_descr (&mem_loc_result,
	mem_loc_descriptor (XEXP (rtl, 1), mode));
	add_loc_descr (&mem_loc_result,
	new_loc_descr (DW_OP_plus, 0, 0));
	}
	}
	break;

	/* If a pseudo-reg is optimized away, it is possible for it to
	be replaced with a MEM containing a multiply or shift. */
	case MULT:
	op = DW_OP_mul;
	goto do_binop;

	case ASHIFT:
	op = DW_OP_shl;
	goto do_binop;

	case ASHIFTRT:
	op = DW_OP_shra;
	goto do_binop;

	case LSHIFTRT:
	op = DW_OP_shr;
	goto do_binop;

	do_binop:
	{
	dw_loc_descr_ref op0 = mem_loc_descriptor (XEXP (rtl, 0), mode);
	dw_loc_descr_ref op1 = mem_loc_descriptor (XEXP (rtl, 1), mode);

	if (op0 == 0 \|\| op1 == 0)
	break;

	mem_loc_result = op0;
	add_loc_descr (&mem_loc_result, op1);
	add_loc_descr (&mem_loc_result, new_loc_descr (op, 0, 0));
	break;
	}

	case CONST_INT:
	mem_loc_result = int_loc_descriptor (INTVAL (rtl));
	break;

	default:
	gcc_unreachable ();
	}

	return mem_loc_result;
	}

	/* Return a descriptor that describes the concatenation of two locations.
	This is typically a complex variable. */

	static dw_loc_descr_ref
	concat_loc_descriptor (rtx x0, rtx x1)
	{
	dw_loc_descr_ref cc_loc_result = NULL;
	dw_loc_descr_ref x0_ref = loc_descriptor (x0);
	dw_loc_descr_ref x1_ref = loc_descriptor (x1);

	if (x0_ref == 0 \|\| x1_ref == 0)
	return 0;

	cc_loc_result = x0_ref;
	add_loc_descr_op_piece (&cc_loc_result, GET_MODE_SIZE (GET_MODE (x0)));

	add_loc_descr (&cc_loc_result, x1_ref);
	add_loc_descr_op_piece (&cc_loc_result, GET_MODE_SIZE (GET_MODE (x1)));

	return cc_loc_result;
	}

	/* Output a proper Dwarf location descriptor for a variable or parameter
	which is either allocated in a register or in a memory location. For a
	register, we just generate an OP_REG and the register number. For a
	memory location we provide a Dwarf postfix expression describing how to
	generate the (dynamic) address of the object onto the address stack.

	If we don't know how to describe it, return 0. */

	static dw_loc_descr_ref
	loc_descriptor (rtx rtl)
	{
	dw_loc_descr_ref loc_result = NULL;

	switch (GET_CODE (rtl))
	{
	case SUBREG:
	/* The case of a subreg may arise when we have a local (register)
	variable or a formal (register) parameter which doesn't quite fill
	up an entire register. For now, just assume that it is
	legitimate to make the Dwarf info refer to the whole register which
	contains the given subreg. */
	rtl = SUBREG_REG (rtl);

	/* ... fall through ... */

	case REG:
	loc_result = reg_loc_descriptor (rtl);
	break;

	case MEM:
	loc_result = mem_loc_descriptor (XEXP (rtl, 0), GET_MODE (rtl));
	break;

	case CONCAT:
	loc_result = concat_loc_descriptor (XEXP (rtl, 0), XEXP (rtl, 1));
	break;

	case VAR_LOCATION:
	/* Single part. */
	if (GET_CODE (XEXP (rtl, 1)) != PARALLEL)
	{
	loc_result = loc_descriptor (XEXP (XEXP (rtl, 1), 0));
	break;
	}

	rtl = XEXP (rtl, 1);
	/* FALLTHRU */

	case PARALLEL:
	{
	rtvec par_elems = XVEC (rtl, 0);
	int num_elem = GET_NUM_ELEM (par_elems);
	enum machine_mode mode;
	int i;

	/* Create the first one, so we have something to add to. */
	loc_result = loc_descriptor (XEXP (RTVEC_ELT (par_elems, 0), 0));
	mode = GET_MODE (XEXP (RTVEC_ELT (par_elems, 0), 0));
	add_loc_descr_op_piece (&loc_result, GET_MODE_SIZE (mode));
	for (i = 1; i < num_elem; i++)
	{
	dw_loc_descr_ref temp;

	temp = loc_descriptor (XEXP (RTVEC_ELT (par_elems, i), 0));
	add_loc_descr (&loc_result, temp);
	mode = GET_MODE (XEXP (RTVEC_ELT (par_elems, i), 0));
	add_loc_descr_op_piece (&loc_result, GET_MODE_SIZE (mode));
	}
	}
	break;

	default:
	gcc_unreachable ();
	}

	return loc_result;
	}

	/* Similar, but generate the descriptor from trees instead of rtl. This comes
	up particularly with variable length arrays. WANT_ADDRESS is 2 if this is
	a top-level invocation of loc_descriptor_from_tree; is 1 if this is not a
	top-level invocation, and we require the address of LOC; is 0 if we require
	the value of LOC. */

	static dw_loc_descr_ref
	loc_descriptor_from_tree_1 (tree loc, int want_address)
	{
	dw_loc_descr_ref ret, ret1;
	int have_address = 0;
	enum dwarf_location_atom op;

	/* ??? Most of the time we do not take proper care for sign/zero
	extending the values properly. Hopefully this won't be a real
	problem... */

	switch (TREE_CODE (loc))
	{
	case ERROR_MARK:
	return 0;

	case PLACEHOLDER_EXPR:
	/* This case involves extracting fields from an object to determine the
	position of other fields. We don't try to encode this here. The
	only user of this is Ada, which encodes the needed information using
	the names of types. */
	return 0;

	case CALL_EXPR:
	return 0;

	case PREINCREMENT_EXPR:
	case PREDECREMENT_EXPR:
	case POSTINCREMENT_EXPR:
	case POSTDECREMENT_EXPR:
	/* There are no opcodes for these operations. */
	return 0;

	case ADDR_EXPR:
	/* If we already want an address, there's nothing we can do. */
	if (want_address)
	return 0;

	/* Otherwise, process the argument and look for the address. */
	return loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 0), 1);

	case VAR_DECL:
	if (DECL_THREAD_LOCAL_P (loc))
	{
	rtx rtl;

	/* If this is not defined, we have no way to emit the data. */
	if (!targetm.asm_out.output_dwarf_dtprel)
	return 0;

	/* The way DW_OP_GNU_push_tls_address is specified, we can only
	look up addresses of objects in the current module. */
	if (DECL_EXTERNAL (loc))
	return 0;

	rtl = rtl_for_decl_location (loc);
	if (rtl == NULL_RTX)
	return 0;

	if (!MEM_P (rtl))
	return 0;
	rtl = XEXP (rtl, 0);
	if (! CONSTANT_P (rtl))
	return 0;

	ret = new_loc_descr (INTERNAL_DW_OP_tls_addr, 0, 0);
	ret->dw_loc_oprnd1.val_class = dw_val_class_addr;
	ret->dw_loc_oprnd1.v.val_addr = rtl;

	ret1 = new_loc_descr (DW_OP_GNU_push_tls_address, 0, 0);
	add_loc_descr (&ret, ret1);

	have_address = 1;
	break;
	}
	/* FALLTHRU */

	case PARM_DECL:
	if (DECL_HAS_VALUE_EXPR_P (loc))
	return loc_descriptor_from_tree_1 (DECL_VALUE_EXPR (loc),
	want_address);
	/* FALLTHRU */

	case RESULT_DECL:
	case FUNCTION_DECL:
	{
	rtx rtl = rtl_for_decl_location (loc);

	if (rtl == NULL_RTX)
	return 0;
	else if (GET_CODE (rtl) == CONST_INT)
	{
	HOST_WIDE_INT val = INTVAL (rtl);
	if (TYPE_UNSIGNED (TREE_TYPE (loc)))
	val &= GET_MODE_MASK (DECL_MODE (loc));
	ret = int_loc_descriptor (val);
	}
	else if (GET_CODE (rtl) == CONST_STRING)
	return 0;
	else if (CONSTANT_P (rtl))
	{
	ret = new_loc_descr (DW_OP_addr, 0, 0);
	ret->dw_loc_oprnd1.val_class = dw_val_class_addr;
	ret->dw_loc_oprnd1.v.val_addr = rtl;
	}
	else
	{
	enum machine_mode mode;

	/* Certain constructs can only be represented at top-level. */
	if (want_address == 2)
	return loc_descriptor (rtl);

	mode = GET_MODE (rtl);
	if (MEM_P (rtl))
	{
	rtl = XEXP (rtl, 0);
	have_address = 1;
	}
	ret = mem_loc_descriptor (rtl, mode);
	}
	}
	break;

	case INDIRECT_REF:
	ret = loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 0), 0);
	have_address = 1;
	break;

	case COMPOUND_EXPR:
	return loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 1), want_address);

	case NOP_EXPR:
	case CONVERT_EXPR:
	case NON_LVALUE_EXPR:
	case VIEW_CONVERT_EXPR:
	case SAVE_EXPR:
	case MODIFY_EXPR:
	return loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 0), want_address);

	case COMPONENT_REF:
	case BIT_FIELD_REF:
	case ARRAY_REF:
	case ARRAY_RANGE_REF:
	{
	tree obj, offset;
	HOST_WIDE_INT bitsize, bitpos, bytepos;
	enum machine_mode mode;
	int volatilep;
	int unsignedp = TYPE_UNSIGNED (TREE_TYPE (loc));

	obj = get_inner_reference (loc, &bitsize, &bitpos, &offset, &mode,
	&unsignedp, &volatilep, false);

	if (obj == loc)
	return 0;

	ret = loc_descriptor_from_tree_1 (obj, 1);
	if (ret == 0
	\|\| bitpos % BITS_PER_UNIT != 0 \|\| bitsize % BITS_PER_UNIT != 0)
	return 0;

	if (offset != NULL_TREE)
	{
	/* Variable offset. */
	add_loc_descr (&ret, loc_descriptor_from_tree_1 (offset, 0));
	add_loc_descr (&ret, new_loc_descr (DW_OP_plus, 0, 0));
	}

	bytepos = bitpos / BITS_PER_UNIT;
	if (bytepos > 0)
	add_loc_descr (&ret, new_loc_descr (DW_OP_plus_uconst, bytepos, 0));
	else if (bytepos < 0)
	{
	add_loc_descr (&ret, int_loc_descriptor (bytepos));
	add_loc_descr (&ret, new_loc_descr (DW_OP_plus, 0, 0));
	}

	have_address = 1;
	break;
	}

	case INTEGER_CST:
	if (host_integerp (loc, 0))
	ret = int_loc_descriptor (tree_low_cst (loc, 0));
	else
	return 0;
	break;

	case CONSTRUCTOR:
	{
	/* Get an RTL for this, if something has been emitted. */
	rtx rtl = lookup_constant_def (loc);
	enum machine_mode mode;

	if (!rtl \|\| !MEM_P (rtl))
	return 0;
	mode = GET_MODE (rtl);
	rtl = XEXP (rtl, 0);
	ret = mem_loc_descriptor (rtl, mode);
	have_address = 1;
	break;
	}

	case TRUTH_AND_EXPR:
	case TRUTH_ANDIF_EXPR:
	case BIT_AND_EXPR:
	op = DW_OP_and;
	goto do_binop;

	case TRUTH_XOR_EXPR:
	case BIT_XOR_EXPR:
	op = DW_OP_xor;
	goto do_binop;

	case TRUTH_OR_EXPR:
	case TRUTH_ORIF_EXPR:
	case BIT_IOR_EXPR:
	op = DW_OP_or;
	goto do_binop;

	case FLOOR_DIV_EXPR:
	case CEIL_DIV_EXPR:
	case ROUND_DIV_EXPR:
	case TRUNC_DIV_EXPR:
	op = DW_OP_div;
	goto do_binop;

	case MINUS_EXPR:
	op = DW_OP_minus;
	goto do_binop;

	case FLOOR_MOD_EXPR:
	case CEIL_MOD_EXPR:
	case ROUND_MOD_EXPR:
	case TRUNC_MOD_EXPR:
	op = DW_OP_mod;
	goto do_binop;

	case MULT_EXPR:
	op = DW_OP_mul;
	goto do_binop;

	case LSHIFT_EXPR:
	op = DW_OP_shl;
	goto do_binop;

	case RSHIFT_EXPR:
	op = (TYPE_UNSIGNED (TREE_TYPE (loc)) ? DW_OP_shr : DW_OP_shra);
	goto do_binop;

	case PLUS_EXPR:
	if (TREE_CODE (TREE_OPERAND (loc, 1)) == INTEGER_CST
	&& host_integerp (TREE_OPERAND (loc, 1), 0))
	{
	ret = loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 0), 0);
	if (ret == 0)
	return 0;

	add_loc_descr (&ret,
	new_loc_descr (DW_OP_plus_uconst,
	tree_low_cst (TREE_OPERAND (loc, 1),
	0),
	0));
	break;
	}

	op = DW_OP_plus;
	goto do_binop;

	case LE_EXPR:
	if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (loc, 0))))
	return 0;

	op = DW_OP_le;
	goto do_binop;

	case GE_EXPR:
	if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (loc, 0))))
	return 0;

	op = DW_OP_ge;
	goto do_binop;

	case LT_EXPR:
	if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (loc, 0))))
	return 0;

	op = DW_OP_lt;
	goto do_binop;

	case GT_EXPR:
	if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (loc, 0))))
	return 0;

	op = DW_OP_gt;
	goto do_binop;

	case EQ_EXPR:
	op = DW_OP_eq;
	goto do_binop;

	case NE_EXPR:
	op = DW_OP_ne;
	goto do_binop;

	do_binop:
	ret = loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 0), 0);
	ret1 = loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 1), 0);
	if (ret == 0 \|\| ret1 == 0)
	return 0;

	add_loc_descr (&ret, ret1);
	add_loc_descr (&ret, new_loc_descr (op, 0, 0));
	break;

	case TRUTH_NOT_EXPR:
	case BIT_NOT_EXPR:
	op = DW_OP_not;
	goto do_unop;

	case ABS_EXPR:
	op = DW_OP_abs;
	goto do_unop;

	case NEGATE_EXPR:
	op = DW_OP_neg;
	goto do_unop;

	do_unop:
	ret = loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 0), 0);
	if (ret == 0)
	return 0;

	add_loc_descr (&ret, new_loc_descr (op, 0, 0));
	break;

	case MIN_EXPR:
	case MAX_EXPR:
	{
	const enum tree_code code =
	TREE_CODE (loc) == MIN_EXPR ? GT_EXPR : LT_EXPR;

	loc = build3 (COND_EXPR, TREE_TYPE (loc),
	build2 (code, integer_type_node,
	TREE_OPERAND (loc, 0), TREE_OPERAND (loc, 1)),
	TREE_OPERAND (loc, 1), TREE_OPERAND (loc, 0));
	}

	/* ... fall through ... */

	case COND_EXPR:
	{
	dw_loc_descr_ref lhs
	= loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 1), 0);
	dw_loc_descr_ref rhs
	= loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 2), 0);
	dw_loc_descr_ref bra_node, jump_node, tmp;

	ret = loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 0), 0);
	if (ret == 0 \|\| lhs == 0 \|\| rhs == 0)
	return 0;

	bra_node = new_loc_descr (DW_OP_bra, 0, 0);
	add_loc_descr (&ret, bra_node);

	add_loc_descr (&ret, rhs);
	jump_node = new_loc_descr (DW_OP_skip, 0, 0);
	add_loc_descr (&ret, jump_node);

	add_loc_descr (&ret, lhs);
	bra_node->dw_loc_oprnd1.val_class = dw_val_class_loc;
	bra_node->dw_loc_oprnd1.v.val_loc = lhs;

	/* ??? Need a node to point the skip at. Use a nop. */
	tmp = new_loc_descr (DW_OP_nop, 0, 0);
	add_loc_descr (&ret, tmp);
	jump_node->dw_loc_oprnd1.val_class = dw_val_class_loc;
	jump_node->dw_loc_oprnd1.v.val_loc = tmp;
	}
	break;

	case FIX_TRUNC_EXPR:
	case FIX_CEIL_EXPR:
	case FIX_FLOOR_EXPR:
	case FIX_ROUND_EXPR:
	return 0;

	default:
	/* Leave front-end specific codes as simply unknown. This comes
	up, for instance, with the C STMT_EXPR. */
	if ((unsigned int) TREE_CODE (loc)
	>= (unsigned int) LAST_AND_UNUSED_TREE_CODE)
	return 0;

	#ifdef ENABLE_CHECKING
	/* Otherwise this is a generic code; we should just lists all of
	these explicitly. We forgot one. */
	gcc_unreachable ();
	#else
	/* In a release build, we want to degrade gracefully: better to
	generate incomplete debugging information than to crash. */
	return NULL;
	#endif
	}

	/* Show if we can't fill the request for an address. */
	if (want_address && !have_address)
	return 0;

	/* If we've got an address and don't want one, dereference. */
	if (!want_address && have_address && ret)
	{
	HOST_WIDE_INT size = int_size_in_bytes (TREE_TYPE (loc));

	if (size > DWARF2_ADDR_SIZE \|\| size == -1)
	return 0;
	else if (size == DWARF2_ADDR_SIZE)
	op = DW_OP_deref;
	else
	op = DW_OP_deref_size;

	add_loc_descr (&ret, new_loc_descr (op, size, 0));
	}

	return ret;
	}

	static inline dw_loc_descr_ref
	loc_descriptor_from_tree (tree loc)
	{
	return loc_descriptor_from_tree_1 (loc, 2);
	}

	/* Given a value, round it up to the lowest multiple of `boundary'
	which is not less than the value itself. */

	static inline HOST_WIDE_INT
	ceiling (HOST_WIDE_INT value, unsigned int boundary)
	{
	return (((value + boundary - 1) / boundary) * boundary);
	}

	/* Given a pointer to what is assumed to be a FIELD_DECL node, return a
	pointer to the declared type for the relevant field variable, or return
	`integer_type_node' if the given node turns out to be an
	ERROR_MARK node. */

	static inline tree
	field_type (tree decl)
	{
	tree type;

	if (TREE_CODE (decl) == ERROR_MARK)
	return integer_type_node;

	type = DECL_BIT_FIELD_TYPE (decl);
	if (type == NULL_TREE)
	type = TREE_TYPE (decl);

	return type;
	}

	/* Given a pointer to a tree node, return the alignment in bits for
	it, or else return BITS_PER_WORD if the node actually turns out to
	be an ERROR_MARK node. */

	static inline unsigned
	simple_type_align_in_bits (tree type)
	{
	return (TREE_CODE (type) != ERROR_MARK) ? TYPE_ALIGN (type) : BITS_PER_WORD;
	}

	static inline unsigned
	simple_decl_align_in_bits (tree decl)
	{
	return (TREE_CODE (decl) != ERROR_MARK) ? DECL_ALIGN (decl) : BITS_PER_WORD;
	}

	/* Given a pointer to a FIELD_DECL, compute and return the byte offset of the
	lowest addressed byte of the "containing object" for the given FIELD_DECL,
	or return 0 if we are unable to determine what that offset is, either
	because the argument turns out to be a pointer to an ERROR_MARK node, or
	because the offset is actually variable. (We can't handle the latter case
	just yet). */

	static HOST_WIDE_INT
	field_byte_offset (tree decl)
	{
	unsigned int type_align_in_bits;
	unsigned int decl_align_in_bits;
	unsigned HOST_WIDE_INT type_size_in_bits;
	HOST_WIDE_INT object_offset_in_bits;
	tree type;
	tree field_size_tree;
	HOST_WIDE_INT bitpos_int;
	HOST_WIDE_INT deepest_bitpos;
	unsigned HOST_WIDE_INT field_size_in_bits;

	if (TREE_CODE (decl) == ERROR_MARK)
	return 0;

	gcc_assert (TREE_CODE (decl) == FIELD_DECL);

	type = field_type (decl);
	field_size_tree = DECL_SIZE (decl);

	/* The size could be unspecified if there was an error, or for
	a flexible array member. */
	if (! field_size_tree)
	field_size_tree = bitsize_zero_node;

	/* We cannot yet cope with fields whose positions are variable, so
	for now, when we see such things, we simply return 0. Someday, we may
	be able to handle such cases, but it will be damn difficult. */
	if (! host_integerp (bit_position (decl), 0))
	return 0;

	bitpos_int = int_bit_position (decl);

	/* If we don't know the size of the field, pretend it's a full word. */
	if (host_integerp (field_size_tree, 1))
	field_size_in_bits = tree_low_cst (field_size_tree, 1);
	else
	field_size_in_bits = BITS_PER_WORD;

	type_size_in_bits = simple_type_size_in_bits (type);
	type_align_in_bits = simple_type_align_in_bits (type);
	decl_align_in_bits = simple_decl_align_in_bits (decl);

	/* The GCC front-end doesn't make any attempt to keep track of the starting
	bit offset (relative to the start of the containing structure type) of the
	hypothetical "containing object" for a bit-field. Thus, when computing
	the byte offset value for the start of the "containing object" of a
	bit-field, we must deduce this information on our own. This can be rather
	tricky to do in some cases. For example, handling the following structure
	type definition when compiling for an i386/i486 target (which only aligns
	long long's to 32-bit boundaries) can be very tricky:

	struct S { int field1; long long field2:31; };

	Fortunately, there is a simple rule-of-thumb which can be used in such
	cases. When compiling for an i386/i486, GCC will allocate 8 bytes for the
	structure shown above. It decides to do this based upon one simple rule
	for bit-field allocation. GCC allocates each "containing object" for each
	bit-field at the first (i.e. lowest addressed) legitimate alignment
	boundary (based upon the required minimum alignment for the declared type
	of the field) which it can possibly use, subject to the condition that
	there is still enough available space remaining in the containing object
	(when allocated at the selected point) to fully accommodate all of the
	bits of the bit-field itself.

	This simple rule makes it obvious why GCC allocates 8 bytes for each
	object of the structure type shown above. When looking for a place to
	allocate the "containing object" for `field2', the compiler simply tries
	to allocate a 64-bit "containing object" at each successive 32-bit
	boundary (starting at zero) until it finds a place to allocate that 64-
	bit field such that at least 31 contiguous (and previously unallocated)
	bits remain within that selected 64 bit field. (As it turns out, for the
	example above, the compiler finds it is OK to allocate the "containing
	object" 64-bit field at bit-offset zero within the structure type.)

	Here we attempt to work backwards from the limited set of facts we're
	given, and we try to deduce from those facts, where GCC must have believed
	that the containing object started (within the structure type). The value
	we deduce is then used (by the callers of this routine) to generate
	DW_AT_location and DW_AT_bit_offset attributes for fields (both bit-fields
	and, in the case of DW_AT_location, regular fields as well). */

	/* Figure out the bit-distance from the start of the structure to the
	"deepest" bit of the bit-field. */
	deepest_bitpos = bitpos_int + field_size_in_bits;

	/* This is the tricky part. Use some fancy footwork to deduce where the
	lowest addressed bit of the containing object must be. */
	object_offset_in_bits = deepest_bitpos - type_size_in_bits;

	/* Round up to type_align by default. This works best for bitfields. */
	object_offset_in_bits += type_align_in_bits - 1;
	object_offset_in_bits /= type_align_in_bits;
	object_offset_in_bits *= type_align_in_bits;

	if (object_offset_in_bits > bitpos_int)
	{
	/* Sigh, the decl must be packed. */
	object_offset_in_bits = deepest_bitpos - type_size_in_bits;

	/* Round up to decl_align instead. */
	object_offset_in_bits += decl_align_in_bits - 1;
	object_offset_in_bits /= decl_align_in_bits;
	object_offset_in_bits *= decl_align_in_bits;
	}

	return object_offset_in_bits / BITS_PER_UNIT;
	}

	/* The following routines define various Dwarf attributes and any data
	associated with them. */

	/* Add a location description attribute value to a DIE.

	This emits location attributes suitable for whole variables and
	whole parameters. Note that the location attributes for struct fields are
	generated by the routine `data_member_location_attribute' below. */

	static inline void
	add_AT_location_description (dw_die_ref die, enum dwarf_attribute attr_kind,
	dw_loc_descr_ref descr)
	{
	if (descr != 0)
	add_AT_loc (die, attr_kind, descr);
	}

	/* Attach the specialized form of location attribute used for data members of
	struct and union types. In the special case of a FIELD_DECL node which
	represents a bit-field, the "offset" part of this special location
	descriptor must indicate the distance in bytes from the lowest-addressed
	byte of the containing struct or union type to the lowest-addressed byte of
	the "containing object" for the bit-field. (See the `field_byte_offset'
	function above).

	For any given bit-field, the "containing object" is a hypothetical object
	(of some integral or enum type) within which the given bit-field lives. The
	type of this hypothetical "containing object" is always the same as the
	declared type of the individual bit-field itself (for GCC anyway... the
	DWARF spec doesn't actually mandate this). Note that it is the size (in
	bytes) of the hypothetical "containing object" which will be given in the
	DW_AT_byte_size attribute for this bit-field. (See the
	`byte_size_attribute' function below.) It is also used when calculating the
	value of the DW_AT_bit_offset attribute. (See the `bit_offset_attribute'
	function below.) */

	static void
	add_data_member_location_attribute (dw_die_ref die, tree decl)
	{
	HOST_WIDE_INT offset;
	dw_loc_descr_ref loc_descr = 0;

	if (TREE_CODE (decl) == TREE_BINFO)
	{
	/* We're working on the TAG_inheritance for a base class. */
	if (BINFO_VIRTUAL_P (decl) && is_cxx ())
	{
	/* For C++ virtual bases we can't just use BINFO_OFFSET, as they
	aren't at a fixed offset from all (sub)objects of the same
	type. We need to extract the appropriate offset from our
	vtable. The following dwarf expression means

	BaseAddr = ObAddr + ((ObAddr) - Offset)

	This is specific to the V3 ABI, of course. */

	dw_loc_descr_ref tmp;

	/* Make a copy of the object address. */
	tmp = new_loc_descr (DW_OP_dup, 0, 0);
	add_loc_descr (&loc_descr, tmp);

	/* Extract the vtable address. */
	tmp = new_loc_descr (DW_OP_deref, 0, 0);
	add_loc_descr (&loc_descr, tmp);

	/* Calculate the address of the offset. */
	offset = tree_low_cst (BINFO_VPTR_FIELD (decl), 0);
	gcc_assert (offset < 0);

	tmp = int_loc_descriptor (-offset);
	add_loc_descr (&loc_descr, tmp);
	tmp = new_loc_descr (DW_OP_minus, 0, 0);
	add_loc_descr (&loc_descr, tmp);

	/* Extract the offset. */
	tmp = new_loc_descr (DW_OP_deref, 0, 0);
	add_loc_descr (&loc_descr, tmp);

	/* Add it to the object address. */
	tmp = new_loc_descr (DW_OP_plus, 0, 0);
	add_loc_descr (&loc_descr, tmp);
	}
	else
	offset = tree_low_cst (BINFO_OFFSET (decl), 0);
	}
	else
	offset = field_byte_offset (decl);

	if (! loc_descr)
	{
	enum dwarf_location_atom op;

	/* The DWARF2 standard says that we should assume that the structure
	address is already on the stack, so we can specify a structure field
	address by using DW_OP_plus_uconst. */

	#ifdef MIPS_DEBUGGING_INFO
	/* ??? The SGI dwarf reader does not handle the DW_OP_plus_uconst
	operator correctly. It works only if we leave the offset on the
	stack. */
	op = DW_OP_constu;
	#else
	op = DW_OP_plus_uconst;
	#endif

	loc_descr = new_loc_descr (op, offset, 0);
	}

	add_AT_loc (die, DW_AT_data_member_location, loc_descr);
	}

	/* Writes integer values to dw_vec_const array. */

	static void
	insert_int (HOST_WIDE_INT val, unsigned int size, unsigned char *dest)
	{
	while (size != 0)
	{
	*dest++ = val & 0xff;
	val >>= 8;
	--size;
	}
	}

	/* Reads integers from dw_vec_const array. Inverse of insert_int. */

	static HOST_WIDE_INT
	extract_int (const unsigned char *src, unsigned int size)
	{
	HOST_WIDE_INT val = 0;

	src += size;
	while (size != 0)
	{
	val <<= 8;
	val \|= *--src & 0xff;
	--size;
	}
	return val;
	}

	/* Writes floating point values to dw_vec_const array. */

	static void
	insert_float (rtx rtl, unsigned char *array)
	{
	REAL_VALUE_TYPE rv;
	long val[4];
	int i;

	REAL_VALUE_FROM_CONST_DOUBLE (rv, rtl);
	real_to_target (val, &rv, GET_MODE (rtl));

	/* real_to_target puts 32-bit pieces in each long. Pack them. */
	for (i = 0; i < GET_MODE_SIZE (GET_MODE (rtl)) / 4; i++)
	{
	insert_int (val[i], 4, array);
	array += 4;
	}
	}

	/* Attach a DW_AT_const_value attribute for a variable or a parameter which
	does not have a "location" either in memory or in a register. These
	things can arise in GNU C when a constant is passed as an actual parameter
	to an inlined function. They can also arise in C++ where declared
	constants do not necessarily get memory "homes". */

	static void
	add_const_value_attribute (dw_die_ref die, rtx rtl)
	{
	switch (GET_CODE (rtl))
	{
	case CONST_INT:
	{
	HOST_WIDE_INT val = INTVAL (rtl);

	if (val < 0)
	add_AT_int (die, DW_AT_const_value, val);
	else
	add_AT_unsigned (die, DW_AT_const_value, (unsigned HOST_WIDE_INT) val);
	}
	break;

	case CONST_DOUBLE:
	/* Note that a CONST_DOUBLE rtx could represent either an integer or a
	floating-point constant. A CONST_DOUBLE is used whenever the
	constant requires more than one word in order to be adequately
	represented. We output CONST_DOUBLEs as blocks. */
	{
	enum machine_mode mode = GET_MODE (rtl);

	if (SCALAR_FLOAT_MODE_P (mode))
	{
	unsigned int length = GET_MODE_SIZE (mode);
	unsigned char *array = ggc_alloc (length);

	insert_float (rtl, array);
	add_AT_vec (die, DW_AT_const_value, length / 4, 4, array);
	}
	else
	{
	/* ??? We really should be using HOST_WIDE_INT throughout. */
	gcc_assert (HOST_BITS_PER_LONG == HOST_BITS_PER_WIDE_INT);

	add_AT_long_long (die, DW_AT_const_value,
	CONST_DOUBLE_HIGH (rtl), CONST_DOUBLE_LOW (rtl));
	}
	}
	break;

	case CONST_VECTOR:
	{
	enum machine_mode mode = GET_MODE (rtl);
	unsigned int elt_size = GET_MODE_UNIT_SIZE (mode);
	unsigned int length = CONST_VECTOR_NUNITS (rtl);
	unsigned char array = ggc_alloc (length elt_size);
	unsigned int i;
	unsigned char *p;

	switch (GET_MODE_CLASS (mode))
	{
	case MODE_VECTOR_INT:
	for (i = 0, p = array; i < length; i++, p += elt_size)
	{
	rtx elt = CONST_VECTOR_ELT (rtl, i);
	HOST_WIDE_INT lo, hi;

	switch (GET_CODE (elt))
	{
	case CONST_INT:
	lo = INTVAL (elt);
	hi = -(lo < 0);
	break;

	case CONST_DOUBLE:
	lo = CONST_DOUBLE_LOW (elt);
	hi = CONST_DOUBLE_HIGH (elt);
	break;

	default:
	gcc_unreachable ();
	}

	if (elt_size <= sizeof (HOST_WIDE_INT))
	insert_int (lo, elt_size, p);
	else
	{
	unsigned char *p0 = p;
	unsigned char *p1 = p + sizeof (HOST_WIDE_INT);

	gcc_assert (elt_size == 2 * sizeof (HOST_WIDE_INT));
	if (WORDS_BIG_ENDIAN)
	{
	p0 = p1;
	p1 = p;
	}
	insert_int (lo, sizeof (HOST_WIDE_INT), p0);
	insert_int (hi, sizeof (HOST_WIDE_INT), p1);
	}
	}
	break;

	case MODE_VECTOR_FLOAT:
	for (i = 0, p = array; i < length; i++, p += elt_size)
	{
	rtx elt = CONST_VECTOR_ELT (rtl, i);
	insert_float (elt, p);
	}
	break;

	default:
	gcc_unreachable ();
	}

	add_AT_vec (die, DW_AT_const_value, length, elt_size, array);
	}
	break;

	case CONST_STRING:
	add_AT_string (die, DW_AT_const_value, XSTR (rtl, 0));
	break;

	case SYMBOL_REF:
	case LABEL_REF:
	case CONST:
	add_AT_addr (die, DW_AT_const_value, rtl);
	VEC_safe_push (rtx, gc, used_rtx_array, rtl);
	break;

	case PLUS:
	/* In cases where an inlined instance of an inline function is passed
	the address of an `auto' variable (which is local to the caller) we
	can get a situation where the DECL_RTL of the artificial local
	variable (for the inlining) which acts as a stand-in for the
	corresponding formal parameter (of the inline function) will look
	like (plus:SI (reg:SI FRAME_PTR) (const_int ...)). This is not
	exactly a compile-time constant expression, but it isn't the address
	of the (artificial) local variable either. Rather, it represents the
	value which the artificial local variable always has during its
	lifetime. We currently have no way to represent such quasi-constant
	values in Dwarf, so for now we just punt and generate nothing. */
	break;

	default:
	/* No other kinds of rtx should be possible here. */
	gcc_unreachable ();
	}

	}

	/* Determine whether the evaluation of EXPR references any variables
	or functions which aren't otherwise used (and therefore may not be
	output). */
	static tree
	reference_to_unused (tree * tp, int * walk_subtrees,
	void * data ATTRIBUTE_UNUSED)
	{
	if (! EXPR_P (tp) && ! CONSTANT_CLASS_P (tp))
	*walk_subtrees = 0;

	if (DECL_P (tp) && ! TREE_PUBLIC (tp) && ! TREE_USED (*tp)
	&& ! TREE_ASM_WRITTEN (*tp))
	return *tp;
	else if (!flag_unit_at_a_time)
	return NULL_TREE;
	else if (!cgraph_global_info_ready
	&& (TREE_CODE (tp) == VAR_DECL \|\| TREE_CODE (tp) == FUNCTION_DECL))
	return *tp;
	else if (DECL_P (tp) && TREE_CODE (tp) == VAR_DECL)
	{
	struct cgraph_varpool_node node = cgraph_varpool_node (tp);
	if (!node->needed)
	return *tp;
	}
	else if (DECL_P (tp) && TREE_CODE (tp) == FUNCTION_DECL
	&& (!DECL_EXTERNAL (tp) \|\| DECL_DECLARED_INLINE_P (tp)))
	{
	struct cgraph_node node = cgraph_node (tp);
	if (!node->output)
	return *tp;
	}

	return NULL_TREE;
	}

	/* Generate an RTL constant from a decl initializer INIT with decl type TYPE,
	for use in a later add_const_value_attribute call. */

	static rtx
	rtl_for_decl_init (tree init, tree type)
	{
	rtx rtl = NULL_RTX;

	/* If a variable is initialized with a string constant without embedded
	zeros, build CONST_STRING. */
	if (TREE_CODE (init) == STRING_CST && TREE_CODE (type) == ARRAY_TYPE)
	{
	tree enttype = TREE_TYPE (type);
	tree domain = TYPE_DOMAIN (type);
	enum machine_mode mode = TYPE_MODE (enttype);

	if (GET_MODE_CLASS (mode) == MODE_INT && GET_MODE_SIZE (mode) == 1
	&& domain
	&& integer_zerop (TYPE_MIN_VALUE (domain))
	&& compare_tree_int (TYPE_MAX_VALUE (domain),
	TREE_STRING_LENGTH (init) - 1) == 0
	&& ((size_t) TREE_STRING_LENGTH (init)
	== strlen (TREE_STRING_POINTER (init)) + 1))
	rtl = gen_rtx_CONST_STRING (VOIDmode,
	ggc_strdup (TREE_STRING_POINTER (init)));
	}
	/* Other aggregates, and complex values, could be represented using
	CONCAT: FIXME! */
	else if (AGGREGATE_TYPE_P (type) \|\| TREE_CODE (type) == COMPLEX_TYPE)
	;
	/* Vectors only work if their mode is supported by the target.
	FIXME: generic vectors ought to work too. */
	else if (TREE_CODE (type) == VECTOR_TYPE && TYPE_MODE (type) == BLKmode)
	;
	/* If the initializer is something that we know will expand into an
	immediate RTL constant, expand it now. We must be careful not to
	reference variables which won't be output. */
	else if (initializer_constant_valid_p (init, type)
	&& ! walk_tree (&init, reference_to_unused, NULL, NULL))
	{
	/* Convert vector CONSTRUCTOR initializers to VECTOR_CST if
	possible. */
	if (TREE_CODE (type) == VECTOR_TYPE)
	switch (TREE_CODE (init))
	{
	case VECTOR_CST:
	break;
	case CONSTRUCTOR:
	if (TREE_CONSTANT (init))
	{
	VEC(constructor_elt,gc) *elts = CONSTRUCTOR_ELTS (init);
	bool constant_p = true;
	tree value;
	unsigned HOST_WIDE_INT ix;

	/* Even when ctor is constant, it might contain non-*_CST
	elements (e.g. { 1.0/0.0 - 1.0/0.0, 0.0 }) and those don't
	belong into VECTOR_CST nodes. */
	FOR_EACH_CONSTRUCTOR_VALUE (elts, ix, value)
	if (!CONSTANT_CLASS_P (value))
	{
	constant_p = false;
	break;
	}

	if (constant_p)
	{
	init = build_vector_from_ctor (type, elts);
	break;
	}
	}
	/* FALLTHRU */

	default:
	return NULL;
	}

	rtl = expand_expr (init, NULL_RTX, VOIDmode, EXPAND_INITIALIZER);

	/* If expand_expr returns a MEM, it wasn't immediate. */
	gcc_assert (!rtl \|\| !MEM_P (rtl));
	}

	return rtl;
	}

	/* Generate RTL for the variable DECL to represent its location. */

	static rtx
	rtl_for_decl_location (tree decl)
	{
	rtx rtl;

	/* Here we have to decide where we are going to say the parameter "lives"
	(as far as the debugger is concerned). We only have a couple of
	choices. GCC provides us with DECL_RTL and with DECL_INCOMING_RTL.

	DECL_RTL normally indicates where the parameter lives during most of the
	activation of the function. If optimization is enabled however, this
	could be either NULL or else a pseudo-reg. Both of those cases indicate
	that the parameter doesn't really live anywhere (as far as the code
	generation parts of GCC are concerned) during most of the function's
	activation. That will happen (for example) if the parameter is never
	referenced within the function.

	We could just generate a location descriptor here for all non-NULL
	non-pseudo values of DECL_RTL and ignore all of the rest, but we can be
	a little nicer than that if we also consider DECL_INCOMING_RTL in cases
	where DECL_RTL is NULL or is a pseudo-reg.

	Note however that we can only get away with using DECL_INCOMING_RTL as
	a backup substitute for DECL_RTL in certain limited cases. In cases
	where DECL_ARG_TYPE (decl) indicates the same type as TREE_TYPE (decl),
	we can be sure that the parameter was passed using the same type as it is
	declared to have within the function, and that its DECL_INCOMING_RTL
	points us to a place where a value of that type is passed.

	In cases where DECL_ARG_TYPE (decl) and TREE_TYPE (decl) are different,
	we cannot (in general) use DECL_INCOMING_RTL as a substitute for DECL_RTL
	because in these cases DECL_INCOMING_RTL points us to a value of some
	type which is different from the type of the parameter itself. Thus,
	if we tried to use DECL_INCOMING_RTL to generate a location attribute in
	such cases, the debugger would end up (for example) trying to fetch a
	`float' from a place which actually contains the first part of a
	`double'. That would lead to really incorrect and confusing
	output at debug-time.

	So, in general, we do not use DECL_INCOMING_RTL as a backup for DECL_RTL
	in cases where DECL_ARG_TYPE (decl) != TREE_TYPE (decl). There
	are a couple of exceptions however. On little-endian machines we can
	get away with using DECL_INCOMING_RTL even when DECL_ARG_TYPE (decl) is
	not the same as TREE_TYPE (decl), but only when DECL_ARG_TYPE (decl) is
	an integral type that is smaller than TREE_TYPE (decl). These cases arise
	when (on a little-endian machine) a non-prototyped function has a
	parameter declared to be of type `short' or `char'. In such cases,
	TREE_TYPE (decl) will be `short' or `char', DECL_ARG_TYPE (decl) will
	be `int', and DECL_INCOMING_RTL will point to the lowest-order byte of the
	passed `int' value. If the debugger then uses that address to fetch
	a `short' or a `char' (on a little-endian machine) the result will be
	the correct data, so we allow for such exceptional cases below.

	Note that our goal here is to describe the place where the given formal
	parameter lives during most of the function's activation (i.e. between the
	end of the prologue and the start of the epilogue). We'll do that as best
	as we can. Note however that if the given formal parameter is modified
	sometime during the execution of the function, then a stack backtrace (at
	debug-time) will show the function as having been called with the new
	value rather than the value which was originally passed in. This happens
	rarely enough that it is not a major problem, but it is a problem, and
	I'd like to fix it.

	A future version of dwarf2out.c may generate two additional attributes for
	any given DW_TAG_formal_parameter DIE which will describe the "passed
	type" and the "passed location" for the given formal parameter in addition
	to the attributes we now generate to indicate the "declared type" and the
	"active location" for each parameter. This additional set of attributes
	could be used by debuggers for stack backtraces. Separately, note that
	sometimes DECL_RTL can be NULL and DECL_INCOMING_RTL can be NULL also.
	This happens (for example) for inlined-instances of inline function formal
	parameters which are never referenced. This really shouldn't be
	happening. All PARM_DECL nodes should get valid non-NULL
	DECL_INCOMING_RTL values. FIXME. */

	/* Use DECL_RTL as the "location" unless we find something better. */
	rtl = DECL_RTL_IF_SET (decl);

	/* When generating abstract instances, ignore everything except
	constants, symbols living in memory, and symbols living in
	fixed registers. */
	if (! reload_completed)
	{
	if (rtl
	&& (CONSTANT_P (rtl)
	\|\| (MEM_P (rtl)
	&& CONSTANT_P (XEXP (rtl, 0)))
	\|\| (REG_P (rtl)
	&& TREE_CODE (decl) == VAR_DECL
	&& TREE_STATIC (decl))))
	{
	rtl = targetm.delegitimize_address (rtl);
	return rtl;
	}
	rtl = NULL_RTX;
	}
	else if (TREE_CODE (decl) == PARM_DECL)
	{
	if (rtl == NULL_RTX \|\| is_pseudo_reg (rtl))
	{
	tree declared_type = TREE_TYPE (decl);
	tree passed_type = DECL_ARG_TYPE (decl);
	enum machine_mode dmode = TYPE_MODE (declared_type);
	enum machine_mode pmode = TYPE_MODE (passed_type);

	/* This decl represents a formal parameter which was optimized out.
	Note that DECL_INCOMING_RTL may be NULL in here, but we handle
	all cases where (rtl == NULL_RTX) just below. */
	if (dmode == pmode)
	rtl = DECL_INCOMING_RTL (decl);
	else if (SCALAR_INT_MODE_P (dmode)
	&& GET_MODE_SIZE (dmode) <= GET_MODE_SIZE (pmode)
	&& DECL_INCOMING_RTL (decl))
	{
	rtx inc = DECL_INCOMING_RTL (decl);
	if (REG_P (inc))
	rtl = inc;
	else if (MEM_P (inc))
	{
	if (BYTES_BIG_ENDIAN)
	rtl = adjust_address_nv (inc, dmode,
	GET_MODE_SIZE (pmode)
	- GET_MODE_SIZE (dmode));
	else
	rtl = inc;
	}
	}
	}

	/* If the parm was passed in registers, but lives on the stack, then
	make a big endian correction if the mode of the type of the
	parameter is not the same as the mode of the rtl. */
	/* ??? This is the same series of checks that are made in dbxout.c before
	we reach the big endian correction code there. It isn't clear if all
	of these checks are necessary here, but keeping them all is the safe
	thing to do. */
	else if (MEM_P (rtl)
	&& XEXP (rtl, 0) != const0_rtx
	&& ! CONSTANT_P (XEXP (rtl, 0))
	/* Not passed in memory. */
	&& !MEM_P (DECL_INCOMING_RTL (decl))
	/* Not passed by invisible reference. */
	&& (!REG_P (XEXP (rtl, 0))
	\|\| REGNO (XEXP (rtl, 0)) == HARD_FRAME_POINTER_REGNUM
	\|\| REGNO (XEXP (rtl, 0)) == STACK_POINTER_REGNUM
	#if ARG_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM
	\|\| REGNO (XEXP (rtl, 0)) == ARG_POINTER_REGNUM
	#endif
	)
	/* Big endian correction check. */
	&& BYTES_BIG_ENDIAN
	&& TYPE_MODE (TREE_TYPE (decl)) != GET_MODE (rtl)
	&& (GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (decl)))
	< UNITS_PER_WORD))
	{
	int offset = (UNITS_PER_WORD
	- GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (decl))));

	rtl = gen_rtx_MEM (TYPE_MODE (TREE_TYPE (decl)),
	plus_constant (XEXP (rtl, 0), offset));
	}
	}
	else if (TREE_CODE (decl) == VAR_DECL
	&& rtl
	&& MEM_P (rtl)
	&& GET_MODE (rtl) != TYPE_MODE (TREE_TYPE (decl))
	&& BYTES_BIG_ENDIAN)
	{
	int rsize = GET_MODE_SIZE (GET_MODE (rtl));
	int dsize = GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (decl)));

	/* If a variable is declared "register" yet is smaller than
	a register, then if we store the variable to memory, it
	looks like we're storing a register-sized value, when in
	fact we are not. We need to adjust the offset of the
	storage location to reflect the actual value's bytes,
	else gdb will not be able to display it. */
	if (rsize > dsize)
	rtl = gen_rtx_MEM (TYPE_MODE (TREE_TYPE (decl)),
	plus_constant (XEXP (rtl, 0), rsize-dsize));
	}

	/* A variable with no DECL_RTL but a DECL_INITIAL is a compile-time constant,
	and will have been substituted directly into all expressions that use it.
	C does not have such a concept, but C++ and other languages do. */
	if (!rtl && TREE_CODE (decl) == VAR_DECL && DECL_INITIAL (decl))
	rtl = rtl_for_decl_init (DECL_INITIAL (decl), TREE_TYPE (decl));

	if (rtl)
	rtl = targetm.delegitimize_address (rtl);

	/* If we don't look past the constant pool, we risk emitting a
	reference to a constant pool entry that isn't referenced from
	code, and thus is not emitted. */
	if (rtl)
	rtl = avoid_constant_pool_reference (rtl);

	return rtl;
	}

	/* We need to figure out what section we should use as the base for the
	address ranges where a given location is valid.
	1. If this particular DECL has a section associated with it, use that.
	2. If this function has a section associated with it, use that.
	3. Otherwise, use the text section.
	XXX: If you split a variable across multiple sections, we won't notice. */

	static const char *
	secname_for_decl (tree decl)
	{
	const char *secname;

	if (VAR_OR_FUNCTION_DECL_P (decl) && DECL_SECTION_NAME (decl))
	{
	tree sectree = DECL_SECTION_NAME (decl);
	secname = TREE_STRING_POINTER (sectree);
	}
	else if (current_function_decl && DECL_SECTION_NAME (current_function_decl))
	{
	tree sectree = DECL_SECTION_NAME (current_function_decl);
	secname = TREE_STRING_POINTER (sectree);
	}
	else if (cfun && in_cold_section_p)
	secname = cfun->cold_section_label;
	else
	secname = text_section_label;

	return secname;
	}

	/* Generate either a DW_AT_location attribute or else a DW_AT_const_value
	data attribute for a variable or a parameter. We generate the
	DW_AT_const_value attribute only in those cases where the given variable
	or parameter does not have a true "location" either in memory or in a
	register. This can happen (for example) when a constant is passed as an
	actual argument in a call to an inline function. (It's possible that
	these things can crop up in other ways also.) Note that one type of
	constant value which can be passed into an inlined function is a constant
	pointer. This can happen for example if an actual argument in an inlined
	function call evaluates to a compile-time constant address. */

	static void
	add_location_or_const_value_attribute (dw_die_ref die, tree decl,
	enum dwarf_attribute attr)
	{
	rtx rtl;
	dw_loc_descr_ref descr;
	var_loc_list *loc_list;
	struct var_loc_node *node;
	if (TREE_CODE (decl) == ERROR_MARK)
	return;

	gcc_assert (TREE_CODE (decl) == VAR_DECL \|\| TREE_CODE (decl) == PARM_DECL
	\|\| TREE_CODE (decl) == RESULT_DECL);

	/* See if we possibly have multiple locations for this variable. */
	loc_list = lookup_decl_loc (decl);

	/* If it truly has multiple locations, the first and last node will
	differ. */
	if (loc_list && loc_list->first != loc_list->last)
	{
	const char endname, secname;
	dw_loc_list_ref list;
	rtx varloc;

	/* Now that we know what section we are using for a base,
	actually construct the list of locations.
	The first location information is what is passed to the
	function that creates the location list, and the remaining
	locations just get added on to that list.
	Note that we only know the start address for a location
	(IE location changes), so to build the range, we use
	the range [current location start, next location start].
	This means we have to special case the last node, and generate
	a range of [last location start, end of function label]. */

	node = loc_list->first;
	varloc = NOTE_VAR_LOCATION (node->var_loc_note);
	secname = secname_for_decl (decl);

	list = new_loc_list (loc_descriptor (varloc),
	node->label, node->next->label, secname, 1);
	node = node->next;

	for (; node->next; node = node->next)
	if (NOTE_VAR_LOCATION_LOC (node->var_loc_note) != NULL_RTX)
	{
	/* The variable has a location between NODE->LABEL and
	NODE->NEXT->LABEL. */
	varloc = NOTE_VAR_LOCATION (node->var_loc_note);
	add_loc_descr_to_loc_list (&list, loc_descriptor (varloc),
	node->label, node->next->label, secname);
	}

	/* If the variable has a location at the last label
	it keeps its location until the end of function. */
	if (NOTE_VAR_LOCATION_LOC (node->var_loc_note) != NULL_RTX)
	{
	char label_id[MAX_ARTIFICIAL_LABEL_BYTES];

	varloc = NOTE_VAR_LOCATION (node->var_loc_note);
	if (!current_function_decl)
	endname = text_end_label;
	else
	{
	ASM_GENERATE_INTERNAL_LABEL (label_id, FUNC_END_LABEL,
	current_function_funcdef_no);
	endname = ggc_strdup (label_id);
	}
	add_loc_descr_to_loc_list (&list, loc_descriptor (varloc),
	node->label, endname, secname);
	}

	/* Finally, add the location list to the DIE, and we are done. */
	add_AT_loc_list (die, attr, list);
	return;
	}

	/* Try to get some constant RTL for this decl, and use that as the value of
	the location. */

	rtl = rtl_for_decl_location (decl);
	if (rtl && (CONSTANT_P (rtl) \|\| GET_CODE (rtl) == CONST_STRING))
	{
	add_const_value_attribute (die, rtl);
	return;
	}

	/* If we have tried to generate the location otherwise, and it
	didn't work out (we wouldn't be here if we did), and we have a one entry
	location list, try generating a location from that. */
	if (loc_list && loc_list->first)
	{
	node = loc_list->first;
	descr = loc_descriptor (NOTE_VAR_LOCATION (node->var_loc_note));
	if (descr)
	{
	add_AT_location_description (die, attr, descr);
	return;
	}
	}

	/* We couldn't get any rtl, so try directly generating the location
	description from the tree. */
	descr = loc_descriptor_from_tree (decl);
	if (descr)
	{
	add_AT_location_description (die, attr, descr);
	return;
	}
	/* None of that worked, so it must not really have a location;
	try adding a constant value attribute from the DECL_INITIAL. */
	tree_add_const_value_attribute (die, decl);
	}

	/* If we don't have a copy of this variable in memory for some reason (such
	as a C++ member constant that doesn't have an out-of-line definition),
	we should tell the debugger about the constant value. */

	static void
	tree_add_const_value_attribute (dw_die_ref var_die, tree decl)
	{
	tree init = DECL_INITIAL (decl);
	tree type = TREE_TYPE (decl);
	rtx rtl;

	if (TREE_READONLY (decl) && ! TREE_THIS_VOLATILE (decl) && init)
	/* OK */;
	else
	return;

	rtl = rtl_for_decl_init (init, type);
	if (rtl)
	add_const_value_attribute (var_die, rtl);
	}

	/* Convert the CFI instructions for the current function into a
	location list. This is used for DW_AT_frame_base when we targeting
	a dwarf2 consumer that does not support the dwarf3
	DW_OP_call_frame_cfa. OFFSET is a constant to be added to all CFA
	expressions. */

	static dw_loc_list_ref
	convert_cfa_to_fb_loc_list (HOST_WIDE_INT offset)
	{
	dw_fde_ref fde;
	dw_loc_list_ref list, *list_tail;
	dw_cfi_ref cfi;
	dw_cfa_location last_cfa, next_cfa;
	const char start_label, last_label, *section;

	fde = &fde_table[fde_table_in_use - 1];

	section = secname_for_decl (current_function_decl);
	list_tail = &list;
	list = NULL;

	next_cfa.reg = INVALID_REGNUM;
	next_cfa.offset = 0;
	next_cfa.indirect = 0;
	next_cfa.base_offset = 0;

	start_label = fde->dw_fde_begin;

	/* ??? Bald assumption that the CIE opcode list does not contain
	advance opcodes. */
	for (cfi = cie_cfi_head; cfi; cfi = cfi->dw_cfi_next)
	lookup_cfa_1 (cfi, &next_cfa);

	last_cfa = next_cfa;
	last_label = start_label;

	for (cfi = fde->dw_fde_cfi; cfi; cfi = cfi->dw_cfi_next)
	switch (cfi->dw_cfi_opc)
	{
	case DW_CFA_set_loc:
	case DW_CFA_advance_loc1:
	case DW_CFA_advance_loc2:
	case DW_CFA_advance_loc4:
	if (!cfa_equal_p (&last_cfa, &next_cfa))
	{
	*list_tail = new_loc_list (build_cfa_loc (&last_cfa, offset),
	start_label, last_label, section,
	list == NULL);

	list_tail = &(*list_tail)->dw_loc_next;
	last_cfa = next_cfa;
	start_label = last_label;
	}
	last_label = cfi->dw_cfi_oprnd1.dw_cfi_addr;
	break;

	case DW_CFA_advance_loc:
	/* The encoding is complex enough that we should never emit this. */
	case DW_CFA_remember_state:
	case DW_CFA_restore_state:
	/* We don't handle these two in this function. It would be possible
	if it were to be required. */
	gcc_unreachable ();

	default:
	lookup_cfa_1 (cfi, &next_cfa);
	break;
	}

	if (!cfa_equal_p (&last_cfa, &next_cfa))
	{
	*list_tail = new_loc_list (build_cfa_loc (&last_cfa, offset),
	start_label, last_label, section,
	list == NULL);
	list_tail = &(*list_tail)->dw_loc_next;
	start_label = last_label;
	}
	*list_tail = new_loc_list (build_cfa_loc (&next_cfa, offset),
	start_label, fde->dw_fde_end, section,
	list == NULL);

	return list;
	}

	/* Compute a displacement from the "steady-state frame pointer" to the
	frame base (often the same as the CFA), and store it in
	frame_pointer_fb_offset. OFFSET is added to the displacement
	before the latter is negated. */

	static void
	compute_frame_pointer_to_fb_displacement (HOST_WIDE_INT offset)
	{
	rtx reg, elim;

	#ifdef FRAME_POINTER_CFA_OFFSET
	reg = frame_pointer_rtx;
	offset += FRAME_POINTER_CFA_OFFSET (current_function_decl);
	#else
	reg = arg_pointer_rtx;
	offset += ARG_POINTER_CFA_OFFSET (current_function_decl);
	#endif

	elim = eliminate_regs (reg, VOIDmode, NULL_RTX);
	if (GET_CODE (elim) == PLUS)
	{
	offset += INTVAL (XEXP (elim, 1));
	elim = XEXP (elim, 0);
	}
	gcc_assert (elim == (frame_pointer_needed ? hard_frame_pointer_rtx
	: stack_pointer_rtx));

	frame_pointer_fb_offset = -offset;
	}

	/* Generate a DW_AT_name attribute given some string value to be included as
	the value of the attribute. */

	static void
	add_name_attribute (dw_die_ref die, const char *name_string)
	{
	if (name_string != NULL && *name_string != 0)
	{
	if (demangle_name_func)
	name_string = (*demangle_name_func) (name_string);

	add_AT_string (die, DW_AT_name, name_string);
	}
	}

	/* Generate a DW_AT_comp_dir attribute for DIE. */

	static void
	add_comp_dir_attribute (dw_die_ref die)
	{
	const char *wd = get_src_pwd ();
	if (wd != NULL)
	add_AT_string (die, DW_AT_comp_dir, wd);
	}

	/* Given a tree node describing an array bound (either lower or upper) output
	a representation for that bound. */

	static void
	add_bound_info (dw_die_ref subrange_die, enum dwarf_attribute bound_attr, tree bound)
	{
	switch (TREE_CODE (bound))
	{
	case ERROR_MARK:
	return;

	/* All fixed-bounds are represented by INTEGER_CST nodes. */
	case INTEGER_CST:
	if (! host_integerp (bound, 0)
	\|\| (bound_attr == DW_AT_lower_bound
	&& (((is_c_family () \|\| is_java ()) && integer_zerop (bound))
	\|\| (is_fortran () && integer_onep (bound)))))
	/* Use the default. */
	;
	else
	add_AT_unsigned (subrange_die, bound_attr, tree_low_cst (bound, 0));
	break;

	case CONVERT_EXPR:
	case NOP_EXPR:
	case NON_LVALUE_EXPR:
	case VIEW_CONVERT_EXPR:
	add_bound_info (subrange_die, bound_attr, TREE_OPERAND (bound, 0));
	break;

	case SAVE_EXPR:
	break;

	case VAR_DECL:
	case PARM_DECL:
	case RESULT_DECL:
	{
	dw_die_ref decl_die = lookup_decl_die (bound);

	/* ??? Can this happen, or should the variable have been bound
	first? Probably it can, since I imagine that we try to create
	the types of parameters in the order in which they exist in
	the list, and won't have created a forward reference to a
	later parameter. */
	if (decl_die != NULL)
	add_AT_die_ref (subrange_die, bound_attr, decl_die);
	break;
	}

	default:
	{
	/* Otherwise try to create a stack operation procedure to
	evaluate the value of the array bound. */

	dw_die_ref ctx, decl_die;
	dw_loc_descr_ref loc;

	loc = loc_descriptor_from_tree (bound);
	if (loc == NULL)
	break;

	if (current_function_decl == 0)
	ctx = comp_unit_die;
	else
	ctx = lookup_decl_die (current_function_decl);

	decl_die = new_die (DW_TAG_variable, ctx, bound);
	add_AT_flag (decl_die, DW_AT_artificial, 1);
	add_type_attribute (decl_die, TREE_TYPE (bound), 1, 0, ctx);
	add_AT_loc (decl_die, DW_AT_location, loc);

	add_AT_die_ref (subrange_die, bound_attr, decl_die);
	break;
	}
	}
	}

	/* Note that the block of subscript information for an array type also
	includes information about the element type of type given array type. */

	static void
	add_subscript_info (dw_die_ref type_die, tree type)
	{
	#ifndef MIPS_DEBUGGING_INFO
	unsigned dimension_number;
	#endif
	tree lower, upper;
	dw_die_ref subrange_die;

	/* The GNU compilers represent multidimensional array types as sequences of
	one dimensional array types whose element types are themselves array
	types. Here we squish that down, so that each multidimensional array
	type gets only one array_type DIE in the Dwarf debugging info. The draft
	Dwarf specification say that we are allowed to do this kind of
	compression in C (because there is no difference between an array or
	arrays and a multidimensional array in C) but for other source languages
	(e.g. Ada) we probably shouldn't do this. */

	/* ??? The SGI dwarf reader fails for multidimensional arrays with a
	const enum type. E.g. const enum machine_mode insn_operand_mode[2][10].
	We work around this by disabling this feature. See also
	gen_array_type_die. */
	#ifndef MIPS_DEBUGGING_INFO
	for (dimension_number = 0;
	TREE_CODE (type) == ARRAY_TYPE;
	type = TREE_TYPE (type), dimension_number++)
	#endif
	{
	tree domain = TYPE_DOMAIN (type);

	/* Arrays come in three flavors: Unspecified bounds, fixed bounds,
	and (in GNU C only) variable bounds. Handle all three forms
	here. */
	subrange_die = new_die (DW_TAG_subrange_type, type_die, NULL);
	if (domain)
	{
	/* We have an array type with specified bounds. */
	lower = TYPE_MIN_VALUE (domain);
	upper = TYPE_MAX_VALUE (domain);

	/* Define the index type. */
	if (TREE_TYPE (domain))
	{
	/* ??? This is probably an Ada unnamed subrange type. Ignore the
	TREE_TYPE field. We can't emit debug info for this
	because it is an unnamed integral type. */
	if (TREE_CODE (domain) == INTEGER_TYPE
	&& TYPE_NAME (domain) == NULL_TREE
	&& TREE_CODE (TREE_TYPE (domain)) == INTEGER_TYPE
	&& TYPE_NAME (TREE_TYPE (domain)) == NULL_TREE)
	;
	else
	add_type_attribute (subrange_die, TREE_TYPE (domain), 0, 0,
	type_die);
	}

	/* ??? If upper is NULL, the array has unspecified length,
	but it does have a lower bound. This happens with Fortran
	dimension arr(N:*)
	Since the debugger is definitely going to need to know N
	to produce useful results, go ahead and output the lower
	bound solo, and hope the debugger can cope. */

	add_bound_info (subrange_die, DW_AT_lower_bound, lower);
	if (upper)
	add_bound_info (subrange_die, DW_AT_upper_bound, upper);
	}

	/* Otherwise we have an array type with an unspecified length. The
	DWARF-2 spec does not say how to handle this; let's just leave out the
	bounds. */
	}
	}

	static void
	add_byte_size_attribute (dw_die_ref die, tree tree_node)
	{
	unsigned size;

	switch (TREE_CODE (tree_node))
	{
	case ERROR_MARK:
	size = 0;
	break;
	case ENUMERAL_TYPE:
	case RECORD_TYPE:
	case UNION_TYPE:
	case QUAL_UNION_TYPE:
	size = int_size_in_bytes (tree_node);
	break;
	case FIELD_DECL:
	/* For a data member of a struct or union, the DW_AT_byte_size is
	generally given as the number of bytes normally allocated for an
	object of the declared type of the member itself. This is true
	even for bit-fields. */
	size = simple_type_size_in_bits (field_type (tree_node)) / BITS_PER_UNIT;
	break;
	default:
	gcc_unreachable ();
	}

	/* Note that `size' might be -1 when we get to this point. If it is, that
	indicates that the byte size of the entity in question is variable. We
	have no good way of expressing this fact in Dwarf at the present time.
	GCC/35998: Avoid passing negative sizes to Dtrace and gdb. */
	add_AT_unsigned (die, DW_AT_byte_size, (size != (unsigned)-1 ? size : 0));
	}

	/* For a FIELD_DECL node which represents a bit-field, output an attribute
	which specifies the distance in bits from the highest order bit of the
	"containing object" for the bit-field to the highest order bit of the
	bit-field itself.

	For any given bit-field, the "containing object" is a hypothetical object
	(of some integral or enum type) within which the given bit-field lives. The
	type of this hypothetical "containing object" is always the same as the
	declared type of the individual bit-field itself. The determination of the
	exact location of the "containing object" for a bit-field is rather
	complicated. It's handled by the `field_byte_offset' function (above).

	Note that it is the size (in bytes) of the hypothetical "containing object"
	which will be given in the DW_AT_byte_size attribute for this bit-field.
	(See `byte_size_attribute' above). */

	static inline void
	add_bit_offset_attribute (dw_die_ref die, tree decl)
	{
	HOST_WIDE_INT object_offset_in_bytes = field_byte_offset (decl);
	tree type = DECL_BIT_FIELD_TYPE (decl);
	HOST_WIDE_INT bitpos_int;
	HOST_WIDE_INT highest_order_object_bit_offset;
	HOST_WIDE_INT highest_order_field_bit_offset;
	HOST_WIDE_INT unsigned bit_offset;

	/* Must be a field and a bit field. */
	gcc_assert (type && TREE_CODE (decl) == FIELD_DECL);

	/* We can't yet handle bit-fields whose offsets are variable, so if we
	encounter such things, just return without generating any attribute
	whatsoever. Likewise for variable or too large size. */
	if (! host_integerp (bit_position (decl), 0)
	\|\| ! host_integerp (DECL_SIZE (decl), 1))
	return;

	bitpos_int = int_bit_position (decl);

	/* Note that the bit offset is always the distance (in bits) from the
	highest-order bit of the "containing object" to the highest-order bit of
	the bit-field itself. Since the "high-order end" of any object or field
	is different on big-endian and little-endian machines, the computation
	below must take account of these differences. */
	highest_order_object_bit_offset = object_offset_in_bytes * BITS_PER_UNIT;
	highest_order_field_bit_offset = bitpos_int;

	if (! BYTES_BIG_ENDIAN)
	{
	highest_order_field_bit_offset += tree_low_cst (DECL_SIZE (decl), 0);
	highest_order_object_bit_offset += simple_type_size_in_bits (type);
	}

	bit_offset
	= (! BYTES_BIG_ENDIAN
	? highest_order_object_bit_offset - highest_order_field_bit_offset
	: highest_order_field_bit_offset - highest_order_object_bit_offset);

	add_AT_unsigned (die, DW_AT_bit_offset, bit_offset);
	}

	/* For a FIELD_DECL node which represents a bit field, output an attribute
	which specifies the length in bits of the given field. */

	static inline void
	add_bit_size_attribute (dw_die_ref die, tree decl)
	{
	/* Must be a field and a bit field. */
	gcc_assert (TREE_CODE (decl) == FIELD_DECL
	&& DECL_BIT_FIELD_TYPE (decl));

	if (host_integerp (DECL_SIZE (decl), 1))
	add_AT_unsigned (die, DW_AT_bit_size, tree_low_cst (DECL_SIZE (decl), 1));
	}

	/* If the compiled language is ANSI C, then add a 'prototyped'
	attribute, if arg types are given for the parameters of a function. */

	static inline void
	add_prototyped_attribute (dw_die_ref die, tree func_type)
	{
	if (get_AT_unsigned (comp_unit_die, DW_AT_language) == DW_LANG_C89
	&& TYPE_ARG_TYPES (func_type) != NULL)
	add_AT_flag (die, DW_AT_prototyped, 1);
	}

	/* Add an 'abstract_origin' attribute below a given DIE. The DIE is found
	by looking in either the type declaration or object declaration
	equate table. */

	static inline void
	add_abstract_origin_attribute (dw_die_ref die, tree origin)
	{
	dw_die_ref origin_die = NULL;

	if (TREE_CODE (origin) != FUNCTION_DECL)
	{
	/* We may have gotten separated from the block for the inlined
	function, if we're in an exception handler or some such; make
	sure that the abstract function has been written out.

	Doing this for nested functions is wrong, however; functions are
	distinct units, and our context might not even be inline. */
	tree fn = origin;

	if (TYPE_P (fn))
	fn = TYPE_STUB_DECL (fn);

	fn = decl_function_context (fn);
	if (fn)
	dwarf2out_abstract_function (fn);
	}

	if (DECL_P (origin))
	origin_die = lookup_decl_die (origin);
	else if (TYPE_P (origin))
	origin_die = lookup_type_die (origin);

	/* XXX: Functions that are never lowered don't always have correct block
	trees (in the case of java, they simply have no block tree, in some other
	languages). For these functions, there is nothing we can really do to
	output correct debug info for inlined functions in all cases. Rather
	than die, we'll just produce deficient debug info now, in that we will
	have variables without a proper abstract origin. In the future, when all
	functions are lowered, we should re-add a gcc_assert (origin_die)
	here. */

	if (origin_die)
	add_AT_die_ref (die, DW_AT_abstract_origin, origin_die);
	}

	/* We do not currently support the pure_virtual attribute. */

	static inline void
	add_pure_or_virtual_attribute (dw_die_ref die, tree func_decl)
	{
	if (DECL_VINDEX (func_decl))
	{
	add_AT_unsigned (die, DW_AT_virtuality, DW_VIRTUALITY_virtual);

	if (host_integerp (DECL_VINDEX (func_decl), 0))
	add_AT_loc (die, DW_AT_vtable_elem_location,
	new_loc_descr (DW_OP_constu,
	tree_low_cst (DECL_VINDEX (func_decl), 0),
	0));

	/* GNU extension: Record what type this method came from originally. */
	if (debug_info_level > DINFO_LEVEL_TERSE)
	add_AT_die_ref (die, DW_AT_containing_type,
	lookup_type_die (DECL_CONTEXT (func_decl)));
	}
	}

	/* Add source coordinate attributes for the given decl. */

	static void
	add_src_coords_attributes (dw_die_ref die, tree decl)
	{
	expanded_location s = expand_location (DECL_SOURCE_LOCATION (decl));

	add_AT_file (die, DW_AT_decl_file, lookup_filename (s.file));
	add_AT_unsigned (die, DW_AT_decl_line, s.line);
	}

	/* Add a DW_AT_name attribute and source coordinate attribute for the
	given decl, but only if it actually has a name. */

	static void
	add_name_and_src_coords_attributes (dw_die_ref die, tree decl)
	{
	tree decl_name;

	decl_name = DECL_NAME (decl);
	if (decl_name != NULL && IDENTIFIER_POINTER (decl_name) != NULL)
	{
	add_name_attribute (die, dwarf2_name (decl, 0));
	if (! DECL_ARTIFICIAL (decl))
	add_src_coords_attributes (die, decl);

	if ((TREE_CODE (decl) == FUNCTION_DECL \|\| TREE_CODE (decl) == VAR_DECL)
	&& TREE_PUBLIC (decl)
	&& DECL_ASSEMBLER_NAME (decl) != DECL_NAME (decl)
	&& !DECL_ABSTRACT (decl)
	&& !(TREE_CODE (decl) == VAR_DECL && DECL_REGISTER (decl)))
	add_AT_string (die, DW_AT_MIPS_linkage_name,
	IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)));
	}

	#ifdef VMS_DEBUGGING_INFO
	/* Get the function's name, as described by its RTL. This may be different
	from the DECL_NAME name used in the source file. */
	if (TREE_CODE (decl) == FUNCTION_DECL && TREE_ASM_WRITTEN (decl))
	{
	add_AT_addr (die, DW_AT_VMS_rtnbeg_pd_address,
	XEXP (DECL_RTL (decl), 0));
	VEC_safe_push (tree, gc, used_rtx_array, XEXP (DECL_RTL (decl), 0));
	}
	#endif
	}

	/* Push a new declaration scope. */

	static void
	push_decl_scope (tree scope)
	{
	VEC_safe_push (tree, gc, decl_scope_table, scope);
	}

	/* Pop a declaration scope. */

	static inline void
	pop_decl_scope (void)
	{
	VEC_pop (tree, decl_scope_table);
	}

	/* Return the DIE for the scope that immediately contains this type.
	Non-named types get global scope. Named types nested in other
	types get their containing scope if it's open, or global scope
	otherwise. All other types (i.e. function-local named types) get
	the current active scope. */

	static dw_die_ref
	scope_die_for (tree t, dw_die_ref context_die)
	{
	dw_die_ref scope_die = NULL;
	tree containing_scope;
	int i;

	/* Non-types always go in the current scope. */
	gcc_assert (TYPE_P (t));

	containing_scope = TYPE_CONTEXT (t);

	/* Use the containing namespace if it was passed in (for a declaration). */
	if (containing_scope && TREE_CODE (containing_scope) == NAMESPACE_DECL)
	{
	if (context_die == lookup_decl_die (containing_scope))
	/* OK */;
	else
	containing_scope = NULL_TREE;
	}

	/* Ignore function type "scopes" from the C frontend. They mean that
	a tagged type is local to a parmlist of a function declarator, but
	that isn't useful to DWARF. */
	if (containing_scope && TREE_CODE (containing_scope) == FUNCTION_TYPE)
	containing_scope = NULL_TREE;

	if (containing_scope == NULL_TREE)
	scope_die = comp_unit_die;
	else if (TYPE_P (containing_scope))
	{
	/* For types, we can just look up the appropriate DIE. But
	first we check to see if we're in the middle of emitting it
	so we know where the new DIE should go. */
	for (i = VEC_length (tree, decl_scope_table) - 1; i >= 0; --i)
	if (VEC_index (tree, decl_scope_table, i) == containing_scope)
	break;

	if (i < 0)
	{
	gcc_assert (debug_info_level <= DINFO_LEVEL_TERSE
	\|\| TREE_ASM_WRITTEN (containing_scope));

	/* If none of the current dies are suitable, we get file scope. */
	scope_die = comp_unit_die;
	}
	else
	scope_die = lookup_type_die (containing_scope);
	}
	else
	scope_die = context_die;

	return scope_die;
	}

	/* Returns nonzero if CONTEXT_DIE is internal to a function. */

	static inline int
	local_scope_p (dw_die_ref context_die)
	{
	for (; context_die; context_die = context_die->die_parent)
	if (context_die->die_tag == DW_TAG_inlined_subroutine
	\|\| context_die->die_tag == DW_TAG_subprogram)
	return 1;

	return 0;
	}

	/* Returns nonzero if CONTEXT_DIE is a class or namespace, for deciding
	whether or not to treat a DIE in this context as a declaration. */

	static inline int
	class_or_namespace_scope_p (dw_die_ref context_die)
	{
	return (context_die
	&& (context_die->die_tag == DW_TAG_structure_type
	\|\| context_die->die_tag == DW_TAG_union_type
	\|\| context_die->die_tag == DW_TAG_namespace));
	}

	/* Many forms of DIEs require a "type description" attribute. This
	routine locates the proper "type descriptor" die for the type given
	by 'type', and adds a DW_AT_type attribute below the given die. */

	static void
	add_type_attribute (dw_die_ref object_die, tree type, int decl_const,
	int decl_volatile, dw_die_ref context_die)
	{
	enum tree_code code = TREE_CODE (type);
	dw_die_ref type_die = NULL;

	/* ??? If this type is an unnamed subrange type of an integral or
	floating-point type, use the inner type. This is because we have no
	support for unnamed types in base_type_die. This can happen if this is
	an Ada subrange type. Correct solution is emit a subrange type die. */
	if ((code == INTEGER_TYPE \|\| code == REAL_TYPE)
	&& TREE_TYPE (type) != 0 && TYPE_NAME (type) == 0)
	type = TREE_TYPE (type), code = TREE_CODE (type);

	if (code == ERROR_MARK
	/* Handle a special case. For functions whose return type is void, we
	generate no type attribute. (Note that no object may have type
	`void', so this only applies to function return types). */
	\|\| code == VOID_TYPE)
	return;

	type_die = modified_type_die (type,
	decl_const \|\| TYPE_READONLY (type),
	decl_volatile \|\| TYPE_VOLATILE (type),
	context_die);

	if (type_die != NULL)
	add_AT_die_ref (object_die, DW_AT_type, type_die);
	}

	/* Given an object die, add the calling convention attribute for the
	function call type. */
	static void
	add_calling_convention_attribute (dw_die_ref subr_die, tree type)
	{
	enum dwarf_calling_convention value = DW_CC_normal;

	value = targetm.dwarf_calling_convention (type);

	/* Only add the attribute if the backend requests it, and
	is not DW_CC_normal. */
	if (value && (value != DW_CC_normal))
	add_AT_unsigned (subr_die, DW_AT_calling_convention, value);
	}

	/* Given a tree pointer to a struct, class, union, or enum type node, return
	a pointer to the (string) tag name for the given type, or zero if the type
	was declared without a tag. */

	static const char *
	type_tag (tree type)
	{
	const char *name = 0;

	if (TYPE_NAME (type) != 0)
	{
	tree t = 0;

	/* Find the IDENTIFIER_NODE for the type name. */
	if (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE)
	t = TYPE_NAME (type);

	/* The g++ front end makes the TYPE_NAME of each tagged type point to
	a TYPE_DECL node, regardless of whether or not a `typedef' was
	involved. */
	else if (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
	&& ! DECL_IGNORED_P (TYPE_NAME (type)))
	t = DECL_NAME (TYPE_NAME (type));

	/* Now get the name as a string, or invent one. */
	if (t != 0)
	name = IDENTIFIER_POINTER (t);
	}

	return (name == 0 \|\| *name == '\0') ? 0 : name;
	}

	/* Return the type associated with a data member, make a special check
	for bit field types. */

	static inline tree
	member_declared_type (tree member)
	{
	return (DECL_BIT_FIELD_TYPE (member)
	? DECL_BIT_FIELD_TYPE (member) : TREE_TYPE (member));
	}

	/* Get the decl's label, as described by its RTL. This may be different
	from the DECL_NAME name used in the source file. */

	#if 0
	static const char *
	decl_start_label (tree decl)
	{
	rtx x;
	const char *fnname;

	x = DECL_RTL (decl);
	gcc_assert (MEM_P (x));

	x = XEXP (x, 0);
	gcc_assert (GET_CODE (x) == SYMBOL_REF);

	fnname = XSTR (x, 0);
	return fnname;
	}
	#endif

	/* These routines generate the internal representation of the DIE's for
	the compilation unit. Debugging information is collected by walking
	the declaration trees passed in from dwarf2out_decl(). */

	static void
	gen_array_type_die (tree type, dw_die_ref context_die)
	{
	dw_die_ref scope_die = scope_die_for (type, context_die);
	dw_die_ref array_die;
	tree element_type;

	/* ??? The SGI dwarf reader fails for array of array of enum types unless
	the inner array type comes before the outer array type. Thus we must
	call gen_type_die before we call new_die. See below also. */
	#ifdef MIPS_DEBUGGING_INFO
	gen_type_die (TREE_TYPE (type), context_die);
	#endif

	array_die = new_die (DW_TAG_array_type, scope_die, type);
	add_name_attribute (array_die, type_tag (type));
	equate_type_number_to_die (type, array_die);

	if (TREE_CODE (type) == VECTOR_TYPE)
	{
	/* The frontend feeds us a representation for the vector as a struct
	containing an array. Pull out the array type. */
	type = TREE_TYPE (TYPE_FIELDS (TYPE_DEBUG_REPRESENTATION_TYPE (type)));
	add_AT_flag (array_die, DW_AT_GNU_vector, 1);
	}

	#if 0
	/* We default the array ordering. SDB will probably do
	the right things even if DW_AT_ordering is not present. It's not even
	an issue until we start to get into multidimensional arrays anyway. If
	SDB is ever caught doing the Wrong Thing for multi-dimensional arrays,
	then we'll have to put the DW_AT_ordering attribute back in. (But if
	and when we find out that we need to put these in, we will only do so
	for multidimensional arrays. */
	add_AT_unsigned (array_die, DW_AT_ordering, DW_ORD_row_major);
	#endif

	#ifdef MIPS_DEBUGGING_INFO
	/* The SGI compilers handle arrays of unknown bound by setting
	AT_declaration and not emitting any subrange DIEs. */
	if (! TYPE_DOMAIN (type))
	add_AT_flag (array_die, DW_AT_declaration, 1);
	else
	#endif
	add_subscript_info (array_die, type);

	/* Add representation of the type of the elements of this array type. */
	element_type = TREE_TYPE (type);

	/* ??? The SGI dwarf reader fails for multidimensional arrays with a
	const enum type. E.g. const enum machine_mode insn_operand_mode[2][10].
	We work around this by disabling this feature. See also
	add_subscript_info. */
	#ifndef MIPS_DEBUGGING_INFO
	while (TREE_CODE (element_type) == ARRAY_TYPE)
	element_type = TREE_TYPE (element_type);

	gen_type_die (element_type, context_die);
	#endif

	add_type_attribute (array_die, element_type, 0, 0, context_die);

	if (get_AT (array_die, DW_AT_name))
	add_pubtype (type, array_die);
	}

	#if 0
	static void
	gen_entry_point_die (tree decl, dw_die_ref context_die)
	{
	tree origin = decl_ultimate_origin (decl);
	dw_die_ref decl_die = new_die (DW_TAG_entry_point, context_die, decl);

	if (origin != NULL)
	add_abstract_origin_attribute (decl_die, origin);
	else
	{
	add_name_and_src_coords_attributes (decl_die, decl);
	add_type_attribute (decl_die, TREE_TYPE (TREE_TYPE (decl)),
	0, 0, context_die);
	}

	if (DECL_ABSTRACT (decl))
	equate_decl_number_to_die (decl, decl_die);
	else
	add_AT_lbl_id (decl_die, DW_AT_low_pc, decl_start_label (decl));
	}
	#endif

	/* Walk through the list of incomplete types again, trying once more to
	emit full debugging info for them. */

	static void
	retry_incomplete_types (void)
	{
	int i;

	for (i = VEC_length (tree, incomplete_types) - 1; i >= 0; i--)
	gen_type_die (VEC_index (tree, incomplete_types, i), comp_unit_die);
	}

	/* Generate a DIE to represent an inlined instance of an enumeration type. */

	static void
	gen_inlined_enumeration_type_die (tree type, dw_die_ref context_die)
	{
	dw_die_ref type_die = new_die (DW_TAG_enumeration_type, context_die, type);

	/* We do not check for TREE_ASM_WRITTEN (type) being set, as the type may
	be incomplete and such types are not marked. */
	add_abstract_origin_attribute (type_die, type);
	}

	/* Generate a DIE to represent an inlined instance of a structure type. */

	static void
	gen_inlined_structure_type_die (tree type, dw_die_ref context_die)
	{
	dw_die_ref type_die = new_die (DW_TAG_structure_type, context_die, type);

	/* We do not check for TREE_ASM_WRITTEN (type) being set, as the type may
	be incomplete and such types are not marked. */
	add_abstract_origin_attribute (type_die, type);
	}

	/* Generate a DIE to represent an inlined instance of a union type. */

	static void
	gen_inlined_union_type_die (tree type, dw_die_ref context_die)
	{
	dw_die_ref type_die = new_die (DW_TAG_union_type, context_die, type);

	/* We do not check for TREE_ASM_WRITTEN (type) being set, as the type may
	be incomplete and such types are not marked. */
	add_abstract_origin_attribute (type_die, type);
	}

	/* Generate a DIE to represent an enumeration type. Note that these DIEs
	include all of the information about the enumeration values also. Each
	enumerated type name/value is listed as a child of the enumerated type
	DIE. */

	static dw_die_ref
	gen_enumeration_type_die (tree type, dw_die_ref context_die)
	{
	dw_die_ref type_die = lookup_type_die (type);

	if (type_die == NULL)
	{
	type_die = new_die (DW_TAG_enumeration_type,
	scope_die_for (type, context_die), type);
	equate_type_number_to_die (type, type_die);
	add_name_attribute (type_die, type_tag (type));
	}
	else if (! TYPE_SIZE (type))
	return type_die;
	else
	remove_AT (type_die, DW_AT_declaration);

	/* Handle a GNU C/C++ extension, i.e. incomplete enum types. If the
	given enum type is incomplete, do not generate the DW_AT_byte_size
	attribute or the DW_AT_element_list attribute. */
	if (TYPE_SIZE (type))
	{
	tree link;

	TREE_ASM_WRITTEN (type) = 1;
	add_byte_size_attribute (type_die, type);
	if (TYPE_STUB_DECL (type) != NULL_TREE)
	add_src_coords_attributes (type_die, TYPE_STUB_DECL (type));

	/* If the first reference to this type was as the return type of an
	inline function, then it may not have a parent. Fix this now. */
	if (type_die->die_parent == NULL)
	add_child_die (scope_die_for (type, context_die), type_die);

	for (link = TYPE_VALUES (type);
	link != NULL; link = TREE_CHAIN (link))
	{
	dw_die_ref enum_die = new_die (DW_TAG_enumerator, type_die, link);
	tree value = TREE_VALUE (link);

	add_name_attribute (enum_die,
	IDENTIFIER_POINTER (TREE_PURPOSE (link)));

	if (host_integerp (value, TYPE_UNSIGNED (TREE_TYPE (value))))
	/* DWARF2 does not provide a way of indicating whether or
	not enumeration constants are signed or unsigned. GDB
	always assumes the values are signed, so we output all
	values as if they were signed. That means that
	enumeration constants with very large unsigned values
	will appear to have negative values in the debugger. */
	add_AT_int (enum_die, DW_AT_const_value,
	tree_low_cst (value, tree_int_cst_sgn (value) > 0));
	}
	}
	else
	add_AT_flag (type_die, DW_AT_declaration, 1);

	if (get_AT (type_die, DW_AT_name))
	add_pubtype (type, type_die);

	return type_die;
	}

	/* Generate a DIE to represent either a real live formal parameter decl or to
	represent just the type of some formal parameter position in some function
	type.

	Note that this routine is a bit unusual because its argument may be a
	..._DECL node (i.e. either a PARM_DECL or perhaps a VAR_DECL which
	represents an inlining of some PARM_DECL) or else some sort of a ..._TYPE
	node. If it's the former then this function is being called to output a
	DIE to represent a formal parameter object (or some inlining thereof). If
	it's the latter, then this function is only being called to output a
	DW_TAG_formal_parameter DIE to stand as a placeholder for some formal
	argument type of some subprogram type. */

	static dw_die_ref
	gen_formal_parameter_die (tree node, dw_die_ref context_die)
	{
	dw_die_ref parm_die
	= new_die (DW_TAG_formal_parameter, context_die, node);
	tree origin;

	switch (TREE_CODE_CLASS (TREE_CODE (node)))
	{
	case tcc_declaration:
	origin = decl_ultimate_origin (node);
	if (origin != NULL)
	add_abstract_origin_attribute (parm_die, origin);
	else
	{
	add_name_and_src_coords_attributes (parm_die, node);
	add_type_attribute (parm_die, TREE_TYPE (node),
	TREE_READONLY (node),
	TREE_THIS_VOLATILE (node),
	context_die);
	if (DECL_ARTIFICIAL (node))
	add_AT_flag (parm_die, DW_AT_artificial, 1);
	}

	equate_decl_number_to_die (node, parm_die);
	if (! DECL_ABSTRACT (node))
	add_location_or_const_value_attribute (parm_die, node, DW_AT_location);

	break;

	case tcc_type:
	/* We were called with some kind of a ..._TYPE node. */
	add_type_attribute (parm_die, node, 0, 0, context_die);
	break;

	default:
	gcc_unreachable ();
	}

	return parm_die;
	}

	/* Generate a special type of DIE used as a stand-in for a trailing ellipsis
	at the end of an (ANSI prototyped) formal parameters list. */

	static void
	gen_unspecified_parameters_die (tree decl_or_type, dw_die_ref context_die)
	{
	new_die (DW_TAG_unspecified_parameters, context_die, decl_or_type);
	}

	/* Generate a list of nameless DW_TAG_formal_parameter DIEs (and perhaps a
	DW_TAG_unspecified_parameters DIE) to represent the types of the formal
	parameters as specified in some function type specification (except for
	those which appear as part of a function definition). */

	static void
	gen_formal_types_die (tree function_or_method_type, dw_die_ref context_die)
	{
	tree link;
	tree formal_type = NULL;
	tree first_parm_type;
	tree arg;

	if (TREE_CODE (function_or_method_type) == FUNCTION_DECL)
	{
	arg = DECL_ARGUMENTS (function_or_method_type);
	function_or_method_type = TREE_TYPE (function_or_method_type);
	}
	else
	arg = NULL_TREE;

	first_parm_type = TYPE_ARG_TYPES (function_or_method_type);

	/* Make our first pass over the list of formal parameter types and output a
	DW_TAG_formal_parameter DIE for each one. */
	for (link = first_parm_type; link; )
	{
	dw_die_ref parm_die;

	formal_type = TREE_VALUE (link);
	if (formal_type == void_type_node)
	break;

	/* Output a (nameless) DIE to represent the formal parameter itself. */
	parm_die = gen_formal_parameter_die (formal_type, context_die);
	if ((TREE_CODE (function_or_method_type) == METHOD_TYPE
	&& link == first_parm_type)
	\|\| (arg && DECL_ARTIFICIAL (arg)))
	add_AT_flag (parm_die, DW_AT_artificial, 1);

	link = TREE_CHAIN (link);
	if (arg)
	arg = TREE_CHAIN (arg);
	}

	/* If this function type has an ellipsis, add a
	DW_TAG_unspecified_parameters DIE to the end of the parameter list. */
	if (formal_type != void_type_node)
	gen_unspecified_parameters_die (function_or_method_type, context_die);

	/* Make our second (and final) pass over the list of formal parameter types
	and output DIEs to represent those types (as necessary). */
	for (link = TYPE_ARG_TYPES (function_or_method_type);
	link && TREE_VALUE (link);
	link = TREE_CHAIN (link))
	gen_type_die (TREE_VALUE (link), context_die);
	}

	/* We want to generate the DIE for TYPE so that we can generate the
	die for MEMBER, which has been defined; we will need to refer back
	to the member declaration nested within TYPE. If we're trying to
	generate minimal debug info for TYPE, processing TYPE won't do the
	trick; we need to attach the member declaration by hand. */

	static void
	gen_type_die_for_member (tree type, tree member, dw_die_ref context_die)
	{
	gen_type_die (type, context_die);

	/* If we're trying to avoid duplicate debug info, we may not have
	emitted the member decl for this function. Emit it now. */
	if (TYPE_DECL_SUPPRESS_DEBUG (TYPE_STUB_DECL (type))
	&& ! lookup_decl_die (member))
	{
	dw_die_ref type_die;
	gcc_assert (!decl_ultimate_origin (member));

	push_decl_scope (type);
	type_die = lookup_type_die (type);
	if (TREE_CODE (member) == FUNCTION_DECL)
	gen_subprogram_die (member, type_die);
	else if (TREE_CODE (member) == FIELD_DECL)
	{
	/* Ignore the nameless fields that are used to skip bits but handle
	C++ anonymous unions and structs. */
	if (DECL_NAME (member) != NULL_TREE
	\|\| TREE_CODE (TREE_TYPE (member)) == UNION_TYPE
	\|\| TREE_CODE (TREE_TYPE (member)) == RECORD_TYPE)
	{
	gen_type_die (member_declared_type (member), type_die);
	gen_field_die (member, type_die);
	}
	}
	else
	gen_variable_die (member, type_die);

	pop_decl_scope ();
	}
	}

	/* Generate the DWARF2 info for the "abstract" instance of a function which we
	may later generate inlined and/or out-of-line instances of. */

	static void
	dwarf2out_abstract_function (tree decl)
	{
	dw_die_ref old_die;
	tree save_fn;
	struct function *save_cfun;
	tree context;
	int was_abstract = DECL_ABSTRACT (decl);

	/* Make sure we have the actual abstract inline, not a clone. */
	decl = DECL_ORIGIN (decl);

	old_die = lookup_decl_die (decl);
	if (old_die && get_AT (old_die, DW_AT_inline))
	/* We've already generated the abstract instance. */
	return;

	/* Be sure we've emitted the in-class declaration DIE (if any) first, so
	we don't get confused by DECL_ABSTRACT. */
	if (debug_info_level > DINFO_LEVEL_TERSE)
	{
	context = decl_class_context (decl);
	if (context)
	gen_type_die_for_member
	(context, decl, decl_function_context (decl) ? NULL : comp_unit_die);
	}

	/* Pretend we've just finished compiling this function. */
	save_fn = current_function_decl;
	save_cfun = cfun;
	current_function_decl = decl;
	cfun = DECL_STRUCT_FUNCTION (decl);

	set_decl_abstract_flags (decl, 1);
	dwarf2out_decl (decl);
	if (! was_abstract)
	set_decl_abstract_flags (decl, 0);

	current_function_decl = save_fn;
	cfun = save_cfun;
	}

	/* Helper function of premark_used_types() which gets called through
	htab_traverse_resize().

	Marks the DIE of a given type in *SLOT as perennial, so it never gets
	marked as unused by prune_unused_types. */
	static int
	premark_used_types_helper (void *slot, void data ATTRIBUTE_UNUSED)
	{
	tree type;
	dw_die_ref die;

	type = *slot;
	die = lookup_type_die (type);
	if (die != NULL)
	die->die_perennial_p = 1;
	return 1;
	}

	/* Mark all members of used_types_hash as perennial. */
	static void
	premark_used_types (void)
	{
	if (cfun && cfun->used_types_hash)
	htab_traverse (cfun->used_types_hash, premark_used_types_helper, NULL);
	}

	/* Generate a DIE to represent a declared function (either file-scope or
	block-local). */

	static void
	gen_subprogram_die (tree decl, dw_die_ref context_die)
	{
	char label_id[MAX_ARTIFICIAL_LABEL_BYTES];
	tree origin = decl_ultimate_origin (decl);
	dw_die_ref subr_die;
	tree fn_arg_types;
	tree outer_scope;
	dw_die_ref old_die = lookup_decl_die (decl);
	int declaration = (current_function_decl != decl
	\|\| class_or_namespace_scope_p (context_die));

	premark_used_types ();

	/* It is possible to have both DECL_ABSTRACT and DECLARATION be true if we
	started to generate the abstract instance of an inline, decided to output
	its containing class, and proceeded to emit the declaration of the inline
	from the member list for the class. If so, DECLARATION takes priority;
	we'll get back to the abstract instance when done with the class. */

	/* The class-scope declaration DIE must be the primary DIE. */
	if (origin && declaration && class_or_namespace_scope_p (context_die))
	{
	origin = NULL;
	gcc_assert (!old_die);
	}

	/* Now that the C++ front end lazily declares artificial member fns, we
	might need to retrofit the declaration into its class. */
	if (!declaration && !origin && !old_die
	&& DECL_CONTEXT (decl) && TYPE_P (DECL_CONTEXT (decl))
	&& !class_or_namespace_scope_p (context_die)
	&& debug_info_level > DINFO_LEVEL_TERSE)
	old_die = force_decl_die (decl);

	if (origin != NULL)
	{
	gcc_assert (!declaration \|\| local_scope_p (context_die));

	/* Fixup die_parent for the abstract instance of a nested
	inline function. */
	if (old_die && old_die->die_parent == NULL)
	add_child_die (context_die, old_die);

	subr_die = new_die (DW_TAG_subprogram, context_die, decl);
	add_abstract_origin_attribute (subr_die, origin);
	}
	else if (old_die)
	{
	expanded_location s = expand_location (DECL_SOURCE_LOCATION (decl));
	struct dwarf_file_data * file_index = lookup_filename (s.file);

	if (!get_AT_flag (old_die, DW_AT_declaration)
	/* We can have a normal definition following an inline one in the
	case of redefinition of GNU C extern inlines.
	It seems reasonable to use AT_specification in this case. */
	&& !get_AT (old_die, DW_AT_inline))
	{
	/* Detect and ignore this case, where we are trying to output
	something we have already output. */
	return;
	}

	/* If the definition comes from the same place as the declaration,
	maybe use the old DIE. We always want the DIE for this function
	that has the *_pc attributes to be under comp_unit_die so the
	debugger can find it. We also need to do this for abstract
	instances of inlines, since the spec requires the out-of-line copy
	to have the same parent. For local class methods, this doesn't
	apply; we just use the old DIE. */
	if ((old_die->die_parent == comp_unit_die \|\| context_die == NULL)
	&& (DECL_ARTIFICIAL (decl)
	\|\| (get_AT_file (old_die, DW_AT_decl_file) == file_index
	&& (get_AT_unsigned (old_die, DW_AT_decl_line)
	== (unsigned) s.line))))
	{
	subr_die = old_die;

	/* Clear out the declaration attribute and the formal parameters.
	Do not remove all children, because it is possible that this
	declaration die was forced using force_decl_die(). In such
	cases die that forced declaration die (e.g. TAG_imported_module)
	is one of the children that we do not want to remove. */
	remove_AT (subr_die, DW_AT_declaration);
	remove_child_TAG (subr_die, DW_TAG_formal_parameter);
	}
	else
	{
	subr_die = new_die (DW_TAG_subprogram, context_die, decl);
	add_AT_specification (subr_die, old_die);
	if (get_AT_file (old_die, DW_AT_decl_file) != file_index)
	add_AT_file (subr_die, DW_AT_decl_file, file_index);
	if (get_AT_unsigned (old_die, DW_AT_decl_line) != (unsigned) s.line)
	add_AT_unsigned (subr_die, DW_AT_decl_line, s.line);
	}
	}
	else
	{
	subr_die = new_die (DW_TAG_subprogram, context_die, decl);

	if (TREE_PUBLIC (decl))
	add_AT_flag (subr_die, DW_AT_external, 1);

	add_name_and_src_coords_attributes (subr_die, decl);
	if (debug_info_level > DINFO_LEVEL_TERSE)
	{
	add_prototyped_attribute (subr_die, TREE_TYPE (decl));
	add_type_attribute (subr_die, TREE_TYPE (TREE_TYPE (decl)),
	0, 0, context_die);
	}

	add_pure_or_virtual_attribute (subr_die, decl);
	if (DECL_ARTIFICIAL (decl))
	add_AT_flag (subr_die, DW_AT_artificial, 1);

	if (TREE_PROTECTED (decl))
	add_AT_unsigned (subr_die, DW_AT_accessibility, DW_ACCESS_protected);
	else if (TREE_PRIVATE (decl))
	add_AT_unsigned (subr_die, DW_AT_accessibility, DW_ACCESS_private);
	}

	if (declaration)
	{
	if (!old_die \|\| !get_AT (old_die, DW_AT_inline))
	{
	add_AT_flag (subr_die, DW_AT_declaration, 1);

	/* The first time we see a member function, it is in the context of
	the class to which it belongs. We make sure of this by emitting
	the class first. The next time is the definition, which is
	handled above. The two may come from the same source text.

	Note that force_decl_die() forces function declaration die. It is
	later reused to represent definition. */
	equate_decl_number_to_die (decl, subr_die);
	}
	}
	else if (DECL_ABSTRACT (decl))
	{
	if (DECL_DECLARED_INLINE_P (decl))
	{
	if (cgraph_function_possibly_inlined_p (decl))
	add_AT_unsigned (subr_die, DW_AT_inline, DW_INL_declared_inlined);
	else
	add_AT_unsigned (subr_die, DW_AT_inline, DW_INL_declared_not_inlined);
	}
	else
	{
	if (cgraph_function_possibly_inlined_p (decl))
	add_AT_unsigned (subr_die, DW_AT_inline, DW_INL_inlined);
	else
	add_AT_unsigned (subr_die, DW_AT_inline, DW_INL_not_inlined);
	}

	equate_decl_number_to_die (decl, subr_die);
	}
	else if (!DECL_EXTERNAL (decl))
	{
	HOST_WIDE_INT cfa_fb_offset;

	if (!old_die \|\| !get_AT (old_die, DW_AT_inline))
	equate_decl_number_to_die (decl, subr_die);

	if (!flag_reorder_blocks_and_partition)
	{
	ASM_GENERATE_INTERNAL_LABEL (label_id, FUNC_BEGIN_LABEL,
	current_function_funcdef_no);
	add_AT_lbl_id (subr_die, DW_AT_low_pc, label_id);
	ASM_GENERATE_INTERNAL_LABEL (label_id, FUNC_END_LABEL,
	current_function_funcdef_no);
	add_AT_lbl_id (subr_die, DW_AT_high_pc, label_id);

	add_pubname (decl, subr_die);
	add_arange (decl, subr_die);
	}
	else
	{ /* Do nothing for now; maybe need to duplicate die, one for
	hot section and ond for cold section, then use the hot/cold
	section begin/end labels to generate the aranges... */
	/*
	add_AT_lbl_id (subr_die, DW_AT_low_pc, hot_section_label);
	add_AT_lbl_id (subr_die, DW_AT_high_pc, hot_section_end_label);
	add_AT_lbl_id (subr_die, DW_AT_lo_user, unlikely_section_label);
	add_AT_lbl_id (subr_die, DW_AT_hi_user, cold_section_end_label);

	add_pubname (decl, subr_die);
	add_arange (decl, subr_die);
	add_arange (decl, subr_die);
	*/
	}

	#ifdef MIPS_DEBUGGING_INFO
	/* Add a reference to the FDE for this routine. */
	add_AT_fde_ref (subr_die, DW_AT_MIPS_fde, current_funcdef_fde);
	#endif

	cfa_fb_offset = CFA_FRAME_BASE_OFFSET (decl);

	/* We define the "frame base" as the function's CFA. This is more
	convenient for several reasons: (1) It's stable across the prologue
	and epilogue, which makes it better than just a frame pointer,
	(2) With dwarf3, there exists a one-byte encoding that allows us
	to reference the .debug_frame data by proxy, but failing that,
	(3) We can at least reuse the code inspection and interpretation
	code that determines the CFA position at various points in the
	function. */
	/* ??? Use some command-line or configury switch to enable the use
	of dwarf3 DW_OP_call_frame_cfa. At present there are no dwarf
	consumers that understand it; fall back to "pure" dwarf2 and
	convert the CFA data into a location list. */
	{
	dw_loc_list_ref list = convert_cfa_to_fb_loc_list (cfa_fb_offset);
	if (list->dw_loc_next)
	add_AT_loc_list (subr_die, DW_AT_frame_base, list);
	else
	add_AT_loc (subr_die, DW_AT_frame_base, list->expr);
	}

	/* Compute a displacement from the "steady-state frame pointer" to
	the CFA. The former is what all stack slots and argument slots
	will reference in the rtl; the later is what we've told the
	debugger about. We'll need to adjust all frame_base references
	by this displacement. */
	compute_frame_pointer_to_fb_displacement (cfa_fb_offset);

	if (cfun->static_chain_decl)
	add_AT_location_description (subr_die, DW_AT_static_link,
	loc_descriptor_from_tree (cfun->static_chain_decl));
	}

	/* Now output descriptions of the arguments for this function. This gets
	(unnecessarily?) complex because of the fact that the DECL_ARGUMENT list
	for a FUNCTION_DECL doesn't indicate cases where there was a trailing
	`...' at the end of the formal parameter list. In order to find out if
	there was a trailing ellipsis or not, we must instead look at the type
	associated with the FUNCTION_DECL. This will be a node of type
	FUNCTION_TYPE. If the chain of type nodes hanging off of this
	FUNCTION_TYPE node ends with a void_type_node then there should not be
	an ellipsis at the end. */

	/* In the case where we are describing a mere function declaration, all we
	need to do here (and all we can do here) is to describe the types of
	its formal parameters. */
	if (debug_info_level <= DINFO_LEVEL_TERSE)
	;
	else if (declaration)
	gen_formal_types_die (decl, subr_die);
	else
	{
	/* Generate DIEs to represent all known formal parameters. */
	tree arg_decls = DECL_ARGUMENTS (decl);
	tree parm;

	/* When generating DIEs, generate the unspecified_parameters DIE
	instead if we come across the arg "__builtin_va_alist" */
	for (parm = arg_decls; parm; parm = TREE_CHAIN (parm))
	if (TREE_CODE (parm) == PARM_DECL)
	{
	if (DECL_NAME (parm)
	&& !strcmp (IDENTIFIER_POINTER (DECL_NAME (parm)),
	"__builtin_va_alist"))
	gen_unspecified_parameters_die (parm, subr_die);
	else
	gen_decl_die (parm, subr_die);
	}

	/* Decide whether we need an unspecified_parameters DIE at the end.
	There are 2 more cases to do this for: 1) the ansi ... declaration -
	this is detectable when the end of the arg list is not a
	void_type_node 2) an unprototyped function declaration (not a
	definition). This just means that we have no info about the
	parameters at all. */
	fn_arg_types = TYPE_ARG_TYPES (TREE_TYPE (decl));
	if (fn_arg_types != NULL)
	{
	/* This is the prototyped case, check for.... */
	if (TREE_VALUE (tree_last (fn_arg_types)) != void_type_node)
	gen_unspecified_parameters_die (decl, subr_die);
	}
	else if (DECL_INITIAL (decl) == NULL_TREE)
	gen_unspecified_parameters_die (decl, subr_die);
	}

	/* Output Dwarf info for all of the stuff within the body of the function
	(if it has one - it may be just a declaration). */
	outer_scope = DECL_INITIAL (decl);

	/* OUTER_SCOPE is a pointer to the outermost BLOCK node created to represent
	a function. This BLOCK actually represents the outermost binding contour
	for the function, i.e. the contour in which the function's formal
	parameters and labels get declared. Curiously, it appears that the front
	end doesn't actually put the PARM_DECL nodes for the current function onto
	the BLOCK_VARS list for this outer scope, but are strung off of the
	DECL_ARGUMENTS list for the function instead.

	The BLOCK_VARS list for the `outer_scope' does provide us with a list of
	the LABEL_DECL nodes for the function however, and we output DWARF info
	for those in decls_for_scope. Just within the `outer_scope' there will be
	a BLOCK node representing the function's outermost pair of curly braces,
	and any blocks used for the base and member initializers of a C++
	constructor function. */
	if (! declaration && TREE_CODE (outer_scope) != ERROR_MARK)
	{
	/* Emit a DW_TAG_variable DIE for a named return value. */
	if (DECL_NAME (DECL_RESULT (decl)))
	gen_decl_die (DECL_RESULT (decl), subr_die);

	current_function_has_inlines = 0;
	decls_for_scope (outer_scope, subr_die, 0);

	#if 0 && defined (MIPS_DEBUGGING_INFO)
	if (current_function_has_inlines)
	{
	add_AT_flag (subr_die, DW_AT_MIPS_has_inlines, 1);
	if (! comp_unit_has_inlines)
	{
	add_AT_flag (comp_unit_die, DW_AT_MIPS_has_inlines, 1);
	comp_unit_has_inlines = 1;
	}
	}
	#endif
	}
	/* Add the calling convention attribute if requested. */
	add_calling_convention_attribute (subr_die, TREE_TYPE (decl));

	}

	/* Generate a DIE to represent a declared data object. */

	static void
	gen_variable_die (tree decl, dw_die_ref context_die)
	{
	tree origin = decl_ultimate_origin (decl);
	dw_die_ref var_die = new_die (DW_TAG_variable, context_die, decl);

	dw_die_ref old_die = lookup_decl_die (decl);
	int declaration = (DECL_EXTERNAL (decl)
	/* If DECL is COMDAT and has not actually been
	emitted, we cannot take its address; there
	might end up being no definition anywhere in
	the program. For example, consider the C++
	test case:

	template <class T>
	struct S { static const int i = 7; };

	template <class T>
	const int S<T>::i;

	int f() { return S<int>::i; }

	Here, S<int>::i is not DECL_EXTERNAL, but no
	definition is required, so the compiler will
	not emit a definition. */
	\|\| (TREE_CODE (decl) == VAR_DECL
	&& DECL_COMDAT (decl) && !TREE_ASM_WRITTEN (decl))
	\|\| class_or_namespace_scope_p (context_die));

	if (origin != NULL)
	add_abstract_origin_attribute (var_die, origin);

	/* Loop unrolling can create multiple blocks that refer to the same
	static variable, so we must test for the DW_AT_declaration flag.

	??? Loop unrolling/reorder_blocks should perhaps be rewritten to
	copy decls and set the DECL_ABSTRACT flag on them instead of
	sharing them.

	??? Duplicated blocks have been rewritten to use .debug_ranges.

	??? The declare_in_namespace support causes us to get two DIEs for one
	variable, both of which are declarations. We want to avoid considering
	one to be a specification, so we must test that this DIE is not a
	declaration. */
	else if (old_die && TREE_STATIC (decl) && ! declaration
	&& get_AT_flag (old_die, DW_AT_declaration) == 1)
	{
	/* This is a definition of a C++ class level static. */
	add_AT_specification (var_die, old_die);
	if (DECL_NAME (decl))
	{
	expanded_location s = expand_location (DECL_SOURCE_LOCATION (decl));
	struct dwarf_file_data * file_index = lookup_filename (s.file);

	if (get_AT_file (old_die, DW_AT_decl_file) != file_index)
	add_AT_file (var_die, DW_AT_decl_file, file_index);

	if (get_AT_unsigned (old_die, DW_AT_decl_line) != (unsigned) s.line)

	add_AT_unsigned (var_die, DW_AT_decl_line, s.line);
	}
	}
	else
	{
	add_name_and_src_coords_attributes (var_die, decl);
	add_type_attribute (var_die, TREE_TYPE (decl), TREE_READONLY (decl),
	TREE_THIS_VOLATILE (decl), context_die);

	if (TREE_PUBLIC (decl))
	add_AT_flag (var_die, DW_AT_external, 1);

	if (DECL_ARTIFICIAL (decl))
	add_AT_flag (var_die, DW_AT_artificial, 1);

	if (TREE_PROTECTED (decl))
	add_AT_unsigned (var_die, DW_AT_accessibility, DW_ACCESS_protected);
	else if (TREE_PRIVATE (decl))
	add_AT_unsigned (var_die, DW_AT_accessibility, DW_ACCESS_private);
	}

	if (declaration)
	add_AT_flag (var_die, DW_AT_declaration, 1);

	if (DECL_ABSTRACT (decl) \|\| declaration)
	equate_decl_number_to_die (decl, var_die);

	if (! declaration && ! DECL_ABSTRACT (decl))
	{
	add_location_or_const_value_attribute (var_die, decl, DW_AT_location);
	add_pubname (decl, var_die);
	}
	else
	tree_add_const_value_attribute (var_die, decl);
	}

	/* Generate a DIE to represent a label identifier. */

	static void
	gen_label_die (tree decl, dw_die_ref context_die)
	{
	tree origin = decl_ultimate_origin (decl);
	dw_die_ref lbl_die = new_die (DW_TAG_label, context_die, decl);
	rtx insn;
	char label[MAX_ARTIFICIAL_LABEL_BYTES];

	if (origin != NULL)
	add_abstract_origin_attribute (lbl_die, origin);
	else
	add_name_and_src_coords_attributes (lbl_die, decl);

	if (DECL_ABSTRACT (decl))
	equate_decl_number_to_die (decl, lbl_die);
	else
	{
	insn = DECL_RTL_IF_SET (decl);

	/* Deleted labels are programmer specified labels which have been
	eliminated because of various optimizations. We still emit them
	here so that it is possible to put breakpoints on them. */
	if (insn
	&& (LABEL_P (insn)
	\|\| ((NOTE_P (insn)
	&& NOTE_LINE_NUMBER (insn) == NOTE_INSN_DELETED_LABEL))))
	{
	/* When optimization is enabled (via -O) some parts of the compiler
	(e.g. jump.c and cse.c) may try to delete CODE_LABEL insns which
	represent source-level labels which were explicitly declared by
	the user. This really shouldn't be happening though, so catch
	it if it ever does happen. */
	gcc_assert (!INSN_DELETED_P (insn));

	ASM_GENERATE_INTERNAL_LABEL (label, "L", CODE_LABEL_NUMBER (insn));
	add_AT_lbl_id (lbl_die, DW_AT_low_pc, label);
	}
	}
	}

	/* A helper function for gen_inlined_subroutine_die. Add source coordinate
	attributes to the DIE for a block STMT, to describe where the inlined
	function was called from. This is similar to add_src_coords_attributes. */

	static inline void
	add_call_src_coords_attributes (tree stmt, dw_die_ref die)
	{
	expanded_location s = expand_location (BLOCK_SOURCE_LOCATION (stmt));

	add_AT_file (die, DW_AT_call_file, lookup_filename (s.file));
	add_AT_unsigned (die, DW_AT_call_line, s.line);
	}

	/* A helper function for gen_lexical_block_die and gen_inlined_subroutine_die.
	Add low_pc and high_pc attributes to the DIE for a block STMT. */

	static inline void
	add_high_low_attributes (tree stmt, dw_die_ref die)
	{
	char label[MAX_ARTIFICIAL_LABEL_BYTES];

	if (BLOCK_FRAGMENT_CHAIN (stmt))
	{
	tree chain;

	add_AT_range_list (die, DW_AT_ranges, add_ranges (stmt));

	chain = BLOCK_FRAGMENT_CHAIN (stmt);
	do
	{
	add_ranges (chain);
	chain = BLOCK_FRAGMENT_CHAIN (chain);
	}
	while (chain);
	add_ranges (NULL);
	}
	else
	{
	ASM_GENERATE_INTERNAL_LABEL (label, BLOCK_BEGIN_LABEL,
	BLOCK_NUMBER (stmt));
	add_AT_lbl_id (die, DW_AT_low_pc, label);
	ASM_GENERATE_INTERNAL_LABEL (label, BLOCK_END_LABEL,
	BLOCK_NUMBER (stmt));
	add_AT_lbl_id (die, DW_AT_high_pc, label);
	}
	}

	/* Generate a DIE for a lexical block. */

	static void
	gen_lexical_block_die (tree stmt, dw_die_ref context_die, int depth)
	{
	dw_die_ref stmt_die = new_die (DW_TAG_lexical_block, context_die, stmt);

	if (! BLOCK_ABSTRACT (stmt))
	add_high_low_attributes (stmt, stmt_die);

	decls_for_scope (stmt, stmt_die, depth);
	}

	/* Generate a DIE for an inlined subprogram. */

	static void
	gen_inlined_subroutine_die (tree stmt, dw_die_ref context_die, int depth)
	{
	tree decl = block_ultimate_origin (stmt);

	/* Emit info for the abstract instance first, if we haven't yet. We
	must emit this even if the block is abstract, otherwise when we
	emit the block below (or elsewhere), we may end up trying to emit
	a die whose origin die hasn't been emitted, and crashing. */
	dwarf2out_abstract_function (decl);

	if (! BLOCK_ABSTRACT (stmt))
	{
	dw_die_ref subr_die
	= new_die (DW_TAG_inlined_subroutine, context_die, stmt);

	add_abstract_origin_attribute (subr_die, decl);
	add_high_low_attributes (stmt, subr_die);
	add_call_src_coords_attributes (stmt, subr_die);

	decls_for_scope (stmt, subr_die, depth);
	current_function_has_inlines = 1;
	}
	else
	/* We may get here if we're the outer block of function A that was
	inlined into function B that was inlined into function C. When
	generating debugging info for C, dwarf2out_abstract_function(B)
	would mark all inlined blocks as abstract, including this one.
	So, we wouldn't (and shouldn't) expect labels to be generated
	for this one. Instead, just emit debugging info for
	declarations within the block. This is particularly important
	in the case of initializers of arguments passed from B to us:
	if they're statement expressions containing declarations, we
	wouldn't generate dies for their abstract variables, and then,
	when generating dies for the real variables, we'd die (pun
	intended :-) */
	gen_lexical_block_die (stmt, context_die, depth);
	}

	/* Generate a DIE for a field in a record, or structure. */

	static void
	gen_field_die (tree decl, dw_die_ref context_die)
	{
	dw_die_ref decl_die;

	if (TREE_TYPE (decl) == error_mark_node)
	return;

	decl_die = new_die (DW_TAG_member, context_die, decl);
	add_name_and_src_coords_attributes (decl_die, decl);
	add_type_attribute (decl_die, member_declared_type (decl),
	TREE_READONLY (decl), TREE_THIS_VOLATILE (decl),
	context_die);

	if (DECL_BIT_FIELD_TYPE (decl))
	{
	add_byte_size_attribute (decl_die, decl);
	add_bit_size_attribute (decl_die, decl);
	add_bit_offset_attribute (decl_die, decl);
	}

	if (TREE_CODE (DECL_FIELD_CONTEXT (decl)) != UNION_TYPE)
	add_data_member_location_attribute (decl_die, decl);

	if (DECL_ARTIFICIAL (decl))
	add_AT_flag (decl_die, DW_AT_artificial, 1);

	if (TREE_PROTECTED (decl))
	add_AT_unsigned (decl_die, DW_AT_accessibility, DW_ACCESS_protected);
	else if (TREE_PRIVATE (decl))
	add_AT_unsigned (decl_die, DW_AT_accessibility, DW_ACCESS_private);

	/* Equate decl number to die, so that we can look up this decl later on. */
	equate_decl_number_to_die (decl, decl_die);
	}

	#if 0
	/* Don't generate either pointer_type DIEs or reference_type DIEs here.
	Use modified_type_die instead.
	We keep this code here just in case these types of DIEs may be needed to
	represent certain things in other languages (e.g. Pascal) someday. */

	static void
	gen_pointer_type_die (tree type, dw_die_ref context_die)
	{
	dw_die_ref ptr_die
	= new_die (DW_TAG_pointer_type, scope_die_for (type, context_die), type);

	equate_type_number_to_die (type, ptr_die);
	add_type_attribute (ptr_die, TREE_TYPE (type), 0, 0, context_die);
	add_AT_unsigned (mod_type_die, DW_AT_byte_size, PTR_SIZE);
	}

	/* Don't generate either pointer_type DIEs or reference_type DIEs here.
	Use modified_type_die instead.
	We keep this code here just in case these types of DIEs may be needed to
	represent certain things in other languages (e.g. Pascal) someday. */

	static void
	gen_reference_type_die (tree type, dw_die_ref context_die)
	{
	dw_die_ref ref_die
	= new_die (DW_TAG_reference_type, scope_die_for (type, context_die), type);

	equate_type_number_to_die (type, ref_die);
	add_type_attribute (ref_die, TREE_TYPE (type), 0, 0, context_die);
	add_AT_unsigned (mod_type_die, DW_AT_byte_size, PTR_SIZE);
	}
	#endif

	/* Generate a DIE for a pointer to a member type. */

	static void
	gen_ptr_to_mbr_type_die (tree type, dw_die_ref context_die)
	{
	dw_die_ref ptr_die
	= new_die (DW_TAG_ptr_to_member_type,
	scope_die_for (type, context_die), type);

	equate_type_number_to_die (type, ptr_die);
	add_AT_die_ref (ptr_die, DW_AT_containing_type,
	lookup_type_die (TYPE_OFFSET_BASETYPE (type)));
	add_type_attribute (ptr_die, TREE_TYPE (type), 0, 0, context_die);
	}

	/* Generate the DIE for the compilation unit. */

	static dw_die_ref
	gen_compile_unit_die (const char *filename)
	{
	dw_die_ref die;
	char producer[250];
	const char *language_string = lang_hooks.name;
	int language;

	die = new_die (DW_TAG_compile_unit, NULL, NULL);

	if (filename)
	{
	add_name_attribute (die, filename);
	/* Don't add cwd for <built-in>. */
	if (filename[0] != DIR_SEPARATOR && filename[0] != '<')
	add_comp_dir_attribute (die);
	}

	sprintf (producer, "%s %s", language_string, version_string);

	#ifdef MIPS_DEBUGGING_INFO
	/* The MIPS/SGI compilers place the 'cc' command line options in the producer
	string. The SGI debugger looks for -g, -g1, -g2, or -g3; if they do
	not appear in the producer string, the debugger reaches the conclusion
	that the object file is stripped and has no debugging information.
	To get the MIPS/SGI debugger to believe that there is debugging
	information in the object file, we add a -g to the producer string. */
	if (debug_info_level > DINFO_LEVEL_TERSE)
	strcat (producer, " -g");
	#endif

	add_AT_string (die, DW_AT_producer, producer);

	if (strcmp (language_string, "GNU C++") == 0)
	language = DW_LANG_C_plus_plus;
	else if (strcmp (language_string, "GNU Ada") == 0)
	language = DW_LANG_Ada95;
	else if (strcmp (language_string, "GNU F77") == 0)
	language = DW_LANG_Fortran77;
	else if (strcmp (language_string, "GNU F95") == 0)
	language = DW_LANG_Fortran95;
	else if (strcmp (language_string, "GNU Pascal") == 0)
	language = DW_LANG_Pascal83;
	else if (strcmp (language_string, "GNU Java") == 0)
	language = DW_LANG_Java;
	else if (strcmp (language_string, "GNU Objective-C") == 0)
	language = DW_LANG_ObjC;
	else if (strcmp (language_string, "GNU Objective-C++") == 0)
	language = DW_LANG_ObjC_plus_plus;
	else
	language = DW_LANG_C89;

	add_AT_unsigned (die, DW_AT_language, language);
	return die;
	}

	/* Generate the DIE for a base class. */

	static void
	gen_inheritance_die (tree binfo, tree access, dw_die_ref context_die)
	{
	dw_die_ref die = new_die (DW_TAG_inheritance, context_die, binfo);

	add_type_attribute (die, BINFO_TYPE (binfo), 0, 0, context_die);
	add_data_member_location_attribute (die, binfo);

	if (BINFO_VIRTUAL_P (binfo))
	add_AT_unsigned (die, DW_AT_virtuality, DW_VIRTUALITY_virtual);

	if (access == access_public_node)
	add_AT_unsigned (die, DW_AT_accessibility, DW_ACCESS_public);
	else if (access == access_protected_node)
	add_AT_unsigned (die, DW_AT_accessibility, DW_ACCESS_protected);
	}

	/* Generate a DIE for a class member. */

	static void
	gen_member_die (tree type, dw_die_ref context_die)
	{
	tree member;
	tree binfo = TYPE_BINFO (type);
	dw_die_ref child;

	/* If this is not an incomplete type, output descriptions of each of its
	members. Note that as we output the DIEs necessary to represent the
	members of this record or union type, we will also be trying to output
	DIEs to represent the types of those members. However the `type'
	function (above) will specifically avoid generating type DIEs for member
	types within the list of member DIEs for this (containing) type except
	for those types (of members) which are explicitly marked as also being
	members of this (containing) type themselves. The g++ front- end can
	force any given type to be treated as a member of some other (containing)
	type by setting the TYPE_CONTEXT of the given (member) type to point to
	the TREE node representing the appropriate (containing) type. */

	/* First output info about the base classes. */
	if (binfo)
	{
	VEC(tree,gc) *accesses = BINFO_BASE_ACCESSES (binfo);
	int i;
	tree base;

	for (i = 0; BINFO_BASE_ITERATE (binfo, i, base); i++)
	gen_inheritance_die (base,
	(accesses ? VEC_index (tree, accesses, i)
	: access_public_node), context_die);
	}

	/* Now output info about the data members and type members. */
	for (member = TYPE_FIELDS (type); member; member = TREE_CHAIN (member))
	{
	/* If we thought we were generating minimal debug info for TYPE
	and then changed our minds, some of the member declarations
	may have already been defined. Don't define them again, but
	do put them in the right order. */

	child = lookup_decl_die (member);
	if (child)
	splice_child_die (context_die, child);
	else
	gen_decl_die (member, context_die);
	}

	/* Now output info about the function members (if any). */
	for (member = TYPE_METHODS (type); member; member = TREE_CHAIN (member))
	{
	/* Don't include clones in the member list. */
	if (DECL_ABSTRACT_ORIGIN (member))
	continue;

	child = lookup_decl_die (member);
	if (child)
	splice_child_die (context_die, child);
	else
	gen_decl_die (member, context_die);
	}
	}

	/* Generate a DIE for a structure or union type. If TYPE_DECL_SUPPRESS_DEBUG
	is set, we pretend that the type was never defined, so we only get the
	member DIEs needed by later specification DIEs. */

	static void
	gen_struct_or_union_type_die (tree type, dw_die_ref context_die,
	enum debug_info_usage usage)
	{
	dw_die_ref type_die = lookup_type_die (type);
	dw_die_ref scope_die = 0;
	int nested = 0;
	int complete = (TYPE_SIZE (type)
	&& (! TYPE_STUB_DECL (type)
	\|\| ! TYPE_DECL_SUPPRESS_DEBUG (TYPE_STUB_DECL (type))));
	int ns_decl = (context_die && context_die->die_tag == DW_TAG_namespace);
	complete = complete && should_emit_struct_debug (type, usage);

	if (type_die && ! complete)
	return;

	if (TYPE_CONTEXT (type) != NULL_TREE
	&& (AGGREGATE_TYPE_P (TYPE_CONTEXT (type))
	\|\| TREE_CODE (TYPE_CONTEXT (type)) == NAMESPACE_DECL))
	nested = 1;

	scope_die = scope_die_for (type, context_die);

	if (! type_die \|\| (nested && scope_die == comp_unit_die))
	/* First occurrence of type or toplevel definition of nested class. */
	{
	dw_die_ref old_die = type_die;

	type_die = new_die (TREE_CODE (type) == RECORD_TYPE
	? DW_TAG_structure_type : DW_TAG_union_type,
	scope_die, type);
	equate_type_number_to_die (type, type_die);
	if (old_die)
	add_AT_specification (type_die, old_die);
	else
	add_name_attribute (type_die, type_tag (type));
	}
	else
	remove_AT (type_die, DW_AT_declaration);

	/* If this type has been completed, then give it a byte_size attribute and
	then give a list of members. */
	if (complete && !ns_decl)
	{
	/* Prevent infinite recursion in cases where the type of some member of
	this type is expressed in terms of this type itself. */
	TREE_ASM_WRITTEN (type) = 1;
	add_byte_size_attribute (type_die, type);
	if (TYPE_STUB_DECL (type) != NULL_TREE)
	add_src_coords_attributes (type_die, TYPE_STUB_DECL (type));

	/* If the first reference to this type was as the return type of an
	inline function, then it may not have a parent. Fix this now. */
	if (type_die->die_parent == NULL)
	add_child_die (scope_die, type_die);

	push_decl_scope (type);
	gen_member_die (type, type_die);
	pop_decl_scope ();

	/* GNU extension: Record what type our vtable lives in. */
	if (TYPE_VFIELD (type))
	{
	tree vtype = DECL_FCONTEXT (TYPE_VFIELD (type));

	gen_type_die (vtype, context_die);
	add_AT_die_ref (type_die, DW_AT_containing_type,
	lookup_type_die (vtype));
	}
	}
	else
	{
	add_AT_flag (type_die, DW_AT_declaration, 1);

	/* We don't need to do this for function-local types. */
	if (TYPE_STUB_DECL (type)
	&& ! decl_function_context (TYPE_STUB_DECL (type)))
	VEC_safe_push (tree, gc, incomplete_types, type);
	}

	if (get_AT (type_die, DW_AT_name))
	add_pubtype (type, type_die);
	}

	/* Generate a DIE for a subroutine _type_. */

	static void
	gen_subroutine_type_die (tree type, dw_die_ref context_die)
	{
	tree return_type = TREE_TYPE (type);
	dw_die_ref subr_die
	= new_die (DW_TAG_subroutine_type,
	scope_die_for (type, context_die), type);

	equate_type_number_to_die (type, subr_die);
	add_prototyped_attribute (subr_die, type);
	add_type_attribute (subr_die, return_type, 0, 0, context_die);
	gen_formal_types_die (type, subr_die);

	if (get_AT (subr_die, DW_AT_name))
	add_pubtype (type, subr_die);
	}

	/* Generate a DIE for a type definition. */

	static void
	gen_typedef_die (tree decl, dw_die_ref context_die)
	{
	dw_die_ref type_die;
	tree origin;

	if (TREE_ASM_WRITTEN (decl))
	return;

	TREE_ASM_WRITTEN (decl) = 1;
	type_die = new_die (DW_TAG_typedef, context_die, decl);
	origin = decl_ultimate_origin (decl);
	if (origin != NULL)
	add_abstract_origin_attribute (type_die, origin);
	else
	{
	tree type;

	add_name_and_src_coords_attributes (type_die, decl);
	if (DECL_ORIGINAL_TYPE (decl))
	{
	type = DECL_ORIGINAL_TYPE (decl);

	gcc_assert (type != TREE_TYPE (decl));
	equate_type_number_to_die (TREE_TYPE (decl), type_die);
	}
	else
	type = TREE_TYPE (decl);

	add_type_attribute (type_die, type, TREE_READONLY (decl),
	TREE_THIS_VOLATILE (decl), context_die);
	}

	if (DECL_ABSTRACT (decl))
	equate_decl_number_to_die (decl, type_die);

	if (get_AT (type_die, DW_AT_name))
	add_pubtype (decl, type_die);
	}

	/* Generate a type description DIE. */

	static void
	gen_type_die_with_usage (tree type, dw_die_ref context_die,
	enum debug_info_usage usage)
	{
	int need_pop;

	if (type == NULL_TREE \|\| type == error_mark_node)
	return;

	if (TYPE_NAME (type) && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
	&& DECL_ORIGINAL_TYPE (TYPE_NAME (type)))
	{
	if (TREE_ASM_WRITTEN (type))
	return;

	/* Prevent broken recursion; we can't hand off to the same type. */
	gcc_assert (DECL_ORIGINAL_TYPE (TYPE_NAME (type)) != type);

	TREE_ASM_WRITTEN (type) = 1;
	gen_decl_die (TYPE_NAME (type), context_die);
	return;
	}

	/* We are going to output a DIE to represent the unqualified version
	of this type (i.e. without any const or volatile qualifiers) so
	get the main variant (i.e. the unqualified version) of this type
	now. (Vectors are special because the debugging info is in the
	cloned type itself). */
	if (TREE_CODE (type) != VECTOR_TYPE)
	type = type_main_variant (type);

	if (TREE_ASM_WRITTEN (type))
	return;

	switch (TREE_CODE (type))
	{
	case ERROR_MARK:
	break;

	case POINTER_TYPE:
	case REFERENCE_TYPE:
	/* We must set TREE_ASM_WRITTEN in case this is a recursive type. This
	ensures that the gen_type_die recursion will terminate even if the
	type is recursive. Recursive types are possible in Ada. */
	/* ??? We could perhaps do this for all types before the switch
	statement. */
	TREE_ASM_WRITTEN (type) = 1;

	/* For these types, all that is required is that we output a DIE (or a
	set of DIEs) to represent the "basis" type. */
	gen_type_die_with_usage (TREE_TYPE (type), context_die,
	DINFO_USAGE_IND_USE);
	break;

	case OFFSET_TYPE:
	/* This code is used for C++ pointer-to-data-member types.
	Output a description of the relevant class type. */
	gen_type_die_with_usage (TYPE_OFFSET_BASETYPE (type), context_die,
	DINFO_USAGE_IND_USE);

	/* Output a description of the type of the object pointed to. */
	gen_type_die_with_usage (TREE_TYPE (type), context_die,
	DINFO_USAGE_IND_USE);

	/* Now output a DIE to represent this pointer-to-data-member type
	itself. */
	gen_ptr_to_mbr_type_die (type, context_die);
	break;

	case FUNCTION_TYPE:
	/* Force out return type (in case it wasn't forced out already). */
	gen_type_die_with_usage (TREE_TYPE (type), context_die,
	DINFO_USAGE_DIR_USE);
	gen_subroutine_type_die (type, context_die);
	break;

	case METHOD_TYPE:
	/* Force out return type (in case it wasn't forced out already). */
	gen_type_die_with_usage (TREE_TYPE (type), context_die,
	DINFO_USAGE_DIR_USE);
	gen_subroutine_type_die (type, context_die);
	break;

	case ARRAY_TYPE:
	gen_array_type_die (type, context_die);
	break;

	case VECTOR_TYPE:
	gen_array_type_die (type, context_die);
	break;

	case ENUMERAL_TYPE:
	case RECORD_TYPE:
	case UNION_TYPE:
	case QUAL_UNION_TYPE:
	/* If this is a nested type whose containing class hasn't been written
	out yet, writing it out will cover this one, too. This does not apply
	to instantiations of member class templates; they need to be added to
	the containing class as they are generated. FIXME: This hurts the
	idea of combining type decls from multiple TUs, since we can't predict
	what set of template instantiations we'll get. */
	if (TYPE_CONTEXT (type)
	&& AGGREGATE_TYPE_P (TYPE_CONTEXT (type))
	&& ! TREE_ASM_WRITTEN (TYPE_CONTEXT (type)))
	{
	gen_type_die_with_usage (TYPE_CONTEXT (type), context_die, usage);

	if (TREE_ASM_WRITTEN (type))
	return;

	/* If that failed, attach ourselves to the stub. */
	push_decl_scope (TYPE_CONTEXT (type));
	context_die = lookup_type_die (TYPE_CONTEXT (type));
	need_pop = 1;
	}
	else
	{
	declare_in_namespace (type, context_die);
	need_pop = 0;
	}

	if (TREE_CODE (type) == ENUMERAL_TYPE)
	{
	/* This might have been written out by the call to
	declare_in_namespace. */
	if (!TREE_ASM_WRITTEN (type))
	gen_enumeration_type_die (type, context_die);
	}
	else
	gen_struct_or_union_type_die (type, context_die, usage);

	if (need_pop)
	pop_decl_scope ();

	/* Don't set TREE_ASM_WRITTEN on an incomplete struct; we want to fix
	it up if it is ever completed. gen_*_type_die will set it for us
	when appropriate. */
	return;

	case VOID_TYPE:
	case INTEGER_TYPE:
	case REAL_TYPE:
	case COMPLEX_TYPE:
	case BOOLEAN_TYPE:
	/* No DIEs needed for fundamental types. */
	break;

	case LANG_TYPE:
	/* No Dwarf representation currently defined. */
	break;

	default:
	gcc_unreachable ();
	}

	TREE_ASM_WRITTEN (type) = 1;
	}

	static void
	gen_type_die (tree type, dw_die_ref context_die)
	{
	gen_type_die_with_usage (type, context_die, DINFO_USAGE_DIR_USE);
	}

	/* Generate a DIE for a tagged type instantiation. */

	static void
	gen_tagged_type_instantiation_die (tree type, dw_die_ref context_die)
	{
	if (type == NULL_TREE \|\| type == error_mark_node)
	return;

	/* We are going to output a DIE to represent the unqualified version of
	this type (i.e. without any const or volatile qualifiers) so make sure
	that we have the main variant (i.e. the unqualified version) of this
	type now. */
	gcc_assert (type == type_main_variant (type));

	/* Do not check TREE_ASM_WRITTEN (type) as it may not be set if this is
	an instance of an unresolved type. */

	switch (TREE_CODE (type))
	{
	case ERROR_MARK:
	break;

	case ENUMERAL_TYPE:
	gen_inlined_enumeration_type_die (type, context_die);
	break;

	case RECORD_TYPE:
	gen_inlined_structure_type_die (type, context_die);
	break;

	case UNION_TYPE:
	case QUAL_UNION_TYPE:
	gen_inlined_union_type_die (type, context_die);
	break;

	default:
	gcc_unreachable ();
	}
	}

	/* Generate a DW_TAG_lexical_block DIE followed by DIEs to represent all of the
	things which are local to the given block. */

	static void
	gen_block_die (tree stmt, dw_die_ref context_die, int depth)
	{
	int must_output_die = 0;
	tree origin;
	tree decl;
	enum tree_code origin_code;

	/* Ignore blocks that are NULL. */
	if (stmt == NULL_TREE)
	return;

	/* If the block is one fragment of a non-contiguous block, do not
	process the variables, since they will have been done by the
	origin block. Do process subblocks. */
	if (BLOCK_FRAGMENT_ORIGIN (stmt))
	{
	tree sub;

	for (sub = BLOCK_SUBBLOCKS (stmt); sub; sub = BLOCK_CHAIN (sub))
	gen_block_die (sub, context_die, depth + 1);

	return;
	}

	/* Determine the "ultimate origin" of this block. This block may be an
	inlined instance of an inlined instance of inline function, so we have
	to trace all of the way back through the origin chain to find out what
	sort of node actually served as the original seed for the creation of
	the current block. */
	origin = block_ultimate_origin (stmt);
	origin_code = (origin != NULL) ? TREE_CODE (origin) : ERROR_MARK;

	/* Determine if we need to output any Dwarf DIEs at all to represent this
	block. */
	if (origin_code == FUNCTION_DECL)
	/* The outer scopes for inlinings must always be represented. We
	generate DW_TAG_inlined_subroutine DIEs for them. (See below.) */
	must_output_die = 1;
	else
	{
	/* In the case where the current block represents an inlining of the
	"body block" of an inline function, we must NOT output any DIE for
	this block because we have already output a DIE to represent the whole
	inlined function scope and the "body block" of any function doesn't
	really represent a different scope according to ANSI C rules. So we
	check here to make sure that this block does not represent a "body
	block inlining" before trying to set the MUST_OUTPUT_DIE flag. */
	if (! is_body_block (origin ? origin : stmt))
	{
	/* Determine if this block directly contains any "significant"
	local declarations which we will need to output DIEs for. */
	if (debug_info_level > DINFO_LEVEL_TERSE)
	/* We are not in terse mode so any local declaration counts
	as being a "significant" one. */
	must_output_die = (BLOCK_VARS (stmt) != NULL
	&& (TREE_USED (stmt)
	\|\| TREE_ASM_WRITTEN (stmt)
	\|\| BLOCK_ABSTRACT (stmt)));
	else
	/* We are in terse mode, so only local (nested) function
	definitions count as "significant" local declarations. */
	for (decl = BLOCK_VARS (stmt);
	decl != NULL; decl = TREE_CHAIN (decl))
	if (TREE_CODE (decl) == FUNCTION_DECL
	&& DECL_INITIAL (decl))
	{
	must_output_die = 1;
	break;
	}
	}
	}

	/* It would be a waste of space to generate a Dwarf DW_TAG_lexical_block
	DIE for any block which contains no significant local declarations at
	all. Rather, in such cases we just call `decls_for_scope' so that any
	needed Dwarf info for any sub-blocks will get properly generated. Note
	that in terse mode, our definition of what constitutes a "significant"
	local declaration gets restricted to include only inlined function
	instances and local (nested) function definitions. */
	if (must_output_die)
	{
	if (origin_code == FUNCTION_DECL)
	gen_inlined_subroutine_die (stmt, context_die, depth);
	else
	gen_lexical_block_die (stmt, context_die, depth);
	}
	else
	decls_for_scope (stmt, context_die, depth);
	}

	/* Generate all of the decls declared within a given scope and (recursively)
	all of its sub-blocks. */

	static void
	decls_for_scope (tree stmt, dw_die_ref context_die, int depth)
	{
	tree decl;
	tree subblocks;

	/* Ignore NULL blocks. */
	if (stmt == NULL_TREE)
	return;

	if (TREE_USED (stmt))
	{
	/* Output the DIEs to represent all of the data objects and typedefs
	declared directly within this block but not within any nested
	sub-blocks. Also, nested function and tag DIEs have been
	generated with a parent of NULL; fix that up now. */
	for (decl = BLOCK_VARS (stmt); decl != NULL; decl = TREE_CHAIN (decl))
	{
	dw_die_ref die;

	if (TREE_CODE (decl) == FUNCTION_DECL)
	die = lookup_decl_die (decl);
	else if (TREE_CODE (decl) == TYPE_DECL && TYPE_DECL_IS_STUB (decl))
	die = lookup_type_die (TREE_TYPE (decl));
	else
	die = NULL;

	if (die != NULL && die->die_parent == NULL)
	add_child_die (context_die, die);
	/* Do not produce debug information for static variables since
	these might be optimized out. We are called for these later
	in cgraph_varpool_analyze_pending_decls. */
	if (TREE_CODE (decl) == VAR_DECL && TREE_STATIC (decl))
	;
	else
	gen_decl_die (decl, context_die);
	}
	}

	/* If we're at -g1, we're not interested in subblocks. */
	if (debug_info_level <= DINFO_LEVEL_TERSE)
	return;

	/* Output the DIEs to represent all sub-blocks (and the items declared
	therein) of this block. */
	for (subblocks = BLOCK_SUBBLOCKS (stmt);
	subblocks != NULL;
	subblocks = BLOCK_CHAIN (subblocks))
	gen_block_die (subblocks, context_die, depth + 1);
	}

	/* Is this a typedef we can avoid emitting? */

	static inline int
	is_redundant_typedef (tree decl)
	{
	if (TYPE_DECL_IS_STUB (decl))
	return 1;

	if (DECL_ARTIFICIAL (decl)
	&& DECL_CONTEXT (decl)
	&& is_tagged_type (DECL_CONTEXT (decl))
	&& TREE_CODE (TYPE_NAME (DECL_CONTEXT (decl))) == TYPE_DECL
	&& DECL_NAME (decl) == DECL_NAME (TYPE_NAME (DECL_CONTEXT (decl))))
	/* Also ignore the artificial member typedef for the class name. */
	return 1;

	return 0;
	}

	/* Returns the DIE for decl. A DIE will always be returned. */

	static dw_die_ref
	force_decl_die (tree decl)
	{
	dw_die_ref decl_die;
	unsigned saved_external_flag;
	tree save_fn = NULL_TREE;
	decl_die = lookup_decl_die (decl);
	if (!decl_die)
	{
	dw_die_ref context_die;
	tree decl_context = DECL_CONTEXT (decl);
	if (decl_context)
	{
	/* Find die that represents this context. */
	if (TYPE_P (decl_context))
	context_die = force_type_die (decl_context);
	else
	context_die = force_decl_die (decl_context);
	}
	else
	context_die = comp_unit_die;

	decl_die = lookup_decl_die (decl);
	if (decl_die)
	return decl_die;

	switch (TREE_CODE (decl))
	{
	case FUNCTION_DECL:
	/* Clear current_function_decl, so that gen_subprogram_die thinks
	that this is a declaration. At this point, we just want to force
	declaration die. */
	save_fn = current_function_decl;
	current_function_decl = NULL_TREE;
	gen_subprogram_die (decl, context_die);
	current_function_decl = save_fn;
	break;

	case VAR_DECL:
	/* Set external flag to force declaration die. Restore it after
	gen_decl_die() call. */
	saved_external_flag = DECL_EXTERNAL (decl);
	DECL_EXTERNAL (decl) = 1;
	gen_decl_die (decl, context_die);
	DECL_EXTERNAL (decl) = saved_external_flag;
	break;

	case NAMESPACE_DECL:
	dwarf2out_decl (decl);
	break;

	default:
	gcc_unreachable ();
	}

	/* We should be able to find the DIE now. */
	if (!decl_die)
	decl_die = lookup_decl_die (decl);
	gcc_assert (decl_die);
	}

	return decl_die;
	}

	/* Returns the DIE for TYPE, that must not be a base type. A DIE is
	always returned. */

	static dw_die_ref
	force_type_die (tree type)
	{
	dw_die_ref type_die;

	type_die = lookup_type_die (type);
	if (!type_die)
	{
	dw_die_ref context_die;
	if (TYPE_CONTEXT (type))
	{
	if (TYPE_P (TYPE_CONTEXT (type)))
	context_die = force_type_die (TYPE_CONTEXT (type));
	else
	context_die = force_decl_die (TYPE_CONTEXT (type));
	}
	else
	context_die = comp_unit_die;

	type_die = lookup_type_die (type);
	if (type_die)
	return type_die;
	gen_type_die (type, context_die);
	type_die = lookup_type_die (type);
	gcc_assert (type_die);
	}
	return type_die;
	}

	/* Force out any required namespaces to be able to output DECL,
	and return the new context_die for it, if it's changed. */

	static dw_die_ref
	setup_namespace_context (tree thing, dw_die_ref context_die)
	{
	tree context = (DECL_P (thing)
	? DECL_CONTEXT (thing) : TYPE_CONTEXT (thing));
	if (context && TREE_CODE (context) == NAMESPACE_DECL)
	/* Force out the namespace. */
	context_die = force_decl_die (context);

	return context_die;
	}

	/* Emit a declaration DIE for THING (which is either a DECL or a tagged
	type) within its namespace, if appropriate.

	For compatibility with older debuggers, namespace DIEs only contain
	declarations; all definitions are emitted at CU scope. */

	static void
	declare_in_namespace (tree thing, dw_die_ref context_die)
	{
	dw_die_ref ns_context;

	if (debug_info_level <= DINFO_LEVEL_TERSE)
	return;

	/* If this decl is from an inlined function, then don't try to emit it in its
	namespace, as we will get confused. It would have already been emitted
	when the abstract instance of the inline function was emitted anyways. */
	if (DECL_P (thing) && DECL_ABSTRACT_ORIGIN (thing))
	return;

	ns_context = setup_namespace_context (thing, context_die);

	if (ns_context != context_die)
	{
	if (DECL_P (thing))
	gen_decl_die (thing, ns_context);
	else
	gen_type_die (thing, ns_context);
	}
	}

	/* Generate a DIE for a namespace or namespace alias. */

	static void
	gen_namespace_die (tree decl)
	{
	dw_die_ref context_die = setup_namespace_context (decl, comp_unit_die);

	/* Namespace aliases have a DECL_ABSTRACT_ORIGIN of the namespace
	they are an alias of. */
	if (DECL_ABSTRACT_ORIGIN (decl) == NULL)
	{
	/* Output a real namespace. */
	dw_die_ref namespace_die
	= new_die (DW_TAG_namespace, context_die, decl);
	add_name_and_src_coords_attributes (namespace_die, decl);
	equate_decl_number_to_die (decl, namespace_die);
	}
	else
	{
	/* Output a namespace alias. */

	/* Force out the namespace we are an alias of, if necessary. */
	dw_die_ref origin_die
	= force_decl_die (DECL_ABSTRACT_ORIGIN (decl));

	/* Now create the namespace alias DIE. */
	dw_die_ref namespace_die
	= new_die (DW_TAG_imported_declaration, context_die, decl);
	add_name_and_src_coords_attributes (namespace_die, decl);
	add_AT_die_ref (namespace_die, DW_AT_import, origin_die);
	equate_decl_number_to_die (decl, namespace_die);
	}
	}

	/* Generate Dwarf debug information for a decl described by DECL. */

	static void
	gen_decl_die (tree decl, dw_die_ref context_die)
	{
	tree origin;

	if (DECL_P (decl) && DECL_IGNORED_P (decl))
	return;

	switch (TREE_CODE (decl))
	{
	case ERROR_MARK:
	break;

	case CONST_DECL:
	/* The individual enumerators of an enum type get output when we output
	the Dwarf representation of the relevant enum type itself. */
	break;

	case FUNCTION_DECL:
	/* Don't output any DIEs to represent mere function declarations,
	unless they are class members or explicit block externs. */
	if (DECL_INITIAL (decl) == NULL_TREE && DECL_CONTEXT (decl) == NULL_TREE
	&& (current_function_decl == NULL_TREE \|\| DECL_ARTIFICIAL (decl)))
	break;

	#if 0
	/* FIXME */
	/* This doesn't work because the C frontend sets DECL_ABSTRACT_ORIGIN
	on local redeclarations of global functions. That seems broken. */
	if (current_function_decl != decl)
	/* This is only a declaration. */;
	#endif

	/* If we're emitting a clone, emit info for the abstract instance. */
	if (DECL_ORIGIN (decl) != decl)
	dwarf2out_abstract_function (DECL_ABSTRACT_ORIGIN (decl));

	/* If we're emitting an out-of-line copy of an inline function,
	emit info for the abstract instance and set up to refer to it. */
	else if (cgraph_function_possibly_inlined_p (decl)
	&& ! DECL_ABSTRACT (decl)
	&& ! class_or_namespace_scope_p (context_die)
	/* dwarf2out_abstract_function won't emit a die if this is just
	a declaration. We must avoid setting DECL_ABSTRACT_ORIGIN in
	that case, because that works only if we have a die. */
	&& DECL_INITIAL (decl) != NULL_TREE)
	{
	dwarf2out_abstract_function (decl);
	set_decl_origin_self (decl);
	}

	/* Otherwise we're emitting the primary DIE for this decl. */
	else if (debug_info_level > DINFO_LEVEL_TERSE)
	{
	/* Before we describe the FUNCTION_DECL itself, make sure that we
	have described its return type. */
	gen_type_die (TREE_TYPE (TREE_TYPE (decl)), context_die);

	/* And its virtual context. */
	if (DECL_VINDEX (decl) != NULL_TREE)
	gen_type_die (DECL_CONTEXT (decl), context_die);

	/* And its containing type. */
	origin = decl_class_context (decl);
	if (origin != NULL_TREE)
	gen_type_die_for_member (origin, decl, context_die);

	/* And its containing namespace. */
	declare_in_namespace (decl, context_die);
	}

	/* Now output a DIE to represent the function itself. */
	gen_subprogram_die (decl, context_die);
	break;

	case TYPE_DECL:
	/* If we are in terse mode, don't generate any DIEs to represent any
	actual typedefs. */
	if (debug_info_level <= DINFO_LEVEL_TERSE)
	break;

	/* In the special case of a TYPE_DECL node representing the declaration
	of some type tag, if the given TYPE_DECL is marked as having been
	instantiated from some other (original) TYPE_DECL node (e.g. one which
	was generated within the original definition of an inline function) we
	have to generate a special (abbreviated) DW_TAG_structure_type,
	DW_TAG_union_type, or DW_TAG_enumeration_type DIE here. */
	if (TYPE_DECL_IS_STUB (decl) && decl_ultimate_origin (decl) != NULL_TREE
	&& is_tagged_type (TREE_TYPE (decl)))
	{
	gen_tagged_type_instantiation_die (TREE_TYPE (decl), context_die);
	break;
	}

	if (is_redundant_typedef (decl))
	gen_type_die (TREE_TYPE (decl), context_die);
	else
	/* Output a DIE to represent the typedef itself. */
	gen_typedef_die (decl, context_die);
	break;

	case LABEL_DECL:
	if (debug_info_level >= DINFO_LEVEL_NORMAL)
	gen_label_die (decl, context_die);
	break;

	case VAR_DECL:
	case RESULT_DECL:
	/* If we are in terse mode, don't generate any DIEs to represent any
	variable declarations or definitions. */
	if (debug_info_level <= DINFO_LEVEL_TERSE)
	break;

	/* Output any DIEs that are needed to specify the type of this data
	object. */
	gen_type_die (TREE_TYPE (decl), context_die);

	/* And its containing type. */
	origin = decl_class_context (decl);
	if (origin != NULL_TREE)
	gen_type_die_for_member (origin, decl, context_die);

	/* And its containing namespace. */
	declare_in_namespace (decl, context_die);

	/* Now output the DIE to represent the data object itself. This gets
	complicated because of the possibility that the VAR_DECL really
	represents an inlined instance of a formal parameter for an inline
	function. */
	origin = decl_ultimate_origin (decl);
	if (origin != NULL_TREE && TREE_CODE (origin) == PARM_DECL)
	gen_formal_parameter_die (decl, context_die);
	else
	gen_variable_die (decl, context_die);
	break;

	case FIELD_DECL:
	/* Ignore the nameless fields that are used to skip bits but handle C++
	anonymous unions and structs. */
	if (DECL_NAME (decl) != NULL_TREE
	\|\| TREE_CODE (TREE_TYPE (decl)) == UNION_TYPE
	\|\| TREE_CODE (TREE_TYPE (decl)) == RECORD_TYPE)
	{
	gen_type_die (member_declared_type (decl), context_die);
	gen_field_die (decl, context_die);
	}
	break;

	case PARM_DECL:
	gen_type_die (TREE_TYPE (decl), context_die);
	gen_formal_parameter_die (decl, context_die);
	break;

	case NAMESPACE_DECL:
	gen_namespace_die (decl);
	break;

	default:
	/* Probably some frontend-internal decl. Assume we don't care. */
	gcc_assert ((int)TREE_CODE (decl) > NUM_TREE_CODES);
	break;
	}
	}

	/* Output debug information for global decl DECL. Called from toplev.c after
	compilation proper has finished. */

	static void
	dwarf2out_global_decl (tree decl)
	{
	/* Output DWARF2 information for file-scope tentative data object
	declarations, file-scope (extern) function declarations (which had no
	corresponding body) and file-scope tagged type declarations and
	definitions which have not yet been forced out. */
	if (TREE_CODE (decl) != FUNCTION_DECL \|\| !DECL_INITIAL (decl))
	dwarf2out_decl (decl);
	}

	/* Output debug information for type decl DECL. Called from toplev.c
	and from language front ends (to record built-in types). */
	static void
	dwarf2out_type_decl (tree decl, int local)
	{
	if (!local)
	dwarf2out_decl (decl);
	}

	/* Output debug information for imported module or decl. */

	static void
	dwarf2out_imported_module_or_decl (tree decl, tree context)
	{
	dw_die_ref imported_die, at_import_die;
	dw_die_ref scope_die;
	expanded_location xloc;

	if (debug_info_level <= DINFO_LEVEL_TERSE)
	return;

	gcc_assert (decl);

	/* To emit DW_TAG_imported_module or DW_TAG_imported_decl, we need two DIEs.
	We need decl DIE for reference and scope die. First, get DIE for the decl
	itself. */

	/* Get the scope die for decl context. Use comp_unit_die for global module
	or decl. If die is not found for non globals, force new die. */
	if (!context)
	scope_die = comp_unit_die;
	else if (TYPE_P (context))
	{
	if (!should_emit_struct_debug (context, DINFO_USAGE_DIR_USE))
	return;
	scope_die = force_type_die (context);
	}
	else
	scope_die = force_decl_die (context);

	/* For TYPE_DECL or CONST_DECL, lookup TREE_TYPE. */
	if (TREE_CODE (decl) == TYPE_DECL \|\| TREE_CODE (decl) == CONST_DECL)
	{
	if (is_base_type (TREE_TYPE (decl)))
	at_import_die = base_type_die (TREE_TYPE (decl));
	else
	at_import_die = force_type_die (TREE_TYPE (decl));
	}
	else
	{
	at_import_die = lookup_decl_die (decl);
	if (!at_import_die)
	{
	/* If we're trying to avoid duplicate debug info, we may not have
	emitted the member decl for this field. Emit it now. */
	if (TREE_CODE (decl) == FIELD_DECL)
	{
	tree type = DECL_CONTEXT (decl);
	dw_die_ref type_context_die;

	if (TYPE_CONTEXT (type))
	if (TYPE_P (TYPE_CONTEXT (type)))
	{
	if (!should_emit_struct_debug (TYPE_CONTEXT (type),
	DINFO_USAGE_DIR_USE))
	return;
	type_context_die = force_type_die (TYPE_CONTEXT (type));
	}
	else
	type_context_die = force_decl_die (TYPE_CONTEXT (type));
	else
	type_context_die = comp_unit_die;
	gen_type_die_for_member (type, decl, type_context_die);
	}
	at_import_die = force_decl_die (decl);
	}
	}

	/* OK, now we have DIEs for decl as well as scope. Emit imported die. */
	if (TREE_CODE (decl) == NAMESPACE_DECL)
	imported_die = new_die (DW_TAG_imported_module, scope_die, context);
	else
	imported_die = new_die (DW_TAG_imported_declaration, scope_die, context);

	xloc = expand_location (input_location);
	add_AT_file (imported_die, DW_AT_decl_file, lookup_filename (xloc.file));
	add_AT_unsigned (imported_die, DW_AT_decl_line, xloc.line);
	add_AT_die_ref (imported_die, DW_AT_import, at_import_die);
	}

	/* Write the debugging output for DECL. */

	void
	dwarf2out_decl (tree decl)
	{
	dw_die_ref context_die = comp_unit_die;

	switch (TREE_CODE (decl))
	{
	case ERROR_MARK:
	return;

	case FUNCTION_DECL:
	/* What we would really like to do here is to filter out all mere
	file-scope declarations of file-scope functions which are never
	referenced later within this translation unit (and keep all of ones
	that are referenced later on) but we aren't clairvoyant, so we have
	no idea which functions will be referenced in the future (i.e. later
	on within the current translation unit). So here we just ignore all
	file-scope function declarations which are not also definitions. If
	and when the debugger needs to know something about these functions,
	it will have to hunt around and find the DWARF information associated
	with the definition of the function.

	We can't just check DECL_EXTERNAL to find out which FUNCTION_DECL
	nodes represent definitions and which ones represent mere
	declarations. We have to check DECL_INITIAL instead. That's because
	the C front-end supports some weird semantics for "extern inline"
	function definitions. These can get inlined within the current
	translation unit (and thus, we need to generate Dwarf info for their
	abstract instances so that the Dwarf info for the concrete inlined
	instances can have something to refer to) but the compiler never
	generates any out-of-lines instances of such things (despite the fact
	that they are definitions).

	The important point is that the C front-end marks these "extern
	inline" functions as DECL_EXTERNAL, but we need to generate DWARF for
	them anyway. Note that the C++ front-end also plays some similar games
	for inline function definitions appearing within include files which
	also contain `#pragma interface' pragmas. */
	if (DECL_INITIAL (decl) == NULL_TREE)
	return;

	/* If we're a nested function, initially use a parent of NULL; if we're
	a plain function, this will be fixed up in decls_for_scope. If
	we're a method, it will be ignored, since we already have a DIE. */
	if (decl_function_context (decl)
	/* But if we're in terse mode, we don't care about scope. */
	&& debug_info_level > DINFO_LEVEL_TERSE)
	context_die = NULL;
	break;

	case VAR_DECL:
	/* Ignore this VAR_DECL if it refers to a file-scope extern data object
	declaration and if the declaration was never even referenced from
	within this entire compilation unit. We suppress these DIEs in
	order to save space in the .debug section (by eliminating entries
	which are probably useless). Note that we must not suppress
	block-local extern declarations (whether used or not) because that
	would screw-up the debugger's name lookup mechanism and cause it to
	miss things which really ought to be in scope at a given point. */
	if (DECL_EXTERNAL (decl) && !TREE_USED (decl))
	return;

	/* For local statics lookup proper context die. */
	if (TREE_STATIC (decl) && decl_function_context (decl))
	context_die = lookup_decl_die (DECL_CONTEXT (decl));

	/* If we are in terse mode, don't generate any DIEs to represent any
	variable declarations or definitions. */
	if (debug_info_level <= DINFO_LEVEL_TERSE)
	return;
	break;

	case NAMESPACE_DECL:
	if (debug_info_level <= DINFO_LEVEL_TERSE)
	return;
	if (lookup_decl_die (decl) != NULL)
	return;
	break;

	case TYPE_DECL:
	/* Don't emit stubs for types unless they are needed by other DIEs. */
	if (TYPE_DECL_SUPPRESS_DEBUG (decl))
	return;

	/* Don't bother trying to generate any DIEs to represent any of the
	normal built-in types for the language we are compiling. */
	if (DECL_IS_BUILTIN (decl))
	{
	/* OK, we need to generate one for `bool' so GDB knows what type
	comparisons have. */
	if (is_cxx ()
	&& TREE_CODE (TREE_TYPE (decl)) == BOOLEAN_TYPE
	&& ! DECL_IGNORED_P (decl))
	modified_type_die (TREE_TYPE (decl), 0, 0, NULL);

	return;
	}

	/* If we are in terse mode, don't generate any DIEs for types. */
	if (debug_info_level <= DINFO_LEVEL_TERSE)
	return;

	/* If we're a function-scope tag, initially use a parent of NULL;
	this will be fixed up in decls_for_scope. */
	if (decl_function_context (decl))
	context_die = NULL;

	break;

	default:
	return;
	}

	gen_decl_die (decl, context_die);
	}

	/* Output a marker (i.e. a label) for the beginning of the generated code for
	a lexical block. */

	static void
	dwarf2out_begin_block (unsigned int line ATTRIBUTE_UNUSED,
	unsigned int blocknum)
	{
	switch_to_section (current_function_section ());
	ASM_OUTPUT_DEBUG_LABEL (asm_out_file, BLOCK_BEGIN_LABEL, blocknum);
	}

	/* Output a marker (i.e. a label) for the end of the generated code for a
	lexical block. */

	static void
	dwarf2out_end_block (unsigned int line ATTRIBUTE_UNUSED, unsigned int blocknum)
	{
	switch_to_section (current_function_section ());
	ASM_OUTPUT_DEBUG_LABEL (asm_out_file, BLOCK_END_LABEL, blocknum);
	}

	/* Returns nonzero if it is appropriate not to emit any debugging
	information for BLOCK, because it doesn't contain any instructions.

	Don't allow this for blocks with nested functions or local classes
	as we would end up with orphans, and in the presence of scheduling
	we may end up calling them anyway. */

	static bool
	dwarf2out_ignore_block (tree block)
	{
	tree decl;

	for (decl = BLOCK_VARS (block); decl; decl = TREE_CHAIN (decl))
	if (TREE_CODE (decl) == FUNCTION_DECL
	\|\| (TREE_CODE (decl) == TYPE_DECL && TYPE_DECL_IS_STUB (decl)))
	return 0;

	return 1;
	}

	/* Hash table routines for file_hash. */

	static int
	file_table_eq (const void p1_p, const void p2_p)
	{
	const struct dwarf_file_data * p1 = p1_p;
	const char * p2 = p2_p;
	return strcmp (p1->filename, p2) == 0;
	}

	static hashval_t
	file_table_hash (const void *p_p)
	{
	const struct dwarf_file_data * p = p_p;
	return htab_hash_string (p->filename);
	}

	/* Lookup FILE_NAME (in the list of filenames that we know about here in
	dwarf2out.c) and return its "index". The index of each (known) filename is
	just a unique number which is associated with only that one filename. We
	need such numbers for the sake of generating labels (in the .debug_sfnames
	section) and references to those files numbers (in the .debug_srcinfo
	and.debug_macinfo sections). If the filename given as an argument is not
	found in our current list, add it to the list and assign it the next
	available unique index number. In order to speed up searches, we remember
	the index of the filename was looked up last. This handles the majority of
	all searches. */

	static struct dwarf_file_data *
	lookup_filename (const char *file_name)
	{
	void ** slot;
	struct dwarf_file_data * created;

	/* Check to see if the file name that was searched on the previous
	call matches this file name. If so, return the index. */
	if (file_table_last_lookup
	&& (file_name == file_table_last_lookup->filename
	\|\| strcmp (file_table_last_lookup->filename, file_name) == 0))
	return file_table_last_lookup;

	/* Didn't match the previous lookup, search the table. */
	slot = htab_find_slot_with_hash (file_table, file_name,
	htab_hash_string (file_name), INSERT);
	if (*slot)
	return *slot;

	created = ggc_alloc (sizeof (struct dwarf_file_data));
	created->filename = file_name;
	created->emitted_number = 0;
	*slot = created;
	return created;
	}

	/* If the assembler will construct the file table, then translate the compiler
	internal file table number into the assembler file table number, and emit
	a .file directive if we haven't already emitted one yet. The file table
	numbers are different because we prune debug info for unused variables and
	types, which may include filenames. */

	static int
	maybe_emit_file (struct dwarf_file_data * fd)
	{
	if (! fd->emitted_number)
	{
	if (last_emitted_file)
	fd->emitted_number = last_emitted_file->emitted_number + 1;
	else
	fd->emitted_number = 1;
	last_emitted_file = fd;

	if (DWARF2_ASM_LINE_DEBUG_INFO)
	{
	fprintf (asm_out_file, "\t.file %u ", fd->emitted_number);
	output_quoted_string (asm_out_file, fd->filename);
	fputc ('\n', asm_out_file);
	}
	}

	return fd->emitted_number;
	}

	/* Called by the final INSN scan whenever we see a var location. We
	use it to drop labels in the right places, and throw the location in
	our lookup table. */

	static void
	dwarf2out_var_location (rtx loc_note)
	{
	char loclabel[MAX_ARTIFICIAL_LABEL_BYTES];
	struct var_loc_node *newloc;
	rtx prev_insn;
	static rtx last_insn;
	static const char *last_label;
	tree decl;

	if (!DECL_P (NOTE_VAR_LOCATION_DECL (loc_note)))
	return;
	prev_insn = PREV_INSN (loc_note);

	newloc = ggc_alloc_cleared (sizeof (struct var_loc_node));
	/* If the insn we processed last time is the previous insn
	and it is also a var location note, use the label we emitted
	last time. */
	if (last_insn != NULL_RTX
	&& last_insn == prev_insn
	&& NOTE_P (prev_insn)
	&& NOTE_LINE_NUMBER (prev_insn) == NOTE_INSN_VAR_LOCATION)
	{
	newloc->label = last_label;
	}
	else
	{
	ASM_GENERATE_INTERNAL_LABEL (loclabel, "LVL", loclabel_num);
	ASM_OUTPUT_DEBUG_LABEL (asm_out_file, "LVL", loclabel_num);
	loclabel_num++;
	newloc->label = ggc_strdup (loclabel);
	}
	newloc->var_loc_note = loc_note;
	newloc->next = NULL;

	if (cfun && in_cold_section_p)
	newloc->section_label = cfun->cold_section_label;
	else
	newloc->section_label = text_section_label;

	last_insn = loc_note;
	last_label = newloc->label;
	decl = NOTE_VAR_LOCATION_DECL (loc_note);
	add_var_loc_to_decl (decl, newloc);
	}

	/* We need to reset the locations at the beginning of each
	function. We can't do this in the end_function hook, because the
	declarations that use the locations won't have been output when
	that hook is called. Also compute have_multiple_function_sections here. */

	static void
	dwarf2out_begin_function (tree fun)
	{
	htab_empty (decl_loc_table);

	if (function_section (fun) != text_section)
	have_multiple_function_sections = true;
	}

	/* Output a label to mark the beginning of a source code line entry
	and record information relating to this source line, in
	'line_info_table' for later output of the .debug_line section. */

	static void
	dwarf2out_source_line (unsigned int line, const char *filename)
	{
	if (debug_info_level >= DINFO_LEVEL_NORMAL
	&& line != 0)
	{
	int file_num = maybe_emit_file (lookup_filename (filename));

	switch_to_section (current_function_section ());

	/* If requested, emit something human-readable. */
	if (flag_debug_asm)
	fprintf (asm_out_file, "\t%s %s:%d\n", ASM_COMMENT_START,
	filename, line);

	if (DWARF2_ASM_LINE_DEBUG_INFO)
	{
	/* Emit the .loc directive understood by GNU as. */
	fprintf (asm_out_file, "\t.loc %d %d 0\n", file_num, line);

	/* Indicate that line number info exists. */
	line_info_table_in_use++;
	}
	else if (function_section (current_function_decl) != text_section)
	{
	dw_separate_line_info_ref line_info;
	targetm.asm_out.internal_label (asm_out_file,
	SEPARATE_LINE_CODE_LABEL,
	separate_line_info_table_in_use);

	/* Expand the line info table if necessary. */
	if (separate_line_info_table_in_use
	== separate_line_info_table_allocated)
	{
	separate_line_info_table_allocated += LINE_INFO_TABLE_INCREMENT;
	separate_line_info_table
	= ggc_realloc (separate_line_info_table,
	separate_line_info_table_allocated
	* sizeof (dw_separate_line_info_entry));
	memset (separate_line_info_table
	+ separate_line_info_table_in_use,
	0,
	(LINE_INFO_TABLE_INCREMENT
	* sizeof (dw_separate_line_info_entry)));
	}

	/* Add the new entry at the end of the line_info_table. */
	line_info
	= &separate_line_info_table[separate_line_info_table_in_use++];
	line_info->dw_file_num = file_num;
	line_info->dw_line_num = line;
	line_info->function = current_function_funcdef_no;
	}
	else
	{
	dw_line_info_ref line_info;

	targetm.asm_out.internal_label (asm_out_file, LINE_CODE_LABEL,
	line_info_table_in_use);

	/* Expand the line info table if necessary. */
	if (line_info_table_in_use == line_info_table_allocated)
	{
	line_info_table_allocated += LINE_INFO_TABLE_INCREMENT;
	line_info_table
	= ggc_realloc (line_info_table,
	(line_info_table_allocated
	* sizeof (dw_line_info_entry)));
	memset (line_info_table + line_info_table_in_use, 0,
	LINE_INFO_TABLE_INCREMENT * sizeof (dw_line_info_entry));
	}

	/* Add the new entry at the end of the line_info_table. */
	line_info = &line_info_table[line_info_table_in_use++];
	line_info->dw_file_num = file_num;
	line_info->dw_line_num = line;
	}
	}
	}

	/* Record the beginning of a new source file. */

	static void
	dwarf2out_start_source_file (unsigned int lineno, const char *filename)
	{
	if (flag_eliminate_dwarf2_dups)
	{
	/* Record the beginning of the file for break_out_includes. */
	dw_die_ref bincl_die;

	bincl_die = new_die (DW_TAG_GNU_BINCL, comp_unit_die, NULL);
	add_AT_string (bincl_die, DW_AT_name, filename);
	}

	if (debug_info_level >= DINFO_LEVEL_VERBOSE)
	{
	int file_num = maybe_emit_file (lookup_filename (filename));

	switch_to_section (debug_macinfo_section);
	dw2_asm_output_data (1, DW_MACINFO_start_file, "Start new file");
	dw2_asm_output_data_uleb128 (lineno, "Included from line number %d",
	lineno);

	dw2_asm_output_data_uleb128 (file_num, "file %s", filename);
	}
	}

	/* Record the end of a source file. */

	static void
	dwarf2out_end_source_file (unsigned int lineno ATTRIBUTE_UNUSED)
	{
	if (flag_eliminate_dwarf2_dups)
	/* Record the end of the file for break_out_includes. */
	new_die (DW_TAG_GNU_EINCL, comp_unit_die, NULL);

	if (debug_info_level >= DINFO_LEVEL_VERBOSE)
	{
	switch_to_section (debug_macinfo_section);
	dw2_asm_output_data (1, DW_MACINFO_end_file, "End file");
	}
	}

	/* Called from debug_define in toplev.c. The `buffer' parameter contains
	the tail part of the directive line, i.e. the part which is past the
	initial whitespace, #, whitespace, directive-name, whitespace part. */

	static void
	dwarf2out_define (unsigned int lineno ATTRIBUTE_UNUSED,
	const char *buffer ATTRIBUTE_UNUSED)
	{
	if (debug_info_level >= DINFO_LEVEL_VERBOSE)
	{
	switch_to_section (debug_macinfo_section);
	dw2_asm_output_data (1, DW_MACINFO_define, "Define macro");
	dw2_asm_output_data_uleb128 (lineno, "At line number %d", lineno);
	dw2_asm_output_nstring (buffer, -1, "The macro");
	}
	}

	/* Called from debug_undef in toplev.c. The `buffer' parameter contains
	the tail part of the directive line, i.e. the part which is past the
	initial whitespace, #, whitespace, directive-name, whitespace part. */

	static void
	dwarf2out_undef (unsigned int lineno ATTRIBUTE_UNUSED,
	const char *buffer ATTRIBUTE_UNUSED)
	{
	if (debug_info_level >= DINFO_LEVEL_VERBOSE)
	{
	switch_to_section (debug_macinfo_section);
	dw2_asm_output_data (1, DW_MACINFO_undef, "Undefine macro");
	dw2_asm_output_data_uleb128 (lineno, "At line number %d", lineno);
	dw2_asm_output_nstring (buffer, -1, "The macro");
	}
	}

	/* Set up for Dwarf output at the start of compilation. */

	static void
	dwarf2out_init (const char *filename ATTRIBUTE_UNUSED)
	{
	/* Allocate the file_table. */
	file_table = htab_create_ggc (50, file_table_hash,
	file_table_eq, NULL);

	/* Allocate the decl_die_table. */
	decl_die_table = htab_create_ggc (10, decl_die_table_hash,
	decl_die_table_eq, NULL);

	/* Allocate the decl_loc_table. */
	decl_loc_table = htab_create_ggc (10, decl_loc_table_hash,
	decl_loc_table_eq, NULL);

	/* Allocate the initial hunk of the decl_scope_table. */
	decl_scope_table = VEC_alloc (tree, gc, 256);

	/* Allocate the initial hunk of the abbrev_die_table. */
	abbrev_die_table = ggc_alloc_cleared (ABBREV_DIE_TABLE_INCREMENT
	* sizeof (dw_die_ref));
	abbrev_die_table_allocated = ABBREV_DIE_TABLE_INCREMENT;
	/* Zero-th entry is allocated, but unused. */
	abbrev_die_table_in_use = 1;

	/* Allocate the initial hunk of the line_info_table. */
	line_info_table = ggc_alloc_cleared (LINE_INFO_TABLE_INCREMENT
	* sizeof (dw_line_info_entry));
	line_info_table_allocated = LINE_INFO_TABLE_INCREMENT;

	/* Zero-th entry is allocated, but unused. */
	line_info_table_in_use = 1;

	/* Allocate the pubtypes and pubnames vectors. */
	pubname_table = VEC_alloc (pubname_entry, gc, 32);
	pubtype_table = VEC_alloc (pubname_entry, gc, 32);

	/* Generate the initial DIE for the .debug section. Note that the (string)
	value given in the DW_AT_name attribute of the DW_TAG_compile_unit DIE
	will (typically) be a relative pathname and that this pathname should be
	taken as being relative to the directory from which the compiler was
	invoked when the given (base) source file was compiled. We will fill
	in this value in dwarf2out_finish. */
	comp_unit_die = gen_compile_unit_die (NULL);

	incomplete_types = VEC_alloc (tree, gc, 64);

	used_rtx_array = VEC_alloc (rtx, gc, 32);

	debug_info_section = get_section (DEBUG_INFO_SECTION,
	SECTION_DEBUG, NULL);
	debug_abbrev_section = get_section (DEBUG_ABBREV_SECTION,
	SECTION_DEBUG, NULL);
	debug_aranges_section = get_section (DEBUG_ARANGES_SECTION,
	SECTION_DEBUG, NULL);
	debug_macinfo_section = get_section (DEBUG_MACINFO_SECTION,
	SECTION_DEBUG, NULL);
	debug_line_section = get_section (DEBUG_LINE_SECTION,
	SECTION_DEBUG, NULL);
	debug_loc_section = get_section (DEBUG_LOC_SECTION,
	SECTION_DEBUG, NULL);
	debug_pubnames_section = get_section (DEBUG_PUBNAMES_SECTION,
	SECTION_DEBUG, NULL);
	#ifdef DEBUG_PUBTYPES_SECTION
	debug_pubtypes_section = get_section (DEBUG_PUBTYPES_SECTION,
	SECTION_DEBUG, NULL);
	#endif
	debug_str_section = get_section (DEBUG_STR_SECTION,
	DEBUG_STR_SECTION_FLAGS, NULL);
	debug_ranges_section = get_section (DEBUG_RANGES_SECTION,
	SECTION_DEBUG, NULL);
	debug_frame_section = get_section (DEBUG_FRAME_SECTION,
	SECTION_DEBUG, NULL);

	ASM_GENERATE_INTERNAL_LABEL (text_end_label, TEXT_END_LABEL, 0);
	ASM_GENERATE_INTERNAL_LABEL (abbrev_section_label,
	DEBUG_ABBREV_SECTION_LABEL, 0);
	ASM_GENERATE_INTERNAL_LABEL (text_section_label, TEXT_SECTION_LABEL, 0);
	ASM_GENERATE_INTERNAL_LABEL (cold_text_section_label,
	COLD_TEXT_SECTION_LABEL, 0);
	ASM_GENERATE_INTERNAL_LABEL (cold_end_label, COLD_END_LABEL, 0);

	ASM_GENERATE_INTERNAL_LABEL (debug_info_section_label,
	DEBUG_INFO_SECTION_LABEL, 0);
	ASM_GENERATE_INTERNAL_LABEL (debug_line_section_label,
	DEBUG_LINE_SECTION_LABEL, 0);
	ASM_GENERATE_INTERNAL_LABEL (ranges_section_label,
	DEBUG_RANGES_SECTION_LABEL, 0);
	switch_to_section (debug_abbrev_section);
	ASM_OUTPUT_LABEL (asm_out_file, abbrev_section_label);
	switch_to_section (debug_info_section);
	ASM_OUTPUT_LABEL (asm_out_file, debug_info_section_label);
	switch_to_section (debug_line_section);
	ASM_OUTPUT_LABEL (asm_out_file, debug_line_section_label);

	if (debug_info_level >= DINFO_LEVEL_VERBOSE)
	{
	switch_to_section (debug_macinfo_section);
	ASM_GENERATE_INTERNAL_LABEL (macinfo_section_label,
	DEBUG_MACINFO_SECTION_LABEL, 0);
	ASM_OUTPUT_LABEL (asm_out_file, macinfo_section_label);
	}

	switch_to_section (text_section);
	ASM_OUTPUT_LABEL (asm_out_file, text_section_label);
	if (flag_reorder_blocks_and_partition)
	{
	switch_to_section (unlikely_text_section ());
	ASM_OUTPUT_LABEL (asm_out_file, cold_text_section_label);
	}
	}

	/* A helper function for dwarf2out_finish called through
	ht_forall. Emit one queued .debug_str string. */

	static int
	output_indirect_string (void *h, void v ATTRIBUTE_UNUSED)
	{
	struct indirect_string_node node = (struct indirect_string_node ) *h;

	if (node->form == DW_FORM_strp)
	{
	switch_to_section (debug_str_section);
	ASM_OUTPUT_LABEL (asm_out_file, node->label);
	assemble_string (node->str, strlen (node->str) + 1);
	}

	return 1;
	}

	#if ENABLE_ASSERT_CHECKING
	/* Verify that all marks are clear. */

	static void
	verify_marks_clear (dw_die_ref die)
	{
	dw_die_ref c;

	gcc_assert (! die->die_mark);
	FOR_EACH_CHILD (die, c, verify_marks_clear (c));
	}
	#endif /* ENABLE_ASSERT_CHECKING */

	/* Clear the marks for a die and its children.
	Be cool if the mark isn't set. */

	static void
	prune_unmark_dies (dw_die_ref die)
	{
	dw_die_ref c;

	if (die->die_mark)
	die->die_mark = 0;
	FOR_EACH_CHILD (die, c, prune_unmark_dies (c));
	}

	/* Given DIE that we're marking as used, find any other dies
	it references as attributes and mark them as used. */

	static void
	prune_unused_types_walk_attribs (dw_die_ref die)
	{
	dw_attr_ref a;
	unsigned ix;

	for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, a); ix++)
	{
	if (a->dw_attr_val.val_class == dw_val_class_die_ref)
	{
	/* A reference to another DIE.
	Make sure that it will get emitted. */
	prune_unused_types_mark (a->dw_attr_val.v.val_die_ref.die, 1);
	}
	/* Set the string's refcount to 0 so that prune_unused_types_mark
	accounts properly for it. */
	if (AT_class (a) == dw_val_class_str)
	a->dw_attr_val.v.val_str->refcount = 0;
	}
	}


	/* Mark DIE as being used. If DOKIDS is true, then walk down
	to DIE's children. */

	static void
	prune_unused_types_mark (dw_die_ref die, int dokids)
	{
	dw_die_ref c;

	if (die->die_mark == 0)
	{
	/* We haven't done this node yet. Mark it as used. */
	die->die_mark = 1;

	/* We also have to mark its parents as used.
	(But we don't want to mark our parents' kids due to this.) */
	if (die->die_parent)
	prune_unused_types_mark (die->die_parent, 0);

	/* Mark any referenced nodes. */
	prune_unused_types_walk_attribs (die);

	/* If this node is a specification,
	also mark the definition, if it exists. */
	if (get_AT_flag (die, DW_AT_declaration) && die->die_definition)
	prune_unused_types_mark (die->die_definition, 1);
	}

	if (dokids && die->die_mark != 2)
	{
	/* We need to walk the children, but haven't done so yet.
	Remember that we've walked the kids. */
	die->die_mark = 2;

	/* If this is an array type, we need to make sure our
	kids get marked, even if they're types. */
	if (die->die_tag == DW_TAG_array_type)
	FOR_EACH_CHILD (die, c, prune_unused_types_mark (c, 1));
	else
	FOR_EACH_CHILD (die, c, prune_unused_types_walk (c));
	}
	}


	/* Walk the tree DIE and mark types that we actually use. */

	static void
	prune_unused_types_walk (dw_die_ref die)
	{
	dw_die_ref c;

	/* Don't do anything if this node is already marked. */
	if (die->die_mark)
	return;

	switch (die->die_tag) {
	case DW_TAG_const_type:
	case DW_TAG_packed_type:
	case DW_TAG_pointer_type:
	case DW_TAG_reference_type:
	case DW_TAG_volatile_type:
	case DW_TAG_typedef:
	case DW_TAG_array_type:
	case DW_TAG_structure_type:
	case DW_TAG_union_type:
	case DW_TAG_class_type:
	case DW_TAG_friend:
	case DW_TAG_variant_part:
	case DW_TAG_enumeration_type:
	case DW_TAG_subroutine_type:
	case DW_TAG_string_type:
	case DW_TAG_set_type:
	case DW_TAG_subrange_type:
	case DW_TAG_ptr_to_member_type:
	case DW_TAG_file_type:
	if (die->die_perennial_p)
	break;

	/* It's a type node --- don't mark it. */
	return;

	default:
	/* Mark everything else. */
	break;
	}

	die->die_mark = 1;

	/* Now, mark any dies referenced from here. */
	prune_unused_types_walk_attribs (die);

	/* Mark children. */
	FOR_EACH_CHILD (die, c, prune_unused_types_walk (c));
	}

	/* Increment the string counts on strings referred to from DIE's
	attributes. */

	static void
	prune_unused_types_update_strings (dw_die_ref die)
	{
	dw_attr_ref a;
	unsigned ix;

	for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, a); ix++)
	if (AT_class (a) == dw_val_class_str)
	{
	struct indirect_string_node *s = a->dw_attr_val.v.val_str;
	s->refcount++;
	/* Avoid unnecessarily putting strings that are used less than
	twice in the hash table. */
	if (s->refcount
	== ((DEBUG_STR_SECTION_FLAGS & SECTION_MERGE) ? 1 : 2))
	{
	void ** slot;
	slot = htab_find_slot_with_hash (debug_str_hash, s->str,
	htab_hash_string (s->str),
	INSERT);
	gcc_assert (*slot == NULL);
	*slot = s;
	}
	}
	}

	/* Remove from the tree DIE any dies that aren't marked. */

	static void
	prune_unused_types_prune (dw_die_ref die)
	{
	dw_die_ref c;

	gcc_assert (die->die_mark);
	prune_unused_types_update_strings (die);

	if (! die->die_child)
	return;

	c = die->die_child;
	do {
	dw_die_ref prev = c;
	for (c = c->die_sib; ! c->die_mark; c = c->die_sib)
	if (c == die->die_child)
	{
	/* No marked children between 'prev' and the end of the list. */
	if (prev == c)
	/* No marked children at all. */
	die->die_child = NULL;
	else
	{
	prev->die_sib = c->die_sib;
	die->die_child = prev;
	}
	return;
	}

	if (c != prev->die_sib)
	prev->die_sib = c;
	prune_unused_types_prune (c);
	} while (c != die->die_child);
	}


	/* Remove dies representing declarations that we never use. */

	static void
	prune_unused_types (void)
	{
	unsigned int i;
	limbo_die_node *node;
	pubname_ref pub;

	#if ENABLE_ASSERT_CHECKING
	/* All the marks should already be clear. */
	verify_marks_clear (comp_unit_die);
	for (node = limbo_die_list; node; node = node->next)
	verify_marks_clear (node->die);
	#endif /* ENABLE_ASSERT_CHECKING */

	/* Set the mark on nodes that are actually used. */
	prune_unused_types_walk (comp_unit_die);
	for (node = limbo_die_list; node; node = node->next)
	prune_unused_types_walk (node->die);

	/* Also set the mark on nodes referenced from the
	pubname_table or arange_table. */
	for (i = 0; VEC_iterate (pubname_entry, pubname_table, i, pub); i++)
	prune_unused_types_mark (pub->die, 1);
	for (i = 0; i < arange_table_in_use; i++)
	prune_unused_types_mark (arange_table[i], 1);

	/* Get rid of nodes that aren't marked; and update the string counts. */
	if (debug_str_hash)
	htab_empty (debug_str_hash);
	prune_unused_types_prune (comp_unit_die);
	for (node = limbo_die_list; node; node = node->next)
	prune_unused_types_prune (node->die);

	/* Leave the marks clear. */
	prune_unmark_dies (comp_unit_die);
	for (node = limbo_die_list; node; node = node->next)
	prune_unmark_dies (node->die);
	}

	/* Set the parameter to true if there are any relative pathnames in
	the file table. */
	static int
	file_table_relative_p (void ** slot, void *param)
	{
	bool *p = param;
	struct dwarf_file_data d = slot;
	if (d->emitted_number && d->filename[0] != DIR_SEPARATOR)
	{
	*p = true;
	return 0;
	}
	return 1;
	}

	/* Output stuff that dwarf requires at the end of every file,
	and generate the DWARF-2 debugging info. */

	static void
	dwarf2out_finish (const char *filename)
	{
	limbo_die_node node, next_node;
	dw_die_ref die = 0;

	/* Add the name for the main input file now. We delayed this from
	dwarf2out_init to avoid complications with PCH. */
	add_name_attribute (comp_unit_die, filename);
	if (filename[0] != DIR_SEPARATOR)
	add_comp_dir_attribute (comp_unit_die);
	else if (get_AT (comp_unit_die, DW_AT_comp_dir) == NULL)
	{
	bool p = false;
	htab_traverse (file_table, file_table_relative_p, &p);
	if (p)
	add_comp_dir_attribute (comp_unit_die);
	}

	/* Traverse the limbo die list, and add parent/child links. The only
	dies without parents that should be here are concrete instances of
	inline functions, and the comp_unit_die. We can ignore the comp_unit_die.
	For concrete instances, we can get the parent die from the abstract
	instance. */
	for (node = limbo_die_list; node; node = next_node)
	{
	next_node = node->next;
	die = node->die;

	if (die->die_parent == NULL)
	{
	dw_die_ref origin = get_AT_ref (die, DW_AT_abstract_origin);

	if (origin)
	add_child_die (origin->die_parent, die);
	else if (die == comp_unit_die)
	;
	else if (errorcount > 0 \|\| sorrycount > 0)
	/* It's OK to be confused by errors in the input. */
	add_child_die (comp_unit_die, die);
	else
	{
	/* In certain situations, the lexical block containing a
	nested function can be optimized away, which results
	in the nested function die being orphaned. Likewise
	with the return type of that nested function. Force
	this to be a child of the containing function.

	It may happen that even the containing function got fully
	inlined and optimized out. In that case we are lost and
	assign the empty child. This should not be big issue as
	the function is likely unreachable too. */
	tree context = NULL_TREE;

	gcc_assert (node->created_for);

	if (DECL_P (node->created_for))
	context = DECL_CONTEXT (node->created_for);
	else if (TYPE_P (node->created_for))
	context = TYPE_CONTEXT (node->created_for);

	gcc_assert (context
	&& (TREE_CODE (context) == FUNCTION_DECL
	\|\| TREE_CODE (context) == NAMESPACE_DECL));

	origin = lookup_decl_die (context);
	if (origin)
	add_child_die (origin, die);
	else
	add_child_die (comp_unit_die, die);
	}
	}
	}

	limbo_die_list = NULL;

	/* Walk through the list of incomplete types again, trying once more to
	emit full debugging info for them. */
	retry_incomplete_types ();

	if (flag_eliminate_unused_debug_types)
	prune_unused_types ();

	/* Generate separate CUs for each of the include files we've seen.
	They will go into limbo_die_list. */
	if (flag_eliminate_dwarf2_dups)
	break_out_includes (comp_unit_die);

	/* Traverse the DIE's and add add sibling attributes to those DIE's
	that have children. */
	add_sibling_attributes (comp_unit_die);
	for (node = limbo_die_list; node; node = node->next)
	add_sibling_attributes (node->die);

	/* Output a terminator label for the .text section. */
	switch_to_section (text_section);
	targetm.asm_out.internal_label (asm_out_file, TEXT_END_LABEL, 0);
	if (flag_reorder_blocks_and_partition)
	{
	switch_to_section (unlikely_text_section ());
	targetm.asm_out.internal_label (asm_out_file, COLD_END_LABEL, 0);
	}

	/* We can only use the low/high_pc attributes if all of the code was
	in .text. */
	if (!have_multiple_function_sections)
	{
	add_AT_lbl_id (comp_unit_die, DW_AT_low_pc, text_section_label);
	add_AT_lbl_id (comp_unit_die, DW_AT_high_pc, text_end_label);
	}

	/* If it wasn't, we need to give .debug_loc and .debug_ranges an appropriate
	"base address". Use zero so that these addresses become absolute. */
	else if (have_location_lists \|\| ranges_table_in_use)
	add_AT_addr (comp_unit_die, DW_AT_entry_pc, const0_rtx);

	/* Output location list section if necessary. */
	if (have_location_lists)
	{
	/* Output the location lists info. */
	switch_to_section (debug_loc_section);
	ASM_GENERATE_INTERNAL_LABEL (loc_section_label,
	DEBUG_LOC_SECTION_LABEL, 0);
	ASM_OUTPUT_LABEL (asm_out_file, loc_section_label);
	output_location_lists (die);
	}

	if (debug_info_level >= DINFO_LEVEL_NORMAL)
	add_AT_lineptr (comp_unit_die, DW_AT_stmt_list,
	debug_line_section_label);

	if (debug_info_level >= DINFO_LEVEL_VERBOSE)
	add_AT_macptr (comp_unit_die, DW_AT_macro_info, macinfo_section_label);

	/* Output all of the compilation units. We put the main one last so that
	the offsets are available to output_pubnames. */
	for (node = limbo_die_list; node; node = node->next)
	output_comp_unit (node->die, 0);

	output_comp_unit (comp_unit_die, 0);

	/* Output the abbreviation table. */
	switch_to_section (debug_abbrev_section);
	output_abbrev_section ();

	/* Output public names table if necessary. */
	if (!VEC_empty (pubname_entry, pubname_table))
	{
	switch_to_section (debug_pubnames_section);
	output_pubnames (pubname_table);
	}

	#ifdef DEBUG_PUBTYPES_SECTION
	/* Output public types table if necessary. */
	if (!VEC_empty (pubname_entry, pubtype_table))
	{
	switch_to_section (debug_pubtypes_section);
	output_pubnames (pubtype_table);
	}
	#endif

	/* Output the address range information. We only put functions in the arange
	table, so don't write it out if we don't have any. */
	if (fde_table_in_use)
	{
	switch_to_section (debug_aranges_section);
	output_aranges ();
	}

	/* Output ranges section if necessary. */
	if (ranges_table_in_use)
	{
	switch_to_section (debug_ranges_section);
	ASM_OUTPUT_LABEL (asm_out_file, ranges_section_label);
	output_ranges ();
	}

	/* Output the source line correspondence table. We must do this
	even if there is no line information. Otherwise, on an empty
	translation unit, we will generate a present, but empty,
	.debug_info section. IRIX 6.5 `nm' will then complain when
	examining the file. This is done late so that any filenames
	used by the debug_info section are marked as 'used'. */
	if (! DWARF2_ASM_LINE_DEBUG_INFO)
	{
	switch_to_section (debug_line_section);
	output_line_info ();
	}

	/* Have to end the macro section. */
	if (debug_info_level >= DINFO_LEVEL_VERBOSE)
	{
	switch_to_section (debug_macinfo_section);
	dw2_asm_output_data (1, 0, "End compilation unit");
	}

	/* If we emitted any DW_FORM_strp form attribute, output the string
	table too. */
	if (debug_str_hash)
	htab_traverse (debug_str_hash, output_indirect_string, NULL);
	}
	#else

	/* This should never be used, but its address is needed for comparisons. */
	const struct gcc_debug_hooks dwarf2_debug_hooks;

	#endif /* DWARF2_DEBUGGING_INFO */

	#include "gt-dwarf2out.h"
	diff --git a/contrib/gcc/emit-rtl.c b/contrib/gcc/emit-rtl.c
	index 73ce0b4b8ab7..fea0c112fd33 100644
	--- a/contrib/gcc/emit-rtl.c
	+++ b/contrib/gcc/emit-rtl.c
	@@ -1,5382 +1,5384 @@
	/* Emit RTL for the GCC expander.
	Copyright (C) 1987, 1988, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
	1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006
	Free Software Foundation, Inc.

	This file is part of GCC.

	GCC is free software; you can redistribute it and/or modify it under
	the terms of the GNU General Public License as published by the Free
	Software Foundation; either version 2, or (at your option) any later
	version.

	GCC is distributed in the hope that it will be useful, but WITHOUT ANY
	WARRANTY; without even the implied warranty of MERCHANTABILITY or
	FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	for more details.

	You should have received a copy of the GNU General Public License
	along with GCC; see the file COPYING. If not, write to the Free
	Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
	02110-1301, USA. */


	/* Middle-to-low level generation of rtx code and insns.

	This file contains support functions for creating rtl expressions
	and manipulating them in the doubly-linked chain of insns.

	The patterns of the insns are created by machine-dependent
	routines in insn-emit.c, which is generated automatically from
	the machine description. These routines make the individual rtx's
	of the pattern with `gen_rtx_fmt_ee' and others in genrtl.[ch],
	which are automatically generated from rtl.def; what is machine
	dependent is the kind of rtx's they make and what arguments they
	use. */

	#include "config.h"
	#include "system.h"
	#include "coretypes.h"
	#include "tm.h"
	#include "toplev.h"
	#include "rtl.h"
	#include "tree.h"
	#include "tm_p.h"
	#include "flags.h"
	#include "function.h"
	#include "expr.h"
	#include "regs.h"
	#include "hard-reg-set.h"
	#include "hashtab.h"
	#include "insn-config.h"
	#include "recog.h"
	#include "real.h"
	#include "bitmap.h"
	#include "basic-block.h"
	#include "ggc.h"
	#include "debug.h"
	#include "langhooks.h"
	#include "tree-pass.h"

	/* Commonly used modes. */

	enum machine_mode byte_mode; /* Mode whose width is BITS_PER_UNIT. */
	enum machine_mode word_mode; /* Mode whose width is BITS_PER_WORD. */
	enum machine_mode double_mode; /* Mode whose width is DOUBLE_TYPE_SIZE. */
	enum machine_mode ptr_mode; /* Mode whose width is POINTER_SIZE. */


	/* This is not reset after each function. It gives each CODE_LABEL
	in the entire compilation a unique label number. */

	static GTY(()) int label_num = 1;

	/* Nonzero means do not generate NOTEs for source line numbers. */

	static int no_line_numbers;

	/* Commonly used rtx's, so that we only need space for one copy.
	These are initialized once for the entire compilation.
	All of these are unique; no other rtx-object will be equal to any
	of these. */

	rtx global_rtl[GR_MAX];

	/* Commonly used RTL for hard registers. These objects are not necessarily
	unique, so we allocate them separately from global_rtl. They are
	initialized once per compilation unit, then copied into regno_reg_rtx
	at the beginning of each function. */
	static GTY(()) rtx static_regno_reg_rtx[FIRST_PSEUDO_REGISTER];

	/* We record floating-point CONST_DOUBLEs in each floating-point mode for
	the values of 0, 1, and 2. For the integer entries and VOIDmode, we
	record a copy of const[012]_rtx. */

	rtx const_tiny_rtx[3][(int) MAX_MACHINE_MODE];

	rtx const_true_rtx;

	REAL_VALUE_TYPE dconst0;
	REAL_VALUE_TYPE dconst1;
	REAL_VALUE_TYPE dconst2;
	REAL_VALUE_TYPE dconst3;
	REAL_VALUE_TYPE dconst10;
	REAL_VALUE_TYPE dconstm1;
	REAL_VALUE_TYPE dconstm2;
	REAL_VALUE_TYPE dconsthalf;
	REAL_VALUE_TYPE dconstthird;
	REAL_VALUE_TYPE dconstpi;
	REAL_VALUE_TYPE dconste;

	/* All references to the following fixed hard registers go through
	these unique rtl objects. On machines where the frame-pointer and
	arg-pointer are the same register, they use the same unique object.

	After register allocation, other rtl objects which used to be pseudo-regs
	may be clobbered to refer to the frame-pointer register.
	But references that were originally to the frame-pointer can be
	distinguished from the others because they contain frame_pointer_rtx.

	When to use frame_pointer_rtx and hard_frame_pointer_rtx is a little
	tricky: until register elimination has taken place hard_frame_pointer_rtx
	should be used if it is being set, and frame_pointer_rtx otherwise. After
	register elimination hard_frame_pointer_rtx should always be used.
	On machines where the two registers are same (most) then these are the
	same.

	In an inline procedure, the stack and frame pointer rtxs may not be
	used for anything else. */
	rtx static_chain_rtx; /* (REG:Pmode STATIC_CHAIN_REGNUM) */
	rtx static_chain_incoming_rtx; /* (REG:Pmode STATIC_CHAIN_INCOMING_REGNUM) */
	rtx pic_offset_table_rtx; /* (REG:Pmode PIC_OFFSET_TABLE_REGNUM) */

	/* This is used to implement __builtin_return_address for some machines.
	See for instance the MIPS port. */
	rtx return_address_pointer_rtx; /* (REG:Pmode RETURN_ADDRESS_POINTER_REGNUM) */

	/* We make one copy of (const_int C) where C is in
	[- MAX_SAVED_CONST_INT, MAX_SAVED_CONST_INT]
	to save space during the compilation and simplify comparisons of
	integers. */

	rtx const_int_rtx[MAX_SAVED_CONST_INT * 2 + 1];

	/* A hash table storing CONST_INTs whose absolute value is greater
	than MAX_SAVED_CONST_INT. */

	static GTY ((if_marked ("ggc_marked_p"), param_is (struct rtx_def)))
	htab_t const_int_htab;

	/* A hash table storing memory attribute structures. */
	static GTY ((if_marked ("ggc_marked_p"), param_is (struct mem_attrs)))
	htab_t mem_attrs_htab;

	/* A hash table storing register attribute structures. */
	static GTY ((if_marked ("ggc_marked_p"), param_is (struct reg_attrs)))
	htab_t reg_attrs_htab;

	/* A hash table storing all CONST_DOUBLEs. */
	static GTY ((if_marked ("ggc_marked_p"), param_is (struct rtx_def)))
	htab_t const_double_htab;

	#define first_insn (cfun->emit->x_first_insn)
	#define last_insn (cfun->emit->x_last_insn)
	#define cur_insn_uid (cfun->emit->x_cur_insn_uid)
	#define last_location (cfun->emit->x_last_location)
	#define first_label_num (cfun->emit->x_first_label_num)

	static rtx make_call_insn_raw (rtx);
	static rtx find_line_note (rtx);
	static rtx change_address_1 (rtx, enum machine_mode, rtx, int);
	static void unshare_all_decls (tree);
	static void reset_used_decls (tree);
	static void mark_label_nuses (rtx);
	static hashval_t const_int_htab_hash (const void *);
	static int const_int_htab_eq (const void , const void );
	static hashval_t const_double_htab_hash (const void *);
	static int const_double_htab_eq (const void , const void );
	static rtx lookup_const_double (rtx);
	static hashval_t mem_attrs_htab_hash (const void *);
	static int mem_attrs_htab_eq (const void , const void );
	static mem_attrs *get_mem_attrs (HOST_WIDE_INT, tree, rtx, rtx, unsigned int,
	enum machine_mode);
	static hashval_t reg_attrs_htab_hash (const void *);
	static int reg_attrs_htab_eq (const void , const void );
	static reg_attrs *get_reg_attrs (tree, int);
	static tree component_ref_for_mem_expr (tree);
	static rtx gen_const_vector (enum machine_mode, int);
	static void copy_rtx_if_shared_1 (rtx *orig);

	/* Probability of the conditional branch currently proceeded by try_split.
	Set to -1 otherwise. */
	int split_branch_probability = -1;

	/* Returns a hash code for X (which is a really a CONST_INT). */

	static hashval_t
	const_int_htab_hash (const void *x)
	{
	return (hashval_t) INTVAL ((rtx) x);
	}

	/* Returns nonzero if the value represented by X (which is really a
	CONST_INT) is the same as that given by Y (which is really a
	HOST_WIDE_INT ). /

	static int
	const_int_htab_eq (const void x, const void y)
	{
	return (INTVAL ((rtx) x) == ((const HOST_WIDE_INT ) y));
	}

	/* Returns a hash code for X (which is really a CONST_DOUBLE). */
	static hashval_t
	const_double_htab_hash (const void *x)
	{
	rtx value = (rtx) x;
	hashval_t h;

	if (GET_MODE (value) == VOIDmode)
	h = CONST_DOUBLE_LOW (value) ^ CONST_DOUBLE_HIGH (value);
	else
	{
	h = real_hash (CONST_DOUBLE_REAL_VALUE (value));
	/* MODE is used in the comparison, so it should be in the hash. */
	h ^= GET_MODE (value);
	}
	return h;
	}

	/* Returns nonzero if the value represented by X (really a ...)
	is the same as that represented by Y (really a ...) */
	static int
	const_double_htab_eq (const void x, const void y)
	{
	rtx a = (rtx)x, b = (rtx)y;

	if (GET_MODE (a) != GET_MODE (b))
	return 0;
	if (GET_MODE (a) == VOIDmode)
	return (CONST_DOUBLE_LOW (a) == CONST_DOUBLE_LOW (b)
	&& CONST_DOUBLE_HIGH (a) == CONST_DOUBLE_HIGH (b));
	else
	return real_identical (CONST_DOUBLE_REAL_VALUE (a),
	CONST_DOUBLE_REAL_VALUE (b));
	}

	/* Returns a hash code for X (which is a really a mem_attrs ). /

	static hashval_t
	mem_attrs_htab_hash (const void *x)
	{
	mem_attrs p = (mem_attrs ) x;

	return (p->alias ^ (p->align * 1000)
	^ ((p->offset ? INTVAL (p->offset) : 0) * 50000)
	^ ((p->size ? INTVAL (p->size) : 0) * 2500000)
	^ (size_t) iterative_hash_expr (p->expr, 0));
	}

	/* Returns nonzero if the value represented by X (which is really a
	mem_attrs *) is the same as that given by Y (which is also really a
	mem_attrs ). /

	static int
	mem_attrs_htab_eq (const void x, const void y)
	{
	mem_attrs p = (mem_attrs ) x;
	mem_attrs q = (mem_attrs ) y;

	return (p->alias == q->alias && p->offset == q->offset
	&& p->size == q->size && p->align == q->align
	&& (p->expr == q->expr
	\|\| (p->expr != NULL_TREE && q->expr != NULL_TREE
	&& operand_equal_p (p->expr, q->expr, 0))));
	}

	/* Allocate a new mem_attrs structure and insert it into the hash table if
	one identical to it is not already in the table. We are doing this for
	MEM of mode MODE. */

	static mem_attrs *
	get_mem_attrs (HOST_WIDE_INT alias, tree expr, rtx offset, rtx size,
	unsigned int align, enum machine_mode mode)
	{
	mem_attrs attrs;
	void **slot;

	/* If everything is the default, we can just return zero.
	This must match what the corresponding MEM_* macros return when the
	field is not present. */
	if (alias == 0 && expr == 0 && offset == 0
	&& (size == 0
	\|\| (mode != BLKmode && GET_MODE_SIZE (mode) == INTVAL (size)))
	&& (STRICT_ALIGNMENT && mode != BLKmode
	? align == GET_MODE_ALIGNMENT (mode) : align == BITS_PER_UNIT))
	return 0;

	attrs.alias = alias;
	attrs.expr = expr;
	attrs.offset = offset;
	attrs.size = size;
	attrs.align = align;

	slot = htab_find_slot (mem_attrs_htab, &attrs, INSERT);
	if (*slot == 0)
	{
	*slot = ggc_alloc (sizeof (mem_attrs));
	memcpy (*slot, &attrs, sizeof (mem_attrs));
	}

	return *slot;
	}

	/* Returns a hash code for X (which is a really a reg_attrs ). /

	static hashval_t
	reg_attrs_htab_hash (const void *x)
	{
	reg_attrs p = (reg_attrs ) x;

	return ((p->offset * 1000) ^ (long) p->decl);
	}

	/* Returns nonzero if the value represented by X (which is really a
	reg_attrs *) is the same as that given by Y (which is also really a
	reg_attrs ). /

	static int
	reg_attrs_htab_eq (const void x, const void y)
	{
	reg_attrs p = (reg_attrs ) x;
	reg_attrs q = (reg_attrs ) y;

	return (p->decl == q->decl && p->offset == q->offset);
	}
	/* Allocate a new reg_attrs structure and insert it into the hash table if
	one identical to it is not already in the table. We are doing this for
	MEM of mode MODE. */

	static reg_attrs *
	get_reg_attrs (tree decl, int offset)
	{
	reg_attrs attrs;
	void **slot;

	/* If everything is the default, we can just return zero. */
	if (decl == 0 && offset == 0)
	return 0;

	attrs.decl = decl;
	attrs.offset = offset;

	slot = htab_find_slot (reg_attrs_htab, &attrs, INSERT);
	if (*slot == 0)
	{
	*slot = ggc_alloc (sizeof (reg_attrs));
	memcpy (*slot, &attrs, sizeof (reg_attrs));
	}

	return *slot;
	}

	/* Generate a new REG rtx. Make sure ORIGINAL_REGNO is set properly, and
	don't attempt to share with the various global pieces of rtl (such as
	frame_pointer_rtx). */

	rtx
	gen_raw_REG (enum machine_mode mode, int regno)
	{
	rtx x = gen_rtx_raw_REG (mode, regno);
	ORIGINAL_REGNO (x) = regno;
	return x;
	}

	/* There are some RTL codes that require special attention; the generation
	functions do the raw handling. If you add to this list, modify
	special_rtx in gengenrtl.c as well. */

	rtx
	gen_rtx_CONST_INT (enum machine_mode mode ATTRIBUTE_UNUSED, HOST_WIDE_INT arg)
	{
	void **slot;

	if (arg >= - MAX_SAVED_CONST_INT && arg <= MAX_SAVED_CONST_INT)
	return const_int_rtx[arg + MAX_SAVED_CONST_INT];

	#if STORE_FLAG_VALUE != 1 && STORE_FLAG_VALUE != -1
	if (const_true_rtx && arg == STORE_FLAG_VALUE)
	return const_true_rtx;
	#endif

	/* Look up the CONST_INT in the hash table. */
	slot = htab_find_slot_with_hash (const_int_htab, &arg,
	(hashval_t) arg, INSERT);
	if (*slot == 0)
	*slot = gen_rtx_raw_CONST_INT (VOIDmode, arg);

	return (rtx) *slot;
	}

	rtx
	gen_int_mode (HOST_WIDE_INT c, enum machine_mode mode)
	{
	return GEN_INT (trunc_int_for_mode (c, mode));
	}

	/* CONST_DOUBLEs might be created from pairs of integers, or from
	REAL_VALUE_TYPEs. Also, their length is known only at run time,
	so we cannot use gen_rtx_raw_CONST_DOUBLE. */

	/* Determine whether REAL, a CONST_DOUBLE, already exists in the
	hash table. If so, return its counterpart; otherwise add it
	to the hash table and return it. */
	static rtx
	lookup_const_double (rtx real)
	{
	void **slot = htab_find_slot (const_double_htab, real, INSERT);
	if (*slot == 0)
	*slot = real;

	return (rtx) *slot;
	}

	/* Return a CONST_DOUBLE rtx for a floating-point value specified by
	VALUE in mode MODE. */
	rtx
	const_double_from_real_value (REAL_VALUE_TYPE value, enum machine_mode mode)
	{
	rtx real = rtx_alloc (CONST_DOUBLE);
	PUT_MODE (real, mode);

	real->u.rv = value;

	return lookup_const_double (real);
	}

	/* Return a CONST_DOUBLE or CONST_INT for a value specified as a pair
	of ints: I0 is the low-order word and I1 is the high-order word.
	Do not use this routine for non-integer modes; convert to
	REAL_VALUE_TYPE and use CONST_DOUBLE_FROM_REAL_VALUE. */

	rtx
	immed_double_const (HOST_WIDE_INT i0, HOST_WIDE_INT i1, enum machine_mode mode)
	{
	rtx value;
	unsigned int i;

	/* There are the following cases (note that there are no modes with
	HOST_BITS_PER_WIDE_INT < GET_MODE_BITSIZE (mode) < 2 * HOST_BITS_PER_WIDE_INT):

	1) If GET_MODE_BITSIZE (mode) <= HOST_BITS_PER_WIDE_INT, then we use
	gen_int_mode.
	2) GET_MODE_BITSIZE (mode) == 2 * HOST_BITS_PER_WIDE_INT, but the value of
	the integer fits into HOST_WIDE_INT anyway (i.e., i1 consists only
	from copies of the sign bit, and sign of i0 and i1 are the same), then
	we return a CONST_INT for i0.
	3) Otherwise, we create a CONST_DOUBLE for i0 and i1. */
	if (mode != VOIDmode)
	{
	gcc_assert (GET_MODE_CLASS (mode) == MODE_INT
	\|\| GET_MODE_CLASS (mode) == MODE_PARTIAL_INT
	/* We can get a 0 for an error mark. */
	\|\| GET_MODE_CLASS (mode) == MODE_VECTOR_INT
	\|\| GET_MODE_CLASS (mode) == MODE_VECTOR_FLOAT);

	if (GET_MODE_BITSIZE (mode) <= HOST_BITS_PER_WIDE_INT)
	return gen_int_mode (i0, mode);

	gcc_assert (GET_MODE_BITSIZE (mode) == 2 * HOST_BITS_PER_WIDE_INT);
	}

	/* If this integer fits in one word, return a CONST_INT. */
	if ((i1 == 0 && i0 >= 0) \|\| (i1 == ~0 && i0 < 0))
	return GEN_INT (i0);

	/* We use VOIDmode for integers. */
	value = rtx_alloc (CONST_DOUBLE);
	PUT_MODE (value, VOIDmode);

	CONST_DOUBLE_LOW (value) = i0;
	CONST_DOUBLE_HIGH (value) = i1;

	for (i = 2; i < (sizeof CONST_DOUBLE_FORMAT - 1); i++)
	XWINT (value, i) = 0;

	return lookup_const_double (value);
	}

	rtx
	gen_rtx_REG (enum machine_mode mode, unsigned int regno)
	{
	/* In case the MD file explicitly references the frame pointer, have
	all such references point to the same frame pointer. This is
	used during frame pointer elimination to distinguish the explicit
	references to these registers from pseudos that happened to be
	assigned to them.

	If we have eliminated the frame pointer or arg pointer, we will
	be using it as a normal register, for example as a spill
	register. In such cases, we might be accessing it in a mode that
	is not Pmode and therefore cannot use the pre-allocated rtx.

	Also don't do this when we are making new REGs in reload, since
	we don't want to get confused with the real pointers. */

	if (mode == Pmode && !reload_in_progress)
	{
	if (regno == FRAME_POINTER_REGNUM
	&& (!reload_completed \|\| frame_pointer_needed))
	return frame_pointer_rtx;
	#if FRAME_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM
	if (regno == HARD_FRAME_POINTER_REGNUM
	&& (!reload_completed \|\| frame_pointer_needed))
	return hard_frame_pointer_rtx;
	#endif
	#if FRAME_POINTER_REGNUM != ARG_POINTER_REGNUM && HARD_FRAME_POINTER_REGNUM != ARG_POINTER_REGNUM
	if (regno == ARG_POINTER_REGNUM)
	return arg_pointer_rtx;
	#endif
	#ifdef RETURN_ADDRESS_POINTER_REGNUM
	if (regno == RETURN_ADDRESS_POINTER_REGNUM)
	return return_address_pointer_rtx;
	#endif
	if (regno == (unsigned) PIC_OFFSET_TABLE_REGNUM
	&& fixed_regs[PIC_OFFSET_TABLE_REGNUM])
	return pic_offset_table_rtx;
	if (regno == STACK_POINTER_REGNUM)
	return stack_pointer_rtx;
	}

	#if 0
	/* If the per-function register table has been set up, try to re-use
	an existing entry in that table to avoid useless generation of RTL.

	This code is disabled for now until we can fix the various backends
	which depend on having non-shared hard registers in some cases. Long
	term we want to re-enable this code as it can significantly cut down
	on the amount of useless RTL that gets generated.

	We'll also need to fix some code that runs after reload that wants to
	set ORIGINAL_REGNO. */

	if (cfun
	&& cfun->emit
	&& regno_reg_rtx
	&& regno < FIRST_PSEUDO_REGISTER
	&& reg_raw_mode[regno] == mode)
	return regno_reg_rtx[regno];
	#endif

	return gen_raw_REG (mode, regno);
	}

	rtx
	gen_rtx_MEM (enum machine_mode mode, rtx addr)
	{
	rtx rt = gen_rtx_raw_MEM (mode, addr);

	/* This field is not cleared by the mere allocation of the rtx, so
	we clear it here. */
	MEM_ATTRS (rt) = 0;

	return rt;
	}

	/* Generate a memory referring to non-trapping constant memory. */

	rtx
	gen_const_mem (enum machine_mode mode, rtx addr)
	{
	rtx mem = gen_rtx_MEM (mode, addr);
	MEM_READONLY_P (mem) = 1;
	MEM_NOTRAP_P (mem) = 1;
	return mem;
	}

	/* Generate a MEM referring to fixed portions of the frame, e.g., register
	save areas. */

	rtx
	gen_frame_mem (enum machine_mode mode, rtx addr)
	{
	rtx mem = gen_rtx_MEM (mode, addr);
	MEM_NOTRAP_P (mem) = 1;
	set_mem_alias_set (mem, get_frame_alias_set ());
	return mem;
	}

	/* Generate a MEM referring to a temporary use of the stack, not part
	of the fixed stack frame. For example, something which is pushed
	by a target splitter. */
	rtx
	gen_tmp_stack_mem (enum machine_mode mode, rtx addr)
	{
	rtx mem = gen_rtx_MEM (mode, addr);
	MEM_NOTRAP_P (mem) = 1;
	if (!current_function_calls_alloca)
	set_mem_alias_set (mem, get_frame_alias_set ());
	return mem;
	}

	/* We want to create (subreg:OMODE (obj:IMODE) OFFSET). Return true if
	this construct would be valid, and false otherwise. */

	bool
	validate_subreg (enum machine_mode omode, enum machine_mode imode,
	rtx reg, unsigned int offset)
	{
	unsigned int isize = GET_MODE_SIZE (imode);
	unsigned int osize = GET_MODE_SIZE (omode);

	/* All subregs must be aligned. */
	if (offset % osize != 0)
	return false;

	/* The subreg offset cannot be outside the inner object. */
	if (offset >= isize)
	return false;

	/* ??? This should not be here. Temporarily continue to allow word_mode
	subregs of anything. The most common offender is (subreg:SI (reg:DF)).
	Generally, backends are doing something sketchy but it'll take time to
	fix them all. */
	if (omode == word_mode)
	;
	/* ??? Similarly, e.g. with (subreg:DF (reg:TI)). Though store_bit_field
	is the culprit here, and not the backends. */
	else if (osize >= UNITS_PER_WORD && isize >= osize)
	;
	/* Allow component subregs of complex and vector. Though given the below
	extraction rules, it's not always clear what that means. */
	else if ((COMPLEX_MODE_P (imode) \|\| VECTOR_MODE_P (imode))
	&& GET_MODE_INNER (imode) == omode)
	;
	/* ??? x86 sse code makes heavy use of paradoxical vector subregs,
	i.e. (subreg:V4SF (reg:SF) 0). This surely isn't the cleanest way to
	represent this. It's questionable if this ought to be represented at
	all -- why can't this all be hidden in post-reload splitters that make
	arbitrarily mode changes to the registers themselves. */
	else if (VECTOR_MODE_P (omode) && GET_MODE_INNER (omode) == imode)
	;
	/* Subregs involving floating point modes are not allowed to
	change size. Therefore (subreg:DI (reg:DF) 0) is fine, but
	(subreg:SI (reg:DF) 0) isn't. */
	else if (FLOAT_MODE_P (imode) \|\| FLOAT_MODE_P (omode))
	{
	if (isize != osize)
	return false;
	}

	/* Paradoxical subregs must have offset zero. */
	if (osize > isize)
	return offset == 0;

	/* This is a normal subreg. Verify that the offset is representable. */

	/* For hard registers, we already have most of these rules collected in
	subreg_offset_representable_p. */
	if (reg && REG_P (reg) && HARD_REGISTER_P (reg))
	{
	unsigned int regno = REGNO (reg);

	#ifdef CANNOT_CHANGE_MODE_CLASS
	if ((COMPLEX_MODE_P (imode) \|\| VECTOR_MODE_P (imode))
	&& GET_MODE_INNER (imode) == omode)
	;
	else if (REG_CANNOT_CHANGE_MODE_P (regno, imode, omode))
	return false;
	#endif

	return subreg_offset_representable_p (regno, imode, offset, omode);
	}

	/* For pseudo registers, we want most of the same checks. Namely:
	If the register no larger than a word, the subreg must be lowpart.
	If the register is larger than a word, the subreg must be the lowpart
	of a subword. A subreg does not perform arbitrary bit extraction.
	Given that we've already checked mode/offset alignment, we only have
	to check subword subregs here. */
	if (osize < UNITS_PER_WORD)
	{
	enum machine_mode wmode = isize > UNITS_PER_WORD ? word_mode : imode;
	unsigned int low_off = subreg_lowpart_offset (omode, wmode);
	if (offset % UNITS_PER_WORD != low_off)
	return false;
	}
	return true;
	}

	rtx
	gen_rtx_SUBREG (enum machine_mode mode, rtx reg, int offset)
	{
	gcc_assert (validate_subreg (mode, GET_MODE (reg), reg, offset));
	return gen_rtx_raw_SUBREG (mode, reg, offset);
	}

	/* Generate a SUBREG representing the least-significant part of REG if MODE
	is smaller than mode of REG, otherwise paradoxical SUBREG. */

	rtx
	gen_lowpart_SUBREG (enum machine_mode mode, rtx reg)
	{
	enum machine_mode inmode;

	inmode = GET_MODE (reg);
	if (inmode == VOIDmode)
	inmode = mode;
	return gen_rtx_SUBREG (mode, reg,
	subreg_lowpart_offset (mode, inmode));
	}

	/* gen_rtvec (n, [rt1, ..., rtn])
	**
	** This routine creates an rtvec and stores within it the
	** pointers to rtx's which are its arguments.
	*/

	/VARARGS1/
	rtvec
	gen_rtvec (int n, ...)
	{
	int i, save_n;
	rtx *vector;
	va_list p;

	va_start (p, n);

	if (n == 0)
	return NULL_RTVEC; /* Don't allocate an empty rtvec... */

	vector = alloca (n * sizeof (rtx));

	for (i = 0; i < n; i++)
	vector[i] = va_arg (p, rtx);

	/* The definition of VA_* in K&R C causes `n' to go out of scope. */
	save_n = n;
	va_end (p);

	return gen_rtvec_v (save_n, vector);
	}

	rtvec
	gen_rtvec_v (int n, rtx *argp)
	{
	int i;
	rtvec rt_val;

	if (n == 0)
	return NULL_RTVEC; /* Don't allocate an empty rtvec... */

	rt_val = rtvec_alloc (n); /* Allocate an rtvec... */

	for (i = 0; i < n; i++)
	rt_val->elem[i] = *argp++;

	return rt_val;
	}

	/* Generate a REG rtx for a new pseudo register of mode MODE.
	This pseudo is assigned the next sequential register number. */

	rtx
	gen_reg_rtx (enum machine_mode mode)
	{
	struct function *f = cfun;
	rtx val;

	/* Don't let anything called after initial flow analysis create new
	registers. */
	gcc_assert (!no_new_pseudos);

	if (generating_concat_p
	&& (GET_MODE_CLASS (mode) == MODE_COMPLEX_FLOAT
	\|\| GET_MODE_CLASS (mode) == MODE_COMPLEX_INT))
	{
	/* For complex modes, don't make a single pseudo.
	Instead, make a CONCAT of two pseudos.
	This allows noncontiguous allocation of the real and imaginary parts,
	which makes much better code. Besides, allocating DCmode
	pseudos overstrains reload on some machines like the 386. */
	rtx realpart, imagpart;
	enum machine_mode partmode = GET_MODE_INNER (mode);

	realpart = gen_reg_rtx (partmode);
	imagpart = gen_reg_rtx (partmode);
	return gen_rtx_CONCAT (mode, realpart, imagpart);
	}

	/* Make sure regno_pointer_align, and regno_reg_rtx are large
	enough to have an element for this pseudo reg number. */

	if (reg_rtx_no == f->emit->regno_pointer_align_length)
	{
	int old_size = f->emit->regno_pointer_align_length;
	char *new;
	rtx *new1;

	new = ggc_realloc (f->emit->regno_pointer_align, old_size * 2);
	memset (new + old_size, 0, old_size);
	f->emit->regno_pointer_align = (unsigned char *) new;

	new1 = ggc_realloc (f->emit->x_regno_reg_rtx,
	old_size * 2 * sizeof (rtx));
	memset (new1 + old_size, 0, old_size * sizeof (rtx));
	regno_reg_rtx = new1;

	f->emit->regno_pointer_align_length = old_size * 2;
	}

	val = gen_raw_REG (mode, reg_rtx_no);
	regno_reg_rtx[reg_rtx_no++] = val;
	return val;
	}

	/* Generate a register with same attributes as REG, but offsetted by OFFSET.
	Do the big endian correction if needed. */

	rtx
	gen_rtx_REG_offset (rtx reg, enum machine_mode mode, unsigned int regno, int offset)
	{
	rtx new = gen_rtx_REG (mode, regno);
	tree decl;
	HOST_WIDE_INT var_size;

	/* PR middle-end/14084
	The problem appears when a variable is stored in a larger register
	and later it is used in the original mode or some mode in between
	or some part of variable is accessed.

	On little endian machines there is no problem because
	the REG_OFFSET of the start of the variable is the same when
	accessed in any mode (it is 0).

	However, this is not true on big endian machines.
	The offset of the start of the variable is different when accessed
	in different modes.
	When we are taking a part of the REG we have to change the OFFSET
	from offset WRT size of mode of REG to offset WRT size of variable.

	If we would not do the big endian correction the resulting REG_OFFSET
	would be larger than the size of the DECL.

	Examples of correction, for BYTES_BIG_ENDIAN WORDS_BIG_ENDIAN machine:

	REG.mode MODE DECL size old offset new offset description
	DI SI 4 4 0 int32 in SImode
	DI SI 1 4 0 char in SImode
	DI QI 1 7 0 char in QImode
	DI QI 4 5 1 1st element in QImode
	of char[4]
	DI HI 4 6 2 1st element in HImode
	of int16[2]

	If the size of DECL is equal or greater than the size of REG
	we can't do this correction because the register holds the
	whole variable or a part of the variable and thus the REG_OFFSET
	is already correct. */

	decl = REG_EXPR (reg);
	if ((BYTES_BIG_ENDIAN \|\| WORDS_BIG_ENDIAN)
	&& decl != NULL
	&& offset > 0
	&& GET_MODE_SIZE (GET_MODE (reg)) > GET_MODE_SIZE (mode)
	&& ((var_size = int_size_in_bytes (TREE_TYPE (decl))) > 0
	&& var_size < GET_MODE_SIZE (GET_MODE (reg))))
	{
	int offset_le;

	/* Convert machine endian to little endian WRT size of mode of REG. */
	if (WORDS_BIG_ENDIAN)
	offset_le = ((GET_MODE_SIZE (GET_MODE (reg)) - 1 - offset)
	/ UNITS_PER_WORD) * UNITS_PER_WORD;
	else
	offset_le = (offset / UNITS_PER_WORD) * UNITS_PER_WORD;

	if (BYTES_BIG_ENDIAN)
	offset_le += ((GET_MODE_SIZE (GET_MODE (reg)) - 1 - offset)
	% UNITS_PER_WORD);
	else
	offset_le += offset % UNITS_PER_WORD;

	if (offset_le >= var_size)
	{
	/* MODE is wider than the variable so the new reg will cover
	the whole variable so the resulting OFFSET should be 0. */
	offset = 0;
	}
	else
	{
	/* Convert little endian to machine endian WRT size of variable. */
	if (WORDS_BIG_ENDIAN)
	offset = ((var_size - 1 - offset_le)
	/ UNITS_PER_WORD) * UNITS_PER_WORD;
	else
	offset = (offset_le / UNITS_PER_WORD) * UNITS_PER_WORD;

	if (BYTES_BIG_ENDIAN)
	offset += ((var_size - 1 - offset_le)
	% UNITS_PER_WORD);
	else
	offset += offset_le % UNITS_PER_WORD;
	}
	}

	REG_ATTRS (new) = get_reg_attrs (REG_EXPR (reg),
	REG_OFFSET (reg) + offset);
	return new;
	}

	/* Set the decl for MEM to DECL. */

	void
	set_reg_attrs_from_mem (rtx reg, rtx mem)
	{
	if (MEM_OFFSET (mem) && GET_CODE (MEM_OFFSET (mem)) == CONST_INT)
	REG_ATTRS (reg)
	= get_reg_attrs (MEM_EXPR (mem), INTVAL (MEM_OFFSET (mem)));
	}

	/* Set the register attributes for registers contained in PARM_RTX.
	Use needed values from memory attributes of MEM. */

	void
	set_reg_attrs_for_parm (rtx parm_rtx, rtx mem)
	{
	if (REG_P (parm_rtx))
	set_reg_attrs_from_mem (parm_rtx, mem);
	else if (GET_CODE (parm_rtx) == PARALLEL)
	{
	/* Check for a NULL entry in the first slot, used to indicate that the
	parameter goes both on the stack and in registers. */
	int i = XEXP (XVECEXP (parm_rtx, 0, 0), 0) ? 0 : 1;
	for (; i < XVECLEN (parm_rtx, 0); i++)
	{
	rtx x = XVECEXP (parm_rtx, 0, i);
	if (REG_P (XEXP (x, 0)))
	REG_ATTRS (XEXP (x, 0))
	= get_reg_attrs (MEM_EXPR (mem),
	INTVAL (XEXP (x, 1)));
	}
	}
	}

	/* Assign the RTX X to declaration T. */
	void
	set_decl_rtl (tree t, rtx x)
	{
	DECL_WRTL_CHECK (t)->decl_with_rtl.rtl = x;

	if (!x)
	return;
	/* For register, we maintain the reverse information too. */
	if (REG_P (x))
	REG_ATTRS (x) = get_reg_attrs (t, 0);
	else if (GET_CODE (x) == SUBREG)
	REG_ATTRS (SUBREG_REG (x))
	= get_reg_attrs (t, -SUBREG_BYTE (x));
	if (GET_CODE (x) == CONCAT)
	{
	if (REG_P (XEXP (x, 0)))
	REG_ATTRS (XEXP (x, 0)) = get_reg_attrs (t, 0);
	if (REG_P (XEXP (x, 1)))
	REG_ATTRS (XEXP (x, 1))
	= get_reg_attrs (t, GET_MODE_UNIT_SIZE (GET_MODE (XEXP (x, 0))));
	}
	if (GET_CODE (x) == PARALLEL)
	{
	int i;
	for (i = 0; i < XVECLEN (x, 0); i++)
	{
	rtx y = XVECEXP (x, 0, i);
	if (REG_P (XEXP (y, 0)))
	REG_ATTRS (XEXP (y, 0)) = get_reg_attrs (t, INTVAL (XEXP (y, 1)));
	}
	}
	}

	/* Assign the RTX X to parameter declaration T. */
	void
	set_decl_incoming_rtl (tree t, rtx x)
	{
	DECL_INCOMING_RTL (t) = x;

	if (!x)
	return;
	/* For register, we maintain the reverse information too. */
	if (REG_P (x))
	REG_ATTRS (x) = get_reg_attrs (t, 0);
	else if (GET_CODE (x) == SUBREG)
	REG_ATTRS (SUBREG_REG (x))
	= get_reg_attrs (t, -SUBREG_BYTE (x));
	if (GET_CODE (x) == CONCAT)
	{
	if (REG_P (XEXP (x, 0)))
	REG_ATTRS (XEXP (x, 0)) = get_reg_attrs (t, 0);
	if (REG_P (XEXP (x, 1)))
	REG_ATTRS (XEXP (x, 1))
	= get_reg_attrs (t, GET_MODE_UNIT_SIZE (GET_MODE (XEXP (x, 0))));
	}
	if (GET_CODE (x) == PARALLEL)
	{
	int i, start;

	/* Check for a NULL entry, used to indicate that the parameter goes
	both on the stack and in registers. */
	if (XEXP (XVECEXP (x, 0, 0), 0))
	start = 0;
	else
	start = 1;

	for (i = start; i < XVECLEN (x, 0); i++)
	{
	rtx y = XVECEXP (x, 0, i);
	if (REG_P (XEXP (y, 0)))
	REG_ATTRS (XEXP (y, 0)) = get_reg_attrs (t, INTVAL (XEXP (y, 1)));
	}
	}
	}

	/* Identify REG (which may be a CONCAT) as a user register. */

	void
	mark_user_reg (rtx reg)
	{
	if (GET_CODE (reg) == CONCAT)
	{
	REG_USERVAR_P (XEXP (reg, 0)) = 1;
	REG_USERVAR_P (XEXP (reg, 1)) = 1;
	}
	else
	{
	gcc_assert (REG_P (reg));
	REG_USERVAR_P (reg) = 1;
	}
	}

	/* Identify REG as a probable pointer register and show its alignment
	as ALIGN, if nonzero. */

	void
	mark_reg_pointer (rtx reg, int align)
	{
	if (! REG_POINTER (reg))
	{
	REG_POINTER (reg) = 1;

	if (align)
	REGNO_POINTER_ALIGN (REGNO (reg)) = align;
	}
	else if (align && align < REGNO_POINTER_ALIGN (REGNO (reg)))
	/* We can no-longer be sure just how aligned this pointer is. */
	REGNO_POINTER_ALIGN (REGNO (reg)) = align;
	}

	/* Return 1 plus largest pseudo reg number used in the current function. */

	int
	max_reg_num (void)
	{
	return reg_rtx_no;
	}

	/* Return 1 + the largest label number used so far in the current function. */

	int
	max_label_num (void)
	{
	return label_num;
	}

	/* Return first label number used in this function (if any were used). */

	int
	get_first_label_num (void)
	{
	return first_label_num;
	}

	/* If the rtx for label was created during the expansion of a nested
	function, then first_label_num won't include this label number.
	Fix this now so that array indicies work later. */

	void
	maybe_set_first_label_num (rtx x)
	{
	if (CODE_LABEL_NUMBER (x) < first_label_num)
	first_label_num = CODE_LABEL_NUMBER (x);
	}

	/* Return a value representing some low-order bits of X, where the number
	of low-order bits is given by MODE. Note that no conversion is done
	between floating-point and fixed-point values, rather, the bit
	representation is returned.

	This function handles the cases in common between gen_lowpart, below,
	and two variants in cse.c and combine.c. These are the cases that can
	be safely handled at all points in the compilation.

	If this is not a case we can handle, return 0. */

	rtx
	gen_lowpart_common (enum machine_mode mode, rtx x)
	{
	int msize = GET_MODE_SIZE (mode);
	int xsize;
	int offset = 0;
	enum machine_mode innermode;

	/* Unfortunately, this routine doesn't take a parameter for the mode of X,
	so we have to make one up. Yuk. */
	innermode = GET_MODE (x);
	if (GET_CODE (x) == CONST_INT
	&& msize * BITS_PER_UNIT <= HOST_BITS_PER_WIDE_INT)
	innermode = mode_for_size (HOST_BITS_PER_WIDE_INT, MODE_INT, 0);
	else if (innermode == VOIDmode)
	innermode = mode_for_size (HOST_BITS_PER_WIDE_INT * 2, MODE_INT, 0);

	xsize = GET_MODE_SIZE (innermode);

	gcc_assert (innermode != VOIDmode && innermode != BLKmode);

	if (innermode == mode)
	return x;

	/* MODE must occupy no more words than the mode of X. */
	if ((msize + (UNITS_PER_WORD - 1)) / UNITS_PER_WORD
	> ((xsize + (UNITS_PER_WORD - 1)) / UNITS_PER_WORD))
	return 0;

	/* Don't allow generating paradoxical FLOAT_MODE subregs. */
	if (SCALAR_FLOAT_MODE_P (mode) && msize > xsize)
	return 0;

	offset = subreg_lowpart_offset (mode, innermode);

	if ((GET_CODE (x) == ZERO_EXTEND \|\| GET_CODE (x) == SIGN_EXTEND)
	&& (GET_MODE_CLASS (mode) == MODE_INT
	\|\| GET_MODE_CLASS (mode) == MODE_PARTIAL_INT))
	{
	/* If we are getting the low-order part of something that has been
	sign- or zero-extended, we can either just use the object being
	extended or make a narrower extension. If we want an even smaller
	piece than the size of the object being extended, call ourselves
	recursively.

	This case is used mostly by combine and cse. */

	if (GET_MODE (XEXP (x, 0)) == mode)
	return XEXP (x, 0);
	else if (msize < GET_MODE_SIZE (GET_MODE (XEXP (x, 0))))
	return gen_lowpart_common (mode, XEXP (x, 0));
	else if (msize < xsize)
	return gen_rtx_fmt_e (GET_CODE (x), mode, XEXP (x, 0));
	}
	else if (GET_CODE (x) == SUBREG \|\| REG_P (x)
	\|\| GET_CODE (x) == CONCAT \|\| GET_CODE (x) == CONST_VECTOR
	\|\| GET_CODE (x) == CONST_DOUBLE \|\| GET_CODE (x) == CONST_INT)
	return simplify_gen_subreg (mode, x, innermode, offset);

	/* Otherwise, we can't do this. */
	return 0;
	}

	rtx
	gen_highpart (enum machine_mode mode, rtx x)
	{
	unsigned int msize = GET_MODE_SIZE (mode);
	rtx result;

	/* This case loses if X is a subreg. To catch bugs early,
	complain if an invalid MODE is used even in other cases. */
	gcc_assert (msize <= UNITS_PER_WORD
	\|\| msize == (unsigned int) GET_MODE_UNIT_SIZE (GET_MODE (x)));

	result = simplify_gen_subreg (mode, x, GET_MODE (x),
	subreg_highpart_offset (mode, GET_MODE (x)));
	gcc_assert (result);

	/* simplify_gen_subreg is not guaranteed to return a valid operand for
	the target if we have a MEM. gen_highpart must return a valid operand,
	emitting code if necessary to do so. */
	if (MEM_P (result))
	{
	result = validize_mem (result);
	gcc_assert (result);
	}

	return result;
	}

	/* Like gen_highpart, but accept mode of EXP operand in case EXP can
	be VOIDmode constant. */
	rtx
	gen_highpart_mode (enum machine_mode outermode, enum machine_mode innermode, rtx exp)
	{
	if (GET_MODE (exp) != VOIDmode)
	{
	gcc_assert (GET_MODE (exp) == innermode);
	return gen_highpart (outermode, exp);
	}
	return simplify_gen_subreg (outermode, exp, innermode,
	subreg_highpart_offset (outermode, innermode));
	}

	/* Return offset in bytes to get OUTERMODE low part
	of the value in mode INNERMODE stored in memory in target format. */

	unsigned int
	subreg_lowpart_offset (enum machine_mode outermode, enum machine_mode innermode)
	{
	unsigned int offset = 0;
	int difference = (GET_MODE_SIZE (innermode) - GET_MODE_SIZE (outermode));

	if (difference > 0)
	{
	if (WORDS_BIG_ENDIAN)
	offset += (difference / UNITS_PER_WORD) * UNITS_PER_WORD;
	if (BYTES_BIG_ENDIAN)
	offset += difference % UNITS_PER_WORD;
	}

	return offset;
	}

	/* Return offset in bytes to get OUTERMODE high part
	of the value in mode INNERMODE stored in memory in target format. */
	unsigned int
	subreg_highpart_offset (enum machine_mode outermode, enum machine_mode innermode)
	{
	unsigned int offset = 0;
	int difference = (GET_MODE_SIZE (innermode) - GET_MODE_SIZE (outermode));

	gcc_assert (GET_MODE_SIZE (innermode) >= GET_MODE_SIZE (outermode));

	if (difference > 0)
	{
	if (! WORDS_BIG_ENDIAN)
	offset += (difference / UNITS_PER_WORD) * UNITS_PER_WORD;
	if (! BYTES_BIG_ENDIAN)
	offset += difference % UNITS_PER_WORD;
	}

	return offset;
	}

	/* Return 1 iff X, assumed to be a SUBREG,
	refers to the least significant part of its containing reg.
	If X is not a SUBREG, always return 1 (it is its own low part!). */

	int
	subreg_lowpart_p (rtx x)
	{
	if (GET_CODE (x) != SUBREG)
	return 1;
	else if (GET_MODE (SUBREG_REG (x)) == VOIDmode)
	return 0;

	return (subreg_lowpart_offset (GET_MODE (x), GET_MODE (SUBREG_REG (x)))
	== SUBREG_BYTE (x));
	}

	/* Return subword OFFSET of operand OP.
	The word number, OFFSET, is interpreted as the word number starting
	at the low-order address. OFFSET 0 is the low-order word if not
	WORDS_BIG_ENDIAN, otherwise it is the high-order word.

	If we cannot extract the required word, we return zero. Otherwise,
	an rtx corresponding to the requested word will be returned.

	VALIDATE_ADDRESS is nonzero if the address should be validated. Before
	reload has completed, a valid address will always be returned. After
	reload, if a valid address cannot be returned, we return zero.

	If VALIDATE_ADDRESS is zero, we simply form the required address; validating
	it is the responsibility of the caller.

	MODE is the mode of OP in case it is a CONST_INT.

	??? This is still rather broken for some cases. The problem for the
	moment is that all callers of this thing provide no 'goal mode' to
	tell us to work with. This exists because all callers were written
	in a word based SUBREG world.
	Now use of this function can be deprecated by simplify_subreg in most
	cases.
	*/

	rtx
	operand_subword (rtx op, unsigned int offset, int validate_address, enum machine_mode mode)
	{
	if (mode == VOIDmode)
	mode = GET_MODE (op);

	gcc_assert (mode != VOIDmode);

	/* If OP is narrower than a word, fail. */
	if (mode != BLKmode
	&& (GET_MODE_SIZE (mode) < UNITS_PER_WORD))
	return 0;

	/* If we want a word outside OP, return zero. */
	if (mode != BLKmode
	&& (offset + 1) * UNITS_PER_WORD > GET_MODE_SIZE (mode))
	return const0_rtx;

	/* Form a new MEM at the requested address. */
	if (MEM_P (op))
	{
	rtx new = adjust_address_nv (op, word_mode, offset * UNITS_PER_WORD);

	if (! validate_address)
	return new;

	else if (reload_completed)
	{
	if (! strict_memory_address_p (word_mode, XEXP (new, 0)))
	return 0;
	}
	else
	return replace_equiv_address (new, XEXP (new, 0));
	}

	/* Rest can be handled by simplify_subreg. */
	return simplify_gen_subreg (word_mode, op, mode, (offset * UNITS_PER_WORD));
	}

	/* Similar to `operand_subword', but never return 0. If we can't
	extract the required subword, put OP into a register and try again.
	The second attempt must succeed. We always validate the address in
	this case.

	MODE is the mode of OP, in case it is CONST_INT. */

	rtx
	operand_subword_force (rtx op, unsigned int offset, enum machine_mode mode)
	{
	rtx result = operand_subword (op, offset, 1, mode);

	if (result)
	return result;

	if (mode != BLKmode && mode != VOIDmode)
	{
	/* If this is a register which can not be accessed by words, copy it
	to a pseudo register. */
	if (REG_P (op))
	op = copy_to_reg (op);
	else
	op = force_reg (mode, op);
	}

	result = operand_subword (op, offset, 1, mode);
	gcc_assert (result);

	return result;
	}

	/* Within a MEM_EXPR, we care about either (1) a component ref of a decl,
	or (2) a component ref of something variable. Represent the later with
	a NULL expression. */

	static tree
	component_ref_for_mem_expr (tree ref)
	{
	tree inner = TREE_OPERAND (ref, 0);

	if (TREE_CODE (inner) == COMPONENT_REF)
	inner = component_ref_for_mem_expr (inner);
	else
	{
	/* Now remove any conversions: they don't change what the underlying
	object is. Likewise for SAVE_EXPR. */
	while (TREE_CODE (inner) == NOP_EXPR \|\| TREE_CODE (inner) == CONVERT_EXPR
	\|\| TREE_CODE (inner) == NON_LVALUE_EXPR
	\|\| TREE_CODE (inner) == VIEW_CONVERT_EXPR
	\|\| TREE_CODE (inner) == SAVE_EXPR)
	inner = TREE_OPERAND (inner, 0);

	if (! DECL_P (inner))
	inner = NULL_TREE;
	}

	if (inner == TREE_OPERAND (ref, 0))
	return ref;
	else
	return build3 (COMPONENT_REF, TREE_TYPE (ref), inner,
	TREE_OPERAND (ref, 1), NULL_TREE);
	}

	/* Returns 1 if both MEM_EXPR can be considered equal
	and 0 otherwise. */

	int
	mem_expr_equal_p (tree expr1, tree expr2)
	{
	if (expr1 == expr2)
	return 1;

	if (! expr1 \|\| ! expr2)
	return 0;

	if (TREE_CODE (expr1) != TREE_CODE (expr2))
	return 0;

	if (TREE_CODE (expr1) == COMPONENT_REF)
	return
	mem_expr_equal_p (TREE_OPERAND (expr1, 0),
	TREE_OPERAND (expr2, 0))
	&& mem_expr_equal_p (TREE_OPERAND (expr1, 1), /* field decl */
	TREE_OPERAND (expr2, 1));

	if (INDIRECT_REF_P (expr1))
	return mem_expr_equal_p (TREE_OPERAND (expr1, 0),
	TREE_OPERAND (expr2, 0));

	/* ARRAY_REFs, ARRAY_RANGE_REFs and BIT_FIELD_REFs should already
	have been resolved here. */
	gcc_assert (DECL_P (expr1));

	/* Decls with different pointers can't be equal. */
	return 0;
	}

	/* Given REF, a MEM, and T, either the type of X or the expression
	corresponding to REF, set the memory attributes. OBJECTP is nonzero
	if we are making a new object of this type. BITPOS is nonzero if
	there is an offset outstanding on T that will be applied later. */

	void
	set_mem_attributes_minus_bitpos (rtx ref, tree t, int objectp,
	HOST_WIDE_INT bitpos)
	{
	HOST_WIDE_INT alias = MEM_ALIAS_SET (ref);
	tree expr = MEM_EXPR (ref);
	rtx offset = MEM_OFFSET (ref);
	rtx size = MEM_SIZE (ref);
	unsigned int align = MEM_ALIGN (ref);
	HOST_WIDE_INT apply_bitpos = 0;
	tree type;

	/* It can happen that type_for_mode was given a mode for which there
	is no language-level type. In which case it returns NULL, which
	we can see here. */
	if (t == NULL_TREE)
	return;

	type = TYPE_P (t) ? t : TREE_TYPE (t);
	if (type == error_mark_node)
	return;

	/* If we have already set DECL_RTL = ref, get_alias_set will get the
	wrong answer, as it assumes that DECL_RTL already has the right alias
	info. Callers should not set DECL_RTL until after the call to
	set_mem_attributes. */
	gcc_assert (!DECL_P (t) \|\| ref != DECL_RTL_IF_SET (t));

	/* Get the alias set from the expression or type (perhaps using a
	front-end routine) and use it. */
	alias = get_alias_set (t);

	MEM_VOLATILE_P (ref) \|= TYPE_VOLATILE (type);
	MEM_IN_STRUCT_P (ref) = AGGREGATE_TYPE_P (type);
	MEM_POINTER (ref) = POINTER_TYPE_P (type);

	/* If we are making an object of this type, or if this is a DECL, we know
	that it is a scalar if the type is not an aggregate. */
	if ((objectp \|\| DECL_P (t)) && ! AGGREGATE_TYPE_P (type))
	MEM_SCALAR_P (ref) = 1;

	/* We can set the alignment from the type if we are making an object,
	this is an INDIRECT_REF, or if TYPE_ALIGN_OK. */
	if (objectp \|\| TREE_CODE (t) == INDIRECT_REF
	\|\| TREE_CODE (t) == ALIGN_INDIRECT_REF
	\|\| TYPE_ALIGN_OK (type))
	align = MAX (align, TYPE_ALIGN (type));
	else
	if (TREE_CODE (t) == MISALIGNED_INDIRECT_REF)
	{
	if (integer_zerop (TREE_OPERAND (t, 1)))
	/* We don't know anything about the alignment. */
	align = BITS_PER_UNIT;
	else
	align = tree_low_cst (TREE_OPERAND (t, 1), 1);
	}

	/* If the size is known, we can set that. */
	if (TYPE_SIZE_UNIT (type) && host_integerp (TYPE_SIZE_UNIT (type), 1))
	size = GEN_INT (tree_low_cst (TYPE_SIZE_UNIT (type), 1));

	/* If T is not a type, we may be able to deduce some more information about
	the expression. */
	if (! TYPE_P (t))
	{
	tree base;

	if (TREE_THIS_VOLATILE (t))
	MEM_VOLATILE_P (ref) = 1;

	/* Now remove any conversions: they don't change what the underlying
	object is. Likewise for SAVE_EXPR. */
	while (TREE_CODE (t) == NOP_EXPR \|\| TREE_CODE (t) == CONVERT_EXPR
	\|\| TREE_CODE (t) == NON_LVALUE_EXPR
	\|\| TREE_CODE (t) == VIEW_CONVERT_EXPR
	\|\| TREE_CODE (t) == SAVE_EXPR)
	t = TREE_OPERAND (t, 0);

	/* We may look through structure-like accesses for the purposes of
	examining TREE_THIS_NOTRAP, but not array-like accesses. */
	base = t;
	while (TREE_CODE (base) == COMPONENT_REF
	\|\| TREE_CODE (base) == REALPART_EXPR
	\|\| TREE_CODE (base) == IMAGPART_EXPR
	\|\| TREE_CODE (base) == BIT_FIELD_REF)
	base = TREE_OPERAND (base, 0);

	if (DECL_P (base))
	{
	if (CODE_CONTAINS_STRUCT (TREE_CODE (base), TS_DECL_WITH_VIS))
	MEM_NOTRAP_P (ref) = !DECL_WEAK (base);
	else
	MEM_NOTRAP_P (ref) = 1;
	}
	else
	MEM_NOTRAP_P (ref) = TREE_THIS_NOTRAP (base);

	base = get_base_address (base);
	if (base && DECL_P (base)
	&& TREE_READONLY (base)
	&& (TREE_STATIC (base) \|\| DECL_EXTERNAL (base)))
	{
	tree base_type = TREE_TYPE (base);
	gcc_assert (!(base_type && TYPE_NEEDS_CONSTRUCTING (base_type))
	\|\| DECL_ARTIFICIAL (base));
	MEM_READONLY_P (ref) = 1;
	}

	/* If this expression uses it's parent's alias set, mark it such
	that we won't change it. */
	if (component_uses_parent_alias_set (t))
	MEM_KEEP_ALIAS_SET_P (ref) = 1;

	/* If this is a decl, set the attributes of the MEM from it. */
	if (DECL_P (t))
	{
	expr = t;
	offset = const0_rtx;
	apply_bitpos = bitpos;
	size = (DECL_SIZE_UNIT (t)
	&& host_integerp (DECL_SIZE_UNIT (t), 1)
	? GEN_INT (tree_low_cst (DECL_SIZE_UNIT (t), 1)) : 0);
	align = DECL_ALIGN (t);
	}

	/* If this is a constant, we know the alignment. */
	else if (CONSTANT_CLASS_P (t))
	{
	align = TYPE_ALIGN (type);
	#ifdef CONSTANT_ALIGNMENT
	align = CONSTANT_ALIGNMENT (t, align);
	#endif
	}

	/* If this is a field reference and not a bit-field, record it. */
	/* ??? There is some information that can be gleened from bit-fields,
	such as the word offset in the structure that might be modified.
	But skip it for now. */
	else if (TREE_CODE (t) == COMPONENT_REF
	&& ! DECL_BIT_FIELD (TREE_OPERAND (t, 1)))
	{
	expr = component_ref_for_mem_expr (t);
	offset = const0_rtx;
	apply_bitpos = bitpos;
	/* ??? Any reason the field size would be different than
	the size we got from the type? */
	}

	/* If this is an array reference, look for an outer field reference. */
	else if (TREE_CODE (t) == ARRAY_REF)
	{
	tree off_tree = size_zero_node;
	/* We can't modify t, because we use it at the end of the
	function. */
	tree t2 = t;

	do
	{
	tree index = TREE_OPERAND (t2, 1);
	tree low_bound = array_ref_low_bound (t2);
	tree unit_size = array_ref_element_size (t2);

	/* We assume all arrays have sizes that are a multiple of a byte.
	First subtract the lower bound, if any, in the type of the
	index, then convert to sizetype and multiply by the size of
	the array element. */
	if (! integer_zerop (low_bound))
	index = fold_build2 (MINUS_EXPR, TREE_TYPE (index),
	index, low_bound);

	off_tree = size_binop (PLUS_EXPR,
	size_binop (MULT_EXPR,
	fold_convert (sizetype,
	index),
	unit_size),
	off_tree);
	t2 = TREE_OPERAND (t2, 0);
	}
	while (TREE_CODE (t2) == ARRAY_REF);

	if (DECL_P (t2))
	{
	expr = t2;
	offset = NULL;
	if (host_integerp (off_tree, 1))
	{
	HOST_WIDE_INT ioff = tree_low_cst (off_tree, 1);
	HOST_WIDE_INT aoff = (ioff & -ioff) * BITS_PER_UNIT;
	align = DECL_ALIGN (t2);
	if (aoff && (unsigned HOST_WIDE_INT) aoff < align)
	align = aoff;
	offset = GEN_INT (ioff);
	apply_bitpos = bitpos;
	}
	}
	else if (TREE_CODE (t2) == COMPONENT_REF)
	{
	expr = component_ref_for_mem_expr (t2);
	if (host_integerp (off_tree, 1))
	{
	offset = GEN_INT (tree_low_cst (off_tree, 1));
	apply_bitpos = bitpos;
	}
	/* ??? Any reason the field size would be different than
	the size we got from the type? */
	}
	else if (flag_argument_noalias > 1
	&& (INDIRECT_REF_P (t2))
	&& TREE_CODE (TREE_OPERAND (t2, 0)) == PARM_DECL)
	{
	expr = t2;
	offset = NULL;
	}
	}

	/* If this is a Fortran indirect argument reference, record the
	parameter decl. */
	else if (flag_argument_noalias > 1
	&& (INDIRECT_REF_P (t))
	&& TREE_CODE (TREE_OPERAND (t, 0)) == PARM_DECL)
	{
	expr = t;
	offset = NULL;
	}
	}

	/* If we modified OFFSET based on T, then subtract the outstanding
	bit position offset. Similarly, increase the size of the accessed
	object to contain the negative offset. */
	if (apply_bitpos)
	{
	offset = plus_constant (offset, -(apply_bitpos / BITS_PER_UNIT));
	if (size)
	size = plus_constant (size, apply_bitpos / BITS_PER_UNIT);
	}

	if (TREE_CODE (t) == ALIGN_INDIRECT_REF)
	{
	/* Force EXPR and OFFSE to NULL, since we don't know exactly what
	we're overlapping. */
	offset = NULL;
	expr = NULL;
	}

	/* Now set the attributes we computed above. */
	MEM_ATTRS (ref)
	= get_mem_attrs (alias, expr, offset, size, align, GET_MODE (ref));

	/* If this is already known to be a scalar or aggregate, we are done. */
	if (MEM_IN_STRUCT_P (ref) \|\| MEM_SCALAR_P (ref))
	return;

	/* If it is a reference into an aggregate, this is part of an aggregate.
	Otherwise we don't know. */
	else if (TREE_CODE (t) == COMPONENT_REF \|\| TREE_CODE (t) == ARRAY_REF
	\|\| TREE_CODE (t) == ARRAY_RANGE_REF
	\|\| TREE_CODE (t) == BIT_FIELD_REF)
	MEM_IN_STRUCT_P (ref) = 1;
	}

	void
	set_mem_attributes (rtx ref, tree t, int objectp)
	{
	set_mem_attributes_minus_bitpos (ref, t, objectp, 0);
	}

	/* Set the decl for MEM to DECL. */

	void
	set_mem_attrs_from_reg (rtx mem, rtx reg)
	{
	MEM_ATTRS (mem)
	= get_mem_attrs (MEM_ALIAS_SET (mem), REG_EXPR (reg),
	GEN_INT (REG_OFFSET (reg)),
	MEM_SIZE (mem), MEM_ALIGN (mem), GET_MODE (mem));
	}

	/* Set the alias set of MEM to SET. */

	void
	set_mem_alias_set (rtx mem, HOST_WIDE_INT set)
	{
	#ifdef ENABLE_CHECKING
	/* If the new and old alias sets don't conflict, something is wrong. */
	gcc_assert (alias_sets_conflict_p (set, MEM_ALIAS_SET (mem)));
	#endif

	MEM_ATTRS (mem) = get_mem_attrs (set, MEM_EXPR (mem), MEM_OFFSET (mem),
	MEM_SIZE (mem), MEM_ALIGN (mem),
	GET_MODE (mem));
	}

	/* Set the alignment of MEM to ALIGN bits. */

	void
	set_mem_align (rtx mem, unsigned int align)
	{
	MEM_ATTRS (mem) = get_mem_attrs (MEM_ALIAS_SET (mem), MEM_EXPR (mem),
	MEM_OFFSET (mem), MEM_SIZE (mem), align,
	GET_MODE (mem));
	}

	/* Set the expr for MEM to EXPR. */

	void
	set_mem_expr (rtx mem, tree expr)
	{
	MEM_ATTRS (mem)
	= get_mem_attrs (MEM_ALIAS_SET (mem), expr, MEM_OFFSET (mem),
	MEM_SIZE (mem), MEM_ALIGN (mem), GET_MODE (mem));
	}

	/* Set the offset of MEM to OFFSET. */

	void
	set_mem_offset (rtx mem, rtx offset)
	{
	MEM_ATTRS (mem) = get_mem_attrs (MEM_ALIAS_SET (mem), MEM_EXPR (mem),
	offset, MEM_SIZE (mem), MEM_ALIGN (mem),
	GET_MODE (mem));
	}

	/* Set the size of MEM to SIZE. */

	void
	set_mem_size (rtx mem, rtx size)
	{
	MEM_ATTRS (mem) = get_mem_attrs (MEM_ALIAS_SET (mem), MEM_EXPR (mem),
	MEM_OFFSET (mem), size, MEM_ALIGN (mem),
	GET_MODE (mem));
	}

	/* Return a memory reference like MEMREF, but with its mode changed to MODE
	and its address changed to ADDR. (VOIDmode means don't change the mode.
	NULL for ADDR means don't change the address.) VALIDATE is nonzero if the
	returned memory location is required to be valid. The memory
	attributes are not changed. */

	static rtx
	change_address_1 (rtx memref, enum machine_mode mode, rtx addr, int validate)
	{
	rtx new;

	gcc_assert (MEM_P (memref));
	if (mode == VOIDmode)
	mode = GET_MODE (memref);
	if (addr == 0)
	addr = XEXP (memref, 0);
	if (mode == GET_MODE (memref) && addr == XEXP (memref, 0)
	&& (!validate \|\| memory_address_p (mode, addr)))
	return memref;

	if (validate)
	{
	if (reload_in_progress \|\| reload_completed)
	gcc_assert (memory_address_p (mode, addr));
	else
	addr = memory_address (mode, addr);
	}

	if (rtx_equal_p (addr, XEXP (memref, 0)) && mode == GET_MODE (memref))
	return memref;

	new = gen_rtx_MEM (mode, addr);
	MEM_COPY_ATTRIBUTES (new, memref);
	return new;
	}

	/* Like change_address_1 with VALIDATE nonzero, but we are not saying in what
	way we are changing MEMREF, so we only preserve the alias set. */

	rtx
	change_address (rtx memref, enum machine_mode mode, rtx addr)
	{
	rtx new = change_address_1 (memref, mode, addr, 1), size;
	enum machine_mode mmode = GET_MODE (new);
	unsigned int align;

	size = mmode == BLKmode ? 0 : GEN_INT (GET_MODE_SIZE (mmode));
	align = mmode == BLKmode ? BITS_PER_UNIT : GET_MODE_ALIGNMENT (mmode);

	/* If there are no changes, just return the original memory reference. */
	if (new == memref)
	{
	if (MEM_ATTRS (memref) == 0
	\|\| (MEM_EXPR (memref) == NULL
	&& MEM_OFFSET (memref) == NULL
	&& MEM_SIZE (memref) == size
	&& MEM_ALIGN (memref) == align))
	return new;

	new = gen_rtx_MEM (mmode, XEXP (memref, 0));
	MEM_COPY_ATTRIBUTES (new, memref);
	}

	MEM_ATTRS (new)
	= get_mem_attrs (MEM_ALIAS_SET (memref), 0, 0, size, align, mmode);

	return new;
	}

	/* Return a memory reference like MEMREF, but with its mode changed
	to MODE and its address offset by OFFSET bytes. If VALIDATE is
	nonzero, the memory address is forced to be valid.
	If ADJUST is zero, OFFSET is only used to update MEM_ATTRS
	and caller is responsible for adjusting MEMREF base register. */

	rtx
	adjust_address_1 (rtx memref, enum machine_mode mode, HOST_WIDE_INT offset,
	int validate, int adjust)
	{
	rtx addr = XEXP (memref, 0);
	rtx new;
	rtx memoffset = MEM_OFFSET (memref);
	rtx size = 0;
	unsigned int memalign = MEM_ALIGN (memref);

	/* If there are no changes, just return the original memory reference. */
	if (mode == GET_MODE (memref) && !offset
	&& (!validate \|\| memory_address_p (mode, addr)))
	return memref;

	/* ??? Prefer to create garbage instead of creating shared rtl.
	This may happen even if offset is nonzero -- consider
	(plus (plus reg reg) const_int) -- so do this always. */
	addr = copy_rtx (addr);

	if (adjust)
	{
	/* If MEMREF is a LO_SUM and the offset is within the alignment of the
	object, we can merge it into the LO_SUM. */
	if (GET_MODE (memref) != BLKmode && GET_CODE (addr) == LO_SUM
	&& offset >= 0
	&& (unsigned HOST_WIDE_INT) offset
	< GET_MODE_ALIGNMENT (GET_MODE (memref)) / BITS_PER_UNIT)
	addr = gen_rtx_LO_SUM (Pmode, XEXP (addr, 0),
	plus_constant (XEXP (addr, 1), offset));
	else
	addr = plus_constant (addr, offset);
	}

	new = change_address_1 (memref, mode, addr, validate);

	/* Compute the new values of the memory attributes due to this adjustment.
	We add the offsets and update the alignment. */
	if (memoffset)
	memoffset = GEN_INT (offset + INTVAL (memoffset));

	/* Compute the new alignment by taking the MIN of the alignment and the
	lowest-order set bit in OFFSET, but don't change the alignment if OFFSET
	if zero. */
	if (offset != 0)
	memalign
	= MIN (memalign,
	(unsigned HOST_WIDE_INT) (offset & -offset) * BITS_PER_UNIT);

	/* We can compute the size in a number of ways. */
	if (GET_MODE (new) != BLKmode)
	size = GEN_INT (GET_MODE_SIZE (GET_MODE (new)));
	else if (MEM_SIZE (memref))
	size = plus_constant (MEM_SIZE (memref), -offset);

	MEM_ATTRS (new) = get_mem_attrs (MEM_ALIAS_SET (memref), MEM_EXPR (memref),
	memoffset, size, memalign, GET_MODE (new));

	/* At some point, we should validate that this offset is within the object,
	if all the appropriate values are known. */
	return new;
	}

	/* Return a memory reference like MEMREF, but with its mode changed
	to MODE and its address changed to ADDR, which is assumed to be
	MEMREF offseted by OFFSET bytes. If VALIDATE is
	nonzero, the memory address is forced to be valid. */

	rtx
	adjust_automodify_address_1 (rtx memref, enum machine_mode mode, rtx addr,
	HOST_WIDE_INT offset, int validate)
	{
	memref = change_address_1 (memref, VOIDmode, addr, validate);
	return adjust_address_1 (memref, mode, offset, validate, 0);
	}

	/* Return a memory reference like MEMREF, but whose address is changed by
	adding OFFSET, an RTX, to it. POW2 is the highest power of two factor
	known to be in OFFSET (possibly 1). */

	rtx
	offset_address (rtx memref, rtx offset, unsigned HOST_WIDE_INT pow2)
	{
	rtx new, addr = XEXP (memref, 0);

	new = simplify_gen_binary (PLUS, Pmode, addr, offset);

	/* At this point we don't know _why_ the address is invalid. It
	could have secondary memory references, multiplies or anything.

	However, if we did go and rearrange things, we can wind up not
	being able to recognize the magic around pic_offset_table_rtx.
	This stuff is fragile, and is yet another example of why it is
	bad to expose PIC machinery too early. */
	if (! memory_address_p (GET_MODE (memref), new)
	&& GET_CODE (addr) == PLUS
	&& XEXP (addr, 0) == pic_offset_table_rtx)
	{
	addr = force_reg (GET_MODE (addr), addr);
	new = simplify_gen_binary (PLUS, Pmode, addr, offset);
	}

	update_temp_slot_address (XEXP (memref, 0), new);
	new = change_address_1 (memref, VOIDmode, new, 1);

	/* If there are no changes, just return the original memory reference. */
	if (new == memref)
	return new;

	/* Update the alignment to reflect the offset. Reset the offset, which
	we don't know. */
	MEM_ATTRS (new)
	= get_mem_attrs (MEM_ALIAS_SET (memref), MEM_EXPR (memref), 0, 0,
	MIN (MEM_ALIGN (memref), pow2 * BITS_PER_UNIT),
	GET_MODE (new));
	return new;
	}

	/* Return a memory reference like MEMREF, but with its address changed to
	ADDR. The caller is asserting that the actual piece of memory pointed
	to is the same, just the form of the address is being changed, such as
	by putting something into a register. */

	rtx
	replace_equiv_address (rtx memref, rtx addr)
	{
	/* change_address_1 copies the memory attribute structure without change
	and that's exactly what we want here. */
	update_temp_slot_address (XEXP (memref, 0), addr);
	return change_address_1 (memref, VOIDmode, addr, 1);
	}

	/* Likewise, but the reference is not required to be valid. */

	rtx
	replace_equiv_address_nv (rtx memref, rtx addr)
	{
	return change_address_1 (memref, VOIDmode, addr, 0);
	}

	/* Return a memory reference like MEMREF, but with its mode widened to
	MODE and offset by OFFSET. This would be used by targets that e.g.
	cannot issue QImode memory operations and have to use SImode memory
	operations plus masking logic. */

	rtx
	widen_memory_access (rtx memref, enum machine_mode mode, HOST_WIDE_INT offset)
	{
	rtx new = adjust_address_1 (memref, mode, offset, 1, 1);
	tree expr = MEM_EXPR (new);
	rtx memoffset = MEM_OFFSET (new);
	unsigned int size = GET_MODE_SIZE (mode);

	/* If there are no changes, just return the original memory reference. */
	if (new == memref)
	return new;

	/* If we don't know what offset we were at within the expression, then
	we can't know if we've overstepped the bounds. */
	if (! memoffset)
	expr = NULL_TREE;

	while (expr)
	{
	if (TREE_CODE (expr) == COMPONENT_REF)
	{
	tree field = TREE_OPERAND (expr, 1);
	tree offset = component_ref_field_offset (expr);

	if (! DECL_SIZE_UNIT (field))
	{
	expr = NULL_TREE;
	break;
	}

	/* Is the field at least as large as the access? If so, ok,
	otherwise strip back to the containing structure. */
	if (TREE_CODE (DECL_SIZE_UNIT (field)) == INTEGER_CST
	&& compare_tree_int (DECL_SIZE_UNIT (field), size) >= 0
	&& INTVAL (memoffset) >= 0)
	break;

	if (! host_integerp (offset, 1))
	{
	expr = NULL_TREE;
	break;
	}

	expr = TREE_OPERAND (expr, 0);
	memoffset
	= (GEN_INT (INTVAL (memoffset)
	+ tree_low_cst (offset, 1)
	+ (tree_low_cst (DECL_FIELD_BIT_OFFSET (field), 1)
	/ BITS_PER_UNIT)));
	}
	/* Similarly for the decl. */
	else if (DECL_P (expr)
	&& DECL_SIZE_UNIT (expr)
	&& TREE_CODE (DECL_SIZE_UNIT (expr)) == INTEGER_CST
	&& compare_tree_int (DECL_SIZE_UNIT (expr), size) >= 0
	&& (! memoffset \|\| INTVAL (memoffset) >= 0))
	break;
	else
	{
	/* The widened memory access overflows the expression, which means
	that it could alias another expression. Zap it. */
	expr = NULL_TREE;
	break;
	}
	}

	if (! expr)
	memoffset = NULL_RTX;

	/* The widened memory may alias other stuff, so zap the alias set. */
	/* ??? Maybe use get_alias_set on any remaining expression. */

	MEM_ATTRS (new) = get_mem_attrs (0, expr, memoffset, GEN_INT (size),
	MEM_ALIGN (new), mode);

	return new;
	}

	/* Return a newly created CODE_LABEL rtx with a unique label number. */

	rtx
	gen_label_rtx (void)
	{
	return gen_rtx_CODE_LABEL (VOIDmode, 0, NULL_RTX, NULL_RTX,
	- NULL, label_num++, NULL);
	+/* APPLE LOCAL begin for-fsf-4_4 3274130 5295549 */ \
	+ NULL, label_num++, NULL, 0);
	+/* APPLE LOCAL end for-fsf-4_4 3274130 5295549 */ \
	}

	/* For procedure integration. */

	/* Install new pointers to the first and last insns in the chain.
	Also, set cur_insn_uid to one higher than the last in use.
	Used for an inline-procedure after copying the insn chain. */

	void
	set_new_first_and_last_insn (rtx first, rtx last)
	{
	rtx insn;

	first_insn = first;
	last_insn = last;
	cur_insn_uid = 0;

	for (insn = first; insn; insn = NEXT_INSN (insn))
	cur_insn_uid = MAX (cur_insn_uid, INSN_UID (insn));

	cur_insn_uid++;
	}

	/* Go through all the RTL insn bodies and copy any invalid shared
	structure. This routine should only be called once. */

	static void
	unshare_all_rtl_1 (tree fndecl, rtx insn)
	{
	tree decl;

	/* Make sure that virtual parameters are not shared. */
	for (decl = DECL_ARGUMENTS (fndecl); decl; decl = TREE_CHAIN (decl))
	SET_DECL_RTL (decl, copy_rtx_if_shared (DECL_RTL (decl)));

	/* Make sure that virtual stack slots are not shared. */
	unshare_all_decls (DECL_INITIAL (fndecl));

	/* Unshare just about everything else. */
	unshare_all_rtl_in_chain (insn);

	/* Make sure the addresses of stack slots found outside the insn chain
	(such as, in DECL_RTL of a variable) are not shared
	with the insn chain.

	This special care is necessary when the stack slot MEM does not
	actually appear in the insn chain. If it does appear, its address
	is unshared from all else at that point. */
	stack_slot_list = copy_rtx_if_shared (stack_slot_list);
	}

	/* Go through all the RTL insn bodies and copy any invalid shared
	structure, again. This is a fairly expensive thing to do so it
	should be done sparingly. */

	void
	unshare_all_rtl_again (rtx insn)
	{
	rtx p;
	tree decl;

	for (p = insn; p; p = NEXT_INSN (p))
	if (INSN_P (p))
	{
	reset_used_flags (PATTERN (p));
	reset_used_flags (REG_NOTES (p));
	reset_used_flags (LOG_LINKS (p));
	}

	/* Make sure that virtual stack slots are not shared. */
	reset_used_decls (DECL_INITIAL (cfun->decl));

	/* Make sure that virtual parameters are not shared. */
	for (decl = DECL_ARGUMENTS (cfun->decl); decl; decl = TREE_CHAIN (decl))
	reset_used_flags (DECL_RTL (decl));

	reset_used_flags (stack_slot_list);

	unshare_all_rtl_1 (cfun->decl, insn);
	}

	unsigned int
	unshare_all_rtl (void)
	{
	unshare_all_rtl_1 (current_function_decl, get_insns ());
	return 0;
	}

	struct tree_opt_pass pass_unshare_all_rtl =
	{
	"unshare", /* name */
	NULL, /* gate */
	unshare_all_rtl, /* execute */
	NULL, /* sub */
	NULL, /* next */
	0, /* static_pass_number */
	0, /* tv_id */
	0, /* properties_required */
	0, /* properties_provided */
	0, /* properties_destroyed */
	0, /* todo_flags_start */
	TODO_dump_func, /* todo_flags_finish */
	0 /* letter */
	};


	/* Check that ORIG is not marked when it should not be and mark ORIG as in use,
	Recursively does the same for subexpressions. */

	static void
	verify_rtx_sharing (rtx orig, rtx insn)
	{
	rtx x = orig;
	int i;
	enum rtx_code code;
	const char *format_ptr;

	if (x == 0)
	return;

	code = GET_CODE (x);

	/* These types may be freely shared. */

	switch (code)
	{
	case REG:
	case CONST_INT:
	case CONST_DOUBLE:
	case CONST_VECTOR:
	case SYMBOL_REF:
	case LABEL_REF:
	case CODE_LABEL:
	case PC:
	case CC0:
	case SCRATCH:
	return;
	/* SCRATCH must be shared because they represent distinct values. */
	case CLOBBER:
	if (REG_P (XEXP (x, 0)) && REGNO (XEXP (x, 0)) < FIRST_PSEUDO_REGISTER)
	return;
	break;

	case CONST:
	/* CONST can be shared if it contains a SYMBOL_REF. If it contains
	a LABEL_REF, it isn't sharable. */
	if (GET_CODE (XEXP (x, 0)) == PLUS
	&& GET_CODE (XEXP (XEXP (x, 0), 0)) == SYMBOL_REF
	&& GET_CODE (XEXP (XEXP (x, 0), 1)) == CONST_INT)
	return;
	break;

	case MEM:
	/* A MEM is allowed to be shared if its address is constant. */
	if (CONSTANT_ADDRESS_P (XEXP (x, 0))
	\|\| reload_completed \|\| reload_in_progress)
	return;

	break;

	default:
	break;
	}

	/* This rtx may not be shared. If it has already been seen,
	replace it with a copy of itself. */
	#ifdef ENABLE_CHECKING
	if (RTX_FLAG (x, used))
	{
	error ("invalid rtl sharing found in the insn");
	debug_rtx (insn);
	error ("shared rtx");
	debug_rtx (x);
	internal_error ("internal consistency failure");
	}
	#endif
	gcc_assert (!RTX_FLAG (x, used));

	RTX_FLAG (x, used) = 1;

	/* Now scan the subexpressions recursively. */

	format_ptr = GET_RTX_FORMAT (code);

	for (i = 0; i < GET_RTX_LENGTH (code); i++)
	{
	switch (*format_ptr++)
	{
	case 'e':
	verify_rtx_sharing (XEXP (x, i), insn);
	break;

	case 'E':
	if (XVEC (x, i) != NULL)
	{
	int j;
	int len = XVECLEN (x, i);

	for (j = 0; j < len; j++)
	{
	/* We allow sharing of ASM_OPERANDS inside single
	instruction. */
	if (j && GET_CODE (XVECEXP (x, i, j)) == SET
	&& (GET_CODE (SET_SRC (XVECEXP (x, i, j)))
	== ASM_OPERANDS))
	verify_rtx_sharing (SET_DEST (XVECEXP (x, i, j)), insn);
	else
	verify_rtx_sharing (XVECEXP (x, i, j), insn);
	}
	}
	break;
	}
	}
	return;
	}

	/* Go through all the RTL insn bodies and check that there is no unexpected
	sharing in between the subexpressions. */

	void
	verify_rtl_sharing (void)
	{
	rtx p;

	for (p = get_insns (); p; p = NEXT_INSN (p))
	if (INSN_P (p))
	{
	reset_used_flags (PATTERN (p));
	reset_used_flags (REG_NOTES (p));
	reset_used_flags (LOG_LINKS (p));
	}

	for (p = get_insns (); p; p = NEXT_INSN (p))
	if (INSN_P (p))
	{
	verify_rtx_sharing (PATTERN (p), p);
	verify_rtx_sharing (REG_NOTES (p), p);
	verify_rtx_sharing (LOG_LINKS (p), p);
	}
	}

	/* Go through all the RTL insn bodies and copy any invalid shared structure.
	Assumes the mark bits are cleared at entry. */

	void
	unshare_all_rtl_in_chain (rtx insn)
	{
	for (; insn; insn = NEXT_INSN (insn))
	if (INSN_P (insn))
	{
	PATTERN (insn) = copy_rtx_if_shared (PATTERN (insn));
	REG_NOTES (insn) = copy_rtx_if_shared (REG_NOTES (insn));
	LOG_LINKS (insn) = copy_rtx_if_shared (LOG_LINKS (insn));
	}
	}

	/* Go through all virtual stack slots of a function and copy any
	shared structure. */
	static void
	unshare_all_decls (tree blk)
	{
	tree t;

	/* Copy shared decls. */
	for (t = BLOCK_VARS (blk); t; t = TREE_CHAIN (t))
	if (DECL_RTL_SET_P (t))
	SET_DECL_RTL (t, copy_rtx_if_shared (DECL_RTL (t)));

	/* Now process sub-blocks. */
	for (t = BLOCK_SUBBLOCKS (blk); t; t = TREE_CHAIN (t))
	unshare_all_decls (t);
	}

	/* Go through all virtual stack slots of a function and mark them as
	not shared. */
	static void
	reset_used_decls (tree blk)
	{
	tree t;

	/* Mark decls. */
	for (t = BLOCK_VARS (blk); t; t = TREE_CHAIN (t))
	if (DECL_RTL_SET_P (t))
	reset_used_flags (DECL_RTL (t));

	/* Now process sub-blocks. */
	for (t = BLOCK_SUBBLOCKS (blk); t; t = TREE_CHAIN (t))
	reset_used_decls (t);
	}

	/* Mark ORIG as in use, and return a copy of it if it was already in use.
	Recursively does the same for subexpressions. Uses
	copy_rtx_if_shared_1 to reduce stack space. */

	rtx
	copy_rtx_if_shared (rtx orig)
	{
	copy_rtx_if_shared_1 (&orig);
	return orig;
	}

	/* Mark *ORIG1 as in use, and set it to a copy of it if it was already in
	use. Recursively does the same for subexpressions. */

	static void
	copy_rtx_if_shared_1 (rtx *orig1)
	{
	rtx x;
	int i;
	enum rtx_code code;
	rtx *last_ptr;
	const char *format_ptr;
	int copied = 0;
	int length;

	/* Repeat is used to turn tail-recursion into iteration. */
	repeat:
	x = *orig1;

	if (x == 0)
	return;

	code = GET_CODE (x);

	/* These types may be freely shared. */

	switch (code)
	{
	case REG:
	case CONST_INT:
	case CONST_DOUBLE:
	case CONST_VECTOR:
	case SYMBOL_REF:
	case LABEL_REF:
	case CODE_LABEL:
	case PC:
	case CC0:
	case SCRATCH:
	/* SCRATCH must be shared because they represent distinct values. */
	return;
	case CLOBBER:
	if (REG_P (XEXP (x, 0)) && REGNO (XEXP (x, 0)) < FIRST_PSEUDO_REGISTER)
	return;
	break;

	case CONST:
	/* CONST can be shared if it contains a SYMBOL_REF. If it contains
	a LABEL_REF, it isn't sharable. */
	if (GET_CODE (XEXP (x, 0)) == PLUS
	&& GET_CODE (XEXP (XEXP (x, 0), 0)) == SYMBOL_REF
	&& GET_CODE (XEXP (XEXP (x, 0), 1)) == CONST_INT)
	return;
	break;

	case INSN:
	case JUMP_INSN:
	case CALL_INSN:
	case NOTE:
	case BARRIER:
	/* The chain of insns is not being copied. */
	return;

	default:
	break;
	}

	/* This rtx may not be shared. If it has already been seen,
	replace it with a copy of itself. */

	if (RTX_FLAG (x, used))
	{
	x = shallow_copy_rtx (x);
	copied = 1;
	}
	RTX_FLAG (x, used) = 1;

	/* Now scan the subexpressions recursively.
	We can store any replaced subexpressions directly into X
	since we know X is not shared! Any vectors in X
	must be copied if X was copied. */

	format_ptr = GET_RTX_FORMAT (code);
	length = GET_RTX_LENGTH (code);
	last_ptr = NULL;

	for (i = 0; i < length; i++)
	{
	switch (*format_ptr++)
	{
	case 'e':
	if (last_ptr)
	copy_rtx_if_shared_1 (last_ptr);
	last_ptr = &XEXP (x, i);
	break;

	case 'E':
	if (XVEC (x, i) != NULL)
	{
	int j;
	int len = XVECLEN (x, i);

	/* Copy the vector iff I copied the rtx and the length
	is nonzero. */
	if (copied && len > 0)
	XVEC (x, i) = gen_rtvec_v (len, XVEC (x, i)->elem);

	/* Call recursively on all inside the vector. */
	for (j = 0; j < len; j++)
	{
	if (last_ptr)
	copy_rtx_if_shared_1 (last_ptr);
	last_ptr = &XVECEXP (x, i, j);
	}
	}
	break;
	}
	}
	*orig1 = x;
	if (last_ptr)
	{
	orig1 = last_ptr;
	goto repeat;
	}
	return;
	}

	/* Clear all the USED bits in X to allow copy_rtx_if_shared to be used
	to look for shared sub-parts. */

	void
	reset_used_flags (rtx x)
	{
	int i, j;
	enum rtx_code code;
	const char *format_ptr;
	int length;

	/* Repeat is used to turn tail-recursion into iteration. */
	repeat:
	if (x == 0)
	return;

	code = GET_CODE (x);

	/* These types may be freely shared so we needn't do any resetting
	for them. */

	switch (code)
	{
	case REG:
	case CONST_INT:
	case CONST_DOUBLE:
	case CONST_VECTOR:
	case SYMBOL_REF:
	case CODE_LABEL:
	case PC:
	case CC0:
	return;

	case INSN:
	case JUMP_INSN:
	case CALL_INSN:
	case NOTE:
	case LABEL_REF:
	case BARRIER:
	/* The chain of insns is not being copied. */
	return;

	default:
	break;
	}

	RTX_FLAG (x, used) = 0;

	format_ptr = GET_RTX_FORMAT (code);
	length = GET_RTX_LENGTH (code);

	for (i = 0; i < length; i++)
	{
	switch (*format_ptr++)
	{
	case 'e':
	if (i == length-1)
	{
	x = XEXP (x, i);
	goto repeat;
	}
	reset_used_flags (XEXP (x, i));
	break;

	case 'E':
	for (j = 0; j < XVECLEN (x, i); j++)
	reset_used_flags (XVECEXP (x, i, j));
	break;
	}
	}
	}

	/* Set all the USED bits in X to allow copy_rtx_if_shared to be used
	to look for shared sub-parts. */

	void
	set_used_flags (rtx x)
	{
	int i, j;
	enum rtx_code code;
	const char *format_ptr;

	if (x == 0)
	return;

	code = GET_CODE (x);

	/* These types may be freely shared so we needn't do any resetting
	for them. */

	switch (code)
	{
	case REG:
	case CONST_INT:
	case CONST_DOUBLE:
	case CONST_VECTOR:
	case SYMBOL_REF:
	case CODE_LABEL:
	case PC:
	case CC0:
	return;

	case INSN:
	case JUMP_INSN:
	case CALL_INSN:
	case NOTE:
	case LABEL_REF:
	case BARRIER:
	/* The chain of insns is not being copied. */
	return;

	default:
	break;
	}

	RTX_FLAG (x, used) = 1;

	format_ptr = GET_RTX_FORMAT (code);
	for (i = 0; i < GET_RTX_LENGTH (code); i++)
	{
	switch (*format_ptr++)
	{
	case 'e':
	set_used_flags (XEXP (x, i));
	break;

	case 'E':
	for (j = 0; j < XVECLEN (x, i); j++)
	set_used_flags (XVECEXP (x, i, j));
	break;
	}
	}
	}

	/* Copy X if necessary so that it won't be altered by changes in OTHER.
	Return X or the rtx for the pseudo reg the value of X was copied into.
	OTHER must be valid as a SET_DEST. */

	rtx
	make_safe_from (rtx x, rtx other)
	{
	while (1)
	switch (GET_CODE (other))
	{
	case SUBREG:
	other = SUBREG_REG (other);
	break;
	case STRICT_LOW_PART:
	case SIGN_EXTEND:
	case ZERO_EXTEND:
	other = XEXP (other, 0);
	break;
	default:
	goto done;
	}
	done:
	if ((MEM_P (other)
	&& ! CONSTANT_P (x)
	&& !REG_P (x)
	&& GET_CODE (x) != SUBREG)
	\|\| (REG_P (other)
	&& (REGNO (other) < FIRST_PSEUDO_REGISTER
	\|\| reg_mentioned_p (other, x))))
	{
	rtx temp = gen_reg_rtx (GET_MODE (x));
	emit_move_insn (temp, x);
	return temp;
	}
	return x;
	}

	/* Emission of insns (adding them to the doubly-linked list). */

	/* Return the first insn of the current sequence or current function. */

	rtx
	get_insns (void)
	{
	return first_insn;
	}

	/* Specify a new insn as the first in the chain. */

	void
	set_first_insn (rtx insn)
	{
	gcc_assert (!PREV_INSN (insn));
	first_insn = insn;
	}

	/* Return the last insn emitted in current sequence or current function. */

	rtx
	get_last_insn (void)
	{
	return last_insn;
	}

	/* Specify a new insn as the last in the chain. */

	void
	set_last_insn (rtx insn)
	{
	gcc_assert (!NEXT_INSN (insn));
	last_insn = insn;
	}

	/* Return the last insn emitted, even if it is in a sequence now pushed. */

	rtx
	get_last_insn_anywhere (void)
	{
	struct sequence_stack *stack;
	if (last_insn)
	return last_insn;
	for (stack = seq_stack; stack; stack = stack->next)
	if (stack->last != 0)
	return stack->last;
	return 0;
	}

	/* Return the first nonnote insn emitted in current sequence or current
	function. This routine looks inside SEQUENCEs. */

	rtx
	get_first_nonnote_insn (void)
	{
	rtx insn = first_insn;

	if (insn)
	{
	if (NOTE_P (insn))
	for (insn = next_insn (insn);
	insn && NOTE_P (insn);
	insn = next_insn (insn))
	continue;
	else
	{
	if (NONJUMP_INSN_P (insn)
	&& GET_CODE (PATTERN (insn)) == SEQUENCE)
	insn = XVECEXP (PATTERN (insn), 0, 0);
	}
	}

	return insn;
	}

	/* Return the last nonnote insn emitted in current sequence or current
	function. This routine looks inside SEQUENCEs. */

	rtx
	get_last_nonnote_insn (void)
	{
	rtx insn = last_insn;

	if (insn)
	{
	if (NOTE_P (insn))
	for (insn = previous_insn (insn);
	insn && NOTE_P (insn);
	insn = previous_insn (insn))
	continue;
	else
	{
	if (NONJUMP_INSN_P (insn)
	&& GET_CODE (PATTERN (insn)) == SEQUENCE)
	insn = XVECEXP (PATTERN (insn), 0,
	XVECLEN (PATTERN (insn), 0) - 1);
	}
	}

	return insn;
	}

	/* Return a number larger than any instruction's uid in this function. */

	int
	get_max_uid (void)
	{
	return cur_insn_uid;
	}

	/* Renumber instructions so that no instruction UIDs are wasted. */

	void
	renumber_insns (void)
	{
	rtx insn;

	/* If we're not supposed to renumber instructions, don't. */
	if (!flag_renumber_insns)
	return;

	/* If there aren't that many instructions, then it's not really
	worth renumbering them. */
	if (flag_renumber_insns == 1 && get_max_uid () < 25000)
	return;

	cur_insn_uid = 1;

	for (insn = get_insns (); insn; insn = NEXT_INSN (insn))
	{
	if (dump_file)
	fprintf (dump_file, "Renumbering insn %d to %d\n",
	INSN_UID (insn), cur_insn_uid);
	INSN_UID (insn) = cur_insn_uid++;
	}
	}

	/* Return the next insn. If it is a SEQUENCE, return the first insn
	of the sequence. */

	rtx
	next_insn (rtx insn)
	{
	if (insn)
	{
	insn = NEXT_INSN (insn);
	if (insn && NONJUMP_INSN_P (insn)
	&& GET_CODE (PATTERN (insn)) == SEQUENCE)
	insn = XVECEXP (PATTERN (insn), 0, 0);
	}

	return insn;
	}

	/* Return the previous insn. If it is a SEQUENCE, return the last insn
	of the sequence. */

	rtx
	previous_insn (rtx insn)
	{
	if (insn)
	{
	insn = PREV_INSN (insn);
	if (insn && NONJUMP_INSN_P (insn)
	&& GET_CODE (PATTERN (insn)) == SEQUENCE)
	insn = XVECEXP (PATTERN (insn), 0, XVECLEN (PATTERN (insn), 0) - 1);
	}

	return insn;
	}

	/* Return the next insn after INSN that is not a NOTE. This routine does not
	look inside SEQUENCEs. */

	rtx
	next_nonnote_insn (rtx insn)
	{
	while (insn)
	{
	insn = NEXT_INSN (insn);
	if (insn == 0 \|\| !NOTE_P (insn))
	break;
	}

	return insn;
	}

	/* Return the previous insn before INSN that is not a NOTE. This routine does
	not look inside SEQUENCEs. */

	rtx
	prev_nonnote_insn (rtx insn)
	{
	while (insn)
	{
	insn = PREV_INSN (insn);
	if (insn == 0 \|\| !NOTE_P (insn))
	break;
	}

	return insn;
	}

	/* Return the next INSN, CALL_INSN or JUMP_INSN after INSN;
	or 0, if there is none. This routine does not look inside
	SEQUENCEs. */

	rtx
	next_real_insn (rtx insn)
	{
	while (insn)
	{
	insn = NEXT_INSN (insn);
	if (insn == 0 \|\| INSN_P (insn))
	break;
	}

	return insn;
	}

	/* Return the last INSN, CALL_INSN or JUMP_INSN before INSN;
	or 0, if there is none. This routine does not look inside
	SEQUENCEs. */

	rtx
	prev_real_insn (rtx insn)
	{
	while (insn)
	{
	insn = PREV_INSN (insn);
	if (insn == 0 \|\| INSN_P (insn))
	break;
	}

	return insn;
	}

	/* Return the last CALL_INSN in the current list, or 0 if there is none.
	This routine does not look inside SEQUENCEs. */

	rtx
	last_call_insn (void)
	{
	rtx insn;

	for (insn = get_last_insn ();
	insn && !CALL_P (insn);
	insn = PREV_INSN (insn))
	;

	return insn;
	}

	/* Find the next insn after INSN that really does something. This routine
	does not look inside SEQUENCEs. Until reload has completed, this is the
	same as next_real_insn. */

	int
	active_insn_p (rtx insn)
	{
	return (CALL_P (insn) \|\| JUMP_P (insn)
	\|\| (NONJUMP_INSN_P (insn)
	&& (! reload_completed
	\|\| (GET_CODE (PATTERN (insn)) != USE
	&& GET_CODE (PATTERN (insn)) != CLOBBER))));
	}

	rtx
	next_active_insn (rtx insn)
	{
	while (insn)
	{
	insn = NEXT_INSN (insn);
	if (insn == 0 \|\| active_insn_p (insn))
	break;
	}

	return insn;
	}

	/* Find the last insn before INSN that really does something. This routine
	does not look inside SEQUENCEs. Until reload has completed, this is the
	same as prev_real_insn. */

	rtx
	prev_active_insn (rtx insn)
	{
	while (insn)
	{
	insn = PREV_INSN (insn);
	if (insn == 0 \|\| active_insn_p (insn))
	break;
	}

	return insn;
	}

	/* Return the next CODE_LABEL after the insn INSN, or 0 if there is none. */

	rtx
	next_label (rtx insn)
	{
	while (insn)
	{
	insn = NEXT_INSN (insn);
	if (insn == 0 \|\| LABEL_P (insn))
	break;
	}

	return insn;
	}

	/* Return the last CODE_LABEL before the insn INSN, or 0 if there is none. */

	rtx
	prev_label (rtx insn)
	{
	while (insn)
	{
	insn = PREV_INSN (insn);
	if (insn == 0 \|\| LABEL_P (insn))
	break;
	}

	return insn;
	}

	/* Return the last label to mark the same position as LABEL. Return null
	if LABEL itself is null. */

	rtx
	skip_consecutive_labels (rtx label)
	{
	rtx insn;

	for (insn = label; insn != 0 && !INSN_P (insn); insn = NEXT_INSN (insn))
	if (LABEL_P (insn))
	label = insn;

	return label;
	}

	#ifdef HAVE_cc0
	/* INSN uses CC0 and is being moved into a delay slot. Set up REG_CC_SETTER
	and REG_CC_USER notes so we can find it. */

	void
	link_cc0_insns (rtx insn)
	{
	rtx user = next_nonnote_insn (insn);

	if (NONJUMP_INSN_P (user) && GET_CODE (PATTERN (user)) == SEQUENCE)
	user = XVECEXP (PATTERN (user), 0, 0);

	REG_NOTES (user) = gen_rtx_INSN_LIST (REG_CC_SETTER, insn,
	REG_NOTES (user));
	REG_NOTES (insn) = gen_rtx_INSN_LIST (REG_CC_USER, user, REG_NOTES (insn));
	}

	/* Return the next insn that uses CC0 after INSN, which is assumed to
	set it. This is the inverse of prev_cc0_setter (i.e., prev_cc0_setter
	applied to the result of this function should yield INSN).

	Normally, this is simply the next insn. However, if a REG_CC_USER note
	is present, it contains the insn that uses CC0.

	Return 0 if we can't find the insn. */

	rtx
	next_cc0_user (rtx insn)
	{
	rtx note = find_reg_note (insn, REG_CC_USER, NULL_RTX);

	if (note)
	return XEXP (note, 0);

	insn = next_nonnote_insn (insn);
	if (insn && NONJUMP_INSN_P (insn) && GET_CODE (PATTERN (insn)) == SEQUENCE)
	insn = XVECEXP (PATTERN (insn), 0, 0);

	if (insn && INSN_P (insn) && reg_mentioned_p (cc0_rtx, PATTERN (insn)))
	return insn;

	return 0;
	}

	/* Find the insn that set CC0 for INSN. Unless INSN has a REG_CC_SETTER
	note, it is the previous insn. */

	rtx
	prev_cc0_setter (rtx insn)
	{
	rtx note = find_reg_note (insn, REG_CC_SETTER, NULL_RTX);

	if (note)
	return XEXP (note, 0);

	insn = prev_nonnote_insn (insn);
	gcc_assert (sets_cc0_p (PATTERN (insn)));

	return insn;
	}
	#endif

	/* Increment the label uses for all labels present in rtx. */

	static void
	mark_label_nuses (rtx x)
	{
	enum rtx_code code;
	int i, j;
	const char *fmt;

	code = GET_CODE (x);
	if (code == LABEL_REF && LABEL_P (XEXP (x, 0)))
	LABEL_NUSES (XEXP (x, 0))++;

	fmt = GET_RTX_FORMAT (code);
	for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
	{
	if (fmt[i] == 'e')
	mark_label_nuses (XEXP (x, i));
	else if (fmt[i] == 'E')
	for (j = XVECLEN (x, i) - 1; j >= 0; j--)
	mark_label_nuses (XVECEXP (x, i, j));
	}
	}


	/* Try splitting insns that can be split for better scheduling.
	PAT is the pattern which might split.
	TRIAL is the insn providing PAT.
	LAST is nonzero if we should return the last insn of the sequence produced.

	If this routine succeeds in splitting, it returns the first or last
	replacement insn depending on the value of LAST. Otherwise, it
	returns TRIAL. If the insn to be returned can be split, it will be. */

	rtx
	try_split (rtx pat, rtx trial, int last)
	{
	rtx before = PREV_INSN (trial);
	rtx after = NEXT_INSN (trial);
	int has_barrier = 0;
	rtx tem;
	rtx note, seq;
	int probability;
	rtx insn_last, insn;
	int njumps = 0;

	if (any_condjump_p (trial)
	&& (note = find_reg_note (trial, REG_BR_PROB, 0)))
	split_branch_probability = INTVAL (XEXP (note, 0));
	probability = split_branch_probability;

	seq = split_insns (pat, trial);

	split_branch_probability = -1;

	/* If we are splitting a JUMP_INSN, it might be followed by a BARRIER.
	We may need to handle this specially. */
	if (after && BARRIER_P (after))
	{
	has_barrier = 1;
	after = NEXT_INSN (after);
	}

	if (!seq)
	return trial;

	/* Avoid infinite loop if any insn of the result matches
	the original pattern. */
	insn_last = seq;
	while (1)
	{
	if (INSN_P (insn_last)
	&& rtx_equal_p (PATTERN (insn_last), pat))
	return trial;
	if (!NEXT_INSN (insn_last))
	break;
	insn_last = NEXT_INSN (insn_last);
	}

	/* Mark labels. */
	for (insn = insn_last; insn ; insn = PREV_INSN (insn))
	{
	if (JUMP_P (insn))
	{
	mark_jump_label (PATTERN (insn), insn, 0);
	njumps++;
	if (probability != -1
	&& any_condjump_p (insn)
	&& !find_reg_note (insn, REG_BR_PROB, 0))
	{
	/* We can preserve the REG_BR_PROB notes only if exactly
	one jump is created, otherwise the machine description
	is responsible for this step using
	split_branch_probability variable. */
	gcc_assert (njumps == 1);
	REG_NOTES (insn)
	= gen_rtx_EXPR_LIST (REG_BR_PROB,
	GEN_INT (probability),
	REG_NOTES (insn));
	}
	}
	}

	/* If we are splitting a CALL_INSN, look for the CALL_INSN
	in SEQ and copy our CALL_INSN_FUNCTION_USAGE to it. */
	if (CALL_P (trial))
	{
	for (insn = insn_last; insn ; insn = PREV_INSN (insn))
	if (CALL_P (insn))
	{
	rtx *p = &CALL_INSN_FUNCTION_USAGE (insn);
	while (*p)
	p = &XEXP (*p, 1);
	*p = CALL_INSN_FUNCTION_USAGE (trial);
	SIBLING_CALL_P (insn) = SIBLING_CALL_P (trial);
	}
	}

	/* Copy notes, particularly those related to the CFG. */
	for (note = REG_NOTES (trial); note; note = XEXP (note, 1))
	{
	switch (REG_NOTE_KIND (note))
	{
	case REG_EH_REGION:
	insn = insn_last;
	while (insn != NULL_RTX)
	{
	if (CALL_P (insn)
	\|\| (flag_non_call_exceptions && INSN_P (insn)
	&& may_trap_p (PATTERN (insn))))
	REG_NOTES (insn)
	= gen_rtx_EXPR_LIST (REG_EH_REGION,
	XEXP (note, 0),
	REG_NOTES (insn));
	insn = PREV_INSN (insn);
	}
	break;

	case REG_NORETURN:
	case REG_SETJMP:
	insn = insn_last;
	while (insn != NULL_RTX)
	{
	if (CALL_P (insn))
	REG_NOTES (insn)
	= gen_rtx_EXPR_LIST (GET_MODE (note),
	XEXP (note, 0),
	REG_NOTES (insn));
	insn = PREV_INSN (insn);
	}
	break;

	case REG_NON_LOCAL_GOTO:
	insn = insn_last;
	while (insn != NULL_RTX)
	{
	if (JUMP_P (insn))
	REG_NOTES (insn)
	= gen_rtx_EXPR_LIST (GET_MODE (note),
	XEXP (note, 0),
	REG_NOTES (insn));
	insn = PREV_INSN (insn);
	}
	break;

	default:
	break;
	}
	}

	/* If there are LABELS inside the split insns increment the
	usage count so we don't delete the label. */
	if (NONJUMP_INSN_P (trial))
	{
	insn = insn_last;
	while (insn != NULL_RTX)
	{
	if (NONJUMP_INSN_P (insn))
	mark_label_nuses (PATTERN (insn));

	insn = PREV_INSN (insn);
	}
	}

	tem = emit_insn_after_setloc (seq, trial, INSN_LOCATOR (trial));

	delete_insn (trial);
	if (has_barrier)
	emit_barrier_after (tem);

	/* Recursively call try_split for each new insn created; by the
	time control returns here that insn will be fully split, so
	set LAST and continue from the insn after the one returned.
	We can't use next_active_insn here since AFTER may be a note.
	Ignore deleted insns, which can be occur if not optimizing. */
	for (tem = NEXT_INSN (before); tem != after; tem = NEXT_INSN (tem))
	if (! INSN_DELETED_P (tem) && INSN_P (tem))
	tem = try_split (PATTERN (tem), tem, 1);

	/* Return either the first or the last insn, depending on which was
	requested. */
	return last
	? (after ? PREV_INSN (after) : last_insn)
	: NEXT_INSN (before);
	}

	/* Make and return an INSN rtx, initializing all its slots.
	Store PATTERN in the pattern slots. */

	rtx
	make_insn_raw (rtx pattern)
	{
	rtx insn;

	insn = rtx_alloc (INSN);

	INSN_UID (insn) = cur_insn_uid++;
	PATTERN (insn) = pattern;
	INSN_CODE (insn) = -1;
	LOG_LINKS (insn) = NULL;
	REG_NOTES (insn) = NULL;
	INSN_LOCATOR (insn) = 0;
	BLOCK_FOR_INSN (insn) = NULL;

	#ifdef ENABLE_RTL_CHECKING
	if (insn
	&& INSN_P (insn)
	&& (returnjump_p (insn)
	\|\| (GET_CODE (insn) == SET
	&& SET_DEST (insn) == pc_rtx)))
	{
	warning (0, "ICE: emit_insn used where emit_jump_insn needed:\n");
	debug_rtx (insn);
	}
	#endif

	return insn;
	}

	/* Like `make_insn_raw' but make a JUMP_INSN instead of an insn. */

	rtx
	make_jump_insn_raw (rtx pattern)
	{
	rtx insn;

	insn = rtx_alloc (JUMP_INSN);
	INSN_UID (insn) = cur_insn_uid++;

	PATTERN (insn) = pattern;
	INSN_CODE (insn) = -1;
	LOG_LINKS (insn) = NULL;
	REG_NOTES (insn) = NULL;
	JUMP_LABEL (insn) = NULL;
	INSN_LOCATOR (insn) = 0;
	BLOCK_FOR_INSN (insn) = NULL;

	return insn;
	}

	/* Like `make_insn_raw' but make a CALL_INSN instead of an insn. */

	static rtx
	make_call_insn_raw (rtx pattern)
	{
	rtx insn;

	insn = rtx_alloc (CALL_INSN);
	INSN_UID (insn) = cur_insn_uid++;

	PATTERN (insn) = pattern;
	INSN_CODE (insn) = -1;
	LOG_LINKS (insn) = NULL;
	REG_NOTES (insn) = NULL;
	CALL_INSN_FUNCTION_USAGE (insn) = NULL;
	INSN_LOCATOR (insn) = 0;
	BLOCK_FOR_INSN (insn) = NULL;

	return insn;
	}

	/* Add INSN to the end of the doubly-linked list.
	INSN may be an INSN, JUMP_INSN, CALL_INSN, CODE_LABEL, BARRIER or NOTE. */

	void
	add_insn (rtx insn)
	{
	PREV_INSN (insn) = last_insn;
	NEXT_INSN (insn) = 0;

	if (NULL != last_insn)
	NEXT_INSN (last_insn) = insn;

	if (NULL == first_insn)
	first_insn = insn;

	last_insn = insn;
	}

	/* Add INSN into the doubly-linked list after insn AFTER. This and
	the next should be the only functions called to insert an insn once
	delay slots have been filled since only they know how to update a
	SEQUENCE. */

	void
	add_insn_after (rtx insn, rtx after)
	{
	rtx next = NEXT_INSN (after);
	basic_block bb;

	gcc_assert (!optimize \|\| !INSN_DELETED_P (after));

	NEXT_INSN (insn) = next;
	PREV_INSN (insn) = after;

	if (next)
	{
	PREV_INSN (next) = insn;
	if (NONJUMP_INSN_P (next) && GET_CODE (PATTERN (next)) == SEQUENCE)
	PREV_INSN (XVECEXP (PATTERN (next), 0, 0)) = insn;
	}
	else if (last_insn == after)
	last_insn = insn;
	else
	{
	struct sequence_stack *stack = seq_stack;
	/* Scan all pending sequences too. */
	for (; stack; stack = stack->next)
	if (after == stack->last)
	{
	stack->last = insn;
	break;
	}

	gcc_assert (stack);
	}

	if (!BARRIER_P (after)
	&& !BARRIER_P (insn)
	&& (bb = BLOCK_FOR_INSN (after)))
	{
	set_block_for_insn (insn, bb);
	if (INSN_P (insn))
	bb->flags \|= BB_DIRTY;
	/* Should not happen as first in the BB is always
	either NOTE or LABEL. */
	if (BB_END (bb) == after
	/* Avoid clobbering of structure when creating new BB. */
	&& !BARRIER_P (insn)
	&& (!NOTE_P (insn)
	\|\| NOTE_LINE_NUMBER (insn) != NOTE_INSN_BASIC_BLOCK))
	BB_END (bb) = insn;
	}

	NEXT_INSN (after) = insn;
	if (NONJUMP_INSN_P (after) && GET_CODE (PATTERN (after)) == SEQUENCE)
	{
	rtx sequence = PATTERN (after);
	NEXT_INSN (XVECEXP (sequence, 0, XVECLEN (sequence, 0) - 1)) = insn;
	}
	}

	/* Add INSN into the doubly-linked list before insn BEFORE. This and
	the previous should be the only functions called to insert an insn once
	delay slots have been filled since only they know how to update a
	SEQUENCE. */

	void
	add_insn_before (rtx insn, rtx before)
	{
	rtx prev = PREV_INSN (before);
	basic_block bb;

	gcc_assert (!optimize \|\| !INSN_DELETED_P (before));

	PREV_INSN (insn) = prev;
	NEXT_INSN (insn) = before;

	if (prev)
	{
	NEXT_INSN (prev) = insn;
	if (NONJUMP_INSN_P (prev) && GET_CODE (PATTERN (prev)) == SEQUENCE)
	{
	rtx sequence = PATTERN (prev);
	NEXT_INSN (XVECEXP (sequence, 0, XVECLEN (sequence, 0) - 1)) = insn;
	}
	}
	else if (first_insn == before)
	first_insn = insn;
	else
	{
	struct sequence_stack *stack = seq_stack;
	/* Scan all pending sequences too. */
	for (; stack; stack = stack->next)
	if (before == stack->first)
	{
	stack->first = insn;
	break;
	}

	gcc_assert (stack);
	}

	if (!BARRIER_P (before)
	&& !BARRIER_P (insn)
	&& (bb = BLOCK_FOR_INSN (before)))
	{
	set_block_for_insn (insn, bb);
	if (INSN_P (insn))
	bb->flags \|= BB_DIRTY;
	/* Should not happen as first in the BB is always either NOTE or
	LABEL. */
	gcc_assert (BB_HEAD (bb) != insn
	/* Avoid clobbering of structure when creating new BB. */
	\|\| BARRIER_P (insn)
	\|\| (NOTE_P (insn)
	&& NOTE_LINE_NUMBER (insn) == NOTE_INSN_BASIC_BLOCK));
	}

	PREV_INSN (before) = insn;
	if (NONJUMP_INSN_P (before) && GET_CODE (PATTERN (before)) == SEQUENCE)
	PREV_INSN (XVECEXP (PATTERN (before), 0, 0)) = insn;
	}

	/* Remove an insn from its doubly-linked list. This function knows how
	to handle sequences. */
	void
	remove_insn (rtx insn)
	{
	rtx next = NEXT_INSN (insn);
	rtx prev = PREV_INSN (insn);
	basic_block bb;

	if (prev)
	{
	NEXT_INSN (prev) = next;
	if (NONJUMP_INSN_P (prev) && GET_CODE (PATTERN (prev)) == SEQUENCE)
	{
	rtx sequence = PATTERN (prev);
	NEXT_INSN (XVECEXP (sequence, 0, XVECLEN (sequence, 0) - 1)) = next;
	}
	}
	else if (first_insn == insn)
	first_insn = next;
	else
	{
	struct sequence_stack *stack = seq_stack;
	/* Scan all pending sequences too. */
	for (; stack; stack = stack->next)
	if (insn == stack->first)
	{
	stack->first = next;
	break;
	}

	gcc_assert (stack);
	}

	if (next)
	{
	PREV_INSN (next) = prev;
	if (NONJUMP_INSN_P (next) && GET_CODE (PATTERN (next)) == SEQUENCE)
	PREV_INSN (XVECEXP (PATTERN (next), 0, 0)) = prev;
	}
	else if (last_insn == insn)
	last_insn = prev;
	else
	{
	struct sequence_stack *stack = seq_stack;
	/* Scan all pending sequences too. */
	for (; stack; stack = stack->next)
	if (insn == stack->last)
	{
	stack->last = prev;
	break;
	}

	gcc_assert (stack);
	}
	if (!BARRIER_P (insn)
	&& (bb = BLOCK_FOR_INSN (insn)))
	{
	if (INSN_P (insn))
	bb->flags \|= BB_DIRTY;
	if (BB_HEAD (bb) == insn)
	{
	/* Never ever delete the basic block note without deleting whole
	basic block. */
	gcc_assert (!NOTE_P (insn));
	BB_HEAD (bb) = next;
	}
	if (BB_END (bb) == insn)
	BB_END (bb) = prev;
	}
	}

	/* Append CALL_FUSAGE to the CALL_INSN_FUNCTION_USAGE for CALL_INSN. */

	void
	add_function_usage_to (rtx call_insn, rtx call_fusage)
	{
	gcc_assert (call_insn && CALL_P (call_insn));

	/* Put the register usage information on the CALL. If there is already
	some usage information, put ours at the end. */
	if (CALL_INSN_FUNCTION_USAGE (call_insn))
	{
	rtx link;

	for (link = CALL_INSN_FUNCTION_USAGE (call_insn); XEXP (link, 1) != 0;
	link = XEXP (link, 1))
	;

	XEXP (link, 1) = call_fusage;
	}
	else
	CALL_INSN_FUNCTION_USAGE (call_insn) = call_fusage;
	}

	/* Delete all insns made since FROM.
	FROM becomes the new last instruction. */

	void
	delete_insns_since (rtx from)
	{
	if (from == 0)
	first_insn = 0;
	else
	NEXT_INSN (from) = 0;
	last_insn = from;
	}

	/* This function is deprecated, please use sequences instead.

	Move a consecutive bunch of insns to a different place in the chain.
	The insns to be moved are those between FROM and TO.
	They are moved to a new position after the insn AFTER.
	AFTER must not be FROM or TO or any insn in between.

	This function does not know about SEQUENCEs and hence should not be
	called after delay-slot filling has been done. */

	void
	reorder_insns_nobb (rtx from, rtx to, rtx after)
	{
	/* Splice this bunch out of where it is now. */
	if (PREV_INSN (from))
	NEXT_INSN (PREV_INSN (from)) = NEXT_INSN (to);
	if (NEXT_INSN (to))
	PREV_INSN (NEXT_INSN (to)) = PREV_INSN (from);
	if (last_insn == to)
	last_insn = PREV_INSN (from);
	if (first_insn == from)
	first_insn = NEXT_INSN (to);

	/* Make the new neighbors point to it and it to them. */
	if (NEXT_INSN (after))
	PREV_INSN (NEXT_INSN (after)) = to;

	NEXT_INSN (to) = NEXT_INSN (after);
	PREV_INSN (from) = after;
	NEXT_INSN (after) = from;
	if (after == last_insn)
	last_insn = to;
	}

	/* Same as function above, but take care to update BB boundaries. */
	void
	reorder_insns (rtx from, rtx to, rtx after)
	{
	rtx prev = PREV_INSN (from);
	basic_block bb, bb2;

	reorder_insns_nobb (from, to, after);

	if (!BARRIER_P (after)
	&& (bb = BLOCK_FOR_INSN (after)))
	{
	rtx x;
	bb->flags \|= BB_DIRTY;

	if (!BARRIER_P (from)
	&& (bb2 = BLOCK_FOR_INSN (from)))
	{
	if (BB_END (bb2) == to)
	BB_END (bb2) = prev;
	bb2->flags \|= BB_DIRTY;
	}

	if (BB_END (bb) == after)
	BB_END (bb) = to;

	for (x = from; x != NEXT_INSN (to); x = NEXT_INSN (x))
	if (!BARRIER_P (x))
	set_block_for_insn (x, bb);
	}
	}

	/* Return the line note insn preceding INSN. */

	static rtx
	find_line_note (rtx insn)
	{
	if (no_line_numbers)
	return 0;

	for (; insn; insn = PREV_INSN (insn))
	if (NOTE_P (insn)
	&& NOTE_LINE_NUMBER (insn) >= 0)
	break;

	return insn;
	}


	/* Emit insn(s) of given code and pattern
	at a specified place within the doubly-linked list.

	All of the emit_foo global entry points accept an object
	X which is either an insn list or a PATTERN of a single
	instruction.

	There are thus a few canonical ways to generate code and
	emit it at a specific place in the instruction stream. For
	example, consider the instruction named SPOT and the fact that
	we would like to emit some instructions before SPOT. We might
	do it like this:

	start_sequence ();
	... emit the new instructions ...
	insns_head = get_insns ();
	end_sequence ();

	emit_insn_before (insns_head, SPOT);

	It used to be common to generate SEQUENCE rtl instead, but that
	is a relic of the past which no longer occurs. The reason is that
	SEQUENCE rtl results in much fragmented RTL memory since the SEQUENCE
	generated would almost certainly die right after it was created. */

	/* Make X be output before the instruction BEFORE. */

	rtx
	emit_insn_before_noloc (rtx x, rtx before)
	{
	rtx last = before;
	rtx insn;

	gcc_assert (before);

	if (x == NULL_RTX)
	return last;

	switch (GET_CODE (x))
	{
	case INSN:
	case JUMP_INSN:
	case CALL_INSN:
	case CODE_LABEL:
	case BARRIER:
	case NOTE:
	insn = x;
	while (insn)
	{
	rtx next = NEXT_INSN (insn);
	add_insn_before (insn, before);
	last = insn;
	insn = next;
	}
	break;

	#ifdef ENABLE_RTL_CHECKING
	case SEQUENCE:
	gcc_unreachable ();
	break;
	#endif

	default:
	last = make_insn_raw (x);
	add_insn_before (last, before);
	break;
	}

	return last;
	}

	/* Make an instruction with body X and code JUMP_INSN
	and output it before the instruction BEFORE. */

	rtx
	emit_jump_insn_before_noloc (rtx x, rtx before)
	{
	rtx insn, last = NULL_RTX;

	gcc_assert (before);

	switch (GET_CODE (x))
	{
	case INSN:
	case JUMP_INSN:
	case CALL_INSN:
	case CODE_LABEL:
	case BARRIER:
	case NOTE:
	insn = x;
	while (insn)
	{
	rtx next = NEXT_INSN (insn);
	add_insn_before (insn, before);
	last = insn;
	insn = next;
	}
	break;

	#ifdef ENABLE_RTL_CHECKING
	case SEQUENCE:
	gcc_unreachable ();
	break;
	#endif

	default:
	last = make_jump_insn_raw (x);
	add_insn_before (last, before);
	break;
	}

	return last;
	}

	/* Make an instruction with body X and code CALL_INSN
	and output it before the instruction BEFORE. */

	rtx
	emit_call_insn_before_noloc (rtx x, rtx before)
	{
	rtx last = NULL_RTX, insn;

	gcc_assert (before);

	switch (GET_CODE (x))
	{
	case INSN:
	case JUMP_INSN:
	case CALL_INSN:
	case CODE_LABEL:
	case BARRIER:
	case NOTE:
	insn = x;
	while (insn)
	{
	rtx next = NEXT_INSN (insn);
	add_insn_before (insn, before);
	last = insn;
	insn = next;
	}
	break;

	#ifdef ENABLE_RTL_CHECKING
	case SEQUENCE:
	gcc_unreachable ();
	break;
	#endif

	default:
	last = make_call_insn_raw (x);
	add_insn_before (last, before);
	break;
	}

	return last;
	}

	/* Make an insn of code BARRIER
	and output it before the insn BEFORE. */

	rtx
	emit_barrier_before (rtx before)
	{
	rtx insn = rtx_alloc (BARRIER);

	INSN_UID (insn) = cur_insn_uid++;

	add_insn_before (insn, before);
	return insn;
	}

	/* Emit the label LABEL before the insn BEFORE. */

	rtx
	emit_label_before (rtx label, rtx before)
	{
	/* This can be called twice for the same label as a result of the
	confusion that follows a syntax error! So make it harmless. */
	if (INSN_UID (label) == 0)
	{
	INSN_UID (label) = cur_insn_uid++;
	add_insn_before (label, before);
	}

	return label;
	}

	/* Emit a note of subtype SUBTYPE before the insn BEFORE. */

	rtx
	emit_note_before (int subtype, rtx before)
	{
	rtx note = rtx_alloc (NOTE);
	INSN_UID (note) = cur_insn_uid++;
	#ifndef USE_MAPPED_LOCATION
	NOTE_SOURCE_FILE (note) = 0;
	#endif
	NOTE_LINE_NUMBER (note) = subtype;
	BLOCK_FOR_INSN (note) = NULL;

	add_insn_before (note, before);
	return note;
	}

	/* Helper for emit_insn_after, handles lists of instructions
	efficiently. */

	static rtx emit_insn_after_1 (rtx, rtx);

	static rtx
	emit_insn_after_1 (rtx first, rtx after)
	{
	rtx last;
	rtx after_after;
	basic_block bb;

	if (!BARRIER_P (after)
	&& (bb = BLOCK_FOR_INSN (after)))
	{
	bb->flags \|= BB_DIRTY;
	for (last = first; NEXT_INSN (last); last = NEXT_INSN (last))
	if (!BARRIER_P (last))
	set_block_for_insn (last, bb);
	if (!BARRIER_P (last))
	set_block_for_insn (last, bb);
	if (BB_END (bb) == after)
	BB_END (bb) = last;
	}
	else
	for (last = first; NEXT_INSN (last); last = NEXT_INSN (last))
	continue;

	after_after = NEXT_INSN (after);

	NEXT_INSN (after) = first;
	PREV_INSN (first) = after;
	NEXT_INSN (last) = after_after;
	if (after_after)
	PREV_INSN (after_after) = last;

	if (after == last_insn)
	last_insn = last;
	return last;
	}

	/* Make X be output after the insn AFTER. */

	rtx
	emit_insn_after_noloc (rtx x, rtx after)
	{
	rtx last = after;

	gcc_assert (after);

	if (x == NULL_RTX)
	return last;

	switch (GET_CODE (x))
	{
	case INSN:
	case JUMP_INSN:
	case CALL_INSN:
	case CODE_LABEL:
	case BARRIER:
	case NOTE:
	last = emit_insn_after_1 (x, after);
	break;

	#ifdef ENABLE_RTL_CHECKING
	case SEQUENCE:
	gcc_unreachable ();
	break;
	#endif

	default:
	last = make_insn_raw (x);
	add_insn_after (last, after);
	break;
	}

	return last;
	}

	/* Similar to emit_insn_after, except that line notes are to be inserted so
	as to act as if this insn were at FROM. */

	void
	emit_insn_after_with_line_notes (rtx x, rtx after, rtx from)
	{
	rtx from_line = find_line_note (from);
	rtx after_line = find_line_note (after);
	rtx insn = emit_insn_after (x, after);

	if (from_line)
	emit_note_copy_after (from_line, after);

	if (after_line)
	emit_note_copy_after (after_line, insn);
	}

	/* Make an insn of code JUMP_INSN with body X
	and output it after the insn AFTER. */

	rtx
	emit_jump_insn_after_noloc (rtx x, rtx after)
	{
	rtx last;

	gcc_assert (after);

	switch (GET_CODE (x))
	{
	case INSN:
	case JUMP_INSN:
	case CALL_INSN:
	case CODE_LABEL:
	case BARRIER:
	case NOTE:
	last = emit_insn_after_1 (x, after);
	break;

	#ifdef ENABLE_RTL_CHECKING
	case SEQUENCE:
	gcc_unreachable ();
	break;
	#endif

	default:
	last = make_jump_insn_raw (x);
	add_insn_after (last, after);
	break;
	}

	return last;
	}

	/* Make an instruction with body X and code CALL_INSN
	and output it after the instruction AFTER. */

	rtx
	emit_call_insn_after_noloc (rtx x, rtx after)
	{
	rtx last;

	gcc_assert (after);

	switch (GET_CODE (x))
	{
	case INSN:
	case JUMP_INSN:
	case CALL_INSN:
	case CODE_LABEL:
	case BARRIER:
	case NOTE:
	last = emit_insn_after_1 (x, after);
	break;

	#ifdef ENABLE_RTL_CHECKING
	case SEQUENCE:
	gcc_unreachable ();
	break;
	#endif

	default:
	last = make_call_insn_raw (x);
	add_insn_after (last, after);
	break;
	}

	return last;
	}

	/* Make an insn of code BARRIER
	and output it after the insn AFTER. */

	rtx
	emit_barrier_after (rtx after)
	{
	rtx insn = rtx_alloc (BARRIER);

	INSN_UID (insn) = cur_insn_uid++;

	add_insn_after (insn, after);
	return insn;
	}

	/* Emit the label LABEL after the insn AFTER. */

	rtx
	emit_label_after (rtx label, rtx after)
	{
	/* This can be called twice for the same label
	as a result of the confusion that follows a syntax error!
	So make it harmless. */
	if (INSN_UID (label) == 0)
	{
	INSN_UID (label) = cur_insn_uid++;
	add_insn_after (label, after);
	}

	return label;
	}

	/* Emit a note of subtype SUBTYPE after the insn AFTER. */

	rtx
	emit_note_after (int subtype, rtx after)
	{
	rtx note = rtx_alloc (NOTE);
	INSN_UID (note) = cur_insn_uid++;
	#ifndef USE_MAPPED_LOCATION
	NOTE_SOURCE_FILE (note) = 0;
	#endif
	NOTE_LINE_NUMBER (note) = subtype;
	BLOCK_FOR_INSN (note) = NULL;
	add_insn_after (note, after);
	return note;
	}

	/* Emit a copy of note ORIG after the insn AFTER. */

	rtx
	emit_note_copy_after (rtx orig, rtx after)
	{
	rtx note;

	if (NOTE_LINE_NUMBER (orig) >= 0 && no_line_numbers)
	{
	cur_insn_uid++;
	return 0;
	}

	note = rtx_alloc (NOTE);
	INSN_UID (note) = cur_insn_uid++;
	NOTE_LINE_NUMBER (note) = NOTE_LINE_NUMBER (orig);
	NOTE_DATA (note) = NOTE_DATA (orig);
	BLOCK_FOR_INSN (note) = NULL;
	add_insn_after (note, after);
	return note;
	}

	/* Like emit_insn_after_noloc, but set INSN_LOCATOR according to SCOPE. */
	rtx
	emit_insn_after_setloc (rtx pattern, rtx after, int loc)
	{
	rtx last = emit_insn_after_noloc (pattern, after);

	if (pattern == NULL_RTX \|\| !loc)
	return last;

	after = NEXT_INSN (after);
	while (1)
	{
	if (active_insn_p (after) && !INSN_LOCATOR (after))
	INSN_LOCATOR (after) = loc;
	if (after == last)
	break;
	after = NEXT_INSN (after);
	}
	return last;
	}

	/* Like emit_insn_after_noloc, but set INSN_LOCATOR according to AFTER. */
	rtx
	emit_insn_after (rtx pattern, rtx after)
	{
	if (INSN_P (after))
	return emit_insn_after_setloc (pattern, after, INSN_LOCATOR (after));
	else
	return emit_insn_after_noloc (pattern, after);
	}

	/* Like emit_jump_insn_after_noloc, but set INSN_LOCATOR according to SCOPE. */
	rtx
	emit_jump_insn_after_setloc (rtx pattern, rtx after, int loc)
	{
	rtx last = emit_jump_insn_after_noloc (pattern, after);

	if (pattern == NULL_RTX \|\| !loc)
	return last;

	after = NEXT_INSN (after);
	while (1)
	{
	if (active_insn_p (after) && !INSN_LOCATOR (after))
	INSN_LOCATOR (after) = loc;
	if (after == last)
	break;
	after = NEXT_INSN (after);
	}
	return last;
	}

	/* Like emit_jump_insn_after_noloc, but set INSN_LOCATOR according to AFTER. */
	rtx
	emit_jump_insn_after (rtx pattern, rtx after)
	{
	if (INSN_P (after))
	return emit_jump_insn_after_setloc (pattern, after, INSN_LOCATOR (after));
	else
	return emit_jump_insn_after_noloc (pattern, after);
	}

	/* Like emit_call_insn_after_noloc, but set INSN_LOCATOR according to SCOPE. */
	rtx
	emit_call_insn_after_setloc (rtx pattern, rtx after, int loc)
	{
	rtx last = emit_call_insn_after_noloc (pattern, after);

	if (pattern == NULL_RTX \|\| !loc)
	return last;

	after = NEXT_INSN (after);
	while (1)
	{
	if (active_insn_p (after) && !INSN_LOCATOR (after))
	INSN_LOCATOR (after) = loc;
	if (after == last)
	break;
	after = NEXT_INSN (after);
	}
	return last;
	}

	/* Like emit_call_insn_after_noloc, but set INSN_LOCATOR according to AFTER. */
	rtx
	emit_call_insn_after (rtx pattern, rtx after)
	{
	if (INSN_P (after))
	return emit_call_insn_after_setloc (pattern, after, INSN_LOCATOR (after));
	else
	return emit_call_insn_after_noloc (pattern, after);
	}

	/* Like emit_insn_before_noloc, but set INSN_LOCATOR according to SCOPE. */
	rtx
	emit_insn_before_setloc (rtx pattern, rtx before, int loc)
	{
	rtx first = PREV_INSN (before);
	rtx last = emit_insn_before_noloc (pattern, before);

	if (pattern == NULL_RTX \|\| !loc)
	return last;

	first = NEXT_INSN (first);
	while (1)
	{
	if (active_insn_p (first) && !INSN_LOCATOR (first))
	INSN_LOCATOR (first) = loc;
	if (first == last)
	break;
	first = NEXT_INSN (first);
	}
	return last;
	}

	/* Like emit_insn_before_noloc, but set INSN_LOCATOR according to BEFORE. */
	rtx
	emit_insn_before (rtx pattern, rtx before)
	{
	if (INSN_P (before))
	return emit_insn_before_setloc (pattern, before, INSN_LOCATOR (before));
	else
	return emit_insn_before_noloc (pattern, before);
	}

	/* like emit_insn_before_noloc, but set insn_locator according to scope. */
	rtx
	emit_jump_insn_before_setloc (rtx pattern, rtx before, int loc)
	{
	rtx first = PREV_INSN (before);
	rtx last = emit_jump_insn_before_noloc (pattern, before);

	if (pattern == NULL_RTX)
	return last;

	first = NEXT_INSN (first);
	while (1)
	{
	if (active_insn_p (first) && !INSN_LOCATOR (first))
	INSN_LOCATOR (first) = loc;
	if (first == last)
	break;
	first = NEXT_INSN (first);
	}
	return last;
	}

	/* Like emit_jump_insn_before_noloc, but set INSN_LOCATOR according to BEFORE. */
	rtx
	emit_jump_insn_before (rtx pattern, rtx before)
	{
	if (INSN_P (before))
	return emit_jump_insn_before_setloc (pattern, before, INSN_LOCATOR (before));
	else
	return emit_jump_insn_before_noloc (pattern, before);
	}

	/* like emit_insn_before_noloc, but set insn_locator according to scope. */
	rtx
	emit_call_insn_before_setloc (rtx pattern, rtx before, int loc)
	{
	rtx first = PREV_INSN (before);
	rtx last = emit_call_insn_before_noloc (pattern, before);

	if (pattern == NULL_RTX)
	return last;

	first = NEXT_INSN (first);
	while (1)
	{
	if (active_insn_p (first) && !INSN_LOCATOR (first))
	INSN_LOCATOR (first) = loc;
	if (first == last)
	break;
	first = NEXT_INSN (first);
	}
	return last;
	}

	/* like emit_call_insn_before_noloc,
	but set insn_locator according to before. */
	rtx
	emit_call_insn_before (rtx pattern, rtx before)
	{
	if (INSN_P (before))
	return emit_call_insn_before_setloc (pattern, before, INSN_LOCATOR (before));
	else
	return emit_call_insn_before_noloc (pattern, before);
	}

	/* Take X and emit it at the end of the doubly-linked
	INSN list.

	Returns the last insn emitted. */

	rtx
	emit_insn (rtx x)
	{
	rtx last = last_insn;
	rtx insn;

	if (x == NULL_RTX)
	return last;

	switch (GET_CODE (x))
	{
	case INSN:
	case JUMP_INSN:
	case CALL_INSN:
	case CODE_LABEL:
	case BARRIER:
	case NOTE:
	insn = x;
	while (insn)
	{
	rtx next = NEXT_INSN (insn);
	add_insn (insn);
	last = insn;
	insn = next;
	}
	break;

	#ifdef ENABLE_RTL_CHECKING
	case SEQUENCE:
	gcc_unreachable ();
	break;
	#endif

	default:
	last = make_insn_raw (x);
	add_insn (last);
	break;
	}

	return last;
	}

	/* Make an insn of code JUMP_INSN with pattern X
	and add it to the end of the doubly-linked list. */

	rtx
	emit_jump_insn (rtx x)
	{
	rtx last = NULL_RTX, insn;

	switch (GET_CODE (x))
	{
	case INSN:
	case JUMP_INSN:
	case CALL_INSN:
	case CODE_LABEL:
	case BARRIER:
	case NOTE:
	insn = x;
	while (insn)
	{
	rtx next = NEXT_INSN (insn);
	add_insn (insn);
	last = insn;
	insn = next;
	}
	break;

	#ifdef ENABLE_RTL_CHECKING
	case SEQUENCE:
	gcc_unreachable ();
	break;
	#endif

	default:
	last = make_jump_insn_raw (x);
	add_insn (last);
	break;
	}

	return last;
	}

	/* Make an insn of code CALL_INSN with pattern X
	and add it to the end of the doubly-linked list. */

	rtx
	emit_call_insn (rtx x)
	{
	rtx insn;

	switch (GET_CODE (x))
	{
	case INSN:
	case JUMP_INSN:
	case CALL_INSN:
	case CODE_LABEL:
	case BARRIER:
	case NOTE:
	insn = emit_insn (x);
	break;

	#ifdef ENABLE_RTL_CHECKING
	case SEQUENCE:
	gcc_unreachable ();
	break;
	#endif

	default:
	insn = make_call_insn_raw (x);
	add_insn (insn);
	break;
	}

	return insn;
	}

	/* Add the label LABEL to the end of the doubly-linked list. */

	rtx
	emit_label (rtx label)
	{
	/* This can be called twice for the same label
	as a result of the confusion that follows a syntax error!
	So make it harmless. */
	if (INSN_UID (label) == 0)
	{
	INSN_UID (label) = cur_insn_uid++;
	add_insn (label);
	}
	return label;
	}

	/* Make an insn of code BARRIER
	and add it to the end of the doubly-linked list. */

	rtx
	emit_barrier (void)
	{
	rtx barrier = rtx_alloc (BARRIER);
	INSN_UID (barrier) = cur_insn_uid++;
	add_insn (barrier);
	return barrier;
	}

	/* Make line numbering NOTE insn for LOCATION add it to the end
	of the doubly-linked list, but only if line-numbers are desired for
	debugging info and it doesn't match the previous one. */

	rtx
	emit_line_note (location_t location)
	{
	rtx note;

	#ifdef USE_MAPPED_LOCATION
	if (location == last_location)
	return NULL_RTX;
	#else
	if (location.file && last_location.file
	&& !strcmp (location.file, last_location.file)
	&& location.line == last_location.line)
	return NULL_RTX;
	#endif
	last_location = location;

	if (no_line_numbers)
	{
	cur_insn_uid++;
	return NULL_RTX;
	}

	#ifdef USE_MAPPED_LOCATION
	note = emit_note ((int) location);
	#else
	note = emit_note (location.line);
	NOTE_SOURCE_FILE (note) = location.file;
	#endif

	return note;
	}

	/* Emit a copy of note ORIG. */

	rtx
	emit_note_copy (rtx orig)
	{
	rtx note;

	if (NOTE_LINE_NUMBER (orig) >= 0 && no_line_numbers)
	{
	cur_insn_uid++;
	return NULL_RTX;
	}

	note = rtx_alloc (NOTE);

	INSN_UID (note) = cur_insn_uid++;
	NOTE_DATA (note) = NOTE_DATA (orig);
	NOTE_LINE_NUMBER (note) = NOTE_LINE_NUMBER (orig);
	BLOCK_FOR_INSN (note) = NULL;
	add_insn (note);

	return note;
	}

	/* Make an insn of code NOTE or type NOTE_NO
	and add it to the end of the doubly-linked list. */

	rtx
	emit_note (int note_no)
	{
	rtx note;

	note = rtx_alloc (NOTE);
	INSN_UID (note) = cur_insn_uid++;
	NOTE_LINE_NUMBER (note) = note_no;
	memset (&NOTE_DATA (note), 0, sizeof (NOTE_DATA (note)));
	BLOCK_FOR_INSN (note) = NULL;
	add_insn (note);
	return note;
	}

	/* Cause next statement to emit a line note even if the line number
	has not changed. */

	void
	force_next_line_note (void)
	{
	#ifdef USE_MAPPED_LOCATION
	last_location = -1;
	#else
	last_location.line = -1;
	#endif
	}

	/* Place a note of KIND on insn INSN with DATUM as the datum. If a
	note of this type already exists, remove it first. */

	rtx
	set_unique_reg_note (rtx insn, enum reg_note kind, rtx datum)
	{
	rtx note = find_reg_note (insn, kind, NULL_RTX);

	switch (kind)
	{
	case REG_EQUAL:
	case REG_EQUIV:
	/* Don't add REG_EQUAL/REG_EQUIV notes if the insn
	has multiple sets (some callers assume single_set
	means the insn only has one set, when in fact it
	means the insn only has one * useful * set). */
	if (GET_CODE (PATTERN (insn)) == PARALLEL && multiple_sets (insn))
	{
	gcc_assert (!note);
	return NULL_RTX;
	}

	/* Don't add ASM_OPERAND REG_EQUAL/REG_EQUIV notes.
	It serves no useful purpose and breaks eliminate_regs. */
	if (GET_CODE (datum) == ASM_OPERANDS)
	return NULL_RTX;
	break;

	default:
	break;
	}

	if (note)
	{
	XEXP (note, 0) = datum;
	return note;
	}

	REG_NOTES (insn) = gen_rtx_EXPR_LIST ((enum machine_mode) kind, datum,
	REG_NOTES (insn));
	return REG_NOTES (insn);
	}

	/* Return an indication of which type of insn should have X as a body.
	The value is CODE_LABEL, INSN, CALL_INSN or JUMP_INSN. */

	static enum rtx_code
	classify_insn (rtx x)
	{
	if (LABEL_P (x))
	return CODE_LABEL;
	if (GET_CODE (x) == CALL)
	return CALL_INSN;
	if (GET_CODE (x) == RETURN)
	return JUMP_INSN;
	if (GET_CODE (x) == SET)
	{
	if (SET_DEST (x) == pc_rtx)
	return JUMP_INSN;
	else if (GET_CODE (SET_SRC (x)) == CALL)
	return CALL_INSN;
	else
	return INSN;
	}
	if (GET_CODE (x) == PARALLEL)
	{
	int j;
	for (j = XVECLEN (x, 0) - 1; j >= 0; j--)
	if (GET_CODE (XVECEXP (x, 0, j)) == CALL)
	return CALL_INSN;
	else if (GET_CODE (XVECEXP (x, 0, j)) == SET
	&& SET_DEST (XVECEXP (x, 0, j)) == pc_rtx)
	return JUMP_INSN;
	else if (GET_CODE (XVECEXP (x, 0, j)) == SET
	&& GET_CODE (SET_SRC (XVECEXP (x, 0, j))) == CALL)
	return CALL_INSN;
	}
	return INSN;
	}

	/* Emit the rtl pattern X as an appropriate kind of insn.
	If X is a label, it is simply added into the insn chain. */

	rtx
	emit (rtx x)
	{
	enum rtx_code code = classify_insn (x);

	switch (code)
	{
	case CODE_LABEL:
	return emit_label (x);
	case INSN:
	return emit_insn (x);
	case JUMP_INSN:
	{
	rtx insn = emit_jump_insn (x);
	if (any_uncondjump_p (insn) \|\| GET_CODE (x) == RETURN)
	return emit_barrier ();
	return insn;
	}
	case CALL_INSN:
	return emit_call_insn (x);
	default:
	gcc_unreachable ();
	}
	}

	/* Space for free sequence stack entries. */
	static GTY ((deletable)) struct sequence_stack *free_sequence_stack;

	/* Begin emitting insns to a sequence. If this sequence will contain
	something that might cause the compiler to pop arguments to function
	calls (because those pops have previously been deferred; see
	INHIBIT_DEFER_POP for more details), use do_pending_stack_adjust
	before calling this function. That will ensure that the deferred
	pops are not accidentally emitted in the middle of this sequence. */

	void
	start_sequence (void)
	{
	struct sequence_stack *tem;

	if (free_sequence_stack != NULL)
	{
	tem = free_sequence_stack;
	free_sequence_stack = tem->next;
	}
	else
	tem = ggc_alloc (sizeof (struct sequence_stack));

	tem->next = seq_stack;
	tem->first = first_insn;
	tem->last = last_insn;

	seq_stack = tem;

	first_insn = 0;
	last_insn = 0;
	}

	/* Set up the insn chain starting with FIRST as the current sequence,
	saving the previously current one. See the documentation for
	start_sequence for more information about how to use this function. */

	void
	push_to_sequence (rtx first)
	{
	rtx last;

	start_sequence ();

	for (last = first; last && NEXT_INSN (last); last = NEXT_INSN (last));

	first_insn = first;
	last_insn = last;
	}

	/* Set up the outer-level insn chain
	as the current sequence, saving the previously current one. */

	void
	push_topmost_sequence (void)
	{
	struct sequence_stack stack, top = NULL;

	start_sequence ();

	for (stack = seq_stack; stack; stack = stack->next)
	top = stack;

	first_insn = top->first;
	last_insn = top->last;
	}

	/* After emitting to the outer-level insn chain, update the outer-level
	insn chain, and restore the previous saved state. */

	void
	pop_topmost_sequence (void)
	{
	struct sequence_stack stack, top = NULL;

	for (stack = seq_stack; stack; stack = stack->next)
	top = stack;

	top->first = first_insn;
	top->last = last_insn;

	end_sequence ();
	}

	/* After emitting to a sequence, restore previous saved state.

	To get the contents of the sequence just made, you must call
	`get_insns' before calling here.

	If the compiler might have deferred popping arguments while
	generating this sequence, and this sequence will not be immediately
	inserted into the instruction stream, use do_pending_stack_adjust
	before calling get_insns. That will ensure that the deferred
	pops are inserted into this sequence, and not into some random
	location in the instruction stream. See INHIBIT_DEFER_POP for more
	information about deferred popping of arguments. */

	void
	end_sequence (void)
	{
	struct sequence_stack *tem = seq_stack;

	first_insn = tem->first;
	last_insn = tem->last;
	seq_stack = tem->next;

	memset (tem, 0, sizeof (*tem));
	tem->next = free_sequence_stack;
	free_sequence_stack = tem;
	}

	/* Return 1 if currently emitting into a sequence. */

	int
	in_sequence_p (void)
	{
	return seq_stack != 0;
	}

	/* Put the various virtual registers into REGNO_REG_RTX. */

	static void
	init_virtual_regs (struct emit_status *es)
	{
	rtx *ptr = es->x_regno_reg_rtx;
	ptr[VIRTUAL_INCOMING_ARGS_REGNUM] = virtual_incoming_args_rtx;
	ptr[VIRTUAL_STACK_VARS_REGNUM] = virtual_stack_vars_rtx;
	ptr[VIRTUAL_STACK_DYNAMIC_REGNUM] = virtual_stack_dynamic_rtx;
	ptr[VIRTUAL_OUTGOING_ARGS_REGNUM] = virtual_outgoing_args_rtx;
	ptr[VIRTUAL_CFA_REGNUM] = virtual_cfa_rtx;
	}


	/* Used by copy_insn_1 to avoid copying SCRATCHes more than once. */
	static rtx copy_insn_scratch_in[MAX_RECOG_OPERANDS];
	static rtx copy_insn_scratch_out[MAX_RECOG_OPERANDS];
	static int copy_insn_n_scratches;

	/* When an insn is being copied by copy_insn_1, this is nonzero if we have
	copied an ASM_OPERANDS.
	In that case, it is the original input-operand vector. */
	static rtvec orig_asm_operands_vector;

	/* When an insn is being copied by copy_insn_1, this is nonzero if we have
	copied an ASM_OPERANDS.
	In that case, it is the copied input-operand vector. */
	static rtvec copy_asm_operands_vector;

	/* Likewise for the constraints vector. */
	static rtvec orig_asm_constraints_vector;
	static rtvec copy_asm_constraints_vector;

	/* Recursively create a new copy of an rtx for copy_insn.
	This function differs from copy_rtx in that it handles SCRATCHes and
	ASM_OPERANDs properly.
	Normally, this function is not used directly; use copy_insn as front end.
	However, you could first copy an insn pattern with copy_insn and then use
	this function afterwards to properly copy any REG_NOTEs containing
	SCRATCHes. */

	rtx
	copy_insn_1 (rtx orig)
	{
	rtx copy;
	int i, j;
	RTX_CODE code;
	const char *format_ptr;

	code = GET_CODE (orig);

	switch (code)
	{
	case REG:
	case CONST_INT:
	case CONST_DOUBLE:
	case CONST_VECTOR:
	case SYMBOL_REF:
	case CODE_LABEL:
	case PC:
	case CC0:
	return orig;
	case CLOBBER:
	if (REG_P (XEXP (orig, 0)) && REGNO (XEXP (orig, 0)) < FIRST_PSEUDO_REGISTER)
	return orig;
	break;

	case SCRATCH:
	for (i = 0; i < copy_insn_n_scratches; i++)
	if (copy_insn_scratch_in[i] == orig)
	return copy_insn_scratch_out[i];
	break;

	case CONST:
	/* CONST can be shared if it contains a SYMBOL_REF. If it contains
	a LABEL_REF, it isn't sharable. */
	if (GET_CODE (XEXP (orig, 0)) == PLUS
	&& GET_CODE (XEXP (XEXP (orig, 0), 0)) == SYMBOL_REF
	&& GET_CODE (XEXP (XEXP (orig, 0), 1)) == CONST_INT)
	return orig;
	break;

	/* A MEM with a constant address is not sharable. The problem is that
	the constant address may need to be reloaded. If the mem is shared,
	then reloading one copy of this mem will cause all copies to appear
	to have been reloaded. */

	default:
	break;
	}

	/* Copy the various flags, fields, and other information. We assume
	that all fields need copying, and then clear the fields that should
	not be copied. That is the sensible default behavior, and forces
	us to explicitly document why we are not copying a flag. */
	copy = shallow_copy_rtx (orig);

	/* We do not copy the USED flag, which is used as a mark bit during
	walks over the RTL. */
	RTX_FLAG (copy, used) = 0;

	/* We do not copy JUMP, CALL, or FRAME_RELATED for INSNs. */
	if (INSN_P (orig))
	{
	RTX_FLAG (copy, jump) = 0;
	RTX_FLAG (copy, call) = 0;
	RTX_FLAG (copy, frame_related) = 0;
	}

	format_ptr = GET_RTX_FORMAT (GET_CODE (copy));

	for (i = 0; i < GET_RTX_LENGTH (GET_CODE (copy)); i++)
	switch (*format_ptr++)
	{
	case 'e':
	if (XEXP (orig, i) != NULL)
	XEXP (copy, i) = copy_insn_1 (XEXP (orig, i));
	break;

	case 'E':
	case 'V':
	if (XVEC (orig, i) == orig_asm_constraints_vector)
	XVEC (copy, i) = copy_asm_constraints_vector;
	else if (XVEC (orig, i) == orig_asm_operands_vector)
	XVEC (copy, i) = copy_asm_operands_vector;
	else if (XVEC (orig, i) != NULL)
	{
	XVEC (copy, i) = rtvec_alloc (XVECLEN (orig, i));
	for (j = 0; j < XVECLEN (copy, i); j++)
	XVECEXP (copy, i, j) = copy_insn_1 (XVECEXP (orig, i, j));
	}
	break;

	case 't':
	case 'w':
	case 'i':
	case 's':
	case 'S':
	case 'u':
	case '0':
	/* These are left unchanged. */
	break;

	default:
	gcc_unreachable ();
	}

	if (code == SCRATCH)
	{
	i = copy_insn_n_scratches++;
	gcc_assert (i < MAX_RECOG_OPERANDS);
	copy_insn_scratch_in[i] = orig;
	copy_insn_scratch_out[i] = copy;
	}
	else if (code == ASM_OPERANDS)
	{
	orig_asm_operands_vector = ASM_OPERANDS_INPUT_VEC (orig);
	copy_asm_operands_vector = ASM_OPERANDS_INPUT_VEC (copy);
	orig_asm_constraints_vector = ASM_OPERANDS_INPUT_CONSTRAINT_VEC (orig);
	copy_asm_constraints_vector = ASM_OPERANDS_INPUT_CONSTRAINT_VEC (copy);
	}

	return copy;
	}

	/* Create a new copy of an rtx.
	This function differs from copy_rtx in that it handles SCRATCHes and
	ASM_OPERANDs properly.
	INSN doesn't really have to be a full INSN; it could be just the
	pattern. */
	rtx
	copy_insn (rtx insn)
	{
	copy_insn_n_scratches = 0;
	orig_asm_operands_vector = 0;
	orig_asm_constraints_vector = 0;
	copy_asm_operands_vector = 0;
	copy_asm_constraints_vector = 0;
	return copy_insn_1 (insn);
	}

	/* Initialize data structures and variables in this file
	before generating rtl for each function. */

	void
	init_emit (void)
	{
	struct function *f = cfun;

	f->emit = ggc_alloc (sizeof (struct emit_status));
	first_insn = NULL;
	last_insn = NULL;
	cur_insn_uid = 1;
	reg_rtx_no = LAST_VIRTUAL_REGISTER + 1;
	last_location = UNKNOWN_LOCATION;
	first_label_num = label_num;
	seq_stack = NULL;

	/* Init the tables that describe all the pseudo regs. */

	f->emit->regno_pointer_align_length = LAST_VIRTUAL_REGISTER + 101;

	f->emit->regno_pointer_align
	= ggc_alloc_cleared (f->emit->regno_pointer_align_length
	* sizeof (unsigned char));

	regno_reg_rtx
	= ggc_alloc (f->emit->regno_pointer_align_length * sizeof (rtx));

	/* Put copies of all the hard registers into regno_reg_rtx. */
	memcpy (regno_reg_rtx,
	static_regno_reg_rtx,
	FIRST_PSEUDO_REGISTER * sizeof (rtx));

	/* Put copies of all the virtual register rtx into regno_reg_rtx. */
	init_virtual_regs (f->emit);

	/* Indicate that the virtual registers and stack locations are
	all pointers. */
	REG_POINTER (stack_pointer_rtx) = 1;
	REG_POINTER (frame_pointer_rtx) = 1;
	REG_POINTER (hard_frame_pointer_rtx) = 1;
	REG_POINTER (arg_pointer_rtx) = 1;

	REG_POINTER (virtual_incoming_args_rtx) = 1;
	REG_POINTER (virtual_stack_vars_rtx) = 1;
	REG_POINTER (virtual_stack_dynamic_rtx) = 1;
	REG_POINTER (virtual_outgoing_args_rtx) = 1;
	REG_POINTER (virtual_cfa_rtx) = 1;

	#ifdef STACK_BOUNDARY
	REGNO_POINTER_ALIGN (STACK_POINTER_REGNUM) = STACK_BOUNDARY;
	REGNO_POINTER_ALIGN (FRAME_POINTER_REGNUM) = STACK_BOUNDARY;
	REGNO_POINTER_ALIGN (HARD_FRAME_POINTER_REGNUM) = STACK_BOUNDARY;
	REGNO_POINTER_ALIGN (ARG_POINTER_REGNUM) = STACK_BOUNDARY;

	REGNO_POINTER_ALIGN (VIRTUAL_INCOMING_ARGS_REGNUM) = STACK_BOUNDARY;
	REGNO_POINTER_ALIGN (VIRTUAL_STACK_VARS_REGNUM) = STACK_BOUNDARY;
	REGNO_POINTER_ALIGN (VIRTUAL_STACK_DYNAMIC_REGNUM) = STACK_BOUNDARY;
	REGNO_POINTER_ALIGN (VIRTUAL_OUTGOING_ARGS_REGNUM) = STACK_BOUNDARY;
	REGNO_POINTER_ALIGN (VIRTUAL_CFA_REGNUM) = BITS_PER_WORD;
	#endif

	#ifdef INIT_EXPANDERS
	INIT_EXPANDERS;
	#endif
	}

	/* Generate a vector constant for mode MODE and constant value CONSTANT. */

	static rtx
	gen_const_vector (enum machine_mode mode, int constant)
	{
	rtx tem;
	rtvec v;
	int units, i;
	enum machine_mode inner;

	units = GET_MODE_NUNITS (mode);
	inner = GET_MODE_INNER (mode);

	gcc_assert (!DECIMAL_FLOAT_MODE_P (inner));

	v = rtvec_alloc (units);

	/* We need to call this function after we set the scalar const_tiny_rtx
	entries. */
	gcc_assert (const_tiny_rtx[constant][(int) inner]);

	for (i = 0; i < units; ++i)
	RTVEC_ELT (v, i) = const_tiny_rtx[constant][(int) inner];

	tem = gen_rtx_raw_CONST_VECTOR (mode, v);
	return tem;
	}

	/* Generate a vector like gen_rtx_raw_CONST_VEC, but use the zero vector when
	all elements are zero, and the one vector when all elements are one. */
	rtx
	gen_rtx_CONST_VECTOR (enum machine_mode mode, rtvec v)
	{
	enum machine_mode inner = GET_MODE_INNER (mode);
	int nunits = GET_MODE_NUNITS (mode);
	rtx x;
	int i;

	/* Check to see if all of the elements have the same value. */
	x = RTVEC_ELT (v, nunits - 1);
	for (i = nunits - 2; i >= 0; i--)
	if (RTVEC_ELT (v, i) != x)
	break;

	/* If the values are all the same, check to see if we can use one of the
	standard constant vectors. */
	if (i == -1)
	{
	if (x == CONST0_RTX (inner))
	return CONST0_RTX (mode);
	else if (x == CONST1_RTX (inner))
	return CONST1_RTX (mode);
	}

	return gen_rtx_raw_CONST_VECTOR (mode, v);
	}

	/* Create some permanent unique rtl objects shared between all functions.
	LINE_NUMBERS is nonzero if line numbers are to be generated. */

	void
	init_emit_once (int line_numbers)
	{
	int i;
	enum machine_mode mode;
	enum machine_mode double_mode;

	/* We need reg_raw_mode, so initialize the modes now. */
	init_reg_modes_once ();

	/* Initialize the CONST_INT, CONST_DOUBLE, and memory attribute hash
	tables. */
	const_int_htab = htab_create_ggc (37, const_int_htab_hash,
	const_int_htab_eq, NULL);

	const_double_htab = htab_create_ggc (37, const_double_htab_hash,
	const_double_htab_eq, NULL);

	mem_attrs_htab = htab_create_ggc (37, mem_attrs_htab_hash,
	mem_attrs_htab_eq, NULL);
	reg_attrs_htab = htab_create_ggc (37, reg_attrs_htab_hash,
	reg_attrs_htab_eq, NULL);

	no_line_numbers = ! line_numbers;

	/* Compute the word and byte modes. */

	byte_mode = VOIDmode;
	word_mode = VOIDmode;
	double_mode = VOIDmode;

	for (mode = GET_CLASS_NARROWEST_MODE (MODE_INT);
	mode != VOIDmode;
	mode = GET_MODE_WIDER_MODE (mode))
	{
	if (GET_MODE_BITSIZE (mode) == BITS_PER_UNIT
	&& byte_mode == VOIDmode)
	byte_mode = mode;

	if (GET_MODE_BITSIZE (mode) == BITS_PER_WORD
	&& word_mode == VOIDmode)
	word_mode = mode;
	}

	for (mode = GET_CLASS_NARROWEST_MODE (MODE_FLOAT);
	mode != VOIDmode;
	mode = GET_MODE_WIDER_MODE (mode))
	{
	if (GET_MODE_BITSIZE (mode) == DOUBLE_TYPE_SIZE
	&& double_mode == VOIDmode)
	double_mode = mode;
	}

	ptr_mode = mode_for_size (POINTER_SIZE, GET_MODE_CLASS (Pmode), 0);

	/* Assign register numbers to the globally defined register rtx.
	This must be done at runtime because the register number field
	is in a union and some compilers can't initialize unions. */

	pc_rtx = gen_rtx_PC (VOIDmode);
	cc0_rtx = gen_rtx_CC0 (VOIDmode);
	stack_pointer_rtx = gen_raw_REG (Pmode, STACK_POINTER_REGNUM);
	frame_pointer_rtx = gen_raw_REG (Pmode, FRAME_POINTER_REGNUM);
	if (hard_frame_pointer_rtx == 0)
	hard_frame_pointer_rtx = gen_raw_REG (Pmode,
	HARD_FRAME_POINTER_REGNUM);
	if (arg_pointer_rtx == 0)
	arg_pointer_rtx = gen_raw_REG (Pmode, ARG_POINTER_REGNUM);
	virtual_incoming_args_rtx =
	gen_raw_REG (Pmode, VIRTUAL_INCOMING_ARGS_REGNUM);
	virtual_stack_vars_rtx =
	gen_raw_REG (Pmode, VIRTUAL_STACK_VARS_REGNUM);
	virtual_stack_dynamic_rtx =
	gen_raw_REG (Pmode, VIRTUAL_STACK_DYNAMIC_REGNUM);
	virtual_outgoing_args_rtx =
	gen_raw_REG (Pmode, VIRTUAL_OUTGOING_ARGS_REGNUM);
	virtual_cfa_rtx = gen_raw_REG (Pmode, VIRTUAL_CFA_REGNUM);

	/* Initialize RTL for commonly used hard registers. These are
	copied into regno_reg_rtx as we begin to compile each function. */
	for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
	static_regno_reg_rtx[i] = gen_raw_REG (reg_raw_mode[i], i);

	#ifdef INIT_EXPANDERS
	/* This is to initialize {init\|mark\|free}_machine_status before the first
	call to push_function_context_to. This is needed by the Chill front
	end which calls push_function_context_to before the first call to
	init_function_start. */
	INIT_EXPANDERS;
	#endif

	/* Create the unique rtx's for certain rtx codes and operand values. */

	/* Don't use gen_rtx_CONST_INT here since gen_rtx_CONST_INT in this case
	tries to use these variables. */
	for (i = - MAX_SAVED_CONST_INT; i <= MAX_SAVED_CONST_INT; i++)
	const_int_rtx[i + MAX_SAVED_CONST_INT] =
	gen_rtx_raw_CONST_INT (VOIDmode, (HOST_WIDE_INT) i);

	if (STORE_FLAG_VALUE >= - MAX_SAVED_CONST_INT
	&& STORE_FLAG_VALUE <= MAX_SAVED_CONST_INT)
	const_true_rtx = const_int_rtx[STORE_FLAG_VALUE + MAX_SAVED_CONST_INT];
	else
	const_true_rtx = gen_rtx_CONST_INT (VOIDmode, STORE_FLAG_VALUE);

	REAL_VALUE_FROM_INT (dconst0, 0, 0, double_mode);
	REAL_VALUE_FROM_INT (dconst1, 1, 0, double_mode);
	REAL_VALUE_FROM_INT (dconst2, 2, 0, double_mode);
	REAL_VALUE_FROM_INT (dconst3, 3, 0, double_mode);
	REAL_VALUE_FROM_INT (dconst10, 10, 0, double_mode);
	REAL_VALUE_FROM_INT (dconstm1, -1, -1, double_mode);
	REAL_VALUE_FROM_INT (dconstm2, -2, -1, double_mode);

	dconsthalf = dconst1;
	SET_REAL_EXP (&dconsthalf, REAL_EXP (&dconsthalf) - 1);

	real_arithmetic (&dconstthird, RDIV_EXPR, &dconst1, &dconst3);

	/* Initialize mathematical constants for constant folding builtins.
	These constants need to be given to at least 160 bits precision. */
	real_from_string (&dconstpi,
	"3.1415926535897932384626433832795028841971693993751058209749445923078");
	real_from_string (&dconste,
	"2.7182818284590452353602874713526624977572470936999595749669676277241");

	for (i = 0; i < (int) ARRAY_SIZE (const_tiny_rtx); i++)
	{
	REAL_VALUE_TYPE *r =
	(i == 0 ? &dconst0 : i == 1 ? &dconst1 : &dconst2);

	for (mode = GET_CLASS_NARROWEST_MODE (MODE_FLOAT);
	mode != VOIDmode;
	mode = GET_MODE_WIDER_MODE (mode))
	const_tiny_rtx[i][(int) mode] =
	CONST_DOUBLE_FROM_REAL_VALUE (*r, mode);

	for (mode = GET_CLASS_NARROWEST_MODE (MODE_DECIMAL_FLOAT);
	mode != VOIDmode;
	mode = GET_MODE_WIDER_MODE (mode))
	const_tiny_rtx[i][(int) mode] =
	CONST_DOUBLE_FROM_REAL_VALUE (*r, mode);

	const_tiny_rtx[i][(int) VOIDmode] = GEN_INT (i);

	for (mode = GET_CLASS_NARROWEST_MODE (MODE_INT);
	mode != VOIDmode;
	mode = GET_MODE_WIDER_MODE (mode))
	const_tiny_rtx[i][(int) mode] = GEN_INT (i);

	for (mode = GET_CLASS_NARROWEST_MODE (MODE_PARTIAL_INT);
	mode != VOIDmode;
	mode = GET_MODE_WIDER_MODE (mode))
	const_tiny_rtx[i][(int) mode] = GEN_INT (i);
	}

	for (mode = GET_CLASS_NARROWEST_MODE (MODE_VECTOR_INT);
	mode != VOIDmode;
	mode = GET_MODE_WIDER_MODE (mode))
	{
	const_tiny_rtx[0][(int) mode] = gen_const_vector (mode, 0);
	const_tiny_rtx[1][(int) mode] = gen_const_vector (mode, 1);
	}

	for (mode = GET_CLASS_NARROWEST_MODE (MODE_VECTOR_FLOAT);
	mode != VOIDmode;
	mode = GET_MODE_WIDER_MODE (mode))
	{
	const_tiny_rtx[0][(int) mode] = gen_const_vector (mode, 0);
	const_tiny_rtx[1][(int) mode] = gen_const_vector (mode, 1);
	}

	for (i = (int) CCmode; i < (int) MAX_MACHINE_MODE; ++i)
	if (GET_MODE_CLASS ((enum machine_mode) i) == MODE_CC)
	const_tiny_rtx[0][i] = const0_rtx;

	const_tiny_rtx[0][(int) BImode] = const0_rtx;
	if (STORE_FLAG_VALUE == 1)
	const_tiny_rtx[1][(int) BImode] = const1_rtx;

	#ifdef RETURN_ADDRESS_POINTER_REGNUM
	return_address_pointer_rtx
	= gen_raw_REG (Pmode, RETURN_ADDRESS_POINTER_REGNUM);
	#endif

	#ifdef STATIC_CHAIN_REGNUM
	static_chain_rtx = gen_rtx_REG (Pmode, STATIC_CHAIN_REGNUM);

	#ifdef STATIC_CHAIN_INCOMING_REGNUM
	if (STATIC_CHAIN_INCOMING_REGNUM != STATIC_CHAIN_REGNUM)
	static_chain_incoming_rtx
	= gen_rtx_REG (Pmode, STATIC_CHAIN_INCOMING_REGNUM);
	else
	#endif
	static_chain_incoming_rtx = static_chain_rtx;
	#endif

	#ifdef STATIC_CHAIN
	static_chain_rtx = STATIC_CHAIN;

	#ifdef STATIC_CHAIN_INCOMING
	static_chain_incoming_rtx = STATIC_CHAIN_INCOMING;
	#else
	static_chain_incoming_rtx = static_chain_rtx;
	#endif
	#endif

	if ((unsigned) PIC_OFFSET_TABLE_REGNUM != INVALID_REGNUM)
	pic_offset_table_rtx = gen_raw_REG (Pmode, PIC_OFFSET_TABLE_REGNUM);
	}

	/* Produce exact duplicate of insn INSN after AFTER.
	Care updating of libcall regions if present. */

	rtx
	emit_copy_of_insn_after (rtx insn, rtx after)
	{
	rtx new;
	rtx note1, note2, link;

	switch (GET_CODE (insn))
	{
	case INSN:
	new = emit_insn_after (copy_insn (PATTERN (insn)), after);
	break;

	case JUMP_INSN:
	new = emit_jump_insn_after (copy_insn (PATTERN (insn)), after);
	break;

	case CALL_INSN:
	new = emit_call_insn_after (copy_insn (PATTERN (insn)), after);
	if (CALL_INSN_FUNCTION_USAGE (insn))
	CALL_INSN_FUNCTION_USAGE (new)
	= copy_insn (CALL_INSN_FUNCTION_USAGE (insn));
	SIBLING_CALL_P (new) = SIBLING_CALL_P (insn);
	CONST_OR_PURE_CALL_P (new) = CONST_OR_PURE_CALL_P (insn);
	break;

	default:
	gcc_unreachable ();
	}

	/* Update LABEL_NUSES. */
	mark_jump_label (PATTERN (new), new, 0);

	INSN_LOCATOR (new) = INSN_LOCATOR (insn);

	/* If the old insn is frame related, then so is the new one. This is
	primarily needed for IA-64 unwind info which marks epilogue insns,
	which may be duplicated by the basic block reordering code. */
	RTX_FRAME_RELATED_P (new) = RTX_FRAME_RELATED_P (insn);

	/* Copy all REG_NOTES except REG_LABEL since mark_jump_label will
	make them. */
	for (link = REG_NOTES (insn); link; link = XEXP (link, 1))
	if (REG_NOTE_KIND (link) != REG_LABEL)
	{
	if (GET_CODE (link) == EXPR_LIST)
	REG_NOTES (new)
	= copy_insn_1 (gen_rtx_EXPR_LIST (GET_MODE (link),
	XEXP (link, 0),
	REG_NOTES (new)));
	else
	REG_NOTES (new)
	= copy_insn_1 (gen_rtx_INSN_LIST (GET_MODE (link),
	XEXP (link, 0),
	REG_NOTES (new)));
	}

	/* Fix the libcall sequences. */
	if ((note1 = find_reg_note (new, REG_RETVAL, NULL_RTX)) != NULL)
	{
	rtx p = new;
	while ((note2 = find_reg_note (p, REG_LIBCALL, NULL_RTX)) == NULL)
	p = PREV_INSN (p);
	XEXP (note1, 0) = p;
	XEXP (note2, 0) = new;
	}
	INSN_CODE (new) = INSN_CODE (insn);
	return new;
	}

	static GTY((deletable)) rtx hard_reg_clobbers [NUM_MACHINE_MODES][FIRST_PSEUDO_REGISTER];
	rtx
	gen_hard_reg_clobber (enum machine_mode mode, unsigned int regno)
	{
	if (hard_reg_clobbers[mode][regno])
	return hard_reg_clobbers[mode][regno];
	else
	return (hard_reg_clobbers[mode][regno] =
	gen_rtx_CLOBBER (VOIDmode, gen_rtx_REG (mode, regno)));
	}

	#include "gt-emit-rtl.h"
	diff --git a/contrib/gcc/final.c b/contrib/gcc/final.c
	index ef50ed933838..90cad920ebd5 100644
	--- a/contrib/gcc/final.c
	+++ b/contrib/gcc/final.c
	@@ -1,4094 +1,4091 @@
	/* Convert RTL to assembler code and output it, for GNU compiler.
	Copyright (C) 1987, 1988, 1989, 1992, 1993, 1994, 1995, 1996, 1997,
	1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006
	Free Software Foundation, Inc.

	This file is part of GCC.

	GCC is free software; you can redistribute it and/or modify it under
	the terms of the GNU General Public License as published by the Free
	Software Foundation; either version 2, or (at your option) any later
	version.

	GCC is distributed in the hope that it will be useful, but WITHOUT ANY
	WARRANTY; without even the implied warranty of MERCHANTABILITY or
	FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	for more details.

	You should have received a copy of the GNU General Public License
	along with GCC; see the file COPYING. If not, write to the Free
	Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
	02110-1301, USA. */

	/* This is the final pass of the compiler.
	It looks at the rtl code for a function and outputs assembler code.

	Call `final_start_function' to output the assembler code for function entry,
	`final' to output assembler code for some RTL code,
	`final_end_function' to output assembler code for function exit.
	If a function is compiled in several pieces, each piece is
	output separately with `final'.

	Some optimizations are also done at this level.
	Move instructions that were made unnecessary by good register allocation
	are detected and omitted from the output. (Though most of these
	are removed by the last jump pass.)

	Instructions to set the condition codes are omitted when it can be
	seen that the condition codes already had the desired values.

	In some cases it is sufficient if the inherited condition codes
	have related values, but this may require the following insn
	(the one that tests the condition codes) to be modified.

	The code for the function prologue and epilogue are generated
	directly in assembler by the target functions function_prologue and
	function_epilogue. Those instructions never exist as rtl. */

	#include "config.h"
	#include "system.h"
	#include "coretypes.h"
	#include "tm.h"

	#include "tree.h"
	#include "rtl.h"
	#include "tm_p.h"
	#include "regs.h"
	#include "insn-config.h"
	#include "insn-attr.h"
	#include "recog.h"
	#include "conditions.h"
	#include "flags.h"
	#include "real.h"
	#include "hard-reg-set.h"
	#include "output.h"
	#include "except.h"
	#include "function.h"
	#include "toplev.h"
	#include "reload.h"
	#include "intl.h"
	#include "basic-block.h"
	#include "target.h"
	#include "debug.h"
	#include "expr.h"
	#include "cfglayout.h"
	#include "tree-pass.h"
	#include "timevar.h"
	#include "cgraph.h"
	#include "coverage.h"

	#ifdef XCOFF_DEBUGGING_INFO
	#include "xcoffout.h" /* Needed for external data
	declarations for e.g. AIX 4.x. */
	#endif

	#if defined (DWARF2_UNWIND_INFO) \|\| defined (DWARF2_DEBUGGING_INFO)
	#include "dwarf2out.h"
	#endif

	#ifdef DBX_DEBUGGING_INFO
	#include "dbxout.h"
	#endif

	#ifdef SDB_DEBUGGING_INFO
	#include "sdbout.h"
	#endif

	/* If we aren't using cc0, CC_STATUS_INIT shouldn't exist. So define a
	null default for it to save conditionalization later. */
	#ifndef CC_STATUS_INIT
	#define CC_STATUS_INIT
	#endif

	/* How to start an assembler comment. */
	#ifndef ASM_COMMENT_START
	#define ASM_COMMENT_START ";#"
	#endif

	/* Is the given character a logical line separator for the assembler? */
	#ifndef IS_ASM_LOGICAL_LINE_SEPARATOR
	#define IS_ASM_LOGICAL_LINE_SEPARATOR(C) ((C) == ';')
	#endif

	#ifndef JUMP_TABLES_IN_TEXT_SECTION
	#define JUMP_TABLES_IN_TEXT_SECTION 0
	#endif

	/* Bitflags used by final_scan_insn. */
	#define SEEN_BB 1
	#define SEEN_NOTE 2
	#define SEEN_EMITTED 4

	/* Last insn processed by final_scan_insn. */
	static rtx debug_insn;
	rtx current_output_insn;

	/* Line number of last NOTE. */
	static int last_linenum;

	/* Highest line number in current block. */
	static int high_block_linenum;

	/* Likewise for function. */
	static int high_function_linenum;

	/* Filename of last NOTE. */
	static const char *last_filename;

	/* Whether to force emission of a line note before the next insn. */
	static bool force_source_line = false;

	extern const int length_unit_log; /* This is defined in insn-attrtab.c. */

	/* Nonzero while outputting an `asm' with operands.
	This means that inconsistencies are the user's fault, so don't die.
	The precise value is the insn being output, to pass to error_for_asm. */
	rtx this_is_asm_operands;

	/* Number of operands of this insn, for an `asm' with operands. */
	static unsigned int insn_noperands;

	/* Compare optimization flag. */

	static rtx last_ignored_compare = 0;

	/* Assign a unique number to each insn that is output.
	This can be used to generate unique local labels. */

	static int insn_counter = 0;

	#ifdef HAVE_cc0
	/* This variable contains machine-dependent flags (defined in tm.h)
	set and examined by output routines
	that describe how to interpret the condition codes properly. */

	CC_STATUS cc_status;

	/* During output of an insn, this contains a copy of cc_status
	from before the insn. */

	CC_STATUS cc_prev_status;
	#endif

	/* Indexed by hardware reg number, is 1 if that register is ever
	used in the current function.

	In life_analysis, or in stupid_life_analysis, this is set
	up to record the hard regs used explicitly. Reload adds
	in the hard regs used for holding pseudo regs. Final uses
	it to generate the code in the function prologue and epilogue
	to save and restore registers as needed. */

	char regs_ever_live[FIRST_PSEUDO_REGISTER];

	/* Like regs_ever_live, but 1 if a reg is set or clobbered from an asm.
	Unlike regs_ever_live, elements of this array corresponding to
	eliminable regs like the frame pointer are set if an asm sets them. */

	char regs_asm_clobbered[FIRST_PSEUDO_REGISTER];

	/* Nonzero means current function must be given a frame pointer.
	Initialized in function.c to 0. Set only in reload1.c as per
	the needs of the function. */

	int frame_pointer_needed;

	/* Number of unmatched NOTE_INSN_BLOCK_BEG notes we have seen. */

	static int block_depth;

	/* Nonzero if have enabled APP processing of our assembler output. */

	static int app_on;

	/* If we are outputting an insn sequence, this contains the sequence rtx.
	Zero otherwise. */

	rtx final_sequence;

	#ifdef ASSEMBLER_DIALECT

	/* Number of the assembler dialect to use, starting at 0. */
	static int dialect_number;
	#endif

	#ifdef HAVE_conditional_execution
	/* Nonnull if the insn currently being emitted was a COND_EXEC pattern. */
	rtx current_insn_predicate;
	#endif

	#ifdef HAVE_ATTR_length
	static int asm_insn_count (rtx);
	#endif
	static void profile_function (FILE *);
	static void profile_after_prologue (FILE *);
	static bool notice_source_line (rtx);
	static rtx walk_alter_subreg (rtx *);
	static void output_asm_name (void);
	static void output_alternate_entry_point (FILE *, rtx);
	static tree get_mem_expr_from_op (rtx, int *);
	static void output_asm_operand_names (rtx , int , int);
	static void output_operand (rtx, int);
	#ifdef LEAF_REGISTERS
	static void leaf_renumber_regs (rtx);
	#endif
	#ifdef HAVE_cc0
	static int alter_cond (rtx);
	#endif
	#ifndef ADDR_VEC_ALIGN
	static int final_addr_vec_align (rtx);
	#endif
	#ifdef HAVE_ATTR_length
	static int align_fuzz (rtx, rtx, int, unsigned);
	#endif

	/* Initialize data in final at the beginning of a compilation. */

	void
	init_final (const char *filename ATTRIBUTE_UNUSED)
	{
	app_on = 0;
	final_sequence = 0;

	#ifdef ASSEMBLER_DIALECT
	dialect_number = ASSEMBLER_DIALECT;
	#endif
	}

	/* Default target function prologue and epilogue assembler output.

	If not overridden for epilogue code, then the function body itself
	contains return instructions wherever needed. */
	void
	default_function_pro_epilogue (FILE *file ATTRIBUTE_UNUSED,
	HOST_WIDE_INT size ATTRIBUTE_UNUSED)
	{
	}

	/* Default target hook that outputs nothing to a stream. */
	void
	no_asm_to_stream (FILE *file ATTRIBUTE_UNUSED)
	{
	}

	/* Enable APP processing of subsequent output.
	Used before the output from an `asm' statement. */

	void
	app_enable (void)
	{
	if (! app_on)
	{
	fputs (ASM_APP_ON, asm_out_file);
	app_on = 1;
	}
	}

	/* Disable APP processing of subsequent output.
	Called from varasm.c before most kinds of output. */

	void
	app_disable (void)
	{
	if (app_on)
	{
	fputs (ASM_APP_OFF, asm_out_file);
	app_on = 0;
	}
	}

	/* Return the number of slots filled in the current
	delayed branch sequence (we don't count the insn needing the
	delay slot). Zero if not in a delayed branch sequence. */

	#ifdef DELAY_SLOTS
	int
	dbr_sequence_length (void)
	{
	if (final_sequence != 0)
	return XVECLEN (final_sequence, 0) - 1;
	else
	return 0;
	}
	#endif

	/* The next two pages contain routines used to compute the length of an insn
	and to shorten branches. */

	/* Arrays for insn lengths, and addresses. The latter is referenced by
	`insn_current_length'. */

	static int *insn_lengths;

	varray_type insn_addresses_;

	/* Max uid for which the above arrays are valid. */
	static int insn_lengths_max_uid;

	/* Address of insn being processed. Used by `insn_current_length'. */
	int insn_current_address;

	/* Address of insn being processed in previous iteration. */
	int insn_last_address;

	/* known invariant alignment of insn being processed. */
	int insn_current_align;

	/* After shorten_branches, for any insn, uid_align[INSN_UID (insn)]
	gives the next following alignment insn that increases the known
	alignment, or NULL_RTX if there is no such insn.
	For any alignment obtained this way, we can again index uid_align with
	its uid to obtain the next following align that in turn increases the
	alignment, till we reach NULL_RTX; the sequence obtained this way
	for each insn we'll call the alignment chain of this insn in the following
	comments. */

	-struct label_alignment
	-{
	- short alignment;
	- short max_skip;
	-};
	-
	+/* APPLE LOCAL begin for-fsf-4_4 3274130 5295549 */ \
	+/* APPLE LOCAL end for-fsf-4_4 3274130 5295549 */ \
	static rtx *uid_align;
	static int *uid_shuid;
	-static struct label_alignment *label_align;
	+/* APPLE LOCAL begin for-fsf-4_4 3274130 5295549 */ \
	+
	+/* APPLE LOCAL end for-fsf-4_4 3274130 5295549 */ \

	/* Indicate that branch shortening hasn't yet been done. */

	void
	init_insn_lengths (void)
	{
	if (uid_shuid)
	{
	free (uid_shuid);
	uid_shuid = 0;
	}
	if (insn_lengths)
	{
	free (insn_lengths);
	insn_lengths = 0;
	insn_lengths_max_uid = 0;
	}
	#ifdef HAVE_ATTR_length
	INSN_ADDRESSES_FREE ();
	#endif
	if (uid_align)
	{
	free (uid_align);
	uid_align = 0;
	}
	}

	/* Obtain the current length of an insn. If branch shortening has been done,
	get its actual length. Otherwise, use FALLBACK_FN to calculate the
	length. */
	static inline int
	get_attr_length_1 (rtx insn ATTRIBUTE_UNUSED,
	int (*fallback_fn) (rtx) ATTRIBUTE_UNUSED)
	{
	#ifdef HAVE_ATTR_length
	rtx body;
	int i;
	int length = 0;

	if (insn_lengths_max_uid > INSN_UID (insn))
	return insn_lengths[INSN_UID (insn)];
	else
	switch (GET_CODE (insn))
	{
	case NOTE:
	case BARRIER:
	case CODE_LABEL:
	return 0;

	case CALL_INSN:
	length = fallback_fn (insn);
	break;

	case JUMP_INSN:
	body = PATTERN (insn);
	if (GET_CODE (body) == ADDR_VEC \|\| GET_CODE (body) == ADDR_DIFF_VEC)
	{
	/* Alignment is machine-dependent and should be handled by
	ADDR_VEC_ALIGN. */
	}
	else
	length = fallback_fn (insn);
	break;

	case INSN:
	body = PATTERN (insn);
	if (GET_CODE (body) == USE \|\| GET_CODE (body) == CLOBBER)
	return 0;

	else if (GET_CODE (body) == ASM_INPUT \|\| asm_noperands (body) >= 0)
	length = asm_insn_count (body) * fallback_fn (insn);
	else if (GET_CODE (body) == SEQUENCE)
	for (i = 0; i < XVECLEN (body, 0); i++)
	length += get_attr_length (XVECEXP (body, 0, i));
	else
	length = fallback_fn (insn);
	break;

	default:
	break;
	}

	#ifdef ADJUST_INSN_LENGTH
	ADJUST_INSN_LENGTH (insn, length);
	#endif
	return length;
	#else /* not HAVE_ATTR_length */
	return 0;
	#define insn_default_length 0
	#define insn_min_length 0
	#endif /* not HAVE_ATTR_length */
	}

	/* Obtain the current length of an insn. If branch shortening has been done,
	get its actual length. Otherwise, get its maximum length. */
	int
	get_attr_length (rtx insn)
	{
	return get_attr_length_1 (insn, insn_default_length);
	}

	/* Obtain the current length of an insn. If branch shortening has been done,
	get its actual length. Otherwise, get its minimum length. */
	int
	get_attr_min_length (rtx insn)
	{
	return get_attr_length_1 (insn, insn_min_length);
	}

	/* Code to handle alignment inside shorten_branches. */

	/* Here is an explanation how the algorithm in align_fuzz can give
	proper results:

	Call a sequence of instructions beginning with alignment point X
	and continuing until the next alignment point `block X'. When `X'
	is used in an expression, it means the alignment value of the
	alignment point.

	Call the distance between the start of the first insn of block X, and
	the end of the last insn of block X `IX', for the `inner size of X'.
	This is clearly the sum of the instruction lengths.

	Likewise with the next alignment-delimited block following X, which we
	shall call block Y.

	Call the distance between the start of the first insn of block X, and
	the start of the first insn of block Y `OX', for the `outer size of X'.

	The estimated padding is then OX - IX.

	OX can be safely estimated as

	if (X >= Y)
	OX = round_up(IX, Y)
	else
	OX = round_up(IX, X) + Y - X

	Clearly est(IX) >= real(IX), because that only depends on the
	instruction lengths, and those being overestimated is a given.

	Clearly round_up(foo, Z) >= round_up(bar, Z) if foo >= bar, so
	we needn't worry about that when thinking about OX.

	When X >= Y, the alignment provided by Y adds no uncertainty factor
	for branch ranges starting before X, so we can just round what we have.
	But when X < Y, we don't know anything about the, so to speak,
	`middle bits', so we have to assume the worst when aligning up from an
	address mod X to one mod Y, which is Y - X. */

	#ifndef LABEL_ALIGN
	#define LABEL_ALIGN(LABEL) align_labels_log
	#endif

	#ifndef LABEL_ALIGN_MAX_SKIP
	#define LABEL_ALIGN_MAX_SKIP align_labels_max_skip
	#endif

	#ifndef LOOP_ALIGN
	#define LOOP_ALIGN(LABEL) align_loops_log
	#endif

	#ifndef LOOP_ALIGN_MAX_SKIP
	#define LOOP_ALIGN_MAX_SKIP align_loops_max_skip
	#endif

	#ifndef LABEL_ALIGN_AFTER_BARRIER
	#define LABEL_ALIGN_AFTER_BARRIER(LABEL) 0
	#endif

	#ifndef LABEL_ALIGN_AFTER_BARRIER_MAX_SKIP
	#define LABEL_ALIGN_AFTER_BARRIER_MAX_SKIP 0
	#endif

	#ifndef JUMP_ALIGN
	#define JUMP_ALIGN(LABEL) align_jumps_log
	#endif

	#ifndef JUMP_ALIGN_MAX_SKIP
	#define JUMP_ALIGN_MAX_SKIP align_jumps_max_skip
	#endif

	#ifndef ADDR_VEC_ALIGN
	static int
	final_addr_vec_align (rtx addr_vec)
	{
	int align = GET_MODE_SIZE (GET_MODE (PATTERN (addr_vec)));

	if (align > BIGGEST_ALIGNMENT / BITS_PER_UNIT)
	align = BIGGEST_ALIGNMENT / BITS_PER_UNIT;
	return exact_log2 (align);

	}

	#define ADDR_VEC_ALIGN(ADDR_VEC) final_addr_vec_align (ADDR_VEC)
	#endif

	#ifndef INSN_LENGTH_ALIGNMENT
	#define INSN_LENGTH_ALIGNMENT(INSN) length_unit_log
	#endif

	#define INSN_SHUID(INSN) (uid_shuid[INSN_UID (INSN)])

	-static int min_labelno, max_labelno;
	-
	-#define LABEL_TO_ALIGNMENT(LABEL) \
	- (label_align[CODE_LABEL_NUMBER (LABEL) - min_labelno].alignment)
	-
	-#define LABEL_TO_MAX_SKIP(LABEL) \
	- (label_align[CODE_LABEL_NUMBER (LABEL) - min_labelno].max_skip)
	-
	+/* APPLE LOCAL begin for-fsf-4_4 3274130 5295549 */ \
	+/* APPLE LOCAL end for-fsf-4_4 3274130 5295549 */ \
	/* For the benefit of port specific code do this also as a function. */

	int
	label_to_alignment (rtx label)
	{
	- return LABEL_TO_ALIGNMENT (label);
	+/* APPLE LOCAL begin for-fsf-4_4 3274130 5295549 */ \
	+ return LABEL_ALIGN_LOG (label);
	+/* APPLE LOCAL end for-fsf-4_4 3274130 5295549 */ \
	}

	#ifdef HAVE_ATTR_length
	/* The differences in addresses
	between a branch and its target might grow or shrink depending on
	the alignment the start insn of the range (the branch for a forward
	branch or the label for a backward branch) starts out on; if these
	differences are used naively, they can even oscillate infinitely.
	We therefore want to compute a 'worst case' address difference that
	is independent of the alignment the start insn of the range end
	up on, and that is at least as large as the actual difference.
	The function align_fuzz calculates the amount we have to add to the
	naively computed difference, by traversing the part of the alignment
	chain of the start insn of the range that is in front of the end insn
	of the range, and considering for each alignment the maximum amount
	that it might contribute to a size increase.

	For casesi tables, we also want to know worst case minimum amounts of
	address difference, in case a machine description wants to introduce
	some common offset that is added to all offsets in a table.
	For this purpose, align_fuzz with a growth argument of 0 computes the
	appropriate adjustment. */

	/* Compute the maximum delta by which the difference of the addresses of
	START and END might grow / shrink due to a different address for start
	which changes the size of alignment insns between START and END.
	KNOWN_ALIGN_LOG is the alignment known for START.
	GROWTH should be ~0 if the objective is to compute potential code size
	increase, and 0 if the objective is to compute potential shrink.
	The return value is undefined for any other value of GROWTH. */

	static int
	align_fuzz (rtx start, rtx end, int known_align_log, unsigned int growth)
	{
	int uid = INSN_UID (start);
	rtx align_label;
	int known_align = 1 << known_align_log;
	int end_shuid = INSN_SHUID (end);
	int fuzz = 0;

	for (align_label = uid_align[uid]; align_label; align_label = uid_align[uid])
	{
	int align_addr, new_align;

	uid = INSN_UID (align_label);
	align_addr = INSN_ADDRESSES (uid) - insn_lengths[uid];
	if (uid_shuid[uid] > end_shuid)
	break;
	- known_align_log = LABEL_TO_ALIGNMENT (align_label);
	+/* APPLE LOCAL begin for-fsf-4_4 3274130 5295549 */ \
	+ known_align_log = LABEL_ALIGN_LOG (align_label);
	+/* APPLE LOCAL end for-fsf-4_4 3274130 5295549 */ \
	new_align = 1 << known_align_log;
	if (new_align < known_align)
	continue;
	fuzz += (-align_addr ^ growth) & (new_align - known_align);
	known_align = new_align;
	}
	return fuzz;
	}

	/* Compute a worst-case reference address of a branch so that it
	can be safely used in the presence of aligned labels. Since the
	size of the branch itself is unknown, the size of the branch is
	not included in the range. I.e. for a forward branch, the reference
	address is the end address of the branch as known from the previous
	branch shortening pass, minus a value to account for possible size
	increase due to alignment. For a backward branch, it is the start
	address of the branch as known from the current pass, plus a value
	to account for possible size increase due to alignment.
	NB.: Therefore, the maximum offset allowed for backward branches needs
	to exclude the branch size. */

	int
	insn_current_reference_address (rtx branch)
	{
	rtx dest, seq;
	int seq_uid;

	if (! INSN_ADDRESSES_SET_P ())
	return 0;

	seq = NEXT_INSN (PREV_INSN (branch));
	seq_uid = INSN_UID (seq);
	if (!JUMP_P (branch))
	/* This can happen for example on the PA; the objective is to know the
	offset to address something in front of the start of the function.
	Thus, we can treat it like a backward branch.
	We assume here that FUNCTION_BOUNDARY / BITS_PER_UNIT is larger than
	any alignment we'd encounter, so we skip the call to align_fuzz. */
	return insn_current_address;
	dest = JUMP_LABEL (branch);

	/* BRANCH has no proper alignment chain set, so use SEQ.
	BRANCH also has no INSN_SHUID. */
	if (INSN_SHUID (seq) < INSN_SHUID (dest))
	{
	/* Forward branch. */
	return (insn_last_address + insn_lengths[seq_uid]
	- align_fuzz (seq, dest, length_unit_log, ~0));
	}
	else
	{
	/* Backward branch. */
	return (insn_current_address
	+ align_fuzz (dest, seq, length_unit_log, ~0));
	}
	}
	#endif /* HAVE_ATTR_length */

	/* Compute branch alignments based on frequency information in the
	CFG. */

	static unsigned int
	compute_alignments (void)
	{
	- int log, max_skip, max_log;
	+/* APPLE LOCAL begin for-fsf-4_4 3274130 5295549 */ \
	+/* APPLE LOCAL end for-fsf-4_4 3274130 5295549 */ \
	basic_block bb;

	- if (label_align)
	- {
	- free (label_align);
	- label_align = 0;
	- }
	-
	- max_labelno = max_label_num ();
	- min_labelno = get_first_label_num ();
	- label_align = XCNEWVEC (struct label_alignment, max_labelno - min_labelno + 1);
	+/* APPLE LOCAL begin for-fsf-4_4 3274130 5295549 */ \
	+/* APPLE LOCAL end for-fsf-4_4 3274130 5295549 */ \

	/* If not optimizing or optimizing for size, don't assign any alignments. */
	if (! optimize \|\| optimize_size)
	return 0;

	FOR_EACH_BB (bb)
	{
	rtx label = BB_HEAD (bb);
	int fallthru_frequency = 0, branch_frequency = 0, has_fallthru = 0;
	edge e;
	edge_iterator ei;
	+/* APPLE LOCAL begin for-fsf-4_4 3274130 5295549 */ \
	+ int log, max_skip, max_log;

	+/* APPLE LOCAL end for-fsf-4_4 3274130 5295549 */ \
	if (!LABEL_P (label)
	\|\| probably_never_executed_bb_p (bb))
	continue;
	+/* APPLE LOCAL begin for-fsf-4_4 3274130 5295549 */ \
	+ /* If user has specified an alignment, honour it. */
	+ if (LABEL_ALIGN_LOG (label) > 0)
	+ continue;
	+
	+/* APPLE LOCAL end for-fsf-4_4 3274130 5295549 */ \
	max_log = LABEL_ALIGN (label);
	max_skip = LABEL_ALIGN_MAX_SKIP;

	FOR_EACH_EDGE (e, ei, bb->preds)
	{
	if (e->flags & EDGE_FALLTHRU)
	has_fallthru = 1, fallthru_frequency += EDGE_FREQUENCY (e);
	else
	branch_frequency += EDGE_FREQUENCY (e);
	}

	/* There are two purposes to align block with no fallthru incoming edge:
	1) to avoid fetch stalls when branch destination is near cache boundary
	2) to improve cache efficiency in case the previous block is not executed
	(so it does not need to be in the cache).

	We to catch first case, we align frequently executed blocks.
	To catch the second, we align blocks that are executed more frequently
	than the predecessor and the predecessor is likely to not be executed
	when function is called. */

	if (!has_fallthru
	&& (branch_frequency > BB_FREQ_MAX / 10
	\|\| (bb->frequency > bb->prev_bb->frequency * 10
	&& (bb->prev_bb->frequency
	<= ENTRY_BLOCK_PTR->frequency / 2))))
	{
	log = JUMP_ALIGN (label);
	if (max_log < log)
	{
	max_log = log;
	max_skip = JUMP_ALIGN_MAX_SKIP;
	}
	}
	/* In case block is frequent and reached mostly by non-fallthru edge,
	align it. It is most likely a first block of loop. */
	if (has_fallthru
	&& maybe_hot_bb_p (bb)
	&& branch_frequency + fallthru_frequency > BB_FREQ_MAX / 10
	&& branch_frequency > fallthru_frequency * 2)
	{
	log = LOOP_ALIGN (label);
	if (max_log < log)
	{
	max_log = log;
	max_skip = LOOP_ALIGN_MAX_SKIP;
	}
	}
	- LABEL_TO_ALIGNMENT (label) = max_log;
	- LABEL_TO_MAX_SKIP (label) = max_skip;
	+/* APPLE LOCAL begin for-fsf-4_4 3274130 5295549 */ \
	+ SET_LABEL_ALIGN (label, max_log, max_skip);
	+/* APPLE LOCAL end for-fsf-4_4 3274130 5295549 */ \
	}
	return 0;
	}

	struct tree_opt_pass pass_compute_alignments =
	{
	NULL, /* name */
	NULL, /* gate */
	compute_alignments, /* execute */
	NULL, /* sub */
	NULL, /* next */
	0, /* static_pass_number */
	0, /* tv_id */
	0, /* properties_required */
	0, /* properties_provided */
	0, /* properties_destroyed */
	0, /* todo_flags_start */
	0, /* todo_flags_finish */
	0 /* letter */
	};


	/* Make a pass over all insns and compute their actual lengths by shortening
	any branches of variable length if possible. */

	/* shorten_branches might be called multiple times: for example, the SH
	port splits out-of-range conditional branches in MACHINE_DEPENDENT_REORG.
	In order to do this, it needs proper length information, which it obtains
	by calling shorten_branches. This cannot be collapsed with
	shorten_branches itself into a single pass unless we also want to integrate
	reorg.c, since the branch splitting exposes new instructions with delay
	slots. */

	void
	shorten_branches (rtx first ATTRIBUTE_UNUSED)
	{
	rtx insn;
	int max_uid;
	int i;
	int max_log;
	int max_skip;
	#ifdef HAVE_ATTR_length
	#define MAX_CODE_ALIGN 16
	rtx seq;
	int something_changed = 1;
	char *varying_length;
	rtx body;
	int uid;
	rtx align_tab[MAX_CODE_ALIGN];

	#endif

	- /* Compute maximum UID and allocate label_align / uid_shuid. */
	+/* APPLE LOCAL begin for-fsf-4_4 3274130 5295549 */ \
	+ /* Compute maximum UID and allocate uid_shuid. */
	+/* APPLE LOCAL end for-fsf-4_4 3274130 5295549 */ \
	max_uid = get_max_uid ();

	/* Free uid_shuid before reallocating it. */
	free (uid_shuid);

	uid_shuid = XNEWVEC (int, max_uid);

	- if (max_labelno != max_label_num ())
	- {
	- int old = max_labelno;
	- int n_labels;
	- int n_old_labels;
	-
	- max_labelno = max_label_num ();
	-
	- n_labels = max_labelno - min_labelno + 1;
	- n_old_labels = old - min_labelno + 1;
	-
	- label_align = xrealloc (label_align,
	- n_labels * sizeof (struct label_alignment));
	-
	- /* Range of labels grows monotonically in the function. Failing here
	- means that the initialization of array got lost. */
	- gcc_assert (n_old_labels <= n_labels);
	-
	- memset (label_align + n_old_labels, 0,
	- (n_labels - n_old_labels) * sizeof (struct label_alignment));
	- }
	-
	- /* Initialize label_align and set up uid_shuid to be strictly
	+ /* APPLE LOCAL for-fsf-4_4 3274130 5295549 */ \
	+ /* Initialize set up uid_shuid to be strictly
	monotonically rising with insn order. */
	/* We use max_log here to keep track of the maximum alignment we want to
	impose on the next CODE_LABEL (or the current one if we are processing
	the CODE_LABEL itself). */

	max_log = 0;
	max_skip = 0;

	for (insn = get_insns (), i = 1; insn; insn = NEXT_INSN (insn))
	{
	int log;

	INSN_SHUID (insn) = i++;
	if (INSN_P (insn))
	continue;

	if (LABEL_P (insn))
	{
	rtx next;

	/* Merge in alignments computed by compute_alignments. */
	- log = LABEL_TO_ALIGNMENT (insn);
	+/* APPLE LOCAL begin for-fsf-4_4 3274130 5295549 */ \
	+ log = LABEL_ALIGN_LOG (insn);
	+/* APPLE LOCAL end for-fsf-4_4 3274130 5295549 */ \
	if (max_log < log)
	{
	max_log = log;
	- max_skip = LABEL_TO_MAX_SKIP (insn);
	+/* APPLE LOCAL begin for-fsf-4_4 3274130 5295549 */ \
	+ max_skip = LABEL_MAX_SKIP (insn);
	+/* APPLE LOCAL end for-fsf-4_4 3274130 5295549 */ \
	}

	log = LABEL_ALIGN (insn);
	if (max_log < log)
	{
	max_log = log;
	max_skip = LABEL_ALIGN_MAX_SKIP;
	}
	next = next_nonnote_insn (insn);
	/* ADDR_VECs only take room if read-only data goes into the text
	section. */
	if (JUMP_TABLES_IN_TEXT_SECTION
	\|\| readonly_data_section == text_section)
	if (next && JUMP_P (next))
	{
	rtx nextbody = PATTERN (next);
	if (GET_CODE (nextbody) == ADDR_VEC
	\|\| GET_CODE (nextbody) == ADDR_DIFF_VEC)
	{
	log = ADDR_VEC_ALIGN (next);
	if (max_log < log)
	{
	max_log = log;
	max_skip = LABEL_ALIGN_MAX_SKIP;
	}
	}
	}
	- LABEL_TO_ALIGNMENT (insn) = max_log;
	- LABEL_TO_MAX_SKIP (insn) = max_skip;
	+/* APPLE LOCAL begin for-fsf-4_4 3274130 5295549 */ \
	+ SET_LABEL_ALIGN (insn, max_log, max_skip);
	+/* APPLE LOCAL end for-fsf-4_4 3274130 5295549 */ \
	max_log = 0;
	max_skip = 0;
	}
	else if (BARRIER_P (insn))
	{
	rtx label;

	for (label = insn; label && ! INSN_P (label);
	label = NEXT_INSN (label))
	if (LABEL_P (label))
	{
	log = LABEL_ALIGN_AFTER_BARRIER (insn);
	if (max_log < log)
	{
	max_log = log;
	max_skip = LABEL_ALIGN_AFTER_BARRIER_MAX_SKIP;
	}
	break;
	}
	}
	}
	#ifdef HAVE_ATTR_length

	/* Allocate the rest of the arrays. */
	insn_lengths = XNEWVEC (int, max_uid);
	insn_lengths_max_uid = max_uid;
	/* Syntax errors can lead to labels being outside of the main insn stream.
	Initialize insn_addresses, so that we get reproducible results. */
	INSN_ADDRESSES_ALLOC (max_uid);

	varying_length = XCNEWVEC (char, max_uid);

	/* Initialize uid_align. We scan instructions
	from end to start, and keep in align_tab[n] the last seen insn
	that does an alignment of at least n+1, i.e. the successor
	in the alignment chain for an insn that does / has a known
	alignment of n. */
	uid_align = XCNEWVEC (rtx, max_uid);

	for (i = MAX_CODE_ALIGN; --i >= 0;)
	align_tab[i] = NULL_RTX;
	seq = get_last_insn ();
	for (; seq; seq = PREV_INSN (seq))
	{
	int uid = INSN_UID (seq);
	int log;
	- log = (LABEL_P (seq) ? LABEL_TO_ALIGNMENT (seq) : 0);
	+/* APPLE LOCAL begin for-fsf-4_4 3274130 5295549 */ \
	+ log = (LABEL_P (seq) ? LABEL_ALIGN_LOG (seq) : 0);
	+/* APPLE LOCAL end for-fsf-4_4 3274130 5295549 */ \
	uid_align[uid] = align_tab[0];
	if (log)
	{
	/* Found an alignment label. */
	uid_align[uid] = align_tab[log];
	for (i = log - 1; i >= 0; i--)
	align_tab[i] = seq;
	}
	}
	#ifdef CASE_VECTOR_SHORTEN_MODE
	if (optimize)
	{
	/* Look for ADDR_DIFF_VECs, and initialize their minimum and maximum
	label fields. */

	int min_shuid = INSN_SHUID (get_insns ()) - 1;
	int max_shuid = INSN_SHUID (get_last_insn ()) + 1;
	int rel;

	for (insn = first; insn != 0; insn = NEXT_INSN (insn))
	{
	rtx min_lab = NULL_RTX, max_lab = NULL_RTX, pat;
	int len, i, min, max, insn_shuid;
	int min_align;
	addr_diff_vec_flags flags;

	if (!JUMP_P (insn)
	\|\| GET_CODE (PATTERN (insn)) != ADDR_DIFF_VEC)
	continue;
	pat = PATTERN (insn);
	len = XVECLEN (pat, 1);
	gcc_assert (len > 0);
	min_align = MAX_CODE_ALIGN;
	for (min = max_shuid, max = min_shuid, i = len - 1; i >= 0; i--)
	{
	rtx lab = XEXP (XVECEXP (pat, 1, i), 0);
	int shuid = INSN_SHUID (lab);
	if (shuid < min)
	{
	min = shuid;
	min_lab = lab;
	}
	if (shuid > max)
	{
	max = shuid;
	max_lab = lab;
	}
	- if (min_align > LABEL_TO_ALIGNMENT (lab))
	- min_align = LABEL_TO_ALIGNMENT (lab);
	+/* APPLE LOCAL begin for-fsf-4_4 3274130 5295549 */ \
	+ if (min_align > (int) LABEL_ALIGN_LOG (lab))
	+ min_align = LABEL_ALIGN_LOG (lab);
	+/* APPLE LOCAL end for-fsf-4_4 3274130 5295549 */ \
	}
	XEXP (pat, 2) = gen_rtx_LABEL_REF (Pmode, min_lab);
	XEXP (pat, 3) = gen_rtx_LABEL_REF (Pmode, max_lab);
	insn_shuid = INSN_SHUID (insn);
	rel = INSN_SHUID (XEXP (XEXP (pat, 0), 0));
	memset (&flags, 0, sizeof (flags));
	flags.min_align = min_align;
	flags.base_after_vec = rel > insn_shuid;
	flags.min_after_vec = min > insn_shuid;
	flags.max_after_vec = max > insn_shuid;
	flags.min_after_base = min > rel;
	flags.max_after_base = max > rel;
	ADDR_DIFF_VEC_FLAGS (pat) = flags;
	}
	}
	#endif /* CASE_VECTOR_SHORTEN_MODE */

	/* Compute initial lengths, addresses, and varying flags for each insn. */
	for (insn_current_address = 0, insn = first;
	insn != 0;
	insn_current_address += insn_lengths[uid], insn = NEXT_INSN (insn))
	{
	uid = INSN_UID (insn);

	insn_lengths[uid] = 0;

	if (LABEL_P (insn))
	{
	- int log = LABEL_TO_ALIGNMENT (insn);
	+/* APPLE LOCAL begin for-fsf-4_4 3274130 5295549 */ \
	+ int log = LABEL_ALIGN_LOG (insn);
	+/* APPLE LOCAL end for-fsf-4_4 3274130 5295549 */ \
	if (log)
	{
	int align = 1 << log;
	int new_address = (insn_current_address + align - 1) & -align;
	insn_lengths[uid] = new_address - insn_current_address;
	}
	}

	INSN_ADDRESSES (uid) = insn_current_address + insn_lengths[uid];

	if (NOTE_P (insn) \|\| BARRIER_P (insn)
	\|\| LABEL_P (insn))
	continue;
	if (INSN_DELETED_P (insn))
	continue;

	body = PATTERN (insn);
	if (GET_CODE (body) == ADDR_VEC \|\| GET_CODE (body) == ADDR_DIFF_VEC)
	{
	/* This only takes room if read-only data goes into the text
	section. */
	if (JUMP_TABLES_IN_TEXT_SECTION
	\|\| readonly_data_section == text_section)
	insn_lengths[uid] = (XVECLEN (body,
	GET_CODE (body) == ADDR_DIFF_VEC)
	* GET_MODE_SIZE (GET_MODE (body)));
	/* Alignment is handled by ADDR_VEC_ALIGN. */
	}
	else if (GET_CODE (body) == ASM_INPUT \|\| asm_noperands (body) >= 0)
	insn_lengths[uid] = asm_insn_count (body) * insn_default_length (insn);
	else if (GET_CODE (body) == SEQUENCE)
	{
	int i;
	int const_delay_slots;
	#ifdef DELAY_SLOTS
	const_delay_slots = const_num_delay_slots (XVECEXP (body, 0, 0));
	#else
	const_delay_slots = 0;
	#endif
	/* Inside a delay slot sequence, we do not do any branch shortening
	if the shortening could change the number of delay slots
	of the branch. */
	for (i = 0; i < XVECLEN (body, 0); i++)
	{
	rtx inner_insn = XVECEXP (body, 0, i);
	int inner_uid = INSN_UID (inner_insn);
	int inner_length;

	if (GET_CODE (body) == ASM_INPUT
	\|\| asm_noperands (PATTERN (XVECEXP (body, 0, i))) >= 0)
	inner_length = (asm_insn_count (PATTERN (inner_insn))
	* insn_default_length (inner_insn));
	else
	inner_length = insn_default_length (inner_insn);

	insn_lengths[inner_uid] = inner_length;
	if (const_delay_slots)
	{
	if ((varying_length[inner_uid]
	= insn_variable_length_p (inner_insn)) != 0)
	varying_length[uid] = 1;
	INSN_ADDRESSES (inner_uid) = (insn_current_address
	+ insn_lengths[uid]);
	}
	else
	varying_length[inner_uid] = 0;
	insn_lengths[uid] += inner_length;
	}
	}
	else if (GET_CODE (body) != USE && GET_CODE (body) != CLOBBER)
	{
	insn_lengths[uid] = insn_default_length (insn);
	varying_length[uid] = insn_variable_length_p (insn);
	}

	/* If needed, do any adjustment. */
	#ifdef ADJUST_INSN_LENGTH
	ADJUST_INSN_LENGTH (insn, insn_lengths[uid]);
	if (insn_lengths[uid] < 0)
	fatal_insn ("negative insn length", insn);
	#endif
	}

	/* Now loop over all the insns finding varying length insns. For each,
	get the current insn length. If it has changed, reflect the change.
	When nothing changes for a full pass, we are done. */

	while (something_changed)
	{
	something_changed = 0;
	insn_current_align = MAX_CODE_ALIGN - 1;
	for (insn_current_address = 0, insn = first;
	insn != 0;
	insn = NEXT_INSN (insn))
	{
	int new_length;
	#ifdef ADJUST_INSN_LENGTH
	int tmp_length;
	#endif
	int length_align;

	uid = INSN_UID (insn);

	if (LABEL_P (insn))
	{
	- int log = LABEL_TO_ALIGNMENT (insn);
	+/* APPLE LOCAL begin for-fsf-4_4 3274130 5295549 */ \
	+ int log = LABEL_ALIGN_LOG (insn);
	+/* APPLE LOCAL end for-fsf-4_4 3274130 5295549 */ \
	if (log > insn_current_align)
	{
	int align = 1 << log;
	int new_address= (insn_current_address + align - 1) & -align;
	insn_lengths[uid] = new_address - insn_current_address;
	insn_current_align = log;
	insn_current_address = new_address;
	}
	else
	insn_lengths[uid] = 0;
	INSN_ADDRESSES (uid) = insn_current_address;
	continue;
	}

	length_align = INSN_LENGTH_ALIGNMENT (insn);
	if (length_align < insn_current_align)
	insn_current_align = length_align;

	insn_last_address = INSN_ADDRESSES (uid);
	INSN_ADDRESSES (uid) = insn_current_address;

	#ifdef CASE_VECTOR_SHORTEN_MODE
	if (optimize && JUMP_P (insn)
	&& GET_CODE (PATTERN (insn)) == ADDR_DIFF_VEC)
	{
	rtx body = PATTERN (insn);
	int old_length = insn_lengths[uid];
	rtx rel_lab = XEXP (XEXP (body, 0), 0);
	rtx min_lab = XEXP (XEXP (body, 2), 0);
	rtx max_lab = XEXP (XEXP (body, 3), 0);
	int rel_addr = INSN_ADDRESSES (INSN_UID (rel_lab));
	int min_addr = INSN_ADDRESSES (INSN_UID (min_lab));
	int max_addr = INSN_ADDRESSES (INSN_UID (max_lab));
	rtx prev;
	int rel_align = 0;
	addr_diff_vec_flags flags;

	/* Avoid automatic aggregate initialization. */
	flags = ADDR_DIFF_VEC_FLAGS (body);

	/* Try to find a known alignment for rel_lab. */
	for (prev = rel_lab;
	prev
	&& ! insn_lengths[INSN_UID (prev)]
	&& ! (varying_length[INSN_UID (prev)] & 1);
	prev = PREV_INSN (prev))
	if (varying_length[INSN_UID (prev)] & 2)
	{
	- rel_align = LABEL_TO_ALIGNMENT (prev);
	+/* APPLE LOCAL begin for-fsf-4_4 3274130 5295549 */ \
	+ rel_align = LABEL_ALIGN_LOG (prev);
	+/* APPLE LOCAL end for-fsf-4_4 3274130 5295549 */ \
	break;
	}

	/* See the comment on addr_diff_vec_flags in rtl.h for the
	meaning of the flags values. base: REL_LAB vec: INSN */
	/* Anything after INSN has still addresses from the last
	pass; adjust these so that they reflect our current
	estimate for this pass. */
	if (flags.base_after_vec)
	rel_addr += insn_current_address - insn_last_address;
	if (flags.min_after_vec)
	min_addr += insn_current_address - insn_last_address;
	if (flags.max_after_vec)
	max_addr += insn_current_address - insn_last_address;
	/* We want to know the worst case, i.e. lowest possible value
	for the offset of MIN_LAB. If MIN_LAB is after REL_LAB,
	its offset is positive, and we have to be wary of code shrink;
	otherwise, it is negative, and we have to be vary of code
	size increase. */
	if (flags.min_after_base)
	{
	/* If INSN is between REL_LAB and MIN_LAB, the size
	changes we are about to make can change the alignment
	within the observed offset, therefore we have to break
	it up into two parts that are independent. */
	if (! flags.base_after_vec && flags.min_after_vec)
	{
	min_addr -= align_fuzz (rel_lab, insn, rel_align, 0);
	min_addr -= align_fuzz (insn, min_lab, 0, 0);
	}
	else
	min_addr -= align_fuzz (rel_lab, min_lab, rel_align, 0);
	}
	else
	{
	if (flags.base_after_vec && ! flags.min_after_vec)
	{
	min_addr -= align_fuzz (min_lab, insn, 0, ~0);
	min_addr -= align_fuzz (insn, rel_lab, 0, ~0);
	}
	else
	min_addr -= align_fuzz (min_lab, rel_lab, 0, ~0);
	}
	/* Likewise, determine the highest lowest possible value
	for the offset of MAX_LAB. */
	if (flags.max_after_base)
	{
	if (! flags.base_after_vec && flags.max_after_vec)
	{
	max_addr += align_fuzz (rel_lab, insn, rel_align, ~0);
	max_addr += align_fuzz (insn, max_lab, 0, ~0);
	}
	else
	max_addr += align_fuzz (rel_lab, max_lab, rel_align, ~0);
	}
	else
	{
	if (flags.base_after_vec && ! flags.max_after_vec)
	{
	max_addr += align_fuzz (max_lab, insn, 0, 0);
	max_addr += align_fuzz (insn, rel_lab, 0, 0);
	}
	else
	max_addr += align_fuzz (max_lab, rel_lab, 0, 0);
	}
	PUT_MODE (body, CASE_VECTOR_SHORTEN_MODE (min_addr - rel_addr,
	max_addr - rel_addr,
	body));
	if (JUMP_TABLES_IN_TEXT_SECTION
	\|\| readonly_data_section == text_section)
	{
	insn_lengths[uid]
	= (XVECLEN (body, 1) * GET_MODE_SIZE (GET_MODE (body)));
	insn_current_address += insn_lengths[uid];
	if (insn_lengths[uid] != old_length)
	something_changed = 1;
	}

	continue;
	}
	#endif /* CASE_VECTOR_SHORTEN_MODE */

	if (! (varying_length[uid]))
	{
	if (NONJUMP_INSN_P (insn)
	&& GET_CODE (PATTERN (insn)) == SEQUENCE)
	{
	int i;

	body = PATTERN (insn);
	for (i = 0; i < XVECLEN (body, 0); i++)
	{
	rtx inner_insn = XVECEXP (body, 0, i);
	int inner_uid = INSN_UID (inner_insn);

	INSN_ADDRESSES (inner_uid) = insn_current_address;

	insn_current_address += insn_lengths[inner_uid];
	}
	}
	else
	insn_current_address += insn_lengths[uid];

	continue;
	}

	if (NONJUMP_INSN_P (insn) && GET_CODE (PATTERN (insn)) == SEQUENCE)
	{
	int i;

	body = PATTERN (insn);
	new_length = 0;
	for (i = 0; i < XVECLEN (body, 0); i++)
	{
	rtx inner_insn = XVECEXP (body, 0, i);
	int inner_uid = INSN_UID (inner_insn);
	int inner_length;

	INSN_ADDRESSES (inner_uid) = insn_current_address;

	/* insn_current_length returns 0 for insns with a
	non-varying length. */
	if (! varying_length[inner_uid])
	inner_length = insn_lengths[inner_uid];
	else
	inner_length = insn_current_length (inner_insn);

	if (inner_length != insn_lengths[inner_uid])
	{
	insn_lengths[inner_uid] = inner_length;
	something_changed = 1;
	}
	insn_current_address += insn_lengths[inner_uid];
	new_length += inner_length;
	}
	}
	else
	{
	new_length = insn_current_length (insn);
	insn_current_address += new_length;
	}

	#ifdef ADJUST_INSN_LENGTH
	/* If needed, do any adjustment. */
	tmp_length = new_length;
	ADJUST_INSN_LENGTH (insn, new_length);
	insn_current_address += (new_length - tmp_length);
	#endif

	if (new_length != insn_lengths[uid])
	{
	insn_lengths[uid] = new_length;
	something_changed = 1;
	}
	}
	/* For a non-optimizing compile, do only a single pass. */
	if (!optimize)
	break;
	}

	free (varying_length);

	#endif /* HAVE_ATTR_length */
	}

	#ifdef HAVE_ATTR_length
	/* Given the body of an INSN known to be generated by an ASM statement, return
	the number of machine instructions likely to be generated for this insn.
	This is used to compute its length. */

	static int
	asm_insn_count (rtx body)
	{
	const char *template;
	int count = 1;

	if (GET_CODE (body) == ASM_INPUT)
	template = XSTR (body, 0);
	else
	template = decode_asm_operands (body, NULL, NULL, NULL, NULL);

	for (; *template; template++)
	if (IS_ASM_LOGICAL_LINE_SEPARATOR (template) \|\| template == '\n')
	count++;

	return count;
	}
	#endif

	/* Output assembler code for the start of a function,
	and initialize some of the variables in this file
	for the new function. The label for the function and associated
	assembler pseudo-ops have already been output in `assemble_start_function'.

	FIRST is the first insn of the rtl for the function being compiled.
	FILE is the file to write assembler code to.
	OPTIMIZE is nonzero if we should eliminate redundant
	test and compare insns. */

	void
	final_start_function (rtx first ATTRIBUTE_UNUSED, FILE *file,
	int optimize ATTRIBUTE_UNUSED)
	{
	block_depth = 0;

	this_is_asm_operands = 0;

	last_filename = locator_file (prologue_locator);
	last_linenum = locator_line (prologue_locator);

	high_block_linenum = high_function_linenum = last_linenum;

	(*debug_hooks->begin_prologue) (last_linenum, last_filename);

	#if defined (DWARF2_UNWIND_INFO) \|\| defined (TARGET_UNWIND_INFO)
	if (write_symbols != DWARF2_DEBUG && write_symbols != VMS_AND_DWARF2_DEBUG)
	dwarf2out_begin_prologue (0, NULL);
	#endif

	#ifdef LEAF_REG_REMAP
	if (current_function_uses_only_leaf_regs)
	leaf_renumber_regs (first);
	#endif

	/* The Sun386i and perhaps other machines don't work right
	if the profiling code comes after the prologue. */
	#ifdef PROFILE_BEFORE_PROLOGUE
	if (current_function_profile)
	profile_function (file);
	#endif /* PROFILE_BEFORE_PROLOGUE */

	#if defined (DWARF2_UNWIND_INFO) && defined (HAVE_prologue)
	if (dwarf2out_do_frame ())
	dwarf2out_frame_debug (NULL_RTX, false);
	#endif

	/* If debugging, assign block numbers to all of the blocks in this
	function. */
	if (write_symbols)
	{
	reemit_insn_block_notes ();
	number_blocks (current_function_decl);
	/* We never actually put out begin/end notes for the top-level
	block in the function. But, conceptually, that block is
	always needed. */
	TREE_ASM_WRITTEN (DECL_INITIAL (current_function_decl)) = 1;
	}

	if (warn_frame_larger_than
	&& get_frame_size () > frame_larger_than_size)
	{
	/* Issue a warning */
	warning (OPT_Wframe_larger_than_,
	"the frame size of %wd bytes is larger than %wd bytes",
	get_frame_size (), frame_larger_than_size);
	}

	/* First output the function prologue: code to set up the stack frame. */
	targetm.asm_out.function_prologue (file, get_frame_size ());

	/* If the machine represents the prologue as RTL, the profiling code must
	be emitted when NOTE_INSN_PROLOGUE_END is scanned. */
	#ifdef HAVE_prologue
	if (! HAVE_prologue)
	#endif
	profile_after_prologue (file);
	}

	static void
	profile_after_prologue (FILE *file ATTRIBUTE_UNUSED)
	{
	#ifndef PROFILE_BEFORE_PROLOGUE
	if (current_function_profile)
	profile_function (file);
	#endif /* not PROFILE_BEFORE_PROLOGUE */
	}

	static void
	profile_function (FILE *file ATTRIBUTE_UNUSED)
	{
	#ifndef NO_PROFILE_COUNTERS
	# define NO_PROFILE_COUNTERS 0
	#endif
	#if defined(ASM_OUTPUT_REG_PUSH)
	int sval = current_function_returns_struct;
	rtx svrtx = targetm.calls.struct_value_rtx (TREE_TYPE (current_function_decl), 1);
	#if defined(STATIC_CHAIN_INCOMING_REGNUM) \|\| defined(STATIC_CHAIN_REGNUM)
	int cxt = cfun->static_chain_decl != NULL;
	#endif
	#endif /* ASM_OUTPUT_REG_PUSH */

	if (! NO_PROFILE_COUNTERS)
	{
	int align = MIN (BIGGEST_ALIGNMENT, LONG_TYPE_SIZE);
	switch_to_section (data_section);
	ASM_OUTPUT_ALIGN (file, floor_log2 (align / BITS_PER_UNIT));
	targetm.asm_out.internal_label (file, "LP", current_function_funcdef_no);
	assemble_integer (const0_rtx, LONG_TYPE_SIZE / BITS_PER_UNIT, align, 1);
	}

	switch_to_section (current_function_section ());

	#if defined(ASM_OUTPUT_REG_PUSH)
	if (sval && svrtx != NULL_RTX && REG_P (svrtx))
	ASM_OUTPUT_REG_PUSH (file, REGNO (svrtx));
	#endif

	#if defined(STATIC_CHAIN_INCOMING_REGNUM) && defined(ASM_OUTPUT_REG_PUSH)
	if (cxt)
	ASM_OUTPUT_REG_PUSH (file, STATIC_CHAIN_INCOMING_REGNUM);
	#else
	#if defined(STATIC_CHAIN_REGNUM) && defined(ASM_OUTPUT_REG_PUSH)
	if (cxt)
	{
	ASM_OUTPUT_REG_PUSH (file, STATIC_CHAIN_REGNUM);
	}
	#endif
	#endif

	FUNCTION_PROFILER (file, current_function_funcdef_no);

	#if defined(STATIC_CHAIN_INCOMING_REGNUM) && defined(ASM_OUTPUT_REG_PUSH)
	if (cxt)
	ASM_OUTPUT_REG_POP (file, STATIC_CHAIN_INCOMING_REGNUM);
	#else
	#if defined(STATIC_CHAIN_REGNUM) && defined(ASM_OUTPUT_REG_PUSH)
	if (cxt)
	{
	ASM_OUTPUT_REG_POP (file, STATIC_CHAIN_REGNUM);
	}
	#endif
	#endif

	#if defined(ASM_OUTPUT_REG_PUSH)
	if (sval && svrtx != NULL_RTX && REG_P (svrtx))
	ASM_OUTPUT_REG_POP (file, REGNO (svrtx));
	#endif
	}

	/* Output assembler code for the end of a function.
	For clarity, args are same as those of `final_start_function'
	even though not all of them are needed. */

	void
	final_end_function (void)
	{
	app_disable ();

	(*debug_hooks->end_function) (high_function_linenum);

	/* Finally, output the function epilogue:
	code to restore the stack frame and return to the caller. */
	targetm.asm_out.function_epilogue (asm_out_file, get_frame_size ());

	/* And debug output. */
	(*debug_hooks->end_epilogue) (last_linenum, last_filename);

	#if defined (DWARF2_UNWIND_INFO)
	if (write_symbols != DWARF2_DEBUG && write_symbols != VMS_AND_DWARF2_DEBUG
	&& dwarf2out_do_frame ())
	dwarf2out_end_epilogue (last_linenum, last_filename);
	#endif
	}

	/* Output assembler code for some insns: all or part of a function.
	For description of args, see `final_start_function', above. */

	void
	final (rtx first, FILE *file, int optimize)
	{
	rtx insn;
	int max_uid = 0;
	int seen = 0;

	last_ignored_compare = 0;

	#ifdef SDB_DEBUGGING_INFO
	/* When producing SDB debugging info, delete troublesome line number
	notes from inlined functions in other files as well as duplicate
	line number notes. */
	if (write_symbols == SDB_DEBUG)
	{
	rtx last = 0;
	for (insn = first; insn; insn = NEXT_INSN (insn))
	if (NOTE_P (insn) && NOTE_LINE_NUMBER (insn) > 0)
	{
	if (last != 0
	#ifdef USE_MAPPED_LOCATION
	&& NOTE_SOURCE_LOCATION (insn) == NOTE_SOURCE_LOCATION (last)
	#else
	&& NOTE_LINE_NUMBER (insn) == NOTE_LINE_NUMBER (last)
	&& NOTE_SOURCE_FILE (insn) == NOTE_SOURCE_FILE (last)
	#endif
	)
	{
	delete_insn (insn); /* Use delete_note. */
	continue;
	}
	last = insn;
	}
	}
	#endif

	for (insn = first; insn; insn = NEXT_INSN (insn))
	{
	if (INSN_UID (insn) > max_uid) /* Find largest UID. */
	max_uid = INSN_UID (insn);
	#ifdef HAVE_cc0
	/* If CC tracking across branches is enabled, record the insn which
	jumps to each branch only reached from one place. */
	if (optimize && JUMP_P (insn))
	{
	rtx lab = JUMP_LABEL (insn);
	if (lab && LABEL_NUSES (lab) == 1)
	{
	LABEL_REFS (lab) = insn;
	}
	}
	#endif
	}

	init_recog ();

	CC_STATUS_INIT;

	/* Output the insns. */
	for (insn = NEXT_INSN (first); insn;)
	{
	#ifdef HAVE_ATTR_length
	if ((unsigned) INSN_UID (insn) >= INSN_ADDRESSES_SIZE ())
	{
	/* This can be triggered by bugs elsewhere in the compiler if
	new insns are created after init_insn_lengths is called. */
	gcc_assert (NOTE_P (insn));
	insn_current_address = -1;
	}
	else
	insn_current_address = INSN_ADDRESSES (INSN_UID (insn));
	#endif /* HAVE_ATTR_length */

	insn = final_scan_insn (insn, file, optimize, 0, &seen);
	}
	}

	const char *
	get_insn_template (int code, rtx insn)
	{
	switch (insn_data[code].output_format)
	{
	case INSN_OUTPUT_FORMAT_SINGLE:
	return insn_data[code].output.single;
	case INSN_OUTPUT_FORMAT_MULTI:
	return insn_data[code].output.multi[which_alternative];
	case INSN_OUTPUT_FORMAT_FUNCTION:
	gcc_assert (insn);
	return (*insn_data[code].output.function) (recog_data.operand, insn);

	default:
	gcc_unreachable ();
	}
	}

	/* Emit the appropriate declaration for an alternate-entry-point
	symbol represented by INSN, to FILE. INSN is a CODE_LABEL with
	LABEL_KIND != LABEL_NORMAL.

	The case fall-through in this function is intentional. */
	static void
	output_alternate_entry_point (FILE *file, rtx insn)
	{
	const char *name = LABEL_NAME (insn);

	switch (LABEL_KIND (insn))
	{
	case LABEL_WEAK_ENTRY:
	#ifdef ASM_WEAKEN_LABEL
	ASM_WEAKEN_LABEL (file, name);
	#endif
	case LABEL_GLOBAL_ENTRY:
	targetm.asm_out.globalize_label (file, name);
	case LABEL_STATIC_ENTRY:
	#ifdef ASM_OUTPUT_TYPE_DIRECTIVE
	ASM_OUTPUT_TYPE_DIRECTIVE (file, name, "function");
	#endif
	ASM_OUTPUT_LABEL (file, name);
	break;

	case LABEL_NORMAL:
	default:
	gcc_unreachable ();
	}
	}

	/* The final scan for one insn, INSN.
	Args are same as in `final', except that INSN
	is the insn being scanned.
	Value returned is the next insn to be scanned.

	NOPEEPHOLES is the flag to disallow peephole processing (currently
	used for within delayed branch sequence output).

	SEEN is used to track the end of the prologue, for emitting
	debug information. We force the emission of a line note after
	both NOTE_INSN_PROLOGUE_END and NOTE_INSN_FUNCTION_BEG, or
	at the beginning of the second basic block, whichever comes
	first. */

	rtx
	final_scan_insn (rtx insn, FILE *file, int optimize ATTRIBUTE_UNUSED,
	int nopeepholes ATTRIBUTE_UNUSED, int *seen)
	{
	#ifdef HAVE_cc0
	rtx set;
	#endif
	rtx next;

	insn_counter++;

	/* Ignore deleted insns. These can occur when we split insns (due to a
	template of "#") while not optimizing. */
	if (INSN_DELETED_P (insn))
	return NEXT_INSN (insn);

	switch (GET_CODE (insn))
	{
	case NOTE:
	switch (NOTE_LINE_NUMBER (insn))
	{
	case NOTE_INSN_DELETED:
	case NOTE_INSN_FUNCTION_END:
	case NOTE_INSN_REPEATED_LINE_NUMBER:
	case NOTE_INSN_EXPECTED_VALUE:
	break;

	case NOTE_INSN_SWITCH_TEXT_SECTIONS:
	in_cold_section_p = !in_cold_section_p;
	(*debug_hooks->switch_text_section) ();
	switch_to_section (current_function_section ());
	break;

	case NOTE_INSN_BASIC_BLOCK:
	#ifdef TARGET_UNWIND_INFO
	targetm.asm_out.unwind_emit (asm_out_file, insn);
	#endif

	if (flag_debug_asm)
	fprintf (asm_out_file, "\t%s basic block %d\n",
	ASM_COMMENT_START, NOTE_BASIC_BLOCK (insn)->index);

	if ((*seen & (SEEN_EMITTED \| SEEN_BB)) == SEEN_BB)
	{
	*seen \|= SEEN_EMITTED;
	force_source_line = true;
	}
	else
	*seen \|= SEEN_BB;

	break;

	case NOTE_INSN_EH_REGION_BEG:
	ASM_OUTPUT_DEBUG_LABEL (asm_out_file, "LEHB",
	NOTE_EH_HANDLER (insn));
	break;

	case NOTE_INSN_EH_REGION_END:
	ASM_OUTPUT_DEBUG_LABEL (asm_out_file, "LEHE",
	NOTE_EH_HANDLER (insn));
	break;

	case NOTE_INSN_PROLOGUE_END:
	targetm.asm_out.function_end_prologue (file);
	profile_after_prologue (file);

	if ((*seen & (SEEN_EMITTED \| SEEN_NOTE)) == SEEN_NOTE)
	{
	*seen \|= SEEN_EMITTED;
	force_source_line = true;
	}
	else
	*seen \|= SEEN_NOTE;

	break;

	case NOTE_INSN_EPILOGUE_BEG:
	targetm.asm_out.function_begin_epilogue (file);
	break;

	case NOTE_INSN_FUNCTION_BEG:
	app_disable ();
	(*debug_hooks->end_prologue) (last_linenum, last_filename);

	if ((*seen & (SEEN_EMITTED \| SEEN_NOTE)) == SEEN_NOTE)
	{
	*seen \|= SEEN_EMITTED;
	force_source_line = true;
	}
	else
	*seen \|= SEEN_NOTE;

	break;

	case NOTE_INSN_BLOCK_BEG:
	if (debug_info_level == DINFO_LEVEL_NORMAL
	\|\| debug_info_level == DINFO_LEVEL_VERBOSE
	\|\| write_symbols == DWARF2_DEBUG
	\|\| write_symbols == VMS_AND_DWARF2_DEBUG
	\|\| write_symbols == VMS_DEBUG)
	{
	int n = BLOCK_NUMBER (NOTE_BLOCK (insn));

	app_disable ();
	++block_depth;
	high_block_linenum = last_linenum;

	/* Output debugging info about the symbol-block beginning. */
	(*debug_hooks->begin_block) (last_linenum, n);

	/* Mark this block as output. */
	TREE_ASM_WRITTEN (NOTE_BLOCK (insn)) = 1;
	}
	break;

	case NOTE_INSN_BLOCK_END:
	if (debug_info_level == DINFO_LEVEL_NORMAL
	\|\| debug_info_level == DINFO_LEVEL_VERBOSE
	\|\| write_symbols == DWARF2_DEBUG
	\|\| write_symbols == VMS_AND_DWARF2_DEBUG
	\|\| write_symbols == VMS_DEBUG)
	{
	int n = BLOCK_NUMBER (NOTE_BLOCK (insn));

	app_disable ();

	/* End of a symbol-block. */
	--block_depth;
	gcc_assert (block_depth >= 0);

	(*debug_hooks->end_block) (high_block_linenum, n);
	}
	break;

	case NOTE_INSN_DELETED_LABEL:
	/* Emit the label. We may have deleted the CODE_LABEL because
	the label could be proved to be unreachable, though still
	referenced (in the form of having its address taken. */
	ASM_OUTPUT_DEBUG_LABEL (file, "L", CODE_LABEL_NUMBER (insn));
	break;

	case NOTE_INSN_VAR_LOCATION:
	(*debug_hooks->var_location) (insn);
	break;

	case 0:
	break;

	default:
	gcc_assert (NOTE_LINE_NUMBER (insn) > 0);
	break;
	}
	break;

	case BARRIER:
	#if defined (DWARF2_UNWIND_INFO)
	if (dwarf2out_do_frame ())
	dwarf2out_frame_debug (insn, false);
	#endif
	break;

	case CODE_LABEL:
	/* The target port might emit labels in the output function for
	some insn, e.g. sh.c output_branchy_insn. */
	- if (CODE_LABEL_NUMBER (insn) <= max_labelno)
	- {
	- int align = LABEL_TO_ALIGNMENT (insn);
	+/* APPLE LOCAL begin for-fsf-4_4 3274130 5295549 */ \
	+ {
	+ int align = LABEL_ALIGN_LOG (insn);
	#ifdef ASM_OUTPUT_MAX_SKIP_ALIGN
	- int max_skip = LABEL_TO_MAX_SKIP (insn);
	+ int max_skip = LABEL_MAX_SKIP (insn);
	#endif
	-
	- if (align && NEXT_INSN (insn))
	- {
	+
	+ if (align && NEXT_INSN (insn))
	+ {
	#ifdef ASM_OUTPUT_MAX_SKIP_ALIGN
	- ASM_OUTPUT_MAX_SKIP_ALIGN (file, align, max_skip);
	+ ASM_OUTPUT_MAX_SKIP_ALIGN (file, align, max_skip);
	#else
	#ifdef ASM_OUTPUT_ALIGN_WITH_NOP
	- ASM_OUTPUT_ALIGN_WITH_NOP (file, align);
	+ ASM_OUTPUT_ALIGN_WITH_NOP (file, align);
	#else
	- ASM_OUTPUT_ALIGN (file, align);
	+ ASM_OUTPUT_ALIGN (file, align);
	#endif
	#endif
	- }
	- }
	+ }
	+ }
	+/* APPLE LOCAL end for-fsf-4_4 3274130 5295549 */ \
	#ifdef HAVE_cc0
	CC_STATUS_INIT;
	/* If this label is reached from only one place, set the condition
	codes from the instruction just before the branch. */

	/* Disabled because some insns set cc_status in the C output code
	and NOTICE_UPDATE_CC alone can set incorrect status. */
	if (0 /* optimize && LABEL_NUSES (insn) == 1*/)
	{
	rtx jump = LABEL_REFS (insn);
	rtx barrier = prev_nonnote_insn (insn);
	rtx prev;
	/* If the LABEL_REFS field of this label has been set to point
	at a branch, the predecessor of the branch is a regular
	insn, and that branch is the only way to reach this label,
	set the condition codes based on the branch and its
	predecessor. */
	if (barrier && BARRIER_P (barrier)
	&& jump && JUMP_P (jump)
	&& (prev = prev_nonnote_insn (jump))
	&& NONJUMP_INSN_P (prev))
	{
	NOTICE_UPDATE_CC (PATTERN (prev), prev);
	NOTICE_UPDATE_CC (PATTERN (jump), jump);
	}
	}
	#endif

	if (LABEL_NAME (insn))
	(*debug_hooks->label) (insn);

	if (app_on)
	{
	fputs (ASM_APP_OFF, file);
	app_on = 0;
	}

	next = next_nonnote_insn (insn);
	if (next != 0 && JUMP_P (next))
	{
	rtx nextbody = PATTERN (next);

	/* If this label is followed by a jump-table,
	make sure we put the label in the read-only section. Also
	possibly write the label and jump table together. */

	if (GET_CODE (nextbody) == ADDR_VEC
	\|\| GET_CODE (nextbody) == ADDR_DIFF_VEC)
	{
	#if defined(ASM_OUTPUT_ADDR_VEC) \|\| defined(ASM_OUTPUT_ADDR_DIFF_VEC)
	/* In this case, the case vector is being moved by the
	target, so don't output the label at all. Leave that
	to the back end macros. */
	#else
	if (! JUMP_TABLES_IN_TEXT_SECTION)
	{
	int log_align;

	switch_to_section (targetm.asm_out.function_rodata_section
	(current_function_decl));

	#ifdef ADDR_VEC_ALIGN
	log_align = ADDR_VEC_ALIGN (next);
	#else
	log_align = exact_log2 (BIGGEST_ALIGNMENT / BITS_PER_UNIT);
	#endif
	ASM_OUTPUT_ALIGN (file, log_align);
	}
	else
	switch_to_section (current_function_section ());

	#ifdef ASM_OUTPUT_CASE_LABEL
	ASM_OUTPUT_CASE_LABEL (file, "L", CODE_LABEL_NUMBER (insn),
	next);
	#else
	targetm.asm_out.internal_label (file, "L", CODE_LABEL_NUMBER (insn));
	#endif
	#endif
	break;
	}
	}
	if (LABEL_ALT_ENTRY_P (insn))
	output_alternate_entry_point (file, insn);
	else
	targetm.asm_out.internal_label (file, "L", CODE_LABEL_NUMBER (insn));
	break;

	default:
	{
	rtx body = PATTERN (insn);
	int insn_code_number;
	const char *template;

	#ifdef HAVE_conditional_execution
	/* Reset this early so it is correct for ASM statements. */
	current_insn_predicate = NULL_RTX;
	#endif
	/* An INSN, JUMP_INSN or CALL_INSN.
	First check for special kinds that recog doesn't recognize. */

	if (GET_CODE (body) == USE /* These are just declarations. */
	\|\| GET_CODE (body) == CLOBBER)
	break;

	#ifdef HAVE_cc0
	{
	/* If there is a REG_CC_SETTER note on this insn, it means that
	the setting of the condition code was done in the delay slot
	of the insn that branched here. So recover the cc status
	from the insn that set it. */

	rtx note = find_reg_note (insn, REG_CC_SETTER, NULL_RTX);
	if (note)
	{
	NOTICE_UPDATE_CC (PATTERN (XEXP (note, 0)), XEXP (note, 0));
	cc_prev_status = cc_status;
	}
	}
	#endif

	/* Detect insns that are really jump-tables
	and output them as such. */

	if (GET_CODE (body) == ADDR_VEC \|\| GET_CODE (body) == ADDR_DIFF_VEC)
	{
	#if !(defined(ASM_OUTPUT_ADDR_VEC) \|\| defined(ASM_OUTPUT_ADDR_DIFF_VEC))
	int vlen, idx;
	#endif

	if (! JUMP_TABLES_IN_TEXT_SECTION)
	switch_to_section (targetm.asm_out.function_rodata_section
	(current_function_decl));
	else
	switch_to_section (current_function_section ());

	if (app_on)
	{
	fputs (ASM_APP_OFF, file);
	app_on = 0;
	}

	#if defined(ASM_OUTPUT_ADDR_VEC) \|\| defined(ASM_OUTPUT_ADDR_DIFF_VEC)
	if (GET_CODE (body) == ADDR_VEC)
	{
	#ifdef ASM_OUTPUT_ADDR_VEC
	ASM_OUTPUT_ADDR_VEC (PREV_INSN (insn), body);
	#else
	gcc_unreachable ();
	#endif
	}
	else
	{
	#ifdef ASM_OUTPUT_ADDR_DIFF_VEC
	ASM_OUTPUT_ADDR_DIFF_VEC (PREV_INSN (insn), body);
	#else
	gcc_unreachable ();
	#endif
	}
	#else
	vlen = XVECLEN (body, GET_CODE (body) == ADDR_DIFF_VEC);
	for (idx = 0; idx < vlen; idx++)
	{
	if (GET_CODE (body) == ADDR_VEC)
	{
	#ifdef ASM_OUTPUT_ADDR_VEC_ELT
	ASM_OUTPUT_ADDR_VEC_ELT
	(file, CODE_LABEL_NUMBER (XEXP (XVECEXP (body, 0, idx), 0)));
	#else
	gcc_unreachable ();
	#endif
	}
	else
	{
	#ifdef ASM_OUTPUT_ADDR_DIFF_ELT
	ASM_OUTPUT_ADDR_DIFF_ELT
	(file,
	body,
	CODE_LABEL_NUMBER (XEXP (XVECEXP (body, 1, idx), 0)),
	CODE_LABEL_NUMBER (XEXP (XEXP (body, 0), 0)));
	#else
	gcc_unreachable ();
	#endif
	}
	}
	#ifdef ASM_OUTPUT_CASE_END
	ASM_OUTPUT_CASE_END (file,
	CODE_LABEL_NUMBER (PREV_INSN (insn)),
	insn);
	#endif
	#endif

	switch_to_section (current_function_section ());

	break;
	}
	/* Output this line note if it is the first or the last line
	note in a row. */
	if (notice_source_line (insn))
	{
	(*debug_hooks->source_line) (last_linenum, last_filename);
	}

	if (GET_CODE (body) == ASM_INPUT)
	{
	const char *string = XSTR (body, 0);

	/* There's no telling what that did to the condition codes. */
	CC_STATUS_INIT;

	if (string[0])
	{
	if (! app_on)
	{
	fputs (ASM_APP_ON, file);
	app_on = 1;
	}
	fprintf (asm_out_file, "\t%s\n", string);
	}
	break;
	}

	/* Detect `asm' construct with operands. */
	if (asm_noperands (body) >= 0)
	{
	unsigned int noperands = asm_noperands (body);
	rtx ops = alloca (noperands sizeof (rtx));
	const char *string;

	/* There's no telling what that did to the condition codes. */
	CC_STATUS_INIT;

	/* Get out the operand values. */
	string = decode_asm_operands (body, ops, NULL, NULL, NULL);
	/* Inhibit dieing on what would otherwise be compiler bugs. */
	insn_noperands = noperands;
	this_is_asm_operands = insn;

	#ifdef FINAL_PRESCAN_INSN
	FINAL_PRESCAN_INSN (insn, ops, insn_noperands);
	#endif

	/* Output the insn using them. */
	if (string[0])
	{
	if (! app_on)
	{
	fputs (ASM_APP_ON, file);
	app_on = 1;
	}
	output_asm_insn (string, ops);
	}

	this_is_asm_operands = 0;
	break;
	}

	if (app_on)
	{
	fputs (ASM_APP_OFF, file);
	app_on = 0;
	}

	if (GET_CODE (body) == SEQUENCE)
	{
	/* A delayed-branch sequence */
	int i;

	final_sequence = body;

	/* Record the delay slots' frame information before the branch.
	This is needed for delayed calls: see execute_cfa_program(). */
	#if defined (DWARF2_UNWIND_INFO)
	if (dwarf2out_do_frame ())
	for (i = 1; i < XVECLEN (body, 0); i++)
	dwarf2out_frame_debug (XVECEXP (body, 0, i), false);
	#endif

	/* The first insn in this SEQUENCE might be a JUMP_INSN that will
	force the restoration of a comparison that was previously
	thought unnecessary. If that happens, cancel this sequence
	and cause that insn to be restored. */

	next = final_scan_insn (XVECEXP (body, 0, 0), file, 0, 1, seen);
	if (next != XVECEXP (body, 0, 1))
	{
	final_sequence = 0;
	return next;
	}

	for (i = 1; i < XVECLEN (body, 0); i++)
	{
	rtx insn = XVECEXP (body, 0, i);
	rtx next = NEXT_INSN (insn);
	/* We loop in case any instruction in a delay slot gets
	split. */
	do
	insn = final_scan_insn (insn, file, 0, 1, seen);
	while (insn != next);
	}
	#ifdef DBR_OUTPUT_SEQEND
	DBR_OUTPUT_SEQEND (file);
	#endif
	final_sequence = 0;

	/* If the insn requiring the delay slot was a CALL_INSN, the
	insns in the delay slot are actually executed before the
	called function. Hence we don't preserve any CC-setting
	actions in these insns and the CC must be marked as being
	clobbered by the function. */
	if (CALL_P (XVECEXP (body, 0, 0)))
	{
	CC_STATUS_INIT;
	}
	break;
	}

	/* We have a real machine instruction as rtl. */

	body = PATTERN (insn);

	#ifdef HAVE_cc0
	set = single_set (insn);

	/* Check for redundant test and compare instructions
	(when the condition codes are already set up as desired).
	This is done only when optimizing; if not optimizing,
	it should be possible for the user to alter a variable
	with the debugger in between statements
	and the next statement should reexamine the variable
	to compute the condition codes. */

	if (optimize)
	{
	if (set
	&& GET_CODE (SET_DEST (set)) == CC0
	&& insn != last_ignored_compare)
	{
	if (GET_CODE (SET_SRC (set)) == SUBREG)
	SET_SRC (set) = alter_subreg (&SET_SRC (set));
	else if (GET_CODE (SET_SRC (set)) == COMPARE)
	{
	if (GET_CODE (XEXP (SET_SRC (set), 0)) == SUBREG)
	XEXP (SET_SRC (set), 0)
	= alter_subreg (&XEXP (SET_SRC (set), 0));
	if (GET_CODE (XEXP (SET_SRC (set), 1)) == SUBREG)
	XEXP (SET_SRC (set), 1)
	= alter_subreg (&XEXP (SET_SRC (set), 1));
	}
	if ((cc_status.value1 != 0
	&& rtx_equal_p (SET_SRC (set), cc_status.value1))
	\|\| (cc_status.value2 != 0
	&& rtx_equal_p (SET_SRC (set), cc_status.value2)))
	{
	/* Don't delete insn if it has an addressing side-effect. */
	if (! FIND_REG_INC_NOTE (insn, NULL_RTX)
	/* or if anything in it is volatile. */
	&& ! volatile_refs_p (PATTERN (insn)))
	{
	/* We don't really delete the insn; just ignore it. */
	last_ignored_compare = insn;
	break;
	}
	}
	}
	}
	#endif

	#ifdef HAVE_cc0
	/* If this is a conditional branch, maybe modify it
	if the cc's are in a nonstandard state
	so that it accomplishes the same thing that it would
	do straightforwardly if the cc's were set up normally. */

	if (cc_status.flags != 0
	&& JUMP_P (insn)
	&& GET_CODE (body) == SET
	&& SET_DEST (body) == pc_rtx
	&& GET_CODE (SET_SRC (body)) == IF_THEN_ELSE
	&& COMPARISON_P (XEXP (SET_SRC (body), 0))
	&& XEXP (XEXP (SET_SRC (body), 0), 0) == cc0_rtx)
	{
	/* This function may alter the contents of its argument
	and clear some of the cc_status.flags bits.
	It may also return 1 meaning condition now always true
	or -1 meaning condition now always false
	or 2 meaning condition nontrivial but altered. */
	int result = alter_cond (XEXP (SET_SRC (body), 0));
	/* If condition now has fixed value, replace the IF_THEN_ELSE
	with its then-operand or its else-operand. */
	if (result == 1)
	SET_SRC (body) = XEXP (SET_SRC (body), 1);
	if (result == -1)
	SET_SRC (body) = XEXP (SET_SRC (body), 2);

	/* The jump is now either unconditional or a no-op.
	If it has become a no-op, don't try to output it.
	(It would not be recognized.) */
	if (SET_SRC (body) == pc_rtx)
	{
	delete_insn (insn);
	break;
	}
	else if (GET_CODE (SET_SRC (body)) == RETURN)
	/* Replace (set (pc) (return)) with (return). */
	PATTERN (insn) = body = SET_SRC (body);

	/* Rerecognize the instruction if it has changed. */
	if (result != 0)
	INSN_CODE (insn) = -1;
	}

	/* Make same adjustments to instructions that examine the
	condition codes without jumping and instructions that
	handle conditional moves (if this machine has either one). */

	if (cc_status.flags != 0
	&& set != 0)
	{
	rtx cond_rtx, then_rtx, else_rtx;

	if (!JUMP_P (insn)
	&& GET_CODE (SET_SRC (set)) == IF_THEN_ELSE)
	{
	cond_rtx = XEXP (SET_SRC (set), 0);
	then_rtx = XEXP (SET_SRC (set), 1);
	else_rtx = XEXP (SET_SRC (set), 2);
	}
	else
	{
	cond_rtx = SET_SRC (set);
	then_rtx = const_true_rtx;
	else_rtx = const0_rtx;
	}

	switch (GET_CODE (cond_rtx))
	{
	case GTU:
	case GT:
	case LTU:
	case LT:
	case GEU:
	case GE:
	case LEU:
	case LE:
	case EQ:
	case NE:
	{
	int result;
	if (XEXP (cond_rtx, 0) != cc0_rtx)
	break;
	result = alter_cond (cond_rtx);
	if (result == 1)
	validate_change (insn, &SET_SRC (set), then_rtx, 0);
	else if (result == -1)
	validate_change (insn, &SET_SRC (set), else_rtx, 0);
	else if (result == 2)
	INSN_CODE (insn) = -1;
	if (SET_DEST (set) == SET_SRC (set))
	delete_insn (insn);
	}
	break;

	default:
	break;
	}
	}

	#endif

	#ifdef HAVE_peephole
	/* Do machine-specific peephole optimizations if desired. */

	if (optimize && !flag_no_peephole && !nopeepholes)
	{
	rtx next = peephole (insn);
	/* When peepholing, if there were notes within the peephole,
	emit them before the peephole. */
	if (next != 0 && next != NEXT_INSN (insn))
	{
	rtx note, prev = PREV_INSN (insn);

	for (note = NEXT_INSN (insn); note != next;
	note = NEXT_INSN (note))
	final_scan_insn (note, file, optimize, nopeepholes, seen);

	/* Put the notes in the proper position for a later
	rescan. For example, the SH target can do this
	when generating a far jump in a delayed branch
	sequence. */
	note = NEXT_INSN (insn);
	PREV_INSN (note) = prev;
	NEXT_INSN (prev) = note;
	NEXT_INSN (PREV_INSN (next)) = insn;
	PREV_INSN (insn) = PREV_INSN (next);
	NEXT_INSN (insn) = next;
	PREV_INSN (next) = insn;
	}

	/* PEEPHOLE might have changed this. */
	body = PATTERN (insn);
	}
	#endif

	/* Try to recognize the instruction.
	If successful, verify that the operands satisfy the
	constraints for the instruction. Crash if they don't,
	since `reload' should have changed them so that they do. */

	insn_code_number = recog_memoized (insn);
	cleanup_subreg_operands (insn);

	/* Dump the insn in the assembly for debugging. */
	if (flag_dump_rtl_in_asm)
	{
	print_rtx_head = ASM_COMMENT_START;
	print_rtl_single (asm_out_file, insn);
	print_rtx_head = "";
	}

	if (! constrain_operands_cached (1))
	fatal_insn_not_found (insn);

	/* Some target machines need to prescan each insn before
	it is output. */

	#ifdef FINAL_PRESCAN_INSN
	FINAL_PRESCAN_INSN (insn, recog_data.operand, recog_data.n_operands);
	#endif

	#ifdef HAVE_conditional_execution
	if (GET_CODE (PATTERN (insn)) == COND_EXEC)
	current_insn_predicate = COND_EXEC_TEST (PATTERN (insn));
	#endif

	#ifdef HAVE_cc0
	cc_prev_status = cc_status;

	/* Update `cc_status' for this instruction.
	The instruction's output routine may change it further.
	If the output routine for a jump insn needs to depend
	on the cc status, it should look at cc_prev_status. */

	NOTICE_UPDATE_CC (body, insn);
	#endif

	current_output_insn = debug_insn = insn;

	#if defined (DWARF2_UNWIND_INFO)
	if (CALL_P (insn) && dwarf2out_do_frame ())
	dwarf2out_frame_debug (insn, false);
	#endif

	/* Find the proper template for this insn. */
	template = get_insn_template (insn_code_number, insn);

	/* If the C code returns 0, it means that it is a jump insn
	which follows a deleted test insn, and that test insn
	needs to be reinserted. */
	if (template == 0)
	{
	rtx prev;

	gcc_assert (prev_nonnote_insn (insn) == last_ignored_compare);

	/* We have already processed the notes between the setter and
	the user. Make sure we don't process them again, this is
	particularly important if one of the notes is a block
	scope note or an EH note. */
	for (prev = insn;
	prev != last_ignored_compare;
	prev = PREV_INSN (prev))
	{
	if (NOTE_P (prev))
	delete_insn (prev); /* Use delete_note. */
	}

	return prev;
	}

	/* If the template is the string "#", it means that this insn must
	be split. */
	if (template[0] == '#' && template[1] == '\0')
	{
	rtx new = try_split (body, insn, 0);

	/* If we didn't split the insn, go away. */
	if (new == insn && PATTERN (new) == body)
	fatal_insn ("could not split insn", insn);

	#ifdef HAVE_ATTR_length
	/* This instruction should have been split in shorten_branches,
	to ensure that we would have valid length info for the
	splitees. */
	gcc_unreachable ();
	#endif

	return new;
	}

	#ifdef TARGET_UNWIND_INFO
	/* ??? This will put the directives in the wrong place if
	get_insn_template outputs assembly directly. However calling it
	before get_insn_template breaks if the insns is split. */
	targetm.asm_out.unwind_emit (asm_out_file, insn);
	#endif

	/* Output assembler code from the template. */
	output_asm_insn (template, recog_data.operand);

	/* If necessary, report the effect that the instruction has on
	the unwind info. We've already done this for delay slots
	and call instructions. */
	#if defined (DWARF2_UNWIND_INFO)
	if (final_sequence == 0
	#if !defined (HAVE_prologue)
	&& !ACCUMULATE_OUTGOING_ARGS
	#endif
	&& dwarf2out_do_frame ())
	dwarf2out_frame_debug (insn, true);
	#endif

	current_output_insn = debug_insn = 0;
	}
	}
	return NEXT_INSN (insn);
	}

	/* Return whether a source line note needs to be emitted before INSN. */

	static bool
	notice_source_line (rtx insn)
	{
	const char *filename = insn_file (insn);
	int linenum = insn_line (insn);

	if (filename
	&& (force_source_line
	\|\| filename != last_filename
	\|\| last_linenum != linenum))
	{
	force_source_line = false;
	last_filename = filename;
	last_linenum = linenum;
	high_block_linenum = MAX (last_linenum, high_block_linenum);
	high_function_linenum = MAX (last_linenum, high_function_linenum);
	return true;
	}
	return false;
	}

	/* For each operand in INSN, simplify (subreg (reg)) so that it refers
	directly to the desired hard register. */

	void
	cleanup_subreg_operands (rtx insn)
	{
	int i;
	extract_insn_cached (insn);
	for (i = 0; i < recog_data.n_operands; i++)
	{
	/* The following test cannot use recog_data.operand when testing
	for a SUBREG: the underlying object might have been changed
	already if we are inside a match_operator expression that
	matches the else clause. Instead we test the underlying
	expression directly. */
	if (GET_CODE (*recog_data.operand_loc[i]) == SUBREG)
	recog_data.operand[i] = alter_subreg (recog_data.operand_loc[i]);
	else if (GET_CODE (recog_data.operand[i]) == PLUS
	\|\| GET_CODE (recog_data.operand[i]) == MULT
	\|\| MEM_P (recog_data.operand[i]))
	recog_data.operand[i] = walk_alter_subreg (recog_data.operand_loc[i]);
	}

	for (i = 0; i < recog_data.n_dups; i++)
	{
	if (GET_CODE (*recog_data.dup_loc[i]) == SUBREG)
	*recog_data.dup_loc[i] = alter_subreg (recog_data.dup_loc[i]);
	else if (GET_CODE (*recog_data.dup_loc[i]) == PLUS
	\|\| GET_CODE (*recog_data.dup_loc[i]) == MULT
	\|\| MEM_P (*recog_data.dup_loc[i]))
	*recog_data.dup_loc[i] = walk_alter_subreg (recog_data.dup_loc[i]);
	}
	}

	/* If X is a SUBREG, replace it with a REG or a MEM,
	based on the thing it is a subreg of. */

	rtx
	alter_subreg (rtx *xp)
	{
	rtx x = *xp;
	rtx y = SUBREG_REG (x);

	/* simplify_subreg does not remove subreg from volatile references.
	We are required to. */
	if (MEM_P (y))
	{
	int offset = SUBREG_BYTE (x);

	/* For paradoxical subregs on big-endian machines, SUBREG_BYTE
	contains 0 instead of the proper offset. See simplify_subreg. */
	if (offset == 0
	&& GET_MODE_SIZE (GET_MODE (y)) < GET_MODE_SIZE (GET_MODE (x)))
	{
	int difference = GET_MODE_SIZE (GET_MODE (y))
	- GET_MODE_SIZE (GET_MODE (x));
	if (WORDS_BIG_ENDIAN)
	offset += (difference / UNITS_PER_WORD) * UNITS_PER_WORD;
	if (BYTES_BIG_ENDIAN)
	offset += difference % UNITS_PER_WORD;
	}

	*xp = adjust_address (y, GET_MODE (x), offset);
	}
	else
	{
	rtx new = simplify_subreg (GET_MODE (x), y, GET_MODE (y),
	SUBREG_BYTE (x));

	if (new != 0)
	*xp = new;
	else if (REG_P (y))
	{
	/* Simplify_subreg can't handle some REG cases, but we have to. */
	unsigned int regno = subreg_regno (x);
	*xp = gen_rtx_REG_offset (y, GET_MODE (x), regno, SUBREG_BYTE (x));
	}
	}

	return *xp;
	}

	/* Do alter_subreg on all the SUBREGs contained in X. */

	static rtx
	walk_alter_subreg (rtx *xp)
	{
	rtx x = *xp;
	switch (GET_CODE (x))
	{
	case PLUS:
	case MULT:
	case AND:
	XEXP (x, 0) = walk_alter_subreg (&XEXP (x, 0));
	XEXP (x, 1) = walk_alter_subreg (&XEXP (x, 1));
	break;

	case MEM:
	case ZERO_EXTEND:
	XEXP (x, 0) = walk_alter_subreg (&XEXP (x, 0));
	break;

	case SUBREG:
	return alter_subreg (xp);

	default:
	break;
	}

	return *xp;
	}

	#ifdef HAVE_cc0

	/* Given BODY, the body of a jump instruction, alter the jump condition
	as required by the bits that are set in cc_status.flags.
	Not all of the bits there can be handled at this level in all cases.

	The value is normally 0.
	1 means that the condition has become always true.
	-1 means that the condition has become always false.
	2 means that COND has been altered. */

	static int
	alter_cond (rtx cond)
	{
	int value = 0;

	if (cc_status.flags & CC_REVERSED)
	{
	value = 2;
	PUT_CODE (cond, swap_condition (GET_CODE (cond)));
	}

	if (cc_status.flags & CC_INVERTED)
	{
	value = 2;
	PUT_CODE (cond, reverse_condition (GET_CODE (cond)));
	}

	if (cc_status.flags & CC_NOT_POSITIVE)
	switch (GET_CODE (cond))
	{
	case LE:
	case LEU:
	case GEU:
	/* Jump becomes unconditional. */
	return 1;

	case GT:
	case GTU:
	case LTU:
	/* Jump becomes no-op. */
	return -1;

	case GE:
	PUT_CODE (cond, EQ);
	value = 2;
	break;

	case LT:
	PUT_CODE (cond, NE);
	value = 2;
	break;

	default:
	break;
	}

	if (cc_status.flags & CC_NOT_NEGATIVE)
	switch (GET_CODE (cond))
	{
	case GE:
	case GEU:
	/* Jump becomes unconditional. */
	return 1;

	case LT:
	case LTU:
	/* Jump becomes no-op. */
	return -1;

	case LE:
	case LEU:
	PUT_CODE (cond, EQ);
	value = 2;
	break;

	case GT:
	case GTU:
	PUT_CODE (cond, NE);
	value = 2;
	break;

	default:
	break;
	}

	if (cc_status.flags & CC_NO_OVERFLOW)
	switch (GET_CODE (cond))
	{
	case GEU:
	/* Jump becomes unconditional. */
	return 1;

	case LEU:
	PUT_CODE (cond, EQ);
	value = 2;
	break;

	case GTU:
	PUT_CODE (cond, NE);
	value = 2;
	break;

	case LTU:
	/* Jump becomes no-op. */
	return -1;

	default:
	break;
	}

	if (cc_status.flags & (CC_Z_IN_NOT_N \| CC_Z_IN_N))
	switch (GET_CODE (cond))
	{
	default:
	gcc_unreachable ();

	case NE:
	PUT_CODE (cond, cc_status.flags & CC_Z_IN_N ? GE : LT);
	value = 2;
	break;

	case EQ:
	PUT_CODE (cond, cc_status.flags & CC_Z_IN_N ? LT : GE);
	value = 2;
	break;
	}

	if (cc_status.flags & CC_NOT_SIGNED)
	/* The flags are valid if signed condition operators are converted
	to unsigned. */
	switch (GET_CODE (cond))
	{
	case LE:
	PUT_CODE (cond, LEU);
	value = 2;
	break;

	case LT:
	PUT_CODE (cond, LTU);
	value = 2;
	break;

	case GT:
	PUT_CODE (cond, GTU);
	value = 2;
	break;

	case GE:
	PUT_CODE (cond, GEU);
	value = 2;
	break;

	default:
	break;
	}

	return value;
	}
	#endif

	/* Report inconsistency between the assembler template and the operands.
	In an `asm', it's the user's fault; otherwise, the compiler's fault. */

	void
	output_operand_lossage (const char *cmsgid, ...)
	{
	char *fmt_string;
	char *new_message;
	const char *pfx_str;
	va_list ap;

	va_start (ap, cmsgid);

	pfx_str = this_is_asm_operands ? _("invalid 'asm': ") : "output_operand: ";
	asprintf (&fmt_string, "%s%s", pfx_str, _(cmsgid));
	vasprintf (&new_message, fmt_string, ap);

	if (this_is_asm_operands)
	error_for_asm (this_is_asm_operands, "%s", new_message);
	else
	internal_error ("%s", new_message);

	free (fmt_string);
	free (new_message);
	va_end (ap);
	}

	/* Output of assembler code from a template, and its subroutines. */

	/* Annotate the assembly with a comment describing the pattern and
	alternative used. */

	static void
	output_asm_name (void)
	{
	if (debug_insn)
	{
	int num = INSN_CODE (debug_insn);
	fprintf (asm_out_file, "\t%s %d\t%s",
	ASM_COMMENT_START, INSN_UID (debug_insn),
	insn_data[num].name);
	if (insn_data[num].n_alternatives > 1)
	fprintf (asm_out_file, "/%d", which_alternative + 1);
	#ifdef HAVE_ATTR_length
	fprintf (asm_out_file, "\t[length = %d]",
	get_attr_length (debug_insn));
	#endif
	/* Clear this so only the first assembler insn
	of any rtl insn will get the special comment for -dp. */
	debug_insn = 0;
	}
	}

	/* If OP is a REG or MEM and we can find a MEM_EXPR corresponding to it
	or its address, return that expr . Set *PADDRESSP to 1 if the expr
	corresponds to the address of the object and 0 if to the object. */

	static tree
	get_mem_expr_from_op (rtx op, int *paddressp)
	{
	tree expr;
	int inner_addressp;

	*paddressp = 0;

	if (REG_P (op))
	return REG_EXPR (op);
	else if (!MEM_P (op))
	return 0;

	if (MEM_EXPR (op) != 0)
	return MEM_EXPR (op);

	/* Otherwise we have an address, so indicate it and look at the address. */
	*paddressp = 1;
	op = XEXP (op, 0);

	/* First check if we have a decl for the address, then look at the right side
	if it is a PLUS. Otherwise, strip off arithmetic and keep looking.
	But don't allow the address to itself be indirect. */
	if ((expr = get_mem_expr_from_op (op, &inner_addressp)) && ! inner_addressp)
	return expr;
	else if (GET_CODE (op) == PLUS
	&& (expr = get_mem_expr_from_op (XEXP (op, 1), &inner_addressp)))
	return expr;

	while (GET_RTX_CLASS (GET_CODE (op)) == RTX_UNARY
	\|\| GET_RTX_CLASS (GET_CODE (op)) == RTX_BIN_ARITH)
	op = XEXP (op, 0);

	expr = get_mem_expr_from_op (op, &inner_addressp);
	return inner_addressp ? 0 : expr;
	}

	/* Output operand names for assembler instructions. OPERANDS is the
	operand vector, OPORDER is the order to write the operands, and NOPS
	is the number of operands to write. */

	static void
	output_asm_operand_names (rtx operands, int oporder, int nops)
	{
	int wrote = 0;
	int i;

	for (i = 0; i < nops; i++)
	{
	int addressp;
	rtx op = operands[oporder[i]];
	tree expr = get_mem_expr_from_op (op, &addressp);

	fprintf (asm_out_file, "%c%s",
	wrote ? ',' : '\t', wrote ? "" : ASM_COMMENT_START);
	wrote = 1;
	if (expr)
	{
	fprintf (asm_out_file, "%s",
	addressp ? "*" : "");
	print_mem_expr (asm_out_file, expr);
	wrote = 1;
	}
	else if (REG_P (op) && ORIGINAL_REGNO (op)
	&& ORIGINAL_REGNO (op) != REGNO (op))
	fprintf (asm_out_file, " tmp%i", ORIGINAL_REGNO (op));
	}
	}

	/* Output text from TEMPLATE to the assembler output file,
	obeying %-directions to substitute operands taken from
	the vector OPERANDS.

	%N (for N a digit) means print operand N in usual manner.
	%lN means require operand N to be a CODE_LABEL or LABEL_REF
	and print the label name with no punctuation.
	%cN means require operand N to be a constant
	and print the constant expression with no punctuation.
	%aN means expect operand N to be a memory address
	(not a memory reference!) and print a reference
	to that address.
	%nN means expect operand N to be a constant
	and print a constant expression for minus the value
	of the operand, with no other punctuation. */

	void
	output_asm_insn (const char template, rtx operands)
	{
	const char *p;
	int c;
	#ifdef ASSEMBLER_DIALECT
	int dialect = 0;
	#endif
	int oporder[MAX_RECOG_OPERANDS];
	char opoutput[MAX_RECOG_OPERANDS];
	int ops = 0;

	/* An insn may return a null string template
	in a case where no assembler code is needed. */
	if (*template == 0)
	return;

	memset (opoutput, 0, sizeof opoutput);
	p = template;
	putc ('\t', asm_out_file);

	#ifdef ASM_OUTPUT_OPCODE
	ASM_OUTPUT_OPCODE (asm_out_file, p);
	#endif

	while ((c = *p++))
	switch (c)
	{
	case '\n':
	if (flag_verbose_asm)
	output_asm_operand_names (operands, oporder, ops);
	if (flag_print_asm_name)
	output_asm_name ();

	ops = 0;
	memset (opoutput, 0, sizeof opoutput);

	putc (c, asm_out_file);
	#ifdef ASM_OUTPUT_OPCODE
	while ((c = *p) == '\t')
	{
	putc (c, asm_out_file);
	p++;
	}
	ASM_OUTPUT_OPCODE (asm_out_file, p);
	#endif
	break;

	#ifdef ASSEMBLER_DIALECT
	case '{':
	{
	int i;

	if (dialect)
	output_operand_lossage ("nested assembly dialect alternatives");
	else
	dialect = 1;

	/* If we want the first dialect, do nothing. Otherwise, skip
	DIALECT_NUMBER of strings ending with '\|'. */
	for (i = 0; i < dialect_number; i++)
	{
	while (p && p != '}' && *p++ != '\|')
	;
	if (*p == '}')
	break;
	if (*p == '\|')
	p++;
	}

	if (*p == '\0')
	output_operand_lossage ("unterminated assembly dialect alternative");
	}
	break;

	case '\|':
	if (dialect)
	{
	/* Skip to close brace. */
	do
	{
	if (*p == '\0')
	{
	output_operand_lossage ("unterminated assembly dialect alternative");
	break;
	}
	}
	while (*p++ != '}');
	dialect = 0;
	}
	else
	putc (c, asm_out_file);
	break;

	case '}':
	if (! dialect)
	putc (c, asm_out_file);
	dialect = 0;
	break;
	#endif

	case '%':
	/* %% outputs a single %. */
	if (*p == '%')
	{
	p++;
	putc (c, asm_out_file);
	}
	/* %= outputs a number which is unique to each insn in the entire
	compilation. This is useful for making local labels that are
	referred to more than once in a given insn. */
	else if (*p == '=')
	{
	p++;
	fprintf (asm_out_file, "%d", insn_counter);
	}
	/* % followed by a letter and some digits
	outputs an operand in a special way depending on the letter.
	Letters `acln' are implemented directly.
	Other letters are passed to `output_operand' so that
	the PRINT_OPERAND macro can define them. */
	else if (ISALPHA (*p))
	{
	int letter = *p++;
	unsigned long opnum;
	char *endptr;

	opnum = strtoul (p, &endptr, 10);

	if (endptr == p)
	output_operand_lossage ("operand number missing "
	"after %%-letter");
	else if (this_is_asm_operands && opnum >= insn_noperands)
	output_operand_lossage ("operand number out of range");
	else if (letter == 'l')
	output_asm_label (operands[opnum]);
	else if (letter == 'a')
	output_address (operands[opnum]);
	else if (letter == 'c')
	{
	if (CONSTANT_ADDRESS_P (operands[opnum]))
	output_addr_const (asm_out_file, operands[opnum]);
	else
	output_operand (operands[opnum], 'c');
	}
	else if (letter == 'n')
	{
	if (GET_CODE (operands[opnum]) == CONST_INT)
	fprintf (asm_out_file, HOST_WIDE_INT_PRINT_DEC,
	- INTVAL (operands[opnum]));
	else
	{
	putc ('-', asm_out_file);
	output_addr_const (asm_out_file, operands[opnum]);
	}
	}
	else
	output_operand (operands[opnum], letter);

	if (!opoutput[opnum])
	oporder[ops++] = opnum;
	opoutput[opnum] = 1;

	p = endptr;
	c = *p;
	}
	/* % followed by a digit outputs an operand the default way. */
	else if (ISDIGIT (*p))
	{
	unsigned long opnum;
	char *endptr;

	opnum = strtoul (p, &endptr, 10);
	if (this_is_asm_operands && opnum >= insn_noperands)
	output_operand_lossage ("operand number out of range");
	else
	output_operand (operands[opnum], 0);

	if (!opoutput[opnum])
	oporder[ops++] = opnum;
	opoutput[opnum] = 1;

	p = endptr;
	c = *p;
	}
	/* % followed by punctuation: output something for that
	punctuation character alone, with no operand.
	The PRINT_OPERAND macro decides what is actually done. */
	#ifdef PRINT_OPERAND_PUNCT_VALID_P
	else if (PRINT_OPERAND_PUNCT_VALID_P ((unsigned char) *p))
	output_operand (NULL_RTX, *p++);
	#endif
	else
	output_operand_lossage ("invalid %%-code");
	break;

	default:
	putc (c, asm_out_file);
	}

	/* Write out the variable names for operands, if we know them. */
	if (flag_verbose_asm)
	output_asm_operand_names (operands, oporder, ops);
	if (flag_print_asm_name)
	output_asm_name ();

	putc ('\n', asm_out_file);
	}

	/* Output a LABEL_REF, or a bare CODE_LABEL, as an assembler symbol. */

	void
	output_asm_label (rtx x)
	{
	char buf[256];

	if (GET_CODE (x) == LABEL_REF)
	x = XEXP (x, 0);
	if (LABEL_P (x)
	\|\| (NOTE_P (x)
	&& NOTE_LINE_NUMBER (x) == NOTE_INSN_DELETED_LABEL))
	ASM_GENERATE_INTERNAL_LABEL (buf, "L", CODE_LABEL_NUMBER (x));
	else
	output_operand_lossage ("'%%l' operand isn't a label");

	assemble_name (asm_out_file, buf);
	}

	/* Print operand X using machine-dependent assembler syntax.
	The macro PRINT_OPERAND is defined just to control this function.
	CODE is a non-digit that preceded the operand-number in the % spec,
	such as 'z' if the spec was `%z3'. CODE is 0 if there was no char
	between the % and the digits.
	When CODE is a non-letter, X is 0.

	The meanings of the letters are machine-dependent and controlled
	by PRINT_OPERAND. */

	static void
	output_operand (rtx x, int code ATTRIBUTE_UNUSED)
	{
	if (x && GET_CODE (x) == SUBREG)
	x = alter_subreg (&x);

	/* X must not be a pseudo reg. */
	gcc_assert (!x \|\| !REG_P (x) \|\| REGNO (x) < FIRST_PSEUDO_REGISTER);

	PRINT_OPERAND (asm_out_file, x, code);
	}

	/* Print a memory reference operand for address X
	using machine-dependent assembler syntax.
	The macro PRINT_OPERAND_ADDRESS exists just to control this function. */

	void
	output_address (rtx x)
	{
	walk_alter_subreg (&x);
	PRINT_OPERAND_ADDRESS (asm_out_file, x);
	}

	/* Print an integer constant expression in assembler syntax.
	Addition and subtraction are the only arithmetic
	that may appear in these expressions. */

	void
	output_addr_const (FILE *file, rtx x)
	{
	char buf[256];

	restart:
	switch (GET_CODE (x))
	{
	case PC:
	putc ('.', file);
	break;

	case SYMBOL_REF:
	if (SYMBOL_REF_DECL (x))
	mark_decl_referenced (SYMBOL_REF_DECL (x));
	#ifdef ASM_OUTPUT_SYMBOL_REF
	ASM_OUTPUT_SYMBOL_REF (file, x);
	#else
	assemble_name (file, XSTR (x, 0));
	#endif
	break;

	case LABEL_REF:
	x = XEXP (x, 0);
	/* Fall through. */
	case CODE_LABEL:
	ASM_GENERATE_INTERNAL_LABEL (buf, "L", CODE_LABEL_NUMBER (x));
	#ifdef ASM_OUTPUT_LABEL_REF
	ASM_OUTPUT_LABEL_REF (file, buf);
	#else
	assemble_name (file, buf);
	#endif
	break;

	case CONST_INT:
	fprintf (file, HOST_WIDE_INT_PRINT_DEC, INTVAL (x));
	break;

	case CONST:
	/* This used to output parentheses around the expression,
	but that does not work on the 386 (either ATT or BSD assembler). */
	output_addr_const (file, XEXP (x, 0));
	break;

	case CONST_DOUBLE:
	if (GET_MODE (x) == VOIDmode)
	{
	/* We can use %d if the number is one word and positive. */
	if (CONST_DOUBLE_HIGH (x))
	fprintf (file, HOST_WIDE_INT_PRINT_DOUBLE_HEX,
	CONST_DOUBLE_HIGH (x), CONST_DOUBLE_LOW (x));
	else if (CONST_DOUBLE_LOW (x) < 0)
	fprintf (file, HOST_WIDE_INT_PRINT_HEX, CONST_DOUBLE_LOW (x));
	else
	fprintf (file, HOST_WIDE_INT_PRINT_DEC, CONST_DOUBLE_LOW (x));
	}
	else
	/* We can't handle floating point constants;
	PRINT_OPERAND must handle them. */
	output_operand_lossage ("floating constant misused");
	break;

	case PLUS:
	/* Some assemblers need integer constants to appear last (eg masm). */
	if (GET_CODE (XEXP (x, 0)) == CONST_INT)
	{
	output_addr_const (file, XEXP (x, 1));
	if (INTVAL (XEXP (x, 0)) >= 0)
	fprintf (file, "+");
	output_addr_const (file, XEXP (x, 0));
	}
	else
	{
	output_addr_const (file, XEXP (x, 0));
	if (GET_CODE (XEXP (x, 1)) != CONST_INT
	\|\| INTVAL (XEXP (x, 1)) >= 0)
	fprintf (file, "+");
	output_addr_const (file, XEXP (x, 1));
	}
	break;

	case MINUS:
	/* Avoid outputting things like x-x or x+5-x,
	since some assemblers can't handle that. */
	x = simplify_subtraction (x);
	if (GET_CODE (x) != MINUS)
	goto restart;

	output_addr_const (file, XEXP (x, 0));
	fprintf (file, "-");
	if ((GET_CODE (XEXP (x, 1)) == CONST_INT && INTVAL (XEXP (x, 1)) >= 0)
	\|\| GET_CODE (XEXP (x, 1)) == PC
	\|\| GET_CODE (XEXP (x, 1)) == SYMBOL_REF)
	output_addr_const (file, XEXP (x, 1));
	else
	{
	fputs (targetm.asm_out.open_paren, file);
	output_addr_const (file, XEXP (x, 1));
	fputs (targetm.asm_out.close_paren, file);
	}
	break;

	case ZERO_EXTEND:
	case SIGN_EXTEND:
	case SUBREG:
	output_addr_const (file, XEXP (x, 0));
	break;

	default:
	#ifdef OUTPUT_ADDR_CONST_EXTRA
	OUTPUT_ADDR_CONST_EXTRA (file, x, fail);
	break;

	fail:
	#endif
	output_operand_lossage ("invalid expression as operand");
	}
	}

	/* A poor man's fprintf, with the added features of %I, %R, %L, and %U.
	%R prints the value of REGISTER_PREFIX.
	%L prints the value of LOCAL_LABEL_PREFIX.
	%U prints the value of USER_LABEL_PREFIX.
	%I prints the value of IMMEDIATE_PREFIX.
	%O runs ASM_OUTPUT_OPCODE to transform what follows in the string.
	Also supported are %d, %i, %u, %x, %X, %o, %c, %s and %%.

	We handle alternate assembler dialects here, just like output_asm_insn. */

	void
	asm_fprintf (FILE file, const char p, ...)
	{
	char buf[10];
	char *q, c;
	va_list argptr;

	va_start (argptr, p);

	buf[0] = '%';

	while ((c = *p++))
	switch (c)
	{
	#ifdef ASSEMBLER_DIALECT
	case '{':
	{
	int i;

	/* If we want the first dialect, do nothing. Otherwise, skip
	DIALECT_NUMBER of strings ending with '\|'. */
	for (i = 0; i < dialect_number; i++)
	{
	while (p && p++ != '\|')
	;

	if (*p == '\|')
	p++;
	}
	}
	break;

	case '\|':
	/* Skip to close brace. */
	while (p && p++ != '}')
	;
	break;

	case '}':
	break;
	#endif

	case '%':
	c = *p++;
	q = &buf[1];
	while (strchr ("-+ #0", c))
	{
	*q++ = c;
	c = *p++;
	}
	while (ISDIGIT (c) \|\| c == '.')
	{
	*q++ = c;
	c = *p++;
	}
	switch (c)
	{
	case '%':
	putc ('%', file);
	break;

	case 'd': case 'i': case 'u':
	case 'x': case 'X': case 'o':
	case 'c':
	*q++ = c;
	*q = 0;
	fprintf (file, buf, va_arg (argptr, int));
	break;

	case 'w':
	/* This is a prefix to the 'd', 'i', 'u', 'x', 'X', and
	'o' cases, but we do not check for those cases. It
	means that the value is a HOST_WIDE_INT, which may be
	either `long' or `long long'. */
	memcpy (q, HOST_WIDE_INT_PRINT, strlen (HOST_WIDE_INT_PRINT));
	q += strlen (HOST_WIDE_INT_PRINT);
	q++ = p++;
	*q = 0;
	fprintf (file, buf, va_arg (argptr, HOST_WIDE_INT));
	break;

	case 'l':
	*q++ = c;
	#ifdef HAVE_LONG_LONG
	if (*p == 'l')
	{
	q++ = p++;
	q++ = p++;
	*q = 0;
	fprintf (file, buf, va_arg (argptr, long long));
	}
	else
	#endif
	{
	q++ = p++;
	*q = 0;
	fprintf (file, buf, va_arg (argptr, long));
	}

	break;

	case 's':
	*q++ = c;
	*q = 0;
	fprintf (file, buf, va_arg (argptr, char *));
	break;

	case 'O':
	#ifdef ASM_OUTPUT_OPCODE
	ASM_OUTPUT_OPCODE (asm_out_file, p);
	#endif
	break;

	case 'R':
	#ifdef REGISTER_PREFIX
	fprintf (file, "%s", REGISTER_PREFIX);
	#endif
	break;

	case 'I':
	#ifdef IMMEDIATE_PREFIX
	fprintf (file, "%s", IMMEDIATE_PREFIX);
	#endif
	break;

	case 'L':
	#ifdef LOCAL_LABEL_PREFIX
	fprintf (file, "%s", LOCAL_LABEL_PREFIX);
	#endif
	break;

	case 'U':
	fputs (user_label_prefix, file);
	break;

	#ifdef ASM_FPRINTF_EXTENSIONS
	/* Uppercase letters are reserved for general use by asm_fprintf
	and so are not available to target specific code. In order to
	prevent the ASM_FPRINTF_EXTENSIONS macro from using them then,
	they are defined here. As they get turned into real extensions
	to asm_fprintf they should be removed from this list. */
	case 'A': case 'B': case 'C': case 'D': case 'E':
	case 'F': case 'G': case 'H': case 'J': case 'K':
	case 'M': case 'N': case 'P': case 'Q': case 'S':
	case 'T': case 'V': case 'W': case 'Y': case 'Z':
	break;

	ASM_FPRINTF_EXTENSIONS (file, argptr, p)
	#endif
	default:
	gcc_unreachable ();
	}
	break;

	default:
	putc (c, file);
	}
	va_end (argptr);
	}

	/* Split up a CONST_DOUBLE or integer constant rtx
	into two rtx's for single words,
	storing in *FIRST the word that comes first in memory in the target
	and in SECOND the other. /

	void
	split_double (rtx value, rtx first, rtx second)
	{
	if (GET_CODE (value) == CONST_INT)
	{
	if (HOST_BITS_PER_WIDE_INT >= (2 * BITS_PER_WORD))
	{
	/* In this case the CONST_INT holds both target words.
	Extract the bits from it into two word-sized pieces.
	Sign extend each half to HOST_WIDE_INT. */
	unsigned HOST_WIDE_INT low, high;
	unsigned HOST_WIDE_INT mask, sign_bit, sign_extend;

	/* Set sign_bit to the most significant bit of a word. */
	sign_bit = 1;
	sign_bit <<= BITS_PER_WORD - 1;

	/* Set mask so that all bits of the word are set. We could
	have used 1 << BITS_PER_WORD instead of basing the
	calculation on sign_bit. However, on machines where
	HOST_BITS_PER_WIDE_INT == BITS_PER_WORD, it could cause a
	compiler warning, even though the code would never be
	executed. */
	mask = sign_bit << 1;
	mask--;

	/* Set sign_extend as any remaining bits. */
	sign_extend = ~mask;

	/* Pick the lower word and sign-extend it. */
	low = INTVAL (value);
	low &= mask;
	if (low & sign_bit)
	low \|= sign_extend;

	/* Pick the higher word, shifted to the least significant
	bits, and sign-extend it. */
	high = INTVAL (value);
	high >>= BITS_PER_WORD - 1;
	high >>= 1;
	high &= mask;
	if (high & sign_bit)
	high \|= sign_extend;

	/* Store the words in the target machine order. */
	if (WORDS_BIG_ENDIAN)
	{
	*first = GEN_INT (high);
	*second = GEN_INT (low);
	}
	else
	{
	*first = GEN_INT (low);
	*second = GEN_INT (high);
	}
	}
	else
	{
	/* The rule for using CONST_INT for a wider mode
	is that we regard the value as signed.
	So sign-extend it. */
	rtx high = (INTVAL (value) < 0 ? constm1_rtx : const0_rtx);
	if (WORDS_BIG_ENDIAN)
	{
	*first = high;
	*second = value;
	}
	else
	{
	*first = value;
	*second = high;
	}
	}
	}
	else if (GET_CODE (value) != CONST_DOUBLE)
	{
	if (WORDS_BIG_ENDIAN)
	{
	*first = const0_rtx;
	*second = value;
	}
	else
	{
	*first = value;
	*second = const0_rtx;
	}
	}
	else if (GET_MODE (value) == VOIDmode
	/* This is the old way we did CONST_DOUBLE integers. */
	\|\| GET_MODE_CLASS (GET_MODE (value)) == MODE_INT)
	{
	/* In an integer, the words are defined as most and least significant.
	So order them by the target's convention. */
	if (WORDS_BIG_ENDIAN)
	{
	*first = GEN_INT (CONST_DOUBLE_HIGH (value));
	*second = GEN_INT (CONST_DOUBLE_LOW (value));
	}
	else
	{
	*first = GEN_INT (CONST_DOUBLE_LOW (value));
	*second = GEN_INT (CONST_DOUBLE_HIGH (value));
	}
	}
	else
	{
	REAL_VALUE_TYPE r;
	long l[2];
	REAL_VALUE_FROM_CONST_DOUBLE (r, value);

	/* Note, this converts the REAL_VALUE_TYPE to the target's
	format, splits up the floating point double and outputs
	exactly 32 bits of it into each of l[0] and l[1] --
	not necessarily BITS_PER_WORD bits. */
	REAL_VALUE_TO_TARGET_DOUBLE (r, l);

	/* If 32 bits is an entire word for the target, but not for the host,
	then sign-extend on the host so that the number will look the same
	way on the host that it would on the target. See for instance
	simplify_unary_operation. The #if is needed to avoid compiler
	warnings. */

	#if HOST_BITS_PER_LONG > 32
	if (BITS_PER_WORD < HOST_BITS_PER_LONG && BITS_PER_WORD == 32)
	{
	if (l[0] & ((long) 1 << 31))
	l[0] \|= ((long) (-1) << 32);
	if (l[1] & ((long) 1 << 31))
	l[1] \|= ((long) (-1) << 32);
	}
	#endif

	*first = GEN_INT (l[0]);
	*second = GEN_INT (l[1]);
	}
	}

	/* Return nonzero if this function has no function calls. */

	int
	leaf_function_p (void)
	{
	rtx insn;
	rtx link;

	if (current_function_profile \|\| profile_arc_flag)
	return 0;

	for (insn = get_insns (); insn; insn = NEXT_INSN (insn))
	{
	if (CALL_P (insn)
	&& ! SIBLING_CALL_P (insn))
	return 0;
	if (NONJUMP_INSN_P (insn)
	&& GET_CODE (PATTERN (insn)) == SEQUENCE
	&& CALL_P (XVECEXP (PATTERN (insn), 0, 0))
	&& ! SIBLING_CALL_P (XVECEXP (PATTERN (insn), 0, 0)))
	return 0;
	}
	for (link = current_function_epilogue_delay_list;
	link;
	link = XEXP (link, 1))
	{
	insn = XEXP (link, 0);

	if (CALL_P (insn)
	&& ! SIBLING_CALL_P (insn))
	return 0;
	if (NONJUMP_INSN_P (insn)
	&& GET_CODE (PATTERN (insn)) == SEQUENCE
	&& CALL_P (XVECEXP (PATTERN (insn), 0, 0))
	&& ! SIBLING_CALL_P (XVECEXP (PATTERN (insn), 0, 0)))
	return 0;
	}

	return 1;
	}

	/* Return 1 if branch is a forward branch.
	Uses insn_shuid array, so it works only in the final pass. May be used by
	output templates to customary add branch prediction hints.
	*/
	int
	final_forward_branch_p (rtx insn)
	{
	int insn_id, label_id;

	gcc_assert (uid_shuid);
	insn_id = INSN_SHUID (insn);
	label_id = INSN_SHUID (JUMP_LABEL (insn));
	/* We've hit some insns that does not have id information available. */
	gcc_assert (insn_id && label_id);
	return insn_id < label_id;
	}

	/* On some machines, a function with no call insns
	can run faster if it doesn't create its own register window.
	When output, the leaf function should use only the "output"
	registers. Ordinarily, the function would be compiled to use
	the "input" registers to find its arguments; it is a candidate
	for leaf treatment if it uses only the "input" registers.
	Leaf function treatment means renumbering so the function
	uses the "output" registers instead. */

	#ifdef LEAF_REGISTERS

	/* Return 1 if this function uses only the registers that can be
	safely renumbered. */

	int
	only_leaf_regs_used (void)
	{
	int i;
	const char *const permitted_reg_in_leaf_functions = LEAF_REGISTERS;

	for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
	if ((regs_ever_live[i] \|\| global_regs[i])
	&& ! permitted_reg_in_leaf_functions[i])
	return 0;

	if (current_function_uses_pic_offset_table
	&& pic_offset_table_rtx != 0
	&& REG_P (pic_offset_table_rtx)
	&& ! permitted_reg_in_leaf_functions[REGNO (pic_offset_table_rtx)])
	return 0;

	return 1;
	}

	/* Scan all instructions and renumber all registers into those
	available in leaf functions. */

	static void
	leaf_renumber_regs (rtx first)
	{
	rtx insn;

	/* Renumber only the actual patterns.
	The reg-notes can contain frame pointer refs,
	and renumbering them could crash, and should not be needed. */
	for (insn = first; insn; insn = NEXT_INSN (insn))
	if (INSN_P (insn))
	leaf_renumber_regs_insn (PATTERN (insn));
	for (insn = current_function_epilogue_delay_list;
	insn;
	insn = XEXP (insn, 1))
	if (INSN_P (XEXP (insn, 0)))
	leaf_renumber_regs_insn (PATTERN (XEXP (insn, 0)));
	}

	/* Scan IN_RTX and its subexpressions, and renumber all regs into those
	available in leaf functions. */

	void
	leaf_renumber_regs_insn (rtx in_rtx)
	{
	int i, j;
	const char *format_ptr;

	if (in_rtx == 0)
	return;

	/* Renumber all input-registers into output-registers.
	renumbered_regs would be 1 for an output-register;
	they */

	if (REG_P (in_rtx))
	{
	int newreg;

	/* Don't renumber the same reg twice. */
	if (in_rtx->used)
	return;

	newreg = REGNO (in_rtx);
	/* Don't try to renumber pseudo regs. It is possible for a pseudo reg
	to reach here as part of a REG_NOTE. */
	if (newreg >= FIRST_PSEUDO_REGISTER)
	{
	in_rtx->used = 1;
	return;
	}
	newreg = LEAF_REG_REMAP (newreg);
	gcc_assert (newreg >= 0);
	regs_ever_live[REGNO (in_rtx)] = 0;
	regs_ever_live[newreg] = 1;
	REGNO (in_rtx) = newreg;
	in_rtx->used = 1;
	}

	if (INSN_P (in_rtx))
	{
	/* Inside a SEQUENCE, we find insns.
	Renumber just the patterns of these insns,
	just as we do for the top-level insns. */
	leaf_renumber_regs_insn (PATTERN (in_rtx));
	return;
	}

	format_ptr = GET_RTX_FORMAT (GET_CODE (in_rtx));

	for (i = 0; i < GET_RTX_LENGTH (GET_CODE (in_rtx)); i++)
	switch (*format_ptr++)
	{
	case 'e':
	leaf_renumber_regs_insn (XEXP (in_rtx, i));
	break;

	case 'E':
	if (NULL != XVEC (in_rtx, i))
	{
	for (j = 0; j < XVECLEN (in_rtx, i); j++)
	leaf_renumber_regs_insn (XVECEXP (in_rtx, i, j));
	}
	break;

	case 'S':
	case 's':
	case '0':
	case 'i':
	case 'w':
	case 'n':
	case 'u':
	break;

	default:
	gcc_unreachable ();
	}
	}
	#endif


	/* When -gused is used, emit debug info for only used symbols. But in
	addition to the standard intercepted debug_hooks there are some direct
	calls into this file, i.e., dbxout_symbol, dbxout_parms, and dbxout_reg_params.
	Those routines may also be called from a higher level intercepted routine. So
	to prevent recording data for an inner call to one of these for an intercept,
	we maintain an intercept nesting counter (debug_nesting). We only save the
	intercepted arguments if the nesting is 1. */
	int debug_nesting = 0;

	static tree *symbol_queue;
	int symbol_queue_index = 0;
	static int symbol_queue_size = 0;

	/* Generate the symbols for any queued up type symbols we encountered
	while generating the type info for some originally used symbol.
	This might generate additional entries in the queue. Only when
	the nesting depth goes to 0 is this routine called. */

	void
	debug_flush_symbol_queue (void)
	{
	int i;

	/* Make sure that additionally queued items are not flushed
	prematurely. */

	++debug_nesting;

	for (i = 0; i < symbol_queue_index; ++i)
	{
	/* If we pushed queued symbols then such symbols must be
	output no matter what anyone else says. Specifically,
	we need to make sure dbxout_symbol() thinks the symbol was
	used and also we need to override TYPE_DECL_SUPPRESS_DEBUG
	which may be set for outside reasons. */
	int saved_tree_used = TREE_USED (symbol_queue[i]);
	int saved_suppress_debug = TYPE_DECL_SUPPRESS_DEBUG (symbol_queue[i]);
	TREE_USED (symbol_queue[i]) = 1;
	TYPE_DECL_SUPPRESS_DEBUG (symbol_queue[i]) = 0;

	#ifdef DBX_DEBUGGING_INFO
	dbxout_symbol (symbol_queue[i], 0);
	#endif

	TREE_USED (symbol_queue[i]) = saved_tree_used;
	TYPE_DECL_SUPPRESS_DEBUG (symbol_queue[i]) = saved_suppress_debug;
	}

	symbol_queue_index = 0;
	--debug_nesting;
	}

	/* Queue a type symbol needed as part of the definition of a decl
	symbol. These symbols are generated when debug_flush_symbol_queue()
	is called. */

	void
	debug_queue_symbol (tree decl)
	{
	if (symbol_queue_index >= symbol_queue_size)
	{
	symbol_queue_size += 10;
	symbol_queue = xrealloc (symbol_queue,
	symbol_queue_size * sizeof (tree));
	}

	symbol_queue[symbol_queue_index++] = decl;
	}

	/* Free symbol queue. */
	void
	debug_free_queue (void)
	{
	if (symbol_queue)
	{
	free (symbol_queue);
	symbol_queue = NULL;
	symbol_queue_size = 0;
	}
	}

	/* Turn the RTL into assembly. */
	static unsigned int
	rest_of_handle_final (void)
	{
	rtx x;
	const char *fnname;

	/* Get the function's name, as described by its RTL. This may be
	different from the DECL_NAME name used in the source file. */

	x = DECL_RTL (current_function_decl);
	gcc_assert (MEM_P (x));
	x = XEXP (x, 0);
	gcc_assert (GET_CODE (x) == SYMBOL_REF);
	fnname = XSTR (x, 0);

	assemble_start_function (current_function_decl, fnname);
	final_start_function (get_insns (), asm_out_file, optimize);
	final (get_insns (), asm_out_file, optimize);
	final_end_function ();

	#ifdef TARGET_UNWIND_INFO
	/* ??? The IA-64 ".handlerdata" directive must be issued before
	the ".endp" directive that closes the procedure descriptor. */
	output_function_exception_table ();
	#endif

	assemble_end_function (current_function_decl, fnname);

	#ifndef TARGET_UNWIND_INFO
	/* Otherwise, it feels unclean to switch sections in the middle. */
	output_function_exception_table ();
	#endif

	user_defined_section_attribute = false;

	if (! quiet_flag)
	fflush (asm_out_file);

	/* Release all memory allocated by flow. */
	free_basic_block_vars ();

	/* Write DBX symbols if requested. */

	/* Note that for those inline functions where we don't initially
	know for certain that we will be generating an out-of-line copy,
	the first invocation of this routine (rest_of_compilation) will
	skip over this code by doing a `goto exit_rest_of_compilation;'.
	Later on, wrapup_global_declarations will (indirectly) call
	rest_of_compilation again for those inline functions that need
	to have out-of-line copies generated. During that call, we
	will be routed past here. */

	timevar_push (TV_SYMOUT);
	(*debug_hooks->function_decl) (current_function_decl);
	timevar_pop (TV_SYMOUT);
	return 0;
	}

	struct tree_opt_pass pass_final =
	{
	NULL, /* name */
	NULL, /* gate */
	rest_of_handle_final, /* execute */
	NULL, /* sub */
	NULL, /* next */
	0, /* static_pass_number */
	TV_FINAL, /* tv_id */
	0, /* properties_required */
	0, /* properties_provided */
	0, /* properties_destroyed */
	0, /* todo_flags_start */
	TODO_ggc_collect, /* todo_flags_finish */
	0 /* letter */
	};


	static unsigned int
	rest_of_handle_shorten_branches (void)
	{
	/* Shorten branches. */
	shorten_branches (get_insns ());
	return 0;
	}

	struct tree_opt_pass pass_shorten_branches =
	{
	"shorten", /* name */
	NULL, /* gate */
	rest_of_handle_shorten_branches, /* execute */
	NULL, /* sub */
	NULL, /* next */
	0, /* static_pass_number */
	TV_FINAL, /* tv_id */
	0, /* properties_required */
	0, /* properties_provided */
	0, /* properties_destroyed */
	0, /* todo_flags_start */
	TODO_dump_func, /* todo_flags_finish */
	0 /* letter */
	};


	static unsigned int
	rest_of_clean_state (void)
	{
	rtx insn, next;

	/* It is very important to decompose the RTL instruction chain here:
	debug information keeps pointing into CODE_LABEL insns inside the function
	body. If these remain pointing to the other insns, we end up preserving
	whole RTL chain and attached detailed debug info in memory. */
	for (insn = get_insns (); insn; insn = next)
	{
	next = NEXT_INSN (insn);
	NEXT_INSN (insn) = NULL;
	PREV_INSN (insn) = NULL;
	}

	/* In case the function was not output,
	don't leave any temporary anonymous types
	queued up for sdb output. */
	#ifdef SDB_DEBUGGING_INFO
	if (write_symbols == SDB_DEBUG)
	sdbout_types (NULL_TREE);
	#endif

	reload_completed = 0;
	epilogue_completed = 0;
	flow2_completed = 0;
	no_new_pseudos = 0;
	#ifdef STACK_REGS
	regstack_completed = 0;
	#endif

	/* Clear out the insn_length contents now that they are no
	longer valid. */
	init_insn_lengths ();

	/* Show no temporary slots allocated. */
	init_temp_slots ();

	free_basic_block_vars ();
	free_bb_for_insn ();


	if (targetm.binds_local_p (current_function_decl))
	{
	int pref = cfun->preferred_stack_boundary;
	if (cfun->stack_alignment_needed > cfun->preferred_stack_boundary)
	pref = cfun->stack_alignment_needed;
	cgraph_rtl_info (current_function_decl)->preferred_incoming_stack_boundary
	= pref;
	}

	/* Make sure volatile mem refs aren't considered valid operands for
	arithmetic insns. We must call this here if this is a nested inline
	function, since the above code leaves us in the init_recog state,
	and the function context push/pop code does not save/restore volatile_ok.

	??? Maybe it isn't necessary for expand_start_function to call this
	anymore if we do it here? */

	init_recog_no_volatile ();

	/* We're done with this function. Free up memory if we can. */
	free_after_parsing (cfun);
	free_after_compilation (cfun);
	return 0;
	}

	struct tree_opt_pass pass_clean_state =
	{
	NULL, /* name */
	NULL, /* gate */
	rest_of_clean_state, /* execute */
	NULL, /* sub */
	NULL, /* next */
	0, /* static_pass_number */
	TV_FINAL, /* tv_id */
	0, /* properties_required */
	0, /* properties_provided */
	PROP_rtl, /* properties_destroyed */
	0, /* todo_flags_start */
	0, /* todo_flags_finish */
	0 /* letter */
	};
	diff --git a/contrib/gcc/print-rtl.c b/contrib/gcc/print-rtl.c
	index a9c1a932bded..12f742527892 100644
	--- a/contrib/gcc/print-rtl.c
	+++ b/contrib/gcc/print-rtl.c
	@@ -1,799 +1,804 @@
	/* Print RTL for GCC.
	Copyright (C) 1987, 1988, 1992, 1997, 1998, 1999, 2000, 2002, 2003,
	2004, 2005
	Free Software Foundation, Inc.

	This file is part of GCC.

	GCC is free software; you can redistribute it and/or modify it under
	the terms of the GNU General Public License as published by the Free
	Software Foundation; either version 2, or (at your option) any later
	version.

	GCC is distributed in the hope that it will be useful, but WITHOUT ANY
	WARRANTY; without even the implied warranty of MERCHANTABILITY or
	FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	for more details.

	You should have received a copy of the GNU General Public License
	along with GCC; see the file COPYING. If not, write to the Free
	Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
	02110-1301, USA. */

	/* This file is compiled twice: once for the generator programs,
	once for the compiler. */
	#ifdef GENERATOR_FILE
	#include "bconfig.h"
	#else
	#include "config.h"
	#endif

	#include "system.h"
	#include "coretypes.h"
	#include "tm.h"
	#include "rtl.h"

	/* These headers all define things which are not available in
	generator programs. */
	#ifndef GENERATOR_FILE
	#include "tree.h"
	#include "real.h"
	#include "flags.h"
	#include "hard-reg-set.h"
	#include "basic-block.h"
	#endif

	static FILE *outfile;

	static int sawclose = 0;

	static int indent;

	static void print_rtx (rtx);

	/* String printed at beginning of each RTL when it is dumped.
	This string is set to ASM_COMMENT_START when the RTL is dumped in
	the assembly output file. */
	const char *print_rtx_head = "";

	/* Nonzero means suppress output of instruction numbers and line number
	notes in debugging dumps.
	This must be defined here so that programs like gencodes can be linked. */
	int flag_dump_unnumbered = 0;

	/* Nonzero means use simplified format without flags, modes, etc. */
	int flag_simple = 0;

	/* Nonzero if we are dumping graphical description. */
	int dump_for_graph;

	#ifndef GENERATOR_FILE
	static void
	print_decl_name (FILE *outfile, tree node)
	{
	if (DECL_NAME (node))
	fputs (IDENTIFIER_POINTER (DECL_NAME (node)), outfile);
	else
	{
	if (TREE_CODE (node) == LABEL_DECL && LABEL_DECL_UID (node) != -1)
	fprintf (outfile, "L." HOST_WIDE_INT_PRINT_DEC, LABEL_DECL_UID (node));
	else
	{
	char c = TREE_CODE (node) == CONST_DECL ? 'C' : 'D';
	fprintf (outfile, "%c.%u", c, DECL_UID (node));
	}
	}
	}

	void
	print_mem_expr (FILE *outfile, tree expr)
	{
	if (TREE_CODE (expr) == COMPONENT_REF)
	{
	if (TREE_OPERAND (expr, 0))
	print_mem_expr (outfile, TREE_OPERAND (expr, 0));
	else
	fputs (" <variable>", outfile);
	fputc ('.', outfile);
	print_decl_name (outfile, TREE_OPERAND (expr, 1));
	}
	else if (TREE_CODE (expr) == INDIRECT_REF)
	{
	fputs (" (*", outfile);
	print_mem_expr (outfile, TREE_OPERAND (expr, 0));
	fputs (")", outfile);
	}
	else if (TREE_CODE (expr) == ALIGN_INDIRECT_REF)
	{
	fputs (" (A*", outfile);
	print_mem_expr (outfile, TREE_OPERAND (expr, 0));
	fputs (")", outfile);
	}
	else if (TREE_CODE (expr) == MISALIGNED_INDIRECT_REF)
	{
	fputs (" (M*", outfile);
	print_mem_expr (outfile, TREE_OPERAND (expr, 0));
	fputs (")", outfile);
	}
	else if (TREE_CODE (expr) == RESULT_DECL)
	fputs (" <result>", outfile);
	else
	{
	fputc (' ', outfile);
	print_decl_name (outfile, expr);
	}
	}
	#endif

	/* Print IN_RTX onto OUTFILE. This is the recursive part of printing. */

	static void
	print_rtx (rtx in_rtx)
	{
	int i = 0;
	int j;
	const char *format_ptr;
	int is_insn;

	if (sawclose)
	{
	if (flag_simple)
	fputc (' ', outfile);
	else
	fprintf (outfile, "\n%s%s", print_rtx_head, indent 2, "");
	sawclose = 0;
	}

	if (in_rtx == 0)
	{
	fputs ("(nil)", outfile);
	sawclose = 1;
	return;
	}
	else if (GET_CODE (in_rtx) > NUM_RTX_CODE)
	{
	fprintf (outfile, "(??? bad code %d\n)", GET_CODE (in_rtx));
	sawclose = 1;
	return;
	}

	is_insn = INSN_P (in_rtx);

	/* When printing in VCG format we write INSNs, NOTE, LABEL, and BARRIER
	in separate nodes and therefore have to handle them special here. */
	if (dump_for_graph
	&& (is_insn \|\| NOTE_P (in_rtx)
	\|\| LABEL_P (in_rtx) \|\| BARRIER_P (in_rtx)))
	{
	i = 3;
	indent = 0;
	}
	else
	{
	/* Print name of expression code. */
	if (flag_simple && GET_CODE (in_rtx) == CONST_INT)
	fputc ('(', outfile);
	else
	fprintf (outfile, "(%s", GET_RTX_NAME (GET_CODE (in_rtx)));

	if (! flag_simple)
	{
	if (RTX_FLAG (in_rtx, in_struct))
	fputs ("/s", outfile);

	if (RTX_FLAG (in_rtx, volatil))
	fputs ("/v", outfile);

	if (RTX_FLAG (in_rtx, unchanging))
	fputs ("/u", outfile);

	if (RTX_FLAG (in_rtx, frame_related))
	fputs ("/f", outfile);

	if (RTX_FLAG (in_rtx, jump))
	fputs ("/j", outfile);

	if (RTX_FLAG (in_rtx, call))
	fputs ("/c", outfile);

	if (RTX_FLAG (in_rtx, return_val))
	fputs ("/i", outfile);

	/* Print REG_NOTE names for EXPR_LIST and INSN_LIST. */
	if (GET_CODE (in_rtx) == EXPR_LIST
	\|\| GET_CODE (in_rtx) == INSN_LIST)
	fprintf (outfile, ":%s",
	GET_REG_NOTE_NAME (GET_MODE (in_rtx)));

	/* For other rtl, print the mode if it's not VOID. */
	else if (GET_MODE (in_rtx) != VOIDmode)
	fprintf (outfile, ":%s", GET_MODE_NAME (GET_MODE (in_rtx)));
	}
	}

	#ifndef GENERATOR_FILE
	if (GET_CODE (in_rtx) == CONST_DOUBLE && FLOAT_MODE_P (GET_MODE (in_rtx)))
	i = 5;
	#endif

	/* Get the format string and skip the first elements if we have handled
	them already. */
	format_ptr = GET_RTX_FORMAT (GET_CODE (in_rtx)) + i;
	for (; i < GET_RTX_LENGTH (GET_CODE (in_rtx)); i++)
	switch (*format_ptr++)
	{
	const char *str;

	case 'T':
	str = XTMPL (in_rtx, i);
	goto string;

	case 'S':
	case 's':
	str = XSTR (in_rtx, i);
	string:

	if (str == 0)
	fputs (dump_for_graph ? " \\\"\\\"" : " \"\"", outfile);
	else
	{
	if (dump_for_graph)
	fprintf (outfile, " (\\\"%s\\\")", str);
	else
	fprintf (outfile, " (\"%s\")", str);
	}
	sawclose = 1;
	break;

	/* 0 indicates a field for internal use that should not be printed.
	An exception is the third field of a NOTE, where it indicates
	that the field has several different valid contents. */
	case '0':
	if (i == 1 && REG_P (in_rtx))
	{
	if (REGNO (in_rtx) != ORIGINAL_REGNO (in_rtx))
	fprintf (outfile, " [%d]", ORIGINAL_REGNO (in_rtx));
	}
	#ifndef GENERATOR_FILE
	else if (i == 1 && GET_CODE (in_rtx) == SYMBOL_REF)
	{
	int flags = SYMBOL_REF_FLAGS (in_rtx);
	if (flags)
	fprintf (outfile, " [flags 0x%x]", flags);
	}
	else if (i == 2 && GET_CODE (in_rtx) == SYMBOL_REF)
	{
	tree decl = SYMBOL_REF_DECL (in_rtx);
	if (decl)
	print_node_brief (outfile, "", decl, 0);
	}
	#endif
	else if (i == 4 && NOTE_P (in_rtx))
	{
	switch (NOTE_LINE_NUMBER (in_rtx))
	{
	case NOTE_INSN_EH_REGION_BEG:
	case NOTE_INSN_EH_REGION_END:
	if (flag_dump_unnumbered)
	fprintf (outfile, " #");
	else
	fprintf (outfile, " %d", NOTE_EH_HANDLER (in_rtx));
	sawclose = 1;
	break;

	case NOTE_INSN_BLOCK_BEG:
	case NOTE_INSN_BLOCK_END:
	#ifndef GENERATOR_FILE
	dump_addr (outfile, " ", NOTE_BLOCK (in_rtx));
	#endif
	sawclose = 1;
	break;

	case NOTE_INSN_BASIC_BLOCK:
	{
	#ifndef GENERATOR_FILE
	basic_block bb = NOTE_BASIC_BLOCK (in_rtx);
	if (bb != 0)
	fprintf (outfile, " [bb %d]", bb->index);
	#endif
	break;
	}

	case NOTE_INSN_EXPECTED_VALUE:
	indent += 2;
	if (!sawclose)
	fprintf (outfile, " ");
	print_rtx (NOTE_EXPECTED_VALUE (in_rtx));
	indent -= 2;
	break;

	case NOTE_INSN_DELETED_LABEL:
	{
	const char *label = NOTE_DELETED_LABEL_NAME (in_rtx);
	if (label)
	fprintf (outfile, " (\"%s\")", label);
	else
	fprintf (outfile, " \"\"");
	}
	break;

	case NOTE_INSN_SWITCH_TEXT_SECTIONS:
	{
	#ifndef GENERATOR_FILE
	basic_block bb = NOTE_BASIC_BLOCK (in_rtx);
	if (bb != 0)
	fprintf (outfile, " [bb %d]", bb->index);
	#endif
	break;
	}

	case NOTE_INSN_VAR_LOCATION:
	#ifndef GENERATOR_FILE
	fprintf (outfile, " (");
	print_mem_expr (outfile, NOTE_VAR_LOCATION_DECL (in_rtx));
	fprintf (outfile, " ");
	print_rtx (NOTE_VAR_LOCATION_LOC (in_rtx));
	fprintf (outfile, ")");
	#endif
	break;

	default:
	{
	const char * const str = X0STR (in_rtx, i);

	if (NOTE_LINE_NUMBER (in_rtx) < 0)
	;
	else if (str == 0)
	fputs (dump_for_graph ? " \\\"\\\"" : " \"\"", outfile);
	else
	{
	if (dump_for_graph)
	fprintf (outfile, " (\\\"%s\\\")", str);
	else
	fprintf (outfile, " (\"%s\")", str);
	}
	break;
	}
	}
	}
	break;

	case 'e':
	do_e:
	indent += 2;
	if (!sawclose)
	fprintf (outfile, " ");
	print_rtx (XEXP (in_rtx, i));
	indent -= 2;
	break;

	case 'E':
	case 'V':
	indent += 2;
	if (sawclose)
	{
	fprintf (outfile, "\n%s%*s",
	print_rtx_head, indent * 2, "");
	sawclose = 0;
	}
	fputs (" [", outfile);
	if (NULL != XVEC (in_rtx, i))
	{
	indent += 2;
	if (XVECLEN (in_rtx, i))
	sawclose = 1;

	for (j = 0; j < XVECLEN (in_rtx, i); j++)
	print_rtx (XVECEXP (in_rtx, i, j));

	indent -= 2;
	}
	if (sawclose)
	fprintf (outfile, "\n%s%s", print_rtx_head, indent 2, "");

	fputs ("]", outfile);
	sawclose = 1;
	indent -= 2;
	break;

	case 'w':
	if (! flag_simple)
	fprintf (outfile, " ");
	fprintf (outfile, HOST_WIDE_INT_PRINT_DEC, XWINT (in_rtx, i));
	if (! flag_simple)
	fprintf (outfile, " [" HOST_WIDE_INT_PRINT_HEX "]",
	XWINT (in_rtx, i));
	break;

	case 'i':
	if (i == 4 && INSN_P (in_rtx))
	{
	#ifndef GENERATOR_FILE
	/* Pretty-print insn locators. Ignore scoping as it is mostly
	redundant with line number information and do not print anything
	when there is no location information available. */
	if (INSN_LOCATOR (in_rtx) && insn_file (in_rtx))
	fprintf(outfile, " %s:%i", insn_file (in_rtx), insn_line (in_rtx));
	#endif
	}
	else if (i == 6 && NOTE_P (in_rtx))
	{
	/* This field is only used for NOTE_INSN_DELETED_LABEL, and
	other times often contains garbage from INSN->NOTE death. */
	if (NOTE_LINE_NUMBER (in_rtx) == NOTE_INSN_DELETED_LABEL)
	fprintf (outfile, " %d", XINT (in_rtx, i));
	}
	else
	{
	int value = XINT (in_rtx, i);
	const char *name;

	#ifndef GENERATOR_FILE
	if (REG_P (in_rtx) && value < FIRST_PSEUDO_REGISTER)
	fprintf (outfile, " %d %s", REGNO (in_rtx),
	reg_names[REGNO (in_rtx)]);
	else if (REG_P (in_rtx)
	&& value <= LAST_VIRTUAL_REGISTER)
	{
	if (value == VIRTUAL_INCOMING_ARGS_REGNUM)
	fprintf (outfile, " %d virtual-incoming-args", value);
	else if (value == VIRTUAL_STACK_VARS_REGNUM)
	fprintf (outfile, " %d virtual-stack-vars", value);
	else if (value == VIRTUAL_STACK_DYNAMIC_REGNUM)
	fprintf (outfile, " %d virtual-stack-dynamic", value);
	else if (value == VIRTUAL_OUTGOING_ARGS_REGNUM)
	fprintf (outfile, " %d virtual-outgoing-args", value);
	else if (value == VIRTUAL_CFA_REGNUM)
	fprintf (outfile, " %d virtual-cfa", value);
	else
	fprintf (outfile, " %d virtual-reg-%d", value,
	value-FIRST_VIRTUAL_REGISTER);
	}
	else
	#endif
	if (flag_dump_unnumbered
	&& (is_insn \|\| NOTE_P (in_rtx)))
	fputc ('#', outfile);
	else
	fprintf (outfile, " %d", value);

	#ifndef GENERATOR_FILE
	if (REG_P (in_rtx) && REG_ATTRS (in_rtx))
	{
	fputs (" [", outfile);
	if (ORIGINAL_REGNO (in_rtx) != REGNO (in_rtx))
	fprintf (outfile, "orig:%i", ORIGINAL_REGNO (in_rtx));
	if (REG_EXPR (in_rtx))
	print_mem_expr (outfile, REG_EXPR (in_rtx));

	if (REG_OFFSET (in_rtx))
	fprintf (outfile, "+" HOST_WIDE_INT_PRINT_DEC,
	REG_OFFSET (in_rtx));
	fputs (" ]", outfile);
	}
	#endif

	if (is_insn && &INSN_CODE (in_rtx) == &XINT (in_rtx, i)
	&& XINT (in_rtx, i) >= 0
	&& (name = get_insn_name (XINT (in_rtx, i))) != NULL)
	fprintf (outfile, " {%s}", name);
	sawclose = 0;
	}
	break;

	/* Print NOTE_INSN names rather than integer codes. */

	case 'n':
	if (XINT (in_rtx, i) >= (int) NOTE_INSN_BIAS
	&& XINT (in_rtx, i) < (int) NOTE_INSN_MAX)
	fprintf (outfile, " %s", GET_NOTE_INSN_NAME (XINT (in_rtx, i)));
	else
	fprintf (outfile, " %d", XINT (in_rtx, i));
	sawclose = 0;
	break;

	case 'u':
	if (XEXP (in_rtx, i) != NULL)
	{
	rtx sub = XEXP (in_rtx, i);
	enum rtx_code subc = GET_CODE (sub);

	if (GET_CODE (in_rtx) == LABEL_REF)
	{
	if (subc == NOTE
	&& NOTE_LINE_NUMBER (sub) == NOTE_INSN_DELETED_LABEL)
	{
	if (flag_dump_unnumbered)
	fprintf (outfile, " [# deleted]");
	else
	fprintf (outfile, " [%d deleted]", INSN_UID (sub));
	sawclose = 0;
	break;
	}

	if (subc != CODE_LABEL)
	goto do_e;
	}

	if (flag_dump_unnumbered)
	fputs (" #", outfile);
	else
	fprintf (outfile, " %d", INSN_UID (sub));
	}
	else
	fputs (" 0", outfile);
	sawclose = 0;
	break;

	case 'b':
	#ifndef GENERATOR_FILE
	if (XBITMAP (in_rtx, i) == NULL)
	fputs (" {null}", outfile);
	else
	bitmap_print (outfile, XBITMAP (in_rtx, i), " {", "}");
	#endif
	sawclose = 0;
	break;

	case 't':
	#ifndef GENERATOR_FILE
	dump_addr (outfile, " ", XTREE (in_rtx, i));
	#endif
	break;

	case '*':
	fputs (" Unknown", outfile);
	sawclose = 0;
	break;

	case 'B':
	#ifndef GENERATOR_FILE
	if (XBBDEF (in_rtx, i))
	fprintf (outfile, " %i", XBBDEF (in_rtx, i)->index);
	#endif
	break;

	default:
	gcc_unreachable ();
	}

	switch (GET_CODE (in_rtx))
	{
	#ifndef GENERATOR_FILE
	case MEM:
	fprintf (outfile, " [" HOST_WIDE_INT_PRINT_DEC, MEM_ALIAS_SET (in_rtx));

	if (MEM_EXPR (in_rtx))
	print_mem_expr (outfile, MEM_EXPR (in_rtx));

	if (MEM_OFFSET (in_rtx))
	fprintf (outfile, "+" HOST_WIDE_INT_PRINT_DEC,
	INTVAL (MEM_OFFSET (in_rtx)));

	if (MEM_SIZE (in_rtx))
	fprintf (outfile, " S" HOST_WIDE_INT_PRINT_DEC,
	INTVAL (MEM_SIZE (in_rtx)));

	if (MEM_ALIGN (in_rtx) != 1)
	fprintf (outfile, " A%u", MEM_ALIGN (in_rtx));

	fputc (']', outfile);
	break;

	case CONST_DOUBLE:
	if (FLOAT_MODE_P (GET_MODE (in_rtx)))
	{
	char s[60];

	real_to_decimal (s, CONST_DOUBLE_REAL_VALUE (in_rtx),
	sizeof (s), 0, 1);
	fprintf (outfile, " %s", s);

	real_to_hexadecimal (s, CONST_DOUBLE_REAL_VALUE (in_rtx),
	sizeof (s), 0, 1);
	fprintf (outfile, " [%s]", s);
	}
	break;
	#endif

	case CODE_LABEL:
	fprintf (outfile, " [%d uses]", LABEL_NUSES (in_rtx));
	switch (LABEL_KIND (in_rtx))
	{
	case LABEL_NORMAL: break;
	case LABEL_STATIC_ENTRY: fputs (" [entry]", outfile); break;
	case LABEL_GLOBAL_ENTRY: fputs (" [global entry]", outfile); break;
	case LABEL_WEAK_ENTRY: fputs (" [weak entry]", outfile); break;
	default: gcc_unreachable ();
	}
	+/* APPLE LOCAL begin for-fsf-4_4 3274130 5295549 */ \
	+ if (LABEL_ALIGN_LOG (in_rtx) > 0)
	+ fprintf (outfile, " [log_align %u skip %u]", LABEL_ALIGN_LOG (in_rtx),
	+ LABEL_MAX_SKIP (in_rtx));
	+/* APPLE LOCAL end for-fsf-4_4 3274130 5295549 */ \
	break;

	default:
	break;
	}

	if (dump_for_graph
	&& (is_insn \|\| NOTE_P (in_rtx)
	\|\| LABEL_P (in_rtx) \|\| BARRIER_P (in_rtx)))
	sawclose = 0;
	else
	{
	fputc (')', outfile);
	sawclose = 1;
	}
	}

	/* Print an rtx on the current line of FILE. Initially indent IND
	characters. */

	void
	print_inline_rtx (FILE *outf, rtx x, int ind)
	{
	int oldsaw = sawclose;
	int oldindent = indent;

	sawclose = 0;
	indent = ind;
	outfile = outf;
	print_rtx (x);
	sawclose = oldsaw;
	indent = oldindent;
	}

	/* Call this function from the debugger to see what X looks like. */

	void
	debug_rtx (rtx x)
	{
	outfile = stderr;
	sawclose = 0;
	print_rtx (x);
	fprintf (stderr, "\n");
	}

	/* Count of rtx's to print with debug_rtx_list.
	This global exists because gdb user defined commands have no arguments. */

	int debug_rtx_count = 0; /* 0 is treated as equivalent to 1 */

	/* Call this function to print list from X on.

	N is a count of the rtx's to print. Positive values print from the specified
	rtx on. Negative values print a window around the rtx.
	EG: -5 prints 2 rtx's on either side (in addition to the specified rtx). */

	void
	debug_rtx_list (rtx x, int n)
	{
	int i,count;
	rtx insn;

	count = n == 0 ? 1 : n < 0 ? -n : n;

	/* If we are printing a window, back up to the start. */

	if (n < 0)
	for (i = count / 2; i > 0; i--)
	{
	if (PREV_INSN (x) == 0)
	break;
	x = PREV_INSN (x);
	}

	for (i = count, insn = x; i > 0 && insn != 0; i--, insn = NEXT_INSN (insn))
	{
	debug_rtx (insn);
	fprintf (stderr, "\n");
	}
	}

	/* Call this function to print an rtx list from START to END inclusive. */

	void
	debug_rtx_range (rtx start, rtx end)
	{
	while (1)
	{
	debug_rtx (start);
	fprintf (stderr, "\n");
	if (!start \|\| start == end)
	break;
	start = NEXT_INSN (start);
	}
	}

	/* Call this function to search an rtx list to find one with insn uid UID,
	and then call debug_rtx_list to print it, using DEBUG_RTX_COUNT.
	The found insn is returned to enable further debugging analysis. */

	rtx
	debug_rtx_find (rtx x, int uid)
	{
	while (x != 0 && INSN_UID (x) != uid)
	x = NEXT_INSN (x);
	if (x != 0)
	{
	debug_rtx_list (x, debug_rtx_count);
	return x;
	}
	else
	{
	fprintf (stderr, "insn uid %d not found\n", uid);
	return 0;
	}
	}

	/* External entry point for printing a chain of insns
	starting with RTX_FIRST onto file OUTF.
	A blank line separates insns.

	If RTX_FIRST is not an insn, then it alone is printed, with no newline. */

	void
	print_rtl (FILE *outf, rtx rtx_first)
	{
	rtx tmp_rtx;

	outfile = outf;
	sawclose = 0;

	if (rtx_first == 0)
	{
	fputs (print_rtx_head, outf);
	fputs ("(nil)\n", outf);
	}
	else
	switch (GET_CODE (rtx_first))
	{
	case INSN:
	case JUMP_INSN:
	case CALL_INSN:
	case NOTE:
	case CODE_LABEL:
	case BARRIER:
	for (tmp_rtx = rtx_first; tmp_rtx != 0; tmp_rtx = NEXT_INSN (tmp_rtx))
	if (! flag_dump_unnumbered
	\|\| !NOTE_P (tmp_rtx) \|\| NOTE_LINE_NUMBER (tmp_rtx) < 0)
	{
	fputs (print_rtx_head, outfile);
	print_rtx (tmp_rtx);
	fprintf (outfile, "\n");
	}
	break;

	default:
	fputs (print_rtx_head, outfile);
	print_rtx (rtx_first);
	}
	}

	/* Like print_rtx, except specify a file. */
	/* Return nonzero if we actually printed anything. */

	int
	print_rtl_single (FILE *outf, rtx x)
	{
	outfile = outf;
	sawclose = 0;
	if (! flag_dump_unnumbered
	\|\| !NOTE_P (x) \|\| NOTE_LINE_NUMBER (x) < 0)
	{
	fputs (print_rtx_head, outfile);
	print_rtx (x);
	putc ('\n', outf);
	return 1;
	}
	return 0;
	}


	/* Like print_rtl except without all the detail; for example,
	if RTX is a CONST_INT then print in decimal format. */

	void
	print_simple_rtl (FILE *outf, rtx x)
	{
	flag_simple = 1;
	print_rtl (outf, x);
	flag_simple = 0;
	}
	diff --git a/contrib/gcc/print-tree.c b/contrib/gcc/print-tree.c
	index ef87ab6abad2..1c480f9af95a 100644
	--- a/contrib/gcc/print-tree.c
	+++ b/contrib/gcc/print-tree.c
	@@ -1,874 +1,878 @@
	/* Prints out tree in human readable form - GCC
	Copyright (C) 1990, 1991, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
	2001, 2002, 2003, 2004, 2005 Free Software Foundation, Inc.

	This file is part of GCC.

	GCC is free software; you can redistribute it and/or modify it under
	the terms of the GNU General Public License as published by the Free
	Software Foundation; either version 2, or (at your option) any later
	version.

	GCC is distributed in the hope that it will be useful, but WITHOUT ANY
	WARRANTY; without even the implied warranty of MERCHANTABILITY or
	FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	for more details.

	You should have received a copy of the GNU General Public License
	along with GCC; see the file COPYING. If not, write to the Free
	Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
	02110-1301, USA. */


	#include "config.h"
	#include "system.h"
	#include "coretypes.h"
	#include "tm.h"
	#include "tree.h"
	#include "real.h"
	#include "ggc.h"
	#include "langhooks.h"
	#include "tree-iterator.h"

	/* Define the hash table of nodes already seen.
	Such nodes are not repeated; brief cross-references are used. */

	#define HASH_SIZE 37

	struct bucket
	{
	tree node;
	struct bucket *next;
	};

	static struct bucket **table;

	/* Print the node NODE on standard error, for debugging.
	Most nodes referred to by this one are printed recursively
	down to a depth of six. */

	void
	debug_tree (tree node)
	{
	table = XCNEWVEC (struct bucket *, HASH_SIZE);
	print_node (stderr, "", node, 0);
	free (table);
	table = 0;
	putc ('\n', stderr);
	}

	/* Print PREFIX and ADDR to FILE. */
	void
	dump_addr (FILE file, const char prefix, void *addr)
	{
	if (flag_dump_noaddr \|\| flag_dump_unnumbered)
	fprintf (file, "%s#", prefix);
	else
	fprintf (file, "%s%p", prefix, addr);
	}

	/* Print a node in brief fashion, with just the code, address and name. */

	void
	print_node_brief (FILE file, const char prefix, tree node, int indent)
	{
	enum tree_code_class class;

	if (node == 0)
	return;

	class = TREE_CODE_CLASS (TREE_CODE (node));

	/* Always print the slot this node is in, and its code, address and
	name if any. */
	if (indent > 0)
	fprintf (file, " ");
	fprintf (file, "%s <%s", prefix, tree_code_name[(int) TREE_CODE (node)]);
	dump_addr (file, " ", node);

	if (class == tcc_declaration)
	{
	if (DECL_NAME (node))
	fprintf (file, " %s", IDENTIFIER_POINTER (DECL_NAME (node)));
	else if (TREE_CODE (node) == LABEL_DECL
	&& LABEL_DECL_UID (node) != -1)
	fprintf (file, " L." HOST_WIDE_INT_PRINT_DEC, LABEL_DECL_UID (node));
	else
	fprintf (file, " %c.%u", TREE_CODE (node) == CONST_DECL ? 'C' : 'D',
	DECL_UID (node));
	}
	else if (class == tcc_type)
	{
	if (TYPE_NAME (node))
	{
	if (TREE_CODE (TYPE_NAME (node)) == IDENTIFIER_NODE)
	fprintf (file, " %s", IDENTIFIER_POINTER (TYPE_NAME (node)));
	else if (TREE_CODE (TYPE_NAME (node)) == TYPE_DECL
	&& DECL_NAME (TYPE_NAME (node)))
	fprintf (file, " %s",
	IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (node))));
	}
	}
	if (TREE_CODE (node) == IDENTIFIER_NODE)
	fprintf (file, " %s", IDENTIFIER_POINTER (node));

	/* We might as well always print the value of an integer or real. */
	if (TREE_CODE (node) == INTEGER_CST)
	{
	if (TREE_CONSTANT_OVERFLOW (node))
	fprintf (file, " overflow");

	fprintf (file, " ");
	if (TREE_INT_CST_HIGH (node) == 0)
	fprintf (file, HOST_WIDE_INT_PRINT_UNSIGNED, TREE_INT_CST_LOW (node));
	else if (TREE_INT_CST_HIGH (node) == -1
	&& TREE_INT_CST_LOW (node) != 0)
	fprintf (file, "-" HOST_WIDE_INT_PRINT_UNSIGNED,
	-TREE_INT_CST_LOW (node));
	else
	fprintf (file, HOST_WIDE_INT_PRINT_DOUBLE_HEX,
	TREE_INT_CST_HIGH (node), TREE_INT_CST_LOW (node));
	}
	if (TREE_CODE (node) == REAL_CST)
	{
	REAL_VALUE_TYPE d;

	if (TREE_OVERFLOW (node))
	fprintf (file, " overflow");

	d = TREE_REAL_CST (node);
	if (REAL_VALUE_ISINF (d))
	fprintf (file, REAL_VALUE_NEGATIVE (d) ? " -Inf" : " Inf");
	else if (REAL_VALUE_ISNAN (d))
	fprintf (file, " Nan");
	else
	{
	char string[60];
	real_to_decimal (string, &d, sizeof (string), 0, 1);
	fprintf (file, " %s", string);
	}
	}

	fprintf (file, ">");
	}

	void
	indent_to (FILE *file, int column)
	{
	int i;

	/* Since this is the long way, indent to desired column. */
	if (column > 0)
	fprintf (file, "\n");
	for (i = 0; i < column; i++)
	fprintf (file, " ");
	}

	/* Print the node NODE in full on file FILE, preceded by PREFIX,
	starting in column INDENT. */

	void
	print_node (FILE file, const char prefix, tree node, int indent)
	{
	int hash;
	struct bucket *b;
	enum machine_mode mode;
	enum tree_code_class class;
	int len;
	int i;
	expanded_location xloc;
	enum tree_code code;

	if (node == 0)
	return;

	code = TREE_CODE (node);
	class = TREE_CODE_CLASS (code);

	/* Don't get too deep in nesting. If the user wants to see deeper,
	it is easy to use the address of a lowest-level node
	as an argument in another call to debug_tree. */

	if (indent > 24)
	{
	print_node_brief (file, prefix, node, indent);
	return;
	}

	if (indent > 8 && (class == tcc_type \|\| class == tcc_declaration))
	{
	print_node_brief (file, prefix, node, indent);
	return;
	}

	/* It is unsafe to look at any other fields of an ERROR_MARK node. */
	if (TREE_CODE (node) == ERROR_MARK)
	{
	print_node_brief (file, prefix, node, indent);
	return;
	}

	hash = ((unsigned long) node) % HASH_SIZE;

	/* If node is in the table, just mention its address. */
	for (b = table[hash]; b; b = b->next)
	if (b->node == node)
	{
	print_node_brief (file, prefix, node, indent);
	return;
	}

	/* Add this node to the table. */
	b = XNEW (struct bucket);
	b->node = node;
	b->next = table[hash];
	table[hash] = b;

	/* Indent to the specified column, since this is the long form. */
	indent_to (file, indent);

	/* Print the slot this node is in, and its code, and address. */
	fprintf (file, "%s <%s", prefix, tree_code_name[(int) TREE_CODE (node)]);
	dump_addr (file, " ", node);

	/* Print the name, if any. */
	if (class == tcc_declaration)
	{
	if (DECL_NAME (node))
	fprintf (file, " %s", IDENTIFIER_POINTER (DECL_NAME (node)));
	else if (TREE_CODE (node) == LABEL_DECL
	&& LABEL_DECL_UID (node) != -1)
	fprintf (file, " L." HOST_WIDE_INT_PRINT_DEC, LABEL_DECL_UID (node));
	else
	fprintf (file, " %c.%u", TREE_CODE (node) == CONST_DECL ? 'C' : 'D',
	DECL_UID (node));
	}
	else if (class == tcc_type)
	{
	if (TYPE_NAME (node))
	{
	if (TREE_CODE (TYPE_NAME (node)) == IDENTIFIER_NODE)
	fprintf (file, " %s", IDENTIFIER_POINTER (TYPE_NAME (node)));
	else if (TREE_CODE (TYPE_NAME (node)) == TYPE_DECL
	&& DECL_NAME (TYPE_NAME (node)))
	fprintf (file, " %s",
	IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (node))));
	}
	}
	if (TREE_CODE (node) == IDENTIFIER_NODE)
	fprintf (file, " %s", IDENTIFIER_POINTER (node));

	if (TREE_CODE (node) == INTEGER_CST)
	{
	if (indent <= 4)
	print_node_brief (file, "type", TREE_TYPE (node), indent + 4);
	}
	else
	{
	print_node (file, "type", TREE_TYPE (node), indent + 4);
	if (TREE_TYPE (node))
	indent_to (file, indent + 3);
	}

	if (!TYPE_P (node) && TREE_SIDE_EFFECTS (node))
	fputs (" side-effects", file);

	if (TYPE_P (node) ? TYPE_READONLY (node) : TREE_READONLY (node))
	fputs (" readonly", file);
	if (!TYPE_P (node) && TREE_CONSTANT (node))
	fputs (" constant", file);
	else if (TYPE_P (node) && TYPE_SIZES_GIMPLIFIED (node))
	fputs (" sizes-gimplified", file);

	if (TREE_INVARIANT (node))
	fputs (" invariant", file);
	if (TREE_ADDRESSABLE (node))
	fputs (" addressable", file);
	if (TREE_THIS_VOLATILE (node))
	fputs (" volatile", file);
	if (TREE_ASM_WRITTEN (node))
	fputs (" asm_written", file);
	if (TREE_USED (node))
	fputs (" used", file);
	if (TREE_NOTHROW (node))
	fputs (TYPE_P (node) ? " align-ok" : " nothrow", file);
	if (TREE_PUBLIC (node))
	fputs (" public", file);
	if (TREE_PRIVATE (node))
	fputs (" private", file);
	if (TREE_PROTECTED (node))
	fputs (" protected", file);
	if (TREE_STATIC (node))
	fputs (" static", file);
	if (TREE_DEPRECATED (node))
	fputs (" deprecated", file);
	+ /* APPLE LOCAL begin "unavailable" attribute (Radar 2809697) */
	+ if (TREE_UNAVAILABLE (node))
	+ fputs (" unavailable", file);
	+ /* APPLE LOCAL end "unavailable" attribute (Radar 2809697) */
	if (TREE_VISITED (node))
	fputs (" visited", file);
	if (TREE_LANG_FLAG_0 (node))
	fputs (" tree_0", file);
	if (TREE_LANG_FLAG_1 (node))
	fputs (" tree_1", file);
	if (TREE_LANG_FLAG_2 (node))
	fputs (" tree_2", file);
	if (TREE_LANG_FLAG_3 (node))
	fputs (" tree_3", file);
	if (TREE_LANG_FLAG_4 (node))
	fputs (" tree_4", file);
	if (TREE_LANG_FLAG_5 (node))
	fputs (" tree_5", file);
	if (TREE_LANG_FLAG_6 (node))
	fputs (" tree_6", file);

	/* DECL_ nodes have additional attributes. */

	switch (TREE_CODE_CLASS (TREE_CODE (node)))
	{
	case tcc_declaration:
	if (CODE_CONTAINS_STRUCT (code, TS_DECL_COMMON))
	{
	if (DECL_UNSIGNED (node))
	fputs (" unsigned", file);
	if (DECL_IGNORED_P (node))
	fputs (" ignored", file);
	if (DECL_ABSTRACT (node))
	fputs (" abstract", file);
	if (DECL_EXTERNAL (node))
	fputs (" external", file);
	if (DECL_NONLOCAL (node))
	fputs (" nonlocal", file);
	}
	if (CODE_CONTAINS_STRUCT (code, TS_DECL_WITH_VIS))
	{
	if (DECL_WEAK (node))
	fputs (" weak", file);
	if (DECL_IN_SYSTEM_HEADER (node))
	fputs (" in_system_header", file);
	}
	if (CODE_CONTAINS_STRUCT (code, TS_DECL_WRTL)
	&& TREE_CODE (node) != LABEL_DECL
	&& TREE_CODE (node) != FUNCTION_DECL
	&& DECL_REGISTER (node))
	fputs (" regdecl", file);

	if (TREE_CODE (node) == TYPE_DECL && TYPE_DECL_SUPPRESS_DEBUG (node))
	fputs (" suppress-debug", file);

	if (TREE_CODE (node) == FUNCTION_DECL && DECL_INLINE (node))
	fputs (DECL_DECLARED_INLINE_P (node) ? " inline" : " autoinline", file);
	if (TREE_CODE (node) == FUNCTION_DECL && DECL_BUILT_IN (node))
	fputs (" built-in", file);
	if (TREE_CODE (node) == FUNCTION_DECL && DECL_NO_STATIC_CHAIN (node))
	fputs (" no-static-chain", file);

	if (TREE_CODE (node) == FIELD_DECL && DECL_PACKED (node))
	fputs (" packed", file);
	if (TREE_CODE (node) == FIELD_DECL && DECL_BIT_FIELD (node))
	fputs (" bit-field", file);
	if (TREE_CODE (node) == FIELD_DECL && DECL_NONADDRESSABLE_P (node))
	fputs (" nonaddressable", file);

	if (TREE_CODE (node) == LABEL_DECL && DECL_ERROR_ISSUED (node))
	fputs (" error-issued", file);

	if (TREE_CODE (node) == VAR_DECL && DECL_IN_TEXT_SECTION (node))
	fputs (" in-text-section", file);
	if (TREE_CODE (node) == VAR_DECL && DECL_COMMON (node))
	fputs (" common", file);
	if (TREE_CODE (node) == VAR_DECL && DECL_THREAD_LOCAL_P (node))
	{
	enum tls_model kind = DECL_TLS_MODEL (node);
	switch (kind)
	{
	case TLS_MODEL_GLOBAL_DYNAMIC:
	fputs (" tls-global-dynamic", file);
	break;
	case TLS_MODEL_LOCAL_DYNAMIC:
	fputs (" tls-local-dynamic", file);
	break;
	case TLS_MODEL_INITIAL_EXEC:
	fputs (" tls-initial-exec", file);
	break;
	case TLS_MODEL_LOCAL_EXEC:
	fputs (" tls-local-exec", file);
	break;
	default:
	gcc_unreachable ();
	}
	}

	if (CODE_CONTAINS_STRUCT (code, TS_DECL_COMMON))
	{
	if (DECL_VIRTUAL_P (node))
	fputs (" virtual", file);
	if (DECL_PRESERVE_P (node))
	fputs (" preserve", file);
	if (DECL_LANG_FLAG_0 (node))
	fputs (" decl_0", file);
	if (DECL_LANG_FLAG_1 (node))
	fputs (" decl_1", file);
	if (DECL_LANG_FLAG_2 (node))
	fputs (" decl_2", file);
	if (DECL_LANG_FLAG_3 (node))
	fputs (" decl_3", file);
	if (DECL_LANG_FLAG_4 (node))
	fputs (" decl_4", file);
	if (DECL_LANG_FLAG_5 (node))
	fputs (" decl_5", file);
	if (DECL_LANG_FLAG_6 (node))
	fputs (" decl_6", file);
	if (DECL_LANG_FLAG_7 (node))
	fputs (" decl_7", file);

	mode = DECL_MODE (node);
	fprintf (file, " %s", GET_MODE_NAME (mode));
	}

	if (CODE_CONTAINS_STRUCT (code, TS_DECL_WITH_VIS) && DECL_DEFER_OUTPUT (node))
	fputs (" defer-output", file);


	xloc = expand_location (DECL_SOURCE_LOCATION (node));
	fprintf (file, " file %s line %d", xloc.file, xloc.line);

	if (CODE_CONTAINS_STRUCT (code, TS_DECL_COMMON))
	{
	print_node (file, "size", DECL_SIZE (node), indent + 4);
	print_node (file, "unit size", DECL_SIZE_UNIT (node), indent + 4);

	if (TREE_CODE (node) != FUNCTION_DECL
	\|\| DECL_INLINE (node) \|\| DECL_BUILT_IN (node))
	indent_to (file, indent + 3);

	if (DECL_USER_ALIGN (node))
	fprintf (file, " user");

	fprintf (file, " align %d", DECL_ALIGN (node));
	if (TREE_CODE (node) == FIELD_DECL)
	fprintf (file, " offset_align " HOST_WIDE_INT_PRINT_UNSIGNED,
	DECL_OFFSET_ALIGN (node));

	if (TREE_CODE (node) == FUNCTION_DECL && DECL_BUILT_IN (node))
	{
	if (DECL_BUILT_IN_CLASS (node) == BUILT_IN_MD)
	fprintf (file, " built-in BUILT_IN_MD %d", DECL_FUNCTION_CODE (node));
	else
	fprintf (file, " built-in %s:%s",
	built_in_class_names[(int) DECL_BUILT_IN_CLASS (node)],
	built_in_names[(int) DECL_FUNCTION_CODE (node)]);
	}

	if (DECL_POINTER_ALIAS_SET_KNOWN_P (node))
	fprintf (file, " alias set " HOST_WIDE_INT_PRINT_DEC,
	DECL_POINTER_ALIAS_SET (node));
	}
	if (TREE_CODE (node) == FIELD_DECL)
	{
	print_node (file, "offset", DECL_FIELD_OFFSET (node), indent + 4);
	print_node (file, "bit offset", DECL_FIELD_BIT_OFFSET (node),
	indent + 4);
	if (DECL_BIT_FIELD_TYPE (node))
	print_node (file, "bit_field_type", DECL_BIT_FIELD_TYPE (node),
	indent + 4);
	}

	print_node_brief (file, "context", DECL_CONTEXT (node), indent + 4);

	if (CODE_CONTAINS_STRUCT (code, TS_DECL_COMMON))
	{
	print_node_brief (file, "attributes",
	DECL_ATTRIBUTES (node), indent + 4);
	print_node_brief (file, "initial", DECL_INITIAL (node), indent + 4);
	}
	if (CODE_CONTAINS_STRUCT (code, TS_DECL_WRTL))
	{
	print_node_brief (file, "abstract_origin",
	DECL_ABSTRACT_ORIGIN (node), indent + 4);
	}
	if (CODE_CONTAINS_STRUCT (code, TS_DECL_NON_COMMON))
	{
	print_node (file, "arguments", DECL_ARGUMENT_FLD (node), indent + 4);
	print_node (file, "result", DECL_RESULT_FLD (node), indent + 4);
	}

	lang_hooks.print_decl (file, node, indent);

	if (DECL_RTL_SET_P (node))
	{
	indent_to (file, indent + 4);
	print_rtl (file, DECL_RTL (node));
	}

	if (TREE_CODE (node) == PARM_DECL)
	{
	print_node (file, "arg-type", DECL_ARG_TYPE (node), indent + 4);

	if (DECL_INCOMING_RTL (node) != 0)
	{
	indent_to (file, indent + 4);
	fprintf (file, "incoming-rtl ");
	print_rtl (file, DECL_INCOMING_RTL (node));
	}
	}
	else if (TREE_CODE (node) == FUNCTION_DECL
	&& DECL_STRUCT_FUNCTION (node) != 0)
	{
	indent_to (file, indent + 4);
	dump_addr (file, "saved-insns ", DECL_STRUCT_FUNCTION (node));
	}

	if ((TREE_CODE (node) == VAR_DECL \|\| TREE_CODE (node) == PARM_DECL)
	&& DECL_HAS_VALUE_EXPR_P (node))
	print_node (file, "value-expr", DECL_VALUE_EXPR (node), indent + 4);

	if (TREE_CODE (node) == STRUCT_FIELD_TAG)
	{
	fprintf (file, " sft size " HOST_WIDE_INT_PRINT_DEC,
	SFT_SIZE (node));
	fprintf (file, " sft offset " HOST_WIDE_INT_PRINT_DEC,
	SFT_OFFSET (node));
	print_node_brief (file, "parent var", SFT_PARENT_VAR (node),
	indent + 4);
	}
	/* Print the decl chain only if decl is at second level. */
	if (indent == 4)
	print_node (file, "chain", TREE_CHAIN (node), indent + 4);
	else
	print_node_brief (file, "chain", TREE_CHAIN (node), indent + 4);
	break;

	case tcc_type:
	if (TYPE_UNSIGNED (node))
	fputs (" unsigned", file);

	/* The no-force-blk flag is used for different things in
	different types. */
	if ((TREE_CODE (node) == RECORD_TYPE
	\|\| TREE_CODE (node) == UNION_TYPE
	\|\| TREE_CODE (node) == QUAL_UNION_TYPE)
	&& TYPE_NO_FORCE_BLK (node))
	fputs (" no-force-blk", file);
	else if (TREE_CODE (node) == INTEGER_TYPE
	&& TYPE_IS_SIZETYPE (node))
	fputs (" sizetype", file);
	else if (TREE_CODE (node) == FUNCTION_TYPE
	&& TYPE_RETURNS_STACK_DEPRESSED (node))
	fputs (" returns-stack-depressed", file);

	if (TYPE_STRING_FLAG (node))
	fputs (" string-flag", file);
	if (TYPE_NEEDS_CONSTRUCTING (node))
	fputs (" needs-constructing", file);

	/* The transparent-union flag is used for different things in
	different nodes. */
	if (TREE_CODE (node) == UNION_TYPE && TYPE_TRANSPARENT_UNION (node))
	fputs (" transparent-union", file);
	else if (TREE_CODE (node) == ARRAY_TYPE
	&& TYPE_NONALIASED_COMPONENT (node))
	fputs (" nonaliased-component", file);

	if (TYPE_PACKED (node))
	fputs (" packed", file);

	if (TYPE_RESTRICT (node))
	fputs (" restrict", file);

	if (TYPE_LANG_FLAG_0 (node))
	fputs (" type_0", file);
	if (TYPE_LANG_FLAG_1 (node))
	fputs (" type_1", file);
	if (TYPE_LANG_FLAG_2 (node))
	fputs (" type_2", file);
	if (TYPE_LANG_FLAG_3 (node))
	fputs (" type_3", file);
	if (TYPE_LANG_FLAG_4 (node))
	fputs (" type_4", file);
	if (TYPE_LANG_FLAG_5 (node))
	fputs (" type_5", file);
	if (TYPE_LANG_FLAG_6 (node))
	fputs (" type_6", file);

	mode = TYPE_MODE (node);
	fprintf (file, " %s", GET_MODE_NAME (mode));

	print_node (file, "size", TYPE_SIZE (node), indent + 4);
	print_node (file, "unit size", TYPE_SIZE_UNIT (node), indent + 4);
	indent_to (file, indent + 3);

	if (TYPE_USER_ALIGN (node))
	fprintf (file, " user");

	fprintf (file, " align %d symtab %d alias set " HOST_WIDE_INT_PRINT_DEC,
	TYPE_ALIGN (node), TYPE_SYMTAB_ADDRESS (node),
	TYPE_ALIAS_SET (node));

	print_node (file, "attributes", TYPE_ATTRIBUTES (node), indent + 4);

	if (INTEGRAL_TYPE_P (node) \|\| TREE_CODE (node) == REAL_TYPE)
	{
	fprintf (file, " precision %d", TYPE_PRECISION (node));
	print_node_brief (file, "min", TYPE_MIN_VALUE (node), indent + 4);
	print_node_brief (file, "max", TYPE_MAX_VALUE (node), indent + 4);
	}

	if (TREE_CODE (node) == ENUMERAL_TYPE)
	print_node (file, "values", TYPE_VALUES (node), indent + 4);
	else if (TREE_CODE (node) == ARRAY_TYPE)
	print_node (file, "domain", TYPE_DOMAIN (node), indent + 4);
	else if (TREE_CODE (node) == VECTOR_TYPE)
	fprintf (file, " nunits %d", (int) TYPE_VECTOR_SUBPARTS (node));
	else if (TREE_CODE (node) == RECORD_TYPE
	\|\| TREE_CODE (node) == UNION_TYPE
	\|\| TREE_CODE (node) == QUAL_UNION_TYPE)
	print_node (file, "fields", TYPE_FIELDS (node), indent + 4);
	else if (TREE_CODE (node) == FUNCTION_TYPE
	\|\| TREE_CODE (node) == METHOD_TYPE)
	{
	if (TYPE_METHOD_BASETYPE (node))
	print_node_brief (file, "method basetype",
	TYPE_METHOD_BASETYPE (node), indent + 4);
	print_node (file, "arg-types", TYPE_ARG_TYPES (node), indent + 4);
	}
	else if (TREE_CODE (node) == OFFSET_TYPE)
	print_node_brief (file, "basetype", TYPE_OFFSET_BASETYPE (node),
	indent + 4);

	if (TYPE_CONTEXT (node))
	print_node_brief (file, "context", TYPE_CONTEXT (node), indent + 4);

	lang_hooks.print_type (file, node, indent);

	if (TYPE_POINTER_TO (node) \|\| TREE_CHAIN (node))
	indent_to (file, indent + 3);

	print_node_brief (file, "pointer_to_this", TYPE_POINTER_TO (node),
	indent + 4);
	print_node_brief (file, "reference_to_this", TYPE_REFERENCE_TO (node),
	indent + 4);
	print_node_brief (file, "chain", TREE_CHAIN (node), indent + 4);
	break;

	case tcc_expression:
	case tcc_comparison:
	case tcc_unary:
	case tcc_binary:
	case tcc_reference:
	case tcc_statement:
	if (TREE_CODE (node) == BIT_FIELD_REF && BIT_FIELD_REF_UNSIGNED (node))
	fputs (" unsigned", file);
	if (TREE_CODE (node) == BIND_EXPR)
	{
	print_node (file, "vars", TREE_OPERAND (node, 0), indent + 4);
	print_node (file, "body", TREE_OPERAND (node, 1), indent + 4);
	print_node (file, "block", TREE_OPERAND (node, 2), indent + 4);
	break;
	}

	len = TREE_CODE_LENGTH (TREE_CODE (node));

	for (i = 0; i < len; i++)
	{
	char temp[10];

	sprintf (temp, "arg %d", i);
	print_node (file, temp, TREE_OPERAND (node, i), indent + 4);
	}

	print_node (file, "chain", TREE_CHAIN (node), indent + 4);
	break;

	case tcc_constant:
	case tcc_exceptional:
	switch (TREE_CODE (node))
	{
	case INTEGER_CST:
	if (TREE_CONSTANT_OVERFLOW (node))
	fprintf (file, " overflow");

	fprintf (file, " ");
	if (TREE_INT_CST_HIGH (node) == 0)
	fprintf (file, HOST_WIDE_INT_PRINT_UNSIGNED,
	TREE_INT_CST_LOW (node));
	else if (TREE_INT_CST_HIGH (node) == -1
	&& TREE_INT_CST_LOW (node) != 0)
	fprintf (file, "-" HOST_WIDE_INT_PRINT_UNSIGNED,
	-TREE_INT_CST_LOW (node));
	else
	fprintf (file, HOST_WIDE_INT_PRINT_DOUBLE_HEX,
	TREE_INT_CST_HIGH (node), TREE_INT_CST_LOW (node));
	break;

	case REAL_CST:
	{
	REAL_VALUE_TYPE d;

	if (TREE_OVERFLOW (node))
	fprintf (file, " overflow");

	d = TREE_REAL_CST (node);
	if (REAL_VALUE_ISINF (d))
	fprintf (file, REAL_VALUE_NEGATIVE (d) ? " -Inf" : " Inf");
	else if (REAL_VALUE_ISNAN (d))
	fprintf (file, " Nan");
	else
	{
	char string[64];
	real_to_decimal (string, &d, sizeof (string), 0, 1);
	fprintf (file, " %s", string);
	}
	}
	break;

	case VECTOR_CST:
	{
	tree vals = TREE_VECTOR_CST_ELTS (node);
	char buf[10];
	tree link;
	int i;

	i = 0;
	for (link = vals; link; link = TREE_CHAIN (link), ++i)
	{
	sprintf (buf, "elt%d: ", i);
	print_node (file, buf, TREE_VALUE (link), indent + 4);
	}
	}
	break;

	case COMPLEX_CST:
	print_node (file, "real", TREE_REALPART (node), indent + 4);
	print_node (file, "imag", TREE_IMAGPART (node), indent + 4);
	break;

	case STRING_CST:
	{
	const char *p = TREE_STRING_POINTER (node);
	int i = TREE_STRING_LENGTH (node);
	fputs (" \"", file);
	while (--i >= 0)
	{
	char ch = *p++;
	if (ch >= ' ' && ch < 127)
	putc (ch, file);
	else
	fprintf(file, "\\%03o", ch & 0xFF);
	}
	fputc ('\"', file);
	}
	/* Print the chain at second level. */
	if (indent == 4)
	print_node (file, "chain", TREE_CHAIN (node), indent + 4);
	else
	print_node_brief (file, "chain", TREE_CHAIN (node), indent + 4);
	break;

	case IDENTIFIER_NODE:
	lang_hooks.print_identifier (file, node, indent);
	break;

	case TREE_LIST:
	print_node (file, "purpose", TREE_PURPOSE (node), indent + 4);
	print_node (file, "value", TREE_VALUE (node), indent + 4);
	print_node (file, "chain", TREE_CHAIN (node), indent + 4);
	break;

	case TREE_VEC:
	len = TREE_VEC_LENGTH (node);
	for (i = 0; i < len; i++)
	if (TREE_VEC_ELT (node, i))
	{
	char temp[10];
	sprintf (temp, "elt %d", i);
	indent_to (file, indent + 4);
	print_node_brief (file, temp, TREE_VEC_ELT (node, i), 0);
	}
	break;

	case STATEMENT_LIST:
	dump_addr (file, " head ", node->stmt_list.head);
	dump_addr (file, " tail ", node->stmt_list.tail);
	fprintf (file, " stmts");
	{
	tree_stmt_iterator i;
	for (i = tsi_start (node); !tsi_end_p (i); tsi_next (&i))
	{
	/* Not printing the addresses of the (not-a-tree)
	'struct tree_stmt_list_node's. */
	dump_addr (file, " ", tsi_stmt (i));
	}
	fprintf (file, "\n");
	for (i = tsi_start (node); !tsi_end_p (i); tsi_next (&i))
	{
	/* Not printing the addresses of the (not-a-tree)
	'struct tree_stmt_list_node's. */
	print_node (file, "stmt", tsi_stmt (i), indent + 4);
	}
	}
	print_node (file, "chain", TREE_CHAIN (node), indent + 4);
	break;

	case BLOCK:
	print_node (file, "vars", BLOCK_VARS (node), indent + 4);
	print_node (file, "supercontext", BLOCK_SUPERCONTEXT (node),
	indent + 4);
	print_node (file, "subblocks", BLOCK_SUBBLOCKS (node), indent + 4);
	print_node (file, "chain", BLOCK_CHAIN (node), indent + 4);
	print_node (file, "abstract_origin",
	BLOCK_ABSTRACT_ORIGIN (node), indent + 4);
	break;

	case SSA_NAME:
	print_node_brief (file, "var", SSA_NAME_VAR (node), indent + 4);
	print_node_brief (file, "def_stmt",
	SSA_NAME_DEF_STMT (node), indent + 4);

	indent_to (file, indent + 4);
	fprintf (file, "version %u", SSA_NAME_VERSION (node));
	if (SSA_NAME_OCCURS_IN_ABNORMAL_PHI (node))
	fprintf (file, " in-abnormal-phi");
	if (SSA_NAME_IN_FREE_LIST (node))
	fprintf (file, " in-free-list");

	if (SSA_NAME_PTR_INFO (node)
	\|\| SSA_NAME_VALUE (node))
	{
	indent_to (file, indent + 3);
	if (SSA_NAME_PTR_INFO (node))
	dump_addr (file, " ptr-info ", SSA_NAME_PTR_INFO (node));
	if (SSA_NAME_VALUE (node))
	dump_addr (file, " value ", SSA_NAME_VALUE (node));
	}
	break;

	case OMP_CLAUSE:
	{
	int i;
	fprintf (file, " %s",
	omp_clause_code_name[OMP_CLAUSE_CODE (node)]);
	for (i = 0; i < omp_clause_num_ops[OMP_CLAUSE_CODE (node)]; i++)
	{
	indent_to (file, indent + 4);
	fprintf (file, "op %d:", i);
	print_node_brief (file, "", OMP_CLAUSE_OPERAND (node, i), 0);
	}
	}
	break;

	default:
	if (EXCEPTIONAL_CLASS_P (node))
	lang_hooks.print_xnode (file, node, indent);
	break;
	}

	break;
	}

	if (EXPR_HAS_LOCATION (node))
	{
	expanded_location xloc = expand_location (EXPR_LOCATION (node));
	indent_to (file, indent+4);
	fprintf (file, "%s:%d", xloc.file, xloc.line);
	}

	fprintf (file, ">");
	}
	diff --git a/contrib/gcc/rtl.def b/contrib/gcc/rtl.def
	index cb37f1ab2b2b..f60644358b57 100644
	--- a/contrib/gcc/rtl.def
	+++ b/contrib/gcc/rtl.def
	@@ -1,1210 +1,1214 @@
	/* This file contains the definitions and documentation for the
	Register Transfer Expressions (rtx's) that make up the
	Register Transfer Language (rtl) used in the Back End of the GNU compiler.
	Copyright (C) 1987, 1988, 1992, 1994, 1995, 1997, 1998, 1999, 2000, 2004,
	2005, 2006
	Free Software Foundation, Inc.

	This file is part of GCC.

	GCC is free software; you can redistribute it and/or modify it under
	the terms of the GNU General Public License as published by the Free
	Software Foundation; either version 2, or (at your option) any later
	version.

	GCC is distributed in the hope that it will be useful, but WITHOUT ANY
	WARRANTY; without even the implied warranty of MERCHANTABILITY or
	FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	for more details.

	You should have received a copy of the GNU General Public License
	along with GCC; see the file COPYING. If not, write to the Free
	Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
	02110-1301, USA. */


	/* Expression definitions and descriptions for all targets are in this file.
	Some will not be used for some targets.

	The fields in the cpp macro call "DEF_RTL_EXPR()"
	are used to create declarations in the C source of the compiler.

	The fields are:

	1. The internal name of the rtx used in the C source.
	It is a tag in the enumeration "enum rtx_code" defined in "rtl.h".
	By convention these are in UPPER_CASE.

	2. The name of the rtx in the external ASCII format read by
	read_rtx(), and printed by print_rtx().
	These names are stored in rtx_name[].
	By convention these are the internal (field 1) names in lower_case.

	3. The print format, and type of each rtx->u.fld[] (field) in this rtx.
	These formats are stored in rtx_format[].
	The meaning of the formats is documented in front of this array in rtl.c

	4. The class of the rtx. These are stored in rtx_class and are accessed
	via the GET_RTX_CLASS macro. They are defined as follows:

	RTX_CONST_OBJ
	an rtx code that can be used to represent a constant object
	(e.g, CONST_INT)
	RTX_OBJ
	an rtx code that can be used to represent an object (e.g, REG, MEM)
	RTX_COMPARE
	an rtx code for a comparison (e.g, LT, GT)
	RTX_COMM_COMPARE
	an rtx code for a commutative comparison (e.g, EQ, NE, ORDERED)
	RTX_UNARY
	an rtx code for a unary arithmetic expression (e.g, NEG, NOT)
	RTX_COMM_ARITH
	an rtx code for a commutative binary operation (e.g,, PLUS, MULT)
	RTX_TERNARY
	an rtx code for a non-bitfield three input operation (IF_THEN_ELSE)
	RTX_BIN_ARITH
	an rtx code for a non-commutative binary operation (e.g., MINUS, DIV)
	RTX_BITFIELD_OPS
	an rtx code for a bit-field operation (ZERO_EXTRACT, SIGN_EXTRACT)
	RTX_INSN
	an rtx code for a machine insn (INSN, JUMP_INSN, CALL_INSN)
	RTX_MATCH
	an rtx code for something that matches in insns (e.g, MATCH_DUP)
	RTX_AUTOINC
	an rtx code for autoincrement addressing modes (e.g. POST_DEC)
	RTX_EXTRA
	everything else

	All of the expressions that appear only in machine descriptions,
	not in RTL used by the compiler itself, are at the end of the file. */

	/* Unknown, or no such operation; the enumeration constant should have
	value zero. */
	DEF_RTL_EXPR(UNKNOWN, "UnKnown", "*", RTX_EXTRA)

	/* ---------------------------------------------------------------------
	Expressions used in constructing lists.
	--------------------------------------------------------------------- */

	/* a linked list of expressions */
	DEF_RTL_EXPR(EXPR_LIST, "expr_list", "ee", RTX_EXTRA)

	/* a linked list of instructions.
	The insns are represented in print by their uids. */
	DEF_RTL_EXPR(INSN_LIST, "insn_list", "ue", RTX_EXTRA)

	/* a linked list of dependencies.
	The insns are represented in print by their uids.
	Operand 2 is the status of a dependence (see sched-int.h for more). */
	DEF_RTL_EXPR(DEPS_LIST, "deps_list", "uei", RTX_EXTRA)

	/* SEQUENCE appears in the result of a `gen_...' function
	for a DEFINE_EXPAND that wants to make several insns.
	Its elements are the bodies of the insns that should be made.
	`emit_insn' takes the SEQUENCE apart and makes separate insns. */
	DEF_RTL_EXPR(SEQUENCE, "sequence", "E", RTX_EXTRA)

	/* Refers to the address of its argument. This is only used in alias.c. */
	DEF_RTL_EXPR(ADDRESS, "address", "e", RTX_MATCH)

	/* ----------------------------------------------------------------------
	Expression types used for things in the instruction chain.

	All formats must start with "iuu" to handle the chain.
	Each insn expression holds an rtl instruction and its semantics
	during back-end processing.
	See macros's in "rtl.h" for the meaning of each rtx->u.fld[].

	---------------------------------------------------------------------- */

	/* An instruction that cannot jump. */
	DEF_RTL_EXPR(INSN, "insn", "iuuBieiee", RTX_INSN)

	/* An instruction that can possibly jump.
	Fields ( rtx->u.fld[] ) have exact same meaning as INSN's. */
	DEF_RTL_EXPR(JUMP_INSN, "jump_insn", "iuuBieiee0", RTX_INSN)

	/* An instruction that can possibly call a subroutine
	but which will not change which instruction comes next
	in the current function.
	Field ( rtx->u.fld[9] ) is CALL_INSN_FUNCTION_USAGE.
	All other fields ( rtx->u.fld[] ) have exact same meaning as INSN's. */
	DEF_RTL_EXPR(CALL_INSN, "call_insn", "iuuBieieee", RTX_INSN)

	/* A marker that indicates that control will not flow through. */
	DEF_RTL_EXPR(BARRIER, "barrier", "iuu000000", RTX_EXTRA)

	/* Holds a label that is followed by instructions.
	Operand:
	4: is used in jump.c for the use-count of the label.
	5: is used in flow.c to point to the chain of label_ref's to this label.
	6: is a number that is unique in the entire compilation.
	- 7: is the user-given name of the label, if any. */
	-DEF_RTL_EXPR(CODE_LABEL, "code_label", "iuuB00is", RTX_EXTRA)
	+ APPLE LOCAL begin for-fsf-4_4 3274130 5295549
	+ 7: is the user-given name of the label, if any.
	+ 8: is the alignment of the label, made up of two parts,
	+ LABEL_ALIGNMENT and LABEL_MAX_SKIP. */
	+DEF_RTL_EXPR(CODE_LABEL, "code_label", "iuuB00isi", RTX_EXTRA)

	+/* APPLE LOCAL end for-fsf-4_4 3274130 5295549 */ \
	#ifdef USE_MAPPED_LOCATION
	/* Say where in the code a source line starts, for symbol table's sake.
	Operand:
	4: unused if line number > 0, note-specific data otherwise.
	5: line number if > 0, enum note_insn otherwise.
	6: CODE_LABEL_NUMBER if line number == NOTE_INSN_DELETED_LABEL. */
	#else
	/* Say where in the code a source line starts, for symbol table's sake.
	Operand:
	4: filename, if line number > 0, note-specific data otherwise.
	5: line number if > 0, enum note_insn otherwise.
	6: unique number if line number == note_insn_deleted_label. */
	#endif
	DEF_RTL_EXPR(NOTE, "note", "iuuB0ni", RTX_EXTRA)

	/* ----------------------------------------------------------------------
	Top level constituents of INSN, JUMP_INSN and CALL_INSN.
	---------------------------------------------------------------------- */

	/* Conditionally execute code.
	Operand 0 is the condition that if true, the code is executed.
	Operand 1 is the code to be executed (typically a SET).

	Semantics are that there are no side effects if the condition
	is false. This pattern is created automatically by the if_convert
	pass run after reload or by target-specific splitters. */
	DEF_RTL_EXPR(COND_EXEC, "cond_exec", "ee", RTX_EXTRA)

	/* Several operations to be done in parallel (perhaps under COND_EXEC). */
	DEF_RTL_EXPR(PARALLEL, "parallel", "E", RTX_EXTRA)

	/* A string that is passed through to the assembler as input.
	One can obviously pass comments through by using the
	assembler comment syntax.
	These occur in an insn all by themselves as the PATTERN.
	They also appear inside an ASM_OPERANDS
	as a convenient way to hold a string. */
	DEF_RTL_EXPR(ASM_INPUT, "asm_input", "s", RTX_EXTRA)

	#ifdef USE_MAPPED_LOCATION
	/* An assembler instruction with operands.
	1st operand is the instruction template.
	2nd operand is the constraint for the output.
	3rd operand is the number of the output this expression refers to.
	When an insn stores more than one value, a separate ASM_OPERANDS
	is made for each output; this integer distinguishes them.
	4th is a vector of values of input operands.
	5th is a vector of modes and constraints for the input operands.
	Each element is an ASM_INPUT containing a constraint string
	and whose mode indicates the mode of the input operand.
	6th is the source line number. */
	DEF_RTL_EXPR(ASM_OPERANDS, "asm_operands", "ssiEEi", RTX_EXTRA)
	#else
	/* An assembler instruction with operands.
	1st operand is the instruction template.
	2nd operand is the constraint for the output.
	3rd operand is the number of the output this expression refers to.
	When an insn stores more than one value, a separate ASM_OPERANDS
	is made for each output; this integer distinguishes them.
	4th is a vector of values of input operands.
	5th is a vector of modes and constraints for the input operands.
	Each element is an ASM_INPUT containing a constraint string
	and whose mode indicates the mode of the input operand.
	6th is the name of the containing source file.
	7th is the source line number. */
	DEF_RTL_EXPR(ASM_OPERANDS, "asm_operands", "ssiEEsi", RTX_EXTRA)
	#endif

	/* A machine-specific operation.
	1st operand is a vector of operands being used by the operation so that
	any needed reloads can be done.
	2nd operand is a unique value saying which of a number of machine-specific
	operations is to be performed.
	(Note that the vector must be the first operand because of the way that
	genrecog.c record positions within an insn.)
	This can occur all by itself in a PATTERN, as a component of a PARALLEL,
	or inside an expression. */
	DEF_RTL_EXPR(UNSPEC, "unspec", "Ei", RTX_EXTRA)

	/* Similar, but a volatile operation and one which may trap. */
	DEF_RTL_EXPR(UNSPEC_VOLATILE, "unspec_volatile", "Ei", RTX_EXTRA)

	/* Vector of addresses, stored as full words. */
	/* Each element is a LABEL_REF to a CODE_LABEL whose address we want. */
	DEF_RTL_EXPR(ADDR_VEC, "addr_vec", "E", RTX_EXTRA)

	/* Vector of address differences X0 - BASE, X1 - BASE, ...
	First operand is BASE; the vector contains the X's.
	The machine mode of this rtx says how much space to leave
	for each difference and is adjusted by branch shortening if
	CASE_VECTOR_SHORTEN_MODE is defined.
	The third and fourth operands store the target labels with the
	minimum and maximum addresses respectively.
	The fifth operand stores flags for use by branch shortening.
	Set at the start of shorten_branches:
	min_align: the minimum alignment for any of the target labels.
	base_after_vec: true iff BASE is after the ADDR_DIFF_VEC.
	min_after_vec: true iff minimum addr target label is after the ADDR_DIFF_VEC.
	max_after_vec: true iff maximum addr target label is after the ADDR_DIFF_VEC.
	min_after_base: true iff minimum address target label is after BASE.
	max_after_base: true iff maximum address target label is after BASE.
	Set by the actual branch shortening process:
	offset_unsigned: true iff offsets have to be treated as unsigned.
	scale: scaling that is necessary to make offsets fit into the mode.

	The third, fourth and fifth operands are only valid when
	CASE_VECTOR_SHORTEN_MODE is defined, and only in an optimizing
	compilations. */

	DEF_RTL_EXPR(ADDR_DIFF_VEC, "addr_diff_vec", "eEee0", RTX_EXTRA)

	/* Memory prefetch, with attributes supported on some targets.
	Operand 1 is the address of the memory to fetch.
	Operand 2 is 1 for a write access, 0 otherwise.
	Operand 3 is the level of temporal locality; 0 means there is no
	temporal locality and 1, 2, and 3 are for increasing levels of temporal
	locality.

	The attributes specified by operands 2 and 3 are ignored for targets
	whose prefetch instructions do not support them. */
	DEF_RTL_EXPR(PREFETCH, "prefetch", "eee", RTX_EXTRA)

	/* ----------------------------------------------------------------------
	At the top level of an instruction (perhaps under PARALLEL).
	---------------------------------------------------------------------- */

	/* Assignment.
	Operand 1 is the location (REG, MEM, PC, CC0 or whatever) assigned to.
	Operand 2 is the value stored there.
	ALL assignment must use SET.
	Instructions that do multiple assignments must use multiple SET,
	under PARALLEL. */
	DEF_RTL_EXPR(SET, "set", "ee", RTX_EXTRA)

	/* Indicate something is used in a way that we don't want to explain.
	For example, subroutine calls will use the register
	in which the static chain is passed. */
	DEF_RTL_EXPR(USE, "use", "e", RTX_EXTRA)

	/* Indicate something is clobbered in a way that we don't want to explain.
	For example, subroutine calls will clobber some physical registers
	(the ones that are by convention not saved). */
	DEF_RTL_EXPR(CLOBBER, "clobber", "e", RTX_EXTRA)

	/* Call a subroutine.
	Operand 1 is the address to call.
	Operand 2 is the number of arguments. */

	DEF_RTL_EXPR(CALL, "call", "ee", RTX_EXTRA)

	/* Return from a subroutine. */

	DEF_RTL_EXPR(RETURN, "return", "", RTX_EXTRA)

	/* Conditional trap.
	Operand 1 is the condition.
	Operand 2 is the trap code.
	For an unconditional trap, make the condition (const_int 1). */
	DEF_RTL_EXPR(TRAP_IF, "trap_if", "ee", RTX_EXTRA)

	/* Placeholder for _Unwind_Resume before we know if a function call
	or a branch is needed. Operand 1 is the exception region from
	which control is flowing. */
	DEF_RTL_EXPR(RESX, "resx", "i", RTX_EXTRA)

	/* ----------------------------------------------------------------------
	Primitive values for use in expressions.
	---------------------------------------------------------------------- */

	/* numeric integer constant */
	DEF_RTL_EXPR(CONST_INT, "const_int", "w", RTX_CONST_OBJ)

	/* numeric floating point constant.
	Operands hold the value. They are all 'w' and there may be from 2 to 6;
	see real.h. */
	DEF_RTL_EXPR(CONST_DOUBLE, "const_double", CONST_DOUBLE_FORMAT, RTX_CONST_OBJ)

	/* Describes a vector constant. */
	DEF_RTL_EXPR(CONST_VECTOR, "const_vector", "E", RTX_CONST_OBJ)

	/* String constant. Used for attributes in machine descriptions and
	for special cases in DWARF2 debug output. NOT used for source-
	language string constants. */
	DEF_RTL_EXPR(CONST_STRING, "const_string", "s", RTX_OBJ)

	/* This is used to encapsulate an expression whose value is constant
	(such as the sum of a SYMBOL_REF and a CONST_INT) so that it will be
	recognized as a constant operand rather than by arithmetic instructions. */

	DEF_RTL_EXPR(CONST, "const", "e", RTX_CONST_OBJ)

	/* program counter. Ordinary jumps are represented
	by a SET whose first operand is (PC). */
	DEF_RTL_EXPR(PC, "pc", "", RTX_OBJ)

	/* Used in the cselib routines to describe a value. Objects of this
	kind are only allocated in cselib.c, in an alloc pool instead of
	in GC memory. The only operand of a VALUE is a cselib_val_struct. */
	DEF_RTL_EXPR(VALUE, "value", "0", RTX_OBJ)

	/* A register. The "operand" is the register number, accessed with
	the REGNO macro. If this number is less than FIRST_PSEUDO_REGISTER
	than a hardware register is being referred to. The second operand
	holds the original register number - this will be different for a
	pseudo register that got turned into a hard register. The third
	operand points to a reg_attrs structure.
	This rtx needs to have as many (or more) fields as a MEM, since we
	can change REG rtx's into MEMs during reload. */
	DEF_RTL_EXPR(REG, "reg", "i00", RTX_OBJ)

	/* A scratch register. This represents a register used only within a
	single insn. It will be turned into a REG during register allocation
	or reload unless the constraint indicates that the register won't be
	needed, in which case it can remain a SCRATCH. This code is
	marked as having one operand so it can be turned into a REG. */
	DEF_RTL_EXPR(SCRATCH, "scratch", "0", RTX_OBJ)

	/* One word of a multi-word value.
	The first operand is the complete value; the second says which word.
	The WORDS_BIG_ENDIAN flag controls whether word number 0
	(as numbered in a SUBREG) is the most or least significant word.

	This is also used to refer to a value in a different machine mode.
	For example, it can be used to refer to a SImode value as if it were
	Qimode, or vice versa. Then the word number is always 0. */
	DEF_RTL_EXPR(SUBREG, "subreg", "ei", RTX_EXTRA)

	/* This one-argument rtx is used for move instructions
	that are guaranteed to alter only the low part of a destination.
	Thus, (SET (SUBREG:HI (REG...)) (MEM:HI ...))
	has an unspecified effect on the high part of REG,
	but (SET (STRICT_LOW_PART (SUBREG:HI (REG...))) (MEM:HI ...))
	is guaranteed to alter only the bits of REG that are in HImode.

	The actual instruction used is probably the same in both cases,
	but the register constraints may be tighter when STRICT_LOW_PART
	is in use. */

	DEF_RTL_EXPR(STRICT_LOW_PART, "strict_low_part", "e", RTX_EXTRA)

	/* (CONCAT a b) represents the virtual concatenation of a and b
	to make a value that has as many bits as a and b put together.
	This is used for complex values. Normally it appears only
	in DECL_RTLs and during RTL generation, but not in the insn chain. */
	DEF_RTL_EXPR(CONCAT, "concat", "ee", RTX_OBJ)

	/* A memory location; operand is the address. The second operand is the
	alias set to which this MEM belongs. We use `0' instead of `w' for this
	field so that the field need not be specified in machine descriptions. */
	DEF_RTL_EXPR(MEM, "mem", "e0", RTX_OBJ)

	/* Reference to an assembler label in the code for this function.
	The operand is a CODE_LABEL found in the insn chain. */
	DEF_RTL_EXPR(LABEL_REF, "label_ref", "u", RTX_CONST_OBJ)

	/* Reference to a named label:
	Operand 0: label name
	Operand 1: flags (see SYMBOL_FLAG_* in rtl.h)
	Operand 2: tree from which this symbol is derived, or null.
	This is either a DECL node, or some kind of constant. */
	DEF_RTL_EXPR(SYMBOL_REF, "symbol_ref", "s00", RTX_CONST_OBJ)

	/* The condition code register is represented, in our imagination,
	as a register holding a value that can be compared to zero.
	In fact, the machine has already compared them and recorded the
	results; but instructions that look at the condition code
	pretend to be looking at the entire value and comparing it. */
	DEF_RTL_EXPR(CC0, "cc0", "", RTX_OBJ)

	/* ----------------------------------------------------------------------
	Expressions for operators in an rtl pattern
	---------------------------------------------------------------------- */

	/* if_then_else. This is used in representing ordinary
	conditional jump instructions.
	Operand:
	0: condition
	1: then expr
	2: else expr */
	DEF_RTL_EXPR(IF_THEN_ELSE, "if_then_else", "eee", RTX_TERNARY)

	/* Comparison, produces a condition code result. */
	DEF_RTL_EXPR(COMPARE, "compare", "ee", RTX_BIN_ARITH)

	/* plus */
	DEF_RTL_EXPR(PLUS, "plus", "ee", RTX_COMM_ARITH)

	/* Operand 0 minus operand 1. */
	DEF_RTL_EXPR(MINUS, "minus", "ee", RTX_BIN_ARITH)

	/* Minus operand 0. */
	DEF_RTL_EXPR(NEG, "neg", "e", RTX_UNARY)

	DEF_RTL_EXPR(MULT, "mult", "ee", RTX_COMM_ARITH)

	/* Operand 0 divided by operand 1. */
	DEF_RTL_EXPR(DIV, "div", "ee", RTX_BIN_ARITH)
	/* Remainder of operand 0 divided by operand 1. */
	DEF_RTL_EXPR(MOD, "mod", "ee", RTX_BIN_ARITH)

	/* Unsigned divide and remainder. */
	DEF_RTL_EXPR(UDIV, "udiv", "ee", RTX_BIN_ARITH)
	DEF_RTL_EXPR(UMOD, "umod", "ee", RTX_BIN_ARITH)

	/* Bitwise operations. */
	DEF_RTL_EXPR(AND, "and", "ee", RTX_COMM_ARITH)
	DEF_RTL_EXPR(IOR, "ior", "ee", RTX_COMM_ARITH)
	DEF_RTL_EXPR(XOR, "xor", "ee", RTX_COMM_ARITH)
	DEF_RTL_EXPR(NOT, "not", "e", RTX_UNARY)

	/* Operand:
	0: value to be shifted.
	1: number of bits. */
	DEF_RTL_EXPR(ASHIFT, "ashift", "ee", RTX_BIN_ARITH) /* shift left */
	DEF_RTL_EXPR(ROTATE, "rotate", "ee", RTX_BIN_ARITH) /* rotate left */
	DEF_RTL_EXPR(ASHIFTRT, "ashiftrt", "ee", RTX_BIN_ARITH) /* arithmetic shift right */
	DEF_RTL_EXPR(LSHIFTRT, "lshiftrt", "ee", RTX_BIN_ARITH) /* logical shift right */
	DEF_RTL_EXPR(ROTATERT, "rotatert", "ee", RTX_BIN_ARITH) /* rotate right */

	/* Minimum and maximum values of two operands. We need both signed and
	unsigned forms. (We cannot use MIN for SMIN because it conflicts
	with a macro of the same name.) The signed variants should be used
	with floating point. Further, if both operands are zeros, or if either
	operand is NaN, then it is unspecified which of the two operands is
	returned as the result. */

	DEF_RTL_EXPR(SMIN, "smin", "ee", RTX_COMM_ARITH)
	DEF_RTL_EXPR(SMAX, "smax", "ee", RTX_COMM_ARITH)
	DEF_RTL_EXPR(UMIN, "umin", "ee", RTX_COMM_ARITH)
	DEF_RTL_EXPR(UMAX, "umax", "ee", RTX_COMM_ARITH)

	/* These unary operations are used to represent incrementation
	and decrementation as they occur in memory addresses.
	The amount of increment or decrement are not represented
	because they can be understood from the machine-mode of the
	containing MEM. These operations exist in only two cases:
	1. pushes onto the stack.
	2. created automatically by the life_analysis pass in flow.c. */
	DEF_RTL_EXPR(PRE_DEC, "pre_dec", "e", RTX_AUTOINC)
	DEF_RTL_EXPR(PRE_INC, "pre_inc", "e", RTX_AUTOINC)
	DEF_RTL_EXPR(POST_DEC, "post_dec", "e", RTX_AUTOINC)
	DEF_RTL_EXPR(POST_INC, "post_inc", "e", RTX_AUTOINC)

	/* These binary operations are used to represent generic address
	side-effects in memory addresses, except for simple incrementation
	or decrementation which use the above operations. They are
	created automatically by the life_analysis pass in flow.c.
	The first operand is a REG which is used as the address.
	The second operand is an expression that is assigned to the
	register, either before (PRE_MODIFY) or after (POST_MODIFY)
	evaluating the address.
	Currently, the compiler can only handle second operands of the
	form (plus (reg) (reg)) and (plus (reg) (const_int)), where
	the first operand of the PLUS has to be the same register as
	the first operand of the _MODIFY. /
	DEF_RTL_EXPR(PRE_MODIFY, "pre_modify", "ee", RTX_AUTOINC)
	DEF_RTL_EXPR(POST_MODIFY, "post_modify", "ee", RTX_AUTOINC)

	/* Comparison operations. The ordered comparisons exist in two
	flavors, signed and unsigned. */
	DEF_RTL_EXPR(NE, "ne", "ee", RTX_COMM_COMPARE)
	DEF_RTL_EXPR(EQ, "eq", "ee", RTX_COMM_COMPARE)
	DEF_RTL_EXPR(GE, "ge", "ee", RTX_COMPARE)
	DEF_RTL_EXPR(GT, "gt", "ee", RTX_COMPARE)
	DEF_RTL_EXPR(LE, "le", "ee", RTX_COMPARE)
	DEF_RTL_EXPR(LT, "lt", "ee", RTX_COMPARE)
	DEF_RTL_EXPR(GEU, "geu", "ee", RTX_COMPARE)
	DEF_RTL_EXPR(GTU, "gtu", "ee", RTX_COMPARE)
	DEF_RTL_EXPR(LEU, "leu", "ee", RTX_COMPARE)
	DEF_RTL_EXPR(LTU, "ltu", "ee", RTX_COMPARE)

	/* Additional floating point unordered comparison flavors. */
	DEF_RTL_EXPR(UNORDERED, "unordered", "ee", RTX_COMM_COMPARE)
	DEF_RTL_EXPR(ORDERED, "ordered", "ee", RTX_COMM_COMPARE)

	/* These are equivalent to unordered or ... */
	DEF_RTL_EXPR(UNEQ, "uneq", "ee", RTX_COMM_COMPARE)
	DEF_RTL_EXPR(UNGE, "unge", "ee", RTX_COMPARE)
	DEF_RTL_EXPR(UNGT, "ungt", "ee", RTX_COMPARE)
	DEF_RTL_EXPR(UNLE, "unle", "ee", RTX_COMPARE)
	DEF_RTL_EXPR(UNLT, "unlt", "ee", RTX_COMPARE)

	/* This is an ordered NE, ie !UNEQ, ie false for NaN. */
	DEF_RTL_EXPR(LTGT, "ltgt", "ee", RTX_COMM_COMPARE)

	/* Represents the result of sign-extending the sole operand.
	The machine modes of the operand and of the SIGN_EXTEND expression
	determine how much sign-extension is going on. */
	DEF_RTL_EXPR(SIGN_EXTEND, "sign_extend", "e", RTX_UNARY)

	/* Similar for zero-extension (such as unsigned short to int). */
	DEF_RTL_EXPR(ZERO_EXTEND, "zero_extend", "e", RTX_UNARY)

	/* Similar but here the operand has a wider mode. */
	DEF_RTL_EXPR(TRUNCATE, "truncate", "e", RTX_UNARY)

	/* Similar for extending floating-point values (such as SFmode to DFmode). */
	DEF_RTL_EXPR(FLOAT_EXTEND, "float_extend", "e", RTX_UNARY)
	DEF_RTL_EXPR(FLOAT_TRUNCATE, "float_truncate", "e", RTX_UNARY)

	/* Conversion of fixed point operand to floating point value. */
	DEF_RTL_EXPR(FLOAT, "float", "e", RTX_UNARY)

	/* With fixed-point machine mode:
	Conversion of floating point operand to fixed point value.
	Value is defined only when the operand's value is an integer.
	With floating-point machine mode (and operand with same mode):
	Operand is rounded toward zero to produce an integer value
	represented in floating point. */
	DEF_RTL_EXPR(FIX, "fix", "e", RTX_UNARY)

	/* Conversion of unsigned fixed point operand to floating point value. */
	DEF_RTL_EXPR(UNSIGNED_FLOAT, "unsigned_float", "e", RTX_UNARY)

	/* With fixed-point machine mode:
	Conversion of floating point operand to unsigned fixed point value.
	Value is defined only when the operand's value is an integer. */
	DEF_RTL_EXPR(UNSIGNED_FIX, "unsigned_fix", "e", RTX_UNARY)

	/* Absolute value */
	DEF_RTL_EXPR(ABS, "abs", "e", RTX_UNARY)

	/* Square root */
	DEF_RTL_EXPR(SQRT, "sqrt", "e", RTX_UNARY)

	/* Swap bytes. */
	DEF_RTL_EXPR(BSWAP, "bswap", "e", RTX_UNARY)

	/* Find first bit that is set.
	Value is 1 + number of trailing zeros in the arg.,
	or 0 if arg is 0. */
	DEF_RTL_EXPR(FFS, "ffs", "e", RTX_UNARY)

	/* Count leading zeros. */
	DEF_RTL_EXPR(CLZ, "clz", "e", RTX_UNARY)

	/* Count trailing zeros. */
	DEF_RTL_EXPR(CTZ, "ctz", "e", RTX_UNARY)

	/* Population count (number of 1 bits). */
	DEF_RTL_EXPR(POPCOUNT, "popcount", "e", RTX_UNARY)

	/* Population parity (number of 1 bits modulo 2). */
	DEF_RTL_EXPR(PARITY, "parity", "e", RTX_UNARY)

	/* Reference to a signed bit-field of specified size and position.
	Operand 0 is the memory unit (usually SImode or QImode) which
	contains the field's first bit. Operand 1 is the width, in bits.
	Operand 2 is the number of bits in the memory unit before the
	first bit of this field.
	If BITS_BIG_ENDIAN is defined, the first bit is the msb and
	operand 2 counts from the msb of the memory unit.
	Otherwise, the first bit is the lsb and operand 2 counts from
	the lsb of the memory unit.
	This kind of expression can not appear as an lvalue in RTL. */
	DEF_RTL_EXPR(SIGN_EXTRACT, "sign_extract", "eee", RTX_BITFIELD_OPS)

	/* Similar for unsigned bit-field.
	But note! This kind of expression _can_ appear as an lvalue. */
	DEF_RTL_EXPR(ZERO_EXTRACT, "zero_extract", "eee", RTX_BITFIELD_OPS)

	/* For RISC machines. These save memory when splitting insns. */

	/* HIGH are the high-order bits of a constant expression. */
	DEF_RTL_EXPR(HIGH, "high", "e", RTX_CONST_OBJ)

	/* LO_SUM is the sum of a register and the low-order bits
	of a constant expression. */
	DEF_RTL_EXPR(LO_SUM, "lo_sum", "ee", RTX_OBJ)

	/* Describes a merge operation between two vector values.
	Operands 0 and 1 are the vectors to be merged, operand 2 is a bitmask
	that specifies where the parts of the result are taken from. Set bits
	indicate operand 0, clear bits indicate operand 1. The parts are defined
	by the mode of the vectors. */
	DEF_RTL_EXPR(VEC_MERGE, "vec_merge", "eee", RTX_TERNARY)

	/* Describes an operation that selects parts of a vector.
	Operands 0 is the source vector, operand 1 is a PARALLEL that contains
	a CONST_INT for each of the subparts of the result vector, giving the
	number of the source subpart that should be stored into it. */
	DEF_RTL_EXPR(VEC_SELECT, "vec_select", "ee", RTX_BIN_ARITH)

	/* Describes a vector concat operation. Operands 0 and 1 are the source
	vectors, the result is a vector that is as long as operands 0 and 1
	combined and is the concatenation of the two source vectors. */
	DEF_RTL_EXPR(VEC_CONCAT, "vec_concat", "ee", RTX_BIN_ARITH)

	/* Describes an operation that converts a small vector into a larger one by
	duplicating the input values. The output vector mode must have the same
	submodes as the input vector mode, and the number of output parts must be
	an integer multiple of the number of input parts. */
	DEF_RTL_EXPR(VEC_DUPLICATE, "vec_duplicate", "e", RTX_UNARY)

	/* Addition with signed saturation */
	DEF_RTL_EXPR(SS_PLUS, "ss_plus", "ee", RTX_COMM_ARITH)

	/* Addition with unsigned saturation */
	DEF_RTL_EXPR(US_PLUS, "us_plus", "ee", RTX_COMM_ARITH)

	/* Operand 0 minus operand 1, with signed saturation. */
	DEF_RTL_EXPR(SS_MINUS, "ss_minus", "ee", RTX_BIN_ARITH)

	/* Negation with signed saturation. */
	DEF_RTL_EXPR(SS_NEG, "ss_neg", "e", RTX_UNARY)

	/* Shift left with signed saturation. */
	DEF_RTL_EXPR(SS_ASHIFT, "ss_ashift", "ee", RTX_BIN_ARITH)

	/* Operand 0 minus operand 1, with unsigned saturation. */
	DEF_RTL_EXPR(US_MINUS, "us_minus", "ee", RTX_BIN_ARITH)

	/* Signed saturating truncate. */
	DEF_RTL_EXPR(SS_TRUNCATE, "ss_truncate", "e", RTX_UNARY)

	/* Unsigned saturating truncate. */
	DEF_RTL_EXPR(US_TRUNCATE, "us_truncate", "e", RTX_UNARY)

	/* Information about the variable and its location. */
	DEF_RTL_EXPR(VAR_LOCATION, "var_location", "te", RTX_EXTRA)

	/* All expressions from this point forward appear only in machine
	descriptions. */
	#ifdef GENERATOR_FILE

	/* Include a secondary machine-description file at this point. */
	DEF_RTL_EXPR(INCLUDE, "include", "s", RTX_EXTRA)

	/* Pattern-matching operators: */

	/* Use the function named by the second arg (the string)
	as a predicate; if matched, store the structure that was matched
	in the operand table at index specified by the first arg (the integer).
	If the second arg is the null string, the structure is just stored.

	A third string argument indicates to the register allocator restrictions
	on where the operand can be allocated.

	If the target needs no restriction on any instruction this field should
	be the null string.

	The string is prepended by:
	'=' to indicate the operand is only written to.
	'+' to indicate the operand is both read and written to.

	Each character in the string represents an allocable class for an operand.
	'g' indicates the operand can be any valid class.
	'i' indicates the operand can be immediate (in the instruction) data.
	'r' indicates the operand can be in a register.
	'm' indicates the operand can be in memory.
	'o' a subset of the 'm' class. Those memory addressing modes that
	can be offset at compile time (have a constant added to them).

	Other characters indicate target dependent operand classes and
	are described in each target's machine description.

	For instructions with more than one operand, sets of classes can be
	separated by a comma to indicate the appropriate multi-operand constraints.
	There must be a 1 to 1 correspondence between these sets of classes in
	all operands for an instruction.
	*/
	DEF_RTL_EXPR(MATCH_OPERAND, "match_operand", "iss", RTX_MATCH)

	/* Match a SCRATCH or a register. When used to generate rtl, a
	SCRATCH is generated. As for MATCH_OPERAND, the mode specifies
	the desired mode and the first argument is the operand number.
	The second argument is the constraint. */
	DEF_RTL_EXPR(MATCH_SCRATCH, "match_scratch", "is", RTX_MATCH)

	/* Apply a predicate, AND match recursively the operands of the rtx.
	Operand 0 is the operand-number, as in match_operand.
	Operand 1 is a predicate to apply (as a string, a function name).
	Operand 2 is a vector of expressions, each of which must match
	one subexpression of the rtx this construct is matching. */
	DEF_RTL_EXPR(MATCH_OPERATOR, "match_operator", "isE", RTX_MATCH)

	/* Match a PARALLEL of arbitrary length. The predicate is applied
	to the PARALLEL and the initial expressions in the PARALLEL are matched.
	Operand 0 is the operand-number, as in match_operand.
	Operand 1 is a predicate to apply to the PARALLEL.
	Operand 2 is a vector of expressions, each of which must match the
	corresponding element in the PARALLEL. */
	DEF_RTL_EXPR(MATCH_PARALLEL, "match_parallel", "isE", RTX_MATCH)

	/* Match only something equal to what is stored in the operand table
	at the index specified by the argument. Use with MATCH_OPERAND. */
	DEF_RTL_EXPR(MATCH_DUP, "match_dup", "i", RTX_MATCH)

	/* Match only something equal to what is stored in the operand table
	at the index specified by the argument. Use with MATCH_OPERATOR. */
	DEF_RTL_EXPR(MATCH_OP_DUP, "match_op_dup", "iE", RTX_MATCH)

	/* Match only something equal to what is stored in the operand table
	at the index specified by the argument. Use with MATCH_PARALLEL. */
	DEF_RTL_EXPR(MATCH_PAR_DUP, "match_par_dup", "iE", RTX_MATCH)

	/* Appears only in define_predicate/define_special_predicate
	expressions. Evaluates true only if the operand has an RTX code
	from the set given by the argument (a comma-separated list). If the
	second argument is present and nonempty, it is a sequence of digits
	and/or letters which indicates the subexpression to test, using the
	same syntax as genextract/genrecog's location strings: 0-9 for
	XEXP (op, n), a-z for XVECEXP (op, 0, n); each character applies to
	the result of the one before it. */
	DEF_RTL_EXPR(MATCH_CODE, "match_code", "ss", RTX_MATCH)

	/* Appears only in define_predicate/define_special_predicate
	expressions. The argument is a C expression to be injected at this
	point in the predicate formula. */
	DEF_RTL_EXPR(MATCH_TEST, "match_test", "s", RTX_MATCH)

	/* Insn (and related) definitions. */

	/* Definition of the pattern for one kind of instruction.
	Operand:
	0: names this instruction.
	If the name is the null string, the instruction is in the
	machine description just to be recognized, and will never be emitted by
	the tree to rtl expander.
	1: is the pattern.
	2: is a string which is a C expression
	giving an additional condition for recognizing this pattern.
	A null string means no extra condition.
	3: is the action to execute if this pattern is matched.
	If this assembler code template starts with a * then it is a fragment of
	C code to run to decide on a template to use. Otherwise, it is the
	template to use.
	4: optionally, a vector of attributes for this insn.
	*/
	DEF_RTL_EXPR(DEFINE_INSN, "define_insn", "sEsTV", RTX_EXTRA)

	/* Definition of a peephole optimization.
	1st operand: vector of insn patterns to match
	2nd operand: C expression that must be true
	3rd operand: template or C code to produce assembler output.
	4: optionally, a vector of attributes for this insn.

	This form is deprecated; use define_peephole2 instead. */
	DEF_RTL_EXPR(DEFINE_PEEPHOLE, "define_peephole", "EsTV", RTX_EXTRA)

	/* Definition of a split operation.
	1st operand: insn pattern to match
	2nd operand: C expression that must be true
	3rd operand: vector of insn patterns to place into a SEQUENCE
	4th operand: optionally, some C code to execute before generating the
	insns. This might, for example, create some RTX's and store them in
	elements of `recog_data.operand' for use by the vector of
	insn-patterns.
	(`operands' is an alias here for `recog_data.operand'). */
	DEF_RTL_EXPR(DEFINE_SPLIT, "define_split", "EsES", RTX_EXTRA)

	/* Definition of an insn and associated split.
	This is the concatenation, with a few modifications, of a define_insn
	and a define_split which share the same pattern.
	Operand:
	0: names this instruction.
	If the name is the null string, the instruction is in the
	machine description just to be recognized, and will never be emitted by
	the tree to rtl expander.
	1: is the pattern.
	2: is a string which is a C expression
	giving an additional condition for recognizing this pattern.
	A null string means no extra condition.
	3: is the action to execute if this pattern is matched.
	If this assembler code template starts with a * then it is a fragment of
	C code to run to decide on a template to use. Otherwise, it is the
	template to use.
	4: C expression that must be true for split. This may start with "&&"
	in which case the split condition is the logical and of the insn
	condition and what follows the "&&" of this operand.
	5: vector of insn patterns to place into a SEQUENCE
	6: optionally, some C code to execute before generating the
	insns. This might, for example, create some RTX's and store them in
	elements of `recog_data.operand' for use by the vector of
	insn-patterns.
	(`operands' is an alias here for `recog_data.operand').
	7: optionally, a vector of attributes for this insn. */
	DEF_RTL_EXPR(DEFINE_INSN_AND_SPLIT, "define_insn_and_split", "sEsTsESV", RTX_EXTRA)

	/* Definition of an RTL peephole operation.
	Follows the same arguments as define_split. */
	DEF_RTL_EXPR(DEFINE_PEEPHOLE2, "define_peephole2", "EsES", RTX_EXTRA)

	/* Define how to generate multiple insns for a standard insn name.
	1st operand: the insn name.
	2nd operand: vector of insn-patterns.
	Use match_operand to substitute an element of `recog_data.operand'.
	3rd operand: C expression that must be true for this to be available.
	This may not test any operands.
	4th operand: Extra C code to execute before generating the insns.
	This might, for example, create some RTX's and store them in
	elements of `recog_data.operand' for use by the vector of
	insn-patterns.
	(`operands' is an alias here for `recog_data.operand'). */
	DEF_RTL_EXPR(DEFINE_EXPAND, "define_expand", "sEss", RTX_EXTRA)

	/* Define a requirement for delay slots.
	1st operand: Condition involving insn attributes that, if true,
	indicates that the insn requires the number of delay slots
	shown.
	2nd operand: Vector whose length is the three times the number of delay
	slots required.
	Each entry gives three conditions, each involving attributes.
	The first must be true for an insn to occupy that delay slot
	location. The second is true for all insns that can be
	annulled if the branch is true and the third is true for all
	insns that can be annulled if the branch is false.

	Multiple DEFINE_DELAYs may be present. They indicate differing
	requirements for delay slots. */
	DEF_RTL_EXPR(DEFINE_DELAY, "define_delay", "eE", RTX_EXTRA)

	/* Define attribute computation for `asm' instructions. */
	DEF_RTL_EXPR(DEFINE_ASM_ATTRIBUTES, "define_asm_attributes", "V", RTX_EXTRA)

	/* Definition of a conditional execution meta operation. Automatically
	generates new instances of DEFINE_INSN, selected by having attribute
	"predicable" true. The new pattern will contain a COND_EXEC and the
	predicate at top-level.

	Operand:
	0: The predicate pattern. The top-level form should match a
	relational operator. Operands should have only one alternative.
	1: A C expression giving an additional condition for recognizing
	the generated pattern.
	2: A template or C code to produce assembler output. */
	DEF_RTL_EXPR(DEFINE_COND_EXEC, "define_cond_exec", "Ess", RTX_EXTRA)

	/* Definition of an operand predicate. The difference between
	DEFINE_PREDICATE and DEFINE_SPECIAL_PREDICATE is that genrecog will
	not warn about a match_operand with no mode if it has a predicate
	defined with DEFINE_SPECIAL_PREDICATE.

	Operand:
	0: The name of the predicate.
	1: A boolean expression which computes whether or not the predicate
	matches. This expression can use IOR, AND, NOT, MATCH_OPERAND,
	MATCH_CODE, and MATCH_TEST. It must be specific enough that genrecog
	can calculate the set of RTX codes that can possibly match.
	2: A C function body which must return true for the predicate to match.
	Optional. Use this when the test is too complicated to fit into a
	match_test expression. */
	DEF_RTL_EXPR(DEFINE_PREDICATE, "define_predicate", "ses", RTX_EXTRA)
	DEF_RTL_EXPR(DEFINE_SPECIAL_PREDICATE, "define_special_predicate", "ses", RTX_EXTRA)

	/* Definition of a register operand constraint. This simply maps the
	constraint string to a register class.

	Operand:
	0: The name of the constraint (often, but not always, a single letter).
	1: A C expression which evaluates to the appropriate register class for
	this constraint. If this is not just a constant, it should look only
	at -m switches and the like.
	2: A docstring for this constraint, in Texinfo syntax; not currently
	used, in future will be incorporated into the manual's list of
	machine-specific operand constraints. */
	DEF_RTL_EXPR(DEFINE_REGISTER_CONSTRAINT, "define_register_constraint", "sss", RTX_EXTRA)

	/* Definition of a non-register operand constraint. These look at the
	operand and decide whether it fits the constraint.

	DEFINE_CONSTRAINT gets no special treatment if it fails to match.
	It is appropriate for constant-only constraints, and most others.

	DEFINE_MEMORY_CONSTRAINT tells reload that this constraint can be made
	to match, if it doesn't already, by converting the operand to the form
	(mem (reg X)) where X is a base register. It is suitable for constraints
	that describe a subset of all memory references.

	DEFINE_ADDRESS_CONSTRAINT tells reload that this constraint can be made
	to match, if it doesn't already, by converting the operand to the form
	(reg X) where X is a base register. It is suitable for constraints that
	describe a subset of all address references.

	When in doubt, use plain DEFINE_CONSTRAINT.

	Operand:
	0: The name of the constraint (often, but not always, a single letter).
	1: A docstring for this constraint, in Texinfo syntax; not currently
	used, in future will be incorporated into the manual's list of
	machine-specific operand constraints.
	2: A boolean expression which computes whether or not the constraint
	matches. It should follow the same rules as a define_predicate
	expression, including the bit about specifying the set of RTX codes
	that could possibly match. MATCH_TEST subexpressions may make use of
	these variables:
	`op' - the RTL object defining the operand.
	`mode' - the mode of `op'.
	`ival' - INTVAL(op), if op is a CONST_INT.
	`hval' - CONST_DOUBLE_HIGH(op), if op is an integer CONST_DOUBLE.
	`lval' - CONST_DOUBLE_LOW(op), if op is an integer CONST_DOUBLE.
	`rval' - CONST_DOUBLE_REAL_VALUE(op), if op is a floating-point
	CONST_DOUBLE.
	Do not use ival/hval/lval/rval if op is not the appropriate kind of
	RTL object. */
	DEF_RTL_EXPR(DEFINE_CONSTRAINT, "define_constraint", "sse", RTX_EXTRA)
	DEF_RTL_EXPR(DEFINE_MEMORY_CONSTRAINT, "define_memory_constraint", "sse", RTX_EXTRA)
	DEF_RTL_EXPR(DEFINE_ADDRESS_CONSTRAINT, "define_address_constraint", "sse", RTX_EXTRA)


	/* Constructions for CPU pipeline description described by NDFAs. */

	/* (define_cpu_unit string [string]) describes cpu functional
	units (separated by comma).

	1st operand: Names of cpu functional units.
	2nd operand: Name of automaton (see comments for DEFINE_AUTOMATON).

	All define_reservations, define_cpu_units, and
	define_query_cpu_units should have unique names which may not be
	"nothing". */
	DEF_RTL_EXPR(DEFINE_CPU_UNIT, "define_cpu_unit", "sS", RTX_EXTRA)

	/* (define_query_cpu_unit string [string]) describes cpu functional
	units analogously to define_cpu_unit. The reservation of such
	units can be queried for automaton state. */
	DEF_RTL_EXPR(DEFINE_QUERY_CPU_UNIT, "define_query_cpu_unit", "sS", RTX_EXTRA)

	/* (exclusion_set string string) means that each CPU functional unit
	in the first string can not be reserved simultaneously with any
	unit whose name is in the second string and vise versa. CPU units
	in the string are separated by commas. For example, it is useful
	for description CPU with fully pipelined floating point functional
	unit which can execute simultaneously only single floating point
	insns or only double floating point insns. All CPU functional
	units in a set should belong to the same automaton. */
	DEF_RTL_EXPR(EXCLUSION_SET, "exclusion_set", "ss", RTX_EXTRA)

	/* (presence_set string string) means that each CPU functional unit in
	the first string can not be reserved unless at least one of pattern
	of units whose names are in the second string is reserved. This is
	an asymmetric relation. CPU units or unit patterns in the strings
	are separated by commas. Pattern is one unit name or unit names
	separated by white-spaces.

	For example, it is useful for description that slot1 is reserved
	after slot0 reservation for a VLIW processor. We could describe it
	by the following construction

	(presence_set "slot1" "slot0")

	Or slot1 is reserved only after slot0 and unit b0 reservation. In
	this case we could write

	(presence_set "slot1" "slot0 b0")

	All CPU functional units in a set should belong to the same
	automaton. */
	DEF_RTL_EXPR(PRESENCE_SET, "presence_set", "ss", RTX_EXTRA)

	/* (final_presence_set string string) is analogous to `presence_set'.
	The difference between them is when checking is done. When an
	instruction is issued in given automaton state reflecting all
	current and planned unit reservations, the automaton state is
	changed. The first state is a source state, the second one is a
	result state. Checking for `presence_set' is done on the source
	state reservation, checking for `final_presence_set' is done on the
	result reservation. This construction is useful to describe a
	reservation which is actually two subsequent reservations. For
	example, if we use

	(presence_set "slot1" "slot0")

	the following insn will be never issued (because slot1 requires
	slot0 which is absent in the source state).

	(define_reservation "insn_and_nop" "slot0 + slot1")

	but it can be issued if we use analogous `final_presence_set'. */
	DEF_RTL_EXPR(FINAL_PRESENCE_SET, "final_presence_set", "ss", RTX_EXTRA)

	/* (absence_set string string) means that each CPU functional unit in
	the first string can be reserved only if each pattern of units
	whose names are in the second string is not reserved. This is an
	asymmetric relation (actually exclusion set is analogous to this
	one but it is symmetric). CPU units or unit patterns in the string
	are separated by commas. Pattern is one unit name or unit names
	separated by white-spaces.

	For example, it is useful for description that slot0 can not be
	reserved after slot1 or slot2 reservation for a VLIW processor. We
	could describe it by the following construction

	(absence_set "slot2" "slot0, slot1")

	Or slot2 can not be reserved if slot0 and unit b0 are reserved or
	slot1 and unit b1 are reserved . In this case we could write

	(absence_set "slot2" "slot0 b0, slot1 b1")

	All CPU functional units in a set should to belong the same
	automaton. */
	DEF_RTL_EXPR(ABSENCE_SET, "absence_set", "ss", RTX_EXTRA)

	/* (final_absence_set string string) is analogous to `absence_set' but
	checking is done on the result (state) reservation. See comments
	for `final_presence_set'. */
	DEF_RTL_EXPR(FINAL_ABSENCE_SET, "final_absence_set", "ss", RTX_EXTRA)

	/* (define_bypass number out_insn_names in_insn_names) names bypass
	with given latency (the first number) from insns given by the first
	string (see define_insn_reservation) into insns given by the second
	string. Insn names in the strings are separated by commas. The
	third operand is optional name of function which is additional
	guard for the bypass. The function will get the two insns as
	parameters. If the function returns zero the bypass will be
	ignored for this case. Additional guard is necessary to recognize
	complicated bypasses, e.g. when consumer is load address. */
	DEF_RTL_EXPR(DEFINE_BYPASS, "define_bypass", "issS", RTX_EXTRA)

	/* (define_automaton string) describes names of automata generated and
	used for pipeline hazards recognition. The names are separated by
	comma. Actually it is possibly to generate the single automaton
	but unfortunately it can be very large. If we use more one
	automata, the summary size of the automata usually is less than the
	single one. The automaton name is used in define_cpu_unit and
	define_query_cpu_unit. All automata should have unique names. */
	DEF_RTL_EXPR(DEFINE_AUTOMATON, "define_automaton", "s", RTX_EXTRA)

	/* (automata_option string) describes option for generation of
	automata. Currently there are the following options:

	o "no-minimization" which makes no minimization of automata. This
	is only worth to do when we are debugging the description and
	need to look more accurately at reservations of states.

	o "time" which means printing additional time statistics about
	generation of automata.

	o "v" which means generation of file describing the result
	automata. The file has suffix `.dfa' and can be used for the
	description verification and debugging.

	o "w" which means generation of warning instead of error for
	non-critical errors.

	o "ndfa" which makes nondeterministic finite state automata.

	o "progress" which means output of a progress bar showing how many
	states were generated so far for automaton being processed. */
	DEF_RTL_EXPR(AUTOMATA_OPTION, "automata_option", "s", RTX_EXTRA)

	/* (define_reservation string string) names reservation (the first
	string) of cpu functional units (the 2nd string). Sometimes unit
	reservations for different insns contain common parts. In such
	case, you can describe common part and use its name (the 1st
	parameter) in regular expression in define_insn_reservation. All
	define_reservations, define_cpu_units, and define_query_cpu_units
	should have unique names which may not be "nothing". */
	DEF_RTL_EXPR(DEFINE_RESERVATION, "define_reservation", "ss", RTX_EXTRA)

	/* (define_insn_reservation name default_latency condition regexpr)
	describes reservation of cpu functional units (the 3nd operand) for
	instruction which is selected by the condition (the 2nd parameter).
	The first parameter is used for output of debugging information.
	The reservations are described by a regular expression according
	the following syntax:

	regexp = regexp "," oneof
	\| oneof

	oneof = oneof "\|" allof
	\| allof

	allof = allof "+" repeat
	\| repeat

	repeat = element "*" number
	\| element

	element = cpu_function_unit_name
	\| reservation_name
	\| result_name
	\| "nothing"
	\| "(" regexp ")"

	1. "," is used for describing start of the next cycle in
	reservation.

	2. "\|" is used for describing the reservation described by the
	first regular expression or the reservation described by the
	second regular expression or etc.

	3. "+" is used for describing the reservation described by the
	first regular expression and the reservation described by the
	second regular expression and etc.

	4. "*" is used for convenience and simply means sequence in
	which the regular expression are repeated NUMBER times with
	cycle advancing (see ",").

	5. cpu functional unit name which means its reservation.

	6. reservation name -- see define_reservation.

	7. string "nothing" means no units reservation. */

	DEF_RTL_EXPR(DEFINE_INSN_RESERVATION, "define_insn_reservation", "sies", RTX_EXTRA)

	/* Expressions used for insn attributes. */

	/* Definition of an insn attribute.
	1st operand: name of the attribute
	2nd operand: comma-separated list of possible attribute values
	3rd operand: expression for the default value of the attribute. */
	DEF_RTL_EXPR(DEFINE_ATTR, "define_attr", "sse", RTX_EXTRA)

	/* Marker for the name of an attribute. */
	DEF_RTL_EXPR(ATTR, "attr", "s", RTX_EXTRA)

	/* For use in the last (optional) operand of DEFINE_INSN or DEFINE_PEEPHOLE and
	in DEFINE_ASM_INSN to specify an attribute to assign to insns matching that
	pattern.

	(set_attr "name" "value") is equivalent to
	(set (attr "name") (const_string "value")) */
	DEF_RTL_EXPR(SET_ATTR, "set_attr", "ss", RTX_EXTRA)

	/* In the last operand of DEFINE_INSN and DEFINE_PEEPHOLE, this can be used to
	specify that attribute values are to be assigned according to the
	alternative matched.

	The following three expressions are equivalent:

	(set (attr "att") (cond [(eq_attrq "alternative" "1") (const_string "a1")
	(eq_attrq "alternative" "2") (const_string "a2")]
	(const_string "a3")))
	(set_attr_alternative "att" [(const_string "a1") (const_string "a2")
	(const_string "a3")])
	(set_attr "att" "a1,a2,a3")
	*/
	DEF_RTL_EXPR(SET_ATTR_ALTERNATIVE, "set_attr_alternative", "sE", RTX_EXTRA)

	/* A conditional expression true if the value of the specified attribute of
	the current insn equals the specified value. The first operand is the
	attribute name and the second is the comparison value. */
	DEF_RTL_EXPR(EQ_ATTR, "eq_attr", "ss", RTX_EXTRA)

	/* A special case of the above representing a set of alternatives. The first
	operand is bitmap of the set, the second one is the default value. */
	DEF_RTL_EXPR(EQ_ATTR_ALT, "eq_attr_alt", "ii", RTX_EXTRA)

	/* A conditional expression which is true if the specified flag is
	true for the insn being scheduled in reorg.

	genattr.c defines the following flags which can be tested by
	(attr_flag "foo") expressions in eligible_for_delay.

	forward, backward, very_likely, likely, very_unlikely, and unlikely. */

	DEF_RTL_EXPR (ATTR_FLAG, "attr_flag", "s", RTX_EXTRA)

	/* General conditional. The first operand is a vector composed of pairs of
	expressions. The first element of each pair is evaluated, in turn.
	The value of the conditional is the second expression of the first pair
	whose first expression evaluates nonzero. If none of the expressions is
	true, the second operand will be used as the value of the conditional. */
	DEF_RTL_EXPR(COND, "cond", "Ee", RTX_EXTRA)

	#endif /* GENERATOR_FILE */

	/*
	Local variables:
	mode:c
	End:
	*/
	diff --git a/contrib/gcc/rtl.h b/contrib/gcc/rtl.h
	index 57de5165f268..b92d53ca6be3 100644
	--- a/contrib/gcc/rtl.h
	+++ b/contrib/gcc/rtl.h
	@@ -1,2299 +1,2308 @@
	/* Register Transfer Language (RTL) definitions for GCC
	Copyright (C) 1987, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
	2000, 2001, 2002, 2003, 2004, 2005, 2006 Free Software Foundation, Inc.

	This file is part of GCC.

	GCC is free software; you can redistribute it and/or modify it under
	the terms of the GNU General Public License as published by the Free
	Software Foundation; either version 2, or (at your option) any later
	version.

	GCC is distributed in the hope that it will be useful, but WITHOUT ANY
	WARRANTY; without even the implied warranty of MERCHANTABILITY or
	FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	for more details.

	You should have received a copy of the GNU General Public License
	along with GCC; see the file COPYING. If not, write to the Free
	Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
	02110-1301, USA. */

	#ifndef GCC_RTL_H
	#define GCC_RTL_H

	#include <sys/param.h>
	#ifndef __PAST_END
	# define __PAST_END(array, offset) (((typeof((array)) )(array))[offset])
	#endif

	#include "statistics.h"
	#include "machmode.h"
	#include "input.h"
	#include "real.h"
	#include "vec.h"

	#undef FFS /* Some systems predefine this symbol; don't let it interfere. */
	#undef FLOAT /* Likewise. */
	#undef ABS /* Likewise. */
	#undef PC /* Likewise. */

	/* Value used by some passes to "recognize" noop moves as valid
	instructions. */
	#define NOOP_MOVE_INSN_CODE INT_MAX

	/* Register Transfer Language EXPRESSIONS CODES */

	#define RTX_CODE enum rtx_code
	enum rtx_code {

	#define DEF_RTL_EXPR(ENUM, NAME, FORMAT, CLASS) ENUM ,
	#include "rtl.def" /* rtl expressions are documented here */
	#undef DEF_RTL_EXPR

	LAST_AND_UNUSED_RTX_CODE}; /* A convenient way to get a value for
	NUM_RTX_CODE.
	Assumes default enum value assignment. */

	#define NUM_RTX_CODE ((int) LAST_AND_UNUSED_RTX_CODE)
	/* The cast here, saves many elsewhere. */

	/* Register Transfer Language EXPRESSIONS CODE CLASSES */

	enum rtx_class {
	/* We check bit 0-1 of some rtx class codes in the predicates below. */

	/* Bit 0 = comparison if 0, arithmetic is 1
	Bit 1 = 1 if commutative. */
	RTX_COMPARE, /* 0 */
	RTX_COMM_COMPARE,
	RTX_BIN_ARITH,
	RTX_COMM_ARITH,

	/* Must follow the four preceding values. */
	RTX_UNARY, /* 4 */

	RTX_EXTRA,
	RTX_MATCH,
	RTX_INSN,

	/* Bit 0 = 1 if constant. */
	RTX_OBJ, /* 8 */
	RTX_CONST_OBJ,

	RTX_TERNARY,
	RTX_BITFIELD_OPS,
	RTX_AUTOINC
	};

	#define RTX_OBJ_MASK (~1)
	#define RTX_OBJ_RESULT (RTX_OBJ & RTX_OBJ_MASK)
	#define RTX_COMPARE_MASK (~1)
	#define RTX_COMPARE_RESULT (RTX_COMPARE & RTX_COMPARE_MASK)
	#define RTX_ARITHMETIC_MASK (~1)
	#define RTX_ARITHMETIC_RESULT (RTX_COMM_ARITH & RTX_ARITHMETIC_MASK)
	#define RTX_BINARY_MASK (~3)
	#define RTX_BINARY_RESULT (RTX_COMPARE & RTX_BINARY_MASK)
	#define RTX_COMMUTATIVE_MASK (~2)
	#define RTX_COMMUTATIVE_RESULT (RTX_COMM_COMPARE & RTX_COMMUTATIVE_MASK)
	#define RTX_NON_COMMUTATIVE_RESULT (RTX_COMPARE & RTX_COMMUTATIVE_MASK)

	extern const unsigned char rtx_length[NUM_RTX_CODE];
	#define GET_RTX_LENGTH(CODE) (rtx_length[(int) (CODE)])

	extern const char * const rtx_name[NUM_RTX_CODE];
	#define GET_RTX_NAME(CODE) (rtx_name[(int) (CODE)])

	extern const char * const rtx_format[NUM_RTX_CODE];
	#define GET_RTX_FORMAT(CODE) (rtx_format[(int) (CODE)])

	extern const enum rtx_class rtx_class[NUM_RTX_CODE];
	#define GET_RTX_CLASS(CODE) (rtx_class[(int) (CODE)])

	extern const unsigned char rtx_code_size[NUM_RTX_CODE];
	extern const unsigned char rtx_next[NUM_RTX_CODE];

	/* The flags and bitfields of an ADDR_DIFF_VEC. BASE is the base label
	relative to which the offsets are calculated, as explained in rtl.def. */
	typedef struct
	{
	/* Set at the start of shorten_branches - ONLY WHEN OPTIMIZING - : */
	unsigned min_align: 8;
	/* Flags: */
	unsigned base_after_vec: 1; /* BASE is after the ADDR_DIFF_VEC. */
	unsigned min_after_vec: 1; /* minimum address target label is
	after the ADDR_DIFF_VEC. */
	unsigned max_after_vec: 1; /* maximum address target label is
	after the ADDR_DIFF_VEC. */
	unsigned min_after_base: 1; /* minimum address target label is
	after BASE. */
	unsigned max_after_base: 1; /* maximum address target label is
	after BASE. */
	/* Set by the actual branch shortening process - ONLY WHEN OPTIMIZING - : */
	unsigned offset_unsigned: 1; /* offsets have to be treated as unsigned. */
	unsigned : 2;
	unsigned scale : 8;
	} addr_diff_vec_flags;

	/* Structure used to describe the attributes of a MEM. These are hashed
	so MEMs that the same attributes share a data structure. This means
	they cannot be modified in place. If any element is nonzero, it means
	the value of the corresponding attribute is unknown. */
	/* ALIGN and SIZE are the alignment and size of the MEM itself,
	while EXPR can describe a larger underlying object, which might have a
	stricter alignment; OFFSET is the offset of the MEM within that object. */
	typedef struct mem_attrs GTY(())
	{
	HOST_WIDE_INT alias; /* Memory alias set. */
	tree expr; /* expr corresponding to MEM. */
	rtx offset; /* Offset from start of DECL, as CONST_INT. */
	rtx size; /* Size in bytes, as a CONST_INT. */
	unsigned int align; /* Alignment of MEM in bits. */
	} mem_attrs;

	/* Structure used to describe the attributes of a REG in similar way as
	mem_attrs does for MEM above. */

	typedef struct reg_attrs GTY(())
	{
	tree decl; /* decl corresponding to REG. */
	HOST_WIDE_INT offset; /* Offset from start of DECL. */
	} reg_attrs;

	/* Common union for an element of an rtx. */

	union rtunion_def
	{
	int rt_int;
	unsigned int rt_uint;
	const char *rt_str;
	rtx rt_rtx;
	rtvec rt_rtvec;
	enum machine_mode rt_type;
	addr_diff_vec_flags rt_addr_diff_vec_flags;
	struct cselib_val_struct *rt_cselib;
	struct bitmap_head_def *rt_bit;
	tree rt_tree;
	struct basic_block_def *rt_bb;
	mem_attrs *rt_mem;
	reg_attrs *rt_reg;
	struct constant_descriptor_rtx *rt_constant;
	};
	typedef union rtunion_def rtunion;

	/* This structure remembers the position of a SYMBOL_REF within an
	object_block structure. A SYMBOL_REF only provides this information
	if SYMBOL_REF_HAS_BLOCK_INFO_P is true. */
	struct block_symbol GTY(()) {
	/* The usual SYMBOL_REF fields. */
	rtunion GTY ((skip)) fld[3];

	/* The block that contains this object. */
	struct object_block *block;

	/* The offset of this object from the start of its block. It is negative
	if the symbol has not yet been assigned an offset. */
	HOST_WIDE_INT offset;
	};

	DEF_VEC_P(rtx);
	DEF_VEC_ALLOC_P(rtx,heap);
	DEF_VEC_ALLOC_P(rtx,gc);

	/* Describes a group of objects that are to be placed together in such
	a way that their relative positions are known. */
	struct object_block GTY(())
	{
	/* The section in which these objects should be placed. */
	section *sect;

	/* The alignment of the first object, measured in bits. */
	unsigned int alignment;

	/* The total size of the objects, measured in bytes. */
	HOST_WIDE_INT size;

	/* The SYMBOL_REFs for each object. The vector is sorted in
	order of increasing offset and the following conditions will
	hold for each element X:

	SYMBOL_REF_HAS_BLOCK_INFO_P (X)
	!SYMBOL_REF_ANCHOR_P (X)
	SYMBOL_REF_BLOCK (X) == [address of this structure]
	SYMBOL_REF_BLOCK_OFFSET (X) >= 0. */
	VEC(rtx,gc) *objects;

	/* All the anchor SYMBOL_REFs used to address these objects, sorted
	in order of increasing offset, and then increasing TLS model.
	The following conditions will hold for each element X in this vector:

	SYMBOL_REF_HAS_BLOCK_INFO_P (X)
	SYMBOL_REF_ANCHOR_P (X)
	SYMBOL_REF_BLOCK (X) == [address of this structure]
	SYMBOL_REF_BLOCK_OFFSET (X) >= 0. */
	VEC(rtx,gc) *anchors;
	};

	/* RTL expression ("rtx"). */

	struct rtx_def GTY((chain_next ("RTX_NEXT (&%h)"),
	chain_prev ("RTX_PREV (&%h)")))
	{
	/* The kind of expression this is. */
	ENUM_BITFIELD(rtx_code) code: 16;

	/* The kind of value the expression has. */
	ENUM_BITFIELD(machine_mode) mode : 8;

	/* 1 in a MEM if we should keep the alias set for this mem unchanged
	when we access a component.
	1 in a CALL_INSN if it is a sibling call.
	1 in a SET that is for a return.
	In a CODE_LABEL, part of the two-bit alternate entry field. */
	unsigned int jump : 1;
	/* In a CODE_LABEL, part of the two-bit alternate entry field.
	1 in a MEM if it cannot trap. */
	unsigned int call : 1;
	/* 1 in a REG, MEM, or CONCAT if the value is set at most once, anywhere.
	1 in a SUBREG if it references an unsigned object whose mode has been
	from a promoted to a wider mode.
	1 in a SYMBOL_REF if it addresses something in the per-function
	constants pool.
	1 in a CALL_INSN, NOTE, or EXPR_LIST for a const or pure call.
	1 in a JUMP_INSN, CALL_INSN, or INSN of an annulling branch. */
	unsigned int unchanging : 1;
	/* 1 in a MEM or ASM_OPERANDS expression if the memory reference is volatile.
	1 in an INSN, CALL_INSN, JUMP_INSN, CODE_LABEL, BARRIER, or NOTE
	if it has been deleted.
	1 in a REG expression if corresponds to a variable declared by the user,
	0 for an internally generated temporary.
	1 in a SUBREG with a negative value.
	1 in a LABEL_REF or in a REG_LABEL note for a non-local label.
	In a SYMBOL_REF, this flag is used for machine-specific purposes. */
	unsigned int volatil : 1;
	/* 1 in a MEM referring to a field of an aggregate.
	0 if the MEM was a variable or the result of a * operator in C;
	1 if it was the result of a . or -> operator (on a struct) in C.
	1 in a REG if the register is used only in exit code a loop.
	1 in a SUBREG expression if was generated from a variable with a
	promoted mode.
	1 in a CODE_LABEL if the label is used for nonlocal gotos
	and must not be deleted even if its count is zero.
	1 in an INSN, JUMP_INSN or CALL_INSN if this insn must be scheduled
	together with the preceding insn. Valid only within sched.
	1 in an INSN, JUMP_INSN, or CALL_INSN if insn is in a delay slot and
	from the target of a branch. Valid from reorg until end of compilation;
	cleared before used. */
	unsigned int in_struct : 1;
	/* At the end of RTL generation, 1 if this rtx is used. This is used for
	copying shared structure. See `unshare_all_rtl'.
	In a REG, this is not needed for that purpose, and used instead
	in `leaf_renumber_regs_insn'.
	1 in a SYMBOL_REF, means that emit_library_call
	has used it as the function. */
	unsigned int used : 1;
	/* 1 in an INSN or a SET if this rtx is related to the call frame,
	either changing how we compute the frame address or saving and
	restoring registers in the prologue and epilogue.
	1 in a REG or MEM if it is a pointer.
	1 in a SYMBOL_REF if it addresses something in the per-function
	constant string pool. */
	unsigned frame_related : 1;
	/* 1 in a REG or PARALLEL that is the current function's return value.
	1 in a MEM if it refers to a scalar.
	1 in a SYMBOL_REF for a weak symbol. */
	unsigned return_val : 1;

	/* The first element of the operands of this rtx.
	The number of operands and their types are controlled
	by the `code' field, according to rtl.def. */
	union u {
	rtunion fld[1];
	HOST_WIDE_INT hwint[1];
	struct block_symbol block_sym;
	struct real_value rv;
	} GTY ((special ("rtx_def"), desc ("GET_CODE (&%0)"))) u;
	};

	/* The size in bytes of an rtx header (code, mode and flags). */
	#define RTX_HDR_SIZE offsetof (struct rtx_def, u)

	/* The size in bytes of an rtx with code CODE. */
	#define RTX_CODE_SIZE(CODE) rtx_code_size[CODE]

	#define NULL_RTX (rtx) 0

	/* The "next" and "previous" RTX, relative to this one. */

	#define RTX_NEXT(X) (rtx_next[GET_CODE (X)] == 0 ? NULL \
	: (rtx )(((char *)X) + rtx_next[GET_CODE (X)]))

	/* FIXME: the "NEXT_INSN (PREV_INSN (X)) == X" condition shouldn't be needed.
	*/
	#define RTX_PREV(X) ((INSN_P (X) \
	\|\| NOTE_P (X) \
	\|\| BARRIER_P (X) \
	\|\| LABEL_P (X)) \
	&& PREV_INSN (X) != NULL \
	&& NEXT_INSN (PREV_INSN (X)) == X \
	? PREV_INSN (X) : NULL)

	/* Define macros to access the `code' field of the rtx. */

	#define GET_CODE(RTX) ((enum rtx_code) (RTX)->code)
	#define PUT_CODE(RTX, CODE) ((RTX)->code = (CODE))

	#define GET_MODE(RTX) ((enum machine_mode) (RTX)->mode)
	#define PUT_MODE(RTX, MODE) ((RTX)->mode = (MODE))

	/* RTL vector. These appear inside RTX's when there is a need
	for a variable number of things. The principle use is inside
	PARALLEL expressions. */

	struct rtvec_def GTY(()) {
	int num_elem; /* number of elements */
	rtx GTY ((length ("%h.num_elem"))) elem[1];
	};

	#define NULL_RTVEC (rtvec) 0

	#define GET_NUM_ELEM(RTVEC) ((RTVEC)->num_elem)
	#define PUT_NUM_ELEM(RTVEC, NUM) ((RTVEC)->num_elem = (NUM))

	/* Predicate yielding nonzero iff X is an rtx for a register. */
	#define REG_P(X) (GET_CODE (X) == REG)

	/* Predicate yielding nonzero iff X is an rtx for a memory location. */
	#define MEM_P(X) (GET_CODE (X) == MEM)

	/* Predicate yielding nonzero iff X is an rtx for a constant integer. */
	#define CONST_INT_P(X) (GET_CODE (X) == CONST_INT)

	/* Predicate yielding nonzero iff X is a label insn. */
	#define LABEL_P(X) (GET_CODE (X) == CODE_LABEL)

	/* Predicate yielding nonzero iff X is a jump insn. */
	#define JUMP_P(X) (GET_CODE (X) == JUMP_INSN)

	/* Predicate yielding nonzero iff X is a call insn. */
	#define CALL_P(X) (GET_CODE (X) == CALL_INSN)

	/* Predicate yielding nonzero iff X is an insn that cannot jump. */
	#define NONJUMP_INSN_P(X) (GET_CODE (X) == INSN)

	/* Predicate yielding nonzero iff X is a real insn. */
	#define INSN_P(X) \
	(NONJUMP_INSN_P (X) \|\| JUMP_P (X) \|\| CALL_P (X))

	/* Predicate yielding nonzero iff X is a note insn. */
	#define NOTE_P(X) (GET_CODE (X) == NOTE)

	/* Predicate yielding nonzero iff X is a barrier insn. */
	#define BARRIER_P(X) (GET_CODE (X) == BARRIER)

	/* Predicate yielding nonzero iff X is a data for a jump table. */
	#define JUMP_TABLE_DATA_P(INSN) \
	(JUMP_P (INSN) && (GET_CODE (PATTERN (INSN)) == ADDR_VEC \|\| \
	GET_CODE (PATTERN (INSN)) == ADDR_DIFF_VEC))

	/* 1 if X is a unary operator. */

	#define UNARY_P(X) \
	(GET_RTX_CLASS (GET_CODE (X)) == RTX_UNARY)

	/* 1 if X is a binary operator. */

	#define BINARY_P(X) \
	((GET_RTX_CLASS (GET_CODE (X)) & RTX_BINARY_MASK) == RTX_BINARY_RESULT)

	/* 1 if X is an arithmetic operator. */

	#define ARITHMETIC_P(X) \
	((GET_RTX_CLASS (GET_CODE (X)) & RTX_ARITHMETIC_MASK) \
	== RTX_ARITHMETIC_RESULT)

	/* 1 if X is an arithmetic operator. */

	#define COMMUTATIVE_ARITH_P(X) \
	(GET_RTX_CLASS (GET_CODE (X)) == RTX_COMM_ARITH)

	/* 1 if X is a commutative arithmetic operator or a comparison operator.
	These two are sometimes selected together because it is possible to
	swap the two operands. */

	#define SWAPPABLE_OPERANDS_P(X) \
	((1 << GET_RTX_CLASS (GET_CODE (X))) \
	& ((1 << RTX_COMM_ARITH) \| (1 << RTX_COMM_COMPARE) \
	\| (1 << RTX_COMPARE)))

	/* 1 if X is a non-commutative operator. */

	#define NON_COMMUTATIVE_P(X) \
	((GET_RTX_CLASS (GET_CODE (X)) & RTX_COMMUTATIVE_MASK) \
	== RTX_NON_COMMUTATIVE_RESULT)

	/* 1 if X is a commutative operator on integers. */

	#define COMMUTATIVE_P(X) \
	((GET_RTX_CLASS (GET_CODE (X)) & RTX_COMMUTATIVE_MASK) \
	== RTX_COMMUTATIVE_RESULT)

	/* 1 if X is a relational operator. */

	#define COMPARISON_P(X) \
	((GET_RTX_CLASS (GET_CODE (X)) & RTX_COMPARE_MASK) == RTX_COMPARE_RESULT)

	/* 1 if X is a constant value that is an integer. */

	#define CONSTANT_P(X) \
	(GET_RTX_CLASS (GET_CODE (X)) == RTX_CONST_OBJ)

	/* 1 if X can be used to represent an object. */
	#define OBJECT_P(X) \
	((GET_RTX_CLASS (GET_CODE (X)) & RTX_OBJ_MASK) == RTX_OBJ_RESULT)

	/* General accessor macros for accessing the fields of an rtx. */

	#if defined ENABLE_RTL_CHECKING && (GCC_VERSION >= 2007)
	/* The bit with a star outside the statement expr and an & inside is
	so that N can be evaluated only once. */
	#define RTL_CHECK1(RTX, N, C1) __extension__ \
	(*({ rtx const _rtx = (RTX); const int _n = (N); \
	const enum rtx_code _code = GET_CODE (_rtx); \
	if (_n < 0 \|\| _n >= GET_RTX_LENGTH (_code)) \
	rtl_check_failed_bounds (_rtx, _n, __FILE__, __LINE__, \
	__FUNCTION__); \
	if (GET_RTX_FORMAT(_code)[_n] != C1) \
	rtl_check_failed_type1 (_rtx, _n, C1, __FILE__, __LINE__, \
	__FUNCTION__); \
	&_rtx->u.fld[_n]; }))

	#define RTL_CHECK2(RTX, N, C1, C2) __extension__ \
	(*({ rtx const _rtx = (RTX); const int _n = (N); \
	const enum rtx_code _code = GET_CODE (_rtx); \
	if (_n < 0 \|\| _n >= GET_RTX_LENGTH (_code)) \
	rtl_check_failed_bounds (_rtx, _n, __FILE__, __LINE__, \
	__FUNCTION__); \
	if (GET_RTX_FORMAT(_code)[_n] != C1 \
	&& GET_RTX_FORMAT(_code)[_n] != C2) \
	rtl_check_failed_type2 (_rtx, _n, C1, C2, __FILE__, __LINE__, \
	__FUNCTION__); \
	&_rtx->u.fld[_n]; }))

	#define RTL_CHECKC1(RTX, N, C) __extension__ \
	(*({ rtx const _rtx = (RTX); const int _n = (N); \
	if (GET_CODE (_rtx) != (C)) \
	rtl_check_failed_code1 (_rtx, (C), __FILE__, __LINE__, \
	__FUNCTION__); \
	&_rtx->u.fld[_n]; }))

	#define RTL_CHECKC2(RTX, N, C1, C2) __extension__ \
	(*({ rtx const _rtx = (RTX); const int _n = (N); \
	const enum rtx_code _code = GET_CODE (_rtx); \
	if (_code != (C1) && _code != (C2)) \
	rtl_check_failed_code2 (_rtx, (C1), (C2), __FILE__, __LINE__, \
	__FUNCTION__); \
	&_rtx->u.fld[_n]; }))

	#define RTVEC_ELT(RTVEC, I) __extension__ \
	(*({ rtvec const _rtvec = (RTVEC); const int _i = (I); \
	if (_i < 0 \|\| _i >= GET_NUM_ELEM (_rtvec)) \
	rtvec_check_failed_bounds (_rtvec, _i, __FILE__, __LINE__, \
	__FUNCTION__); \
	&_rtvec->elem[_i]; }))

	#define XWINT(RTX, N) __extension__ \
	(*({ rtx const _rtx = (RTX); const int _n = (N); \
	const enum rtx_code _code = GET_CODE (_rtx); \
	if (_n < 0 \|\| _n >= GET_RTX_LENGTH (_code)) \
	rtl_check_failed_bounds (_rtx, _n, __FILE__, __LINE__, \
	__FUNCTION__); \
	if (GET_RTX_FORMAT(_code)[_n] != 'w') \
	rtl_check_failed_type1 (_rtx, _n, 'w', __FILE__, __LINE__, \
	__FUNCTION__); \
	&_rtx->u.hwint[_n]; }))

	#define XCWINT(RTX, N, C) __extension__ \
	(*({ rtx const _rtx = (RTX); \
	if (GET_CODE (_rtx) != (C)) \
	rtl_check_failed_code1 (_rtx, (C), __FILE__, __LINE__, \
	__FUNCTION__); \
	&_rtx->u.hwint[N]; }))

	#define XCMWINT(RTX, N, C, M) __extension__ \
	(*({ rtx const _rtx = (RTX); \
	if (GET_CODE (_rtx) != (C) \|\| GET_MODE (_rtx) != (M)) \
	rtl_check_failed_code_mode (_rtx, (C), (M), false, __FILE__, \
	__LINE__, __FUNCTION__); \
	&_rtx->u.hwint[N]; }))

	#define XCNMPRV(RTX, C, M) __extension__ \
	({ rtx const _rtx = (RTX); \
	if (GET_CODE (_rtx) != (C) \|\| GET_MODE (_rtx) == (M)) \
	rtl_check_failed_code_mode (_rtx, (C), (M), true, __FILE__, \
	__LINE__, __FUNCTION__); \
	&_rtx->u.rv; })

	#define BLOCK_SYMBOL_CHECK(RTX) __extension__ \
	({ rtx const _symbol = (RTX); \
	unsigned int flags = RTL_CHECKC1 (_symbol, 1, SYMBOL_REF).rt_int; \
	if ((flags & SYMBOL_FLAG_HAS_BLOCK_INFO) == 0) \
	rtl_check_failed_block_symbol (__FILE__, __LINE__, \
	__FUNCTION__); \
	&_symbol->u.block_sym; })

	extern void rtl_check_failed_bounds (rtx, int, const char *, int,
	const char *)
	ATTRIBUTE_NORETURN;
	extern void rtl_check_failed_type1 (rtx, int, int, const char *, int,
	const char *)
	ATTRIBUTE_NORETURN;
	extern void rtl_check_failed_type2 (rtx, int, int, int, const char *,
	int, const char *)
	ATTRIBUTE_NORETURN;
	extern void rtl_check_failed_code1 (rtx, enum rtx_code, const char *,
	int, const char *)
	ATTRIBUTE_NORETURN;
	extern void rtl_check_failed_code2 (rtx, enum rtx_code, enum rtx_code,
	const char , int, const char )
	ATTRIBUTE_NORETURN;
	extern void rtl_check_failed_code_mode (rtx, enum rtx_code, enum machine_mode,
	bool, const char , int, const char )
	ATTRIBUTE_NORETURN;
	extern void rtl_check_failed_block_symbol (const char , int, const char )
	ATTRIBUTE_NORETURN;
	extern void rtvec_check_failed_bounds (rtvec, int, const char *, int,
	const char *)
	ATTRIBUTE_NORETURN;

	#else /* not ENABLE_RTL_CHECKING */

	#define RTL_CHECK1(RTX, N, C1) ((RTX)->u.fld[N])
	#define RTL_CHECK2(RTX, N, C1, C2) ((RTX)->u.fld[N])
	#define RTL_CHECKC1(RTX, N, C) __PAST_END((RTX)->u.fld, N)
	#define RTL_CHECKC2(RTX, N, C1, C2) ((RTX)->u.fld[N])
	#define RTVEC_ELT(RTVEC, I) __PAST_END((RTVEC)->elem, I)
	#define XWINT(RTX, N) ((RTX)->u.hwint[N])
	#define XCWINT(RTX, N, C) ((RTX)->u.hwint[N])
	#define XCMWINT(RTX, N, C, M) __PAST_END((RTX)->u.hwint, N)
	#define XCNMWINT(RTX, N, C, M) ((RTX)->u.hwint[N])
	#define XCNMPRV(RTX, C, M) (&(RTX)->u.rv)
	#define BLOCK_SYMBOL_CHECK(RTX) (&(RTX)->u.block_sym)

	#endif

	/* General accessor macros for accessing the flags of an rtx. */

	/* Access an individual rtx flag, with no checking of any kind. */
	#define RTX_FLAG(RTX, FLAG) ((RTX)->FLAG)

	#if defined ENABLE_RTL_FLAG_CHECKING && (GCC_VERSION >= 2007)
	#define RTL_FLAG_CHECK1(NAME, RTX, C1) __extension__ \
	({ rtx const _rtx = (RTX); \
	if (GET_CODE(_rtx) != C1) \
	rtl_check_failed_flag (NAME, _rtx, __FILE__, __LINE__, \
	__FUNCTION__); \
	_rtx; })

	#define RTL_FLAG_CHECK2(NAME, RTX, C1, C2) __extension__ \
	({ rtx const _rtx = (RTX); \
	if (GET_CODE(_rtx) != C1 && GET_CODE(_rtx) != C2) \
	rtl_check_failed_flag (NAME,_rtx, __FILE__, __LINE__, \
	__FUNCTION__); \
	_rtx; })

	#define RTL_FLAG_CHECK3(NAME, RTX, C1, C2, C3) __extension__ \
	({ rtx const _rtx = (RTX); \
	if (GET_CODE(_rtx) != C1 && GET_CODE(_rtx) != C2 \
	&& GET_CODE(_rtx) != C3) \
	rtl_check_failed_flag (NAME, _rtx, __FILE__, __LINE__, \
	__FUNCTION__); \
	_rtx; })

	#define RTL_FLAG_CHECK4(NAME, RTX, C1, C2, C3, C4) __extension__ \
	({ rtx const _rtx = (RTX); \
	if (GET_CODE(_rtx) != C1 && GET_CODE(_rtx) != C2 \
	&& GET_CODE(_rtx) != C3 && GET_CODE(_rtx) != C4) \
	rtl_check_failed_flag (NAME, _rtx, __FILE__, __LINE__, \
	__FUNCTION__); \
	_rtx; })

	#define RTL_FLAG_CHECK5(NAME, RTX, C1, C2, C3, C4, C5) __extension__ \
	({ rtx const _rtx = (RTX); \
	if (GET_CODE(_rtx) != C1 && GET_CODE(_rtx) != C2 \
	&& GET_CODE(_rtx) != C3 && GET_CODE(_rtx) != C4 \
	&& GET_CODE(_rtx) != C5) \
	rtl_check_failed_flag (NAME, _rtx, __FILE__, __LINE__, \
	__FUNCTION__); \
	_rtx; })

	#define RTL_FLAG_CHECK6(NAME, RTX, C1, C2, C3, C4, C5, C6) \
	__extension__ \
	({ rtx const _rtx = (RTX); \
	if (GET_CODE(_rtx) != C1 && GET_CODE(_rtx) != C2 \
	&& GET_CODE(_rtx) != C3 && GET_CODE(_rtx) != C4 \
	&& GET_CODE(_rtx) != C5 && GET_CODE(_rtx) != C6) \
	rtl_check_failed_flag (NAME,_rtx, __FILE__, __LINE__, \
	__FUNCTION__); \
	_rtx; })

	#define RTL_FLAG_CHECK7(NAME, RTX, C1, C2, C3, C4, C5, C6, C7) \
	__extension__ \
	({ rtx const _rtx = (RTX); \
	if (GET_CODE(_rtx) != C1 && GET_CODE(_rtx) != C2 \
	&& GET_CODE(_rtx) != C3 && GET_CODE(_rtx) != C4 \
	&& GET_CODE(_rtx) != C5 && GET_CODE(_rtx) != C6 \
	&& GET_CODE(_rtx) != C7) \
	rtl_check_failed_flag (NAME, _rtx, __FILE__, __LINE__, \
	__FUNCTION__); \
	_rtx; })

	#define RTL_FLAG_CHECK8(NAME, RTX, C1, C2, C3, C4, C5, C6, C7, C8) \
	__extension__ \
	({ rtx const _rtx = (RTX); \
	if (GET_CODE(_rtx) != C1 && GET_CODE(_rtx) != C2 \
	&& GET_CODE(_rtx) != C3 && GET_CODE(_rtx) != C4 \
	&& GET_CODE(_rtx) != C5 && GET_CODE(_rtx) != C6 \
	&& GET_CODE(_rtx) != C7 && GET_CODE(_rtx) != C8) \
	rtl_check_failed_flag (NAME, _rtx, __FILE__, __LINE__, \
	__FUNCTION__); \
	_rtx; })

	extern void rtl_check_failed_flag (const char , rtx, const char ,
	int, const char *)
	ATTRIBUTE_NORETURN
	;

	#else /* not ENABLE_RTL_FLAG_CHECKING */

	#define RTL_FLAG_CHECK1(NAME, RTX, C1) (RTX)
	#define RTL_FLAG_CHECK2(NAME, RTX, C1, C2) (RTX)
	#define RTL_FLAG_CHECK3(NAME, RTX, C1, C2, C3) (RTX)
	#define RTL_FLAG_CHECK4(NAME, RTX, C1, C2, C3, C4) (RTX)
	#define RTL_FLAG_CHECK5(NAME, RTX, C1, C2, C3, C4, C5) (RTX)
	#define RTL_FLAG_CHECK6(NAME, RTX, C1, C2, C3, C4, C5, C6) (RTX)
	#define RTL_FLAG_CHECK7(NAME, RTX, C1, C2, C3, C4, C5, C6, C7) (RTX)
	#define RTL_FLAG_CHECK8(NAME, RTX, C1, C2, C3, C4, C5, C6, C7, C8) (RTX)
	#endif

	#define XINT(RTX, N) (RTL_CHECK2 (RTX, N, 'i', 'n').rt_int)
	#define XSTR(RTX, N) (RTL_CHECK2 (RTX, N, 's', 'S').rt_str)
	#define XEXP(RTX, N) (RTL_CHECK2 (RTX, N, 'e', 'u').rt_rtx)
	#define XVEC(RTX, N) (RTL_CHECK2 (RTX, N, 'E', 'V').rt_rtvec)
	#define XMODE(RTX, N) (RTL_CHECK1 (RTX, N, 'M').rt_type)
	#define XBITMAP(RTX, N) (RTL_CHECK1 (RTX, N, 'b').rt_bit)
	#define XTREE(RTX, N) (RTL_CHECK1 (RTX, N, 't').rt_tree)
	#define XBBDEF(RTX, N) (RTL_CHECK1 (RTX, N, 'B').rt_bb)
	#define XTMPL(RTX, N) (RTL_CHECK1 (RTX, N, 'T').rt_str)

	#define XVECEXP(RTX, N, M) RTVEC_ELT (XVEC (RTX, N), M)
	#define XVECLEN(RTX, N) GET_NUM_ELEM (XVEC (RTX, N))

	/* These are like XINT, etc. except that they expect a '0' field instead
	of the normal type code. */

	#define X0INT(RTX, N) (RTL_CHECK1 (RTX, N, '0').rt_int)
	#define X0UINT(RTX, N) (RTL_CHECK1 (RTX, N, '0').rt_uint)
	#define X0STR(RTX, N) (RTL_CHECK1 (RTX, N, '0').rt_str)
	#define X0EXP(RTX, N) (RTL_CHECK1 (RTX, N, '0').rt_rtx)
	#define X0VEC(RTX, N) (RTL_CHECK1 (RTX, N, '0').rt_rtvec)
	#define X0MODE(RTX, N) (RTL_CHECK1 (RTX, N, '0').rt_type)
	#define X0BITMAP(RTX, N) (RTL_CHECK1 (RTX, N, '0').rt_bit)
	#define X0TREE(RTX, N) (RTL_CHECK1 (RTX, N, '0').rt_tree)
	#define X0BBDEF(RTX, N) (RTL_CHECK1 (RTX, N, '0').rt_bb)
	#define X0ADVFLAGS(RTX, N) (RTL_CHECK1 (RTX, N, '0').rt_addr_diff_vec_flags)
	#define X0CSELIB(RTX, N) (RTL_CHECK1 (RTX, N, '0').rt_cselib)
	#define X0MEMATTR(RTX, N) (RTL_CHECKC1 (RTX, N, MEM).rt_mem)
	#define X0REGATTR(RTX, N) (RTL_CHECKC1 (RTX, N, REG).rt_reg)
	#define X0CONSTANT(RTX, N) (RTL_CHECK1 (RTX, N, '0').rt_constant)

	/* Access a '0' field with any type. */
	#define X0ANY(RTX, N) RTL_CHECK1 (RTX, N, '0')

	#define XCINT(RTX, N, C) (RTL_CHECKC1 (RTX, N, C).rt_int)
	#define XCUINT(RTX, N, C) (RTL_CHECKC1 (RTX, N, C).rt_uint)
	#define XCSTR(RTX, N, C) (RTL_CHECKC1 (RTX, N, C).rt_str)
	#define XCEXP(RTX, N, C) (RTL_CHECKC1 (RTX, N, C).rt_rtx)
	#define XCVEC(RTX, N, C) (RTL_CHECKC1 (RTX, N, C).rt_rtvec)
	#define XCMODE(RTX, N, C) (RTL_CHECKC1 (RTX, N, C).rt_type)
	#define XCBITMAP(RTX, N, C) (RTL_CHECKC1 (RTX, N, C).rt_bit)
	#define XCTREE(RTX, N, C) (RTL_CHECKC1 (RTX, N, C).rt_tree)
	#define XCBBDEF(RTX, N, C) (RTL_CHECKC1 (RTX, N, C).rt_bb)
	#define XCCSELIB(RTX, N, C) (RTL_CHECKC1 (RTX, N, C).rt_cselib)

	#define XCVECEXP(RTX, N, M, C) RTVEC_ELT (XCVEC (RTX, N, C), M)
	#define XCVECLEN(RTX, N, C) GET_NUM_ELEM (XCVEC (RTX, N, C))

	#define XC2EXP(RTX, N, C1, C2) (RTL_CHECKC2 (RTX, N, C1, C2).rt_rtx)

	/* ACCESS MACROS for particular fields of insns. */

	/* Holds a unique number for each insn.
	These are not necessarily sequentially increasing. */
	#define INSN_UID(INSN) XINT (INSN, 0)

	/* Chain insns together in sequence. */
	#define PREV_INSN(INSN) XEXP (INSN, 1)
	#define NEXT_INSN(INSN) XEXP (INSN, 2)

	#define BLOCK_FOR_INSN(INSN) XBBDEF (INSN, 3)
	#define INSN_LOCATOR(INSN) XINT (INSN, 4)
	/* The body of an insn. */
	#define PATTERN(INSN) XEXP (INSN, 5)

	/* Code number of instruction, from when it was recognized.
	-1 means this instruction has not been recognized yet. */
	#define INSN_CODE(INSN) XINT (INSN, 6)

	/* Set up in flow.c; empty before then.
	Holds a chain of INSN_LIST rtx's whose first operands point at
	previous insns with direct data-flow connections to this one.
	That means that those insns set variables whose next use is in this insn.
	They are always in the same basic block as this insn. */
	#define LOG_LINKS(INSN) XEXP(INSN, 7)

	#define RTX_FRAME_RELATED_P(RTX) \
	(RTL_FLAG_CHECK5("RTX_FRAME_RELATED_P", (RTX), INSN, CALL_INSN, \
	JUMP_INSN, BARRIER, SET)->frame_related)

	/* 1 if RTX is an insn that has been deleted. */
	#define INSN_DELETED_P(RTX) \
	(RTL_FLAG_CHECK6("INSN_DELETED_P", (RTX), INSN, CALL_INSN, JUMP_INSN, \
	CODE_LABEL, BARRIER, NOTE)->volatil)

	/* 1 if RTX is a call to a const or pure function. */
	#define CONST_OR_PURE_CALL_P(RTX) \
	(RTL_FLAG_CHECK3("CONST_OR_PURE_CALL_P", (RTX), CALL_INSN, NOTE, \
	EXPR_LIST)->unchanging)

	/* 1 if RTX is a call_insn for a sibling call. */
	#define SIBLING_CALL_P(RTX) \
	(RTL_FLAG_CHECK1("SIBLING_CALL_P", (RTX), CALL_INSN)->jump)

	/* 1 if RTX is a jump_insn, call_insn, or insn that is an annulling branch. */
	#define INSN_ANNULLED_BRANCH_P(RTX) \
	(RTL_FLAG_CHECK3("INSN_ANNULLED_BRANCH_P", (RTX), JUMP_INSN, CALL_INSN, INSN)->unchanging)

	/* 1 if RTX is an insn in a delay slot and is from the target of the branch.
	If the branch insn has INSN_ANNULLED_BRANCH_P set, this insn should only be
	executed if the branch is taken. For annulled branches with this bit
	clear, the insn should be executed only if the branch is not taken. */
	#define INSN_FROM_TARGET_P(RTX) \
	(RTL_FLAG_CHECK3("INSN_FROM_TARGET_P", (RTX), INSN, JUMP_INSN, CALL_INSN)->in_struct)

	/* In an ADDR_DIFF_VEC, the flags for RTX for use by branch shortening.
	See the comments for ADDR_DIFF_VEC in rtl.def. */
	#define ADDR_DIFF_VEC_FLAGS(RTX) X0ADVFLAGS(RTX, 4)

	/* In a VALUE, the value cselib has assigned to RTX.
	This is a "struct cselib_val_struct", see cselib.h. */
	#define CSELIB_VAL_PTR(RTX) X0CSELIB(RTX, 0)

	/* Holds a list of notes on what this insn does to various REGs.
	It is a chain of EXPR_LIST rtx's, where the second operand is the
	chain pointer and the first operand is the REG being described.
	The mode field of the EXPR_LIST contains not a real machine mode
	but a value from enum reg_note. */
	#define REG_NOTES(INSN) XEXP(INSN, 8)

	enum reg_note
	{
	#define DEF_REG_NOTE(NAME) NAME,
	#include "reg-notes.def"
	#undef DEF_REG_NOTE
	REG_NOTE_MAX
	};

	/* Define macros to extract and insert the reg-note kind in an EXPR_LIST. */
	#define REG_NOTE_KIND(LINK) ((enum reg_note) GET_MODE (LINK))
	#define PUT_REG_NOTE_KIND(LINK, KIND) \
	PUT_MODE (LINK, (enum machine_mode) (KIND))

	/* Names for REG_NOTE's in EXPR_LIST insn's. */

	extern const char * const reg_note_name[];
	#define GET_REG_NOTE_NAME(MODE) (reg_note_name[(int) (MODE)])

	/* This field is only present on CALL_INSNs. It holds a chain of EXPR_LIST of
	USE and CLOBBER expressions.
	USE expressions list the registers filled with arguments that
	are passed to the function.
	CLOBBER expressions document the registers explicitly clobbered
	by this CALL_INSN.
	Pseudo registers can not be mentioned in this list. */
	#define CALL_INSN_FUNCTION_USAGE(INSN) XEXP(INSN, 9)

	/* The label-number of a code-label. The assembler label
	is made from `L' and the label-number printed in decimal.
	Label numbers are unique in a compilation. */
	#define CODE_LABEL_NUMBER(INSN) XINT (INSN, 6)

	/* In a NOTE that is a line number, this is a string for the file name that the
	line is in. We use the same field to record block numbers temporarily in
	NOTE_INSN_BLOCK_BEG and NOTE_INSN_BLOCK_END notes. (We avoid lots of casts
	between ints and pointers if we use a different macro for the block number.)
	*/

	/* Opaque data. */
	#define NOTE_DATA(INSN) RTL_CHECKC1 (INSN, 4, NOTE)
	#define NOTE_DELETED_LABEL_NAME(INSN) XCSTR (INSN, 4, NOTE)
	#ifdef USE_MAPPED_LOCATION
	#define NOTE_SOURCE_LOCATION(INSN) XCUINT (INSN, 5, NOTE)
	#define NOTE_EXPANDED_LOCATION(XLOC, INSN) \
	(XLOC) = expand_location (NOTE_SOURCE_LOCATION (INSN))
	#define SET_INSN_DELETED(INSN) \
	(PUT_CODE (INSN, NOTE), NOTE_LINE_NUMBER (INSN) = NOTE_INSN_DELETED)
	#else
	#define NOTE_EXPANDED_LOCATION(XLOC, INSN) \
	((XLOC).file = NOTE_SOURCE_FILE (INSN), \
	(XLOC).line = NOTE_LINE_NUMBER (INSN))
	#define NOTE_SOURCE_FILE(INSN) XCSTR (INSN, 4, NOTE)
	#define SET_INSN_DELETED(INSN) \
	(PUT_CODE (INSN, NOTE), NOTE_SOURCE_FILE (INSN) = 0, \
	NOTE_LINE_NUMBER (INSN) = NOTE_INSN_DELETED)
	#endif
	#define NOTE_BLOCK(INSN) XCTREE (INSN, 4, NOTE)
	#define NOTE_EH_HANDLER(INSN) XCINT (INSN, 4, NOTE)
	#define NOTE_BASIC_BLOCK(INSN) XCBBDEF (INSN, 4, NOTE)
	#define NOTE_EXPECTED_VALUE(INSN) XCEXP (INSN, 4, NOTE)
	#define NOTE_VAR_LOCATION(INSN) XCEXP (INSN, 4, NOTE)

	/* In a NOTE that is a line number, this is the line number.
	Other kinds of NOTEs are identified by negative numbers here. */
	#define NOTE_LINE_NUMBER(INSN) XCINT (INSN, 5, NOTE)

	/* Nonzero if INSN is a note marking the beginning of a basic block. */
	#define NOTE_INSN_BASIC_BLOCK_P(INSN) \
	(GET_CODE (INSN) == NOTE \
	&& NOTE_LINE_NUMBER (INSN) == NOTE_INSN_BASIC_BLOCK)

	/* Variable declaration and the location of a variable. */
	#define NOTE_VAR_LOCATION_DECL(INSN) (XCTREE (XCEXP (INSN, 4, NOTE), \
	0, VAR_LOCATION))
	#define NOTE_VAR_LOCATION_LOC(INSN) (XCEXP (XCEXP (INSN, 4, NOTE), \
	1, VAR_LOCATION))

	/* Codes that appear in the NOTE_LINE_NUMBER field for kinds of notes
	that are not line numbers. These codes are all negative.

	Notice that we do not try to use zero here for any of
	the special note codes because sometimes the source line
	actually can be zero! This happens (for example) when we
	are generating code for the per-translation-unit constructor
	and destructor routines for some C++ translation unit. */

	enum insn_note
	{
	/* Keep all of these numbers negative. Adjust as needed. */
	NOTE_INSN_BIAS = -100,

	#define DEF_INSN_NOTE(NAME) NAME,
	#include "insn-notes.def"
	#undef DEF_INSN_NOTE

	NOTE_INSN_MAX
	};

	/* Names for NOTE insn's other than line numbers. */

	extern const char * const note_insn_name[NOTE_INSN_MAX - NOTE_INSN_BIAS];
	#define GET_NOTE_INSN_NAME(NOTE_CODE) \
	(note_insn_name[(NOTE_CODE) - (int) NOTE_INSN_BIAS])

	/* The name of a label, in case it corresponds to an explicit label
	in the input source code. */
	#define LABEL_NAME(RTX) XCSTR (RTX, 7, CODE_LABEL)

	/* In jump.c, each label contains a count of the number
	of LABEL_REFs that point at it, so unused labels can be deleted. */
	#define LABEL_NUSES(RTX) XCINT (RTX, 4, CODE_LABEL)

	+/* APPLE LOCAL begin for-fsf-4_4 3274130 5295549 */ \
	+/* The alignment of the label, as the log-base-2 of the alignment in bytes. */
	+#define LABEL_ALIGN_LOG(RTX) (XCUINT (RTX, 8, CODE_LABEL) & 0xFF)
	+/* The maximum number of bytes to skip to achieve that alignment. */
	+#define LABEL_MAX_SKIP(RTX) (XCUINT (RTX, 8, CODE_LABEL) >> 8)
	+#define SET_LABEL_ALIGN(RTX, ALIGN, MAX_SKIP) \
	+ (XCUINT (RTX, 8, CODE_LABEL) = (ALIGN) \| ((MAX_SKIP) << 8))
	+
	+/* APPLE LOCAL end for-fsf-4_4 3274130 5295549 */ \
	/* Labels carry a two-bit field composed of the ->jump and ->call
	bits. This field indicates whether the label is an alternate
	entry point, and if so, what kind. */
	enum label_kind
	{
	LABEL_NORMAL = 0, /* ordinary label */
	LABEL_STATIC_ENTRY, /* alternate entry point, not exported */
	LABEL_GLOBAL_ENTRY, /* alternate entry point, exported */
	LABEL_WEAK_ENTRY /* alternate entry point, exported as weak symbol */
	};

	#if defined ENABLE_RTL_FLAG_CHECKING && (GCC_VERSION > 2007)

	/* Retrieve the kind of LABEL. */
	#define LABEL_KIND(LABEL) __extension__ \
	({ rtx const _label = (LABEL); \
	if (GET_CODE (_label) != CODE_LABEL) \
	rtl_check_failed_flag ("LABEL_KIND", _label, __FILE__, __LINE__, \
	__FUNCTION__); \
	(enum label_kind) ((_label->jump << 1) \| _label->call); })

	/* Set the kind of LABEL. */
	#define SET_LABEL_KIND(LABEL, KIND) do { \
	rtx _label = (LABEL); \
	unsigned int _kind = (KIND); \
	if (GET_CODE (_label) != CODE_LABEL) \
	rtl_check_failed_flag ("SET_LABEL_KIND", _label, __FILE__, __LINE__, \
	__FUNCTION__); \
	_label->jump = ((_kind >> 1) & 1); \
	_label->call = (_kind & 1); \
	} while (0)

	#else

	/* Retrieve the kind of LABEL. */
	#define LABEL_KIND(LABEL) \
	((enum label_kind) (((LABEL)->jump << 1) \| (LABEL)->call))

	/* Set the kind of LABEL. */
	#define SET_LABEL_KIND(LABEL, KIND) do { \
	rtx _label = (LABEL); \
	unsigned int _kind = (KIND); \
	_label->jump = ((_kind >> 1) & 1); \
	_label->call = (_kind & 1); \
	} while (0)

	#endif /* rtl flag checking */

	#define LABEL_ALT_ENTRY_P(LABEL) (LABEL_KIND (LABEL) != LABEL_NORMAL)

	/* In jump.c, each JUMP_INSN can point to a label that it can jump to,
	so that if the JUMP_INSN is deleted, the label's LABEL_NUSES can
	be decremented and possibly the label can be deleted. */
	#define JUMP_LABEL(INSN) XCEXP (INSN, 9, JUMP_INSN)

	/* Once basic blocks are found in flow.c,
	each CODE_LABEL starts a chain that goes through
	all the LABEL_REFs that jump to that label.
	The chain eventually winds up at the CODE_LABEL: it is circular. */
	#define LABEL_REFS(LABEL) XCEXP (LABEL, 5, CODE_LABEL)

	/* For a REG rtx, REGNO extracts the register number. ORIGINAL_REGNO holds
	the number the register originally had; for a pseudo register turned into
	a hard reg this will hold the old pseudo register number. */

	#define REGNO(RTX) XCUINT (RTX, 0, REG)
	#define ORIGINAL_REGNO(RTX) X0UINT (RTX, 1)

	/* 1 if RTX is a reg or parallel that is the current function's return
	value. */
	#define REG_FUNCTION_VALUE_P(RTX) \
	(RTL_FLAG_CHECK2("REG_FUNCTION_VALUE_P", (RTX), REG, PARALLEL)->return_val)

	/* 1 if RTX is a reg that corresponds to a variable declared by the user. */
	#define REG_USERVAR_P(RTX) \
	(RTL_FLAG_CHECK1("REG_USERVAR_P", (RTX), REG)->volatil)

	/* 1 if RTX is a reg that holds a pointer value. */
	#define REG_POINTER(RTX) \
	(RTL_FLAG_CHECK1("REG_POINTER", (RTX), REG)->frame_related)

	/* 1 if RTX is a mem that holds a pointer value. */
	#define MEM_POINTER(RTX) \
	(RTL_FLAG_CHECK1("MEM_POINTER", (RTX), MEM)->frame_related)

	/* 1 if the given register REG corresponds to a hard register. */
	#define HARD_REGISTER_P(REG) (HARD_REGISTER_NUM_P (REGNO (REG)))

	/* 1 if the given register number REG_NO corresponds to a hard register. */
	#define HARD_REGISTER_NUM_P(REG_NO) ((REG_NO) < FIRST_PSEUDO_REGISTER)

	/* For a CONST_INT rtx, INTVAL extracts the integer. */
	#define INTVAL(RTX) XCWINT(RTX, 0, CONST_INT)
	#define UINTVAL(RTX) ((unsigned HOST_WIDE_INT) INTVAL (RTX))

	/* For a CONST_DOUBLE:
	For a VOIDmode, there are two integers CONST_DOUBLE_LOW is the
	low-order word and ..._HIGH the high-order.
	For a float, there is a REAL_VALUE_TYPE structure, and
	CONST_DOUBLE_REAL_VALUE(r) is a pointer to it. */
	#define CONST_DOUBLE_LOW(r) XCMWINT (r, 0, CONST_DOUBLE, VOIDmode)
	#define CONST_DOUBLE_HIGH(r) XCMWINT (r, 1, CONST_DOUBLE, VOIDmode)
	#define CONST_DOUBLE_REAL_VALUE(r) \
	((const struct real_value *) XCNMPRV (r, CONST_DOUBLE, VOIDmode))

	/* For a CONST_VECTOR, return element #n. */
	#define CONST_VECTOR_ELT(RTX, N) XCVECEXP (RTX, 0, N, CONST_VECTOR)

	/* For a CONST_VECTOR, return the number of elements in a vector. */
	#define CONST_VECTOR_NUNITS(RTX) XCVECLEN (RTX, 0, CONST_VECTOR)

	/* For a SUBREG rtx, SUBREG_REG extracts the value we want a subreg of.
	SUBREG_BYTE extracts the byte-number. */

	#define SUBREG_REG(RTX) XCEXP (RTX, 0, SUBREG)
	#define SUBREG_BYTE(RTX) XCUINT (RTX, 1, SUBREG)

	/* in rtlanal.c */
	/* Return the right cost to give to an operation
	to make the cost of the corresponding register-to-register instruction
	N times that of a fast register-to-register instruction. */
	#define COSTS_N_INSNS(N) ((N) * 4)

	/* Maximum cost of an rtl expression. This value has the special meaning
	not to use an rtx with this cost under any circumstances. */
	#define MAX_COST INT_MAX

	extern void init_rtlanal (void);
	extern int rtx_cost (rtx, enum rtx_code);
	extern int address_cost (rtx, enum machine_mode);
	extern unsigned int subreg_lsb (rtx);
	extern unsigned int subreg_lsb_1 (enum machine_mode, enum machine_mode,
	unsigned int);
	extern unsigned int subreg_regno_offset (unsigned int, enum machine_mode,
	unsigned int, enum machine_mode);
	extern bool subreg_offset_representable_p (unsigned int, enum machine_mode,
	unsigned int, enum machine_mode);
	extern unsigned int subreg_regno (rtx);
	extern unsigned HOST_WIDE_INT nonzero_bits (rtx, enum machine_mode);
	extern unsigned int num_sign_bit_copies (rtx, enum machine_mode);
	extern bool constant_pool_constant_p (rtx);
	extern bool truncated_to_mode (enum machine_mode, rtx);


	/* 1 if RTX is a subreg containing a reg that is already known to be
	sign- or zero-extended from the mode of the subreg to the mode of
	the reg. SUBREG_PROMOTED_UNSIGNED_P gives the signedness of the
	extension.

	When used as a LHS, is means that this extension must be done
	when assigning to SUBREG_REG. */

	#define SUBREG_PROMOTED_VAR_P(RTX) \
	(RTL_FLAG_CHECK1("SUBREG_PROMOTED", (RTX), SUBREG)->in_struct)

	#define SUBREG_PROMOTED_UNSIGNED_SET(RTX, VAL) \
	do { \
	rtx const _rtx = RTL_FLAG_CHECK1("SUBREG_PROMOTED_UNSIGNED_SET", (RTX), SUBREG); \
	if ((VAL) < 0) \
	_rtx->volatil = 1; \
	else { \
	_rtx->volatil = 0; \
	_rtx->unchanging = (VAL); \
	} \
	} while (0)
	#define SUBREG_PROMOTED_UNSIGNED_P(RTX) \
	((RTL_FLAG_CHECK1("SUBREG_PROMOTED_UNSIGNED_P", (RTX), SUBREG)->volatil) \
	? -1 : (RTX)->unchanging)

	/* Access various components of an ASM_OPERANDS rtx. */

	#define ASM_OPERANDS_TEMPLATE(RTX) XCSTR (RTX, 0, ASM_OPERANDS)
	#define ASM_OPERANDS_OUTPUT_CONSTRAINT(RTX) XCSTR (RTX, 1, ASM_OPERANDS)
	#define ASM_OPERANDS_OUTPUT_IDX(RTX) XCINT (RTX, 2, ASM_OPERANDS)
	#define ASM_OPERANDS_INPUT_VEC(RTX) XCVEC (RTX, 3, ASM_OPERANDS)
	#define ASM_OPERANDS_INPUT_CONSTRAINT_VEC(RTX) XCVEC (RTX, 4, ASM_OPERANDS)
	#define ASM_OPERANDS_INPUT(RTX, N) XCVECEXP (RTX, 3, N, ASM_OPERANDS)
	#define ASM_OPERANDS_INPUT_LENGTH(RTX) XCVECLEN (RTX, 3, ASM_OPERANDS)
	#define ASM_OPERANDS_INPUT_CONSTRAINT_EXP(RTX, N) \
	XCVECEXP (RTX, 4, N, ASM_OPERANDS)
	#define ASM_OPERANDS_INPUT_CONSTRAINT(RTX, N) \
	XSTR (XCVECEXP (RTX, 4, N, ASM_OPERANDS), 0)
	#define ASM_OPERANDS_INPUT_MODE(RTX, N) \
	GET_MODE (XCVECEXP (RTX, 4, N, ASM_OPERANDS))
	#ifdef USE_MAPPED_LOCATION
	#define ASM_OPERANDS_SOURCE_LOCATION(RTX) XCUINT (RTX, 5, ASM_OPERANDS)
	#else
	#define ASM_OPERANDS_SOURCE_FILE(RTX) XCSTR (RTX, 5, ASM_OPERANDS)
	#define ASM_OPERANDS_SOURCE_LINE(RTX) XCINT (RTX, 6, ASM_OPERANDS)
	#endif

	/* 1 if RTX is a mem that is statically allocated in read-only memory. */
	#define MEM_READONLY_P(RTX) \
	(RTL_FLAG_CHECK1("MEM_READONLY_P", (RTX), MEM)->unchanging)

	/* 1 if RTX is a mem and we should keep the alias set for this mem
	unchanged when we access a component. Set to 1, or example, when we
	are already in a non-addressable component of an aggregate. */
	#define MEM_KEEP_ALIAS_SET_P(RTX) \
	(RTL_FLAG_CHECK1("MEM_KEEP_ALIAS_SET_P", (RTX), MEM)->jump)

	/* 1 if RTX is a mem or asm_operand for a volatile reference. */
	#define MEM_VOLATILE_P(RTX) \
	(RTL_FLAG_CHECK3("MEM_VOLATILE_P", (RTX), MEM, ASM_OPERANDS, \
	ASM_INPUT)->volatil)

	/* 1 if RTX is a mem that refers to an aggregate, either to the
	aggregate itself or to a field of the aggregate. If zero, RTX may
	or may not be such a reference. */
	#define MEM_IN_STRUCT_P(RTX) \
	(RTL_FLAG_CHECK1("MEM_IN_STRUCT_P", (RTX), MEM)->in_struct)

	/* 1 if RTX is a MEM that refers to a scalar. If zero, RTX may or may
	not refer to a scalar. */
	#define MEM_SCALAR_P(RTX) \
	(RTL_FLAG_CHECK1("MEM_SCALAR_P", (RTX), MEM)->return_val)

	/* 1 if RTX is a mem that cannot trap. */
	#define MEM_NOTRAP_P(RTX) \
	(RTL_FLAG_CHECK1("MEM_NOTRAP_P", (RTX), MEM)->call)

	/* If VAL is nonzero, set MEM_IN_STRUCT_P and clear MEM_SCALAR_P in
	RTX. Otherwise, vice versa. Use this macro only when you are
	sure that you know that the MEM is in a structure, or is a
	scalar. VAL is evaluated only once. */
	#define MEM_SET_IN_STRUCT_P(RTX, VAL) \
	do { \
	if (VAL) \
	{ \
	MEM_IN_STRUCT_P (RTX) = 1; \
	MEM_SCALAR_P (RTX) = 0; \
	} \
	else \
	{ \
	MEM_IN_STRUCT_P (RTX) = 0; \
	MEM_SCALAR_P (RTX) = 1; \
	} \
	} while (0)

	/* The memory attribute block. We provide access macros for each value
	in the block and provide defaults if none specified. */
	#define MEM_ATTRS(RTX) X0MEMATTR (RTX, 1)

	/* The register attribute block. We provide access macros for each value
	in the block and provide defaults if none specified. */
	#define REG_ATTRS(RTX) X0REGATTR (RTX, 2)

	/* For a MEM rtx, the alias set. If 0, this MEM is not in any alias
	set, and may alias anything. Otherwise, the MEM can only alias
	MEMs in a conflicting alias set. This value is set in a
	language-dependent manner in the front-end, and should not be
	altered in the back-end. These set numbers are tested with
	alias_sets_conflict_p. */
	#define MEM_ALIAS_SET(RTX) (MEM_ATTRS (RTX) == 0 ? 0 : MEM_ATTRS (RTX)->alias)

	/* For a MEM rtx, the decl it is known to refer to, if it is known to
	refer to part of a DECL. It may also be a COMPONENT_REF. */
	#define MEM_EXPR(RTX) (MEM_ATTRS (RTX) == 0 ? 0 : MEM_ATTRS (RTX)->expr)

	/* For a MEM rtx, the offset from the start of MEM_EXPR, if known, as a
	RTX that is always a CONST_INT. */
	#define MEM_OFFSET(RTX) (MEM_ATTRS (RTX) == 0 ? 0 : MEM_ATTRS (RTX)->offset)

	/* For a MEM rtx, the size in bytes of the MEM, if known, as an RTX that
	is always a CONST_INT. */
	#define MEM_SIZE(RTX) \
	(MEM_ATTRS (RTX) != 0 ? MEM_ATTRS (RTX)->size \
	: GET_MODE (RTX) != BLKmode ? GEN_INT (GET_MODE_SIZE (GET_MODE (RTX))) \
	: 0)

	/* For a MEM rtx, the alignment in bits. We can use the alignment of the
	mode as a default when STRICT_ALIGNMENT, but not if not. */
	#define MEM_ALIGN(RTX) \
	(MEM_ATTRS (RTX) != 0 ? MEM_ATTRS (RTX)->align \
	: (STRICT_ALIGNMENT && GET_MODE (RTX) != BLKmode \
	? GET_MODE_ALIGNMENT (GET_MODE (RTX)) : BITS_PER_UNIT))

	/* For a REG rtx, the decl it is known to refer to, if it is known to
	refer to part of a DECL. */
	#define REG_EXPR(RTX) (REG_ATTRS (RTX) == 0 ? 0 : REG_ATTRS (RTX)->decl)

	/* For a REG rtx, the offset from the start of REG_EXPR, if known, as an
	HOST_WIDE_INT. */
	#define REG_OFFSET(RTX) (REG_ATTRS (RTX) == 0 ? 0 : REG_ATTRS (RTX)->offset)

	/* Copy the attributes that apply to memory locations from RHS to LHS. */
	#define MEM_COPY_ATTRIBUTES(LHS, RHS) \
	(MEM_VOLATILE_P (LHS) = MEM_VOLATILE_P (RHS), \
	MEM_IN_STRUCT_P (LHS) = MEM_IN_STRUCT_P (RHS), \
	MEM_SCALAR_P (LHS) = MEM_SCALAR_P (RHS), \
	MEM_NOTRAP_P (LHS) = MEM_NOTRAP_P (RHS), \
	MEM_READONLY_P (LHS) = MEM_READONLY_P (RHS), \
	MEM_KEEP_ALIAS_SET_P (LHS) = MEM_KEEP_ALIAS_SET_P (RHS), \
	MEM_ATTRS (LHS) = MEM_ATTRS (RHS))

	/* 1 if RTX is a label_ref for a nonlocal label. */
	/* Likewise in an expr_list for a reg_label note. */
	#define LABEL_REF_NONLOCAL_P(RTX) \
	(RTL_FLAG_CHECK2("LABEL_REF_NONLOCAL_P", (RTX), LABEL_REF, \
	REG_LABEL)->volatil)

	/* 1 if RTX is a code_label that should always be considered to be needed. */
	#define LABEL_PRESERVE_P(RTX) \
	(RTL_FLAG_CHECK2("LABEL_PRESERVE_P", (RTX), CODE_LABEL, NOTE)->in_struct)

	/* During sched, 1 if RTX is an insn that must be scheduled together
	with the preceding insn. */
	#define SCHED_GROUP_P(RTX) \
	(RTL_FLAG_CHECK3("SCHED_GROUP_P", (RTX), INSN, JUMP_INSN, CALL_INSN \
	)->in_struct)

	/* For a SET rtx, SET_DEST is the place that is set
	and SET_SRC is the value it is set to. */
	#define SET_DEST(RTX) XC2EXP(RTX, 0, SET, CLOBBER)
	#define SET_SRC(RTX) XCEXP(RTX, 1, SET)
	#define SET_IS_RETURN_P(RTX) \
	(RTL_FLAG_CHECK1("SET_IS_RETURN_P", (RTX), SET)->jump)

	/* For a TRAP_IF rtx, TRAP_CONDITION is an expression. */
	#define TRAP_CONDITION(RTX) XCEXP (RTX, 0, TRAP_IF)
	#define TRAP_CODE(RTX) XCEXP (RTX, 1, TRAP_IF)

	/* For a COND_EXEC rtx, COND_EXEC_TEST is the condition to base
	conditionally executing the code on, COND_EXEC_CODE is the code
	to execute if the condition is true. */
	#define COND_EXEC_TEST(RTX) XCEXP (RTX, 0, COND_EXEC)
	#define COND_EXEC_CODE(RTX) XCEXP (RTX, 1, COND_EXEC)

	/* 1 if RTX is a symbol_ref that addresses this function's rtl
	constants pool. */
	#define CONSTANT_POOL_ADDRESS_P(RTX) \
	(RTL_FLAG_CHECK1("CONSTANT_POOL_ADDRESS_P", (RTX), SYMBOL_REF)->unchanging)

	/* 1 if RTX is a symbol_ref that addresses a value in the file's
	tree constant pool. This information is private to varasm.c. */
	#define TREE_CONSTANT_POOL_ADDRESS_P(RTX) \
	(RTL_FLAG_CHECK1("TREE_CONSTANT_POOL_ADDRESS_P", \
	(RTX), SYMBOL_REF)->frame_related)

	/* Used if RTX is a symbol_ref, for machine-specific purposes. */
	#define SYMBOL_REF_FLAG(RTX) \
	(RTL_FLAG_CHECK1("SYMBOL_REF_FLAG", (RTX), SYMBOL_REF)->volatil)

	/* 1 if RTX is a symbol_ref that has been the library function in
	emit_library_call. */
	#define SYMBOL_REF_USED(RTX) \
	(RTL_FLAG_CHECK1("SYMBOL_REF_USED", (RTX), SYMBOL_REF)->used)

	/* 1 if RTX is a symbol_ref for a weak symbol. */
	#define SYMBOL_REF_WEAK(RTX) \
	(RTL_FLAG_CHECK1("SYMBOL_REF_WEAK", (RTX), SYMBOL_REF)->return_val)

	/* A pointer attached to the SYMBOL_REF; either SYMBOL_REF_DECL or
	SYMBOL_REF_CONSTANT. */
	#define SYMBOL_REF_DATA(RTX) X0ANY ((RTX), 2)

	/* Set RTX's SYMBOL_REF_DECL to DECL. RTX must not be a constant
	pool symbol. */
	#define SET_SYMBOL_REF_DECL(RTX, DECL) \
	(gcc_assert (!CONSTANT_POOL_ADDRESS_P (RTX)), X0TREE ((RTX), 2) = (DECL))

	/* The tree (decl or constant) associated with the symbol, or null. */
	#define SYMBOL_REF_DECL(RTX) \
	(CONSTANT_POOL_ADDRESS_P (RTX) ? NULL : X0TREE ((RTX), 2))

	/* Set RTX's SYMBOL_REF_CONSTANT to C. RTX must be a constant pool symbol. */
	#define SET_SYMBOL_REF_CONSTANT(RTX, C) \
	(gcc_assert (CONSTANT_POOL_ADDRESS_P (RTX)), X0CONSTANT ((RTX), 2) = (C))

	/* The rtx constant pool entry for a symbol, or null. */
	#define SYMBOL_REF_CONSTANT(RTX) \
	(CONSTANT_POOL_ADDRESS_P (RTX) ? X0CONSTANT ((RTX), 2) : NULL)

	/* A set of flags on a symbol_ref that are, in some respects, redundant with
	information derivable from the tree decl associated with this symbol.
	Except that we build a lot of SYMBOL_REFs that aren't associated with a
	decl. In some cases this is a bug. But beyond that, it's nice to cache
	this information to avoid recomputing it. Finally, this allows space for
	the target to store more than one bit of information, as with
	SYMBOL_REF_FLAG. */
	#define SYMBOL_REF_FLAGS(RTX) X0INT ((RTX), 1)

	/* These flags are common enough to be defined for all targets. They
	are computed by the default version of targetm.encode_section_info. */

	/* Set if this symbol is a function. */
	#define SYMBOL_FLAG_FUNCTION (1 << 0)
	#define SYMBOL_REF_FUNCTION_P(RTX) \
	((SYMBOL_REF_FLAGS (RTX) & SYMBOL_FLAG_FUNCTION) != 0)
	/* Set if targetm.binds_local_p is true. */
	#define SYMBOL_FLAG_LOCAL (1 << 1)
	#define SYMBOL_REF_LOCAL_P(RTX) \
	((SYMBOL_REF_FLAGS (RTX) & SYMBOL_FLAG_LOCAL) != 0)
	/* Set if targetm.in_small_data_p is true. */
	#define SYMBOL_FLAG_SMALL (1 << 2)
	#define SYMBOL_REF_SMALL_P(RTX) \
	((SYMBOL_REF_FLAGS (RTX) & SYMBOL_FLAG_SMALL) != 0)
	/* The three-bit field at [5:3] is true for TLS variables; use
	SYMBOL_REF_TLS_MODEL to extract the field as an enum tls_model. */
	#define SYMBOL_FLAG_TLS_SHIFT 3
	#define SYMBOL_REF_TLS_MODEL(RTX) \
	((enum tls_model) ((SYMBOL_REF_FLAGS (RTX) >> SYMBOL_FLAG_TLS_SHIFT) & 7))
	/* Set if this symbol is not defined in this translation unit. */
	#define SYMBOL_FLAG_EXTERNAL (1 << 6)
	#define SYMBOL_REF_EXTERNAL_P(RTX) \
	((SYMBOL_REF_FLAGS (RTX) & SYMBOL_FLAG_EXTERNAL) != 0)
	/* Set if this symbol has a block_symbol structure associated with it. */
	#define SYMBOL_FLAG_HAS_BLOCK_INFO (1 << 7)
	#define SYMBOL_REF_HAS_BLOCK_INFO_P(RTX) \
	((SYMBOL_REF_FLAGS (RTX) & SYMBOL_FLAG_HAS_BLOCK_INFO) != 0)
	/* Set if this symbol is a section anchor. SYMBOL_REF_ANCHOR_P implies
	SYMBOL_REF_HAS_BLOCK_INFO_P. */
	#define SYMBOL_FLAG_ANCHOR (1 << 8)
	#define SYMBOL_REF_ANCHOR_P(RTX) \
	((SYMBOL_REF_FLAGS (RTX) & SYMBOL_FLAG_ANCHOR) != 0)

	/* Subsequent bits are available for the target to use. */
	#define SYMBOL_FLAG_MACH_DEP_SHIFT 9
	#define SYMBOL_FLAG_MACH_DEP (1 << SYMBOL_FLAG_MACH_DEP_SHIFT)

	/* If SYMBOL_REF_HAS_BLOCK_INFO_P (RTX), this is the object_block
	structure to which the symbol belongs, or NULL if it has not been
	assigned a block. */
	#define SYMBOL_REF_BLOCK(RTX) (BLOCK_SYMBOL_CHECK (RTX)->block)

	/* If SYMBOL_REF_HAS_BLOCK_INFO_P (RTX), this is the offset of RTX from
	the first object in SYMBOL_REF_BLOCK (RTX). The value is negative if
	RTX has not yet been assigned to a block, or it has not been given an
	offset within that block. */
	#define SYMBOL_REF_BLOCK_OFFSET(RTX) (BLOCK_SYMBOL_CHECK (RTX)->offset)

	/* Define a macro to look for REG_INC notes,
	but save time on machines where they never exist. */

	#if (defined (HAVE_PRE_INCREMENT) \|\| defined (HAVE_PRE_DECREMENT) \|\| defined (HAVE_POST_INCREMENT) \|\| defined (HAVE_POST_DECREMENT))
	#define FIND_REG_INC_NOTE(INSN, REG) \
	((REG) != NULL_RTX && REG_P ((REG)) \
	? find_regno_note ((INSN), REG_INC, REGNO (REG)) \
	: find_reg_note ((INSN), REG_INC, (REG)))
	#else
	#define FIND_REG_INC_NOTE(INSN, REG) 0
	#endif

	/* Indicate whether the machine has any sort of auto increment addressing.
	If not, we can avoid checking for REG_INC notes. */

	#if (defined (HAVE_PRE_INCREMENT) \|\| defined (HAVE_PRE_DECREMENT) \|\| defined (HAVE_POST_INCREMENT) \|\| defined (HAVE_POST_DECREMENT))
	#define AUTO_INC_DEC
	#endif

	#ifndef HAVE_PRE_INCREMENT
	#define HAVE_PRE_INCREMENT 0
	#endif

	#ifndef HAVE_PRE_DECREMENT
	#define HAVE_PRE_DECREMENT 0
	#endif

	#ifndef HAVE_POST_INCREMENT
	#define HAVE_POST_INCREMENT 0
	#endif

	#ifndef HAVE_POST_DECREMENT
	#define HAVE_POST_DECREMENT 0
	#endif

	#ifndef HAVE_POST_MODIFY_DISP
	#define HAVE_POST_MODIFY_DISP 0
	#endif

	#ifndef HAVE_POST_MODIFY_REG
	#define HAVE_POST_MODIFY_REG 0
	#endif

	#ifndef HAVE_PRE_MODIFY_DISP
	#define HAVE_PRE_MODIFY_DISP 0
	#endif

	#ifndef HAVE_PRE_MODIFY_REG
	#define HAVE_PRE_MODIFY_REG 0
	#endif


	/* Some architectures do not have complete pre/post increment/decrement
	instruction sets, or only move some modes efficiently. These macros
	allow us to tune autoincrement generation. */

	#ifndef USE_LOAD_POST_INCREMENT
	#define USE_LOAD_POST_INCREMENT(MODE) HAVE_POST_INCREMENT
	#endif

	#ifndef USE_LOAD_POST_DECREMENT
	#define USE_LOAD_POST_DECREMENT(MODE) HAVE_POST_DECREMENT
	#endif

	#ifndef USE_LOAD_PRE_INCREMENT
	#define USE_LOAD_PRE_INCREMENT(MODE) HAVE_PRE_INCREMENT
	#endif

	#ifndef USE_LOAD_PRE_DECREMENT
	#define USE_LOAD_PRE_DECREMENT(MODE) HAVE_PRE_DECREMENT
	#endif

	#ifndef USE_STORE_POST_INCREMENT
	#define USE_STORE_POST_INCREMENT(MODE) HAVE_POST_INCREMENT
	#endif

	#ifndef USE_STORE_POST_DECREMENT
	#define USE_STORE_POST_DECREMENT(MODE) HAVE_POST_DECREMENT
	#endif

	#ifndef USE_STORE_PRE_INCREMENT
	#define USE_STORE_PRE_INCREMENT(MODE) HAVE_PRE_INCREMENT
	#endif

	#ifndef USE_STORE_PRE_DECREMENT
	#define USE_STORE_PRE_DECREMENT(MODE) HAVE_PRE_DECREMENT
	#endif

	/* Nonzero when we are generating CONCATs. */
	extern int generating_concat_p;

	/* Nonzero when we are expanding trees to RTL. */
	extern int currently_expanding_to_rtl;

	/* Generally useful functions. */

	/* In expmed.c */
	extern int ceil_log2 (unsigned HOST_WIDE_INT);

	/* In builtins.c */
	extern rtx expand_builtin_expect_jump (tree, rtx, rtx);

	/* In explow.c */
	extern void set_stack_check_libfunc (rtx);
	extern HOST_WIDE_INT trunc_int_for_mode (HOST_WIDE_INT, enum machine_mode);
	extern rtx plus_constant (rtx, HOST_WIDE_INT);

	/* In emit-rtl.c */
	extern rtvec gen_rtvec (int, ...);
	extern rtx copy_insn_1 (rtx);
	extern rtx copy_insn (rtx);
	extern rtx gen_int_mode (HOST_WIDE_INT, enum machine_mode);
	extern rtx emit_copy_of_insn_after (rtx, rtx);
	extern void set_reg_attrs_from_mem (rtx, rtx);
	extern void set_mem_attrs_from_reg (rtx, rtx);
	extern void set_reg_attrs_for_parm (rtx, rtx);
	extern int mem_expr_equal_p (tree, tree);

	/* In rtl.c */
	extern rtx rtx_alloc_stat (RTX_CODE MEM_STAT_DECL);
	#define rtx_alloc(c) rtx_alloc_stat (c MEM_STAT_INFO)

	extern rtvec rtvec_alloc (int);
	extern rtx copy_rtx (rtx);
	extern void dump_rtx_statistics (void);

	/* In emit-rtl.c */
	extern rtx copy_rtx_if_shared (rtx);

	/* In rtl.c */
	extern unsigned int rtx_size (rtx);
	extern rtx shallow_copy_rtx_stat (rtx MEM_STAT_DECL);
	#define shallow_copy_rtx(a) shallow_copy_rtx_stat (a MEM_STAT_INFO)
	extern int rtx_equal_p (rtx, rtx);

	/* In emit-rtl.c */
	extern rtvec gen_rtvec_v (int, rtx *);
	extern rtx gen_reg_rtx (enum machine_mode);
	extern rtx gen_rtx_REG_offset (rtx, enum machine_mode, unsigned int, int);
	extern rtx gen_label_rtx (void);
	extern rtx gen_lowpart_common (enum machine_mode, rtx);

	/* In cse.c */
	extern rtx gen_lowpart_if_possible (enum machine_mode, rtx);

	/* In emit-rtl.c */
	extern rtx gen_highpart (enum machine_mode, rtx);
	extern rtx gen_highpart_mode (enum machine_mode, enum machine_mode, rtx);
	extern rtx operand_subword (rtx, unsigned int, int, enum machine_mode);

	/* In emit-rtl.c */
	extern rtx operand_subword_force (rtx, unsigned int, enum machine_mode);
	extern int subreg_lowpart_p (rtx);
	extern unsigned int subreg_lowpart_offset (enum machine_mode,
	enum machine_mode);
	extern unsigned int subreg_highpart_offset (enum machine_mode,
	enum machine_mode);
	extern rtx make_safe_from (rtx, rtx);
	extern rtx convert_memory_address (enum machine_mode, rtx);
	extern rtx get_insns (void);
	extern const char *get_insn_name (int);
	extern rtx get_last_insn (void);
	extern rtx get_last_insn_anywhere (void);
	extern rtx get_first_nonnote_insn (void);
	extern rtx get_last_nonnote_insn (void);
	extern void start_sequence (void);
	extern void push_to_sequence (rtx);
	extern void end_sequence (void);
	extern rtx immed_double_const (HOST_WIDE_INT, HOST_WIDE_INT,
	enum machine_mode);

	/* In loop-iv.c */

	extern rtx lowpart_subreg (enum machine_mode, rtx, enum machine_mode);

	/* In varasm.c */
	extern rtx force_const_mem (enum machine_mode, rtx);

	/* In varasm.c */

	struct function;
	extern rtx get_pool_constant (rtx);
	extern rtx get_pool_constant_mark (rtx, bool *);
	extern enum machine_mode get_pool_mode (rtx);
	extern rtx simplify_subtraction (rtx);

	/* In function.c */
	extern rtx assign_stack_local (enum machine_mode, HOST_WIDE_INT, int);
	extern rtx assign_stack_temp (enum machine_mode, HOST_WIDE_INT, int);
	extern rtx assign_stack_temp_for_type (enum machine_mode,
	HOST_WIDE_INT, int, tree);
	extern rtx assign_temp (tree, int, int, int);

	/* In emit-rtl.c */
	extern rtx emit_insn_before (rtx, rtx);
	extern rtx emit_insn_before_noloc (rtx, rtx);
	extern rtx emit_insn_before_setloc (rtx, rtx, int);
	extern rtx emit_jump_insn_before (rtx, rtx);
	extern rtx emit_jump_insn_before_noloc (rtx, rtx);
	extern rtx emit_jump_insn_before_setloc (rtx, rtx, int);
	extern rtx emit_call_insn_before (rtx, rtx);
	extern rtx emit_call_insn_before_noloc (rtx, rtx);
	extern rtx emit_call_insn_before_setloc (rtx, rtx, int);
	extern rtx emit_barrier_before (rtx);
	extern rtx emit_label_before (rtx, rtx);
	extern rtx emit_note_before (int, rtx);
	extern rtx emit_insn_after (rtx, rtx);
	extern rtx emit_insn_after_noloc (rtx, rtx);
	extern rtx emit_insn_after_setloc (rtx, rtx, int);
	extern rtx emit_jump_insn_after (rtx, rtx);
	extern rtx emit_jump_insn_after_noloc (rtx, rtx);
	extern rtx emit_jump_insn_after_setloc (rtx, rtx, int);
	extern rtx emit_call_insn_after (rtx, rtx);
	extern rtx emit_call_insn_after_noloc (rtx, rtx);
	extern rtx emit_call_insn_after_setloc (rtx, rtx, int);
	extern rtx emit_barrier_after (rtx);
	extern rtx emit_label_after (rtx, rtx);
	extern rtx emit_note_after (int, rtx);
	extern rtx emit_note_copy_after (rtx, rtx);
	extern rtx emit_insn (rtx);
	extern rtx emit_jump_insn (rtx);
	extern rtx emit_call_insn (rtx);
	extern rtx emit_label (rtx);
	extern rtx emit_barrier (void);
	extern rtx emit_note (int);
	extern rtx emit_note_copy (rtx);
	extern rtx emit_line_note (location_t);
	extern rtx make_insn_raw (rtx);
	extern rtx make_jump_insn_raw (rtx);
	extern void add_function_usage_to (rtx, rtx);
	extern rtx last_call_insn (void);
	extern rtx previous_insn (rtx);
	extern rtx next_insn (rtx);
	extern rtx prev_nonnote_insn (rtx);
	extern rtx next_nonnote_insn (rtx);
	extern rtx prev_real_insn (rtx);
	extern rtx next_real_insn (rtx);
	extern rtx prev_active_insn (rtx);
	extern rtx next_active_insn (rtx);
	extern int active_insn_p (rtx);
	extern rtx prev_label (rtx);
	extern rtx next_label (rtx);
	extern rtx skip_consecutive_labels (rtx);
	extern rtx next_cc0_user (rtx);
	extern rtx prev_cc0_setter (rtx);

	/* In cfglayout.c */
	extern int insn_line (rtx);
	extern const char * insn_file (rtx);
	extern int locator_line (int);
	extern const char * locator_file (int);
	extern int prologue_locator, epilogue_locator;

	/* In jump.c */
	extern enum rtx_code reverse_condition (enum rtx_code);
	extern enum rtx_code reverse_condition_maybe_unordered (enum rtx_code);
	extern enum rtx_code swap_condition (enum rtx_code);
	extern enum rtx_code unsigned_condition (enum rtx_code);
	extern enum rtx_code signed_condition (enum rtx_code);
	extern void mark_jump_label (rtx, rtx, int);
	extern unsigned int cleanup_barriers (void);

	/* In jump.c */
	extern bool squeeze_notes (rtx , rtx );
	extern rtx delete_related_insns (rtx);
	extern void delete_jump (rtx);
	extern rtx get_label_before (rtx);
	extern rtx get_label_after (rtx);
	extern rtx follow_jumps (rtx);

	/* In recog.c */
	extern rtx find_constant_term_loc (rtx );

	/* In emit-rtl.c */
	extern rtx try_split (rtx, rtx, int);
	extern int split_branch_probability;

	/* In unknown file */
	extern rtx split_insns (rtx, rtx);

	/* In simplify-rtx.c */
	extern rtx simplify_const_unary_operation (enum rtx_code, enum machine_mode,
	rtx, enum machine_mode);
	extern rtx simplify_unary_operation (enum rtx_code, enum machine_mode, rtx,
	enum machine_mode);
	extern rtx simplify_const_binary_operation (enum rtx_code, enum machine_mode,
	rtx, rtx);
	extern rtx simplify_binary_operation (enum rtx_code, enum machine_mode, rtx,
	rtx);
	extern rtx simplify_ternary_operation (enum rtx_code, enum machine_mode,
	enum machine_mode, rtx, rtx, rtx);
	extern rtx simplify_const_relational_operation (enum rtx_code,
	enum machine_mode, rtx, rtx);
	extern rtx simplify_relational_operation (enum rtx_code, enum machine_mode,
	enum machine_mode, rtx, rtx);
	extern rtx simplify_gen_binary (enum rtx_code, enum machine_mode, rtx, rtx);
	extern rtx simplify_gen_unary (enum rtx_code, enum machine_mode, rtx,
	enum machine_mode);
	extern rtx simplify_gen_ternary (enum rtx_code, enum machine_mode,
	enum machine_mode, rtx, rtx, rtx);
	extern rtx simplify_gen_relational (enum rtx_code, enum machine_mode,
	enum machine_mode, rtx, rtx);
	extern rtx simplify_subreg (enum machine_mode, rtx, enum machine_mode,
	unsigned int);
	extern rtx simplify_gen_subreg (enum machine_mode, rtx, enum machine_mode,
	unsigned int);
	extern rtx simplify_replace_rtx (rtx, rtx, rtx);
	extern rtx simplify_rtx (rtx);
	extern rtx avoid_constant_pool_reference (rtx);
	extern bool constant_pool_reference_p (rtx x);
	extern bool mode_signbit_p (enum machine_mode, rtx);

	/* In regclass.c */
	extern enum machine_mode choose_hard_reg_mode (unsigned int, unsigned int,
	bool);

	/* In emit-rtl.c */
	extern rtx set_unique_reg_note (rtx, enum reg_note, rtx);

	/* Functions in rtlanal.c */

	/* Single set is implemented as macro for performance reasons. */
	#define single_set(I) (INSN_P (I) \
	? (GET_CODE (PATTERN (I)) == SET \
	? PATTERN (I) : single_set_1 (I)) \
	: NULL_RTX)
	#define single_set_1(I) single_set_2 (I, PATTERN (I))

	/* Structure used for passing data to REPLACE_LABEL. */
	typedef struct replace_label_data
	{
	rtx r1;
	rtx r2;
	bool update_label_nuses;
	} replace_label_data;

	extern int rtx_addr_can_trap_p (rtx);
	extern bool nonzero_address_p (rtx);
	extern int rtx_unstable_p (rtx);
	extern int rtx_varies_p (rtx, int);
	extern int rtx_addr_varies_p (rtx, int);
	extern HOST_WIDE_INT get_integer_term (rtx);
	extern rtx get_related_value (rtx);
	extern int reg_mentioned_p (rtx, rtx);
	extern int count_occurrences (rtx, rtx, int);
	extern int reg_referenced_p (rtx, rtx);
	extern int reg_used_between_p (rtx, rtx, rtx);
	extern int reg_set_between_p (rtx, rtx, rtx);
	extern int commutative_operand_precedence (rtx);
	extern int swap_commutative_operands_p (rtx, rtx);
	extern int modified_between_p (rtx, rtx, rtx);
	extern int no_labels_between_p (rtx, rtx);
	extern int modified_in_p (rtx, rtx);
	extern int reg_set_p (rtx, rtx);
	extern rtx single_set_2 (rtx, rtx);
	extern int multiple_sets (rtx);
	extern int set_noop_p (rtx);
	extern int noop_move_p (rtx);
	extern rtx find_last_value (rtx, rtx *, rtx, int);
	extern int refers_to_regno_p (unsigned int, unsigned int, rtx, rtx *);
	extern int reg_overlap_mentioned_p (rtx, rtx);
	extern rtx set_of (rtx, rtx);
	extern void note_stores (rtx, void () (rtx, rtx, void ), void *);
	extern void note_uses (rtx , void () (rtx , void ), void *);
	extern int dead_or_set_p (rtx, rtx);
	extern int dead_or_set_regno_p (rtx, unsigned int);
	extern rtx find_reg_note (rtx, enum reg_note, rtx);
	extern rtx find_regno_note (rtx, enum reg_note, unsigned int);
	extern rtx find_reg_equal_equiv_note (rtx);
	extern int find_reg_fusage (rtx, enum rtx_code, rtx);
	extern int find_regno_fusage (rtx, enum rtx_code, unsigned int);
	extern int pure_call_p (rtx);
	extern void remove_note (rtx, rtx);
	extern int side_effects_p (rtx);
	extern int volatile_refs_p (rtx);
	extern int volatile_insn_p (rtx);
	extern int may_trap_p (rtx);
	extern int may_trap_after_code_motion_p (rtx);
	extern int may_trap_or_fault_p (rtx);
	extern int inequality_comparisons_p (rtx);
	extern rtx replace_rtx (rtx, rtx, rtx);
	extern int replace_label (rtx , void );
	extern int rtx_referenced_p (rtx, rtx);
	extern bool tablejump_p (rtx, rtx , rtx );
	extern int computed_jump_p (rtx);
	typedef int (rtx_function) (rtx , void *);
	extern int for_each_rtx (rtx , rtx_function, void );
	extern rtx regno_use_in (unsigned int, rtx);
	extern int auto_inc_p (rtx);
	extern int in_expr_list_p (rtx, rtx);
	extern void remove_node_from_expr_list (rtx, rtx *);
	extern int loc_mentioned_in_p (rtx *, rtx);
	extern rtx find_first_parameter_load (rtx, rtx);
	extern bool keep_with_call_p (rtx);
	extern bool label_is_jump_target_p (rtx, rtx);
	extern int insn_rtx_cost (rtx);

	/* Given an insn and condition, return a canonical description of
	the test being made. */
	extern rtx canonicalize_condition (rtx, rtx, int, rtx *, rtx, int, int);

	/* Given a JUMP_INSN, return a canonical description of the test
	being made. */
	extern rtx get_condition (rtx, rtx *, int, int);


	/* flow.c */

	extern rtx find_use_as_address (rtx, rtx, HOST_WIDE_INT);

	/* lists.c */

	void free_EXPR_LIST_list (rtx *);
	void free_INSN_LIST_list (rtx *);
	void free_EXPR_LIST_node (rtx);
	void free_INSN_LIST_node (rtx);
	rtx alloc_INSN_LIST (rtx, rtx);
	rtx alloc_EXPR_LIST (int, rtx, rtx);
	void free_DEPS_LIST_list (rtx *);
	rtx alloc_DEPS_LIST (rtx, rtx, int);
	void remove_free_DEPS_LIST_elem (rtx, rtx *);
	void remove_free_INSN_LIST_elem (rtx, rtx *);
	rtx remove_list_elem (rtx, rtx *);
	rtx copy_DEPS_LIST_list (rtx);

	/* regclass.c */

	/* Maximum number of parallel sets and clobbers in any insn in this fn.
	Always at least 3, since the combiner could put that many together
	and we want this to remain correct for all the remaining passes. */

	extern int max_parallel;

	/* Free up register info memory. */
	extern void free_reg_info (void);

	/* recog.c */
	extern int asm_noperands (rtx);
	extern const char decode_asm_operands (rtx, rtx , rtx , const char ,
	enum machine_mode *);

	extern enum reg_class reg_preferred_class (int);
	extern enum reg_class reg_alternate_class (int);

	extern void split_all_insns (int);
	extern unsigned int split_all_insns_noflow (void);

	#define MAX_SAVED_CONST_INT 64
	extern GTY(()) rtx const_int_rtx[MAX_SAVED_CONST_INT * 2 + 1];

	#define const0_rtx (const_int_rtx[MAX_SAVED_CONST_INT])
	#define const1_rtx (const_int_rtx[MAX_SAVED_CONST_INT+1])
	#define const2_rtx (const_int_rtx[MAX_SAVED_CONST_INT+2])
	#define constm1_rtx (const_int_rtx[MAX_SAVED_CONST_INT-1])
	extern GTY(()) rtx const_true_rtx;

	extern GTY(()) rtx const_tiny_rtx[3][(int) MAX_MACHINE_MODE];

	/* Returns a constant 0 rtx in mode MODE. Integer modes are treated the
	same as VOIDmode. */

	#define CONST0_RTX(MODE) (const_tiny_rtx[0][(int) (MODE)])

	/* Likewise, for the constants 1 and 2. */

	#define CONST1_RTX(MODE) (const_tiny_rtx[1][(int) (MODE)])
	#define CONST2_RTX(MODE) (const_tiny_rtx[2][(int) (MODE)])

	/* If HARD_FRAME_POINTER_REGNUM is defined, then a special dummy reg
	is used to represent the frame pointer. This is because the
	hard frame pointer and the automatic variables are separated by an amount
	that cannot be determined until after register allocation. We can assume
	that in this case ELIMINABLE_REGS will be defined, one action of which
	will be to eliminate FRAME_POINTER_REGNUM into HARD_FRAME_POINTER_REGNUM. */
	#ifndef HARD_FRAME_POINTER_REGNUM
	#define HARD_FRAME_POINTER_REGNUM FRAME_POINTER_REGNUM
	#endif

	/* Index labels for global_rtl. */
	enum global_rtl_index
	{
	GR_PC,
	GR_CC0,
	GR_STACK_POINTER,
	GR_FRAME_POINTER,
	/* For register elimination to work properly these hard_frame_pointer_rtx,
	frame_pointer_rtx, and arg_pointer_rtx must be the same if they refer to
	the same register. */
	#if FRAME_POINTER_REGNUM == ARG_POINTER_REGNUM
	GR_ARG_POINTER = GR_FRAME_POINTER,
	#endif
	#if HARD_FRAME_POINTER_REGNUM == FRAME_POINTER_REGNUM
	GR_HARD_FRAME_POINTER = GR_FRAME_POINTER,
	#else
	GR_HARD_FRAME_POINTER,
	#endif
	#if FRAME_POINTER_REGNUM != ARG_POINTER_REGNUM
	#if HARD_FRAME_POINTER_REGNUM == ARG_POINTER_REGNUM
	GR_ARG_POINTER = GR_HARD_FRAME_POINTER,
	#else
	GR_ARG_POINTER,
	#endif
	#endif
	GR_VIRTUAL_INCOMING_ARGS,
	GR_VIRTUAL_STACK_ARGS,
	GR_VIRTUAL_STACK_DYNAMIC,
	GR_VIRTUAL_OUTGOING_ARGS,
	GR_VIRTUAL_CFA,

	GR_MAX
	};

	/* Pointers to standard pieces of rtx are stored here. */
	extern GTY(()) rtx global_rtl[GR_MAX];

	/* Standard pieces of rtx, to be substituted directly into things. */
	#define pc_rtx (global_rtl[GR_PC])
	#define cc0_rtx (global_rtl[GR_CC0])

	/* All references to certain hard regs, except those created
	by allocating pseudo regs into them (when that's possible),
	go through these unique rtx objects. */
	#define stack_pointer_rtx (global_rtl[GR_STACK_POINTER])
	#define frame_pointer_rtx (global_rtl[GR_FRAME_POINTER])
	#define hard_frame_pointer_rtx (global_rtl[GR_HARD_FRAME_POINTER])
	#define arg_pointer_rtx (global_rtl[GR_ARG_POINTER])

	extern GTY(()) rtx pic_offset_table_rtx;
	extern GTY(()) rtx static_chain_rtx;
	extern GTY(()) rtx static_chain_incoming_rtx;
	extern GTY(()) rtx return_address_pointer_rtx;

	/* Include the RTL generation functions. */

	#ifndef GENERATOR_FILE
	#include "genrtl.h"
	#ifndef USE_MAPPED_LOCATION
	#undef gen_rtx_ASM_OPERANDS
	#define gen_rtx_ASM_OPERANDS(MODE, ARG0, ARG1, ARG2, ARG3, ARG4, LOC) \
	gen_rtx_fmt_ssiEEsi (ASM_OPERANDS, (MODE), (ARG0), (ARG1), (ARG2), (ARG3), (ARG4), (LOC).file, (LOC).line)
	#endif
	#endif

	/* There are some RTL codes that require special attention; the
	generation functions included above do the raw handling. If you
	add to this list, modify special_rtx in gengenrtl.c as well. */

	extern rtx gen_rtx_CONST_INT (enum machine_mode, HOST_WIDE_INT);
	extern rtx gen_rtx_CONST_VECTOR (enum machine_mode, rtvec);
	extern rtx gen_raw_REG (enum machine_mode, int);
	extern rtx gen_rtx_REG (enum machine_mode, unsigned);
	extern rtx gen_rtx_SUBREG (enum machine_mode, rtx, int);
	extern rtx gen_rtx_MEM (enum machine_mode, rtx);

	#define GEN_INT(N) gen_rtx_CONST_INT (VOIDmode, (N))

	/* Virtual registers are used during RTL generation to refer to locations into
	the stack frame when the actual location isn't known until RTL generation
	is complete. The routine instantiate_virtual_regs replaces these with
	the proper value, which is normally {frame,arg,stack}_pointer_rtx plus
	a constant. */

	#define FIRST_VIRTUAL_REGISTER (FIRST_PSEUDO_REGISTER)

	/* This points to the first word of the incoming arguments passed on the stack,
	either by the caller or by the callee when pretending it was passed by the
	caller. */

	#define virtual_incoming_args_rtx (global_rtl[GR_VIRTUAL_INCOMING_ARGS])

	#define VIRTUAL_INCOMING_ARGS_REGNUM (FIRST_VIRTUAL_REGISTER)

	/* If FRAME_GROWS_DOWNWARD, this points to immediately above the first
	variable on the stack. Otherwise, it points to the first variable on
	the stack. */

	#define virtual_stack_vars_rtx (global_rtl[GR_VIRTUAL_STACK_ARGS])

	#define VIRTUAL_STACK_VARS_REGNUM ((FIRST_VIRTUAL_REGISTER) + 1)

	/* This points to the location of dynamically-allocated memory on the stack
	immediately after the stack pointer has been adjusted by the amount
	desired. */

	#define virtual_stack_dynamic_rtx (global_rtl[GR_VIRTUAL_STACK_DYNAMIC])

	#define VIRTUAL_STACK_DYNAMIC_REGNUM ((FIRST_VIRTUAL_REGISTER) + 2)

	/* This points to the location in the stack at which outgoing arguments should
	be written when the stack is pre-pushed (arguments pushed using push
	insns always use sp). */

	#define virtual_outgoing_args_rtx (global_rtl[GR_VIRTUAL_OUTGOING_ARGS])

	#define VIRTUAL_OUTGOING_ARGS_REGNUM ((FIRST_VIRTUAL_REGISTER) + 3)

	/* This points to the Canonical Frame Address of the function. This
	should correspond to the CFA produced by INCOMING_FRAME_SP_OFFSET,
	but is calculated relative to the arg pointer for simplicity; the
	frame pointer nor stack pointer are necessarily fixed relative to
	the CFA until after reload. */

	#define virtual_cfa_rtx (global_rtl[GR_VIRTUAL_CFA])

	#define VIRTUAL_CFA_REGNUM ((FIRST_VIRTUAL_REGISTER) + 4)

	#define LAST_VIRTUAL_REGISTER ((FIRST_VIRTUAL_REGISTER) + 4)

	/* Nonzero if REGNUM is a pointer into the stack frame. */
	#define REGNO_PTR_FRAME_P(REGNUM) \
	((REGNUM) == STACK_POINTER_REGNUM \
	\|\| (REGNUM) == FRAME_POINTER_REGNUM \
	\|\| (REGNUM) == HARD_FRAME_POINTER_REGNUM \
	\|\| (REGNUM) == ARG_POINTER_REGNUM \
	\|\| ((REGNUM) >= FIRST_VIRTUAL_REGISTER \
	&& (REGNUM) <= LAST_VIRTUAL_REGISTER))

	/* REGNUM never really appearing in the INSN stream. */
	#define INVALID_REGNUM (~(unsigned int) 0)

	extern rtx output_constant_def (tree, int);
	extern rtx lookup_constant_def (tree);

	/* Nonzero after the second flow pass has completed.
	Set to 1 or 0 by toplev.c */
	extern int flow2_completed;

	/* Nonzero after end of reload pass.
	Set to 1 or 0 by reload1.c. */

	extern int reload_completed;

	/* Nonzero after thread_prologue_and_epilogue_insns has run. */
	extern int epilogue_completed;

	/* Set to 1 while reload_as_needed is operating.
	Required by some machines to handle any generated moves differently. */

	extern int reload_in_progress;

	#ifdef STACK_REGS
	/* Nonzero after end of regstack pass.
	Set to 1 or 0 by reg-stack.c. */
	extern int regstack_completed;
	#endif

	/* If this is nonzero, we do not bother generating VOLATILE
	around volatile memory references, and we are willing to
	output indirect addresses. If cse is to follow, we reject
	indirect addresses so a useful potential cse is generated;
	if it is used only once, instruction combination will produce
	the same indirect address eventually. */
	extern int cse_not_expected;

	/* Set to nonzero before life analysis to indicate that it is unsafe to
	generate any new pseudo registers. */
	extern int no_new_pseudos;

	/* Translates rtx code to tree code, for those codes needed by
	REAL_ARITHMETIC. The function returns an int because the caller may not
	know what `enum tree_code' means. */

	extern int rtx_to_tree_code (enum rtx_code);

	/* In cse.c */
	extern int delete_trivially_dead_insns (rtx, int);
	extern int cse_main (rtx, int);
	extern int exp_equiv_p (rtx, rtx, int, bool);
	extern unsigned hash_rtx (rtx x, enum machine_mode, int , int , bool);

	/* In jump.c */
	extern int comparison_dominates_p (enum rtx_code, enum rtx_code);
	extern int condjump_p (rtx);
	extern int any_condjump_p (rtx);
	extern int any_uncondjump_p (rtx);
	extern rtx pc_set (rtx);
	extern rtx condjump_label (rtx);
	extern int simplejump_p (rtx);
	extern int returnjump_p (rtx);
	extern int onlyjump_p (rtx);
	extern int only_sets_cc0_p (rtx);
	extern int sets_cc0_p (rtx);
	extern int invert_jump_1 (rtx, rtx);
	extern int invert_jump (rtx, rtx, int);
	extern int rtx_renumbered_equal_p (rtx, rtx);
	extern int true_regnum (rtx);
	extern unsigned int reg_or_subregno (rtx);
	extern int redirect_jump_1 (rtx, rtx);
	extern void redirect_jump_2 (rtx, rtx, rtx, int, int);
	extern int redirect_jump (rtx, rtx, int);
	extern void rebuild_jump_labels (rtx);
	extern rtx reversed_comparison (rtx, enum machine_mode);
	extern enum rtx_code reversed_comparison_code (rtx, rtx);
	extern enum rtx_code reversed_comparison_code_parts (enum rtx_code,
	rtx, rtx, rtx);
	extern void delete_for_peephole (rtx, rtx);
	extern int condjump_in_parallel_p (rtx);
	extern unsigned int purge_line_number_notes (void);

	/* In emit-rtl.c. */
	extern int max_reg_num (void);
	extern int max_label_num (void);
	extern int get_first_label_num (void);
	extern void maybe_set_first_label_num (rtx);
	extern void delete_insns_since (rtx);
	extern void mark_reg_pointer (rtx, int);
	extern void mark_user_reg (rtx);
	extern void reset_used_flags (rtx);
	extern void set_used_flags (rtx);
	extern void reorder_insns (rtx, rtx, rtx);
	extern void reorder_insns_nobb (rtx, rtx, rtx);
	extern int get_max_uid (void);
	extern int in_sequence_p (void);
	extern void force_next_line_note (void);
	extern void init_emit (void);
	extern void init_emit_once (int);
	extern void push_topmost_sequence (void);
	extern void pop_topmost_sequence (void);
	extern void set_new_first_and_last_insn (rtx, rtx);
	extern unsigned int unshare_all_rtl (void);
	extern void unshare_all_rtl_again (rtx);
	extern void unshare_all_rtl_in_chain (rtx);
	extern void verify_rtl_sharing (void);
	extern void set_first_insn (rtx);
	extern void set_last_insn (rtx);
	extern void link_cc0_insns (rtx);
	extern void add_insn (rtx);
	extern void add_insn_before (rtx, rtx);
	extern void add_insn_after (rtx, rtx);
	extern void remove_insn (rtx);
	extern void emit_insn_after_with_line_notes (rtx, rtx, rtx);
	extern rtx emit (rtx);
	extern void renumber_insns (void);
	extern rtx delete_insn (rtx);
	extern rtx entry_of_function (void);
	extern void emit_insn_at_entry (rtx);
	extern void delete_insn_chain (rtx, rtx);
	extern rtx unlink_insn_chain (rtx, rtx);
	extern rtx delete_insn_and_edges (rtx);
	extern void delete_insn_chain_and_edges (rtx, rtx);
	extern rtx gen_lowpart_SUBREG (enum machine_mode, rtx);
	extern rtx gen_const_mem (enum machine_mode, rtx);
	extern rtx gen_frame_mem (enum machine_mode, rtx);
	extern rtx gen_tmp_stack_mem (enum machine_mode, rtx);
	extern bool validate_subreg (enum machine_mode, enum machine_mode,
	rtx, unsigned int);

	/* In combine.c */
	extern unsigned int extended_count (rtx, enum machine_mode, int);
	extern rtx remove_death (unsigned int, rtx);
	extern void dump_combine_stats (FILE *);
	extern void dump_combine_total_stats (FILE *);

	/* In sched-vis.c. */
	extern void print_rtl_slim_with_bb (FILE *, rtx, int);
	extern void dump_insn_slim (FILE *f, rtx x);
	extern void debug_insn_slim (rtx x);

	/* In sched-rgn.c. */
	extern void schedule_insns (void);

	/* In sched-ebb.c. */
	extern void schedule_ebbs (void);

	/* In haifa-sched.c. */
	extern void fix_sched_param (const char , const char );

	/* In print-rtl.c */
	extern const char *print_rtx_head;
	extern void debug_rtx (rtx);
	extern void debug_rtx_list (rtx, int);
	extern void debug_rtx_range (rtx, rtx);
	extern rtx debug_rtx_find (rtx, int);
	extern void print_mem_expr (FILE *, tree);
	extern void print_rtl (FILE *, rtx);
	extern void print_simple_rtl (FILE *, rtx);
	extern int print_rtl_single (FILE *, rtx);
	extern void print_inline_rtx (FILE *, rtx, int);

	/* In bt-load.c */
	extern void branch_target_load_optimize (bool);

	/* In function.c */
	extern void reposition_prologue_and_epilogue_notes (rtx);
	extern void thread_prologue_and_epilogue_insns (rtx);
	extern int prologue_epilogue_contains (rtx);
	extern int sibcall_epilogue_contains (rtx);
	extern void mark_temp_addr_taken (rtx);
	extern void update_temp_slot_address (rtx, rtx);

	/* In stmt.c */
	extern void expand_null_return (void);
	extern void expand_naked_return (void);
	extern void emit_jump (rtx);

	/* In expr.c */
	extern rtx move_by_pieces (rtx, rtx, unsigned HOST_WIDE_INT,
	unsigned int, int);

	/* In flow.c */
	extern void delete_dead_jumptables (void);
	extern void print_rtl_with_bb (FILE *, rtx);
	extern void dump_flow_info (FILE *, int);

	/* In expmed.c */
	extern void init_expmed (void);
	extern void expand_inc (rtx, rtx);
	extern void expand_dec (rtx, rtx);

	/* In gcse.c */
	extern bool can_copy_p (enum machine_mode);
	extern rtx fis_get_condition (rtx);

	/* In global.c */
	extern void mark_elimination (int, int);
	extern void dump_global_regs (FILE *);
	#ifdef HARD_CONST
	/* Yes, this ifdef is silly, but HARD_REG_SET is not always defined. */
	extern void retry_global_alloc (int, HARD_REG_SET);
	#endif
	extern void build_insn_chain (rtx);

	/* In regclass.c */
	extern int reg_classes_intersect_p (enum reg_class, enum reg_class);
	extern int reg_class_subset_p (enum reg_class, enum reg_class);
	extern void globalize_reg (int);
	extern void init_reg_modes_once (void);
	extern void init_regs (void);
	extern void init_fake_stack_mems (void);
	extern void init_reg_sets (void);
	extern void regclass_init (void);
	extern void regclass (rtx, int);
	extern void reg_scan (rtx, unsigned int);
	extern void fix_register (const char *, int, int);
	extern void init_subregs_of_mode (void);
	extern void record_subregs_of_mode (rtx);
	#ifdef HARD_CONST
	extern void cannot_change_mode_set_regs (HARD_REG_SET *,
	enum machine_mode, unsigned int);
	#endif
	extern bool invalid_mode_change_p (unsigned int, enum reg_class,
	enum machine_mode);

	/* In reorg.c */
	extern void dbr_schedule (rtx);

	/* In local-alloc.c */
	extern void dump_local_alloc (FILE *);

	/* In reload1.c */
	extern int function_invariant_p (rtx);

	/* In calls.c */
	enum libcall_type
	{
	LCT_NORMAL = 0,
	LCT_CONST = 1,
	LCT_PURE = 2,
	LCT_CONST_MAKE_BLOCK = 3,
	LCT_PURE_MAKE_BLOCK = 4,
	LCT_NORETURN = 5,
	LCT_THROW = 6,
	LCT_RETURNS_TWICE = 7
	};

	extern void emit_library_call (rtx, enum libcall_type, enum machine_mode, int,
	...);
	extern rtx emit_library_call_value (rtx, rtx, enum libcall_type,
	enum machine_mode, int, ...);

	/* In varasm.c */
	extern void init_varasm_once (void);
	extern enum tls_model decl_default_tls_model (tree);

	/* In rtl.c */
	extern void traverse_md_constants (int () (void , void ), void *);
	struct md_constant { char name, value; };

	/* In read-rtl.c */
	extern int read_skip_spaces (FILE *);
	extern bool read_rtx (FILE , rtx , int *);
	extern void copy_rtx_ptr_loc (const void , const void );
	extern void print_rtx_ptr_loc (const void *);
	extern const char join_c_conditions (const char , const char *);
	extern void print_c_condition (const char *);
	extern const char *read_rtx_filename;
	extern int read_rtx_lineno;

	/* In alias.c */
	extern void clear_reg_alias_info (rtx);
	extern rtx canon_rtx (rtx);
	extern int true_dependence (rtx, enum machine_mode, rtx, int (*)(rtx, int));
	extern rtx get_addr (rtx);
	extern int canon_true_dependence (rtx, enum machine_mode, rtx, rtx,
	int (*)(rtx, int));
	extern int read_dependence (rtx, rtx);
	extern int anti_dependence (rtx, rtx);
	extern int output_dependence (rtx, rtx);
	extern void init_alias_once (void);
	extern void init_alias_analysis (void);
	extern void end_alias_analysis (void);
	extern bool memory_modified_in_insn_p (rtx, rtx);
	extern rtx find_base_term (rtx);
	extern rtx gen_hard_reg_clobber (enum machine_mode, unsigned int);
	extern rtx get_reg_known_value (unsigned int);
	extern bool get_reg_known_equiv_p (unsigned int);

	#ifdef STACK_REGS
	extern int stack_regs_mentioned (rtx insn);
	#endif

	/* In toplev.c */
	extern GTY(()) rtx stack_limit_rtx;

	/* In predict.c */
	extern void invert_br_probabilities (rtx);
	extern bool expensive_function_p (int);
	/* In tracer.c */
	extern void tracer (unsigned int);

	/* In var-tracking.c */
	extern unsigned int variable_tracking_main (void);

	/* In stor-layout.c. */
	extern void get_mode_bounds (enum machine_mode, int, enum machine_mode,
	rtx , rtx );

	/* In loop-unswitch.c */
	extern rtx reversed_condition (rtx);
	extern rtx compare_and_jump_seq (rtx, rtx, enum rtx_code, rtx, int, rtx);

	/* In loop-iv.c */
	extern rtx canon_condition (rtx);
	extern void simplify_using_condition (rtx, rtx , struct bitmap_head_def );

	struct rtl_hooks
	{
	rtx (*gen_lowpart) (enum machine_mode, rtx);
	rtx (*gen_lowpart_no_emit) (enum machine_mode, rtx);
	rtx (*reg_nonzero_bits) (rtx, enum machine_mode, rtx, enum machine_mode,
	unsigned HOST_WIDE_INT, unsigned HOST_WIDE_INT *);
	rtx (*reg_num_sign_bit_copies) (rtx, enum machine_mode, rtx, enum machine_mode,
	unsigned int, unsigned int *);
	bool (*reg_truncated_to_mode) (enum machine_mode, rtx);

	/* Whenever you add entries here, make sure you adjust rtlhooks-def.h. */
	};

	/* Each pass can provide its own. */
	extern struct rtl_hooks rtl_hooks;

	/* ... but then it has to restore these. */
	extern const struct rtl_hooks general_rtl_hooks;

	/* Keep this for the nonce. */
	#define gen_lowpart rtl_hooks.gen_lowpart

	#endif /* ! GCC_RTL_H */
	diff --git a/contrib/gcc/stmt.c b/contrib/gcc/stmt.c
	index 671e98a7206a..279691b5b1f2 100644
	--- a/contrib/gcc/stmt.c
	+++ b/contrib/gcc/stmt.c
	@@ -1,3303 +1,3314 @@
	/* Expands front end tree to back end RTL for GCC
	Copyright (C) 1987, 1988, 1989, 1992, 1993, 1994, 1995, 1996, 1997,
	1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006
	Free Software Foundation, Inc.

	This file is part of GCC.

	GCC is free software; you can redistribute it and/or modify it under
	the terms of the GNU General Public License as published by the Free
	Software Foundation; either version 2, or (at your option) any later
	version.

	GCC is distributed in the hope that it will be useful, but WITHOUT ANY
	WARRANTY; without even the implied warranty of MERCHANTABILITY or
	FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	for more details.

	You should have received a copy of the GNU General Public License
	along with GCC; see the file COPYING. If not, write to the Free
	Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
	02110-1301, USA. */

	/* This file handles the generation of rtl code from tree structure
	above the level of expressions, using subroutines in exp*.c and emit-rtl.c.
	The functions whose names start with `expand_' are called by the
	expander to generate RTL instructions for various kinds of constructs. */

	#include "config.h"
	#include "system.h"
	#include "coretypes.h"
	#include "tm.h"

	#include "rtl.h"
	#include "hard-reg-set.h"
	#include "tree.h"
	#include "tm_p.h"
	#include "flags.h"
	#include "except.h"
	#include "function.h"
	#include "insn-config.h"
	#include "expr.h"
	#include "libfuncs.h"
	#include "recog.h"
	#include "machmode.h"
	#include "toplev.h"
	#include "output.h"
	#include "ggc.h"
	#include "langhooks.h"
	#include "predict.h"
	#include "optabs.h"
	#include "target.h"
	#include "regs.h"

	/* Functions and data structures for expanding case statements. */

	/* Case label structure, used to hold info on labels within case
	statements. We handle "range" labels; for a single-value label
	as in C, the high and low limits are the same.

	We start with a vector of case nodes sorted in ascending order, and
	the default label as the last element in the vector. Before expanding
	to RTL, we transform this vector into a list linked via the RIGHT
	fields in the case_node struct. Nodes with higher case values are
	later in the list.

	Switch statements can be output in three forms. A branch table is
	used if there are more than a few labels and the labels are dense
	within the range between the smallest and largest case value. If a
	branch table is used, no further manipulations are done with the case
	node chain.

	The alternative to the use of a branch table is to generate a series
	of compare and jump insns. When that is done, we use the LEFT, RIGHT,
	and PARENT fields to hold a binary tree. Initially the tree is
	totally unbalanced, with everything on the right. We balance the tree
	with nodes on the left having lower case values than the parent
	and nodes on the right having higher values. We then output the tree
	in order.

	For very small, suitable switch statements, we can generate a series
	of simple bit test and branches instead. */

	struct case_node GTY(())
	{
	struct case_node left; / Left son in binary tree */
	struct case_node right; / Right son in binary tree; also node chain */
	struct case_node parent; / Parent of node in binary tree */
	tree low; /* Lowest index value for this label */
	tree high; /* Highest index value for this label */
	tree code_label; /* Label to jump to when node matches */
	};

	typedef struct case_node case_node;
	typedef struct case_node *case_node_ptr;

	/* These are used by estimate_case_costs and balance_case_nodes. */

	/* This must be a signed type, and non-ANSI compilers lack signed char. */
	static short cost_table_[129];
	static int use_cost_table;
	static int cost_table_initialized;

	/* Special care is needed because we allow -1, but TREE_INT_CST_LOW
	is unsigned. */
	#define COST_TABLE(I) cost_table_[(unsigned HOST_WIDE_INT) ((I) + 1)]

	static int n_occurrences (int, const char *);
	static bool tree_conflicts_with_clobbers_p (tree, HARD_REG_SET *);
	static void expand_nl_goto_receiver (void);
	static bool check_operand_nalternatives (tree, tree);
	static bool check_unique_operand_names (tree, tree);
	static char resolve_operand_name_1 (char , tree, tree);
	static void expand_null_return_1 (void);
	static void expand_value_return (rtx);
	static int estimate_case_costs (case_node_ptr);
	static bool lshift_cheap_p (void);
	static int case_bit_test_cmp (const void , const void );
	static void emit_case_bit_tests (tree, tree, tree, tree, case_node_ptr, rtx);
	static void balance_case_nodes (case_node_ptr *, case_node_ptr);
	static int node_has_low_bound (case_node_ptr, tree);
	static int node_has_high_bound (case_node_ptr, tree);
	static int node_is_bounded (case_node_ptr, tree);
	static void emit_case_nodes (rtx, case_node_ptr, rtx, tree);
	static struct case_node add_case_node (struct case_node , tree,
	tree, tree, tree);


	/* Return the rtx-label that corresponds to a LABEL_DECL,
	creating it if necessary. */

	rtx
	label_rtx (tree label)
	{
	gcc_assert (TREE_CODE (label) == LABEL_DECL);

	if (!DECL_RTL_SET_P (label))
	{
	rtx r = gen_label_rtx ();
	+/* APPLE LOCAL begin for-fsf-4_4 3274130 5295549 */ \
	+ unsigned align = DECL_ALIGN_UNIT (label);
	+ int align_log2 = exact_log2 (align);
	+
	+/* APPLE LOCAL end for-fsf-4_4 3274130 5295549 */ \
	SET_DECL_RTL (label, r);
	if (FORCED_LABEL (label) \|\| DECL_NONLOCAL (label))
	LABEL_PRESERVE_P (r) = 1;
	+/* APPLE LOCAL begin for-fsf-4_4 3274130 5295549 */ \
	+
	+ if (align_log2 >= 0 && align_log2 <= 0xFF)
	+ SET_LABEL_ALIGN (r, align_log2, align - 1);
	+/* APPLE LOCAL end for-fsf-4_4 3274130 5295549 */ \
	}

	return DECL_RTL (label);
	}

	/* As above, but also put it on the forced-reference list of the
	function that contains it. */
	rtx
	force_label_rtx (tree label)
	{
	rtx ref = label_rtx (label);
	tree function = decl_function_context (label);
	struct function *p;

	gcc_assert (function);

	if (function != current_function_decl)
	p = find_function_data (function);
	else
	p = cfun;

	p->expr->x_forced_labels = gen_rtx_EXPR_LIST (VOIDmode, ref,
	p->expr->x_forced_labels);
	return ref;
	}

	/* Add an unconditional jump to LABEL as the next sequential instruction. */

	void
	emit_jump (rtx label)
	{
	do_pending_stack_adjust ();
	emit_jump_insn (gen_jump (label));
	emit_barrier ();
	}

	/* Emit code to jump to the address
	specified by the pointer expression EXP. */

	void
	expand_computed_goto (tree exp)
	{
	rtx x = expand_normal (exp);

	x = convert_memory_address (Pmode, x);

	do_pending_stack_adjust ();
	emit_indirect_jump (x);
	}

	/* Handle goto statements and the labels that they can go to. */

	/* Specify the location in the RTL code of a label LABEL,
	which is a LABEL_DECL tree node.

	- This is used for the kind of label that the user can jump to with a
	- goto statement, and for alternatives of a switch or case statement.
	- RTL labels generated for loops and conditionals don't go through here;
	- they are generated directly at the RTL level, by other functions below.
	+ APPLE LOCAL begin for-fsf-4_4 3274130 5295549
	+ This is used for those labels created by the front-end that survive
	+ through CFG generation, including all user labels. (Some labels
	+ are removed by cleanup_dead_labels in tree-cfg.c.)

	+ APPLE LOCAL end for-fsf-4_4 3274130 5295549
	Note that this has nothing to do with defining label names.
	Languages vary in how they do that and what that even means. */

	void
	expand_label (tree label)
	{
	rtx label_r = label_rtx (label);

	do_pending_stack_adjust ();
	emit_label (label_r);
	if (DECL_NAME (label))
	LABEL_NAME (DECL_RTL (label)) = IDENTIFIER_POINTER (DECL_NAME (label));

	if (DECL_NONLOCAL (label))
	{
	expand_nl_goto_receiver ();
	nonlocal_goto_handler_labels
	= gen_rtx_EXPR_LIST (VOIDmode, label_r,
	nonlocal_goto_handler_labels);
	}

	if (FORCED_LABEL (label))
	forced_labels = gen_rtx_EXPR_LIST (VOIDmode, label_r, forced_labels);

	if (DECL_NONLOCAL (label) \|\| FORCED_LABEL (label))
	maybe_set_first_label_num (label_r);
	}

	/* Generate RTL code for a `goto' statement with target label LABEL.
	LABEL should be a LABEL_DECL tree node that was or will later be
	defined with `expand_label'. */

	void
	expand_goto (tree label)
	{
	#ifdef ENABLE_CHECKING
	/* Check for a nonlocal goto to a containing function. Should have
	gotten translated to __builtin_nonlocal_goto. */
	tree context = decl_function_context (label);
	gcc_assert (!context \|\| context == current_function_decl);
	#endif

	emit_jump (label_rtx (label));
	}

	/* Return the number of times character C occurs in string S. */
	static int
	n_occurrences (int c, const char *s)
	{
	int n = 0;
	while (*s)
	n += (*s++ == c);
	return n;
	}

	/* Generate RTL for an asm statement (explicit assembler code).
	STRING is a STRING_CST node containing the assembler code text,
	or an ADDR_EXPR containing a STRING_CST. VOL nonzero means the
	insn is volatile; don't optimize it. */

	static void
	expand_asm (tree string, int vol)
	{
	rtx body;

	if (TREE_CODE (string) == ADDR_EXPR)
	string = TREE_OPERAND (string, 0);

	body = gen_rtx_ASM_INPUT (VOIDmode,
	ggc_strdup (TREE_STRING_POINTER (string)));

	MEM_VOLATILE_P (body) = vol;

	emit_insn (body);
	}

	/* Parse the output constraint pointed to by *CONSTRAINT_P. It is the
	OPERAND_NUMth output operand, indexed from zero. There are NINPUTS
	inputs and NOUTPUTS outputs to this extended-asm. Upon return,
	*ALLOWS_MEM will be TRUE iff the constraint allows the use of a
	memory operand. Similarly, *ALLOWS_REG will be TRUE iff the
	constraint allows the use of a register operand. And, *IS_INOUT
	will be true if the operand is read-write, i.e., if it is used as
	an input as well as an output. If *CONSTRAINT_P is not in
	canonical form, it will be made canonical. (Note that `+' will be
	replaced with `=' as part of this process.)

	Returns TRUE if all went well; FALSE if an error occurred. */

	bool
	parse_output_constraint (const char **constraint_p, int operand_num,
	int ninputs, int noutputs, bool *allows_mem,
	bool allows_reg, bool is_inout)
	{
	const char constraint = constraint_p;
	const char *p;

	/* Assume the constraint doesn't allow the use of either a register
	or memory. */
	*allows_mem = false;
	*allows_reg = false;

	/* Allow the `=' or `+' to not be at the beginning of the string,
	since it wasn't explicitly documented that way, and there is a
	large body of code that puts it last. Swap the character to
	the front, so as not to uglify any place else. */
	p = strchr (constraint, '=');
	if (!p)
	p = strchr (constraint, '+');

	/* If the string doesn't contain an `=', issue an error
	message. */
	if (!p)
	{
	error ("output operand constraint lacks %<=%>");
	return false;
	}

	/* If the constraint begins with `+', then the operand is both read
	from and written to. */
	is_inout = (p == '+');

	/* Canonicalize the output constraint so that it begins with `='. */
	if (p != constraint \|\| *is_inout)
	{
	char *buf;
	size_t c_len = strlen (constraint);

	if (p != constraint)
	warning (0, "output constraint %qc for operand %d "
	"is not at the beginning",
	*p, operand_num);

	/* Make a copy of the constraint. */
	buf = alloca (c_len + 1);
	strcpy (buf, constraint);
	/* Swap the first character and the `=' or `+'. */
	buf[p - constraint] = buf[0];
	/* Make sure the first character is an `='. (Until we do this,
	it might be a `+'.) */
	buf[0] = '=';
	/* Replace the constraint with the canonicalized string. */
	*constraint_p = ggc_alloc_string (buf, c_len);
	constraint = *constraint_p;
	}

	/* Loop through the constraint string. */
	for (p = constraint + 1; p; p += CONSTRAINT_LEN (p, p))
	switch (*p)
	{
	case '+':
	case '=':
	error ("operand constraint contains incorrectly positioned "
	"%<+%> or %<=%>");
	return false;

	case '%':
	if (operand_num + 1 == ninputs + noutputs)
	{
	error ("%<%%%> constraint used with last operand");
	return false;
	}
	break;

	case 'V': case 'm': case 'o':
	*allows_mem = true;
	break;

	case '?': case '!': case '*': case '&': case '#':
	case 'E': case 'F': case 'G': case 'H':
	case 's': case 'i': case 'n':
	case 'I': case 'J': case 'K': case 'L': case 'M':
	case 'N': case 'O': case 'P': case ',':
	break;

	case '0': case '1': case '2': case '3': case '4':
	case '5': case '6': case '7': case '8': case '9':
	case '[':
	error ("matching constraint not valid in output operand");
	return false;

	case '<': case '>':
	/* ??? Before flow, auto inc/dec insns are not supposed to exist,
	excepting those that expand_call created. So match memory
	and hope. */
	*allows_mem = true;
	break;

	case 'g': case 'X':
	*allows_reg = true;
	*allows_mem = true;
	break;

	case 'p': case 'r':
	*allows_reg = true;
	break;

	default:
	if (!ISALPHA (*p))
	break;
	if (REG_CLASS_FROM_CONSTRAINT (*p, p) != NO_REGS)
	*allows_reg = true;
	#ifdef EXTRA_CONSTRAINT_STR
	else if (EXTRA_ADDRESS_CONSTRAINT (*p, p))
	*allows_reg = true;
	else if (EXTRA_MEMORY_CONSTRAINT (*p, p))
	*allows_mem = true;
	else
	{
	/* Otherwise we can't assume anything about the nature of
	the constraint except that it isn't purely registers.
	Treat it like "g" and hope for the best. */
	*allows_reg = true;
	*allows_mem = true;
	}
	#endif
	break;
	}

	return true;
	}

	/* Similar, but for input constraints. */

	bool
	parse_input_constraint (const char **constraint_p, int input_num,
	int ninputs, int noutputs, int ninout,
	const char * const * constraints,
	bool allows_mem, bool allows_reg)
	{
	const char constraint = constraint_p;
	const char *orig_constraint = constraint;
	size_t c_len = strlen (constraint);
	size_t j;
	bool saw_match = false;

	/* Assume the constraint doesn't allow the use of either
	a register or memory. */
	*allows_mem = false;
	*allows_reg = false;

	/* Make sure constraint has neither `=', `+', nor '&'. */

	for (j = 0; j < c_len; j += CONSTRAINT_LEN (constraint[j], constraint+j))
	switch (constraint[j])
	{
	case '+': case '=': case '&':
	if (constraint == orig_constraint)
	{
	error ("input operand constraint contains %qc", constraint[j]);
	return false;
	}
	break;

	case '%':
	if (constraint == orig_constraint
	&& input_num + 1 == ninputs - ninout)
	{
	error ("%<%%%> constraint used with last operand");
	return false;
	}
	break;

	case 'V': case 'm': case 'o':
	*allows_mem = true;
	break;

	case '<': case '>':
	case '?': case '!': case '*': case '#':
	case 'E': case 'F': case 'G': case 'H':
	case 's': case 'i': case 'n':
	case 'I': case 'J': case 'K': case 'L': case 'M':
	case 'N': case 'O': case 'P': case ',':
	break;

	/* Whether or not a numeric constraint allows a register is
	decided by the matching constraint, and so there is no need
	to do anything special with them. We must handle them in
	the default case, so that we don't unnecessarily force
	operands to memory. */
	case '0': case '1': case '2': case '3': case '4':
	case '5': case '6': case '7': case '8': case '9':
	{
	char *end;
	unsigned long match;

	saw_match = true;

	match = strtoul (constraint + j, &end, 10);
	if (match >= (unsigned long) noutputs)
	{
	error ("matching constraint references invalid operand number");
	return false;
	}

	/* Try and find the real constraint for this dup. Only do this
	if the matching constraint is the only alternative. */
	if (*end == '\0'
	&& (j == 0 \|\| (j == 1 && constraint[0] == '%')))
	{
	constraint = constraints[match];
	*constraint_p = constraint;
	c_len = strlen (constraint);
	j = 0;
	/* ??? At the end of the loop, we will skip the first part of
	the matched constraint. This assumes not only that the
	other constraint is an output constraint, but also that
	the '=' or '+' come first. */
	break;
	}
	else
	j = end - constraint;
	/* Anticipate increment at end of loop. */
	j--;
	}
	/* Fall through. */

	case 'p': case 'r':
	*allows_reg = true;
	break;

	case 'g': case 'X':
	*allows_reg = true;
	*allows_mem = true;
	break;

	default:
	if (! ISALPHA (constraint[j]))
	{
	error ("invalid punctuation %qc in constraint", constraint[j]);
	return false;
	}
	if (REG_CLASS_FROM_CONSTRAINT (constraint[j], constraint + j)
	!= NO_REGS)
	*allows_reg = true;
	#ifdef EXTRA_CONSTRAINT_STR
	else if (EXTRA_ADDRESS_CONSTRAINT (constraint[j], constraint + j))
	*allows_reg = true;
	else if (EXTRA_MEMORY_CONSTRAINT (constraint[j], constraint + j))
	*allows_mem = true;
	else
	{
	/* Otherwise we can't assume anything about the nature of
	the constraint except that it isn't purely registers.
	Treat it like "g" and hope for the best. */
	*allows_reg = true;
	*allows_mem = true;
	}
	#endif
	break;
	}

	if (saw_match && !*allows_reg)
	warning (0, "matching constraint does not allow a register");

	return true;
	}

	/* Return DECL iff there's an overlap between *REGS and DECL, where DECL
	can be an asm-declared register. Called via walk_tree. */

	static tree
	decl_overlaps_hard_reg_set_p (tree declp, int walk_subtrees ATTRIBUTE_UNUSED,
	void *data)
	{
	tree decl = *declp;
	const HARD_REG_SET *regs = data;

	if (TREE_CODE (decl) == VAR_DECL)
	{
	if (DECL_HARD_REGISTER (decl)
	&& REG_P (DECL_RTL (decl))
	&& REGNO (DECL_RTL (decl)) < FIRST_PSEUDO_REGISTER)
	{
	rtx reg = DECL_RTL (decl);
	unsigned int regno;

	for (regno = REGNO (reg);
	regno < (REGNO (reg)
	+ hard_regno_nregs[REGNO (reg)][GET_MODE (reg)]);
	regno++)
	if (TEST_HARD_REG_BIT (*regs, regno))
	return decl;
	}
	walk_subtrees = 0;
	}
	else if (TYPE_P (decl) \|\| TREE_CODE (decl) == PARM_DECL)
	walk_subtrees = 0;
	return NULL_TREE;
	}

	/* If there is an overlap between *REGS and DECL, return the first overlap
	found. */
	tree
	tree_overlaps_hard_reg_set (tree decl, HARD_REG_SET *regs)
	{
	return walk_tree (&decl, decl_overlaps_hard_reg_set_p, regs, NULL);
	}

	/* Check for overlap between registers marked in CLOBBERED_REGS and
	anything inappropriate in T. Emit error and return the register
	variable definition for error, NULL_TREE for ok. */

	static bool
	tree_conflicts_with_clobbers_p (tree t, HARD_REG_SET *clobbered_regs)
	{
	/* Conflicts between asm-declared register variables and the clobber
	list are not allowed. */
	tree overlap = tree_overlaps_hard_reg_set (t, clobbered_regs);

	if (overlap)
	{
	error ("asm-specifier for variable %qs conflicts with asm clobber list",
	IDENTIFIER_POINTER (DECL_NAME (overlap)));

	/* Reset registerness to stop multiple errors emitted for a single
	variable. */
	DECL_REGISTER (overlap) = 0;
	return true;
	}

	return false;
	}

	/* Generate RTL for an asm statement with arguments.
	STRING is the instruction template.
	OUTPUTS is a list of output arguments (lvalues); INPUTS a list of inputs.
	Each output or input has an expression in the TREE_VALUE and
	and a tree list in TREE_PURPOSE which in turn contains a constraint
	name in TREE_VALUE (or NULL_TREE) and a constraint string
	in TREE_PURPOSE.
	CLOBBERS is a list of STRING_CST nodes each naming a hard register
	that is clobbered by this insn.

	Not all kinds of lvalue that may appear in OUTPUTS can be stored directly.
	Some elements of OUTPUTS may be replaced with trees representing temporary
	values. The caller should copy those temporary values to the originally
	specified lvalues.

	VOL nonzero means the insn is volatile; don't optimize it. */

	static void
	expand_asm_operands (tree string, tree outputs, tree inputs,
	tree clobbers, int vol, location_t locus)
	{
	rtvec argvec, constraintvec;
	rtx body;
	int ninputs = list_length (inputs);
	int noutputs = list_length (outputs);
	int ninout;
	int nclobbers;
	HARD_REG_SET clobbered_regs;
	int clobber_conflict_found = 0;
	tree tail;
	tree t;
	int i;
	/* Vector of RTX's of evaluated output operands. */
	rtx output_rtx = alloca (noutputs sizeof (rtx));
	int inout_opnum = alloca (noutputs sizeof (int));
	rtx real_output_rtx = alloca (noutputs sizeof (rtx));
	enum machine_mode *inout_mode
	= alloca (noutputs * sizeof (enum machine_mode));
	const char **constraints
	= alloca ((noutputs + ninputs) * sizeof (const char *));
	int old_generating_concat_p = generating_concat_p;

	/* An ASM with no outputs needs to be treated as volatile, for now. */
	if (noutputs == 0)
	vol = 1;

	if (! check_operand_nalternatives (outputs, inputs))
	return;

	string = resolve_asm_operand_names (string, outputs, inputs);

	/* Collect constraints. */
	i = 0;
	for (t = outputs; t ; t = TREE_CHAIN (t), i++)
	constraints[i] = TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (t)));
	for (t = inputs; t ; t = TREE_CHAIN (t), i++)
	constraints[i] = TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (t)));

	/* Sometimes we wish to automatically clobber registers across an asm.
	Case in point is when the i386 backend moved from cc0 to a hard reg --
	maintaining source-level compatibility means automatically clobbering
	the flags register. */
	clobbers = targetm.md_asm_clobbers (outputs, inputs, clobbers);

	/* Count the number of meaningful clobbered registers, ignoring what
	we would ignore later. */
	nclobbers = 0;
	CLEAR_HARD_REG_SET (clobbered_regs);
	for (tail = clobbers; tail; tail = TREE_CHAIN (tail))
	{
	const char *regname;

	if (TREE_VALUE (tail) == error_mark_node)
	return;
	regname = TREE_STRING_POINTER (TREE_VALUE (tail));

	i = decode_reg_name (regname);
	if (i >= 0 \|\| i == -4)
	++nclobbers;
	else if (i == -2)
	error ("unknown register name %qs in %<asm%>", regname);

	/* Mark clobbered registers. */
	if (i >= 0)
	{
	/* Clobbering the PIC register is an error. */
	if (i == (int) PIC_OFFSET_TABLE_REGNUM)
	{
	error ("PIC register %qs clobbered in %<asm%>", regname);
	return;
	}

	SET_HARD_REG_BIT (clobbered_regs, i);
	}
	}

	/* First pass over inputs and outputs checks validity and sets
	mark_addressable if needed. */

	ninout = 0;
	for (i = 0, tail = outputs; tail; tail = TREE_CHAIN (tail), i++)
	{
	tree val = TREE_VALUE (tail);
	tree type = TREE_TYPE (val);
	const char *constraint;
	bool is_inout;
	bool allows_reg;
	bool allows_mem;

	/* If there's an erroneous arg, emit no insn. */
	if (type == error_mark_node)
	return;

	/* Try to parse the output constraint. If that fails, there's
	no point in going further. */
	constraint = constraints[i];
	if (!parse_output_constraint (&constraint, i, ninputs, noutputs,
	&allows_mem, &allows_reg, &is_inout))
	return;

	if (! allows_reg
	&& (allows_mem
	\|\| is_inout
	\|\| (DECL_P (val)
	&& REG_P (DECL_RTL (val))
	&& GET_MODE (DECL_RTL (val)) != TYPE_MODE (type))))
	lang_hooks.mark_addressable (val);

	if (is_inout)
	ninout++;
	}

	ninputs += ninout;
	if (ninputs + noutputs > MAX_RECOG_OPERANDS)
	{
	error ("more than %d operands in %<asm%>", MAX_RECOG_OPERANDS);
	return;
	}

	for (i = 0, tail = inputs; tail; i++, tail = TREE_CHAIN (tail))
	{
	bool allows_reg, allows_mem;
	const char *constraint;

	/* If there's an erroneous arg, emit no insn, because the ASM_INPUT
	would get VOIDmode and that could cause a crash in reload. */
	if (TREE_TYPE (TREE_VALUE (tail)) == error_mark_node)
	return;

	constraint = constraints[i + noutputs];
	if (! parse_input_constraint (&constraint, i, ninputs, noutputs, ninout,
	constraints, &allows_mem, &allows_reg))
	return;

	if (! allows_reg && allows_mem)
	lang_hooks.mark_addressable (TREE_VALUE (tail));
	}

	/* Second pass evaluates arguments. */

	ninout = 0;
	for (i = 0, tail = outputs; tail; tail = TREE_CHAIN (tail), i++)
	{
	tree val = TREE_VALUE (tail);
	tree type = TREE_TYPE (val);
	bool is_inout;
	bool allows_reg;
	bool allows_mem;
	rtx op;
	bool ok;

	ok = parse_output_constraint (&constraints[i], i, ninputs,
	noutputs, &allows_mem, &allows_reg,
	&is_inout);
	gcc_assert (ok);

	/* If an output operand is not a decl or indirect ref and our constraint
	allows a register, make a temporary to act as an intermediate.
	Make the asm insn write into that, then our caller will copy it to
	the real output operand. Likewise for promoted variables. */

	generating_concat_p = 0;

	real_output_rtx[i] = NULL_RTX;
	if ((TREE_CODE (val) == INDIRECT_REF
	&& allows_mem)
	\|\| (DECL_P (val)
	&& (allows_mem \|\| REG_P (DECL_RTL (val)))
	&& ! (REG_P (DECL_RTL (val))
	&& GET_MODE (DECL_RTL (val)) != TYPE_MODE (type)))
	\|\| ! allows_reg
	\|\| is_inout)
	{
	op = expand_expr (val, NULL_RTX, VOIDmode, EXPAND_WRITE);
	if (MEM_P (op))
	op = validize_mem (op);

	if (! allows_reg && !MEM_P (op))
	error ("output number %d not directly addressable", i);
	if ((! allows_mem && MEM_P (op))
	\|\| GET_CODE (op) == CONCAT)
	{
	real_output_rtx[i] = op;
	op = gen_reg_rtx (GET_MODE (op));
	if (is_inout)
	emit_move_insn (op, real_output_rtx[i]);
	}
	}
	else
	{
	op = assign_temp (type, 0, 0, 1);
	op = validize_mem (op);
	TREE_VALUE (tail) = make_tree (type, op);
	}
	output_rtx[i] = op;

	generating_concat_p = old_generating_concat_p;

	if (is_inout)
	{
	inout_mode[ninout] = TYPE_MODE (type);
	inout_opnum[ninout++] = i;
	}

	if (tree_conflicts_with_clobbers_p (val, &clobbered_regs))
	clobber_conflict_found = 1;
	}

	/* Make vectors for the expression-rtx, constraint strings,
	and named operands. */

	argvec = rtvec_alloc (ninputs);
	constraintvec = rtvec_alloc (ninputs);

	body = gen_rtx_ASM_OPERANDS ((noutputs == 0 ? VOIDmode
	: GET_MODE (output_rtx[0])),
	ggc_strdup (TREE_STRING_POINTER (string)),
	empty_string, 0, argvec, constraintvec,
	locus);

	MEM_VOLATILE_P (body) = vol;

	/* Eval the inputs and put them into ARGVEC.
	Put their constraints into ASM_INPUTs and store in CONSTRAINTS. */

	for (i = 0, tail = inputs; tail; tail = TREE_CHAIN (tail), ++i)
	{
	bool allows_reg, allows_mem;
	const char *constraint;
	tree val, type;
	rtx op;
	bool ok;

	constraint = constraints[i + noutputs];
	ok = parse_input_constraint (&constraint, i, ninputs, noutputs, ninout,
	constraints, &allows_mem, &allows_reg);
	gcc_assert (ok);

	generating_concat_p = 0;

	val = TREE_VALUE (tail);
	type = TREE_TYPE (val);
	/* EXPAND_INITIALIZER will not generate code for valid initializer
	constants, but will still generate code for other types of operand.
	This is the behavior we want for constant constraints. */
	op = expand_expr (val, NULL_RTX, VOIDmode,
	allows_reg ? EXPAND_NORMAL
	: allows_mem ? EXPAND_MEMORY
	: EXPAND_INITIALIZER);

	/* Never pass a CONCAT to an ASM. */
	if (GET_CODE (op) == CONCAT)
	op = force_reg (GET_MODE (op), op);
	else if (MEM_P (op))
	op = validize_mem (op);

	if (asm_operand_ok (op, constraint) <= 0)
	{
	if (allows_reg && TYPE_MODE (type) != BLKmode)
	op = force_reg (TYPE_MODE (type), op);
	else if (!allows_mem)
	warning (0, "asm operand %d probably doesn%'t match constraints",
	i + noutputs);
	else if (MEM_P (op))
	{
	/* We won't recognize either volatile memory or memory
	with a queued address as available a memory_operand
	at this point. Ignore it: clearly this is a memory. */
	}
	else
	{
	warning (0, "use of memory input without lvalue in "
	"asm operand %d is deprecated", i + noutputs);

	if (CONSTANT_P (op))
	{
	rtx mem = force_const_mem (TYPE_MODE (type), op);
	if (mem)
	op = validize_mem (mem);
	else
	op = force_reg (TYPE_MODE (type), op);
	}
	if (REG_P (op)
	\|\| GET_CODE (op) == SUBREG
	\|\| GET_CODE (op) == CONCAT)
	{
	tree qual_type = build_qualified_type (type,
	(TYPE_QUALS (type)
	\| TYPE_QUAL_CONST));
	rtx memloc = assign_temp (qual_type, 1, 1, 1);
	memloc = validize_mem (memloc);
	emit_move_insn (memloc, op);
	op = memloc;
	}
	}
	}

	generating_concat_p = old_generating_concat_p;
	ASM_OPERANDS_INPUT (body, i) = op;

	ASM_OPERANDS_INPUT_CONSTRAINT_EXP (body, i)
	= gen_rtx_ASM_INPUT (TYPE_MODE (type),
	ggc_strdup (constraints[i + noutputs]));

	if (tree_conflicts_with_clobbers_p (val, &clobbered_regs))
	clobber_conflict_found = 1;
	}

	/* Protect all the operands from the queue now that they have all been
	evaluated. */

	generating_concat_p = 0;

	/* For in-out operands, copy output rtx to input rtx. */
	for (i = 0; i < ninout; i++)
	{
	int j = inout_opnum[i];
	char buffer[16];

	ASM_OPERANDS_INPUT (body, ninputs - ninout + i)
	= output_rtx[j];

	sprintf (buffer, "%d", j);
	ASM_OPERANDS_INPUT_CONSTRAINT_EXP (body, ninputs - ninout + i)
	= gen_rtx_ASM_INPUT (inout_mode[i], ggc_strdup (buffer));
	}

	generating_concat_p = old_generating_concat_p;

	/* Now, for each output, construct an rtx
	(set OUTPUT (asm_operands INSN OUTPUTCONSTRAINT OUTPUTNUMBER
	ARGVEC CONSTRAINTS OPNAMES))
	If there is more than one, put them inside a PARALLEL. */

	if (noutputs == 1 && nclobbers == 0)
	{
	ASM_OPERANDS_OUTPUT_CONSTRAINT (body) = ggc_strdup (constraints[0]);
	emit_insn (gen_rtx_SET (VOIDmode, output_rtx[0], body));
	}

	else if (noutputs == 0 && nclobbers == 0)
	{
	/* No output operands: put in a raw ASM_OPERANDS rtx. */
	emit_insn (body);
	}

	else
	{
	rtx obody = body;
	int num = noutputs;

	if (num == 0)
	num = 1;

	body = gen_rtx_PARALLEL (VOIDmode, rtvec_alloc (num + nclobbers));

	/* For each output operand, store a SET. */
	for (i = 0, tail = outputs; tail; tail = TREE_CHAIN (tail), i++)
	{
	XVECEXP (body, 0, i)
	= gen_rtx_SET (VOIDmode,
	output_rtx[i],
	gen_rtx_ASM_OPERANDS
	(GET_MODE (output_rtx[i]),
	ggc_strdup (TREE_STRING_POINTER (string)),
	ggc_strdup (constraints[i]),
	i, argvec, constraintvec, locus));

	MEM_VOLATILE_P (SET_SRC (XVECEXP (body, 0, i))) = vol;
	}

	/* If there are no outputs (but there are some clobbers)
	store the bare ASM_OPERANDS into the PARALLEL. */

	if (i == 0)
	XVECEXP (body, 0, i++) = obody;

	/* Store (clobber REG) for each clobbered register specified. */

	for (tail = clobbers; tail; tail = TREE_CHAIN (tail))
	{
	const char *regname = TREE_STRING_POINTER (TREE_VALUE (tail));
	int j = decode_reg_name (regname);
	rtx clobbered_reg;

	if (j < 0)
	{
	if (j == -3) /* `cc', which is not a register */
	continue;

	if (j == -4) /* `memory', don't cache memory across asm */
	{
	XVECEXP (body, 0, i++)
	= gen_rtx_CLOBBER (VOIDmode,
	gen_rtx_MEM
	(BLKmode,
	gen_rtx_SCRATCH (VOIDmode)));
	continue;
	}

	/* Ignore unknown register, error already signaled. */
	continue;
	}

	/* Use QImode since that's guaranteed to clobber just one reg. */
	clobbered_reg = gen_rtx_REG (QImode, j);

	/* Do sanity check for overlap between clobbers and respectively
	input and outputs that hasn't been handled. Such overlap
	should have been detected and reported above. */
	if (!clobber_conflict_found)
	{
	int opno;

	/* We test the old body (obody) contents to avoid tripping
	over the under-construction body. */
	for (opno = 0; opno < noutputs; opno++)
	if (reg_overlap_mentioned_p (clobbered_reg, output_rtx[opno]))
	internal_error ("asm clobber conflict with output operand");

	for (opno = 0; opno < ninputs - ninout; opno++)
	if (reg_overlap_mentioned_p (clobbered_reg,
	ASM_OPERANDS_INPUT (obody, opno)))
	internal_error ("asm clobber conflict with input operand");
	}

	XVECEXP (body, 0, i++)
	= gen_rtx_CLOBBER (VOIDmode, clobbered_reg);
	}

	emit_insn (body);
	}

	/* For any outputs that needed reloading into registers, spill them
	back to where they belong. */
	for (i = 0; i < noutputs; ++i)
	if (real_output_rtx[i])
	emit_move_insn (real_output_rtx[i], output_rtx[i]);

	free_temp_slots ();
	}

	void
	expand_asm_expr (tree exp)
	{
	int noutputs, i;
	tree outputs, tail;
	tree *o;

	if (ASM_INPUT_P (exp))
	{
	expand_asm (ASM_STRING (exp), ASM_VOLATILE_P (exp));
	return;
	}

	outputs = ASM_OUTPUTS (exp);
	noutputs = list_length (outputs);
	/* o[I] is the place that output number I should be written. */
	o = (tree ) alloca (noutputs sizeof (tree));

	/* Record the contents of OUTPUTS before it is modified. */
	for (i = 0, tail = outputs; tail; tail = TREE_CHAIN (tail), i++)
	o[i] = TREE_VALUE (tail);

	/* Generate the ASM_OPERANDS insn; store into the TREE_VALUEs of
	OUTPUTS some trees for where the values were actually stored. */
	expand_asm_operands (ASM_STRING (exp), outputs, ASM_INPUTS (exp),
	ASM_CLOBBERS (exp), ASM_VOLATILE_P (exp),
	input_location);

	/* Copy all the intermediate outputs into the specified outputs. */
	for (i = 0, tail = outputs; tail; tail = TREE_CHAIN (tail), i++)
	{
	if (o[i] != TREE_VALUE (tail))
	{
	expand_assignment (o[i], TREE_VALUE (tail));
	free_temp_slots ();

	/* Restore the original value so that it's correct the next
	time we expand this function. */
	TREE_VALUE (tail) = o[i];
	}
	}
	}

	/* A subroutine of expand_asm_operands. Check that all operands have
	the same number of alternatives. Return true if so. */

	static bool
	check_operand_nalternatives (tree outputs, tree inputs)
	{
	if (outputs \|\| inputs)
	{
	tree tmp = TREE_PURPOSE (outputs ? outputs : inputs);
	int nalternatives
	= n_occurrences (',', TREE_STRING_POINTER (TREE_VALUE (tmp)));
	tree next = inputs;

	if (nalternatives + 1 > MAX_RECOG_ALTERNATIVES)
	{
	error ("too many alternatives in %<asm%>");
	return false;
	}

	tmp = outputs;
	while (tmp)
	{
	const char *constraint
	= TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (tmp)));

	if (n_occurrences (',', constraint) != nalternatives)
	{
	error ("operand constraints for %<asm%> differ "
	"in number of alternatives");
	return false;
	}

	if (TREE_CHAIN (tmp))
	tmp = TREE_CHAIN (tmp);
	else
	tmp = next, next = 0;
	}
	}

	return true;
	}

	/* A subroutine of expand_asm_operands. Check that all operand names
	are unique. Return true if so. We rely on the fact that these names
	are identifiers, and so have been canonicalized by get_identifier,
	so all we need are pointer comparisons. */

	static bool
	check_unique_operand_names (tree outputs, tree inputs)
	{
	tree i, j;

	for (i = outputs; i ; i = TREE_CHAIN (i))
	{
	tree i_name = TREE_PURPOSE (TREE_PURPOSE (i));
	if (! i_name)
	continue;

	for (j = TREE_CHAIN (i); j ; j = TREE_CHAIN (j))
	if (simple_cst_equal (i_name, TREE_PURPOSE (TREE_PURPOSE (j))))
	goto failure;
	}

	for (i = inputs; i ; i = TREE_CHAIN (i))
	{
	tree i_name = TREE_PURPOSE (TREE_PURPOSE (i));
	if (! i_name)
	continue;

	for (j = TREE_CHAIN (i); j ; j = TREE_CHAIN (j))
	if (simple_cst_equal (i_name, TREE_PURPOSE (TREE_PURPOSE (j))))
	goto failure;
	for (j = outputs; j ; j = TREE_CHAIN (j))
	if (simple_cst_equal (i_name, TREE_PURPOSE (TREE_PURPOSE (j))))
	goto failure;
	}

	return true;

	failure:
	error ("duplicate asm operand name %qs",
	TREE_STRING_POINTER (TREE_PURPOSE (TREE_PURPOSE (i))));
	return false;
	}

	/* A subroutine of expand_asm_operands. Resolve the names of the operands
	in POUTPUTS and PINPUTS to numbers, and replace the name expansions in
	STRING and in the constraints to those numbers. */

	tree
	resolve_asm_operand_names (tree string, tree outputs, tree inputs)
	{
	char *buffer;
	char *p;
	const char *c;
	tree t;

	check_unique_operand_names (outputs, inputs);

	/* Substitute [<name>] in input constraint strings. There should be no
	named operands in output constraints. */
	for (t = inputs; t ; t = TREE_CHAIN (t))
	{
	c = TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (t)));
	if (strchr (c, '[') != NULL)
	{
	p = buffer = xstrdup (c);
	while ((p = strchr (p, '[')) != NULL)
	p = resolve_operand_name_1 (p, outputs, inputs);
	TREE_VALUE (TREE_PURPOSE (t))
	= build_string (strlen (buffer), buffer);
	free (buffer);
	}
	}

	/* Now check for any needed substitutions in the template. */
	c = TREE_STRING_POINTER (string);
	while ((c = strchr (c, '%')) != NULL)
	{
	if (c[1] == '[')
	break;
	else if (ISALPHA (c[1]) && c[2] == '[')
	break;
	else
	{
	c += 1;
	continue;
	}
	}

	if (c)
	{
	/* OK, we need to make a copy so we can perform the substitutions.
	Assume that we will not need extra space--we get to remove '['
	and ']', which means we cannot have a problem until we have more
	than 999 operands. */
	buffer = xstrdup (TREE_STRING_POINTER (string));
	p = buffer + (c - TREE_STRING_POINTER (string));

	while ((p = strchr (p, '%')) != NULL)
	{
	if (p[1] == '[')
	p += 1;
	else if (ISALPHA (p[1]) && p[2] == '[')
	p += 2;
	else
	{
	p += 1;
	continue;
	}

	p = resolve_operand_name_1 (p, outputs, inputs);
	}

	string = build_string (strlen (buffer), buffer);
	free (buffer);
	}

	return string;
	}

	/* A subroutine of resolve_operand_names. P points to the '[' for a
	potential named operand of the form [<name>]. In place, replace
	the name and brackets with a number. Return a pointer to the
	balance of the string after substitution. */

	static char *
	resolve_operand_name_1 (char *p, tree outputs, tree inputs)
	{
	char *q;
	int op;
	tree t;
	size_t len;

	/* Collect the operand name. */
	q = strchr (p, ']');
	if (!q)
	{
	error ("missing close brace for named operand");
	return strchr (p, '\0');
	}
	len = q - p - 1;

	/* Resolve the name to a number. */
	for (op = 0, t = outputs; t ; t = TREE_CHAIN (t), op++)
	{
	tree name = TREE_PURPOSE (TREE_PURPOSE (t));
	if (name)
	{
	const char *c = TREE_STRING_POINTER (name);
	if (strncmp (c, p + 1, len) == 0 && c[len] == '\0')
	goto found;
	}
	}
	for (t = inputs; t ; t = TREE_CHAIN (t), op++)
	{
	tree name = TREE_PURPOSE (TREE_PURPOSE (t));
	if (name)
	{
	const char *c = TREE_STRING_POINTER (name);
	if (strncmp (c, p + 1, len) == 0 && c[len] == '\0')
	goto found;
	}
	}

	*q = '\0';
	error ("undefined named operand %qs", p + 1);
	op = 0;
	found:

	/* Replace the name with the number. Unfortunately, not all libraries
	get the return value of sprintf correct, so search for the end of the
	generated string by hand. */
	sprintf (p, "%d", op);
	p = strchr (p, '\0');

	/* Verify the no extra buffer space assumption. */
	gcc_assert (p <= q);

	/* Shift the rest of the buffer down to fill the gap. */
	memmove (p, q + 1, strlen (q + 1) + 1);

	return p;
	}

	/* Generate RTL to evaluate the expression EXP. */

	void
	expand_expr_stmt (tree exp)
	{
	rtx value;
	tree type;

	value = expand_expr (exp, const0_rtx, VOIDmode, 0);
	type = TREE_TYPE (exp);

	/* If all we do is reference a volatile value in memory,
	copy it to a register to be sure it is actually touched. */
	if (value && MEM_P (value) && TREE_THIS_VOLATILE (exp))
	{
	if (TYPE_MODE (type) == VOIDmode)
	;
	else if (TYPE_MODE (type) != BLKmode)
	value = copy_to_reg (value);
	else
	{
	rtx lab = gen_label_rtx ();

	/* Compare the value with itself to reference it. */
	emit_cmp_and_jump_insns (value, value, EQ,
	expand_normal (TYPE_SIZE (type)),
	BLKmode, 0, lab);
	emit_label (lab);
	}
	}

	/* Free any temporaries used to evaluate this expression. */
	free_temp_slots ();
	}

	/* Warn if EXP contains any computations whose results are not used.
	Return 1 if a warning is printed; 0 otherwise. LOCUS is the
	(potential) location of the expression. */

	int
	warn_if_unused_value (tree exp, location_t locus)
	{
	restart:
	if (TREE_USED (exp) \|\| TREE_NO_WARNING (exp))
	return 0;

	/* Don't warn about void constructs. This includes casting to void,
	void function calls, and statement expressions with a final cast
	to void. */
	if (VOID_TYPE_P (TREE_TYPE (exp)))
	return 0;

	if (EXPR_HAS_LOCATION (exp))
	locus = EXPR_LOCATION (exp);

	switch (TREE_CODE (exp))
	{
	case PREINCREMENT_EXPR:
	case POSTINCREMENT_EXPR:
	case PREDECREMENT_EXPR:
	case POSTDECREMENT_EXPR:
	case MODIFY_EXPR:
	case INIT_EXPR:
	case TARGET_EXPR:
	case CALL_EXPR:
	case TRY_CATCH_EXPR:
	case WITH_CLEANUP_EXPR:
	case EXIT_EXPR:
	case VA_ARG_EXPR:
	return 0;

	case BIND_EXPR:
	/* For a binding, warn if no side effect within it. */
	exp = BIND_EXPR_BODY (exp);
	goto restart;

	case SAVE_EXPR:
	exp = TREE_OPERAND (exp, 0);
	goto restart;

	case TRUTH_ORIF_EXPR:
	case TRUTH_ANDIF_EXPR:
	/* In && or \|\|, warn if 2nd operand has no side effect. */
	exp = TREE_OPERAND (exp, 1);
	goto restart;

	case COMPOUND_EXPR:
	if (warn_if_unused_value (TREE_OPERAND (exp, 0), locus))
	return 1;
	/* Let people do `(foo (), 0)' without a warning. */
	if (TREE_CONSTANT (TREE_OPERAND (exp, 1)))
	return 0;
	exp = TREE_OPERAND (exp, 1);
	goto restart;

	case COND_EXPR:
	/* If this is an expression with side effects, don't warn; this
	case commonly appears in macro expansions. */
	if (TREE_SIDE_EFFECTS (exp))
	return 0;
	goto warn;

	case INDIRECT_REF:
	/* Don't warn about automatic dereferencing of references, since
	the user cannot control it. */
	if (TREE_CODE (TREE_TYPE (TREE_OPERAND (exp, 0))) == REFERENCE_TYPE)
	{
	exp = TREE_OPERAND (exp, 0);
	goto restart;
	}
	/* Fall through. */

	default:
	/* Referencing a volatile value is a side effect, so don't warn. */
	if ((DECL_P (exp) \|\| REFERENCE_CLASS_P (exp))
	&& TREE_THIS_VOLATILE (exp))
	return 0;

	/* If this is an expression which has no operands, there is no value
	to be unused. There are no such language-independent codes,
	but front ends may define such. */
	if (EXPRESSION_CLASS_P (exp) && TREE_CODE_LENGTH (TREE_CODE (exp)) == 0)
	return 0;

	warn:
	warning (0, "%Hvalue computed is not used", &locus);
	return 1;
	}
	}


	/* Generate RTL to return from the current function, with no value.
	(That is, we do not do anything about returning any value.) */

	void
	expand_null_return (void)
	{
	/* If this function was declared to return a value, but we
	didn't, clobber the return registers so that they are not
	propagated live to the rest of the function. */
	clobber_return_register ();

	expand_null_return_1 ();
	}

	/* Generate RTL to return directly from the current function.
	(That is, we bypass any return value.) */

	void
	expand_naked_return (void)
	{
	rtx end_label;

	clear_pending_stack_adjust ();
	do_pending_stack_adjust ();

	end_label = naked_return_label;
	if (end_label == 0)
	end_label = naked_return_label = gen_label_rtx ();

	emit_jump (end_label);
	}

	/* Generate RTL to return from the current function, with value VAL. */

	static void
	expand_value_return (rtx val)
	{
	/* Copy the value to the return location
	unless it's already there. */

	rtx return_reg = DECL_RTL (DECL_RESULT (current_function_decl));
	if (return_reg != val)
	{
	tree type = TREE_TYPE (DECL_RESULT (current_function_decl));
	if (targetm.calls.promote_function_return (TREE_TYPE (current_function_decl)))
	{
	int unsignedp = TYPE_UNSIGNED (type);
	enum machine_mode old_mode
	= DECL_MODE (DECL_RESULT (current_function_decl));
	enum machine_mode mode
	= promote_mode (type, old_mode, &unsignedp, 1);

	if (mode != old_mode)
	val = convert_modes (mode, old_mode, val, unsignedp);
	}
	if (GET_CODE (return_reg) == PARALLEL)
	emit_group_load (return_reg, val, type, int_size_in_bytes (type));
	else
	emit_move_insn (return_reg, val);
	}

	expand_null_return_1 ();
	}

	/* Output a return with no value. */

	static void
	expand_null_return_1 (void)
	{
	clear_pending_stack_adjust ();
	do_pending_stack_adjust ();
	emit_jump (return_label);
	}

	/* Generate RTL to evaluate the expression RETVAL and return it
	from the current function. */

	void
	expand_return (tree retval)
	{
	rtx result_rtl;
	rtx val = 0;
	tree retval_rhs;

	/* If function wants no value, give it none. */
	if (TREE_CODE (TREE_TYPE (TREE_TYPE (current_function_decl))) == VOID_TYPE)
	{
	expand_normal (retval);
	expand_null_return ();
	return;
	}

	if (retval == error_mark_node)
	{
	/* Treat this like a return of no value from a function that
	returns a value. */
	expand_null_return ();
	return;
	}
	else if ((TREE_CODE (retval) == MODIFY_EXPR
	\|\| TREE_CODE (retval) == INIT_EXPR)
	&& TREE_CODE (TREE_OPERAND (retval, 0)) == RESULT_DECL)
	retval_rhs = TREE_OPERAND (retval, 1);
	else
	retval_rhs = retval;

	result_rtl = DECL_RTL (DECL_RESULT (current_function_decl));

	/* If we are returning the RESULT_DECL, then the value has already
	been stored into it, so we don't have to do anything special. */
	if (TREE_CODE (retval_rhs) == RESULT_DECL)
	expand_value_return (result_rtl);

	/* If the result is an aggregate that is being returned in one (or more)
	registers, load the registers here. The compiler currently can't handle
	copying a BLKmode value into registers. We could put this code in a
	more general area (for use by everyone instead of just function
	call/return), but until this feature is generally usable it is kept here
	(and in expand_call). */

	else if (retval_rhs != 0
	&& TYPE_MODE (TREE_TYPE (retval_rhs)) == BLKmode
	&& REG_P (result_rtl))
	{
	int i;
	unsigned HOST_WIDE_INT bitpos, xbitpos;
	unsigned HOST_WIDE_INT padding_correction = 0;
	unsigned HOST_WIDE_INT bytes
	= int_size_in_bytes (TREE_TYPE (retval_rhs));
	int n_regs = (bytes + UNITS_PER_WORD - 1) / UNITS_PER_WORD;
	unsigned int bitsize
	= MIN (TYPE_ALIGN (TREE_TYPE (retval_rhs)), BITS_PER_WORD);
	rtx result_pseudos = alloca (sizeof (rtx) n_regs);
	rtx result_reg, src = NULL_RTX, dst = NULL_RTX;
	rtx result_val = expand_normal (retval_rhs);
	enum machine_mode tmpmode, result_reg_mode;

	if (bytes == 0)
	{
	expand_null_return ();
	return;
	}

	/* If the structure doesn't take up a whole number of words, see
	whether the register value should be padded on the left or on
	the right. Set PADDING_CORRECTION to the number of padding
	bits needed on the left side.

	In most ABIs, the structure will be returned at the least end of
	the register, which translates to right padding on little-endian
	targets and left padding on big-endian targets. The opposite
	holds if the structure is returned at the most significant
	end of the register. */
	if (bytes % UNITS_PER_WORD != 0
	&& (targetm.calls.return_in_msb (TREE_TYPE (retval_rhs))
	? !BYTES_BIG_ENDIAN
	: BYTES_BIG_ENDIAN))
	padding_correction = (BITS_PER_WORD - ((bytes % UNITS_PER_WORD)
	* BITS_PER_UNIT));

	/* Copy the structure BITSIZE bits at a time. */
	for (bitpos = 0, xbitpos = padding_correction;
	bitpos < bytes * BITS_PER_UNIT;
	bitpos += bitsize, xbitpos += bitsize)
	{
	/* We need a new destination pseudo each time xbitpos is
	on a word boundary and when xbitpos == padding_correction
	(the first time through). */
	if (xbitpos % BITS_PER_WORD == 0
	\|\| xbitpos == padding_correction)
	{
	/* Generate an appropriate register. */
	dst = gen_reg_rtx (word_mode);
	result_pseudos[xbitpos / BITS_PER_WORD] = dst;

	/* Clear the destination before we move anything into it. */
	emit_move_insn (dst, CONST0_RTX (GET_MODE (dst)));
	}

	/* We need a new source operand each time bitpos is on a word
	boundary. */
	if (bitpos % BITS_PER_WORD == 0)
	src = operand_subword_force (result_val,
	bitpos / BITS_PER_WORD,
	BLKmode);

	/* Use bitpos for the source extraction (left justified) and
	xbitpos for the destination store (right justified). */
	store_bit_field (dst, bitsize, xbitpos % BITS_PER_WORD, word_mode,
	extract_bit_field (src, bitsize,
	bitpos % BITS_PER_WORD, 1,
	NULL_RTX, word_mode, word_mode));
	}

	tmpmode = GET_MODE (result_rtl);
	if (tmpmode == BLKmode)
	{
	/* Find the smallest integer mode large enough to hold the
	entire structure and use that mode instead of BLKmode
	on the USE insn for the return register. */
	for (tmpmode = GET_CLASS_NARROWEST_MODE (MODE_INT);
	tmpmode != VOIDmode;
	tmpmode = GET_MODE_WIDER_MODE (tmpmode))
	/* Have we found a large enough mode? */
	if (GET_MODE_SIZE (tmpmode) >= bytes)
	break;

	/* A suitable mode should have been found. */
	gcc_assert (tmpmode != VOIDmode);

	PUT_MODE (result_rtl, tmpmode);
	}

	if (GET_MODE_SIZE (tmpmode) < GET_MODE_SIZE (word_mode))
	result_reg_mode = word_mode;
	else
	result_reg_mode = tmpmode;
	result_reg = gen_reg_rtx (result_reg_mode);

	for (i = 0; i < n_regs; i++)
	emit_move_insn (operand_subword (result_reg, i, 0, result_reg_mode),
	result_pseudos[i]);

	if (tmpmode != result_reg_mode)
	result_reg = gen_lowpart (tmpmode, result_reg);

	expand_value_return (result_reg);
	}
	else if (retval_rhs != 0
	&& !VOID_TYPE_P (TREE_TYPE (retval_rhs))
	&& (REG_P (result_rtl)
	\|\| (GET_CODE (result_rtl) == PARALLEL)))
	{
	/* Calculate the return value into a temporary (usually a pseudo
	reg). */
	tree ot = TREE_TYPE (DECL_RESULT (current_function_decl));
	tree nt = build_qualified_type (ot, TYPE_QUALS (ot) \| TYPE_QUAL_CONST);

	val = assign_temp (nt, 0, 0, 1);
	val = expand_expr (retval_rhs, val, GET_MODE (val), 0);
	val = force_not_mem (val);
	/* Return the calculated value. */
	expand_value_return (val);
	}
	else
	{
	/* No hard reg used; calculate value into hard return reg. */
	expand_expr (retval, const0_rtx, VOIDmode, 0);
	expand_value_return (result_rtl);
	}
	}

	/* Given a pointer to a BLOCK node return nonzero if (and only if) the node
	in question represents the outermost pair of curly braces (i.e. the "body
	block") of a function or method.

	For any BLOCK node representing a "body block" of a function or method, the
	BLOCK_SUPERCONTEXT of the node will point to another BLOCK node which
	represents the outermost (function) scope for the function or method (i.e.
	the one which includes the formal parameters). The BLOCK_SUPERCONTEXT of
	that node in turn will point to the relevant FUNCTION_DECL node. */

	int
	is_body_block (tree stmt)
	{
	if (lang_hooks.no_body_blocks)
	return 0;

	if (TREE_CODE (stmt) == BLOCK)
	{
	tree parent = BLOCK_SUPERCONTEXT (stmt);

	if (parent && TREE_CODE (parent) == BLOCK)
	{
	tree grandparent = BLOCK_SUPERCONTEXT (parent);

	if (grandparent && TREE_CODE (grandparent) == FUNCTION_DECL)
	return 1;
	}
	}

	return 0;
	}

	/* Emit code to restore vital registers at the beginning of a nonlocal goto
	handler. */
	static void
	expand_nl_goto_receiver (void)
	{
	/* Clobber the FP when we get here, so we have to make sure it's
	marked as used by this function. */
	emit_insn (gen_rtx_USE (VOIDmode, hard_frame_pointer_rtx));

	/* Mark the static chain as clobbered here so life information
	doesn't get messed up for it. */
	emit_insn (gen_rtx_CLOBBER (VOIDmode, static_chain_rtx));

	#ifdef HAVE_nonlocal_goto
	if (! HAVE_nonlocal_goto)
	#endif
	/* First adjust our frame pointer to its actual value. It was
	previously set to the start of the virtual area corresponding to
	the stacked variables when we branched here and now needs to be
	adjusted to the actual hardware fp value.

	Assignments are to virtual registers are converted by
	instantiate_virtual_regs into the corresponding assignment
	to the underlying register (fp in this case) that makes
	the original assignment true.
	So the following insn will actually be
	decrementing fp by STARTING_FRAME_OFFSET. */
	emit_move_insn (virtual_stack_vars_rtx, hard_frame_pointer_rtx);

	#if ARG_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM
	if (fixed_regs[ARG_POINTER_REGNUM])
	{
	#ifdef ELIMINABLE_REGS
	/* If the argument pointer can be eliminated in favor of the
	frame pointer, we don't need to restore it. We assume here
	that if such an elimination is present, it can always be used.
	This is the case on all known machines; if we don't make this
	assumption, we do unnecessary saving on many machines. */
	static const struct elims {const int from, to;} elim_regs[] = ELIMINABLE_REGS;
	size_t i;

	for (i = 0; i < ARRAY_SIZE (elim_regs); i++)
	if (elim_regs[i].from == ARG_POINTER_REGNUM
	&& elim_regs[i].to == HARD_FRAME_POINTER_REGNUM)
	break;

	if (i == ARRAY_SIZE (elim_regs))
	#endif
	{
	/* Now restore our arg pointer from the address at which it
	was saved in our stack frame. */
	emit_move_insn (virtual_incoming_args_rtx,
	copy_to_reg (get_arg_pointer_save_area (cfun)));
	}
	}
	#endif

	#ifdef HAVE_nonlocal_goto_receiver
	if (HAVE_nonlocal_goto_receiver)
	emit_insn (gen_nonlocal_goto_receiver ());
	#endif

	/* @@@ This is a kludge. Not all machine descriptions define a blockage
	insn, but we must not allow the code we just generated to be reordered
	by scheduling. Specifically, the update of the frame pointer must
	happen immediately, not later. So emit an ASM_INPUT to act as blockage
	insn. */
	emit_insn (gen_rtx_ASM_INPUT (VOIDmode, ""));
	}

	/* Generate RTL for the automatic variable declaration DECL.
	(Other kinds of declarations are simply ignored if seen here.) */

	void
	expand_decl (tree decl)
	{
	tree type;

	type = TREE_TYPE (decl);

	/* For a CONST_DECL, set mode, alignment, and sizes from those of the
	type in case this node is used in a reference. */
	if (TREE_CODE (decl) == CONST_DECL)
	{
	DECL_MODE (decl) = TYPE_MODE (type);
	DECL_ALIGN (decl) = TYPE_ALIGN (type);
	DECL_SIZE (decl) = TYPE_SIZE (type);
	DECL_SIZE_UNIT (decl) = TYPE_SIZE_UNIT (type);
	return;
	}

	/* Otherwise, only automatic variables need any expansion done. Static and
	external variables, and external functions, will be handled by
	`assemble_variable' (called from finish_decl). TYPE_DECL requires
	nothing. PARM_DECLs are handled in `assign_parms'. */
	if (TREE_CODE (decl) != VAR_DECL)
	return;

	if (TREE_STATIC (decl) \|\| DECL_EXTERNAL (decl))
	return;

	/* Create the RTL representation for the variable. */

	if (type == error_mark_node)
	SET_DECL_RTL (decl, gen_rtx_MEM (BLKmode, const0_rtx));

	else if (DECL_SIZE (decl) == 0)
	/* Variable with incomplete type. */
	{
	rtx x;
	if (DECL_INITIAL (decl) == 0)
	/* Error message was already done; now avoid a crash. */
	x = gen_rtx_MEM (BLKmode, const0_rtx);
	else
	/* An initializer is going to decide the size of this array.
	Until we know the size, represent its address with a reg. */
	x = gen_rtx_MEM (BLKmode, gen_reg_rtx (Pmode));

	set_mem_attributes (x, decl, 1);
	SET_DECL_RTL (decl, x);
	}
	else if (use_register_for_decl (decl))
	{
	/* Automatic variable that can go in a register. */
	int unsignedp = TYPE_UNSIGNED (type);
	enum machine_mode reg_mode
	= promote_mode (type, DECL_MODE (decl), &unsignedp, 0);

	SET_DECL_RTL (decl, gen_reg_rtx (reg_mode));

	/* Note if the object is a user variable. */
	if (!DECL_ARTIFICIAL (decl))
	{
	mark_user_reg (DECL_RTL (decl));

	/* Trust user variables which have a pointer type to really
	be pointers. Do not trust compiler generated temporaries
	as our type system is totally busted as it relates to
	pointer arithmetic which translates into lots of compiler
	generated objects with pointer types, but which are not really
	pointers. */
	if (POINTER_TYPE_P (type))
	mark_reg_pointer (DECL_RTL (decl),
	TYPE_ALIGN (TREE_TYPE (TREE_TYPE (decl))));
	}
	}

	else if (TREE_CODE (DECL_SIZE_UNIT (decl)) == INTEGER_CST
	&& ! (flag_stack_check && ! STACK_CHECK_BUILTIN
	&& 0 < compare_tree_int (DECL_SIZE_UNIT (decl),
	STACK_CHECK_MAX_VAR_SIZE)))
	{
	/* Variable of fixed size that goes on the stack. */
	rtx oldaddr = 0;
	rtx addr;
	rtx x;

	/* If we previously made RTL for this decl, it must be an array
	whose size was determined by the initializer.
	The old address was a register; set that register now
	to the proper address. */
	if (DECL_RTL_SET_P (decl))
	{
	gcc_assert (MEM_P (DECL_RTL (decl)));
	gcc_assert (REG_P (XEXP (DECL_RTL (decl), 0)));
	oldaddr = XEXP (DECL_RTL (decl), 0);
	}

	/* Set alignment we actually gave this decl. */
	DECL_ALIGN (decl) = (DECL_MODE (decl) == BLKmode ? BIGGEST_ALIGNMENT
	: GET_MODE_BITSIZE (DECL_MODE (decl)));
	DECL_USER_ALIGN (decl) = 0;

	x = assign_temp (decl, 1, 1, 1);
	set_mem_attributes (x, decl, 1);
	SET_DECL_RTL (decl, x);

	if (oldaddr)
	{
	addr = force_operand (XEXP (DECL_RTL (decl), 0), oldaddr);
	if (addr != oldaddr)
	emit_move_insn (oldaddr, addr);
	}
	}
	else
	/* Dynamic-size object: must push space on the stack. */
	{
	rtx address, size, x;

	/* Record the stack pointer on entry to block, if have
	not already done so. */
	do_pending_stack_adjust ();

	/* Compute the variable's size, in bytes. This will expand any
	needed SAVE_EXPRs for the first time. */
	size = expand_normal (DECL_SIZE_UNIT (decl));
	free_temp_slots ();

	/* Allocate space on the stack for the variable. Note that
	DECL_ALIGN says how the variable is to be aligned and we
	cannot use it to conclude anything about the alignment of
	the size. */
	address = allocate_dynamic_stack_space (size, NULL_RTX,
	TYPE_ALIGN (TREE_TYPE (decl)));

	/* Reference the variable indirect through that rtx. */
	x = gen_rtx_MEM (DECL_MODE (decl), address);
	set_mem_attributes (x, decl, 1);
	SET_DECL_RTL (decl, x);


	/* Indicate the alignment we actually gave this variable. */
	#ifdef STACK_BOUNDARY
	DECL_ALIGN (decl) = STACK_BOUNDARY;
	#else
	DECL_ALIGN (decl) = BIGGEST_ALIGNMENT;
	#endif
	DECL_USER_ALIGN (decl) = 0;
	}
	}

	/* Emit code to save the current value of stack. */
	rtx
	expand_stack_save (void)
	{
	rtx ret = NULL_RTX;

	do_pending_stack_adjust ();
	emit_stack_save (SAVE_BLOCK, &ret, NULL_RTX);
	return ret;
	}

	/* Emit code to restore the current value of stack. */
	void
	expand_stack_restore (tree var)
	{
	rtx sa = DECL_RTL (var);

	emit_stack_restore (SAVE_BLOCK, sa, NULL_RTX);
	}

	/* DECL is an anonymous union. CLEANUP is a cleanup for DECL.
	DECL_ELTS is the list of elements that belong to DECL's type.
	In each, the TREE_VALUE is a VAR_DECL, and the TREE_PURPOSE a cleanup. */

	void
	expand_anon_union_decl (tree decl, tree cleanup ATTRIBUTE_UNUSED,
	tree decl_elts)
	{
	rtx x;
	tree t;

	/* If any of the elements are addressable, so is the entire union. */
	for (t = decl_elts; t; t = TREE_CHAIN (t))
	if (TREE_ADDRESSABLE (TREE_VALUE (t)))
	{
	TREE_ADDRESSABLE (decl) = 1;
	break;
	}

	expand_decl (decl);
	x = DECL_RTL (decl);

	/* Go through the elements, assigning RTL to each. */
	for (t = decl_elts; t; t = TREE_CHAIN (t))
	{
	tree decl_elt = TREE_VALUE (t);
	enum machine_mode mode = TYPE_MODE (TREE_TYPE (decl_elt));
	rtx decl_rtl;

	/* If any of the elements are addressable, so is the entire
	union. */
	if (TREE_USED (decl_elt))
	TREE_USED (decl) = 1;

	/* Propagate the union's alignment to the elements. */
	DECL_ALIGN (decl_elt) = DECL_ALIGN (decl);
	DECL_USER_ALIGN (decl_elt) = DECL_USER_ALIGN (decl);

	/* If the element has BLKmode and the union doesn't, the union is
	aligned such that the element doesn't need to have BLKmode, so
	change the element's mode to the appropriate one for its size. */
	if (mode == BLKmode && DECL_MODE (decl) != BLKmode)
	DECL_MODE (decl_elt) = mode
	= mode_for_size_tree (DECL_SIZE (decl_elt), MODE_INT, 1);

	if (mode == GET_MODE (x))
	decl_rtl = x;
	else if (MEM_P (x))
	/* (SUBREG (MEM ...)) at RTL generation time is invalid, so we
	instead create a new MEM rtx with the proper mode. */
	decl_rtl = adjust_address_nv (x, mode, 0);
	else
	{
	gcc_assert (REG_P (x));
	decl_rtl = gen_lowpart_SUBREG (mode, x);
	}
	SET_DECL_RTL (decl_elt, decl_rtl);
	}
	}

	/* Do the insertion of a case label into case_list. The labels are
	fed to us in descending order from the sorted vector of case labels used
	in the tree part of the middle end. So the list we construct is
	sorted in ascending order. The bounds on the case range, LOW and HIGH,
	are converted to case's index type TYPE. */

	static struct case_node *
	add_case_node (struct case_node *head, tree type, tree low, tree high,
	tree label)
	{
	tree min_value, max_value;
	struct case_node *r;

	gcc_assert (TREE_CODE (low) == INTEGER_CST);
	gcc_assert (!high \|\| TREE_CODE (high) == INTEGER_CST);

	min_value = TYPE_MIN_VALUE (type);
	max_value = TYPE_MAX_VALUE (type);

	/* If there's no HIGH value, then this is not a case range; it's
	just a simple case label. But that's just a degenerate case
	range.
	If the bounds are equal, turn this into the one-value case. */
	if (!high \|\| tree_int_cst_equal (low, high))
	{
	/* If the simple case value is unreachable, ignore it. */
	if ((TREE_CODE (min_value) == INTEGER_CST
	&& tree_int_cst_compare (low, min_value) < 0)
	\|\| (TREE_CODE (max_value) == INTEGER_CST
	&& tree_int_cst_compare (low, max_value) > 0))
	return head;
	low = fold_convert (type, low);
	high = low;
	}
	else
	{
	/* If the entire case range is unreachable, ignore it. */
	if ((TREE_CODE (min_value) == INTEGER_CST
	&& tree_int_cst_compare (high, min_value) < 0)
	\|\| (TREE_CODE (max_value) == INTEGER_CST
	&& tree_int_cst_compare (low, max_value) > 0))
	return head;

	/* If the lower bound is less than the index type's minimum
	value, truncate the range bounds. */
	if (TREE_CODE (min_value) == INTEGER_CST
	&& tree_int_cst_compare (low, min_value) < 0)
	low = min_value;
	low = fold_convert (type, low);

	/* If the upper bound is greater than the index type's maximum
	value, truncate the range bounds. */
	if (TREE_CODE (max_value) == INTEGER_CST
	&& tree_int_cst_compare (high, max_value) > 0)
	high = max_value;
	high = fold_convert (type, high);
	}


	/* Add this label to the chain. Make sure to drop overflow flags. */
	r = ggc_alloc (sizeof (struct case_node));
	r->low = build_int_cst_wide (TREE_TYPE (low), TREE_INT_CST_LOW (low),
	TREE_INT_CST_HIGH (low));
	r->high = build_int_cst_wide (TREE_TYPE (high), TREE_INT_CST_LOW (high),
	TREE_INT_CST_HIGH (high));
	r->code_label = label;
	r->parent = r->left = NULL;
	r->right = head;
	return r;
	}

	/* Maximum number of case bit tests. */
	#define MAX_CASE_BIT_TESTS 3

	/* By default, enable case bit tests on targets with ashlsi3. */
	#ifndef CASE_USE_BIT_TESTS
	#define CASE_USE_BIT_TESTS (ashl_optab->handlers[word_mode].insn_code \
	!= CODE_FOR_nothing)
	#endif


	/* A case_bit_test represents a set of case nodes that may be
	selected from using a bit-wise comparison. HI and LO hold
	the integer to be tested against, LABEL contains the label
	to jump to upon success and BITS counts the number of case
	nodes handled by this test, typically the number of bits
	set in HI:LO. */

	struct case_bit_test
	{
	HOST_WIDE_INT hi;
	HOST_WIDE_INT lo;
	rtx label;
	int bits;
	};

	/* Determine whether "1 << x" is relatively cheap in word_mode. */

	static
	bool lshift_cheap_p (void)
	{
	static bool init = false;
	static bool cheap = true;

	if (!init)
	{
	rtx reg = gen_rtx_REG (word_mode, 10000);
	int cost = rtx_cost (gen_rtx_ASHIFT (word_mode, const1_rtx, reg), SET);
	cheap = cost < COSTS_N_INSNS (3);
	init = true;
	}

	return cheap;
	}

	/* Comparison function for qsort to order bit tests by decreasing
	number of case nodes, i.e. the node with the most cases gets
	tested first. */

	static int
	case_bit_test_cmp (const void p1, const void p2)
	{
	const struct case_bit_test *d1 = p1;
	const struct case_bit_test *d2 = p2;

	if (d2->bits != d1->bits)
	return d2->bits - d1->bits;

	/* Stabilize the sort. */
	return CODE_LABEL_NUMBER (d2->label) - CODE_LABEL_NUMBER (d1->label);
	}

	/* Expand a switch statement by a short sequence of bit-wise
	comparisons. "switch(x)" is effectively converted into
	"if ((1 << (x-MINVAL)) & CST)" where CST and MINVAL are
	integer constants.

	INDEX_EXPR is the value being switched on, which is of
	type INDEX_TYPE. MINVAL is the lowest case value of in
	the case nodes, of INDEX_TYPE type, and RANGE is highest
	value minus MINVAL, also of type INDEX_TYPE. NODES is
	the set of case nodes, and DEFAULT_LABEL is the label to
	branch to should none of the cases match.

	There MUST be MAX_CASE_BIT_TESTS or less unique case
	node targets. */

	static void
	emit_case_bit_tests (tree index_type, tree index_expr, tree minval,
	tree range, case_node_ptr nodes, rtx default_label)
	{
	struct case_bit_test test[MAX_CASE_BIT_TESTS];
	enum machine_mode mode;
	rtx expr, index, label;
	unsigned int i,j,lo,hi;
	struct case_node *n;
	unsigned int count;

	count = 0;
	for (n = nodes; n; n = n->right)
	{
	label = label_rtx (n->code_label);
	for (i = 0; i < count; i++)
	if (label == test[i].label)
	break;

	if (i == count)
	{
	gcc_assert (count < MAX_CASE_BIT_TESTS);
	test[i].hi = 0;
	test[i].lo = 0;
	test[i].label = label;
	test[i].bits = 1;
	count++;
	}
	else
	test[i].bits++;

	lo = tree_low_cst (fold_build2 (MINUS_EXPR, index_type,
	n->low, minval), 1);
	hi = tree_low_cst (fold_build2 (MINUS_EXPR, index_type,
	n->high, minval), 1);
	for (j = lo; j <= hi; j++)
	if (j >= HOST_BITS_PER_WIDE_INT)
	test[i].hi \|= (HOST_WIDE_INT) 1 << (j - HOST_BITS_PER_INT);
	else
	test[i].lo \|= (HOST_WIDE_INT) 1 << j;
	}

	qsort (test, count, sizeof(*test), case_bit_test_cmp);

	index_expr = fold_build2 (MINUS_EXPR, index_type,
	fold_convert (index_type, index_expr),
	fold_convert (index_type, minval));
	index = expand_normal (index_expr);
	do_pending_stack_adjust ();

	mode = TYPE_MODE (index_type);
	expr = expand_normal (range);
	emit_cmp_and_jump_insns (index, expr, GTU, NULL_RTX, mode, 1,
	default_label);

	index = convert_to_mode (word_mode, index, 0);
	index = expand_binop (word_mode, ashl_optab, const1_rtx,
	index, NULL_RTX, 1, OPTAB_WIDEN);

	for (i = 0; i < count; i++)
	{
	expr = immed_double_const (test[i].lo, test[i].hi, word_mode);
	expr = expand_binop (word_mode, and_optab, index, expr,
	NULL_RTX, 1, OPTAB_WIDEN);
	emit_cmp_and_jump_insns (expr, const0_rtx, NE, NULL_RTX,
	word_mode, 1, test[i].label);
	}

	emit_jump (default_label);
	}

	#ifndef HAVE_casesi
	#define HAVE_casesi 0
	#endif

	#ifndef HAVE_tablejump
	#define HAVE_tablejump 0
	#endif

	/* Terminate a case (Pascal/Ada) or switch (C) statement
	in which ORIG_INDEX is the expression to be tested.
	If ORIG_TYPE is not NULL, it is the original ORIG_INDEX
	type as given in the source before any compiler conversions.
	Generate the code to test it and jump to the right place. */

	void
	expand_case (tree exp)
	{
	tree minval = NULL_TREE, maxval = NULL_TREE, range = NULL_TREE;
	rtx default_label = 0;
	struct case_node *n;
	unsigned int count, uniq;
	rtx index;
	rtx table_label;
	int ncases;
	rtx *labelvec;
	int i, fail;
	rtx before_case, end, lab;

	tree vec = SWITCH_LABELS (exp);
	tree orig_type = TREE_TYPE (exp);
	tree index_expr = SWITCH_COND (exp);
	tree index_type = TREE_TYPE (index_expr);
	int unsignedp = TYPE_UNSIGNED (index_type);

	/* The insn after which the case dispatch should finally
	be emitted. Zero for a dummy. */
	rtx start;

	/* A list of case labels; it is first built as a list and it may then
	be rearranged into a nearly balanced binary tree. */
	struct case_node *case_list = 0;

	/* Label to jump to if no case matches. */
	tree default_label_decl;

	/* The switch body is lowered in gimplify.c, we should never have
	switches with a non-NULL SWITCH_BODY here. */
	gcc_assert (!SWITCH_BODY (exp));
	gcc_assert (SWITCH_LABELS (exp));

	do_pending_stack_adjust ();

	/* An ERROR_MARK occurs for various reasons including invalid data type. */
	if (index_type != error_mark_node)
	{
	tree elt;
	bitmap label_bitmap;

	/* cleanup_tree_cfg removes all SWITCH_EXPR with their index
	expressions being INTEGER_CST. */
	gcc_assert (TREE_CODE (index_expr) != INTEGER_CST);

	/* The default case is at the end of TREE_VEC. */
	elt = TREE_VEC_ELT (vec, TREE_VEC_LENGTH (vec) - 1);
	gcc_assert (!CASE_HIGH (elt));
	gcc_assert (!CASE_LOW (elt));
	default_label_decl = CASE_LABEL (elt);

	for (i = TREE_VEC_LENGTH (vec) - 1; --i >= 0; )
	{
	tree low, high;
	elt = TREE_VEC_ELT (vec, i);

	low = CASE_LOW (elt);
	gcc_assert (low);
	high = CASE_HIGH (elt);

	/* Discard empty ranges. */
	if (high && INT_CST_LT (high, low))
	continue;

	case_list = add_case_node (case_list, index_type, low, high,
	CASE_LABEL (elt));
	}


	before_case = start = get_last_insn ();
	default_label = label_rtx (default_label_decl);

	/* Get upper and lower bounds of case values. */

	uniq = 0;
	count = 0;
	label_bitmap = BITMAP_ALLOC (NULL);
	for (n = case_list; n; n = n->right)
	{
	/* Count the elements and track the largest and smallest
	of them (treating them as signed even if they are not). */
	if (count++ == 0)
	{
	minval = n->low;
	maxval = n->high;
	}
	else
	{
	if (INT_CST_LT (n->low, minval))
	minval = n->low;
	if (INT_CST_LT (maxval, n->high))
	maxval = n->high;
	}
	/* A range counts double, since it requires two compares. */
	if (! tree_int_cst_equal (n->low, n->high))
	count++;

	/* If we have not seen this label yet, then increase the
	number of unique case node targets seen. */
	lab = label_rtx (n->code_label);
	if (!bitmap_bit_p (label_bitmap, CODE_LABEL_NUMBER (lab)))
	{
	bitmap_set_bit (label_bitmap, CODE_LABEL_NUMBER (lab));
	uniq++;
	}
	}

	BITMAP_FREE (label_bitmap);

	/* cleanup_tree_cfg removes all SWITCH_EXPR with a single
	destination, such as one with a default case only. However,
	it doesn't remove cases that are out of range for the switch
	type, so we may still get a zero here. */
	if (count == 0)
	{
	emit_jump (default_label);
	return;
	}

	/* Compute span of values. */
	range = fold_build2 (MINUS_EXPR, index_type, maxval, minval);

	/* Try implementing this switch statement by a short sequence of
	bit-wise comparisons. However, we let the binary-tree case
	below handle constant index expressions. */
	if (CASE_USE_BIT_TESTS
	&& ! TREE_CONSTANT (index_expr)
	&& compare_tree_int (range, GET_MODE_BITSIZE (word_mode)) < 0
	&& compare_tree_int (range, 0) > 0
	&& lshift_cheap_p ()
	&& ((uniq == 1 && count >= 3)
	\|\| (uniq == 2 && count >= 5)
	\|\| (uniq == 3 && count >= 6)))
	{
	/* Optimize the case where all the case values fit in a
	word without having to subtract MINVAL. In this case,
	we can optimize away the subtraction. */
	if (compare_tree_int (minval, 0) > 0
	&& compare_tree_int (maxval, GET_MODE_BITSIZE (word_mode)) < 0)
	{
	minval = build_int_cst (index_type, 0);
	range = maxval;
	}
	emit_case_bit_tests (index_type, index_expr, minval, range,
	case_list, default_label);
	}

	/* If range of values is much bigger than number of values,
	make a sequence of conditional branches instead of a dispatch.
	If the switch-index is a constant, do it this way
	because we can optimize it. */

	else if (count < case_values_threshold ()
	\|\| compare_tree_int (range,
	(optimize_size ? 3 : 10) * count) > 0
	/* RANGE may be signed, and really large ranges will show up
	as negative numbers. */
	\|\| compare_tree_int (range, 0) < 0
	#ifndef ASM_OUTPUT_ADDR_DIFF_ELT
	\|\| flag_pic
	#endif
	\|\| !flag_jump_tables
	\|\| TREE_CONSTANT (index_expr)
	/* If neither casesi or tablejump is available, we can
	only go this way. */
	\|\| (!HAVE_casesi && !HAVE_tablejump))
	{
	index = expand_normal (index_expr);

	/* If the index is a short or char that we do not have
	an insn to handle comparisons directly, convert it to
	a full integer now, rather than letting each comparison
	generate the conversion. */

	if (GET_MODE_CLASS (GET_MODE (index)) == MODE_INT
	&& ! have_insn_for (COMPARE, GET_MODE (index)))
	{
	enum machine_mode wider_mode;
	for (wider_mode = GET_MODE (index); wider_mode != VOIDmode;
	wider_mode = GET_MODE_WIDER_MODE (wider_mode))
	if (have_insn_for (COMPARE, wider_mode))
	{
	index = convert_to_mode (wider_mode, index, unsignedp);
	break;
	}
	}

	do_pending_stack_adjust ();

	if (MEM_P (index))
	index = copy_to_reg (index);

	/* We generate a binary decision tree to select the
	appropriate target code. This is done as follows:

	The list of cases is rearranged into a binary tree,
	nearly optimal assuming equal probability for each case.

	The tree is transformed into RTL, eliminating
	redundant test conditions at the same time.

	If program flow could reach the end of the
	decision tree an unconditional jump to the
	default code is emitted. */

	use_cost_table
	= (TREE_CODE (orig_type) != ENUMERAL_TYPE
	&& estimate_case_costs (case_list));
	balance_case_nodes (&case_list, NULL);
	emit_case_nodes (index, case_list, default_label, index_type);
	emit_jump (default_label);
	}
	else
	{
	table_label = gen_label_rtx ();
	if (! try_casesi (index_type, index_expr, minval, range,
	table_label, default_label))
	{
	bool ok;

	/* Index jumptables from zero for suitable values of
	minval to avoid a subtraction. */
	if (! optimize_size
	&& compare_tree_int (minval, 0) > 0
	&& compare_tree_int (minval, 3) < 0)
	{
	minval = build_int_cst (index_type, 0);
	range = maxval;
	}

	ok = try_tablejump (index_type, index_expr, minval, range,
	table_label, default_label);
	gcc_assert (ok);
	}

	/* Get table of labels to jump to, in order of case index. */

	ncases = tree_low_cst (range, 0) + 1;
	labelvec = alloca (ncases * sizeof (rtx));
	memset (labelvec, 0, ncases * sizeof (rtx));

	for (n = case_list; n; n = n->right)
	{
	/* Compute the low and high bounds relative to the minimum
	value since that should fit in a HOST_WIDE_INT while the
	actual values may not. */
	HOST_WIDE_INT i_low
	= tree_low_cst (fold_build2 (MINUS_EXPR, index_type,
	n->low, minval), 1);
	HOST_WIDE_INT i_high
	= tree_low_cst (fold_build2 (MINUS_EXPR, index_type,
	n->high, minval), 1);
	HOST_WIDE_INT i;

	for (i = i_low; i <= i_high; i ++)
	labelvec[i]
	= gen_rtx_LABEL_REF (Pmode, label_rtx (n->code_label));
	}

	/* Fill in the gaps with the default. */
	for (i = 0; i < ncases; i++)
	if (labelvec[i] == 0)
	labelvec[i] = gen_rtx_LABEL_REF (Pmode, default_label);

	/* Output the table. */
	emit_label (table_label);

	if (CASE_VECTOR_PC_RELATIVE \|\| flag_pic)
	emit_jump_insn (gen_rtx_ADDR_DIFF_VEC (CASE_VECTOR_MODE,
	gen_rtx_LABEL_REF (Pmode, table_label),
	gen_rtvec_v (ncases, labelvec),
	const0_rtx, const0_rtx));
	else
	emit_jump_insn (gen_rtx_ADDR_VEC (CASE_VECTOR_MODE,
	gen_rtvec_v (ncases, labelvec)));

	/* Record no drop-through after the table. */
	emit_barrier ();
	}

	before_case = NEXT_INSN (before_case);
	end = get_last_insn ();
	fail = squeeze_notes (&before_case, &end);
	gcc_assert (!fail);
	reorder_insns (before_case, end, start);
	}

	free_temp_slots ();
	}

	/* Generate code to jump to LABEL if OP0 and OP1 are equal in mode MODE. */

	static void
	do_jump_if_equal (enum machine_mode mode, rtx op0, rtx op1, rtx label,
	int unsignedp)
	{
	do_compare_rtx_and_jump (op0, op1, EQ, unsignedp, mode,
	NULL_RTX, NULL_RTX, label);
	}

	/* Not all case values are encountered equally. This function
	uses a heuristic to weight case labels, in cases where that
	looks like a reasonable thing to do.

	Right now, all we try to guess is text, and we establish the
	following weights:

	chars above space: 16
	digits: 16
	default: 12
	space, punct: 8
	tab: 4
	newline: 2
	other "\" chars: 1
	remaining chars: 0

	If we find any cases in the switch that are not either -1 or in the range
	of valid ASCII characters, or are control characters other than those
	commonly used with "\", don't treat this switch scanning text.

	Return 1 if these nodes are suitable for cost estimation, otherwise
	return 0. */

	static int
	estimate_case_costs (case_node_ptr node)
	{
	tree min_ascii = integer_minus_one_node;
	tree max_ascii = build_int_cst (TREE_TYPE (node->high), 127);
	case_node_ptr n;
	int i;

	/* If we haven't already made the cost table, make it now. Note that the
	lower bound of the table is -1, not zero. */

	if (! cost_table_initialized)
	{
	cost_table_initialized = 1;

	for (i = 0; i < 128; i++)
	{
	if (ISALNUM (i))
	COST_TABLE (i) = 16;
	else if (ISPUNCT (i))
	COST_TABLE (i) = 8;
	else if (ISCNTRL (i))
	COST_TABLE (i) = -1;
	}

	COST_TABLE (' ') = 8;
	COST_TABLE ('\t') = 4;
	COST_TABLE ('\0') = 4;
	COST_TABLE ('\n') = 2;
	COST_TABLE ('\f') = 1;
	COST_TABLE ('\v') = 1;
	COST_TABLE ('\b') = 1;
	}

	/* See if all the case expressions look like text. It is text if the
	constant is >= -1 and the highest constant is <= 127. Do all comparisons
	as signed arithmetic since we don't want to ever access cost_table with a
	value less than -1. Also check that none of the constants in a range
	are strange control characters. */

	for (n = node; n; n = n->right)
	{
	if ((INT_CST_LT (n->low, min_ascii)) \|\| INT_CST_LT (max_ascii, n->high))
	return 0;

	for (i = (HOST_WIDE_INT) TREE_INT_CST_LOW (n->low);
	i <= (HOST_WIDE_INT) TREE_INT_CST_LOW (n->high); i++)
	if (COST_TABLE (i) < 0)
	return 0;
	}

	/* All interesting values are within the range of interesting
	ASCII characters. */
	return 1;
	}

	/* Take an ordered list of case nodes
	and transform them into a near optimal binary tree,
	on the assumption that any target code selection value is as
	likely as any other.

	The transformation is performed by splitting the ordered
	list into two equal sections plus a pivot. The parts are
	then attached to the pivot as left and right branches. Each
	branch is then transformed recursively. */

	static void
	balance_case_nodes (case_node_ptr *head, case_node_ptr parent)
	{
	case_node_ptr np;

	np = *head;
	if (np)
	{
	int cost = 0;
	int i = 0;
	int ranges = 0;
	case_node_ptr *npp;
	case_node_ptr left;

	/* Count the number of entries on branch. Also count the ranges. */

	while (np)
	{
	if (!tree_int_cst_equal (np->low, np->high))
	{
	ranges++;
	if (use_cost_table)
	cost += COST_TABLE (TREE_INT_CST_LOW (np->high));
	}

	if (use_cost_table)
	cost += COST_TABLE (TREE_INT_CST_LOW (np->low));

	i++;
	np = np->right;
	}

	if (i > 2)
	{
	/* Split this list if it is long enough for that to help. */
	npp = head;
	left = *npp;
	if (use_cost_table)
	{
	/* Find the place in the list that bisects the list's total cost,
	Here I gets half the total cost. */
	int n_moved = 0;
	i = (cost + 1) / 2;
	while (1)
	{
	/* Skip nodes while their cost does not reach that amount. */
	if (!tree_int_cst_equal ((npp)->low, (npp)->high))
	i -= COST_TABLE (TREE_INT_CST_LOW ((*npp)->high));
	i -= COST_TABLE (TREE_INT_CST_LOW ((*npp)->low));
	if (i <= 0)
	break;
	npp = &(*npp)->right;
	n_moved += 1;
	}
	if (n_moved == 0)
	{
	/* Leave this branch lopsided, but optimize left-hand
	side and fill in `parent' fields for right-hand side. */
	np = *head;
	np->parent = parent;
	balance_case_nodes (&np->left, np);
	for (; np->right; np = np->right)
	np->right->parent = np;
	return;
	}
	}
	/* If there are just three nodes, split at the middle one. */
	else if (i == 3)
	npp = &(*npp)->right;
	else
	{
	/* Find the place in the list that bisects the list's total cost,
	where ranges count as 2.
	Here I gets half the total cost. */
	i = (i + ranges + 1) / 2;
	while (1)
	{
	/* Skip nodes while their cost does not reach that amount. */
	if (!tree_int_cst_equal ((npp)->low, (npp)->high))
	i--;
	i--;
	if (i <= 0)
	break;
	npp = &(*npp)->right;
	}
	}
	head = np = npp;
	*npp = 0;
	np->parent = parent;
	np->left = left;

	/* Optimize each of the two split parts. */
	balance_case_nodes (&np->left, np);
	balance_case_nodes (&np->right, np);
	}
	else
	{
	/* Else leave this branch as one level,
	but fill in `parent' fields. */
	np = *head;
	np->parent = parent;
	for (; np->right; np = np->right)
	np->right->parent = np;
	}
	}
	}

	/* Search the parent sections of the case node tree
	to see if a test for the lower bound of NODE would be redundant.
	INDEX_TYPE is the type of the index expression.

	The instructions to generate the case decision tree are
	output in the same order as nodes are processed so it is
	known that if a parent node checks the range of the current
	node minus one that the current node is bounded at its lower
	span. Thus the test would be redundant. */

	static int
	node_has_low_bound (case_node_ptr node, tree index_type)
	{
	tree low_minus_one;
	case_node_ptr pnode;

	/* If the lower bound of this node is the lowest value in the index type,
	we need not test it. */

	if (tree_int_cst_equal (node->low, TYPE_MIN_VALUE (index_type)))
	return 1;

	/* If this node has a left branch, the value at the left must be less
	than that at this node, so it cannot be bounded at the bottom and
	we need not bother testing any further. */

	if (node->left)
	return 0;

	low_minus_one = fold_build2 (MINUS_EXPR, TREE_TYPE (node->low),
	node->low,
	build_int_cst (TREE_TYPE (node->low), 1));

	/* If the subtraction above overflowed, we can't verify anything.
	Otherwise, look for a parent that tests our value - 1. */

	if (! tree_int_cst_lt (low_minus_one, node->low))
	return 0;

	for (pnode = node->parent; pnode; pnode = pnode->parent)
	if (tree_int_cst_equal (low_minus_one, pnode->high))
	return 1;

	return 0;
	}

	/* Search the parent sections of the case node tree
	to see if a test for the upper bound of NODE would be redundant.
	INDEX_TYPE is the type of the index expression.

	The instructions to generate the case decision tree are
	output in the same order as nodes are processed so it is
	known that if a parent node checks the range of the current
	node plus one that the current node is bounded at its upper
	span. Thus the test would be redundant. */

	static int
	node_has_high_bound (case_node_ptr node, tree index_type)
	{
	tree high_plus_one;
	case_node_ptr pnode;

	/* If there is no upper bound, obviously no test is needed. */

	if (TYPE_MAX_VALUE (index_type) == NULL)
	return 1;

	/* If the upper bound of this node is the highest value in the type
	of the index expression, we need not test against it. */

	if (tree_int_cst_equal (node->high, TYPE_MAX_VALUE (index_type)))
	return 1;

	/* If this node has a right branch, the value at the right must be greater
	than that at this node, so it cannot be bounded at the top and
	we need not bother testing any further. */

	if (node->right)
	return 0;

	high_plus_one = fold_build2 (PLUS_EXPR, TREE_TYPE (node->high),
	node->high,
	build_int_cst (TREE_TYPE (node->high), 1));

	/* If the addition above overflowed, we can't verify anything.
	Otherwise, look for a parent that tests our value + 1. */

	if (! tree_int_cst_lt (node->high, high_plus_one))
	return 0;

	for (pnode = node->parent; pnode; pnode = pnode->parent)
	if (tree_int_cst_equal (high_plus_one, pnode->low))
	return 1;

	return 0;
	}

	/* Search the parent sections of the
	case node tree to see if both tests for the upper and lower
	bounds of NODE would be redundant. */

	static int
	node_is_bounded (case_node_ptr node, tree index_type)
	{
	return (node_has_low_bound (node, index_type)
	&& node_has_high_bound (node, index_type));
	}

	/* Emit step-by-step code to select a case for the value of INDEX.
	The thus generated decision tree follows the form of the
	case-node binary tree NODE, whose nodes represent test conditions.
	INDEX_TYPE is the type of the index of the switch.

	Care is taken to prune redundant tests from the decision tree
	by detecting any boundary conditions already checked by
	emitted rtx. (See node_has_high_bound, node_has_low_bound
	and node_is_bounded, above.)

	Where the test conditions can be shown to be redundant we emit
	an unconditional jump to the target code. As a further
	optimization, the subordinates of a tree node are examined to
	check for bounded nodes. In this case conditional and/or
	unconditional jumps as a result of the boundary check for the
	current node are arranged to target the subordinates associated
	code for out of bound conditions on the current node.

	We can assume that when control reaches the code generated here,
	the index value has already been compared with the parents
	of this node, and determined to be on the same side of each parent
	as this node is. Thus, if this node tests for the value 51,
	and a parent tested for 52, we don't need to consider
	the possibility of a value greater than 51. If another parent
	tests for the value 50, then this node need not test anything. */

	static void
	emit_case_nodes (rtx index, case_node_ptr node, rtx default_label,
	tree index_type)
	{
	/* If INDEX has an unsigned type, we must make unsigned branches. */
	int unsignedp = TYPE_UNSIGNED (index_type);
	enum machine_mode mode = GET_MODE (index);
	enum machine_mode imode = TYPE_MODE (index_type);

	/* Handle indices detected as constant during RTL expansion. */
	if (mode == VOIDmode)
	mode = imode;

	/* See if our parents have already tested everything for us.
	If they have, emit an unconditional jump for this node. */
	if (node_is_bounded (node, index_type))
	emit_jump (label_rtx (node->code_label));

	else if (tree_int_cst_equal (node->low, node->high))
	{
	/* Node is single valued. First see if the index expression matches
	this node and then check our children, if any. */

	do_jump_if_equal (mode, index,
	convert_modes (mode, imode,
	expand_normal (node->low),
	unsignedp),
	label_rtx (node->code_label), unsignedp);

	if (node->right != 0 && node->left != 0)
	{
	/* This node has children on both sides.
	Dispatch to one side or the other
	by comparing the index value with this node's value.
	If one subtree is bounded, check that one first,
	so we can avoid real branches in the tree. */

	if (node_is_bounded (node->right, index_type))
	{
	emit_cmp_and_jump_insns (index,
	convert_modes
	(mode, imode,
	expand_normal (node->high),
	unsignedp),
	GT, NULL_RTX, mode, unsignedp,
	label_rtx (node->right->code_label));
	emit_case_nodes (index, node->left, default_label, index_type);
	}

	else if (node_is_bounded (node->left, index_type))
	{
	emit_cmp_and_jump_insns (index,
	convert_modes
	(mode, imode,
	expand_normal (node->high),
	unsignedp),
	LT, NULL_RTX, mode, unsignedp,
	label_rtx (node->left->code_label));
	emit_case_nodes (index, node->right, default_label, index_type);
	}

	/* If both children are single-valued cases with no
	children, finish up all the work. This way, we can save
	one ordered comparison. */
	else if (tree_int_cst_equal (node->right->low, node->right->high)
	&& node->right->left == 0
	&& node->right->right == 0
	&& tree_int_cst_equal (node->left->low, node->left->high)
	&& node->left->left == 0
	&& node->left->right == 0)
	{
	/* Neither node is bounded. First distinguish the two sides;
	then emit the code for one side at a time. */

	/* See if the value matches what the right hand side
	wants. */
	do_jump_if_equal (mode, index,
	convert_modes (mode, imode,
	expand_normal (node->right->low),
	unsignedp),
	label_rtx (node->right->code_label),
	unsignedp);

	/* See if the value matches what the left hand side
	wants. */
	do_jump_if_equal (mode, index,
	convert_modes (mode, imode,
	expand_normal (node->left->low),
	unsignedp),
	label_rtx (node->left->code_label),
	unsignedp);
	}

	else
	{
	/* Neither node is bounded. First distinguish the two sides;
	then emit the code for one side at a time. */

	tree test_label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);

	/* See if the value is on the right. */
	emit_cmp_and_jump_insns (index,
	convert_modes
	(mode, imode,
	expand_normal (node->high),
	unsignedp),
	GT, NULL_RTX, mode, unsignedp,
	label_rtx (test_label));

	/* Value must be on the left.
	Handle the left-hand subtree. */
	emit_case_nodes (index, node->left, default_label, index_type);
	/* If left-hand subtree does nothing,
	go to default. */
	emit_jump (default_label);

	/* Code branches here for the right-hand subtree. */
	expand_label (test_label);
	emit_case_nodes (index, node->right, default_label, index_type);
	}
	}

	else if (node->right != 0 && node->left == 0)
	{
	/* Here we have a right child but no left so we issue a conditional
	branch to default and process the right child.

	Omit the conditional branch to default if the right child
	does not have any children and is single valued; it would
	cost too much space to save so little time. */

	if (node->right->right \|\| node->right->left
	\|\| !tree_int_cst_equal (node->right->low, node->right->high))
	{
	if (!node_has_low_bound (node, index_type))
	{
	emit_cmp_and_jump_insns (index,
	convert_modes
	(mode, imode,
	expand_normal (node->high),
	unsignedp),
	LT, NULL_RTX, mode, unsignedp,
	default_label);
	}

	emit_case_nodes (index, node->right, default_label, index_type);
	}
	else
	/* We cannot process node->right normally
	since we haven't ruled out the numbers less than
	this node's value. So handle node->right explicitly. */
	do_jump_if_equal (mode, index,
	convert_modes
	(mode, imode,
	expand_normal (node->right->low),
	unsignedp),
	label_rtx (node->right->code_label), unsignedp);
	}

	else if (node->right == 0 && node->left != 0)
	{
	/* Just one subtree, on the left. */
	if (node->left->left \|\| node->left->right
	\|\| !tree_int_cst_equal (node->left->low, node->left->high))
	{
	if (!node_has_high_bound (node, index_type))
	{
	emit_cmp_and_jump_insns (index,
	convert_modes
	(mode, imode,
	expand_normal (node->high),
	unsignedp),
	GT, NULL_RTX, mode, unsignedp,
	default_label);
	}

	emit_case_nodes (index, node->left, default_label, index_type);
	}
	else
	/* We cannot process node->left normally
	since we haven't ruled out the numbers less than
	this node's value. So handle node->left explicitly. */
	do_jump_if_equal (mode, index,
	convert_modes
	(mode, imode,
	expand_normal (node->left->low),
	unsignedp),
	label_rtx (node->left->code_label), unsignedp);
	}
	}
	else
	{
	/* Node is a range. These cases are very similar to those for a single
	value, except that we do not start by testing whether this node
	is the one to branch to. */

	if (node->right != 0 && node->left != 0)
	{
	/* Node has subtrees on both sides.
	If the right-hand subtree is bounded,
	test for it first, since we can go straight there.
	Otherwise, we need to make a branch in the control structure,
	then handle the two subtrees. */
	tree test_label = 0;

	if (node_is_bounded (node->right, index_type))
	/* Right hand node is fully bounded so we can eliminate any
	testing and branch directly to the target code. */
	emit_cmp_and_jump_insns (index,
	convert_modes
	(mode, imode,
	expand_normal (node->high),
	unsignedp),
	GT, NULL_RTX, mode, unsignedp,
	label_rtx (node->right->code_label));
	else
	{
	/* Right hand node requires testing.
	Branch to a label where we will handle it later. */

	test_label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
	emit_cmp_and_jump_insns (index,
	convert_modes
	(mode, imode,
	expand_normal (node->high),
	unsignedp),
	GT, NULL_RTX, mode, unsignedp,
	label_rtx (test_label));
	}

	/* Value belongs to this node or to the left-hand subtree. */

	emit_cmp_and_jump_insns (index,
	convert_modes
	(mode, imode,
	expand_normal (node->low),
	unsignedp),
	GE, NULL_RTX, mode, unsignedp,
	label_rtx (node->code_label));

	/* Handle the left-hand subtree. */
	emit_case_nodes (index, node->left, default_label, index_type);

	/* If right node had to be handled later, do that now. */

	if (test_label)
	{
	/* If the left-hand subtree fell through,
	don't let it fall into the right-hand subtree. */
	emit_jump (default_label);

	expand_label (test_label);
	emit_case_nodes (index, node->right, default_label, index_type);
	}
	}

	else if (node->right != 0 && node->left == 0)
	{
	/* Deal with values to the left of this node,
	if they are possible. */
	if (!node_has_low_bound (node, index_type))
	{
	emit_cmp_and_jump_insns (index,
	convert_modes
	(mode, imode,
	expand_normal (node->low),
	unsignedp),
	LT, NULL_RTX, mode, unsignedp,
	default_label);
	}

	/* Value belongs to this node or to the right-hand subtree. */

	emit_cmp_and_jump_insns (index,
	convert_modes
	(mode, imode,
	expand_normal (node->high),
	unsignedp),
	LE, NULL_RTX, mode, unsignedp,
	label_rtx (node->code_label));

	emit_case_nodes (index, node->right, default_label, index_type);
	}

	else if (node->right == 0 && node->left != 0)
	{
	/* Deal with values to the right of this node,
	if they are possible. */
	if (!node_has_high_bound (node, index_type))
	{
	emit_cmp_and_jump_insns (index,
	convert_modes
	(mode, imode,
	expand_normal (node->high),
	unsignedp),
	GT, NULL_RTX, mode, unsignedp,
	default_label);
	}

	/* Value belongs to this node or to the left-hand subtree. */

	emit_cmp_and_jump_insns (index,
	convert_modes
	(mode, imode,
	expand_normal (node->low),
	unsignedp),
	GE, NULL_RTX, mode, unsignedp,
	label_rtx (node->code_label));

	emit_case_nodes (index, node->left, default_label, index_type);
	}

	else
	{
	/* Node has no children so we check low and high bounds to remove
	redundant tests. Only one of the bounds can exist,
	since otherwise this node is bounded--a case tested already. */
	int high_bound = node_has_high_bound (node, index_type);
	int low_bound = node_has_low_bound (node, index_type);

	if (!high_bound && low_bound)
	{
	emit_cmp_and_jump_insns (index,
	convert_modes
	(mode, imode,
	expand_normal (node->high),
	unsignedp),
	GT, NULL_RTX, mode, unsignedp,
	default_label);
	}

	else if (!low_bound && high_bound)
	{
	emit_cmp_and_jump_insns (index,
	convert_modes
	(mode, imode,
	expand_normal (node->low),
	unsignedp),
	LT, NULL_RTX, mode, unsignedp,
	default_label);
	}
	else if (!low_bound && !high_bound)
	{
	/* Widen LOW and HIGH to the same width as INDEX. */
	tree type = lang_hooks.types.type_for_mode (mode, unsignedp);
	tree low = build1 (CONVERT_EXPR, type, node->low);
	tree high = build1 (CONVERT_EXPR, type, node->high);
	rtx low_rtx, new_index, new_bound;

	/* Instead of doing two branches, emit one unsigned branch for
	(index-low) > (high-low). */
	low_rtx = expand_expr (low, NULL_RTX, mode, EXPAND_NORMAL);
	new_index = expand_simple_binop (mode, MINUS, index, low_rtx,
	NULL_RTX, unsignedp,
	OPTAB_WIDEN);
	new_bound = expand_expr (fold_build2 (MINUS_EXPR, type,
	high, low),
	NULL_RTX, mode, EXPAND_NORMAL);

	emit_cmp_and_jump_insns (new_index, new_bound, GT, NULL_RTX,
	mode, 1, default_label);
	}

	emit_jump (label_rtx (node->code_label));
	}
	}
	}
	diff --git a/contrib/gcc/toplev.c b/contrib/gcc/toplev.c
	index ab6a7ff6f54d..786ec128977b 100644
	--- a/contrib/gcc/toplev.c
	+++ b/contrib/gcc/toplev.c
	@@ -1,2040 +1,2080 @@
	/* Top level of GCC compilers (cc1, cc1plus, etc.)
	Copyright (C) 1987, 1988, 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
	1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006
	Free Software Foundation, Inc.

	This file is part of GCC.

	GCC is free software; you can redistribute it and/or modify it under
	the terms of the GNU General Public License as published by the Free
	Software Foundation; either version 2, or (at your option) any later
	version.

	GCC is distributed in the hope that it will be useful, but WITHOUT ANY
	WARRANTY; without even the implied warranty of MERCHANTABILITY or
	FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	for more details.

	You should have received a copy of the GNU General Public License
	along with GCC; see the file COPYING. If not, write to the Free
	Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
	02110-1301, USA. */

	/* $FreeBSD$ */

	/* This is the top level of cc1/c++.
	It parses command args, opens files, invokes the various passes
	in the proper order, and counts the time used by each.
	Error messages and low-level interface to malloc also handled here. */

	#include "config.h"
	#undef FLOAT /* This is for hpux. They should change hpux. */
	#undef FFS /* Some systems define this in param.h. */
	#include "system.h"
	#include "coretypes.h"
	#include "tm.h"
	#include <signal.h>

	#ifdef HAVE_SYS_RESOURCE_H
	# include <sys/resource.h>
	#endif

	#ifdef HAVE_SYS_TIMES_H
	# include <sys/times.h>
	#endif

	#include "line-map.h"
	#include "input.h"
	#include "tree.h"
	#include "version.h"
	#include "rtl.h"
	#include "tm_p.h"
	#include "flags.h"
	#include "insn-attr.h"
	#include "insn-config.h"
	#include "insn-flags.h"
	#include "hard-reg-set.h"
	#include "recog.h"
	#include "output.h"
	#include "except.h"
	#include "function.h"
	#include "toplev.h"
	#include "expr.h"
	#include "basic-block.h"
	#include "intl.h"
	#include "ggc.h"
	#include "graph.h"
	#include "regs.h"
	#include "timevar.h"
	#include "diagnostic.h"
	#include "params.h"
	#include "reload.h"
	#include "dwarf2asm.h"
	#include "integrate.h"
	#include "real.h"
	#include "debug.h"
	#include "target.h"
	#include "langhooks.h"
	#include "cfglayout.h"
	#include "cfgloop.h"
	#include "hosthooks.h"
	#include "cgraph.h"
	#include "opts.h"
	#include "coverage.h"
	#include "value-prof.h"
	#include "alloc-pool.h"
	#include "tree-mudflap.h"

	#if defined (DWARF2_UNWIND_INFO) \|\| defined (DWARF2_DEBUGGING_INFO)
	#include "dwarf2out.h"
	#endif

	#if defined(DBX_DEBUGGING_INFO) \|\| defined(XCOFF_DEBUGGING_INFO)
	#include "dbxout.h"
	#endif

	#ifdef SDB_DEBUGGING_INFO
	#include "sdbout.h"
	#endif

	#ifdef XCOFF_DEBUGGING_INFO
	#include "xcoffout.h" /* Needed for external data
	declarations for e.g. AIX 4.x. */
	#endif

	static void general_init (const char *);
	static void do_compile (void);
	static void process_options (void);
	static void backend_init (void);
	static int lang_dependent_init (const char *);
	static void init_asm_output (const char *);
	static void finalize (void);

	static void crash_signal (int) ATTRIBUTE_NORETURN;
	static void setup_core_dumping (void);
	static void compile_file (void);

	static int print_single_switch (FILE , int, int, const char ,
	const char , const char ,
	const char , const char );
	static void print_switch_values (FILE , int, int, const char ,
	const char , const char );

	/* Nonzero to dump debug info whilst parsing (-dy option). */
	static int set_yydebug;

	/* True if we don't need a backend (e.g. preprocessing only). */
	static bool no_backend;

	/* Length of line when printing switch values. */
	#define MAX_LINE 75

	/* Name of program invoked, sans directories. */

	const char *progname;

	/* Copy of argument vector to toplev_main. */
	static const char **save_argv;

	/* Name of top-level original source file (what was input to cpp).
	This comes from the #-command at the beginning of the actual input.
	If there isn't any there, then this is the cc1 input file name. */

	const char *main_input_filename;

	#ifndef USE_MAPPED_LOCATION
	location_t unknown_location = { NULL, 0 };
	#endif

	/* Used to enable -fvar-tracking, -fweb and -frename-registers according
	to optimize and default_debug_hooks in process_options (). */
	#define AUTODETECT_VALUE 2

	/* Current position in real source file. */

	location_t input_location;

	struct line_maps line_table;

	/* Nonzero if it is unsafe to create any new pseudo registers. */
	int no_new_pseudos;

	/* Stack of currently pending input files. */

	struct file_stack *input_file_stack;

	/* Incremented on each change to input_file_stack. */
	int input_file_stack_tick;

	/* Record of input_file_stack at each tick. */
	typedef struct file_stack *fs_p;
	DEF_VEC_P(fs_p);
	DEF_VEC_ALLOC_P(fs_p,heap);
	static VEC(fs_p,heap) *input_file_stack_history;

	/* Whether input_file_stack has been restored to a previous state (in
	which case there should be no more pushing). */
	static bool input_file_stack_restored;

	/* Name to use as base of names for dump output files. */

	const char *dump_base_name;

	/* Name to use as a base for auxiliary output files. */

	const char *aux_base_name;

	/* Bit flags that specify the machine subtype we are compiling for.
	Bits are tested using macros TARGET_... defined in the tm.h file
	and set by `-m...' switches. Must be defined in rtlanal.c. */

	extern int target_flags;

	/* A mask of target_flags that includes bit X if X was set or cleared
	on the command line. */

	int target_flags_explicit;

	/* Debug hooks - dependent upon command line options. */

	const struct gcc_debug_hooks *debug_hooks;

	/* Debug hooks - target default. */

	static const struct gcc_debug_hooks *default_debug_hooks;

	/* Other flags saying which kinds of debugging dump have been requested. */

	int rtl_dump_and_exit;
	int flag_print_asm_name;
	enum graph_dump_types graph_dump_format;

	/* Name for output file of assembly code, specified with -o. */

	const char *asm_file_name;

	/* Nonzero means do optimizations. -O.
	Particular numeric values stand for particular amounts of optimization;
	thus, -O2 stores 2 here. However, the optimizations beyond the basic
	ones are not controlled directly by this variable. Instead, they are
	controlled by individual `flag_...' variables that are defaulted
	based on this variable. */

	int optimize = 0;

	/* Nonzero means optimize for size. -Os.
	The only valid values are zero and nonzero. When optimize_size is
	nonzero, optimize defaults to 2, but certain individual code
	bloating optimizations are disabled. */

	int optimize_size = 0;

	/* The FUNCTION_DECL for the function currently being compiled,
	or 0 if between functions. */
	tree current_function_decl;

	/* Set to the FUNC_BEGIN label of the current function, or NULL
	if none. */
	const char * current_function_func_begin_label;

	/* Temporarily suppress certain warnings.
	This is set while reading code from a system header file. */

	int in_system_header = 0;

	/* Nonzero means to collect statistics which might be expensive
	and to print them when we are done. */
	int flag_detailed_statistics = 0;

	/* A random sequence of characters, unless overridden by user. */
	const char *flag_random_seed;

	/* A local time stamp derived from the time of compilation. It will be
	zero if the system cannot provide a time. It will be -1u, if the
	user has specified a particular random seed. */
	unsigned local_tick;

	/* -f flags. */

	/* Nonzero means `char' should be signed. */

	int flag_signed_char;

	/* Nonzero means give an enum type only as many bytes as it needs. A value
	of 2 means it has not yet been initialized. */

	int flag_short_enums;

	/* Nonzero if structures and unions should be returned in memory.

	This should only be defined if compatibility with another compiler or
	with an ABI is needed, because it results in slower code. */

	#ifndef DEFAULT_PCC_STRUCT_RETURN
	#define DEFAULT_PCC_STRUCT_RETURN 1
	#endif

	/* Nonzero for -fpcc-struct-return: return values the same way PCC does. */

	int flag_pcc_struct_return = DEFAULT_PCC_STRUCT_RETURN;

	/* 0 means straightforward implementation of complex divide acceptable.
	1 means wide ranges of inputs must work for complex divide.
	2 means C99-like requirements for complex multiply and divide. */

	int flag_complex_method = 1;

	/* Nonzero means that we don't want inlining by virtue of -fno-inline,
	not just because the tree inliner turned us off. */

	int flag_really_no_inline = 2;

	/* Nonzero means we should be saving declaration info into a .X file. */

	int flag_gen_aux_info = 0;

	/* Specified name of aux-info file. */

	const char *aux_info_file_name;

	/* Nonzero if we are compiling code for a shared library, zero for
	executable. */

	int flag_shlib;

	/* Generate code for GNU or NeXT Objective-C runtime environment. */

	#ifdef NEXT_OBJC_RUNTIME
	int flag_next_runtime = 1;
	#else
	int flag_next_runtime = 0;
	#endif

	/* Set to the default thread-local storage (tls) model to use. */

	enum tls_model flag_tls_default = TLS_MODEL_GLOBAL_DYNAMIC;

	/* Nonzero means change certain warnings into errors.
	Usually these are warnings about failure to conform to some standard. */

	int flag_pedantic_errors = 0;

	/* -dA causes debug commentary information to be produced in
	the generated assembly code (to make it more readable). This option
	is generally only of use to those who actually need to read the
	generated assembly code (perhaps while debugging the compiler itself).
	Currently, this switch is only used by dwarfout.c; however, it is intended
	to be a catchall for printing debug information in the assembler file. */

	int flag_debug_asm = 0;

	/* -dP causes the rtl to be emitted as a comment in assembly. */

	int flag_dump_rtl_in_asm = 0;

	/* When non-NULL, indicates that whenever space is allocated on the
	stack, the resulting stack pointer must not pass this
	address---that is, for stacks that grow downward, the stack pointer
	must always be greater than or equal to this address; for stacks
	that grow upward, the stack pointer must be less than this address.
	At present, the rtx may be either a REG or a SYMBOL_REF, although
	the support provided depends on the backend. */
	rtx stack_limit_rtx;

	/* If one, renumber instruction UIDs to reduce the number of
	unused UIDs if there are a lot of instructions. If greater than
	one, unconditionally renumber instruction UIDs. */
	int flag_renumber_insns = 1;

	/* Nonzero if we should track variables. When
	flag_var_tracking == AUTODETECT_VALUE it will be set according
	to optimize, debug_info_level and debug_hooks in process_options (). */
	int flag_var_tracking = AUTODETECT_VALUE;

	/* True if the user has tagged the function with the 'section'
	attribute. */

	bool user_defined_section_attribute = false;

	/* Values of the -falign-* flags: how much to align labels in code.
	0 means `use default', 1 means `don't align'.
	For each variable, there is an _log variant which is the power
	of two not less than the variable, for .align output. */

	int align_loops_log;
	int align_loops_max_skip;
	int align_jumps_log;
	int align_jumps_max_skip;
	int align_labels_log;
	int align_labels_max_skip;
	int align_functions_log;

	typedef struct
	{
	const char *const string;
	int *const variable;
	const int on_value;
	}
	lang_independent_options;

	/* Nonzero if subexpressions must be evaluated from left-to-right. */
	int flag_evaluation_order = 0;

	/* The user symbol prefix after having resolved same. */
	const char *user_label_prefix;

	static const param_info lang_independent_params[] = {
	#define DEFPARAM(ENUM, OPTION, HELP, DEFAULT, MIN, MAX) \
	{ OPTION, DEFAULT, MIN, MAX, HELP },
	#include "params.def"
	#undef DEFPARAM
	{ NULL, 0, 0, 0, NULL }
	};

	/* Output files for assembler code (real compiler output)
	and debugging dumps. */

	FILE *asm_out_file;
	FILE *aux_info_file;
	FILE *dump_file = NULL;
	const char *dump_file_name;

	/* The current working directory of a translation. It's generally the
	directory from which compilation was initiated, but a preprocessed
	file may specify the original directory in which it was
	created. */

	static const char *src_pwd;

	/* Initialize src_pwd with the given string, and return true. If it
	was already initialized, return false. As a special case, it may
	be called with a NULL argument to test whether src_pwd has NOT been
	initialized yet. */

	bool
	set_src_pwd (const char *pwd)
	{
	if (src_pwd)
	{
	if (strcmp (src_pwd, pwd) == 0)
	return true;
	else
	return false;
	}

	src_pwd = xstrdup (pwd);
	return true;
	}

	/* Return the directory from which the translation unit was initiated,
	in case set_src_pwd() was not called before to assign it a
	different value. */

	const char *
	get_src_pwd (void)
	{
	if (! src_pwd)
	{
	src_pwd = getpwd ();
	if (!src_pwd)
	src_pwd = ".";
	}

	return src_pwd;
	}

	/* Called when the start of a function definition is parsed,
	this function prints on stderr the name of the function. */
	void
	announce_function (tree decl)
	{
	if (!quiet_flag)
	{
	if (rtl_dump_and_exit)
	fprintf (stderr, "%s ", IDENTIFIER_POINTER (DECL_NAME (decl)));
	else
	fprintf (stderr, " %s", lang_hooks.decl_printable_name (decl, 2));
	fflush (stderr);
	pp_needs_newline (global_dc->printer) = true;
	diagnostic_set_last_function (global_dc);
	}
	}

	/* Set up a default flag_random_seed and local_tick, unless the user
	already specified one. */

	static void
	randomize (void)
	{
	if (!flag_random_seed)
	{
	unsigned HOST_WIDE_INT value;
	static char random_seed[HOST_BITS_PER_WIDE_INT / 4 + 3];

	/* Get some more or less random data. */
	#ifdef HAVE_GETTIMEOFDAY
	{
	struct timeval tv;

	gettimeofday (&tv, NULL);
	local_tick = tv.tv_sec * 1000 + tv.tv_usec / 1000;
	}
	#else
	{
	time_t now = time (NULL);

	if (now != (time_t)-1)
	local_tick = (unsigned) now;
	}
	#endif
	value = local_tick ^ getpid ();

	sprintf (random_seed, HOST_WIDE_INT_PRINT_HEX, value);
	flag_random_seed = random_seed;
	}
	else if (!local_tick)
	local_tick = -1;
	}


	/* Decode the string P as an integral parameter.
	If the string is indeed an integer return its numeric value else
	issue an Invalid Option error for the option PNAME and return DEFVAL.
	If PNAME is zero just return DEFVAL, do not call error. */

	int
	read_integral_parameter (const char p, const char pname, const int defval)
	{
	const char *endp = p;

	while (*endp)
	{
	if (ISDIGIT (*endp))
	endp++;
	else
	break;
	}

	if (*endp != 0)
	{
	if (pname != 0)
	error ("invalid option argument %qs", pname);
	return defval;
	}

	return atoi (p);
	}

	/* When compiling with a recent enough GCC, we use the GNU C "extern inline"
	for floor_log2 and exact_log2; see toplev.h. That construct, however,
	conflicts with the ISO C++ One Definition Rule. */

	#if GCC_VERSION < 3004 \|\| !defined (__cplusplus)

	/* Given X, an unsigned number, return the largest int Y such that 2**Y <= X.
	If X is 0, return -1. */

	int
	floor_log2 (unsigned HOST_WIDE_INT x)
	{
	int t = 0;

	if (x == 0)
	return -1;

	#ifdef CLZ_HWI
	t = HOST_BITS_PER_WIDE_INT - 1 - (int) CLZ_HWI (x);
	#else
	if (HOST_BITS_PER_WIDE_INT > 64)
	if (x >= (unsigned HOST_WIDE_INT) 1 << (t + 64))
	t += 64;
	if (HOST_BITS_PER_WIDE_INT > 32)
	if (x >= ((unsigned HOST_WIDE_INT) 1) << (t + 32))
	t += 32;
	if (x >= ((unsigned HOST_WIDE_INT) 1) << (t + 16))
	t += 16;
	if (x >= ((unsigned HOST_WIDE_INT) 1) << (t + 8))
	t += 8;
	if (x >= ((unsigned HOST_WIDE_INT) 1) << (t + 4))
	t += 4;
	if (x >= ((unsigned HOST_WIDE_INT) 1) << (t + 2))
	t += 2;
	if (x >= ((unsigned HOST_WIDE_INT) 1) << (t + 1))
	t += 1;
	#endif

	return t;
	}

	/* Return the logarithm of X, base 2, considering X unsigned,
	if X is a power of 2. Otherwise, returns -1. */

	int
	exact_log2 (unsigned HOST_WIDE_INT x)
	{
	if (x != (x & -x))
	return -1;
	#ifdef CTZ_HWI
	return x ? CTZ_HWI (x) : -1;
	#else
	return floor_log2 (x);
	#endif
	}

	#endif /* GCC_VERSION < 3004 \|\| !defined (__cplusplus) */

	/* Handler for fatal signals, such as SIGSEGV. These are transformed
	into ICE messages, which is much more user friendly. In case the
	error printer crashes, reset the signal to prevent infinite recursion. */

	static void
	crash_signal (int signo)
	{
	signal (signo, SIG_DFL);

	/* If we crashed while processing an ASM statement, then be a little more
	graceful. It's most likely the user's fault. */
	if (this_is_asm_operands)
	{
	output_operand_lossage ("unrecoverable error");
	exit (FATAL_EXIT_CODE);
	}

	internal_error ("%s", strsignal (signo));
	}

	/* Arrange to dump core on error. (The regular error message is still
	printed first, except in the case of abort().) */

	static void
	setup_core_dumping (void)
	{
	#ifdef SIGABRT
	signal (SIGABRT, SIG_DFL);
	#endif
	#if defined(HAVE_SETRLIMIT)
	{
	struct rlimit rlim;
	if (getrlimit (RLIMIT_CORE, &rlim) != 0)
	fatal_error ("getting core file size maximum limit: %m");
	rlim.rlim_cur = rlim.rlim_max;
	if (setrlimit (RLIMIT_CORE, &rlim) != 0)
	fatal_error ("setting core file size limit to maximum: %m");
	}
	#endif
	diagnostic_abort_on_error (global_dc);
	}


	/* Strip off a legitimate source ending from the input string NAME of
	length LEN. Rather than having to know the names used by all of
	our front ends, we strip off an ending of a period followed by
	up to five characters. (Java uses ".class".) */

	void
	strip_off_ending (char *name, int len)
	{
	int i;
	for (i = 2; i < 6 && len > i; i++)
	{
	if (name[len - i] == '.')
	{
	name[len - i] = '\0';
	break;
	}
	}
	}

	/* Output a quoted string. */

	void
	output_quoted_string (FILE asm_file, const char string)
	{
	#ifdef OUTPUT_QUOTED_STRING
	OUTPUT_QUOTED_STRING (asm_file, string);
	#else
	char c;

	putc ('\"', asm_file);
	while ((c = *string++) != 0)
	{
	if (ISPRINT (c))
	{
	if (c == '\"' \|\| c == '\\')
	putc ('\\', asm_file);
	putc (c, asm_file);
	}
	else
	fprintf (asm_file, "\\%03o", (unsigned char) c);
	}
	putc ('\"', asm_file);
	#endif
	}

	/* Output a file name in the form wanted by System V. */

	void
	output_file_directive (FILE asm_file, const char input_name)
	{
	int len;
	const char *na;

	if (input_name == NULL)
	input_name = "<stdin>";

	len = strlen (input_name);
	na = input_name + len;

	/* NA gets INPUT_NAME sans directory names. */
	while (na > input_name)
	{
	if (IS_DIR_SEPARATOR (na[-1]))
	break;
	na--;
	}

	#ifdef ASM_OUTPUT_SOURCE_FILENAME
	ASM_OUTPUT_SOURCE_FILENAME (asm_file, na);
	#else
	fprintf (asm_file, "\t.file\t");
	output_quoted_string (asm_file, na);
	fputc ('\n', asm_file);
	#endif
	}

	/* A subroutine of wrapup_global_declarations. We've come to the end of
	the compilation unit. All deferred variables should be undeferred,
	and all incomplete decls should be finalized. */

	void
	wrapup_global_declaration_1 (tree decl)
	{
	/* We're not deferring this any longer. Assignment is conditional to
	avoid needlessly dirtying PCH pages. */
	if (CODE_CONTAINS_STRUCT (TREE_CODE (decl), TS_DECL_WITH_VIS)
	&& DECL_DEFER_OUTPUT (decl) != 0)
	DECL_DEFER_OUTPUT (decl) = 0;

	if (TREE_CODE (decl) == VAR_DECL && DECL_SIZE (decl) == 0)
	lang_hooks.finish_incomplete_decl (decl);
	}

	/* A subroutine of wrapup_global_declarations. Decide whether or not DECL
	needs to be output. Return true if it is output. */

	bool
	wrapup_global_declaration_2 (tree decl)
	{
	if (TREE_ASM_WRITTEN (decl) \|\| DECL_EXTERNAL (decl))
	return false;

	/* Don't write out static consts, unless we still need them.

	We also keep static consts if not optimizing (for debugging),
	unless the user specified -fno-keep-static-consts.
	??? They might be better written into the debug information.
	This is possible when using DWARF.

	A language processor that wants static constants to be always
	written out (even if it is not used) is responsible for
	calling rest_of_decl_compilation itself. E.g. the C front-end
	calls rest_of_decl_compilation from finish_decl.
	One motivation for this is that is conventional in some
	environments to write things like:
	static const char rcsid[] = "... version string ...";
	intending to force the string to be in the executable.

	A language processor that would prefer to have unneeded
	static constants "optimized away" would just defer writing
	them out until here. E.g. C++ does this, because static
	constants are often defined in header files.

	??? A tempting alternative (for both C and C++) would be
	to force a constant to be written if and only if it is
	defined in a main file, as opposed to an include file. */

	if (TREE_CODE (decl) == VAR_DECL && TREE_STATIC (decl))
	{
	struct cgraph_varpool_node *node;
	bool needed = true;
	node = cgraph_varpool_node (decl);

	if (node->finalized)
	needed = false;
	else if (node->alias)
	needed = false;
	else if (!cgraph_global_info_ready
	&& (TREE_USED (decl)
	\|\| TREE_USED (DECL_ASSEMBLER_NAME (decl))))
	/* needed */;
	else if (node->needed)
	/* needed */;
	else if (DECL_COMDAT (decl))
	needed = false;
	else if (TREE_READONLY (decl) && !TREE_PUBLIC (decl)
	&& (optimize \|\| !flag_keep_static_consts
	\|\| DECL_ARTIFICIAL (decl)))
	needed = false;

	if (needed)
	{
	rest_of_decl_compilation (decl, 1, 1);
	return true;
	}
	}

	return false;
	}

	/* Do any final processing required for the declarations in VEC, of
	which there are LEN. We write out inline functions and variables
	that have been deferred until this point, but which are required.
	Returns nonzero if anything was put out. */

	bool
	wrapup_global_declarations (tree *vec, int len)
	{
	bool reconsider, output_something = false;
	int i;

	for (i = 0; i < len; i++)
	wrapup_global_declaration_1 (vec[i]);

	/* Now emit any global variables or functions that we have been
	putting off. We need to loop in case one of the things emitted
	here references another one which comes earlier in the list. */
	do
	{
	reconsider = false;
	for (i = 0; i < len; i++)
	reconsider \|= wrapup_global_declaration_2 (vec[i]);
	if (reconsider)
	output_something = true;
	}
	while (reconsider);

	return output_something;
	}

	/* A subroutine of check_global_declarations. Issue appropriate warnings
	for the global declaration DECL. */

	void
	check_global_declaration_1 (tree decl)
	{
	/* Warn about any function declared static but not defined. We don't
	warn about variables, because many programs have static variables
	that exist only to get some text into the object file. */
	if (TREE_CODE (decl) == FUNCTION_DECL
	&& DECL_INITIAL (decl) == 0
	&& DECL_EXTERNAL (decl)
	&& ! DECL_ARTIFICIAL (decl)
	&& ! TREE_NO_WARNING (decl)
	&& ! TREE_PUBLIC (decl)
	&& (warn_unused_function
	\|\| TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (decl))))
	{
	if (TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (decl)))
	pedwarn ("%q+F used but never defined", decl);
	else
	warning (0, "%q+F declared %<static%> but never defined", decl);
	/* This symbol is effectively an "extern" declaration now. */
	TREE_PUBLIC (decl) = 1;
	assemble_external (decl);
	}

	/* Warn about static fns or vars defined but not used. */
	if (((warn_unused_function && TREE_CODE (decl) == FUNCTION_DECL)
	/* We don't warn about "static const" variables because the
	"rcs_id" idiom uses that construction. */
	\|\| (warn_unused_variable
	&& TREE_CODE (decl) == VAR_DECL && ! TREE_READONLY (decl)))
	&& ! DECL_IN_SYSTEM_HEADER (decl)
	&& ! TREE_USED (decl)
	/* The TREE_USED bit for file-scope decls is kept in the identifier,
	to handle multiple external decls in different scopes. */
	&& ! (DECL_NAME (decl) && TREE_USED (DECL_NAME (decl)))
	&& ! DECL_EXTERNAL (decl)
	&& ! TREE_PUBLIC (decl)
	/* A volatile variable might be used in some non-obvious way. */
	&& ! TREE_THIS_VOLATILE (decl)
	/* Global register variables must be declared to reserve them. */
	&& ! (TREE_CODE (decl) == VAR_DECL && DECL_REGISTER (decl))
	/* Otherwise, ask the language. */
	&& lang_hooks.decls.warn_unused_global (decl))
	warning (0, "%q+D defined but not used", decl);
	}

	/* Issue appropriate warnings for the global declarations in VEC (of
	which there are LEN). */

	void
	check_global_declarations (tree *vec, int len)
	{
	int i;

	for (i = 0; i < len; i++)
	check_global_declaration_1 (vec[i]);
	}

	/* Emit debugging information for all global declarations in VEC. */

	void
	emit_debug_global_declarations (tree *vec, int len)
	{
	int i;

	/* Avoid confusing the debug information machinery when there are errors. */
	if (errorcount != 0 \|\| sorrycount != 0)
	return;

	timevar_push (TV_SYMOUT);
	for (i = 0; i < len; i++)
	debug_hooks->global_decl (vec[i]);
	timevar_pop (TV_SYMOUT);
	}

	/* Warn about a use of an identifier which was marked deprecated. */
	void
	warn_deprecated_use (tree node)
	{
	if (node == 0 \|\| !warn_deprecated_decl)
	return;

	if (DECL_P (node))
	{
	expanded_location xloc = expand_location (DECL_SOURCE_LOCATION (node));
	warning (OPT_Wdeprecated_declarations,
	"%qs is deprecated (declared at %s:%d)",
	IDENTIFIER_POINTER (DECL_NAME (node)),
	xloc.file, xloc.line);
	}
	else if (TYPE_P (node))
	{
	const char *what = NULL;
	tree decl = TYPE_STUB_DECL (node);

	if (TYPE_NAME (node))
	{
	if (TREE_CODE (TYPE_NAME (node)) == IDENTIFIER_NODE)
	what = IDENTIFIER_POINTER (TYPE_NAME (node));
	else if (TREE_CODE (TYPE_NAME (node)) == TYPE_DECL
	&& DECL_NAME (TYPE_NAME (node)))
	what = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (node)));
	}

	if (decl)
	{
	expanded_location xloc
	= expand_location (DECL_SOURCE_LOCATION (decl));
	if (what)
	warning (OPT_Wdeprecated_declarations,
	"%qs is deprecated (declared at %s:%d)", what,
	xloc.file, xloc.line);
	else
	warning (OPT_Wdeprecated_declarations,
	"type is deprecated (declared at %s:%d)",
	xloc.file, xloc.line);
	}
	else
	{
	if (what)
	warning (OPT_Wdeprecated_declarations, "%qs is deprecated", what);
	else
	warning (OPT_Wdeprecated_declarations, "type is deprecated");
	}
	}
	}

	+/* APPLE LOCAL begin "unavailable" attribute (radar 2809697) --ilr */
	+/* Warn about a use of an identifier which was marked deprecated. */
	+void
	+error_unavailable_use (tree node)
	+{
	+ if (node == 0)
	+ return;
	+
	+ if (DECL_P (node))
	+ error ("%qs is unavailable (declared at %s:%d)",
	+ IDENTIFIER_POINTER (DECL_NAME (node)),
	+ DECL_SOURCE_FILE (node), DECL_SOURCE_LINE (node));
	+ else if (TYPE_P (node))
	+ {
	+ const char *what = NULL;
	+ tree decl = TYPE_STUB_DECL (node);
	+
	+ if (TREE_CODE (TYPE_NAME (node)) == IDENTIFIER_NODE)
	+ what = IDENTIFIER_POINTER (TYPE_NAME (node));
	+ else if (TREE_CODE (TYPE_NAME (node)) == TYPE_DECL
	+ && DECL_NAME (TYPE_NAME (node)))
	+ what = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (node)));
	+
	+ if (what)
	+ {
	+ if (decl)
	+ error ("%qs is unavailable (declared at %s:%d)", what,
	+ DECL_SOURCE_FILE (decl), DECL_SOURCE_LINE (decl));
	+ else
	+ error ("%qs is unavailable", what);
	+ }
	+ else if (decl)
	+ error ("type is unavailable (declared at %s:%d)",
	+ DECL_SOURCE_FILE (decl), DECL_SOURCE_LINE (decl));
	+ else
	+ error ("type is unavailable");
	+ }
	+}
	+/* APPLE LOCAL end "unavailable" attribute (radar 2809697) --ilr */
	+
	/* Save the current INPUT_LOCATION on the top entry in the
	INPUT_FILE_STACK. Push a new entry for FILE and LINE, and set the
	INPUT_LOCATION accordingly. */

	void
	#ifdef USE_MAPPED_LOCATION
	push_srcloc (location_t fline)
	#else
	push_srcloc (const char *file, int line)
	#endif
	{
	struct file_stack *fs;

	gcc_assert (!input_file_stack_restored);
	if (input_file_stack_tick == (int) ((1U << INPUT_FILE_STACK_BITS) - 1))
	sorry ("GCC supports only %d input file changes", input_file_stack_tick);

	fs = XNEW (struct file_stack);
	fs->location = input_location;
	fs->next = input_file_stack;
	#ifdef USE_MAPPED_LOCATION
	input_location = fline;
	#else
	input_filename = file;
	input_line = line;
	#endif
	input_file_stack = fs;
	input_file_stack_tick++;
	VEC_safe_push (fs_p, heap, input_file_stack_history, input_file_stack);
	}

	/* Pop the top entry off the stack of presently open source files.
	Restore the INPUT_LOCATION from the new topmost entry on the
	stack. */

	void
	pop_srcloc (void)
	{
	struct file_stack *fs;

	gcc_assert (!input_file_stack_restored);
	if (input_file_stack_tick == (int) ((1U << INPUT_FILE_STACK_BITS) - 1))
	sorry ("GCC supports only %d input file changes", input_file_stack_tick);

	fs = input_file_stack;
	input_location = fs->location;
	input_file_stack = fs->next;
	input_file_stack_tick++;
	VEC_safe_push (fs_p, heap, input_file_stack_history, input_file_stack);
	}

	/* Restore the input file stack to its state as of TICK, for the sake
	of diagnostics after processing the whole input. Once this has
	been called, push_srcloc and pop_srcloc may no longer be
	called. */
	void
	restore_input_file_stack (int tick)
	{
	if (tick == 0)
	input_file_stack = NULL;
	else
	input_file_stack = VEC_index (fs_p, input_file_stack_history, tick - 1);
	input_file_stack_tick = tick;
	input_file_stack_restored = true;
	}

	/* Compile an entire translation unit. Write a file of assembly
	output and various debugging dumps. */

	static void
	compile_file (void)
	{
	/* Initialize yet another pass. */

	init_cgraph ();
	init_final (main_input_filename);
	coverage_init (aux_base_name);

	timevar_push (TV_PARSE);

	/* Call the parser, which parses the entire file (calling
	rest_of_compilation for each function). */
	lang_hooks.parse_file (set_yydebug);

	/* In case there were missing block closers,
	get us back to the global binding level. */
	lang_hooks.clear_binding_stack ();

	/* Compilation is now finished except for writing
	what's left of the symbol table output. */
	timevar_pop (TV_PARSE);

	if (flag_syntax_only \|\| errorcount \|\| sorrycount)
	return;

	lang_hooks.decls.final_write_globals ();
	cgraph_varpool_assemble_pending_decls ();
	finish_aliases_2 ();

	/* This must occur after the loop to output deferred functions.
	Else the coverage initializer would not be emitted if all the
	functions in this compilation unit were deferred. */
	coverage_finish ();

	/* Likewise for mudflap static object registrations. */
	if (flag_mudflap)
	mudflap_finish_file ();

	output_shared_constant_pool ();
	output_object_blocks ();

	/* Write out any pending weak symbol declarations. */

	weak_finish ();

	/* Do dbx symbols. */
	timevar_push (TV_SYMOUT);

	#if defined DWARF2_DEBUGGING_INFO \|\| defined DWARF2_UNWIND_INFO
	if (dwarf2out_do_frame ())
	dwarf2out_frame_finish ();
	#endif

	(*debug_hooks->finish) (main_input_filename);
	timevar_pop (TV_SYMOUT);

	/* Output some stuff at end of file if nec. */

	dw2_output_indirect_constants ();

	/* Flush any pending external directives. */
	process_pending_assemble_externals ();

	/* Attach a special .ident directive to the end of the file to identify
	the version of GCC which compiled this code. The format of the .ident
	string is patterned after the ones produced by native SVR4 compilers. */
	#ifdef IDENT_ASM_OP
	if (!flag_no_ident)
	fprintf (asm_out_file, "%s\"GCC: (GNU) %s\"\n",
	IDENT_ASM_OP, version_string);
	#endif

	/* This must be at the end. Some target ports emit end of file directives
	into the assembly file here, and hence we can not output anything to the
	assembly file after this point. */
	targetm.asm_out.file_end ();
	}

	/* Parse a -d... command line switch. */

	void
	decode_d_option (const char *arg)
	{
	int c;

	while (*arg)
	switch (c = *arg++)
	{
	case 'A':
	flag_debug_asm = 1;
	break;
	case 'p':
	flag_print_asm_name = 1;
	break;
	case 'P':
	flag_dump_rtl_in_asm = 1;
	flag_print_asm_name = 1;
	break;
	case 'v':
	graph_dump_format = vcg;
	break;
	case 'x':
	rtl_dump_and_exit = 1;
	break;
	case 'y':
	set_yydebug = 1;
	break;
	case 'D': /* These are handled by the preprocessor. */
	case 'I':
	break;
	case 'H':
	setup_core_dumping();
	break;

	case 'a':
	default:
	if (!enable_rtl_dump_file (c))
	warning (0, "unrecognized gcc debugging option: %c", c);
	break;
	}
	}

	/* Indexed by enum debug_info_type. */
	const char *const debug_type_names[] =
	{
	"none", "stabs", "coff", "dwarf-2", "xcoff", "vms"
	};

	/* Print version information to FILE.
	Each line begins with INDENT (for the case where FILE is the
	assembler output file). */

	void
	print_version (FILE file, const char indent)
	{
	static const char fmt1[] =
	#ifdef __GNUC__
	N_("%s%s%s version %s (%s)\n%s\tcompiled by GNU C version %s.\n")
	#else
	N_("%s%s%s version %s (%s) compiled by CC.\n")
	#endif
	;
	static const char fmt2[] =
	N_("%s%sGGC heuristics: --param ggc-min-expand=%d --param ggc-min-heapsize=%d\n");
	#ifndef __VERSION__
	#define __VERSION__ "[?]"
	#endif
	fprintf (file,
	file == stderr ? _(fmt1) : fmt1,
	indent, *indent != 0 ? " " : "",
	lang_hooks.name, version_string, TARGET_NAME,
	indent, __VERSION__);
	fprintf (file,
	file == stderr ? _(fmt2) : fmt2,
	indent, *indent != 0 ? " " : "",
	PARAM_VALUE (GGC_MIN_EXPAND), PARAM_VALUE (GGC_MIN_HEAPSIZE));
	}

	/* Print an option value and return the adjusted position in the line.
	??? We don't handle error returns from fprintf (disk full); presumably
	other code will catch a disk full though. */

	static int
	print_single_switch (FILE *file, int pos, int max,
	const char indent, const char sep, const char *term,
	const char type, const char name)
	{
	/* The ultrix fprintf returns 0 on success, so compute the result we want
	here since we need it for the following test. */
	int len = strlen (sep) + strlen (type) + strlen (name);

	if (pos != 0
	&& pos + len > max)
	{
	fprintf (file, "%s", term);
	pos = 0;
	}
	if (pos == 0)
	{
	fprintf (file, "%s", indent);
	pos = strlen (indent);
	}
	fprintf (file, "%s%s%s", sep, type, name);
	pos += len;
	return pos;
	}

	/* Print active target switches to FILE.
	POS is the current cursor position and MAX is the size of a "line".
	Each line begins with INDENT and ends with TERM.
	Each switch is separated from the next by SEP. */

	static void
	print_switch_values (FILE *file, int pos, int max,
	const char indent, const char sep, const char *term)
	{
	size_t j;
	const char **p;

	/* Fill in the -frandom-seed option, if the user didn't pass it, so
	that it can be printed below. This helps reproducibility. */
	randomize ();

	/* Print the options as passed. */
	pos = print_single_switch (file, pos, max, indent, *indent ? " " : "", term,
	_("options passed: "), "");

	for (p = &save_argv[1]; *p != NULL; p++)
	if (**p == '-')
	{
	/* Ignore these. */
	if (strcmp (*p, "-o") == 0)
	{
	if (p[1] != NULL)
	p++;
	continue;
	}
	if (strcmp (*p, "-quiet") == 0)
	continue;
	if (strcmp (*p, "-version") == 0)
	continue;
	if ((*p)[1] == 'd')
	continue;

	pos = print_single_switch (file, pos, max, indent, sep, term, *p, "");
	}
	if (pos > 0)
	fprintf (file, "%s", term);

	/* Print the -f and -m options that have been enabled.
	We don't handle language specific options but printing argv
	should suffice. */

	pos = print_single_switch (file, 0, max, indent, *indent ? " " : "", term,
	_("options enabled: "), "");

	for (j = 0; j < cl_options_count; j++)
	if ((cl_options[j].flags & CL_REPORT)
	&& option_enabled (j) > 0)
	pos = print_single_switch (file, pos, max, indent, sep, term,
	"", cl_options[j].opt_text);

	fprintf (file, "%s", term);
	}

	/* Open assembly code output file. Do this even if -fsyntax-only is
	on, because then the driver will have provided the name of a
	temporary file or bit bucket for us. NAME is the file specified on
	the command line, possibly NULL. */
	static void
	init_asm_output (const char *name)
	{
	if (name == NULL && asm_file_name == 0)
	asm_out_file = stdout;
	else
	{
	if (asm_file_name == 0)
	{
	int len = strlen (dump_base_name);
	char *dumpname = XNEWVEC (char, len + 6);
	memcpy (dumpname, dump_base_name, len + 1);
	strip_off_ending (dumpname, len);
	strcat (dumpname, ".s");
	asm_file_name = dumpname;
	}
	if (!strcmp (asm_file_name, "-"))
	asm_out_file = stdout;
	else
	asm_out_file = fopen (asm_file_name, "w+b");
	if (asm_out_file == 0)
	fatal_error ("can%'t open %s for writing: %m", asm_file_name);
	}

	if (!flag_syntax_only)
	{
	targetm.asm_out.file_start ();

	#ifdef ASM_COMMENT_START
	if (flag_verbose_asm)
	{
	/* Print the list of options in effect. */
	print_version (asm_out_file, ASM_COMMENT_START);
	print_switch_values (asm_out_file, 0, MAX_LINE,
	ASM_COMMENT_START, " ", "\n");
	/* Add a blank line here so it appears in assembler output but not
	screen output. */
	fprintf (asm_out_file, "\n");
	}
	#endif
	}
	}

	/* Return true if the state of option OPTION should be stored in PCH files
	and checked by default_pch_valid_p. Store the option's current state
	in STATE if so. */

	static inline bool
	option_affects_pch_p (int option, struct cl_option_state *state)
	{
	if ((cl_options[option].flags & CL_TARGET) == 0)
	return false;
	if (cl_options[option].flag_var == &target_flags)
	if (targetm.check_pch_target_flags)
	return false;
	return get_option_state (option, state);
	}

	/* Default version of get_pch_validity.
	By default, every flag difference is fatal; that will be mostly right for
	most targets, but completely right for very few. */

	void *
	default_get_pch_validity (size_t *len)
	{
	struct cl_option_state state;
	size_t i;
	char result, r;

	*len = 2;
	if (targetm.check_pch_target_flags)
	*len += sizeof (target_flags);
	for (i = 0; i < cl_options_count; i++)
	if (option_affects_pch_p (i, &state))
	*len += state.size;

	result = r = XNEWVEC (char, *len);
	r[0] = flag_pic;
	r[1] = flag_pie;
	r += 2;
	if (targetm.check_pch_target_flags)
	{
	memcpy (r, &target_flags, sizeof (target_flags));
	r += sizeof (target_flags);
	}

	for (i = 0; i < cl_options_count; i++)
	if (option_affects_pch_p (i, &state))
	{
	memcpy (r, state.data, state.size);
	r += state.size;
	}

	return result;
	}

	/* Return a message which says that a PCH file was created with a different
	setting of OPTION. */

	static const char *
	pch_option_mismatch (const char *option)
	{
	char *r;

	asprintf (&r, _("created and used with differing settings of '%s'"), option);
	if (r == NULL)
	return _("out of memory");
	return r;
	}

	/* Default version of pch_valid_p. */

	const char *
	default_pch_valid_p (const void *data_p, size_t len)
	{
	struct cl_option_state state;
	const char data = (const char )data_p;
	size_t i;

	/* -fpic and -fpie also usually make a PCH invalid. */
	if (data[0] != flag_pic)
	return _("created and used with different settings of -fpic");
	if (data[1] != flag_pie)
	return _("created and used with different settings of -fpie");
	data += 2;

	/* Check target_flags. */
	if (targetm.check_pch_target_flags)
	{
	int tf;
	const char *r;

	memcpy (&tf, data, sizeof (target_flags));
	data += sizeof (target_flags);
	len -= sizeof (target_flags);
	r = targetm.check_pch_target_flags (tf);
	if (r != NULL)
	return r;
	}

	for (i = 0; i < cl_options_count; i++)
	if (option_affects_pch_p (i, &state))
	{
	if (memcmp (data, state.data, state.size) != 0)
	return pch_option_mismatch (cl_options[i].opt_text);
	data += state.size;
	len -= state.size;
	}

	return NULL;
	}

	/* Default tree printer. Handles declarations only. */
	static bool
	default_tree_printer (pretty_printer * pp, text_info text, const char spec,
	int precision, bool wide, bool set_locus, bool hash)
	{
	tree t;

	/* FUTURE: %+x should set the locus. */
	if (precision != 0 \|\| wide \|\| hash)
	return false;

	switch (*spec)
	{
	case 'D':
	t = va_arg (*text->args_ptr, tree);
	if (DECL_DEBUG_EXPR_IS_FROM (t) && DECL_DEBUG_EXPR (t))
	t = DECL_DEBUG_EXPR (t);
	break;

	case 'F':
	case 'T':
	t = va_arg (*text->args_ptr, tree);
	break;

	default:
	return false;
	}

	if (set_locus && text->locus)
	*text->locus = DECL_SOURCE_LOCATION (t);

	if (DECL_P (t))
	{
	const char *n = DECL_NAME (t)
	? lang_hooks.decl_printable_name (t, 2)
	: "<anonymous>";
	pp_string (pp, n);
	}
	else
	dump_generic_node (pp, t, 0, 0, 0);

	return true;
	}

	/* Initialization of the front end environment, before command line
	options are parsed. Signal handlers, internationalization etc.
	ARGV0 is main's argv[0]. */
	static void
	general_init (const char *argv0)
	{
	const char *p;

	p = argv0 + strlen (argv0);
	while (p != argv0 && !IS_DIR_SEPARATOR (p[-1]))
	--p;
	progname = p;

	xmalloc_set_program_name (progname);

	hex_init ();

	/* Unlock the stdio streams. */
	unlock_std_streams ();

	gcc_init_libintl ();

	/* Initialize the diagnostics reporting machinery, so option parsing
	can give warnings and errors. */
	diagnostic_initialize (global_dc);
	/* Set a default printer. Language specific initializations will
	override it later. */
	pp_format_decoder (global_dc->printer) = &default_tree_printer;

	/* Trap fatal signals, e.g. SIGSEGV, and convert them to ICE messages. */
	#ifdef SIGSEGV
	signal (SIGSEGV, crash_signal);
	#endif
	#ifdef SIGILL
	signal (SIGILL, crash_signal);
	#endif
	#ifdef SIGBUS
	signal (SIGBUS, crash_signal);
	#endif
	#ifdef SIGABRT
	signal (SIGABRT, crash_signal);
	#endif
	#if defined SIGIOT && (!defined SIGABRT \|\| SIGABRT != SIGIOT)
	signal (SIGIOT, crash_signal);
	#endif
	#ifdef SIGFPE
	signal (SIGFPE, crash_signal);
	#endif

	/* Other host-specific signal setup. */
	(*host_hooks.extra_signals)();

	/* Initialize the garbage-collector, string pools and tree type hash
	table. */
	init_ggc ();
	init_stringpool ();
	linemap_init (&line_table);
	init_ttree ();

	/* Initialize register usage now so switches may override. */
	init_reg_sets ();

	/* Register the language-independent parameters. */
	add_params (lang_independent_params, LAST_PARAM);

	/* This must be done after add_params but before argument processing. */
	init_ggc_heuristics();
	init_optimization_passes ();
	}

	/* Return true if the current target supports -fsection-anchors. */

	static bool
	target_supports_section_anchors_p (void)
	{
	if (targetm.min_anchor_offset == 0 && targetm.max_anchor_offset == 0)
	return false;

	if (targetm.asm_out.output_anchor == NULL)
	return false;

	return true;
	}

	/* Process the options that have been parsed. */
	static void
	process_options (void)
	{
	/* Just in case lang_hooks.post_options ends up calling a debug_hook.
	This can happen with incorrect pre-processed input. */
	debug_hooks = &do_nothing_debug_hooks;

	/* Allow the front end to perform consistency checks and do further
	initialization based on the command line options. This hook also
	sets the original filename if appropriate (e.g. foo.i -> foo.c)
	so we can correctly initialize debug output. */
	no_backend = lang_hooks.post_options (&main_input_filename);
	#ifndef USE_MAPPED_LOCATION
	input_filename = main_input_filename;
	#endif

	#ifdef OVERRIDE_OPTIONS
	/* Some machines may reject certain combinations of options. */
	OVERRIDE_OPTIONS;
	#endif

	if (flag_section_anchors && !target_supports_section_anchors_p ())
	{
	warning (OPT_fsection_anchors,
	"this target does not support %qs", "-fsection-anchors");
	flag_section_anchors = 0;
	}

	if (flag_short_enums == 2)
	flag_short_enums = targetm.default_short_enums ();

	/* Set aux_base_name if not already set. */
	if (aux_base_name)
	;
	else if (main_input_filename)
	{
	char *name = xstrdup (lbasename (main_input_filename));

	strip_off_ending (name, strlen (name));
	aux_base_name = name;
	}
	else
	aux_base_name = "gccaux";

	/* Set up the align_*_log variables, defaulting them to 1 if they
	were still unset. */
	if (align_loops <= 0) align_loops = 1;
	if (align_loops_max_skip > align_loops \|\| !align_loops)
	align_loops_max_skip = align_loops - 1;
	align_loops_log = floor_log2 (align_loops * 2 - 1);
	if (align_jumps <= 0) align_jumps = 1;
	if (align_jumps_max_skip > align_jumps \|\| !align_jumps)
	align_jumps_max_skip = align_jumps - 1;
	align_jumps_log = floor_log2 (align_jumps * 2 - 1);
	if (align_labels <= 0) align_labels = 1;
	align_labels_log = floor_log2 (align_labels * 2 - 1);
	if (align_labels_max_skip > align_labels \|\| !align_labels)
	align_labels_max_skip = align_labels - 1;
	if (align_functions <= 0) align_functions = 1;
	align_functions_log = floor_log2 (align_functions * 2 - 1);

	/* Unrolling all loops implies that standard loop unrolling must also
	be done. */
	if (flag_unroll_all_loops)
	flag_unroll_loops = 1;

	/* The loop unrolling code assumes that cse will be run after loop.
	web and rename-registers also help when run after loop unrolling. */

	if (flag_rerun_cse_after_loop == AUTODETECT_VALUE)
	flag_rerun_cse_after_loop = flag_unroll_loops \|\| flag_peel_loops;
	if (flag_web == AUTODETECT_VALUE)
	flag_web = flag_unroll_loops \|\| flag_peel_loops;
	if (flag_rename_registers == AUTODETECT_VALUE)
	flag_rename_registers = flag_unroll_loops \|\| flag_peel_loops;

	if (flag_non_call_exceptions)
	flag_asynchronous_unwind_tables = 1;
	if (flag_asynchronous_unwind_tables)
	flag_unwind_tables = 1;

	/* Disable unit-at-a-time mode for frontends not supporting callgraph
	interface. */
	if (flag_unit_at_a_time && ! lang_hooks.callgraph.expand_function)
	flag_unit_at_a_time = 0;

	if (!flag_unit_at_a_time)
	flag_section_anchors = 0;

	if (flag_value_profile_transformations)
	flag_profile_values = 1;

	/* Warn about options that are not supported on this machine. */
	#ifndef INSN_SCHEDULING
	if (flag_schedule_insns \|\| flag_schedule_insns_after_reload)
	warning (0, "instruction scheduling not supported on this target machine");
	#endif
	#ifndef DELAY_SLOTS
	if (flag_delayed_branch)
	warning (0, "this target machine does not have delayed branches");
	#endif

	user_label_prefix = USER_LABEL_PREFIX;
	if (flag_leading_underscore != -1)
	{
	/* If the default prefix is more complicated than "" or "_",
	issue a warning and ignore this option. */
	if (user_label_prefix[0] == 0 \|\|
	(user_label_prefix[0] == '_' && user_label_prefix[1] == 0))
	{
	user_label_prefix = flag_leading_underscore ? "_" : "";
	}
	else
	warning (0, "-f%sleading-underscore not supported on this target machine",
	flag_leading_underscore ? "" : "no-");
	}

	/* If we are in verbose mode, write out the version and maybe all the
	option flags in use. */
	if (version_flag)
	{
	print_version (stderr, "");
	if (! quiet_flag)
	print_switch_values (stderr, 0, MAX_LINE, "", " ", "\n");
	}

	if (flag_syntax_only)
	{
	write_symbols = NO_DEBUG;
	profile_flag = 0;
	}

	/* A lot of code assumes write_symbols == NO_DEBUG if the debugging
	level is 0. */
	if (debug_info_level == DINFO_LEVEL_NONE)
	write_symbols = NO_DEBUG;

	/* Now we know write_symbols, set up the debug hooks based on it.
	By default we do nothing for debug output. */
	if (PREFERRED_DEBUGGING_TYPE == NO_DEBUG)
	default_debug_hooks = &do_nothing_debug_hooks;
	#if defined(DBX_DEBUGGING_INFO)
	else if (PREFERRED_DEBUGGING_TYPE == DBX_DEBUG)
	default_debug_hooks = &dbx_debug_hooks;
	#endif
	#if defined(XCOFF_DEBUGGING_INFO)
	else if (PREFERRED_DEBUGGING_TYPE == XCOFF_DEBUG)
	default_debug_hooks = &xcoff_debug_hooks;
	#endif
	#ifdef SDB_DEBUGGING_INFO
	else if (PREFERRED_DEBUGGING_TYPE == SDB_DEBUG)
	default_debug_hooks = &sdb_debug_hooks;
	#endif
	#ifdef DWARF2_DEBUGGING_INFO
	else if (PREFERRED_DEBUGGING_TYPE == DWARF2_DEBUG)
	default_debug_hooks = &dwarf2_debug_hooks;
	#endif
	#ifdef VMS_DEBUGGING_INFO
	else if (PREFERRED_DEBUGGING_TYPE == VMS_DEBUG
	\|\| PREFERRED_DEBUGGING_TYPE == VMS_AND_DWARF2_DEBUG)
	default_debug_hooks = &vmsdbg_debug_hooks;
	#endif

	if (write_symbols == NO_DEBUG)
	;
	#if defined(DBX_DEBUGGING_INFO)
	else if (write_symbols == DBX_DEBUG)
	debug_hooks = &dbx_debug_hooks;
	#endif
	#if defined(XCOFF_DEBUGGING_INFO)
	else if (write_symbols == XCOFF_DEBUG)
	debug_hooks = &xcoff_debug_hooks;
	#endif
	#ifdef SDB_DEBUGGING_INFO
	else if (write_symbols == SDB_DEBUG)
	debug_hooks = &sdb_debug_hooks;
	#endif
	#ifdef DWARF2_DEBUGGING_INFO
	else if (write_symbols == DWARF2_DEBUG)
	debug_hooks = &dwarf2_debug_hooks;
	#endif
	#ifdef VMS_DEBUGGING_INFO
	else if (write_symbols == VMS_DEBUG \|\| write_symbols == VMS_AND_DWARF2_DEBUG)
	debug_hooks = &vmsdbg_debug_hooks;
	#endif
	else
	error ("target system does not support the \"%s\" debug format",
	debug_type_names[write_symbols]);

	/* Now we know which debug output will be used so we can set
	flag_var_tracking, flag_rename_registers if the user has
	not specified them. */
	if (debug_info_level < DINFO_LEVEL_NORMAL
	\|\| debug_hooks->var_location == do_nothing_debug_hooks.var_location)
	{
	if (flag_var_tracking == 1)
	{
	if (debug_info_level < DINFO_LEVEL_NORMAL)
	warning (0, "variable tracking requested, but useless unless "
	"producing debug info");
	else
	warning (0, "variable tracking requested, but not supported "
	"by this debug format");
	}
	flag_var_tracking = 0;
	}

	if (flag_rename_registers == AUTODETECT_VALUE)
	flag_rename_registers = default_debug_hooks->var_location
	!= do_nothing_debug_hooks.var_location;

	if (flag_var_tracking == AUTODETECT_VALUE)
	flag_var_tracking = optimize >= 1;

	/* If auxiliary info generation is desired, open the output file.
	This goes in the same directory as the source file--unlike
	all the other output files. */
	if (flag_gen_aux_info)
	{
	aux_info_file = fopen (aux_info_file_name, "w");
	if (aux_info_file == 0)
	fatal_error ("can%'t open %s: %m", aux_info_file_name);
	}

	if (! targetm.have_named_sections)
	{
	if (flag_function_sections)
	{
	warning (0, "-ffunction-sections not supported for this target");
	flag_function_sections = 0;
	}
	if (flag_data_sections)
	{
	warning (0, "-fdata-sections not supported for this target");
	flag_data_sections = 0;
	}
	}

	if (flag_function_sections && profile_flag)
	{
	warning (0, "-ffunction-sections disabled; it makes profiling impossible");
	flag_function_sections = 0;
	}

	#ifndef HAVE_prefetch
	if (flag_prefetch_loop_arrays)
	{
	warning (0, "-fprefetch-loop-arrays not supported for this target");
	flag_prefetch_loop_arrays = 0;
	}
	#else
	if (flag_prefetch_loop_arrays && !HAVE_prefetch)
	{
	warning (0, "-fprefetch-loop-arrays not supported for this target (try -march switches)");
	flag_prefetch_loop_arrays = 0;
	}
	#endif

	/* This combination of options isn't handled for i386 targets and doesn't
	make much sense anyway, so don't allow it. */
	if (flag_prefetch_loop_arrays && optimize_size)
	{
	warning (0, "-fprefetch-loop-arrays is not supported with -Os");
	flag_prefetch_loop_arrays = 0;
	}

	#ifndef OBJECT_FORMAT_ELF
	#ifndef OBJECT_FORMAT_MACHO
	if (flag_function_sections && write_symbols != NO_DEBUG)
	warning (0, "-ffunction-sections may affect debugging on some targets");
	#endif
	#endif

	/* The presence of IEEE signaling NaNs, implies all math can trap. */
	if (flag_signaling_nans)
	flag_trapping_math = 1;

	/* With -fcx-limited-range, we do cheap and quick complex arithmetic. */
	if (flag_cx_limited_range)
	flag_complex_method = 0;

	/* Targets must be able to place spill slots at lower addresses. If the
	target already uses a soft frame pointer, the transition is trivial. */
	if (!FRAME_GROWS_DOWNWARD && flag_stack_protect)
	{
	warning (0, "-fstack-protector not supported for this target");
	flag_stack_protect = 0;
	}
	if (!flag_stack_protect)
	warn_stack_protect = 0;

	/* ??? Unwind info is not correct around the CFG unless either a frame
	pointer is present or A_O_A is set. Fixing this requires rewriting
	unwind info generation to be aware of the CFG and propagating states
	around edges. */
	if (flag_unwind_tables && !ACCUMULATE_OUTGOING_ARGS
	&& flag_omit_frame_pointer)
	{
	warning (0, "unwind tables currently requires a frame pointer "
	"for correctness");
	flag_omit_frame_pointer = 0;
	}
	}

	/* Initialize the compiler back end. */
	static void
	backend_init (void)
	{
	init_emit_once (debug_info_level == DINFO_LEVEL_NORMAL
	\|\| debug_info_level == DINFO_LEVEL_VERBOSE
	#ifdef VMS_DEBUGGING_INFO
	/* Enable line number info for traceback. */
	\|\| debug_info_level > DINFO_LEVEL_NONE
	#endif
	\|\| flag_test_coverage);

	init_rtlanal ();
	init_regs ();
	init_fake_stack_mems ();
	init_alias_once ();
	init_reload ();
	init_varasm_once ();

	/* The following initialization functions need to generate rtl, so
	provide a dummy function context for them. */
	init_dummy_function_start ();
	init_expmed ();
	if (flag_caller_saves)
	init_caller_save ();
	expand_dummy_function_end ();
	}

	/* Language-dependent initialization. Returns nonzero on success. */
	static int
	lang_dependent_init (const char *name)
	{
	location_t save_loc = input_location;
	if (dump_base_name == 0)
	dump_base_name = name && name[0] ? name : "gccdump";

	/* Other front-end initialization. */
	#ifdef USE_MAPPED_LOCATION
	input_location = BUILTINS_LOCATION;
	#else
	input_filename = "<built-in>";
	input_line = 0;
	#endif
	if (lang_hooks.init () == 0)
	return 0;
	input_location = save_loc;

	init_asm_output (name);

	/* These create various _DECL nodes, so need to be called after the
	front end is initialized. */
	init_eh ();
	init_optabs ();

	/* The following initialization functions need to generate rtl, so
	provide a dummy function context for them. */
	init_dummy_function_start ();
	init_expr_once ();
	expand_dummy_function_end ();

	/* If dbx symbol table desired, initialize writing it and output the
	predefined types. */
	timevar_push (TV_SYMOUT);

	#if defined DWARF2_DEBUGGING_INFO \|\| defined DWARF2_UNWIND_INFO
	if (dwarf2out_do_frame ())
	dwarf2out_frame_init ();
	#endif

	/* Now we have the correct original filename, we can initialize
	debug output. */
	(*debug_hooks->init) (name);

	timevar_pop (TV_SYMOUT);

	return 1;
	}

	/* Clean up: close opened files, etc. */

	static void
	finalize (void)
	{
	/* Close the dump files. */
	if (flag_gen_aux_info)
	{
	fclose (aux_info_file);
	if (errorcount)
	unlink (aux_info_file_name);
	}

	/* Close non-debugging input and output files. Take special care to note
	whether fclose returns an error, since the pages might still be on the
	buffer chain while the file is open. */

	if (asm_out_file)
	{
	if (ferror (asm_out_file) != 0)
	fatal_error ("error writing to %s: %m", asm_file_name);
	if (fclose (asm_out_file) != 0)
	fatal_error ("error closing %s: %m", asm_file_name);
	}

	finish_optimization_passes ();

	if (mem_report)
	{
	ggc_print_statistics ();
	stringpool_statistics ();
	dump_tree_statistics ();
	dump_rtx_statistics ();
	dump_varray_statistics ();
	dump_alloc_pool_statistics ();
	dump_ggc_loc_statistics ();
	}

	/* Free up memory for the benefit of leak detectors. */
	free_reg_info ();

	/* Language-specific end of compilation actions. */
	lang_hooks.finish ();
	}

	/* Initialize the compiler, and compile the input file. */
	static void
	do_compile (void)
	{
	/* Initialize timing first. The C front ends read the main file in
	the post_options hook, and C++ does file timings. */
	if (time_report \|\| !quiet_flag \|\| flag_detailed_statistics)
	timevar_init ();
	timevar_start (TV_TOTAL);

	process_options ();

	/* Don't do any more if an error has already occurred. */
	if (!errorcount)
	{
	/* This must be run always, because it is needed to compute the FP
	predefined macros, such as __LDBL_MAX__, for targets using non
	default FP formats. */
	init_adjust_machine_modes ();

	/* Set up the back-end if requested. */
	if (!no_backend)
	backend_init ();

	/* Language-dependent initialization. Returns true on success. */
	if (lang_dependent_init (main_input_filename))
	compile_file ();

	finalize ();
	}

	/* Stop timing and print the times. */
	timevar_stop (TV_TOTAL);
	timevar_print (stderr);
	}

	/* Entry point of cc1, cc1plus, jc1, f771, etc.
	Exit code is FATAL_EXIT_CODE if can't open files or if there were
	any errors, or SUCCESS_EXIT_CODE if compilation succeeded.

	It is not safe to call this function more than once. */

	int
	toplev_main (unsigned int argc, const char **argv)
	{
	save_argv = argv;

	/* Initialization of GCC's environment, and diagnostics. */
	general_init (argv[0]);

	/* Parse the options and do minimal processing; basically just
	enough to default flags appropriately. */
	decode_options (argc, argv);

	randomize ();

	/* Exit early if we can (e.g. -help). */
	if (!exit_after_options)
	do_compile ();

	if (errorcount \|\| sorrycount)
	return (FATAL_EXIT_CODE);

	return (SUCCESS_EXIT_CODE);
	}
	diff --git a/contrib/gcc/toplev.h b/contrib/gcc/toplev.h
	index c935f7ee7970..3b0744193a49 100644
	--- a/contrib/gcc/toplev.h
	+++ b/contrib/gcc/toplev.h
	@@ -1,192 +1,194 @@
	/* toplev.h - Various declarations for functions found in toplev.c
	Copyright (C) 1998, 1999, 2000, 2001, 2003, 2004, 2005
	Free Software Foundation, Inc.

	This file is part of GCC.

	GCC is free software; you can redistribute it and/or modify it under
	the terms of the GNU General Public License as published by the Free
	Software Foundation; either version 2, or (at your option) any later
	version.

	GCC is distributed in the hope that it will be useful, but WITHOUT ANY
	WARRANTY; without even the implied warranty of MERCHANTABILITY or
	FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	for more details.

	You should have received a copy of the GNU General Public License
	along with GCC; see the file COPYING. If not, write to the Free
	Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
	02110-1301, USA. */

	#ifndef GCC_TOPLEV_H
	#define GCC_TOPLEV_H

	/* If non-NULL, return one past-the-end of the matching SUBPART of
	the WHOLE string. */
	#define skip_leading_substring(whole, part) \
	(strncmp (whole, part, strlen (part)) ? NULL : whole + strlen (part))

	extern int toplev_main (unsigned int, const char **);
	extern int read_integral_parameter (const char , const char , const int);
	extern void strip_off_ending (char *, int);
	extern const char trim_filename (const char );
	extern void _fatal_insn_not_found (rtx, const char , int, const char )
	ATTRIBUTE_NORETURN;
	extern void _fatal_insn (const char , rtx, const char , int, const char *)
	ATTRIBUTE_NORETURN;

	#define fatal_insn(msgid, insn) \
	_fatal_insn (msgid, insn, __FILE__, __LINE__, __FUNCTION__)
	#define fatal_insn_not_found(insn) \
	_fatal_insn_not_found (insn, __FILE__, __LINE__, __FUNCTION__)

	/* If we haven't already defined a frontend specific diagnostics
	style, use the generic one. */
	#ifndef GCC_DIAG_STYLE
	#define GCC_DIAG_STYLE __gcc_tdiag__
	#endif
	/* None of these functions are suitable for ATTRIBUTE_PRINTF, because
	each language front end can extend them with its own set of format
	specifiers. We must use custom format checks. */
	#if GCC_VERSION >= 4001
	#define ATTRIBUTE_GCC_DIAG(m, n) __attribute__ ((__format__ (GCC_DIAG_STYLE, m, n))) ATTRIBUTE_NONNULL(m)
	#else
	#define ATTRIBUTE_GCC_DIAG(m, n) ATTRIBUTE_NONNULL(m)
	#endif
	extern void internal_error (const char *, ...) ATTRIBUTE_GCC_DIAG(1,2)
	ATTRIBUTE_NORETURN;
	extern void warning0 (const char *, ...) ATTRIBUTE_GCC_DIAG(1,2);
	/* Pass one of the OPT_W* from options.h as the first parameter. */
	extern void warning (int, const char *, ...) ATTRIBUTE_GCC_DIAG(2,3);
	extern void error (const char *, ...) ATTRIBUTE_GCC_DIAG(1,2);
	extern void fatal_error (const char *, ...) ATTRIBUTE_GCC_DIAG(1,2)
	ATTRIBUTE_NORETURN;
	extern void pedwarn (const char *, ...) ATTRIBUTE_GCC_DIAG(1,2);
	extern void sorry (const char *, ...) ATTRIBUTE_GCC_DIAG(1,2);
	extern void inform (const char *, ...) ATTRIBUTE_GCC_DIAG(1,2);
	extern void verbatim (const char *, ...) ATTRIBUTE_GCC_DIAG(1,2);

	extern void rest_of_decl_compilation (tree, int, int);
	extern void rest_of_type_compilation (tree, int);
	extern void tree_rest_of_compilation (tree);
	extern void init_optimization_passes (void);
	extern void finish_optimization_passes (void);
	extern bool enable_rtl_dump_file (int);

	extern void announce_function (tree);

	extern void error_for_asm (rtx, const char *, ...) ATTRIBUTE_GCC_DIAG(2,3);
	extern void warning_for_asm (rtx, const char *, ...) ATTRIBUTE_GCC_DIAG(2,3);
	extern void warn_deprecated_use (tree);
	+/* APPLE LOCAL "unavailable" attribute (radar 2809697) */
	+extern void error_unavailable_use (tree);

	#ifdef BUFSIZ
	extern void output_quoted_string (FILE , const char );
	extern void output_file_directive (FILE , const char );
	#endif

	#ifdef BUFSIZ
	/* N.B. Unlike all the others, fnotice is just gettext+fprintf, and
	therefore it can have ATTRIBUTE_PRINTF. */
	extern void fnotice (FILE , const char , ...)
	ATTRIBUTE_PRINTF_2;
	#endif

	extern void wrapup_global_declaration_1 (tree);
	extern bool wrapup_global_declaration_2 (tree);
	extern bool wrapup_global_declarations (tree *, int);
	extern void check_global_declaration_1 (tree);
	extern void check_global_declarations (tree *, int);
	extern void emit_debug_global_declarations (tree *, int);
	extern void write_global_declarations (void);

	/* A unique local time stamp, might be zero if none is available. */
	extern unsigned local_tick;

	extern const char *progname;
	extern const char *dump_base_name;
	extern const char *aux_base_name;
	extern const char *aux_info_file_name;
	extern const char *asm_file_name;
	extern bool exit_after_options;

	extern int target_flags_explicit;

	/* True if the user has tagged the function with the 'section'
	attribute. */

	extern bool user_defined_section_attribute;

	/* See toplev.c. */
	extern int flag_crossjumping;
	extern int flag_if_conversion;
	extern int flag_if_conversion2;
	extern int flag_keep_static_consts;
	extern int flag_peel_loops;
	extern int flag_rerun_cse_after_loop;
	extern int flag_thread_jumps;
	extern int flag_tracer;
	extern int flag_unroll_loops;
	extern int flag_unroll_all_loops;
	extern int flag_unswitch_loops;
	extern int flag_cprop_registers;
	extern int time_report;

	/* Things to do with target switches. */
	extern void print_version (FILE , const char );
	extern void * default_get_pch_validity (size_t *);
	extern const char * default_pch_valid_p (const void *, size_t);

	/* The hashtable, so that the C front ends can pass it to cpplib. */
	extern struct ht *ident_hash;

	/* This function can be used by targets to set the flags originally
	implied by -ffast-math and -fno-fast-math. */

	extern void set_fast_math_flags (int);

	/* Handle -d switch. */
	extern void decode_d_option (const char *);

	/* Return true iff flags are set as if -ffast-math. */
	extern bool fast_math_flags_set_p (void);

	/* Return log2, or -1 if not exact. */
	extern int exact_log2 (unsigned HOST_WIDE_INT);

	/* Return floor of log2, with -1 for zero. */
	extern int floor_log2 (unsigned HOST_WIDE_INT);

	/* Inline versions of the above for speed. */
	#if GCC_VERSION >= 3004
	# if HOST_BITS_PER_WIDE_INT == HOST_BITS_PER_LONG
	# define CLZ_HWI __builtin_clzl
	# define CTZ_HWI __builtin_ctzl
	# elif HOST_BITS_PER_WIDE_INT == HOST_BITS_PER_LONGLONG
	# define CLZ_HWI __builtin_clzll
	# define CTZ_HWI __builtin_ctzll
	# else
	# define CLZ_HWI __builtin_clz
	# define CTZ_HWI __builtin_ctz
	# endif

	extern inline int
	floor_log2 (unsigned HOST_WIDE_INT x)
	{
	return x ? HOST_BITS_PER_WIDE_INT - 1 - (int) CLZ_HWI (x) : -1;
	}

	extern inline int
	exact_log2 (unsigned HOST_WIDE_INT x)
	{
	return x == (x & -x) && x ? (int) CTZ_HWI (x) : -1;
	}
	#endif /* GCC_VERSION >= 3004 */

	/* Functions used to get and set GCC's notion of in what directory
	compilation was started. */

	extern const char *get_src_pwd (void);
	extern bool set_src_pwd (const char *);

	#endif /* ! GCC_TOPLEV_H */
	diff --git a/contrib/gcc/tree-cfg.c b/contrib/gcc/tree-cfg.c
	index 7573439c6541..60c474bf45a6 100644
	--- a/contrib/gcc/tree-cfg.c
	+++ b/contrib/gcc/tree-cfg.c
	@@ -1,5883 +1,5890 @@
	/* Control flow functions for trees.
	Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006
	Free Software Foundation, Inc.
	Contributed by Diego Novillo <dnovillo@redhat.com>

	This file is part of GCC.

	GCC is free software; you can redistribute it and/or modify
	it under the terms of the GNU General Public License as published by
	the Free Software Foundation; either version 2, or (at your option)
	any later version.

	GCC is distributed in the hope that it will be useful,
	but WITHOUT ANY WARRANTY; without even the implied warranty of
	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	GNU General Public License for more details.

	You should have received a copy of the GNU General Public License
	along with GCC; see the file COPYING. If not, write to
	the Free Software Foundation, 51 Franklin Street, Fifth Floor,
	Boston, MA 02110-1301, USA. */

	#include "config.h"
	#include "system.h"
	#include "coretypes.h"
	#include "tm.h"
	#include "tree.h"
	#include "rtl.h"
	#include "tm_p.h"
	#include "hard-reg-set.h"
	#include "basic-block.h"
	#include "output.h"
	#include "flags.h"
	#include "function.h"
	#include "expr.h"
	#include "ggc.h"
	#include "langhooks.h"
	#include "diagnostic.h"
	#include "tree-flow.h"
	#include "timevar.h"
	#include "tree-dump.h"
	#include "tree-pass.h"
	#include "toplev.h"
	#include "except.h"
	#include "cfgloop.h"
	#include "cfglayout.h"
	#include "hashtab.h"
	#include "tree-ssa-propagate.h"

	/* This file contains functions for building the Control Flow Graph (CFG)
	for a function tree. */

	/* Local declarations. */

	/* Initial capacity for the basic block array. */
	static const int initial_cfg_capacity = 20;

	/* This hash table allows us to efficiently lookup all CASE_LABEL_EXPRs
	which use a particular edge. The CASE_LABEL_EXPRs are chained together
	via their TREE_CHAIN field, which we clear after we're done with the
	hash table to prevent problems with duplication of SWITCH_EXPRs.

	Access to this list of CASE_LABEL_EXPRs allows us to efficiently
	update the case vector in response to edge redirections.

	Right now this table is set up and torn down at key points in the
	compilation process. It would be nice if we could make the table
	more persistent. The key is getting notification of changes to
	the CFG (particularly edge removal, creation and redirection). */

	struct edge_to_cases_elt
	{
	/* The edge itself. Necessary for hashing and equality tests. */
	edge e;

	/* The case labels associated with this edge. We link these up via
	their TREE_CHAIN field, then we wipe out the TREE_CHAIN fields
	when we destroy the hash table. This prevents problems when copying
	SWITCH_EXPRs. */
	tree case_labels;
	};

	static htab_t edge_to_cases;

	/* CFG statistics. */
	struct cfg_stats_d
	{
	long num_merged_labels;
	};

	static struct cfg_stats_d cfg_stats;

	/* Nonzero if we found a computed goto while building basic blocks. */
	static bool found_computed_goto;

	/* Basic blocks and flowgraphs. */
	static basic_block create_bb (void , void , basic_block);
	static void make_blocks (tree);
	static void factor_computed_gotos (void);

	/* Edges. */
	static void make_edges (void);
	static void make_cond_expr_edges (basic_block);
	static void make_switch_expr_edges (basic_block);
	static void make_goto_expr_edges (basic_block);
	static edge tree_redirect_edge_and_branch (edge, basic_block);
	static edge tree_try_redirect_by_replacing_jump (edge, basic_block);
	static unsigned int split_critical_edges (void);

	/* Various helpers. */
	static inline bool stmt_starts_bb_p (tree, tree);
	static int tree_verify_flow_info (void);
	static void tree_make_forwarder_block (edge);
	static void tree_cfg2vcg (FILE *);
	static inline void change_bb_for_stmt (tree t, basic_block bb);

	/* Flowgraph optimization and cleanup. */
	static void tree_merge_blocks (basic_block, basic_block);
	static bool tree_can_merge_blocks_p (basic_block, basic_block);
	static void remove_bb (basic_block);
	static edge find_taken_edge_computed_goto (basic_block, tree);
	static edge find_taken_edge_cond_expr (basic_block, tree);
	static edge find_taken_edge_switch_expr (basic_block, tree);
	static tree find_case_label_for_value (tree, tree);

	void
	init_empty_tree_cfg (void)
	{
	/* Initialize the basic block array. */
	init_flow ();
	profile_status = PROFILE_ABSENT;
	n_basic_blocks = NUM_FIXED_BLOCKS;
	last_basic_block = NUM_FIXED_BLOCKS;
	basic_block_info = VEC_alloc (basic_block, gc, initial_cfg_capacity);
	VEC_safe_grow (basic_block, gc, basic_block_info, initial_cfg_capacity);
	memset (VEC_address (basic_block, basic_block_info), 0,
	sizeof (basic_block) * initial_cfg_capacity);

	/* Build a mapping of labels to their associated blocks. */
	label_to_block_map = VEC_alloc (basic_block, gc, initial_cfg_capacity);
	VEC_safe_grow (basic_block, gc, label_to_block_map, initial_cfg_capacity);
	memset (VEC_address (basic_block, label_to_block_map),
	0, sizeof (basic_block) * initial_cfg_capacity);

	SET_BASIC_BLOCK (ENTRY_BLOCK, ENTRY_BLOCK_PTR);
	SET_BASIC_BLOCK (EXIT_BLOCK, EXIT_BLOCK_PTR);
	ENTRY_BLOCK_PTR->next_bb = EXIT_BLOCK_PTR;
	EXIT_BLOCK_PTR->prev_bb = ENTRY_BLOCK_PTR;
	}

	/*---------------------------------------------------------------------------
	Create basic blocks
	---------------------------------------------------------------------------*/

	/* Entry point to the CFG builder for trees. TP points to the list of
	statements to be added to the flowgraph. */

	static void
	build_tree_cfg (tree *tp)
	{
	/* Register specific tree functions. */
	tree_register_cfg_hooks ();

	memset ((void *) &cfg_stats, 0, sizeof (cfg_stats));

	init_empty_tree_cfg ();

	found_computed_goto = 0;
	make_blocks (*tp);

	/* Computed gotos are hell to deal with, especially if there are
	lots of them with a large number of destinations. So we factor
	them to a common computed goto location before we build the
	edge list. After we convert back to normal form, we will un-factor
	the computed gotos since factoring introduces an unwanted jump. */
	if (found_computed_goto)
	factor_computed_gotos ();

	/* Make sure there is always at least one block, even if it's empty. */
	if (n_basic_blocks == NUM_FIXED_BLOCKS)
	create_empty_bb (ENTRY_BLOCK_PTR);

	/* Adjust the size of the array. */
	if (VEC_length (basic_block, basic_block_info) < (size_t) n_basic_blocks)
	{
	size_t old_size = VEC_length (basic_block, basic_block_info);
	basic_block *p;
	VEC_safe_grow (basic_block, gc, basic_block_info, n_basic_blocks);
	p = VEC_address (basic_block, basic_block_info);
	memset (&p[old_size], 0,
	sizeof (basic_block) * (n_basic_blocks - old_size));
	}

	/* To speed up statement iterator walks, we first purge dead labels. */
	cleanup_dead_labels ();

	/* Group case nodes to reduce the number of edges.
	We do this after cleaning up dead labels because otherwise we miss
	a lot of obvious case merging opportunities. */
	group_case_labels ();

	/* Create the edges of the flowgraph. */
	make_edges ();

	/* Debugging dumps. */

	/* Write the flowgraph to a VCG file. */
	{
	int local_dump_flags;
	FILE *vcg_file = dump_begin (TDI_vcg, &local_dump_flags);
	if (vcg_file)
	{
	tree_cfg2vcg (vcg_file);
	dump_end (TDI_vcg, vcg_file);
	}
	}

	#ifdef ENABLE_CHECKING
	verify_stmts ();
	#endif

	/* Dump a textual representation of the flowgraph. */
	if (dump_file)
	dump_tree_cfg (dump_file, dump_flags);
	}

	static unsigned int
	execute_build_cfg (void)
	{
	build_tree_cfg (&DECL_SAVED_TREE (current_function_decl));
	return 0;
	}

	struct tree_opt_pass pass_build_cfg =
	{
	"cfg", /* name */
	NULL, /* gate */
	execute_build_cfg, /* execute */
	NULL, /* sub */
	NULL, /* next */
	0, /* static_pass_number */
	TV_TREE_CFG, /* tv_id */
	PROP_gimple_leh, /* properties_required */
	PROP_cfg, /* properties_provided */
	0, /* properties_destroyed */
	0, /* todo_flags_start */
	TODO_verify_stmts, /* todo_flags_finish */
	0 /* letter */
	};

	/* Search the CFG for any computed gotos. If found, factor them to a
	common computed goto site. Also record the location of that site so
	that we can un-factor the gotos after we have converted back to
	normal form. */

	static void
	factor_computed_gotos (void)
	{
	basic_block bb;
	tree factored_label_decl = NULL;
	tree var = NULL;
	tree factored_computed_goto_label = NULL;
	tree factored_computed_goto = NULL;

	/* We know there are one or more computed gotos in this function.
	Examine the last statement in each basic block to see if the block
	ends with a computed goto. */

	FOR_EACH_BB (bb)
	{
	block_stmt_iterator bsi = bsi_last (bb);
	tree last;

	if (bsi_end_p (bsi))
	continue;
	last = bsi_stmt (bsi);

	/* Ignore the computed goto we create when we factor the original
	computed gotos. */
	if (last == factored_computed_goto)
	continue;

	/* If the last statement is a computed goto, factor it. */
	if (computed_goto_p (last))
	{
	tree assignment;

	/* The first time we find a computed goto we need to create
	the factored goto block and the variable each original
	computed goto will use for their goto destination. */
	if (! factored_computed_goto)
	{
	basic_block new_bb = create_empty_bb (bb);
	block_stmt_iterator new_bsi = bsi_start (new_bb);

	/* Create the destination of the factored goto. Each original
	computed goto will put its desired destination into this
	variable and jump to the label we create immediately
	below. */
	var = create_tmp_var (ptr_type_node, "gotovar");

	/* Build a label for the new block which will contain the
	factored computed goto. */
	factored_label_decl = create_artificial_label ();
	factored_computed_goto_label
	= build1 (LABEL_EXPR, void_type_node, factored_label_decl);
	bsi_insert_after (&new_bsi, factored_computed_goto_label,
	BSI_NEW_STMT);

	/* Build our new computed goto. */
	factored_computed_goto = build1 (GOTO_EXPR, void_type_node, var);
	bsi_insert_after (&new_bsi, factored_computed_goto,
	BSI_NEW_STMT);
	}

	/* Copy the original computed goto's destination into VAR. */
	assignment = build2 (MODIFY_EXPR, ptr_type_node,
	var, GOTO_DESTINATION (last));
	bsi_insert_before (&bsi, assignment, BSI_SAME_STMT);

	/* And re-vector the computed goto to the new destination. */
	GOTO_DESTINATION (last) = factored_label_decl;
	}
	}
	}


	/* Build a flowgraph for the statement_list STMT_LIST. */

	static void
	make_blocks (tree stmt_list)
	{
	tree_stmt_iterator i = tsi_start (stmt_list);
	tree stmt = NULL;
	bool start_new_block = true;
	bool first_stmt_of_list = true;
	basic_block bb = ENTRY_BLOCK_PTR;

	while (!tsi_end_p (i))
	{
	tree prev_stmt;

	prev_stmt = stmt;
	stmt = tsi_stmt (i);

	/* If the statement starts a new basic block or if we have determined
	in a previous pass that we need to create a new block for STMT, do
	so now. */
	if (start_new_block \|\| stmt_starts_bb_p (stmt, prev_stmt))
	{
	if (!first_stmt_of_list)
	stmt_list = tsi_split_statement_list_before (&i);
	bb = create_basic_block (stmt_list, NULL, bb);
	start_new_block = false;
	}

	/* Now add STMT to BB and create the subgraphs for special statement
	codes. */
	set_bb_for_stmt (stmt, bb);

	if (computed_goto_p (stmt))
	found_computed_goto = true;

	/* If STMT is a basic block terminator, set START_NEW_BLOCK for the
	next iteration. */
	if (stmt_ends_bb_p (stmt))
	start_new_block = true;

	tsi_next (&i);
	first_stmt_of_list = false;
	}
	}


	/* Create and return a new empty basic block after bb AFTER. */

	static basic_block
	create_bb (void h, void e, basic_block after)
	{
	basic_block bb;

	gcc_assert (!e);

	/* Create and initialize a new basic block. Since alloc_block uses
	ggc_alloc_cleared to allocate a basic block, we do not have to
	clear the newly allocated basic block here. */
	bb = alloc_block ();

	bb->index = last_basic_block;
	bb->flags = BB_NEW;
	bb->stmt_list = h ? (tree) h : alloc_stmt_list ();

	/* Add the new block to the linked list of blocks. */
	link_block (bb, after);

	/* Grow the basic block array if needed. */
	if ((size_t) last_basic_block == VEC_length (basic_block, basic_block_info))
	{
	size_t old_size = VEC_length (basic_block, basic_block_info);
	size_t new_size = last_basic_block + (last_basic_block + 3) / 4;
	basic_block *p;
	VEC_safe_grow (basic_block, gc, basic_block_info, new_size);
	p = VEC_address (basic_block, basic_block_info);
	memset (&p[old_size], 0, sizeof (basic_block) * (new_size - old_size));
	}

	/* Add the newly created block to the array. */
	SET_BASIC_BLOCK (last_basic_block, bb);

	n_basic_blocks++;
	last_basic_block++;

	return bb;
	}


	/*---------------------------------------------------------------------------
	Edge creation
	---------------------------------------------------------------------------*/

	/* Fold COND_EXPR_COND of each COND_EXPR. */

	void
	fold_cond_expr_cond (void)
	{
	basic_block bb;

	FOR_EACH_BB (bb)
	{
	tree stmt = last_stmt (bb);

	if (stmt
	&& TREE_CODE (stmt) == COND_EXPR)
	{
	tree cond;
	bool zerop, onep;

	fold_defer_overflow_warnings ();
	cond = fold (COND_EXPR_COND (stmt));
	zerop = integer_zerop (cond);
	onep = integer_onep (cond);
	fold_undefer_overflow_warnings (((zerop \|\| onep)
	&& !TREE_NO_WARNING (stmt)),
	stmt,
	WARN_STRICT_OVERFLOW_CONDITIONAL);
	if (zerop)
	COND_EXPR_COND (stmt) = boolean_false_node;
	else if (onep)
	COND_EXPR_COND (stmt) = boolean_true_node;
	}
	}
	}

	/* Join all the blocks in the flowgraph. */

	static void
	make_edges (void)
	{
	basic_block bb;
	struct omp_region *cur_region = NULL;

	/* Create an edge from entry to the first block with executable
	statements in it. */
	make_edge (ENTRY_BLOCK_PTR, BASIC_BLOCK (NUM_FIXED_BLOCKS), EDGE_FALLTHRU);

	/* Traverse the basic block array placing edges. */
	FOR_EACH_BB (bb)
	{
	tree last = last_stmt (bb);
	bool fallthru;

	if (last)
	{
	enum tree_code code = TREE_CODE (last);
	switch (code)
	{
	case GOTO_EXPR:
	make_goto_expr_edges (bb);
	fallthru = false;
	break;
	case RETURN_EXPR:
	make_edge (bb, EXIT_BLOCK_PTR, 0);
	fallthru = false;
	break;
	case COND_EXPR:
	make_cond_expr_edges (bb);
	fallthru = false;
	break;
	case SWITCH_EXPR:
	make_switch_expr_edges (bb);
	fallthru = false;
	break;
	case RESX_EXPR:
	make_eh_edges (last);
	fallthru = false;
	break;

	case CALL_EXPR:
	/* If this function receives a nonlocal goto, then we need to
	make edges from this call site to all the nonlocal goto
	handlers. */
	if (tree_can_make_abnormal_goto (last))
	make_abnormal_goto_edges (bb, true);

	/* If this statement has reachable exception handlers, then
	create abnormal edges to them. */
	make_eh_edges (last);

	/* Some calls are known not to return. */
	fallthru = !(call_expr_flags (last) & ECF_NORETURN);
	break;

	case MODIFY_EXPR:
	if (is_ctrl_altering_stmt (last))
	{
	/* A MODIFY_EXPR may have a CALL_EXPR on its RHS and the
	CALL_EXPR may have an abnormal edge. Search the RHS for
	this case and create any required edges. */
	if (tree_can_make_abnormal_goto (last))
	make_abnormal_goto_edges (bb, true);

	make_eh_edges (last);
	}
	fallthru = true;
	break;

	case OMP_PARALLEL:
	case OMP_FOR:
	case OMP_SINGLE:
	case OMP_MASTER:
	case OMP_ORDERED:
	case OMP_CRITICAL:
	case OMP_SECTION:
	cur_region = new_omp_region (bb, code, cur_region);
	fallthru = true;
	break;

	case OMP_SECTIONS:
	cur_region = new_omp_region (bb, code, cur_region);
	fallthru = false;
	break;

	case OMP_RETURN:
	/* In the case of an OMP_SECTION, the edge will go somewhere
	other than the next block. This will be created later. */
	cur_region->exit = bb;
	fallthru = cur_region->type != OMP_SECTION;
	cur_region = cur_region->outer;
	break;

	case OMP_CONTINUE:
	cur_region->cont = bb;
	switch (cur_region->type)
	{
	case OMP_FOR:
	/* ??? Technically there should be a some sort of loopback
	edge here, but it goes to a block that doesn't exist yet,
	and without it, updating the ssa form would be a real
	bear. Fortunately, we don't yet do ssa before expanding
	these nodes. */
	break;

	case OMP_SECTIONS:
	/* Wire up the edges into and out of the nested sections. */
	/* ??? Similarly wrt loopback. */
	{
	struct omp_region *i;
	for (i = cur_region->inner; i ; i = i->next)
	{
	gcc_assert (i->type == OMP_SECTION);
	make_edge (cur_region->entry, i->entry, 0);
	make_edge (i->exit, bb, EDGE_FALLTHRU);
	}
	}
	break;

	default:
	gcc_unreachable ();
	}
	fallthru = true;
	break;

	default:
	gcc_assert (!stmt_ends_bb_p (last));
	fallthru = true;
	}
	}
	else
	fallthru = true;

	if (fallthru)
	make_edge (bb, bb->next_bb, EDGE_FALLTHRU);
	}

	if (root_omp_region)
	free_omp_regions ();

	/* Fold COND_EXPR_COND of each COND_EXPR. */
	fold_cond_expr_cond ();

	/* Clean up the graph and warn for unreachable code. */
	cleanup_tree_cfg ();
	}


	/* Create the edges for a COND_EXPR starting at block BB.
	At this point, both clauses must contain only simple gotos. */

	static void
	make_cond_expr_edges (basic_block bb)
	{
	tree entry = last_stmt (bb);
	basic_block then_bb, else_bb;
	tree then_label, else_label;
	edge e;

	gcc_assert (entry);
	gcc_assert (TREE_CODE (entry) == COND_EXPR);

	/* Entry basic blocks for each component. */
	then_label = GOTO_DESTINATION (COND_EXPR_THEN (entry));
	else_label = GOTO_DESTINATION (COND_EXPR_ELSE (entry));
	then_bb = label_to_block (then_label);
	else_bb = label_to_block (else_label);

	e = make_edge (bb, then_bb, EDGE_TRUE_VALUE);
	#ifdef USE_MAPPED_LOCATION
	e->goto_locus = EXPR_LOCATION (COND_EXPR_THEN (entry));
	#else
	e->goto_locus = EXPR_LOCUS (COND_EXPR_THEN (entry));
	#endif
	e = make_edge (bb, else_bb, EDGE_FALSE_VALUE);
	if (e)
	{
	#ifdef USE_MAPPED_LOCATION
	e->goto_locus = EXPR_LOCATION (COND_EXPR_ELSE (entry));
	#else
	e->goto_locus = EXPR_LOCUS (COND_EXPR_ELSE (entry));
	#endif
	}
	}

	/* Hashing routine for EDGE_TO_CASES. */

	static hashval_t
	edge_to_cases_hash (const void *p)
	{
	edge e = ((struct edge_to_cases_elt *)p)->e;

	/* Hash on the edge itself (which is a pointer). */
	return htab_hash_pointer (e);
	}

	/* Equality routine for EDGE_TO_CASES, edges are unique, so testing
	for equality is just a pointer comparison. */

	static int
	edge_to_cases_eq (const void p1, const void p2)
	{
	edge e1 = ((struct edge_to_cases_elt *)p1)->e;
	edge e2 = ((struct edge_to_cases_elt *)p2)->e;

	return e1 == e2;
	}

	/* Called for each element in the hash table (P) as we delete the
	edge to cases hash table.

	Clear all the TREE_CHAINs to prevent problems with copying of
	SWITCH_EXPRs and structure sharing rules, then free the hash table
	element. */

	static void
	edge_to_cases_cleanup (void *p)
	{
	struct edge_to_cases_elt elt = (struct edge_to_cases_elt ) p;
	tree t, next;

	for (t = elt->case_labels; t; t = next)
	{
	next = TREE_CHAIN (t);
	TREE_CHAIN (t) = NULL;
	}
	free (p);
	}

	/* Start recording information mapping edges to case labels. */

	void
	start_recording_case_labels (void)
	{
	gcc_assert (edge_to_cases == NULL);

	edge_to_cases = htab_create (37,
	edge_to_cases_hash,
	edge_to_cases_eq,
	edge_to_cases_cleanup);
	}

	/* Return nonzero if we are recording information for case labels. */

	static bool
	recording_case_labels_p (void)
	{
	return (edge_to_cases != NULL);
	}

	/* Stop recording information mapping edges to case labels and
	remove any information we have recorded. */
	void
	end_recording_case_labels (void)
	{
	htab_delete (edge_to_cases);
	edge_to_cases = NULL;
	}

	/* Record that CASE_LABEL (a CASE_LABEL_EXPR) references edge E. */

	static void
	record_switch_edge (edge e, tree case_label)
	{
	struct edge_to_cases_elt *elt;
	void **slot;

	/* Build a hash table element so we can see if E is already
	in the table. */
	elt = XNEW (struct edge_to_cases_elt);
	elt->e = e;
	elt->case_labels = case_label;

	slot = htab_find_slot (edge_to_cases, elt, INSERT);

	if (*slot == NULL)
	{
	/* E was not in the hash table. Install E into the hash table. */
	slot = (void )elt;
	}
	else
	{
	/* E was already in the hash table. Free ELT as we do not need it
	anymore. */
	free (elt);

	/* Get the entry stored in the hash table. */
	elt = (struct edge_to_cases_elt ) slot;

	/* Add it to the chain of CASE_LABEL_EXPRs referencing E. */
	TREE_CHAIN (case_label) = elt->case_labels;
	elt->case_labels = case_label;
	}
	}

	/* If we are inside a {start,end}_recording_cases block, then return
	a chain of CASE_LABEL_EXPRs from T which reference E.

	Otherwise return NULL. */

	static tree
	get_cases_for_edge (edge e, tree t)
	{
	struct edge_to_cases_elt elt, *elt_p;
	void **slot;
	size_t i, n;
	tree vec;

	/* If we are not recording cases, then we do not have CASE_LABEL_EXPR
	chains available. Return NULL so the caller can detect this case. */
	if (!recording_case_labels_p ())
	return NULL;

	restart:
	elt.e = e;
	elt.case_labels = NULL;
	slot = htab_find_slot (edge_to_cases, &elt, NO_INSERT);

	if (slot)
	{
	elt_p = (struct edge_to_cases_elt )slot;
	return elt_p->case_labels;
	}

	/* If we did not find E in the hash table, then this must be the first
	time we have been queried for information about E & T. Add all the
	elements from T to the hash table then perform the query again. */

	vec = SWITCH_LABELS (t);
	n = TREE_VEC_LENGTH (vec);
	for (i = 0; i < n; i++)
	{
	tree lab = CASE_LABEL (TREE_VEC_ELT (vec, i));
	basic_block label_bb = label_to_block (lab);
	record_switch_edge (find_edge (e->src, label_bb), TREE_VEC_ELT (vec, i));
	}
	goto restart;
	}

	/* Create the edges for a SWITCH_EXPR starting at block BB.
	At this point, the switch body has been lowered and the
	SWITCH_LABELS filled in, so this is in effect a multi-way branch. */

	static void
	make_switch_expr_edges (basic_block bb)
	{
	tree entry = last_stmt (bb);
	size_t i, n;
	tree vec;

	vec = SWITCH_LABELS (entry);
	n = TREE_VEC_LENGTH (vec);

	for (i = 0; i < n; ++i)
	{
	tree lab = CASE_LABEL (TREE_VEC_ELT (vec, i));
	basic_block label_bb = label_to_block (lab);
	make_edge (bb, label_bb, 0);
	}
	}


	/* Return the basic block holding label DEST. */

	basic_block
	label_to_block_fn (struct function *ifun, tree dest)
	{
	int uid = LABEL_DECL_UID (dest);

	/* We would die hard when faced by an undefined label. Emit a label to
	the very first basic block. This will hopefully make even the dataflow
	and undefined variable warnings quite right. */
	if ((errorcount \|\| sorrycount) && uid < 0)
	{
	block_stmt_iterator bsi =
	bsi_start (BASIC_BLOCK (NUM_FIXED_BLOCKS));
	tree stmt;

	stmt = build1 (LABEL_EXPR, void_type_node, dest);
	bsi_insert_before (&bsi, stmt, BSI_NEW_STMT);
	uid = LABEL_DECL_UID (dest);
	}
	if (VEC_length (basic_block, ifun->cfg->x_label_to_block_map)
	<= (unsigned int) uid)
	return NULL;
	return VEC_index (basic_block, ifun->cfg->x_label_to_block_map, uid);
	}

	/* Create edges for an abnormal goto statement at block BB. If FOR_CALL
	is true, the source statement is a CALL_EXPR instead of a GOTO_EXPR. */

	void
	make_abnormal_goto_edges (basic_block bb, bool for_call)
	{
	basic_block target_bb;
	block_stmt_iterator bsi;

	FOR_EACH_BB (target_bb)
	for (bsi = bsi_start (target_bb); !bsi_end_p (bsi); bsi_next (&bsi))
	{
	tree target = bsi_stmt (bsi);

	if (TREE_CODE (target) != LABEL_EXPR)
	break;

	target = LABEL_EXPR_LABEL (target);

	/* Make an edge to every label block that has been marked as a
	potential target for a computed goto or a non-local goto. */
	if ((FORCED_LABEL (target) && !for_call)
	\|\| (DECL_NONLOCAL (target) && for_call))
	{
	make_edge (bb, target_bb, EDGE_ABNORMAL);
	break;
	}
	}
	}

	/* Create edges for a goto statement at block BB. */

	static void
	make_goto_expr_edges (basic_block bb)
	{
	block_stmt_iterator last = bsi_last (bb);
	tree goto_t = bsi_stmt (last);

	/* A simple GOTO creates normal edges. */
	if (simple_goto_p (goto_t))
	{
	tree dest = GOTO_DESTINATION (goto_t);
	edge e = make_edge (bb, label_to_block (dest), EDGE_FALLTHRU);
	#ifdef USE_MAPPED_LOCATION
	e->goto_locus = EXPR_LOCATION (goto_t);
	#else
	e->goto_locus = EXPR_LOCUS (goto_t);
	#endif
	bsi_remove (&last, true);
	return;
	}

	/* A computed GOTO creates abnormal edges. */
	make_abnormal_goto_edges (bb, false);
	}


	/*---------------------------------------------------------------------------
	Flowgraph analysis
	---------------------------------------------------------------------------*/

	/* Cleanup useless labels in basic blocks. This is something we wish
	to do early because it allows us to group case labels before creating
	the edges for the CFG, and it speeds up block statement iterators in
	all passes later on.
	We only run this pass once, running it more than once is probably not
	profitable. */

	/* A map from basic block index to the leading label of that block. */
	static tree *label_for_bb;

	/* Callback for for_each_eh_region. Helper for cleanup_dead_labels. */
	static void
	update_eh_label (struct eh_region *region)
	{
	tree old_label = get_eh_region_tree_label (region);
	if (old_label)
	{
	tree new_label;
	basic_block bb = label_to_block (old_label);

	/* ??? After optimizing, there may be EH regions with labels
	that have already been removed from the function body, so
	there is no basic block for them. */
	if (! bb)
	return;

	new_label = label_for_bb[bb->index];
	set_eh_region_tree_label (region, new_label);
	}
	}

	/* Given LABEL return the first label in the same basic block. */
	static tree
	main_block_label (tree label)
	{
	basic_block bb = label_to_block (label);

	/* label_to_block possibly inserted undefined label into the chain. */
	if (!label_for_bb[bb->index])
	label_for_bb[bb->index] = label;
	return label_for_bb[bb->index];
	}

	/* Cleanup redundant labels. This is a three-step process:
	1) Find the leading label for each block.
	2) Redirect all references to labels to the leading labels.
	3) Cleanup all useless labels. */

	void
	cleanup_dead_labels (void)
	{
	basic_block bb;
	label_for_bb = XCNEWVEC (tree, last_basic_block);

	/* Find a suitable label for each block. We use the first user-defined
	label if there is one, or otherwise just the first label we see. */
	FOR_EACH_BB (bb)
	{
	block_stmt_iterator i;

	for (i = bsi_start (bb); !bsi_end_p (i); bsi_next (&i))
	{
	tree label, stmt = bsi_stmt (i);

	if (TREE_CODE (stmt) != LABEL_EXPR)
	break;

	label = LABEL_EXPR_LABEL (stmt);

	/* If we have not yet seen a label for the current block,
	remember this one and see if there are more labels. */
	if (! label_for_bb[bb->index])
	{
	label_for_bb[bb->index] = label;
	continue;
	}

	/* If we did see a label for the current block already, but it
	is an artificially created label, replace it if the current
	label is a user defined label. */
	if (! DECL_ARTIFICIAL (label)
	&& DECL_ARTIFICIAL (label_for_bb[bb->index]))
	{
	label_for_bb[bb->index] = label;
	break;
	}
	}
	}

	/* Now redirect all jumps/branches to the selected label.
	First do so for each block ending in a control statement. */
	FOR_EACH_BB (bb)
	{
	tree stmt = last_stmt (bb);
	if (!stmt)
	continue;

	switch (TREE_CODE (stmt))
	{
	case COND_EXPR:
	{
	tree true_branch, false_branch;

	true_branch = COND_EXPR_THEN (stmt);
	false_branch = COND_EXPR_ELSE (stmt);

	GOTO_DESTINATION (true_branch)
	= main_block_label (GOTO_DESTINATION (true_branch));
	GOTO_DESTINATION (false_branch)
	= main_block_label (GOTO_DESTINATION (false_branch));

	break;
	}

	case SWITCH_EXPR:
	{
	size_t i;
	tree vec = SWITCH_LABELS (stmt);
	size_t n = TREE_VEC_LENGTH (vec);

	/* Replace all destination labels. */
	for (i = 0; i < n; ++i)
	{
	tree elt = TREE_VEC_ELT (vec, i);
	tree label = main_block_label (CASE_LABEL (elt));
	CASE_LABEL (elt) = label;
	}
	break;
	}

	/* We have to handle GOTO_EXPRs until they're removed, and we don't
	remove them until after we've created the CFG edges. */
	case GOTO_EXPR:
	if (! computed_goto_p (stmt))
	{
	GOTO_DESTINATION (stmt)
	= main_block_label (GOTO_DESTINATION (stmt));
	break;
	}

	default:
	break;
	}
	}

	for_each_eh_region (update_eh_label);

	- /* Finally, purge dead labels. All user-defined labels and labels that
	- can be the target of non-local gotos and labels which have their
	- address taken are preserved. */
	+/* APPLE LOCAL begin for-fsf-4_4 3274130 5295549 */ \
	+ /* Finally, purge dead labels. All user-defined labels, labels that
	+ can be the target of non-local gotos, labels which have their
	+ address taken and labels which have attributes or alignment are
	+ preserved. */
	+/* APPLE LOCAL end for-fsf-4_4 3274130 5295549 */ \
	FOR_EACH_BB (bb)
	{
	block_stmt_iterator i;
	tree label_for_this_bb = label_for_bb[bb->index];

	if (! label_for_this_bb)
	continue;

	for (i = bsi_start (bb); !bsi_end_p (i); )
	{
	tree label, stmt = bsi_stmt (i);

	if (TREE_CODE (stmt) != LABEL_EXPR)
	break;

	label = LABEL_EXPR_LABEL (stmt);

	if (label == label_for_this_bb
	\|\| ! DECL_ARTIFICIAL (label)
	+/* APPLE LOCAL begin for-fsf-4_4 3274130 5295549 */ \
	+ \|\| DECL_ATTRIBUTES (label)
	+ \|\| DECL_USER_ALIGN (label)
	+/* APPLE LOCAL end for-fsf-4_4 3274130 5295549 */ \
	\|\| DECL_NONLOCAL (label)
	\|\| FORCED_LABEL (label))
	bsi_next (&i);
	else
	bsi_remove (&i, true);
	}
	}

	free (label_for_bb);
	}

	/* Look for blocks ending in a multiway branch (a SWITCH_EXPR in GIMPLE),
	and scan the sorted vector of cases. Combine the ones jumping to the
	same label.
	Eg. three separate entries 1: 2: 3: become one entry 1..3: */

	void
	group_case_labels (void)
	{
	basic_block bb;

	FOR_EACH_BB (bb)
	{
	tree stmt = last_stmt (bb);
	if (stmt && TREE_CODE (stmt) == SWITCH_EXPR)
	{
	tree labels = SWITCH_LABELS (stmt);
	int old_size = TREE_VEC_LENGTH (labels);
	int i, j, new_size = old_size;
	tree default_case = TREE_VEC_ELT (labels, old_size - 1);
	tree default_label;

	/* The default label is always the last case in a switch
	statement after gimplification. */
	default_label = CASE_LABEL (default_case);

	/* Look for possible opportunities to merge cases.
	Ignore the last element of the label vector because it
	must be the default case. */
	i = 0;
	while (i < old_size - 1)
	{
	tree base_case, base_label, base_high;
	base_case = TREE_VEC_ELT (labels, i);

	gcc_assert (base_case);
	base_label = CASE_LABEL (base_case);

	/* Discard cases that have the same destination as the
	default case. */
	if (base_label == default_label)
	{
	TREE_VEC_ELT (labels, i) = NULL_TREE;
	i++;
	new_size--;
	continue;
	}

	base_high = CASE_HIGH (base_case) ?
	CASE_HIGH (base_case) : CASE_LOW (base_case);
	i++;
	/* Try to merge case labels. Break out when we reach the end
	of the label vector or when we cannot merge the next case
	label with the current one. */
	while (i < old_size - 1)
	{
	tree merge_case = TREE_VEC_ELT (labels, i);
	tree merge_label = CASE_LABEL (merge_case);
	tree t = int_const_binop (PLUS_EXPR, base_high,
	integer_one_node, 1);

	/* Merge the cases if they jump to the same place,
	and their ranges are consecutive. */
	if (merge_label == base_label
	&& tree_int_cst_equal (CASE_LOW (merge_case), t))
	{
	base_high = CASE_HIGH (merge_case) ?
	CASE_HIGH (merge_case) : CASE_LOW (merge_case);
	CASE_HIGH (base_case) = base_high;
	TREE_VEC_ELT (labels, i) = NULL_TREE;
	new_size--;
	i++;
	}
	else
	break;
	}
	}

	/* Compress the case labels in the label vector, and adjust the
	length of the vector. */
	for (i = 0, j = 0; i < new_size; i++)
	{
	while (! TREE_VEC_ELT (labels, j))
	j++;
	TREE_VEC_ELT (labels, i) = TREE_VEC_ELT (labels, j++);
	}
	TREE_VEC_LENGTH (labels) = new_size;
	}
	}
	}

	/* Checks whether we can merge block B into block A. */

	static bool
	tree_can_merge_blocks_p (basic_block a, basic_block b)
	{
	tree stmt;
	block_stmt_iterator bsi;
	tree phi;

	if (!single_succ_p (a))
	return false;

	if (single_succ_edge (a)->flags & EDGE_ABNORMAL)
	return false;

	if (single_succ (a) != b)
	return false;

	if (!single_pred_p (b))
	return false;

	if (b == EXIT_BLOCK_PTR)
	return false;

	/* If A ends by a statement causing exceptions or something similar, we
	cannot merge the blocks. */
	stmt = last_stmt (a);
	if (stmt && stmt_ends_bb_p (stmt))
	return false;

	/* Do not allow a block with only a non-local label to be merged. */
	if (stmt && TREE_CODE (stmt) == LABEL_EXPR
	&& DECL_NONLOCAL (LABEL_EXPR_LABEL (stmt)))
	return false;

	/* It must be possible to eliminate all phi nodes in B. If ssa form
	is not up-to-date, we cannot eliminate any phis. */
	phi = phi_nodes (b);
	if (phi)
	{
	if (need_ssa_update_p ())
	return false;

	for (; phi; phi = PHI_CHAIN (phi))
	if (!is_gimple_reg (PHI_RESULT (phi))
	&& !may_propagate_copy (PHI_RESULT (phi), PHI_ARG_DEF (phi, 0)))
	return false;
	}

	/* Do not remove user labels. */
	for (bsi = bsi_start (b); !bsi_end_p (bsi); bsi_next (&bsi))
	{
	stmt = bsi_stmt (bsi);
	if (TREE_CODE (stmt) != LABEL_EXPR)
	break;
	if (!DECL_ARTIFICIAL (LABEL_EXPR_LABEL (stmt)))
	return false;
	}

	/* Protect the loop latches. */
	if (current_loops
	&& b->loop_father->latch == b)
	return false;

	return true;
	}

	/* Replaces all uses of NAME by VAL. */

	void
	replace_uses_by (tree name, tree val)
	{
	imm_use_iterator imm_iter;
	use_operand_p use;
	tree stmt;
	edge e;
	unsigned i;


	FOR_EACH_IMM_USE_STMT (stmt, imm_iter, name)
	{
	FOR_EACH_IMM_USE_ON_STMT (use, imm_iter)
	{
	replace_exp (use, val);

	if (TREE_CODE (stmt) == PHI_NODE)
	{
	e = PHI_ARG_EDGE (stmt, PHI_ARG_INDEX_FROM_USE (use));
	if (e->flags & EDGE_ABNORMAL)
	{
	/* This can only occur for virtual operands, since
	for the real ones SSA_NAME_OCCURS_IN_ABNORMAL_PHI (name))
	would prevent replacement. */
	gcc_assert (!is_gimple_reg (name));
	SSA_NAME_OCCURS_IN_ABNORMAL_PHI (val) = 1;
	}
	}
	}
	if (TREE_CODE (stmt) != PHI_NODE)
	{
	tree rhs;

	fold_stmt_inplace (stmt);
	rhs = get_rhs (stmt);
	if (TREE_CODE (rhs) == ADDR_EXPR)
	recompute_tree_invariant_for_addr_expr (rhs);

	maybe_clean_or_replace_eh_stmt (stmt, stmt);
	mark_new_vars_to_rename (stmt);
	}
	}

	gcc_assert (num_imm_uses (name) == 0);

	/* Also update the trees stored in loop structures. */
	if (current_loops)
	{
	struct loop *loop;

	for (i = 0; i < current_loops->num; i++)
	{
	loop = current_loops->parray[i];
	if (loop)
	substitute_in_loop_info (loop, name, val);
	}
	}
	}

	/* Merge block B into block A. */

	static void
	tree_merge_blocks (basic_block a, basic_block b)
	{
	block_stmt_iterator bsi;
	tree_stmt_iterator last;
	tree phi;

	if (dump_file)
	fprintf (dump_file, "Merging blocks %d and %d\n", a->index, b->index);

	/* Remove all single-valued PHI nodes from block B of the form
	V_i = PHI <V_j> by propagating V_j to all the uses of V_i. */
	bsi = bsi_last (a);
	for (phi = phi_nodes (b); phi; phi = phi_nodes (b))
	{
	tree def = PHI_RESULT (phi), use = PHI_ARG_DEF (phi, 0);
	tree copy;
	bool may_replace_uses = may_propagate_copy (def, use);

	/* In case we have loops to care about, do not propagate arguments of
	loop closed ssa phi nodes. */
	if (current_loops
	&& is_gimple_reg (def)
	&& TREE_CODE (use) == SSA_NAME
	&& a->loop_father != b->loop_father)
	may_replace_uses = false;

	if (!may_replace_uses)
	{
	gcc_assert (is_gimple_reg (def));

	/* Note that just emitting the copies is fine -- there is no problem
	with ordering of phi nodes. This is because A is the single
	predecessor of B, therefore results of the phi nodes cannot
	appear as arguments of the phi nodes. */
	copy = build2 (MODIFY_EXPR, void_type_node, def, use);
	bsi_insert_after (&bsi, copy, BSI_NEW_STMT);
	SET_PHI_RESULT (phi, NULL_TREE);
	SSA_NAME_DEF_STMT (def) = copy;
	}
	else
	replace_uses_by (def, use);

	remove_phi_node (phi, NULL);
	}

	/* Ensure that B follows A. */
	move_block_after (b, a);

	gcc_assert (single_succ_edge (a)->flags & EDGE_FALLTHRU);
	gcc_assert (!last_stmt (a) \|\| !stmt_ends_bb_p (last_stmt (a)));

	/* Remove labels from B and set bb_for_stmt to A for other statements. */
	for (bsi = bsi_start (b); !bsi_end_p (bsi);)
	{
	if (TREE_CODE (bsi_stmt (bsi)) == LABEL_EXPR)
	{
	tree label = bsi_stmt (bsi);

	bsi_remove (&bsi, false);
	/* Now that we can thread computed gotos, we might have
	a situation where we have a forced label in block B
	However, the label at the start of block B might still be
	used in other ways (think about the runtime checking for
	Fortran assigned gotos). So we can not just delete the
	label. Instead we move the label to the start of block A. */
	if (FORCED_LABEL (LABEL_EXPR_LABEL (label)))
	{
	block_stmt_iterator dest_bsi = bsi_start (a);
	bsi_insert_before (&dest_bsi, label, BSI_NEW_STMT);
	}
	}
	else
	{
	change_bb_for_stmt (bsi_stmt (bsi), a);
	bsi_next (&bsi);
	}
	}

	/* Merge the chains. */
	last = tsi_last (a->stmt_list);
	tsi_link_after (&last, b->stmt_list, TSI_NEW_STMT);
	b->stmt_list = NULL;
	}


	/* Return the one of two successors of BB that is not reachable by a
	reached by a complex edge, if there is one. Else, return BB. We use
	this in optimizations that use post-dominators for their heuristics,
	to catch the cases in C++ where function calls are involved. */

	basic_block
	single_noncomplex_succ (basic_block bb)
	{
	edge e0, e1;
	if (EDGE_COUNT (bb->succs) != 2)
	return bb;

	e0 = EDGE_SUCC (bb, 0);
	e1 = EDGE_SUCC (bb, 1);
	if (e0->flags & EDGE_COMPLEX)
	return e1->dest;
	if (e1->flags & EDGE_COMPLEX)
	return e0->dest;

	return bb;
	}


	/* Walk the function tree removing unnecessary statements.

	* Empty statement nodes are removed

	* Unnecessary TRY_FINALLY and TRY_CATCH blocks are removed

	* Unnecessary COND_EXPRs are removed

	* Some unnecessary BIND_EXPRs are removed

	Clearly more work could be done. The trick is doing the analysis
	and removal fast enough to be a net improvement in compile times.

	Note that when we remove a control structure such as a COND_EXPR
	BIND_EXPR, or TRY block, we will need to repeat this optimization pass
	to ensure we eliminate all the useless code. */

	struct rus_data
	{
	tree *last_goto;
	bool repeat;
	bool may_throw;
	bool may_branch;
	bool has_label;
	};

	static void remove_useless_stmts_1 (tree , struct rus_data );

	static bool
	remove_useless_stmts_warn_notreached (tree stmt)
	{
	if (EXPR_HAS_LOCATION (stmt))
	{
	location_t loc = EXPR_LOCATION (stmt);
	if (LOCATION_LINE (loc) > 0)
	{
	warning (0, "%Hwill never be executed", &loc);
	return true;
	}
	}

	switch (TREE_CODE (stmt))
	{
	case STATEMENT_LIST:
	{
	tree_stmt_iterator i;
	for (i = tsi_start (stmt); !tsi_end_p (i); tsi_next (&i))
	if (remove_useless_stmts_warn_notreached (tsi_stmt (i)))
	return true;
	}
	break;

	case COND_EXPR:
	if (remove_useless_stmts_warn_notreached (COND_EXPR_COND (stmt)))
	return true;
	if (remove_useless_stmts_warn_notreached (COND_EXPR_THEN (stmt)))
	return true;
	if (remove_useless_stmts_warn_notreached (COND_EXPR_ELSE (stmt)))
	return true;
	break;

	case TRY_FINALLY_EXPR:
	case TRY_CATCH_EXPR:
	if (remove_useless_stmts_warn_notreached (TREE_OPERAND (stmt, 0)))
	return true;
	if (remove_useless_stmts_warn_notreached (TREE_OPERAND (stmt, 1)))
	return true;
	break;

	case CATCH_EXPR:
	return remove_useless_stmts_warn_notreached (CATCH_BODY (stmt));
	case EH_FILTER_EXPR:
	return remove_useless_stmts_warn_notreached (EH_FILTER_FAILURE (stmt));
	case BIND_EXPR:
	return remove_useless_stmts_warn_notreached (BIND_EXPR_BLOCK (stmt));

	default:
	/* Not a live container. */
	break;
	}

	return false;
	}

	static void
	remove_useless_stmts_cond (tree stmt_p, struct rus_data data)
	{
	tree then_clause, else_clause, cond;
	bool save_has_label, then_has_label, else_has_label;

	save_has_label = data->has_label;
	data->has_label = false;
	data->last_goto = NULL;

	remove_useless_stmts_1 (&COND_EXPR_THEN (*stmt_p), data);

	then_has_label = data->has_label;
	data->has_label = false;
	data->last_goto = NULL;

	remove_useless_stmts_1 (&COND_EXPR_ELSE (*stmt_p), data);

	else_has_label = data->has_label;
	data->has_label = save_has_label \| then_has_label \| else_has_label;

	then_clause = COND_EXPR_THEN (*stmt_p);
	else_clause = COND_EXPR_ELSE (*stmt_p);
	cond = fold (COND_EXPR_COND (*stmt_p));

	/* If neither arm does anything at all, we can remove the whole IF. */
	if (!TREE_SIDE_EFFECTS (then_clause) && !TREE_SIDE_EFFECTS (else_clause))
	{
	*stmt_p = build_empty_stmt ();
	data->repeat = true;
	}

	/* If there are no reachable statements in an arm, then we can
	zap the entire conditional. */
	else if (integer_nonzerop (cond) && !else_has_label)
	{
	if (warn_notreached)
	remove_useless_stmts_warn_notreached (else_clause);
	*stmt_p = then_clause;
	data->repeat = true;
	}
	else if (integer_zerop (cond) && !then_has_label)
	{
	if (warn_notreached)
	remove_useless_stmts_warn_notreached (then_clause);
	*stmt_p = else_clause;
	data->repeat = true;
	}

	/* Check a couple of simple things on then/else with single stmts. */
	else
	{
	tree then_stmt = expr_only (then_clause);
	tree else_stmt = expr_only (else_clause);

	/* Notice branches to a common destination. */
	if (then_stmt && else_stmt
	&& TREE_CODE (then_stmt) == GOTO_EXPR
	&& TREE_CODE (else_stmt) == GOTO_EXPR
	&& (GOTO_DESTINATION (then_stmt) == GOTO_DESTINATION (else_stmt)))
	{
	*stmt_p = then_stmt;
	data->repeat = true;
	}

	/* If the THEN/ELSE clause merely assigns a value to a variable or
	parameter which is already known to contain that value, then
	remove the useless THEN/ELSE clause. */
	else if (TREE_CODE (cond) == VAR_DECL \|\| TREE_CODE (cond) == PARM_DECL)
	{
	if (else_stmt
	&& TREE_CODE (else_stmt) == MODIFY_EXPR
	&& TREE_OPERAND (else_stmt, 0) == cond
	&& integer_zerop (TREE_OPERAND (else_stmt, 1)))
	COND_EXPR_ELSE (*stmt_p) = alloc_stmt_list ();
	}
	else if ((TREE_CODE (cond) == EQ_EXPR \|\| TREE_CODE (cond) == NE_EXPR)
	&& (TREE_CODE (TREE_OPERAND (cond, 0)) == VAR_DECL
	\|\| TREE_CODE (TREE_OPERAND (cond, 0)) == PARM_DECL)
	&& TREE_CONSTANT (TREE_OPERAND (cond, 1)))
	{
	tree stmt = (TREE_CODE (cond) == EQ_EXPR
	? then_stmt : else_stmt);
	tree *location = (TREE_CODE (cond) == EQ_EXPR
	? &COND_EXPR_THEN (*stmt_p)
	: &COND_EXPR_ELSE (*stmt_p));

	if (stmt
	&& TREE_CODE (stmt) == MODIFY_EXPR
	&& TREE_OPERAND (stmt, 0) == TREE_OPERAND (cond, 0)
	&& TREE_OPERAND (stmt, 1) == TREE_OPERAND (cond, 1))
	*location = alloc_stmt_list ();
	}
	}

	/* Protect GOTOs in the arm of COND_EXPRs from being removed. They
	would be re-introduced during lowering. */
	data->last_goto = NULL;
	}


	static void
	remove_useless_stmts_tf (tree stmt_p, struct rus_data data)
	{
	bool save_may_branch, save_may_throw;
	bool this_may_branch, this_may_throw;

	/* Collect may_branch and may_throw information for the body only. */
	save_may_branch = data->may_branch;
	save_may_throw = data->may_throw;
	data->may_branch = false;
	data->may_throw = false;
	data->last_goto = NULL;

	remove_useless_stmts_1 (&TREE_OPERAND (*stmt_p, 0), data);

	this_may_branch = data->may_branch;
	this_may_throw = data->may_throw;
	data->may_branch \|= save_may_branch;
	data->may_throw \|= save_may_throw;
	data->last_goto = NULL;

	remove_useless_stmts_1 (&TREE_OPERAND (*stmt_p, 1), data);

	/* If the body is empty, then we can emit the FINALLY block without
	the enclosing TRY_FINALLY_EXPR. */
	if (!TREE_SIDE_EFFECTS (TREE_OPERAND (*stmt_p, 0)))
	{
	stmt_p = TREE_OPERAND (stmt_p, 1);
	data->repeat = true;
	}

	/* If the handler is empty, then we can emit the TRY block without
	the enclosing TRY_FINALLY_EXPR. */
	else if (!TREE_SIDE_EFFECTS (TREE_OPERAND (*stmt_p, 1)))
	{
	stmt_p = TREE_OPERAND (stmt_p, 0);
	data->repeat = true;
	}

	/* If the body neither throws, nor branches, then we can safely
	string the TRY and FINALLY blocks together. */
	else if (!this_may_branch && !this_may_throw)
	{
	tree stmt = *stmt_p;
	*stmt_p = TREE_OPERAND (stmt, 0);
	append_to_statement_list (TREE_OPERAND (stmt, 1), stmt_p);
	data->repeat = true;
	}
	}


	static void
	remove_useless_stmts_tc (tree stmt_p, struct rus_data data)
	{
	bool save_may_throw, this_may_throw;
	tree_stmt_iterator i;
	tree stmt;

	/* Collect may_throw information for the body only. */
	save_may_throw = data->may_throw;
	data->may_throw = false;
	data->last_goto = NULL;

	remove_useless_stmts_1 (&TREE_OPERAND (*stmt_p, 0), data);

	this_may_throw = data->may_throw;
	data->may_throw = save_may_throw;

	/* If the body cannot throw, then we can drop the entire TRY_CATCH_EXPR. */
	if (!this_may_throw)
	{
	if (warn_notreached)
	remove_useless_stmts_warn_notreached (TREE_OPERAND (*stmt_p, 1));
	stmt_p = TREE_OPERAND (stmt_p, 0);
	data->repeat = true;
	return;
	}

	/* Process the catch clause specially. We may be able to tell that
	no exceptions propagate past this point. */

	this_may_throw = true;
	i = tsi_start (TREE_OPERAND (*stmt_p, 1));
	stmt = tsi_stmt (i);
	data->last_goto = NULL;

	switch (TREE_CODE (stmt))
	{
	case CATCH_EXPR:
	for (; !tsi_end_p (i); tsi_next (&i))
	{
	stmt = tsi_stmt (i);
	/* If we catch all exceptions, then the body does not
	propagate exceptions past this point. */
	if (CATCH_TYPES (stmt) == NULL)
	this_may_throw = false;
	data->last_goto = NULL;
	remove_useless_stmts_1 (&CATCH_BODY (stmt), data);
	}
	break;

	case EH_FILTER_EXPR:
	if (EH_FILTER_MUST_NOT_THROW (stmt))
	this_may_throw = false;
	else if (EH_FILTER_TYPES (stmt) == NULL)
	this_may_throw = false;
	remove_useless_stmts_1 (&EH_FILTER_FAILURE (stmt), data);
	break;

	default:
	/* Otherwise this is a cleanup. */
	remove_useless_stmts_1 (&TREE_OPERAND (*stmt_p, 1), data);

	/* If the cleanup is empty, then we can emit the TRY block without
	the enclosing TRY_CATCH_EXPR. */
	if (!TREE_SIDE_EFFECTS (TREE_OPERAND (*stmt_p, 1)))
	{
	stmt_p = TREE_OPERAND (stmt_p, 0);
	data->repeat = true;
	}
	break;
	}
	data->may_throw \|= this_may_throw;
	}


	static void
	remove_useless_stmts_bind (tree stmt_p, struct rus_data data)
	{
	tree block;

	/* First remove anything underneath the BIND_EXPR. */
	remove_useless_stmts_1 (&BIND_EXPR_BODY (*stmt_p), data);

	/* If the BIND_EXPR has no variables, then we can pull everything
	up one level and remove the BIND_EXPR, unless this is the toplevel
	BIND_EXPR for the current function or an inlined function.

	When this situation occurs we will want to apply this
	optimization again. */
	block = BIND_EXPR_BLOCK (*stmt_p);
	if (BIND_EXPR_VARS (*stmt_p) == NULL_TREE
	&& *stmt_p != DECL_SAVED_TREE (current_function_decl)
	&& (! block
	\|\| ! BLOCK_ABSTRACT_ORIGIN (block)
	\|\| (TREE_CODE (BLOCK_ABSTRACT_ORIGIN (block))
	!= FUNCTION_DECL)))
	{
	stmt_p = BIND_EXPR_BODY (stmt_p);
	data->repeat = true;
	}
	}


	static void
	remove_useless_stmts_goto (tree stmt_p, struct rus_data data)
	{
	tree dest = GOTO_DESTINATION (*stmt_p);

	data->may_branch = true;
	data->last_goto = NULL;

	/* Record the last goto expr, so that we can delete it if unnecessary. */
	if (TREE_CODE (dest) == LABEL_DECL)
	data->last_goto = stmt_p;
	}


	static void
	remove_useless_stmts_label (tree stmt_p, struct rus_data data)
	{
	tree label = LABEL_EXPR_LABEL (*stmt_p);

	data->has_label = true;

	/* We do want to jump across non-local label receiver code. */
	if (DECL_NONLOCAL (label))
	data->last_goto = NULL;

	else if (data->last_goto && GOTO_DESTINATION (*data->last_goto) == label)
	{
	*data->last_goto = build_empty_stmt ();
	data->repeat = true;
	}

	/* ??? Add something here to delete unused labels. */
	}


	/* If the function is "const" or "pure", then clear TREE_SIDE_EFFECTS on its
	decl. This allows us to eliminate redundant or useless
	calls to "const" functions.

	Gimplifier already does the same operation, but we may notice functions
	being const and pure once their calls has been gimplified, so we need
	to update the flag. */

	static void
	update_call_expr_flags (tree call)
	{
	tree decl = get_callee_fndecl (call);
	if (!decl)
	return;
	if (call_expr_flags (call) & (ECF_CONST \| ECF_PURE))
	TREE_SIDE_EFFECTS (call) = 0;
	if (TREE_NOTHROW (decl))
	TREE_NOTHROW (call) = 1;
	}


	/* T is CALL_EXPR. Set current_function_calls_* flags. */

	void
	notice_special_calls (tree t)
	{
	int flags = call_expr_flags (t);

	if (flags & ECF_MAY_BE_ALLOCA)
	current_function_calls_alloca = true;
	if (flags & ECF_RETURNS_TWICE)
	current_function_calls_setjmp = true;
	}


	/* Clear flags set by notice_special_calls. Used by dead code removal
	to update the flags. */

	void
	clear_special_calls (void)
	{
	current_function_calls_alloca = false;
	current_function_calls_setjmp = false;
	}


	static void
	remove_useless_stmts_1 (tree tp, struct rus_data data)
	{
	tree t = *tp, op;

	switch (TREE_CODE (t))
	{
	case COND_EXPR:
	remove_useless_stmts_cond (tp, data);
	break;

	case TRY_FINALLY_EXPR:
	remove_useless_stmts_tf (tp, data);
	break;

	case TRY_CATCH_EXPR:
	remove_useless_stmts_tc (tp, data);
	break;

	case BIND_EXPR:
	remove_useless_stmts_bind (tp, data);
	break;

	case GOTO_EXPR:
	remove_useless_stmts_goto (tp, data);
	break;

	case LABEL_EXPR:
	remove_useless_stmts_label (tp, data);
	break;

	case RETURN_EXPR:
	fold_stmt (tp);
	data->last_goto = NULL;
	data->may_branch = true;
	break;

	case CALL_EXPR:
	fold_stmt (tp);
	data->last_goto = NULL;
	notice_special_calls (t);
	update_call_expr_flags (t);
	if (tree_could_throw_p (t))
	data->may_throw = true;
	break;

	case MODIFY_EXPR:
	data->last_goto = NULL;
	fold_stmt (tp);
	op = get_call_expr_in (t);
	if (op)
	{
	update_call_expr_flags (op);
	notice_special_calls (op);
	}
	if (tree_could_throw_p (t))
	data->may_throw = true;
	break;

	case STATEMENT_LIST:
	{
	tree_stmt_iterator i = tsi_start (t);
	while (!tsi_end_p (i))
	{
	t = tsi_stmt (i);
	if (IS_EMPTY_STMT (t))
	{
	tsi_delink (&i);
	continue;
	}

	remove_useless_stmts_1 (tsi_stmt_ptr (i), data);

	t = tsi_stmt (i);
	if (TREE_CODE (t) == STATEMENT_LIST)
	{
	tsi_link_before (&i, t, TSI_SAME_STMT);
	tsi_delink (&i);
	}
	else
	tsi_next (&i);
	}
	}
	break;
	case ASM_EXPR:
	fold_stmt (tp);
	data->last_goto = NULL;
	break;

	default:
	data->last_goto = NULL;
	break;
	}
	}

	static unsigned int
	remove_useless_stmts (void)
	{
	struct rus_data data;

	clear_special_calls ();

	do
	{
	memset (&data, 0, sizeof (data));
	remove_useless_stmts_1 (&DECL_SAVED_TREE (current_function_decl), &data);
	}
	while (data.repeat);
	return 0;
	}


	struct tree_opt_pass pass_remove_useless_stmts =
	{
	"useless", /* name */
	NULL, /* gate */
	remove_useless_stmts, /* execute */
	NULL, /* sub */
	NULL, /* next */
	0, /* static_pass_number */
	0, /* tv_id */
	PROP_gimple_any, /* properties_required */
	0, /* properties_provided */
	0, /* properties_destroyed */
	0, /* todo_flags_start */
	TODO_dump_func, /* todo_flags_finish */
	0 /* letter */
	};

	/* Remove PHI nodes associated with basic block BB and all edges out of BB. */

	static void
	remove_phi_nodes_and_edges_for_unreachable_block (basic_block bb)
	{
	tree phi;

	/* Since this block is no longer reachable, we can just delete all
	of its PHI nodes. */
	phi = phi_nodes (bb);
	while (phi)
	{
	tree next = PHI_CHAIN (phi);
	remove_phi_node (phi, NULL_TREE);
	phi = next;
	}

	/* Remove edges to BB's successors. */
	while (EDGE_COUNT (bb->succs) > 0)
	remove_edge (EDGE_SUCC (bb, 0));
	}


	/* Remove statements of basic block BB. */

	static void
	remove_bb (basic_block bb)
	{
	block_stmt_iterator i;
	#ifdef USE_MAPPED_LOCATION
	source_location loc = UNKNOWN_LOCATION;
	#else
	source_locus loc = 0;
	#endif

	if (dump_file)
	{
	fprintf (dump_file, "Removing basic block %d\n", bb->index);
	if (dump_flags & TDF_DETAILS)
	{
	dump_bb (bb, dump_file, 0);
	fprintf (dump_file, "\n");
	}
	}

	/* If we remove the header or the latch of a loop, mark the loop for
	removal by setting its header and latch to NULL. */
	if (current_loops)
	{
	struct loop *loop = bb->loop_father;

	if (loop->latch == bb
	\|\| loop->header == bb)
	{
	loop->latch = NULL;
	loop->header = NULL;

	/* Also clean up the information associated with the loop. Updating
	it would waste time. More importantly, it may refer to ssa
	names that were defined in other removed basic block -- these
	ssa names are now removed and invalid. */
	free_numbers_of_iterations_estimates_loop (loop);
	}
	}

	/* Remove all the instructions in the block. */
	for (i = bsi_start (bb); !bsi_end_p (i);)
	{
	tree stmt = bsi_stmt (i);
	if (TREE_CODE (stmt) == LABEL_EXPR
	&& (FORCED_LABEL (LABEL_EXPR_LABEL (stmt))
	\|\| DECL_NONLOCAL (LABEL_EXPR_LABEL (stmt))))
	{
	basic_block new_bb;
	block_stmt_iterator new_bsi;

	/* A non-reachable non-local label may still be referenced.
	But it no longer needs to carry the extra semantics of
	non-locality. */
	if (DECL_NONLOCAL (LABEL_EXPR_LABEL (stmt)))
	{
	DECL_NONLOCAL (LABEL_EXPR_LABEL (stmt)) = 0;
	FORCED_LABEL (LABEL_EXPR_LABEL (stmt)) = 1;
	}

	new_bb = bb->prev_bb;
	new_bsi = bsi_start (new_bb);
	bsi_remove (&i, false);
	bsi_insert_before (&new_bsi, stmt, BSI_NEW_STMT);
	}
	else
	{
	/* Release SSA definitions if we are in SSA. Note that we
	may be called when not in SSA. For example,
	final_cleanup calls this function via
	cleanup_tree_cfg. */
	if (in_ssa_p)
	release_defs (stmt);

	bsi_remove (&i, true);
	}

	/* Don't warn for removed gotos. Gotos are often removed due to
	jump threading, thus resulting in bogus warnings. Not great,
	since this way we lose warnings for gotos in the original
	program that are indeed unreachable. */
	if (TREE_CODE (stmt) != GOTO_EXPR && EXPR_HAS_LOCATION (stmt) && !loc)
	{
	#ifdef USE_MAPPED_LOCATION
	if (EXPR_HAS_LOCATION (stmt))
	loc = EXPR_LOCATION (stmt);
	#else
	source_locus t;
	t = EXPR_LOCUS (stmt);
	if (t && LOCATION_LINE (*t) > 0)
	loc = t;
	#endif
	}
	}

	/* If requested, give a warning that the first statement in the
	block is unreachable. We walk statements backwards in the
	loop above, so the last statement we process is the first statement
	in the block. */
	#ifdef USE_MAPPED_LOCATION
	if (loc > BUILTINS_LOCATION)
	warning (OPT_Wunreachable_code, "%Hwill never be executed", &loc);
	#else
	if (loc)
	warning (OPT_Wunreachable_code, "%Hwill never be executed", loc);
	#endif

	remove_phi_nodes_and_edges_for_unreachable_block (bb);
	}


	/* Given a basic block BB ending with COND_EXPR or SWITCH_EXPR, and a
	predicate VAL, return the edge that will be taken out of the block.
	If VAL does not match a unique edge, NULL is returned. */

	edge
	find_taken_edge (basic_block bb, tree val)
	{
	tree stmt;

	stmt = last_stmt (bb);

	gcc_assert (stmt);
	gcc_assert (is_ctrl_stmt (stmt));
	gcc_assert (val);

	if (! is_gimple_min_invariant (val))
	return NULL;

	if (TREE_CODE (stmt) == COND_EXPR)
	return find_taken_edge_cond_expr (bb, val);

	if (TREE_CODE (stmt) == SWITCH_EXPR)
	return find_taken_edge_switch_expr (bb, val);

	if (computed_goto_p (stmt))
	{
	/* Only optimize if the argument is a label, if the argument is
	not a label then we can not construct a proper CFG.

	It may be the case that we only need to allow the LABEL_REF to
	appear inside an ADDR_EXPR, but we also allow the LABEL_REF to
	appear inside a LABEL_EXPR just to be safe. */
	if ((TREE_CODE (val) == ADDR_EXPR \|\| TREE_CODE (val) == LABEL_EXPR)
	&& TREE_CODE (TREE_OPERAND (val, 0)) == LABEL_DECL)
	return find_taken_edge_computed_goto (bb, TREE_OPERAND (val, 0));
	return NULL;
	}

	gcc_unreachable ();
	}

	/* Given a constant value VAL and the entry block BB to a GOTO_EXPR
	statement, determine which of the outgoing edges will be taken out of the
	block. Return NULL if either edge may be taken. */

	static edge
	find_taken_edge_computed_goto (basic_block bb, tree val)
	{
	basic_block dest;
	edge e = NULL;

	dest = label_to_block (val);
	if (dest)
	{
	e = find_edge (bb, dest);
	gcc_assert (e != NULL);
	}

	return e;
	}

	/* Given a constant value VAL and the entry block BB to a COND_EXPR
	statement, determine which of the two edges will be taken out of the
	block. Return NULL if either edge may be taken. */

	static edge
	find_taken_edge_cond_expr (basic_block bb, tree val)
	{
	edge true_edge, false_edge;

	extract_true_false_edges_from_block (bb, &true_edge, &false_edge);

	gcc_assert (TREE_CODE (val) == INTEGER_CST);
	return (zero_p (val) ? false_edge : true_edge);
	}

	/* Given an INTEGER_CST VAL and the entry block BB to a SWITCH_EXPR
	statement, determine which edge will be taken out of the block. Return
	NULL if any edge may be taken. */

	static edge
	find_taken_edge_switch_expr (basic_block bb, tree val)
	{
	tree switch_expr, taken_case;
	basic_block dest_bb;
	edge e;

	switch_expr = last_stmt (bb);
	taken_case = find_case_label_for_value (switch_expr, val);
	dest_bb = label_to_block (CASE_LABEL (taken_case));

	e = find_edge (bb, dest_bb);
	gcc_assert (e);
	return e;
	}


	/* Return the CASE_LABEL_EXPR that SWITCH_EXPR will take for VAL.
	We can make optimal use here of the fact that the case labels are
	sorted: We can do a binary search for a case matching VAL. */

	static tree
	find_case_label_for_value (tree switch_expr, tree val)
	{
	tree vec = SWITCH_LABELS (switch_expr);
	size_t low, high, n = TREE_VEC_LENGTH (vec);
	tree default_case = TREE_VEC_ELT (vec, n - 1);

	for (low = -1, high = n - 1; high - low > 1; )
	{
	size_t i = (high + low) / 2;
	tree t = TREE_VEC_ELT (vec, i);
	int cmp;

	/* Cache the result of comparing CASE_LOW and val. */
	cmp = tree_int_cst_compare (CASE_LOW (t), val);

	if (cmp > 0)
	high = i;
	else
	low = i;

	if (CASE_HIGH (t) == NULL)
	{
	/* A singe-valued case label. */
	if (cmp == 0)
	return t;
	}
	else
	{
	/* A case range. We can only handle integer ranges. */
	if (cmp <= 0 && tree_int_cst_compare (CASE_HIGH (t), val) >= 0)
	return t;
	}
	}

	return default_case;
	}




	/*---------------------------------------------------------------------------
	Debugging functions
	---------------------------------------------------------------------------*/

	/* Dump tree-specific information of block BB to file OUTF. */

	void
	tree_dump_bb (basic_block bb, FILE *outf, int indent)
	{
	dump_generic_bb (outf, bb, indent, TDF_VOPS);
	}


	/* Dump a basic block on stderr. */

	void
	debug_tree_bb (basic_block bb)
	{
	dump_bb (bb, stderr, 0);
	}


	/* Dump basic block with index N on stderr. */

	basic_block
	debug_tree_bb_n (int n)
	{
	debug_tree_bb (BASIC_BLOCK (n));
	return BASIC_BLOCK (n);
	}


	/* Dump the CFG on stderr.

	FLAGS are the same used by the tree dumping functions
	(see TDF_* in tree-pass.h). */

	void
	debug_tree_cfg (int flags)
	{
	dump_tree_cfg (stderr, flags);
	}


	/* Dump the program showing basic block boundaries on the given FILE.

	FLAGS are the same used by the tree dumping functions (see TDF_* in
	tree.h). */

	void
	dump_tree_cfg (FILE *file, int flags)
	{
	if (flags & TDF_DETAILS)
	{
	const char *funcname
	= lang_hooks.decl_printable_name (current_function_decl, 2);

	fputc ('\n', file);
	fprintf (file, ";; Function %s\n\n", funcname);
	fprintf (file, ";; \n%d basic blocks, %d edges, last basic block %d.\n\n",
	n_basic_blocks, n_edges, last_basic_block);

	brief_dump_cfg (file);
	fprintf (file, "\n");
	}

	if (flags & TDF_STATS)
	dump_cfg_stats (file);

	dump_function_to_file (current_function_decl, file, flags \| TDF_BLOCKS);
	}


	/* Dump CFG statistics on FILE. */

	void
	dump_cfg_stats (FILE *file)
	{
	static long max_num_merged_labels = 0;
	unsigned long size, total = 0;
	long num_edges;
	basic_block bb;
	const char * const fmt_str = "%-30s%-13s%12s\n";
	const char * const fmt_str_1 = "%-30s%13d%11lu%c\n";
	const char * const fmt_str_2 = "%-30s%13ld%11lu%c\n";
	const char * const fmt_str_3 = "%-43s%11lu%c\n";
	const char *funcname
	= lang_hooks.decl_printable_name (current_function_decl, 2);


	fprintf (file, "\nCFG Statistics for %s\n\n", funcname);

	fprintf (file, "---------------------------------------------------------\n");
	fprintf (file, fmt_str, "", " Number of ", "Memory");
	fprintf (file, fmt_str, "", " instances ", "used ");
	fprintf (file, "---------------------------------------------------------\n");

	size = n_basic_blocks * sizeof (struct basic_block_def);
	total += size;
	fprintf (file, fmt_str_1, "Basic blocks", n_basic_blocks,
	SCALE (size), LABEL (size));

	num_edges = 0;
	FOR_EACH_BB (bb)
	num_edges += EDGE_COUNT (bb->succs);
	size = num_edges * sizeof (struct edge_def);
	total += size;
	fprintf (file, fmt_str_2, "Edges", num_edges, SCALE (size), LABEL (size));

	fprintf (file, "---------------------------------------------------------\n");
	fprintf (file, fmt_str_3, "Total memory used by CFG data", SCALE (total),
	LABEL (total));
	fprintf (file, "---------------------------------------------------------\n");
	fprintf (file, "\n");

	if (cfg_stats.num_merged_labels > max_num_merged_labels)
	max_num_merged_labels = cfg_stats.num_merged_labels;

	fprintf (file, "Coalesced label blocks: %ld (Max so far: %ld)\n",
	cfg_stats.num_merged_labels, max_num_merged_labels);

	fprintf (file, "\n");
	}


	/* Dump CFG statistics on stderr. Keep extern so that it's always
	linked in the final executable. */

	void
	debug_cfg_stats (void)
	{
	dump_cfg_stats (stderr);
	}


	/* Dump the flowgraph to a .vcg FILE. */

	static void
	tree_cfg2vcg (FILE *file)
	{
	edge e;
	edge_iterator ei;
	basic_block bb;
	const char *funcname
	= lang_hooks.decl_printable_name (current_function_decl, 2);

	/* Write the file header. */
	fprintf (file, "graph: { title: \"%s\"\n", funcname);
	fprintf (file, "node: { title: \"ENTRY\" label: \"ENTRY\" }\n");
	fprintf (file, "node: { title: \"EXIT\" label: \"EXIT\" }\n");

	/* Write blocks and edges. */
	FOR_EACH_EDGE (e, ei, ENTRY_BLOCK_PTR->succs)
	{
	fprintf (file, "edge: { sourcename: \"ENTRY\" targetname: \"%d\"",
	e->dest->index);

	if (e->flags & EDGE_FAKE)
	fprintf (file, " linestyle: dotted priority: 10");
	else
	fprintf (file, " linestyle: solid priority: 100");

	fprintf (file, " }\n");
	}
	fputc ('\n', file);

	FOR_EACH_BB (bb)
	{
	enum tree_code head_code, end_code;
	const char head_name, end_name;
	int head_line = 0;
	int end_line = 0;
	tree first = first_stmt (bb);
	tree last = last_stmt (bb);

	if (first)
	{
	head_code = TREE_CODE (first);
	head_name = tree_code_name[head_code];
	head_line = get_lineno (first);
	}
	else
	head_name = "no-statement";

	if (last)
	{
	end_code = TREE_CODE (last);
	end_name = tree_code_name[end_code];
	end_line = get_lineno (last);
	}
	else
	end_name = "no-statement";

	fprintf (file, "node: { title: \"%d\" label: \"#%d\\n%s (%d)\\n%s (%d)\"}\n",
	bb->index, bb->index, head_name, head_line, end_name,
	end_line);

	FOR_EACH_EDGE (e, ei, bb->succs)
	{
	if (e->dest == EXIT_BLOCK_PTR)
	fprintf (file, "edge: { sourcename: \"%d\" targetname: \"EXIT\"", bb->index);
	else
	fprintf (file, "edge: { sourcename: \"%d\" targetname: \"%d\"", bb->index, e->dest->index);

	if (e->flags & EDGE_FAKE)
	fprintf (file, " priority: 10 linestyle: dotted");
	else
	fprintf (file, " priority: 100 linestyle: solid");

	fprintf (file, " }\n");
	}

	if (bb->next_bb != EXIT_BLOCK_PTR)
	fputc ('\n', file);
	}

	fputs ("}\n\n", file);
	}



	/*---------------------------------------------------------------------------
	Miscellaneous helpers
	---------------------------------------------------------------------------*/

	/* Return true if T represents a stmt that always transfers control. */

	bool
	is_ctrl_stmt (tree t)
	{
	return (TREE_CODE (t) == COND_EXPR
	\|\| TREE_CODE (t) == SWITCH_EXPR
	\|\| TREE_CODE (t) == GOTO_EXPR
	\|\| TREE_CODE (t) == RETURN_EXPR
	\|\| TREE_CODE (t) == RESX_EXPR);
	}


	/* Return true if T is a statement that may alter the flow of control
	(e.g., a call to a non-returning function). */

	bool
	is_ctrl_altering_stmt (tree t)
	{
	tree call;

	gcc_assert (t);
	call = get_call_expr_in (t);
	if (call)
	{
	/* A non-pure/const CALL_EXPR alters flow control if the current
	function has nonlocal labels. */
	if (TREE_SIDE_EFFECTS (call) && current_function_has_nonlocal_label)
	return true;

	/* A CALL_EXPR also alters control flow if it does not return. */
	if (call_expr_flags (call) & ECF_NORETURN)
	return true;
	}

	/* OpenMP directives alter control flow. */
	if (OMP_DIRECTIVE_P (t))
	return true;

	/* If a statement can throw, it alters control flow. */
	return tree_can_throw_internal (t);
	}


	/* Return true if T is a computed goto. */

	bool
	computed_goto_p (tree t)
	{
	return (TREE_CODE (t) == GOTO_EXPR
	&& TREE_CODE (GOTO_DESTINATION (t)) != LABEL_DECL);
	}


	/* Return true if T is a simple local goto. */

	bool
	simple_goto_p (tree t)
	{
	return (TREE_CODE (t) == GOTO_EXPR
	&& TREE_CODE (GOTO_DESTINATION (t)) == LABEL_DECL);
	}


	/* Return true if T can make an abnormal transfer of control flow.
	Transfers of control flow associated with EH are excluded. */

	bool
	tree_can_make_abnormal_goto (tree t)
	{
	if (computed_goto_p (t))
	return true;
	if (TREE_CODE (t) == MODIFY_EXPR)
	t = TREE_OPERAND (t, 1);
	if (TREE_CODE (t) == WITH_SIZE_EXPR)
	t = TREE_OPERAND (t, 0);
	if (TREE_CODE (t) == CALL_EXPR)
	return TREE_SIDE_EFFECTS (t) && current_function_has_nonlocal_label;
	return false;
	}


	/* Return true if T should start a new basic block. PREV_T is the
	statement preceding T. It is used when T is a label or a case label.
	Labels should only start a new basic block if their previous statement
	wasn't a label. Otherwise, sequence of labels would generate
	unnecessary basic blocks that only contain a single label. */

	static inline bool
	stmt_starts_bb_p (tree t, tree prev_t)
	{
	if (t == NULL_TREE)
	return false;

	/* LABEL_EXPRs start a new basic block only if the preceding
	statement wasn't a label of the same type. This prevents the
	creation of consecutive blocks that have nothing but a single
	label. */
	if (TREE_CODE (t) == LABEL_EXPR)
	{
	/* Nonlocal and computed GOTO targets always start a new block. */
	if (DECL_NONLOCAL (LABEL_EXPR_LABEL (t))
	\|\| FORCED_LABEL (LABEL_EXPR_LABEL (t)))
	return true;

	if (prev_t && TREE_CODE (prev_t) == LABEL_EXPR)
	{
	if (DECL_NONLOCAL (LABEL_EXPR_LABEL (prev_t)))
	return true;

	cfg_stats.num_merged_labels++;
	return false;
	}
	else
	return true;
	}

	return false;
	}


	/* Return true if T should end a basic block. */

	bool
	stmt_ends_bb_p (tree t)
	{
	return is_ctrl_stmt (t) \|\| is_ctrl_altering_stmt (t);
	}


	/* Add gotos that used to be represented implicitly in the CFG. */

	void
	disband_implicit_edges (void)
	{
	basic_block bb;
	block_stmt_iterator last;
	edge e;
	edge_iterator ei;
	tree stmt, label;

	FOR_EACH_BB (bb)
	{
	last = bsi_last (bb);
	stmt = last_stmt (bb);

	if (stmt && TREE_CODE (stmt) == COND_EXPR)
	{
	/* Remove superfluous gotos from COND_EXPR branches. Moved
	from cfg_remove_useless_stmts here since it violates the
	invariants for tree--cfg correspondence and thus fits better
	here where we do it anyway. */
	e = find_edge (bb, bb->next_bb);
	if (e)
	{
	if (e->flags & EDGE_TRUE_VALUE)
	COND_EXPR_THEN (stmt) = build_empty_stmt ();
	else if (e->flags & EDGE_FALSE_VALUE)
	COND_EXPR_ELSE (stmt) = build_empty_stmt ();
	else
	gcc_unreachable ();
	e->flags \|= EDGE_FALLTHRU;
	}

	continue;
	}

	if (stmt && TREE_CODE (stmt) == RETURN_EXPR)
	{
	/* Remove the RETURN_EXPR if we may fall though to the exit
	instead. */
	gcc_assert (single_succ_p (bb));
	gcc_assert (single_succ (bb) == EXIT_BLOCK_PTR);

	if (bb->next_bb == EXIT_BLOCK_PTR
	&& !TREE_OPERAND (stmt, 0))
	{
	bsi_remove (&last, true);
	single_succ_edge (bb)->flags \|= EDGE_FALLTHRU;
	}
	continue;
	}

	/* There can be no fallthru edge if the last statement is a control
	one. */
	if (stmt && is_ctrl_stmt (stmt))
	continue;

	/* Find a fallthru edge and emit the goto if necessary. */
	FOR_EACH_EDGE (e, ei, bb->succs)
	if (e->flags & EDGE_FALLTHRU)
	break;

	if (!e \|\| e->dest == bb->next_bb)
	continue;

	gcc_assert (e->dest != EXIT_BLOCK_PTR);
	label = tree_block_label (e->dest);

	stmt = build1 (GOTO_EXPR, void_type_node, label);
	#ifdef USE_MAPPED_LOCATION
	SET_EXPR_LOCATION (stmt, e->goto_locus);
	#else
	SET_EXPR_LOCUS (stmt, e->goto_locus);
	#endif
	bsi_insert_after (&last, stmt, BSI_NEW_STMT);
	e->flags &= ~EDGE_FALLTHRU;
	}
	}

	/* Remove block annotations and other datastructures. */

	void
	delete_tree_cfg_annotations (void)
	{
	label_to_block_map = NULL;
	}


	/* Return the first statement in basic block BB. */

	tree
	first_stmt (basic_block bb)
	{
	block_stmt_iterator i = bsi_start (bb);
	return !bsi_end_p (i) ? bsi_stmt (i) : NULL_TREE;
	}


	/* Return the last statement in basic block BB. */

	tree
	last_stmt (basic_block bb)
	{
	block_stmt_iterator b = bsi_last (bb);
	return !bsi_end_p (b) ? bsi_stmt (b) : NULL_TREE;
	}


	/* Return a pointer to the last statement in block BB. */

	tree *
	last_stmt_ptr (basic_block bb)
	{
	block_stmt_iterator last = bsi_last (bb);
	return !bsi_end_p (last) ? bsi_stmt_ptr (last) : NULL;
	}


	/* Return the last statement of an otherwise empty block. Return NULL
	if the block is totally empty, or if it contains more than one
	statement. */

	tree
	last_and_only_stmt (basic_block bb)
	{
	block_stmt_iterator i = bsi_last (bb);
	tree last, prev;

	if (bsi_end_p (i))
	return NULL_TREE;

	last = bsi_stmt (i);
	bsi_prev (&i);
	if (bsi_end_p (i))
	return last;

	/* Empty statements should no longer appear in the instruction stream.
	Everything that might have appeared before should be deleted by
	remove_useless_stmts, and the optimizers should just bsi_remove
	instead of smashing with build_empty_stmt.

	Thus the only thing that should appear here in a block containing
	one executable statement is a label. */
	prev = bsi_stmt (i);
	if (TREE_CODE (prev) == LABEL_EXPR)
	return last;
	else
	return NULL_TREE;
	}


	/* Mark BB as the basic block holding statement T. */

	void
	set_bb_for_stmt (tree t, basic_block bb)
	{
	if (TREE_CODE (t) == PHI_NODE)
	PHI_BB (t) = bb;
	else if (TREE_CODE (t) == STATEMENT_LIST)
	{
	tree_stmt_iterator i;
	for (i = tsi_start (t); !tsi_end_p (i); tsi_next (&i))
	set_bb_for_stmt (tsi_stmt (i), bb);
	}
	else
	{
	stmt_ann_t ann = get_stmt_ann (t);
	ann->bb = bb;

	/* If the statement is a label, add the label to block-to-labels map
	so that we can speed up edge creation for GOTO_EXPRs. */
	if (TREE_CODE (t) == LABEL_EXPR)
	{
	int uid;

	t = LABEL_EXPR_LABEL (t);
	uid = LABEL_DECL_UID (t);
	if (uid == -1)
	{
	unsigned old_len = VEC_length (basic_block, label_to_block_map);
	LABEL_DECL_UID (t) = uid = cfun->last_label_uid++;
	if (old_len <= (unsigned) uid)
	{
	basic_block *addr;
	unsigned new_len = 3 * uid / 2;

	VEC_safe_grow (basic_block, gc, label_to_block_map,
	new_len);
	addr = VEC_address (basic_block, label_to_block_map);
	memset (&addr[old_len],
	0, sizeof (basic_block) * (new_len - old_len));
	}
	}
	else
	/* We're moving an existing label. Make sure that we've
	removed it from the old block. */
	gcc_assert (!bb
	\|\| !VEC_index (basic_block, label_to_block_map, uid));
	VEC_replace (basic_block, label_to_block_map, uid, bb);
	}
	}
	}

	/* Faster version of set_bb_for_stmt that assume that statement is being moved
	from one basic block to another.
	For BB splitting we can run into quadratic case, so performance is quite
	important and knowing that the tables are big enough, change_bb_for_stmt
	can inline as leaf function. */
	static inline void
	change_bb_for_stmt (tree t, basic_block bb)
	{
	get_stmt_ann (t)->bb = bb;
	if (TREE_CODE (t) == LABEL_EXPR)
	VEC_replace (basic_block, label_to_block_map,
	LABEL_DECL_UID (LABEL_EXPR_LABEL (t)), bb);
	}

	/* Finds iterator for STMT. */

	extern block_stmt_iterator
	bsi_for_stmt (tree stmt)
	{
	block_stmt_iterator bsi;

	for (bsi = bsi_start (bb_for_stmt (stmt)); !bsi_end_p (bsi); bsi_next (&bsi))
	if (bsi_stmt (bsi) == stmt)
	return bsi;

	gcc_unreachable ();
	}

	/* Mark statement T as modified, and update it. */
	static inline void
	update_modified_stmts (tree t)
	{
	if (TREE_CODE (t) == STATEMENT_LIST)
	{
	tree_stmt_iterator i;
	tree stmt;
	for (i = tsi_start (t); !tsi_end_p (i); tsi_next (&i))
	{
	stmt = tsi_stmt (i);
	update_stmt_if_modified (stmt);
	}
	}
	else
	update_stmt_if_modified (t);
	}

	/* Insert statement (or statement list) T before the statement
	pointed-to by iterator I. M specifies how to update iterator I
	after insertion (see enum bsi_iterator_update). */

	void
	bsi_insert_before (block_stmt_iterator *i, tree t, enum bsi_iterator_update m)
	{
	set_bb_for_stmt (t, i->bb);
	update_modified_stmts (t);
	tsi_link_before (&i->tsi, t, (enum tsi_iterator_update) m);
	}


	/* Insert statement (or statement list) T after the statement
	pointed-to by iterator I. M specifies how to update iterator I
	after insertion (see enum bsi_iterator_update). */

	void
	bsi_insert_after (block_stmt_iterator *i, tree t, enum bsi_iterator_update m)
	{
	set_bb_for_stmt (t, i->bb);
	update_modified_stmts (t);
	tsi_link_after (&i->tsi, t, (enum tsi_iterator_update) m);
	}


	/* Remove the statement pointed to by iterator I. The iterator is updated
	to the next statement.

	When REMOVE_EH_INFO is true we remove the statement pointed to by
	iterator I from the EH tables. Otherwise we do not modify the EH
	tables.

	Generally, REMOVE_EH_INFO should be true when the statement is going to
	be removed from the IL and not reinserted elsewhere. */

	void
	bsi_remove (block_stmt_iterator *i, bool remove_eh_info)
	{
	tree t = bsi_stmt (*i);
	set_bb_for_stmt (t, NULL);
	delink_stmt_imm_use (t);
	tsi_delink (&i->tsi);
	mark_stmt_modified (t);
	if (remove_eh_info)
	remove_stmt_from_eh_region (t);
	}


	/* Move the statement at FROM so it comes right after the statement at TO. */

	void
	bsi_move_after (block_stmt_iterator from, block_stmt_iterator to)
	{
	tree stmt = bsi_stmt (*from);
	bsi_remove (from, false);
	bsi_insert_after (to, stmt, BSI_SAME_STMT);
	}


	/* Move the statement at FROM so it comes right before the statement at TO. */

	void
	bsi_move_before (block_stmt_iterator from, block_stmt_iterator to)
	{
	tree stmt = bsi_stmt (*from);
	bsi_remove (from, false);
	bsi_insert_before (to, stmt, BSI_SAME_STMT);
	}


	/* Move the statement at FROM to the end of basic block BB. */

	void
	bsi_move_to_bb_end (block_stmt_iterator *from, basic_block bb)
	{
	block_stmt_iterator last = bsi_last (bb);

	/* Have to check bsi_end_p because it could be an empty block. */
	if (!bsi_end_p (last) && is_ctrl_stmt (bsi_stmt (last)))
	bsi_move_before (from, &last);
	else
	bsi_move_after (from, &last);
	}


	/* Replace the contents of the statement pointed to by iterator BSI
	with STMT. If UPDATE_EH_INFO is true, the exception handling
	information of the original statement is moved to the new statement. */

	void
	bsi_replace (const block_stmt_iterator *bsi, tree stmt, bool update_eh_info)
	{
	int eh_region;
	tree orig_stmt = bsi_stmt (*bsi);

	SET_EXPR_LOCUS (stmt, EXPR_LOCUS (orig_stmt));
	set_bb_for_stmt (stmt, bsi->bb);

	/* Preserve EH region information from the original statement, if
	requested by the caller. */
	if (update_eh_info)
	{
	eh_region = lookup_stmt_eh_region (orig_stmt);
	if (eh_region >= 0)
	{
	remove_stmt_from_eh_region (orig_stmt);
	add_stmt_to_eh_region (stmt, eh_region);
	}
	}

	delink_stmt_imm_use (orig_stmt);
	bsi_stmt_ptr (bsi) = stmt;
	mark_stmt_modified (stmt);
	update_modified_stmts (stmt);
	}


	/* Insert the statement pointed-to by BSI into edge E. Every attempt
	is made to place the statement in an existing basic block, but
	sometimes that isn't possible. When it isn't possible, the edge is
	split and the statement is added to the new block.

	In all cases, the returned *BSI points to the correct location. The
	return value is true if insertion should be done after the location,
	or false if it should be done before the location. If new basic block
	has to be created, it is stored in NEW_BB. /

	static bool
	tree_find_edge_insert_loc (edge e, block_stmt_iterator *bsi,
	basic_block *new_bb)
	{
	basic_block dest, src;
	tree tmp;

	dest = e->dest;
	restart:

	/* If the destination has one predecessor which has no PHI nodes,
	insert there. Except for the exit block.

	The requirement for no PHI nodes could be relaxed. Basically we
	would have to examine the PHIs to prove that none of them used
	the value set by the statement we want to insert on E. That
	hardly seems worth the effort. */
	if (single_pred_p (dest)
	&& ! phi_nodes (dest)
	&& dest != EXIT_BLOCK_PTR)
	{
	*bsi = bsi_start (dest);
	if (bsi_end_p (*bsi))
	return true;

	/* Make sure we insert after any leading labels. */
	tmp = bsi_stmt (*bsi);
	while (TREE_CODE (tmp) == LABEL_EXPR)
	{
	bsi_next (bsi);
	if (bsi_end_p (*bsi))
	break;
	tmp = bsi_stmt (*bsi);
	}

	if (bsi_end_p (*bsi))
	{
	*bsi = bsi_last (dest);
	return true;
	}
	else
	return false;
	}

	/* If the source has one successor, the edge is not abnormal and
	the last statement does not end a basic block, insert there.
	Except for the entry block. */
	src = e->src;
	if ((e->flags & EDGE_ABNORMAL) == 0
	&& single_succ_p (src)
	&& src != ENTRY_BLOCK_PTR)
	{
	*bsi = bsi_last (src);
	if (bsi_end_p (*bsi))
	return true;

	tmp = bsi_stmt (*bsi);
	if (!stmt_ends_bb_p (tmp))
	return true;

	/* Insert code just before returning the value. We may need to decompose
	the return in the case it contains non-trivial operand. */
	if (TREE_CODE (tmp) == RETURN_EXPR)
	{
	tree op = TREE_OPERAND (tmp, 0);
	if (op && !is_gimple_val (op))
	{
	gcc_assert (TREE_CODE (op) == MODIFY_EXPR);
	bsi_insert_before (bsi, op, BSI_NEW_STMT);
	TREE_OPERAND (tmp, 0) = TREE_OPERAND (op, 0);
	}
	bsi_prev (bsi);
	return true;
	}
	}

	/* Otherwise, create a new basic block, and split this edge. */
	dest = split_edge (e);
	if (new_bb)
	*new_bb = dest;
	e = single_pred_edge (dest);
	goto restart;
	}


	/* This routine will commit all pending edge insertions, creating any new
	basic blocks which are necessary. */

	void
	bsi_commit_edge_inserts (void)
	{
	basic_block bb;
	edge e;
	edge_iterator ei;

	bsi_commit_one_edge_insert (single_succ_edge (ENTRY_BLOCK_PTR), NULL);

	FOR_EACH_BB (bb)
	FOR_EACH_EDGE (e, ei, bb->succs)
	bsi_commit_one_edge_insert (e, NULL);
	}


	/* Commit insertions pending at edge E. If a new block is created, set NEW_BB
	to this block, otherwise set it to NULL. */

	void
	bsi_commit_one_edge_insert (edge e, basic_block *new_bb)
	{
	if (new_bb)
	*new_bb = NULL;
	if (PENDING_STMT (e))
	{
	block_stmt_iterator bsi;
	tree stmt = PENDING_STMT (e);

	PENDING_STMT (e) = NULL_TREE;

	if (tree_find_edge_insert_loc (e, &bsi, new_bb))
	bsi_insert_after (&bsi, stmt, BSI_NEW_STMT);
	else
	bsi_insert_before (&bsi, stmt, BSI_NEW_STMT);
	}
	}


	/* Add STMT to the pending list of edge E. No actual insertion is
	made until a call to bsi_commit_edge_inserts () is made. */

	void
	bsi_insert_on_edge (edge e, tree stmt)
	{
	append_to_statement_list (stmt, &PENDING_STMT (e));
	}

	/* Similar to bsi_insert_on_edge+bsi_commit_edge_inserts. If a new
	block has to be created, it is returned. */

	basic_block
	bsi_insert_on_edge_immediate (edge e, tree stmt)
	{
	block_stmt_iterator bsi;
	basic_block new_bb = NULL;

	gcc_assert (!PENDING_STMT (e));

	if (tree_find_edge_insert_loc (e, &bsi, &new_bb))
	bsi_insert_after (&bsi, stmt, BSI_NEW_STMT);
	else
	bsi_insert_before (&bsi, stmt, BSI_NEW_STMT);

	return new_bb;
	}

	/*---------------------------------------------------------------------------
	Tree specific functions for CFG manipulation
	---------------------------------------------------------------------------*/

	/* Reinstall those PHI arguments queued in OLD_EDGE to NEW_EDGE. */

	static void
	reinstall_phi_args (edge new_edge, edge old_edge)
	{
	tree var, phi;

	if (!PENDING_STMT (old_edge))
	return;

	for (var = PENDING_STMT (old_edge), phi = phi_nodes (new_edge->dest);
	var && phi;
	var = TREE_CHAIN (var), phi = PHI_CHAIN (phi))
	{
	tree result = TREE_PURPOSE (var);
	tree arg = TREE_VALUE (var);

	gcc_assert (result == PHI_RESULT (phi));

	add_phi_arg (phi, arg, new_edge);
	}

	PENDING_STMT (old_edge) = NULL;
	}

	/* Returns the basic block after which the new basic block created
	by splitting edge EDGE_IN should be placed. Tries to keep the new block
	near its "logical" location. This is of most help to humans looking
	at debugging dumps. */

	static basic_block
	split_edge_bb_loc (edge edge_in)
	{
	basic_block dest = edge_in->dest;

	if (dest->prev_bb && find_edge (dest->prev_bb, dest))
	return edge_in->src;
	else
	return dest->prev_bb;
	}

	/* Split a (typically critical) edge EDGE_IN. Return the new block.
	Abort on abnormal edges. */

	static basic_block
	tree_split_edge (edge edge_in)
	{
	basic_block new_bb, after_bb, dest;
	edge new_edge, e;

	/* Abnormal edges cannot be split. */
	gcc_assert (!(edge_in->flags & EDGE_ABNORMAL));

	dest = edge_in->dest;

	after_bb = split_edge_bb_loc (edge_in);

	new_bb = create_empty_bb (after_bb);
	new_bb->frequency = EDGE_FREQUENCY (edge_in);
	new_bb->count = edge_in->count;
	new_edge = make_edge (new_bb, dest, EDGE_FALLTHRU);
	new_edge->probability = REG_BR_PROB_BASE;
	new_edge->count = edge_in->count;

	e = redirect_edge_and_branch (edge_in, new_bb);
	gcc_assert (e);
	reinstall_phi_args (new_edge, e);

	return new_bb;
	}


	/* Return true when BB has label LABEL in it. */

	static bool
	has_label_p (basic_block bb, tree label)
	{
	block_stmt_iterator bsi;

	for (bsi = bsi_start (bb); !bsi_end_p (bsi); bsi_next (&bsi))
	{
	tree stmt = bsi_stmt (bsi);

	if (TREE_CODE (stmt) != LABEL_EXPR)
	return false;
	if (LABEL_EXPR_LABEL (stmt) == label)
	return true;
	}
	return false;
	}


	/* Callback for walk_tree, check that all elements with address taken are
	properly noticed as such. The DATA is an int* that is 1 if TP was seen
	inside a PHI node. */

	static tree
	verify_expr (tree tp, int walk_subtrees, void *data ATTRIBUTE_UNUSED)
	{
	tree t = *tp, x;
	bool in_phi = (data != NULL);

	if (TYPE_P (t))
	*walk_subtrees = 0;

	/* Check operand N for being valid GIMPLE and give error MSG if not. */
	#define CHECK_OP(N, MSG) \
	do { if (!is_gimple_val (TREE_OPERAND (t, N))) \
	{ error (MSG); return TREE_OPERAND (t, N); }} while (0)

	switch (TREE_CODE (t))
	{
	case SSA_NAME:
	if (SSA_NAME_IN_FREE_LIST (t))
	{
	error ("SSA name in freelist but still referenced");
	return *tp;
	}
	break;

	case ASSERT_EXPR:
	x = fold (ASSERT_EXPR_COND (t));
	if (x == boolean_false_node)
	{
	error ("ASSERT_EXPR with an always-false condition");
	return *tp;
	}
	break;

	case MODIFY_EXPR:
	x = TREE_OPERAND (t, 0);
	if (TREE_CODE (x) == BIT_FIELD_REF
	&& is_gimple_reg (TREE_OPERAND (x, 0)))
	{
	error ("GIMPLE register modified with BIT_FIELD_REF");
	return t;
	}
	break;

	case ADDR_EXPR:
	{
	bool old_invariant;
	bool old_constant;
	bool old_side_effects;
	bool new_invariant;
	bool new_constant;
	bool new_side_effects;

	/* ??? tree-ssa-alias.c may have overlooked dead PHI nodes, missing
	dead PHIs that take the address of something. But if the PHI
	result is dead, the fact that it takes the address of anything
	is irrelevant. Because we can not tell from here if a PHI result
	is dead, we just skip this check for PHIs altogether. This means
	we may be missing "valid" checks, but what can you do?
	This was PR19217. */
	if (in_phi)
	break;

	old_invariant = TREE_INVARIANT (t);
	old_constant = TREE_CONSTANT (t);
	old_side_effects = TREE_SIDE_EFFECTS (t);

	recompute_tree_invariant_for_addr_expr (t);
	new_invariant = TREE_INVARIANT (t);
	new_side_effects = TREE_SIDE_EFFECTS (t);
	new_constant = TREE_CONSTANT (t);

	if (old_invariant != new_invariant)
	{
	error ("invariant not recomputed when ADDR_EXPR changed");
	return t;
	}

	if (old_constant != new_constant)
	{
	error ("constant not recomputed when ADDR_EXPR changed");
	return t;
	}
	if (old_side_effects != new_side_effects)
	{
	error ("side effects not recomputed when ADDR_EXPR changed");
	return t;
	}

	/* Skip any references (they will be checked when we recurse down the
	tree) and ensure that any variable used as a prefix is marked
	addressable. */
	for (x = TREE_OPERAND (t, 0);
	handled_component_p (x);
	x = TREE_OPERAND (x, 0))
	;

	if (TREE_CODE (x) != VAR_DECL && TREE_CODE (x) != PARM_DECL)
	return NULL;
	if (!TREE_ADDRESSABLE (x))
	{
	error ("address taken, but ADDRESSABLE bit not set");
	return x;
	}
	break;
	}

	case COND_EXPR:
	x = COND_EXPR_COND (t);
	if (TREE_CODE (TREE_TYPE (x)) != BOOLEAN_TYPE)
	{
	error ("non-boolean used in condition");
	return x;
	}
	if (!is_gimple_condexpr (x))
	{
	error ("invalid conditional operand");
	return x;
	}
	break;

	case NOP_EXPR:
	case CONVERT_EXPR:
	case FIX_TRUNC_EXPR:
	case FIX_CEIL_EXPR:
	case FIX_FLOOR_EXPR:
	case FIX_ROUND_EXPR:
	case FLOAT_EXPR:
	case NEGATE_EXPR:
	case ABS_EXPR:
	case BIT_NOT_EXPR:
	case NON_LVALUE_EXPR:
	case TRUTH_NOT_EXPR:
	CHECK_OP (0, "invalid operand to unary operator");
	break;

	case REALPART_EXPR:
	case IMAGPART_EXPR:
	case COMPONENT_REF:
	case ARRAY_REF:
	case ARRAY_RANGE_REF:
	case BIT_FIELD_REF:
	case VIEW_CONVERT_EXPR:
	/* We have a nest of references. Verify that each of the operands
	that determine where to reference is either a constant or a variable,
	verify that the base is valid, and then show we've already checked
	the subtrees. */
	while (handled_component_p (t))
	{
	if (TREE_CODE (t) == COMPONENT_REF && TREE_OPERAND (t, 2))
	CHECK_OP (2, "invalid COMPONENT_REF offset operator");
	else if (TREE_CODE (t) == ARRAY_REF
	\|\| TREE_CODE (t) == ARRAY_RANGE_REF)
	{
	CHECK_OP (1, "invalid array index");
	if (TREE_OPERAND (t, 2))
	CHECK_OP (2, "invalid array lower bound");
	if (TREE_OPERAND (t, 3))
	CHECK_OP (3, "invalid array stride");
	}
	else if (TREE_CODE (t) == BIT_FIELD_REF)
	{
	CHECK_OP (1, "invalid operand to BIT_FIELD_REF");
	CHECK_OP (2, "invalid operand to BIT_FIELD_REF");
	}

	t = TREE_OPERAND (t, 0);
	}

	if (!CONSTANT_CLASS_P (t) && !is_gimple_lvalue (t))
	{
	error ("invalid reference prefix");
	return t;
	}
	*walk_subtrees = 0;
	break;

	case LT_EXPR:
	case LE_EXPR:
	case GT_EXPR:
	case GE_EXPR:
	case EQ_EXPR:
	case NE_EXPR:
	case UNORDERED_EXPR:
	case ORDERED_EXPR:
	case UNLT_EXPR:
	case UNLE_EXPR:
	case UNGT_EXPR:
	case UNGE_EXPR:
	case UNEQ_EXPR:
	case LTGT_EXPR:
	case PLUS_EXPR:
	case MINUS_EXPR:
	case MULT_EXPR:
	case TRUNC_DIV_EXPR:
	case CEIL_DIV_EXPR:
	case FLOOR_DIV_EXPR:
	case ROUND_DIV_EXPR:
	case TRUNC_MOD_EXPR:
	case CEIL_MOD_EXPR:
	case FLOOR_MOD_EXPR:
	case ROUND_MOD_EXPR:
	case RDIV_EXPR:
	case EXACT_DIV_EXPR:
	case MIN_EXPR:
	case MAX_EXPR:
	case LSHIFT_EXPR:
	case RSHIFT_EXPR:
	case LROTATE_EXPR:
	case RROTATE_EXPR:
	case BIT_IOR_EXPR:
	case BIT_XOR_EXPR:
	case BIT_AND_EXPR:
	CHECK_OP (0, "invalid operand to binary operator");
	CHECK_OP (1, "invalid operand to binary operator");
	break;

	case CONSTRUCTOR:
	if (TREE_CONSTANT (t) && TREE_CODE (TREE_TYPE (t)) == VECTOR_TYPE)
	*walk_subtrees = 0;
	break;

	default:
	break;
	}
	return NULL;

	#undef CHECK_OP
	}


	/* Verify STMT, return true if STMT is not in GIMPLE form.
	TODO: Implement type checking. */

	static bool
	verify_stmt (tree stmt, bool last_in_block)
	{
	tree addr;

	if (OMP_DIRECTIVE_P (stmt))
	{
	/* OpenMP directives are validated by the FE and never operated
	on by the optimizers. Furthermore, OMP_FOR may contain
	non-gimple expressions when the main index variable has had
	its address taken. This does not affect the loop itself
	because the header of an OMP_FOR is merely used to determine
	how to setup the parallel iteration. */
	return false;
	}

	if (!is_gimple_stmt (stmt))
	{
	error ("is not a valid GIMPLE statement");
	goto fail;
	}

	addr = walk_tree (&stmt, verify_expr, NULL, NULL);
	if (addr)
	{
	debug_generic_stmt (addr);
	return true;
	}

	/* If the statement is marked as part of an EH region, then it is
	expected that the statement could throw. Verify that when we
	have optimizations that simplify statements such that we prove
	that they cannot throw, that we update other data structures
	to match. */
	if (lookup_stmt_eh_region (stmt) >= 0)
	{
	if (!tree_could_throw_p (stmt))
	{
	error ("statement marked for throw, but doesn%'t");
	goto fail;
	}
	if (!last_in_block && tree_can_throw_internal (stmt))
	{
	error ("statement marked for throw in middle of block");
	goto fail;
	}
	}

	return false;

	fail:
	debug_generic_stmt (stmt);
	return true;
	}


	/* Return true when the T can be shared. */

	static bool
	tree_node_can_be_shared (tree t)
	{
	if (IS_TYPE_OR_DECL_P (t)
	\|\| is_gimple_min_invariant (t)
	\|\| TREE_CODE (t) == SSA_NAME
	\|\| t == error_mark_node
	\|\| TREE_CODE (t) == IDENTIFIER_NODE)
	return true;

	if (TREE_CODE (t) == CASE_LABEL_EXPR)
	return true;

	while (((TREE_CODE (t) == ARRAY_REF \|\| TREE_CODE (t) == ARRAY_RANGE_REF)
	&& is_gimple_min_invariant (TREE_OPERAND (t, 1)))
	\|\| TREE_CODE (t) == COMPONENT_REF
	\|\| TREE_CODE (t) == REALPART_EXPR
	\|\| TREE_CODE (t) == IMAGPART_EXPR)
	t = TREE_OPERAND (t, 0);

	if (DECL_P (t))
	return true;

	return false;
	}


	/* Called via walk_trees. Verify tree sharing. */

	static tree
	verify_node_sharing (tree * tp, int walk_subtrees, void data)
	{
	htab_t htab = (htab_t) data;
	void **slot;

	if (tree_node_can_be_shared (*tp))
	{
	*walk_subtrees = false;
	return NULL;
	}

	slot = htab_find_slot (htab, *tp, INSERT);
	if (*slot)
	return (tree) *slot;
	slot = tp;

	return NULL;
	}


	/* Verify the GIMPLE statement chain. */

	void
	verify_stmts (void)
	{
	basic_block bb;
	block_stmt_iterator bsi;
	bool err = false;
	htab_t htab;
	tree addr;

	timevar_push (TV_TREE_STMT_VERIFY);
	htab = htab_create (37, htab_hash_pointer, htab_eq_pointer, NULL);

	FOR_EACH_BB (bb)
	{
	tree phi;
	int i;

	for (phi = phi_nodes (bb); phi; phi = PHI_CHAIN (phi))
	{
	int phi_num_args = PHI_NUM_ARGS (phi);

	if (bb_for_stmt (phi) != bb)
	{
	error ("bb_for_stmt (phi) is set to a wrong basic block");
	err \|= true;
	}

	for (i = 0; i < phi_num_args; i++)
	{
	tree t = PHI_ARG_DEF (phi, i);
	tree addr;

	/* Addressable variables do have SSA_NAMEs but they
	are not considered gimple values. */
	if (TREE_CODE (t) != SSA_NAME
	&& TREE_CODE (t) != FUNCTION_DECL
	&& !is_gimple_val (t))
	{
	error ("PHI def is not a GIMPLE value");
	debug_generic_stmt (phi);
	debug_generic_stmt (t);
	err \|= true;
	}

	addr = walk_tree (&t, verify_expr, (void *) 1, NULL);
	if (addr)
	{
	debug_generic_stmt (addr);
	err \|= true;
	}

	addr = walk_tree (&t, verify_node_sharing, htab, NULL);
	if (addr)
	{
	error ("incorrect sharing of tree nodes");
	debug_generic_stmt (phi);
	debug_generic_stmt (addr);
	err \|= true;
	}
	}
	}

	for (bsi = bsi_start (bb); !bsi_end_p (bsi); )
	{
	tree stmt = bsi_stmt (bsi);

	if (bb_for_stmt (stmt) != bb)
	{
	error ("bb_for_stmt (stmt) is set to a wrong basic block");
	err \|= true;
	}

	bsi_next (&bsi);
	err \|= verify_stmt (stmt, bsi_end_p (bsi));
	addr = walk_tree (&stmt, verify_node_sharing, htab, NULL);
	if (addr)
	{
	error ("incorrect sharing of tree nodes");
	debug_generic_stmt (stmt);
	debug_generic_stmt (addr);
	err \|= true;
	}
	}
	}

	if (err)
	internal_error ("verify_stmts failed");

	htab_delete (htab);
	timevar_pop (TV_TREE_STMT_VERIFY);
	}


	/* Verifies that the flow information is OK. */

	static int
	tree_verify_flow_info (void)
	{
	int err = 0;
	basic_block bb;
	block_stmt_iterator bsi;
	tree stmt;
	edge e;
	edge_iterator ei;

	if (ENTRY_BLOCK_PTR->stmt_list)
	{
	error ("ENTRY_BLOCK has a statement list associated with it");
	err = 1;
	}

	if (EXIT_BLOCK_PTR->stmt_list)
	{
	error ("EXIT_BLOCK has a statement list associated with it");
	err = 1;
	}

	FOR_EACH_EDGE (e, ei, EXIT_BLOCK_PTR->preds)
	if (e->flags & EDGE_FALLTHRU)
	{
	error ("fallthru to exit from bb %d", e->src->index);
	err = 1;
	}

	FOR_EACH_BB (bb)
	{
	bool found_ctrl_stmt = false;

	stmt = NULL_TREE;

	/* Skip labels on the start of basic block. */
	for (bsi = bsi_start (bb); !bsi_end_p (bsi); bsi_next (&bsi))
	{
	tree prev_stmt = stmt;

	stmt = bsi_stmt (bsi);

	if (TREE_CODE (stmt) != LABEL_EXPR)
	break;

	if (prev_stmt && DECL_NONLOCAL (LABEL_EXPR_LABEL (stmt)))
	{
	error ("nonlocal label ");
	print_generic_expr (stderr, LABEL_EXPR_LABEL (stmt), 0);
	fprintf (stderr, " is not first in a sequence of labels in bb %d",
	bb->index);
	err = 1;
	}

	if (label_to_block (LABEL_EXPR_LABEL (stmt)) != bb)
	{
	error ("label ");
	print_generic_expr (stderr, LABEL_EXPR_LABEL (stmt), 0);
	fprintf (stderr, " to block does not match in bb %d",
	bb->index);
	err = 1;
	}

	if (decl_function_context (LABEL_EXPR_LABEL (stmt))
	!= current_function_decl)
	{
	error ("label ");
	print_generic_expr (stderr, LABEL_EXPR_LABEL (stmt), 0);
	fprintf (stderr, " has incorrect context in bb %d",
	bb->index);
	err = 1;
	}
	}

	/* Verify that body of basic block BB is free of control flow. */
	for (; !bsi_end_p (bsi); bsi_next (&bsi))
	{
	tree stmt = bsi_stmt (bsi);

	if (found_ctrl_stmt)
	{
	error ("control flow in the middle of basic block %d",
	bb->index);
	err = 1;
	}

	if (stmt_ends_bb_p (stmt))
	found_ctrl_stmt = true;

	if (TREE_CODE (stmt) == LABEL_EXPR)
	{
	error ("label ");
	print_generic_expr (stderr, LABEL_EXPR_LABEL (stmt), 0);
	fprintf (stderr, " in the middle of basic block %d", bb->index);
	err = 1;
	}
	}

	bsi = bsi_last (bb);
	if (bsi_end_p (bsi))
	continue;

	stmt = bsi_stmt (bsi);

	err \|= verify_eh_edges (stmt);

	if (is_ctrl_stmt (stmt))
	{
	FOR_EACH_EDGE (e, ei, bb->succs)
	if (e->flags & EDGE_FALLTHRU)
	{
	error ("fallthru edge after a control statement in bb %d",
	bb->index);
	err = 1;
	}
	}

	if (TREE_CODE (stmt) != COND_EXPR)
	{
	/* Verify that there are no edges with EDGE_TRUE/FALSE_FLAG set
	after anything else but if statement. */
	FOR_EACH_EDGE (e, ei, bb->succs)
	if (e->flags & (EDGE_TRUE_VALUE \| EDGE_FALSE_VALUE))
	{
	error ("true/false edge after a non-COND_EXPR in bb %d",
	bb->index);
	err = 1;
	}
	}

	switch (TREE_CODE (stmt))
	{
	case COND_EXPR:
	{
	edge true_edge;
	edge false_edge;
	if (TREE_CODE (COND_EXPR_THEN (stmt)) != GOTO_EXPR
	\|\| TREE_CODE (COND_EXPR_ELSE (stmt)) != GOTO_EXPR)
	{
	error ("structured COND_EXPR at the end of bb %d", bb->index);
	err = 1;
	}

	extract_true_false_edges_from_block (bb, &true_edge, &false_edge);

	if (!true_edge \|\| !false_edge
	\|\| !(true_edge->flags & EDGE_TRUE_VALUE)
	\|\| !(false_edge->flags & EDGE_FALSE_VALUE)
	\|\| (true_edge->flags & (EDGE_FALLTHRU \| EDGE_ABNORMAL))
	\|\| (false_edge->flags & (EDGE_FALLTHRU \| EDGE_ABNORMAL))
	\|\| EDGE_COUNT (bb->succs) >= 3)
	{
	error ("wrong outgoing edge flags at end of bb %d",
	bb->index);
	err = 1;
	}

	if (!has_label_p (true_edge->dest,
	GOTO_DESTINATION (COND_EXPR_THEN (stmt))))
	{
	error ("%<then%> label does not match edge at end of bb %d",
	bb->index);
	err = 1;
	}

	if (!has_label_p (false_edge->dest,
	GOTO_DESTINATION (COND_EXPR_ELSE (stmt))))
	{
	error ("%<else%> label does not match edge at end of bb %d",
	bb->index);
	err = 1;
	}
	}
	break;

	case GOTO_EXPR:
	if (simple_goto_p (stmt))
	{
	error ("explicit goto at end of bb %d", bb->index);
	err = 1;
	}
	else
	{
	/* FIXME. We should double check that the labels in the
	destination blocks have their address taken. */
	FOR_EACH_EDGE (e, ei, bb->succs)
	if ((e->flags & (EDGE_FALLTHRU \| EDGE_TRUE_VALUE
	\| EDGE_FALSE_VALUE))
	\|\| !(e->flags & EDGE_ABNORMAL))
	{
	error ("wrong outgoing edge flags at end of bb %d",
	bb->index);
	err = 1;
	}
	}
	break;

	case RETURN_EXPR:
	if (!single_succ_p (bb)
	\|\| (single_succ_edge (bb)->flags
	& (EDGE_FALLTHRU \| EDGE_ABNORMAL
	\| EDGE_TRUE_VALUE \| EDGE_FALSE_VALUE)))
	{
	error ("wrong outgoing edge flags at end of bb %d", bb->index);
	err = 1;
	}
	if (single_succ (bb) != EXIT_BLOCK_PTR)
	{
	error ("return edge does not point to exit in bb %d",
	bb->index);
	err = 1;
	}
	break;

	case SWITCH_EXPR:
	{
	tree prev;
	edge e;
	size_t i, n;
	tree vec;

	vec = SWITCH_LABELS (stmt);
	n = TREE_VEC_LENGTH (vec);

	/* Mark all the destination basic blocks. */
	for (i = 0; i < n; ++i)
	{
	tree lab = CASE_LABEL (TREE_VEC_ELT (vec, i));
	basic_block label_bb = label_to_block (lab);

	gcc_assert (!label_bb->aux \|\| label_bb->aux == (void *)1);
	label_bb->aux = (void *)1;
	}

	/* Verify that the case labels are sorted. */
	prev = TREE_VEC_ELT (vec, 0);
	for (i = 1; i < n - 1; ++i)
	{
	tree c = TREE_VEC_ELT (vec, i);
	if (! CASE_LOW (c))
	{
	error ("found default case not at end of case vector");
	err = 1;
	continue;
	}
	if (! tree_int_cst_lt (CASE_LOW (prev), CASE_LOW (c)))
	{
	error ("case labels not sorted: ");
	print_generic_expr (stderr, prev, 0);
	fprintf (stderr," is greater than ");
	print_generic_expr (stderr, c, 0);
	fprintf (stderr," but comes before it.\n");
	err = 1;
	}
	prev = c;
	}
	if (CASE_LOW (TREE_VEC_ELT (vec, n - 1)))
	{
	error ("no default case found at end of case vector");
	err = 1;
	}

	FOR_EACH_EDGE (e, ei, bb->succs)
	{
	if (!e->dest->aux)
	{
	error ("extra outgoing edge %d->%d",
	bb->index, e->dest->index);
	err = 1;
	}
	e->dest->aux = (void *)2;
	if ((e->flags & (EDGE_FALLTHRU \| EDGE_ABNORMAL
	\| EDGE_TRUE_VALUE \| EDGE_FALSE_VALUE)))
	{
	error ("wrong outgoing edge flags at end of bb %d",
	bb->index);
	err = 1;
	}
	}

	/* Check that we have all of them. */
	for (i = 0; i < n; ++i)
	{
	tree lab = CASE_LABEL (TREE_VEC_ELT (vec, i));
	basic_block label_bb = label_to_block (lab);

	if (label_bb->aux != (void *)2)
	{
	error ("missing edge %i->%i",
	bb->index, label_bb->index);
	err = 1;
	}
	}

	FOR_EACH_EDGE (e, ei, bb->succs)
	e->dest->aux = (void *)0;
	}

	default: ;
	}
	}

	if (dom_computed[CDI_DOMINATORS] >= DOM_NO_FAST_QUERY)
	verify_dominators (CDI_DOMINATORS);

	return err;
	}


	/* Updates phi nodes after creating a forwarder block joined
	by edge FALLTHRU. */

	static void
	tree_make_forwarder_block (edge fallthru)
	{
	edge e;
	edge_iterator ei;
	basic_block dummy, bb;
	tree phi, new_phi, var;

	dummy = fallthru->src;
	bb = fallthru->dest;

	if (single_pred_p (bb))
	return;

	/* If we redirected a branch we must create new phi nodes at the
	start of BB. */
	for (phi = phi_nodes (dummy); phi; phi = PHI_CHAIN (phi))
	{
	var = PHI_RESULT (phi);
	new_phi = create_phi_node (var, bb);
	SSA_NAME_DEF_STMT (var) = new_phi;
	SET_PHI_RESULT (phi, make_ssa_name (SSA_NAME_VAR (var), phi));
	add_phi_arg (new_phi, PHI_RESULT (phi), fallthru);
	}

	/* Ensure that the PHI node chain is in the same order. */
	set_phi_nodes (bb, phi_reverse (phi_nodes (bb)));

	/* Add the arguments we have stored on edges. */
	FOR_EACH_EDGE (e, ei, bb->preds)
	{
	if (e == fallthru)
	continue;

	flush_pending_stmts (e);
	}
	}


	/* Return a non-special label in the head of basic block BLOCK.
	Create one if it doesn't exist. */

	tree
	tree_block_label (basic_block bb)
	{
	block_stmt_iterator i, s = bsi_start (bb);
	bool first = true;
	tree label, stmt;

	for (i = s; !bsi_end_p (i); first = false, bsi_next (&i))
	{
	stmt = bsi_stmt (i);
	if (TREE_CODE (stmt) != LABEL_EXPR)
	break;
	label = LABEL_EXPR_LABEL (stmt);
	if (!DECL_NONLOCAL (label))
	{
	if (!first)
	bsi_move_before (&i, &s);
	return label;
	}
	}

	label = create_artificial_label ();
	stmt = build1 (LABEL_EXPR, void_type_node, label);
	bsi_insert_before (&s, stmt, BSI_NEW_STMT);
	return label;
	}


	/* Attempt to perform edge redirection by replacing a possibly complex
	jump instruction by a goto or by removing the jump completely.
	This can apply only if all edges now point to the same block. The
	parameters and return values are equivalent to
	redirect_edge_and_branch. */

	static edge
	tree_try_redirect_by_replacing_jump (edge e, basic_block target)
	{
	basic_block src = e->src;
	block_stmt_iterator b;
	tree stmt;

	/* We can replace or remove a complex jump only when we have exactly
	two edges. */
	if (EDGE_COUNT (src->succs) != 2
	/* Verify that all targets will be TARGET. Specifically, the
	edge that is not E must also go to TARGET. */
	\|\| EDGE_SUCC (src, EDGE_SUCC (src, 0) == e)->dest != target)
	return NULL;

	b = bsi_last (src);
	if (bsi_end_p (b))
	return NULL;
	stmt = bsi_stmt (b);

	if (TREE_CODE (stmt) == COND_EXPR
	\|\| TREE_CODE (stmt) == SWITCH_EXPR)
	{
	bsi_remove (&b, true);
	e = ssa_redirect_edge (e, target);
	e->flags = EDGE_FALLTHRU;
	return e;
	}

	return NULL;
	}


	/* Redirect E to DEST. Return NULL on failure. Otherwise, return the
	edge representing the redirected branch. */

	static edge
	tree_redirect_edge_and_branch (edge e, basic_block dest)
	{
	basic_block bb = e->src;
	block_stmt_iterator bsi;
	edge ret;
	tree label, stmt;

	if (e->flags & EDGE_ABNORMAL)
	return NULL;

	if (e->src != ENTRY_BLOCK_PTR
	&& (ret = tree_try_redirect_by_replacing_jump (e, dest)))
	return ret;

	if (e->dest == dest)
	return NULL;

	label = tree_block_label (dest);

	bsi = bsi_last (bb);
	stmt = bsi_end_p (bsi) ? NULL : bsi_stmt (bsi);

	switch (stmt ? TREE_CODE (stmt) : ERROR_MARK)
	{
	case COND_EXPR:
	stmt = (e->flags & EDGE_TRUE_VALUE
	? COND_EXPR_THEN (stmt)
	: COND_EXPR_ELSE (stmt));
	GOTO_DESTINATION (stmt) = label;
	break;

	case GOTO_EXPR:
	/* No non-abnormal edges should lead from a non-simple goto, and
	simple ones should be represented implicitly. */
	gcc_unreachable ();

	case SWITCH_EXPR:
	{
	tree cases = get_cases_for_edge (e, stmt);

	/* If we have a list of cases associated with E, then use it
	as it's a lot faster than walking the entire case vector. */
	if (cases)
	{
	edge e2 = find_edge (e->src, dest);
	tree last, first;

	first = cases;
	while (cases)
	{
	last = cases;
	CASE_LABEL (cases) = label;
	cases = TREE_CHAIN (cases);
	}

	/* If there was already an edge in the CFG, then we need
	to move all the cases associated with E to E2. */
	if (e2)
	{
	tree cases2 = get_cases_for_edge (e2, stmt);

	TREE_CHAIN (last) = TREE_CHAIN (cases2);
	TREE_CHAIN (cases2) = first;
	}
	}
	else
	{
	tree vec = SWITCH_LABELS (stmt);
	size_t i, n = TREE_VEC_LENGTH (vec);

	for (i = 0; i < n; i++)
	{
	tree elt = TREE_VEC_ELT (vec, i);

	if (label_to_block (CASE_LABEL (elt)) == e->dest)
	CASE_LABEL (elt) = label;
	}
	}

	break;
	}

	case RETURN_EXPR:
	bsi_remove (&bsi, true);
	e->flags \|= EDGE_FALLTHRU;
	break;

	default:
	/* Otherwise it must be a fallthru edge, and we don't need to
	do anything besides redirecting it. */
	gcc_assert (e->flags & EDGE_FALLTHRU);
	break;
	}

	/* Update/insert PHI nodes as necessary. */

	/* Now update the edges in the CFG. */
	e = ssa_redirect_edge (e, dest);

	return e;
	}


	/* Simple wrapper, as we can always redirect fallthru edges. */

	static basic_block
	tree_redirect_edge_and_branch_force (edge e, basic_block dest)
	{
	e = tree_redirect_edge_and_branch (e, dest);
	gcc_assert (e);

	return NULL;
	}


	/* Splits basic block BB after statement STMT (but at least after the
	labels). If STMT is NULL, BB is split just after the labels. */

	static basic_block
	tree_split_block (basic_block bb, void *stmt)
	{
	block_stmt_iterator bsi;
	tree_stmt_iterator tsi_tgt;
	tree act;
	basic_block new_bb;
	edge e;
	edge_iterator ei;

	new_bb = create_empty_bb (bb);

	/* Redirect the outgoing edges. */
	new_bb->succs = bb->succs;
	bb->succs = NULL;
	FOR_EACH_EDGE (e, ei, new_bb->succs)
	e->src = new_bb;

	if (stmt && TREE_CODE ((tree) stmt) == LABEL_EXPR)
	stmt = NULL;

	/* Move everything from BSI to the new basic block. */
	for (bsi = bsi_start (bb); !bsi_end_p (bsi); bsi_next (&bsi))
	{
	act = bsi_stmt (bsi);
	if (TREE_CODE (act) == LABEL_EXPR)
	continue;

	if (!stmt)
	break;

	if (stmt == act)
	{
	bsi_next (&bsi);
	break;
	}
	}

	if (bsi_end_p (bsi))
	return new_bb;

	/* Split the statement list - avoid re-creating new containers as this
	brings ugly quadratic memory consumption in the inliner.
	(We are still quadratic since we need to update stmt BB pointers,
	sadly.) */
	new_bb->stmt_list = tsi_split_statement_list_before (&bsi.tsi);
	for (tsi_tgt = tsi_start (new_bb->stmt_list);
	!tsi_end_p (tsi_tgt); tsi_next (&tsi_tgt))
	change_bb_for_stmt (tsi_stmt (tsi_tgt), new_bb);

	return new_bb;
	}


	/* Moves basic block BB after block AFTER. */

	static bool
	tree_move_block_after (basic_block bb, basic_block after)
	{
	if (bb->prev_bb == after)
	return true;

	unlink_block (bb);
	link_block (bb, after);

	return true;
	}


	/* Return true if basic_block can be duplicated. */

	static bool
	tree_can_duplicate_bb_p (basic_block bb ATTRIBUTE_UNUSED)
	{
	return true;
	}


	/* Create a duplicate of the basic block BB. NOTE: This does not
	preserve SSA form. */

	static basic_block
	tree_duplicate_bb (basic_block bb)
	{
	basic_block new_bb;
	block_stmt_iterator bsi, bsi_tgt;
	tree phi;

	new_bb = create_empty_bb (EXIT_BLOCK_PTR->prev_bb);

	/* Copy the PHI nodes. We ignore PHI node arguments here because
	the incoming edges have not been setup yet. */
	for (phi = phi_nodes (bb); phi; phi = PHI_CHAIN (phi))
	{
	tree copy = create_phi_node (PHI_RESULT (phi), new_bb);
	create_new_def_for (PHI_RESULT (copy), copy, PHI_RESULT_PTR (copy));
	}

	/* Keep the chain of PHI nodes in the same order so that they can be
	updated by ssa_redirect_edge. */
	set_phi_nodes (new_bb, phi_reverse (phi_nodes (new_bb)));

	bsi_tgt = bsi_start (new_bb);
	for (bsi = bsi_start (bb); !bsi_end_p (bsi); bsi_next (&bsi))
	{
	def_operand_p def_p;
	ssa_op_iter op_iter;
	tree stmt, copy;
	int region;

	stmt = bsi_stmt (bsi);
	if (TREE_CODE (stmt) == LABEL_EXPR)
	continue;

	/* Create a new copy of STMT and duplicate STMT's virtual
	operands. */
	copy = unshare_expr (stmt);
	bsi_insert_after (&bsi_tgt, copy, BSI_NEW_STMT);
	copy_virtual_operands (copy, stmt);
	region = lookup_stmt_eh_region (stmt);
	if (region >= 0)
	add_stmt_to_eh_region (copy, region);

	/* Create new names for all the definitions created by COPY and
	add replacement mappings for each new name. */
	FOR_EACH_SSA_DEF_OPERAND (def_p, copy, op_iter, SSA_OP_ALL_DEFS)
	create_new_def_for (DEF_FROM_PTR (def_p), copy, def_p);
	}

	return new_bb;
	}


	/* Basic block BB_COPY was created by code duplication. Add phi node
	arguments for edges going out of BB_COPY. The blocks that were
	duplicated have BB_DUPLICATED set. */

	void
	add_phi_args_after_copy_bb (basic_block bb_copy)
	{
	basic_block bb, dest;
	edge e, e_copy;
	edge_iterator ei;
	tree phi, phi_copy, phi_next, def;

	bb = get_bb_original (bb_copy);

	FOR_EACH_EDGE (e_copy, ei, bb_copy->succs)
	{
	if (!phi_nodes (e_copy->dest))
	continue;

	if (e_copy->dest->flags & BB_DUPLICATED)
	dest = get_bb_original (e_copy->dest);
	else
	dest = e_copy->dest;

	e = find_edge (bb, dest);
	if (!e)
	{
	/* During loop unrolling the target of the latch edge is copied.
	In this case we are not looking for edge to dest, but to
	duplicated block whose original was dest. */
	FOR_EACH_EDGE (e, ei, bb->succs)
	if ((e->dest->flags & BB_DUPLICATED)
	&& get_bb_original (e->dest) == dest)
	break;

	gcc_assert (e != NULL);
	}

	for (phi = phi_nodes (e->dest), phi_copy = phi_nodes (e_copy->dest);
	phi;
	phi = phi_next, phi_copy = PHI_CHAIN (phi_copy))
	{
	phi_next = PHI_CHAIN (phi);
	def = PHI_ARG_DEF_FROM_EDGE (phi, e);
	add_phi_arg (phi_copy, def, e_copy);
	}
	}
	}

	/* Blocks in REGION_COPY array of length N_REGION were created by
	duplication of basic blocks. Add phi node arguments for edges
	going from these blocks. */

	void
	add_phi_args_after_copy (basic_block *region_copy, unsigned n_region)
	{
	unsigned i;

	for (i = 0; i < n_region; i++)
	region_copy[i]->flags \|= BB_DUPLICATED;

	for (i = 0; i < n_region; i++)
	add_phi_args_after_copy_bb (region_copy[i]);

	for (i = 0; i < n_region; i++)
	region_copy[i]->flags &= ~BB_DUPLICATED;
	}

	/* Duplicates a REGION (set of N_REGION basic blocks) with just a single
	important exit edge EXIT. By important we mean that no SSA name defined
	inside region is live over the other exit edges of the region. All entry
	edges to the region must go to ENTRY->dest. The edge ENTRY is redirected
	to the duplicate of the region. SSA form, dominance and loop information
	is updated. The new basic blocks are stored to REGION_COPY in the same
	order as they had in REGION, provided that REGION_COPY is not NULL.
	The function returns false if it is unable to copy the region,
	true otherwise. */

	bool
	tree_duplicate_sese_region (edge entry, edge exit,
	basic_block *region, unsigned n_region,
	basic_block *region_copy)
	{
	unsigned i, n_doms;
	bool free_region_copy = false, copying_header = false;
	struct loop *loop = entry->dest->loop_father;
	edge exit_copy;
	basic_block *doms;
	edge redirected;
	int total_freq = 0, entry_freq = 0;
	gcov_type total_count = 0, entry_count = 0;

	if (!can_copy_bbs_p (region, n_region))
	return false;

	/* Some sanity checking. Note that we do not check for all possible
	missuses of the functions. I.e. if you ask to copy something weird,
	it will work, but the state of structures probably will not be
	correct. */
	for (i = 0; i < n_region; i++)
	{
	/* We do not handle subloops, i.e. all the blocks must belong to the
	same loop. */
	if (region[i]->loop_father != loop)
	return false;

	if (region[i] != entry->dest
	&& region[i] == loop->header)
	return false;
	}

	loop->copy = loop;

	/* In case the function is used for loop header copying (which is the primary
	use), ensure that EXIT and its copy will be new latch and entry edges. */
	if (loop->header == entry->dest)
	{
	copying_header = true;
	loop->copy = loop->outer;

	if (!dominated_by_p (CDI_DOMINATORS, loop->latch, exit->src))
	return false;

	for (i = 0; i < n_region; i++)
	if (region[i] != exit->src
	&& dominated_by_p (CDI_DOMINATORS, region[i], exit->src))
	return false;
	}

	if (!region_copy)
	{
	region_copy = XNEWVEC (basic_block, n_region);
	free_region_copy = true;
	}

	gcc_assert (!need_ssa_update_p ());

	/* Record blocks outside the region that are dominated by something
	inside. */
	doms = XNEWVEC (basic_block, n_basic_blocks);
	initialize_original_copy_tables ();

	n_doms = get_dominated_by_region (CDI_DOMINATORS, region, n_region, doms);

	if (entry->dest->count)
	{
	total_count = entry->dest->count;
	entry_count = entry->count;
	/* Fix up corner cases, to avoid division by zero or creation of negative
	frequencies. */
	if (entry_count > total_count)
	entry_count = total_count;
	}
	else
	{
	total_freq = entry->dest->frequency;
	entry_freq = EDGE_FREQUENCY (entry);
	/* Fix up corner cases, to avoid division by zero or creation of negative
	frequencies. */
	if (total_freq == 0)
	total_freq = 1;
	else if (entry_freq > total_freq)
	entry_freq = total_freq;
	}

	copy_bbs (region, n_region, region_copy, &exit, 1, &exit_copy, loop,
	split_edge_bb_loc (entry));
	if (total_count)
	{
	scale_bbs_frequencies_gcov_type (region, n_region,
	total_count - entry_count,
	total_count);
	scale_bbs_frequencies_gcov_type (region_copy, n_region, entry_count,
	total_count);
	}
	else
	{
	scale_bbs_frequencies_int (region, n_region, total_freq - entry_freq,
	total_freq);
	scale_bbs_frequencies_int (region_copy, n_region, entry_freq, total_freq);
	}

	if (copying_header)
	{
	loop->header = exit->dest;
	loop->latch = exit->src;
	}

	/* Redirect the entry and add the phi node arguments. */
	redirected = redirect_edge_and_branch (entry, get_bb_copy (entry->dest));
	gcc_assert (redirected != NULL);
	flush_pending_stmts (entry);

	/* Concerning updating of dominators: We must recount dominators
	for entry block and its copy. Anything that is outside of the
	region, but was dominated by something inside needs recounting as
	well. */
	set_immediate_dominator (CDI_DOMINATORS, entry->dest, entry->src);
	doms[n_doms++] = get_bb_original (entry->dest);
	iterate_fix_dominators (CDI_DOMINATORS, doms, n_doms);
	free (doms);

	/* Add the other PHI node arguments. */
	add_phi_args_after_copy (region_copy, n_region);

	/* Update the SSA web. */
	update_ssa (TODO_update_ssa);

	if (free_region_copy)
	free (region_copy);

	free_original_copy_tables ();
	return true;
	}

	/*
	DEF_VEC_P(basic_block);
	DEF_VEC_ALLOC_P(basic_block,heap);
	*/

	/* Add all the blocks dominated by ENTRY to the array BBS_P. Stop
	adding blocks when the dominator traversal reaches EXIT. This
	function silently assumes that ENTRY strictly dominates EXIT. */

	static void
	gather_blocks_in_sese_region (basic_block entry, basic_block exit,
	VEC(basic_block,heap) **bbs_p)
	{
	basic_block son;

	for (son = first_dom_son (CDI_DOMINATORS, entry);
	son;
	son = next_dom_son (CDI_DOMINATORS, son))
	{
	VEC_safe_push (basic_block, heap, *bbs_p, son);
	if (son != exit)
	gather_blocks_in_sese_region (son, exit, bbs_p);
	}
	}


	struct move_stmt_d
	{
	tree block;
	tree from_context;
	tree to_context;
	bitmap vars_to_remove;
	htab_t new_label_map;
	bool remap_decls_p;
	};

	/* Helper for move_block_to_fn. Set TREE_BLOCK in every expression
	contained in *TP and change the DECL_CONTEXT of every local
	variable referenced in TP. /

	static tree
	move_stmt_r (tree tp, int walk_subtrees, void *data)
	{
	struct move_stmt_d p = (struct move_stmt_d ) data;
	tree t = *tp;

	if (p->block && IS_EXPR_CODE_CLASS (TREE_CODE_CLASS (TREE_CODE (t))))
	TREE_BLOCK (t) = p->block;

	if (OMP_DIRECTIVE_P (t)
	&& TREE_CODE (t) != OMP_RETURN
	&& TREE_CODE (t) != OMP_CONTINUE)
	{
	/* Do not remap variables inside OMP directives. Variables
	referenced in clauses and directive header belong to the
	parent function and should not be moved into the child
	function. */
	bool save_remap_decls_p = p->remap_decls_p;
	p->remap_decls_p = false;
	*walk_subtrees = 0;

	walk_tree (&OMP_BODY (t), move_stmt_r, p, NULL);

	p->remap_decls_p = save_remap_decls_p;
	}
	else if (DECL_P (t) && DECL_CONTEXT (t) == p->from_context)
	{
	if (TREE_CODE (t) == LABEL_DECL)
	{
	if (p->new_label_map)
	{
	struct tree_map in, *out;
	in.from = t;
	out = htab_find_with_hash (p->new_label_map, &in, DECL_UID (t));
	if (out)
	*tp = t = out->to;
	}

	DECL_CONTEXT (t) = p->to_context;
	}
	else if (p->remap_decls_p)
	{
	DECL_CONTEXT (t) = p->to_context;

	if (TREE_CODE (t) == VAR_DECL)
	{
	struct function *f = DECL_STRUCT_FUNCTION (p->to_context);
	f->unexpanded_var_list
	= tree_cons (0, t, f->unexpanded_var_list);

	/* Mark T to be removed from the original function,
	otherwise it will be given a DECL_RTL when the
	original function is expanded. */
	bitmap_set_bit (p->vars_to_remove, DECL_UID (t));
	}
	}
	}
	else if (TYPE_P (t))
	*walk_subtrees = 0;

	return NULL_TREE;
	}


	/* Move basic block BB from function CFUN to function DEST_FN. The
	block is moved out of the original linked list and placed after
	block AFTER in the new list. Also, the block is removed from the
	original array of blocks and placed in DEST_FN's array of blocks.
	If UPDATE_EDGE_COUNT_P is true, the edge counts on both CFGs is
	updated to reflect the moved edges.

	On exit, local variables that need to be removed from
	CFUN->UNEXPANDED_VAR_LIST will have been added to VARS_TO_REMOVE. */

	static void
	move_block_to_fn (struct function *dest_cfun, basic_block bb,
	basic_block after, bool update_edge_count_p,
	bitmap vars_to_remove, htab_t new_label_map, int eh_offset)
	{
	struct control_flow_graph *cfg;
	edge_iterator ei;
	edge e;
	block_stmt_iterator si;
	struct move_stmt_d d;
	unsigned old_len, new_len;
	basic_block *addr;

	/* Link BB to the new linked list. */
	move_block_after (bb, after);

	/* Update the edge count in the corresponding flowgraphs. */
	if (update_edge_count_p)
	FOR_EACH_EDGE (e, ei, bb->succs)
	{
	cfun->cfg->x_n_edges--;
	dest_cfun->cfg->x_n_edges++;
	}

	/* Remove BB from the original basic block array. */
	VEC_replace (basic_block, cfun->cfg->x_basic_block_info, bb->index, NULL);
	cfun->cfg->x_n_basic_blocks--;

	/* Grow DEST_CFUN's basic block array if needed. */
	cfg = dest_cfun->cfg;
	cfg->x_n_basic_blocks++;
	if (bb->index > cfg->x_last_basic_block)
	cfg->x_last_basic_block = bb->index;

	old_len = VEC_length (basic_block, cfg->x_basic_block_info);
	if ((unsigned) cfg->x_last_basic_block >= old_len)
	{
	new_len = cfg->x_last_basic_block + (cfg->x_last_basic_block + 3) / 4;
	VEC_safe_grow (basic_block, gc, cfg->x_basic_block_info, new_len);
	addr = VEC_address (basic_block, cfg->x_basic_block_info);
	memset (&addr[old_len], 0, sizeof (basic_block) * (new_len - old_len));
	}

	VEC_replace (basic_block, cfg->x_basic_block_info,
	cfg->x_last_basic_block, bb);

	/* The statements in BB need to be associated with a new TREE_BLOCK.
	Labels need to be associated with a new label-to-block map. */
	memset (&d, 0, sizeof (d));
	d.vars_to_remove = vars_to_remove;

	for (si = bsi_start (bb); !bsi_end_p (si); bsi_next (&si))
	{
	tree stmt = bsi_stmt (si);
	int region;

	d.from_context = cfun->decl;
	d.to_context = dest_cfun->decl;
	d.remap_decls_p = true;
	d.new_label_map = new_label_map;
	if (TREE_BLOCK (stmt))
	d.block = DECL_INITIAL (dest_cfun->decl);

	walk_tree (&stmt, move_stmt_r, &d, NULL);

	if (TREE_CODE (stmt) == LABEL_EXPR)
	{
	tree label = LABEL_EXPR_LABEL (stmt);
	int uid = LABEL_DECL_UID (label);

	gcc_assert (uid > -1);

	old_len = VEC_length (basic_block, cfg->x_label_to_block_map);
	if (old_len <= (unsigned) uid)
	{
	new_len = 3 * uid / 2;
	VEC_safe_grow (basic_block, gc, cfg->x_label_to_block_map,
	new_len);
	addr = VEC_address (basic_block, cfg->x_label_to_block_map);
	memset (&addr[old_len], 0,
	sizeof (basic_block) * (new_len - old_len));
	}

	VEC_replace (basic_block, cfg->x_label_to_block_map, uid, bb);
	VEC_replace (basic_block, cfun->cfg->x_label_to_block_map, uid, NULL);

	gcc_assert (DECL_CONTEXT (label) == dest_cfun->decl);

	if (uid >= dest_cfun->last_label_uid)
	dest_cfun->last_label_uid = uid + 1;
	}
	else if (TREE_CODE (stmt) == RESX_EXPR && eh_offset != 0)
	TREE_OPERAND (stmt, 0) =
	build_int_cst (NULL_TREE,
	TREE_INT_CST_LOW (TREE_OPERAND (stmt, 0))
	+ eh_offset);

	region = lookup_stmt_eh_region (stmt);
	if (region >= 0)
	{
	add_stmt_to_eh_region_fn (dest_cfun, stmt, region + eh_offset);
	remove_stmt_from_eh_region (stmt);
	}
	}
	}

	/* Examine the statements in BB (which is in SRC_CFUN); find and return
	the outermost EH region. Use REGION as the incoming base EH region. */

	static int
	find_outermost_region_in_block (struct function *src_cfun,
	basic_block bb, int region)
	{
	block_stmt_iterator si;

	for (si = bsi_start (bb); !bsi_end_p (si); bsi_next (&si))
	{
	tree stmt = bsi_stmt (si);
	int stmt_region;

	if (TREE_CODE (stmt) == RESX_EXPR)
	stmt_region = TREE_INT_CST_LOW (TREE_OPERAND (stmt, 0));
	else
	stmt_region = lookup_stmt_eh_region_fn (src_cfun, stmt);
	if (stmt_region > 0)
	{
	if (region < 0)
	region = stmt_region;
	else if (stmt_region != region)
	{
	region = eh_region_outermost (src_cfun, stmt_region, region);
	gcc_assert (region != -1);
	}
	}
	}

	return region;
	}

	static tree
	new_label_mapper (tree decl, void *data)
	{
	htab_t hash = (htab_t) data;
	struct tree_map *m;
	void **slot;

	gcc_assert (TREE_CODE (decl) == LABEL_DECL);

	m = xmalloc (sizeof (struct tree_map));
	m->hash = DECL_UID (decl);
	m->from = decl;
	m->to = create_artificial_label ();
	LABEL_DECL_UID (m->to) = LABEL_DECL_UID (decl);

	slot = htab_find_slot_with_hash (hash, m, m->hash, INSERT);
	gcc_assert (*slot == NULL);

	*slot = m;

	return m->to;
	}

	/* Move a single-entry, single-exit region delimited by ENTRY_BB and
	EXIT_BB to function DEST_CFUN. The whole region is replaced by a
	single basic block in the original CFG and the new basic block is
	returned. DEST_CFUN must not have a CFG yet.

	Note that the region need not be a pure SESE region. Blocks inside
	the region may contain calls to abort/exit. The only restriction
	is that ENTRY_BB should be the only entry point and it must
	dominate EXIT_BB.

	All local variables referenced in the region are assumed to be in
	the corresponding BLOCK_VARS and unexpanded variable lists
	associated with DEST_CFUN. */

	basic_block
	move_sese_region_to_fn (struct function *dest_cfun, basic_block entry_bb,
	basic_block exit_bb)
	{
	VEC(basic_block,heap) *bbs;
	basic_block after, bb, entry_pred, exit_succ;
	struct function *saved_cfun;
	int entry_flag, exit_flag, eh_offset;
	unsigned i, num_entry_edges, num_exit_edges;
	edge e;
	edge_iterator ei;
	bitmap vars_to_remove;
	htab_t new_label_map;

	saved_cfun = cfun;

	/* Collect all the blocks in the region. Manually add ENTRY_BB
	because it won't be added by dfs_enumerate_from. */
	calculate_dominance_info (CDI_DOMINATORS);

	/* If ENTRY does not strictly dominate EXIT, this cannot be an SESE
	region. */
	gcc_assert (entry_bb != exit_bb
	&& (!exit_bb
	\|\| dominated_by_p (CDI_DOMINATORS, exit_bb, entry_bb)));

	bbs = NULL;
	VEC_safe_push (basic_block, heap, bbs, entry_bb);
	gather_blocks_in_sese_region (entry_bb, exit_bb, &bbs);

	/* Detach ENTRY_BB and EXIT_BB from CFUN->CFG. We need to remember
	the predecessor edges to ENTRY_BB and the successor edges to
	EXIT_BB so that we can re-attach them to the new basic block that
	will replace the region. */
	num_entry_edges = EDGE_COUNT (entry_bb->preds);
	entry_pred = (basic_block *) xcalloc (num_entry_edges, sizeof (basic_block));
	entry_flag = (int *) xcalloc (num_entry_edges, sizeof (int));
	i = 0;
	for (ei = ei_start (entry_bb->preds); (e = ei_safe_edge (ei)) != NULL;)
	{
	entry_flag[i] = e->flags;
	entry_pred[i++] = e->src;
	remove_edge (e);
	}

	if (exit_bb)
	{
	num_exit_edges = EDGE_COUNT (exit_bb->succs);
	exit_succ = (basic_block *) xcalloc (num_exit_edges,
	sizeof (basic_block));
	exit_flag = (int *) xcalloc (num_exit_edges, sizeof (int));
	i = 0;
	for (ei = ei_start (exit_bb->succs); (e = ei_safe_edge (ei)) != NULL;)
	{
	exit_flag[i] = e->flags;
	exit_succ[i++] = e->dest;
	remove_edge (e);
	}
	}
	else
	{
	num_exit_edges = 0;
	exit_succ = NULL;
	exit_flag = NULL;
	}

	/* Switch context to the child function to initialize DEST_FN's CFG. */
	gcc_assert (dest_cfun->cfg == NULL);
	cfun = dest_cfun;

	init_empty_tree_cfg ();

	/* Initialize EH information for the new function. */
	eh_offset = 0;
	new_label_map = NULL;
	if (saved_cfun->eh)
	{
	int region = -1;

	for (i = 0; VEC_iterate (basic_block, bbs, i, bb); i++)
	region = find_outermost_region_in_block (saved_cfun, bb, region);

	init_eh_for_function ();
	if (region != -1)
	{
	new_label_map = htab_create (17, tree_map_hash, tree_map_eq, free);
	eh_offset = duplicate_eh_regions (saved_cfun, new_label_mapper,
	new_label_map, region, 0);
	}
	}

	cfun = saved_cfun;

	/* Move blocks from BBS into DEST_CFUN. */
	gcc_assert (VEC_length (basic_block, bbs) >= 2);
	after = dest_cfun->cfg->x_entry_block_ptr;
	vars_to_remove = BITMAP_ALLOC (NULL);
	for (i = 0; VEC_iterate (basic_block, bbs, i, bb); i++)
	{
	/* No need to update edge counts on the last block. It has
	already been updated earlier when we detached the region from
	the original CFG. */
	move_block_to_fn (dest_cfun, bb, after, bb != exit_bb, vars_to_remove,
	new_label_map, eh_offset);
	after = bb;
	}

	if (new_label_map)
	htab_delete (new_label_map);

	/* Remove the variables marked in VARS_TO_REMOVE from
	CFUN->UNEXPANDED_VAR_LIST. Otherwise, they will be given a
	DECL_RTL in the context of CFUN. */
	if (!bitmap_empty_p (vars_to_remove))
	{
	tree *p;

	for (p = &cfun->unexpanded_var_list; *p; )
	{
	tree var = TREE_VALUE (*p);
	if (bitmap_bit_p (vars_to_remove, DECL_UID (var)))
	{
	p = TREE_CHAIN (p);
	continue;
	}

	p = &TREE_CHAIN (*p);
	}
	}

	BITMAP_FREE (vars_to_remove);

	/* Rewire the entry and exit blocks. The successor to the entry
	block turns into the successor of DEST_FN's ENTRY_BLOCK_PTR in
	the child function. Similarly, the predecessor of DEST_FN's
	EXIT_BLOCK_PTR turns into the predecessor of EXIT_BLOCK_PTR. We
	need to switch CFUN between DEST_CFUN and SAVED_CFUN so that the
	various CFG manipulation function get to the right CFG.

	FIXME, this is silly. The CFG ought to become a parameter to
	these helpers. */
	cfun = dest_cfun;
	make_edge (ENTRY_BLOCK_PTR, entry_bb, EDGE_FALLTHRU);
	if (exit_bb)
	make_edge (exit_bb, EXIT_BLOCK_PTR, 0);
	cfun = saved_cfun;

	/* Back in the original function, the SESE region has disappeared,
	create a new basic block in its place. */
	bb = create_empty_bb (entry_pred[0]);
	for (i = 0; i < num_entry_edges; i++)
	make_edge (entry_pred[i], bb, entry_flag[i]);

	for (i = 0; i < num_exit_edges; i++)
	make_edge (bb, exit_succ[i], exit_flag[i]);

	if (exit_bb)
	{
	free (exit_flag);
	free (exit_succ);
	}
	free (entry_flag);
	free (entry_pred);
	free_dominance_info (CDI_DOMINATORS);
	free_dominance_info (CDI_POST_DOMINATORS);
	VEC_free (basic_block, heap, bbs);

	return bb;
	}


	/* Dump FUNCTION_DECL FN to file FILE using FLAGS (see TDF_* in tree.h) */

	void
	dump_function_to_file (tree fn, FILE *file, int flags)
	{
	tree arg, vars, var;
	bool ignore_topmost_bind = false, any_var = false;
	basic_block bb;
	tree chain;
	struct function *saved_cfun;

	fprintf (file, "%s (", lang_hooks.decl_printable_name (fn, 2));

	arg = DECL_ARGUMENTS (fn);
	while (arg)
	{
	print_generic_expr (file, arg, dump_flags);
	if (TREE_CHAIN (arg))
	fprintf (file, ", ");
	arg = TREE_CHAIN (arg);
	}
	fprintf (file, ")\n");

	if (flags & TDF_DETAILS)
	dump_eh_tree (file, DECL_STRUCT_FUNCTION (fn));
	if (flags & TDF_RAW)
	{
	dump_node (fn, TDF_SLIM \| flags, file);
	return;
	}

	/* Switch CFUN to point to FN. */
	saved_cfun = cfun;
	cfun = DECL_STRUCT_FUNCTION (fn);

	/* When GIMPLE is lowered, the variables are no longer available in
	BIND_EXPRs, so display them separately. */
	if (cfun && cfun->decl == fn && cfun->unexpanded_var_list)
	{
	ignore_topmost_bind = true;

	fprintf (file, "{\n");
	for (vars = cfun->unexpanded_var_list; vars; vars = TREE_CHAIN (vars))
	{
	var = TREE_VALUE (vars);

	print_generic_decl (file, var, flags);
	fprintf (file, "\n");

	any_var = true;
	}
	}

	if (cfun && cfun->decl == fn && cfun->cfg && basic_block_info)
	{
	/* Make a CFG based dump. */
	check_bb_profile (ENTRY_BLOCK_PTR, file);
	if (!ignore_topmost_bind)
	fprintf (file, "{\n");

	if (any_var && n_basic_blocks)
	fprintf (file, "\n");

	FOR_EACH_BB (bb)
	dump_generic_bb (file, bb, 2, flags);

	fprintf (file, "}\n");
	check_bb_profile (EXIT_BLOCK_PTR, file);
	}
	else
	{
	int indent;

	/* Make a tree based dump. */
	chain = DECL_SAVED_TREE (fn);

	if (chain && TREE_CODE (chain) == BIND_EXPR)
	{
	if (ignore_topmost_bind)
	{
	chain = BIND_EXPR_BODY (chain);
	indent = 2;
	}
	else
	indent = 0;
	}
	else
	{
	if (!ignore_topmost_bind)
	fprintf (file, "{\n");
	indent = 2;
	}

	if (any_var)
	fprintf (file, "\n");

	print_generic_stmt_indented (file, chain, flags, indent);
	if (ignore_topmost_bind)
	fprintf (file, "}\n");
	}

	fprintf (file, "\n\n");

	/* Restore CFUN. */
	cfun = saved_cfun;
	}


	/* Dump FUNCTION_DECL FN to stderr using FLAGS (see TDF_* in tree.h) */

	void
	debug_function (tree fn, int flags)
	{
	dump_function_to_file (fn, stderr, flags);
	}


	/* Pretty print of the loops intermediate representation. */
	static void print_loop (FILE , struct loop , int);
	static void print_pred_bbs (FILE *, basic_block bb);
	static void print_succ_bbs (FILE *, basic_block bb);


	/* Print on FILE the indexes for the predecessors of basic_block BB. */

	static void
	print_pred_bbs (FILE *file, basic_block bb)
	{
	edge e;
	edge_iterator ei;

	FOR_EACH_EDGE (e, ei, bb->preds)
	fprintf (file, "bb_%d ", e->src->index);
	}


	/* Print on FILE the indexes for the successors of basic_block BB. */

	static void
	print_succ_bbs (FILE *file, basic_block bb)
	{
	edge e;
	edge_iterator ei;

	FOR_EACH_EDGE (e, ei, bb->succs)
	fprintf (file, "bb_%d ", e->dest->index);
	}


	/* Pretty print LOOP on FILE, indented INDENT spaces. */

	static void
	print_loop (FILE file, struct loop loop, int indent)
	{
	char *s_indent;
	basic_block bb;

	if (loop == NULL)
	return;

	s_indent = (char *) alloca ((size_t) indent + 1);
	memset ((void *) s_indent, ' ', (size_t) indent);
	s_indent[indent] = '\0';

	/* Print the loop's header. */
	fprintf (file, "%sloop_%d\n", s_indent, loop->num);

	/* Print the loop's body. */
	fprintf (file, "%s{\n", s_indent);
	FOR_EACH_BB (bb)
	if (bb->loop_father == loop)
	{
	/* Print the basic_block's header. */
	fprintf (file, "%s bb_%d (preds = {", s_indent, bb->index);
	print_pred_bbs (file, bb);
	fprintf (file, "}, succs = {");
	print_succ_bbs (file, bb);
	fprintf (file, "})\n");

	/* Print the basic_block's body. */
	fprintf (file, "%s {\n", s_indent);
	tree_dump_bb (bb, file, indent + 4);
	fprintf (file, "%s }\n", s_indent);
	}

	print_loop (file, loop->inner, indent + 2);
	fprintf (file, "%s}\n", s_indent);
	print_loop (file, loop->next, indent);
	}


	/* Follow a CFG edge from the entry point of the program, and on entry
	of a loop, pretty print the loop structure on FILE. */

	void
	print_loop_ir (FILE *file)
	{
	basic_block bb;

	bb = BASIC_BLOCK (NUM_FIXED_BLOCKS);
	if (bb && bb->loop_father)
	print_loop (file, bb->loop_father, 0);
	}


	/* Debugging loops structure at tree level. */

	void
	debug_loop_ir (void)
	{
	print_loop_ir (stderr);
	}


	/* Return true if BB ends with a call, possibly followed by some
	instructions that must stay with the call. Return false,
	otherwise. */

	static bool
	tree_block_ends_with_call_p (basic_block bb)
	{
	block_stmt_iterator bsi = bsi_last (bb);
	return get_call_expr_in (bsi_stmt (bsi)) != NULL;
	}


	/* Return true if BB ends with a conditional branch. Return false,
	otherwise. */

	static bool
	tree_block_ends_with_condjump_p (basic_block bb)
	{
	tree stmt = last_stmt (bb);
	return (stmt && TREE_CODE (stmt) == COND_EXPR);
	}


	/* Return true if we need to add fake edge to exit at statement T.
	Helper function for tree_flow_call_edges_add. */

	static bool
	need_fake_edge_p (tree t)
	{
	tree call;

	/* NORETURN and LONGJMP calls already have an edge to exit.
	CONST and PURE calls do not need one.
	We don't currently check for CONST and PURE here, although
	it would be a good idea, because those attributes are
	figured out from the RTL in mark_constant_function, and
	the counter incrementation code from -fprofile-arcs
	leads to different results from -fbranch-probabilities. */
	call = get_call_expr_in (t);
	if (call
	&& !(call_expr_flags (call) & ECF_NORETURN))
	return true;

	if (TREE_CODE (t) == ASM_EXPR
	&& (ASM_VOLATILE_P (t) \|\| ASM_INPUT_P (t)))
	return true;

	return false;
	}


	/* Add fake edges to the function exit for any non constant and non
	noreturn calls, volatile inline assembly in the bitmap of blocks
	specified by BLOCKS or to the whole CFG if BLOCKS is zero. Return
	the number of blocks that were split.

	The goal is to expose cases in which entering a basic block does
	not imply that all subsequent instructions must be executed. */

	static int
	tree_flow_call_edges_add (sbitmap blocks)
	{
	int i;
	int blocks_split = 0;
	int last_bb = last_basic_block;
	bool check_last_block = false;

	if (n_basic_blocks == NUM_FIXED_BLOCKS)
	return 0;

	if (! blocks)
	check_last_block = true;
	else
	check_last_block = TEST_BIT (blocks, EXIT_BLOCK_PTR->prev_bb->index);

	/* In the last basic block, before epilogue generation, there will be
	a fallthru edge to EXIT. Special care is required if the last insn
	of the last basic block is a call because make_edge folds duplicate
	edges, which would result in the fallthru edge also being marked
	fake, which would result in the fallthru edge being removed by
	remove_fake_edges, which would result in an invalid CFG.

	Moreover, we can't elide the outgoing fake edge, since the block
	profiler needs to take this into account in order to solve the minimal
	spanning tree in the case that the call doesn't return.

	Handle this by adding a dummy instruction in a new last basic block. */
	if (check_last_block)
	{
	basic_block bb = EXIT_BLOCK_PTR->prev_bb;
	block_stmt_iterator bsi = bsi_last (bb);
	tree t = NULL_TREE;
	if (!bsi_end_p (bsi))
	t = bsi_stmt (bsi);

	if (t && need_fake_edge_p (t))
	{
	edge e;

	e = find_edge (bb, EXIT_BLOCK_PTR);
	if (e)
	{
	bsi_insert_on_edge (e, build_empty_stmt ());
	bsi_commit_edge_inserts ();
	}
	}
	}

	/* Now add fake edges to the function exit for any non constant
	calls since there is no way that we can determine if they will
	return or not... */
	for (i = 0; i < last_bb; i++)
	{
	basic_block bb = BASIC_BLOCK (i);
	block_stmt_iterator bsi;
	tree stmt, last_stmt;

	if (!bb)
	continue;

	if (blocks && !TEST_BIT (blocks, i))
	continue;

	bsi = bsi_last (bb);
	if (!bsi_end_p (bsi))
	{
	last_stmt = bsi_stmt (bsi);
	do
	{
	stmt = bsi_stmt (bsi);
	if (need_fake_edge_p (stmt))
	{
	edge e;
	/* The handling above of the final block before the
	epilogue should be enough to verify that there is
	no edge to the exit block in CFG already.
	Calling make_edge in such case would cause us to
	mark that edge as fake and remove it later. */
	#ifdef ENABLE_CHECKING
	if (stmt == last_stmt)
	{
	e = find_edge (bb, EXIT_BLOCK_PTR);
	gcc_assert (e == NULL);
	}
	#endif

	/* Note that the following may create a new basic block
	and renumber the existing basic blocks. */
	if (stmt != last_stmt)
	{
	e = split_block (bb, stmt);
	if (e)
	blocks_split++;
	}
	make_edge (bb, EXIT_BLOCK_PTR, EDGE_FAKE);
	}
	bsi_prev (&bsi);
	}
	while (!bsi_end_p (bsi));
	}
	}

	if (blocks_split)
	verify_flow_info ();

	return blocks_split;
	}

	/* Purge dead abnormal call edges from basic block BB. */

	bool
	tree_purge_dead_abnormal_call_edges (basic_block bb)
	{
	bool changed = tree_purge_dead_eh_edges (bb);

	if (current_function_has_nonlocal_label)
	{
	tree stmt = last_stmt (bb);
	edge_iterator ei;
	edge e;

	if (!(stmt && tree_can_make_abnormal_goto (stmt)))
	for (ei = ei_start (bb->succs); (e = ei_safe_edge (ei)); )
	{
	if (e->flags & EDGE_ABNORMAL)
	{
	remove_edge (e);
	changed = true;
	}
	else
	ei_next (&ei);
	}

	/* See tree_purge_dead_eh_edges below. */
	if (changed)
	free_dominance_info (CDI_DOMINATORS);
	}

	return changed;
	}

	/* Purge dead EH edges from basic block BB. */

	bool
	tree_purge_dead_eh_edges (basic_block bb)
	{
	bool changed = false;
	edge e;
	edge_iterator ei;
	tree stmt = last_stmt (bb);

	if (stmt && tree_can_throw_internal (stmt))
	return false;

	for (ei = ei_start (bb->succs); (e = ei_safe_edge (ei)); )
	{
	if (e->flags & EDGE_EH)
	{
	remove_edge (e);
	changed = true;
	}
	else
	ei_next (&ei);
	}

	/* Removal of dead EH edges might change dominators of not
	just immediate successors. E.g. when bb1 is changed so that
	it no longer can throw and bb1->bb3 and bb1->bb4 are dead
	eh edges purged by this function in:
	0
	/ \
	v v
	1-->2
	/ \ \|
	v v \|
	3-->4 \|
	\ v
	--->5
	\|
	-
	idom(bb5) must be recomputed. For now just free the dominance
	info. */
	if (changed)
	free_dominance_info (CDI_DOMINATORS);

	return changed;
	}

	bool
	tree_purge_all_dead_eh_edges (bitmap blocks)
	{
	bool changed = false;
	unsigned i;
	bitmap_iterator bi;

	EXECUTE_IF_SET_IN_BITMAP (blocks, 0, i, bi)
	{
	changed \|= tree_purge_dead_eh_edges (BASIC_BLOCK (i));
	}

	return changed;
	}

	/* This function is called whenever a new edge is created or
	redirected. */

	static void
	tree_execute_on_growing_pred (edge e)
	{
	basic_block bb = e->dest;

	if (phi_nodes (bb))
	reserve_phi_args_for_new_edge (bb);
	}

	/* This function is called immediately before edge E is removed from
	the edge vector E->dest->preds. */

	static void
	tree_execute_on_shrinking_pred (edge e)
	{
	if (phi_nodes (e->dest))
	remove_phi_args (e);
	}

	/*---------------------------------------------------------------------------
	Helper functions for Loop versioning
	---------------------------------------------------------------------------*/

	/* Adjust phi nodes for 'first' basic block. 'second' basic block is a copy
	of 'first'. Both of them are dominated by 'new_head' basic block. When
	'new_head' was created by 'second's incoming edge it received phi arguments
	on the edge by split_edge(). Later, additional edge 'e' was created to
	connect 'new_head' and 'first'. Now this routine adds phi args on this
	additional edge 'e' that new_head to second edge received as part of edge
	splitting.
	*/

	static void
	tree_lv_adjust_loop_header_phi (basic_block first, basic_block second,
	basic_block new_head, edge e)
	{
	tree phi1, phi2;
	edge e2 = find_edge (new_head, second);

	/* Because NEW_HEAD has been created by splitting SECOND's incoming
	edge, we should always have an edge from NEW_HEAD to SECOND. */
	gcc_assert (e2 != NULL);

	/* Browse all 'second' basic block phi nodes and add phi args to
	edge 'e' for 'first' head. PHI args are always in correct order. */

	for (phi2 = phi_nodes (second), phi1 = phi_nodes (first);
	phi2 && phi1;
	phi2 = PHI_CHAIN (phi2), phi1 = PHI_CHAIN (phi1))
	{
	tree def = PHI_ARG_DEF (phi2, e2->dest_idx);
	add_phi_arg (phi1, def, e);
	}
	}

	/* Adds a if else statement to COND_BB with condition COND_EXPR.
	SECOND_HEAD is the destination of the THEN and FIRST_HEAD is
	the destination of the ELSE part. */
	static void
	tree_lv_add_condition_to_bb (basic_block first_head, basic_block second_head,
	basic_block cond_bb, void *cond_e)
	{
	block_stmt_iterator bsi;
	tree goto1 = NULL_TREE;
	tree goto2 = NULL_TREE;
	tree new_cond_expr = NULL_TREE;
	tree cond_expr = (tree) cond_e;
	edge e0;

	/* Build new conditional expr */
	goto1 = build1 (GOTO_EXPR, void_type_node, tree_block_label (first_head));
	goto2 = build1 (GOTO_EXPR, void_type_node, tree_block_label (second_head));
	new_cond_expr = build3 (COND_EXPR, void_type_node, cond_expr, goto1, goto2);

	/* Add new cond in cond_bb. */
	bsi = bsi_start (cond_bb);
	bsi_insert_after (&bsi, new_cond_expr, BSI_NEW_STMT);
	/* Adjust edges appropriately to connect new head with first head
	as well as second head. */
	e0 = single_succ_edge (cond_bb);
	e0->flags &= ~EDGE_FALLTHRU;
	e0->flags \|= EDGE_FALSE_VALUE;
	}

	struct cfg_hooks tree_cfg_hooks = {
	"tree",
	tree_verify_flow_info,
	tree_dump_bb, /* dump_bb */
	create_bb, /* create_basic_block */
	tree_redirect_edge_and_branch,/* redirect_edge_and_branch */
	tree_redirect_edge_and_branch_force,/* redirect_edge_and_branch_force */
	remove_bb, /* delete_basic_block */
	tree_split_block, /* split_block */
	tree_move_block_after, /* move_block_after */
	tree_can_merge_blocks_p, /* can_merge_blocks_p */
	tree_merge_blocks, /* merge_blocks */
	tree_predict_edge, /* predict_edge */
	tree_predicted_by_p, /* predicted_by_p */
	tree_can_duplicate_bb_p, /* can_duplicate_block_p */
	tree_duplicate_bb, /* duplicate_block */
	tree_split_edge, /* split_edge */
	tree_make_forwarder_block, /* make_forward_block */
	NULL, /* tidy_fallthru_edge */
	tree_block_ends_with_call_p, /* block_ends_with_call_p */
	tree_block_ends_with_condjump_p, /* block_ends_with_condjump_p */
	tree_flow_call_edges_add, /* flow_call_edges_add */
	tree_execute_on_growing_pred, /* execute_on_growing_pred */
	tree_execute_on_shrinking_pred, /* execute_on_shrinking_pred */
	tree_duplicate_loop_to_header_edge, /* duplicate loop for trees */
	tree_lv_add_condition_to_bb, /* lv_add_condition_to_bb */
	tree_lv_adjust_loop_header_phi, /* lv_adjust_loop_header_phi*/
	extract_true_false_edges_from_block, /* extract_cond_bb_edges */
	flush_pending_stmts /* flush_pending_stmts */
	};


	/* Split all critical edges. */

	static unsigned int
	split_critical_edges (void)
	{
	basic_block bb;
	edge e;
	edge_iterator ei;

	/* split_edge can redirect edges out of SWITCH_EXPRs, which can get
	expensive. So we want to enable recording of edge to CASE_LABEL_EXPR
	mappings around the calls to split_edge. */
	start_recording_case_labels ();
	FOR_ALL_BB (bb)
	{
	FOR_EACH_EDGE (e, ei, bb->succs)
	if (EDGE_CRITICAL_P (e) && !(e->flags & EDGE_ABNORMAL))
	{
	split_edge (e);
	}
	}
	end_recording_case_labels ();
	return 0;
	}

	struct tree_opt_pass pass_split_crit_edges =
	{
	"crited", /* name */
	NULL, /* gate */
	split_critical_edges, /* execute */
	NULL, /* sub */
	NULL, /* next */
	0, /* static_pass_number */
	TV_TREE_SPLIT_EDGES, /* tv_id */
	PROP_cfg, /* properties required */
	PROP_no_crit_edges, /* properties_provided */
	0, /* properties_destroyed */
	0, /* todo_flags_start */
	TODO_dump_func, /* todo_flags_finish */
	0 /* letter */
	};


	/* Return EXP if it is a valid GIMPLE rvalue, else gimplify it into
	a temporary, make sure and register it to be renamed if necessary,
	and finally return the temporary. Put the statements to compute
	EXP before the current statement in BSI. */

	tree
	gimplify_val (block_stmt_iterator *bsi, tree type, tree exp)
	{
	tree t, new_stmt, orig_stmt;

	if (is_gimple_val (exp))
	return exp;

	t = make_rename_temp (type, NULL);
	new_stmt = build2 (MODIFY_EXPR, type, t, exp);

	orig_stmt = bsi_stmt (*bsi);
	SET_EXPR_LOCUS (new_stmt, EXPR_LOCUS (orig_stmt));
	TREE_BLOCK (new_stmt) = TREE_BLOCK (orig_stmt);

	bsi_insert_before (bsi, new_stmt, BSI_SAME_STMT);
	if (in_ssa_p)
	mark_new_vars_to_rename (new_stmt);

	return t;
	}

	/* Build a ternary operation and gimplify it. Emit code before BSI.
	Return the gimple_val holding the result. */

	tree
	gimplify_build3 (block_stmt_iterator *bsi, enum tree_code code,
	tree type, tree a, tree b, tree c)
	{
	tree ret;

	ret = fold_build3 (code, type, a, b, c);
	STRIP_NOPS (ret);

	return gimplify_val (bsi, type, ret);
	}

	/* Build a binary operation and gimplify it. Emit code before BSI.
	Return the gimple_val holding the result. */

	tree
	gimplify_build2 (block_stmt_iterator *bsi, enum tree_code code,
	tree type, tree a, tree b)
	{
	tree ret;

	ret = fold_build2 (code, type, a, b);
	STRIP_NOPS (ret);

	return gimplify_val (bsi, type, ret);
	}

	/* Build a unary operation and gimplify it. Emit code before BSI.
	Return the gimple_val holding the result. */

	tree
	gimplify_build1 (block_stmt_iterator *bsi, enum tree_code code, tree type,
	tree a)
	{
	tree ret;

	ret = fold_build1 (code, type, a);
	STRIP_NOPS (ret);

	return gimplify_val (bsi, type, ret);
	}



	/* Emit return warnings. */

	static unsigned int
	execute_warn_function_return (void)
	{
	#ifdef USE_MAPPED_LOCATION
	source_location location;
	#else
	location_t *locus;
	#endif
	tree last;
	edge e;
	edge_iterator ei;

	/* If we have a path to EXIT, then we do return. */
	if (TREE_THIS_VOLATILE (cfun->decl)
	&& EDGE_COUNT (EXIT_BLOCK_PTR->preds) > 0)
	{
	#ifdef USE_MAPPED_LOCATION
	location = UNKNOWN_LOCATION;
	#else
	locus = NULL;
	#endif
	FOR_EACH_EDGE (e, ei, EXIT_BLOCK_PTR->preds)
	{
	last = last_stmt (e->src);
	if (TREE_CODE (last) == RETURN_EXPR
	#ifdef USE_MAPPED_LOCATION
	&& (location = EXPR_LOCATION (last)) != UNKNOWN_LOCATION)
	#else
	&& (locus = EXPR_LOCUS (last)) != NULL)
	#endif
	break;
	}
	#ifdef USE_MAPPED_LOCATION
	if (location == UNKNOWN_LOCATION)
	location = cfun->function_end_locus;
	warning (0, "%H%<noreturn%> function does return", &location);
	#else
	if (!locus)
	locus = &cfun->function_end_locus;
	warning (0, "%H%<noreturn%> function does return", locus);
	#endif
	}

	/* If we see "return;" in some basic block, then we do reach the end
	without returning a value. */
	else if (warn_return_type
	&& !TREE_NO_WARNING (cfun->decl)
	&& EDGE_COUNT (EXIT_BLOCK_PTR->preds) > 0
	&& !VOID_TYPE_P (TREE_TYPE (TREE_TYPE (cfun->decl))))
	{
	FOR_EACH_EDGE (e, ei, EXIT_BLOCK_PTR->preds)
	{
	tree last = last_stmt (e->src);
	if (TREE_CODE (last) == RETURN_EXPR
	&& TREE_OPERAND (last, 0) == NULL
	&& !TREE_NO_WARNING (last))
	{
	#ifdef USE_MAPPED_LOCATION
	location = EXPR_LOCATION (last);
	if (location == UNKNOWN_LOCATION)
	location = cfun->function_end_locus;
	warning (0, "%Hcontrol reaches end of non-void function", &location);
	#else
	locus = EXPR_LOCUS (last);
	if (!locus)
	locus = &cfun->function_end_locus;
	warning (0, "%Hcontrol reaches end of non-void function", locus);
	#endif
	TREE_NO_WARNING (cfun->decl) = 1;
	break;
	}
	}
	}
	return 0;
	}


	/* Given a basic block B which ends with a conditional and has
	precisely two successors, determine which of the edges is taken if
	the conditional is true and which is taken if the conditional is
	false. Set TRUE_EDGE and FALSE_EDGE appropriately. */

	void
	extract_true_false_edges_from_block (basic_block b,
	edge *true_edge,
	edge *false_edge)
	{
	edge e = EDGE_SUCC (b, 0);

	if (e->flags & EDGE_TRUE_VALUE)
	{
	*true_edge = e;
	*false_edge = EDGE_SUCC (b, 1);
	}
	else
	{
	*false_edge = e;
	*true_edge = EDGE_SUCC (b, 1);
	}
	}

	struct tree_opt_pass pass_warn_function_return =
	{
	NULL, /* name */
	NULL, /* gate */
	execute_warn_function_return, /* execute */
	NULL, /* sub */
	NULL, /* next */
	0, /* static_pass_number */
	0, /* tv_id */
	PROP_cfg, /* properties_required */
	0, /* properties_provided */
	0, /* properties_destroyed */
	0, /* todo_flags_start */
	0, /* todo_flags_finish */
	0 /* letter */
	};

	/* Emit noreturn warnings. */

	static unsigned int
	execute_warn_function_noreturn (void)
	{
	if (warn_missing_noreturn
	&& !TREE_THIS_VOLATILE (cfun->decl)
	&& EDGE_COUNT (EXIT_BLOCK_PTR->preds) == 0
	&& !lang_hooks.function.missing_noreturn_ok_p (cfun->decl))
	warning (OPT_Wmissing_noreturn, "%Jfunction might be possible candidate "
	"for attribute %<noreturn%>",
	cfun->decl);
	return 0;
	}

	struct tree_opt_pass pass_warn_function_noreturn =
	{
	NULL, /* name */
	NULL, /* gate */
	execute_warn_function_noreturn, /* execute */
	NULL, /* sub */
	NULL, /* next */
	0, /* static_pass_number */
	0, /* tv_id */
	PROP_cfg, /* properties_required */
	0, /* properties_provided */
	0, /* properties_destroyed */
	0, /* todo_flags_start */
	0, /* todo_flags_finish */
	0 /* letter */
	};
	diff --git a/contrib/gcc/tree.h b/contrib/gcc/tree.h
	index 6cfc3d375ccb..e8870f0ef6e3 100644
	--- a/contrib/gcc/tree.h
	+++ b/contrib/gcc/tree.h
	@@ -1,4649 +1,4664 @@
	/* Front-end tree definitions for GNU compiler.
	Copyright (C) 1989, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
	2001, 2002, 2003, 2004, 2005, 2006 Free Software Foundation, Inc.

	This file is part of GCC.

	GCC is free software; you can redistribute it and/or modify it under
	the terms of the GNU General Public License as published by the Free
	Software Foundation; either version 2, or (at your option) any later
	version.

	GCC is distributed in the hope that it will be useful, but WITHOUT ANY
	WARRANTY; without even the implied warranty of MERCHANTABILITY or
	FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	for more details.

	You should have received a copy of the GNU General Public License
	along with GCC; see the file COPYING. If not, write to the Free
	Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
	02110-1301, USA. */

	#ifndef GCC_TREE_H
	#define GCC_TREE_H

	#include <sys/param.h>
	#ifndef __PAST_END
	# define __PAST_END(array, offset) (((typeof((array)) )(array))[offset])
	#endif

	#include "hashtab.h"
	#include "machmode.h"
	#include "input.h"
	#include "statistics.h"
	#include "vec.h"

	/* Codes of tree nodes */

	#define DEFTREECODE(SYM, STRING, TYPE, NARGS) SYM,

	enum tree_code {
	#include "tree.def"

	LAST_AND_UNUSED_TREE_CODE /* A convenient way to get a value for
	NUM_TREE_CODES. */
	};

	#undef DEFTREECODE

	extern unsigned char tree_contains_struct[256][64];
	#define CODE_CONTAINS_STRUCT(CODE, STRUCT) (tree_contains_struct[(CODE)][(STRUCT)])

	/* Number of language-independent tree codes. */
	#define NUM_TREE_CODES ((int) LAST_AND_UNUSED_TREE_CODE)

	/* Tree code classes. */

	/* Each tree_code has an associated code class represented by a
	TREE_CODE_CLASS. */

	enum tree_code_class {
	tcc_exceptional, /* An exceptional code (fits no category). */
	tcc_constant, /* A constant. */
	/* Order of tcc_type and tcc_declaration is important. */
	tcc_type, /* A type object code. */
	tcc_declaration, /* A declaration (also serving as variable refs). */
	tcc_reference, /* A reference to storage. */
	tcc_comparison, /* A comparison expression. */
	tcc_unary, /* A unary arithmetic expression. */
	tcc_binary, /* A binary arithmetic expression. */
	tcc_statement, /* A statement expression, which have side effects
	but usually no interesting value. */
	tcc_expression /* Any other expression. */
	};

	/* Each tree code class has an associated string representation.
	These must correspond to the tree_code_class entries. */

	extern const char *const tree_code_class_strings[];

	/* Returns the string representing CLASS. */

	#define TREE_CODE_CLASS_STRING(CLASS)\
	tree_code_class_strings[(int) (CLASS)]

	#define MAX_TREE_CODES 256
	extern const enum tree_code_class tree_code_type[];
	#define TREE_CODE_CLASS(CODE) tree_code_type[(int) (CODE)]

	/* Nonzero if CODE represents an exceptional code. */

	#define EXCEPTIONAL_CLASS_P(CODE)\
	(TREE_CODE_CLASS (TREE_CODE (CODE)) == tcc_exceptional)

	/* Nonzero if CODE represents a constant. */

	#define CONSTANT_CLASS_P(CODE)\
	(TREE_CODE_CLASS (TREE_CODE (CODE)) == tcc_constant)

	/* Nonzero if CODE represents a type. */

	#define TYPE_P(CODE)\
	(TREE_CODE_CLASS (TREE_CODE (CODE)) == tcc_type)

	/* Nonzero if CODE represents a declaration. */

	#define DECL_P(CODE)\
	(TREE_CODE_CLASS (TREE_CODE (CODE)) == tcc_declaration)

	/* Nonzero if CODE represents a memory tag. */

	#define MTAG_P(CODE) \
	(TREE_CODE (CODE) == STRUCT_FIELD_TAG \
	\|\| TREE_CODE (CODE) == NAME_MEMORY_TAG \
	\|\| TREE_CODE (CODE) == SYMBOL_MEMORY_TAG)


	/* Nonzero if DECL represents a VAR_DECL or FUNCTION_DECL. */

	#define VAR_OR_FUNCTION_DECL_P(DECL)\
	(TREE_CODE (DECL) == VAR_DECL \|\| TREE_CODE (DECL) == FUNCTION_DECL)

	/* Nonzero if CODE represents a INDIRECT_REF. Keep these checks in
	ascending code order. */

	#define INDIRECT_REF_P(CODE)\
	(TREE_CODE (CODE) == INDIRECT_REF \
	\|\| TREE_CODE (CODE) == ALIGN_INDIRECT_REF \
	\|\| TREE_CODE (CODE) == MISALIGNED_INDIRECT_REF)

	/* Nonzero if CODE represents a reference. */

	#define REFERENCE_CLASS_P(CODE)\
	(TREE_CODE_CLASS (TREE_CODE (CODE)) == tcc_reference)

	/* Nonzero if CODE represents a comparison. */

	#define COMPARISON_CLASS_P(CODE)\
	(TREE_CODE_CLASS (TREE_CODE (CODE)) == tcc_comparison)

	/* Nonzero if CODE represents a unary arithmetic expression. */

	#define UNARY_CLASS_P(CODE)\
	(TREE_CODE_CLASS (TREE_CODE (CODE)) == tcc_unary)

	/* Nonzero if CODE represents a binary arithmetic expression. */

	#define BINARY_CLASS_P(CODE)\
	(TREE_CODE_CLASS (TREE_CODE (CODE)) == tcc_binary)

	/* Nonzero if CODE represents a statement expression. */

	#define STATEMENT_CLASS_P(CODE)\
	(TREE_CODE_CLASS (TREE_CODE (CODE)) == tcc_statement)

	/* Nonzero if CODE represents any other expression. */

	#define EXPRESSION_CLASS_P(CODE)\
	(TREE_CODE_CLASS (TREE_CODE (CODE)) == tcc_expression)

	/* Returns nonzero iff CODE represents a type or declaration. */

	#define IS_TYPE_OR_DECL_P(CODE)\
	(TYPE_P (CODE) \|\| DECL_P (CODE))

	/* Returns nonzero iff CLASS is the tree-code class of an
	expression. */

	#define IS_EXPR_CODE_CLASS(CLASS)\
	((CLASS) >= tcc_reference && (CLASS) <= tcc_expression)

	/* Returns nonzero iff NODE is an expression of some kind. */

	#define EXPR_P(NODE) IS_EXPR_CODE_CLASS (TREE_CODE_CLASS (TREE_CODE (NODE)))

	/* Returns nonzero iff NODE is an OpenMP directive. */

	#define OMP_DIRECTIVE_P(NODE) \
	(TREE_CODE (NODE) == OMP_PARALLEL \
	\|\| TREE_CODE (NODE) == OMP_FOR \
	\|\| TREE_CODE (NODE) == OMP_SECTIONS \
	\|\| TREE_CODE (NODE) == OMP_SINGLE \
	\|\| TREE_CODE (NODE) == OMP_SECTION \
	\|\| TREE_CODE (NODE) == OMP_MASTER \
	\|\| TREE_CODE (NODE) == OMP_ORDERED \
	\|\| TREE_CODE (NODE) == OMP_CRITICAL \
	\|\| TREE_CODE (NODE) == OMP_RETURN \
	\|\| TREE_CODE (NODE) == OMP_CONTINUE)

	/* Number of argument-words in each kind of tree-node. */

	extern const unsigned char tree_code_length[];
	#define TREE_CODE_LENGTH(CODE) tree_code_length[(int) (CODE)]

	/* Names of tree components. */

	extern const char *const tree_code_name[];

	/* A vectors of trees. */
	DEF_VEC_P(tree);
	DEF_VEC_ALLOC_P(tree,gc);
	DEF_VEC_ALLOC_P(tree,heap);


	/* Classify which part of the compiler has defined a given builtin function.
	Note that we assume below that this is no more than two bits. */
	enum built_in_class
	{
	NOT_BUILT_IN = 0,
	BUILT_IN_FRONTEND,
	BUILT_IN_MD,
	BUILT_IN_NORMAL
	};

	/* Names for the above. */
	extern const char *const built_in_class_names[4];

	/* Codes that identify the various built in functions
	so that expand_call can identify them quickly. */

	#define DEF_BUILTIN(ENUM, N, C, T, LT, B, F, NA, AT, IM, COND) ENUM,
	enum built_in_function
	{
	#include "builtins.def"

	/* Complex division routines in libgcc. These are done via builtins
	because emit_library_call_value can't handle complex values. */
	BUILT_IN_COMPLEX_MUL_MIN,
	BUILT_IN_COMPLEX_MUL_MAX
	= BUILT_IN_COMPLEX_MUL_MIN
	+ MAX_MODE_COMPLEX_FLOAT
	- MIN_MODE_COMPLEX_FLOAT,

	BUILT_IN_COMPLEX_DIV_MIN,
	BUILT_IN_COMPLEX_DIV_MAX
	= BUILT_IN_COMPLEX_DIV_MIN
	+ MAX_MODE_COMPLEX_FLOAT
	- MIN_MODE_COMPLEX_FLOAT,

	/* Upper bound on non-language-specific builtins. */
	END_BUILTINS
	};
	#undef DEF_BUILTIN

	/* Names for the above. */
	extern const char * built_in_names[(int) END_BUILTINS];

	/* Helper macros for math builtins. */

	#define BUILTIN_EXP10_P(FN) \
	((FN) == BUILT_IN_EXP10 \|\| (FN) == BUILT_IN_EXP10F \|\| (FN) == BUILT_IN_EXP10L \
	\|\| (FN) == BUILT_IN_POW10 \|\| (FN) == BUILT_IN_POW10F \|\| (FN) == BUILT_IN_POW10L)

	#define BUILTIN_EXPONENT_P(FN) (BUILTIN_EXP10_P (FN) \
	\|\| (FN) == BUILT_IN_EXP \|\| (FN) == BUILT_IN_EXPF \|\| (FN) == BUILT_IN_EXPL \
	\|\| (FN) == BUILT_IN_EXP2 \|\| (FN) == BUILT_IN_EXP2F \|\| (FN) == BUILT_IN_EXP2L)

	#define BUILTIN_SQRT_P(FN) \
	((FN) == BUILT_IN_SQRT \|\| (FN) == BUILT_IN_SQRTF \|\| (FN) == BUILT_IN_SQRTL)

	#define BUILTIN_CBRT_P(FN) \
	((FN) == BUILT_IN_CBRT \|\| (FN) == BUILT_IN_CBRTF \|\| (FN) == BUILT_IN_CBRTL)

	#define BUILTIN_ROOT_P(FN) (BUILTIN_SQRT_P (FN) \|\| BUILTIN_CBRT_P (FN))

	#define CASE_FLT_FN(FN) case FN: case FN##F: case FN##L
	#define CASE_INT_FN(FN) case FN: case FN##L: case FN##LL

	/* An array of _DECL trees for the above. */
	extern GTY(()) tree built_in_decls[(int) END_BUILTINS];
	extern GTY(()) tree implicit_built_in_decls[(int) END_BUILTINS];

	/* In an OMP_CLAUSE node. */

	/* Number of operands and names for each clause. */
	extern unsigned const char omp_clause_num_ops[];
	extern const char * const omp_clause_code_name[];

	/* Clause codes. Do not reorder, as this is used to index into the tables
	omp_clause_num_ops and omp_clause_code_name. */
	enum omp_clause_code
	{
	/* Clause zero is special-cased inside the parser
	(c_parser_omp_variable_list). */
	OMP_CLAUSE_ERROR = 0,

	/* OpenMP clause: private (variable_list). */
	OMP_CLAUSE_PRIVATE,

	/* OpenMP clause: shared (variable_list). */
	OMP_CLAUSE_SHARED,

	/* OpenMP clause: firstprivate (variable_list). */
	OMP_CLAUSE_FIRSTPRIVATE,

	/* OpenMP clause: lastprivate (variable_list). */
	OMP_CLAUSE_LASTPRIVATE,

	/* OpenMP clause: reduction (operator:variable_list).
	OMP_CLAUSE_REDUCTION_CODE: The tree_code of the operator.
	Operand 1: OMP_CLAUSE_REDUCTION_INIT: Stmt-list to initialize the var.
	Operand 2: OMP_CLAUSE_REDUCTION_MERGE: Stmt-list to merge private var
	into the shared one.
	Operand 3: OMP_CLAUSE_REDUCTION_PLACEHOLDER: A dummy VAR_DECL
	placeholder used in OMP_CLAUSE_REDUCTION_MERGE. */
	OMP_CLAUSE_REDUCTION,

	/* OpenMP clause: copyin (variable_list). */
	OMP_CLAUSE_COPYIN,

	/* OpenMP clause: copyprivate (variable_list). */
	OMP_CLAUSE_COPYPRIVATE,

	/* OpenMP clause: if (scalar-expression). */
	OMP_CLAUSE_IF,

	/* OpenMP clause: num_threads (integer-expression). */
	OMP_CLAUSE_NUM_THREADS,

	/* OpenMP clause: schedule. */
	OMP_CLAUSE_SCHEDULE,

	/* OpenMP clause: nowait. */
	OMP_CLAUSE_NOWAIT,

	/* OpenMP clause: ordered. */
	OMP_CLAUSE_ORDERED,

	/* OpenMP clause: default. */
	OMP_CLAUSE_DEFAULT
	};

	/* The definition of tree nodes fills the next several pages. */

	/* A tree node can represent a data type, a variable, an expression
	or a statement. Each node has a TREE_CODE which says what kind of
	thing it represents. Some common codes are:
	INTEGER_TYPE -- represents a type of integers.
	ARRAY_TYPE -- represents a type of pointer.
	VAR_DECL -- represents a declared variable.
	INTEGER_CST -- represents a constant integer value.
	PLUS_EXPR -- represents a sum (an expression).

	As for the contents of a tree node: there are some fields
	that all nodes share. Each TREE_CODE has various special-purpose
	fields as well. The fields of a node are never accessed directly,
	always through accessor macros. */

	/* Every kind of tree node starts with this structure,
	so all nodes have these fields.

	See the accessor macros, defined below, for documentation of the
	fields. */
	union tree_ann_d;

	struct tree_common GTY(())
	{
	tree chain;
	tree type;
	union tree_ann_d *ann;

	ENUM_BITFIELD(tree_code) code : 8;

	unsigned side_effects_flag : 1;
	unsigned constant_flag : 1;
	unsigned addressable_flag : 1;
	unsigned volatile_flag : 1;
	unsigned readonly_flag : 1;
	unsigned unsigned_flag : 1;
	unsigned asm_written_flag: 1;
	unsigned nowarning_flag : 1;

	unsigned used_flag : 1;
	unsigned nothrow_flag : 1;
	unsigned static_flag : 1;
	unsigned public_flag : 1;
	unsigned private_flag : 1;
	unsigned protected_flag : 1;
	unsigned deprecated_flag : 1;
	unsigned invariant_flag : 1;

	unsigned lang_flag_0 : 1;
	unsigned lang_flag_1 : 1;
	unsigned lang_flag_2 : 1;
	unsigned lang_flag_3 : 1;
	unsigned lang_flag_4 : 1;
	unsigned lang_flag_5 : 1;
	unsigned lang_flag_6 : 1;
	unsigned visited : 1;
	+ /* APPLE LOCAL "unavailable" attribute (Radar 2809697) --ilr */
	+ unsigned unavailable_flag : 1;
	};

	/* The following table lists the uses of each of the above flags and
	for which types of nodes they are defined. Note that expressions
	include decls.

	addressable_flag:

	TREE_ADDRESSABLE in
	VAR_DECL, FUNCTION_DECL, FIELD_DECL, CONSTRUCTOR, LABEL_DECL,
	..._TYPE, IDENTIFIER_NODE.
	In a STMT_EXPR, it means we want the result of the enclosed
	expression.
	CALL_EXPR_TAILCALL in CALL_EXPR
	CASE_LOW_SEEN in CASE_LABEL_EXPR

	static_flag:

	TREE_STATIC in
	VAR_DECL, FUNCTION_DECL, CONSTRUCTOR, ADDR_EXPR
	BINFO_VIRTUAL_P in
	TREE_BINFO
	TREE_CONSTANT_OVERFLOW in
	INTEGER_CST, REAL_CST, COMPLEX_CST, VECTOR_CST
	TREE_SYMBOL_REFERENCED in
	IDENTIFIER_NODE
	CLEANUP_EH_ONLY in
	TARGET_EXPR, WITH_CLEANUP_EXPR
	ASM_INPUT_P in
	ASM_EXPR
	EH_FILTER_MUST_NOT_THROW in EH_FILTER_EXPR
	TYPE_REF_CAN_ALIAS_ALL in
	POINTER_TYPE, REFERENCE_TYPE
	CASE_HIGH_SEEN in CASE_LABEL_EXPR

	public_flag:

	TREE_OVERFLOW in
	INTEGER_CST, REAL_CST, COMPLEX_CST, VECTOR_CST
	TREE_PUBLIC in
	VAR_DECL or FUNCTION_DECL or IDENTIFIER_NODE
	ASM_VOLATILE_P in
	ASM_EXPR
	TYPE_CACHED_VALUES_P in
	..._TYPE
	SAVE_EXPR_RESOLVED_P in
	SAVE_EXPR
	OMP_CLAUSE_LASTPRIVATE_FIRSTPRIVATE in
	OMP_CLAUSE_LASTPRIVATE
	OMP_CLAUSE_PRIVATE_DEBUG in
	OMP_CLAUSE_PRIVATE

	private_flag:

	TREE_PRIVATE in
	..._DECL
	CALL_EXPR_RETURN_SLOT_OPT in
	CALL_EXPR
	DECL_BY_REFERENCE in
	PARM_DECL, RESULT_DECL
	OMP_RETURN_NOWAIT in
	OMP_RETURN
	OMP_SECTION_LAST in
	OMP_SECTION
	OMP_PARALLEL_COMBINED in
	OMP_PARALLEL

	protected_flag:

	TREE_PROTECTED in
	BLOCK
	..._DECL
	CALL_FROM_THUNK_P in
	CALL_EXPR

	side_effects_flag:

	TREE_SIDE_EFFECTS in
	all expressions
	all decls
	all constants

	FORCED_LABEL in
	LABEL_DECL

	volatile_flag:

	TREE_THIS_VOLATILE in
	all expressions
	TYPE_VOLATILE in
	..._TYPE

	readonly_flag:

	TREE_READONLY in
	all expressions
	TYPE_READONLY in
	..._TYPE

	constant_flag:

	TREE_CONSTANT in
	all expressions
	all decls
	all constants
	TYPE_SIZES_GIMPLIFIED
	..._TYPE

	unsigned_flag:

	TYPE_UNSIGNED in
	all types
	DECL_UNSIGNED in
	all decls
	BIT_FIELD_REF_UNSIGNED in
	BIT_FIELD_REF

	asm_written_flag:

	TREE_ASM_WRITTEN in
	VAR_DECL, FUNCTION_DECL, RECORD_TYPE, UNION_TYPE, QUAL_UNION_TYPE
	BLOCK, SSA_NAME

	used_flag:

	TREE_USED in
	expressions, IDENTIFIER_NODE

	nothrow_flag:

	TREE_NOTHROW in
	CALL_EXPR, FUNCTION_DECL

	TYPE_ALIGN_OK in
	..._TYPE

	TREE_THIS_NOTRAP in
	(ALIGN/MISALIGNED_)INDIRECT_REF, ARRAY_REF, ARRAY_RANGE_REF

	deprecated_flag:

	TREE_DEPRECATED in
	..._DECL

	IDENTIFIER_TRANSPARENT_ALIAS in
	IDENTIFIER_NODE

	+ APPLE LOCAL begin "unavailable" attribute (Radar 2809697)
	+ unavailable_flag:
	+
	+ TREE_UNAVAILABLE in
	+ ..._DECL
	+ APPLE LOCAL end "unavailable" attribute (Radar 2809697)
	+
	visited:

	Used in tree traversals to mark visited nodes.

	invariant_flag:

	TREE_INVARIANT in
	all expressions.

	nowarning_flag:

	TREE_NO_WARNING in
	... any expr or decl node
	*/
	#undef DEFTREESTRUCT
	#define DEFTREESTRUCT(ENUM, NAME) ENUM,
	enum tree_node_structure_enum {
	#include "treestruct.def"
	LAST_TS_ENUM
	};
	#undef DEFTREESTRUCT

	/* Define accessors for the fields that all tree nodes have
	(though some fields are not used for all kinds of nodes). */

	/* The tree-code says what kind of node it is.
	Codes are defined in tree.def. */
	#define TREE_CODE(NODE) ((enum tree_code) (NODE)->common.code)
	#define TREE_SET_CODE(NODE, VALUE) ((NODE)->common.code = (VALUE))

	/* When checking is enabled, errors will be generated if a tree node
	is accessed incorrectly. The macros die with a fatal error. */
	#if defined ENABLE_TREE_CHECKING && (GCC_VERSION >= 2007)

	#define TREE_CHECK(T, CODE) __extension__ \
	({ const tree __t = (T); \
	if (TREE_CODE (__t) != (CODE)) \
	tree_check_failed (__t, __FILE__, __LINE__, __FUNCTION__, \
	(CODE), 0); \
	__t; })

	#define TREE_NOT_CHECK(T, CODE) __extension__ \
	({ const tree __t = (T); \
	if (TREE_CODE (__t) == (CODE)) \
	tree_not_check_failed (__t, __FILE__, __LINE__, __FUNCTION__, \
	(CODE), 0); \
	__t; })

	#define TREE_CHECK2(T, CODE1, CODE2) __extension__ \
	({ const tree __t = (T); \
	if (TREE_CODE (__t) != (CODE1) \
	&& TREE_CODE (__t) != (CODE2)) \
	tree_check_failed (__t, __FILE__, __LINE__, __FUNCTION__, \
	(CODE1), (CODE2), 0); \
	__t; })

	#define TREE_NOT_CHECK2(T, CODE1, CODE2) __extension__ \
	({ const tree __t = (T); \
	if (TREE_CODE (__t) == (CODE1) \
	\|\| TREE_CODE (__t) == (CODE2)) \
	tree_not_check_failed (__t, __FILE__, __LINE__, __FUNCTION__, \
	(CODE1), (CODE2), 0); \
	__t; })

	#define TREE_CHECK3(T, CODE1, CODE2, CODE3) __extension__ \
	({ const tree __t = (T); \
	if (TREE_CODE (__t) != (CODE1) \
	&& TREE_CODE (__t) != (CODE2) \
	&& TREE_CODE (__t) != (CODE3)) \
	tree_check_failed (__t, __FILE__, __LINE__, __FUNCTION__, \
	(CODE1), (CODE2), (CODE3), 0); \
	__t; })

	#define TREE_NOT_CHECK3(T, CODE1, CODE2, CODE3) __extension__ \
	({ const tree __t = (T); \
	if (TREE_CODE (__t) == (CODE1) \
	\|\| TREE_CODE (__t) == (CODE2) \
	\|\| TREE_CODE (__t) == (CODE3)) \
	tree_not_check_failed (__t, __FILE__, __LINE__, __FUNCTION__, \
	(CODE1), (CODE2), (CODE3), 0); \
	__t; })

	#define TREE_CHECK4(T, CODE1, CODE2, CODE3, CODE4) __extension__ \
	({ const tree __t = (T); \
	if (TREE_CODE (__t) != (CODE1) \
	&& TREE_CODE (__t) != (CODE2) \
	&& TREE_CODE (__t) != (CODE3) \
	&& TREE_CODE (__t) != (CODE4)) \
	tree_check_failed (__t, __FILE__, __LINE__, __FUNCTION__, \
	(CODE1), (CODE2), (CODE3), (CODE4), 0); \
	__t; })

	#define NON_TREE_CHECK4(T, CODE1, CODE2, CODE3, CODE4) __extension__ \
	({ const tree __t = (T); \
	if (TREE_CODE (__t) == (CODE1) \
	\|\| TREE_CODE (__t) == (CODE2) \
	\|\| TREE_CODE (__t) == (CODE3) \
	\|\| TREE_CODE (__t) == (CODE4)) \
	tree_not_check_failed (__t, __FILE__, __LINE__, __FUNCTION__, \
	(CODE1), (CODE2), (CODE3), (CODE4), 0); \
	__t; })

	#define TREE_CHECK5(T, CODE1, CODE2, CODE3, CODE4, CODE5) __extension__ \
	({ const tree __t = (T); \
	if (TREE_CODE (__t) != (CODE1) \
	&& TREE_CODE (__t) != (CODE2) \
	&& TREE_CODE (__t) != (CODE3) \
	&& TREE_CODE (__t) != (CODE4) \
	&& TREE_CODE (__t) != (CODE5)) \
	tree_check_failed (__t, __FILE__, __LINE__, __FUNCTION__, \
	(CODE1), (CODE2), (CODE3), (CODE4), (CODE5), 0);\
	__t; })

	#define TREE_NOT_CHECK5(T, CODE1, CODE2, CODE3, CODE4, CODE5) __extension__ \
	({ const tree __t = (T); \
	if (TREE_CODE (__t) == (CODE1) \
	\|\| TREE_CODE (__t) == (CODE2) \
	\|\| TREE_CODE (__t) == (CODE3) \
	\|\| TREE_CODE (__t) == (CODE4) \
	\|\| TREE_CODE (__t) == (CODE5)) \
	tree_not_check_failed (__t, __FILE__, __LINE__, __FUNCTION__, \
	(CODE1), (CODE2), (CODE3), (CODE4), (CODE5), 0);\
	__t; })

	#define CONTAINS_STRUCT_CHECK(T, STRUCT) __extension__ \
	({ const tree __t = (T); \
	if (tree_contains_struct[TREE_CODE(__t)][(STRUCT)] != 1) \
	tree_contains_struct_check_failed (__t, (STRUCT), __FILE__, __LINE__, \
	__FUNCTION__); \
	__t; })

	#define TREE_CLASS_CHECK(T, CLASS) __extension__ \
	({ const tree __t = (T); \
	if (TREE_CODE_CLASS (TREE_CODE(__t)) != (CLASS)) \
	tree_class_check_failed (__t, (CLASS), __FILE__, __LINE__, \
	__FUNCTION__); \
	__t; })

	#define TREE_RANGE_CHECK(T, CODE1, CODE2) __extension__ \
	({ const tree __t = (T); \
	if (TREE_CODE (__t) < (CODE1) \|\| TREE_CODE (__t) > (CODE2)) \
	tree_range_check_failed (__t, __FILE__, __LINE__, __FUNCTION__, \
	(CODE1), (CODE2)); \
	__t; })

	#define OMP_CLAUSE_SUBCODE_CHECK(T, CODE) __extension__ \
	({ const tree __t = (T); \
	if (TREE_CODE (__t) != OMP_CLAUSE) \
	tree_check_failed (__t, __FILE__, __LINE__, __FUNCTION__, \
	OMP_CLAUSE, 0); \
	if (__t->omp_clause.code != (CODE)) \
	omp_clause_check_failed (__t, __FILE__, __LINE__, __FUNCTION__, \
	(CODE)); \
	__t; })

	#define OMP_CLAUSE_RANGE_CHECK(T, CODE1, CODE2) __extension__ \
	({ const tree __t = (T); \
	if (TREE_CODE (__t) != OMP_CLAUSE) \
	tree_check_failed (__t, __FILE__, __LINE__, __FUNCTION__, \
	OMP_CLAUSE, 0); \
	if ((int) __t->omp_clause.code < (int) (CODE1) \
	\|\| (int) __t->omp_clause.code > (int) (CODE2)) \
	omp_clause_range_check_failed (__t, __FILE__, __LINE__, \
	__FUNCTION__, (CODE1), (CODE2)); \
	__t; })

	/* These checks have to be special cased. */
	#define EXPR_CHECK(T) __extension__ \
	({ const tree __t = (T); \
	char const __c = TREE_CODE_CLASS (TREE_CODE (__t)); \
	if (!IS_EXPR_CODE_CLASS (__c)) \
	tree_class_check_failed (__t, tcc_expression, __FILE__, __LINE__, \
	__FUNCTION__); \
	__t; })

	/* These checks have to be special cased. */
	#define NON_TYPE_CHECK(T) __extension__ \
	({ const tree __t = (T); \
	if (TYPE_P (__t)) \
	tree_not_class_check_failed (__t, tcc_type, __FILE__, __LINE__, \
	__FUNCTION__); \
	__t; })

	#define TREE_VEC_ELT_CHECK(T, I) __extension__ \
	(*({const tree __t = (T); \
	const int __i = (I); \
	if (TREE_CODE (__t) != TREE_VEC) \
	tree_check_failed (__t, __FILE__, __LINE__, __FUNCTION__, \
	TREE_VEC, 0); \
	if (__i < 0 \|\| __i >= __t->vec.length) \
	tree_vec_elt_check_failed (__i, __t->vec.length, \
	__FILE__, __LINE__, __FUNCTION__); \
	&__t->vec.a[__i]; }))

	#define PHI_NODE_ELT_CHECK(t, i) __extension__ \
	(*({const tree __t = t; \
	const int __i = (i); \
	if (TREE_CODE (__t) != PHI_NODE) \
	tree_check_failed (__t, __FILE__, __LINE__, __FUNCTION__, \
	PHI_NODE, 0); \
	if (__i < 0 \|\| __i >= __t->phi.capacity) \
	phi_node_elt_check_failed (__i, __t->phi.num_args, \
	__FILE__, __LINE__, __FUNCTION__); \
	&__t->phi.a[__i]; }))

	#define OMP_CLAUSE_ELT_CHECK(t, i) __extension__ \
	(*({const tree __t = t; \
	const int __i = (i); \
	if (TREE_CODE (__t) != OMP_CLAUSE) \
	tree_check_failed (__t, __FILE__, __LINE__, __FUNCTION__, \
	OMP_CLAUSE, 0); \
	if (__i < 0 \|\| __i >= omp_clause_num_ops [__t->omp_clause.code]) \
	omp_clause_operand_check_failed (__i, __t, __FILE__, __LINE__, \
	__FUNCTION__); \
	&__t->omp_clause.ops[__i]; }))

	/* Special checks for TREE_OPERANDs. */
	#define TREE_OPERAND_CHECK(T, I) __extension__ \
	(*({const tree __t = EXPR_CHECK (T); \
	const int __i = (I); \
	if (__i < 0 \|\| __i >= TREE_CODE_LENGTH (TREE_CODE (__t))) \
	tree_operand_check_failed (__i, TREE_CODE (__t), \
	__FILE__, __LINE__, __FUNCTION__); \
	&__t->exp.operands[__i]; }))

	#define TREE_OPERAND_CHECK_CODE(T, CODE, I) __extension__ \
	(*({const tree __t = (T); \
	const int __i = (I); \
	if (TREE_CODE (__t) != CODE) \
	tree_check_failed (__t, __FILE__, __LINE__, __FUNCTION__, (CODE), 0);\
	if (__i < 0 \|\| __i >= TREE_CODE_LENGTH (CODE)) \
	tree_operand_check_failed (__i, (CODE), \
	__FILE__, __LINE__, __FUNCTION__); \
	&__t->exp.operands[__i]; }))

	#define TREE_RTL_OPERAND_CHECK(T, CODE, I) __extension__ \
	((rtx ) \
	({const tree __t = (T); \
	const int __i = (I); \
	if (TREE_CODE (__t) != (CODE)) \
	tree_check_failed (__t, __FILE__, __LINE__, __FUNCTION__, (CODE), 0); \
	if (__i < 0 \|\| __i >= TREE_CODE_LENGTH ((CODE))) \
	tree_operand_check_failed (__i, (CODE), \
	__FILE__, __LINE__, __FUNCTION__); \
	&__t->exp.operands[__i]; }))

	extern void tree_contains_struct_check_failed (const tree,
	const enum tree_node_structure_enum,
	const char , int, const char )
	ATTRIBUTE_NORETURN;

	extern void tree_check_failed (const tree, const char , int, const char ,
	...) ATTRIBUTE_NORETURN;
	extern void tree_not_check_failed (const tree, const char , int, const char ,
	...) ATTRIBUTE_NORETURN;
	extern void tree_class_check_failed (const tree, const enum tree_code_class,
	const char , int, const char )
	ATTRIBUTE_NORETURN;
	extern void tree_range_check_failed (const tree, const char *, int,
	const char *, enum tree_code,
	enum tree_code);
	extern void tree_not_class_check_failed (const tree,
	const enum tree_code_class,
	const char , int, const char )
	ATTRIBUTE_NORETURN;
	extern void tree_vec_elt_check_failed (int, int, const char *,
	int, const char *)
	ATTRIBUTE_NORETURN;
	extern void phi_node_elt_check_failed (int, int, const char *,
	int, const char *)
	ATTRIBUTE_NORETURN;
	extern void tree_operand_check_failed (int, enum tree_code,
	const char , int, const char )
	ATTRIBUTE_NORETURN;
	extern void omp_clause_check_failed (const tree, const char *, int,
	const char *, enum omp_clause_code)
	ATTRIBUTE_NORETURN;
	extern void omp_clause_operand_check_failed (int, tree, const char *,
	int, const char *)
	ATTRIBUTE_NORETURN;
	extern void omp_clause_range_check_failed (const tree, const char *, int,
	const char *, enum omp_clause_code,
	enum omp_clause_code)
	ATTRIBUTE_NORETURN;

	#else /* not ENABLE_TREE_CHECKING, or not gcc */

	#define CONTAINS_STRUCT_CHECK(T, ENUM) (T)
	#define TREE_CHECK(T, CODE) (T)
	#define TREE_NOT_CHECK(T, CODE) (T)
	#define TREE_CHECK2(T, CODE1, CODE2) (T)
	#define TREE_NOT_CHECK2(T, CODE1, CODE2) (T)
	#define TREE_CHECK3(T, CODE1, CODE2, CODE3) (T)
	#define TREE_NOT_CHECK3(T, CODE1, CODE2, CODE3) (T)
	#define TREE_CHECK4(T, CODE1, CODE2, CODE3, CODE4) (T)
	#define TREE_NOT_CHECK4(T, CODE1, CODE2, CODE3, CODE4) (T)
	#define TREE_CHECK5(T, CODE1, CODE2, CODE3, CODE4, CODE5) (T)
	#define TREE_NOT_CHECK5(T, CODE1, CODE2, CODE3, CODE4, CODE5) (T)
	#define TREE_CLASS_CHECK(T, CODE) (T)
	#define TREE_RANGE_CHECK(T, CODE1, CODE2) (T)
	#define EXPR_CHECK(T) (T)
	#define NON_TYPE_CHECK(T) (T)
	#define TREE_VEC_ELT_CHECK(T, I) __PAST_END((T)->vec.a, I)
	#define TREE_OPERAND_CHECK(T, I) __PAST_END((T)->exp.operands, I)
	#define TREE_OPERAND_CHECK_CODE(T, CODE, I) __PAST_END((T)->exp.operands, I)
	#define TREE_RTL_OPERAND_CHECK(T, CODE, I) ((rtx ) &((T)->exp.operands[I]))
	#define PHI_NODE_ELT_CHECK(T, i) ((T)->phi.a[i])
	#define OMP_CLAUSE_ELT_CHECK(T, i) __PAST_END((T)->omp_clause.ops, i)
	#define OMP_CLAUSE_RANGE_CHECK(T, CODE1, CODE2) (T)
	#define OMP_CLAUSE_SUBCODE_CHECK(T, CODE) (T)

	#endif

	#define TREE_BLOCK(NODE) (EXPR_CHECK (NODE)->exp.block)

	#include "tree-check.h"

	#define TYPE_CHECK(T) TREE_CLASS_CHECK (T, tcc_type)
	#define DECL_MINIMAL_CHECK(T) CONTAINS_STRUCT_CHECK (T, TS_DECL_MINIMAL)
	#define TREE_MEMORY_TAG_CHECK(T) CONTAINS_STRUCT_CHECK (T, TS_MEMORY_TAG)
	#define DECL_COMMON_CHECK(T) CONTAINS_STRUCT_CHECK (T, TS_DECL_COMMON)
	#define DECL_WRTL_CHECK(T) CONTAINS_STRUCT_CHECK (T, TS_DECL_WRTL)
	#define DECL_WITH_VIS_CHECK(T) CONTAINS_STRUCT_CHECK (T, TS_DECL_WITH_VIS)
	#define DECL_NON_COMMON_CHECK(T) CONTAINS_STRUCT_CHECK (T, TS_DECL_NON_COMMON)
	#define CST_CHECK(T) TREE_CLASS_CHECK (T, tcc_constant)
	#define STMT_CHECK(T) TREE_CLASS_CHECK (T, tcc_statement)
	#define FUNC_OR_METHOD_CHECK(T) TREE_CHECK2 (T, FUNCTION_TYPE, METHOD_TYPE)
	#define PTR_OR_REF_CHECK(T) TREE_CHECK2 (T, POINTER_TYPE, REFERENCE_TYPE)

	#define RECORD_OR_UNION_CHECK(T) \
	TREE_CHECK3 (T, RECORD_TYPE, UNION_TYPE, QUAL_UNION_TYPE)
	#define NOT_RECORD_OR_UNION_CHECK(T) \
	TREE_NOT_CHECK3 (T, RECORD_TYPE, UNION_TYPE, QUAL_UNION_TYPE)

	#define NUMERICAL_TYPE_CHECK(T) \
	TREE_CHECK4 (T, INTEGER_TYPE, ENUMERAL_TYPE, BOOLEAN_TYPE, REAL_TYPE)

	/* In all nodes that are expressions, this is the data type of the expression.
	In POINTER_TYPE nodes, this is the type that the pointer points to.
	In ARRAY_TYPE nodes, this is the type of the elements.
	In VECTOR_TYPE nodes, this is the type of the elements. */
	#define TREE_TYPE(NODE) ((NODE)->common.type)

	/* Here is how primitive or already-canonicalized types' hash codes
	are made. */
	#define TYPE_HASH(TYPE) (TYPE_UID (TYPE))

	/* A simple hash function for an arbitrary tree node. This must not be
	used in hash tables which are saved to a PCH. */
	#define TREE_HASH(NODE) ((size_t) (NODE) & 0777777)

	/* Nodes are chained together for many purposes.
	Types are chained together to record them for being output to the debugger
	(see the function `chain_type').
	Decls in the same scope are chained together to record the contents
	of the scope.
	Statement nodes for successive statements used to be chained together.
	Often lists of things are represented by TREE_LIST nodes that
	are chained together. */

	#define TREE_CHAIN(NODE) ((NODE)->common.chain)

	/* Given an expression as a tree, strip any NON_LVALUE_EXPRs and NOP_EXPRs
	that don't change the machine mode. */

	#define STRIP_NOPS(EXP) \
	while ((TREE_CODE (EXP) == NOP_EXPR \
	\|\| TREE_CODE (EXP) == CONVERT_EXPR \
	\|\| TREE_CODE (EXP) == NON_LVALUE_EXPR) \
	&& TREE_OPERAND (EXP, 0) != error_mark_node \
	&& (TYPE_MODE (TREE_TYPE (EXP)) \
	== TYPE_MODE (TREE_TYPE (TREE_OPERAND (EXP, 0))))) \
	(EXP) = TREE_OPERAND (EXP, 0)

	/* Like STRIP_NOPS, but don't let the signedness change either. */

	#define STRIP_SIGN_NOPS(EXP) \
	while ((TREE_CODE (EXP) == NOP_EXPR \
	\|\| TREE_CODE (EXP) == CONVERT_EXPR \
	\|\| TREE_CODE (EXP) == NON_LVALUE_EXPR) \
	&& TREE_OPERAND (EXP, 0) != error_mark_node \
	&& (TYPE_MODE (TREE_TYPE (EXP)) \
	== TYPE_MODE (TREE_TYPE (TREE_OPERAND (EXP, 0)))) \
	&& (TYPE_UNSIGNED (TREE_TYPE (EXP)) \
	== TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (EXP, 0))))) \
	(EXP) = TREE_OPERAND (EXP, 0)

	/* Like STRIP_NOPS, but don't alter the TREE_TYPE either. */

	#define STRIP_TYPE_NOPS(EXP) \
	while ((TREE_CODE (EXP) == NOP_EXPR \
	\|\| TREE_CODE (EXP) == CONVERT_EXPR \
	\|\| TREE_CODE (EXP) == NON_LVALUE_EXPR) \
	&& TREE_OPERAND (EXP, 0) != error_mark_node \
	&& (TREE_TYPE (EXP) \
	== TREE_TYPE (TREE_OPERAND (EXP, 0)))) \
	(EXP) = TREE_OPERAND (EXP, 0)

	/* Remove unnecessary type conversions according to
	tree_ssa_useless_type_conversion. */

	#define STRIP_USELESS_TYPE_CONVERSION(EXP) \
	while (tree_ssa_useless_type_conversion (EXP)) \
	EXP = TREE_OPERAND (EXP, 0)

	/* Nonzero if TYPE represents an integral type. Note that we do not
	include COMPLEX types here. Keep these checks in ascending code
	order. */

	#define INTEGRAL_TYPE_P(TYPE) \
	(TREE_CODE (TYPE) == ENUMERAL_TYPE \
	\|\| TREE_CODE (TYPE) == BOOLEAN_TYPE \
	\|\| TREE_CODE (TYPE) == INTEGER_TYPE)

	/* Nonzero if TYPE represents a scalar floating-point type. */

	#define SCALAR_FLOAT_TYPE_P(TYPE) (TREE_CODE (TYPE) == REAL_TYPE)

	/* Nonzero if TYPE represents a complex floating-point type. */

	#define COMPLEX_FLOAT_TYPE_P(TYPE) \
	(TREE_CODE (TYPE) == COMPLEX_TYPE \
	&& TREE_CODE (TREE_TYPE (TYPE)) == REAL_TYPE)

	/* Nonzero if TYPE represents a vector floating-point type. */

	#define VECTOR_FLOAT_TYPE_P(TYPE) \
	(TREE_CODE (TYPE) == VECTOR_TYPE \
	&& TREE_CODE (TREE_TYPE (TYPE)) == REAL_TYPE)

	/* Nonzero if TYPE represents a floating-point type, including complex
	and vector floating-point types. The vector and complex check does
	not use the previous two macros to enable early folding. */

	#define FLOAT_TYPE_P(TYPE) \
	(SCALAR_FLOAT_TYPE_P (TYPE) \
	\|\| ((TREE_CODE (TYPE) == COMPLEX_TYPE \
	\|\| TREE_CODE (TYPE) == VECTOR_TYPE) \
	&& SCALAR_FLOAT_TYPE_P (TREE_TYPE (TYPE))))

	/* Nonzero if TYPE represents a decimal floating-point type. */
	#define DECIMAL_FLOAT_TYPE_P(TYPE) \
	(SCALAR_FLOAT_TYPE_P (TYPE) \
	&& DECIMAL_FLOAT_MODE_P (TYPE_MODE (TYPE)))

	/* Nonzero if TYPE represents an aggregate (multi-component) type.
	Keep these checks in ascending code order. */

	#define AGGREGATE_TYPE_P(TYPE) \
	(TREE_CODE (TYPE) == ARRAY_TYPE \|\| TREE_CODE (TYPE) == RECORD_TYPE \
	\|\| TREE_CODE (TYPE) == UNION_TYPE \|\| TREE_CODE (TYPE) == QUAL_UNION_TYPE)

	/* Nonzero if TYPE represents a pointer or reference type.
	(It should be renamed to INDIRECT_TYPE_P.) Keep these checks in
	ascending code order. */

	#define POINTER_TYPE_P(TYPE) \
	(TREE_CODE (TYPE) == POINTER_TYPE \|\| TREE_CODE (TYPE) == REFERENCE_TYPE)

	/* Nonzero if this type is a complete type. */
	#define COMPLETE_TYPE_P(NODE) (TYPE_SIZE (NODE) != NULL_TREE)

	/* Nonzero if this type is the (possibly qualified) void type. */
	#define VOID_TYPE_P(NODE) (TREE_CODE (NODE) == VOID_TYPE)

	/* Nonzero if this type is complete or is cv void. */
	#define COMPLETE_OR_VOID_TYPE_P(NODE) \
	(COMPLETE_TYPE_P (NODE) \|\| VOID_TYPE_P (NODE))

	/* Nonzero if this type is complete or is an array with unspecified bound. */
	#define COMPLETE_OR_UNBOUND_ARRAY_TYPE_P(NODE) \
	(COMPLETE_TYPE_P (TREE_CODE (NODE) == ARRAY_TYPE ? TREE_TYPE (NODE) : (NODE)))


	/* Define many boolean fields that all tree nodes have. */

	/* In VAR_DECL nodes, nonzero means address of this is needed.
	So it cannot be in a register.
	In a FUNCTION_DECL, nonzero means its address is needed.
	So it must be compiled even if it is an inline function.
	In a FIELD_DECL node, it means that the programmer is permitted to
	construct the address of this field. This is used for aliasing
	purposes: see record_component_aliases.
	In CONSTRUCTOR nodes, it means object constructed must be in memory.
	In LABEL_DECL nodes, it means a goto for this label has been seen
	from a place outside all binding contours that restore stack levels.
	In ..._TYPE nodes, it means that objects of this type must
	be fully addressable. This means that pieces of this
	object cannot go into register parameters, for example.
	In IDENTIFIER_NODEs, this means that some extern decl for this name
	had its address taken. That matters for inline functions. */
	#define TREE_ADDRESSABLE(NODE) ((NODE)->common.addressable_flag)

	/* Set on a CALL_EXPR if the call is in a tail position, ie. just before the
	exit of a function. Calls for which this is true are candidates for tail
	call optimizations. */
	#define CALL_EXPR_TAILCALL(NODE) (CALL_EXPR_CHECK(NODE)->common.addressable_flag)

	/* Used as a temporary field on a CASE_LABEL_EXPR to indicate that the
	CASE_LOW operand has been processed. */
	#define CASE_LOW_SEEN(NODE) \
	(CASE_LABEL_EXPR_CHECK (NODE)->common.addressable_flag)

	/* In a VAR_DECL, nonzero means allocate static storage.
	In a FUNCTION_DECL, nonzero if function has been defined.
	In a CONSTRUCTOR, nonzero means allocate static storage.

	??? This is also used in lots of other nodes in unclear ways which
	should be cleaned up some day. */
	#define TREE_STATIC(NODE) ((NODE)->common.static_flag)

	/* In a TARGET_EXPR, WITH_CLEANUP_EXPR, means that the pertinent cleanup
	should only be executed if an exception is thrown, not on normal exit
	of its scope. */
	#define CLEANUP_EH_ONLY(NODE) ((NODE)->common.static_flag)

	/* Used as a temporary field on a CASE_LABEL_EXPR to indicate that the
	CASE_HIGH operand has been processed. */
	#define CASE_HIGH_SEEN(NODE) \
	(CASE_LABEL_EXPR_CHECK (NODE)->common.static_flag)

	/* In an expr node (usually a conversion) this means the node was made
	implicitly and should not lead to any sort of warning. In a decl node,
	warnings concerning the decl should be suppressed. This is used at
	least for used-before-set warnings, and it set after one warning is
	emitted. */
	#define TREE_NO_WARNING(NODE) ((NODE)->common.nowarning_flag)

	/* In an INTEGER_CST, REAL_CST, COMPLEX_CST, or VECTOR_CST this means
	there was an overflow in folding. This is distinct from
	TREE_OVERFLOW because ANSI C requires a diagnostic when overflows
	occur in constant expressions. */
	#define TREE_CONSTANT_OVERFLOW(NODE) (CST_CHECK (NODE)->common.static_flag)

	/* In an IDENTIFIER_NODE, this means that assemble_name was called with
	this string as an argument. */
	#define TREE_SYMBOL_REFERENCED(NODE) \
	(IDENTIFIER_NODE_CHECK (NODE)->common.static_flag)

	/* Nonzero in a pointer or reference type means the data pointed to
	by this type can alias anything. */
	#define TYPE_REF_CAN_ALIAS_ALL(NODE) \
	(PTR_OR_REF_CHECK (NODE)->common.static_flag)

	/* In an INTEGER_CST, REAL_CST, COMPLEX_CST, or VECTOR_CST, this means
	there was an overflow in folding, and no warning has been issued
	for this subexpression. TREE_OVERFLOW implies TREE_CONSTANT_OVERFLOW,
	but not vice versa. */

	#define TREE_OVERFLOW(NODE) (CST_CHECK (NODE)->common.public_flag)

	/* TREE_OVERFLOW can only be true for EXPR of CONSTANT_CLASS_P. */

	#define TREE_OVERFLOW_P(EXPR) \
	(CONSTANT_CLASS_P (EXPR) && TREE_OVERFLOW (EXPR))

	/* In a VAR_DECL, FUNCTION_DECL, NAMESPACE_DECL or TYPE_DECL,
	nonzero means name is to be accessible from outside this module.
	In an IDENTIFIER_NODE, nonzero means an external declaration
	accessible from outside this module was previously seen
	for this name in an inner scope. */
	#define TREE_PUBLIC(NODE) ((NODE)->common.public_flag)

	/* In a _TYPE, indicates whether TYPE_CACHED_VALUES contains a vector
	of cached values, or is something else. */
	#define TYPE_CACHED_VALUES_P(NODE) (TYPE_CHECK(NODE)->common.public_flag)

	/* In a SAVE_EXPR, indicates that the original expression has already
	been substituted with a VAR_DECL that contains the value. */
	#define SAVE_EXPR_RESOLVED_P(NODE) \
	(TREE_CHECK (NODE, SAVE_EXPR)->common.public_flag)

	/* In any expression, decl, or constant, nonzero means it has side effects or
	reevaluation of the whole expression could produce a different value.
	This is set if any subexpression is a function call, a side effect or a
	reference to a volatile variable. In a ..._DECL, this is set only if the
	declaration said `volatile'. This will never be set for a constant. */
	#define TREE_SIDE_EFFECTS(NODE) \
	(NON_TYPE_CHECK (NODE)->common.side_effects_flag)

	/* In a LABEL_DECL, nonzero means this label had its address taken
	and therefore can never be deleted and is a jump target for
	computed gotos. */
	#define FORCED_LABEL(NODE) ((NODE)->common.side_effects_flag)

	/* Nonzero means this expression is volatile in the C sense:
	its address should be of type `volatile WHATEVER *'.
	In other words, the declared item is volatile qualified.
	This is used in _DECL nodes and _REF nodes.
	On a FUNCTION_DECL node, this means the function does not
	return normally. This is the same effect as setting
	the attribute noreturn on the function in C.

	In a ..._TYPE node, means this type is volatile-qualified.
	But use TYPE_VOLATILE instead of this macro when the node is a type,
	because eventually we may make that a different bit.

	If this bit is set in an expression, so is TREE_SIDE_EFFECTS. */
	#define TREE_THIS_VOLATILE(NODE) ((NODE)->common.volatile_flag)

	/* Nonzero means this node will not trap. In an INDIRECT_REF, means
	accessing the memory pointed to won't generate a trap. However,
	this only applies to an object when used appropriately: it doesn't
	mean that writing a READONLY mem won't trap. Similarly for
	ALIGN_INDIRECT_REF and MISALIGNED_INDIRECT_REF.

	In ARRAY_REF and ARRAY_RANGE_REF means that we know that the index
	(or slice of the array) always belongs to the range of the array.
	I.e. that the access will not trap, provided that the access to
	the base to the array will not trap. */
	#define TREE_THIS_NOTRAP(NODE) ((NODE)->common.nothrow_flag)

	/* In a VAR_DECL, PARM_DECL or FIELD_DECL, or any kind of ..._REF node,
	nonzero means it may not be the lhs of an assignment. */
	#define TREE_READONLY(NODE) (NON_TYPE_CHECK (NODE)->common.readonly_flag)

	/* Nonzero if NODE is a _DECL with TREE_READONLY set. */
	#define TREE_READONLY_DECL_P(NODE)\
	(DECL_P (NODE) && TREE_READONLY (NODE))

	/* Value of expression is constant. Always on in all ..._CST nodes. May
	also appear in an expression or decl where the value is constant. */
	#define TREE_CONSTANT(NODE) (NON_TYPE_CHECK (NODE)->common.constant_flag)

	/* Nonzero if NODE, a type, has had its sizes gimplified. */
	#define TYPE_SIZES_GIMPLIFIED(NODE) (TYPE_CHECK (NODE)->common.constant_flag)

	/* In a decl (most significantly a FIELD_DECL), means an unsigned field. */
	#define DECL_UNSIGNED(NODE) (DECL_COMMON_CHECK (NODE)->common.unsigned_flag)

	/* In a BIT_FIELD_REF, means the bitfield is to be interpreted as unsigned. */
	#define BIT_FIELD_REF_UNSIGNED(NODE) \
	(BIT_FIELD_REF_CHECK (NODE)->common.unsigned_flag)

	/* In integral and pointer types, means an unsigned type. */
	#define TYPE_UNSIGNED(NODE) (TYPE_CHECK (NODE)->common.unsigned_flag)

	/* Nonzero in a VAR_DECL means assembler code has been written.
	Nonzero in a FUNCTION_DECL means that the function has been compiled.
	This is interesting in an inline function, since it might not need
	to be compiled separately.
	Nonzero in a RECORD_TYPE, UNION_TYPE, QUAL_UNION_TYPE or ENUMERAL_TYPE
	if the sdb debugging info for the type has been written.
	In a BLOCK node, nonzero if reorder_blocks has already seen this block.
	In an SSA_NAME node, nonzero if the SSA_NAME occurs in an abnormal
	PHI node. */
	#define TREE_ASM_WRITTEN(NODE) ((NODE)->common.asm_written_flag)

	/* Nonzero in a _DECL if the name is used in its scope.
	Nonzero in an expr node means inhibit warning if value is unused.
	In IDENTIFIER_NODEs, this means that some extern decl for this name
	was used.
	In a BLOCK, this means that the block contains variables that are used. */
	#define TREE_USED(NODE) ((NODE)->common.used_flag)

	/* In a FUNCTION_DECL, nonzero means a call to the function cannot throw
	an exception. In a CALL_EXPR, nonzero means the call cannot throw. */
	#define TREE_NOTHROW(NODE) ((NODE)->common.nothrow_flag)

	/* In a CALL_EXPR, means that it's safe to use the target of the call
	expansion as the return slot for a call that returns in memory. */
	#define CALL_EXPR_RETURN_SLOT_OPT(NODE) ((NODE)->common.private_flag)

	/* In a RESULT_DECL or PARM_DECL, means that it is passed by invisible
	reference (and the TREE_TYPE is a pointer to the true type). */
	#define DECL_BY_REFERENCE(NODE) (DECL_COMMON_CHECK (NODE)->common.private_flag)

	/* In a CALL_EXPR, means that the call is the jump from a thunk to the
	thunked-to function. */
	#define CALL_FROM_THUNK_P(NODE) (CALL_EXPR_CHECK (NODE)->common.protected_flag)

	/* In a type, nonzero means that all objects of the type are guaranteed by the
	language or front-end to be properly aligned, so we can indicate that a MEM
	of this type is aligned at least to the alignment of the type, even if it
	doesn't appear that it is. We see this, for example, in object-oriented
	languages where a tag field may show this is an object of a more-aligned
	variant of the more generic type.

	In an SSA_NAME node, nonzero if the SSA_NAME node is on the SSA_NAME
	freelist. */
	#define TYPE_ALIGN_OK(NODE) (TYPE_CHECK (NODE)->common.nothrow_flag)

	/* Used in classes in C++. */
	#define TREE_PRIVATE(NODE) ((NODE)->common.private_flag)
	/* Used in classes in C++.
	In a BLOCK node, this is BLOCK_HANDLER_BLOCK. */
	#define TREE_PROTECTED(NODE) ((NODE)->common.protected_flag)

	/* Nonzero in a _DECL if the use of the name is defined as a
	deprecated feature by __attribute__((deprecated)). */
	#define TREE_DEPRECATED(NODE) \
	((NODE)->common.deprecated_flag)

	+/* APPLE LOCAL begin "unavailable" attribute (Radar 2809697) */
	+/* Nonzero in a IDENTIFIER_NODE if the use of the name is defined as a
	+ unavailable feature by __attribute__((unavailable)). */
	+#define TREE_UNAVAILABLE(NODE) ((NODE)->common.unavailable_flag)
	+/* APPLE LOCAL end "unavailable" attribute (Radar 2809697) */
	+
	/* Nonzero in an IDENTIFIER_NODE if the name is a local alias, whose
	uses are to be substituted for uses of the TREE_CHAINed identifier. */
	#define IDENTIFIER_TRANSPARENT_ALIAS(NODE) \
	(IDENTIFIER_NODE_CHECK (NODE)->common.deprecated_flag)

	/* Value of expression is function invariant. A strict subset of
	TREE_CONSTANT, such an expression is constant over any one function
	invocation, though not across different invocations. May appear in
	any expression node. */
	#define TREE_INVARIANT(NODE) ((NODE)->common.invariant_flag)

	/* These flags are available for each language front end to use internally. */
	#define TREE_LANG_FLAG_0(NODE) ((NODE)->common.lang_flag_0)
	#define TREE_LANG_FLAG_1(NODE) ((NODE)->common.lang_flag_1)
	#define TREE_LANG_FLAG_2(NODE) ((NODE)->common.lang_flag_2)
	#define TREE_LANG_FLAG_3(NODE) ((NODE)->common.lang_flag_3)
	#define TREE_LANG_FLAG_4(NODE) ((NODE)->common.lang_flag_4)
	#define TREE_LANG_FLAG_5(NODE) ((NODE)->common.lang_flag_5)
	#define TREE_LANG_FLAG_6(NODE) ((NODE)->common.lang_flag_6)

	/* Define additional fields and accessors for nodes representing constants. */

	/* In an INTEGER_CST node. These two together make a 2-word integer.
	If the data type is signed, the value is sign-extended to 2 words
	even though not all of them may really be in use.
	In an unsigned constant shorter than 2 words, the extra bits are 0. */
	#define TREE_INT_CST(NODE) (INTEGER_CST_CHECK (NODE)->int_cst.int_cst)
	#define TREE_INT_CST_LOW(NODE) (TREE_INT_CST (NODE).low)
	#define TREE_INT_CST_HIGH(NODE) (TREE_INT_CST (NODE).high)

	#define INT_CST_LT(A, B) \
	(TREE_INT_CST_HIGH (A) < TREE_INT_CST_HIGH (B) \
	\|\| (TREE_INT_CST_HIGH (A) == TREE_INT_CST_HIGH (B) \
	&& TREE_INT_CST_LOW (A) < TREE_INT_CST_LOW (B)))

	#define INT_CST_LT_UNSIGNED(A, B) \
	(((unsigned HOST_WIDE_INT) TREE_INT_CST_HIGH (A) \
	< (unsigned HOST_WIDE_INT) TREE_INT_CST_HIGH (B)) \
	\|\| (((unsigned HOST_WIDE_INT) TREE_INT_CST_HIGH (A) \
	== (unsigned HOST_WIDE_INT) TREE_INT_CST_HIGH (B)) \
	&& TREE_INT_CST_LOW (A) < TREE_INT_CST_LOW (B)))

	struct tree_int_cst GTY(())
	{
	struct tree_common common;
	double_int int_cst;
	};

	/* In a REAL_CST node. struct real_value is an opaque entity, with
	manipulators defined in real.h. We don't want tree.h depending on
	real.h and transitively on tm.h. */
	struct real_value;

	#define TREE_REAL_CST_PTR(NODE) (REAL_CST_CHECK (NODE)->real_cst.real_cst_ptr)
	#define TREE_REAL_CST(NODE) (*TREE_REAL_CST_PTR (NODE))

	struct tree_real_cst GTY(())
	{
	struct tree_common common;
	struct real_value * real_cst_ptr;
	};

	/* In a STRING_CST */
	#define TREE_STRING_LENGTH(NODE) (STRING_CST_CHECK (NODE)->string.length)
	#define TREE_STRING_POINTER(NODE) \
	((const char *)(STRING_CST_CHECK (NODE)->string.str))

	struct tree_string GTY(())
	{
	struct tree_common common;
	int length;
	char str[1];
	};

	/* In a COMPLEX_CST node. */
	#define TREE_REALPART(NODE) (COMPLEX_CST_CHECK (NODE)->complex.real)
	#define TREE_IMAGPART(NODE) (COMPLEX_CST_CHECK (NODE)->complex.imag)

	struct tree_complex GTY(())
	{
	struct tree_common common;
	tree real;
	tree imag;
	};

	/* In a VECTOR_CST node. */
	#define TREE_VECTOR_CST_ELTS(NODE) (VECTOR_CST_CHECK (NODE)->vector.elements)

	struct tree_vector GTY(())
	{
	struct tree_common common;
	tree elements;
	};

	#include "symtab.h"

	/* Define fields and accessors for some special-purpose tree nodes. */

	#define IDENTIFIER_LENGTH(NODE) \
	(IDENTIFIER_NODE_CHECK (NODE)->identifier.id.len)
	#define IDENTIFIER_POINTER(NODE) \
	((const char *) IDENTIFIER_NODE_CHECK (NODE)->identifier.id.str)
	#define IDENTIFIER_HASH_VALUE(NODE) \
	(IDENTIFIER_NODE_CHECK (NODE)->identifier.id.hash_value)

	/* Translate a hash table identifier pointer to a tree_identifier
	pointer, and vice versa. */

	#define HT_IDENT_TO_GCC_IDENT(NODE) \
	((tree) ((char *) (NODE) - sizeof (struct tree_common)))
	#define GCC_IDENT_TO_HT_IDENT(NODE) (&((struct tree_identifier *) (NODE))->id)

	struct tree_identifier GTY(())
	{
	struct tree_common common;
	struct ht_identifier id;
	};

	/* In a TREE_LIST node. */
	#define TREE_PURPOSE(NODE) (TREE_LIST_CHECK (NODE)->list.purpose)
	#define TREE_VALUE(NODE) (TREE_LIST_CHECK (NODE)->list.value)

	struct tree_list GTY(())
	{
	struct tree_common common;
	tree purpose;
	tree value;
	};

	/* In a TREE_VEC node. */
	#define TREE_VEC_LENGTH(NODE) (TREE_VEC_CHECK (NODE)->vec.length)
	#define TREE_VEC_END(NODE) \
	((void) TREE_VEC_CHECK (NODE), &((NODE)->vec.a[(NODE)->vec.length]))

	#define TREE_VEC_ELT(NODE,I) TREE_VEC_ELT_CHECK (NODE, I)

	struct tree_vec GTY(())
	{
	struct tree_common common;
	int length;
	tree GTY ((length ("TREE_VEC_LENGTH ((tree)&%h)"))) a[1];
	};

	/* In a CONSTRUCTOR node. */
	#define CONSTRUCTOR_ELTS(NODE) (CONSTRUCTOR_CHECK (NODE)->constructor.elts)

	/* Iterate through the vector V of CONSTRUCTOR_ELT elements, yielding the
	value of each element (stored within VAL). IX must be a scratch variable
	of unsigned integer type. */
	#define FOR_EACH_CONSTRUCTOR_VALUE(V, IX, VAL) \
	for (IX = 0; (IX >= VEC_length (constructor_elt, V)) \
	? false \
	: ((VAL = VEC_index (constructor_elt, V, IX)->value), \
	true); \
	(IX)++)

	/* Iterate through the vector V of CONSTRUCTOR_ELT elements, yielding both
	the value of each element (stored within VAL) and its index (stored
	within INDEX). IX must be a scratch variable of unsigned integer type. */
	#define FOR_EACH_CONSTRUCTOR_ELT(V, IX, INDEX, VAL) \
	for (IX = 0; (IX >= VEC_length (constructor_elt, V)) \
	? false \
	: ((VAL = VEC_index (constructor_elt, V, IX)->value), \
	(INDEX = VEC_index (constructor_elt, V, IX)->index), \
	true); \
	(IX)++)

	/* Append a new constructor element to V, with the specified INDEX and VAL. */
	#define CONSTRUCTOR_APPEND_ELT(V, INDEX, VALUE) \
	do { \
	constructor_elt *_ce___ = VEC_safe_push (constructor_elt, gc, V, NULL); \
	_ce___->index = INDEX; \
	_ce___->value = VALUE; \
	} while (0)

	/* A single element of a CONSTRUCTOR. VALUE holds the actual value of the
	element. INDEX can optionally design the position of VALUE: in arrays,
	it is the index where VALUE has to be placed; in structures, it is the
	FIELD_DECL of the member. */
	typedef struct constructor_elt_d GTY(())
	{
	tree index;
	tree value;
	} constructor_elt;

	DEF_VEC_O(constructor_elt);
	DEF_VEC_ALLOC_O(constructor_elt,gc);

	struct tree_constructor GTY(())
	{
	struct tree_common common;
	VEC(constructor_elt,gc) *elts;
	};

	/* Define fields and accessors for some nodes that represent expressions. */

	/* Nonzero if NODE is an empty statement (NOP_EXPR <0>). */
	#define IS_EMPTY_STMT(NODE) (TREE_CODE (NODE) == NOP_EXPR \
	&& VOID_TYPE_P (TREE_TYPE (NODE)) \
	&& integer_zerop (TREE_OPERAND (NODE, 0)))

	/* In ordinary expression nodes. */
	#define TREE_OPERAND(NODE, I) TREE_OPERAND_CHECK (NODE, I)
	#define TREE_COMPLEXITY(NODE) (EXPR_CHECK (NODE)->exp.complexity)

	/* In a LOOP_EXPR node. */
	#define LOOP_EXPR_BODY(NODE) TREE_OPERAND_CHECK_CODE (NODE, LOOP_EXPR, 0)

	#ifdef USE_MAPPED_LOCATION
	/* The source location of this expression. Non-tree_exp nodes such as
	decls and constants can be shared among multiple locations, so
	return nothing. */
	#define EXPR_LOCATION(NODE) \
	(EXPR_P (NODE) ? (NODE)->exp.locus : UNKNOWN_LOCATION)
	#define SET_EXPR_LOCATION(NODE, FROM) \
	(EXPR_CHECK (NODE)->exp.locus = (FROM))
	#define EXPR_HAS_LOCATION(NODE) (EXPR_LOCATION (NODE) != UNKNOWN_LOCATION)
	/* EXPR_LOCUS and SET_EXPR_LOCUS are deprecated. */
	#define EXPR_LOCUS(NODE) \
	(EXPR_P (NODE) ? &(NODE)->exp.locus : (location_t *)NULL)
	#define SET_EXPR_LOCUS(NODE, FROM) \
	do { source_location *loc_tmp = FROM; \
	EXPR_CHECK (NODE)->exp.locus \
	= loc_tmp == NULL ? UNKNOWN_LOCATION : *loc_tmp; } while (0)
	#define EXPR_FILENAME(NODE) \
	LOCATION_FILE (EXPR_CHECK (NODE)->exp.locus)
	#define EXPR_LINENO(NODE) \
	LOCATION_LINE (EXPR_CHECK (NODE)->exp.locus)
	#else
	/* The source location of this expression. Non-tree_exp nodes such as
	decls and constants can be shared among multiple locations, so
	return nothing. */
	#define EXPR_LOCUS(NODE) \
	(EXPR_P (NODE) ? (NODE)->exp.locus : (location_t *)NULL)
	#define SET_EXPR_LOCUS(NODE, FROM) \
	(EXPR_CHECK (NODE)->exp.locus = (FROM))
	#define SET_EXPR_LOCATION(NODE, FROM) annotate_with_locus (NODE, FROM)
	#define EXPR_FILENAME(NODE) \
	(EXPR_CHECK (NODE)->exp.locus->file)
	#define EXPR_LINENO(NODE) \
	(EXPR_CHECK (NODE)->exp.locus->line)
	#define EXPR_HAS_LOCATION(NODE) (EXPR_LOCUS (NODE) != NULL)
	#define EXPR_LOCATION(NODE) \
	(EXPR_HAS_LOCATION(NODE) ? *(NODE)->exp.locus : UNKNOWN_LOCATION)
	#endif

	/* In a TARGET_EXPR node. */
	#define TARGET_EXPR_SLOT(NODE) TREE_OPERAND_CHECK_CODE (NODE, TARGET_EXPR, 0)
	#define TARGET_EXPR_INITIAL(NODE) TREE_OPERAND_CHECK_CODE (NODE, TARGET_EXPR, 1)
	#define TARGET_EXPR_CLEANUP(NODE) TREE_OPERAND_CHECK_CODE (NODE, TARGET_EXPR, 2)

	/* DECL_EXPR accessor. This gives access to the DECL associated with
	the given declaration statement. */
	#define DECL_EXPR_DECL(NODE) TREE_OPERAND (DECL_EXPR_CHECK (NODE), 0)

	#define EXIT_EXPR_COND(NODE) TREE_OPERAND (EXIT_EXPR_CHECK (NODE), 0)

	/* SWITCH_EXPR accessors. These give access to the condition, body and
	original condition type (before any compiler conversions)
	of the switch statement, respectively. */
	#define SWITCH_COND(NODE) TREE_OPERAND (SWITCH_EXPR_CHECK (NODE), 0)
	#define SWITCH_BODY(NODE) TREE_OPERAND (SWITCH_EXPR_CHECK (NODE), 1)
	#define SWITCH_LABELS(NODE) TREE_OPERAND (SWITCH_EXPR_CHECK (NODE), 2)

	/* CASE_LABEL_EXPR accessors. These give access to the high and low values
	of a case label, respectively. */
	#define CASE_LOW(NODE) TREE_OPERAND (CASE_LABEL_EXPR_CHECK (NODE), 0)
	#define CASE_HIGH(NODE) TREE_OPERAND (CASE_LABEL_EXPR_CHECK (NODE), 1)
	#define CASE_LABEL(NODE) TREE_OPERAND (CASE_LABEL_EXPR_CHECK (NODE), 2)

	/* The operands of a TARGET_MEM_REF. */
	#define TMR_SYMBOL(NODE) (TREE_OPERAND (TARGET_MEM_REF_CHECK (NODE), 0))
	#define TMR_BASE(NODE) (TREE_OPERAND (TARGET_MEM_REF_CHECK (NODE), 1))
	#define TMR_INDEX(NODE) (TREE_OPERAND (TARGET_MEM_REF_CHECK (NODE), 2))
	#define TMR_STEP(NODE) (TREE_OPERAND (TARGET_MEM_REF_CHECK (NODE), 3))
	#define TMR_OFFSET(NODE) (TREE_OPERAND (TARGET_MEM_REF_CHECK (NODE), 4))
	#define TMR_ORIGINAL(NODE) (TREE_OPERAND (TARGET_MEM_REF_CHECK (NODE), 5))
	#define TMR_TAG(NODE) (TREE_OPERAND (TARGET_MEM_REF_CHECK (NODE), 6))

	/* The operands of a BIND_EXPR. */
	#define BIND_EXPR_VARS(NODE) (TREE_OPERAND (BIND_EXPR_CHECK (NODE), 0))
	#define BIND_EXPR_BODY(NODE) (TREE_OPERAND (BIND_EXPR_CHECK (NODE), 1))
	#define BIND_EXPR_BLOCK(NODE) (TREE_OPERAND (BIND_EXPR_CHECK (NODE), 2))

	/* GOTO_EXPR accessor. This gives access to the label associated with
	a goto statement. */
	#define GOTO_DESTINATION(NODE) TREE_OPERAND ((NODE), 0)

	/* ASM_EXPR accessors. ASM_STRING returns a STRING_CST for the
	instruction (e.g., "mov x, y"). ASM_OUTPUTS, ASM_INPUTS, and
	ASM_CLOBBERS represent the outputs, inputs, and clobbers for the
	statement. */
	#define ASM_STRING(NODE) TREE_OPERAND (ASM_EXPR_CHECK (NODE), 0)
	#define ASM_OUTPUTS(NODE) TREE_OPERAND (ASM_EXPR_CHECK (NODE), 1)
	#define ASM_INPUTS(NODE) TREE_OPERAND (ASM_EXPR_CHECK (NODE), 2)
	#define ASM_CLOBBERS(NODE) TREE_OPERAND (ASM_EXPR_CHECK (NODE), 3)
	/* Nonzero if we want to create an ASM_INPUT instead of an
	ASM_OPERAND with no operands. */
	#define ASM_INPUT_P(NODE) (TREE_STATIC (NODE))
	#define ASM_VOLATILE_P(NODE) (TREE_PUBLIC (NODE))

	/* COND_EXPR accessors. */
	#define COND_EXPR_COND(NODE) (TREE_OPERAND (COND_EXPR_CHECK (NODE), 0))
	#define COND_EXPR_THEN(NODE) (TREE_OPERAND (COND_EXPR_CHECK (NODE), 1))
	#define COND_EXPR_ELSE(NODE) (TREE_OPERAND (COND_EXPR_CHECK (NODE), 2))

	/* LABEL_EXPR accessor. This gives access to the label associated with
	the given label expression. */
	#define LABEL_EXPR_LABEL(NODE) TREE_OPERAND (LABEL_EXPR_CHECK (NODE), 0)

	/* VDEF_EXPR accessors are specified in tree-flow.h, along with the other
	accessors for SSA operands. */

	/* CATCH_EXPR accessors. */
	#define CATCH_TYPES(NODE) TREE_OPERAND (CATCH_EXPR_CHECK (NODE), 0)
	#define CATCH_BODY(NODE) TREE_OPERAND (CATCH_EXPR_CHECK (NODE), 1)

	/* EH_FILTER_EXPR accessors. */
	#define EH_FILTER_TYPES(NODE) TREE_OPERAND (EH_FILTER_EXPR_CHECK (NODE), 0)
	#define EH_FILTER_FAILURE(NODE) TREE_OPERAND (EH_FILTER_EXPR_CHECK (NODE), 1)
	#define EH_FILTER_MUST_NOT_THROW(NODE) TREE_STATIC (EH_FILTER_EXPR_CHECK (NODE))

	/* OBJ_TYPE_REF accessors. */
	#define OBJ_TYPE_REF_EXPR(NODE) TREE_OPERAND (OBJ_TYPE_REF_CHECK (NODE), 0)
	#define OBJ_TYPE_REF_OBJECT(NODE) TREE_OPERAND (OBJ_TYPE_REF_CHECK (NODE), 1)
	#define OBJ_TYPE_REF_TOKEN(NODE) TREE_OPERAND (OBJ_TYPE_REF_CHECK (NODE), 2)

	/* ASSERT_EXPR accessors. */
	#define ASSERT_EXPR_VAR(NODE) TREE_OPERAND (ASSERT_EXPR_CHECK (NODE), 0)
	#define ASSERT_EXPR_COND(NODE) TREE_OPERAND (ASSERT_EXPR_CHECK (NODE), 1)

	/* OpenMP directive and clause accessors. */

	#define OMP_BODY(NODE) \
	TREE_OPERAND (TREE_RANGE_CHECK (NODE, OMP_PARALLEL, OMP_CRITICAL), 0)
	#define OMP_CLAUSES(NODE) \
	TREE_OPERAND (TREE_RANGE_CHECK (NODE, OMP_PARALLEL, OMP_SINGLE), 1)

	#define OMP_PARALLEL_BODY(NODE) TREE_OPERAND (OMP_PARALLEL_CHECK (NODE), 0)
	#define OMP_PARALLEL_CLAUSES(NODE) TREE_OPERAND (OMP_PARALLEL_CHECK (NODE), 1)
	#define OMP_PARALLEL_FN(NODE) TREE_OPERAND (OMP_PARALLEL_CHECK (NODE), 2)
	#define OMP_PARALLEL_DATA_ARG(NODE) TREE_OPERAND (OMP_PARALLEL_CHECK (NODE), 3)

	#define OMP_FOR_BODY(NODE) TREE_OPERAND (OMP_FOR_CHECK (NODE), 0)
	#define OMP_FOR_CLAUSES(NODE) TREE_OPERAND (OMP_FOR_CHECK (NODE), 1)
	#define OMP_FOR_INIT(NODE) TREE_OPERAND (OMP_FOR_CHECK (NODE), 2)
	#define OMP_FOR_COND(NODE) TREE_OPERAND (OMP_FOR_CHECK (NODE), 3)
	#define OMP_FOR_INCR(NODE) TREE_OPERAND (OMP_FOR_CHECK (NODE), 4)
	#define OMP_FOR_PRE_BODY(NODE) TREE_OPERAND (OMP_FOR_CHECK (NODE), 5)

	#define OMP_SECTIONS_BODY(NODE) TREE_OPERAND (OMP_SECTIONS_CHECK (NODE), 0)
	#define OMP_SECTIONS_CLAUSES(NODE) TREE_OPERAND (OMP_SECTIONS_CHECK (NODE), 1)

	#define OMP_SECTION_BODY(NODE) TREE_OPERAND (OMP_SECTION_CHECK (NODE), 0)

	#define OMP_SINGLE_BODY(NODE) TREE_OPERAND (OMP_SINGLE_CHECK (NODE), 0)
	#define OMP_SINGLE_CLAUSES(NODE) TREE_OPERAND (OMP_SINGLE_CHECK (NODE), 1)

	#define OMP_MASTER_BODY(NODE) TREE_OPERAND (OMP_MASTER_CHECK (NODE), 0)

	#define OMP_ORDERED_BODY(NODE) TREE_OPERAND (OMP_ORDERED_CHECK (NODE), 0)

	#define OMP_CRITICAL_BODY(NODE) TREE_OPERAND (OMP_CRITICAL_CHECK (NODE), 0)
	#define OMP_CRITICAL_NAME(NODE) TREE_OPERAND (OMP_CRITICAL_CHECK (NODE), 1)

	#define OMP_CLAUSE_CHAIN(NODE) TREE_CHAIN (OMP_CLAUSE_CHECK (NODE))
	#define OMP_CLAUSE_DECL(NODE) \
	OMP_CLAUSE_OPERAND (OMP_CLAUSE_RANGE_CHECK (OMP_CLAUSE_CHECK (NODE), \
	OMP_CLAUSE_PRIVATE, \
	OMP_CLAUSE_COPYPRIVATE), 0)

	/* True on an OMP_SECTION statement that was the last lexical member.
	This status is meaningful in the implementation of lastprivate. */
	#define OMP_SECTION_LAST(NODE) \
	TREE_PRIVATE (OMP_SECTION_CHECK (NODE))

	/* True on an OMP_RETURN statement if the return does not require a
	thread synchronization via some sort of barrier. The exact barrier
	that would otherwise be emitted is dependent on the OMP statement
	with which this return is associated. */
	#define OMP_RETURN_NOWAIT(NODE) \
	TREE_PRIVATE (OMP_RETURN_CHECK (NODE))

	/* True on an OMP_PARALLEL statement if it represents an explicit
	combined parallel work-sharing constructs. */
	#define OMP_PARALLEL_COMBINED(NODE) \
	TREE_PRIVATE (OMP_PARALLEL_CHECK (NODE))

	/* True on a PRIVATE clause if its decl is kept around for debugging
	information only and its DECL_VALUE_EXPR is supposed to point
	to what it has been remapped to. */
	#define OMP_CLAUSE_PRIVATE_DEBUG(NODE) \
	TREE_PUBLIC (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_PRIVATE))

	/* True on a LASTPRIVATE clause if a FIRSTPRIVATE clause for the same
	decl is present in the chain. */
	#define OMP_CLAUSE_LASTPRIVATE_FIRSTPRIVATE(NODE) \
	TREE_PUBLIC (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_LASTPRIVATE))

	#define OMP_CLAUSE_IF_EXPR(NODE) \
	OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_IF), 0)
	#define OMP_CLAUSE_NUM_THREADS_EXPR(NODE) \
	OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_NUM_THREADS),0)
	#define OMP_CLAUSE_SCHEDULE_CHUNK_EXPR(NODE) \
	OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_SCHEDULE), 0)

	#define OMP_CLAUSE_REDUCTION_CODE(NODE) \
	(OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_REDUCTION)->omp_clause.subcode.reduction_code)
	#define OMP_CLAUSE_REDUCTION_INIT(NODE) \
	OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_REDUCTION), 1)
	#define OMP_CLAUSE_REDUCTION_MERGE(NODE) \
	OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_REDUCTION), 2)
	#define OMP_CLAUSE_REDUCTION_PLACEHOLDER(NODE) \
	OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_REDUCTION), 3)

	enum omp_clause_schedule_kind
	{
	OMP_CLAUSE_SCHEDULE_STATIC,
	OMP_CLAUSE_SCHEDULE_DYNAMIC,
	OMP_CLAUSE_SCHEDULE_GUIDED,
	OMP_CLAUSE_SCHEDULE_RUNTIME
	};

	#define OMP_CLAUSE_SCHEDULE_KIND(NODE) \
	(OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_SCHEDULE)->omp_clause.subcode.schedule_kind)

	enum omp_clause_default_kind
	{
	OMP_CLAUSE_DEFAULT_UNSPECIFIED,
	OMP_CLAUSE_DEFAULT_SHARED,
	OMP_CLAUSE_DEFAULT_NONE,
	OMP_CLAUSE_DEFAULT_PRIVATE
	};

	#define OMP_CLAUSE_DEFAULT_KIND(NODE) \
	(OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_DEFAULT)->omp_clause.subcode.default_kind)

	struct tree_exp GTY(())
	{
	struct tree_common common;
	source_locus locus;
	int complexity;
	tree block;
	tree GTY ((special ("tree_exp"),
	desc ("TREE_CODE ((tree) &%0)")))
	operands[1];
	};

	/* SSA_NAME accessors. */

	/* Returns the variable being referenced. Once released, this is the
	only field that can be relied upon. */
	#define SSA_NAME_VAR(NODE) SSA_NAME_CHECK (NODE)->ssa_name.var

	/* Returns the statement which defines this reference. Note that
	we use the same field when chaining SSA_NAME nodes together on
	the SSA_NAME freelist. */
	#define SSA_NAME_DEF_STMT(NODE) SSA_NAME_CHECK (NODE)->common.chain

	/* Returns the SSA version number of this SSA name. Note that in
	tree SSA, version numbers are not per variable and may be recycled. */
	#define SSA_NAME_VERSION(NODE) SSA_NAME_CHECK (NODE)->ssa_name.version

	/* Nonzero if this SSA name occurs in an abnormal PHI. SSA_NAMES are
	never output, so we can safely use the ASM_WRITTEN_FLAG for this
	status bit. */
	#define SSA_NAME_OCCURS_IN_ABNORMAL_PHI(NODE) \
	SSA_NAME_CHECK (NODE)->common.asm_written_flag

	/* Nonzero if this SSA_NAME expression is currently on the free list of
	SSA_NAMES. Using NOTHROW_FLAG seems reasonably safe since throwing
	has no meaning for an SSA_NAME. */
	#define SSA_NAME_IN_FREE_LIST(NODE) \
	SSA_NAME_CHECK (NODE)->common.nothrow_flag

	/* Attributes for SSA_NAMEs for pointer-type variables. */
	#define SSA_NAME_PTR_INFO(N) \
	SSA_NAME_CHECK (N)->ssa_name.ptr_info

	/* Get the value of this SSA_NAME, if available. */
	#define SSA_NAME_VALUE(N) \
	SSA_NAME_CHECK (N)->ssa_name.value_handle

	#ifndef _TREE_FLOW_H
	struct ptr_info_def;
	#endif



	/* Immediate use linking structure. This structure is used for maintaining
	a doubly linked list of uses of an SSA_NAME. */
	typedef struct ssa_use_operand_d GTY(())
	{
	struct ssa_use_operand_d* GTY((skip(""))) prev;
	struct ssa_use_operand_d* GTY((skip(""))) next;
	tree GTY((skip(""))) stmt;
	tree *GTY((skip(""))) use;
	} ssa_use_operand_t;

	/* Return the immediate_use information for an SSA_NAME. */
	#define SSA_NAME_IMM_USE_NODE(NODE) SSA_NAME_CHECK (NODE)->ssa_name.imm_uses

	struct tree_ssa_name GTY(())
	{
	struct tree_common common;

	/* _DECL wrapped by this SSA name. */
	tree var;

	/* SSA version number. */
	unsigned int version;

	/* Pointer attributes used for alias analysis. */
	struct ptr_info_def *ptr_info;

	/* Value for SSA name used by various passes.

	Right now only invariants are allowed to persist beyond a pass in
	this field; in the future we will allow VALUE_HANDLEs to persist
	as well. */
	tree value_handle;

	/* Immediate uses list for this SSA_NAME. */
	struct ssa_use_operand_d imm_uses;
	};

	/* In a PHI_NODE node. */

	/* These 2 macros should be considered off limits for use by developers. If
	you wish to access the use or def fields of a PHI_NODE in the SSA
	optimizers, use the accessor macros found in tree-ssa-operands.h.
	These two macros are to be used only by those accessor macros, and other
	select places where we absolutely must take the address of the tree. */

	#define PHI_RESULT_TREE(NODE) PHI_NODE_CHECK (NODE)->phi.result
	#define PHI_ARG_DEF_TREE(NODE, I) PHI_NODE_ELT_CHECK (NODE, I).def

	/* PHI_NODEs for each basic block are chained together in a single linked
	list. The head of the list is linked from the block annotation, and
	the link to the next PHI is in PHI_CHAIN. */
	#define PHI_CHAIN(NODE) TREE_CHAIN (PHI_NODE_CHECK (NODE))

	#define PHI_NUM_ARGS(NODE) PHI_NODE_CHECK (NODE)->phi.num_args
	#define PHI_ARG_CAPACITY(NODE) PHI_NODE_CHECK (NODE)->phi.capacity
	#define PHI_ARG_ELT(NODE, I) PHI_NODE_ELT_CHECK (NODE, I)
	#define PHI_ARG_EDGE(NODE, I) (EDGE_PRED (PHI_BB ((NODE)), (I)))
	#define PHI_BB(NODE) PHI_NODE_CHECK (NODE)->phi.bb
	#define PHI_ARG_IMM_USE_NODE(NODE, I) PHI_NODE_ELT_CHECK (NODE, I).imm_use

	struct phi_arg_d GTY(())
	{
	/* imm_use MUST be the first element in struct because we do some
	pointer arithmetic with it. See phi_arg_index_from_use. */
	struct ssa_use_operand_d imm_use;
	tree def;
	};

	struct tree_phi_node GTY(())
	{
	struct tree_common common;
	tree result;
	int num_args;
	int capacity;

	/* Basic block to that the phi node belongs. */
	struct basic_block_def *bb;

	/* Arguments of the PHI node. These are maintained in the same
	order as predecessor edge vector BB->PREDS. */
	struct phi_arg_d GTY ((length ("((tree)&%h)->phi.num_args"))) a[1];
	};

	#define OMP_CLAUSE_CODE(NODE) \
	(OMP_CLAUSE_CHECK (NODE))->omp_clause.code

	#define OMP_CLAUSE_SET_CODE(NODE, CODE) \
	((OMP_CLAUSE_CHECK (NODE))->omp_clause.code = (CODE))

	#define OMP_CLAUSE_CODE(NODE) \
	(OMP_CLAUSE_CHECK (NODE))->omp_clause.code

	#define OMP_CLAUSE_OPERAND(NODE, I) \
	OMP_CLAUSE_ELT_CHECK (NODE, I)

	struct tree_omp_clause GTY(())
	{
	struct tree_common common;
	enum omp_clause_code code;
	union omp_clause_subcode {
	enum omp_clause_default_kind default_kind;
	enum omp_clause_schedule_kind schedule_kind;
	enum tree_code reduction_code;
	} GTY ((skip)) subcode;
	tree GTY ((length ("omp_clause_num_ops[OMP_CLAUSE_CODE ((tree)&%h)]"))) ops[1];
	};


	struct varray_head_tag;

	/* In a BLOCK node. */
	#define BLOCK_VARS(NODE) (BLOCK_CHECK (NODE)->block.vars)
	#define BLOCK_SUBBLOCKS(NODE) (BLOCK_CHECK (NODE)->block.subblocks)
	#define BLOCK_SUPERCONTEXT(NODE) (BLOCK_CHECK (NODE)->block.supercontext)
	/* Note: when changing this, make sure to find the places
	that use chainon or nreverse. */
	#define BLOCK_CHAIN(NODE) TREE_CHAIN (BLOCK_CHECK (NODE))
	#define BLOCK_ABSTRACT_ORIGIN(NODE) (BLOCK_CHECK (NODE)->block.abstract_origin)
	#define BLOCK_ABSTRACT(NODE) (BLOCK_CHECK (NODE)->block.abstract_flag)

	/* Nonzero means that this block is prepared to handle exceptions
	listed in the BLOCK_VARS slot. */
	#define BLOCK_HANDLER_BLOCK(NODE) \
	(BLOCK_CHECK (NODE)->block.handler_block_flag)

	/* An index number for this block. These values are not guaranteed to
	be unique across functions -- whether or not they are depends on
	the debugging output format in use. */
	#define BLOCK_NUMBER(NODE) (BLOCK_CHECK (NODE)->block.block_num)

	/* If block reordering splits a lexical block into discontiguous
	address ranges, we'll make a copy of the original block.

	Note that this is logically distinct from BLOCK_ABSTRACT_ORIGIN.
	In that case, we have one source block that has been replicated
	(through inlining or unrolling) into many logical blocks, and that
	these logical blocks have different physical variables in them.

	In this case, we have one logical block split into several
	non-contiguous address ranges. Most debug formats can't actually
	represent this idea directly, so we fake it by creating multiple
	logical blocks with the same variables in them. However, for those
	that do support non-contiguous regions, these allow the original
	logical block to be reconstructed, along with the set of address
	ranges.

	One of the logical block fragments is arbitrarily chosen to be
	the ORIGIN. The other fragments will point to the origin via
	BLOCK_FRAGMENT_ORIGIN; the origin itself will have this pointer
	be null. The list of fragments will be chained through
	BLOCK_FRAGMENT_CHAIN from the origin. */

	#define BLOCK_FRAGMENT_ORIGIN(NODE) (BLOCK_CHECK (NODE)->block.fragment_origin)
	#define BLOCK_FRAGMENT_CHAIN(NODE) (BLOCK_CHECK (NODE)->block.fragment_chain)

	/* For an inlined function, this gives the location where it was called
	from. This is only set in the top level block, which corresponds to the
	inlined function scope. This is used in the debug output routines. */

	#define BLOCK_SOURCE_LOCATION(NODE) (BLOCK_CHECK (NODE)->block.locus)

	struct tree_block GTY(())
	{
	struct tree_common common;

	unsigned handler_block_flag : 1;
	unsigned abstract_flag : 1;
	unsigned block_num : 30;

	tree vars;
	tree subblocks;
	tree supercontext;
	tree abstract_origin;
	tree fragment_origin;
	tree fragment_chain;
	location_t locus;
	};

	/* Define fields and accessors for nodes representing data types. */

	/* See tree.def for documentation of the use of these fields.
	Look at the documentation of the various ..._TYPE tree codes.

	Note that the type.values, type.minval, and type.maxval fields are
	overloaded and used for different macros in different kinds of types.
	Each macro must check to ensure the tree node is of the proper kind of
	type. Note also that some of the front-ends also overload these fields,
	so they must be checked as well. */

	#define TYPE_UID(NODE) (TYPE_CHECK (NODE)->type.uid)
	#define TYPE_SIZE(NODE) (TYPE_CHECK (NODE)->type.size)
	#define TYPE_SIZE_UNIT(NODE) (TYPE_CHECK (NODE)->type.size_unit)
	#define TYPE_MODE(NODE) (TYPE_CHECK (NODE)->type.mode)
	#define TYPE_VALUES(NODE) (ENUMERAL_TYPE_CHECK (NODE)->type.values)
	#define TYPE_DOMAIN(NODE) (ARRAY_TYPE_CHECK (NODE)->type.values)
	#define TYPE_FIELDS(NODE) (RECORD_OR_UNION_CHECK (NODE)->type.values)
	#define TYPE_CACHED_VALUES(NODE) (TYPE_CHECK(NODE)->type.values)
	#define TYPE_ORIG_SIZE_TYPE(NODE) \
	(INTEGER_TYPE_CHECK (NODE)->type.values \
	? TREE_TYPE ((NODE)->type.values) : NULL_TREE)
	#define TYPE_METHODS(NODE) (RECORD_OR_UNION_CHECK (NODE)->type.maxval)
	#define TYPE_VFIELD(NODE) (RECORD_OR_UNION_CHECK (NODE)->type.minval)
	#define TYPE_ARG_TYPES(NODE) (FUNC_OR_METHOD_CHECK (NODE)->type.values)
	#define TYPE_METHOD_BASETYPE(NODE) (FUNC_OR_METHOD_CHECK (NODE)->type.maxval)
	#define TYPE_OFFSET_BASETYPE(NODE) (OFFSET_TYPE_CHECK (NODE)->type.maxval)
	#define TYPE_POINTER_TO(NODE) (TYPE_CHECK (NODE)->type.pointer_to)
	#define TYPE_REFERENCE_TO(NODE) (TYPE_CHECK (NODE)->type.reference_to)
	#define TYPE_NEXT_PTR_TO(NODE) (POINTER_TYPE_CHECK (NODE)->type.minval)
	#define TYPE_NEXT_REF_TO(NODE) (REFERENCE_TYPE_CHECK (NODE)->type.minval)
	#define TYPE_MIN_VALUE(NODE) (NUMERICAL_TYPE_CHECK (NODE)->type.minval)
	#define TYPE_MAX_VALUE(NODE) (NUMERICAL_TYPE_CHECK (NODE)->type.maxval)
	#define TYPE_PRECISION(NODE) (TYPE_CHECK (NODE)->type.precision)
	#define TYPE_SYMTAB_ADDRESS(NODE) (TYPE_CHECK (NODE)->type.symtab.address)
	#define TYPE_SYMTAB_POINTER(NODE) (TYPE_CHECK (NODE)->type.symtab.pointer)
	#define TYPE_SYMTAB_DIE(NODE) (TYPE_CHECK (NODE)->type.symtab.die)
	#define TYPE_NAME(NODE) (TYPE_CHECK (NODE)->type.name)
	#define TYPE_NEXT_VARIANT(NODE) (TYPE_CHECK (NODE)->type.next_variant)
	#define TYPE_MAIN_VARIANT(NODE) (TYPE_CHECK (NODE)->type.main_variant)
	#define TYPE_CONTEXT(NODE) (TYPE_CHECK (NODE)->type.context)
	#define TYPE_LANG_SPECIFIC(NODE) (TYPE_CHECK (NODE)->type.lang_specific)

	/* For a VECTOR_TYPE node, this describes a different type which is emitted
	in the debugging output. We use this to describe a vector as a
	structure containing an array. */
	#define TYPE_DEBUG_REPRESENTATION_TYPE(NODE) (VECTOR_TYPE_CHECK (NODE)->type.values)

	/* For record and union types, information about this type, as a base type
	for itself. */
	#define TYPE_BINFO(NODE) (RECORD_OR_UNION_CHECK(NODE)->type.binfo)

	/* For non record and union types, used in a language-dependent way. */
	#define TYPE_LANG_SLOT_1(NODE) (NOT_RECORD_OR_UNION_CHECK(NODE)->type.binfo)

	/* The (language-specific) typed-based alias set for this type.
	Objects whose TYPE_ALIAS_SETs are different cannot alias each
	other. If the TYPE_ALIAS_SET is -1, no alias set has yet been
	assigned to this type. If the TYPE_ALIAS_SET is 0, objects of this
	type can alias objects of any type. */
	#define TYPE_ALIAS_SET(NODE) (TYPE_CHECK (NODE)->type.alias_set)

	/* Nonzero iff the typed-based alias set for this type has been
	calculated. */
	#define TYPE_ALIAS_SET_KNOWN_P(NODE) (TYPE_CHECK (NODE)->type.alias_set != -1)

	/* A TREE_LIST of IDENTIFIER nodes of the attributes that apply
	to this type. */
	#define TYPE_ATTRIBUTES(NODE) (TYPE_CHECK (NODE)->type.attributes)

	/* The alignment necessary for objects of this type.
	The value is an int, measured in bits. */
	#define TYPE_ALIGN(NODE) (TYPE_CHECK (NODE)->type.align)

	/* 1 if the alignment for this type was requested by "aligned" attribute,
	0 if it is the default for this type. */
	#define TYPE_USER_ALIGN(NODE) (TYPE_CHECK (NODE)->type.user_align)

	/* The alignment for NODE, in bytes. */
	#define TYPE_ALIGN_UNIT(NODE) (TYPE_ALIGN (NODE) / BITS_PER_UNIT)

	/* If your language allows you to declare types, and you want debug info
	for them, then you need to generate corresponding TYPE_DECL nodes.
	These "stub" TYPE_DECL nodes have no name, and simply point at the
	type node. You then set the TYPE_STUB_DECL field of the type node
	to point back at the TYPE_DECL node. This allows the debug routines
	to know that the two nodes represent the same type, so that we only
	get one debug info record for them. */
	#define TYPE_STUB_DECL(NODE) TREE_CHAIN (NODE)

	/* In a RECORD_TYPE, UNION_TYPE or QUAL_UNION_TYPE, it means the type
	has BLKmode only because it lacks the alignment requirement for
	its size. */
	#define TYPE_NO_FORCE_BLK(NODE) (TYPE_CHECK (NODE)->type.no_force_blk_flag)

	/* In an INTEGER_TYPE, it means the type represents a size. We use
	this both for validity checking and to permit optimizations that
	are unsafe for other types. Note that the C `size_t' type should
	not have this flag set. The `size_t' type is simply a typedef
	for an ordinary integer type that happens to be the type of an
	expression returned by `sizeof'; `size_t' has no special
	properties. Expressions whose type have TYPE_IS_SIZETYPE set are
	always actual sizes. */
	#define TYPE_IS_SIZETYPE(NODE) \
	(INTEGER_TYPE_CHECK (NODE)->type.no_force_blk_flag)

	/* In a FUNCTION_TYPE, indicates that the function returns with the stack
	pointer depressed. */
	#define TYPE_RETURNS_STACK_DEPRESSED(NODE) \
	(FUNCTION_TYPE_CHECK (NODE)->type.no_force_blk_flag)

	/* Nonzero in a type considered volatile as a whole. */
	#define TYPE_VOLATILE(NODE) (TYPE_CHECK (NODE)->common.volatile_flag)

	/* Means this type is const-qualified. */
	#define TYPE_READONLY(NODE) (TYPE_CHECK (NODE)->common.readonly_flag)

	/* If nonzero, this type is `restrict'-qualified, in the C sense of
	the term. */
	#define TYPE_RESTRICT(NODE) (TYPE_CHECK (NODE)->type.restrict_flag)

	/* There is a TYPE_QUAL value for each type qualifier. They can be
	combined by bitwise-or to form the complete set of qualifiers for a
	type. */

	#define TYPE_UNQUALIFIED 0x0
	#define TYPE_QUAL_CONST 0x1
	#define TYPE_QUAL_VOLATILE 0x2
	#define TYPE_QUAL_RESTRICT 0x4

	/* The set of type qualifiers for this type. */
	#define TYPE_QUALS(NODE) \
	((TYPE_READONLY (NODE) * TYPE_QUAL_CONST) \
	\| (TYPE_VOLATILE (NODE) * TYPE_QUAL_VOLATILE) \
	\| (TYPE_RESTRICT (NODE) * TYPE_QUAL_RESTRICT))

	/* These flags are available for each language front end to use internally. */
	#define TYPE_LANG_FLAG_0(NODE) (TYPE_CHECK (NODE)->type.lang_flag_0)
	#define TYPE_LANG_FLAG_1(NODE) (TYPE_CHECK (NODE)->type.lang_flag_1)
	#define TYPE_LANG_FLAG_2(NODE) (TYPE_CHECK (NODE)->type.lang_flag_2)
	#define TYPE_LANG_FLAG_3(NODE) (TYPE_CHECK (NODE)->type.lang_flag_3)
	#define TYPE_LANG_FLAG_4(NODE) (TYPE_CHECK (NODE)->type.lang_flag_4)
	#define TYPE_LANG_FLAG_5(NODE) (TYPE_CHECK (NODE)->type.lang_flag_5)
	#define TYPE_LANG_FLAG_6(NODE) (TYPE_CHECK (NODE)->type.lang_flag_6)

	/* Used to keep track of visited nodes in tree traversals. This is set to
	0 by copy_node and make_node. */
	#define TREE_VISITED(NODE) ((NODE)->common.visited)

	/* If set in an ARRAY_TYPE, indicates a string type (for languages
	that distinguish string from array of char).
	If set in a INTEGER_TYPE, indicates a character type. */
	#define TYPE_STRING_FLAG(NODE) (TYPE_CHECK (NODE)->type.string_flag)

	/* If non-NULL, this is an upper bound of the size (in bytes) of an
	object of the given ARRAY_TYPE. This allows temporaries to be
	allocated. */
	#define TYPE_ARRAY_MAX_SIZE(ARRAY_TYPE) \
	(ARRAY_TYPE_CHECK (ARRAY_TYPE)->type.maxval)

	/* For a VECTOR_TYPE, this is the number of sub-parts of the vector. */
	#define TYPE_VECTOR_SUBPARTS(VECTOR_TYPE) \
	(((unsigned HOST_WIDE_INT) 1) \
	<< VECTOR_TYPE_CHECK (VECTOR_TYPE)->type.precision)

	/* Set precision to n when we have 2^n sub-parts of the vector. */
	#define SET_TYPE_VECTOR_SUBPARTS(VECTOR_TYPE, X) \
	(VECTOR_TYPE_CHECK (VECTOR_TYPE)->type.precision = exact_log2 (X))

	/* Indicates that objects of this type must be initialized by calling a
	function when they are created. */
	#define TYPE_NEEDS_CONSTRUCTING(NODE) \
	(TYPE_CHECK (NODE)->type.needs_constructing_flag)

	/* Indicates that objects of this type (a UNION_TYPE), should be passed
	the same way that the first union alternative would be passed. */
	#define TYPE_TRANSPARENT_UNION(NODE) \
	(UNION_TYPE_CHECK (NODE)->type.transparent_union_flag)

	/* For an ARRAY_TYPE, indicates that it is not permitted to
	take the address of a component of the type. */
	#define TYPE_NONALIASED_COMPONENT(NODE) \
	(ARRAY_TYPE_CHECK (NODE)->type.transparent_union_flag)

	/* Indicated that objects of this type should be laid out in as
	compact a way as possible. */
	#define TYPE_PACKED(NODE) (TYPE_CHECK (NODE)->type.packed_flag)

	/* Used by type_contains_placeholder_p to avoid recomputation.
	Values are: 0 (unknown), 1 (false), 2 (true). Never access
	this field directly. */
	#define TYPE_CONTAINS_PLACEHOLDER_INTERNAL(NODE) \
	(TYPE_CHECK (NODE)->type.contains_placeholder_bits)

	struct die_struct;

	struct tree_type GTY(())
	{
	struct tree_common common;
	tree values;
	tree size;
	tree size_unit;
	tree attributes;
	unsigned int uid;

	unsigned int precision : 9;
	ENUM_BITFIELD(machine_mode) mode : 7;

	unsigned string_flag : 1;
	unsigned no_force_blk_flag : 1;
	unsigned needs_constructing_flag : 1;
	unsigned transparent_union_flag : 1;
	unsigned packed_flag : 1;
	unsigned restrict_flag : 1;
	unsigned contains_placeholder_bits : 2;

	unsigned lang_flag_0 : 1;
	unsigned lang_flag_1 : 1;
	unsigned lang_flag_2 : 1;
	unsigned lang_flag_3 : 1;
	unsigned lang_flag_4 : 1;
	unsigned lang_flag_5 : 1;
	unsigned lang_flag_6 : 1;
	unsigned user_align : 1;

	unsigned int align;
	tree pointer_to;
	tree reference_to;
	union tree_type_symtab {
	int GTY ((tag ("0"))) address;
	char * GTY ((tag ("1"))) pointer;
	struct die_struct * GTY ((tag ("2"))) die;
	} GTY ((desc ("debug_hooks == &sdb_debug_hooks ? 1 : debug_hooks == &dwarf2_debug_hooks ? 2 : 0"),
	descbits ("2"))) symtab;
	tree name;
	tree minval;
	tree maxval;
	tree next_variant;
	tree main_variant;
	tree binfo;
	tree context;
	HOST_WIDE_INT alias_set;
	/* Points to a structure whose details depend on the language in use. */
	struct lang_type *lang_specific;
	};

	/* Define accessor macros for information about type inheritance
	and basetypes.

	A "basetype" means a particular usage of a data type for inheritance
	in another type. Each such basetype usage has its own "binfo"
	object to describe it. The binfo object is a TREE_VEC node.

	Inheritance is represented by the binfo nodes allocated for a
	given type. For example, given types C and D, such that D is
	inherited by C, 3 binfo nodes will be allocated: one for describing
	the binfo properties of C, similarly one for D, and one for
	describing the binfo properties of D as a base type for C.
	Thus, given a pointer to class C, one can get a pointer to the binfo
	of D acting as a basetype for C by looking at C's binfo's basetypes. */

	/* BINFO specific flags. */

	/* Nonzero means that the derivation chain is via a `virtual' declaration. */
	#define BINFO_VIRTUAL_P(NODE) (TREE_BINFO_CHECK (NODE)->common.static_flag)

	/* Flags for language dependent use. */
	#define BINFO_MARKED(NODE) TREE_LANG_FLAG_0(TREE_BINFO_CHECK(NODE))
	#define BINFO_FLAG_1(NODE) TREE_LANG_FLAG_1(TREE_BINFO_CHECK(NODE))
	#define BINFO_FLAG_2(NODE) TREE_LANG_FLAG_2(TREE_BINFO_CHECK(NODE))
	#define BINFO_FLAG_3(NODE) TREE_LANG_FLAG_3(TREE_BINFO_CHECK(NODE))
	#define BINFO_FLAG_4(NODE) TREE_LANG_FLAG_4(TREE_BINFO_CHECK(NODE))
	#define BINFO_FLAG_5(NODE) TREE_LANG_FLAG_5(TREE_BINFO_CHECK(NODE))
	#define BINFO_FLAG_6(NODE) TREE_LANG_FLAG_6(TREE_BINFO_CHECK(NODE))

	/* The actual data type node being inherited in this basetype. */
	#define BINFO_TYPE(NODE) TREE_TYPE (TREE_BINFO_CHECK(NODE))

	/* The offset where this basetype appears in its containing type.
	BINFO_OFFSET slot holds the offset (in bytes)
	from the base of the complete object to the base of the part of the
	object that is allocated on behalf of this `type'.
	This is always 0 except when there is multiple inheritance. */

	#define BINFO_OFFSET(NODE) (TREE_BINFO_CHECK(NODE)->binfo.offset)
	#define BINFO_OFFSET_ZEROP(NODE) (integer_zerop (BINFO_OFFSET (NODE)))

	/* The virtual function table belonging to this basetype. Virtual
	function tables provide a mechanism for run-time method dispatching.
	The entries of a virtual function table are language-dependent. */

	#define BINFO_VTABLE(NODE) (TREE_BINFO_CHECK(NODE)->binfo.vtable)

	/* The virtual functions in the virtual function table. This is
	a TREE_LIST that is used as an initial approximation for building
	a virtual function table for this basetype. */
	#define BINFO_VIRTUALS(NODE) (TREE_BINFO_CHECK(NODE)->binfo.virtuals)

	/* A vector of binfos for the direct basetypes inherited by this
	basetype.

	If this basetype describes type D as inherited in C, and if the
	basetypes of D are E and F, then this vector contains binfos for
	inheritance of E and F by C. */
	#define BINFO_BASE_BINFOS(NODE) (&TREE_BINFO_CHECK(NODE)->binfo.base_binfos)

	/* The number of basetypes for NODE. */
	#define BINFO_N_BASE_BINFOS(NODE) (VEC_length (tree, BINFO_BASE_BINFOS (NODE)))

	/* Accessor macro to get to the Nth base binfo of this binfo. */
	#define BINFO_BASE_BINFO(NODE,N) \
	(VEC_index (tree, BINFO_BASE_BINFOS (NODE), (N)))
	#define BINFO_BASE_ITERATE(NODE,N,B) \
	(VEC_iterate (tree, BINFO_BASE_BINFOS (NODE), (N), (B)))
	#define BINFO_BASE_APPEND(NODE,T) \
	(VEC_quick_push (tree, BINFO_BASE_BINFOS (NODE), (T)))

	/* For a BINFO record describing a virtual base class, i.e., one where
	TREE_VIA_VIRTUAL is set, this field assists in locating the virtual
	base. The actual contents are language-dependent. In the C++
	front-end this field is an INTEGER_CST giving an offset into the
	vtable where the offset to the virtual base can be found. */
	#define BINFO_VPTR_FIELD(NODE) (TREE_BINFO_CHECK(NODE)->binfo.vptr_field)

	/* Indicates the accesses this binfo has to its bases. The values are
	access_public_node, access_protected_node or access_private_node.
	If this array is not present, public access is implied. */
	#define BINFO_BASE_ACCESSES(NODE) (TREE_BINFO_CHECK(NODE)->binfo.base_accesses)

	#define BINFO_BASE_ACCESS(NODE,N) \
	VEC_index (tree, BINFO_BASE_ACCESSES (NODE), (N))
	#define BINFO_BASE_ACCESS_APPEND(NODE,T) \
	VEC_quick_push (tree, BINFO_BASE_ACCESSES (NODE), (T))

	/* The index in the VTT where this subobject's sub-VTT can be found.
	NULL_TREE if there is no sub-VTT. */
	#define BINFO_SUBVTT_INDEX(NODE) (TREE_BINFO_CHECK(NODE)->binfo.vtt_subvtt)

	/* The index in the VTT where the vptr for this subobject can be
	found. NULL_TREE if there is no secondary vptr in the VTT. */
	#define BINFO_VPTR_INDEX(NODE) (TREE_BINFO_CHECK(NODE)->binfo.vtt_vptr)

	/* The BINFO_INHERITANCE_CHAIN points at the binfo for the base
	inheriting this base for non-virtual bases. For virtual bases it
	points either to the binfo for which this is a primary binfo, or to
	the binfo of the most derived type. */
	#define BINFO_INHERITANCE_CHAIN(NODE) \
	(TREE_BINFO_CHECK(NODE)->binfo.inheritance)

	struct tree_binfo GTY (())
	{
	struct tree_common common;

	tree offset;
	tree vtable;
	tree virtuals;
	tree vptr_field;
	VEC(tree,gc) *base_accesses;
	tree inheritance;

	tree vtt_subvtt;
	tree vtt_vptr;

	VEC(tree,none) base_binfos;
	};


	/* Define fields and accessors for nodes representing declared names. */

	/* Nonzero if DECL represents a variable for the SSA passes. */
	#define SSA_VAR_P(DECL) \
	(TREE_CODE (DECL) == VAR_DECL \
	\|\| TREE_CODE (DECL) == PARM_DECL \
	\|\| TREE_CODE (DECL) == RESULT_DECL \
	\|\| MTAG_P (DECL) \
	\|\| (TREE_CODE (DECL) == SSA_NAME \
	&& (TREE_CODE (SSA_NAME_VAR (DECL)) == VAR_DECL \
	\|\| TREE_CODE (SSA_NAME_VAR (DECL)) == PARM_DECL \
	\|\| TREE_CODE (SSA_NAME_VAR (DECL)) == RESULT_DECL \
	\|\| MTAG_P (SSA_NAME_VAR (DECL)))))




	/* Enumerate visibility settings. */
	#ifndef SYMBOL_VISIBILITY_DEFINED
	#define SYMBOL_VISIBILITY_DEFINED
	enum symbol_visibility
	{
	VISIBILITY_DEFAULT,
	VISIBILITY_PROTECTED,
	VISIBILITY_HIDDEN,
	VISIBILITY_INTERNAL
	};
	#endif

	struct function;


	/* This is the name of the object as written by the user.
	It is an IDENTIFIER_NODE. */
	#define DECL_NAME(NODE) (DECL_MINIMAL_CHECK (NODE)->decl_minimal.name)

	/* Every ..._DECL node gets a unique number. */
	#define DECL_UID(NODE) (DECL_MINIMAL_CHECK (NODE)->decl_minimal.uid)

	/* These two fields describe where in the source code the declaration
	was. If the declaration appears in several places (as for a C
	function that is declared first and then defined later), this
	information should refer to the definition. */
	#define DECL_SOURCE_LOCATION(NODE) (DECL_MINIMAL_CHECK (NODE)->decl_minimal.locus)
	#define DECL_SOURCE_FILE(NODE) LOCATION_FILE (DECL_SOURCE_LOCATION (NODE))
	#define DECL_SOURCE_LINE(NODE) LOCATION_LINE (DECL_SOURCE_LOCATION (NODE))
	#ifdef USE_MAPPED_LOCATION
	#define DECL_IS_BUILTIN(DECL) \
	(DECL_SOURCE_LOCATION (DECL) <= BUILTINS_LOCATION)
	#else
	#define DECL_IS_BUILTIN(DECL) (DECL_SOURCE_LINE(DECL) == 0)
	#endif

	/* For FIELD_DECLs, this is the RECORD_TYPE, UNION_TYPE, or
	QUAL_UNION_TYPE node that the field is a member of. For VAR_DECL,
	PARM_DECL, FUNCTION_DECL, LABEL_DECL, and CONST_DECL nodes, this
	points to either the FUNCTION_DECL for the containing function,
	the RECORD_TYPE or UNION_TYPE for the containing type, or
	NULL_TREE or a TRANSLATION_UNIT_DECL if the given decl has "file
	scope". */
	#define DECL_CONTEXT(NODE) (DECL_MINIMAL_CHECK (NODE)->decl_minimal.context)
	#define DECL_FIELD_CONTEXT(NODE) (FIELD_DECL_CHECK (NODE)->decl_minimal.context)
	struct tree_decl_minimal GTY(())
	{
	struct tree_common common;
	location_t locus;
	unsigned int uid;
	tree name;
	tree context;
	};

	/* When computing aliasing information, we represent the memory pointed-to
	by pointers with artificial variables called "memory tags" (MT). There
	are two kinds of tags, namely symbol and name:

	Symbol tags (SMT) are used in flow-insensitive alias analysis, they
	represent all the pointed-to locations and variables pointed-to by
	the same pointer symbol. Usually, this set is computed using
	type-based analysis (i.e., alias set classes), but this may not
	always be the case.

	Name tags (NMT) are used in flow-sensitive points-to alias
	analysis, they represent the variables and memory locations
	pointed-to by a specific SSA_NAME pointer.

	In general, given a pointer P with a symbol tag SMT, the alias set
	of SMT should be the union of all the alias sets of the NMTs of
	every SSA_NAME for P. */
	struct tree_memory_tag GTY(())
	{
	struct tree_decl_minimal common;
	unsigned int is_global:1;
	unsigned int is_used_alone:1;
	unsigned int old_used_alone:1;
	};

	#define MTAG_GLOBAL(NODE) (TREE_MEMORY_TAG_CHECK (NODE)->mtag.is_global)

	/* This flag is true if a SMT is used as the V_MAY_DEF or VUSE operand
	directly, because the access had all of the SMT's aliases pruned
	from it. */
	#define SMT_USED_ALONE(NODE) (SYMBOL_MEMORY_TAG_CHECK (NODE)->mtag.is_used_alone)

	/* This flag is used to temporarily store the old value of the used alone
	flag when updating so we know whether to mark the symbol for
	renaming. */
	#define SMT_OLD_USED_ALONE(NODE) (SYMBOL_MEMORY_TAG_CHECK (NODE)->mtag.old_used_alone)

	struct tree_struct_field_tag GTY(())
	{
	struct tree_memory_tag common;

	/* Parent variable. */
	tree parent_var;

	/* Offset inside structure. */
	unsigned HOST_WIDE_INT offset;

	/* Size of the field. */
	unsigned HOST_WIDE_INT size;

	};
	#define SFT_PARENT_VAR(NODE) (STRUCT_FIELD_TAG_CHECK (NODE)->sft.parent_var)
	#define SFT_OFFSET(NODE) (STRUCT_FIELD_TAG_CHECK (NODE)->sft.offset)
	#define SFT_SIZE(NODE) (STRUCT_FIELD_TAG_CHECK (NODE)->sft.size)

	/* For any sort of a ..._DECL node, this points to the original (abstract)
	decl node which this decl is an instance of, or else it is NULL indicating
	that this decl is not an instance of some other decl. For example,
	in a nested declaration of an inline function, this points back to the
	definition. */
	#define DECL_ABSTRACT_ORIGIN(NODE) (DECL_COMMON_CHECK (NODE)->decl_common.abstract_origin)

	/* Like DECL_ABSTRACT_ORIGIN, but returns NODE if there's no abstract
	origin. This is useful when setting the DECL_ABSTRACT_ORIGIN. */
	#define DECL_ORIGIN(NODE) \
	(DECL_ABSTRACT_ORIGIN (NODE) ? DECL_ABSTRACT_ORIGIN (NODE) : (NODE))

	/* Nonzero for any sort of ..._DECL node means this decl node represents an
	inline instance of some original (abstract) decl from an inline function;
	suppress any warnings about shadowing some other variable. FUNCTION_DECL
	nodes can also have their abstract origin set to themselves. */
	#define DECL_FROM_INLINE(NODE) (DECL_ABSTRACT_ORIGIN (NODE) != NULL_TREE \
	&& DECL_ABSTRACT_ORIGIN (NODE) != (NODE))

	/* In a DECL this is the field where attributes are stored. */
	#define DECL_ATTRIBUTES(NODE) (DECL_COMMON_CHECK (NODE)->decl_common.attributes)

	/* For a FUNCTION_DECL, holds the tree of BINDINGs.
	For a TRANSLATION_UNIT_DECL, holds the namespace's BLOCK.
	For a VAR_DECL, holds the initial value.
	For a PARM_DECL, not used--default
	values for parameters are encoded in the type of the function,
	not in the PARM_DECL slot.
	For a FIELD_DECL, this is used for enumeration values and the C
	frontend uses it for temporarily storing bitwidth of bitfields.

	??? Need to figure out some way to check this isn't a PARM_DECL. */
	#define DECL_INITIAL(NODE) (DECL_COMMON_CHECK (NODE)->decl_common.initial)

	/* Holds the size of the datum, in bits, as a tree expression.
	Need not be constant. */
	#define DECL_SIZE(NODE) (DECL_COMMON_CHECK (NODE)->decl_common.size)
	/* Likewise for the size in bytes. */
	#define DECL_SIZE_UNIT(NODE) (DECL_COMMON_CHECK (NODE)->decl_common.size_unit)
	/* Holds the alignment required for the datum, in bits. */
	#define DECL_ALIGN(NODE) (DECL_COMMON_CHECK (NODE)->decl_common.align)
	/* The alignment of NODE, in bytes. */
	#define DECL_ALIGN_UNIT(NODE) (DECL_ALIGN (NODE) / BITS_PER_UNIT)
	/* Set if the alignment of this DECL has been set by the user, for
	example with an 'aligned' attribute. */
	#define DECL_USER_ALIGN(NODE) (DECL_COMMON_CHECK (NODE)->decl_common.user_align)
	/* Holds the machine mode corresponding to the declaration of a variable or
	field. Always equal to TYPE_MODE (TREE_TYPE (decl)) except for a
	FIELD_DECL. */
	#define DECL_MODE(NODE) (DECL_COMMON_CHECK (NODE)->decl_common.mode)

	/* For FUNCTION_DECL, if it is built-in, this identifies which built-in
	operation it is. Note, however, that this field is overloaded, with
	DECL_BUILT_IN_CLASS as the discriminant, so the latter must always be
	checked before any access to the former. */
	#define DECL_FUNCTION_CODE(NODE) \
	(FUNCTION_DECL_CHECK (NODE)->function_decl.function_code)
	#define DECL_DEBUG_EXPR_IS_FROM(NODE) \
	(DECL_COMMON_CHECK (NODE)->decl_common.debug_expr_is_from)

	/* Nonzero for a given ..._DECL node means that the name of this node should
	be ignored for symbolic debug purposes. */
	#define DECL_IGNORED_P(NODE) (DECL_COMMON_CHECK (NODE)->decl_common.ignored_flag)

	/* Nonzero for a given ..._DECL node means that this node represents an
	"abstract instance" of the given declaration (e.g. in the original
	declaration of an inline function). When generating symbolic debugging
	information, we mustn't try to generate any address information for nodes
	marked as "abstract instances" because we don't actually generate
	any code or allocate any data space for such instances. */
	#define DECL_ABSTRACT(NODE) (DECL_COMMON_CHECK (NODE)->decl_common.abstract_flag)

	/* Language-specific decl information. */
	#define DECL_LANG_SPECIFIC(NODE) (DECL_COMMON_CHECK (NODE)->decl_common.lang_specific)

	/* In a VAR_DECL or FUNCTION_DECL, nonzero means external reference:
	do not allocate storage, and refer to a definition elsewhere. Note that
	this does not necessarily imply the entity represented by NODE
	has no program source-level definition in this translation unit. For
	example, for a FUNCTION_DECL, DECL_SAVED_TREE may be non-NULL and
	DECL_EXTERNAL may be true simultaneously; that can be the case for
	a C99 "extern inline" function. */
	#define DECL_EXTERNAL(NODE) (DECL_COMMON_CHECK (NODE)->decl_common.decl_flag_2)

	/* In a VAR_DECL for a RECORD_TYPE, sets number for non-init_priority
	initializations. */
	#define DEFAULT_INIT_PRIORITY 65535
	#define MAX_INIT_PRIORITY 65535
	#define MAX_RESERVED_INIT_PRIORITY 100


	/* Nonzero in a ..._DECL means this variable is ref'd from a nested function.
	For VAR_DECL nodes, PARM_DECL nodes, and FUNCTION_DECL nodes.

	For LABEL_DECL nodes, nonzero if nonlocal gotos to the label are permitted.

	Also set in some languages for variables, etc., outside the normal
	lexical scope, such as class instance variables. */
	#define DECL_NONLOCAL(NODE) (DECL_COMMON_CHECK (NODE)->decl_common.nonlocal_flag)

	/* Used in VAR_DECLs to indicate that the variable is a vtable.
	Used in FIELD_DECLs for vtable pointers.
	Used in FUNCTION_DECLs to indicate that the function is virtual. */
	#define DECL_VIRTUAL_P(NODE) (DECL_COMMON_CHECK (NODE)->decl_common.virtual_flag)

	/* Used to indicate that this DECL represents a compiler-generated entity. */
	#define DECL_ARTIFICIAL(NODE) (DECL_COMMON_CHECK (NODE)->decl_common.artificial_flag)

	/* Additional flags for language-specific uses. */
	#define DECL_LANG_FLAG_0(NODE) (DECL_COMMON_CHECK (NODE)->decl_common.lang_flag_0)
	#define DECL_LANG_FLAG_1(NODE) (DECL_COMMON_CHECK (NODE)->decl_common.lang_flag_1)
	#define DECL_LANG_FLAG_2(NODE) (DECL_COMMON_CHECK (NODE)->decl_common.lang_flag_2)
	#define DECL_LANG_FLAG_3(NODE) (DECL_COMMON_CHECK (NODE)->decl_common.lang_flag_3)
	#define DECL_LANG_FLAG_4(NODE) (DECL_COMMON_CHECK (NODE)->decl_common.lang_flag_4)
	#define DECL_LANG_FLAG_5(NODE) (DECL_COMMON_CHECK (NODE)->decl_common.lang_flag_5)
	#define DECL_LANG_FLAG_6(NODE) (DECL_COMMON_CHECK (NODE)->decl_common.lang_flag_6)
	#define DECL_LANG_FLAG_7(NODE) (DECL_COMMON_CHECK (NODE)->decl_common.lang_flag_7)

	/* Used to indicate an alias set for the memory pointed to by this
	particular FIELD_DECL, PARM_DECL, or VAR_DECL, which must have
	pointer (or reference) type. */
	#define DECL_POINTER_ALIAS_SET(NODE) \
	(DECL_COMMON_CHECK (NODE)->decl_common.pointer_alias_set)

	/* Nonzero if an alias set has been assigned to this declaration. */
	#define DECL_POINTER_ALIAS_SET_KNOWN_P(NODE) \
	(DECL_POINTER_ALIAS_SET (NODE) != - 1)

	/* Nonzero for a decl which is at file scope. */
	#define DECL_FILE_SCOPE_P(EXP) \
	(! DECL_CONTEXT (EXP) \
	\|\| TREE_CODE (DECL_CONTEXT (EXP)) == TRANSLATION_UNIT_DECL)

	/* Nonzero for a decl that is decorated using attribute used.
	This indicates compiler tools that this decl needs to be preserved. */
	#define DECL_PRESERVE_P(DECL) \
	DECL_COMMON_CHECK (DECL)->decl_common.preserve_flag

	/* For function local variables of COMPLEX type, indicates that the
	variable is not aliased, and that all modifications to the variable
	have been adjusted so that they are killing assignments. Thus the
	variable may now be treated as a GIMPLE register, and use real
	instead of virtual ops in SSA form. */
	#define DECL_COMPLEX_GIMPLE_REG_P(DECL) \
	DECL_COMMON_CHECK (DECL)->decl_common.gimple_reg_flag

	/* This is true if DECL is call clobbered in the current function.
	The result of this flag should always be the same as
	bitmap_bit_p (call_clobbered_vars, DECL_UID (decl)). */
	#define DECL_CALL_CLOBBERED(DECL) \
	DECL_COMMON_CHECK (DECL)->decl_common.call_clobbered_flag

	struct tree_decl_common GTY(())
	{
	struct tree_decl_minimal common;
	tree size;

	ENUM_BITFIELD(machine_mode) mode : 8;

	unsigned nonlocal_flag : 1;
	unsigned virtual_flag : 1;
	unsigned ignored_flag : 1;
	unsigned abstract_flag : 1;
	unsigned artificial_flag : 1;
	unsigned user_align : 1;
	unsigned preserve_flag: 1;
	unsigned debug_expr_is_from : 1;

	unsigned lang_flag_0 : 1;
	unsigned lang_flag_1 : 1;
	unsigned lang_flag_2 : 1;
	unsigned lang_flag_3 : 1;
	unsigned lang_flag_4 : 1;
	unsigned lang_flag_5 : 1;
	unsigned lang_flag_6 : 1;
	unsigned lang_flag_7 : 1;

	/* In LABEL_DECL, this is DECL_ERROR_ISSUED.
	In VAR_DECL and PARM_DECL, this is DECL_REGISTER. */
	unsigned decl_flag_0 : 1;
	/* In FIELD_DECL, this is DECL_PACKED. */
	unsigned decl_flag_1 : 1;
	/* In FIELD_DECL, this is DECL_BIT_FIELD
	In VAR_DECL and FUNCTION_DECL, this is DECL_EXTERNAL.
	In TYPE_DECL, this is TYPE_DECL_SUPRESS_DEBUG. */
	unsigned decl_flag_2 : 1;
	/* In FIELD_DECL, this is DECL_NONADDRESSABLE_P
	In VAR_DECL and PARM_DECL, this is DECL_HAS_VALUE_EXPR. */
	unsigned decl_flag_3 : 1;
	/* Logically, these two would go in a theoretical base shared by var and
	parm decl. */
	unsigned gimple_reg_flag : 1;
	unsigned call_clobbered_flag : 1;

	unsigned int align : 24;
	/* DECL_OFFSET_ALIGN, used only for FIELD_DECLs. */
	unsigned int off_align : 8;

	tree size_unit;
	tree initial;
	tree attributes;
	tree abstract_origin;

	HOST_WIDE_INT pointer_alias_set;
	/* Points to a structure whose details depend on the language in use. */
	struct lang_decl *lang_specific;
	};

	extern tree decl_value_expr_lookup (tree);
	extern void decl_value_expr_insert (tree, tree);

	/* In a VAR_DECL or PARM_DECL, the location at which the value may be found,
	if transformations have made this more complicated than evaluating the
	decl itself. This should only be used for debugging; once this field has
	been set, the decl itself may not legitimately appear in the function. */
	#define DECL_HAS_VALUE_EXPR_P(NODE) \
	(TREE_CHECK2 (NODE, VAR_DECL, PARM_DECL)->decl_common.decl_flag_3)
	#define DECL_VALUE_EXPR(NODE) \
	(decl_value_expr_lookup (DECL_WRTL_CHECK (NODE)))
	#define SET_DECL_VALUE_EXPR(NODE, VAL) \
	(decl_value_expr_insert (DECL_WRTL_CHECK (NODE), VAL))

	/* Holds the RTL expression for the value of a variable or function.
	This value can be evaluated lazily for functions, variables with
	static storage duration, and labels. */
	#define DECL_RTL(NODE) \
	(DECL_WRTL_CHECK (NODE)->decl_with_rtl.rtl \
	? (NODE)->decl_with_rtl.rtl \
	: (make_decl_rtl (NODE), (NODE)->decl_with_rtl.rtl))

	/* Set the DECL_RTL for NODE to RTL. */
	#define SET_DECL_RTL(NODE, RTL) set_decl_rtl (NODE, RTL)

	/* Returns nonzero if NODE is a tree node that can contain RTL. */
	#define HAS_RTL_P(NODE) (CODE_CONTAINS_STRUCT (TREE_CODE (NODE), TS_DECL_WRTL))

	/* Returns nonzero if the DECL_RTL for NODE has already been set. */
	#define DECL_RTL_SET_P(NODE) (HAS_RTL_P (NODE) && DECL_WRTL_CHECK (NODE)->decl_with_rtl.rtl != NULL)

	/* Copy the RTL from NODE1 to NODE2. If the RTL was not set for
	NODE1, it will not be set for NODE2; this is a lazy copy. */
	#define COPY_DECL_RTL(NODE1, NODE2) \
	(DECL_WRTL_CHECK (NODE2)->decl_with_rtl.rtl = DECL_WRTL_CHECK (NODE1)->decl_with_rtl.rtl)

	/* The DECL_RTL for NODE, if it is set, or NULL, if it is not set. */
	#define DECL_RTL_IF_SET(NODE) (DECL_RTL_SET_P (NODE) ? DECL_RTL (NODE) : NULL)

	/* In VAR_DECL and PARM_DECL nodes, nonzero means declared `register'. */
	#define DECL_REGISTER(NODE) (DECL_WRTL_CHECK (NODE)->decl_common.decl_flag_0)

	struct tree_decl_with_rtl GTY(())
	{
	struct tree_decl_common common;
	rtx rtl;
	};

	/* In a FIELD_DECL, this is the field position, counting in bytes, of the
	DECL_OFFSET_ALIGN-bit-sized word containing the bit closest to the beginning
	of the structure. */
	#define DECL_FIELD_OFFSET(NODE) (FIELD_DECL_CHECK (NODE)->field_decl.offset)

	/* In a FIELD_DECL, this is the offset, in bits, of the first bit of the
	field from DECL_FIELD_OFFSET. This field may be nonzero even for fields
	that are not bit fields (since DECL_OFFSET_ALIGN may be larger than the
	natural alignment of the field's type). */
	#define DECL_FIELD_BIT_OFFSET(NODE) (FIELD_DECL_CHECK (NODE)->field_decl.bit_offset)

	/* In a FIELD_DECL, this indicates whether the field was a bit-field and
	if so, the type that was originally specified for it.
	TREE_TYPE may have been modified (in finish_struct). */
	#define DECL_BIT_FIELD_TYPE(NODE) (FIELD_DECL_CHECK (NODE)->field_decl.bit_field_type)

	/* For a FIELD_DECL in a QUAL_UNION_TYPE, records the expression, which
	if nonzero, indicates that the field occupies the type. */
	#define DECL_QUALIFIER(NODE) (FIELD_DECL_CHECK (NODE)->field_decl.qualifier)

	/* For FIELD_DECLs, off_align holds the number of low-order bits of
	DECL_FIELD_OFFSET which are known to be always zero.
	DECL_OFFSET_ALIGN thus returns the alignment that DECL_FIELD_OFFSET
	has. */
	#define DECL_OFFSET_ALIGN(NODE) \
	(((unsigned HOST_WIDE_INT)1) << FIELD_DECL_CHECK (NODE)->decl_common.off_align)

	/* Specify that DECL_ALIGN(NODE) is a multiple of X. */
	#define SET_DECL_OFFSET_ALIGN(NODE, X) \
	(FIELD_DECL_CHECK (NODE)->decl_common.off_align = exact_log2 ((X) & -(X)))
	/* 1 if the alignment for this type was requested by "aligned" attribute,
	0 if it is the default for this type. */

	/* For FIELD_DECLS, DECL_FCONTEXT is the first baseclass in
	which this FIELD_DECL is defined. This information is needed when
	writing debugging information about vfield and vbase decls for C++. */
	#define DECL_FCONTEXT(NODE) (FIELD_DECL_CHECK (NODE)->field_decl.fcontext)

	/* In a FIELD_DECL, indicates this field should be bit-packed. */
	#define DECL_PACKED(NODE) (FIELD_DECL_CHECK (NODE)->decl_common.decl_flag_1)

	/* Nonzero in a FIELD_DECL means it is a bit field, and must be accessed
	specially. */
	#define DECL_BIT_FIELD(NODE) (FIELD_DECL_CHECK (NODE)->decl_common.decl_flag_2)

	/* Used in a FIELD_DECL to indicate that we cannot form the address of
	this component. */
	#define DECL_NONADDRESSABLE_P(NODE) \
	(FIELD_DECL_CHECK (NODE)->decl_common.decl_flag_3)

	struct tree_field_decl GTY(())
	{
	struct tree_decl_common common;

	tree offset;
	tree bit_field_type;
	tree qualifier;
	tree bit_offset;
	tree fcontext;

	};

	/* A numeric unique identifier for a LABEL_DECL. The UID allocation is
	dense, unique within any one function, and may be used to index arrays.
	If the value is -1, then no UID has been assigned. */
	#define LABEL_DECL_UID(NODE) \
	(LABEL_DECL_CHECK (NODE)->decl_common.pointer_alias_set)

	/* In LABEL_DECL nodes, nonzero means that an error message about
	jumping into such a binding contour has been printed for this label. */
	#define DECL_ERROR_ISSUED(NODE) (LABEL_DECL_CHECK (NODE)->decl_common.decl_flag_0)

	struct tree_label_decl GTY(())
	{
	struct tree_decl_with_rtl common;
	/* Java's verifier has some need to store information about labels,
	and was using fields that no longer exist on labels.
	Once the verifier doesn't need these anymore, they should be removed. */
	tree java_field_1;
	tree java_field_2;
	tree java_field_3;
	unsigned int java_field_4;

	};

	struct tree_result_decl GTY(())
	{
	struct tree_decl_with_rtl common;
	};

	struct tree_const_decl GTY(())
	{
	struct tree_decl_with_rtl common;
	};

	/* For a PARM_DECL, records the data type used to pass the argument,
	which may be different from the type seen in the program. */
	#define DECL_ARG_TYPE(NODE) (PARM_DECL_CHECK (NODE)->decl_common.initial)

	/* For PARM_DECL, holds an RTL for the stack slot or register
	where the data was actually passed. */
	#define DECL_INCOMING_RTL(NODE) (PARM_DECL_CHECK (NODE)->parm_decl.incoming_rtl)

	struct tree_parm_decl GTY(())
	{
	struct tree_decl_with_rtl common;
	rtx incoming_rtl;
	};


	/* Nonzero in a decl means that the gimplifier has seen (or placed)
	this variable in a BIND_EXPR. */
	#define DECL_SEEN_IN_BIND_EXPR_P(NODE) \
	(DECL_WITH_VIS_CHECK (NODE)->decl_with_vis.seen_in_bind_expr)

	/* Used to indicate that the linkage status of this DECL is not yet known,
	so it should not be output now. */
	#define DECL_DEFER_OUTPUT(NODE) (DECL_WITH_VIS_CHECK (NODE)->decl_with_vis.defer_output)

	/* Nonzero for a given ..._DECL node means that no warnings should be
	generated just because this node is unused. */
	#define DECL_IN_SYSTEM_HEADER(NODE) \
	(DECL_WITH_VIS_CHECK (NODE)->decl_with_vis.in_system_header_flag)

	/* Used to indicate that this DECL has weak linkage. */
	#define DECL_WEAK(NODE) (DECL_WITH_VIS_CHECK (NODE)->decl_with_vis.weak_flag)

	/* Internal to the gimplifier. Indicates that the value is a formal
	temporary controlled by the gimplifier. */
	#define DECL_GIMPLE_FORMAL_TEMP_P(DECL) \
	DECL_WITH_VIS_CHECK (DECL)->decl_with_vis.gimple_formal_temp

	/* Used to indicate that the DECL is a dllimport. */
	#define DECL_DLLIMPORT_P(NODE) (DECL_WITH_VIS_CHECK (NODE)->decl_with_vis.dllimport_flag)

	/* DECL_BASED_ON_RESTRICT_P records whether a VAR_DECL is a temporary
	based on a variable with a restrict qualified type. If it is,
	DECL_RESTRICT_BASE returns the restrict qualified variable on which
	it is based. */

	#define DECL_BASED_ON_RESTRICT_P(NODE) \
	(VAR_DECL_CHECK (NODE)->decl_with_vis.based_on_restrict_p)
	#define DECL_GET_RESTRICT_BASE(NODE) \
	(decl_restrict_base_lookup (VAR_DECL_CHECK (NODE)))
	#define SET_DECL_RESTRICT_BASE(NODE, VAL) \
	(decl_restrict_base_insert (VAR_DECL_CHECK (NODE), (VAL)))

	extern tree decl_restrict_base_lookup (tree);
	extern void decl_restrict_base_insert (tree, tree);

	/* Used in a DECL to indicate that, even if it TREE_PUBLIC, it need
	not be put out unless it is needed in this translation unit.
	Entities like this are shared across translation units (like weak
	entities), but are guaranteed to be generated by any translation
	unit that needs them, and therefore need not be put out anywhere
	where they are not needed. DECL_COMDAT is just a hint to the
	back-end; it is up to front-ends which set this flag to ensure
	that there will never be any harm, other than bloat, in putting out
	something which is DECL_COMDAT. */
	#define DECL_COMDAT(NODE) (DECL_WITH_VIS_CHECK (NODE)->decl_with_vis.comdat_flag)

	/* A replaceable function is one which may be replaced at link-time
	with an entirely different definition, provided that the
	replacement has the same type. For example, functions declared
	with __attribute__((weak)) on most systems are replaceable.

	COMDAT functions are not replaceable, since all definitions of the
	function must be equivalent. It is important that COMDAT functions
	not be treated as replaceable so that use of C++ template
	instantiations is not penalized.

	For example, DECL_REPLACEABLE is used to determine whether or not a
	function (including a template instantiation) which is not
	explicitly declared "inline" can be inlined. If the function is
	DECL_REPLACEABLE then it is not safe to do the inlining, since the
	implementation chosen at link-time may be different. However, a
	function that is not DECL_REPLACEABLE can be inlined, since all
	versions of the function will be functionally identical. */
	#define DECL_REPLACEABLE_P(NODE) \
	(!DECL_COMDAT (NODE) && !targetm.binds_local_p (NODE))

	/* The name of the object as the assembler will see it (but before any
	translations made by ASM_OUTPUT_LABELREF). Often this is the same
	as DECL_NAME. It is an IDENTIFIER_NODE. */
	#define DECL_ASSEMBLER_NAME(NODE) decl_assembler_name (NODE)

	/* Return true if NODE is a NODE that can contain a DECL_ASSEMBLER_NAME.
	This is true of all DECL nodes except FIELD_DECL. */
	#define HAS_DECL_ASSEMBLER_NAME_P(NODE) \
	(CODE_CONTAINS_STRUCT (TREE_CODE (NODE), TS_DECL_WITH_VIS))

	/* Returns nonzero if the DECL_ASSEMBLER_NAME for NODE has been set. If zero,
	the NODE might still have a DECL_ASSEMBLER_NAME -- it just hasn't been set
	yet. */
	#define DECL_ASSEMBLER_NAME_SET_P(NODE) \
	(HAS_DECL_ASSEMBLER_NAME_P (NODE) && DECL_WITH_VIS_CHECK (NODE)->decl_with_vis.assembler_name != NULL_TREE)

	/* Set the DECL_ASSEMBLER_NAME for NODE to NAME. */
	#define SET_DECL_ASSEMBLER_NAME(NODE, NAME) \
	(DECL_WITH_VIS_CHECK (NODE)->decl_with_vis.assembler_name = (NAME))

	/* Copy the DECL_ASSEMBLER_NAME from DECL1 to DECL2. Note that if DECL1's
	DECL_ASSEMBLER_NAME has not yet been set, using this macro will not cause
	the DECL_ASSEMBLER_NAME of either DECL to be set. In other words, the
	semantics of using this macro, are different than saying:

	SET_DECL_ASSEMBLER_NAME(DECL2, DECL_ASSEMBLER_NAME (DECL1))

	which will try to set the DECL_ASSEMBLER_NAME for DECL1. */

	#define COPY_DECL_ASSEMBLER_NAME(DECL1, DECL2) \
	(DECL_ASSEMBLER_NAME_SET_P (DECL1) \
	? (void) SET_DECL_ASSEMBLER_NAME (DECL2, \
	DECL_ASSEMBLER_NAME (DECL1)) \
	: (void) 0)

	/* Records the section name in a section attribute. Used to pass
	the name from decl_attributes to make_function_rtl and make_decl_rtl. */
	#define DECL_SECTION_NAME(NODE) (DECL_WITH_VIS_CHECK (NODE)->decl_with_vis.section_name)

	/* Value of the decls's visibility attribute */
	#define DECL_VISIBILITY(NODE) (DECL_WITH_VIS_CHECK (NODE)->decl_with_vis.visibility)

	/* Nonzero means that the decl had its visibility specified rather than
	being inferred. */
	#define DECL_VISIBILITY_SPECIFIED(NODE) (DECL_WITH_VIS_CHECK (NODE)->decl_with_vis.visibility_specified)

	/* Used in TREE_PUBLIC decls to indicate that copies of this DECL in
	multiple translation units should be merged. */
	#define DECL_ONE_ONLY(NODE) (DECL_WITH_VIS_CHECK (NODE)->decl_with_vis.one_only)

	struct tree_decl_with_vis GTY(())
	{
	struct tree_decl_with_rtl common;
	tree assembler_name;
	tree section_name;

	/* Belong to VAR_DECL exclusively. */
	unsigned defer_output:1;
	unsigned hard_register:1;
	unsigned thread_local:1;
	unsigned common_flag:1;
	unsigned in_text_section : 1;
	unsigned gimple_formal_temp : 1;
	unsigned dllimport_flag : 1;
	unsigned based_on_restrict_p : 1;
	/* Used by C++. Might become a generic decl flag. */
	unsigned shadowed_for_var_p : 1;

	/* Don't belong to VAR_DECL exclusively. */
	unsigned in_system_header_flag : 1;
	unsigned weak_flag:1;
	unsigned seen_in_bind_expr : 1;
	unsigned comdat_flag : 1;
	ENUM_BITFIELD(symbol_visibility) visibility : 2;
	unsigned visibility_specified : 1;
	/* Belong to FUNCTION_DECL exclusively. */
	unsigned one_only : 1;
	unsigned init_priority_p:1;

	/* Belongs to VAR_DECL exclusively. */
	ENUM_BITFIELD(tls_model) tls_model : 3;
	/* 11 unused bits. */
	};

	/* In a VAR_DECL that's static,
	nonzero if the space is in the text section. */
	#define DECL_IN_TEXT_SECTION(NODE) (VAR_DECL_CHECK (NODE)->decl_with_vis.in_text_section)

	/* Nonzero for a given ..._DECL node means that this node should be
	put in .common, if possible. If a DECL_INITIAL is given, and it
	is not error_mark_node, then the decl cannot be put in .common. */
	#define DECL_COMMON(NODE) (DECL_WITH_VIS_CHECK (NODE)->decl_with_vis.common_flag)

	/* In a VAR_DECL, nonzero if the decl is a register variable with
	an explicit asm specification. */
	#define DECL_HARD_REGISTER(NODE) (VAR_DECL_CHECK (NODE)->decl_with_vis.hard_register)

	extern tree decl_debug_expr_lookup (tree);
	extern void decl_debug_expr_insert (tree, tree);
	/* For VAR_DECL, this is set to either an expression that it was split
	from (if DECL_DEBUG_EXPR_IS_FROM is true), otherwise a tree_list of
	subexpressions that it was split into. */
	#define DECL_DEBUG_EXPR(NODE) \
	(decl_debug_expr_lookup (VAR_DECL_CHECK (NODE)))

	#define SET_DECL_DEBUG_EXPR(NODE, VAL) \
	(decl_debug_expr_insert (VAR_DECL_CHECK (NODE), VAL))


	extern unsigned short decl_init_priority_lookup (tree);
	extern void decl_init_priority_insert (tree, unsigned short);

	/* In a non-local VAR_DECL with static storage duration, this is the
	initialization priority. If this value is zero, the NODE will be
	initialized at the DEFAULT_INIT_PRIORITY. Only used by C++ FE*/

	#define DECL_HAS_INIT_PRIORITY_P(NODE) \
	(VAR_DECL_CHECK (NODE)->decl_with_vis.init_priority_p)
	#define DECL_INIT_PRIORITY(NODE) \
	(decl_init_priority_lookup (VAR_DECL_CHECK (NODE)))
	#define SET_DECL_INIT_PRIORITY(NODE, VAL) \
	(decl_init_priority_insert (VAR_DECL_CHECK (NODE), VAL))

	/* In a VAR_DECL, the model to use if the data should be allocated from
	thread-local storage. */
	#define DECL_TLS_MODEL(NODE) (VAR_DECL_CHECK (NODE)->decl_with_vis.tls_model)

	/* In a VAR_DECL, nonzero if the data should be allocated from
	thread-local storage. */
	#define DECL_THREAD_LOCAL_P(NODE) \
	(VAR_DECL_CHECK (NODE)->decl_with_vis.tls_model != TLS_MODEL_NONE)

	struct tree_var_decl GTY(())
	{
	struct tree_decl_with_vis common;
	};


	/* This field is used to reference anything in decl.result and is meant only
	for use by the garbage collector. */
	#define DECL_RESULT_FLD(NODE) (DECL_NON_COMMON_CHECK (NODE)->decl_non_common.result)

	/* The DECL_VINDEX is used for FUNCTION_DECLS in two different ways.
	Before the struct containing the FUNCTION_DECL is laid out,
	DECL_VINDEX may point to a FUNCTION_DECL in a base class which
	is the FUNCTION_DECL which this FUNCTION_DECL will replace as a virtual
	function. When the class is laid out, this pointer is changed
	to an INTEGER_CST node which is suitable for use as an index
	into the virtual function table.
	C++ also uses this field in namespaces, hence the DECL_NON_COMMON_CHECK. */
	#define DECL_VINDEX(NODE) (DECL_NON_COMMON_CHECK (NODE)->decl_non_common.vindex)

	struct tree_decl_non_common GTY(())

	{
	struct tree_decl_with_vis common;
	/* C++ uses this in namespaces. */
	tree saved_tree;
	/* C++ uses this in templates. */
	tree arguments;
	/* Almost all FE's use this. */
	tree result;
	/* C++ uses this in namespaces. */
	tree vindex;
	};

	/* In FUNCTION_DECL, holds the decl for the return value. */
	#define DECL_RESULT(NODE) (FUNCTION_DECL_CHECK (NODE)->decl_non_common.result)

	/* In a FUNCTION_DECL, nonzero if the function cannot be inlined. */
	#define DECL_UNINLINABLE(NODE) (FUNCTION_DECL_CHECK (NODE)->function_decl.uninlinable)

	/* In a FUNCTION_DECL, the saved representation of the body of the
	entire function. */
	#define DECL_SAVED_TREE(NODE) (FUNCTION_DECL_CHECK (NODE)->decl_non_common.saved_tree)

	/* Nonzero in a FUNCTION_DECL means this function should be treated
	as if it were a malloc, meaning it returns a pointer that is
	not an alias. */
	#define DECL_IS_MALLOC(NODE) (FUNCTION_DECL_CHECK (NODE)->function_decl.malloc_flag)

	/* Nonzero in a FUNCTION_DECL means this function may return more
	than once. */
	#define DECL_IS_RETURNS_TWICE(NODE) \
	(FUNCTION_DECL_CHECK (NODE)->function_decl.returns_twice_flag)

	/* Nonzero in a FUNCTION_DECL means this function should be treated
	as "pure" function (like const function, but may read global memory). */
	#define DECL_IS_PURE(NODE) (FUNCTION_DECL_CHECK (NODE)->function_decl.pure_flag)

	/* Nonzero in a FUNCTION_DECL means this function should be treated
	as "novops" function (function that does not read global memory,
	but may have arbitrary side effects). */
	#define DECL_IS_NOVOPS(NODE) (FUNCTION_DECL_CHECK (NODE)->function_decl.novops_flag)

	/* Used in FUNCTION_DECLs to indicate that they should be run automatically
	at the beginning or end of execution. */
	#define DECL_STATIC_CONSTRUCTOR(NODE) \
	(FUNCTION_DECL_CHECK (NODE)->function_decl.static_ctor_flag)

	#define DECL_STATIC_DESTRUCTOR(NODE) \
	(FUNCTION_DECL_CHECK (NODE)->function_decl.static_dtor_flag)

	/* Used in FUNCTION_DECLs to indicate that function entry and exit should
	be instrumented with calls to support routines. */
	#define DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT(NODE) \
	(FUNCTION_DECL_CHECK (NODE)->function_decl.no_instrument_function_entry_exit)

	/* Used in FUNCTION_DECLs to indicate that limit-stack-* should be
	disabled in this function. */
	#define DECL_NO_LIMIT_STACK(NODE) \
	(FUNCTION_DECL_CHECK (NODE)->function_decl.no_limit_stack)

	/* In a FUNCTION_DECL with a nonzero DECL_CONTEXT, indicates that a
	static chain is not needed. */
	#define DECL_NO_STATIC_CHAIN(NODE) \
	(FUNCTION_DECL_CHECK (NODE)->function_decl.regdecl_flag)

	/* Nonzero for a decl that cgraph has decided should be inlined into
	at least one call site. It is not meaningful to look at this
	directly; always use cgraph_function_possibly_inlined_p. */
	#define DECL_POSSIBLY_INLINED(DECL) \
	FUNCTION_DECL_CHECK (DECL)->function_decl.possibly_inlined

	/* Nonzero in a FUNCTION_DECL means this function can be substituted
	where it is called. */
	#define DECL_INLINE(NODE) (FUNCTION_DECL_CHECK (NODE)->function_decl.inline_flag)

	/* Nonzero in a FUNCTION_DECL means that this function was declared inline,
	such as via the `inline' keyword in C/C++. This flag controls the linkage
	semantics of 'inline'; whether or not the function is inlined is
	controlled by DECL_INLINE. */
	#define DECL_DECLARED_INLINE_P(NODE) \
	(FUNCTION_DECL_CHECK (NODE)->function_decl.declared_inline_flag)

	/* For FUNCTION_DECL, this holds a pointer to a structure ("struct function")
	that describes the status of this function. */
	#define DECL_STRUCT_FUNCTION(NODE) (FUNCTION_DECL_CHECK (NODE)->function_decl.f)

	/* In a FUNCTION_DECL, nonzero means a built in function. */
	#define DECL_BUILT_IN(NODE) (DECL_BUILT_IN_CLASS (NODE) != NOT_BUILT_IN)

	/* For a builtin function, identify which part of the compiler defined it. */
	#define DECL_BUILT_IN_CLASS(NODE) \
	(FUNCTION_DECL_CHECK (NODE)->function_decl.built_in_class)

	/* In FUNCTION_DECL, a chain of ..._DECL nodes.
	VAR_DECL and PARM_DECL reserve the arguments slot for language-specific
	uses. */
	#define DECL_ARGUMENTS(NODE) (FUNCTION_DECL_CHECK (NODE)->decl_non_common.arguments)
	#define DECL_ARGUMENT_FLD(NODE) (DECL_NON_COMMON_CHECK (NODE)->decl_non_common.arguments)

	/* FUNCTION_DECL inherits from DECL_NON_COMMON because of the use of the
	arguments/result/saved_tree fields by front ends. It was either inherit
	FUNCTION_DECL from non_common, or inherit non_common from FUNCTION_DECL,
	which seemed a bit strange. */

	struct tree_function_decl GTY(())
	{
	struct tree_decl_non_common common;

	/* In a FUNCTION_DECL for which DECL_BUILT_IN holds, this is
	DECL_FUNCTION_CODE. Otherwise unused. */
	enum built_in_function function_code;

	unsigned static_ctor_flag : 1;
	unsigned static_dtor_flag : 1;
	unsigned uninlinable : 1;
	unsigned possibly_inlined : 1;
	unsigned novops_flag : 1;
	unsigned returns_twice_flag : 1;
	unsigned malloc_flag : 1;
	unsigned pure_flag : 1;

	unsigned declared_inline_flag : 1;
	unsigned regdecl_flag : 1;
	unsigned inline_flag : 1;
	unsigned no_instrument_function_entry_exit : 1;
	unsigned no_limit_stack : 1;
	ENUM_BITFIELD(built_in_class) built_in_class : 2;

	struct function *f;
	};

	/* For a TYPE_DECL, holds the "original" type. (TREE_TYPE has the copy.) */
	#define DECL_ORIGINAL_TYPE(NODE) (TYPE_DECL_CHECK (NODE)->decl_non_common.result)

	/* In a TYPE_DECL nonzero means the detail info about this type is not dumped
	into stabs. Instead it will generate cross reference ('x') of names.
	This uses the same flag as DECL_EXTERNAL. */
	#define TYPE_DECL_SUPPRESS_DEBUG(NODE) \
	(TYPE_DECL_CHECK (NODE)->decl_common.decl_flag_2)

	struct tree_type_decl GTY(())
	{
	struct tree_decl_non_common common;

	};

	/* A STATEMENT_LIST chains statements together in GENERIC and GIMPLE.
	To reduce overhead, the nodes containing the statements are not trees.
	This avoids the overhead of tree_common on all linked list elements.

	Use the interface in tree-iterator.h to access this node. */

	#define STATEMENT_LIST_HEAD(NODE) \
	(STATEMENT_LIST_CHECK (NODE)->stmt_list.head)
	#define STATEMENT_LIST_TAIL(NODE) \
	(STATEMENT_LIST_CHECK (NODE)->stmt_list.tail)

	struct tree_statement_list_node
	GTY ((chain_next ("%h.next"), chain_prev ("%h.prev")))
	{
	struct tree_statement_list_node *prev;
	struct tree_statement_list_node *next;
	tree stmt;
	};

	struct tree_statement_list
	GTY(())
	{
	struct tree_common common;
	struct tree_statement_list_node *head;
	struct tree_statement_list_node *tail;
	};

	#define VALUE_HANDLE_ID(NODE) \
	(VALUE_HANDLE_CHECK (NODE)->value_handle.id)

	#define VALUE_HANDLE_EXPR_SET(NODE) \
	(VALUE_HANDLE_CHECK (NODE)->value_handle.expr_set)

	#define VALUE_HANDLE_VUSES(NODE) \
	(VALUE_HANDLE_CHECK (NODE)->value_handle.vuses)

	/* Defined and used in tree-ssa-pre.c. */
	struct value_set;

	struct tree_value_handle GTY(())
	{
	struct tree_common common;

	/* The set of expressions represented by this handle. */
	struct value_set * GTY ((skip)) expr_set;

	/* Unique ID for this value handle. IDs are handed out in a
	conveniently dense form starting at 0, so that we can make
	bitmaps of value handles. */
	unsigned int id;

	/* Set of virtual uses represented by this handle. */
	VEC (tree, gc) *vuses;
	};

	/* Define the overall contents of a tree node.
	It may be any of the structures declared above
	for various types of node. */

	union tree_node GTY ((ptr_alias (union lang_tree_node),
	desc ("tree_node_structure (&%h)")))
	{
	struct tree_common GTY ((tag ("TS_COMMON"))) common;
	struct tree_int_cst GTY ((tag ("TS_INT_CST"))) int_cst;
	struct tree_real_cst GTY ((tag ("TS_REAL_CST"))) real_cst;
	struct tree_vector GTY ((tag ("TS_VECTOR"))) vector;
	struct tree_string GTY ((tag ("TS_STRING"))) string;
	struct tree_complex GTY ((tag ("TS_COMPLEX"))) complex;
	struct tree_identifier GTY ((tag ("TS_IDENTIFIER"))) identifier;
	struct tree_decl_minimal GTY((tag ("TS_DECL_MINIMAL"))) decl_minimal;
	struct tree_decl_common GTY ((tag ("TS_DECL_COMMON"))) decl_common;
	struct tree_decl_with_rtl GTY ((tag ("TS_DECL_WRTL"))) decl_with_rtl;
	struct tree_decl_non_common GTY ((tag ("TS_DECL_NON_COMMON"))) decl_non_common;
	struct tree_parm_decl GTY ((tag ("TS_PARM_DECL"))) parm_decl;
	struct tree_decl_with_vis GTY ((tag ("TS_DECL_WITH_VIS"))) decl_with_vis;
	struct tree_var_decl GTY ((tag ("TS_VAR_DECL"))) var_decl;
	struct tree_field_decl GTY ((tag ("TS_FIELD_DECL"))) field_decl;
	struct tree_label_decl GTY ((tag ("TS_LABEL_DECL"))) label_decl;
	struct tree_result_decl GTY ((tag ("TS_RESULT_DECL"))) result_decl;
	struct tree_const_decl GTY ((tag ("TS_CONST_DECL"))) const_decl;
	struct tree_type_decl GTY ((tag ("TS_TYPE_DECL"))) type_decl;
	struct tree_function_decl GTY ((tag ("TS_FUNCTION_DECL"))) function_decl;
	struct tree_type GTY ((tag ("TS_TYPE"))) type;
	struct tree_list GTY ((tag ("TS_LIST"))) list;
	struct tree_vec GTY ((tag ("TS_VEC"))) vec;
	struct tree_exp GTY ((tag ("TS_EXP"))) exp;
	struct tree_ssa_name GTY ((tag ("TS_SSA_NAME"))) ssa_name;
	struct tree_phi_node GTY ((tag ("TS_PHI_NODE"))) phi;
	struct tree_block GTY ((tag ("TS_BLOCK"))) block;
	struct tree_binfo GTY ((tag ("TS_BINFO"))) binfo;
	struct tree_statement_list GTY ((tag ("TS_STATEMENT_LIST"))) stmt_list;
	struct tree_value_handle GTY ((tag ("TS_VALUE_HANDLE"))) value_handle;
	struct tree_constructor GTY ((tag ("TS_CONSTRUCTOR"))) constructor;
	struct tree_memory_tag GTY ((tag ("TS_MEMORY_TAG"))) mtag;
	struct tree_struct_field_tag GTY ((tag ("TS_STRUCT_FIELD_TAG"))) sft;
	struct tree_omp_clause GTY ((tag ("TS_OMP_CLAUSE"))) omp_clause;
	};

	/* Standard named or nameless data types of the C compiler. */

	enum tree_index
	{
	TI_ERROR_MARK,
	TI_INTQI_TYPE,
	TI_INTHI_TYPE,
	TI_INTSI_TYPE,
	TI_INTDI_TYPE,
	TI_INTTI_TYPE,

	TI_UINTQI_TYPE,
	TI_UINTHI_TYPE,
	TI_UINTSI_TYPE,
	TI_UINTDI_TYPE,
	TI_UINTTI_TYPE,

	TI_UINT32_TYPE,
	TI_UINT64_TYPE,

	TI_INTEGER_ZERO,
	TI_INTEGER_ONE,
	TI_INTEGER_MINUS_ONE,
	TI_NULL_POINTER,

	TI_SIZE_ZERO,
	TI_SIZE_ONE,

	TI_BITSIZE_ZERO,
	TI_BITSIZE_ONE,
	TI_BITSIZE_UNIT,

	TI_PUBLIC,
	TI_PROTECTED,
	TI_PRIVATE,

	TI_BOOLEAN_FALSE,
	TI_BOOLEAN_TRUE,

	TI_COMPLEX_INTEGER_TYPE,
	TI_COMPLEX_FLOAT_TYPE,
	TI_COMPLEX_DOUBLE_TYPE,
	TI_COMPLEX_LONG_DOUBLE_TYPE,

	TI_FLOAT_TYPE,
	TI_DOUBLE_TYPE,
	TI_LONG_DOUBLE_TYPE,

	TI_FLOAT_PTR_TYPE,
	TI_DOUBLE_PTR_TYPE,
	TI_LONG_DOUBLE_PTR_TYPE,
	TI_INTEGER_PTR_TYPE,

	TI_VOID_TYPE,
	TI_PTR_TYPE,
	TI_CONST_PTR_TYPE,
	TI_SIZE_TYPE,
	TI_PID_TYPE,
	TI_PTRDIFF_TYPE,
	TI_VA_LIST_TYPE,
	TI_VA_LIST_GPR_COUNTER_FIELD,
	TI_VA_LIST_FPR_COUNTER_FIELD,
	TI_BOOLEAN_TYPE,
	TI_FILEPTR_TYPE,

	TI_DFLOAT32_TYPE,
	TI_DFLOAT64_TYPE,
	TI_DFLOAT128_TYPE,
	TI_DFLOAT32_PTR_TYPE,
	TI_DFLOAT64_PTR_TYPE,
	TI_DFLOAT128_PTR_TYPE,

	TI_VOID_LIST_NODE,

	TI_MAIN_IDENTIFIER,

	TI_MAX
	};

	extern GTY(()) tree global_trees[TI_MAX];

	#define error_mark_node global_trees[TI_ERROR_MARK]

	#define intQI_type_node global_trees[TI_INTQI_TYPE]
	#define intHI_type_node global_trees[TI_INTHI_TYPE]
	#define intSI_type_node global_trees[TI_INTSI_TYPE]
	#define intDI_type_node global_trees[TI_INTDI_TYPE]
	#define intTI_type_node global_trees[TI_INTTI_TYPE]

	#define unsigned_intQI_type_node global_trees[TI_UINTQI_TYPE]
	#define unsigned_intHI_type_node global_trees[TI_UINTHI_TYPE]
	#define unsigned_intSI_type_node global_trees[TI_UINTSI_TYPE]
	#define unsigned_intDI_type_node global_trees[TI_UINTDI_TYPE]
	#define unsigned_intTI_type_node global_trees[TI_UINTTI_TYPE]

	#define uint32_type_node global_trees[TI_UINT32_TYPE]
	#define uint64_type_node global_trees[TI_UINT64_TYPE]

	#define integer_zero_node global_trees[TI_INTEGER_ZERO]
	#define integer_one_node global_trees[TI_INTEGER_ONE]
	#define integer_minus_one_node global_trees[TI_INTEGER_MINUS_ONE]
	#define size_zero_node global_trees[TI_SIZE_ZERO]
	#define size_one_node global_trees[TI_SIZE_ONE]
	#define bitsize_zero_node global_trees[TI_BITSIZE_ZERO]
	#define bitsize_one_node global_trees[TI_BITSIZE_ONE]
	#define bitsize_unit_node global_trees[TI_BITSIZE_UNIT]

	/* Base access nodes. */
	#define access_public_node global_trees[TI_PUBLIC]
	#define access_protected_node global_trees[TI_PROTECTED]
	#define access_private_node global_trees[TI_PRIVATE]

	#define null_pointer_node global_trees[TI_NULL_POINTER]

	#define float_type_node global_trees[TI_FLOAT_TYPE]
	#define double_type_node global_trees[TI_DOUBLE_TYPE]
	#define long_double_type_node global_trees[TI_LONG_DOUBLE_TYPE]

	#define float_ptr_type_node global_trees[TI_FLOAT_PTR_TYPE]
	#define double_ptr_type_node global_trees[TI_DOUBLE_PTR_TYPE]
	#define long_double_ptr_type_node global_trees[TI_LONG_DOUBLE_PTR_TYPE]
	#define integer_ptr_type_node global_trees[TI_INTEGER_PTR_TYPE]

	#define complex_integer_type_node global_trees[TI_COMPLEX_INTEGER_TYPE]
	#define complex_float_type_node global_trees[TI_COMPLEX_FLOAT_TYPE]
	#define complex_double_type_node global_trees[TI_COMPLEX_DOUBLE_TYPE]
	#define complex_long_double_type_node global_trees[TI_COMPLEX_LONG_DOUBLE_TYPE]

	#define void_type_node global_trees[TI_VOID_TYPE]
	/* The C type `void '. /
	#define ptr_type_node global_trees[TI_PTR_TYPE]
	/* The C type `const void '. /
	#define const_ptr_type_node global_trees[TI_CONST_PTR_TYPE]
	/* The C type `size_t'. */
	#define size_type_node global_trees[TI_SIZE_TYPE]
	#define pid_type_node global_trees[TI_PID_TYPE]
	#define ptrdiff_type_node global_trees[TI_PTRDIFF_TYPE]
	#define va_list_type_node global_trees[TI_VA_LIST_TYPE]
	#define va_list_gpr_counter_field global_trees[TI_VA_LIST_GPR_COUNTER_FIELD]
	#define va_list_fpr_counter_field global_trees[TI_VA_LIST_FPR_COUNTER_FIELD]
	/* The C type `FILE '. /
	#define fileptr_type_node global_trees[TI_FILEPTR_TYPE]

	#define boolean_type_node global_trees[TI_BOOLEAN_TYPE]
	#define boolean_false_node global_trees[TI_BOOLEAN_FALSE]
	#define boolean_true_node global_trees[TI_BOOLEAN_TRUE]

	/* The decimal floating point types. */
	#define dfloat32_type_node global_trees[TI_DFLOAT32_TYPE]
	#define dfloat64_type_node global_trees[TI_DFLOAT64_TYPE]
	#define dfloat128_type_node global_trees[TI_DFLOAT128_TYPE]
	#define dfloat32_ptr_type_node global_trees[TI_DFLOAT32_PTR_TYPE]
	#define dfloat64_ptr_type_node global_trees[TI_DFLOAT64_PTR_TYPE]
	#define dfloat128_ptr_type_node global_trees[TI_DFLOAT128_PTR_TYPE]

	/* The node that should be placed at the end of a parameter list to
	indicate that the function does not take a variable number of
	arguments. The TREE_VALUE will be void_type_node and there will be
	no TREE_CHAIN. Language-independent code should not assume
	anything else about this node. */
	#define void_list_node global_trees[TI_VOID_LIST_NODE]

	#define main_identifier_node global_trees[TI_MAIN_IDENTIFIER]
	#define MAIN_NAME_P(NODE) (IDENTIFIER_NODE_CHECK (NODE) == main_identifier_node)

	/* An enumeration of the standard C integer types. These must be
	ordered so that shorter types appear before longer ones, and so
	that signed types appear before unsigned ones, for the correct
	functioning of interpret_integer() in c-lex.c. */
	enum integer_type_kind
	{
	itk_char,
	itk_signed_char,
	itk_unsigned_char,
	itk_short,
	itk_unsigned_short,
	itk_int,
	itk_unsigned_int,
	itk_long,
	itk_unsigned_long,
	itk_long_long,
	itk_unsigned_long_long,
	itk_none
	};

	typedef enum integer_type_kind integer_type_kind;

	/* The standard C integer types. Use integer_type_kind to index into
	this array. */
	extern GTY(()) tree integer_types[itk_none];

	#define char_type_node integer_types[itk_char]
	#define signed_char_type_node integer_types[itk_signed_char]
	#define unsigned_char_type_node integer_types[itk_unsigned_char]
	#define short_integer_type_node integer_types[itk_short]
	#define short_unsigned_type_node integer_types[itk_unsigned_short]
	#define integer_type_node integer_types[itk_int]
	#define unsigned_type_node integer_types[itk_unsigned_int]
	#define long_integer_type_node integer_types[itk_long]
	#define long_unsigned_type_node integer_types[itk_unsigned_long]
	#define long_long_integer_type_node integer_types[itk_long_long]
	#define long_long_unsigned_type_node integer_types[itk_unsigned_long_long]

	/* Set to the default thread-local storage (tls) model to use. */

	extern enum tls_model flag_tls_default;


	/* A pointer-to-function member type looks like:

	struct {
	__P __pfn;
	ptrdiff_t __delta;
	};

	If __pfn is NULL, it is a NULL pointer-to-member-function.

	(Because the vtable is always the first thing in the object, we
	don't need its offset.) If the function is virtual, then PFN is
	one plus twice the index into the vtable; otherwise, it is just a
	pointer to the function.

	Unfortunately, using the lowest bit of PFN doesn't work in
	architectures that don't impose alignment requirements on function
	addresses, or that use the lowest bit to tell one ISA from another,
	for example. For such architectures, we use the lowest bit of
	DELTA instead of the lowest bit of the PFN, and DELTA will be
	multiplied by 2. */

	enum ptrmemfunc_vbit_where_t
	{
	ptrmemfunc_vbit_in_pfn,
	ptrmemfunc_vbit_in_delta
	};

	#define NULL_TREE (tree) NULL

	extern tree decl_assembler_name (tree);

	/* Compute the number of bytes occupied by 'node'. This routine only
	looks at TREE_CODE and, if the code is TREE_VEC, TREE_VEC_LENGTH. */

	extern size_t tree_size (tree);

	/* Compute the number of bytes occupied by a tree with code CODE. This
	function cannot be used for TREE_VEC or PHI_NODE codes, which are of
	variable length. */
	extern size_t tree_code_size (enum tree_code);

	/* Lowest level primitive for allocating a node.
	The TREE_CODE is the only argument. Contents are initialized
	to zero except for a few of the common fields. */

	extern tree make_node_stat (enum tree_code MEM_STAT_DECL);
	#define make_node(t) make_node_stat (t MEM_STAT_INFO)

	/* Make a copy of a node, with all the same contents. */

	extern tree copy_node_stat (tree MEM_STAT_DECL);
	#define copy_node(t) copy_node_stat (t MEM_STAT_INFO)

	/* Make a copy of a chain of TREE_LIST nodes. */

	extern tree copy_list (tree);

	/* Make a BINFO. */
	extern tree make_tree_binfo_stat (unsigned MEM_STAT_DECL);
	#define make_tree_binfo(t) make_tree_binfo_stat (t MEM_STAT_INFO)

	/* Make a TREE_VEC. */

	extern tree make_tree_vec_stat (int MEM_STAT_DECL);
	#define make_tree_vec(t) make_tree_vec_stat (t MEM_STAT_INFO)

	/* Tree nodes for SSA analysis. */

	extern void init_phinodes (void);
	extern void fini_phinodes (void);
	extern void release_phi_node (tree);
	#ifdef GATHER_STATISTICS
	extern void phinodes_print_statistics (void);
	#endif

	extern void init_ssanames (void);
	extern void fini_ssanames (void);
	extern tree make_ssa_name (tree, tree);
	extern tree duplicate_ssa_name (tree, tree);
	extern void duplicate_ssa_name_ptr_info (tree, struct ptr_info_def *);
	extern void release_ssa_name (tree);
	extern void release_defs (tree);
	extern void replace_ssa_name_symbol (tree, tree);

	#ifdef GATHER_STATISTICS
	extern void ssanames_print_statistics (void);
	#endif

	/* Return the (unique) IDENTIFIER_NODE node for a given name.
	The name is supplied as a char . /

	extern tree get_identifier (const char *);

	#if GCC_VERSION >= 3000
	#define get_identifier(str) \
	(__builtin_constant_p (str) \
	? get_identifier_with_length ((str), strlen (str)) \
	: get_identifier (str))
	#endif


	/* Identical to get_identifier, except that the length is assumed
	known. */

	extern tree get_identifier_with_length (const char *, size_t);

	/* If an identifier with the name TEXT (a null-terminated string) has
	previously been referred to, return that node; otherwise return
	NULL_TREE. */

	extern tree maybe_get_identifier (const char *);

	/* Construct various types of nodes. */

	extern tree build_nt (enum tree_code, ...);

	extern tree build0_stat (enum tree_code, tree MEM_STAT_DECL);
	#define build0(c,t) build0_stat (c,t MEM_STAT_INFO)
	extern tree build1_stat (enum tree_code, tree, tree MEM_STAT_DECL);
	#define build1(c,t1,t2) build1_stat (c,t1,t2 MEM_STAT_INFO)
	extern tree build2_stat (enum tree_code, tree, tree, tree MEM_STAT_DECL);
	#define build2(c,t1,t2,t3) build2_stat (c,t1,t2,t3 MEM_STAT_INFO)
	extern tree build3_stat (enum tree_code, tree, tree, tree, tree MEM_STAT_DECL);
	#define build3(c,t1,t2,t3,t4) build3_stat (c,t1,t2,t3,t4 MEM_STAT_INFO)
	extern tree build4_stat (enum tree_code, tree, tree, tree, tree,
	tree MEM_STAT_DECL);
	#define build4(c,t1,t2,t3,t4,t5) build4_stat (c,t1,t2,t3,t4,t5 MEM_STAT_INFO)
	extern tree build5_stat (enum tree_code, tree, tree, tree, tree, tree,
	tree MEM_STAT_DECL);
	#define build5(c,t1,t2,t3,t4,t5,t6) build5_stat (c,t1,t2,t3,t4,t5,t6 MEM_STAT_INFO)
	extern tree build7_stat (enum tree_code, tree, tree, tree, tree, tree,
	tree, tree, tree MEM_STAT_DECL);
	#define build7(c,t1,t2,t3,t4,t5,t6,t7,t8) \
	build7_stat (c,t1,t2,t3,t4,t5,t6,t7,t8 MEM_STAT_INFO)

	extern tree build_int_cst (tree, HOST_WIDE_INT);
	extern tree build_int_cst_type (tree, HOST_WIDE_INT);
	extern tree build_int_cstu (tree, unsigned HOST_WIDE_INT);
	extern tree build_int_cst_wide (tree, unsigned HOST_WIDE_INT, HOST_WIDE_INT);
	extern tree build_vector (tree, tree);
	extern tree build_vector_from_ctor (tree, VEC(constructor_elt,gc) *);
	extern tree build_constructor (tree, VEC(constructor_elt,gc) *);
	extern tree build_constructor_single (tree, tree, tree);
	extern tree build_constructor_from_list (tree, tree);
	extern tree build_real_from_int_cst (tree, tree);
	extern tree build_complex (tree, tree, tree);
	extern tree build_one_cst (tree);
	extern tree build_string (int, const char *);
	extern tree build_tree_list_stat (tree, tree MEM_STAT_DECL);
	#define build_tree_list(t,q) build_tree_list_stat(t,q MEM_STAT_INFO)
	extern tree build_decl_stat (enum tree_code, tree, tree MEM_STAT_DECL);
	extern tree build_fn_decl (const char *, tree);
	#define build_decl(c,t,q) build_decl_stat (c,t,q MEM_STAT_INFO)
	extern tree build_block (tree, tree, tree, tree);
	#ifndef USE_MAPPED_LOCATION
	extern void annotate_with_file_line (tree, const char *, int);
	extern void annotate_with_locus (tree, location_t);
	#endif
	extern tree build_empty_stmt (void);
	extern tree build_omp_clause (enum omp_clause_code);

	/* Construct various nodes representing data types. */

	extern tree make_signed_type (int);
	extern tree make_unsigned_type (int);
	extern tree signed_type_for (tree);
	extern tree unsigned_type_for (tree);
	extern void initialize_sizetypes (bool);
	extern void set_sizetype (tree);
	extern void fixup_unsigned_type (tree);
	extern tree build_pointer_type_for_mode (tree, enum machine_mode, bool);
	extern tree build_pointer_type (tree);
	extern tree build_reference_type_for_mode (tree, enum machine_mode, bool);
	extern tree build_reference_type (tree);
	extern tree build_vector_type_for_mode (tree, enum machine_mode);
	extern tree build_vector_type (tree innertype, int nunits);
	extern tree build_type_no_quals (tree);
	extern tree build_index_type (tree);
	extern tree build_index_2_type (tree, tree);
	extern tree build_array_type (tree, tree);
	extern tree build_function_type (tree, tree);
	extern tree build_function_type_list (tree, ...);
	extern tree build_method_type_directly (tree, tree, tree);
	extern tree build_method_type (tree, tree);
	extern tree build_offset_type (tree, tree);
	extern tree build_complex_type (tree);
	extern tree build_resx (int);
	extern tree array_type_nelts (tree);
	extern bool in_array_bounds_p (tree);
	extern bool range_in_array_bounds_p (tree);

	extern tree value_member (tree, tree);
	extern tree purpose_member (tree, tree);

	extern int attribute_list_equal (tree, tree);
	extern int attribute_list_contained (tree, tree);
	extern int tree_int_cst_equal (tree, tree);
	extern int tree_int_cst_lt (tree, tree);
	extern int tree_int_cst_compare (tree, tree);
	extern int host_integerp (tree, int);
	extern HOST_WIDE_INT tree_low_cst (tree, int);
	extern int tree_int_cst_msb (tree);
	extern int tree_int_cst_sgn (tree);
	extern int tree_int_cst_sign_bit (tree);
	extern int tree_expr_nonnegative_p (tree);
	extern int tree_expr_nonnegative_warnv_p (tree, bool *);
	extern bool may_negate_without_overflow_p (tree);
	extern tree get_inner_array_type (tree);

	/* From expmed.c. Since rtl.h is included after tree.h, we can't
	put the prototype here. Rtl.h does declare the prototype if
	tree.h had been included. */

	extern tree make_tree (tree, rtx);

	/* Return a type like TTYPE except that its TYPE_ATTRIBUTES
	is ATTRIBUTE.

	Such modified types already made are recorded so that duplicates
	are not made. */

	extern tree build_type_attribute_variant (tree, tree);
	extern tree build_decl_attribute_variant (tree, tree);

	/* Structure describing an attribute and a function to handle it. */
	struct attribute_spec
	{
	/* The name of the attribute (without any leading or trailing __),
	or NULL to mark the end of a table of attributes. */
	const char *const name;
	/* The minimum length of the list of arguments of the attribute. */
	const int min_length;
	/* The maximum length of the list of arguments of the attribute
	(-1 for no maximum). */
	const int max_length;
	/* Whether this attribute requires a DECL. If it does, it will be passed
	from types of DECLs, function return types and array element types to
	the DECLs, function types and array types respectively; but when
	applied to a type in any other circumstances, it will be ignored with
	a warning. (If greater control is desired for a given attribute,
	this should be false, and the flags argument to the handler may be
	used to gain greater control in that case.) */
	const bool decl_required;
	/* Whether this attribute requires a type. If it does, it will be passed
	from a DECL to the type of that DECL. */
	const bool type_required;
	/* Whether this attribute requires a function (or method) type. If it does,
	it will be passed from a function pointer type to the target type,
	and from a function return type (which is not itself a function
	pointer type) to the function type. */
	const bool function_type_required;
	/* Function to handle this attribute. NODE points to the node to which
	the attribute is to be applied. If a DECL, it should be modified in
	place; if a TYPE, a copy should be created. NAME is the name of the
	attribute (possibly with leading or trailing __). ARGS is the TREE_LIST
	of the arguments (which may be NULL). FLAGS gives further information
	about the context of the attribute. Afterwards, the attributes will
	be added to the DECL_ATTRIBUTES or TYPE_ATTRIBUTES, as appropriate,
	unless *NO_ADD_ATTRS is set to true (which should be done on error,
	as well as in any other cases when the attributes should not be added
	to the DECL or TYPE). Depending on FLAGS, any attributes to be
	applied to another type or DECL later may be returned;
	otherwise the return value should be NULL_TREE. This pointer may be
	NULL if no special handling is required beyond the checks implied
	by the rest of this structure. */
	tree (const handler) (tree node, tree name, tree args,
	int flags, bool *no_add_attrs);
	};

	/* Flags that may be passed in the third argument of decl_attributes, and
	to handler functions for attributes. */
	enum attribute_flags
	{
	/* The type passed in is the type of a DECL, and any attributes that
	should be passed in again to be applied to the DECL rather than the
	type should be returned. */
	ATTR_FLAG_DECL_NEXT = 1,
	/* The type passed in is a function return type, and any attributes that
	should be passed in again to be applied to the function type rather
	than the return type should be returned. */
	ATTR_FLAG_FUNCTION_NEXT = 2,
	/* The type passed in is an array element type, and any attributes that
	should be passed in again to be applied to the array type rather
	than the element type should be returned. */
	ATTR_FLAG_ARRAY_NEXT = 4,
	/* The type passed in is a structure, union or enumeration type being
	created, and should be modified in place. */
	ATTR_FLAG_TYPE_IN_PLACE = 8,
	/* The attributes are being applied by default to a library function whose
	name indicates known behavior, and should be silently ignored if they
	are not in fact compatible with the function type. */
	ATTR_FLAG_BUILT_IN = 16
	};

	/* Default versions of target-overridable functions. */

	extern tree merge_decl_attributes (tree, tree);
	extern tree merge_type_attributes (tree, tree);

	/* Given a tree node and a string, return nonzero if the tree node is
	a valid attribute name for the string. */

	extern int is_attribute_p (const char *, tree);

	/* Given an attribute name and a list of attributes, return the list element
	of the attribute or NULL_TREE if not found. */

	extern tree lookup_attribute (const char *, tree);

	/* Remove any instances of attribute ATTR_NAME in LIST and return the
	modified list. */

	extern tree remove_attribute (const char *, tree);

	/* Given two attributes lists, return a list of their union. */

	extern tree merge_attributes (tree, tree);

	#if TARGET_DLLIMPORT_DECL_ATTRIBUTES
	/* Given two Windows decl attributes lists, possibly including
	dllimport, return a list of their union . */
	extern tree merge_dllimport_decl_attributes (tree, tree);

	/* Handle a "dllimport" or "dllexport" attribute. */
	extern tree handle_dll_attribute (tree , tree, tree, int, bool );
	#endif

	/* Check whether CAND is suitable to be returned from get_qualified_type
	(BASE, TYPE_QUALS). */

	extern bool check_qualified_type (tree, tree, int);

	/* Return a version of the TYPE, qualified as indicated by the
	TYPE_QUALS, if one exists. If no qualified version exists yet,
	return NULL_TREE. */

	extern tree get_qualified_type (tree, int);

	/* Like get_qualified_type, but creates the type if it does not
	exist. This function never returns NULL_TREE. */

	extern tree build_qualified_type (tree, int);

	/* Like build_qualified_type, but only deals with the `const' and
	`volatile' qualifiers. This interface is retained for backwards
	compatibility with the various front-ends; new code should use
	build_qualified_type instead. */

	#define build_type_variant(TYPE, CONST_P, VOLATILE_P) \
	build_qualified_type ((TYPE), \
	((CONST_P) ? TYPE_QUAL_CONST : 0) \
	\| ((VOLATILE_P) ? TYPE_QUAL_VOLATILE : 0))

	/* Make a copy of a type node. */

	extern tree build_distinct_type_copy (tree);
	extern tree build_variant_type_copy (tree);

	/* Finish up a builtin RECORD_TYPE. Give it a name and provide its
	fields. Optionally specify an alignment, and then lay it out. */

	extern void finish_builtin_struct (tree, const char *,
	tree, tree);

	/* Given a ..._TYPE node, calculate the TYPE_SIZE, TYPE_SIZE_UNIT,
	TYPE_ALIGN and TYPE_MODE fields. If called more than once on one
	node, does nothing except for the first time. */

	extern void layout_type (tree);

	/* These functions allow a front-end to perform a manual layout of a
	RECORD_TYPE. (For instance, if the placement of subsequent fields
	depends on the placement of fields so far.) Begin by calling
	start_record_layout. Then, call place_field for each of the
	fields. Then, call finish_record_layout. See layout_type for the
	default way in which these functions are used. */

	typedef struct record_layout_info_s
	{
	/* The RECORD_TYPE that we are laying out. */
	tree t;
	/* The offset into the record so far, in bytes, not including bits in
	BITPOS. */
	tree offset;
	/* The last known alignment of SIZE. */
	unsigned int offset_align;
	/* The bit position within the last OFFSET_ALIGN bits, in bits. */
	tree bitpos;
	/* The alignment of the record so far, in bits. */
	unsigned int record_align;
	/* The alignment of the record so far, ignoring #pragma pack and
	__attribute__ ((packed)), in bits. */
	unsigned int unpacked_align;
	/* The previous field layed out. */
	tree prev_field;
	/* The static variables (i.e., class variables, as opposed to
	instance variables) encountered in T. */
	tree pending_statics;
	/* Bits remaining in the current alignment group */
	int remaining_in_alignment;
	/* True if we've seen a packed field that didn't have normal
	alignment anyway. */
	int packed_maybe_necessary;
	} *record_layout_info;

	extern void set_lang_adjust_rli (void (*) (record_layout_info));
	extern record_layout_info start_record_layout (tree);
	extern tree bit_from_pos (tree, tree);
	extern tree byte_from_pos (tree, tree);
	extern void pos_from_bit (tree , tree , unsigned int, tree);
	extern void normalize_offset (tree , tree , unsigned int);
	extern tree rli_size_unit_so_far (record_layout_info);
	extern tree rli_size_so_far (record_layout_info);
	extern void normalize_rli (record_layout_info);
	extern void place_field (record_layout_info, tree);
	extern void compute_record_mode (tree);
	extern void finish_record_layout (record_layout_info, int);

	/* Given a hashcode and a ..._TYPE node (for which the hashcode was made),
	return a canonicalized ..._TYPE node, so that duplicates are not made.
	How the hash code is computed is up to the caller, as long as any two
	callers that could hash identical-looking type nodes agree. */

	extern tree type_hash_canon (unsigned int, tree);

	/* Given a VAR_DECL, PARM_DECL, RESULT_DECL or FIELD_DECL node,
	calculates the DECL_SIZE, DECL_SIZE_UNIT, DECL_ALIGN and DECL_MODE
	fields. Call this only once for any given decl node.

	Second argument is the boundary that this field can be assumed to
	be starting at (in bits). Zero means it can be assumed aligned
	on any boundary that may be needed. */

	extern void layout_decl (tree, unsigned);

	/* Given a VAR_DECL, PARM_DECL or RESULT_DECL, clears the results of
	a previous call to layout_decl and calls it again. */

	extern void relayout_decl (tree);

	/* Return the mode for data of a given size SIZE and mode class CLASS.
	If LIMIT is nonzero, then don't use modes bigger than MAX_FIXED_MODE_SIZE.
	The value is BLKmode if no other mode is found. This is like
	mode_for_size, but is passed a tree. */

	extern enum machine_mode mode_for_size_tree (tree, enum mode_class, int);

	/* Return an expr equal to X but certainly not valid as an lvalue. */

	extern tree non_lvalue (tree);

	extern tree convert (tree, tree);
	extern unsigned int expr_align (tree);
	extern tree expr_first (tree);
	extern tree expr_last (tree);
	extern tree expr_only (tree);
	extern tree size_in_bytes (tree);
	extern HOST_WIDE_INT int_size_in_bytes (tree);
	extern HOST_WIDE_INT max_int_size_in_bytes (tree);
	extern tree bit_position (tree);
	extern HOST_WIDE_INT int_bit_position (tree);
	extern tree byte_position (tree);
	extern HOST_WIDE_INT int_byte_position (tree);

	/* Define data structures, macros, and functions for handling sizes
	and the various types used to represent sizes. */

	enum size_type_kind
	{
	SIZETYPE, /* Normal representation of sizes in bytes. */
	SSIZETYPE, /* Signed representation of sizes in bytes. */
	BITSIZETYPE, /* Normal representation of sizes in bits. */
	SBITSIZETYPE, /* Signed representation of sizes in bits. */
	TYPE_KIND_LAST};

	extern GTY(()) tree sizetype_tab[(int) TYPE_KIND_LAST];

	#define sizetype sizetype_tab[(int) SIZETYPE]
	#define bitsizetype sizetype_tab[(int) BITSIZETYPE]
	#define ssizetype sizetype_tab[(int) SSIZETYPE]
	#define sbitsizetype sizetype_tab[(int) SBITSIZETYPE]

	extern tree size_int_kind (HOST_WIDE_INT, enum size_type_kind);
	extern tree size_binop (enum tree_code, tree, tree);
	extern tree size_diffop (tree, tree);

	#define size_int(L) size_int_kind (L, SIZETYPE)
	#define ssize_int(L) size_int_kind (L, SSIZETYPE)
	#define bitsize_int(L) size_int_kind (L, BITSIZETYPE)
	#define sbitsize_int(L) size_int_kind (L, SBITSIZETYPE)

	extern tree round_up (tree, int);
	extern tree round_down (tree, int);
	extern tree get_pending_sizes (void);
	extern void put_pending_size (tree);
	extern void put_pending_sizes (tree);

	/* Type for sizes of data-type. */

	#define BITS_PER_UNIT_LOG \
	((BITS_PER_UNIT > 1) + (BITS_PER_UNIT > 2) + (BITS_PER_UNIT > 4) \
	+ (BITS_PER_UNIT > 8) + (BITS_PER_UNIT > 16) + (BITS_PER_UNIT > 32) \
	+ (BITS_PER_UNIT > 64) + (BITS_PER_UNIT > 128) + (BITS_PER_UNIT > 256))

	/* If nonzero, an upper limit on alignment of structure fields, in bits, */
	extern unsigned int maximum_field_alignment;
	/* and its original value in bytes, specified via -fpack-struct=<value>. */
	extern unsigned int initial_max_fld_align;

	/* Concatenate two lists (chains of TREE_LIST nodes) X and Y
	by making the last node in X point to Y.
	Returns X, except if X is 0 returns Y. */

	extern tree chainon (tree, tree);

	/* Make a new TREE_LIST node from specified PURPOSE, VALUE and CHAIN. */

	extern tree tree_cons_stat (tree, tree, tree MEM_STAT_DECL);
	#define tree_cons(t,q,w) tree_cons_stat (t,q,w MEM_STAT_INFO)

	/* Return the last tree node in a chain. */

	extern tree tree_last (tree);

	/* Reverse the order of elements in a chain, and return the new head. */

	extern tree nreverse (tree);

	/* Returns the length of a chain of nodes
	(number of chain pointers to follow before reaching a null pointer). */

	extern int list_length (tree);

	/* Returns the number of FIELD_DECLs in a type. */

	extern int fields_length (tree);

	/* Given an initializer INIT, return TRUE if INIT is zero or some
	aggregate of zeros. Otherwise return FALSE. */

	extern bool initializer_zerop (tree);

	/* Examine CTOR to discover:
	* how many scalar fields are set to nonzero values,
	and place it in *P_NZ_ELTS;
	* how many scalar fields in total are in CTOR,
	and place it in *P_ELT_COUNT.
	* if a type is a union, and the initializer from the constructor
	is not the largest element in the union, then set *p_must_clear.

	Return whether or not CTOR is a valid static constant initializer, the same
	as "initializer_constant_valid_p (CTOR, TREE_TYPE (CTOR)) != 0". */

	extern bool categorize_ctor_elements (tree, HOST_WIDE_INT , HOST_WIDE_INT ,
	bool *);

	extern HOST_WIDE_INT count_type_elements (tree, bool);

	/* integer_zerop (tree x) is nonzero if X is an integer constant of value 0. */

	extern int integer_zerop (tree);

	/* integer_onep (tree x) is nonzero if X is an integer constant of value 1. */

	extern int integer_onep (tree);

	/* integer_all_onesp (tree x) is nonzero if X is an integer constant
	all of whose significant bits are 1. */

	extern int integer_all_onesp (tree);

	/* integer_pow2p (tree x) is nonzero is X is an integer constant with
	exactly one bit 1. */

	extern int integer_pow2p (tree);

	/* integer_nonzerop (tree x) is nonzero if X is an integer constant
	with a nonzero value. */

	extern int integer_nonzerop (tree);

	extern bool zero_p (tree);
	extern bool cst_and_fits_in_hwi (tree);
	extern tree num_ending_zeros (tree);

	/* staticp (tree x) is nonzero if X is a reference to data allocated
	at a fixed address in memory. Returns the outermost data. */

	extern tree staticp (tree);

	/* save_expr (EXP) returns an expression equivalent to EXP
	but it can be used multiple times within context CTX
	and only evaluate EXP once. */

	extern tree save_expr (tree);

	/* Look inside EXPR and into any simple arithmetic operations. Return
	the innermost non-arithmetic node. */

	extern tree skip_simple_arithmetic (tree);

	/* Return which tree structure is used by T. */

	enum tree_node_structure_enum tree_node_structure (tree);

	/* Return 1 if EXP contains a PLACEHOLDER_EXPR; i.e., if it represents a size
	or offset that depends on a field within a record.

	Note that we only allow such expressions within simple arithmetic
	or a COND_EXPR. */

	extern bool contains_placeholder_p (tree);

	/* This macro calls the above function but short-circuits the common
	case of a constant to save time. Also check for null. */

	#define CONTAINS_PLACEHOLDER_P(EXP) \
	((EXP) != 0 && ! TREE_CONSTANT (EXP) && contains_placeholder_p (EXP))

	/* Return 1 if any part of the computation of TYPE involves a PLACEHOLDER_EXPR.
	This includes size, bounds, qualifiers (for QUAL_UNION_TYPE) and field
	positions. */

	extern bool type_contains_placeholder_p (tree);

	/* Given a tree EXP, a FIELD_DECL F, and a replacement value R,
	return a tree with all occurrences of references to F in a
	PLACEHOLDER_EXPR replaced by R. Note that we assume here that EXP
	contains only arithmetic expressions. */

	extern tree substitute_in_expr (tree, tree, tree);

	/* This macro calls the above function but short-circuits the common
	case of a constant to save time and also checks for NULL. */

	#define SUBSTITUTE_IN_EXPR(EXP, F, R) \
	((EXP) == 0 \|\| TREE_CONSTANT (EXP) ? (EXP) : substitute_in_expr (EXP, F, R))

	/* Similar, but look for a PLACEHOLDER_EXPR in EXP and find a replacement
	for it within OBJ, a tree that is an object or a chain of references. */

	extern tree substitute_placeholder_in_expr (tree, tree);

	/* This macro calls the above function but short-circuits the common
	case of a constant to save time and also checks for NULL. */

	#define SUBSTITUTE_PLACEHOLDER_IN_EXPR(EXP, OBJ) \
	((EXP) == 0 \|\| TREE_CONSTANT (EXP) ? (EXP) \
	: substitute_placeholder_in_expr (EXP, OBJ))

	/* variable_size (EXP) is like save_expr (EXP) except that it
	is for the special case of something that is part of a
	variable size for a data type. It makes special arrangements
	to compute the value at the right time when the data type
	belongs to a function parameter. */

	extern tree variable_size (tree);

	/* stabilize_reference (EXP) returns a reference equivalent to EXP
	but it can be used multiple times
	and only evaluate the subexpressions once. */

	extern tree stabilize_reference (tree);

	/* Subroutine of stabilize_reference; this is called for subtrees of
	references. Any expression with side-effects must be put in a SAVE_EXPR
	to ensure that it is only evaluated once. */

	extern tree stabilize_reference_1 (tree);

	/* Return EXP, stripped of any conversions to wider types
	in such a way that the result of converting to type FOR_TYPE
	is the same as if EXP were converted to FOR_TYPE.
	If FOR_TYPE is 0, it signifies EXP's type. */

	extern tree get_unwidened (tree, tree);

	/* Return OP or a simpler expression for a narrower value
	which can be sign-extended or zero-extended to give back OP.
	Store in *UNSIGNEDP_PTR either 1 if the value should be zero-extended
	or 0 if the value should be sign-extended. */

	extern tree get_narrower (tree, int *);

	/* Given an expression EXP that may be a COMPONENT_REF or an ARRAY_REF,
	look for nested component-refs or array-refs at constant positions
	and find the ultimate containing object, which is returned. */

	extern tree get_inner_reference (tree, HOST_WIDE_INT , HOST_WIDE_INT ,
	tree , enum machine_mode , int , int ,
	bool);

	/* Given an expression EXP that may be a COMPONENT_REF or an ARRAY_REF,
	look for whether EXP or any nested component-refs within EXP is marked
	as PACKED. */

	extern bool contains_packed_reference (tree exp);

	/* Return 1 if T is an expression that get_inner_reference handles. */

	extern int handled_component_p (tree);

	/* Return a tree of sizetype representing the size, in bytes, of the element
	of EXP, an ARRAY_REF. */

	extern tree array_ref_element_size (tree);

	/* Return a tree representing the lower bound of the array mentioned in
	EXP, an ARRAY_REF. */

	extern tree array_ref_low_bound (tree);

	/* Return a tree representing the upper bound of the array mentioned in
	EXP, an ARRAY_REF. */

	extern tree array_ref_up_bound (tree);

	/* Return a tree representing the offset, in bytes, of the field referenced
	by EXP. This does not include any offset in DECL_FIELD_BIT_OFFSET. */

	extern tree component_ref_field_offset (tree);

	/* Given a DECL or TYPE, return the scope in which it was declared, or
	NUL_TREE if there is no containing scope. */

	extern tree get_containing_scope (tree);

	/* Return the FUNCTION_DECL which provides this _DECL with its context,
	or zero if none. */
	extern tree decl_function_context (tree);

	/* Return the RECORD_TYPE, UNION_TYPE, or QUAL_UNION_TYPE which provides
	this _DECL with its context, or zero if none. */
	extern tree decl_type_context (tree);

	/* Return 1 if EXPR is the real constant zero. */
	extern int real_zerop (tree);

	/* Declare commonly used variables for tree structure. */

	/* Nonzero means lvalues are limited to those valid in pedantic ANSI C.
	Zero means allow extended lvalues. */

	extern int pedantic_lvalues;

	/* Points to the FUNCTION_DECL of the function whose body we are reading. */

	extern GTY(()) tree current_function_decl;

	/* Nonzero means a FUNC_BEGIN label was emitted. */
	extern GTY(()) const char * current_function_func_begin_label;

	/* In tree.c */
	extern unsigned crc32_string (unsigned, const char *);
	extern void clean_symbol_name (char *);
	extern tree get_file_function_name (const char *);
	extern tree get_callee_fndecl (tree);
	extern void change_decl_assembler_name (tree, tree);
	extern int type_num_arguments (tree);
	extern bool associative_tree_code (enum tree_code);
	extern bool commutative_tree_code (enum tree_code);
	extern tree upper_bound_in_type (tree, tree);
	extern tree lower_bound_in_type (tree, tree);
	extern int operand_equal_for_phi_arg_p (tree, tree);
	extern bool empty_body_p (tree);

	/* In stmt.c */

	extern void expand_expr_stmt (tree);
	extern int warn_if_unused_value (tree, location_t);
	extern void expand_label (tree);
	extern void expand_goto (tree);

	extern rtx expand_stack_save (void);
	extern void expand_stack_restore (tree);
	extern void expand_return (tree);
	extern int is_body_block (tree);

	/* In tree-eh.c */
	extern void using_eh_for_cleanups (void);

	/* In fold-const.c */

	/* Non-zero if we are folding constants inside an initializer; zero
	otherwise. */
	extern int folding_initializer;

	/* Fold constants as much as possible in an expression.
	Returns the simplified expression.
	Acts only on the top level of the expression;
	if the argument itself cannot be simplified, its
	subexpressions are not changed. */

	extern tree fold (tree);
	extern tree fold_unary (enum tree_code, tree, tree);
	extern tree fold_binary (enum tree_code, tree, tree, tree);
	extern tree fold_ternary (enum tree_code, tree, tree, tree, tree);
	extern tree fold_build1_stat (enum tree_code, tree, tree MEM_STAT_DECL);
	#define fold_build1(c,t1,t2) fold_build1_stat (c, t1, t2 MEM_STAT_INFO)
	extern tree fold_build2_stat (enum tree_code, tree, tree, tree MEM_STAT_DECL);
	#define fold_build2(c,t1,t2,t3) fold_build2_stat (c, t1, t2, t3 MEM_STAT_INFO)
	extern tree fold_build3_stat (enum tree_code, tree, tree, tree, tree MEM_STAT_DECL);
	#define fold_build3(c,t1,t2,t3,t4) fold_build3_stat (c, t1, t2, t3, t4 MEM_STAT_INFO)
	extern tree fold_build1_initializer (enum tree_code, tree, tree);
	extern tree fold_build2_initializer (enum tree_code, tree, tree, tree);
	extern tree fold_build3_initializer (enum tree_code, tree, tree, tree, tree);
	extern tree fold_convert (tree, tree);
	extern tree fold_single_bit_test (enum tree_code, tree, tree, tree);
	extern tree fold_ignored_result (tree);
	extern tree fold_abs_const (tree, tree);
	extern tree fold_indirect_ref_1 (tree, tree);
	extern void fold_defer_overflow_warnings (void);
	extern void fold_undefer_overflow_warnings (bool, tree, int);
	extern void fold_undefer_and_ignore_overflow_warnings (void);
	extern bool fold_deferring_overflow_warnings_p (void);

	extern tree force_fit_type (tree, int, bool, bool);

	extern int add_double_with_sign (unsigned HOST_WIDE_INT, HOST_WIDE_INT,
	unsigned HOST_WIDE_INT, HOST_WIDE_INT,
	unsigned HOST_WIDE_INT , HOST_WIDE_INT ,
	bool);
	#define add_double(l1,h1,l2,h2,lv,hv) \
	add_double_with_sign (l1, h1, l2, h2, lv, hv, false)
	extern int neg_double (unsigned HOST_WIDE_INT, HOST_WIDE_INT,
	unsigned HOST_WIDE_INT , HOST_WIDE_INT );
	extern int mul_double_with_sign (unsigned HOST_WIDE_INT, HOST_WIDE_INT,
	unsigned HOST_WIDE_INT, HOST_WIDE_INT,
	unsigned HOST_WIDE_INT , HOST_WIDE_INT ,
	bool);
	#define mul_double(l1,h1,l2,h2,lv,hv) \
	mul_double_with_sign (l1, h1, l2, h2, lv, hv, false)
	extern void lshift_double (unsigned HOST_WIDE_INT, HOST_WIDE_INT,
	HOST_WIDE_INT, unsigned int,
	unsigned HOST_WIDE_INT , HOST_WIDE_INT , int);
	extern void rshift_double (unsigned HOST_WIDE_INT, HOST_WIDE_INT,
	HOST_WIDE_INT, unsigned int,
	unsigned HOST_WIDE_INT , HOST_WIDE_INT , int);
	extern void lrotate_double (unsigned HOST_WIDE_INT, HOST_WIDE_INT,
	HOST_WIDE_INT, unsigned int,
	unsigned HOST_WIDE_INT , HOST_WIDE_INT );
	extern void rrotate_double (unsigned HOST_WIDE_INT, HOST_WIDE_INT,
	HOST_WIDE_INT, unsigned int,
	unsigned HOST_WIDE_INT , HOST_WIDE_INT );

	extern int div_and_round_double (enum tree_code, int, unsigned HOST_WIDE_INT,
	HOST_WIDE_INT, unsigned HOST_WIDE_INT,
	HOST_WIDE_INT, unsigned HOST_WIDE_INT *,
	HOST_WIDE_INT , unsigned HOST_WIDE_INT ,
	HOST_WIDE_INT *);

	enum operand_equal_flag
	{
	OEP_ONLY_CONST = 1,
	OEP_PURE_SAME = 2
	};

	extern int operand_equal_p (tree, tree, unsigned int);

	extern tree omit_one_operand (tree, tree, tree);
	extern tree omit_two_operands (tree, tree, tree, tree);
	extern tree invert_truthvalue (tree);
	extern tree fold_truth_not_expr (tree);
	extern tree fold_unary_to_constant (enum tree_code, tree, tree);
	extern tree fold_binary_to_constant (enum tree_code, tree, tree, tree);
	extern tree fold_read_from_constant_string (tree);
	extern tree int_const_binop (enum tree_code, tree, tree, int);
	extern tree build_fold_addr_expr (tree);
	extern tree fold_build_cleanup_point_expr (tree type, tree expr);
	extern tree fold_strip_sign_ops (tree);
	extern tree build_fold_addr_expr_with_type (tree, tree);
	extern tree build_fold_indirect_ref (tree);
	extern tree fold_indirect_ref (tree);
	extern tree constant_boolean_node (int, tree);
	extern tree build_low_bits_mask (tree, unsigned);

	extern bool tree_swap_operands_p (tree, tree, bool);
	extern void swap_tree_operands (tree, tree , tree );
	extern enum tree_code swap_tree_comparison (enum tree_code);

	extern bool ptr_difference_const (tree, tree, HOST_WIDE_INT *);
	extern enum tree_code invert_tree_comparison (enum tree_code, bool);

	extern bool tree_expr_nonzero_p (tree);
	extern bool tree_expr_nonzero_warnv_p (tree, bool *);

	/* In builtins.c */
	extern tree fold_builtin (tree, tree, bool);
	extern tree fold_builtin_fputs (tree, bool, bool, tree);
	extern tree fold_builtin_strcpy (tree, tree, tree);
	extern tree fold_builtin_strncpy (tree, tree, tree);
	extern tree fold_builtin_memory_chk (tree, tree, tree, bool,
	enum built_in_function);
	extern tree fold_builtin_stxcpy_chk (tree, tree, tree, bool,
	enum built_in_function);
	extern tree fold_builtin_strncpy_chk (tree, tree);
	extern tree fold_builtin_snprintf_chk (tree, tree, enum built_in_function);
	extern bool fold_builtin_next_arg (tree);
	extern enum built_in_function builtin_mathfn_code (tree);
	extern tree build_function_call_expr (tree, tree);
	extern tree mathfn_built_in (tree, enum built_in_function fn);
	extern tree strip_float_extensions (tree);
	extern tree c_strlen (tree, int);
	extern tree std_gimplify_va_arg_expr (tree, tree, tree , tree );
	extern tree build_va_arg_indirect_ref (tree);
	tree build_string_literal (int, const char *);

	/* In convert.c */
	extern tree strip_float_extensions (tree);

	/* In alias.c */
	extern void record_component_aliases (tree);
	extern HOST_WIDE_INT get_alias_set (tree);
	extern int alias_sets_conflict_p (HOST_WIDE_INT, HOST_WIDE_INT);
	extern int alias_sets_might_conflict_p (HOST_WIDE_INT, HOST_WIDE_INT);
	extern int objects_must_conflict_p (tree, tree);

	/* In tree.c */
	extern int really_constant_p (tree);
	extern int int_fits_type_p (tree, tree);
	extern bool variably_modified_type_p (tree, tree);
	extern int tree_log2 (tree);
	extern int tree_floor_log2 (tree);
	extern int simple_cst_equal (tree, tree);
	extern hashval_t iterative_hash_expr (tree, hashval_t);
	extern int compare_tree_int (tree, unsigned HOST_WIDE_INT);
	extern int type_list_equal (tree, tree);
	extern int chain_member (tree, tree);
	extern tree type_hash_lookup (unsigned int, tree);
	extern void type_hash_add (unsigned int, tree);
	extern int simple_cst_list_equal (tree, tree);
	extern void dump_tree_statistics (void);
	extern void expand_function_end (void);
	extern void expand_function_start (tree);
	extern void stack_protect_prologue (void);
	extern void stack_protect_epilogue (void);
	extern void recompute_tree_invariant_for_addr_expr (tree);
	extern bool is_global_var (tree t);
	extern bool needs_to_live_in_memory (tree);
	extern tree reconstruct_complex_type (tree, tree);

	extern int real_onep (tree);
	extern int real_twop (tree);
	extern int real_minus_onep (tree);
	extern void init_ttree (void);
	extern void build_common_tree_nodes (bool, bool);
	extern void build_common_tree_nodes_2 (int);
	extern void build_common_builtin_nodes (void);
	extern tree build_nonstandard_integer_type (unsigned HOST_WIDE_INT, int);
	extern tree build_range_type (tree, tree, tree);
	extern HOST_WIDE_INT int_cst_value (tree);
	extern tree tree_fold_gcd (tree, tree);
	extern tree build_addr (tree, tree);

	extern bool fields_compatible_p (tree, tree);
	extern tree find_compatible_field (tree, tree);

	/* In function.c */
	extern void expand_main_function (void);
	extern void init_dummy_function_start (void);
	extern void expand_dummy_function_end (void);
	extern unsigned int init_function_for_compilation (void);
	extern void allocate_struct_function (tree);
	extern void init_function_start (tree);
	extern bool use_register_for_decl (tree);
	extern void setjmp_vars_warning (tree);
	extern void setjmp_args_warning (void);
	extern void init_temp_slots (void);
	extern void free_temp_slots (void);
	extern void pop_temp_slots (void);
	extern void push_temp_slots (void);
	extern void preserve_temp_slots (rtx);
	extern int aggregate_value_p (tree, tree);
	extern void push_function_context (void);
	extern void pop_function_context (void);
	extern void push_function_context_to (tree);
	extern void pop_function_context_from (tree);
	extern tree gimplify_parameters (void);

	/* In print-rtl.c */
	#ifdef BUFSIZ
	extern void print_rtl (FILE *, rtx);
	#endif

	/* In print-tree.c */
	extern void debug_tree (tree);
	#ifdef BUFSIZ
	extern void dump_addr (FILE, const char , void *);
	extern void print_node (FILE , const char , tree, int);
	extern void print_node_brief (FILE , const char , tree, int);
	extern void indent_to (FILE *, int);
	#endif

	/* In tree-inline.c: */
	extern bool debug_find_tree (tree, tree);
	/* This is in tree-inline.c since the routine uses
	data structures from the inliner. */
	extern tree unsave_expr_now (tree);
	extern tree build_duplicate_type (tree);

	/* In emit-rtl.c */
	extern rtx emit_line_note (location_t);

	/* In calls.c */

	/* Nonzero if this is a call to a function whose return value depends
	solely on its arguments, has no side effects, and does not read
	global memory. */
	#define ECF_CONST 1
	/* Nonzero if this call will never return. */
	#define ECF_NORETURN 2
	/* Nonzero if this is a call to malloc or a related function. */
	#define ECF_MALLOC 4
	/* Nonzero if it is plausible that this is a call to alloca. */
	#define ECF_MAY_BE_ALLOCA 8
	/* Nonzero if this is a call to a function that won't throw an exception. */
	#define ECF_NOTHROW 16
	/* Nonzero if this is a call to setjmp or a related function. */
	#define ECF_RETURNS_TWICE 32
	/* Nonzero if this call replaces the current stack frame. */
	#define ECF_SIBCALL 64
	/* Nonzero if this is a call to "pure" function (like const function,
	but may read memory. */
	#define ECF_PURE 128
	/* Nonzero if this is a call to a function that returns with the stack
	pointer depressed. */
	#define ECF_SP_DEPRESSED 256
	/* Create libcall block around the call. */
	#define ECF_LIBCALL_BLOCK 512
	/* Function does not read or write memory (but may have side effects, so
	it does not necessarily fit ECF_CONST). */
	#define ECF_NOVOPS 1024

	extern int flags_from_decl_or_type (tree);
	extern int call_expr_flags (tree);

	extern int setjmp_call_p (tree);
	extern bool alloca_call_p (tree);
	extern bool must_pass_in_stack_var_size (enum machine_mode, tree);
	extern bool must_pass_in_stack_var_size_or_pad (enum machine_mode, tree);

	/* In attribs.c. */

	/* Process the attributes listed in ATTRIBUTES and install them in *NODE,
	which is either a DECL (including a TYPE_DECL) or a TYPE. If a DECL,
	it should be modified in place; if a TYPE, a copy should be created
	unless ATTR_FLAG_TYPE_IN_PLACE is set in FLAGS. FLAGS gives further
	information, in the form of a bitwise OR of flags in enum attribute_flags
	from tree.h. Depending on these flags, some attributes may be
	returned to be applied at a later stage (for example, to apply
	a decl attribute to the declaration rather than to its type). */
	extern tree decl_attributes (tree *, tree, int);

	/* In integrate.c */
	extern void set_decl_abstract_flags (tree, int);
	extern void set_decl_origin_self (tree);

	/* In stor-layout.c */
	extern void set_min_and_max_values_for_integral_type (tree, int, bool);
	extern void fixup_signed_type (tree);
	extern void internal_reference_types (void);
	extern unsigned int update_alignment_for_field (record_layout_info, tree,
	unsigned int);
	/* varasm.c */
	extern void make_decl_rtl (tree);
	extern void make_decl_one_only (tree);
	extern int supports_one_only (void);
	extern void resolve_unique_section (tree, int, int);
	extern void mark_referenced (tree);
	extern void mark_decl_referenced (tree);
	extern void notice_global_symbol (tree);
	extern void set_user_assembler_name (tree, const char *);
	extern void process_pending_assemble_externals (void);
	extern void finish_aliases_1 (void);
	extern void finish_aliases_2 (void);

	/* In stmt.c */
	extern void expand_computed_goto (tree);
	extern bool parse_output_constraint (const char **, int, int, int,
	bool , bool , bool *);
	extern bool parse_input_constraint (const char **, int, int, int, int,
	const char * const , bool , bool *);
	extern void expand_asm_expr (tree);
	extern tree resolve_asm_operand_names (tree, tree, tree);
	extern void expand_case (tree);
	extern void expand_decl (tree);
	extern void expand_anon_union_decl (tree, tree, tree);
	#ifdef HARD_CONST
	/* Silly ifdef to avoid having all includers depend on hard-reg-set.h. */
	extern tree tree_overlaps_hard_reg_set (tree, HARD_REG_SET *);
	#endif

	/* In gimplify.c. */
	extern tree create_artificial_label (void);
	extern void gimplify_function_tree (tree);
	extern const char *get_name (tree);
	extern tree unshare_expr (tree);
	extern void sort_case_labels (tree);

	/* Interface of the DWARF2 unwind info support. */

	/* Generate a new label for the CFI info to refer to. */

	extern char *dwarf2out_cfi_label (void);

	/* Entry point to update the canonical frame address (CFA). */

	extern void dwarf2out_def_cfa (const char *, unsigned, HOST_WIDE_INT);

	/* Add the CFI for saving a register window. */

	extern void dwarf2out_window_save (const char *);

	/* Add a CFI to update the running total of the size of arguments pushed
	onto the stack. */

	extern void dwarf2out_args_size (const char *, HOST_WIDE_INT);

	/* Entry point for saving a register to the stack. */

	extern void dwarf2out_reg_save (const char *, unsigned, HOST_WIDE_INT);

	/* Entry point for saving the return address in the stack. */

	extern void dwarf2out_return_save (const char *, HOST_WIDE_INT);

	/* Entry point for saving the return address in a register. */

	extern void dwarf2out_return_reg (const char *, unsigned);

	/* Entry point for saving the first register into the second. */

	extern void dwarf2out_reg_save_reg (const char *, rtx, rtx);

	/* In tree-inline.c */

	/* The type of a set of already-visited pointers. Functions for creating
	and manipulating it are declared in pointer-set.h */
	struct pointer_set_t;

	/* The type of a callback function for walking over tree structure. */

	typedef tree (walk_tree_fn) (tree , int , void );
	extern tree walk_tree (tree, walk_tree_fn, void, struct pointer_set_t*);
	extern tree walk_tree_without_duplicates (tree, walk_tree_fn, void);

	/* Assign the RTX to declaration. */

	extern void set_decl_rtl (tree, rtx);
	extern void set_decl_incoming_rtl (tree, rtx);

	/* Enum and arrays used for tree allocation stats.
	Keep in sync with tree.c:tree_node_kind_names. */
	typedef enum
	{
	d_kind,
	t_kind,
	b_kind,
	s_kind,
	r_kind,
	e_kind,
	c_kind,
	id_kind,
	perm_list_kind,
	temp_list_kind,
	vec_kind,
	binfo_kind,
	phi_kind,
	ssa_name_kind,
	constr_kind,
	x_kind,
	lang_decl,
	lang_type,
	omp_clause_kind,
	all_kinds
	} tree_node_kind;

	extern int tree_node_counts[];
	extern int tree_node_sizes[];

	/* True if we are in gimple form and the actions of the folders need to
	be restricted. False if we are not in gimple form and folding is not
	restricted to creating gimple expressions. */
	extern bool in_gimple_form;

	/* In tree-gimple.c. */
	extern tree get_base_address (tree t);

	/* In tree-vectorizer.c. */
	extern void vect_set_verbosity_level (const char *);

	struct tree_map GTY(())
	{
	unsigned int hash;
	tree from;
	tree to;
	};

	extern unsigned int tree_map_hash (const void *);
	extern int tree_map_marked_p (const void *);
	extern int tree_map_eq (const void , const void );

	/* In tree-ssa-address.c. */
	extern tree tree_mem_ref_addr (tree, tree);
	extern void copy_mem_ref_info (tree, tree);

	/* In tree-vrp.c */
	extern bool ssa_name_nonzero_p (tree);
	extern bool ssa_name_nonnegative_p (tree);

	/* In tree-object-size.c. */
	extern void init_object_sizes (void);
	extern void fini_object_sizes (void);
	extern unsigned HOST_WIDE_INT compute_builtin_object_size (tree, int);

	/* In expr.c. */
	extern unsigned HOST_WIDE_INT highest_pow2_factor (tree);

	#endif /* GCC_TREE_H */

File Metadata

Mime Type: application/octet-stream
Expires: Mon, Oct 20, 12:32 AM (2 d)
Storage Engine: chunks
Storage Format: Chunks
Storage Handle: 8m2XuCsNAgQk
Default Alt Text: (4 MB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions