OpenMP/C++: Allow classes with static members to be mappable [PR104493]

As this is the last lang-specific user of the omp_mappable_type hook,
the hook is removed, keeping only a generic omp_mappable_type for
incomplete types (or error_node).

	PR c++/104493

gcc/c/ChangeLog:

	* c-decl.cc (c_decl_attributes, finish_decl): Call omp_mappable_type
	instead of removed langhook.
	* c-typeck.cc (c_finish_omp_clauses): Likewise.

gcc/cp/ChangeLog:

	* cp-objcp-common.h (LANG_HOOKS_OMP_MAPPABLE_TYPE): Remove.
	* cp-tree.h (cp_omp_mappable_type, cp_omp_emit_unmappable_type_notes):
	Remove.
	* decl2.cc (cp_omp_mappable_type_1, cp_omp_mappable_type,
	cp_omp_emit_unmappable_type_notes): Remove.
	(cplus_decl_attributes): Call omp_mappable_type instead of
	removed langhook.
	* decl.cc (cp_finish_decl): Likewise; call cxx_incomplete_type_inform
	in lieu of cp_omp_emit_unmappable_type_notes.
	* semantics.cc (finish_omp_clauses): Likewise.

gcc/ChangeLog:

	* gimplify.cc (omp_notice_variable): Call omp_mappable_type
	instead of removed langhook.
	* omp-general.h (omp_mappable_type): New prototype.
	* omp-general.cc (omp_mappable_type):  New; moved from ...
	* langhooks.cc (lhd_omp_mappable_type): ... here.
	* langhooks-def.h (lhd_omp_mappable_type,
	LANG_HOOKS_OMP_MAPPABLE_TYPE): Remove.
	(LANG_HOOKS_FOR_TYPES_INITIALIZER): Remote the latter.
	* langhooks.h (struct lang_hooks_for_types): Remove
	omp_mappable_type.

gcc/testsuite/ChangeLog:

	* g++.dg/gomp/unmappable-1.C: Remove dg-error; remove dg-note no
	longer shown as TYPE_MAIN_DECL is NULL.
	* c-c++-common/gomp/map-incomplete-type.c: New test.

Co-authored-by: Chung-Lin Tang <cltang@codesourcery.com>

5 files changed, 24 insertions, 73 deletions

