[mlir][openacc] Translate ExitDataop to LLVM IR

[clementval]

Summary

Translate ExitDataOp with delete and copyout operands to runtime call.
This is done in a similar way as D101504.

[kiranchandramohan]

A few questions.

mlir/lib/Target/LLVMIR/Dialect/OpenACC/OpenACCToLLVMIRTranslation.cpp

89–95

Can this also be a typeswitch?

mlir/test/Target/LLVMIR/openacc-llvm.mlir

71–76

Can this (%0,%1,%2,%3,%4,%5) be removed to make the testcase simpler? Can %5 come in as an argument?

80

Is getting a pointer with offset from NULL what is expected or is this just a syntactic example?

[clementval]

mlir/lib/Target/LLVMIR/Dialect/OpenACC/OpenACCToLLVMIRTranslation.cpp

89–95

Sure. I'll update that.

mlir/test/Target/LLVMIR/openacc-llvm.mlir

71–76

Sure I can do that. Let me update the test case.

80

That is expected.

This is the direct LLVM IR version of what is done in the std-to-llvm conversion. Comment from this conversion.

// Compute the size of an individual element. This emits the MLIR equivalent
// of the following sizeof(...) implementation in LLVM IR:
//   %0 = getelementptr %elementType* null, %indexType 1
//   %1 = ptrtoint %elementType* %0 to %indexType
// which is a common pattern of getting the size of a type in bytes.

[clementval]

Address review comments

[clementval]

Simplify TypeSwitch

[kiranchandramohan]

LGTM. Please wait a day to see whether others have comments.

mlir/lib/Target/LLVMIR/Dialect/OpenACC/OpenACCToLLVMIRTranslation.cpp

 //===----------------------------------------------------------------------===//
 // Utility functions
 //===----------------------------------------------------------------------===//
 
 /// 0 = alloc/create
 static constexpr uint64_t createFlag = 0;
 /// 1 = to/copyin
 static constexpr uint64_t copyinFlag = 1;
+/// 2 = from/copyout
+static constexpr uint64_t copyoutFlag = 2;
+/// 8 = delete
+static constexpr uint64_t deleteFlag = 8;
+
 /// Default value for the device id
 static constexpr int64_t defaultDevice = -1;
 
 /// Create a constant string location from the MLIR Location information.
 static llvm::Constant *createSourceLocStrFromLocation(Location loc,
                                                       OpenACCIRBuilder &builder,
                                                       StringRef name) {
   if (auto fileLoc = loc.dyn_cast<FileLineColLoc>()) {
     StringRef fileName = fileLoc.getFilename();
     unsigned lineNo = fileLoc.getLine();
     unsigned colNo = fileLoc.getColumn();
     return builder.getOrCreateSrcLocStr(name, fileName, lineNo, colNo);
   } else {
     std::string locStr;
     llvm::raw_string_ostream locOS(locStr);
     locOS << loc;
     return builder.getOrCreateSrcLocStr(locOS.str());
   }
 }
 
 /// Create the location struct from the operation location information.
