[OpenMP][WIP] Use ATTACH maps for array-sections/subscripts on pointers.

[abhinavgaba]

This is the initial clang change to support using ATTACH map-type for pointer-attachment.

This includes changes from the following:

• [Clang][OpenMP] Capture mapped pointers on target by reference. #145454

For example, for the following:

  int *p;
  #pragma omp target enter data map(p[1:10])

The following maps are now emitted by clang:

  (A)
  &p[0], &p[1], 10 * sizeof(p[1]), TO | FROM
  &p, &p[1], sizeof(p), ATTACH

Previously, the two possible maps emitted by clang were:

  (B)
  &p[0], &p[1], 10 * sizeof(p[1]), TO | FROM

  (C)
  &p, &p[1], 10 * sizeof(p[1]), TO | FROM | PTR_AND_OBJ

(B) does not perform any pointer attachment, while (C) also maps the
pointer p, both of which are incorrect.

---

With this change, we are using ATTACH-style maps, like (A), for cases where the expression has a base-pointer. For example:

  int *p, **pp;
  S *ps, **pps;
  ... map(p[0])
  ... map(p[10:20])
  ... map(*p)
  ... map(([20])p)
  ... map(ps->a)
  ... map(pps->p->a)
  ... map(pp[0][0])
  ... map(*(pp + 10)[0])

We also group mapping of clauses with the same base decl in the order of the increasing complexity of their base-pointers, e.g. for something like:

  S **spp;
  map(spp[0][0], spp[0][0].a), // attach-ptr: spp[0]
  map(spp[0]),                 // attach-ptr: spp
  map(spp),                    // attach-ptr: N/A

We first map spp, then spp[0] then spp[0][0] and spp[0][0].a.

This allows us to also group "struct" allocation based on their attach pointers. This resolves the issues of unexpected data being mapped in a chain starting from the base symbol.

The handling of use_device_ptr/addr was updated to use the attach-ptr information, and works for many cases that were failing before. It has to be done as part of this series because otherwise, the switch from ptr_to_obj to attach-style mapping would have caused regressions in existing use_device_ptr/addr tests.

Cases that need handling:

• When a class member like p is a base-pointer in a map from a member function within the same class, p is not being privatized, instead, we still try to create an implicit map of this[0:1], and access p through that, which is incorrect.

 struct S { int *p;
 void f1() {
   #pragma omp target data map(p[0:1])
      printf("%p %p\n", &p, p);
 }

• Mapping of array-sections on struct-members, like map(s.p[0:10]) needs to also add an implicit map of map(s.p) on target constructs.
• Mapping of array-sections on class-members, from a member function of the same class, needs privatization of the base-pointer (existing issue. not specific to this change).
• Attach-style maps not yet emitted for declare mappers. That should be a separate PR.
• Other issues that haven't been found yet.

[github-actions]

✅ With the latest revision this PR passed the C/C++ code formatter.

[abhinavgaba]

Please look at the comments in this example to see the maps we are emitting. It's a smaller/easier to read test.

[abhinavgaba]

This shows how we handle mapping of struct-members that have the same attach-ptr. They are allocated as a contiguous chunk.

[abhinavgaba]

The implicit map is because spp is a pointer referenced within the target construct, and neither spp, nor an expression that has spp as its attach-ptr is mapped on the construct.