Re: [PATCH v2 01/11] OpenMP 5.0: Clause ordering for OpenMP 5.0 (topological sorting by base pointer)

[Jakub Jelinek <jakub@redhat.com>]

On Fri, Mar 18, 2022 at 09:24:51AM -0700, Julian Brown wrote:
> 2021-11-23  Julian Brown  <julian@codesourcery.com>
> 
> gcc/
> 	* gimplify.c (is_or_contains_p, omp_target_reorder_clauses): Delete
> 	functions.
> 	(omp_tsort_mark): Add enum.
> 	(omp_mapping_group): Add struct.
> 	(debug_mapping_group, omp_get_base_pointer, omp_get_attachment,
> 	omp_group_last, omp_gather_mapping_groups, omp_group_base,
> 	omp_index_mapping_groups, omp_containing_struct,
> 	omp_tsort_mapping_groups_1, omp_tsort_mapping_groups,
> 	omp_segregate_mapping_groups, omp_reorder_mapping_groups): New
> 	functions.
> 	(gimplify_scan_omp_clauses): Call above functions instead of
> 	omp_target_reorder_clauses, unless we've seen an error.
> 	* omp-low.c (scan_sharing_clauses): Avoid strict test if we haven't
> 	sorted mapping groups.
> 
> gcc/testsuite/
> 	* g++.dg/gomp/target-lambda-1.C: Adjust expected output.
> 	* g++.dg/gomp/target-this-3.C: Likewise.
> 	* g++.dg/gomp/target-this-4.C: Likewise.
> +

Wouldn't hurt to add a comment on the meanings of the enumerators.

> +enum omp_tsort_mark {
> +  UNVISITED,
> +  TEMPORARY,
> +  PERMANENT
> +};
> +
> +struct omp_mapping_group {
> +  tree *grp_start;
> +  tree grp_end;
> +  omp_tsort_mark mark;
> +  struct omp_mapping_group *sibling;
> +  struct omp_mapping_group *next;
> +};
> +
> +__attribute__((used)) static void

I'd use what is used elsewhere,
DEBUG_FUNCTION void
without static.

> +debug_mapping_group (omp_mapping_group *grp)
> +{
> +  tree tmp = OMP_CLAUSE_CHAIN (grp->grp_end);
> +  OMP_CLAUSE_CHAIN (grp->grp_end) = NULL;
> +  debug_generic_expr (*grp->grp_start);
> +  OMP_CLAUSE_CHAIN (grp->grp_end) = tmp;
> +}
> +
> +/* Return the OpenMP "base pointer" of an expression EXPR, or NULL if there
> +   isn't one.  This needs improvement.  */
> +
> +static tree
> +omp_get_base_pointer (tree expr)
> +{
> +  while (TREE_CODE (expr) == ARRAY_REF)
> +    expr = TREE_OPERAND (expr, 0);
> +
> +  while (TREE_CODE (expr) == COMPONENT_REF
> +	 && (DECL_P (TREE_OPERAND (expr, 0))
> +	     || (TREE_CODE (TREE_OPERAND (expr, 0)) == COMPONENT_REF)
> +	     || TREE_CODE (TREE_OPERAND (expr, 0)) == INDIRECT_REF
> +	     || (TREE_CODE (TREE_OPERAND (expr, 0)) == MEM_REF
> +		 && integer_zerop (TREE_OPERAND (TREE_OPERAND (expr, 0), 1)))
> +	     || TREE_CODE (TREE_OPERAND (expr, 0)) == ARRAY_REF))
> +    {
> +      expr = TREE_OPERAND (expr, 0);
> +
> +      while (TREE_CODE (expr) == ARRAY_REF)
> +	expr = TREE_OPERAND (expr, 0);
> +
> +      if (TREE_CODE (expr) == INDIRECT_REF || TREE_CODE (expr) == MEM_REF)
> +	break;
> +    }

I must say I don't see advantages of just a single loop that
looks through all ARRAY_REFs and all COMPONENT_REFs and then just
checks if the expr it got in the end is a decl or INDIRECT_REF
or MEM_REF with offset 0.

> +  if (DECL_P (expr))
> +    return NULL_TREE;
> +
> +  if (TREE_CODE (expr) == INDIRECT_REF
> +      || TREE_CODE (expr) == MEM_REF)
> +    {
> +      expr = TREE_OPERAND (expr, 0);
> +      while (TREE_CODE (expr) == COMPOUND_EXPR)
> +	expr = TREE_OPERAND (expr, 1);
> +      if (TREE_CODE (expr) == POINTER_PLUS_EXPR)
> +	expr = TREE_OPERAND (expr, 0);
> +      if (TREE_CODE (expr) == SAVE_EXPR)
> +	expr = TREE_OPERAND (expr, 0);
> +      STRIP_NOPS (expr);
> +      return expr;
> +    }
> +
> +  return NULL_TREE;
> +}
> +

