cp-tree.h (CLASSTYPE_DESTRUCTORS): Rename to ...

	* cp-tree.h (CLASSTYPE_DESTRUCTORS): Rename to ...
	(CLASSTYPE_DESTRUCTOR): ... this.
	* class.c (accessible_nvdtor_p)
	maybe_warn_about_overly_private_class,
	add_implicitly_declared_members,
	clone_constructors_and_destructors, type_has_virtual_destructor):
	Adjust for CLASSTYPE_DESTRUCTOR.
	(deduce_noexcept_on_destructors): Absorb into ...
	(check_bases_and_members): ... here.
	* except.c (dtor_nothrow): Adjust for CLASSTYPE_DESTRUCTOR.
	* init.c (build_delete): Likewise.
	* parser.c (cp_parser_lookup_name): Likewise.
	* pt.c (check_explicit_specialization): Likewise.
	* rtti.c (emit_support_tinfos): Likewise.
	* search.c (lookup_fnfields_idx_nolazy): Likewise.
(--This line, and those below, will be ignored--

M    cp/cp-tree.h
M    cp/search.c
M    cp/init.c
M    cp/class.c
M    cp/rtti.c
M    cp/except.c
M    cp/ChangeLog
M    cp/pt.c
M    cp/parser.c

From-SVN: r249701

9 files changed, 45 insertions, 47 deletions

diff --git a/gcc/cp/ChangeLog b/gcc/cp/ChangeLog
index 0a91151..bd22319 100644
--- a/gcc/cp/ChangeLog
+++ b/gcc/cp/ChangeLog
@@ -1,5 +1,21 @@
 2017-06-27  Nathan Sidwell  <nathan@acm.org>
 
+	* cp-tree.h (CLASSTYPE_DESTRUCTORS): Rename to ...
+	(CLASSTYPE_DESTRUCTOR): ... this.
+	* class.c (accessible_nvdtor_p,
+	maybe_warn_about_overly_private_class,
+	add_implicitly_declared_members,
+	clone_constructors_and_destructors, type_has_virtual_destructor):
+	Adjust for CLASSTYPE_DESTRUCTOR.
+	(deduce_noexcept_on_destructors): Absorb into ...
+	(check_bases_and_members): ... here.
+	* except.c (dtor_nothrow): Adjust for CLASSTYPE_DESTRUCTOR.
+	* init.c (build_delete): Likewise.
+	* parser.c (cp_parser_lookup_name): Likewise.
+	* pt.c (check_explicit_specialization): Likewise.
+	* rtti.c (emit_support_tinfos): Likewise.
+	* search.c (lookup_fnfields_idx_nolazy): Likewise.
+
 	Kill IDENTIFIER_TEMPLATE.
 	* cp-tree.h (lang_identifier): Remove class_template_info field.
 	(IDENTIFIER_TEMPLATE): Delete.
diff --git a/gcc/cp/class.c b/gcc/cp/class.c
index 1243f33..833eb94 100644
--- a/gcc/cp/class.c
+++ b/gcc/cp/class.c
@@ -1711,7 +1711,7 @@ inherit_targ_abi_tags (tree t)
 static bool
 accessible_nvdtor_p (tree t)
 {
-  tree dtor = CLASSTYPE_DESTRUCTORS (t);
+  tree dtor = CLASSTYPE_DESTRUCTOR (t);
 
   /* An implicitly declared destructor is always public.  And,
      if it were virtual, we would have created it by now.  */
@@ -2220,7 +2220,7 @@ maybe_warn_about_overly_private_class (tree t)
   /* Even if some of the member functions are non-private, the class
      won't be useful for much if all the constructors or destructors
      are private: such an object can never be created or destroyed.  */
-  fn = CLASSTYPE_DESTRUCTORS (t);
+  fn = CLASSTYPE_DESTRUCTOR (t);
   if (fn && TREE_PRIVATE (fn))
     {
       warning (OPT_Wctor_dtor_privacy,
@@ -3366,18 +3366,17 @@ add_implicitly_declared_members (tree t, tree* access_decls,
 				 int cant_have_const_cctor,
 				 int cant_have_const_assignment)
 {
-  bool move_ok = false;
+  /* Destructor.  */
+  if (!CLASSTYPE_DESTRUCTOR (t))
+    /* In general, we create destructors lazily.  */
+    CLASSTYPE_LAZY_DESTRUCTOR (t) = 1;
 
-  if (cxx_dialect >= cxx11 && !CLASSTYPE_DESTRUCTORS (t)
+  bool move_ok = false;
+  if (cxx_dialect >= cxx11 && CLASSTYPE_LAZY_DESTRUCTOR (t)
       && !TYPE_HAS_COPY_CTOR (t) && !TYPE_HAS_COPY_ASSIGN (t)
       && !type_has_move_constructor (t) && !type_has_move_assign (t))
     move_ok = true;
 
-  /* Destructor.  */
-  if (!CLASSTYPE_DESTRUCTORS (t))
-    /* In general, we create destructors lazily.  */
-    CLASSTYPE_LAZY_DESTRUCTOR (t) = 1;
-
   /* [class.ctor]
 
      If there is no user-declared constructor for a class, a default
@@ -5015,8 +5014,9 @@ clone_constructors_and_destructors (tree t)
      we no longer need to know that.  */
   for (ovl_iterator iter (CLASSTYPE_CONSTRUCTORS (t)); iter; ++iter)
     clone_function_decl (*iter, /*update_methods=*/true);
-  for (ovl_iterator iter (CLASSTYPE_DESTRUCTORS (t)); iter; ++iter)
-    clone_function_decl (*iter, /*update_methods=*/true);
+
+  if (tree dtor = CLASSTYPE_DESTRUCTOR (t))
+    clone_function_decl (dtor, /*update_methods=*/true);
 }
 
 /* Deduce noexcept for a destructor DTOR.  */
@@ -5029,24 +5029,6 @@ deduce_noexcept_on_destructor (tree dtor)
 						noexcept_deferred_spec);
 }
 
-/* For each destructor in T, deduce noexcept:
-
-   12.4/3: A declaration of a destructor that does not have an
-   exception-specification is implicitly considered to have the
-   same exception-specification as an implicit declaration (15.4).  */
-
-static void
-deduce_noexcept_on_destructors (tree t)
-{
-  /* If for some reason we don't have a CLASSTYPE_METHOD_VEC, we bail
-     out now.  */
-  if (!CLASSTYPE_METHOD_VEC (t))
-    return;
-
-  for (ovl_iterator iter (CLASSTYPE_DESTRUCTORS (t)); iter; ++iter)
-    deduce_noexcept_on_destructor (*iter);
-}
-
 /* Subroutine of set_one_vmethod_tm_attributes.  Search base classes
    of TYPE for virtual functions which FNDECL overrides.  Return a
    mask of the tm attributes found therein.  */
@@ -5460,7 +5442,7 @@ type_has_virtual_destructor (tree type)
     return false;
 
   gcc_assert (COMPLETE_TYPE_P (type));
-  dtor = CLASSTYPE_DESTRUCTORS (type);
+  dtor = CLASSTYPE_DESTRUCTOR (type);
   return (dtor && DECL_VIRTUAL_P (dtor));
 }
 
@@ -5851,10 +5833,11 @@ check_bases_and_members (tree t)
      of potential interest.  */
   check_bases (t, &cant_have_const_ctor, &no_const_asn_ref);
 
-  /* Deduce noexcept on destructors.  This needs to happen after we've set
+  /* Deduce noexcept on destructor.  This needs to happen after we've set
      triviality flags appropriately for our bases.  */
   if (cxx_dialect >= cxx11)
-    deduce_noexcept_on_destructors (t);
+    if (tree dtor = CLASSTYPE_DESTRUCTOR (t))
+      deduce_noexcept_on_destructor (dtor);
 
   /* Check all the method declarations.  */
   check_methods (t);
diff --git a/gcc/cp/cp-tree.h b/gcc/cp/cp-tree.h
index 1c7a08d..f82b1b6 100644
--- a/gcc/cp/cp-tree.h
+++ b/gcc/cp/cp-tree.h
@@ -2145,11 +2145,11 @@ struct GTY(()) lang_type {
 #define CLASSTYPE_CONSTRUCTORS(NODE) \
   ((*CLASSTYPE_METHOD_VEC (NODE))[CLASSTYPE_CONSTRUCTOR_SLOT])
 
-/* A FUNCTION_DECL for the destructor for NODE.  These are the
+/* A FUNCTION_DECL for the destructor for NODE.  This is the
    destructors that take an in-charge parameter.  If
    CLASSTYPE_LAZY_DESTRUCTOR is true, then this entry will be NULL
    until the destructor is created with lazily_declare_fn.  */
-#define CLASSTYPE_DESTRUCTORS(NODE) \
+#define CLASSTYPE_DESTRUCTOR(NODE) \
   (CLASSTYPE_METHOD_VEC (NODE)						      \
    ? (*CLASSTYPE_METHOD_VEC (NODE))[CLASSTYPE_DESTRUCTOR_SLOT]		      \
    : NULL_TREE)
@@ -2179,11 +2179,9 @@ struct GTY(()) lang_type {
 
 /* The type corresponding to NODE when NODE is used as a base class,
    i.e., NODE without virtual base classes or tail padding.  */
-
 #define CLASSTYPE_AS_BASE(NODE) (LANG_TYPE_CLASS_CHECK (NODE)->as_base)
 
 /* True iff NODE is the CLASSTYPE_AS_BASE version of some type.  */
-
 #define IS_FAKE_BASE_TYPE(NODE)					\
   (TREE_CODE (NODE) == RECORD_TYPE				\
    && TYPE_CONTEXT (NODE) && CLASS_TYPE_P (TYPE_CONTEXT (NODE))	\
diff --git a/gcc/cp/except.c b/gcc/cp/except.c
index 9e41ec4..208e52a 100644
--- a/gcc/cp/except.c
+++ b/gcc/cp/except.c
@@ -218,7 +218,7 @@ dtor_nothrow (tree type)
   if (CLASSTYPE_LAZY_DESTRUCTOR (type))
     lazily_declare_fn (sfk_destructor, type);
 
-  return TREE_NOTHROW (CLASSTYPE_DESTRUCTORS (type));
+  return TREE_NOTHROW (CLASSTYPE_DESTRUCTOR (type));
 }
 
 /* Build up a call to __cxa_end_catch, to destroy the exception object
diff --git a/gcc/cp/init.c b/gcc/cp/init.c
index b6f6b4f..1433538 100644
--- a/gcc/cp/init.c
+++ b/gcc/cp/init.c
@@ -4580,8 +4580,7 @@ build_delete (tree otype, tree addr, special_function_kind auto_delete,
 	           && MAYBE_CLASS_TYPE_P (type) && !CLASSTYPE_FINAL (type)
 		   && TYPE_POLYMORPHIC_P (type))
 	    {
-	      tree dtor;
-	      dtor = CLASSTYPE_DESTRUCTORS (type);
+	      tree dtor = CLASSTYPE_DESTRUCTOR (type);
 	      if (!dtor || !DECL_VINDEX (dtor))
 		{
 		  if (CLASSTYPE_PURE_VIRTUALS (type))
@@ -4671,7 +4670,7 @@ build_delete (tree otype, tree addr, special_function_kind auto_delete,
       /* If the destructor is non-virtual, there is no deleting
 	 variant.  Instead, we must explicitly call the appropriate
 	 `operator delete' here.  */
-      else if (!DECL_VIRTUAL_P (CLASSTYPE_DESTRUCTORS (type))
+      else if (!DECL_VIRTUAL_P (CLASSTYPE_DESTRUCTOR (type))
 	       && auto_delete == sfk_deleting_destructor)
 	{
 	  /* We will use ADDR multiple times so we must save it.  */
diff --git a/gcc/cp/parser.c b/gcc/cp/parser.c
index 573b97a..2ff6afd 100644
--- a/gcc/cp/parser.c
+++ b/gcc/cp/parser.c
@@ -25679,12 +25679,14 @@ cp_parser_lookup_name (cp_parser *parser, tree name,
       /* If that's not a class type, there is no destructor.  */
       if (!type || !CLASS_TYPE_P (type))
 	return error_mark_node;
+
       if (CLASSTYPE_LAZY_DESTRUCTOR (type))
 	lazily_declare_fn (sfk_destructor, type);
-      if (!CLASSTYPE_DESTRUCTORS (type))
-	  return error_mark_node;
-      /* If it was a class type, return the destructor.  */
-      return CLASSTYPE_DESTRUCTORS (type);
+
+      if (tree dtor = CLASSTYPE_DESTRUCTOR (type))
+	return dtor;
+
+      return error_mark_node;
     }
 
   /* By this point, the NAME should be an ordinary identifier.  If
diff --git a/gcc/cp/pt.c b/gcc/cp/pt.c
index 43f9ca8..c724e27 100644
--- a/gcc/cp/pt.c
+++ b/gcc/cp/pt.c
@@ -2884,7 +2884,7 @@ check_explicit_specialization (tree declarator,
 	      int is_constructor = DECL_CONSTRUCTOR_P (decl);
 
 	      if (is_constructor ? !TYPE_HAS_USER_CONSTRUCTOR (ctype)
-		  : !CLASSTYPE_DESTRUCTORS (ctype))
+		  : !CLASSTYPE_DESTRUCTOR (ctype))
 		{
 		  /* From [temp.expl.spec]:
 
diff --git a/gcc/cp/rtti.c b/gcc/cp/rtti.c
index ff72ce5..d73b1bc 100644
--- a/gcc/cp/rtti.c
+++ b/gcc/cp/rtti.c
@@ -1556,7 +1556,7 @@ emit_support_tinfos (void)
   bltn_type = TREE_TYPE (bltn_type);
   if (!COMPLETE_TYPE_P (bltn_type))
     return;
-  tree dtor = CLASSTYPE_DESTRUCTORS (bltn_type);
+  tree dtor = CLASSTYPE_DESTRUCTOR (bltn_type);
   if (!dtor || DECL_EXTERNAL (dtor))
     return;
 
diff --git a/gcc/cp/search.c b/gcc/cp/search.c
index 2630150..d7895a0 100644
--- a/gcc/cp/search.c
+++ b/gcc/cp/search.c
@@ -1592,7 +1592,7 @@ lookup_fnfields_idx_nolazy (tree type, tree name)
   /* and destructors are second.  */
   if (name == dtor_identifier)
     {
-      fn = CLASSTYPE_DESTRUCTORS (type);
+      fn = CLASSTYPE_DESTRUCTOR (type);
       return fn ? CLASSTYPE_DESTRUCTOR_SLOT : -1;
     }
   if (IDENTIFIER_CONV_OP_P (name))