-static llvm::Value *createSourceLocationInfo(acc::EnterDataOp &op,
-                                             OpenACCIRBuilder &builder) {
-  auto loc = op.getLoc();
-  auto funcOp = op.getOperation()->getParentOfType<LLVM::LLVMFuncOp>();
+static llvm::Value *createSourceLocationInfo(OpenACCIRBuilder &builder,
+                                             Operation *op) {
+  auto loc = op->getLoc();
+  auto funcOp = op->getParentOfType<LLVM::LLVMFuncOp>();
   StringRef funcName = funcOp ? funcOp.getName() : "unknown";
   llvm::Constant *locStr =
       createSourceLocStrFromLocation(loc, builder, funcName);
   return builder.getOrCreateIdent(locStr);
 }
 
 /// Create a constant string representing the mapping information extracted from
 /// the MLIR location information.
 static llvm::Constant *createMappingInformation(Location loc,
                                                 OpenACCIRBuilder &builder) {
   if (auto nameLoc = loc.dyn_cast<NameLoc>()) {
     StringRef name = nameLoc.getName();
     return createSourceLocStrFromLocation(nameLoc.getChildLoc(), builder, name);
   } else {
     return createSourceLocStrFromLocation(loc, builder, "unknown");
   }
 }
 
 /// Return the runtime function used to lower the given operation.
 static llvm::Function *getAssociatedFunction(OpenACCIRBuilder &builder,
-                                             Operation &op) {
-  if (isa<acc::EnterDataOp>(op))
+                                             Operation *op) {
+  return llvm::TypeSwitch<Operation *, llvm::Function *>(op)
+      .Case([&](acc::EnterDataOp) {
         return builder.getOrCreateRuntimeFunctionPtr(
             llvm::omp::OMPRTL___tgt_target_data_begin_mapper);
+      })
+      .Case([&](acc::ExitDataOp) {
+        return builder.getOrCreateRuntimeFunctionPtr(
+            llvm::omp::OMPRTL___tgt_target_data_end_mapper);
+      });
   llvm_unreachable("Unknown OpenACC operation");
 }
 
 /// Computes the size of type in bytes.
 static llvm::Value *getSizeInBytes(llvm::IRBuilderBase &builder,
                                    llvm::Value *basePtr) {
   llvm::LLVMContext &ctx = builder.getContext();
   llvm::Value *null =
       llvm::Constant::getNullValue(basePtr->getType()->getPointerTo());
   llvm::Value *sizeGep =
       builder.CreateGEP(basePtr->getType(), null, builder.getInt32(1));
   llvm::Value *sizePtrToInt =
       builder.CreatePtrToInt(sizeGep, llvm::Type::getInt64Ty(ctx));
   return sizePtrToInt;
 }
 
 /// Extract pointer, size and mapping information from operands
 /// to populate the future functions arguments.
 static LogicalResult
 processOperands(llvm::IRBuilderBase &builder,
-                LLVM::ModuleTranslation &moduleTranslation, Operation &op,
+                LLVM::ModuleTranslation &moduleTranslation, Operation *op,
                 ValueRange operands, unsigned totalNbOperand,
                 uint64_t operandFlag, SmallVector<uint64_t> &flags,
                 SmallVector<llvm::Constant *> &names, unsigned &index,
                 llvm::AllocaInst *argsBase, llvm::AllocaInst *args,
                 llvm::AllocaInst *argSizes) {
   OpenACCIRBuilder *accBuilder = moduleTranslation.getOpenMPBuilder();
   llvm::LLVMContext &ctx = builder.getContext();
   auto *i8PtrTy = llvm::Type::getInt8PtrTy(ctx);
if (DataDescriptor::isValid(data)) {
       dataPtr = builder.CreateExtractValue(dataValue, kPtrPosInDataDescriptor);
       dataSize =
           builder.CreateExtractValue(dataValue, kSizePosInDataDescriptor);
     } else if (data.getType().isa<LLVM::LLVMPointerType>()) {
       dataPtrBase = dataValue;
       dataPtr = dataValue;
       dataSize = getSizeInBytes(builder, dataValue);
     } else {
-      return op.emitOpError()
+      return op->emitOpError()
              << "Data operand must be legalized before translation."
              << "Unsupported type: " << data.getType();
     }
 
     // Store base pointer extracted from operand into the i-th position of
     // argBase.
     llvm::Value *ptrBaseGEP = builder.CreateInBoundsGEP(
         arrI8PtrTy, argsBase, {builder.getInt32(0), builder.getInt32(index)});
for (Value data : operands) {
     llvm::Constant *mapName =
         createMappingInformation(data.getLoc(), *accBuilder);
     names.push_back(mapName);
     ++index;
   }
   return success();
 }
 
+/// Process data operands from acc::EnterDataOp
+static LogicalResult
+processDataOperands(llvm::IRBuilderBase &builder,
+                    LLVM::ModuleTranslation &moduleTranslation,
+                    acc::EnterDataOp op, SmallVector<uint64_t> &flags,
+                    SmallVector<llvm::Constant *> &names, unsigned &index,
+                    llvm::AllocaInst *argsBase, llvm::AllocaInst *args,
+                    llvm::AllocaInst *argSizes) {
+  // TODO add `create_zero` and `attach` operands
+
+  // Create operands are handled as `alloc` call.
+  if (failed(processOperands(builder, moduleTranslation, op,
+                             op.createOperands(), op.getNumDataOperands(),
+                             createFlag, flags, names, index, argsBase, args,
+                             argSizes)))
+    return failure();
+
+  // Copyin operands are handled as `to` call.
+  if (failed(processOperands(builder, moduleTranslation, op,
+                             op.copyinOperands(), op.getNumDataOperands(),
+                             copyinFlag, flags, names, index, argsBase, args,
+                             argSizes)))
+    return failure();
+
+  return success();
+}
+
+/// Process data operands from acc::ExitDataOp
+static LogicalResult
+processDataOperands(llvm::IRBuilderBase &builder,
+                    LLVM::ModuleTranslation &moduleTranslation,
+                    acc::ExitDataOp op, SmallVector<uint64_t> &flags,
+                    SmallVector<llvm::Constant *> &names, unsigned &index,
+                    llvm::AllocaInst *argsBase, llvm::AllocaInst *args,
+                    llvm::AllocaInst *argSizes) {
+  // TODO add `detach` operands
+
+  // Delete operands are handled as `delete` call.
+  if (failed(processOperands(builder, moduleTranslation, op,
+                             op.deleteOperands(), op.getNumDataOperands(),
+                             deleteFlag, flags, names, index, argsBase, args,
+                             argSizes)))
+    return failure();
+
+  // Copyout operands are handled as `from` call.
+  if (failed(processOperands(builder, moduleTranslation, op,
+                             op.copyoutOperands(), op.getNumDataOperands(),
+                             copyoutFlag, flags, names, index, argsBase, args,
+                             argSizes)))
+    return failure();
+
+  return success();
+}
+
 //===----------------------------------------------------------------------===//
 // Conversion functions
 //===----------------------------------------------------------------------===//
 
-/// Converts an OpenACC enter_data operartion into LLVM IR.
+/// Converts an OpenACC standalone data operation into LLVM IR.
+template <typename OpTy>
 static LogicalResult
-convertEnterDataOp(Operation &op, llvm::IRBuilderBase &builder,
+convertStandaloneDataOp(OpTy &op, llvm::IRBuilderBase &builder,
                         LLVM::ModuleTranslation &moduleTranslation) {
-  auto enterDataOp = cast<acc::EnterDataOp>(op);
-  auto enclosingFuncOp = op.getParentOfType<LLVM::LLVMFuncOp>();
+  auto enclosingFuncOp =
+      op.getOperation()->template getParentOfType<LLVM::LLVMFuncOp>();
   llvm::Function *enclosingFunction =
       moduleTranslation.lookupFunction(enclosingFuncOp.getName());
 
   OpenACCIRBuilder *accBuilder = moduleTranslation.getOpenMPBuilder();
 
-  auto *srcLocInfo = createSourceLocationInfo(enterDataOp, *accBuilder);
+  auto *srcLocInfo = createSourceLocationInfo(*accBuilder, op);
   auto *mapperFunc = getAssociatedFunction(*accBuilder, op);
 
   // Number of arguments in the enter_data operation.
-  // TODO include create_zero and attach operands.
-  unsigned totalNbOperand =
-      enterDataOp.createOperands().size() + enterDataOp.copyinOperands().size();
+  unsigned totalNbOperand = op.getNumDataOperands();
 
   // TODO could be moved to OpenXXIRBuilder?
   llvm::LLVMContext &ctx = builder.getContext();
   auto *i8PtrTy = llvm::Type::getInt8PtrTy(ctx);
   auto *arrI8PtrTy = llvm::ArrayType::get(i8PtrTy, totalNbOperand);
   auto *i64Ty = llvm::Type::getInt64Ty(ctx);
   auto *arrI64Ty = llvm::ArrayType::get(i64Ty, totalNbOperand);
   llvm::IRBuilder<>::InsertPoint allocaIP(
       &enclosingFunction->getEntryBlock(),
       enclosingFunction->getEntryBlock().getFirstInsertionPt());
   llvm::IRBuilder<>::InsertPoint currentIP = builder.saveIP();
   builder.restoreIP(allocaIP);
   llvm::AllocaInst *argsBase = builder.CreateAlloca(arrI8PtrTy);
   llvm::AllocaInst *args = builder.CreateAlloca(arrI8PtrTy);
   llvm::AllocaInst *argSizes = builder.CreateAlloca(arrI64Ty);
   builder.restoreIP(currentIP);
 
   SmallVector<uint64_t> flags;
   SmallVector<llvm::Constant *> names;
   unsigned index = 0;
 
-  // Create operands are handled as `alloc` call.
-  if (failed(processOperands(builder, moduleTranslation, op,
-                             enterDataOp.createOperands(), totalNbOperand,
-                             createFlag, flags, names, index, argsBase, args,
-                             argSizes)))
-    return failure();
-
-  // Copyin operands are handled as `to` call.
-  if (failed(processOperands(builder, moduleTranslation, op,
-                             enterDataOp.copyinOperands(), totalNbOperand,
-                             copyinFlag, flags, names, index, argsBase, args,
-                             argSizes)))
+  if (failed(processDataOperands(builder, moduleTranslation, op, flags, names,
+                                 index, argsBase, args, argSizes)))
     return failure();
 
   llvm::GlobalVariable *maptypes =
       accBuilder->createOffloadMaptypes(flags, ".offload_maptypes");
   llvm::Value *maptypesArg = builder.CreateConstInBoundsGEP2_32(
       llvm::ArrayType::get(llvm::Type::getInt64Ty(ctx), totalNbOperand),
       maptypes, /*Idx0=*/0, /*Idx1=*/0);
 

 
 /// Given an OpenACC MLIR operation, create the corresponding LLVM IR
 /// (including OpenACC runtime calls).
 LogicalResult OpenACCDialectLLVMIRTranslationInterface::convertOperation(
     Operation *op, llvm::IRBuilderBase &builder,
     LLVM::ModuleTranslation &moduleTranslation) const {
 
   return llvm::TypeSwitch<Operation *, LogicalResult>(op)
-      .Case([&](acc::EnterDataOp) {
-        return convertEnterDataOp(*op, builder, moduleTranslation);
+      .Case([&](acc::EnterDataOp enterDataOp) {
+        return convertStandaloneDataOp<acc::EnterDataOp>(enterDataOp, builder,
+                                                         moduleTranslation);
+      })
+      .Case([&](acc::ExitDataOp exitDataOp) {
+        return convertStandaloneDataOp<acc::ExitDataOp>(exitDataOp, builder,
+                                                        moduleTranslation);
       })
       .Default([&](Operation *op) {
         return op->emitError("unsupported OpenACC operation: ")
                << op->getName();
       });
 }
 
 void mlir::registerOpenACCDialectTranslation(DialectRegistry &registry) {

mlir/test/Target/LLVMIR/openacc-llvm.mlir

-// RUN: mlir-translate -mlir-to-llvmir %s | FileCheck %s
+// RUN: mlir-translate -mlir-to-llvmir -split-input-file %s | FileCheck %s
 
 llvm.func @testenterdataop(%arg0: !llvm.ptr<f32>, %arg1: !llvm.ptr<f32>, %arg2: i64, %arg3: i64, %arg4: i64, %arg5: !llvm.ptr<f32>) {
   %0 = llvm.mlir.undef : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<1 x i64>, array<1 x i64>)>
   %1 = llvm.insertvalue %arg0, %0[0] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<1 x i64>, array<1 x i64>)>
   %2 = llvm.insertvalue %arg1, %1[1] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<1 x i64>, array<1 x i64>)>
   %3 = llvm.insertvalue %arg2, %2[2] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<1 x i64>, array<1 x i64>)>
   %4 = llvm.insertvalue %arg3, %3[3, 0] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<1 x i64>, array<1 x i64>)>
   %5 = llvm.insertvalue %arg4, %4[4, 0] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<1 x i64>, array<1 x i64>)>

 
 // CHECK: [[ARGBASE_ALLOCA_GEP:%.*]] = getelementptr inbounds [2 x i8*], [2 x i8*]* [[ARGBASE_ALLOCA]], i32 0, i32 0
 // CHECK: [[ARG_ALLOCA_GEP:%.*]] = getelementptr inbounds [2 x i8*], [2 x i8*]* [[ARG_ALLOCA]], i32 0, i32 0
 // CHECK: [[SIZE_ALLOCA_GEP:%.*]] = getelementptr inbounds [2 x i64], [2 x i64]* [[SIZE_ALLOCA]], i32 0, i32 0
 
 // CHECK: call void @__tgt_target_data_begin_mapper(%struct.ident_t* [[LOCGLOBAL]], i64 -1, i32 2, i8** [[ARGBASE_ALLOCA_GEP]], i8** [[ARG_ALLOCA_GEP]], i64* [[SIZE_ALLOCA_GEP]], i64* getelementptr inbounds ([{{[0-9]*}} x i64], [{{[0-9]*}} x i64]* [[MAPTYPES]], i32 0, i32 0), i8** getelementptr inbounds ([{{[0-9]*}} x i8*], [{{[0-9]*}} x i8*]* [[MAPNAMES]], i32 0, i32 0), i8** null)
 
 // CHECK: declare void @__tgt_target_data_begin_mapper(%struct.ident_t*, i64, i32, i8**, i8**, i64*, i64*, i8**, i8**) #0
+
+// -----
+
+
+llvm.func @testexitdataop(%arg0: !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<1 x i64>, array<1 x i64>)>, %arg1: !llvm.ptr<f32>) {
+  %0 = llvm.mlir.constant(10 : index) : i64
+  %1 = llvm.mlir.null : !llvm.ptr<f32>
+  %2 = llvm.getelementptr %1[%0] : (!llvm.ptr<f32>, i64) -> !llvm.ptr<f32>
+  %3 = llvm.ptrtoint %2 : !llvm.ptr<f32> to i64
+  %4 = llvm.extractvalue %arg0[1] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<1 x i64>, array<1 x i64>)>
+  %5 = llvm.mlir.undef : !llvm.struct<"openacc_data", (struct<(ptr<f32>, ptr<f32>, i64, array<1 x i64>, array<1 x i64>)>, ptr<f32>, i64)>
+  %6 = llvm.insertvalue %arg0, %5[0] : !llvm.struct<"openacc_data", (struct<(ptr<f32>, ptr<f32>, i64, array<1 x i64>, array<1 x i64>)>, ptr<f32>, i64)>
+  %7 = llvm.insertvalue %4, %6[1] : !llvm.struct<"openacc_data", (struct<(ptr<f32>, ptr<f32>, i64, array<1 x i64>, array<1 x i64>)>, ptr<f32>, i64)>
+  %8 = llvm.insertvalue %3, %7[2] : !llvm.struct<"openacc_data", (struct<(ptr<f32>, ptr<f32>, i64, array<1 x i64>, array<1 x i64>)>, ptr<f32>, i64)>
+  acc.exit_data copyout(%arg1 : !llvm.ptr<f32>) delete(%8 : !llvm.struct<"openacc_data", (struct<(ptr<f32>, ptr<f32>, i64, array<1 x i64>, array<1 x i64>)>, ptr<f32>, i64)>)
+  llvm.return
+}
+
+// CHECK: %struct.ident_t = type { i32, i32, i32, i32, i8* }
+
+// CHECK: [[LOCSTR:@.*]] = private unnamed_addr constant [{{[0-9]*}} x i8] c";{{.*}};testexitdataop;{{[0-9]*}};{{[0-9]*}};;\00", align 1
+// CHECK: [[LOCGLOBAL:@.*]] = private unnamed_addr constant %struct.ident_t { i32 0, i32 2, i32 0, i32 0, i8* getelementptr inbounds ([{{[0-9]*}} x i8], [{{[0-9]*}} x i8]* [[LOCSTR]], i32 0, i32 0) }, align 8
+// CHECK: [[MAPNAME1:@.*]] = private unnamed_addr constant [{{[0-9]*}} x i8] c";{{.*}};unknown;{{[0-9]*}};{{[0-9]*}};;\00", align 1
+// CHECK: [[MAPNAME2:@.*]] = private unnamed_addr constant [{{[0-9]*}} x i8] c";{{.*}};unknown;{{[0-9]*}};{{[0-9]*}};;\00", align 1
+// CHECK: [[MAPTYPES:@.*]] = private unnamed_addr constant [{{[0-9]*}} x i64] [i64 8, i64 2]
+// CHECK: [[MAPNAMES:@.*]] = private constant [{{[0-9]*}} x i8*] [i8* getelementptr inbounds ([{{[0-9]*}} x i8], [{{[0-9]*}} x i8]* [[MAPNAME1]], i32 0, i32 0), i8* getelementptr inbounds ([{{[0-9]*}} x i8], [{{[0-9]*}} x i8]* [[MAPNAME2]], i32 0, i32 0)]
+
+// CHECK: define void @testexitdataop({ float*, float*, i64, [1 x i64], [1 x i64] } %{{.*}}, float* [[SIMPLEPTR:%.*]])
+// CHECK: [[ARGBASE_ALLOCA:%.*]] = alloca [{{[0-9]*}} x i8*], align 8
+// CHECK: [[ARG_ALLOCA:%.*]] = alloca [{{[0-9]*}} x i8*], align 8
+// CHECK: [[SIZE_ALLOCA:%.*]] = alloca [{{[0-9]*}} x i64], align 8
+
+// CHECK: [[ARGBASE:%.*]] = extractvalue %openacc_data %{{.*}}, 0
+// CHECK: [[ARG:%.*]] = extractvalue %openacc_data %{{.*}}, 1
+// CHECK: [[ARGSIZE:%.*]] = extractvalue %openacc_data %{{.*}}, 2
+// CHECK: [[ARGBASEGEP:%.*]] = getelementptr inbounds [2 x i8*], [2 x i8*]* [[ARGBASE_ALLOCA]], i32 0, i32 0
+// CHECK: [[ARGBASEGEPCAST:%.*]] = bitcast i8** [[ARGBASEGEP]] to { float*, float*, i64, [1 x i64], [1 x i64] }*
+// CHECK: store { float*, float*, i64, [1 x i64], [1 x i64] } [[ARGBASE]], { float*, float*, i64, [1 x i64], [1 x i64] }* [[ARGBASEGEPCAST]], align 8
+// CHECK: [[ARGGEP:%.*]] = getelementptr inbounds [2 x i8*], [2 x i8*]* [[ARG_ALLOCA]], i32 0, i32 0
+// CHECK: [[ARGGEPCAST:%.*]] = bitcast i8** [[ARGGEP]] to float**
+// CHECK: store float* [[ARG]], float** [[ARGGEPCAST]], align 8
+// CHECK: [[SIZEGEP:%.*]] = getelementptr inbounds [2 x i64], [2 x i64]* [[SIZE_ALLOCA]], i32 0, i32 0
+// CHECK: store i64 [[ARGSIZE]], i64* [[SIZEGEP]], align 4
+
+// CHECK: [[ARGBASEGEP:%.*]] = getelementptr inbounds [2 x i8*], [2 x i8*]* [[ARGBASE_ALLOCA]], i32 0, i32 1
+// CHECK: [[ARGBASEGEPCAST:%.*]] = bitcast i8** [[ARGBASEGEP]] to float**
+// CHECK: store float* [[SIMPLEPTR]], float** [[ARGBASEGEPCAST]], align 8
+// CHECK: [[ARGGEP:%.*]] = getelementptr inbounds [2 x i8*], [2 x i8*]* [[ARG_ALLOCA]], i32 0, i32 1
+// CHECK: [[ARGGEPCAST:%.*]] = bitcast i8** [[ARGGEP]] to float**
+// CHECK: store float* [[SIMPLEPTR]], float** [[ARGGEPCAST]], align 8
+// CHECK: [[SIZEGEP:%.*]] = getelementptr inbounds [2 x i64], [2 x i64]* [[SIZE_ALLOCA]], i32 0, i32 1
+// CHECK: store i64 ptrtoint (i1** getelementptr (i1*, i1** null, i32 1) to i64), i64* [[SIZEGEP]], align 4
+
+// CHECK: [[ARGBASE_ALLOCA_GEP:%.*]] = getelementptr inbounds [2 x i8*], [2 x i8*]* [[ARGBASE_ALLOCA]], i32 0, i32 0
+// CHECK: [[ARG_ALLOCA_GEP:%.*]] = getelementptr inbounds [2 x i8*], [2 x i8*]* [[ARG_ALLOCA]], i32 0, i32 0
+// CHECK: [[SIZE_ALLOCA_GEP:%.*]] = getelementptr inbounds [2 x i64], [2 x i64]* [[SIZE_ALLOCA]], i32 0, i32 0
+
+// CHECK: call void @__tgt_target_data_end_mapper(%struct.ident_t* [[LOCGLOBAL]], i64 -1, i32 2, i8** [[ARGBASE_ALLOCA_GEP]], i8** [[ARG_ALLOCA_GEP]], i64* [[SIZE_ALLOCA_GEP]], i64* getelementptr inbounds ([{{[0-9]*}} x i64], [{{[0-9]*}} x i64]* [[MAPTYPES]], i32 0, i32 0), i8** getelementptr inbounds ([{{[0-9]*}} x i8*], [{{[0-9]*}} x i8*]* [[MAPNAMES]], i32 0, i32 0), i8** null)
+
+// CHECK: declare void @__tgt_target_data_end_mapper(%struct.ident_t*, i64, i32, i8**, i8**, i64*, i64*, i8**, i8**) #0