Factor out duplicate code in gimplify_scan_omp_clauses
gcc/ * gimplify.c (insert_struct_comp_map, extract_base_bit_offset): New. (gimplify_scan_omp_clauses): Outline duplicated code into calls to above two functions. From-SVN: r279623
This commit is contained in:
parent
5bcd470bf0
commit
4d83edf7ef
|
@ -1,3 +1,9 @@
|
||||||
|
2019-12-19 Julian Brown <julian@codesourcery.com>
|
||||||
|
|
||||||
|
* gimplify.c (insert_struct_comp_map, extract_base_bit_offset): New.
|
||||||
|
(gimplify_scan_omp_clauses): Outline duplicated code into calls to
|
||||||
|
above two functions.
|
||||||
|
|
||||||
2019-12-19 Vladimir Makarov <vmakarov@redhat.com>
|
2019-12-19 Vladimir Makarov <vmakarov@redhat.com>
|
||||||
|
|
||||||
PR target/92905
|
PR target/92905
|
||||||
|
|
290
gcc/gimplify.c
290
gcc/gimplify.c
|
@ -8186,6 +8186,138 @@ gimplify_omp_depend (tree *list_p, gimple_seq *pre_p)
|
||||||
return 1;
|
return 1;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
/* Insert a GOMP_MAP_ALLOC or GOMP_MAP_RELEASE node following a
|
||||||
|
GOMP_MAP_STRUCT mapping. C is an always_pointer mapping. STRUCT_NODE is
|
||||||
|
the struct node to insert the new mapping after (when the struct node is
|
||||||
|
initially created). PREV_NODE is the first of two or three mappings for a
|
||||||
|
pointer, and is either:
|
||||||
|
- the node before C, when a pair of mappings is used, e.g. for a C/C++
|
||||||
|
array section.
|
||||||
|
- not the node before C. This is true when we have a reference-to-pointer
|
||||||
|
type (with a mapping for the reference and for the pointer), or for
|
||||||
|
Fortran derived-type mappings with a GOMP_MAP_TO_PSET.
|
||||||
|
If SCP is non-null, the new node is inserted before *SCP.
|
||||||
|
if SCP is null, the new node is inserted before PREV_NODE.
|
||||||
|
The return type is:
|
||||||
|
- PREV_NODE, if SCP is non-null.
|
||||||
|
- The newly-created ALLOC or RELEASE node, if SCP is null.
|
||||||
|
- The second newly-created ALLOC or RELEASE node, if we are mapping a
|
||||||
|
reference to a pointer. */
|
||||||
|
|
||||||
|
static tree
|
||||||
|
insert_struct_comp_map (enum tree_code code, tree c, tree struct_node,
|
||||||
|
tree prev_node, tree *scp)
|
||||||
|
{
|
||||||
|
enum gomp_map_kind mkind
|
||||||
|
= code == OMP_TARGET_EXIT_DATA ? GOMP_MAP_RELEASE : GOMP_MAP_ALLOC;
|
||||||
|
|
||||||
|
tree c2 = build_omp_clause (OMP_CLAUSE_LOCATION (c), OMP_CLAUSE_MAP);
|
||||||
|
tree cl = scp ? prev_node : c2;
|
||||||
|
OMP_CLAUSE_SET_MAP_KIND (c2, mkind);
|
||||||
|
OMP_CLAUSE_DECL (c2) = unshare_expr (OMP_CLAUSE_DECL (c));
|
||||||
|
OMP_CLAUSE_CHAIN (c2) = scp ? *scp : prev_node;
|
||||||
|
OMP_CLAUSE_SIZE (c2) = TYPE_SIZE_UNIT (ptr_type_node);
|
||||||
|
if (struct_node)
|
||||||
|
OMP_CLAUSE_CHAIN (struct_node) = c2;
|
||||||
|
|
||||||
|
/* We might need to create an additional mapping if we have a reference to a
|
||||||
|
pointer (in C++). */
|
||||||
|
if (OMP_CLAUSE_CHAIN (prev_node) != c)
|
||||||
|
{
|
||||||
|
tree c4 = OMP_CLAUSE_CHAIN (prev_node);
|
||||||
|
tree c3 = build_omp_clause (OMP_CLAUSE_LOCATION (c), OMP_CLAUSE_MAP);
|
||||||
|
OMP_CLAUSE_SET_MAP_KIND (c3, mkind);
|
||||||
|
OMP_CLAUSE_DECL (c3) = unshare_expr (OMP_CLAUSE_DECL (c4));
|
||||||
|
OMP_CLAUSE_SIZE (c3) = TYPE_SIZE_UNIT (ptr_type_node);
|
||||||
|
OMP_CLAUSE_CHAIN (c3) = prev_node;
|
||||||
|
if (!scp)
|
||||||
|
OMP_CLAUSE_CHAIN (c2) = c3;
|
||||||
|
else
|
||||||
|
cl = c3;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (scp)
|
||||||
|
*scp = c2;
|
||||||
|
|
||||||
|
return cl;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* Strip ARRAY_REFS or an indirect ref off BASE, find the containing object,
|
||||||
|
and set *BITPOSP and *POFFSETP to the bit offset of the access.
|
||||||
|
If BASE_REF is non-NULL and the containing object is a reference, set
|
||||||
|
*BASE_REF to that reference before dereferencing the object.
|
||||||
|
If BASE_REF is NULL, check that the containing object is a COMPONENT_REF or
|
||||||
|
has array type, else return NULL. */
|
||||||
|
|
||||||
|
static tree
|
||||||
|
extract_base_bit_offset (tree base, tree *base_ref, poly_int64 *bitposp,
|
||||||
|
poly_offset_int *poffsetp)
|
||||||
|
{
|
||||||
|
tree offset;
|
||||||
|
poly_int64 bitsize, bitpos;
|
||||||
|
machine_mode mode;
|
||||||
|
int unsignedp, reversep, volatilep = 0;
|
||||||
|
poly_offset_int poffset;
|
||||||
|
|
||||||
|
if (base_ref)
|
||||||
|
{
|
||||||
|
*base_ref = NULL_TREE;
|
||||||
|
|
||||||
|
while (TREE_CODE (base) == ARRAY_REF)
|
||||||
|
base = TREE_OPERAND (base, 0);
|
||||||
|
|
||||||
|
if (TREE_CODE (base) == INDIRECT_REF)
|
||||||
|
base = TREE_OPERAND (base, 0);
|
||||||
|
}
|
||||||
|
else
|
||||||
|
{
|
||||||
|
if (TREE_CODE (base) == ARRAY_REF)
|
||||||
|
{
|
||||||
|
while (TREE_CODE (base) == ARRAY_REF)
|
||||||
|
base = TREE_OPERAND (base, 0);
|
||||||
|
if (TREE_CODE (base) != COMPONENT_REF
|
||||||
|
|| TREE_CODE (TREE_TYPE (base)) != ARRAY_TYPE)
|
||||||
|
return NULL_TREE;
|
||||||
|
}
|
||||||
|
else if (TREE_CODE (base) == INDIRECT_REF
|
||||||
|
&& TREE_CODE (TREE_OPERAND (base, 0)) == COMPONENT_REF
|
||||||
|
&& (TREE_CODE (TREE_TYPE (TREE_OPERAND (base, 0)))
|
||||||
|
== REFERENCE_TYPE))
|
||||||
|
base = TREE_OPERAND (base, 0);
|
||||||
|
}
|
||||||
|
|
||||||
|
base = get_inner_reference (base, &bitsize, &bitpos, &offset, &mode,
|
||||||
|
&unsignedp, &reversep, &volatilep);
|
||||||
|
|
||||||
|
tree orig_base = base;
|
||||||
|
|
||||||
|
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)
|
||||||
|
base = TREE_OPERAND (base, 0);
|
||||||
|
|
||||||
|
gcc_assert (offset == NULL_TREE || poly_int_tree_p (offset));
|
||||||
|
|
||||||
|
if (offset)
|
||||||
|
poffset = wi::to_poly_offset (offset);
|
||||||
|
else
|
||||||
|
poffset = 0;
|
||||||
|
|
||||||
|
if (maybe_ne (bitpos, 0))
|
||||||
|
poffset += bits_to_bytes_round_down (bitpos);
|
||||||
|
|
||||||
|
*bitposp = bitpos;
|
||||||
|
*poffsetp = poffset;
|
||||||
|
|
||||||
|
/* Set *BASE_REF if BASE was a dereferenced reference variable. */
|
||||||
|
if (base_ref && orig_base != base)
|
||||||
|
*base_ref = orig_base;
|
||||||
|
|
||||||
|
return base;
|
||||||
|
}
|
||||||
|
|
||||||
/* Scan the OMP clauses in *LIST_P, installing mappings into a new
|
/* Scan the OMP clauses in *LIST_P, installing mappings into a new
|
||||||
and previous omp contexts. */
|
and previous omp contexts. */
|
||||||
|
|
||||||
|
@ -8738,29 +8870,15 @@ gimplify_scan_omp_clauses (tree *list_p, gimple_seq *pre_p,
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
tree offset;
|
poly_offset_int offset1;
|
||||||
poly_int64 bitsize, bitpos;
|
poly_int64 bitpos1;
|
||||||
machine_mode mode;
|
tree base_ref;
|
||||||
int unsignedp, reversep, volatilep = 0;
|
|
||||||
tree base = OMP_CLAUSE_DECL (c);
|
tree base
|
||||||
while (TREE_CODE (base) == ARRAY_REF)
|
= extract_base_bit_offset (OMP_CLAUSE_DECL (c), &base_ref,
|
||||||
base = TREE_OPERAND (base, 0);
|
&bitpos1, &offset1);
|
||||||
if (TREE_CODE (base) == INDIRECT_REF)
|
|
||||||
base = TREE_OPERAND (base, 0);
|
gcc_assert (base == decl);
|
||||||
base = get_inner_reference (base, &bitsize, &bitpos, &offset,
|
|
||||||
&mode, &unsignedp, &reversep,
|
|
||||||
&volatilep);
|
|
||||||
tree orig_base = base;
|
|
||||||
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))
|
|
||||||
base = TREE_OPERAND (base, 0);
|
|
||||||
gcc_assert (base == decl
|
|
||||||
&& (offset == NULL_TREE
|
|
||||||
|| poly_int_tree_p (offset)));
|
|
||||||
|
|
||||||
splay_tree_node n
|
splay_tree_node n
|
||||||
= splay_tree_lookup (ctx->variables, (splay_tree_key)decl);
|
= splay_tree_lookup (ctx->variables, (splay_tree_key)decl);
|
||||||
|
@ -8771,8 +8889,8 @@ gimplify_scan_omp_clauses (tree *list_p, gimple_seq *pre_p,
|
||||||
tree l = build_omp_clause (OMP_CLAUSE_LOCATION (c),
|
tree l = build_omp_clause (OMP_CLAUSE_LOCATION (c),
|
||||||
OMP_CLAUSE_MAP);
|
OMP_CLAUSE_MAP);
|
||||||
OMP_CLAUSE_SET_MAP_KIND (l, GOMP_MAP_STRUCT);
|
OMP_CLAUSE_SET_MAP_KIND (l, GOMP_MAP_STRUCT);
|
||||||
if (orig_base != base)
|
if (base_ref)
|
||||||
OMP_CLAUSE_DECL (l) = unshare_expr (orig_base);
|
OMP_CLAUSE_DECL (l) = unshare_expr (base_ref);
|
||||||
else
|
else
|
||||||
OMP_CLAUSE_DECL (l) = decl;
|
OMP_CLAUSE_DECL (l) = decl;
|
||||||
OMP_CLAUSE_SIZE (l) = size_int (1);
|
OMP_CLAUSE_SIZE (l) = size_int (1);
|
||||||
|
@ -8781,32 +8899,8 @@ gimplify_scan_omp_clauses (tree *list_p, gimple_seq *pre_p,
|
||||||
struct_map_to_clause->put (decl, l);
|
struct_map_to_clause->put (decl, l);
|
||||||
if (ptr)
|
if (ptr)
|
||||||
{
|
{
|
||||||
enum gomp_map_kind mkind
|
insert_struct_comp_map (code, c, l, *prev_list_p,
|
||||||
= code == OMP_TARGET_EXIT_DATA
|
NULL);
|
||||||
? GOMP_MAP_RELEASE : GOMP_MAP_ALLOC;
|
|
||||||
tree c2 = build_omp_clause (OMP_CLAUSE_LOCATION (c),
|
|
||||||
OMP_CLAUSE_MAP);
|
|
||||||
OMP_CLAUSE_SET_MAP_KIND (c2, mkind);
|
|
||||||
OMP_CLAUSE_DECL (c2)
|
|
||||||
= unshare_expr (OMP_CLAUSE_DECL (c));
|
|
||||||
OMP_CLAUSE_CHAIN (c2) = *prev_list_p;
|
|
||||||
OMP_CLAUSE_SIZE (c2)
|
|
||||||
= TYPE_SIZE_UNIT (ptr_type_node);
|
|
||||||
OMP_CLAUSE_CHAIN (l) = c2;
|
|
||||||
if (OMP_CLAUSE_CHAIN (*prev_list_p) != c)
|
|
||||||
{
|
|
||||||
tree c4 = OMP_CLAUSE_CHAIN (*prev_list_p);
|
|
||||||
tree c3
|
|
||||||
= build_omp_clause (OMP_CLAUSE_LOCATION (c),
|
|
||||||
OMP_CLAUSE_MAP);
|
|
||||||
OMP_CLAUSE_SET_MAP_KIND (c3, mkind);
|
|
||||||
OMP_CLAUSE_DECL (c3)
|
|
||||||
= unshare_expr (OMP_CLAUSE_DECL (c4));
|
|
||||||
OMP_CLAUSE_SIZE (c3)
|
|
||||||
= TYPE_SIZE_UNIT (ptr_type_node);
|
|
||||||
OMP_CLAUSE_CHAIN (c3) = *prev_list_p;
|
|
||||||
OMP_CLAUSE_CHAIN (c2) = c3;
|
|
||||||
}
|
|
||||||
*prev_list_p = l;
|
*prev_list_p = l;
|
||||||
prev_list_p = NULL;
|
prev_list_p = NULL;
|
||||||
}
|
}
|
||||||
|
@ -8816,7 +8910,7 @@ gimplify_scan_omp_clauses (tree *list_p, gimple_seq *pre_p,
|
||||||
*list_p = l;
|
*list_p = l;
|
||||||
list_p = &OMP_CLAUSE_CHAIN (l);
|
list_p = &OMP_CLAUSE_CHAIN (l);
|
||||||
}
|
}
|
||||||
if (orig_base != base && code == OMP_TARGET)
|
if (base_ref && code == OMP_TARGET)
|
||||||
{
|
{
|
||||||
tree c2 = build_omp_clause (OMP_CLAUSE_LOCATION (c),
|
tree c2 = build_omp_clause (OMP_CLAUSE_LOCATION (c),
|
||||||
OMP_CLAUSE_MAP);
|
OMP_CLAUSE_MAP);
|
||||||
|
@ -8839,13 +8933,6 @@ gimplify_scan_omp_clauses (tree *list_p, gimple_seq *pre_p,
|
||||||
tree *sc = NULL, *scp = NULL;
|
tree *sc = NULL, *scp = NULL;
|
||||||
if (GOMP_MAP_ALWAYS_P (OMP_CLAUSE_MAP_KIND (c)) || ptr)
|
if (GOMP_MAP_ALWAYS_P (OMP_CLAUSE_MAP_KIND (c)) || ptr)
|
||||||
n->value |= GOVD_SEEN;
|
n->value |= GOVD_SEEN;
|
||||||
poly_offset_int o1, o2;
|
|
||||||
if (offset)
|
|
||||||
o1 = wi::to_poly_offset (offset);
|
|
||||||
else
|
|
||||||
o1 = 0;
|
|
||||||
if (maybe_ne (bitpos, 0))
|
|
||||||
o1 += bits_to_bytes_round_down (bitpos);
|
|
||||||
sc = &OMP_CLAUSE_CHAIN (*osc);
|
sc = &OMP_CLAUSE_CHAIN (*osc);
|
||||||
if (*sc != c
|
if (*sc != c
|
||||||
&& (OMP_CLAUSE_MAP_KIND (*sc)
|
&& (OMP_CLAUSE_MAP_KIND (*sc)
|
||||||
|
@ -8863,44 +8950,16 @@ gimplify_scan_omp_clauses (tree *list_p, gimple_seq *pre_p,
|
||||||
break;
|
break;
|
||||||
else
|
else
|
||||||
{
|
{
|
||||||
tree offset2;
|
tree sc_decl = OMP_CLAUSE_DECL (*sc);
|
||||||
poly_int64 bitsize2, bitpos2;
|
poly_offset_int offsetn;
|
||||||
base = OMP_CLAUSE_DECL (*sc);
|
poly_int64 bitposn;
|
||||||
if (TREE_CODE (base) == ARRAY_REF)
|
tree base
|
||||||
{
|
= extract_base_bit_offset (sc_decl, NULL,
|
||||||
while (TREE_CODE (base) == ARRAY_REF)
|
&bitposn, &offsetn);
|
||||||
base = TREE_OPERAND (base, 0);
|
|
||||||
if (TREE_CODE (base) != COMPONENT_REF
|
|
||||||
|| (TREE_CODE (TREE_TYPE (base))
|
|
||||||
!= ARRAY_TYPE))
|
|
||||||
break;
|
|
||||||
}
|
|
||||||
else if (TREE_CODE (base) == INDIRECT_REF
|
|
||||||
&& (TREE_CODE (TREE_OPERAND (base, 0))
|
|
||||||
== COMPONENT_REF)
|
|
||||||
&& (TREE_CODE (TREE_TYPE
|
|
||||||
(TREE_OPERAND (base, 0)))
|
|
||||||
== REFERENCE_TYPE))
|
|
||||||
base = TREE_OPERAND (base, 0);
|
|
||||||
base = get_inner_reference (base, &bitsize2,
|
|
||||||
&bitpos2, &offset2,
|
|
||||||
&mode, &unsignedp,
|
|
||||||
&reversep, &volatilep);
|
|
||||||
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))
|
|
||||||
base = TREE_OPERAND (base, 0);
|
|
||||||
if (base != decl)
|
if (base != decl)
|
||||||
break;
|
break;
|
||||||
if (scp)
|
if (scp)
|
||||||
continue;
|
continue;
|
||||||
gcc_assert (offset2 == NULL_TREE
|
|
||||||
|| poly_int_tree_p (offset2));
|
|
||||||
tree d1 = OMP_CLAUSE_DECL (*sc);
|
tree d1 = OMP_CLAUSE_DECL (*sc);
|
||||||
tree d2 = OMP_CLAUSE_DECL (c);
|
tree d2 = OMP_CLAUSE_DECL (c);
|
||||||
while (TREE_CODE (d1) == ARRAY_REF)
|
while (TREE_CODE (d1) == ARRAY_REF)
|
||||||
|
@ -8929,14 +8988,9 @@ gimplify_scan_omp_clauses (tree *list_p, gimple_seq *pre_p,
|
||||||
remove = true;
|
remove = true;
|
||||||
break;
|
break;
|
||||||
}
|
}
|
||||||
if (offset2)
|
if (maybe_lt (offset1, offsetn)
|
||||||
o2 = wi::to_poly_offset (offset2);
|
|| (known_eq (offset1, offsetn)
|
||||||
else
|
&& maybe_lt (bitpos1, bitposn)))
|
||||||
o2 = 0;
|
|
||||||
o2 += bits_to_bytes_round_down (bitpos2);
|
|
||||||
if (maybe_lt (o1, o2)
|
|
||||||
|| (known_eq (o1, o2)
|
|
||||||
&& maybe_lt (bitpos, bitpos2)))
|
|
||||||
{
|
{
|
||||||
if (ptr)
|
if (ptr)
|
||||||
scp = sc;
|
scp = sc;
|
||||||
|
@ -8951,38 +9005,8 @@ gimplify_scan_omp_clauses (tree *list_p, gimple_seq *pre_p,
|
||||||
size_one_node);
|
size_one_node);
|
||||||
if (ptr)
|
if (ptr)
|
||||||
{
|
{
|
||||||
tree c2 = build_omp_clause (OMP_CLAUSE_LOCATION (c),
|
tree cl = insert_struct_comp_map (code, c, NULL,
|
||||||
OMP_CLAUSE_MAP);
|
*prev_list_p, scp);
|
||||||
tree cl = NULL_TREE;
|
|
||||||
enum gomp_map_kind mkind
|
|
||||||
= code == OMP_TARGET_EXIT_DATA
|
|
||||||
? GOMP_MAP_RELEASE : GOMP_MAP_ALLOC;
|
|
||||||
OMP_CLAUSE_SET_MAP_KIND (c2, mkind);
|
|
||||||
OMP_CLAUSE_DECL (c2)
|
|
||||||
= unshare_expr (OMP_CLAUSE_DECL (c));
|
|
||||||
OMP_CLAUSE_CHAIN (c2) = scp ? *scp : *prev_list_p;
|
|
||||||
OMP_CLAUSE_SIZE (c2)
|
|
||||||
= TYPE_SIZE_UNIT (ptr_type_node);
|
|
||||||
cl = scp ? *prev_list_p : c2;
|
|
||||||
if (OMP_CLAUSE_CHAIN (*prev_list_p) != c)
|
|
||||||
{
|
|
||||||
tree c4 = OMP_CLAUSE_CHAIN (*prev_list_p);
|
|
||||||
tree c3
|
|
||||||
= build_omp_clause (OMP_CLAUSE_LOCATION (c),
|
|
||||||
OMP_CLAUSE_MAP);
|
|
||||||
OMP_CLAUSE_SET_MAP_KIND (c3, mkind);
|
|
||||||
OMP_CLAUSE_DECL (c3)
|
|
||||||
= unshare_expr (OMP_CLAUSE_DECL (c4));
|
|
||||||
OMP_CLAUSE_SIZE (c3)
|
|
||||||
= TYPE_SIZE_UNIT (ptr_type_node);
|
|
||||||
OMP_CLAUSE_CHAIN (c3) = *prev_list_p;
|
|
||||||
if (!scp)
|
|
||||||
OMP_CLAUSE_CHAIN (c2) = c3;
|
|
||||||
else
|
|
||||||
cl = c3;
|
|
||||||
}
|
|
||||||
if (scp)
|
|
||||||
*scp = c2;
|
|
||||||
if (sc == prev_list_p)
|
if (sc == prev_list_p)
|
||||||
{
|
{
|
||||||
*sc = cl;
|
*sc = cl;
|
||||||
|
|
Loading…
Reference in New Issue