> +static tree
> +omp_containing_struct (tree expr)
> +{
> +  tree expr0 = expr;
> +
> +  STRIP_NOPS (expr);
> +
> +  tree expr1 = expr;
> +
> +  /* FIXME: other types of accessors?  */
> +  while (TREE_CODE (expr) == ARRAY_REF)
> +    expr = TREE_OPERAND (expr, 0);
> +
> +  if (TREE_CODE (expr) == COMPONENT_REF)
> +    {
> +      if (DECL_P (TREE_OPERAND (expr, 0))
> +	  || TREE_CODE (TREE_OPERAND (expr, 0)) == COMPONENT_REF
> +	  || TREE_CODE (TREE_OPERAND (expr, 0)) == INDIRECT_REF
> +	  || (TREE_CODE (TREE_OPERAND (expr, 0)) == MEM_REF
> +	      && integer_zerop (TREE_OPERAND (TREE_OPERAND (expr, 0), 1)))
> +	  || TREE_CODE (TREE_OPERAND (expr, 0)) == ARRAY_REF)
> +	expr = TREE_OPERAND (expr, 0);
> +      else
> +	internal_error ("unhandled component");
> +    }

Again?

> @@ -9063,11 +9820,29 @@ gimplify_scan_omp_clauses (tree *list_p, gimple_seq *pre_p,
>  	break;
>        }
>  
> -  if (code == OMP_TARGET
> -      || code == OMP_TARGET_DATA
> -      || code == OMP_TARGET_ENTER_DATA
> -      || code == OMP_TARGET_EXIT_DATA)
> -    omp_target_reorder_clauses (list_p);
> +  /* Topological sorting may fail if we have duplicate nodes, which
> +     we should have detected and shown an error for already.  Skip
> +     sorting in that case.  */
> +  if (!seen_error ()
> +      && (code == OMP_TARGET
> +	  || code == OMP_TARGET_DATA
> +	  || code == OMP_TARGET_ENTER_DATA
> +	  || code == OMP_TARGET_EXIT_DATA))
> +    {
> +      vec<omp_mapping_group> *groups;
> +      groups = omp_gather_mapping_groups (list_p);
> +      if (groups)
> +	{
> +	  hash_map<tree_operand_hash, omp_mapping_group *> *grpmap;
> +	  grpmap = omp_index_mapping_groups (groups);
> +	  omp_mapping_group *outlist
> +	    = omp_tsort_mapping_groups (groups, grpmap);
> +	  outlist = omp_segregate_mapping_groups (outlist);
> +	  list_p = omp_reorder_mapping_groups (groups, outlist, list_p);
> +	  delete grpmap;
> +	  delete groups;
> +	}
> +    }

I think big question is if we do want to do this map clause reordering
before processing the  omp target etc. clauses, or after (during
gimplify_adjust_omp_clauses, when clauses from the implicit mappings
are added too and especially with the declare mapper expansions),
or both before and after.

>    while ((c = *list_p) != NULL)
>      {
> diff --git a/gcc/omp-low.cc b/gcc/omp-low.cc
> index c33b3daa439..ffeb1f34fd7 100644
> --- a/gcc/omp-low.cc
> +++ b/gcc/omp-low.cc
> @@ -1537,8 +1537,11 @@ scan_sharing_clauses (tree clauses, omp_context *ctx)
>  	    {
>  	      /* If this is an offloaded region, an attach operation should
>  		 only exist when the pointer variable is mapped in a prior
> -		 clause.  */
> -	      if (is_gimple_omp_offloaded (ctx->stmt))
> +		 clause.
> +		 If we had an error, we may not have attempted to sort clauses
> +		 properly, so avoid the test.  */
> +	      if (is_gimple_omp_offloaded (ctx->stmt)
> +		  && !seen_error ())

If we encounter a major error during processing map clauses, we should consider
just leaving out the offloading construct from the IL.

	Jakub