[OpenMP] Add map info for dereference pointer.

[jyu2]

Summary

This is to fix run time problem when use:

int **a;
map((*a)[:3]) or (*a)[1].

current we skip generate map info for dereference pointer:
&(*a), &(*a)[0], 3*sizeof(int), TARGET_PARAM | TO | FROM

One way to fix runtime problem is to generate map info for dereference
pointer.

&(*a), &(*a), sizeof(pointer), ALLOC | TARGET_PARAM
&(*a), &(*a)[0], 3*sizeof(int), PTR_AND_OBJ | TO | FROM

The change in CGOpenMPRuntime.cpp add that.

The change in SemaOpenMP is to fix variable of dereference pointer to array
captured by reference. That is wrong. That cause run time to fail.

The rule is:
If variable is identified in a map clause it is always captured by
reference except if it is a pointer that is dereferenced somehow.

[ABataev]

clang/test/OpenMP/target_map_deref_array_codegen.cpp

17

Is this correct at all? This is not a pointer to the array, it is an array of pointers, IIRC.

[jyu2]

clang/test/OpenMP/target_map_deref_array_codegen.cpp

17

I am confuse about those two(pointer to array or array of pointer). I thinks

int **tid ===  int (*t1d)[3],

it is pointer to array.

[ABataev]

clang/test/OpenMP/target_map_deref_array_codegen.cpp

17

Nope. The first one is an array of pointers, the second - the pointer to the array of ints. They are different.

https://stackoverflow.com/questions/20120054/pointer-to-an-array-and-array-of-pointers

[ABataev]

