Initial checkin of GCC 4.9.0 from trunk (r208799).

Change-Id: I48a3c08bb98542aa215912a75f03c0890e497dba

1 files changed, 5011 insertions, 0 deletions

diff --git a/gcc-4.9/gcc/cp/decl2.c b/gcc-4.9/gcc/cp/decl2.c
new file mode 100644
index 000000000..dfc532d5b
--- /dev/null
+++ b/gcc-4.9/gcc/cp/decl2.c
@@ -0,0 +1,5011 @@
+/* Process declarations and variables for C++ compiler.
+   Copyright (C) 1988-2014 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 3, 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 COPYING3.  If not see
+<http://www.gnu.org/licenses/>.  */
+
+
+/* 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 "stringpool.h"
+#include "varasm.h"
+#include "attribs.h"
+#include "stor-layout.h"
+#include "calls.h"
+#include "pointer-set.h"
+#include "flags.h"
+#include "cp-tree.h"
+#include "decl.h"
+#include "toplev.h"
+#include "timevar.h"
+#include "cpplib.h"
+#include "target.h"
+#include "c-family/c-common.h"
+#include "c-family/c-objc.h"
+#include "cgraph.h"
+#include "tree-inline.h"
+#include "c-family/c-pragma.h"
+#include "dumpfile.h"
+#include "intl.h"
+#include "splay-tree.h"
+#include "langhooks.h"
+#include "c-family/c-ada-spec.h"
+#include "asan.h"
+
+extern cpp_reader *parse_in;
+
+/* This structure contains information about the initializations
+   and/or destructions required for a particular priority level.  */
+typedef struct priority_info_s {
+  /* Nonzero if there have been any initializations at this priority
+     throughout the translation unit.  */
+  int initializations_p;
+  /* Nonzero if there have been any destructions at this priority
+     throughout the translation unit.  */
+  int destructions_p;
+} *priority_info;
+
+static void mark_vtable_entries (tree);
+static bool maybe_emit_vtables (tree);
+static bool acceptable_java_type (tree);
+static tree start_objects (int, int);
+static void finish_objects (int, int, tree);
+static tree start_static_storage_duration_function (unsigned);
+static void finish_static_storage_duration_function (tree);
+static priority_info get_priority_info (int);
+static void do_static_initialization_or_destruction (tree, bool);
+static void one_static_initialization_or_destruction (tree, tree, bool);
+static void generate_ctor_or_dtor_function (bool, int, location_t *);
+static int generate_ctor_and_dtor_functions_for_priority (splay_tree_node,
+							  void *);
+static tree prune_vars_needing_no_initialization (tree *);
+static void write_out_vars (tree);
+static void import_export_class (tree);
+static tree get_guard_bits (tree);
+static void determine_visibility_from_class (tree, tree);
+static bool determine_hidden_inline (tree);
+static bool decl_defined_p (tree);
+
+/* A list of static class variables.  This is needed, because a
+   static class variable can be declared inside the class without
+   an initializer, and then initialized, statically, outside the class.  */
+static GTY(()) vec<tree, va_gc> *pending_statics;
+
+/* A list of functions which were declared inline, but which we
+   may need to emit outline anyway.  */
+static GTY(()) vec<tree, va_gc> *deferred_fns;
+
+/* A list of decls that use types with no linkage, which we need to make
+   sure are defined.  */
+static GTY(()) vec<tree, va_gc> *no_linkage_decls;
+
+/* Nonzero if we're done parsing and into end-of-file activities.  */
+
+int at_eof;
+
+
+/* Return a member function type (a METHOD_TYPE), given FNTYPE (a
+   FUNCTION_TYPE), CTYPE (class type), and QUALS (the cv-qualifiers
+   that apply to the function).  */
+
+tree
+build_memfn_type (tree fntype, tree ctype, cp_cv_quals quals,
+		  cp_ref_qualifier rqual)
+{
+  tree raises;
+  tree attrs;
+  int type_quals;
+
+  if (fntype == error_mark_node || ctype == error_mark_node)
+    return error_mark_node;
+
+  gcc_assert (TREE_CODE (fntype) == FUNCTION_TYPE
+	      || TREE_CODE (fntype) == METHOD_TYPE);
+
+  type_quals = quals & ~TYPE_QUAL_RESTRICT;
+  ctype = cp_build_qualified_type (ctype, type_quals);
+  raises = TYPE_RAISES_EXCEPTIONS (fntype);
+  attrs = TYPE_ATTRIBUTES (fntype);
+  fntype = build_method_type_directly (ctype, TREE_TYPE (fntype),
+				       (TREE_CODE (fntype) == METHOD_TYPE
+					? TREE_CHAIN (TYPE_ARG_TYPES (fntype))
+					: TYPE_ARG_TYPES (fntype)));
+  if (attrs)
+    fntype = cp_build_type_attribute_variant (fntype, attrs);
+  if (rqual)
+    fntype = build_ref_qualified_type (fntype, rqual);
+  if (raises)
+    fntype = build_exception_variant (fntype, raises);
+
+  return fntype;
+}
+
+/* Return a variant of FNTYPE, a FUNCTION_TYPE or METHOD_TYPE, with its
+   return type changed to NEW_RET.  */
+
+tree
+change_return_type (tree new_ret, tree fntype)
+{
+  tree newtype;
+  tree args = TYPE_ARG_TYPES (fntype);
+  tree raises = TYPE_RAISES_EXCEPTIONS (fntype);
+  tree attrs = TYPE_ATTRIBUTES (fntype);
+
+  if (new_ret == error_mark_node)
+    return fntype;
+
+  if (same_type_p (new_ret, TREE_TYPE (fntype)))
+    return fntype;
+
+  if (TREE_CODE (fntype) == FUNCTION_TYPE)
+    {
+      newtype = build_function_type (new_ret, args);
+      newtype = apply_memfn_quals (newtype,
+				   type_memfn_quals (fntype),
+				   type_memfn_rqual (fntype));
+    }
+  else
+    newtype = build_method_type_directly
+      (class_of_this_parm (fntype), new_ret, TREE_CHAIN (args));
+  if (raises)
+    newtype = build_exception_variant (newtype, raises);
+  if (attrs)
+    newtype = cp_build_type_attribute_variant (newtype, attrs);
+
+  return newtype;
+}
+
+/* Build a PARM_DECL with NAME and TYPE, and set DECL_ARG_TYPE
+   appropriately.  */
+
+tree
+cp_build_parm_decl (tree name, tree type)
+{
+  tree parm = build_decl (input_location,
+			  PARM_DECL, name, type);
+  /* DECL_ARG_TYPE is only used by the back end and the back end never
+     sees templates.  */
+  if (!processing_template_decl)
+    DECL_ARG_TYPE (parm) = type_passed_as (type);
+
+  return parm;
+}
+
+/* Returns a PARM_DECL for a parameter of the indicated TYPE, with the
+   indicated NAME.  */
+
+tree
+build_artificial_parm (tree name, tree type)
+{
+  tree parm = cp_build_parm_decl (name, type);
+  DECL_ARTIFICIAL (parm) = 1;
+  /* All our artificial parms are implicitly `const'; they cannot be
+     assigned to.  */
+  TREE_READONLY (parm) = 1;
+  return parm;
+}
+
+/* Constructors for types with virtual baseclasses need an "in-charge" flag
+   saying whether this constructor is responsible for initialization of
+   virtual baseclasses or not.  All destructors also need this "in-charge"
+   flag, which additionally determines whether or not the destructor should
+   free the memory for the object.
+
+   This function adds the "in-charge" flag to member function FN if
+   appropriate.  It is called from grokclassfn and tsubst.
+   FN must be either a constructor or destructor.
+
+   The in-charge flag follows the 'this' parameter, and is followed by the
+   VTT parm (if any), then the user-written parms.  */
+
+void
+maybe_retrofit_in_chrg (tree fn)
+{
+  tree basetype, arg_types, parms, parm, fntype;
+
+  /* If we've already add the in-charge parameter don't do it again.  */
+  if (DECL_HAS_IN_CHARGE_PARM_P (fn))
+    return;
+
+  /* When processing templates we can't know, in general, whether or
+     not we're going to have virtual baseclasses.  */
+  if (processing_template_decl)
+    return;
+
+  /* We don't need an in-charge parameter for constructors that don't
+     have virtual bases.  */
+  if (DECL_CONSTRUCTOR_P (fn)
+      && !CLASSTYPE_VBASECLASSES (DECL_CONTEXT (fn)))
+    return;
+
+  arg_types = TYPE_ARG_TYPES (TREE_TYPE (fn));
+  basetype = TREE_TYPE (TREE_VALUE (arg_types));
+  arg_types = TREE_CHAIN (arg_types);
+
+  parms = DECL_CHAIN (DECL_ARGUMENTS (fn));
+
+  /* If this is a subobject constructor or destructor, our caller will
+     pass us a pointer to our VTT.  */
+  if (CLASSTYPE_VBASECLASSES (DECL_CONTEXT (fn)))
+    {
+      parm = build_artificial_parm (vtt_parm_identifier, vtt_parm_type);
+
+      /* First add it to DECL_ARGUMENTS between 'this' and the real args...  */
+      DECL_CHAIN (parm) = parms;
+      parms = parm;
+
+      /* ...and then to TYPE_ARG_TYPES.  */
+      arg_types = hash_tree_chain (vtt_parm_type, arg_types);
+
+      DECL_HAS_VTT_PARM_P (fn) = 1;
+    }
+
+  /* Then add the in-charge parm (before the VTT parm).  */
+  parm = build_artificial_parm (in_charge_identifier, integer_type_node);
+  DECL_CHAIN (parm) = parms;
+  parms = parm;
+  arg_types = hash_tree_chain (integer_type_node, arg_types);
+
+  /* Insert our new parameter(s) into the list.  */
+  DECL_CHAIN (DECL_ARGUMENTS (fn)) = parms;
+
+  /* And rebuild the function type.  */
+  fntype = build_method_type_directly (basetype, TREE_TYPE (TREE_TYPE (fn)),
+				       arg_types);
+  if (TYPE_RAISES_EXCEPTIONS (TREE_TYPE (fn)))
+    fntype = build_exception_variant (fntype,
+				      TYPE_RAISES_EXCEPTIONS (TREE_TYPE (fn)));
+  if (TYPE_ATTRIBUTES (TREE_TYPE (fn)))
+    fntype = (cp_build_type_attribute_variant
+	      (fntype, TYPE_ATTRIBUTES (TREE_TYPE (fn))));
+  TREE_TYPE (fn) = fntype;
+
+  /* Now we've got the in-charge parameter.  */
+  DECL_HAS_IN_CHARGE_PARM_P (fn) = 1;
+}
+
+/* Classes overload their constituent function names automatically.
+   When a function name is declared in a record structure,
+   its name is changed to it overloaded name.  Since names for
+   constructors and destructors can conflict, we place a leading
+   '$' for destructors.
+
+   CNAME is the name of the class we are grokking for.
+
+   FUNCTION is a FUNCTION_DECL.  It was created by `grokdeclarator'.
+
+   FLAGS contains bits saying what's special about today's
+   arguments.  DTOR_FLAG == DESTRUCTOR.
+
+   If FUNCTION is a destructor, then we must add the `auto-delete' field
+   as a second parameter.  There is some hair associated with the fact
+   that we must "declare" this variable in the manner consistent with the
+   way the rest of the arguments were declared.
+
+   QUALS are the qualifiers for the this pointer.  */
+
+void
+grokclassfn (tree ctype, tree function, enum overload_flags flags)
+{
+  tree fn_name = DECL_NAME (function);
+
+  /* Even within an `extern "C"' block, members get C++ linkage.  See
+     [dcl.link] for details.  */
+  SET_DECL_LANGUAGE (function, lang_cplusplus);
+
+  if (fn_name == NULL_TREE)
+    {
+      error ("name missing for member function");
+      fn_name = get_identifier ("<anonymous>");
+      DECL_NAME (function) = fn_name;
+    }
+
+  DECL_CONTEXT (function) = ctype;
+
+  if (flags == DTOR_FLAG)
+    DECL_DESTRUCTOR_P (function) = 1;
+
+  if (flags == DTOR_FLAG || DECL_CONSTRUCTOR_P (function))
+    maybe_retrofit_in_chrg (function);
+}
+
+/* Create an ARRAY_REF, checking for the user doing things backwards
+   along the way.  DECLTYPE_P is for N3276, as in the parser.  */
+
+tree
+grok_array_decl (location_t loc, tree array_expr, tree index_exp,
+		 bool decltype_p)
+{
+  tree type;
+  tree expr;
+  tree orig_array_expr = array_expr;
+  tree orig_index_exp = index_exp;
+
+  if (error_operand_p (array_expr) || error_operand_p (index_exp))
+    return error_mark_node;
+
+  if (processing_template_decl)
+    {
+      if (type_dependent_expression_p (array_expr)
+	  || type_dependent_expression_p (index_exp))
+	return build_min_nt_loc (loc, ARRAY_REF, array_expr, index_exp,
+				 NULL_TREE, NULL_TREE);
+      array_expr = build_non_dependent_expr (array_expr);
+      index_exp = build_non_dependent_expr (index_exp);
+    }
+
+  type = TREE_TYPE (array_expr);
+  gcc_assert (type);
+  type = non_reference (type);
+
+  /* If they have an `operator[]', use that.  */
+  if (MAYBE_CLASS_TYPE_P (type) || MAYBE_CLASS_TYPE_P (TREE_TYPE (index_exp)))
+    {
+      tsubst_flags_t complain = tf_warning_or_error;
+      if (decltype_p)
+	complain |= tf_decltype;
+      expr = build_new_op (loc, ARRAY_REF, LOOKUP_NORMAL, array_expr,
+			   index_exp, NULL_TREE, /*overload=*/NULL, complain);
+    }
+  else
+    {
+      tree p1, p2, i1, i2;
+
+      /* Otherwise, create an ARRAY_REF for a pointer or array type.
+	 It is a little-known fact that, if `a' is an array and `i' is
+	 an int, you can write `i[a]', which means the same thing as
+	 `a[i]'.  */
+      if (TREE_CODE (type) == ARRAY_TYPE || TREE_CODE (type) == VECTOR_TYPE)
+	p1 = array_expr;
+      else
+	p1 = build_expr_type_conversion (WANT_POINTER, array_expr, false);
+
+      if (TREE_CODE (TREE_TYPE (index_exp)) == ARRAY_TYPE)
+	p2 = index_exp;
+      else
+	p2 = build_expr_type_conversion (WANT_POINTER, index_exp, false);
+
+      i1 = build_expr_type_conversion (WANT_INT | WANT_ENUM, array_expr,
+				       false);
+      i2 = build_expr_type_conversion (WANT_INT | WANT_ENUM, index_exp,
+				       false);
+
+      if ((p1 && i2) && (i1 && p2))
+	error ("ambiguous conversion for array subscript");
+
+      if (p1 && i2)
+	array_expr = p1, index_exp = i2;
+      else if (i1 && p2)
+	array_expr = p2, index_exp = i1;
+      else
+	{
+	  error ("invalid types %<%T[%T]%> for array subscript",
+		 type, TREE_TYPE (index_exp));
+	  return error_mark_node;
+	}
+
+      if (array_expr == error_mark_node || index_exp == error_mark_node)
+	error ("ambiguous conversion for array subscript");
+
+      expr = build_array_ref (input_location, array_expr, index_exp);
+    }
+  if (processing_template_decl && expr != error_mark_node)
+    return build_min_non_dep (ARRAY_REF, expr, orig_array_expr, orig_index_exp,
+			      NULL_TREE, NULL_TREE);
+  return expr;
+}
+
+/* Given the cast expression EXP, checking out its validity.   Either return
+   an error_mark_node if there was an unavoidable error, return a cast to
+   void for trying to delete a pointer w/ the value 0, or return the
+   call to delete.  If DOING_VEC is true, we handle things differently
+   for doing an array delete.
+   Implements ARM $5.3.4.  This is called from the parser.  */
+
+tree
+delete_sanity (tree exp, tree size, bool doing_vec, int use_global_delete,
+	       tsubst_flags_t complain)
+{
+  tree t, type;
+
+  if (exp == error_mark_node)
+    return exp;
+
+  if (processing_template_decl)
+    {
+      t = build_min (DELETE_EXPR, void_type_node, exp, size);
+      DELETE_EXPR_USE_GLOBAL (t) = use_global_delete;
+      DELETE_EXPR_USE_VEC (t) = doing_vec;
+      TREE_SIDE_EFFECTS (t) = 1;
+      return t;
+    }
+
+  /* An array can't have been allocated by new, so complain.  */
+  if (TREE_CODE (TREE_TYPE (exp)) == ARRAY_TYPE)
+    warning (0, "deleting array %q#E", exp);
+
+  t = build_expr_type_conversion (WANT_POINTER, exp, true);
+
+  if (t == NULL_TREE || t == error_mark_node)
+    {
+      error ("type %q#T argument given to %<delete%>, expected pointer",
+	     TREE_TYPE (exp));
+      return error_mark_node;
+    }
+
+  type = TREE_TYPE (t);
+
+  /* As of Valley Forge, you can delete a pointer to const.  */
+
+  /* You can't delete functions.  */
+  if (TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE)
+    {
+      error ("cannot delete a function.  Only pointer-to-objects are "
+	     "valid arguments to %<delete%>");
+      return error_mark_node;
+    }
+
+  /* Deleting ptr to void is undefined behavior [expr.delete/3].  */
+  if (VOID_TYPE_P (TREE_TYPE (type)))
+    {
+      warning (0, "deleting %qT is undefined", type);
+      doing_vec = 0;
+    }
+
+  /* Deleting a pointer with the value zero is valid and has no effect.  */
+  if (integer_zerop (t))
+    return build1 (NOP_EXPR, void_type_node, t);
+
+  if (doing_vec)
+    return build_vec_delete (t, /*maxindex=*/NULL_TREE,
+			     sfk_deleting_destructor,
+			     use_global_delete, complain);
+  else
+    return build_delete (type, t, sfk_deleting_destructor,
+			 LOOKUP_NORMAL, use_global_delete,
+			 complain);
+}
+
+/* Report an error if the indicated template declaration is not the
+   sort of thing that should be a member template.  */
+
+void
+check_member_template (tree tmpl)
+{
+  tree decl;
+
+  gcc_assert (TREE_CODE (tmpl) == TEMPLATE_DECL);
+  decl = DECL_TEMPLATE_RESULT (tmpl);
+
+  if (TREE_CODE (decl) == FUNCTION_DECL
+      || DECL_ALIAS_TEMPLATE_P (tmpl)
+      || (TREE_CODE (decl) == TYPE_DECL
+	  && MAYBE_CLASS_TYPE_P (TREE_TYPE (decl))))
+    {
+      /* The parser rejects template declarations in local classes
+	 (with the exception of generic lambdas).  */
+      gcc_assert (!current_function_decl || LAMBDA_FUNCTION_P (decl));
+      /* The parser rejects any use of virtual in a function template.  */
+      gcc_assert (!(TREE_CODE (decl) == FUNCTION_DECL
+		    && DECL_VIRTUAL_P (decl)));
+
+      /* The debug-information generating code doesn't know what to do
+	 with member templates.  */
+      DECL_IGNORED_P (tmpl) = 1;
+    }
+  else
+    error ("template declaration of %q#D", decl);
+}
+
+/* Return true iff TYPE is a valid Java parameter or return type.  */
+
+static bool
+acceptable_java_type (tree type)
+{
+  if (type == error_mark_node)
+    return false;
+
+  if (VOID_TYPE_P (type) || TYPE_FOR_JAVA (type))
+    return true;
+  if (TYPE_PTR_P (type) || TREE_CODE (type) == REFERENCE_TYPE)
+    {
+      type = TREE_TYPE (type);
+      if (TREE_CODE (type) == RECORD_TYPE)
+	{
+	  tree args;  int i;
+	  if (! TYPE_FOR_JAVA (type))
+	    return false;
+	  if (! CLASSTYPE_TEMPLATE_INFO (type))
+	    return true;
+	  args = CLASSTYPE_TI_ARGS (type);
+	  i = TREE_VEC_LENGTH (args);
+	  while (--i >= 0)
+	    {
+	      type = TREE_VEC_ELT (args, i);
+	      if (TYPE_PTR_P (type))
+		type = TREE_TYPE (type);
+	      if (! TYPE_FOR_JAVA (type))
+		return false;
+	    }
+	  return true;
+	}
+    }
+  return false;
+}
+
+/* For a METHOD in a Java class CTYPE, return true if
+   the parameter and return types are valid Java types.
+   Otherwise, print appropriate error messages, and return false.  */
+
+bool
+check_java_method (tree method)
+{
+  bool jerr = false;
+  tree arg_types = TYPE_ARG_TYPES (TREE_TYPE (method));
+  tree ret_type = TREE_TYPE (TREE_TYPE (method));
+
+  if (!acceptable_java_type (ret_type))
+    {
+      error ("Java method %qD has non-Java return type %qT",
+	     method, ret_type);
+      jerr = true;
+    }
+
+  arg_types = TREE_CHAIN (arg_types);
+  if (DECL_HAS_IN_CHARGE_PARM_P (method))
+    arg_types = TREE_CHAIN (arg_types);
+  if (DECL_HAS_VTT_PARM_P (method))
+    arg_types = TREE_CHAIN (arg_types);
+
+  for (; arg_types != NULL_TREE; arg_types = TREE_CHAIN (arg_types))
+    {
+      tree type = TREE_VALUE (arg_types);
+      if (!acceptable_java_type (type))
+	{
+          if (type != error_mark_node)
+	    error ("Java method %qD has non-Java parameter type %qT",
+		   method, type);
+	  jerr = true;
+	}
+    }
+  return !jerr;
+}
+
+/* Sanity check: report error if this function FUNCTION is not
+   really a member of the class (CTYPE) it is supposed to belong to.
+   TEMPLATE_PARMS is used to specify the template parameters of a member
+   template passed as FUNCTION_DECL. If the member template is passed as a
+   TEMPLATE_DECL, it can be NULL since the parameters can be extracted
+   from the declaration. If the function is not a function template, it
+   must be NULL.
+   It returns the original declaration for the function, NULL_TREE if
+   no declaration was found, error_mark_node if an error was emitted.  */
+
+tree
+check_classfn (tree ctype, tree function, tree template_parms)
+{
+  int ix;
+  bool is_template;
+  tree pushed_scope;
+  
+  if (DECL_USE_TEMPLATE (function)
+      && !(TREE_CODE (function) == TEMPLATE_DECL
+	   && DECL_TEMPLATE_SPECIALIZATION (function))
+      && DECL_MEMBER_TEMPLATE_P (DECL_TI_TEMPLATE (function)))
+    /* Since this is a specialization of a member template,
+       we're not going to find the declaration in the class.
+       For example, in:
+
+	 struct S { template <typename T> void f(T); };
+	 template <> void S::f(int);
+
+       we're not going to find `S::f(int)', but there's no
+       reason we should, either.  We let our callers know we didn't
+       find the method, but we don't complain.  */
+    return NULL_TREE;
+
+  /* Basic sanity check: for a template function, the template parameters
+     either were not passed, or they are the same of DECL_TEMPLATE_PARMS.  */
+  if (TREE_CODE (function) == TEMPLATE_DECL)
+    {
+      if (template_parms
+	  && !comp_template_parms (template_parms,
+				   DECL_TEMPLATE_PARMS (function)))
+	{
+	  error ("template parameter lists provided don%'t match the "
+		 "template parameters of %qD", function);
+	  return error_mark_node;
+	}
+      template_parms = DECL_TEMPLATE_PARMS (function);
+    }
+
+  /* OK, is this a definition of a member template?  */
+  is_template = (template_parms != NULL_TREE);
+
+  /* [temp.mem]
+
+     A destructor shall not be a member template.  */
+  if (DECL_DESTRUCTOR_P (function) && is_template)
+    {
+      error ("destructor %qD declared as member template", function);
+      return error_mark_node;
+    }
+
+  /* We must enter the scope here, because conversion operators are
+     named by target type, and type equivalence relies on typenames
+     resolving within the scope of CTYPE.  */
+  pushed_scope = push_scope (ctype);
+  ix = class_method_index_for_fn (complete_type (ctype), function);
+  if (ix >= 0)
+    {
+      vec<tree, va_gc> *methods = CLASSTYPE_METHOD_VEC (ctype);
+      tree fndecls, fndecl = 0;
+      bool is_conv_op;
+      const char *format = NULL;
+
+      for (fndecls = (*methods)[ix];
+	   fndecls; fndecls = OVL_NEXT (fndecls))
+	{
+	  tree p1, p2;
+
+	  fndecl = OVL_CURRENT (fndecls);
+	  p1 = TYPE_ARG_TYPES (TREE_TYPE (function));
+	  p2 = TYPE_ARG_TYPES (TREE_TYPE (fndecl));
+
+	  /* We cannot simply call decls_match because this doesn't
+	     work for static member functions that are pretending to
+	     be methods, and because the name may have been changed by
+	     asm("new_name").  */
+
+	   /* Get rid of the this parameter on functions that become
+	      static.  */
+	  if (DECL_STATIC_FUNCTION_P (fndecl)
+	      && TREE_CODE (TREE_TYPE (function)) == METHOD_TYPE)
+	    p1 = TREE_CHAIN (p1);
+
+	  /* A member template definition only matches a member template
+	     declaration.  */
+	  if (is_template != (TREE_CODE (fndecl) == TEMPLATE_DECL))
+	    continue;
+
+	  /* ref-qualifier or absence of same must match.  */
+	  if (type_memfn_rqual (TREE_TYPE (function))
+	      != type_memfn_rqual (TREE_TYPE (fndecl)))
+	    continue;
+
+	  /* While finding a match, same types and params are not enough
+	     if the function is versioned.  Also check version ("target")
+	     attributes.  */
+	  if (same_type_p (TREE_TYPE (TREE_TYPE (function)),
+			   TREE_TYPE (TREE_TYPE (fndecl)))
+	      && compparms (p1, p2)
+	      && !targetm.target_option.function_versions (function, fndecl)
+	      && (!is_template
+		  || comp_template_parms (template_parms,
+					  DECL_TEMPLATE_PARMS (fndecl)))
+	      && (DECL_TEMPLATE_SPECIALIZATION (function)
+		  == DECL_TEMPLATE_SPECIALIZATION (fndecl))
+	      && (!DECL_TEMPLATE_SPECIALIZATION (function)
+		  || (DECL_TI_TEMPLATE (function)
+		      == DECL_TI_TEMPLATE (fndecl))))
+	    break;
+	}
+      if (fndecls)
+	{
+	  if (pushed_scope)
+	    pop_scope (pushed_scope);
+	  return OVL_CURRENT (fndecls);
+	}
+      
+      error_at (DECL_SOURCE_LOCATION (function),
+		"prototype for %q#D does not match any in class %qT",
+		function, ctype);
+      is_conv_op = DECL_CONV_FN_P (fndecl);
+
+      if (is_conv_op)
+	ix = CLASSTYPE_FIRST_CONVERSION_SLOT;
+      fndecls = (*methods)[ix];
+      while (fndecls)
+	{
+	  fndecl = OVL_CURRENT (fndecls);
+	  fndecls = OVL_NEXT (fndecls);
+
+	  if (!fndecls && is_conv_op)
+	    {
+	      if (methods->length () > (size_t) ++ix)
+		{
+		  fndecls = (*methods)[ix];
+		  if (!DECL_CONV_FN_P (OVL_CURRENT (fndecls)))
+		    {
+		      fndecls = NULL_TREE;
+		      is_conv_op = false;
+		    }
+		}
+	      else
+		is_conv_op = false;
+	    }
+	  if (format)
+	    format = "                %+#D";
+	  else if (fndecls)
+	    format = N_("candidates are: %+#D");
+	  else
+	    format = N_("candidate is: %+#D");
+	  error (format, fndecl);
+	}
+    }
+  else if (!COMPLETE_TYPE_P (ctype))
+    cxx_incomplete_type_error (function, ctype);
+  else
+    error ("no %q#D member function declared in class %qT",
+	   function, ctype);
+
+  if (pushed_scope)
+    pop_scope (pushed_scope);
+  return error_mark_node;
+}
+
+/* DECL is a function with vague linkage.  Remember it so that at the
+   end of the translation unit we can decide whether or not to emit
+   it.  */
+
+void
+note_vague_linkage_fn (tree decl)
+{
+  DECL_DEFER_OUTPUT (decl) = 1;
+  vec_safe_push (deferred_fns, decl);
+}
+
+/* We have just processed the DECL, which is a static data member.
+   The other parameters are as for cp_finish_decl.  */
+
+void
+finish_static_data_member_decl (tree decl,
+				tree init, bool init_const_expr_p,
+				tree asmspec_tree,
+				int flags)
+{
+  DECL_CONTEXT (decl) = current_class_type;
+
+  /* We cannot call pushdecl here, because that would fill in the
+     TREE_CHAIN of our decl.  Instead, we modify cp_finish_decl to do
+     the right thing, namely, to put this decl out straight away.  */
+
+  if (! processing_template_decl)
+    vec_safe_push (pending_statics, decl);
+
+  if (LOCAL_CLASS_P (current_class_type)
+      /* We already complained about the template definition.  */
+      && !DECL_TEMPLATE_INSTANTIATION (decl))
+    permerror (input_location, "local class %q#T shall not have static data member %q#D",
+	       current_class_type, decl);
+  else
+    for (tree t = current_class_type; TYPE_P (t);
+	 t = CP_TYPE_CONTEXT (t))
+      if (TYPE_ANONYMOUS_P (t))
+	{
+	  if (permerror (DECL_SOURCE_LOCATION (decl),
+			 "static data member %qD in unnamed class", decl))
+	    inform (DECL_SOURCE_LOCATION (TYPE_NAME (t)),
+		    "unnamed class defined here");
+	  break;
+	}
+
+  DECL_IN_AGGR_P (decl) = 1;
+
+  if (TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE
+      && TYPE_DOMAIN (TREE_TYPE (decl)) == NULL_TREE)
+    SET_VAR_HAD_UNKNOWN_BOUND (decl);
+
+  cp_finish_decl (decl, init, init_const_expr_p, asmspec_tree, flags);
+}
+
+/* DECLARATOR and DECLSPECS correspond to a class member.  The other
+   parameters are as for cp_finish_decl.  Return the DECL for the
+   class member declared.  */
+
+tree
+grokfield (const cp_declarator *declarator,
+	   cp_decl_specifier_seq *declspecs,
+	   tree init, bool init_const_expr_p,
+	   tree asmspec_tree,
+	   tree attrlist)
+{
+  tree value;
+  const char *asmspec = 0;
+  int flags;
+  tree name;
+
+  if (init
+      && TREE_CODE (init) == TREE_LIST
+      && TREE_VALUE (init) == error_mark_node
+      && TREE_CHAIN (init) == NULL_TREE)
+    init = NULL_TREE;
+
+  value = grokdeclarator (declarator, declspecs, FIELD, init != 0, &attrlist);
+  if (! value || value == error_mark_node)
+    /* friend or constructor went bad.  */
+    return error_mark_node;
+  if (TREE_TYPE (value) == error_mark_node)
+    return value;
+
+  if (TREE_CODE (value) == TYPE_DECL && init)
+    {
+      error ("typedef %qD is initialized (use decltype instead)", value);
+      init = NULL_TREE;
+    }
+
+  /* Pass friendly classes back.  */
+  if (value == void_type_node)
+    return value;
+
+  /* Pass friend decls back.  */
+  if ((TREE_CODE (value) == FUNCTION_DECL
+       || TREE_CODE (value) == TEMPLATE_DECL)
+      && DECL_CONTEXT (value) != current_class_type)
+    return value;
+
+  name = DECL_NAME (value);
+
+  if (name != NULL_TREE)
+    {
+      if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
+	{
+	  error ("explicit template argument list not allowed");
+	  return error_mark_node;
+	}
+
+      if (IDENTIFIER_POINTER (name)[0] == '_'
+	  && ! strcmp (IDENTIFIER_POINTER (name), "_vptr"))
+	error ("member %qD conflicts with virtual function table field name",
+	       value);
+    }
+
+  /* Stash away type declarations.  */
+  if (TREE_CODE (value) == TYPE_DECL)
+    {
+      DECL_NONLOCAL (value) = 1;
+      DECL_CONTEXT (value) = current_class_type;
+
+      if (attrlist)
+	{
+	  int attrflags = 0;
+
+	  /* If this is a typedef that names the class for linkage purposes
+	     (7.1.3p8), apply any attributes directly to the type.  */
+	  if (OVERLOAD_TYPE_P (TREE_TYPE (value))
+	      && value == TYPE_NAME (TYPE_MAIN_VARIANT (TREE_TYPE (value))))
+	    attrflags = ATTR_FLAG_TYPE_IN_PLACE;
+
+	  cplus_decl_attributes (&value, attrlist, attrflags);
+	}
+
+      if (decl_spec_seq_has_spec_p (declspecs, ds_typedef)
+          && TREE_TYPE (value) != error_mark_node
+          && TYPE_NAME (TYPE_MAIN_VARIANT (TREE_TYPE (value))) != value)
+	set_underlying_type (value);
+
+      /* It's important that push_template_decl below follows
+	 set_underlying_type above so that the created template
+	 carries the properly set type of VALUE.  */
+      if (processing_template_decl)
+	value = push_template_decl (value);
+
+      record_locally_defined_typedef (value);
+      return value;
+    }
+
+  if (DECL_IN_AGGR_P (value))
+    {
+      error ("%qD is already defined in %qT", value, DECL_CONTEXT (value));
+      return void_type_node;
+    }
+
+  if (asmspec_tree && asmspec_tree != error_mark_node)
+    asmspec = TREE_STRING_POINTER (asmspec_tree);
+
+  if (init)
+    {
+      if (TREE_CODE (value) == FUNCTION_DECL)
+	{
+	  /* Initializers for functions are rejected early in the parser.
+	     If we get here, it must be a pure specifier for a method.  */
+	  if (init == ridpointers[(int)RID_DELETE])
+	    {
+	      DECL_DELETED_FN (value) = 1;
+	      DECL_DECLARED_INLINE_P (value) = 1;
+	      DECL_INITIAL (value) = error_mark_node;
+	    }
+	  else if (init == ridpointers[(int)RID_DEFAULT])
+	    {
+	      if (defaultable_fn_check (value))
+		{
+		  DECL_DEFAULTED_FN (value) = 1;
+		  DECL_INITIALIZED_IN_CLASS_P (value) = 1;
+		  DECL_DECLARED_INLINE_P (value) = 1;
+		}
+	    }
+	  else if (TREE_CODE (init) == DEFAULT_ARG)
+	    error ("invalid initializer for member function %qD", value);
+	  else if (TREE_CODE (TREE_TYPE (value)) == METHOD_TYPE)
+	    {
+	      if (integer_zerop (init))
+		DECL_PURE_VIRTUAL_P (value) = 1;
+	      else if (error_operand_p (init))
+		; /* An error has already been reported.  */
+	      else
+		error ("invalid initializer for member function %qD",
+		       value);
+	    }
+	  else
+	    {
+	      gcc_assert (TREE_CODE (TREE_TYPE (value)) == FUNCTION_TYPE);
+	      error ("initializer specified for static member function %qD",
+		     value);
+	    }
+	}
+      else if (TREE_CODE (value) == FIELD_DECL)
+	/* C++11 NSDMI, keep going.  */;
+      else if (!VAR_P (value))
+	gcc_unreachable ();
+    }
+
+  if (processing_template_decl && VAR_OR_FUNCTION_DECL_P (value))
+    {
+      value = push_template_decl (value);
+      if (error_operand_p (value))
+	return error_mark_node;
+    }
+
+  if (attrlist)
+    cplus_decl_attributes (&value, attrlist, 0);
+
+  if (init && BRACE_ENCLOSED_INITIALIZER_P (init)
+      && CONSTRUCTOR_IS_DIRECT_INIT (init))
+    flags = LOOKUP_NORMAL;
+  else
+    flags = LOOKUP_IMPLICIT;
+
+  switch (TREE_CODE (value))
+    {
+    case VAR_DECL:
+      finish_static_data_member_decl (value, init, init_const_expr_p,
+				      asmspec_tree, flags);
+      return value;
+
+    case FIELD_DECL:
+      if (asmspec)
+	error ("%<asm%> specifiers are not permitted on non-static data members");
+      if (DECL_INITIAL (value) == error_mark_node)
+	init = error_mark_node;
+      cp_finish_decl (value, init, /*init_const_expr_p=*/false,
+		      NULL_TREE, flags);
+      DECL_IN_AGGR_P (value) = 1;
+      return value;
+
+    case  FUNCTION_DECL:
+      if (asmspec)
+	set_user_assembler_name (value, asmspec);
+
+      cp_finish_decl (value,
+		      /*init=*/NULL_TREE,
+		      /*init_const_expr_p=*/false,
+		      asmspec_tree, flags);
+
+      /* Pass friends back this way.  */
+      if (DECL_FRIEND_P (value))
+	return void_type_node;
+
+      DECL_IN_AGGR_P (value) = 1;
+      return value;
+
+    default:
+      gcc_unreachable ();
+    }
+  return NULL_TREE;
+}
+
+/* Like `grokfield', but for bitfields.
+   WIDTH is non-NULL for bit fields only, and is an INTEGER_CST node.  */
+
+tree
+grokbitfield (const cp_declarator *declarator,
+	      cp_decl_specifier_seq *declspecs, tree width,
+	      tree attrlist)
+{
+  tree value = grokdeclarator (declarator, declspecs, BITFIELD, 0, &attrlist);
+
+  if (value == error_mark_node)
+    return NULL_TREE; /* friends went bad.  */
+  if (TREE_TYPE (value) == error_mark_node)
+    return value;
+
+  /* Pass friendly classes back.  */
+  if (VOID_TYPE_P (value))
+    return void_type_node;
+
+  if (!INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (value))
+      && (POINTER_TYPE_P (value)
+          || !dependent_type_p (TREE_TYPE (value))))
+    {
+      error ("bit-field %qD with non-integral type", value);
+      return error_mark_node;
+    }
+
+  if (TREE_CODE (value) == TYPE_DECL)
+    {
+      error ("cannot declare %qD to be a bit-field type", value);
+      return NULL_TREE;
+    }
+
+  /* Usually, finish_struct_1 catches bitfields with invalid types.
+     But, in the case of bitfields with function type, we confuse
+     ourselves into thinking they are member functions, so we must
+     check here.  */
+  if (TREE_CODE (value) == FUNCTION_DECL)
+    {
+      error ("cannot declare bit-field %qD with function type",
+	     DECL_NAME (value));
+      return NULL_TREE;
+    }
+
+  if (DECL_IN_AGGR_P (value))
+    {
+      error ("%qD is already defined in the class %qT", value,
+	     DECL_CONTEXT (value));
+      return void_type_node;
+    }
+
+  if (TREE_STATIC (value))
+    {
+      error ("static member %qD cannot be a bit-field", value);
+      return NULL_TREE;
+    }
+  cp_finish_decl (value, NULL_TREE, false, NULL_TREE, 0);
+
+  if (width != error_mark_node)
+    {
+      /* The width must be an integer type.  */
+      if (!type_dependent_expression_p (width)
+	  && !INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (TREE_TYPE (width)))
+	error ("width of bit-field %qD has non-integral type %qT", value,
+	       TREE_TYPE (width));
+      DECL_INITIAL (value) = width;
+      SET_DECL_C_BIT_FIELD (value);
+    }
+
+  DECL_IN_AGGR_P (value) = 1;
+
+  if (attrlist)
+    cplus_decl_attributes (&value, attrlist, /*flags=*/0);
+
+  return value;
+}
+
+
+/* Returns true iff ATTR is an attribute which needs to be applied at
+   instantiation time rather than template definition time.  */
+
+static bool
+is_late_template_attribute (tree attr, tree decl)
+{
+  tree name = get_attribute_name (attr);
+  tree args = TREE_VALUE (attr);
+  const struct attribute_spec *spec = lookup_attribute_spec (name);
+  tree arg;
+
+  if (!spec)
+    /* Unknown attribute.  */
+    return false;
+
+  /* Attribute weak handling wants to write out assembly right away.  */
+  if (is_attribute_p ("weak", name))
+    return true;
+
+  /* Attribute unused is applied directly, as it appertains to
+     decls. */
+  if (is_attribute_p ("unused", name))
+    return false;
+
+  /* #pragma omp declare simd attribute needs to be always deferred.  */
+  if (flag_openmp
+      && is_attribute_p ("omp declare simd", name))
+    return true;
+
+  /* If any of the arguments are dependent expressions, we can't evaluate
+     the attribute until instantiation time.  */
+  for (arg = args; arg; arg = TREE_CHAIN (arg))
+    {
+      tree t = TREE_VALUE (arg);
+
+      /* If the first attribute argument is an identifier, only consider
+	 second and following arguments.  Attributes like mode, format,
+	 cleanup and several target specific attributes aren't late
+	 just because they have an IDENTIFIER_NODE as first argument.  */
+      if (arg == args && identifier_p (t))
+	continue;
+
+      if (value_dependent_expression_p (t)
+	  || type_dependent_expression_p (t))
+	return true;
+    }
+
+  if (TREE_CODE (decl) == TYPE_DECL
+      || TYPE_P (decl)
+      || spec->type_required)
+    {
+      tree type = TYPE_P (decl) ? decl : TREE_TYPE (decl);
+
+      /* We can't apply any attributes to a completely unknown type until
+	 instantiation time.  */
+      enum tree_code code = TREE_CODE (type);
+      if (code == TEMPLATE_TYPE_PARM
+	  || code == BOUND_TEMPLATE_TEMPLATE_PARM
+	  || code == TYPENAME_TYPE)
+	return true;
+      /* Also defer most attributes on dependent types.  This is not
+	 necessary in all cases, but is the better default.  */
+      else if (dependent_type_p (type)
+	       /* But attribute visibility specifically works on
+		  templates.  */
+	       && !is_attribute_p ("visibility", name))
+	return true;
+      else
+	return false;
+    }
+  else
+    return false;
+}
+
+/* ATTR_P is a list of attributes.  Remove any attributes which need to be
+   applied at instantiation time and return them.  If IS_DEPENDENT is true,
+   the declaration itself is dependent, so all attributes should be applied
+   at instantiation time.  */
+
+static tree
+splice_template_attributes (tree *attr_p, tree decl)
+{
+  tree *p = attr_p;
+  tree late_attrs = NULL_TREE;
+  tree *q = &late_attrs;
+
+  if (!p)
+    return NULL_TREE;
+
+  for (; *p; )
+    {
+      if (is_late_template_attribute (*p, decl))
+	{
+	  ATTR_IS_DEPENDENT (*p) = 1;
+	  *q = *p;
+	  *p = TREE_CHAIN (*p);
+	  q = &TREE_CHAIN (*q);
+	  *q = NULL_TREE;
+	}
+      else
+	p = &TREE_CHAIN (*p);
+    }
+
+  return late_attrs;
+}
+
+/* Remove any late attributes from the list in ATTR_P and attach them to
+   DECL_P.  */
+
+static void
+save_template_attributes (tree *attr_p, tree *decl_p)
+{
+  tree *q;
+
+  if (attr_p && *attr_p == error_mark_node)
+    return;
+
+  tree late_attrs = splice_template_attributes (attr_p, *decl_p);
+  if (!late_attrs)
+    return;
+
+  if (DECL_P (*decl_p))
+    q = &DECL_ATTRIBUTES (*decl_p);
+  else
+    q = &TYPE_ATTRIBUTES (*decl_p);
+
+  tree old_attrs = *q;
+
+  /* Merge the late attributes at the beginning with the attribute
+     list.  */
+  late_attrs = merge_attributes (late_attrs, *q);
+  *q = late_attrs;
+
+  if (!DECL_P (*decl_p) && *decl_p == TYPE_MAIN_VARIANT (*decl_p))
+    {
+      /* We've added new attributes directly to the main variant, so
+	 now we need to update all of the other variants to include
+	 these new attributes.  */
+      tree variant;
+      for (variant = TYPE_NEXT_VARIANT (*decl_p); variant;
+	   variant = TYPE_NEXT_VARIANT (variant))
+	{
+	  gcc_assert (TYPE_ATTRIBUTES (variant) == old_attrs);
+	  TYPE_ATTRIBUTES (variant) = TYPE_ATTRIBUTES (*decl_p);
+	}
+    }
+}
+
+/* Return true iff ATTRS are acceptable attributes to be applied in-place
+   to a typedef which gives a previously anonymous class or enum a name for
+   linkage purposes.  */
+
+bool
+attributes_naming_typedef_ok (tree attrs)
+{
+  for (; attrs; attrs = TREE_CHAIN (attrs))
+    {
+      tree name = get_attribute_name (attrs);
+      if (is_attribute_p ("vector_size", name))
+	return false;
+    }
+  return true;
+}
+
+/* Like reconstruct_complex_type, but handle also template trees.  */
+
+tree
+cp_reconstruct_complex_type (tree type, tree bottom)
+{
+  tree inner, outer;
+
+  if (TYPE_PTR_P (type))
+    {
+      inner = cp_reconstruct_complex_type (TREE_TYPE (type), bottom);
+      outer = build_pointer_type_for_mode (inner, TYPE_MODE (type),
+					   TYPE_REF_CAN_ALIAS_ALL (type));
+    }
+  else if (TREE_CODE (type) == REFERENCE_TYPE)
+    {
+      inner = cp_reconstruct_complex_type (TREE_TYPE (type), bottom);
+      outer = build_reference_type_for_mode (inner, TYPE_MODE (type),
+					     TYPE_REF_CAN_ALIAS_ALL (type));
+    }
+  else if (TREE_CODE (type) == ARRAY_TYPE)
+    {
+      inner = cp_reconstruct_complex_type (TREE_TYPE (type), bottom);
+      outer = build_cplus_array_type (inner, TYPE_DOMAIN (type));
+      /* Don't call cp_build_qualified_type on ARRAY_TYPEs, the
+	 element type qualification will be handled by the recursive
+	 cp_reconstruct_complex_type call and cp_build_qualified_type
+	 for ARRAY_TYPEs changes the element type.  */
+      return outer;
+    }
+  else if (TREE_CODE (type) == FUNCTION_TYPE)
+    {
+      inner = cp_reconstruct_complex_type (TREE_TYPE (type), bottom);
+      outer = build_function_type (inner, TYPE_ARG_TYPES (type));
+      outer = apply_memfn_quals (outer,
+				 type_memfn_quals (type),
+				 type_memfn_rqual (type));
+    }
+  else if (TREE_CODE (type) == METHOD_TYPE)
+    {
+      inner = cp_reconstruct_complex_type (TREE_TYPE (type), bottom);
+      /* The build_method_type_directly() routine prepends 'this' to argument list,
+	 so we must compensate by getting rid of it.  */
+      outer
+	= build_method_type_directly
+	    (class_of_this_parm (type), inner,
+	     TREE_CHAIN (TYPE_ARG_TYPES (type)));
+    }
+  else if (TREE_CODE (type) == OFFSET_TYPE)
+    {
+      inner = cp_reconstruct_complex_type (TREE_TYPE (type), bottom);
+      outer = build_offset_type (TYPE_OFFSET_BASETYPE (type), inner);
+    }
+  else
+    return bottom;
+
+  if (TYPE_ATTRIBUTES (type))
+    outer = cp_build_type_attribute_variant (outer, TYPE_ATTRIBUTES (type));
+  return cp_build_qualified_type (outer, cp_type_quals (type));
+}
+
+/* Replaces any constexpr expression that may be into the attributes
+   arguments with their reduced value.  */
+
+static void
+cp_check_const_attributes (tree attributes)
+{
+  if (attributes == error_mark_node)
+    return;
+
+  tree attr;
+  for (attr = attributes; attr; attr = TREE_CHAIN (attr))
+    {
+      tree arg;
+      for (arg = TREE_VALUE (attr); arg; arg = TREE_CHAIN (arg))
+	{
+	  tree expr = TREE_VALUE (arg);
+	  if (EXPR_P (expr))
+	    TREE_VALUE (arg) = maybe_constant_value (expr);
+	}
+    }
+}
+
+/* Return true if TYPE is an OpenMP mappable type.  */
+bool
+cp_omp_mappable_type (tree type)
+{
+  /* Mappable type has to be complete.  */
+  if (type == error_mark_node || !COMPLETE_TYPE_P (type))
+    return false;
+  /* Arrays have mappable type if the elements have mappable type.  */
+  while (TREE_CODE (type) == ARRAY_TYPE)
+    type = TREE_TYPE (type);
+  /* A mappable type cannot contain virtual members.  */
+  if (CLASS_TYPE_P (type) && CLASSTYPE_VTABLES (type))
+    return false;
+  /* All data members must be non-static.  */
+  if (CLASS_TYPE_P (type))
+    {
+      tree field;
+      for (field = TYPE_FIELDS (type); field; field = DECL_CHAIN (field))
+	if (TREE_CODE (field) == VAR_DECL)
+	  return false;
+	/* All fields must have mappable types.  */
+	else if (TREE_CODE (field) == FIELD_DECL
+		 && !cp_omp_mappable_type (TREE_TYPE (field)))
+	  return false;
+    }
+  return true;
+}
+
+/* Like decl_attributes, but handle C++ complexity.  */
+
+void
+cplus_decl_attributes (tree *decl, tree attributes, int flags)
+{
+  if (*decl == NULL_TREE || *decl == void_type_node
+      || *decl == error_mark_node)
+    return;
+
+  /* Add implicit "omp declare target" attribute if requested.  */
+  if (scope_chain->omp_declare_target_attribute
+      && ((TREE_CODE (*decl) == VAR_DECL && TREE_STATIC (*decl))
+	  || TREE_CODE (*decl) == FUNCTION_DECL))
+    {
+      if (TREE_CODE (*decl) == VAR_DECL
+	  && DECL_CLASS_SCOPE_P (*decl))
+	error ("%q+D static data member inside of declare target directive",
+	       *decl);
+      else if (TREE_CODE (*decl) == VAR_DECL
+	       && (DECL_FUNCTION_SCOPE_P (*decl)
+		   || (current_function_decl && !DECL_EXTERNAL (*decl))))
+	error ("%q+D in block scope inside of declare target directive",
+	       *decl);
+      else if (!processing_template_decl
+	       && TREE_CODE (*decl) == VAR_DECL
+	       && !cp_omp_mappable_type (TREE_TYPE (*decl)))
+	error ("%q+D in declare target directive does not have mappable type",
+	       *decl);
+      else
+	attributes = tree_cons (get_identifier ("omp declare target"),
+				NULL_TREE, attributes);
+    }
+
+  if (processing_template_decl)
+    {
+      if (check_for_bare_parameter_packs (attributes))
+	return;
+
+      save_template_attributes (&attributes, decl);
+    }
+
+  cp_check_const_attributes (attributes);
+
+  if (TREE_CODE (*decl) == TEMPLATE_DECL)
+    decl = &DECL_TEMPLATE_RESULT (*decl);
+
+  decl_attributes (decl, attributes, flags);
+
+  if (TREE_CODE (*decl) == TYPE_DECL)
+    SET_IDENTIFIER_TYPE_VALUE (DECL_NAME (*decl), TREE_TYPE (*decl));
+}
+
+/* Walks through the namespace- or function-scope anonymous union
+   OBJECT, with the indicated TYPE, building appropriate VAR_DECLs.
+   Returns one of the fields for use in the mangled name.  */
+
+static tree
+build_anon_union_vars (tree type, tree object)
+{
+  tree main_decl = NULL_TREE;
+  tree field;
+
+  /* Rather than write the code to handle the non-union case,
+     just give an error.  */
+  if (TREE_CODE (type) != UNION_TYPE)
+    {
+      error ("anonymous struct not inside named type");
+      return error_mark_node;
+    }
+
+  for (field = TYPE_FIELDS (type);
+       field != NULL_TREE;
+       field = DECL_CHAIN (field))
+    {
+      tree decl;
+      tree ref;
+
+      if (DECL_ARTIFICIAL (field))
+	continue;
+      if (TREE_CODE (field) != FIELD_DECL)
+	{
+	  permerror (input_location, "%q+#D invalid; an anonymous union can only "
+		     "have non-static data members", field);
+	  continue;
+	}
+
+      if (TREE_PRIVATE (field))
+	permerror (input_location, "private member %q+#D in anonymous union", field);
+      else if (TREE_PROTECTED (field))
+	permerror (input_location, "protected member %q+#D in anonymous union", field);
+
+      if (processing_template_decl)
+	ref = build_min_nt_loc (UNKNOWN_LOCATION, COMPONENT_REF, object,
+				DECL_NAME (field), NULL_TREE);
+      else
+	ref = build_class_member_access_expr (object, field, NULL_TREE,
+					      false, tf_warning_or_error);
+
+      if (DECL_NAME (field))
+	{
+	  tree base;
+
+	  decl = build_decl (input_location,
+			     VAR_DECL, DECL_NAME (field), TREE_TYPE (field));
+	  DECL_ANON_UNION_VAR_P (decl) = 1;
+	  DECL_ARTIFICIAL (decl) = 1;
+
+	  base = get_base_address (object);
+	  TREE_PUBLIC (decl) = TREE_PUBLIC (base);
+	  TREE_STATIC (decl) = TREE_STATIC (base);
+	  DECL_EXTERNAL (decl) = DECL_EXTERNAL (base);
+
+	  SET_DECL_VALUE_EXPR (decl, ref);
+	  DECL_HAS_VALUE_EXPR_P (decl) = 1;
+
+	  decl = pushdecl (decl);
+	}
+      else if (ANON_AGGR_TYPE_P (TREE_TYPE (field)))
+	decl = build_anon_union_vars (TREE_TYPE (field), ref);
+      else
+	decl = 0;
+
+      if (main_decl == NULL_TREE)
+	main_decl = decl;
+    }
+
+  return main_decl;
+}
+
+/* Finish off the processing of a UNION_TYPE structure.  If the union is an
+   anonymous union, then all members must be laid out together.  PUBLIC_P
+   is nonzero if this union is not declared static.  */
+
+void
+finish_anon_union (tree anon_union_decl)
+{
+  tree type;
+  tree main_decl;
+  bool public_p;
+
+  if (anon_union_decl == error_mark_node)
+    return;
+
+  type = TREE_TYPE (anon_union_decl);
+  public_p = TREE_PUBLIC (anon_union_decl);
+
+  /* The VAR_DECL's context is the same as the TYPE's context.  */
+  DECL_CONTEXT (anon_union_decl) = DECL_CONTEXT (TYPE_NAME (type));
+
+  if (TYPE_FIELDS (type) == NULL_TREE)
+    return;
+
+  if (public_p)
+    {
+      error ("namespace-scope anonymous aggregates must be static");
+      return;
+    }
+
+  main_decl = build_anon_union_vars (type, anon_union_decl);
+  if (main_decl == error_mark_node)
+    return;
+  if (main_decl == NULL_TREE)
+    {
+      warning (0, "anonymous union with no members");
+      return;
+    }
+
+  if (!processing_template_decl)
+    {
+      /* Use main_decl to set the mangled name.  */
+      DECL_NAME (anon_union_decl) = DECL_NAME (main_decl);
+      maybe_commonize_var (anon_union_decl);
+      if (TREE_STATIC (anon_union_decl) || DECL_EXTERNAL (anon_union_decl))
+	mangle_decl (anon_union_decl);
+      DECL_NAME (anon_union_decl) = NULL_TREE;
+    }
+
+  pushdecl (anon_union_decl);
+  cp_finish_decl (anon_union_decl, NULL_TREE, false, NULL_TREE, 0);
+}
+
+/* Auxiliary functions to make type signatures for
+   `operator new' and `operator delete' correspond to
+   what compiler will be expecting.  */
+
+tree
+coerce_new_type (tree type)
+{
+  int e = 0;
+  tree args = TYPE_ARG_TYPES (type);
+
+  gcc_assert (TREE_CODE (type) == FUNCTION_TYPE);
+
+  if (!same_type_p (TREE_TYPE (type), ptr_type_node))
+    {
+      e = 1;
+      error ("%<operator new%> must return type %qT", ptr_type_node);
+    }
+
+  if (args && args != void_list_node)
+    {
+      if (TREE_PURPOSE (args))
+	{
+	  /* [basic.stc.dynamic.allocation]
+	     
+	     The first parameter shall not have an associated default
+	     argument.  */
+	  error ("the first parameter of %<operator new%> cannot "
+		 "have a default argument");
+	  /* Throw away the default argument.  */
+	  TREE_PURPOSE (args) = NULL_TREE;
+	}
+
+      if (!same_type_p (TREE_VALUE (args), size_type_node))
+	{
+	  e = 2;
+	  args = TREE_CHAIN (args);
+	}
+    }
+  else
+    e = 2;
+
+  if (e == 2)
+    permerror (input_location, "%<operator new%> takes type %<size_t%> (%qT) "
+	       "as first parameter", size_type_node);
+
+  switch (e)
+  {
+    case 2:
+      args = tree_cons (NULL_TREE, size_type_node, args);
+      /* Fall through.  */
+    case 1:
+      type = build_exception_variant
+	      (build_function_type (ptr_type_node, args),
+	       TYPE_RAISES_EXCEPTIONS (type));
+      /* Fall through.  */
+    default:;
+  }
+  return type;
+}
+
+tree
+coerce_delete_type (tree type)
+{
+  int e = 0;
+  tree args = TYPE_ARG_TYPES (type);
+
+  gcc_assert (TREE_CODE (type) == FUNCTION_TYPE);
+
+  if (!same_type_p (TREE_TYPE (type), void_type_node))
+    {
+      e = 1;
+      error ("%<operator delete%> must return type %qT", void_type_node);
+    }
+
+  if (!args || args == void_list_node
+      || !same_type_p (TREE_VALUE (args), ptr_type_node))
+    {
+      e = 2;
+      if (args && args != void_list_node)
+	args = TREE_CHAIN (args);
+      error ("%<operator delete%> takes type %qT as first parameter",
+	     ptr_type_node);
+    }
+  switch (e)
+  {
+    case 2:
+      args = tree_cons (NULL_TREE, ptr_type_node, args);
+      /* Fall through.  */
+    case 1:
+      type = build_exception_variant
+	      (build_function_type (void_type_node, args),
+	       TYPE_RAISES_EXCEPTIONS (type));
+      /* Fall through.  */
+    default:;
+  }
+
+  return type;
+}
+
+/* DECL is a VAR_DECL for a vtable: walk through the entries in the vtable
+   and mark them as needed.  */
+
+static void
+mark_vtable_entries (tree decl)
+{
+  tree fnaddr;
+  unsigned HOST_WIDE_INT idx;
+
+  FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (DECL_INITIAL (decl)),
+			      idx, fnaddr)
+    {
+      tree fn;
+
+      STRIP_NOPS (fnaddr);
+
+      if (TREE_CODE (fnaddr) != ADDR_EXPR
+	  && TREE_CODE (fnaddr) != FDESC_EXPR)
+	/* This entry is an offset: a virtual base class offset, a
+	   virtual call offset, an RTTI offset, etc.  */
+	continue;
+
+      fn = TREE_OPERAND (fnaddr, 0);
+      TREE_ADDRESSABLE (fn) = 1;
+      /* When we don't have vcall offsets, we output thunks whenever
+	 we output the vtables that contain them.  With vcall offsets,
+	 we know all the thunks we'll need when we emit a virtual
+	 function, so we emit the thunks there instead.  */
+      if (DECL_THUNK_P (fn))
+	use_thunk (fn, /*emit_p=*/0);
+      mark_used (fn);
+    }
+}
+
+/* Set DECL up to have the closest approximation of "initialized common"
+   linkage available.  */
+
+void
+comdat_linkage (tree decl)
+{
+  if (flag_weak)
+    make_decl_one_only (decl, cxx_comdat_group (decl));
+  else if (TREE_CODE (decl) == FUNCTION_DECL
+	   || (VAR_P (decl) && DECL_ARTIFICIAL (decl)))
+    /* We can just emit function and compiler-generated variables
+       statically; having multiple copies is (for the most part) only
+       a waste of space.
+
+       There are two correctness issues, however: the address of a
+       template instantiation with external linkage should be the
+       same, independent of what translation unit asks for the
+       address, and this will not hold when we emit multiple copies of
+       the function.  However, there's little else we can do.
+
+       Also, by default, the typeinfo implementation assumes that
+       there will be only one copy of the string used as the name for
+       each type.  Therefore, if weak symbols are unavailable, the
+       run-time library should perform a more conservative check; it
+       should perform a string comparison, rather than an address
+       comparison.  */
+    TREE_PUBLIC (decl) = 0;
+  else
+    {
+      /* Static data member template instantiations, however, cannot
+	 have multiple copies.  */
+      if (DECL_INITIAL (decl) == 0
+	  || DECL_INITIAL (decl) == error_mark_node)
+	DECL_COMMON (decl) = 1;
+      else if (EMPTY_CONSTRUCTOR_P (DECL_INITIAL (decl)))
+	{
+	  DECL_COMMON (decl) = 1;
+	  DECL_INITIAL (decl) = error_mark_node;
+	}
+      else if (!DECL_EXPLICIT_INSTANTIATION (decl))
+	{
+	  /* We can't do anything useful; leave vars for explicit
+	     instantiation.  */
+	  DECL_EXTERNAL (decl) = 1;
+	  DECL_NOT_REALLY_EXTERN (decl) = 0;
+	}
+    }
+
+  DECL_COMDAT (decl) = 1;
+}
+
+/* For win32 we also want to put explicit instantiations in
+   linkonce sections, so that they will be merged with implicit
+   instantiations; otherwise we get duplicate symbol errors.
+   For Darwin we do not want explicit instantiations to be
+   linkonce.  */
+
+void
+maybe_make_one_only (tree decl)
+{
+  /* We used to say that this was not necessary on targets that support weak
+     symbols, because the implicit instantiations will defer to the explicit
+     one.  However, that's not actually the case in SVR4; a strong definition
+     after a weak one is an error.  Also, not making explicit
+     instantiations one_only means that we can end up with two copies of
+     some template instantiations.  */
+  if (! flag_weak)
+    return;
+
+  /* We can't set DECL_COMDAT on functions, or cp_finish_file will think
+     we can get away with not emitting them if they aren't used.  We need
+     to for variables so that cp_finish_decl will update their linkage,
+     because their DECL_INITIAL may not have been set properly yet.  */
+
+  if (!TARGET_WEAK_NOT_IN_ARCHIVE_TOC
+      || (! DECL_EXPLICIT_INSTANTIATION (decl)
+	  && ! DECL_TEMPLATE_SPECIALIZATION (decl)))
+    {
+      make_decl_one_only (decl, cxx_comdat_group (decl));
+
+      if (VAR_P (decl))
+	{
+          varpool_node *node = varpool_node_for_decl (decl);
+	  DECL_COMDAT (decl) = 1;
+	  /* Mark it needed so we don't forget to emit it.  */
+          node->forced_by_abi = true;
+	  TREE_USED (decl) = 1;
+	}
+    }
+}
+
+/* Returns true iff DECL, a FUNCTION_DECL or VAR_DECL, has vague linkage.
+   This predicate will give the right answer during parsing of the
+   function, which other tests may not.  */
+
+bool
+vague_linkage_p (tree decl)
+{
+  /* Unfortunately, import_export_decl has not always been called
+     before the function is processed, so we cannot simply check
+     DECL_COMDAT.  */
+  return (DECL_COMDAT (decl)
+	  || (((TREE_CODE (decl) == FUNCTION_DECL
+		&& DECL_DECLARED_INLINE_P (decl))
+	       || (DECL_LANG_SPECIFIC (decl)
+		   && DECL_TEMPLATE_INSTANTIATION (decl)))
+	      && TREE_PUBLIC (decl)));
+}
+
+/* Determine whether or not we want to specifically import or export CTYPE,
+   using various heuristics.  */
+
+static void
+import_export_class (tree ctype)
+{
+  /* -1 for imported, 1 for exported.  */
+  int import_export = 0;
+
+  /* It only makes sense to call this function at EOF.  The reason is
+     that this function looks at whether or not the first non-inline
+     non-abstract virtual member function has been defined in this
+     translation unit.  But, we can't possibly know that until we've
+     seen the entire translation unit.  */
+  gcc_assert (at_eof);
+
+  if (CLASSTYPE_INTERFACE_KNOWN (ctype))
+    return;
+
+  /* If MULTIPLE_SYMBOL_SPACES is set and we saw a #pragma interface,
+     we will have CLASSTYPE_INTERFACE_ONLY set but not
+     CLASSTYPE_INTERFACE_KNOWN.  In that case, we don't want to use this
+     heuristic because someone will supply a #pragma implementation
+     elsewhere, and deducing it here would produce a conflict.  */
+  if (CLASSTYPE_INTERFACE_ONLY (ctype))
+    return;
+
+  if (lookup_attribute ("dllimport", TYPE_ATTRIBUTES (ctype)))
+    import_export = -1;
+  else if (lookup_attribute ("dllexport", TYPE_ATTRIBUTES (ctype)))
+    import_export = 1;
+  else if (CLASSTYPE_IMPLICIT_INSTANTIATION (ctype)
+	   && !flag_implicit_templates)
+    /* For a template class, without -fimplicit-templates, check the
+       repository.  If the virtual table is assigned to this
+       translation unit, then export the class; otherwise, import
+       it.  */
+      import_export = repo_export_class_p (ctype) ? 1 : -1;
+  else if (TYPE_POLYMORPHIC_P (ctype))
+    {
+      /* The ABI specifies that the virtual table and associated
+	 information are emitted with the key method, if any.  */
+      tree method = CLASSTYPE_KEY_METHOD (ctype);
+      /* If weak symbol support is not available, then we must be
+	 careful not to emit the vtable when the key function is
+	 inline.  An inline function can be defined in multiple
+	 translation units.  If we were to emit the vtable in each
+	 translation unit containing a definition, we would get
+	 multiple definition errors at link-time.  */
+      if (method && (flag_weak || ! DECL_DECLARED_INLINE_P (method)))
+	import_export = (DECL_REALLY_EXTERN (method) ? -1 : 1);
+    }
+
+  /* When MULTIPLE_SYMBOL_SPACES is set, we cannot count on seeing
+     a definition anywhere else.  */
+  if (MULTIPLE_SYMBOL_SPACES && import_export == -1)
+    import_export = 0;
+
+  /* Allow back ends the chance to overrule the decision.  */
+  if (targetm.cxx.import_export_class)
+    import_export = targetm.cxx.import_export_class (ctype, import_export);
+
+  if (import_export)
+    {
+      SET_CLASSTYPE_INTERFACE_KNOWN (ctype);
+      CLASSTYPE_INTERFACE_ONLY (ctype) = (import_export < 0);
+    }
+}
+
+/* Return true if VAR has already been provided to the back end; in that
+   case VAR should not be modified further by the front end.  */
+static bool
+var_finalized_p (tree var)
+{
+  return varpool_node_for_decl (var)->definition;
+}
+
+/* DECL is a VAR_DECL or FUNCTION_DECL which, for whatever reason,
+   must be emitted in this translation unit.  Mark it as such.  */
+
+void
+mark_needed (tree decl)
+{
+  TREE_USED (decl) = 1;
+  if (TREE_CODE (decl) == FUNCTION_DECL)
+    {
+      /* Extern inline functions don't become needed when referenced.
+	 If we know a method will be emitted in other TU and no new
+	 functions can be marked reachable, just use the external
+	 definition.  */
+      struct cgraph_node *node = cgraph_get_create_node (decl);
+      node->forced_by_abi = true;
+    }
+  else if (TREE_CODE (decl) == VAR_DECL)
+    {
+      varpool_node *node = varpool_node_for_decl (decl);
+      /* C++ frontend use mark_decl_references to force COMDAT variables
+         to be output that might appear dead otherwise.  */
+      node->forced_by_abi = true;
+    }
+}
+
+/* DECL is either a FUNCTION_DECL or a VAR_DECL.  This function
+   returns true if a definition of this entity should be provided in
+   this object file.  Callers use this function to determine whether
+   or not to let the back end know that a definition of DECL is
+   available in this translation unit.  */
+
+bool
+decl_needed_p (tree decl)
+{
+  gcc_assert (VAR_OR_FUNCTION_DECL_P (decl));
+  /* This function should only be called at the end of the translation
+     unit.  We cannot be sure of whether or not something will be
+     COMDAT until that point.  */
+  gcc_assert (at_eof);
+
+  /* All entities with external linkage that are not COMDAT should be
+     emitted; they may be referred to from other object files.  */
+  if (TREE_PUBLIC (decl) && !DECL_COMDAT (decl))
+    return true;
+  /* If this entity was used, let the back end see it; it will decide
+     whether or not to emit it into the object file.  */
+  if (TREE_USED (decl))
+      return true;
+  /* Functions marked "dllexport" must be emitted so that they are
+     visible to other DLLs.  */
+  if (flag_keep_inline_dllexport
+      && lookup_attribute ("dllexport", DECL_ATTRIBUTES (decl)))
+    return true;
+  /* Otherwise, DECL does not need to be emitted -- yet.  A subsequent
+     reference to DECL might cause it to be emitted later.  */
+  return false;
+}
+
+/* If necessary, write out the vtables for the dynamic class CTYPE.
+   Returns true if any vtables were emitted.  */
+
+static bool
+maybe_emit_vtables (tree ctype)
+{
+  tree vtbl;
+  tree primary_vtbl;
+  int needed = 0;
+  varpool_node *current = NULL, *last = NULL;
+
+  /* If the vtables for this class have already been emitted there is
+     nothing more to do.  */
+  primary_vtbl = CLASSTYPE_VTABLES (ctype);
+  if (var_finalized_p (primary_vtbl))
+    return false;
+  /* Ignore dummy vtables made by get_vtable_decl.  */
+  if (TREE_TYPE (primary_vtbl) == void_type_node)
+    return false;
+
+  /* On some targets, we cannot determine the key method until the end
+     of the translation unit -- which is when this function is
+     called.  */
+  if (!targetm.cxx.key_method_may_be_inline ())
+    determine_key_method (ctype);
+
+  /* See if any of the vtables are needed.  */
+  for (vtbl = CLASSTYPE_VTABLES (ctype); vtbl; vtbl = DECL_CHAIN (vtbl))
+    {
+      import_export_decl (vtbl);
+      if (DECL_NOT_REALLY_EXTERN (vtbl) && decl_needed_p (vtbl))
+	needed = 1;
+    }
+  if (!needed)
+    {
+      /* If the references to this class' vtables are optimized away,
+	 still emit the appropriate debugging information.  See
+	 dfs_debug_mark.  */
+      if (DECL_COMDAT (primary_vtbl)
+	  && CLASSTYPE_DEBUG_REQUESTED (ctype))
+	note_debug_info_needed (ctype);
+      return false;
+    }
+
+  /* The ABI requires that we emit all of the vtables if we emit any
+     of them.  */
+  for (vtbl = CLASSTYPE_VTABLES (ctype); vtbl; vtbl = DECL_CHAIN (vtbl))
+    {
+      /* Mark entities references from the virtual table as used.  */
+      mark_vtable_entries (vtbl);
+
+      if (TREE_TYPE (DECL_INITIAL (vtbl)) == 0)
+	{
+	  vec<tree, va_gc> *cleanups = NULL;
+	  tree expr = store_init_value (vtbl, DECL_INITIAL (vtbl), &cleanups,
+					LOOKUP_NORMAL);
+
+	  /* It had better be all done at compile-time.  */
+	  gcc_assert (!expr && !cleanups);
+	}
+
+      /* Write it out.  */
+      DECL_EXTERNAL (vtbl) = 0;
+      rest_of_decl_compilation (vtbl, 1, 1);
+
+      /* Because we're only doing syntax-checking, we'll never end up
+	 actually marking the variable as written.  */
+      if (flag_syntax_only)
+	TREE_ASM_WRITTEN (vtbl) = 1;
+      else if (DECL_ONE_ONLY (vtbl))
+	{
+	  current = varpool_node_for_decl (vtbl);
+	  if (last)
+	    symtab_add_to_same_comdat_group (current, last);
+	  last = current;
+	}
+    }
+
+  /* Since we're writing out the vtable here, also write the debug
+     info.  */
+  note_debug_info_needed (ctype);
+
+  return true;
+}
+
+/* A special return value from type_visibility meaning internal
+   linkage.  */
+
+enum { VISIBILITY_ANON = VISIBILITY_INTERNAL+1 };
+
+/* walk_tree helper function for type_visibility.  */
+
+static tree
+min_vis_r (tree *tp, int *walk_subtrees, void *data)
+{
+  int *vis_p = (int *)data;
+  if (! TYPE_P (*tp))
+    {
+      *walk_subtrees = 0;
+    }
+  else if (OVERLOAD_TYPE_P (*tp)
+	   && !TREE_PUBLIC (TYPE_MAIN_DECL (*tp)))
+    {
+      *vis_p = VISIBILITY_ANON;
+      return *tp;
+    }
+  else if (CLASS_TYPE_P (*tp)
+	   && CLASSTYPE_VISIBILITY (*tp) > *vis_p)
+    *vis_p = CLASSTYPE_VISIBILITY (*tp);
+  return NULL;
+}
+
+/* Returns the visibility of TYPE, which is the minimum visibility of its
+   component types.  */
+
+static int
+type_visibility (tree type)
+{
+  int vis = VISIBILITY_DEFAULT;
+  cp_walk_tree_without_duplicates (&type, min_vis_r, &vis);
+  return vis;
+}
+
+/* Limit the visibility of DECL to VISIBILITY, if not explicitly
+   specified (or if VISIBILITY is static).  If TMPL is true, this
+   constraint is for a template argument, and takes precedence
+   over explicitly-specified visibility on the template.  */
+
+static void
+constrain_visibility (tree decl, int visibility, bool tmpl)
+{
+  if (visibility == VISIBILITY_ANON)
+    {
+      /* extern "C" declarations aren't affected by the anonymous
+	 namespace.  */
+      if (!DECL_EXTERN_C_P (decl))
+	{
+	  TREE_PUBLIC (decl) = 0;
+	  DECL_WEAK (decl) = 0;
+	  DECL_COMMON (decl) = 0;
+	  DECL_COMDAT_GROUP (decl) = NULL_TREE;
+	  DECL_INTERFACE_KNOWN (decl) = 1;
+	  if (DECL_LANG_SPECIFIC (decl))
+	    DECL_NOT_REALLY_EXTERN (decl) = 1;
+	}
+    }
+  else if (visibility > DECL_VISIBILITY (decl)
+	   && (tmpl || !DECL_VISIBILITY_SPECIFIED (decl)))
+    {
+      DECL_VISIBILITY (decl) = (enum symbol_visibility) visibility;
+      /* This visibility was not specified.  */
+      DECL_VISIBILITY_SPECIFIED (decl) = false;
+    }
+}
+
+/* Constrain the visibility of DECL based on the visibility of its template
+   arguments.  */
+
+static void
+constrain_visibility_for_template (tree decl, tree targs)
+{
+  /* If this is a template instantiation, check the innermost
+     template args for visibility constraints.  The outer template
+     args are covered by the class check.  */
+  tree args = INNERMOST_TEMPLATE_ARGS (targs);
+  int i;
+  for (i = TREE_VEC_LENGTH (args); i > 0; --i)
+    {
+      int vis = 0;
+
+      tree arg = TREE_VEC_ELT (args, i-1);
+      if (TYPE_P (arg))
+	vis = type_visibility (arg);
+      else if (TREE_TYPE (arg) && POINTER_TYPE_P (TREE_TYPE (arg)))
+	{
+	  STRIP_NOPS (arg);
+	  if (TREE_CODE (arg) == ADDR_EXPR)
+	    arg = TREE_OPERAND (arg, 0);
+	  if (VAR_OR_FUNCTION_DECL_P (arg))
+	    {
+	      if (! TREE_PUBLIC (arg))
+		vis = VISIBILITY_ANON;
+	      else
+		vis = DECL_VISIBILITY (arg);
+	    }
+	}
+      if (vis)
+	constrain_visibility (decl, vis, true);
+    }
+}
+
+/* Like c_determine_visibility, but with additional C++-specific
+   behavior.
+
+   Function-scope entities can rely on the function's visibility because
+   it is set in start_preparsed_function.
+
+   Class-scope entities cannot rely on the class's visibility until the end
+   of the enclosing class definition.
+
+   Note that because namespaces have multiple independent definitions,
+   namespace visibility is handled elsewhere using the #pragma visibility
+   machinery rather than by decorating the namespace declaration.
+
+   The goal is for constraints from the type to give a diagnostic, and
+   other constraints to be applied silently.  */
+
+void
+determine_visibility (tree decl)
+{
+  tree class_type = NULL_TREE;
+  bool use_template;
+  bool orig_visibility_specified;
+  enum symbol_visibility orig_visibility;
+
+  /* Remember that all decls get VISIBILITY_DEFAULT when built.  */
+
+  /* Only relevant for names with external linkage.  */
+  if (!TREE_PUBLIC (decl))
+    return;
+
+  /* Cloned constructors and destructors get the same visibility as
+     the underlying function.  That should be set up in
+     maybe_clone_body.  */
+  gcc_assert (!DECL_CLONED_FUNCTION_P (decl));
+
+  orig_visibility_specified = DECL_VISIBILITY_SPECIFIED (decl);
+  orig_visibility = DECL_VISIBILITY (decl);
+
+  if (TREE_CODE (decl) == TYPE_DECL)
+    {
+      if (CLASS_TYPE_P (TREE_TYPE (decl)))
+	use_template = CLASSTYPE_USE_TEMPLATE (TREE_TYPE (decl));
+      else if (TYPE_TEMPLATE_INFO (TREE_TYPE (decl)))
+	use_template = 1;
+      else
+	use_template = 0;
+    }
+  else if (DECL_LANG_SPECIFIC (decl))
+    use_template = DECL_USE_TEMPLATE (decl);
+  else
+    use_template = 0;
+
+  /* If DECL is a member of a class, visibility specifiers on the
+     class can influence the visibility of the DECL.  */
+  if (DECL_CLASS_SCOPE_P (decl))
+    class_type = DECL_CONTEXT (decl);
+  else
+    {
+      /* Not a class member.  */
+
+      /* Virtual tables have DECL_CONTEXT set to their associated class,
+	 so they are automatically handled above.  */
+      gcc_assert (!VAR_P (decl)
+		  || !DECL_VTABLE_OR_VTT_P (decl));
+
+      if (DECL_FUNCTION_SCOPE_P (decl) && ! DECL_VISIBILITY_SPECIFIED (decl))
+	{
+	  /* Local statics and classes get the visibility of their
+	     containing function by default, except that
+	     -fvisibility-inlines-hidden doesn't affect them.  */
+	  tree fn = DECL_CONTEXT (decl);
+	  if (DECL_VISIBILITY_SPECIFIED (fn))
+	    {
+	      DECL_VISIBILITY (decl) = DECL_VISIBILITY (fn);
+	      DECL_VISIBILITY_SPECIFIED (decl) = 
+		DECL_VISIBILITY_SPECIFIED (fn);
+	    }
+	  else
+	    {
+	      if (DECL_CLASS_SCOPE_P (fn))
+		determine_visibility_from_class (decl, DECL_CONTEXT (fn));
+	      else if (determine_hidden_inline (fn))
+		{
+		  DECL_VISIBILITY (decl) = default_visibility;
+		  DECL_VISIBILITY_SPECIFIED (decl) =
+		    visibility_options.inpragma;
+		}
+	      else
+		{
+	          DECL_VISIBILITY (decl) = DECL_VISIBILITY (fn);
+	          DECL_VISIBILITY_SPECIFIED (decl) =
+		    DECL_VISIBILITY_SPECIFIED (fn);
+		}
+	    }
+
+	  /* Local classes in templates have CLASSTYPE_USE_TEMPLATE set,
+	     but have no TEMPLATE_INFO, so don't try to check it.  */
+	  use_template = 0;
+	}
+      else if (VAR_P (decl) && DECL_TINFO_P (decl)
+	       && flag_visibility_ms_compat)
+	{
+	  /* Under -fvisibility-ms-compat, types are visible by default,
+	     even though their contents aren't.  */
+	  tree underlying_type = TREE_TYPE (DECL_NAME (decl));
+	  int underlying_vis = type_visibility (underlying_type);
+	  if (underlying_vis == VISIBILITY_ANON
+	      || (CLASS_TYPE_P (underlying_type)
+		  && CLASSTYPE_VISIBILITY_SPECIFIED (underlying_type)))
+	    constrain_visibility (decl, underlying_vis, false);
+	  else
+	    DECL_VISIBILITY (decl) = VISIBILITY_DEFAULT;
+	}
+      else if (VAR_P (decl) && DECL_TINFO_P (decl))
+	{
+	  /* tinfo visibility is based on the type it's for.  */
+	  constrain_visibility
+	    (decl, type_visibility (TREE_TYPE (DECL_NAME (decl))), false);
+
+	  /* Give the target a chance to override the visibility associated
+	     with DECL.  */
+	  if (TREE_PUBLIC (decl)
+	      && !DECL_REALLY_EXTERN (decl)
+	      && CLASS_TYPE_P (TREE_TYPE (DECL_NAME (decl)))
+	      && !CLASSTYPE_VISIBILITY_SPECIFIED (TREE_TYPE (DECL_NAME (decl))))
+	    targetm.cxx.determine_class_data_visibility (decl);
+	}
+      else if (use_template)
+	/* Template instantiations and specializations get visibility based
+	   on their template unless they override it with an attribute.  */;
+      else if (! DECL_VISIBILITY_SPECIFIED (decl))
+	{
+          if (determine_hidden_inline (decl))
+	    DECL_VISIBILITY (decl) = VISIBILITY_HIDDEN;
+	  else
+            {
+	      /* Set default visibility to whatever the user supplied with
+	         #pragma GCC visibility or a namespace visibility attribute.  */
+	      DECL_VISIBILITY (decl) = default_visibility;
+	      DECL_VISIBILITY_SPECIFIED (decl) = visibility_options.inpragma;
+            }
+	}
+    }
+
+  if (use_template)
+    {
+      /* If the specialization doesn't specify visibility, use the
+	 visibility from the template.  */
+      tree tinfo = (TREE_CODE (decl) == TYPE_DECL
+		    ? TYPE_TEMPLATE_INFO (TREE_TYPE (decl))
+		    : DECL_TEMPLATE_INFO (decl));
+      tree args = TI_ARGS (tinfo);
+      tree attribs = (TREE_CODE (decl) == TYPE_DECL
+		      ? TYPE_ATTRIBUTES (TREE_TYPE (decl))
+		      : DECL_ATTRIBUTES (decl));
+      
+      if (args != error_mark_node)
+	{
+	  tree pattern = DECL_TEMPLATE_RESULT (TI_TEMPLATE (tinfo));
+
+	  if (!DECL_VISIBILITY_SPECIFIED (decl))
+	    {
+	      if (!DECL_VISIBILITY_SPECIFIED (pattern)
+		  && determine_hidden_inline (decl))
+		DECL_VISIBILITY (decl) = VISIBILITY_HIDDEN;
+	      else
+		{
+	          DECL_VISIBILITY (decl) = DECL_VISIBILITY (pattern);
+	          DECL_VISIBILITY_SPECIFIED (decl)
+		    = DECL_VISIBILITY_SPECIFIED (pattern);
+		}
+	    }
+
+	  if (args
+	      /* Template argument visibility outweighs #pragma or namespace
+		 visibility, but not an explicit attribute.  */
+	      && !lookup_attribute ("visibility", attribs))
+	    {
+	      int depth = TMPL_ARGS_DEPTH (args);
+	      if (DECL_VISIBILITY_SPECIFIED (decl))
+		{
+		  /* A class template member with explicit visibility
+		     overrides the class visibility, so we need to apply
+		     all the levels of template args directly.  */
+		  int i;
+		  for (i = 1; i <= depth; ++i)
+		    {
+		      tree lev = TMPL_ARGS_LEVEL (args, i);
+		      constrain_visibility_for_template (decl, lev);
+		    }
+		}
+	      else if (PRIMARY_TEMPLATE_P (TI_TEMPLATE (tinfo)))
+		/* Limit visibility based on its template arguments.  */
+		constrain_visibility_for_template (decl, args);
+	    }
+	}
+    }
+
+  if (class_type)
+    determine_visibility_from_class (decl, class_type);
+
+  if (decl_anon_ns_mem_p (decl))
+    /* Names in an anonymous namespace get internal linkage.
+       This might change once we implement export.  */
+    constrain_visibility (decl, VISIBILITY_ANON, false);
+  else if (TREE_CODE (decl) != TYPE_DECL)
+    {
+      /* Propagate anonymity from type to decl.  */
+      int tvis = type_visibility (TREE_TYPE (decl));
+      if (tvis == VISIBILITY_ANON
+	  || ! DECL_VISIBILITY_SPECIFIED (decl))
+	constrain_visibility (decl, tvis, false);
+    }
+  else if (no_linkage_check (TREE_TYPE (decl), /*relaxed_p=*/true))
+    /* DR 757: A type without linkage shall not be used as the type of a
+       variable or function with linkage, unless
+       o the variable or function has extern "C" linkage (7.5 [dcl.link]), or
+       o the variable or function is not used (3.2 [basic.def.odr]) or is
+       defined in the same translation unit.
+
+       Since non-extern "C" decls need to be defined in the same
+       translation unit, we can make the type internal.  */
+    constrain_visibility (decl, VISIBILITY_ANON, false);
+
+  /* If visibility changed and DECL already has DECL_RTL, ensure
+     symbol flags are updated.  */
+  if ((DECL_VISIBILITY (decl) != orig_visibility
+       || DECL_VISIBILITY_SPECIFIED (decl) != orig_visibility_specified)
+      && ((VAR_P (decl) && TREE_STATIC (decl))
+	  || TREE_CODE (decl) == FUNCTION_DECL)
+      && DECL_RTL_SET_P (decl))
+    make_decl_rtl (decl);
+}
+
+/* By default, static data members and function members receive
+   the visibility of their containing class.  */
+
+static void
+determine_visibility_from_class (tree decl, tree class_type)
+{
+  if (DECL_VISIBILITY_SPECIFIED (decl))
+    return;
+
+  if (determine_hidden_inline (decl))
+    DECL_VISIBILITY (decl) = VISIBILITY_HIDDEN;
+  else
+    {
+      /* Default to the class visibility.  */
+      DECL_VISIBILITY (decl) = CLASSTYPE_VISIBILITY (class_type);
+      DECL_VISIBILITY_SPECIFIED (decl)
+	= CLASSTYPE_VISIBILITY_SPECIFIED (class_type);
+    }
+
+  /* Give the target a chance to override the visibility associated
+     with DECL.  */
+  if (VAR_P (decl)
+      && (DECL_TINFO_P (decl)
+	  || (DECL_VTABLE_OR_VTT_P (decl)
+	      /* Construction virtual tables are not exported because
+		 they cannot be referred to from other object files;
+		 their name is not standardized by the ABI.  */
+	      && !DECL_CONSTRUCTION_VTABLE_P (decl)))
+      && TREE_PUBLIC (decl)
+      && !DECL_REALLY_EXTERN (decl)
+      && !CLASSTYPE_VISIBILITY_SPECIFIED (class_type))
+    targetm.cxx.determine_class_data_visibility (decl);
+}
+
+/* Returns true iff DECL is an inline that should get hidden visibility
+   because of -fvisibility-inlines-hidden.  */
+
+static bool
+determine_hidden_inline (tree decl)
+{
+  return (visibility_options.inlines_hidden
+	  /* Don't do this for inline templates; specializations might not be
+	     inline, and we don't want them to inherit the hidden
+	     visibility.  We'll set it here for all inline instantiations.  */
+	  && !processing_template_decl
+	  && TREE_CODE (decl) == FUNCTION_DECL
+	  && DECL_DECLARED_INLINE_P (decl)
+	  && (! DECL_LANG_SPECIFIC (decl)
+	      || ! DECL_EXPLICIT_INSTANTIATION (decl)));
+}
+
+/* Constrain the visibility of a class TYPE based on the visibility of its
+   field types.  Warn if any fields require lesser visibility.  */
+
+void
+constrain_class_visibility (tree type)
+{
+  tree binfo;
+  tree t;
+  int i;
+
+  int vis = type_visibility (type);
+
+  if (vis == VISIBILITY_ANON
+      || DECL_IN_SYSTEM_HEADER (TYPE_MAIN_DECL (type)))
+    return;
+
+  /* Don't warn about visibility if the class has explicit visibility.  */
+  if (CLASSTYPE_VISIBILITY_SPECIFIED (type))
+    vis = VISIBILITY_INTERNAL;
+
+  for (t = TYPE_FIELDS (type); t; t = DECL_CHAIN (t))
+    if (TREE_CODE (t) == FIELD_DECL && TREE_TYPE (t) != error_mark_node)
+      {
+	tree ftype = strip_pointer_or_array_types (TREE_TYPE (t));
+	int subvis = type_visibility (ftype);
+
+	if (subvis == VISIBILITY_ANON)
+	  {
+	    if (!in_main_input_context ())
+	      warning (0, "\
+%qT has a field %qD whose type uses the anonymous namespace",
+		       type, t);
+	  }
+	else if (MAYBE_CLASS_TYPE_P (ftype)
+		 && vis < VISIBILITY_HIDDEN
+		 && subvis >= VISIBILITY_HIDDEN)
+	  warning (OPT_Wattributes, "\
+%qT declared with greater visibility than the type of its field %qD",
+		   type, t);
+      }
+
+  binfo = TYPE_BINFO (type);
+  for (i = 0; BINFO_BASE_ITERATE (binfo, i, t); ++i)
+    {
+      int subvis = type_visibility (TREE_TYPE (t));
+
+      if (subvis == VISIBILITY_ANON)
+        {
+	  if (!in_main_input_context())
+	    warning (0, "\
+%qT has a base %qT whose type uses the anonymous namespace",
+		     type, TREE_TYPE (t));
+	}
+      else if (vis < VISIBILITY_HIDDEN
+	       && subvis >= VISIBILITY_HIDDEN)
+	warning (OPT_Wattributes, "\
+%qT declared with greater visibility than its base %qT",
+		 type, TREE_TYPE (t));
+    }
+}
+
+/* Functions for adjusting the visibility of a tagged type and its nested
+   types and declarations when it gets a name for linkage purposes from a
+   typedef.  */
+
+static void bt_reset_linkage_1 (binding_entry, void *);
+static void bt_reset_linkage_2 (binding_entry, void *);
+
+/* First reset the visibility of all the types.  */
+
+static void
+reset_type_linkage_1 (tree type)
+{
+  set_linkage_according_to_type (type, TYPE_MAIN_DECL (type));
+  if (CLASS_TYPE_P (type))
+    binding_table_foreach (CLASSTYPE_NESTED_UTDS (type),
+			   bt_reset_linkage_1, NULL);
+}
+static void
+bt_reset_linkage_1 (binding_entry b, void */*data*/)
+{
+  reset_type_linkage_1 (b->type);
+}
+
+/* Then reset the visibility of any static data members or member
+   functions that use those types.  */
+
+static void
+reset_decl_linkage (tree decl)
+{
+  if (TREE_PUBLIC (decl))
+    return;
+  if (DECL_CLONED_FUNCTION_P (decl))
+    return;
+  TREE_PUBLIC (decl) = true;
+  DECL_INTERFACE_KNOWN (decl) = false;
+  determine_visibility (decl);
+  tentative_decl_linkage (decl);
+}
+static void
+reset_type_linkage_2 (tree type)
+{
+  if (CLASS_TYPE_P (type))
+    {
+      if (tree vt = CLASSTYPE_VTABLES (type))
+	{
+	  tree name = mangle_vtbl_for_type (type);
+	  DECL_NAME (vt) = name;
+	  SET_DECL_ASSEMBLER_NAME (vt, name);
+	  reset_decl_linkage (vt);
+	}
+      if (tree ti = CLASSTYPE_TYPEINFO_VAR (type))
+	{
+	  tree name = mangle_typeinfo_for_type (type);
+	  DECL_NAME (ti) = name;
+	  SET_DECL_ASSEMBLER_NAME (ti, name);
+	  TREE_TYPE (name) = type;
+	  reset_decl_linkage (ti);
+	}
+      for (tree m = TYPE_FIELDS (type); m; m = DECL_CHAIN (m))
+	if (TREE_CODE (m) == VAR_DECL)
+	  reset_decl_linkage (m);
+      for (tree m = TYPE_METHODS (type); m; m = DECL_CHAIN (m))
+	reset_decl_linkage (m);
+      binding_table_foreach (CLASSTYPE_NESTED_UTDS (type),
+			     bt_reset_linkage_2, NULL);
+    }
+}
+static void
+bt_reset_linkage_2 (binding_entry b, void */*data*/)
+{
+  reset_type_linkage_2 (b->type);
+}
+void
+reset_type_linkage (tree type)
+{
+  reset_type_linkage_1 (type);
+  reset_type_linkage_2 (type);
+}
+
+/* Set up our initial idea of what the linkage of DECL should be.  */
+
+void
+tentative_decl_linkage (tree decl)
+{
+  if (DECL_INTERFACE_KNOWN (decl))
+    /* We've already made a decision as to how this function will
+       be handled.  */;
+  else if (vague_linkage_p (decl))
+    {
+      if (TREE_CODE (decl) == FUNCTION_DECL
+	  && decl_defined_p (decl))
+	{
+	  DECL_EXTERNAL (decl) = 1;
+	  DECL_NOT_REALLY_EXTERN (decl) = 1;
+	  note_vague_linkage_fn (decl);
+	  /* 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_DECLARED_INLINE_P (decl)
+	      && (!DECL_IMPLICIT_INSTANTIATION (decl)
+		  || DECL_DEFAULTED_FN (decl)))
+	    {
+	      /* This function must have external linkage, as
+		 otherwise DECL_INTERFACE_KNOWN would have been
+		 set.  */
+	      gcc_assert (TREE_PUBLIC (decl));
+	      comdat_linkage (decl);
+	      DECL_INTERFACE_KNOWN (decl) = 1;
+	    }
+	}
+      else if (TREE_CODE (decl) == VAR_DECL)
+	maybe_commonize_var (decl);
+    }
+}
+
+/* DECL is a FUNCTION_DECL or VAR_DECL.  If the object file linkage
+   for DECL has not already been determined, do so now by setting
+   DECL_EXTERNAL, DECL_COMDAT and other related flags.  Until this
+   function is called entities with vague linkage whose definitions
+   are available must have TREE_PUBLIC set.
+
+   If this function decides to place DECL in COMDAT, it will set
+   appropriate flags -- but will not clear DECL_EXTERNAL.  It is up to
+   the caller to decide whether or not to clear DECL_EXTERNAL.  Some
+   callers defer that decision until it is clear that DECL is actually
+   required.  */
+
+void
+import_export_decl (tree decl)
+{
+  int emit_p;
+  bool comdat_p;
+  bool import_p;
+  tree class_type = NULL_TREE;
+
+  if (DECL_INTERFACE_KNOWN (decl))
+    return;
+
+  /* We cannot determine what linkage to give to an entity with vague
+     linkage until the end of the file.  For example, a virtual table
+     for a class will be defined if and only if the key method is
+     defined in this translation unit.  As a further example, consider
+     that when compiling a translation unit that uses PCH file with
+     "-frepo" it would be incorrect to make decisions about what
+     entities to emit when building the PCH; those decisions must be
+     delayed until the repository information has been processed.  */
+  gcc_assert (at_eof);
+  /* Object file linkage for explicit instantiations is handled in
+     mark_decl_instantiated.  For static variables in functions with
+     vague linkage, maybe_commonize_var is used.
+
+     Therefore, the only declarations that should be provided to this
+     function are those with external linkage that are:
+
+     * implicit instantiations of function templates
+
+     * inline function
+
+     * implicit instantiations of static data members of class
+       templates
+
+     * virtual tables
+
+     * typeinfo objects
+
+     Furthermore, all entities that reach this point must have a
+     definition available in this translation unit.
+
+     The following assertions check these conditions.  */
+  gcc_assert (VAR_OR_FUNCTION_DECL_P (decl));
+  /* Any code that creates entities with TREE_PUBLIC cleared should
+     also set DECL_INTERFACE_KNOWN.  */
+  gcc_assert (TREE_PUBLIC (decl));
+  if (TREE_CODE (decl) == FUNCTION_DECL)
+    gcc_assert (DECL_IMPLICIT_INSTANTIATION (decl)
+		|| DECL_FRIEND_PSEUDO_TEMPLATE_INSTANTIATION (decl)
+		|| DECL_DECLARED_INLINE_P (decl));
+  else
+    gcc_assert (DECL_IMPLICIT_INSTANTIATION (decl)
+		|| DECL_VTABLE_OR_VTT_P (decl)
+		|| DECL_TINFO_P (decl));
+  /* Check that a definition of DECL is available in this translation
+     unit.  */
+  gcc_assert (!DECL_REALLY_EXTERN (decl));
+
+  /* Assume that DECL will not have COMDAT linkage.  */
+  comdat_p = false;
+  /* Assume that DECL will not be imported into this translation
+     unit.  */
+  import_p = false;
+
+  /* See if the repository tells us whether or not to emit DECL in
+     this translation unit.  */
+  emit_p = repo_emit_p (decl);
+  if (emit_p == 0)
+    import_p = true;
+  else if (emit_p == 1)
+    {
+      /* The repository indicates that this entity should be defined
+	 here.  Make sure the back end honors that request.  */
+      if (VAR_P (decl))
+	mark_needed (decl);
+      else if (DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (decl)
+	       || DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (decl))
+	{
+	  tree clone;
+	  FOR_EACH_CLONE (clone, decl)
+	    mark_needed (clone);
+	}
+      else
+	mark_needed (decl);
+      /* Output the definition as an ordinary strong definition.  */
+      DECL_EXTERNAL (decl) = 0;
+      DECL_INTERFACE_KNOWN (decl) = 1;
+      return;
+    }
+
+  if (import_p)
+    /* We have already decided what to do with this DECL; there is no
+       need to check anything further.  */
+    ;
+  else if (VAR_P (decl) && DECL_VTABLE_OR_VTT_P (decl))
+    {
+      class_type = DECL_CONTEXT (decl);
+      import_export_class (class_type);
+      if (TYPE_FOR_JAVA (class_type))
+	import_p = true;
+      else if (CLASSTYPE_INTERFACE_KNOWN (class_type)
+	       && CLASSTYPE_INTERFACE_ONLY (class_type))
+	import_p = true;
+      else if ((!flag_weak || TARGET_WEAK_NOT_IN_ARCHIVE_TOC)
+	       && !CLASSTYPE_USE_TEMPLATE (class_type)
+	       && CLASSTYPE_KEY_METHOD (class_type)
+	       && !DECL_DECLARED_INLINE_P (CLASSTYPE_KEY_METHOD (class_type)))
+	/* The ABI requires that all virtual tables be emitted with
+	   COMDAT linkage.  However, on systems where COMDAT symbols
+	   don't show up in the table of contents for a static
+	   archive, or on systems without weak symbols (where we
+	   approximate COMDAT linkage by using internal linkage), the
+	   linker will report errors about undefined symbols because
+	   it will not see the virtual table definition.  Therefore,
+	   in the case that we know that the virtual table will be
+	   emitted in only one translation unit, we make the virtual
+	   table an ordinary definition with external linkage.  */
+	DECL_EXTERNAL (decl) = 0;
+      else if (CLASSTYPE_INTERFACE_KNOWN (class_type))
+	{
+	  /* CLASS_TYPE is being exported from this translation unit,
+	     so DECL should be defined here.  */
+	  if (!flag_weak && CLASSTYPE_EXPLICIT_INSTANTIATION (class_type))
+	    /* If a class is declared in a header with the "extern
+	       template" extension, then it will not be instantiated,
+	       even in translation units that would normally require
+	       it.  Often such classes are explicitly instantiated in
+	       one translation unit.  Therefore, the explicit
+	       instantiation must be made visible to other translation
+	       units.  */
+	    DECL_EXTERNAL (decl) = 0;
+	  else
+	    {
+	      /* The generic C++ ABI says that class data is always
+		 COMDAT, even if there is a key function.  Some
+		 variants (e.g., the ARM EABI) says that class data
+		 only has COMDAT linkage if the class data might be
+		 emitted in more than one translation unit.  When the
+		 key method can be inline and is inline, we still have
+		 to arrange for comdat even though
+		 class_data_always_comdat is false.  */
+	      if (!CLASSTYPE_KEY_METHOD (class_type)
+		  || DECL_DECLARED_INLINE_P (CLASSTYPE_KEY_METHOD (class_type))
+		  || targetm.cxx.class_data_always_comdat ())
+		{
+		  /* The ABI requires COMDAT linkage.  Normally, we
+		     only emit COMDAT things when they are needed;
+		     make sure that we realize that this entity is
+		     indeed needed.  */
+		  comdat_p = true;
+		  mark_needed (decl);
+		}
+	    }
+	}
+      else if (!flag_implicit_templates
+	       && CLASSTYPE_IMPLICIT_INSTANTIATION (class_type))
+	import_p = true;
+      else
+	comdat_p = true;
+    }
+  else if (VAR_P (decl) && DECL_TINFO_P (decl))
+    {
+      tree type = TREE_TYPE (DECL_NAME (decl));
+      if (CLASS_TYPE_P (type))
+	{
+	  class_type = type;
+	  import_export_class (type);
+	  if (CLASSTYPE_INTERFACE_KNOWN (type)
+	      && TYPE_POLYMORPHIC_P (type)
+	      && CLASSTYPE_INTERFACE_ONLY (type)
+	      /* If -fno-rtti was specified, then we cannot be sure
+		 that RTTI information will be emitted with the
+		 virtual table of the class, so we must emit it
+		 wherever it is used.  */
+	      && flag_rtti)
+	    import_p = true;
+	  else
+	    {
+	      if (CLASSTYPE_INTERFACE_KNOWN (type)
+		  && !CLASSTYPE_INTERFACE_ONLY (type))
+		{
+		  comdat_p = (targetm.cxx.class_data_always_comdat ()
+			      || (CLASSTYPE_KEY_METHOD (type)
+				  && DECL_DECLARED_INLINE_P (CLASSTYPE_KEY_METHOD (type))));
+		  mark_needed (decl);
+		  if (!flag_weak)
+		    {
+		      comdat_p = false;
+		      DECL_EXTERNAL (decl) = 0;
+		    }
+		}
+	      else
+		comdat_p = true;
+	    }
+	}
+      else
+	comdat_p = true;
+    }
+  else if (DECL_TEMPLOID_INSTANTIATION (decl))
+    {
+      /* DECL is an implicit instantiation of a function or static
+	 data member.  */
+      if ((flag_implicit_templates
+	   && !flag_use_repository)
+	  || (flag_implicit_inline_templates
+	      && TREE_CODE (decl) == FUNCTION_DECL
+	      && DECL_DECLARED_INLINE_P (decl)))
+	comdat_p = true;
+      else
+	/* If we are not implicitly generating templates, then mark
+	   this entity as undefined in this translation unit.  */
+	import_p = true;
+    }
+  else if (DECL_FUNCTION_MEMBER_P (decl))
+    {
+      if (!DECL_DECLARED_INLINE_P (decl))
+	{
+	  tree ctype = DECL_CONTEXT (decl);
+	  import_export_class (ctype);
+	  if (CLASSTYPE_INTERFACE_KNOWN (ctype))
+	    {
+	      DECL_NOT_REALLY_EXTERN (decl)
+		= ! (CLASSTYPE_INTERFACE_ONLY (ctype)
+		     || (DECL_DECLARED_INLINE_P (decl)
+			 && ! flag_implement_inlines
+			 && !DECL_VINDEX (decl)));
+
+	      if (!DECL_NOT_REALLY_EXTERN (decl))
+		DECL_EXTERNAL (decl) = 1;
+
+	      /* Always make artificials weak.  */
+	      if (DECL_ARTIFICIAL (decl) && flag_weak)
+		comdat_p = true;
+	      else
+		maybe_make_one_only (decl);
+	    }
+	}
+      else
+	comdat_p = true;
+    }
+  else
+    comdat_p = true;
+
+  if (import_p)
+    {
+      /* If we are importing DECL into this translation unit, mark is
+	 an undefined here.  */
+      DECL_EXTERNAL (decl) = 1;
+      DECL_NOT_REALLY_EXTERN (decl) = 0;
+    }
+  else if (comdat_p)
+    {
+      /* If we decided to put DECL in COMDAT, mark it accordingly at
+	 this point.  */
+      comdat_linkage (decl);
+    }
+
+  DECL_INTERFACE_KNOWN (decl) = 1;
+}
+
+/* Return an expression that performs the destruction of DECL, which
+   must be a VAR_DECL whose type has a non-trivial destructor, or is
+   an array whose (innermost) elements have a non-trivial destructor.  */
+
+tree
+build_cleanup (tree decl)
+{
+  tree clean = cxx_maybe_build_cleanup (decl, tf_warning_or_error);
+  gcc_assert (clean != NULL_TREE);
+  return clean;
+}
+
+/* Returns the initialization guard variable for the variable DECL,
+   which has static storage duration.  */
+
+tree
+get_guard (tree decl)
+{
+  tree sname;
+  tree guard;
+
+  sname = mangle_guard_variable (decl);
+  guard = IDENTIFIER_GLOBAL_VALUE (sname);
+  if (! guard)
+    {
+      tree guard_type;
+
+      /* We use a type that is big enough to contain a mutex as well
+	 as an integer counter.  */
+      guard_type = targetm.cxx.guard_type ();
+      guard = build_decl (DECL_SOURCE_LOCATION (decl),
+			  VAR_DECL, sname, guard_type);
+
+      /* The guard should have the same linkage as what it guards.  */
+      TREE_PUBLIC (guard) = TREE_PUBLIC (decl);
+      TREE_STATIC (guard) = TREE_STATIC (decl);
+      DECL_COMMON (guard) = DECL_COMMON (decl);
+      DECL_COMDAT (guard) = DECL_COMDAT (decl);
+      DECL_TLS_MODEL (guard) = DECL_TLS_MODEL (decl);
+      if (DECL_ONE_ONLY (decl))
+	make_decl_one_only (guard, cxx_comdat_group (guard));
+      if (TREE_PUBLIC (decl))
+	DECL_WEAK (guard) = DECL_WEAK (decl);
+      DECL_VISIBILITY (guard) = DECL_VISIBILITY (decl);
+      DECL_VISIBILITY_SPECIFIED (guard) = DECL_VISIBILITY_SPECIFIED (decl);
+
+      DECL_ARTIFICIAL (guard) = 1;
+      DECL_IGNORED_P (guard) = 1;
+      TREE_USED (guard) = 1;
+      pushdecl_top_level_and_finish (guard, NULL_TREE);
+    }
+  return guard;
+}
+
+/* Return those bits of the GUARD variable that should be set when the
+   guarded entity is actually initialized.  */
+
+static tree
+get_guard_bits (tree guard)
+{
+  if (!targetm.cxx.guard_mask_bit ())
+    {
+      /* We only set the first byte of the guard, in order to leave room
+	 for a mutex in the high-order bits.  */
+      guard = build1 (ADDR_EXPR,
+		      build_pointer_type (TREE_TYPE (guard)),
+		      guard);
+      guard = build1 (NOP_EXPR,
+		      build_pointer_type (char_type_node),
+		      guard);
+      guard = build1 (INDIRECT_REF, char_type_node, guard);
+    }
+
+  return guard;
+}
+
+/* Return an expression which determines whether or not the GUARD
+   variable has already been initialized.  */
+
+tree
+get_guard_cond (tree guard)
+{
+  tree guard_value;
+
+  /* Check to see if the GUARD is zero.  */
+  guard = get_guard_bits (guard);
+
+  /* Mask off all but the low bit.  */
+  if (targetm.cxx.guard_mask_bit ())
+    {
+      guard_value = integer_one_node;
+      if (!same_type_p (TREE_TYPE (guard_value), TREE_TYPE (guard)))
+	guard_value = convert (TREE_TYPE (guard), guard_value);
+      guard = cp_build_binary_op (input_location,
+				  BIT_AND_EXPR, guard, guard_value,
+				  tf_warning_or_error);
+    }
+
+  guard_value = integer_zero_node;
+  if (!same_type_p (TREE_TYPE (guard_value), TREE_TYPE (guard)))
+    guard_value = convert (TREE_TYPE (guard), guard_value);
+  return cp_build_binary_op (input_location,
+			     EQ_EXPR, guard, guard_value,
+			     tf_warning_or_error);
+}
+
+/* Return an expression which sets the GUARD variable, indicating that
+   the variable being guarded has been initialized.  */
+
+tree
+set_guard (tree guard)
+{
+  tree guard_init;
+
+  /* Set the GUARD to one.  */
+  guard = get_guard_bits (guard);
+  guard_init = integer_one_node;
+  if (!same_type_p (TREE_TYPE (guard_init), TREE_TYPE (guard)))
+    guard_init = convert (TREE_TYPE (guard), guard_init);
+  return cp_build_modify_expr (guard, NOP_EXPR, guard_init, 
+			       tf_warning_or_error);
+}
+
+/* Returns true iff we can tell that VAR does not have a dynamic
+   initializer.  */
+
+static bool
+var_defined_without_dynamic_init (tree var)
+{
+  /* If it's defined in another TU, we can't tell.  */
+  if (DECL_EXTERNAL (var))
+    return false;
+  /* If it has a non-trivial destructor, registering the destructor
+     counts as dynamic initialization.  */
+  if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TREE_TYPE (var)))
+    return false;
+  /* If it's in this TU, its initializer has been processed.  */
+  gcc_assert (DECL_INITIALIZED_P (var));
+  /* If it has no initializer or a constant one, it's not dynamic.  */
+  return (!DECL_NONTRIVIALLY_INITIALIZED_P (var)
+	  || DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (var));
+}
+
+/* Returns true iff VAR is a variable that needs uses to be
+   wrapped for possible dynamic initialization.  */
+
+static bool
+var_needs_tls_wrapper (tree var)
+{
+  return (!error_operand_p (var)
+	  && DECL_THREAD_LOCAL_P (var)
+	  && !DECL_GNU_TLS_P (var)
+	  && !DECL_FUNCTION_SCOPE_P (var)
+	  && !var_defined_without_dynamic_init (var));
+}
+
+/* Get the FUNCTION_DECL for the shared TLS init function for this
+   translation unit.  */
+
+static tree
+get_local_tls_init_fn (void)
+{
+  tree sname = get_identifier ("__tls_init");
+  tree fn = IDENTIFIER_GLOBAL_VALUE (sname);
+  if (!fn)
+    {
+      fn = build_lang_decl (FUNCTION_DECL, sname,
+			     build_function_type (void_type_node,
+						  void_list_node));
+      SET_DECL_LANGUAGE (fn, lang_c);
+      TREE_PUBLIC (fn) = false;
+      DECL_ARTIFICIAL (fn) = true;
+      mark_used (fn);
+      SET_IDENTIFIER_GLOBAL_VALUE (sname, fn);
+    }
+  return fn;
+}
+
+/* Get a FUNCTION_DECL for the init function for the thread_local
+   variable VAR.  The init function will be an alias to the function
+   that initializes all the non-local TLS variables in the translation
+   unit.  The init function is only used by the wrapper function.  */
+
+static tree
+get_tls_init_fn (tree var)
+{
+  /* Only C++11 TLS vars need this init fn.  */
+  if (!var_needs_tls_wrapper (var))
+    return NULL_TREE;
+
+  /* If -fno-extern-tls-init, assume that we don't need to call
+     a tls init function for a variable defined in another TU.  */
+  if (!flag_extern_tls_init && DECL_EXTERNAL (var))
+    return NULL_TREE;
+
+#ifdef ASM_OUTPUT_DEF
+  /* If the variable is internal, or if we can't generate aliases,
+     call the local init function directly.  */
+  if (!TREE_PUBLIC (var))
+#endif
+    return get_local_tls_init_fn ();
+
+  tree sname = mangle_tls_init_fn (var);
+  tree fn = IDENTIFIER_GLOBAL_VALUE (sname);
+  if (!fn)
+    {
+      fn = build_lang_decl (FUNCTION_DECL, sname,
+			    build_function_type (void_type_node,
+						 void_list_node));
+      SET_DECL_LANGUAGE (fn, lang_c);
+      TREE_PUBLIC (fn) = TREE_PUBLIC (var);
+      DECL_ARTIFICIAL (fn) = true;
+      DECL_COMDAT (fn) = DECL_COMDAT (var);
+      DECL_EXTERNAL (fn) = DECL_EXTERNAL (var);
+      if (DECL_ONE_ONLY (var))
+	make_decl_one_only (fn, cxx_comdat_group (fn));
+      if (TREE_PUBLIC (var))
+	{
+	  tree obtype = strip_array_types (non_reference (TREE_TYPE (var)));
+	  /* If the variable is defined somewhere else and might have static
+	     initialization, make the init function a weak reference.  */
+	  if ((!TYPE_NEEDS_CONSTRUCTING (obtype)
+	       || TYPE_HAS_CONSTEXPR_CTOR (obtype))
+	      && TYPE_HAS_TRIVIAL_DESTRUCTOR (obtype)
+	      && DECL_EXTERNAL (var))
+	    declare_weak (fn);
+	  else
+	    DECL_WEAK (fn) = DECL_WEAK (var);
+	}
+      DECL_VISIBILITY (fn) = DECL_VISIBILITY (var);
+      DECL_VISIBILITY_SPECIFIED (fn) = DECL_VISIBILITY_SPECIFIED (var);
+      DECL_DLLIMPORT_P (fn) = DECL_DLLIMPORT_P (var);
+      DECL_IGNORED_P (fn) = 1;
+      mark_used (fn);
+
+      DECL_BEFRIENDING_CLASSES (fn) = var;
+
+      SET_IDENTIFIER_GLOBAL_VALUE (sname, fn);
+    }
+  return fn;
+}
+
+/* Get a FUNCTION_DECL for the init wrapper function for the thread_local
+   variable VAR.  The wrapper function calls the init function (if any) for
+   VAR and then returns a reference to VAR.  The wrapper function is used
+   in place of VAR everywhere VAR is mentioned.  */
+
+tree
+get_tls_wrapper_fn (tree var)
+{
+  /* Only C++11 TLS vars need this wrapper fn.  */
+  if (!var_needs_tls_wrapper (var))
+    return NULL_TREE;
+
+  tree sname = mangle_tls_wrapper_fn (var);
+  tree fn = IDENTIFIER_GLOBAL_VALUE (sname);
+  if (!fn)
+    {
+      /* A named rvalue reference is an lvalue, so the wrapper should
+	 always return an lvalue reference.  */
+      tree type = non_reference (TREE_TYPE (var));
+      type = build_reference_type (type);
+      tree fntype = build_function_type (type, void_list_node);
+      fn = build_lang_decl (FUNCTION_DECL, sname, fntype);
+      SET_DECL_LANGUAGE (fn, lang_c);
+      TREE_PUBLIC (fn) = TREE_PUBLIC (var);
+      DECL_ARTIFICIAL (fn) = true;
+      DECL_IGNORED_P (fn) = 1;
+      /* The wrapper is inline and emitted everywhere var is used.  */
+      DECL_DECLARED_INLINE_P (fn) = true;
+      if (TREE_PUBLIC (var))
+	{
+	  comdat_linkage (fn);
+#ifdef HAVE_GAS_HIDDEN
+	  /* Make the wrapper bind locally; there's no reason to share
+	     the wrapper between multiple shared objects.  */
+	  DECL_VISIBILITY (fn) = VISIBILITY_INTERNAL;
+	  DECL_VISIBILITY_SPECIFIED (fn) = true;
+#endif
+	}
+      if (!TREE_PUBLIC (fn))
+	DECL_INTERFACE_KNOWN (fn) = true;
+      mark_used (fn);
+      note_vague_linkage_fn (fn);
+
+#if 0
+      /* We want CSE to commonize calls to the wrapper, but marking it as
+	 pure is unsafe since it has side-effects.  I guess we need a new
+	 ECF flag even weaker than ECF_PURE.  FIXME!  */
+      DECL_PURE_P (fn) = true;
+#endif
+
+      DECL_BEFRIENDING_CLASSES (fn) = var;
+
+      SET_IDENTIFIER_GLOBAL_VALUE (sname, fn);
+    }
+  return fn;
+}
+
+/* At EOF, generate the definition for the TLS wrapper function FN:
+
+   T& var_wrapper() {
+     if (init_fn) init_fn();
+     return var;
+   }  */
+
+static void
+generate_tls_wrapper (tree fn)
+{
+  tree var = DECL_BEFRIENDING_CLASSES (fn);
+
+  start_preparsed_function (fn, NULL_TREE, SF_DEFAULT | SF_PRE_PARSED);
+  tree body = begin_function_body ();
+  /* Only call the init fn if there might be one.  */
+  if (tree init_fn = get_tls_init_fn (var))
+    {
+      tree if_stmt = NULL_TREE;
+      /* If init_fn is a weakref, make sure it exists before calling.  */
+      if (lookup_attribute ("weak", DECL_ATTRIBUTES (init_fn)))
+	{
+	  if_stmt = begin_if_stmt ();
+	  tree addr = cp_build_addr_expr (init_fn, tf_warning_or_error);
+	  tree cond = cp_build_binary_op (DECL_SOURCE_LOCATION (var),
+					  NE_EXPR, addr, nullptr_node,
+					  tf_warning_or_error);
+	  finish_if_stmt_cond (cond, if_stmt);
+	}
+      finish_expr_stmt (build_cxx_call
+			(init_fn, 0, NULL, tf_warning_or_error));
+      if (if_stmt)
+	{
+	  finish_then_clause (if_stmt);
+	  finish_if_stmt (if_stmt);
+	}
+    }
+  else
+    /* If there's no initialization, the wrapper is a constant function.  */
+    TREE_READONLY (fn) = true;
+  finish_return_stmt (convert_from_reference (var));
+  finish_function_body (body);
+  expand_or_defer_fn (finish_function (0));
+}
+
+/* Start the process of running a particular set of global constructors
+   or destructors.  Subroutine of do_[cd]tors.  Also called from
+   vtv_start_verification_constructor_init_function.  */
+
+static tree
+start_objects (int method_type, int initp)
+{
+  tree body;
+  tree fndecl;
+  char type[14];
+
+  /* Make ctor or dtor function.  METHOD_TYPE may be 'I' or 'D'.  */
+
+  if (initp != DEFAULT_INIT_PRIORITY)
+    {
+      char joiner;
+
+#ifdef JOINER
+      joiner = JOINER;
+#else
+      joiner = '_';
+#endif
+
+      sprintf (type, "sub_%c%c%.5u", method_type, joiner, initp);
+    }
+  else
+    sprintf (type, "sub_%c", method_type);
+
+  fndecl = build_lang_decl (FUNCTION_DECL,
+			    get_file_function_name (type),
+			    build_function_type_list (void_type_node,
+						      NULL_TREE));
+  start_preparsed_function (fndecl, /*attrs=*/NULL_TREE, SF_PRE_PARSED);
+
+  TREE_PUBLIC (current_function_decl) = 0;
+
+  /* Mark as artificial because it's not explicitly in the user's
+     source code.  */
+  DECL_ARTIFICIAL (current_function_decl) = 1;
+
+  /* Mark this declaration as used to avoid spurious warnings.  */
+  TREE_USED (current_function_decl) = 1;
+
+  /* Mark this function as a global constructor or destructor.  */
+  if (method_type == 'I')
+    DECL_GLOBAL_CTOR_P (current_function_decl) = 1;
+  else
+    DECL_GLOBAL_DTOR_P (current_function_decl) = 1;
+
+  body = begin_compound_stmt (BCS_FN_BODY);
+
+  return body;
+}
+
+/* Finish the process of running a particular set of global constructors
+   or destructors.  Subroutine of do_[cd]tors.  */
+
+static void
+finish_objects (int method_type, int initp, tree body)
+{
+  tree fn;
+
+  /* Finish up.  */
+  finish_compound_stmt (body);
+  fn = finish_function (0);
+
+  if (method_type == 'I')
+    {
+      DECL_STATIC_CONSTRUCTOR (fn) = 1;
+      decl_init_priority_insert (fn, initp);
+    }
+  else
+    {
+      DECL_STATIC_DESTRUCTOR (fn) = 1;
+      decl_fini_priority_insert (fn, initp);
+    }
+
+  expand_or_defer_fn (fn);
+}
+
+/* The names of the parameters to the function created to handle
+   initializations and destructions for objects with static storage
+   duration.  */
+#define INITIALIZE_P_IDENTIFIER "__initialize_p"
+#define PRIORITY_IDENTIFIER "__priority"
+
+/* The name of the function we create to handle initializations and
+   destructions for objects with static storage duration.  */
+#define SSDF_IDENTIFIER "__static_initialization_and_destruction"
+
+/* The declaration for the __INITIALIZE_P argument.  */
+static GTY(()) tree initialize_p_decl;
+
+/* The declaration for the __PRIORITY argument.  */
+static GTY(()) tree priority_decl;
+
+/* The declaration for the static storage duration function.  */
+static GTY(()) tree ssdf_decl;
+
+/* All the static storage duration functions created in this
+   translation unit.  */
+static GTY(()) vec<tree, va_gc> *ssdf_decls;
+
+/* A map from priority levels to information about that priority
+   level.  There may be many such levels, so efficient lookup is
+   important.  */
+static splay_tree priority_info_map;
+
+/* Begins the generation of the function that will handle all
+   initialization and destruction of objects with static storage
+   duration.  The function generated takes two parameters of type
+   `int': __INITIALIZE_P and __PRIORITY.  If __INITIALIZE_P is
+   nonzero, it performs initializations.  Otherwise, it performs
+   destructions.  It only performs those initializations or
+   destructions with the indicated __PRIORITY.  The generated function
+   returns no value.
+
+   It is assumed that this function will only be called once per
+   translation unit.  */
+
+static tree
+start_static_storage_duration_function (unsigned count)
+{
+  tree type;
+  tree body;
+  char id[sizeof (SSDF_IDENTIFIER) + 1 /* '\0' */ + 32];
+
+  /* Create the identifier for this function.  It will be of the form
+     SSDF_IDENTIFIER_<number>.  */
+  sprintf (id, "%s_%u", SSDF_IDENTIFIER, count);
+
+  type = build_function_type_list (void_type_node,
+				   integer_type_node, integer_type_node,
+				   NULL_TREE);
+
+  /* Create the FUNCTION_DECL itself.  */
+  ssdf_decl = build_lang_decl (FUNCTION_DECL,
+			       get_identifier (id),
+			       type);
+  TREE_PUBLIC (ssdf_decl) = 0;
+  DECL_ARTIFICIAL (ssdf_decl) = 1;
+
+  /* Put this function in the list of functions to be called from the
+     static constructors and destructors.  */
+  if (!ssdf_decls)
+    {
+      vec_alloc (ssdf_decls, 32);
+
+      /* Take this opportunity to initialize the map from priority
+	 numbers to information about that priority level.  */
+      priority_info_map = splay_tree_new (splay_tree_compare_ints,
+					  /*delete_key_fn=*/0,
+					  /*delete_value_fn=*/
+					  (splay_tree_delete_value_fn) &free);
+
+      /* We always need to generate functions for the
+	 DEFAULT_INIT_PRIORITY so enter it now.  That way when we walk
+	 priorities later, we'll be sure to find the
+	 DEFAULT_INIT_PRIORITY.  */
+      get_priority_info (DEFAULT_INIT_PRIORITY);
+    }
+
+  vec_safe_push (ssdf_decls, ssdf_decl);
+
+  /* Create the argument list.  */
+  initialize_p_decl = cp_build_parm_decl
+    (get_identifier (INITIALIZE_P_IDENTIFIER), integer_type_node);
+  DECL_CONTEXT (initialize_p_decl) = ssdf_decl;
+  TREE_USED (initialize_p_decl) = 1;
+  priority_decl = cp_build_parm_decl
+    (get_identifier (PRIORITY_IDENTIFIER), integer_type_node);
+  DECL_CONTEXT (priority_decl) = ssdf_decl;
+  TREE_USED (priority_decl) = 1;
+
+  DECL_CHAIN (initialize_p_decl) = priority_decl;
+  DECL_ARGUMENTS (ssdf_decl) = initialize_p_decl;
+
+  /* Put the function in the global scope.  */
+  pushdecl (ssdf_decl);
+
+  /* Start the function itself.  This is equivalent to declaring the
+     function as:
+
+       static void __ssdf (int __initialize_p, init __priority_p);
+
+     It is static because we only need to call this function from the
+     various constructor and destructor functions for this module.  */
+  start_preparsed_function (ssdf_decl,
+			    /*attrs=*/NULL_TREE,
+			    SF_PRE_PARSED);
+
+  /* Set up the scope of the outermost block in the function.  */
+  body = begin_compound_stmt (BCS_FN_BODY);
+
+  return body;
+}
+
+/* Finish the generation of the function which performs initialization
+   and destruction of objects with static storage duration.  After
+   this point, no more such objects can be created.  */
+
+static void
+finish_static_storage_duration_function (tree body)
+{
+  /* Close out the function.  */
+  finish_compound_stmt (body);
+  expand_or_defer_fn (finish_function (0));
+}
+
+/* Return the information about the indicated PRIORITY level.  If no
+   code to handle this level has yet been generated, generate the
+   appropriate prologue.  */
+
+static priority_info
+get_priority_info (int priority)
+{
+  priority_info pi;
+  splay_tree_node n;
+
+  n = splay_tree_lookup (priority_info_map,
+			 (splay_tree_key) priority);
+  if (!n)
+    {
+      /* Create a new priority information structure, and insert it
+	 into the map.  */
+      pi = XNEW (struct priority_info_s);
+      pi->initializations_p = 0;
+      pi->destructions_p = 0;
+      splay_tree_insert (priority_info_map,
+			 (splay_tree_key) priority,
+			 (splay_tree_value) pi);
+    }
+  else
+    pi = (priority_info) n->value;
+
+  return pi;
+}
+
+/* The effective initialization priority of a DECL.  */
+
+#define DECL_EFFECTIVE_INIT_PRIORITY(decl)				      \
+	((!DECL_HAS_INIT_PRIORITY_P (decl) || DECL_INIT_PRIORITY (decl) == 0) \
+	 ? DEFAULT_INIT_PRIORITY : DECL_INIT_PRIORITY (decl))
+
+/* Whether a DECL needs a guard to protect it against multiple
+   initialization.  */
+
+#define NEEDS_GUARD_P(decl) (TREE_PUBLIC (decl) && (DECL_COMMON (decl)      \
+						    || DECL_ONE_ONLY (decl) \
+						    || DECL_WEAK (decl)))
+
+/* Called from one_static_initialization_or_destruction(),
+   via walk_tree.
+   Walks the initializer list of a global variable and looks for
+   temporary variables (DECL_NAME() == NULL and DECL_ARTIFICIAL != 0)
+   and that have their DECL_CONTEXT() == NULL.
+   For each such temporary variable, set their DECL_CONTEXT() to
+   the current function. This is necessary because otherwise
+   some optimizers (enabled by -O2 -fprofile-arcs) might crash
+   when trying to refer to a temporary variable that does not have
+   it's DECL_CONTECT() properly set.  */
+static tree 
+fix_temporary_vars_context_r (tree *node,
+			      int  * /*unused*/,
+			      void * /*unused1*/)
+{
+  gcc_assert (current_function_decl);
+
+  if (TREE_CODE (*node) == BIND_EXPR)
+    {
+      tree var;
+
+      for (var = BIND_EXPR_VARS (*node); var; var = DECL_CHAIN (var))
+	if (VAR_P (var)
+	  && !DECL_NAME (var)
+	  && DECL_ARTIFICIAL (var)
+	  && !DECL_CONTEXT (var))
+	  DECL_CONTEXT (var) = current_function_decl;
+    }
+
+  return NULL_TREE;
+}
+
+/* Set up to handle the initialization or destruction of DECL.  If
+   INITP is nonzero, we are initializing the variable.  Otherwise, we
+   are destroying it.  */
+
+static void
+one_static_initialization_or_destruction (tree decl, tree init, bool initp)
+{
+  tree guard_if_stmt = NULL_TREE;
+  tree guard;
+
+  /* If we are supposed to destruct and there's a trivial destructor,
+     nothing has to be done.  */
+  if (!initp
+      && TYPE_HAS_TRIVIAL_DESTRUCTOR (TREE_TYPE (decl)))
+    return;
+
+  /* Trick the compiler into thinking we are at the file and line
+     where DECL was declared so that error-messages make sense, and so
+     that the debugger will show somewhat sensible file and line
+     information.  */
+  input_location = DECL_SOURCE_LOCATION (decl);
+
+  /* Make sure temporary variables in the initialiser all have
+     their DECL_CONTEXT() set to a value different from NULL_TREE.
+     This can happen when global variables initialisers are built.
+     In that case, the DECL_CONTEXT() of the global variables _AND_ of all 
+     the temporary variables that might have been generated in the
+     accompagning initialisers is NULL_TREE, meaning the variables have been
+     declared in the global namespace.
+     What we want to do here is to fix that and make sure the DECL_CONTEXT()
+     of the temporaries are set to the current function decl.  */
+  cp_walk_tree_without_duplicates (&init,
+				   fix_temporary_vars_context_r,
+				   NULL);
+
+  /* Because of:
+
+       [class.access.spec]
+
+       Access control for implicit calls to the constructors,
+       the conversion functions, or the destructor called to
+       create and destroy a static data member is performed as
+       if these calls appeared in the scope of the member's
+       class.
+
+     we pretend we are in a static member function of the class of
+     which the DECL is a member.  */
+  if (member_p (decl))
+    {
+      DECL_CONTEXT (current_function_decl) = DECL_CONTEXT (decl);
+      DECL_STATIC_FUNCTION_P (current_function_decl) = 1;
+    }
+
+  /* Assume we don't need a guard.  */
+  guard = NULL_TREE;
+  /* We need a guard if this is an object with external linkage that
+     might be initialized in more than one place.  (For example, a
+     static data member of a template, when the data member requires
+     construction.)  */
+  if (NEEDS_GUARD_P (decl))
+    {
+      tree guard_cond;
+
+      guard = get_guard (decl);
+
+      /* When using __cxa_atexit, we just check the GUARD as we would
+	 for a local static.  */
+      if (flag_use_cxa_atexit)
+	{
+	  /* When using __cxa_atexit, we never try to destroy
+	     anything from a static destructor.  */
+	  gcc_assert (initp);
+	  guard_cond = get_guard_cond (guard);
+	}
+      /* If we don't have __cxa_atexit, then we will be running
+	 destructors from .fini sections, or their equivalents.  So,
+	 we need to know how many times we've tried to initialize this
+	 object.  We do initializations only if the GUARD is zero,
+	 i.e., if we are the first to initialize the variable.  We do
+	 destructions only if the GUARD is one, i.e., if we are the
+	 last to destroy the variable.  */
+      else if (initp)
+	guard_cond
+	  = cp_build_binary_op (input_location,
+				EQ_EXPR,
+				cp_build_unary_op (PREINCREMENT_EXPR,
+						   guard,
+						   /*noconvert=*/1,
+						   tf_warning_or_error),
+				integer_one_node,
+				tf_warning_or_error);
+      else
+	guard_cond
+	  = cp_build_binary_op (input_location,
+				EQ_EXPR,
+				cp_build_unary_op (PREDECREMENT_EXPR,
+						   guard,
+						   /*noconvert=*/1,
+						   tf_warning_or_error),
+				integer_zero_node,
+				tf_warning_or_error);
+
+      guard_if_stmt = begin_if_stmt ();
+      finish_if_stmt_cond (guard_cond, guard_if_stmt);
+    }
+
+
+  /* If we're using __cxa_atexit, we have not already set the GUARD,
+     so we must do so now.  */
+  if (guard && initp && flag_use_cxa_atexit)
+    finish_expr_stmt (set_guard (guard));
+
+  /* Perform the initialization or destruction.  */
+  if (initp)
+    {
+      if (init)
+	{
+	  finish_expr_stmt (init);
+	  if (flag_sanitize & SANITIZE_ADDRESS)
+	    {
+	      varpool_node *vnode = varpool_get_node (decl);
+	      if (vnode)
+		vnode->dynamically_initialized = 1;
+	    }
+	}
+
+      /* If we're using __cxa_atexit, register a function that calls the
+	 destructor for the object.  */
+      if (flag_use_cxa_atexit)
+	finish_expr_stmt (register_dtor_fn (decl));
+    }
+  else
+    finish_expr_stmt (build_cleanup (decl));
+
+  /* Finish the guard if-stmt, if necessary.  */
+  if (guard)
+    {
+      finish_then_clause (guard_if_stmt);
+      finish_if_stmt (guard_if_stmt);
+    }
+
+  /* Now that we're done with DECL we don't need to pretend to be a
+     member of its class any longer.  */
+  DECL_CONTEXT (current_function_decl) = NULL_TREE;
+  DECL_STATIC_FUNCTION_P (current_function_decl) = 0;
+}
+
+/* Generate code to do the initialization or destruction of the decls in VARS,
+   a TREE_LIST of VAR_DECL with static storage duration.
+   Whether initialization or destruction is performed is specified by INITP.  */
+
+static void
+do_static_initialization_or_destruction (tree vars, bool initp)
+{
+  tree node, init_if_stmt, cond;
+
+  /* Build the outer if-stmt to check for initialization or destruction.  */
+  init_if_stmt = begin_if_stmt ();
+  cond = initp ? integer_one_node : integer_zero_node;
+  cond = cp_build_binary_op (input_location,
+			     EQ_EXPR,
+			     initialize_p_decl,
+			     cond,
+			     tf_warning_or_error);
+  finish_if_stmt_cond (cond, init_if_stmt);
+
+  /* To make sure dynamic construction doesn't access globals from other
+     compilation units where they might not be yet constructed, for
+     -fsanitize=address insert __asan_before_dynamic_init call that
+     prevents access to either all global variables that need construction
+     in other compilation units, or at least those that haven't been
+     initialized yet.  Variables that need dynamic construction in
+     the current compilation unit are kept accessible.  */
+  if (flag_sanitize & SANITIZE_ADDRESS)
+    finish_expr_stmt (asan_dynamic_init_call (/*after_p=*/false));
+
+  node = vars;
+  do {
+    tree decl = TREE_VALUE (node);
+    tree priority_if_stmt;
+    int priority;
+    priority_info pi;
+
+    /* If we don't need a destructor, there's nothing to do.  Avoid
+       creating a possibly empty if-stmt.  */
+    if (!initp && TYPE_HAS_TRIVIAL_DESTRUCTOR (TREE_TYPE (decl)))
+      {
+	node = TREE_CHAIN (node);
+	continue;
+      }
+
+    /* Remember that we had an initialization or finalization at this
+       priority.  */
+    priority = DECL_EFFECTIVE_INIT_PRIORITY (decl);
+    pi = get_priority_info (priority);
+    if (initp)
+      pi->initializations_p = 1;
+    else
+      pi->destructions_p = 1;
+
+    /* Conditionalize this initialization on being in the right priority
+       and being initializing/finalizing appropriately.  */
+    priority_if_stmt = begin_if_stmt ();
+    cond = cp_build_binary_op (input_location,
+			       EQ_EXPR,
+			       priority_decl,
+			       build_int_cst (NULL_TREE, priority),
+			       tf_warning_or_error);
+    finish_if_stmt_cond (cond, priority_if_stmt);
+
+    /* Process initializers with same priority.  */
+    for (; node
+	   && DECL_EFFECTIVE_INIT_PRIORITY (TREE_VALUE (node)) == priority;
+	 node = TREE_CHAIN (node))
+      /* Do one initialization or destruction.  */
+      one_static_initialization_or_destruction (TREE_VALUE (node),
+						TREE_PURPOSE (node), initp);
+
+    /* Finish up the priority if-stmt body.  */
+    finish_then_clause (priority_if_stmt);
+    finish_if_stmt (priority_if_stmt);
+
+  } while (node);
+
+  /* Revert what __asan_before_dynamic_init did by calling
+     __asan_after_dynamic_init.  */
+  if (flag_sanitize & SANITIZE_ADDRESS)
+    finish_expr_stmt (asan_dynamic_init_call (/*after_p=*/true));
+
+  /* Finish up the init/destruct if-stmt body.  */
+  finish_then_clause (init_if_stmt);
+  finish_if_stmt (init_if_stmt);
+}
+
+/* VARS is a list of variables with static storage duration which may
+   need initialization and/or finalization.  Remove those variables
+   that don't really need to be initialized or finalized, and return
+   the resulting list.  The order in which the variables appear in
+   VARS is in reverse order of the order in which they should actually
+   be initialized.  The list we return is in the unreversed order;
+   i.e., the first variable should be initialized first.  */
+
+static tree
+prune_vars_needing_no_initialization (tree *vars)
+{
+  tree *var = vars;
+  tree result = NULL_TREE;
+
+  while (*var)
+    {
+      tree t = *var;
+      tree decl = TREE_VALUE (t);
+      tree init = TREE_PURPOSE (t);
+
+      /* Deal gracefully with error.  */
+      if (decl == error_mark_node)
+	{
+	  var = &TREE_CHAIN (t);
+	  continue;
+	}
+
+      /* The only things that can be initialized are variables.  */
+      gcc_assert (VAR_P (decl));
+
+      /* If this object is not defined, we don't need to do anything
+	 here.  */
+      if (DECL_EXTERNAL (decl))
+	{
+	  var = &TREE_CHAIN (t);
+	  continue;
+	}
+
+      /* Also, if the initializer already contains errors, we can bail
+	 out now.  */
+      if (init && TREE_CODE (init) == TREE_LIST
+	  && value_member (error_mark_node, init))
+	{
+	  var = &TREE_CHAIN (t);
+	  continue;
+	}
+
+      /* This variable is going to need initialization and/or
+	 finalization, so we add it to the list.  */
+      *var = TREE_CHAIN (t);
+      TREE_CHAIN (t) = result;
+      result = t;
+    }
+
+  return result;
+}
+
+/* Make sure we have told the back end about all the variables in
+   VARS.  */
+
+static void
+write_out_vars (tree vars)
+{
+  tree v;
+
+  for (v = vars; v; v = TREE_CHAIN (v))
+    {
+      tree var = TREE_VALUE (v);
+      if (!var_finalized_p (var))
+	{
+	  import_export_decl (var);
+	  rest_of_decl_compilation (var, 1, 1);
+	}
+    }
+}
+
+/* Generate a static constructor (if CONSTRUCTOR_P) or destructor
+   (otherwise) that will initialize all global objects with static
+   storage duration having the indicated PRIORITY.  */
+
+static void
+generate_ctor_or_dtor_function (bool constructor_p, int priority,
+				location_t *locus)
+{
+  char function_key;
+  tree fndecl;
+  tree body;
+  size_t i;
+
+  input_location = *locus;
+  /* ??? */
+  /* Was: locus->line++; */
+
+  /* We use `I' to indicate initialization and `D' to indicate
+     destruction.  */
+  function_key = constructor_p ? 'I' : 'D';
+
+  /* We emit the function lazily, to avoid generating empty
+     global constructors and destructors.  */
+  body = NULL_TREE;
+
+  /* For Objective-C++, we may need to initialize metadata found in this module.
+     This must be done _before_ any other static initializations.  */
+  if (c_dialect_objc () && (priority == DEFAULT_INIT_PRIORITY)
+      && constructor_p && objc_static_init_needed_p ())
+    {
+      body = start_objects (function_key, priority);
+      objc_generate_static_init_call (NULL_TREE);
+    }
+
+  /* Call the static storage duration function with appropriate
+     arguments.  */
+  FOR_EACH_VEC_SAFE_ELT (ssdf_decls, i, fndecl)
+    {
+      /* Calls to pure or const functions will expand to nothing.  */
+      if (! (flags_from_decl_or_type (fndecl) & (ECF_CONST | ECF_PURE)))
+	{
+	  tree call;
+
+	  if (! body)
+	    body = start_objects (function_key, priority);
+
+	  call = cp_build_function_call_nary (fndecl, tf_warning_or_error,
+					      build_int_cst (NULL_TREE,
+							     constructor_p),
+					      build_int_cst (NULL_TREE,
+							     priority),
+					      NULL_TREE);
+	  finish_expr_stmt (call);
+	}
+    }
+
+  /* Close out the function.  */
+  if (body)
+    finish_objects (function_key, priority, body);
+}
+
+/* Generate constructor and destructor functions for the priority
+   indicated by N.  */
+
+static int
+generate_ctor_and_dtor_functions_for_priority (splay_tree_node n, void * data)
+{
+  location_t *locus = (location_t *) data;
+  int priority = (int) n->key;
+  priority_info pi = (priority_info) n->value;
+
+  /* Generate the functions themselves, but only if they are really
+     needed.  */
+  if (pi->initializations_p)
+    generate_ctor_or_dtor_function (/*constructor_p=*/true, priority, locus);
+  if (pi->destructions_p)
+    generate_ctor_or_dtor_function (/*constructor_p=*/false, priority, locus);
+
+  /* Keep iterating.  */
+  return 0;
+}
+
+/* Java requires that we be able to reference a local address for a
+   method, and not be confused by PLT entries.  If hidden aliases are
+   supported, collect and return all the functions for which we should
+   emit a hidden alias.  */
+
+static struct pointer_set_t *
+collect_candidates_for_java_method_aliases (void)
+{
+  struct cgraph_node *node;
+  struct pointer_set_t *candidates = NULL;
+
+#ifndef HAVE_GAS_HIDDEN
+  return candidates;
+#endif
+
+  FOR_EACH_FUNCTION (node)
+    {
+      tree fndecl = node->decl;
+
+      if (DECL_CLASS_SCOPE_P (fndecl)
+	  && TYPE_FOR_JAVA (DECL_CONTEXT (fndecl))
+	  && TARGET_USE_LOCAL_THUNK_ALIAS_P (fndecl))
+	{
+	  if (candidates == NULL)
+	    candidates = pointer_set_create ();
+	  pointer_set_insert (candidates, fndecl);
+	}
+    }
+
+  return candidates;
+}
+
+
+/* Java requires that we be able to reference a local address for a
+   method, and not be confused by PLT entries.  If hidden aliases are
+   supported, emit one for each java function that we've emitted.
+   CANDIDATES is the set of FUNCTION_DECLs that were gathered
+   by collect_candidates_for_java_method_aliases.  */
+
+static void
+build_java_method_aliases (struct pointer_set_t *candidates)
+{
+  struct cgraph_node *node;
+
+#ifndef HAVE_GAS_HIDDEN
+  return;
+#endif
+
+  FOR_EACH_FUNCTION (node)
+    {
+      tree fndecl = node->decl;
+
+      if (TREE_ASM_WRITTEN (fndecl)
+	  && pointer_set_contains (candidates, fndecl))
+	{
+	  /* Mangle the name in a predictable way; we need to reference
+	     this from a java compiled object file.  */
+	  tree oid, nid, alias;
+	  const char *oname;
+	  char *nname;
+
+	  oid = DECL_ASSEMBLER_NAME (fndecl);
+	  oname = IDENTIFIER_POINTER (oid);
+	  gcc_assert (oname[0] == '_' && oname[1] == 'Z');
+	  nname = ACONCAT (("_ZGA", oname+2, NULL));
+	  nid = get_identifier (nname);
+
+	  alias = make_alias_for (fndecl, nid);
+	  TREE_PUBLIC (alias) = 1;
+	  DECL_VISIBILITY (alias) = VISIBILITY_HIDDEN;
+
+	  assemble_alias (alias, oid);
+	}
+    }
+}
+
+/* Return C++ property of T, based on given operation OP.  */
+
+static int
+cpp_check (tree t, cpp_operation op)
+{
+  switch (op)
+    {
+      case IS_ABSTRACT:
+	return DECL_PURE_VIRTUAL_P (t);
+      case IS_CONSTRUCTOR:
+	return DECL_CONSTRUCTOR_P (t);
+      case IS_DESTRUCTOR:
+	return DECL_DESTRUCTOR_P (t);
+      case IS_COPY_CONSTRUCTOR:
+	return DECL_COPY_CONSTRUCTOR_P (t);
+      case IS_TEMPLATE:
+	return TREE_CODE (t) == TEMPLATE_DECL;
+      case IS_TRIVIAL:
+	return trivial_type_p (t);
+      default:
+        return 0;
+    }
+}
+
+/* Collect source file references recursively, starting from NAMESPC.  */
+
+static void 
+collect_source_refs (tree namespc) 
+{
+  tree t;
+
+  if (!namespc) 
+    return;
+
+  /* Iterate over names in this name space.  */
+  for (t = NAMESPACE_LEVEL (namespc)->names; t; t = TREE_CHAIN (t))
+    if (!DECL_IS_BUILTIN (t) )
+      collect_source_ref (DECL_SOURCE_FILE (t));
+  
+  /* Dump siblings, if any */
+  collect_source_refs (TREE_CHAIN (namespc));
+
+  /* Dump children, if any */
+  collect_source_refs (NAMESPACE_LEVEL (namespc)->namespaces);
+}
+
+/* Collect decls relevant to SOURCE_FILE from all namespaces recursively,
+   starting from NAMESPC.  */
+
+static void
+collect_ada_namespace (tree namespc, const char *source_file)
+{
+  if (!namespc)
+    return;
+
+  /* Collect decls from this namespace */
+  collect_ada_nodes (NAMESPACE_LEVEL (namespc)->names, source_file);
+
+  /* Collect siblings, if any */
+  collect_ada_namespace (TREE_CHAIN (namespc), source_file);
+
+  /* Collect children, if any */
+  collect_ada_namespace (NAMESPACE_LEVEL (namespc)->namespaces, source_file);
+}
+
+/* Returns true iff there is a definition available for variable or
+   function DECL.  */
+
+static bool
+decl_defined_p (tree decl)
+{
+  if (TREE_CODE (decl) == FUNCTION_DECL)
+    return (DECL_INITIAL (decl) != NULL_TREE);
+  else
+    {
+      gcc_assert (VAR_P (decl));
+      return !DECL_EXTERNAL (decl);
+    }
+}
+
+/* Nonzero for a VAR_DECL whose value can be used in a constant expression.
+
+      [expr.const]
+
+      An integral constant-expression can only involve ... const
+      variables of integral or enumeration types initialized with
+      constant expressions ...
+
+      C++0x also allows constexpr variables and temporaries initialized
+      with constant expressions.  We handle the former here, but the latter
+      are just folded away in cxx_eval_constant_expression.
+
+   The standard does not require that the expression be non-volatile.
+   G++ implements the proposed correction in DR 457.  */
+
+bool
+decl_constant_var_p (tree decl)
+{
+  if (!decl_maybe_constant_var_p (decl))
+    return false;
+
+  /* We don't know if a template static data member is initialized with
+     a constant expression until we instantiate its initializer.  Even
+     in the case of a constexpr variable, we can't treat it as a
+     constant until its initializer is complete in case it's used in
+     its own initializer.  */
+  mark_used (decl);
+  return DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (decl);
+}
+
+/* Returns true if DECL could be a symbolic constant variable, depending on
+   its initializer.  */
+
+bool
+decl_maybe_constant_var_p (tree decl)
+{
+  tree type = TREE_TYPE (decl);
+  if (!VAR_P (decl))
+    return false;
+  if (DECL_DECLARED_CONSTEXPR_P (decl))
+    return true;
+  return (CP_TYPE_CONST_NON_VOLATILE_P (type)
+	  && INTEGRAL_OR_ENUMERATION_TYPE_P (type));
+}
+
+/* Complain that DECL uses a type with no linkage.  In C++98 mode this is
+   called from grokfndecl and grokvardecl; in all modes it is called from
+   cp_write_global_declarations.  */
+
+void
+no_linkage_error (tree decl)
+{
+  if (cxx_dialect >= cxx11 && decl_defined_p (decl))
+    /* In C++11 it's ok if the decl is defined.  */
+    return;
+  tree t = no_linkage_check (TREE_TYPE (decl), /*relaxed_p=*/false);
+  if (t == NULL_TREE)
+    /* The type that got us on no_linkage_decls must have gotten a name for
+       linkage purposes.  */;
+  else if (CLASS_TYPE_P (t) && TYPE_BEING_DEFINED (t))
+    /* The type might end up having a typedef name for linkage purposes.  */
+    vec_safe_push (no_linkage_decls, decl);
+  else if (TYPE_ANONYMOUS_P (t))
+    {
+      bool d = false;
+      if (cxx_dialect >= cxx11)
+	d = permerror (DECL_SOURCE_LOCATION (decl), "%q#D, declared using "
+		       "anonymous type, is used but never defined", decl);
+      else if (DECL_EXTERN_C_P (decl))
+	/* Allow this; it's pretty common in C.  */;
+      else if (TREE_CODE (decl) == VAR_DECL)
+	/* 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.  */
+	d = warning_at (DECL_SOURCE_LOCATION (decl), 0, "anonymous type "
+			"with no linkage used to declare variable %q#D with "
+			"linkage", decl);
+      else
+	d = permerror (DECL_SOURCE_LOCATION (decl), "anonymous type with no "
+		       "linkage used to declare function %q#D with linkage",
+		       decl);
+      if (d && is_typedef_decl (TYPE_NAME (t)))
+	inform (DECL_SOURCE_LOCATION (TYPE_NAME (t)), "%q#D does not refer "
+		"to the unqualified type, so it is not used for linkage",
+		TYPE_NAME (t));
+    }
+  else if (cxx_dialect >= cxx11)
+    permerror (DECL_SOURCE_LOCATION (decl), "%q#D, declared using local type "
+	       "%qT, is used but never defined", decl, t);
+  else if (TREE_CODE (decl) == VAR_DECL)
+    warning_at (DECL_SOURCE_LOCATION (decl), 0, "type %qT with no linkage "
+		"used to declare variable %q#D with linkage", t, decl);
+  else
+    permerror (DECL_SOURCE_LOCATION (decl), "type %qT with no linkage used "
+	       "to declare function %q#D with linkage", t, decl);
+}
+
+/* Collect declarations from all namespaces relevant to SOURCE_FILE.  */
+
+static void
+collect_all_refs (const char *source_file)
+{
+  collect_ada_namespace (global_namespace, source_file);
+}
+
+/* Clear DECL_EXTERNAL for NODE.  */
+
+static bool
+clear_decl_external (struct cgraph_node *node, void * /*data*/)
+{
+  DECL_EXTERNAL (node->decl) = 0;
+  return false;
+}
+
+/* Build up the function to run dynamic initializers for thread_local
+   variables in this translation unit and alias the init functions for the
+   individual variables to it.  */
+
+static void
+handle_tls_init (void)
+{
+  tree vars = prune_vars_needing_no_initialization (&tls_aggregates);
+  if (vars == NULL_TREE)
+    return;
+
+  location_t loc = DECL_SOURCE_LOCATION (TREE_VALUE (vars));
+
+  write_out_vars (vars);
+
+  tree guard = build_decl (loc, VAR_DECL, get_identifier ("__tls_guard"),
+			   boolean_type_node);
+  TREE_PUBLIC (guard) = false;
+  TREE_STATIC (guard) = true;
+  DECL_ARTIFICIAL (guard) = true;
+  DECL_IGNORED_P (guard) = true;
+  TREE_USED (guard) = true;
+  DECL_TLS_MODEL (guard) = decl_default_tls_model (guard);
+  pushdecl_top_level_and_finish (guard, NULL_TREE);
+
+  tree fn = get_local_tls_init_fn ();
+  start_preparsed_function (fn, NULL_TREE, SF_PRE_PARSED);
+  tree body = begin_function_body ();
+  tree if_stmt = begin_if_stmt ();
+  tree cond = cp_build_unary_op (TRUTH_NOT_EXPR, guard, false,
+				 tf_warning_or_error);
+  finish_if_stmt_cond (cond, if_stmt);
+  finish_expr_stmt (cp_build_modify_expr (guard, NOP_EXPR, boolean_true_node,
+					  tf_warning_or_error));
+  for (; vars; vars = TREE_CHAIN (vars))
+    {
+      tree var = TREE_VALUE (vars);
+      tree init = TREE_PURPOSE (vars);
+      one_static_initialization_or_destruction (var, init, true);
+
+#ifdef ASM_OUTPUT_DEF
+      /* Output init aliases even with -fno-extern-tls-init.  */
+      if (TREE_PUBLIC (var))
+	{
+          tree single_init_fn = get_tls_init_fn (var);
+	  if (single_init_fn == NULL_TREE)
+	    continue;
+	  cgraph_node *alias
+	    = cgraph_same_body_alias (cgraph_get_create_node (fn),
+				      single_init_fn, fn);
+	  gcc_assert (alias != NULL);
+	}
+#endif
+    }
+
+  finish_then_clause (if_stmt);
+  finish_if_stmt (if_stmt);
+  finish_function_body (body);
+  expand_or_defer_fn (finish_function (0));
+}
+
+/* The entire file is now complete.  If requested, dump everything
+   to a file.  */
+
+static void
+dump_tu (void)
+{
+  int flags;
+  FILE *stream = dump_begin (TDI_tu, &flags);
+
+  if (stream)
+    {
+      dump_node (global_namespace, flags & ~TDF_SLIM, stream);
+      dump_end (TDI_tu, stream);
+    }
+}
+
+/* This routine is called at the end of compilation.
+   Its job is to create all the code needed to initialize and
+   destroy the global aggregates.  We do the destruction
+   first, since that way we only need to reverse the decls once.  */
+
+void
+cp_write_global_declarations (void)
+{
+  tree vars;
+  bool reconsider;
+  size_t i;
+  location_t locus;
+  unsigned ssdf_count = 0;
+  int retries = 0;
+  tree decl;
+  struct pointer_set_t *candidates;
+
+  locus = input_location;
+  at_eof = 1;
+
+  /* Bad parse errors.  Just forget about it.  */
+  if (! global_bindings_p () || current_class_type
+      || !vec_safe_is_empty (decl_namespace_list))
+    return;
+
+  /* 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 ();
+      dump_tu ();
+      return;
+    }
+
+  cgraph_process_same_body_aliases ();
+
+  /* Handle -fdump-ada-spec[-slim] */
+  if (flag_dump_ada_spec || flag_dump_ada_spec_slim)
+    {
+      if (flag_dump_ada_spec_slim)
+	collect_source_ref (main_input_filename);
+      else
+	collect_source_refs (global_namespace);
+
+      dump_ada_specs (collect_all_refs, cpp_check);
+    }
+
+  /* FIXME - huh?  was  input_line -= 1;*/
+
+  timevar_start (TV_PHASE_DEFERRED);
+
+  /* We now have to write out all the stuff we put off writing out.
+     These include:
+
+       o Template specializations that we have not yet instantiated,
+	 but which are needed.
+       o Initialization and destruction for non-local objects with
+	 static storage duration.  (Local objects with static storage
+	 duration are initialized when their scope is first entered,
+	 and are cleaned up via atexit.)
+       o Virtual function tables.
+
+     All of these may cause others to be needed.  For example,
+     instantiating one function may cause another to be needed, and
+     generating the initializer for an object may cause templates to be
+     instantiated, etc., etc.  */
+
+  emit_support_tinfos ();
+
+  do
+    {
+      tree t;
+      tree decl;
+
+      reconsider = false;
+
+      /* If there are templates that we've put off instantiating, do
+	 them now.  */
+      instantiate_pending_templates (retries);
+      ggc_collect ();
+
+      /* Write out virtual tables as required.  Note that writing out
+	 the virtual table for a template class may cause the
+	 instantiation of members of that class.  If we write out
+	 vtables then we remove the class from our list so we don't
+	 have to look at it again.  */
+
+      while (keyed_classes != NULL_TREE
+	     && maybe_emit_vtables (TREE_VALUE (keyed_classes)))
+	{
+	  reconsider = true;
+	  keyed_classes = TREE_CHAIN (keyed_classes);
+	}
+
+      t = keyed_classes;
+      if (t != NULL_TREE)
+	{
+	  tree next = TREE_CHAIN (t);
+
+	  while (next)
+	    {
+	      if (maybe_emit_vtables (TREE_VALUE (next)))
+		{
+		  reconsider = true;
+		  TREE_CHAIN (t) = TREE_CHAIN (next);
+		}
+	      else
+		t = next;
+
+	      next = TREE_CHAIN (t);
+	    }
+	}
+
+      /* Write out needed type info variables.  We have to be careful
+	 looping through unemitted decls, because emit_tinfo_decl may
+	 cause other variables to be needed. New elements will be
+	 appended, and we remove from the vector those that actually
+	 get emitted.  */
+      for (i = unemitted_tinfo_decls->length ();
+	   unemitted_tinfo_decls->iterate (--i, &t);)
+	if (emit_tinfo_decl (t))
+	  {
+	    reconsider = true;
+	    unemitted_tinfo_decls->unordered_remove (i);
+	  }
+
+      /* The list of objects with static storage duration is built up
+	 in reverse order.  We clear STATIC_AGGREGATES so that any new
+	 aggregates added during the initialization of these will be
+	 initialized in the correct order when we next come around the
+	 loop.  */
+      vars = prune_vars_needing_no_initialization (&static_aggregates);
+
+      if (vars)
+	{
+	  /* We need to start a new initialization function each time
+	     through the loop.  That's because we need to know which
+	     vtables have been referenced, and TREE_SYMBOL_REFERENCED
+	     isn't computed until a function is finished, and written
+	     out.  That's a deficiency in the back end.  When this is
+	     fixed, these initialization functions could all become
+	     inline, with resulting performance improvements.  */
+	  tree ssdf_body;
+
+	  /* Set the line and file, so that it is obviously not from
+	     the source file.  */
+	  input_location = locus;
+	  ssdf_body = start_static_storage_duration_function (ssdf_count);
+
+	  /* Make sure the back end knows about all the variables.  */
+	  write_out_vars (vars);
+
+	  /* First generate code to do all the initializations.  */
+	  if (vars)
+	    do_static_initialization_or_destruction (vars, /*initp=*/true);
+
+	  /* Then, generate code to do all the destructions.  Do these
+	     in reverse order so that the most recently constructed
+	     variable is the first destroyed.  If we're using
+	     __cxa_atexit, then we don't need to do this; functions
+	     were registered at initialization time to destroy the
+	     local statics.  */
+	  if (!flag_use_cxa_atexit && vars)
+	    {
+	      vars = nreverse (vars);
+	      do_static_initialization_or_destruction (vars, /*initp=*/false);
+	    }
+	  else
+	    vars = NULL_TREE;
+
+	  /* Finish up the static storage duration function for this
+	     round.  */
+	  input_location = locus;
+	  finish_static_storage_duration_function (ssdf_body);
+
+	  /* All those initializations and finalizations might cause
+	     us to need more inline functions, more template
+	     instantiations, etc.  */
+	  reconsider = true;
+	  ssdf_count++;
+	  /* ??? was:  locus.line++; */
+	}
+
+      /* Now do the same for thread_local variables.  */
+      handle_tls_init ();
+
+      /* Go through the set of inline functions whose bodies have not
+	 been emitted yet.  If out-of-line copies of these functions
+	 are required, emit them.  */
+      FOR_EACH_VEC_SAFE_ELT (deferred_fns, i, decl)
+	{
+	  /* Does it need synthesizing?  */
+	  if (DECL_DEFAULTED_FN (decl) && ! DECL_INITIAL (decl)
+	      && (! DECL_REALLY_EXTERN (decl) || possibly_inlined_p (decl)))
+	    {
+	      /* Even though we're already at the top-level, we push
+		 there again.  That way, when we pop back a few lines
+		 hence, all of our state is restored.  Otherwise,
+		 finish_function doesn't clean things up, and we end
+		 up with CURRENT_FUNCTION_DECL set.  */
+	      push_to_top_level ();
+	      /* The decl's location will mark where it was first
+		 needed.  Save that so synthesize method can indicate
+		 where it was needed from, in case of error  */
+	      input_location = DECL_SOURCE_LOCATION (decl);
+	      synthesize_method (decl);
+	      pop_from_top_level ();
+	      reconsider = true;
+	    }
+
+	  if (!DECL_INITIAL (decl) && decl_tls_wrapper_p (decl))
+	    generate_tls_wrapper (decl);
+
+	  if (!DECL_SAVED_TREE (decl))
+	    continue;
+
+	  /* We lie to the back end, pretending that some functions
+	     are not defined when they really are.  This keeps these
+	     functions from being put out unnecessarily.  But, we must
+	     stop lying when the functions are referenced, or if they
+	     are not comdat since they need to be put out now.  If
+	     DECL_INTERFACE_KNOWN, then we have already set
+	     DECL_EXTERNAL appropriately, so there's no need to check
+	     again, and we do not want to clear DECL_EXTERNAL if a
+	     previous call to import_export_decl set it.
+
+	     This is done in a separate for cycle, because if some
+	     deferred function is contained in another deferred
+	     function later in deferred_fns varray,
+	     rest_of_compilation would skip this function and we
+	     really cannot expand the same function twice.  */
+	  import_export_decl (decl);
+	  if (DECL_NOT_REALLY_EXTERN (decl)
+	      && DECL_INITIAL (decl)
+	      && decl_needed_p (decl))
+	    {
+	      struct cgraph_node *node, *next;
+
+	      node = cgraph_get_node (decl);
+	      if (node->cpp_implicit_alias)
+		node = cgraph_alias_target (node);
+
+	      cgraph_for_node_and_aliases (node, clear_decl_external,
+					   NULL, true);
+	      /* If we mark !DECL_EXTERNAL one of the symbols in some comdat
+		 group, we need to mark all symbols in the same comdat group
+		 that way.  */
+	      if (node->same_comdat_group)
+		for (next = cgraph (node->same_comdat_group);
+		     next != node;
+		     next = cgraph (next->same_comdat_group))
+	          cgraph_for_node_and_aliases (next, clear_decl_external,
+					       NULL, true);
+	    }
+
+	  /* If we're going to need to write this function out, and
+	     there's already a body for it, create RTL for it now.
+	     (There might be no body if this is a method we haven't
+	     gotten around to synthesizing yet.)  */
+	  if (!DECL_EXTERNAL (decl)
+	      && decl_needed_p (decl)
+	      && !TREE_ASM_WRITTEN (decl)
+	      && !cgraph_get_node (decl)->definition)
+	    {
+	      /* We will output the function; no longer consider it in this
+		 loop.  */
+	      DECL_DEFER_OUTPUT (decl) = 0;
+	      /* Generate RTL for this function now that we know we
+		 need it.  */
+	      expand_or_defer_fn (decl);
+	      /* If we're compiling -fsyntax-only pretend that this
+		 function has been written out so that we don't try to
+		 expand it again.  */
+	      if (flag_syntax_only)
+		TREE_ASM_WRITTEN (decl) = 1;
+	      reconsider = true;
+	    }
+	}
+
+      if (walk_namespaces (wrapup_globals_for_namespace, /*data=*/0))
+	reconsider = true;
+
+      /* Static data members are just like namespace-scope globals.  */
+      FOR_EACH_VEC_SAFE_ELT (pending_statics, i, decl)
+	{
+	  if (var_finalized_p (decl) || DECL_REALLY_EXTERN (decl)
+	      /* Don't write it out if we haven't seen a definition.  */
+	      || DECL_IN_AGGR_P (decl))
+	    continue;
+	  import_export_decl (decl);
+	  /* If this static data member is needed, provide it to the
+	     back end.  */
+	  if (DECL_NOT_REALLY_EXTERN (decl) && decl_needed_p (decl))
+	    DECL_EXTERNAL (decl) = 0;
+	}
+      if (vec_safe_length (pending_statics) != 0
+	  && wrapup_global_declarations (pending_statics->address (),
+					 pending_statics->length ()))
+	reconsider = true;
+
+      retries++;
+    }
+  while (reconsider);
+
+  /* All used inline functions must have a definition at this point.  */
+  FOR_EACH_VEC_SAFE_ELT (deferred_fns, i, decl)
+    {
+      if (/* Check online inline functions that were actually used.  */
+	  DECL_ODR_USED (decl) && DECL_DECLARED_INLINE_P (decl)
+	  /* If the definition actually was available here, then the
+	     fact that the function was not defined merely represents
+	     that for some reason (use of a template repository,
+	     #pragma interface, etc.) we decided not to emit the
+	     definition here.  */
+	  && !DECL_INITIAL (decl)
+	  /* Don't complain if the template was defined.  */
+	  && !(DECL_TEMPLATE_INSTANTIATION (decl)
+	       && DECL_INITIAL (DECL_TEMPLATE_RESULT
+				(template_for_substitution (decl)))))
+	{
+	  warning (0, "inline function %q+D used but never defined", decl);
+	  /* Avoid a duplicate warning from check_global_declaration_1.  */
+	  TREE_NO_WARNING (decl) = 1;
+	}
+    }
+
+  /* So must decls that use a type with no linkage.  */
+  FOR_EACH_VEC_SAFE_ELT (no_linkage_decls, i, decl)
+    no_linkage_error (decl);
+
+  /* Then, do the Objective-C stuff.  This is where all the
+     Objective-C module stuff gets generated (symtab,
+     class/protocol/selector lists etc).  This must be done after C++
+     templates, destructors etc. so that selectors used in C++
+     templates are properly allocated.  */
+  if (c_dialect_objc ())
+    objc_write_global_declarations ();
+
+  /* We give C linkage to static constructors and destructors.  */
+  push_lang_context (lang_name_c);
+
+  /* Generate initialization and destruction functions for all
+     priorities for which they are required.  */
+  if (priority_info_map)
+    splay_tree_foreach (priority_info_map,
+			generate_ctor_and_dtor_functions_for_priority,
+			/*data=*/&locus);
+  else if (c_dialect_objc () && objc_static_init_needed_p ())
+    /* If this is obj-c++ and we need a static init, call
+       generate_ctor_or_dtor_function.  */
+    generate_ctor_or_dtor_function (/*constructor_p=*/true,
+				    DEFAULT_INIT_PRIORITY, &locus);
+
+  /* We're done with the splay-tree now.  */
+  if (priority_info_map)
+    splay_tree_delete (priority_info_map);
+
+  /* Generate any missing aliases.  */
+  maybe_apply_pending_pragma_weaks ();
+
+  /* We're done with static constructors, so we can go back to "C++"
+     linkage now.  */
+  pop_lang_context ();
+
+  /* Collect candidates for Java hidden aliases.  */
+  candidates = collect_candidates_for_java_method_aliases ();
+
+  timevar_stop (TV_PHASE_DEFERRED);
+  timevar_start (TV_PHASE_OPT_GEN);
+
+  if (flag_vtable_verify)
+    {
+      vtv_recover_class_info ();
+      vtv_compute_class_hierarchy_transitive_closure ();
+      vtv_build_vtable_verify_fndecl ();
+    }
+
+  finalize_compilation_unit ();
+
+  if (flag_vtable_verify)
+    {
+      /* Generate the special constructor initialization function that
+         calls __VLTRegisterPairs, and give it a very high
+         initialization priority.  This must be done after
+         finalize_compilation_unit so that we have accurate
+         information about which vtable will actually be emitted.  */
+      vtv_generate_init_routine ();
+    }
+
+  timevar_stop (TV_PHASE_OPT_GEN);
+  timevar_start (TV_PHASE_CHECK_DBGINFO);
+
+  /* Now, issue warnings about static, but not defined, functions,
+     etc., and emit debugging information.  */
+  walk_namespaces (wrapup_globals_for_namespace, /*data=*/&reconsider);
+  if (vec_safe_length (pending_statics) != 0)
+    {
+      check_global_declarations (pending_statics->address (),
+				 pending_statics->length ());
+      emit_debug_global_declarations (pending_statics->address (),
+				      pending_statics->length ());
+    }
+
+  perform_deferred_noexcept_checks ();
+
+  /* Generate hidden aliases for Java.  */
+  if (candidates)
+    {
+      build_java_method_aliases (candidates);
+      pointer_set_destroy (candidates);
+    }
+
+  finish_repo ();
+
+  /* The entire file is now complete.  If requested, dump everything
+     to a file.  */
+  dump_tu ();
+
+  if (flag_detailed_statistics)
+    {
+      dump_tree_statistics ();
+      dump_time_statistics ();
+    }
+  input_location = locus;
+
+#ifdef ENABLE_CHECKING
+  validate_conversion_obstack ();
+#endif /* ENABLE_CHECKING */
+
+  timevar_stop (TV_PHASE_CHECK_DBGINFO);
+}
+
+/* FN is an OFFSET_REF, DOTSTAR_EXPR or MEMBER_REF indicating the
+   function to call in parse-tree form; it has not yet been
+   semantically analyzed.  ARGS are the arguments to the function.
+   They have already been semantically analyzed.  This may change
+   ARGS.  */
+
+tree
+build_offset_ref_call_from_tree (tree fn, vec<tree, va_gc> **args,
+				 tsubst_flags_t complain)
+{
+  tree orig_fn;
+  vec<tree, va_gc> *orig_args = NULL;
+  tree expr;
+  tree object;
+
+  orig_fn = fn;
+  object = TREE_OPERAND (fn, 0);
+
+  if (processing_template_decl)
+    {
+      gcc_assert (TREE_CODE (fn) == DOTSTAR_EXPR
+		  || TREE_CODE (fn) == MEMBER_REF);
+      if (type_dependent_expression_p (fn)
+	  || any_type_dependent_arguments_p (*args))
+	return build_nt_call_vec (fn, *args);
+
+      orig_args = make_tree_vector_copy (*args);
+
+      /* Transform the arguments and add the implicit "this"
+	 parameter.  That must be done before the FN is transformed
+	 because we depend on the form of FN.  */
+      make_args_non_dependent (*args);
+      object = build_non_dependent_expr (object);
+      if (TREE_CODE (TREE_TYPE (fn)) == METHOD_TYPE)
+	{
+	  if (TREE_CODE (fn) == DOTSTAR_EXPR)
+	    object = cp_build_addr_expr (object, complain);
+	  vec_safe_insert (*args, 0, object);
+	}
+      /* Now that the arguments are done, transform FN.  */
+      fn = build_non_dependent_expr (fn);
+    }
+
+  /* A qualified name corresponding to a bound pointer-to-member is
+     represented as an OFFSET_REF:
+
+	struct B { void g(); };
+	void (B::*p)();
+	void B::g() { (this->*p)(); }  */
+  if (TREE_CODE (fn) == OFFSET_REF)
+    {
+      tree object_addr = cp_build_addr_expr (object, complain);
+      fn = TREE_OPERAND (fn, 1);
+      fn = get_member_function_from_ptrfunc (&object_addr, fn,
+					     complain);
+      vec_safe_insert (*args, 0, object_addr);
+    }
+
+  if (CLASS_TYPE_P (TREE_TYPE (fn)))
+    expr = build_op_call (fn, args, complain);
+  else
+    expr = cp_build_function_call_vec (fn, args, complain);
+  if (processing_template_decl && expr != error_mark_node)
+    expr = build_min_non_dep_call_vec (expr, orig_fn, orig_args);
+
+  if (orig_args != NULL)
+    release_tree_vector (orig_args);
+
+  return expr;
+}
+
+
+void
+check_default_args (tree x)
+{
+  tree arg = TYPE_ARG_TYPES (TREE_TYPE (x));
+  bool saw_def = false;
+  int i = 0 - (TREE_CODE (TREE_TYPE (x)) == METHOD_TYPE);
+  for (; arg && arg != void_list_node; arg = TREE_CHAIN (arg), ++i)
+    {
+      if (TREE_PURPOSE (arg))
+	saw_def = true;
+      else if (saw_def && !PACK_EXPANSION_P (TREE_VALUE (arg)))
+	{
+	  error ("default argument missing for parameter %P of %q+#D", i, x);
+	  TREE_PURPOSE (arg) = error_mark_node;
+	}
+    }
+}
+
+/* Return true if function DECL can be inlined.  This is used to force
+   instantiation of methods that might be interesting for inlining.  */
+bool
+possibly_inlined_p (tree decl)
+{
+  gcc_assert (TREE_CODE (decl) == FUNCTION_DECL);
+  if (DECL_UNINLINABLE (decl))
+    return false;
+  if (!optimize || pragma_java_exceptions)
+    return DECL_DECLARED_INLINE_P (decl);
+  /* When optimizing, we might inline everything when flatten
+     attribute or heuristics inlining for size or autoinlining
+     is used.  */
+  return true;
+}
+
+/* Mark DECL (either a _DECL or a BASELINK) as "used" in the program.
+   If DECL is a specialization or implicitly declared class member,
+   generate the actual definition.  Return false if something goes
+   wrong, true otherwise.  */
+
+bool
+mark_used (tree decl, tsubst_flags_t complain)
+{
+  /* If DECL is a BASELINK for a single function, then treat it just
+     like the DECL for the function.  Otherwise, if the BASELINK is
+     for an overloaded function, we don't know which function was
+     actually used until after overload resolution.  */
+  if (BASELINK_P (decl))
+    {
+      decl = BASELINK_FUNCTIONS (decl);
+      if (really_overloaded_fn (decl))
+	return true;
+      decl = OVL_CURRENT (decl);
+    }
+
+  /* Set TREE_USED for the benefit of -Wunused.  */
+  TREE_USED (decl) = 1;
+  if (DECL_CLONED_FUNCTION_P (decl))
+    TREE_USED (DECL_CLONED_FUNCTION (decl)) = 1;
+
+  /* Mark enumeration types as used.  */
+  if (TREE_CODE (decl) == CONST_DECL)
+    used_types_insert (DECL_CONTEXT (decl));
+
+  if (TREE_CODE (decl) == FUNCTION_DECL
+      && DECL_DELETED_FN (decl))
+    {
+      if (DECL_ARTIFICIAL (decl))
+	{
+	  if (DECL_OVERLOADED_OPERATOR_P (decl) == TYPE_EXPR
+	      && LAMBDA_TYPE_P (DECL_CONTEXT (decl)))
+	    {
+	      /* We mark a lambda conversion op as deleted if we can't
+		 generate it properly; see maybe_add_lambda_conv_op.  */
+	      sorry ("converting lambda which uses %<...%> to "
+		     "function pointer");
+	      return false;
+	    }
+	}
+      if (complain & tf_error)
+	{
+	  error ("use of deleted function %qD", decl);
+	  if (!maybe_explain_implicit_delete (decl))
+	    inform (DECL_SOURCE_LOCATION (decl), "declared here");
+	}
+      return false;
+    }
+
+  /* We can only check DECL_ODR_USED on variables or functions with
+     DECL_LANG_SPECIFIC set, and these are also the only decls that we
+     might need special handling for.  */
+  if (!VAR_OR_FUNCTION_DECL_P (decl)
+      || DECL_LANG_SPECIFIC (decl) == NULL
+      || DECL_THUNK_P (decl))
+    {
+      if (!processing_template_decl && type_uses_auto (TREE_TYPE (decl)))
+	{
+	  if (complain & tf_error)
+	    error ("use of %qD before deduction of %<auto%>", decl);
+	  return false;
+	}
+      return true;
+    }
+
+  /* We only want to do this processing once.  We don't need to keep trying
+     to instantiate inline templates, because unit-at-a-time will make sure
+     we get them compiled before functions that want to inline them.  */
+  if (DECL_ODR_USED (decl))
+    return true;
+
+  /* If within finish_function, defer the rest until that function
+     finishes, otherwise it might recurse.  */
+  if (defer_mark_used_calls)
+    {
+      vec_safe_push (deferred_mark_used_calls, decl);
+      return true;
+    }
+
+  if (TREE_CODE (decl) == FUNCTION_DECL)
+    maybe_instantiate_noexcept (decl);
+
+  /* Normally, we can wait until instantiation-time to synthesize DECL.
+     However, if DECL is a static data member initialized with a constant
+     or a constexpr function, we need it right now because a reference to
+     such a data member or a call to such function is not value-dependent.
+     For a function that uses auto in the return type, we need to instantiate
+     it to find out its type.  For OpenMP user defined reductions, we need
+     them instantiated for reduction clauses which inline them by hand
+     directly.  */
+  if (DECL_LANG_SPECIFIC (decl)
+      && DECL_TEMPLATE_INFO (decl)
+      && (decl_maybe_constant_var_p (decl)
+	  || (TREE_CODE (decl) == FUNCTION_DECL
+	      && (DECL_DECLARED_CONSTEXPR_P (decl)
+		  || DECL_OMP_DECLARE_REDUCTION_P (decl)))
+	  || undeduced_auto_decl (decl))
+      && !uses_template_parms (DECL_TI_ARGS (decl)))
+    {
+      /* Instantiating a function will result in garbage collection.  We
+	 must treat this situation as if we were within the body of a
+	 function so as to avoid collecting live data only referenced from
+	 the stack (such as overload resolution candidates).  */
+      ++function_depth;
+      instantiate_decl (decl, /*defer_ok=*/false,
+			/*expl_inst_class_mem_p=*/false);
+      --function_depth;
+    }
+
+  if (processing_template_decl)
+    return true;
+
+  /* Check this too in case we're within fold_non_dependent_expr.  */
+  if (DECL_TEMPLATE_INFO (decl)
+      && uses_template_parms (DECL_TI_ARGS (decl)))
+    return true;
+
+  require_deduced_type (decl);
+
+  /* If we don't need a value, then we don't need to synthesize DECL.  */
+  if (cp_unevaluated_operand != 0)
+    return true;
+
+  DECL_ODR_USED (decl) = 1;
+  if (DECL_CLONED_FUNCTION_P (decl))
+    DECL_ODR_USED (DECL_CLONED_FUNCTION (decl)) = 1;
+
+  /* DR 757: A type without linkage shall not be used as the type of a
+     variable or function with linkage, unless
+   o the variable or function has extern "C" linkage (7.5 [dcl.link]), or
+   o the variable or function is not used (3.2 [basic.def.odr]) or is
+   defined in the same translation unit.  */
+  if (cxx_dialect > cxx98
+      && decl_linkage (decl) != lk_none
+      && !DECL_EXTERN_C_P (decl)
+      && !DECL_ARTIFICIAL (decl)
+      && !decl_defined_p (decl)
+      && no_linkage_check (TREE_TYPE (decl), /*relaxed_p=*/false))
+    {
+      if (is_local_extern (decl))
+	/* There's no way to define a local extern, and adding it to
+	   the vector interferes with GC, so give an error now.  */
+	no_linkage_error (decl);
+      else
+	vec_safe_push (no_linkage_decls, decl);
+    }
+
+  if (TREE_CODE (decl) == FUNCTION_DECL && DECL_DECLARED_INLINE_P (decl)
+      && !DECL_INITIAL (decl) && !DECL_ARTIFICIAL (decl))
+    /* Remember it, so we can check it was defined.  */
+    note_vague_linkage_fn (decl);
+
+  /* Is it a synthesized method that needs to be synthesized?  */
+  if (TREE_CODE (decl) == FUNCTION_DECL
+      && DECL_NONSTATIC_MEMBER_FUNCTION_P (decl)
+      && DECL_DEFAULTED_FN (decl)
+      /* A function defaulted outside the class is synthesized either by
+	 cp_finish_decl or instantiate_decl.  */
+      && !DECL_DEFAULTED_OUTSIDE_CLASS_P (decl)
+      && ! DECL_INITIAL (decl))
+    {
+      /* Defer virtual destructors so that thunks get the right
+	 linkage.  */
+      if (DECL_VIRTUAL_P (decl) && !at_eof)
+	{
+	  note_vague_linkage_fn (decl);
+	  return true;
+	}
+
+      /* Remember the current location for a function we will end up
+	 synthesizing.  Then we can inform the user where it was
+	 required in the case of error.  */
+      DECL_SOURCE_LOCATION (decl) = input_location;
+
+      /* Synthesizing an implicitly defined member function will result in
+	 garbage collection.  We must treat this situation as if we were
+	 within the body of a function so as to avoid collecting live data
+	 on the stack (such as overload resolution candidates).
+
+         We could just let cp_write_global_declarations handle synthesizing
+         this function by adding it to deferred_fns, but doing
+         it at the use site produces better error messages.  */
+      ++function_depth;
+      synthesize_method (decl);
+      --function_depth;
+      /* If this is a synthesized method we don't need to
+	 do the instantiation test below.  */
+    }
+  else if (VAR_OR_FUNCTION_DECL_P (decl)
+	   && DECL_TEMPLATE_INFO (decl)
+	   && (!DECL_EXPLICIT_INSTANTIATION (decl)
+	       || always_instantiate_p (decl)))
+    /* If this is a function or variable that is an instance of some
+       template, we now know that we will need to actually do the
+       instantiation. We check that DECL is not an explicit
+       instantiation because that is not checked in instantiate_decl.
+
+       We put off instantiating functions in order to improve compile
+       times.  Maintaining a stack of active functions is expensive,
+       and the inliner knows to instantiate any functions it might
+       need.  Therefore, we always try to defer instantiation.  */
+    {
+      ++function_depth;
+      instantiate_decl (decl, /*defer_ok=*/true,
+			/*expl_inst_class_mem_p=*/false);
+      --function_depth;
+    }
+
+  return true;
+}
+
+bool
+mark_used (tree decl)
+{
+  return mark_used (decl, tf_warning_or_error);
+}
+
+tree
+vtv_start_verification_constructor_init_function (void)
+{
+  return start_objects ('I', MAX_RESERVED_INIT_PRIORITY - 1);
+}
+
+tree
+vtv_finish_verification_constructor_init_function (tree function_body)
+{
+  tree fn;
+
+  finish_compound_stmt (function_body);
+  fn = finish_function (0);
+  DECL_STATIC_CONSTRUCTOR (fn) = 1;
+  decl_init_priority_insert (fn, MAX_RESERVED_INIT_PRIORITY - 1);
+
+  return fn;
+}
+
+#include "gt-cp-decl2.h"