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 builds upon the following:

• [Offload] Introduce ATTACH map-type support for pointer attachment. llvm/llvm-project#149036
• [Clang][OpenMP] Capture mapped pointers on target by reference. llvm/llvm-project#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 base-pointer of the expression being mapped, is a scalar pointer that's not a member of a struct. For example:

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

We still don't use these maps for cases like:

  int **pp;
  ... map(pp[0][0]) // base-pointer is pp[0]
  struct S {
    int *p;
    void f1() {
      ... map(p[0]) // base-pointer is a struct-member
    }

Next steps:

• Add an implicit map of p[0:0] when the user does target map(p->q->r), and there is no map of either p, or something whose base-pointer is p.
• Enable attach-style maps for when the attachable-pointer is a struct member (including in declare mappers).
• Enable attach-style maps for multiple levels of dereference, like map(p->q->t[10].r->x), which would require:
  • grouping mappings of component-lists that have the same attachable base-pointer together.

[abhinavgaba]

The libomptarget code will disappear from this PR once llvm#149036 is merged.

[abhinavgaba]

AreBothBaseptrAndPteeMapped was used to decide to use PTR_AND_OBJ maps for something like map(p, p[0]). We don't do that now, since we map them independently, and attach them separately.