diff mbox series

[05/16] Remove base_ind/base_ref handling from extract_base_bit_offset

Message ID 20211125140843.111405-1-julian@codesourcery.com
State New
Headers show
Series OpenMP: lvalues in "map" clauses and struct handling rework | expand

Commit Message

Julian Brown Nov. 25, 2021, 2:08 p.m. UTC 
In preparation for follow-up patches extending struct dereference
handling for OpenMP, this patch removes base_ind/base_ref handling from
gimplify.c:extract_base_bit_offset. This arguably simplifies some of the
code around the callers of the function also, though subsequent patches
modify those parts further.

(This one has already been approved, pending approval of the rest of
the series:
https://gcc.gnu.org/pipermail/gcc-patches/2021-October/581426.html)

2021-09-29  Julian Brown  <julian@codesourcery.com>

gcc/
	* gimplify.c (extract_base_bit_offset): Remove BASE_IND, BASE_REF and
	OPENMP parameters.
	(strip_indirections): New function.
	(build_struct_group): Update calls to extract_base_bit_offset.
	Rearrange indirect/reference handling accordingly.  Use extracted base
	instead of passed-in decl when grouping component accesses together.
---
 gcc/gimplify.c | 109 ++++++++++++++++++++++++++-----------------------
 1 file changed, 57 insertions(+), 52 deletions(-)
diff mbox series

Patch

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;