diff --git a/gcc/cp/cp-objcp-common.h b/gcc/cp/cp-objcp-common.h
index 3c04e5c..1a67f14 100644
--- a/gcc/cp/cp-objcp-common.h
+++ b/gcc/cp/cp-objcp-common.h
@@ -187,8 +187,6 @@ extern tree cxx_simulate_record_decl (location_t, const char *,
 #define LANG_HOOKS_OMP_FINISH_CLAUSE cxx_omp_finish_clause
 #undef LANG_HOOKS_OMP_PRIVATIZE_BY_REFERENCE
 #define LANG_HOOKS_OMP_PRIVATIZE_BY_REFERENCE cxx_omp_privatize_by_reference
-#undef LANG_HOOKS_OMP_MAPPABLE_TYPE
-#define LANG_HOOKS_OMP_MAPPABLE_TYPE cp_omp_mappable_type
 #undef LANG_HOOKS_OMP_DISREGARD_VALUE_EXPR
 #define LANG_HOOKS_OMP_DISREGARD_VALUE_EXPR cxx_omp_disregard_value_expr
 
diff --git a/gcc/cp/cp-tree.h b/gcc/cp/cp-tree.h
index 3278b41..cb23975 100644
--- a/gcc/cp/cp-tree.h
+++ b/gcc/cp/cp-tree.h
@@ -6959,8 +6959,6 @@ extern bool possibly_inlined_p			(tree);
 extern int parm_index                           (tree);
 extern tree vtv_start_verification_constructor_init_function (void);
 extern tree vtv_finish_verification_constructor_init_function (tree);
-extern bool cp_omp_mappable_type		(tree);
-extern bool cp_omp_emit_unmappable_type_notes	(tree);
 extern void cp_check_const_attributes (tree);
 
 /* in error.cc */
diff --git a/gcc/cp/decl.cc b/gcc/cp/decl.cc
index ff56fdd..031be45 100644
--- a/gcc/cp/decl.cc
+++ b/gcc/cp/decl.cc
@@ -8633,11 +8633,13 @@ cp_finish_decl (tree decl, tree init, bool init_const_expr_p,
 	= remove_attribute ("omp declare target implicit",
 			    DECL_ATTRIBUTES (decl));
       complete_type (TREE_TYPE (decl));
-      if (!cp_omp_mappable_type (TREE_TYPE (decl)))
+      if (!omp_mappable_type (TREE_TYPE (decl)))
 	{
 	  error ("%q+D in declare target directive does not have mappable"
 		 " type", decl);
-	  cp_omp_emit_unmappable_type_notes (TREE_TYPE (decl));
+	  if (TREE_TYPE (decl) != error_mark_node
+	      && !COMPLETE_TYPE_P (TREE_TYPE (decl)))
+	    cxx_incomplete_type_inform (TREE_TYPE (decl));
 	}
       else if (!lookup_attribute ("omp declare target",
 				  DECL_ATTRIBUTES (decl))
diff --git a/gcc/cp/decl2.cc b/gcc/cp/decl2.cc
index 3737e5f..89ab254 100644
--- a/gcc/cp/decl2.cc
+++ b/gcc/cp/decl2.cc
@@ -49,6 +49,7 @@ along with GCC; see the file COPYING3.  If not see
 #include "c-family/c-ada-spec.h"
 #include "asan.h"
 #include "optabs-query.h"
+#include "omp-general.h"
 
 /* Id for dumping the raw trees.  */
 int raw_dump_id;
@@ -1578,62 +1579,6 @@ cp_check_const_attributes (tree attributes)
     }
 }
 
-/* Return true if TYPE is an OpenMP mappable type.
-   If NOTES is non-zero, emit a note message for each problem.  */
-static bool
-cp_omp_mappable_type_1 (tree type, bool notes)
-{
-  bool result = true;
-
-  /* Mappable type has to be complete.  */
-  if (type == error_mark_node || !COMPLETE_TYPE_P (type))
-    {
-      if (notes && type != error_mark_node)
-	{
-	  tree decl = TYPE_MAIN_DECL (type);
-	  inform ((decl ? DECL_SOURCE_LOCATION (decl) : input_location),
-		  "incomplete type %qT is not mappable", type);
-	}
-      result = false;
-    }
-  /* Arrays have mappable type if the elements have mappable type.  */
-  while (TREE_CODE (type) == ARRAY_TYPE)
-    type = TREE_TYPE (type);
-  /* 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 (VAR_P (field))
-	  {
-	    if (notes)
-	      inform (DECL_SOURCE_LOCATION (field),
-		      "static field %qD is not mappable", field);
-	    result = false;
-	  }
-	/* All fields must have mappable types.  */
-	else if (TREE_CODE (field) == FIELD_DECL
-		 && !cp_omp_mappable_type_1 (TREE_TYPE (field), notes))
-	  result = false;
-    }
-  return result;
-}
-
-/* Return true if TYPE is an OpenMP mappable type.  */
-bool
-cp_omp_mappable_type (tree type)
-{
-  return cp_omp_mappable_type_1 (type, false);
-}
-
-/* Return true if TYPE is an OpenMP mappable type.
-   Emit an error messages if not.  */
-bool
-cp_omp_emit_unmappable_type_notes (tree type)
-{
-  return cp_omp_mappable_type_1 (type, true);
-}
-
 /* Return the last pushed declaration for the symbol DECL or NULL
    when no such declaration exists.  */
 
@@ -1709,7 +1654,7 @@ cplus_decl_attributes (tree *decl, tree attributes, int flags)
 	       *decl);
       else if (VAR_P (*decl)
 	       && (processing_template_decl
-		   || !cp_omp_mappable_type (TREE_TYPE (*decl))))
+		   || !omp_mappable_type (TREE_TYPE (*decl))))
 	attributes = tree_cons (get_identifier ("omp declare target implicit"),
 				NULL_TREE, attributes);
       else