What result produces map(a[0][:3]?

[jyu2]

In D145093#4164528, @ABataev wrote:

What result produces map(a[0][:3]?

Yes, that would be another way to fix the runtime problem. However the difficulty is when process array section, section base is different.
with a[0][:3]
the section base is a[0]
with (*a)[:3], the section base is (*a); It is hard to set a[0] as section base during processing the array section.

That is why I am adding dereference pointer not a[0].

[ABataev]

In D145093#4164854, @jyu2 wrote:

In D145093#4164528, @ABataev wrote:

What result produces map(a[0][:3]?

Yes, that would be another way to fix the runtime problem. However the difficulty is when process array section, section base is different.
with a[0][:3]
the section base is a[0]
with (*a)[:3], the section base is (*a); It is hard to set a[0] as section base during processing the array section.

That is why I am adding dereference pointer not a[0].

I mean we shall emit the same mapping for (*a)[:3] and for a[0][:3]

[jyu2]

I mean we shall emit the same mapping for (*a)[:3] and for a[0][:3]

Yes I mean emit (*a)[:3] as a[0][:3]

The difficulty is during the process array section of
OMPArraySectionExpr 0x12aa37e0 '<OpenMP array section type>' lvalue

-ImplicitCastExpr 0x12a8a918 'int *' <ArrayToPointerDecay>
`-ArraySubscriptExpr 0x12a8a8d8 'int[3]':'int[3]' lvalue
	-ImplicitCastExpr 0x12a8a8c0 'int (*)[3]' <LValueToRValue>
	`-DeclRefExpr 0x12a8a880 'int (*)[3]' lvalue ParmVar 0x12a8a000 'a' 'int (*)[3]'
`-IntegerLiteral 0x12a8a8a0 'int' 0
-<<<NULL>>>
-IntegerLiteral 0x12a8a8f8 'int' 3

`-<<<NULL>>>

It is not easy to set section base as a[0].

[ABataev]

In D145093#4164877, @jyu2 wrote:

I mean we shall emit the same mapping for (*a)[:3] and for a[0][:3]

Yes I mean emit (*a)[:3] as a[0][:3]

The difficulty is during the process array section of
OMPArraySectionExpr 0x12aa37e0 '<OpenMP array section type>' lvalue

-ImplicitCastExpr 0x12a8a918 'int *' <ArrayToPointerDecay>
`-ArraySubscriptExpr 0x12a8a8d8 'int[3]':'int[3]' lvalue
	-ImplicitCastExpr 0x12a8a8c0 'int (*)[3]' <LValueToRValue>
	`-DeclRefExpr 0x12a8a880 'int (*)[3]' lvalue ParmVar 0x12a8a000 'a' 'int (*)[3]'
`-IntegerLiteral 0x12a8a8a0 'int' 0
-<<<NULL>>>
-IntegerLiteral 0x12a8a8f8 'int' 3

`-<<<NULL>>>

It is not easy to set section base as a[0].

Yes, I understand. And did not ask for it. I just mean that a[0][:3] emits different mapping data - TARGET_PAPARM|TO|FROM, PTR_AND_OBJ|TO|FROM

[jyu2]

Thanks Alexey for the review.

[jyu2]

Yes, I understand. And did not ask for it. I just mean that a[0][:3] emits different mapping data - TARGET_PAPARM|TO|FROM, PTR_AND_OBJ|TO|FROM

Oh I see. I was think alloc for adding pointer. But I now think I should just orignal maptype. Changed thanks.

[ABataev]

clang/lib/CodeGen/CGOpenMPRuntime.cpp

7488–7498

Why need a loop here? Can you somehow merge analysis for (*p) expression with the pointer subscript analysis?

clang/lib/Sema/SemaOpenMP.cpp

2206–2216

Why do you need a loop here?

[jyu2]

clang/lib/CodeGen/CGOpenMPRuntime.cpp

7488–7498

What about if you have three dereference pointers like (***a)[0:3] or four pointers...

clang/lib/Sema/SemaOpenMP.cpp

2206–2216

What about if you have three dereference pointers like (***a)[0:3] or four pointers...

[ABataev]

clang/lib/CodeGen/CGOpenMPRuntime.cpp

7488–7498

Why you can't iterate through the required components just like for the array subscrit expression?

[jyu2]

clang/lib/CodeGen/CGOpenMPRuntime.cpp

7488–7498

Because currently, for unarray operator the map info is skipped following the rule:

bool IsNonDerefPointer = IsPointer && !UO && !BO && !IsNonContiguous;

So I need to check if it is dereference to array some how to not skip it.

[ABataev]

clang/lib/CodeGen/CGOpenMPRuntime.cpp

7488–7498

1. Same problem in Sema too.
2. Can you try to fix it to avoid those loops?

[jyu2]

Thanks Alexey for the code review. I removed loop by using last expression in the component for checking.

[jyu2]

clang/lib/CodeGen/CGOpenMPRuntime.cpp

7488–7498

Thanks. I removed loop.

[ABataev]

clang/lib/CodeGen/CGOpenMPRuntime.cpp

7490–7494

What if we have something like:

typedef int (T)[3];

T** p;
map(**p)

? Shall it work? I.e. mapping of the whole array by dereferening the pointer to the array.

[jyu2]

clang/lib/CodeGen/CGOpenMPRuntime.cpp

7490–7494

No, it is not work currently. What about *(*(p+a)+b)...

[ABataev]

clang/lib/CodeGen/CGOpenMPRuntime.cpp

7490–7494

My question - shall it work? Mapping (a)[:3] should result in the same in the same code for a if a is

typedef int(T)[3];
T** a;

[jyu2]

Add additional test as Alexey asked.

clang/lib/CodeGen/CGOpenMPRuntime.cpp

7490–7494

Oh, that should work. I add additional test for that.

typedef int(T)[3];
void bar()
{

T** a;
int b[2][3];
int (*p)[3] = b;
a =  &p;
printf("%p %p p %p\n", &a, b, *p);
for (int i = 0; i< 3; i++) {
  (**a)[1] = i;
}
#pragma omp target map((**a)[:3])
{
 (**a)[1]=5;
  // CHECK: 5
  printf("a = %d\n", (**a)[1]);
}
}

[ABataev]

clang/lib/CodeGen/CGOpenMPRuntime.cpp

7490–7494

No, I meant different thing:

T **a;
.. map (**a)

[jyu2]

clang/lib/CodeGen/CGOpenMPRuntime.cpp

7490–7494

Yes, that is not working currently. That is something need to be fixed include *(*(a+i)+j) ....

[ABataev]

clang/lib/CodeGen/CGOpenMPRuntime.cpp

7490–7494

Not sure need to implement such complex expression, but would be good to support (**a) (for arrays, array sections, just a regular scalars, etc.) here

[jyu2]

Okay, I add code to get **a to work. Thanks Alexey for the review.

[ABataev]

LG

[ronlieb]

seems to fail amdgpu buildbot
https://lab.llvm.org/buildbot/#/builders/193/builds/27692

[ronlieb]

had not heard back , so reverted it for now
commit 8cf85a0cadb033fed3d96aa5283deb4bfbbaf2c8 (HEAD -> main, origin/main, origin/HEAD)
Author: Ron Lieberman <[e-mail]>
Date: Wed Mar 8 22:01:22 2023 -0600

Revert "Add map info for dereference pointer."

breaks amdgpu buildbot

[jyu2]

In D145093#4179927, @ronlieb wrote:

seems to fail amdgpu buildbot
https://lab.llvm.org/buildbot/#/builders/193/builds/27692

I turn off the test run to amdgpu. And rechecked in with
c5b060900e98

In D145093#4180143, @ronlieb wrote:

had not heard back , so reverted it for now
commit 8cf85a0cadb033fed3d96aa5283deb4bfbbaf2c8 (HEAD -> main, origin/main, origin/HEAD)
Author: Ron Lieberman <[e-mail]>
Date: Wed Mar 8 22:01:22 2023 -0600

Revert "Add map info for dereference pointer."

breaks amdgpu buildbot

clang/lib/CodeGen/CGOpenMPRuntime.cpp

void generateInfoForComponentList(
     // The following summarizes what has to be generated for each map and the
     // types below. The generated information is expressed in this order:
     // base pointer, section pointer, size, flags
     // (to add to the ones that come from the map type and modifier).
     //
     // double d;
     // int i[100];
     // float *p;
+    // int **a = &i;
     //
     // struct S1 {
     //   int i;
     //   float f[50];
     // }
     // struct S2 {
     //   int i;
     //   float f[50];
void generateInfoForComponentList(
     // map(p)
     // &p, &p, sizeof(float*), TARGET_PARAM | TO | FROM
     //
     // map(p[1:24])
     // &p, &p[1], 24*sizeof(float), TARGET_PARAM | TO | FROM | PTR_AND_OBJ
     // in unified shared memory mode or for local pointers
     // p, &p[1], 24*sizeof(float), TARGET_PARAM | TO | FROM
     //
+    // map((*a)[0:3])
+    // &(*a), &(*a), sizeof(pointer), ALLOC | TARGET_PARAM
+    // &(*a), &(*a)[0], 3*sizeof(int), PTR_AND_OBJ | TO | FROM
+    //
     // map(s)
     // &s, &s, sizeof(S2), TARGET_PARAM | TO | FROM
     //
     // map(s.i)
     // &s, &(s.i), sizeof(int), TARGET_PARAM | TO | FROM
     //
     // map(s.s.f)
     // &s, &(s.s.f[0]), 50*sizeof(float), TARGET_PARAM | TO | FROM
void generateInfoForComponentList(
     const MemberExpr *EncounteredME = nullptr;
 
     // Track for the total number of dimension. Start from one for the dummy
     // dimension.
     uint64_t DimSize = 1;
 
     bool IsNonContiguous = CombinedInfo.NonContigInfo.IsNonContiguous;
     bool IsPrevMemberReference = false;
+    OpenMPMapClauseKind SaveMapType = MapType;
 
     for (; I != CE; ++I) {
       // If the current component is member of a struct (parent struct) mark it.
       if (!EncounteredME) {
         EncounteredME = dyn_cast<MemberExpr>(I->getAssociatedExpression());
         // If we encounter a PTR_AND_OBJ entry from now on it should be marked
         // as MEMBER_OF the parent struct.
         if (EncounteredME) {
for (; I != CE; ++I) {
       // special treatment for array sections given that they are built-in
       // types.
       const auto *OASE =
           dyn_cast<OMPArraySectionExpr>(I->getAssociatedExpression());
       const auto *OAShE =
           dyn_cast<OMPArrayShapingExpr>(I->getAssociatedExpression());
       const auto *UO = dyn_cast<UnaryOperator>(I->getAssociatedExpression());
       const auto *BO = dyn_cast<BinaryOperator>(I->getAssociatedExpression());
+      auto TNext = Next;
+      bool IsVarDerefAssoWithArray = false;
+      if (UO && UO->getOpcode() == UO_Deref)
+        for (; TNext != CE; TNext = std::next(TNext))
+          if (isa<OMPArraySectionExpr>(TNext->getAssociatedExpression()) ||
+              isa<MemberExpr>(TNext->getAssociatedExpression()) ||
+              isa<OMPArrayShapingExpr>(TNext->getAssociatedExpression()) ||
+              isa<ArraySubscriptExpr>(TNext->getAssociatedExpression())) {
+            IsVarDerefAssoWithArray = true;
+            MapType = OMPC_MAP_alloc;
+            break;
+          }
+      if (!IsVarDerefAssoWithArray)
+        MapType = SaveMapType;
       bool IsPointer =
           OAShE ||
           (OASE && OMPArraySectionExpr::getBaseOriginalType(OASE)
                        .getCanonicalType()
                        ->isAnyPointerType()) ||
           I->getAssociatedExpression()->getType()->isAnyPointerType();
       bool IsMemberReference = isa<MemberExpr>(I->getAssociatedExpression()) &&
                                MapDecl &&
                                MapDecl->getType()->isLValueReferenceType();
       bool IsNonDerefPointer = IsPointer && !UO && !BO && !IsNonContiguous;
 
       if (OASE)
         ++DimSize;
 
       if (Next == CE || IsMemberReference || IsNonDerefPointer ||
-          IsFinalArraySection) {
+          IsVarDerefAssoWithArray || IsFinalArraySection) {
         // If this is not the last component, we expect the pointer to be
         // associated with an array expression or member expression.
         assert((Next == CE ||
                 isa<MemberExpr>(Next->getAssociatedExpression()) ||
                 isa<ArraySubscriptExpr>(Next->getAssociatedExpression()) ||
                 isa<OMPArraySectionExpr>(Next->getAssociatedExpression()) ||
                 isa<OMPArrayShapingExpr>(Next->getAssociatedExpression()) ||
                 isa<UnaryOperator>(Next->getAssociatedExpression()) ||

clang/lib/Sema/SemaOpenMP.cpp

DSAStack->checkMappableExprComponentListsForDeclAtLevel(
           assert(EI != EE && "Invalid map expression!");
 
           if (isa<DeclRefExpr>(EI->getAssociatedExpression()))
             IsVariableUsedInMapClause |= EI->getAssociatedDeclaration() == D;
 
           ++EI;
           if (EI == EE)
             return false;
-
-          if (isa<ArraySubscriptExpr>(EI->getAssociatedExpression()) ||
-              isa<OMPArraySectionExpr>(EI->getAssociatedExpression()) ||
+          auto Next = EI;
+          for (; Next != EE; Next = std::next(Next)) {
+            if (isa<ArraySubscriptExpr>(Next->getAssociatedExpression()) ||
+                isa<OMPArraySectionExpr>(Next->getAssociatedExpression()) ||
                 isa<MemberExpr>(EI->getAssociatedExpression()) ||
-              isa<OMPArrayShapingExpr>(EI->getAssociatedExpression())) {
+                isa<OMPArrayShapingExpr>(Next->getAssociatedExpression())) {
               IsVariableAssociatedWithSection = true;
               // There is nothing more we need to know about this variable.
               return true;
             }
+          }
 
           // Keep looking for more map info.
           return false;
         });
 
     if (IsVariableUsedInMapClause) {
       // If variable is identified in a map clause it is always captured by
       // reference except if it is a pointer that is dereferenced somehow.

clang/test/OpenMP/target_map_deref_array_codegen.cpp

+// NOTE: Assertions have been autogenerated by utils/update_cc_test_checks.py UTC_ARGS: --function-signature --include-generated-funcs --replace-value-regex "__omp_offloading_[0-9a-z]+_[0-9a-z]+" "reduction_size[.].+[.]" "pl_cond[.].+[.|,]" --prefix-filecheck-ir-name _
+// RUN: %clang_cc1 -verify -fopenmp -fopenmp-targets=powerpc64le-ibm-linux-gnu -x c++ -triple powerpc64le-unknown-unknown -emit-llvm %s -o - | FileCheck %s
+// RUN: %clang_cc1 -fopenmp -fopenmp-targets=powerpc64le-ibm-linux-gnu -x c++ -std=c++11 -triple powerpc64le-unknown-unknown -emit-pch -o %t %s
+// RUN: %clang_cc1 -fopenmp -fopenmp-targets=powerpc64le-ibm-linux-gnu -x c++ -triple powerpc64le-unknown-unknown -std=c++11 -include-pch %t -verify %s -emit-llvm -o - | FileCheck %s
+
+// expected-no-diagnostics
+#ifndef HEADER
+#define HEADER
+
+extern void *malloc (int __size) throw () __attribute__ ((__malloc__));
+
+void foo(int **t1d)
+{
+  *t1d = (int *) malloc(3 * sizeof(int));
+  for (int j=0; j < 3; j++)
+    (*t1d)[j] = 1;
+  #pragma omp target map(to: (*t1d)[0:3])
+    (*t1d)[2] = 2;
+}
+
+#endif
+
+// CHECK: @.offload_sizes = private unnamed_addr constant [2 x i64] [i64 8, i64 12]
+// CHECK: @.offload_maptypes = private unnamed_addr constant [2 x i64] [i64 32, i64 17]
+// CHECK-LABEL: define {{[^@]+}}@_Z3fooPPi
+// CHECK-SAME: (ptr noundef [[T1D:%.*]]) #[[ATTR0:[0-9]+]] {
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[T1D_ADDR:%.*]] = alloca ptr, align 8
+// CHECK-NEXT:    [[J:%.*]] = alloca i32, align 4
+// CHECK-NEXT:    [[DOTOFFLOAD_BASEPTRS:%.*]] = alloca [2 x ptr], align 8
+// CHECK-NEXT:    [[DOTOFFLOAD_PTRS:%.*]] = alloca [2 x ptr], align 8
+// CHECK-NEXT:    [[DOTOFFLOAD_MAPPERS:%.*]] = alloca [2 x ptr], align 8
+// CHECK-NEXT:    store ptr [[T1D]], ptr [[T1D_ADDR]], align 8
+// CHECK-NEXT:    [[CALL:%.*]] = call noalias noundef ptr @_Z6malloci(i32 noundef signext 12) #[[ATTR3:[0-9]+]]
+// CHECK-NEXT:    [[TMP0:%.*]] = load ptr, ptr [[T1D_ADDR]], align 8
+// CHECK-NEXT:    store ptr [[CALL]], ptr [[TMP0]], align 8
+// CHECK-NEXT:    store i32 0, ptr [[J]], align 4
+// CHECK-NEXT:    br label [[FOR_COND:%.*]]
+// CHECK:       for.cond:
+// CHECK-NEXT:    [[TMP1:%.*]] = load i32, ptr [[J]], align 4
+// CHECK-NEXT:    [[CMP:%.*]] = icmp slt i32 [[TMP1]], 3
+// CHECK-NEXT:    br i1 [[CMP]], label [[FOR_BODY:%.*]], label [[FOR_END:%.*]]
+// CHECK:       for.body:
+// CHECK-NEXT:    [[TMP2:%.*]] = load ptr, ptr [[T1D_ADDR]], align 8
+// CHECK-NEXT:    [[TMP3:%.*]] = load ptr, ptr [[TMP2]], align 8
+// CHECK-NEXT:    [[TMP4:%.*]] = load i32, ptr [[J]], align 4
+// CHECK-NEXT:    [[IDXPROM:%.*]] = sext i32 [[TMP4]] to i64
+// CHECK-NEXT:    [[ARRAYIDX:%.*]] = getelementptr inbounds i32, ptr [[TMP3]], i64 [[IDXPROM]]
+// CHECK-NEXT:    store i32 1, ptr [[ARRAYIDX]], align 4
+// CHECK-NEXT:    br label [[FOR_INC:%.*]]
+// CHECK:       for.inc:
+// CHECK-NEXT:    [[TMP5:%.*]] = load i32, ptr [[J]], align 4
+// CHECK-NEXT:    [[INC:%.*]] = add nsw i32 [[TMP5]], 1
+// CHECK-NEXT:    store i32 [[INC]], ptr [[J]], align 4
+// CHECK-NEXT:    br label [[FOR_COND]], !llvm.loop [[LOOP4:![0-9]+]]
+// CHECK:       for.end:
+// CHECK-NEXT:    [[TMP6:%.*]] = load ptr, ptr [[T1D_ADDR]], align 8
+// CHECK-NEXT:    [[TMP7:%.*]] = load ptr, ptr [[T1D_ADDR]], align 8
+// CHECK-NEXT:    [[TMP8:%.*]] = load ptr, ptr [[T1D_ADDR]], align 8
+// CHECK-NEXT:    [[TMP9:%.*]] = load ptr, ptr [[T1D_ADDR]], align 8
+// CHECK-NEXT:    [[TMP10:%.*]] = load ptr, ptr [[TMP9]], align 8
+// CHECK-NEXT:    [[ARRAYIDX1:%.*]] = getelementptr inbounds i32, ptr [[TMP10]], i64 0
+// CHECK-NEXT:    [[TMP11:%.*]] = getelementptr inbounds [2 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 0
+// CHECK-NEXT:    store ptr [[TMP7]], ptr [[TMP11]], align 8
+// CHECK-NEXT:    [[TMP12:%.*]] = getelementptr inbounds [2 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 0
+// CHECK-NEXT:    store ptr [[TMP8]], ptr [[TMP12]], align 8
+// CHECK-NEXT:    [[TMP13:%.*]] = getelementptr inbounds [2 x ptr], ptr [[DOTOFFLOAD_MAPPERS]], i64 0, i64 0
+// CHECK-NEXT:    store ptr null, ptr [[TMP13]], align 8
+// CHECK-NEXT:    [[TMP14:%.*]] = getelementptr inbounds [2 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 1
+// CHECK-NEXT:    store ptr [[TMP8]], ptr [[TMP14]], align 8
+// CHECK-NEXT:    [[TMP15:%.*]] = getelementptr inbounds [2 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 1
+// CHECK-NEXT:    store ptr [[ARRAYIDX1]], ptr [[TMP15]], align 8
+// CHECK-NEXT:    [[TMP16:%.*]] = getelementptr inbounds [2 x ptr], ptr [[DOTOFFLOAD_MAPPERS]], i64 0, i64 1
+// CHECK-NEXT:    store ptr null, ptr [[TMP16]], align 8
+// CHECK-NEXT:    [[TMP17:%.*]] = getelementptr inbounds [2 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 0
+// CHECK-NEXT:    [[TMP18:%.*]] = getelementptr inbounds [2 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 0
+// CHECK-NEXT:    [[KERNEL_ARGS:%.*]] = alloca [[STRUCT___TGT_KERNEL_ARGUMENTS:%.*]], align 8
+// CHECK-NEXT:    [[TMP19:%.*]] = getelementptr inbounds [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS]], i32 0, i32 0
+// CHECK-NEXT:    store i32 2, ptr [[TMP19]], align 4
+// CHECK-NEXT:    [[TMP20:%.*]] = getelementptr inbounds [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS]], i32 0, i32 1
+// CHECK-NEXT:    store i32 2, ptr [[TMP20]], align 4
+// CHECK-NEXT:    [[TMP21:%.*]] = getelementptr inbounds [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS]], i32 0, i32 2
+// CHECK-NEXT:    store ptr [[TMP17]], ptr [[TMP21]], align 8
+// CHECK-NEXT:    [[TMP22:%.*]] = getelementptr inbounds [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS]], i32 0, i32 3
+// CHECK-NEXT:    store ptr [[TMP18]], ptr [[TMP22]], align 8
+// CHECK-NEXT:    [[TMP23:%.*]] = getelementptr inbounds [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS]], i32 0, i32 4
+// CHECK-NEXT:    store ptr @.offload_sizes, ptr [[TMP23]], align 8
+// CHECK-NEXT:    [[TMP24:%.*]] = getelementptr inbounds [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS]], i32 0, i32 5
+// CHECK-NEXT:    store ptr @.offload_maptypes, ptr [[TMP24]], align 8
+// CHECK-NEXT:    [[TMP25:%.*]] = getelementptr inbounds [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS]], i32 0, i32 6
+// CHECK-NEXT:    store ptr null, ptr [[TMP25]], align 8
+// CHECK-NEXT:    [[TMP26:%.*]] = getelementptr inbounds [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS]], i32 0, i32 7
+// CHECK-NEXT:    store ptr null, ptr [[TMP26]], align 8
+// CHECK-NEXT:    [[TMP27:%.*]] = getelementptr inbounds [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS]], i32 0, i32 8
+// CHECK-NEXT:    store i64 0, ptr [[TMP27]], align 8
+// CHECK-NEXT:    [[TMP28:%.*]] = getelementptr inbounds [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS]], i32 0, i32 9
+// CHECK-NEXT:    store i64 0, ptr [[TMP28]], align 8
+// CHECK-NEXT:    [[TMP29:%.*]] = getelementptr inbounds [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS]], i32 0, i32 10
+// CHECK-NEXT:    store [3 x i32] [i32 -1, i32 0, i32 0], ptr [[TMP29]], align 4
+// CHECK-NEXT:    [[TMP30:%.*]] = getelementptr inbounds [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS]], i32 0, i32 11
+// CHECK-NEXT:    store [3 x i32] zeroinitializer, ptr [[TMP30]], align 4
+// CHECK-NEXT:    [[TMP31:%.*]] = getelementptr inbounds [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS]], i32 0, i32 12
+// CHECK-NEXT:    store i32 0, ptr [[TMP31]], align 4
+// CHECK-NEXT:    [[TMP32:%.*]] = call i32 @__tgt_target_kernel(ptr @[[GLOB1:[0-9]+]], i64 -1, i32 -1, i32 0, ptr @.{{__omp_offloading_[0-9a-z]+_[0-9a-z]+}}__Z3fooPPi_l17.region_id, ptr [[KERNEL_ARGS]])
+// CHECK-NEXT:    [[TMP33:%.*]] = icmp ne i32 [[TMP32]], 0
+// CHECK-NEXT:    br i1 [[TMP33]], label [[OMP_OFFLOAD_FAILED:%.*]], label [[OMP_OFFLOAD_CONT:%.*]]
+// CHECK:       omp_offload.failed:
+// CHECK-NEXT:    call void @{{__omp_offloading_[0-9a-z]+_[0-9a-z]+}}__Z3fooPPi_l17(ptr [[TMP6]]) #[[ATTR3]]
+// CHECK-NEXT:    br label [[OMP_OFFLOAD_CONT]]
+// CHECK:       omp_offload.cont:
+// CHECK-NEXT:    ret void
+//
+//
+// CHECK-LABEL: define {{[^@]+}}@{{__omp_offloading_[0-9a-z]+_[0-9a-z]+}}__Z3fooPPi_l17
+// CHECK-SAME: (ptr noundef [[T1D:%.*]]) #[[ATTR2:[0-9]+]] {
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[T1D_ADDR:%.*]] = alloca ptr, align 8
+// CHECK-NEXT:    store ptr [[T1D]], ptr [[T1D_ADDR]], align 8
+// CHECK-NEXT:    [[TMP0:%.*]] = load ptr, ptr [[T1D_ADDR]], align 8
+// CHECK-NEXT:    [[TMP1:%.*]] = load ptr, ptr [[TMP0]], align 8
+// CHECK-NEXT:    [[ARRAYIDX:%.*]] = getelementptr inbounds i32, ptr [[TMP1]], i64 2
+// CHECK-NEXT:    store i32 2, ptr [[ARRAYIDX]], align 4
+// CHECK-NEXT:    ret void
+//
+//
+// CHECK-LABEL: define {{[^@]+}}@.omp_offloading.requires_reg
+// CHECK-SAME: () #[[ATTR4:[0-9]+]] {
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    call void @__tgt_register_requires(i64 1)
+// CHECK-NEXT:    ret void
+//

openmp/libomptarget/test/mapping/target_derefence_array_pointrs.cpp

+// RUN: %libomptarget-compilexx-generic -fopenmp-version=51
+// RUN: %libomptarget-run-generic 2>&1 \
+// RUN: | %fcheck-generic
+
+#include <stdio.h>
+#include <stdlib.h>
+
+void foo(int **t1d) {
+  int ***t2d = &t1d;
+  int ****t3d = &t2d;
+  *t1d = (int *)malloc(3 * sizeof(int));
+  int j;
+
+  for (j = 0; j < 3; j++)
+    (*t1d)[j] = 0;
+#pragma omp target map(tofrom : (*t1d)[0 : 3])
+  { (*t1d)[1] = 1; }
+  // CHECK: 1
+  printf("%d\n", (*t1d)[1]);
+#pragma omp target map(tofrom : (**t2d)[0 : 3])
+  { (**t2d)[1] = 2; }
+  // CHECK: 2
+  printf("%d\n", (**t2d)[1]);
+#pragma omp target map(tofrom : (***t3d)[0 : 3])
+  { (***t3d)[1] = 3; }
+  // CHECK: 3
+  printf("%d\n", (***t3d)[1]);
+}
+
+int main() {
+  int *data = 0;
+  foo(&data);
+}