diff --git a/gcc/gimplify.c b/gcc/gimplify.c
index fcc278d07cf..73b839daa09 100644
--- a/gcc/gimplify.c
+++ b/gcc/gimplify.c
@@ -8658,9 +8658,8 @@ build_struct_comp_nodes (enum tree_code code, tree grp_start, tree grp_end,
    has array type, else return NULL.  */
 
 static tree
-extract_base_bit_offset (tree base, tree *base_ind, tree *base_ref,
-			 poly_int64 *bitposp, poly_offset_int *poffsetp,
-			 tree *offsetp, bool openmp)
+extract_base_bit_offset (tree base, poly_int64 *bitposp,
+			 poly_offset_int *poffsetp, tree *offsetp)
 {
   tree offset;
   poly_int64 bitsize, bitpos;
@@ -8668,38 +8667,12 @@ extract_base_bit_offset (tree base, tree *base_ind, tree *base_ref,
   int unsignedp, reversep, volatilep = 0;
   poly_offset_int poffset;
 
-  if (base_ind)
-    *base_ind = NULL_TREE;
-
-  if (base_ref)
-    *base_ref = NULL_TREE;
+  STRIP_NOPS (base);
 
   base = get_inner_reference (base, &bitsize, &bitpos, &offset, &mode,
 			      &unsignedp, &reversep, &volatilep);
 
-  if (!openmp
-      && (TREE_CODE (base) == INDIRECT_REF
-	  || (TREE_CODE (base) == MEM_REF
-	      && integer_zerop (TREE_OPERAND (base, 1))))
-      && TREE_CODE (TREE_TYPE (TREE_OPERAND (base, 0))) == POINTER_TYPE)
-    {
-      if (base_ind)
-	*base_ind = base;
-      base = TREE_OPERAND (base, 0);
-    }
-  if ((TREE_CODE (base) == INDIRECT_REF
-       || (TREE_CODE (base) == MEM_REF
-	   && integer_zerop (TREE_OPERAND (base, 1))))
-      && DECL_P (TREE_OPERAND (base, 0))
-      && TREE_CODE (TREE_TYPE (TREE_OPERAND (base, 0))) == REFERENCE_TYPE)
-    {
-      if (base_ref)
-	*base_ref = base;
-      base = TREE_OPERAND (base, 0);
-    }
-
-  if (!openmp)
-    STRIP_NOPS (base);
+  STRIP_NOPS (base);
 
   if (offset && poly_int_tree_p (offset))
     {
@@ -8756,6 +8729,17 @@ strip_components_and_deref (tree expr)
   return expr;
 }
 
+static tree
+strip_indirections (tree expr)
+{
+  while (TREE_CODE (expr) == INDIRECT_REF
+	 || (TREE_CODE (expr) == MEM_REF
+	     && integer_zerop (TREE_OPERAND (expr, 1))))
+    expr = TREE_OPERAND (expr, 0);
+
+  return expr;
+}
+
 /* Return TRUE if EXPR is something we will use as the base of an aggregate
    access, either:
 
@@ -9249,7 +9233,7 @@ build_struct_group (struct gimplify_omp_ctx *ctx,
 {
   poly_offset_int coffset;
   poly_int64 cbitpos;
-  tree base_ind, base_ref, tree_coffset;
+  tree tree_coffset;
   tree ocd = OMP_CLAUSE_DECL (c);
   bool openmp = !(region_type & ORT_ACC);
 
@@ -9259,10 +9243,25 @@ build_struct_group (struct gimplify_omp_ctx *ctx,
   if (TREE_CODE (ocd) == INDIRECT_REF)
     ocd = TREE_OPERAND (ocd, 0);
 
-  tree base = extract_base_bit_offset (ocd, &base_ind, &base_ref, &cbitpos,
-				       &coffset, &tree_coffset, openmp);
+  tree base = extract_base_bit_offset (ocd, &cbitpos, &coffset, &tree_coffset);
+  tree sbase;
 
-  bool do_map_struct = (base == decl && !tree_coffset);
+  if (openmp)
+    {
+      if (TREE_CODE (base) == INDIRECT_REF
+	  && TREE_CODE (TREE_TYPE (TREE_OPERAND (base, 0))) == REFERENCE_TYPE)
+	sbase = strip_indirections (base);
+      else
+	sbase = base;
+    }
+  else
+    {
+      sbase = strip_indirections (base);
+
+      STRIP_NOPS (sbase);
+    }
+
+  bool do_map_struct = (sbase == decl && !tree_coffset);
 
   /* Here, DECL is usually a DECL_P, unless we have chained indirect member
      accesses, e.g. mystruct->a->b.  In that case it'll be the "mystruct->a"
@@ -9322,19 +9321,12 @@ build_struct_group (struct gimplify_omp_ctx *ctx,
 
       OMP_CLAUSE_SET_MAP_KIND (l, k);
 
-      if (!openmp && base_ind)
-	OMP_CLAUSE_DECL (l) = unshare_expr (base_ind);
-      else if (base_ref)
-	OMP_CLAUSE_DECL (l) = unshare_expr (base_ref);
-      else
-	{
-	  OMP_CLAUSE_DECL (l) = unshare_expr (decl);
-	  if (openmp
-	      && !DECL_P (OMP_CLAUSE_DECL (l))
-	      && (gimplify_expr (&OMP_CLAUSE_DECL (l), pre_p, NULL,
-				 is_gimple_lvalue, fb_lvalue) == GS_ERROR))
-	    return error_mark_node;
-	}
+      OMP_CLAUSE_DECL (l) = unshare_expr (base);
+      if (openmp
+	  && !DECL_P (OMP_CLAUSE_DECL (l))
+	  && (gimplify_expr (&OMP_CLAUSE_DECL (l), pre_p, NULL,
+			     is_gimple_lvalue, fb_lvalue) == GS_ERROR))
+	return error_mark_node;
       OMP_CLAUSE_SIZE (l)
 	= (!attach ? size_int (1)
 	   : (DECL_P (OMP_CLAUSE_DECL (l))
@@ -9370,6 +9362,20 @@ build_struct_group (struct gimplify_omp_ctx *ctx,
       else
 	list_p = insert_node_after (l, list_p);
 
+      bool base_ref
+	= (TREE_CODE (base) == INDIRECT_REF
+	   && ((TREE_CODE (TREE_TYPE (TREE_OPERAND (base, 0)))
+		== REFERENCE_TYPE)
+	       || ((TREE_CODE (TREE_OPERAND (base, 0)) == INDIRECT_REF)
+		   && (TREE_CODE (TREE_TYPE (TREE_OPERAND
+					      (TREE_OPERAND (base, 0), 0)))
+		       == REFERENCE_TYPE))));
+      bool base_ind = ((TREE_CODE (base) == INDIRECT_REF
+			|| (TREE_CODE (base) == MEM_REF
+			    && integer_zerop (TREE_OPERAND (base, 1))))
+		       && (TREE_CODE (TREE_TYPE (TREE_OPERAND (base, 0)))
+			   == POINTER_TYPE));
+
 	/* Handle pointers to structs and references to structs: these cases
 	   have an additional GOMP_MAP_FIRSTPRIVATE_{REFERENCE,POINTER} node
 	   inserted after the GOMP_MAP_STRUCT node.  References to pointers
@@ -9502,10 +9508,9 @@ build_struct_group (struct gimplify_omp_ctx *ctx,
 			 == REFERENCE_TYPE))
 	      sc_decl = TREE_OPERAND (sc_decl, 0);
 
-	    tree base = extract_base_bit_offset (sc_decl, NULL, NULL,
-						 &bitpos, &offset,
-						 &tree_offset, openmp);
-	    if (!base || !operand_equal_p (base, decl, 0))
+	    tree base2 = extract_base_bit_offset (sc_decl, &bitpos, &offset,
+						  &tree_offset);
+	    if (!base2 || !operand_equal_p (base2, base, 0))
 	      break;
 	    if (scp)
 	      continue;
