Index: cp-tree.h
===================================================================
--- cp-tree.h	(revision 260252)
+++ cp-tree.h	(working copy)
@@ -2783,6 +2783,12 @@ struct GTY(()) lang_decl {
 #define DECL_DELETING_DESTRUCTOR_P(NODE)		\
   (DECL_NAME (NODE) == deleting_dtor_identifier)
 
+/* Nonzero if either DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P or
+   DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P is true of NODE.  */
+#define DECL_MAYBE_IN_CHARGE_CDTOR_P(NODE)              \
+  (DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (NODE)            \
+   || DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (NODE))
+
 /* Nonzero if NODE (a FUNCTION_DECL) is a cloned constructor or
    destructor.  */
 #define DECL_CLONED_FUNCTION_P(NODE) (!!decl_cloned_function_p (NODE, true))
@@ -2800,8 +2806,7 @@ struct GTY(()) lang_decl {
   */
 #define FOR_EACH_CLONE(CLONE, FN)			\
   if (!(TREE_CODE (FN) == FUNCTION_DECL			\
-	&& (DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (FN)	\
-	    || DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (FN))))\
+	&& DECL_MAYBE_IN_CHARGE_CDTOR_P (FN)))          \
     ;							\
   else							\
     for (CLONE = DECL_CHAIN (FN);			\
Index: decl.c
===================================================================
--- decl.c	(revision 260252)
+++ decl.c	(working copy)
@@ -11721,9 +11721,7 @@ grokdeclarator (const cp_declarator *declarator,
 	{
 	  if (!current_function_decl)
 	    DECL_CONTEXT (decl) = FROB_CONTEXT (current_namespace);
-	  else if (DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (current_function_decl)
-		   || (DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P
-		       (current_function_decl)))
+	  else if (DECL_MAYBE_IN_CHARGE_CDTOR_P (current_function_decl))
 	    /* The TYPE_DECL is "abstract" because there will be
 	       clones of this constructor/destructor, and there will
 	       be copies of this TYPE_DECL generated in those
Index: decl2.c
===================================================================
--- decl2.c	(revision 260252)
+++ decl2.c	(working copy)
@@ -1933,8 +1933,7 @@ vague_linkage_p (tree decl)
 	 maybe-in-charge 'tor variants; in that case we need to check one of
 	 the "clones" for the real linkage.  But only in that case; before
 	 maybe_clone_body we haven't yet copied the linkage to the clones.  */
-      if ((DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (decl)
-	   || DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (decl))
+      if (DECL_MAYBE_IN_CHARGE_CDTOR_P (decl)
 	  && !DECL_ABSTRACT_P (decl)
 	  && DECL_CHAIN (decl)
 	  && DECL_CLONED_FUNCTION_P (DECL_CHAIN (decl)))
Index: mangle.c
===================================================================
--- mangle.c	(revision 260252)
+++ mangle.c	(working copy)
@@ -3862,8 +3862,7 @@ mangle_decl (const tree decl)
   if (id != DECL_NAME (decl)
       /* Don't do this for a fake symbol we aren't going to emit anyway.  */
       && TREE_CODE (decl) != TYPE_DECL
-      && !DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (decl)
-      && !DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (decl))
+      && !DECL_MAYBE_IN_CHARGE_CDTOR_P (decl))
     {
       int save_ver = flag_abi_version;
       tree id2 = NULL_TREE;
Index: method.c
===================================================================
--- method.c	(revision 260252)
+++ method.c	(working copy)
@@ -2422,8 +2422,7 @@ lazily_declare_fn (special_function_kind sfk, tree
   fixup_type_variants (type);
 
   maybe_add_class_template_decl_list (type, fn, /*friend_p=*/0);
-  if (DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (fn)
-      || DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (fn))
+  if (DECL_MAYBE_IN_CHARGE_CDTOR_P (fn))
     /* Create appropriate clones.  */
     clone_function_decl (fn, /*update_methods=*/true);
 
Index: optimize.c
===================================================================
--- optimize.c	(revision 260252)
+++ optimize.c	(working copy)
@@ -194,8 +194,7 @@ can_alias_cdtor (tree fn)
   /* ??? Why not use aliases with -frepo?  */
   if (flag_use_repository)
     return false;
-  gcc_assert (DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (fn)
-	      || DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (fn));
+  gcc_assert (DECL_MAYBE_IN_CHARGE_CDTOR_P (fn));
   /* Don't use aliases for weak/linkonce definitions unless we can put both
      symbols in the same COMDAT group.  */
   return (DECL_INTERFACE_KNOWN (fn)
@@ -440,8 +439,7 @@ maybe_clone_body (tree fn)
   bool need_alias = false;
 
   /* We only clone constructors and destructors.  */
-  if (!DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (fn)
-      && !DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (fn))
+  if (!DECL_MAYBE_IN_CHARGE_CDTOR_P (fn))
     return 0;
 
   populate_clone_array (fn, fns);
Index: repo.c
===================================================================
--- repo.c	(revision 260252)
+++ repo.c	(working copy)
@@ -330,8 +330,7 @@ repo_emit_p (tree decl)
   /* For constructors and destructors, the repository contains
      information about the clones -- not the original function --
      because only the clones are emitted in the object file.  */
-  if (DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (decl)
-      || DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (decl))
+  if (DECL_MAYBE_IN_CHARGE_CDTOR_P (decl))
     {
       int emit_p = 0;
       tree clone;
Index: tree.c
===================================================================
--- tree.c	(revision 260252)
+++ tree.c	(working copy)
@@ -5012,8 +5012,7 @@ decl_linkage (tree decl)
 
   /* maybe_thunk_body clears TREE_PUBLIC on the maybe-in-charge 'tor variants,
      check one of the "clones" for the real linkage.  */
-  if ((DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (decl)
-       || DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (decl))
+  if (DECL_MAYBE_IN_CHARGE_CDTOR_P (decl)
       && DECL_CHAIN (decl)
       && DECL_CLONED_FUNCTION_P (DECL_CHAIN (decl)))
     return decl_linkage (DECL_CHAIN (decl));