diff --git a/gcc/cp/semantics.cc b/gcc/cp/semantics.cc
index 16dea05..ae7c8ea 100644
--- a/gcc/cp/semantics.cc
+++ b/gcc/cp/semantics.cc
@@ -7992,13 +7992,15 @@ finish_omp_clauses (tree clauses, enum c_omp_region_type ort)
 		  t = OMP_CLAUSE_DECL (c);
 		  if (TREE_CODE (t) != TREE_LIST
 		      && !type_dependent_expression_p (t)
-		      && !cp_omp_mappable_type (TREE_TYPE (t)))
+		      && !omp_mappable_type (TREE_TYPE (t)))
 		    {
 		      error_at (OMP_CLAUSE_LOCATION (c),
 				"array section does not have mappable type "
 				"in %qs clause",
 				omp_clause_code_name[OMP_CLAUSE_CODE (c)]);
-		      cp_omp_emit_unmappable_type_notes (TREE_TYPE (t));
+		      if (TREE_TYPE (t) != error_mark_node
+			  && !COMPLETE_TYPE_P (TREE_TYPE (t)))
+			cxx_incomplete_type_inform (TREE_TYPE (t));
 		      remove = true;
 		    }
 		  while (TREE_CODE (t) == ARRAY_REF)
@@ -8134,12 +8136,14 @@ finish_omp_clauses (tree clauses, enum c_omp_region_type ort)
 			    t, omp_clause_code_name[OMP_CLAUSE_CODE (c)]);
 		  remove = true;
 		}
-	      else if (!cp_omp_mappable_type (TREE_TYPE (t)))
+	      else if (!omp_mappable_type (TREE_TYPE (t)))
 		{
 		  error_at (OMP_CLAUSE_LOCATION (c),
 			    "%qE does not have a mappable type in %qs clause",
 			    t, omp_clause_code_name[OMP_CLAUSE_CODE (c)]);
-		  cp_omp_emit_unmappable_type_notes (TREE_TYPE (t));
+		  if (TREE_TYPE (t) != error_mark_node
+		      && !COMPLETE_TYPE_P (TREE_TYPE (t)))
+		    cxx_incomplete_type_inform (TREE_TYPE (t));
 		  remove = true;
 		}
 	      while (TREE_CODE (t) == COMPONENT_REF)
@@ -8232,14 +8236,16 @@ finish_omp_clauses (tree clauses, enum c_omp_region_type ort)
 			     == GOMP_MAP_FIRSTPRIVATE_POINTER)))
 		   && t == OMP_CLAUSE_DECL (c)
 		   && !type_dependent_expression_p (t)
-		   && !cp_omp_mappable_type (TYPE_REF_P (TREE_TYPE (t))
-					     ? TREE_TYPE (TREE_TYPE (t))
-					     : TREE_TYPE (t)))
+		   && !omp_mappable_type (TYPE_REF_P (TREE_TYPE (t))
+					  ? TREE_TYPE (TREE_TYPE (t))
+					  : TREE_TYPE (t)))
 	    {
 	      error_at (OMP_CLAUSE_LOCATION (c),
 			"%qD does not have a mappable type in %qs clause", t,
 			omp_clause_code_name[OMP_CLAUSE_CODE (c)]);
-	      cp_omp_emit_unmappable_type_notes (TREE_TYPE (t));
+	      if (TREE_TYPE (t) != error_mark_node
+		  && !COMPLETE_TYPE_P (TREE_TYPE (t)))
+		cxx_incomplete_type_inform (TREE_TYPE (t));
 	      remove = true;
 	    }
 	  else if (OMP_CLAUSE_CODE (c) == OMP_CLAUSE_MAP
@@ -8409,12 +8415,14 @@ finish_omp_clauses (tree clauses, enum c_omp_region_type ort)
 			cname);
 	      remove = true;
 	    }
-	  else if (!cp_omp_mappable_type (TREE_TYPE (t)))
+	  else if (!omp_mappable_type (TREE_TYPE (t)))
 	    {
 	      error_at (OMP_CLAUSE_LOCATION (c),
 			"%qD does not have a mappable type in %qs clause", t,
 			cname);
-	      cp_omp_emit_unmappable_type_notes (TREE_TYPE (t));
+	      if (TREE_TYPE (t) != error_mark_node
+		  && !COMPLETE_TYPE_P (TREE_TYPE (t)))
+		cxx_incomplete_type_inform (TREE_TYPE (t));
 	      remove = true;
 	    }
 	  if (remove)