[MLIR][OpenMP] Refactoring createTargetData in OMPIRBuilder

[TIFitis]

Summary

Key changes:

• Refactor the createTargetData function to make use of the emitOffloadingArrays and emitOffloadingArraysArgument functions to generate code.
• Added a new emitIfClause helper function to allow handling if clauses in a similar fashion to Clang.
• Updated the MLIR side of code to account for changes to createTargetData.

Depends on D149872

[TIFitis]

llvm/lib/Frontend/OpenMP/OMPIRBuilder.cpp

4153–4163

I couldn't come up with a better way for the code generated inside the target data region to use the new AllocaPtrs when accessing map operands marked with the use_device_ptr clause.

Currently I am just comparing the Users list before and after generating the data region and replacing the new uses.

Alternative method would be to use mlir::LLVM::moduleTranslation.mapValue method to temporarily remap the mlir::Value for the use_device_ptr operands to the AllocaPtrs llvm::Value. But mapValue doesn't allow remapping of values. @kiranchandramohan Is there a good reason to prevent remapping of values?

Let me know if anyone has a better way of doing this :)

[jdoerfert]

Conceptually, I am very confused but mostly because this patch conflates things.

I would suggest to split this part:

This also refactors how the map clause is processed and separates the mlir and IRBuilder parts of the code similar to Clang.

it that is a better way of doing things.

Then, let's talks about use_device_ptr.
For one, I am not sure which test even shows the lowering.

llvm/include/llvm/Frontend/OpenMP/OMPIRBuilder.h

1815

Everything in this file (should) come with documentation, including (most) members.

llvm/lib/Frontend/OpenMP/OMPIRBuilder.cpp

4076

Style, also elsewhere. I know it's annoying that MLIR broke with the LLVM style, but that is what it is now.

4153–4163

This is only a last resort. We should not generate stuff that is wrong and is replaced. However, if we cannot find a better way we can talk about it.

Generally, I would have assumed that the value in the region in marked to be a use_dev_ptr/addr and that we would generate code for that as soon as we generate code for the value.

[TIFitis]

Removed use_dev_ptr clause related code. This patch only refactors the map clause prcoessing now.
Addressed reviewer comments.

[TIFitis]

Updated tests. All tests pass now.

[TIFitis]

llvm/lib/Frontend/OpenMP/OMPIRBuilder.cpp

4153–4163

I have tried to explain this a little better in https://reviews.llvm.org/D146648

The region code is generated immediately, its that it still uses the old pointer for it instead of the newly allocated device ptr and this fixes that.

4220

getPointerDereferenceableBytes doesn't fully support Arguments and mostly returns 0.

I am looking at adding support for arguments in a separate patch, in the meantime the tests added in this patch fail because of incorrect @.offload_sizes.

[jdoerfert]

llvm/lib/Frontend/OpenMP/OMPIRBuilder.cpp

4220

That function is not the right one for code generation. The sizes need to come from the type + data layout, and potentially the expression used in the map.

[TIFitis]

llvm/lib/Frontend/OpenMP/OMPIRBuilder.cpp

4063–4076

I think these should just use the opaque ptr type instead of the ArrI8PtrTy it is currently using, and we can also get rid of the BitCast instructions.

However doing so would break the tests in OpenMPIRBuilderTest.cpp as that unit test still uses typed pointers.

AFAIK the consensus is to completely get rid of typed pointers in llvm 17. Should I updated this code to use opaque pointers and let the test fail until it gets converted to opaque as well?

4220

Thanks for letting me know.

Just to clarify, do you mean it should come from the MLIR::Type?

The llvm::Type doesn't let me get much information because of Opaque pointers.

[TIFitis]

Changed how size is calculated. Updated tests.

[TIFitis]

mlir/lib/Target/LLVMIR/Dialect/OpenMP/OpenMPToLLVMIRTranslation.cpp

1357–1362

@jdoerfert Is this way of getting the size correct? It seems to work for basic types and arrays which is what we support for now.

[TIFitis]

Updated unit test.

[TIFitis]

Polite request for reviews. Thanks :)

[TIFitis]

ping for reviews. Thanks :)

[TIFitis]

Updated to use opaque pointers, removed BitCast Insts.

[TIFitis]

ping for reviews. Thanks :)

[kiranchandramohan]

Please update the summary to convey all the changes introduced in the patch.

From the tests, it looks like there is a substantial change in the IR. I was hoping this to be an NFC change.

llvm/include/llvm/Frontend/OpenMP/OMPIRBuilder.h

1383

Please add the new argument to the documentation above.

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

4–5

Why is the test changed?

[TIFitis]

In D146557#4283149, @kiranchandramohan wrote:

Please update the summary to convey all the changes introduced in the patch.

From the tests, it looks like there is a substantial change in the IR. I was hoping this to be an NFC change.

I have updated the summary highlighting the notable changes along with changes to the generated code.

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

4–5

Moved the map_operand to function parameter to be consistent with other tests. I think it can remain unchanged if you prefer.

[kiranchandramohan]

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

4–5

Consistency can be achieved in a follow-up NFC patch that you can submit without review. If the test can only show the differences of this patch it is easier to review.

[kiranchandramohan]

Would it be possible to break this into a few patches like suggested below or similar?

1. Changed to using inlineConvertOmpRegions to generate target data associated region code inline in same block if possible.

2. Changed to calculating map_operand size from mlir type instead of llvm.

Moved getSizeInBytes function back into OpenACC code as it is no longer shared.

3. Moved most of map_operands related codegen to OMPIRBuilder.

Moved mapper_allocas related codegen to OMPIRBuilder.

4. Changed offload_sizes parameter to a global variable same as offload_maptypes to be more consistent with Clang generated code.

[TIFitis]

Updated tests. Addressed reviewer comments.

[TIFitis]

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

4–5

Thanks for letting me know. I've updated the tests.

[TIFitis]

Cleaned up how IsBegin argument is passed for createTargetData call.

[kiranchandramohan]

In D146557#4292223, @TIFitis wrote:

Cleaned up how IsBegin argument is passed for createTargetData call.

Please submit this directly as an NFC patch.

We should always work towards simple patches that are easy to review. Sometimes a big patch is required to give the full context. But it can then be broken up into small patches for faster review. I have created D149153 for the inlineConvertOmpRegions change.

[TIFitis]

In D146557#4295550, @kiranchandramohan wrote:

In D146557#4292223, @TIFitis wrote:

Cleaned up how IsBegin argument is passed for createTargetData call.

Please submit this directly as an NFC patch.

I have merged it separately.

We should always work towards simple patches that are easy to review. Sometimes a big patch is required to give the full context. But it can then be broken up into small patches for faster review. I have created D149153 for the inlineConvertOmpRegions change.

Thanks for creating your patch. I'll try to make my patches shorter in the future.

Once D149153 is merged I'll rebase this patch.

[TIFitis]

Rebased

[kiranchandramohan]

In D146557#4301955, @TIFitis wrote:

In D146557#4295550, @kiranchandramohan wrote:

In D146557#4292223, @TIFitis wrote:

Cleaned up how IsBegin argument is passed for createTargetData call.

Please submit this directly as an NFC patch.

I have merged it separately.

We should always work towards simple patches that are easy to review. Sometimes a big patch is required to give the full context. But it can then be broken up into small patches for faster review. I have created D149153 for the inlineConvertOmpRegions change.

Thanks for creating your patch. I'll try to make my patches shorter in the future.

Once D149153 is merged I'll rebase this patch.

I have submitted D149153. https://github.com/llvm/llvm-project/commit/1ed522623d95ce7dcf95e711b0f2e3844d2e6be1

[TIFitis]

Rebased

[TIFitis]

@kiranchandramohan I am in the process of submitting a new patch for review which moves the map processing from Clang Codegen to OMPIRBuilder. Once that is moved we can just use that for dealing with the map operands.
Thus putting this patch on hold for now.

[TIFitis]

Done migrating from Clang. This makes use of the clang functions now.

[TIFitis]

Small fix to code comments.

[TIFitis]

Rebased

[TIFitis]

Fix lint messages

[TIFitis]

Try to fix patch application.

[TIFitis]

Moved map processing code from functor to new static function.

[TIFitis]

Renamed from processMapOp to genMapInfos

[jdoerfert]

llvm/include/llvm/Frontend/OpenMP/OMPIRBuilder.h

1357

why are these capitalized?

llvm/lib/Frontend/OpenMP/OMPIRBuilder.cpp

4115

Can we not use an int for some "type". The 1 and 2 below are magic, use an enum and descriptive words.

4139

No llvm::. Also elsewhere.

4363

This function doesn't make sense to me. For one, I don't know what a "unreal block" is. Nor would I have expected a block with terminator to be silently not touched. It might just be a documentation issue (in the header). I would avoid duplicating the comment here again.

4421

CFG Utils have helpers for these things. Do we not use them on purpose?

[TIFitis]

Addressed reviewer comments.

llvm/lib/Frontend/OpenMP/OMPIRBuilder.cpp

4363

I've removed the comment here and updated it in the header file.

The current comment was taken directly from Clang. I've updated it say exactly what it does.

4421

If you are pointing at the SplitBlockAndInsertIfThen like functions in llvm/lib/Transforms/Utils/BasicBlockUtils.cpp then they require the current BB to be well formed with a terminator which it is not in this case.

Earlier we were adding an Unreachable inst and removing it later, however this function I think does a much cleaner job of handling all the cases including region code gen.

Also, it is not apparent in this patch but future patches including some from Jan in review make use of the emitBlock and emitBranch functions directly.

[jdoerfert]

llvm/include/llvm/Frontend/OpenMP/OMPIRBuilder.h

1356

This does not mention the deletion stuff, etc.

1803

documentation, what do they mean

llvm/lib/Frontend/OpenMP/OMPIRBuilder.cpp

4180

Style, also elsewhere.

4370

you should not just delete BB. eraseFromParent is a better way. That said, it is also weird you would delete something in an "emit" function.

4387–4389

mlir/lib/Target/LLVMIR/Dialect/OpenMP/OpenMPToLLVMIRTranslation.cpp

1357–1362

I don't know about mlir, if the DL has a "store size" use that.
That said, the size should potentially come from the user/front-end.

[TIFitis]

Addressed reviewer comments.

[TIFitis]

Update MLIR BodyGen callback.

[TIFitis]

llvm/lib/Frontend/OpenMP/OMPIRBuilder.cpp

4370

I've changed it.

The emitBlock, emitBranch and emitIfClause functions are ported from Clang btw.
clang/lib/CodeGen/CGStmt.cpp

mlir/lib/Target/LLVMIR/Dialect/OpenMP/OpenMPToLLVMIRTranslation.cpp

1357–1362

Clang seems to be doing something similar by calculating typeSize from clang::Type.

In my testing this works for what we support for now which are basic arrays, scalars, etc.

For derived types, array subscripts etc. we would need something more sophisticated. I plan on updating this as we add support.

[jdoerfert]

I think this is now style wise pretty good, I still found some potential problems below.

llvm/include/llvm/Frontend/OpenMP/OMPIRBuilder.h

1356

This talks about creating a new block, but reading the function it seems it will just place \p BB. Which one is it?

llvm/lib/Frontend/OpenMP/OMPIRBuilder.cpp

4147

Can we at least assert MapperFunc is non null if standalone is true. It seems like an invariant almost worth documenting, at least with an assertion + message.

4370

That might be so, but given the name and initial documentation, nobody would have expected this function to delete the block, or at least I would not have.

4390

In the call above you pass the AllocaIP here, now it is both times the saveIP. I doubt this is correct. Allocas will end up in the wrong spot, won't they? Do we have a test for that?

[TIFitis]

Addressed reviewer comments

llvm/include/llvm/Frontend/OpenMP/OMPIRBuilder.h

1356

Fixed.

llvm/lib/Frontend/OpenMP/OMPIRBuilder.cpp

4147

Added

4390

The CallBacks were ignoring the AllocaIP passed and getting it from the context instead.
I've updated them to use the CallBack argument instead.

This patch https://reviews.llvm.org/D150860 changes Clang to use this function for TargetDataCall emission which tests most aspects of it.

[jdoerfert]

LG

clang/lib/CodeGen/CGOpenMPRuntime.cpp

if (Info.NumberOfPtrs) {
     SmallVector<uint64_t, 4> Mapping;
     for (auto mapFlag : CombinedInfo.Types)
       Mapping.push_back(
           static_cast<std::underlying_type_t<OpenMPOffloadMappingFlags>>(
               mapFlag));
     std::string MaptypesName =
         CGM.getOpenMPRuntime().getName({"offload_maptypes"});
     auto *MapTypesArrayGbl =
-        OMPBuilder.createOffloadMaptypes(Mapping, MaptypesName);
+        OMPBuilder.createOffloadMapGlobals(Mapping, MaptypesName);
     Info.RTArgs.MapTypesArray = MapTypesArrayGbl;
 
     // The information types are only built if there is debug information
     // requested.
     if (CGM.getCodeGenOpts().getDebugInfo() ==
         llvm::codegenoptions::NoDebugInfo) {
       Info.RTArgs.MapNamesArray = llvm::Constant::getNullValue(
           llvm::Type::getInt8Ty(CGF.Builder.getContext())->getPointerTo());
if (Info.separateBeginEndCalls()) {
           Type &=
               ~static_cast<std::underlying_type_t<OpenMPOffloadMappingFlags>>(
                   OpenMPOffloadMappingFlags::OMP_MAP_PRESENT);
           EndMapTypesDiffer = true;
         }
       }
       if (EndMapTypesDiffer) {
         MapTypesArrayGbl =
-            OMPBuilder.createOffloadMaptypes(Mapping, MaptypesName);
+            OMPBuilder.createOffloadMapGlobals(Mapping, MaptypesName);
         Info.RTArgs.MapTypesArrayEnd = MapTypesArrayGbl;
       }
     }
 
     for (unsigned I = 0; I < Info.NumberOfPtrs; ++I) {
       llvm::Value *BPVal = *CombinedInfo.BasePointers[I];
       llvm::Value *BP = CGF.Builder.CreateConstInBoundsGEP2_32(
           llvm::ArrayType::get(CGM.VoidPtrTy, Info.NumberOfPtrs),

llvm/include/llvm/Frontend/OpenMP/OMPIRBuilder.h

public:
 
   /// An ordered map of auto-generated variables to their unique names.
   /// It stores variables with the following names: 1) ".gomp_critical_user_" +
   /// <critical_section_name> + ".var" for "omp critical" directives; 2)
   /// <mangled_name_for_global_var> + ".cache." for cache for threadprivate
   /// variables.
   StringMap<Constant*, BumpPtrAllocator> InternalVars;
 
-  /// Computes the size of type in bytes.
-  Value *getSizeInBytes(Value *BasePtr);
-
   /// Create the global variable holding the offload mappings information.
-  GlobalVariable *createOffloadMaptypes(SmallVectorImpl<uint64_t> &Mappings,
+  GlobalVariable *createOffloadMapGlobals(SmallVectorImpl<uint64_t> &Mappings,
                                           std::string VarName);
 
   /// Create the global variable holding the offload names information.
   GlobalVariable *
   createOffloadMapnames(SmallVectorImpl<llvm::Constant *> &Names,
                         std::string VarName);
 
   struct MapperAllocas {
     AllocaInst *ArgsBase = nullptr;
     AllocaInst *Args = nullptr;
     AllocaInst *ArgSizes = nullptr;
   };
 
   /// Create the allocas instruction used in call to mapper functions.
   void createMapperAllocas(const LocationDescription &Loc,
                            InsertPointTy AllocaIP, unsigned NumOperands,
-                           struct MapperAllocas &MapperAllocas);
+                           struct MapperAllocas &MapperAllocas,
+                           bool CreateSizes = true);
 
   /// Create the call for the target mapper function.
   /// \param Loc The source location description.
   /// \param MapperFunc Function to be called.
   /// \param SrcLocInfo Source location information global.
   /// \param MaptypesArg The argument types.
   /// \param MapnamesArg The argument names.
   /// \param MapperAllocas The AllocaInst used for the call.
   /// \param DeviceID Device ID for the call.
   /// \param NumOperands Number of operands in the call.
   void emitMapperCall(const LocationDescription &Loc, Function *MapperFunc,
                       Value *SrcLocInfo, Value *MaptypesArg, Value *MapnamesArg,
                       struct MapperAllocas &MapperAllocas, int64_t DeviceID,
-                      unsigned NumOperands);
+                      unsigned NumOperands, Value *MapsizesArg = nullptr);
 
   /// Container for the arguments used to pass data to the runtime library.
   struct TargetDataRTArgs {
     explicit TargetDataRTArgs() {}
     /// The array of base pointer passed to the runtime library.
     Value *BasePointersArray = nullptr;
     /// The array of section pointers passed to the runtime library.
     Value *PointersArray = nullptr;
public:
   /// \param NumTeams Number default teams
   /// \param NumThreads Number default threads
   Constant *registerTargetRegionFunction(TargetRegionEntryInfo &EntryInfo,
                                          Function *OutlinedFunction,
                                          StringRef EntryFnName,
                                          StringRef EntryFnIDName,
                                          int32_t NumTeams, int32_t NumThreads);
 
+  /// This structure contains combined information generated for mappable
+  /// clauses, including base pointers, pointers, names, sizes and map types.
+  struct MapInfo {
+    Constant *Name = nullptr;
+    uint64_t Type = 0x00;
+    uint64_t Size = 0;
+    Value *BasePtr = nullptr;
+    Value *Ptr = nullptr;
+  };
+
   /// Generator for '#omp target data'
   ///
   /// \param Loc The location where the target data construct was encountered.
+  /// \param AllocaIP The insertion points to be used for alloca instructions.
   /// \param CodeGenIP The insertion point at which the target directive code
   /// should be placed.
-  /// \param MapTypeFlags BitVector storing the mapType flags for the
-  /// mapOperands.
-  /// \param MapNames Names for the mapOperands.
-  /// \param MapperAllocas Pointers to the AllocInsts for the map clause.
   /// \param IsBegin If true then emits begin mapper call otherwise emits
   /// end mapper call.
   /// \param DeviceID Stores the DeviceID from the device clause.
   /// \param IfCond Value which corresponds to the if clause condition.
-  /// \param ProcessMapOpCB Callback that generates code for the map clause.
-  /// \param BodyGenCB Callback that will generate the region code.
-  OpenMPIRBuilder::InsertPointTy createTargetData(
-      const LocationDescription &Loc, OpenMPIRBuilder::InsertPointTy CodeGenIP,
-      SmallVectorImpl<uint64_t> &MapTypeFlags,
-      SmallVectorImpl<Constant *> &MapNames,
-      struct MapperAllocas &MapperAllocas, bool IsBegin, int64_t DeviceID,
-      Value *IfCond, BodyGenCallbackTy ProcessMapOpCB,
+  /// \param MapInfos Map from a 'map' Value* to its corresponding MapInfo.
+  /// \param BodyGenCB Callback that will generate the region body code.
+  InsertPointTy createTargetData(const LocationDescription &Loc,
+                                 InsertPointTy AllocaIP,
+                                 InsertPointTy CodeGenIP, bool IsBegin,
+                                 int64_t DeviceID, Value *IfCond,
+                                 SmallMapVector<Value *, MapInfo, 4> &MapInfos,
                                  BodyGenCallbackTy BodyGenCB = {});
 
   /// Declarations for LLVM-IR types (simple, array, function and structure) are
   /// generated below. Their names are defined and used in OpenMPKinds.def. Here
   /// we provide the declarations, the initializeTypes function will provide the
   /// values.
   ///
   ///{
 #define OMP_TYPE(VarName, InitValue) Type *VarName = nullptr;
private:
   ///
   /// \param XOld the value of the atomic memory address to use for update
   /// \param IRB reference to the IRBuilder to use
   ///
   /// \returns Value to update X to.
   using AtomicUpdateCallbackTy =
       const function_ref<Value *(Value *XOld, IRBuilder<> &IRB)>;
 
+  /// Generator for map clauses
+  ///
+  /// \param Loc The location where the target data construct was encountered.
+  /// \param AllocaIP The insertion points to be used for alloca instructions.
+  /// \param CodeGenIP The insertion point at which the target directive code
+  /// should be placed.
+  /// \param MapInfos Map from a 'map' Value* to its corresponding MapInfo.
+  /// \param BodyGenCB Callback that will generate the region body code.
+  /// \param MapperAllocas Return param for the Alloca pointers from
+  /// BasePtr, Ptr and Size ptr.
+  /// \param MapNamesGV Return param for the MapNames Global.
+  /// \param MapTypesGV Return param for the MapTypes Global.
+  /// \param MapSizesGV Return param for the MapSizes Global.
+  void ProcessMapInfo(const LocationDescription &Loc, InsertPointTy AllocaIP,
+                      InsertPointTy CodeGenIP,
+                      SmallMapVector<Value *, MapInfo, 4> &MapInfos,
+                      struct MapperAllocas &MapperAllocas, Value **MapNamesGV,
+                      Value **MapTypesGV, Value **MapSizesGV);
+
 private:
   enum AtomicKind { Read, Write, Update, Capture, Compare };
 
   /// Determine whether to emit flush or not
   ///
   /// \param Loc    The insert and source location description.
   /// \param AO     The required atomic ordering
   /// \param AK     The OpenMP atomic operation kind used.

llvm/lib/Frontend/OpenMP/OMPIRBuilder.cpp

Constant *OpenMPIRBuilder::registerTargetRegionFunction(
   auto OutlinedFnID = createOutlinedFunctionID(OutlinedFn, EntryFnIDName);
   auto EntryAddr = createTargetRegionEntryAddr(OutlinedFn, EntryFnName);
   OffloadInfoManager.registerTargetRegionEntryInfo(
       EntryInfo, EntryAddr, OutlinedFnID,
       OffloadEntriesInfoManager::OMPTargetRegionEntryTargetRegion);
   return OutlinedFnID;
 }
 
+void OpenMPIRBuilder::ProcessMapInfo(
+    const LocationDescription &Loc, InsertPointTy AllocaIP,
+    InsertPointTy CodeGenIP, SmallMapVector<Value *, MapInfo, 4> &MapInfos,
+    struct MapperAllocas &MapperAllocas, Value **MapNamesArg,
+    Value **MapTypesArg, Value **MapSizesArg) {
+  auto NumMapOperands = MapInfos.size();
+
+  createMapperAllocas(Loc, AllocaIP, NumMapOperands, MapperAllocas, false);
+
+  Builder.restoreIP(CodeGenIP);
+
+  ArrayType *ArrI8PtrTy =
+      ArrayType::get(Builder.getInt8PtrTy(), NumMapOperands);
+
+  unsigned Index = 0;
+  for (auto &MapOp : MapInfos) {
+    auto &MapInfo = MapOp.second;
+    Value *MapOpPtrBase, *MapOpPtr;
+    MapOpPtrBase = MapOpPtr = MapOp.first;
+
+    Value *BaseGEPPtr = Builder.CreateInBoundsGEP(
+        ArrI8PtrTy, MapperAllocas.ArgsBase,
+        {Builder.getInt32(0), Builder.getInt32(Index)});
+    Value *BaseCastPtr = Builder.CreateBitCast(
+        BaseGEPPtr, MapOpPtrBase->getType()->getPointerTo());
+    Builder.CreateStore(MapOpPtrBase, BaseCastPtr);
+    MapInfo.BasePtr = BaseGEPPtr;
+
+    Value *GEPPtr = Builder.CreateInBoundsGEP(
+        ArrI8PtrTy, MapperAllocas.Args,
+        {Builder.getInt32(0), Builder.getInt32(Index)});
+    Value *CastPtr =
+        Builder.CreateBitCast(GEPPtr, MapOpPtr->getType()->getPointerTo());
+    Builder.CreateStore(MapOpPtr, CastPtr);
+    MapInfo.BasePtr = BaseGEPPtr;
+    MapInfo.Ptr = GEPPtr;
+    Index++;
+  }
+
+  SmallVector<Constant *, 4> MapNames;
+  SmallVector<uint64_t, 4> MapTypes;
+  SmallVector<uint64_t, 4> MapSizes;
+
+  for (const auto &MapInfoIter : MapInfos) {
+    const auto &MapInfo = MapInfoIter.second;
+    MapNames.emplace_back(MapInfo.Name);
+    MapTypes.emplace_back(MapInfo.Type);
+    MapSizes.emplace_back(MapInfo.Size);
+  }
+
+  Value *MapNamesGV = createOffloadMapnames(MapNames, ".offload_mapnames");
+  *MapNamesArg = Builder.CreateConstInBoundsGEP2_32(
+      ArrayType::get(Builder.getInt8PtrTy(), NumMapOperands), MapNamesGV,
+      /*Idx0=*/0, /*Idx1=*/0);
+
+  Value *MapTypesGV = createOffloadMapGlobals(MapTypes, ".offload_maptypes");
+  *MapTypesArg = Builder.CreateConstInBoundsGEP2_32(
+      ArrayType::get(Builder.getInt64Ty(), NumMapOperands), MapTypesGV,
+      /*Idx0=*/0, /*Idx1=*/0);
+
+  Value *MapSizesGV = createOffloadMapGlobals(MapSizes, ".offload_sizes");
+  *MapSizesArg = Builder.CreateConstInBoundsGEP2_32(
+      ArrayType::get(Builder.getInt64Ty(), NumMapOperands), MapSizesGV,
+      /*Idx0=*/0, /*Idx1=*/0);
+}
+
 OpenMPIRBuilder::InsertPointTy OpenMPIRBuilder::createTargetData(
-    const LocationDescription &Loc, OpenMPIRBuilder::InsertPointTy CodeGenIP,
-    SmallVectorImpl<uint64_t> &MapTypeFlags,
-    SmallVectorImpl<Constant *> &MapNames, struct MapperAllocas &MapperAllocas,
-    bool IsBegin, int64_t DeviceID, Value *IfCond,
-    BodyGenCallbackTy ProcessMapOpCB, BodyGenCallbackTy BodyGenCB) {
+    const LocationDescription &Loc, InsertPointTy AllocaIP,
+    InsertPointTy CodeGenIP, bool IsBegin, int64_t DeviceID, Value *IfCond,
+    SmallMapVector<Value *, MapInfo, 4> &MapInfos,
+    BodyGenCallbackTy BodyGenCB) {
   if (!updateToLocation(Loc))
     return InsertPointTy();
 
   Builder.restoreIP(CodeGenIP);
 
   // LLVM utilities like blocks with terminators.
   // The UI acts as a resume point for code insertion after the BodyGen
   auto *UI = Builder.CreateUnreachable();
   if (IfCond) {
     auto *ThenTI =
         SplitBlockAndInsertIfThen(IfCond, UI, /* Unreachable */ false);
     ThenTI->getParent()->setName("omp_if.then");
     Builder.SetInsertPoint(ThenTI);
   } else {
     Builder.SetInsertPoint(UI);
   }
 
-  ProcessMapOpCB(Builder.saveIP(), Builder.saveIP());
+  struct MapperAllocas MapperAllocas;
+  Value *MapNamesArg = nullptr, *MapTypesArg = nullptr, *MapSizesArg = nullptr;
+  ProcessMapInfo(Loc, AllocaIP, Builder.saveIP(), MapInfos, MapperAllocas,
+                 &MapNamesArg, &MapTypesArg, &MapSizesArg);
 
   uint32_t SrcLocStrSize;
   Constant *SrcLocStr = getOrCreateSrcLocStr(Loc, SrcLocStrSize);
   Value *srcLocInfo = getOrCreateIdent(SrcLocStr, SrcLocStrSize);
 
-  GlobalVariable *MapTypesGV =
-      createOffloadMaptypes(MapTypeFlags, ".offload_maptypes");
-  Value *MapTypesArg = Builder.CreateConstInBoundsGEP2_32(
-      ArrayType::get(Builder.getInt64Ty(), MapTypeFlags.size()), MapTypesGV,
-      /*Idx0=*/0, /*Idx1=*/0);
-
-  GlobalVariable *MapNamesGV =
-      createOffloadMapnames(MapNames, ".offload_mapnames");
-  Value *MapNamesArg = Builder.CreateConstInBoundsGEP2_32(
-      ArrayType::get(Builder.getInt8PtrTy(), MapNames.size()), MapNamesGV,
-      /*Idx0=*/0, /*Idx1=*/0);
-
   Function *beginMapperFunc =
       getOrCreateRuntimeFunctionPtr(omp::OMPRTL___tgt_target_data_begin_mapper);
   Function *endMapperFunc =
       getOrCreateRuntimeFunctionPtr(omp::OMPRTL___tgt_target_data_end_mapper);
 
   if (BodyGenCB) {
     // Create call to start the data region.
     emitMapperCall(Builder.saveIP(), beginMapperFunc, srcLocInfo, MapTypesArg,
-                   MapNamesArg, MapperAllocas, DeviceID, MapTypeFlags.size());
+                   MapNamesArg, MapperAllocas, DeviceID, MapInfos.size(),
+                   MapSizesArg);
 
     BodyGenCB(Builder.saveIP(), Builder.saveIP());
 
     Builder.SetInsertPoint(UI->getParent());
     // Create call to end the data region.
     emitMapperCall(Builder.saveIP(), endMapperFunc, srcLocInfo, MapTypesArg,
-                   MapNamesArg, MapperAllocas, DeviceID, MapTypeFlags.size());
+                   MapNamesArg, MapperAllocas, DeviceID, MapInfos.size(),
+                   MapSizesArg);
   } else {
     emitMapperCall(Builder.saveIP(), IsBegin ? beginMapperFunc : endMapperFunc,
                    srcLocInfo, MapTypesArg, MapNamesArg, MapperAllocas,
-                   DeviceID, MapTypeFlags.size());
+                   DeviceID, MapInfos.size(), MapSizesArg);
   }
 
   // Update the insertion point and remove the terminator we introduced.
   Builder.SetInsertPoint(UI->getParent());
   if (IfCond)
     UI->getParent()->setName("omp_if.end");
   UI->eraseFromParent();
   return Builder.saveIP();
 }
 
 std::string OpenMPIRBuilder::getNameWithSeparators(ArrayRef<StringRef> Parts,
                                                    StringRef FirstSeparator,
                                                    StringRef Separator) {
   SmallString<128> Buffer;
   llvm::raw_svector_ostream OS(Buffer);
   StringRef Sep = FirstSeparator;
   for (StringRef Part : Parts) {
     OS << Sep << Part;
     Sep = Separator;
   }
   return OS.str().str();
 }
 
 std::string
 OpenMPIRBuilder::createPlatformSpecificName(ArrayRef<StringRef> Parts) const {
   return OpenMPIRBuilder::getNameWithSeparators(Parts, Config.firstSeparator(),
                                                 Config.separator());

 }
 
 Value *OpenMPIRBuilder::getOMPCriticalRegionLock(StringRef CriticalName) {
   std::string Prefix = Twine("gomp_critical_user_", CriticalName).str();
   std::string Name = getNameWithSeparators({Prefix, "var"}, ".", ".");
   return getOrCreateInternalVariable(KmpCriticalNameTy, Name);
 }
 
-Value *OpenMPIRBuilder::getSizeInBytes(Value *BasePtr) {
-  LLVMContext &Ctx = Builder.getContext();
-  Value *Null = Constant::getNullValue(BasePtr->getType()->getPointerTo());
-  Value *SizeGep =
-      Builder.CreateGEP(BasePtr->getType(), Null, Builder.getInt32(1));
-  Value *SizePtrToInt = Builder.CreatePtrToInt(SizeGep, Type::getInt64Ty(Ctx));
-  return SizePtrToInt;
-}
-
 GlobalVariable *
-OpenMPIRBuilder::createOffloadMaptypes(SmallVectorImpl<uint64_t> &Mappings,
+OpenMPIRBuilder::createOffloadMapGlobals(SmallVectorImpl<uint64_t> &Mappings,
                                          std::string VarName) {
   llvm::Constant *MaptypesArrayInit =
       llvm::ConstantDataArray::get(M.getContext(), Mappings);
   auto *MaptypesArrayGlobal = new llvm::GlobalVariable(
       M, MaptypesArrayInit->getType(),
       /*isConstant=*/true, llvm::GlobalValue::PrivateLinkage, MaptypesArrayInit,
       VarName);
   MaptypesArrayGlobal->setUnnamedAddr(llvm::GlobalValue::UnnamedAddr::Global);
   return MaptypesArrayGlobal;
 }
 
 void OpenMPIRBuilder::createMapperAllocas(const LocationDescription &Loc,
                                           InsertPointTy AllocaIP,
                                           unsigned NumOperands,
-                                          struct MapperAllocas &MapperAllocas) {
+                                          struct MapperAllocas &MapperAllocas,
+                                          bool CreateSizes) {
   if (!updateToLocation(Loc))
     return;
 
   auto *ArrI8PtrTy = ArrayType::get(Int8Ptr, NumOperands);
   auto *ArrI64Ty = ArrayType::get(Int64, NumOperands);
   Builder.restoreIP(AllocaIP);
   AllocaInst *ArgsBase = Builder.CreateAlloca(
       ArrI8PtrTy, /* ArraySize = */ nullptr, ".offload_baseptrs");
   AllocaInst *Args = Builder.CreateAlloca(ArrI8PtrTy, /* ArraySize = */ nullptr,
                                           ".offload_ptrs");
-  AllocaInst *ArgSizes = Builder.CreateAlloca(
-      ArrI64Ty, /* ArraySize = */ nullptr, ".offload_sizes");
-  Builder.restoreIP(Loc.IP);
   MapperAllocas.ArgsBase = ArgsBase;
   MapperAllocas.Args = Args;
+
+  if (CreateSizes) {
+    AllocaInst *ArgSizes = Builder.CreateAlloca(
+        ArrI64Ty, /* ArraySize = */ nullptr, ".offload_sizes");
     MapperAllocas.ArgSizes = ArgSizes;
   }
+  Builder.restoreIP(Loc.IP);
+}
 
 void OpenMPIRBuilder::emitMapperCall(const LocationDescription &Loc,
                                      Function *MapperFunc, Value *SrcLocInfo,
                                      Value *MaptypesArg, Value *MapnamesArg,
                                      struct MapperAllocas &MapperAllocas,
-                                     int64_t DeviceID, unsigned NumOperands) {
+                                     int64_t DeviceID, unsigned NumOperands,
+                                     Value *MapsizesArg) {
   if (!updateToLocation(Loc))
     return;
 
   auto *ArrI8PtrTy = ArrayType::get(Int8Ptr, NumOperands);
   auto *ArrI64Ty = ArrayType::get(Int64, NumOperands);
   Value *ArgsBaseGEP =
       Builder.CreateInBoundsGEP(ArrI8PtrTy, MapperAllocas.ArgsBase,
                                 {Builder.getInt32(0), Builder.getInt32(0)});
   Value *ArgsGEP =
       Builder.CreateInBoundsGEP(ArrI8PtrTy, MapperAllocas.Args,
                                 {Builder.getInt32(0), Builder.getInt32(0)});
-  Value *ArgSizesGEP =
+  Value *ArgSizesGEP;
+  if (MapsizesArg) {
+    ArgSizesGEP = MapsizesArg;
+  } else {
+    ArgSizesGEP =
         Builder.CreateInBoundsGEP(ArrI64Ty, MapperAllocas.ArgSizes,
                                   {Builder.getInt32(0), Builder.getInt32(0)});
+  }
   Value *NullPtr = Constant::getNullValue(Int8Ptr->getPointerTo());
   Builder.CreateCall(MapperFunc,
                      {SrcLocInfo, Builder.getInt64(DeviceID),
                       Builder.getInt32(NumOperands), ArgsBaseGEP, ArgsGEP,
                       ArgSizesGEP, MaptypesArg, MapnamesArg, NullPtr});
 }
 
 void OpenMPIRBuilder::emitOffloadingArraysArgument(IRBuilderBase &Builder,
bool OpenMPIRBuilder::checkAndEmitFlushAfterAtomic(
   llvm::AtomicOrdering FlushAO = AtomicOrdering::Monotonic;
 
   switch (AK) {
   case Read:
     if (AO == AtomicOrdering::Acquire || AO == AtomicOrdering::AcquireRelease ||
         AO == AtomicOrdering::SequentiallyConsistent) {
       FlushAO = AtomicOrdering::Acquire;
       Flush = true;
     }
     break;
   case Write:
   case Compare:
   case Update:
     if (AO == AtomicOrdering::Release || AO == AtomicOrdering::AcquireRelease ||
         AO == AtomicOrdering::SequentiallyConsistent) {
       FlushAO = AtomicOrdering::Release;
       Flush = true;
     }
     break;
   case Capture:
     switch (AO) {
     case AtomicOrdering::Acquire:
       FlushAO = AtomicOrdering::Acquire;
       Flush = true;
       break;
     case AtomicOrdering::Release:
       FlushAO = AtomicOrdering::Release;
       Flush = true;
       break;
     case AtomicOrdering::AcquireRelease:
     case AtomicOrdering::SequentiallyConsistent:
       FlushAO = AtomicOrdering::AcquireRelease;
       Flush = true;
       break;
     default:
       // do nothing - leave silently.
       break;
     }
   }
 
   if (Flush) {
     // Currently Flush RT call still doesn't take memory_ordering, so for when
     // that happens, this tries to do the resolution of which atomic ordering
     // to use with but issue the flush call
OpenMPIRBuilder::createAtomicRead(const LocationDescription &Loc,
   if (!updateToLocation(Loc))
     return Loc.IP;
 
   Type *XTy = X.Var->getType();
   assert(XTy->isPointerTy() && "OMP Atomic expects a pointer to target memory");
   Type *XElemTy = X.ElemTy;
   assert((XElemTy->isFloatingPointTy() || XElemTy->isIntegerTy() ||
           XElemTy->isPointerTy()) &&
          "OMP atomic read expected a scalar type");
 
   Value *XRead = nullptr;
 
   if (XElemTy->isIntegerTy()) {
     LoadInst *XLD =
         Builder.CreateLoad(XElemTy, X.Var, X.IsVolatile, "omp.atomic.read");
     XLD->setAtomic(AO);
     XRead = cast<Value>(XLD);

llvm/unittests/Frontend/OpenMPIRBuilderTest.cpp

 TEST_F(OpenMPIRBuilderTest, CreateOffloadMaptypes) {
   OpenMPIRBuilder OMPBuilder(*M);
   OMPBuilder.initialize();
 
   IRBuilder<> Builder(BB);
 
   SmallVector<uint64_t> Mappings = {0, 1};
   GlobalVariable *OffloadMaptypesGlobal =
-      OMPBuilder.createOffloadMaptypes(Mappings, "offload_maptypes");
+      OMPBuilder.createOffloadMapGlobals(Mappings, "offload_maptypes");
   EXPECT_FALSE(M->global_empty());
   EXPECT_EQ(OffloadMaptypesGlobal->getName(), "offload_maptypes");
   EXPECT_TRUE(OffloadMaptypesGlobal->isConstant());
   EXPECT_TRUE(OffloadMaptypesGlobal->hasGlobalUnnamedAddr());
   EXPECT_TRUE(OffloadMaptypesGlobal->hasPrivateLinkage());
   EXPECT_TRUE(OffloadMaptypesGlobal->hasInitializer());
   Constant *Initializer = OffloadMaptypesGlobal->getInitializer();
   EXPECT_TRUE(isa<ConstantDataArray>(Initializer));
TEST_F(OpenMPIRBuilderTest, EmitMapperCall) {
 
   Constant *Cst1 =
       OMPBuilder.getOrCreateSrcLocStr("array1", "file1", 2, 5, StrSize);
   Constant *Cst2 =
       OMPBuilder.getOrCreateSrcLocStr("array2", "file1", 3, 5, StrSize);
   SmallVector<llvm::Constant *> Names = {Cst1, Cst2};
 
   GlobalVariable *Maptypes =
-      OMPBuilder.createOffloadMaptypes(Flags, ".offload_maptypes");
+      OMPBuilder.createOffloadMapGlobals(Flags, ".offload_maptypes");
   Value *MaptypesArg = Builder.CreateConstInBoundsGEP2_32(
       ArrayType::get(Type::getInt64Ty(Ctx), TotalNbOperand), Maptypes,
       /*Idx0=*/0, /*Idx1=*/0);
 
   GlobalVariable *Mapnames =
       OMPBuilder.createOffloadMapnames(Names, ".offload_mapnames");
   Value *MapnamesArg = Builder.CreateConstInBoundsGEP2_32(
       ArrayType::get(Type::getInt8PtrTy(Ctx), TotalNbOperand), Mapnames,
TEST_F(OpenMPIRBuilderTest, EmitMapperCall) {
   EXPECT_TRUE(MapperCall->getOperand(8)->getType()->isPointerTy());
 }
 
 TEST_F(OpenMPIRBuilderTest, TargetEnterData) {
   OpenMPIRBuilder OMPBuilder(*M);
   OMPBuilder.initialize();
   F->setName("func");
   IRBuilder<> Builder(BB);
-
   OpenMPIRBuilder::LocationDescription Loc({Builder.saveIP(), DL});
-
-  unsigned NumDataOperands = 1;
   int64_t DeviceID = 2;
-  struct OpenMPIRBuilder::MapperAllocas MapperAllocas;
-  SmallVector<uint64_t> MapTypeFlagsTo = {1};
-  SmallVector<Constant *> MapNames;
-  auto *I8PtrTy = Builder.getInt8PtrTy();
-  auto *ArrI8PtrTy = ArrayType::get(I8PtrTy, NumDataOperands);
-  auto *I64Ty = Builder.getInt64Ty();
-  auto *ArrI64Ty = ArrayType::get(I64Ty, NumDataOperands);
 
   AllocaInst *Val1 =
       Builder.CreateAlloca(Builder.getInt32Ty(), Builder.getInt64(1));
   ASSERT_NE(Val1, nullptr);
 
   IRBuilder<>::InsertPoint AllocaIP(&F->getEntryBlock(),
                                     F->getEntryBlock().getFirstInsertionPt());
-  OMPBuilder.createMapperAllocas(Builder.saveIP(), AllocaIP, NumDataOperands,
-                                 MapperAllocas);
 
-  using InsertPointTy = OpenMPIRBuilder::InsertPointTy;
-  auto ProcessMapOpCB = [&](InsertPointTy AllocaIP, InsertPointTy CodeGenIP) {
-    Value *DataValue = Val1;
-    Value *DataPtrBase;
-    Value *DataPtr;
-    DataPtrBase = DataValue;
-    DataPtr = DataValue;
-    Builder.restoreIP(CodeGenIP);
+  llvm::SmallMapVector<llvm::Value *, llvm::OpenMPIRBuilder::MapInfo, 4>
+      MapInfos;
 
-    Value *Null = Constant::getNullValue(DataValue->getType()->getPointerTo());
-    Value *SizeGep =
-        Builder.CreateGEP(DataValue->getType(), Null, Builder.getInt32(1));
-    Value *SizePtrToInt = Builder.CreatePtrToInt(SizeGep, I64Ty);
-
-    Value *PtrBaseGEP =
-        Builder.CreateInBoundsGEP(ArrI8PtrTy, MapperAllocas.ArgsBase,
-                                  {Builder.getInt32(0), Builder.getInt32(0)});
-    Value *PtrBaseCast = Builder.CreateBitCast(
-        PtrBaseGEP, DataPtrBase->getType()->getPointerTo());
-    Builder.CreateStore(DataPtrBase, PtrBaseCast);
-    Value *PtrGEP =
-        Builder.CreateInBoundsGEP(ArrI8PtrTy, MapperAllocas.Args,
-                                  {Builder.getInt32(0), Builder.getInt32(0)});
-    Value *PtrCast =
-        Builder.CreateBitCast(PtrGEP, DataPtr->getType()->getPointerTo());
-    Builder.CreateStore(DataPtr, PtrCast);
-    Value *SizeGEP =
-        Builder.CreateInBoundsGEP(ArrI64Ty, MapperAllocas.ArgSizes,
-                                  {Builder.getInt32(0), Builder.getInt32(0)});
-    Builder.CreateStore(SizePtrToInt, SizeGEP);
-  };
+  uint32_t temp;
+  MapInfos[Val1].Name = OMPBuilder.getOrCreateSrcLocStr("unknown", temp);
+  MapInfos[Val1].Size = 4;
+  MapInfos[Val1].Type = 1;
 
   Builder.restoreIP(OMPBuilder.createTargetData(
-      Loc, Builder.saveIP(), MapTypeFlagsTo, MapNames, MapperAllocas,
-      /* IsBegin= */ true, DeviceID, /* IfCond= */ nullptr, ProcessMapOpCB));
+      Loc, AllocaIP, Builder.saveIP(), /* IsBegin= */ true, DeviceID,
+      /* IfCond= */ nullptr, MapInfos));
 
   CallInst *TargetDataCall = dyn_cast<CallInst>(&BB->back());
   EXPECT_NE(TargetDataCall, nullptr);
   EXPECT_EQ(TargetDataCall->arg_size(), 9U);
   EXPECT_EQ(TargetDataCall->getCalledFunction()->getName(),
             "__tgt_target_data_begin_mapper");
   EXPECT_TRUE(TargetDataCall->getOperand(1)->getType()->isIntegerTy(64));
   EXPECT_TRUE(TargetDataCall->getOperand(2)->getType()->isIntegerTy(32));
   EXPECT_TRUE(TargetDataCall->getOperand(8)->getType()->isPointerTy());
 
   Builder.CreateRetVoid();
   EXPECT_FALSE(verifyModule(*M, &errs()));
 }
 
 TEST_F(OpenMPIRBuilderTest, TargetExitData) {
   OpenMPIRBuilder OMPBuilder(*M);
   OMPBuilder.initialize();
   F->setName("func");
   IRBuilder<> Builder(BB);
-
   OpenMPIRBuilder::LocationDescription Loc({Builder.saveIP(), DL});
-
-  unsigned NumDataOperands = 1;
   int64_t DeviceID = 2;
-  struct OpenMPIRBuilder::MapperAllocas MapperAllocas;
-  SmallVector<uint64_t> MapTypeFlagsFrom = {2};
-  SmallVector<Constant *> MapNames;
-  auto *I8PtrTy = Builder.getInt8PtrTy();
-  auto *ArrI8PtrTy = ArrayType::get(I8PtrTy, NumDataOperands);
-  auto *I64Ty = Builder.getInt64Ty();
-  auto *ArrI64Ty = ArrayType::get(I64Ty, NumDataOperands);
 
   AllocaInst *Val1 =
       Builder.CreateAlloca(Builder.getInt32Ty(), Builder.getInt64(1));
   ASSERT_NE(Val1, nullptr);
 
   IRBuilder<>::InsertPoint AllocaIP(&F->getEntryBlock(),
                                     F->getEntryBlock().getFirstInsertionPt());
-  OMPBuilder.createMapperAllocas(Builder.saveIP(), AllocaIP, NumDataOperands,
-                                 MapperAllocas);
 
-  using InsertPointTy = OpenMPIRBuilder::InsertPointTy;
-  auto ProcessMapOpCB = [&](InsertPointTy AllocaIP, InsertPointTy CodeGenIP) {
-    Value *DataValue = Val1;
-    Value *DataPtrBase;
-    Value *DataPtr;
-    DataPtrBase = DataValue;
-    DataPtr = DataValue;
-    Builder.restoreIP(CodeGenIP);
+  llvm::SmallMapVector<llvm::Value *, llvm::OpenMPIRBuilder::MapInfo, 4>
+      MapInfos;
 
-    Value *Null = Constant::getNullValue(DataValue->getType()->getPointerTo());
-    Value *SizeGep =
-        Builder.CreateGEP(DataValue->getType(), Null, Builder.getInt32(1));
-    Value *SizePtrToInt = Builder.CreatePtrToInt(SizeGep, I64Ty);
-
-    Value *PtrBaseGEP =
-        Builder.CreateInBoundsGEP(ArrI8PtrTy, MapperAllocas.ArgsBase,
-                                  {Builder.getInt32(0), Builder.getInt32(0)});
-    Value *PtrBaseCast = Builder.CreateBitCast(
-        PtrBaseGEP, DataPtrBase->getType()->getPointerTo());
-    Builder.CreateStore(DataPtrBase, PtrBaseCast);
-    Value *PtrGEP =
-        Builder.CreateInBoundsGEP(ArrI8PtrTy, MapperAllocas.Args,
-                                  {Builder.getInt32(0), Builder.getInt32(0)});
-    Value *PtrCast =
-        Builder.CreateBitCast(PtrGEP, DataPtr->getType()->getPointerTo());
-    Builder.CreateStore(DataPtr, PtrCast);
-    Value *SizeGEP =
-        Builder.CreateInBoundsGEP(ArrI64Ty, MapperAllocas.ArgSizes,
-                                  {Builder.getInt32(0), Builder.getInt32(0)});
-    Builder.CreateStore(SizePtrToInt, SizeGEP);
-  };
+  uint32_t temp;
+  MapInfos[Val1].Name = OMPBuilder.getOrCreateSrcLocStr("unknown", temp);
+  MapInfos[Val1].Size = 4;
+  MapInfos[Val1].Type = 2;
 
   Builder.restoreIP(OMPBuilder.createTargetData(
-      Loc, Builder.saveIP(), MapTypeFlagsFrom, MapNames, MapperAllocas,
-      /* IsBegin= */ false, DeviceID, /* IfCond= */ nullptr, ProcessMapOpCB));
+      Loc, AllocaIP, Builder.saveIP(), /* IsBegin= */ false, DeviceID,
+      /* IfCond= */ nullptr, MapInfos));
 
   CallInst *TargetDataCall = dyn_cast<CallInst>(&BB->back());
   EXPECT_NE(TargetDataCall, nullptr);
   EXPECT_EQ(TargetDataCall->arg_size(), 9U);
   EXPECT_EQ(TargetDataCall->getCalledFunction()->getName(),
             "__tgt_target_data_end_mapper");
   EXPECT_TRUE(TargetDataCall->getOperand(1)->getType()->isIntegerTy(64));
   EXPECT_TRUE(TargetDataCall->getOperand(2)->getType()->isIntegerTy(32));
   EXPECT_TRUE(TargetDataCall->getOperand(8)->getType()->isPointerTy());
 
   Builder.CreateRetVoid();
   EXPECT_FALSE(verifyModule(*M, &errs()));
 }
 
 TEST_F(OpenMPIRBuilderTest, TargetDataRegion) {
   OpenMPIRBuilder OMPBuilder(*M);
   OMPBuilder.initialize();
   F->setName("func");
   IRBuilder<> Builder(BB);
-
   OpenMPIRBuilder::LocationDescription Loc({Builder.saveIP(), DL});
-
-  unsigned NumDataOperands = 1;
   int64_t DeviceID = 2;
-  struct OpenMPIRBuilder::MapperAllocas MapperAllocas;
-  SmallVector<uint64_t> MapTypeFlagsToFrom = {3};
-  SmallVector<Constant *> MapNames;
-  auto *I8PtrTy = Builder.getInt8PtrTy();
-  auto *ArrI8PtrTy = ArrayType::get(I8PtrTy, NumDataOperands);
-  auto *I64Ty = Builder.getInt64Ty();
-  auto *ArrI64Ty = ArrayType::get(I64Ty, NumDataOperands);
 
   AllocaInst *Val1 =
       Builder.CreateAlloca(Builder.getInt32Ty(), Builder.getInt64(1));
   ASSERT_NE(Val1, nullptr);
 
   IRBuilder<>::InsertPoint AllocaIP(&F->getEntryBlock(),
                                     F->getEntryBlock().getFirstInsertionPt());
-  OMPBuilder.createMapperAllocas(Builder.saveIP(), AllocaIP, NumDataOperands,
-                                 MapperAllocas);
 
-  using InsertPointTy = OpenMPIRBuilder::InsertPointTy;
-  auto ProcessMapOpCB = [&](InsertPointTy AllocaIP, InsertPointTy CodeGenIP) {
-    Value *DataValue = Val1;
-    Value *DataPtrBase;
-    Value *DataPtr;
-    DataPtrBase = DataValue;
-    DataPtr = DataValue;
-    Builder.restoreIP(CodeGenIP);
+  llvm::SmallMapVector<llvm::Value *, llvm::OpenMPIRBuilder::MapInfo, 4>
+      MapInfos;
 
-    Value *Null = Constant::getNullValue(DataValue->getType()->getPointerTo());
-    Value *SizeGep =
-        Builder.CreateGEP(DataValue->getType(), Null, Builder.getInt32(1));
-    Value *SizePtrToInt = Builder.CreatePtrToInt(SizeGep, I64Ty);
-
-    Value *PtrBaseGEP =
-        Builder.CreateInBoundsGEP(ArrI8PtrTy, MapperAllocas.ArgsBase,
-                                  {Builder.getInt32(0), Builder.getInt32(0)});
-    Value *PtrBaseCast = Builder.CreateBitCast(
-        PtrBaseGEP, DataPtrBase->getType()->getPointerTo());
-    Builder.CreateStore(DataPtrBase, PtrBaseCast);
-    Value *PtrGEP =
-        Builder.CreateInBoundsGEP(ArrI8PtrTy, MapperAllocas.Args,
-                                  {Builder.getInt32(0), Builder.getInt32(0)});
-    Value *PtrCast =
-        Builder.CreateBitCast(PtrGEP, DataPtr->getType()->getPointerTo());
-    Builder.CreateStore(DataPtr, PtrCast);
-    Value *SizeGEP =
-        Builder.CreateInBoundsGEP(ArrI64Ty, MapperAllocas.ArgSizes,
-                                  {Builder.getInt32(0), Builder.getInt32(0)});
-    Builder.CreateStore(SizePtrToInt, SizeGEP);
-  };
+  uint32_t temp;
+  MapInfos[Val1].Name = OMPBuilder.getOrCreateSrcLocStr("unknown", temp);
+  MapInfos[Val1].Size = 4;
+  MapInfos[Val1].Type = 3;
 
+  using InsertPointTy = OpenMPIRBuilder::InsertPointTy;
   auto BodyCB = [&](InsertPointTy allocaIP, InsertPointTy codeGenIP) {
+    CallInst *TargetDataCall = dyn_cast<CallInst>(BB->back().getPrevNode());
+    EXPECT_NE(TargetDataCall, nullptr);
+    EXPECT_EQ(TargetDataCall->arg_size(), 9U);
+    EXPECT_EQ(TargetDataCall->getCalledFunction()->getName(),
+              "__tgt_target_data_begin_mapper");
+    EXPECT_TRUE(TargetDataCall->getOperand(1)->getType()->isIntegerTy(64));
+    EXPECT_TRUE(TargetDataCall->getOperand(2)->getType()->isIntegerTy(32));
+    EXPECT_TRUE(TargetDataCall->getOperand(8)->getType()->isPointerTy());
     Builder.restoreIP(codeGenIP);
-    auto *SI = Builder.CreateStore(Builder.getInt32(99), Val1);
-    auto *newBB = SplitBlock(Builder.GetInsertBlock(), SI);
-    Builder.SetInsertPoint(newBB);
-    auto *UI = &Builder.GetInsertBlock()->back();
-    SplitBlock(Builder.GetInsertBlock(), UI);
+    Builder.CreateStore(Builder.getInt32(99), Val1);
   };
 
   Builder.restoreIP(OMPBuilder.createTargetData(
-      Loc, Builder.saveIP(), MapTypeFlagsToFrom, MapNames, MapperAllocas,
-      /* IsBegin= */ false, DeviceID, /* IfCond= */ nullptr, ProcessMapOpCB,
-      BodyCB));
+      Loc, AllocaIP, Builder.saveIP(), /* IsBegin= */ false, DeviceID,
+      /* IfCond= */ nullptr, MapInfos, BodyCB));
 
-  CallInst *TargetDataCall =
-      dyn_cast<CallInst>(&Builder.GetInsertBlock()->back());
+  CallInst *TargetDataCall = dyn_cast<CallInst>(&BB->back());
   EXPECT_NE(TargetDataCall, nullptr);
   EXPECT_EQ(TargetDataCall->arg_size(), 9U);
   EXPECT_EQ(TargetDataCall->getCalledFunction()->getName(),
             "__tgt_target_data_end_mapper");
   EXPECT_TRUE(TargetDataCall->getOperand(1)->getType()->isIntegerTy(64));
   EXPECT_TRUE(TargetDataCall->getOperand(2)->getType()->isIntegerTy(32));
   EXPECT_TRUE(TargetDataCall->getOperand(8)->getType()->isPointerTy());
 

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

return llvm::TypeSwitch<Operation *, llvm::Function *>(op)
       })
       .Case([&](acc::UpdateOp) {
         return builder.getOrCreateRuntimeFunctionPtr(
             llvm::omp::OMPRTL___tgt_target_data_update_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,
                 ValueRange operands, unsigned totalNbOperand,
                 uint64_t operandFlag, SmallVector<uint64_t> &flags,
                 SmallVectorImpl<llvm::Constant *> &names, unsigned &index,
if (DataDescriptor::isValid(data)) {
       dataPtrBase =
           builder.CreateExtractValue(dataValue, kPtrBasePosInDataDescriptor);
       dataPtr = builder.CreateExtractValue(dataValue, kPtrPosInDataDescriptor);
       dataSize =
           builder.CreateExtractValue(dataValue, kSizePosInDataDescriptor);
     } else if (data.getType().isa<LLVM::LLVMPointerType>()) {
       dataPtrBase = dataValue;
       dataPtr = dataValue;
-      dataSize = accBuilder->getSizeInBytes(dataValue);
+      dataSize = getSizeInBytes(builder, dataValue);
     } else {
       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.
static LogicalResult convertDataOp(acc::DataOp &op,
 
   if (failed(processOperands(builder, moduleTranslation, op,
                              op.getPresentOperands(), totalNbOperand,
                              kPresentFlag | kHoldFlag, flags, names, index,
                              mapperAllocas)))
     return failure();
 
   llvm::GlobalVariable *maptypes =
-      accBuilder->createOffloadMaptypes(flags, ".offload_maptypes");
+      accBuilder->createOffloadMapGlobals(flags, ".offload_maptypes");
   llvm::Value *maptypesArg = builder.CreateConstInBoundsGEP2_32(
       llvm::ArrayType::get(llvm::Type::getInt64Ty(ctx), totalNbOperand),
       maptypes, /*Idx0=*/0, /*Idx1=*/0);
 
   llvm::GlobalVariable *mapnames =
       accBuilder->createOffloadMapnames(names, ".offload_mapnames");
   llvm::Value *mapnamesArg = builder.CreateConstInBoundsGEP2_32(
       llvm::ArrayType::get(llvm::Type::getInt8PtrTy(ctx), totalNbOperand),
convertStandaloneDataOp(OpTy &op, llvm::IRBuilderBase &builder,
   SmallVector<uint64_t> flags;
   SmallVector<llvm::Constant *> names;
 
   if (failed(processDataOperands(builder, moduleTranslation, op, flags, names,
                                  mapperAllocas)))
     return failure();
 
   llvm::GlobalVariable *maptypes =
-      accBuilder->createOffloadMaptypes(flags, ".offload_maptypes");
+      accBuilder->createOffloadMapGlobals(flags, ".offload_maptypes");
   llvm::Value *maptypesArg = builder.CreateConstInBoundsGEP2_32(
       llvm::ArrayType::get(llvm::Type::getInt64Ty(ctx), totalNbOperand),
       maptypes, /*Idx0=*/0, /*Idx1=*/0);
 
   llvm::GlobalVariable *mapnames =
       accBuilder->createOffloadMapnames(names, ".offload_mapnames");
   llvm::Value *mapnamesArg = builder.CreateConstInBoundsGEP2_32(
       llvm::ArrayType::get(llvm::Type::getInt8PtrTy(ctx), totalNbOperand),

mlir/lib/Target/LLVMIR/Dialect/OpenMP/OpenMPToLLVMIRTranslation.cpp

convertOmpThreadprivate(Operation &opInst, llvm::IRBuilderBase &builder,
   llvm::Value *callInst =
       moduleTranslation.getOpenMPBuilder()->createCachedThreadPrivate(
           ompLoc, data, size, cacheName);
   llvm::Value *result = builder.CreateBitCast(callInst, globalValue->getType());
   moduleTranslation.mapValue(opInst.getResult(0), result);
   return success();
 }
 
-/// Process MapOperands for Target Data directives.
-static LogicalResult processMapOperand(
-    llvm::IRBuilderBase &builder, LLVM::ModuleTranslation &moduleTranslation,
-    const SmallVector<Value> &mapOperands, const ArrayAttr &mapTypes,
-    SmallVector<uint64_t> &mapTypeFlags,
-    SmallVectorImpl<llvm::Constant *> &mapNames,
-    struct llvm::OpenMPIRBuilder::MapperAllocas &mapperAllocas) {
-  auto numMapOperands = mapOperands.size();
-  llvm::OpenMPIRBuilder *ompBuilder = moduleTranslation.getOpenMPBuilder();
-  llvm::PointerType *i8PtrTy = builder.getInt8PtrTy();
-  llvm::ArrayType *arrI8PtrTy = llvm::ArrayType::get(i8PtrTy, numMapOperands);
-  llvm::IntegerType *i64Ty = builder.getInt64Ty();
-  llvm::ArrayType *arrI64Ty = llvm::ArrayType::get(i64Ty, numMapOperands);
+/// Get size in Bytes for an mlir::Type
+int64_t getSizeInBytes(DataLayout &DL, const mlir::Type &type) {
+  if (isa<LLVM::LLVMPointerType>(type))
+    return DL.getTypeSize(cast<LLVM::LLVMPointerType>(type).getElementType());
+
+  return -1;
+}
 
+/// Gather Type and Name and other information for the map operands.
+static LogicalResult gatherMapInfo(
+    LLVM::ModuleTranslation &moduleTranslation, DataLayout &DL,
+    const SmallVectorImpl<Value> &mapOperands, const ArrayAttr &mapTypes,
+    llvm::SmallMapVector<llvm::Value *, llvm::OpenMPIRBuilder::MapInfo, 4>
+        &mapInfos) {
+  llvm::OpenMPIRBuilder *ompBuilder = moduleTranslation.getOpenMPBuilder();
   unsigned index = 0;
   for (const auto &mapOp : mapOperands) {
-    const auto &mapTypeOp = mapTypes[index];
-
-    llvm::Value *mapOpValue = moduleTranslation.lookupValue(mapOp);
-    llvm::Value *mapOpPtrBase;
-    llvm::Value *mapOpPtr;
-    llvm::Value *mapOpSize;
-
-    if (mapOp.getType().isa<LLVM::LLVMPointerType>()) {
-      mapOpPtrBase = mapOpValue;
-      mapOpPtr = mapOpValue;
-      mapOpSize = ompBuilder->getSizeInBytes(mapOpValue);
-    } else {
+    if (!mapOp.getType().isa<LLVM::LLVMPointerType>())
       return failure();
-    }
-
-    // Store base pointer extracted from operand into the i-th position of
-    // argBase.
-    llvm::Value *ptrBaseGEP = builder.CreateInBoundsGEP(
-        arrI8PtrTy, mapperAllocas.ArgsBase,
-        {builder.getInt32(0), builder.getInt32(index)});
-    llvm::Value *ptrBaseCast = builder.CreateBitCast(
-        ptrBaseGEP, mapOpPtrBase->getType()->getPointerTo());
-    builder.CreateStore(mapOpPtrBase, ptrBaseCast);
-
-    // Store pointer extracted from operand into the i-th position of args.
-    llvm::Value *ptrGEP = builder.CreateInBoundsGEP(
-        arrI8PtrTy, mapperAllocas.Args,
-        {builder.getInt32(0), builder.getInt32(index)});
-    llvm::Value *ptrCast =
-        builder.CreateBitCast(ptrGEP, mapOpPtr->getType()->getPointerTo());
-    builder.CreateStore(mapOpPtr, ptrCast);
-
-    // Store size extracted from operand into the i-th position of argSizes.
-    llvm::Value *sizeGEP = builder.CreateInBoundsGEP(
-        arrI64Ty, mapperAllocas.ArgSizes,
-        {builder.getInt32(0), builder.getInt32(index)});
-    builder.CreateStore(mapOpSize, sizeGEP);
-
-    mapTypeFlags.push_back(mapTypeOp.dyn_cast<mlir::IntegerAttr>().getInt());
-    llvm::Constant *mapName =
+    llvm::Value *mapOpValue = moduleTranslation.lookupValue(mapOp);
+    mapInfos[mapOpValue].Name =
         mlir::LLVM::createMappingInformation(mapOp.getLoc(), *ompBuilder);
-    mapNames.push_back(mapName);
-    ++index;
+    mapInfos[mapOpValue].Type =
+        mapTypes[index].dyn_cast<mlir::IntegerAttr>().getInt();
+    mapInfos[mapOpValue].Size = getSizeInBytes(DL, mapOp.getType());
+    index++;
   }
-
   return success();
 }
 
 static LogicalResult
 convertOmpTargetData(Operation *op, llvm::IRBuilderBase &builder,
                      LLVM::ModuleTranslation &moduleTranslation) {
   unsigned numMapOperands;
-  bool mapperFunc;
+  bool isBegin;
   llvm::Value *ifCond = nullptr;
   int64_t deviceID = llvm::omp::OMP_DEVICEID_UNDEF;
   SmallVector<Value> mapOperands;
   ArrayAttr mapTypes;
+  llvm::SmallMapVector<llvm::Value *, llvm::OpenMPIRBuilder::MapInfo, 4>
+      mapInfos;
+  DataLayout DL = DataLayout(op->getParentOfType<ModuleOp>());
 
   llvm::OpenMPIRBuilder *ompBuilder = moduleTranslation.getOpenMPBuilder();
 
   LogicalResult result =
       llvm::TypeSwitch<Operation *, LogicalResult>(op)
           .Case([&](omp::DataOp dataOp) {
             if (!dataOp.getUseDeviceAddr().empty() ||
                 !dataOp.getUseDevicePtr().empty())
LogicalResult result =
                       devId.getDefiningOp()))
                 if (auto intAttr =
                         constOp.getValue().dyn_cast<mlir::IntegerAttr>())
                   deviceID = intAttr.getInt();
 
             numMapOperands = enterDataOp.getMapOperands().size();
             mapOperands = enterDataOp.getMapOperands();
             mapTypes = enterDataOp.getMapTypes();
-            mapperFunc = true;
+            isBegin = true;
             return success();
           })
           .Case([&](omp::ExitDataOp exitDataOp) {
             if (exitDataOp.getNowait())
               return failure();
 
             if (auto ifExprVar = exitDataOp.getIfExpr())
               ifCond = moduleTranslation.lookupValue(ifExprVar);
 
             if (auto devId = exitDataOp.getDevice())
               if (auto constOp = mlir::dyn_cast<mlir::LLVM::ConstantOp>(
                       devId.getDefiningOp()))
                 if (auto intAttr =
                         constOp.getValue().dyn_cast<mlir::IntegerAttr>())
                   deviceID = intAttr.getInt();
 
             numMapOperands = exitDataOp.getMapOperands().size();
             mapOperands = exitDataOp.getMapOperands();
             mapTypes = exitDataOp.getMapTypes();
-            mapperFunc = false;
+            isBegin = false;
             return success();
           })
           .Default([&](Operation *op) {
             return op->emitError("unsupported OpenMP operation: ")
                    << op->getName();
           });
 
   if (failed(result))
     return failure();
 
-  llvm::OpenMPIRBuilder::LocationDescription ompLoc(builder);
-  llvm::OpenMPIRBuilder::InsertPointTy allocaIP =
-      findAllocaInsertPoint(builder, moduleTranslation);
-
-  struct llvm::OpenMPIRBuilder::MapperAllocas mapperAllocas;
-  SmallVector<uint64_t> mapTypeFlags;
-  SmallVector<llvm::Constant *> mapNames;
-  ompBuilder->createMapperAllocas(builder.saveIP(), allocaIP, numMapOperands,
-                                  mapperAllocas);
-
-  using InsertPointTy = llvm::OpenMPIRBuilder::InsertPointTy;
-  LogicalResult processMapOpStatus = success();
-  auto processMapOpCB = [&](InsertPointTy allocaIP, InsertPointTy codeGenIP) {
-    builder.restoreIP(codeGenIP);
-    processMapOpStatus =
-        processMapOperand(builder, moduleTranslation, mapOperands, mapTypes,
-                          mapTypeFlags, mapNames, mapperAllocas);
-  };
-
   LogicalResult bodyGenStatus = success();
+  using InsertPointTy = llvm::OpenMPIRBuilder::InsertPointTy;
   auto bodyCB = [&](InsertPointTy allocaIP, InsertPointTy codeGenIP) {
     // DataOp has only one region associated with it.
     auto &region = cast<omp::DataOp>(op).getRegion();
     builder.restoreIP(codeGenIP);
-    convertOmpOpRegions(region, "omp.data.region", builder, moduleTranslation,
-                        bodyGenStatus);
+    bodyGenStatus = inlineConvertOmpRegions(region, "omp.data.region", builder,
+                                            moduleTranslation);
   };
 
+  if (failed(gatherMapInfo(moduleTranslation, DL, mapOperands, mapTypes,
+                           mapInfos)))
+    return failure();
+
+  llvm::OpenMPIRBuilder::LocationDescription ompLoc(builder);
+  llvm::OpenMPIRBuilder::InsertPointTy allocaIP =
+      findAllocaInsertPoint(builder, moduleTranslation);
+
   if (isa<omp::DataOp>(op)) {
     builder.restoreIP(ompBuilder->createTargetData(
-        ompLoc, builder.saveIP(), mapTypeFlags, mapNames, mapperAllocas,
-        mapperFunc, deviceID, ifCond, processMapOpCB, bodyCB));
+        ompLoc, allocaIP, builder.saveIP(), isBegin, deviceID, ifCond, mapInfos,
+        bodyCB));
   } else {
-    builder.restoreIP(ompBuilder->createTargetData(
-        ompLoc, builder.saveIP(), mapTypeFlags, mapNames, mapperAllocas,
-        mapperFunc, deviceID, ifCond, processMapOpCB));
+    builder.restoreIP(ompBuilder->createTargetData(ompLoc, allocaIP,
+                                                   builder.saveIP(), isBegin,
+                                                   deviceID, ifCond, mapInfos));
   }
 
-  if (failed(processMapOpStatus))
-    return processMapOpStatus;
   return bodyGenStatus;
 }
 
 namespace {
 
 /// Implementation of the dialect interface that converts operations belonging
 /// to the OpenMP dialect to LLVM IR.
 class OpenMPDialectLLVMIRTranslationInterface

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

 // RUN: mlir-translate -mlir-to-llvmir -split-input-file %s | FileCheck %s
 
-llvm.func @_QPopenmp_target_data() {
-  %0 = llvm.mlir.constant(1 : i64) : i64
-  %1 = llvm.alloca %0 x i32 {bindc_name = "i", in_type = i32, operand_segment_sizes = array<i32: 0, 0>, uniq_name = "_QFopenmp_target_dataEi"} : (i64) -> !llvm.ptr<i32>
+llvm.func @_QPopenmp_target_data(%1 : !llvm.ptr<i32>) {
   omp.target_data   map((tofrom -> %1 : !llvm.ptr<i32>)) {
     %2 = llvm.mlir.constant(99 : i32) : i32
     llvm.store %2, %1 : !llvm.ptr<i32>
     omp.terminator
   }
   llvm.return
 }
 
 // CHECK:         @.offload_maptypes = private unnamed_addr constant [1 x i64] [i64 3]
-// CHECK-LABEL: define void @_QPopenmp_target_data() {
+// CHECK:         @.offload_sizes = private unnamed_addr constant [1 x i64] [i64 4]
+// CHECK-LABEL: define void @_QPopenmp_target_data
+// CHECK:         (ptr %[[ARG_0:.*]]) {
 // CHECK:         %[[VAL_0:.*]] = alloca [1 x ptr], align 8
 // CHECK:         %[[VAL_1:.*]] = alloca [1 x ptr], align 8
-// CHECK:         %[[VAL_2:.*]] = alloca [1 x i64], align 8
-// CHECK:         %[[VAL_3:.*]] = alloca i32, i64 1, align 4
-// CHECK:         br label %[[VAL_4:.*]]
-// CHECK:       entry:                                            ; preds = %[[VAL_5:.*]]
-// CHECK:         %[[VAL_6:.*]] = getelementptr inbounds [1 x ptr], ptr %[[VAL_0]], i32 0, i32 0
-// CHECK:         store ptr %[[VAL_3]], ptr %[[VAL_6]], align 8
-// CHECK:         %[[VAL_7:.*]] = getelementptr inbounds [1 x ptr], ptr %[[VAL_1]], i32 0, i32 0
-// CHECK:         store ptr %[[VAL_3]], ptr %[[VAL_7]], align 8
-// CHECK:         %[[VAL_8:.*]] = getelementptr inbounds [1 x i64], ptr %[[VAL_2]], i32 0, i32 0
-// CHECK:         store i64 ptrtoint (ptr getelementptr (ptr, ptr null, i32 1) to i64), ptr %[[VAL_8]], align 4
+// CHECK:         br label %[[VAL_2:.*]]
+// CHECK:       entry:                                            ; preds = %[[VAL_3:.*]]
+// CHECK:         %[[VAL_4:.*]] = getelementptr inbounds [1 x ptr], ptr %[[VAL_0]], i32 0, i32 0
+// CHECK:         store ptr %[[ARG_0]], ptr %[[VAL_4]], align 8
+// CHECK:         %[[VAL_6:.*]] = getelementptr inbounds [1 x ptr], ptr %[[VAL_1]], i32 0, i32 0
+// CHECK:         store ptr %[[ARG_0]], ptr %[[VAL_6]], align 8
+// CHECK:         %[[VAL_7:.*]] = getelementptr inbounds [1 x ptr], ptr %[[VAL_0]], i32 0, i32 0
+// CHECK:         %[[VAL_8:.*]] = getelementptr inbounds [1 x ptr], ptr %[[VAL_1]], i32 0, i32 0
+// CHECK:         call void @__tgt_target_data_begin_mapper(ptr @2, i64 -1, i32 1, ptr %[[VAL_7]], ptr %[[VAL_8]], ptr @.offload_sizes, ptr @.offload_maptypes, ptr @.offload_mapnames, ptr null)
+// CHECK:         store i32 99, ptr %[[ARG_0]], align 4
 // CHECK:         %[[VAL_9:.*]] = getelementptr inbounds [1 x ptr], ptr %[[VAL_0]], i32 0, i32 0
 // CHECK:         %[[VAL_10:.*]] = getelementptr inbounds [1 x ptr], ptr %[[VAL_1]], i32 0, i32 0
-// CHECK:         %[[VAL_11:.*]] = getelementptr inbounds [1 x i64], ptr %[[VAL_2]], i32 0, i32 0
-// CHECK:         call void @__tgt_target_data_begin_mapper(ptr @2, i64 -1, i32 1, ptr %[[VAL_9]], ptr %[[VAL_10]], ptr %[[VAL_11]], ptr @.offload_maptypes, ptr @.offload_mapnames, ptr null)
-// CHECK:         br label %[[VAL_12:.*]]
-// CHECK:       omp.data.region:                                  ; preds = %[[VAL_4]]
-// CHECK:         store i32 99, ptr %[[VAL_3]], align 4
-// CHECK:         br label %[[VAL_13:.*]]
-// CHECK:       omp.region.cont:                                  ; preds = %[[VAL_12]]
-// CHECK:         %[[VAL_14:.*]] = getelementptr inbounds [1 x ptr], ptr %[[VAL_0]], i32 0, i32 0
-// CHECK:         %[[VAL_15:.*]] = getelementptr inbounds [1 x ptr], ptr %[[VAL_1]], i32 0, i32 0
-// CHECK:         %[[VAL_16:.*]] = getelementptr inbounds [1 x i64], ptr %[[VAL_2]], i32 0, i32 0
-// CHECK:         call void @__tgt_target_data_end_mapper(ptr @2, i64 -1, i32 1, ptr %[[VAL_14]], ptr %[[VAL_15]], ptr %[[VAL_16]], ptr @.offload_maptypes, ptr @.offload_mapnames, ptr null)
+// CHECK:         call void @__tgt_target_data_end_mapper(ptr @2, i64 -1, i32 1, ptr %[[VAL_9]], ptr %[[VAL_10]], ptr @.offload_sizes, ptr @.offload_maptypes, ptr @.offload_mapnames, ptr null)
 // CHECK:         ret void
 
 // -----
 
-llvm.func @_QPopenmp_target_data_region(%1 : !llvm.ptr<array<1024 x i32>>) {
-  omp.target_data   map((from -> %1 : !llvm.ptr<array<1024 x i32>>)) {
-    %2 = llvm.mlir.constant(99 : i32) : i32
+llvm.func @_QPopenmp_target_data_region(%a : !llvm.ptr<array<1024 x i32>>) {
+  omp.target_data   map((from -> %a : !llvm.ptr<array<1024 x i32>>)) {
+    %2 = llvm.mlir.constant(10 : i32) : i32
     %3 = llvm.mlir.constant(1 : i64) : i64
     %4 = llvm.mlir.constant(1 : i64) : i64
     %5 = llvm.mlir.constant(0 : i64) : i64
-    %6 = llvm.getelementptr %1[0, %5] : (!llvm.ptr<array<1024 x i32>>, i64) -> !llvm.ptr<i32>
+    %6 = llvm.getelementptr %a[0, %5] : (!llvm.ptr<array<1024 x i32>>, i64) -> !llvm.ptr<i32>
     llvm.store %2, %6 : !llvm.ptr<i32>
     omp.terminator
   }
   llvm.return
 }
 
 // CHECK:         @.offload_maptypes = private unnamed_addr constant [1 x i64] [i64 2]
+// CHECK:         @.offload_sizes = private unnamed_addr constant [1 x i64] [i64 4096]
 // CHECK-LABEL: define void @_QPopenmp_target_data_region
 // CHECK:         (ptr %[[ARG_0:.*]]) {
 // CHECK:         %[[VAL_0:.*]] = alloca [1 x ptr], align 8
 // CHECK:         %[[VAL_1:.*]] = alloca [1 x ptr], align 8
-// CHECK:         %[[VAL_2:.*]] = alloca [1 x i64], align 8
-// CHECK:         br label %[[VAL_3:.*]]
-// CHECK:       entry:                                            ; preds = %[[VAL_4:.*]]
-// CHECK:         %[[VAL_5:.*]] = getelementptr inbounds [1 x ptr], ptr %[[VAL_0]], i32 0, i32 0
-// CHECK:         store ptr %[[VAL_6:.*]], ptr %[[VAL_5]], align 8
-// CHECK:         %[[VAL_7:.*]] = getelementptr inbounds [1 x ptr], ptr %[[VAL_1]], i32 0, i32 0
-// CHECK:         store ptr %[[VAL_6]], ptr %[[VAL_7]], align 8
-// CHECK:         %[[VAL_8:.*]] = getelementptr inbounds [1 x i64], ptr %[[VAL_2]], i32 0, i32 0
-// CHECK:         store i64 ptrtoint (ptr getelementptr (ptr, ptr null, i32 1) to i64), ptr %[[VAL_8]], align 4
-// CHECK:         %[[VAL_9:.*]] = getelementptr inbounds [1 x ptr], ptr %[[VAL_0]], i32 0, i32 0
-// CHECK:         %[[VAL_10:.*]] = getelementptr inbounds [1 x ptr], ptr %[[VAL_1]], i32 0, i32 0
-// CHECK:         %[[VAL_11:.*]] = getelementptr inbounds [1 x i64], ptr %[[VAL_2]], i32 0, i32 0
-// CHECK:         call void @__tgt_target_data_begin_mapper(ptr @2, i64 -1, i32 1, ptr %[[VAL_9]], ptr %[[VAL_10]], ptr %[[VAL_11]], ptr @.offload_maptypes, ptr @.offload_mapnames, ptr null)
-// CHECK:         br label %[[VAL_12:.*]]
-// CHECK:       omp.data.region:                                  ; preds = %[[VAL_3]]
-// CHECK:         %[[VAL_13:.*]] = getelementptr [1024 x i32], ptr %[[VAL_6]], i32 0, i64 0
-// CHECK:         store i32 99, ptr %[[VAL_13]], align 4
-// CHECK:         br label %[[VAL_14:.*]]
-// CHECK:       omp.region.cont:                                  ; preds = %[[VAL_12]]
-// CHECK:         %[[VAL_15:.*]] = getelementptr inbounds [1 x ptr], ptr %[[VAL_0]], i32 0, i32 0
-// CHECK:         %[[VAL_16:.*]] = getelementptr inbounds [1 x ptr], ptr %[[VAL_1]], i32 0, i32 0
-// CHECK:         %[[VAL_17:.*]] = getelementptr inbounds [1 x i64], ptr %[[VAL_2]], i32 0, i32 0
-// CHECK:         call void @__tgt_target_data_end_mapper(ptr @2, i64 -1, i32 1, ptr %[[VAL_15]], ptr %[[VAL_16]], ptr %[[VAL_17]], ptr @.offload_maptypes, ptr @.offload_mapnames, ptr null)
+// CHECK:         br label %[[VAL_2:.*]]
+// CHECK:       entry:                                            ; preds = %[[VAL_3:.*]]
+// CHECK:         %[[VAL_4:.*]] = getelementptr inbounds [1 x ptr], ptr %[[VAL_0]], i32 0, i32 0
+// CHECK:         store ptr %[[ARG_0]], ptr %[[VAL_4]], align 8
+// CHECK:         %[[VAL_6:.*]] = getelementptr inbounds [1 x ptr], ptr %[[VAL_1]], i32 0, i32 0
+// CHECK:         store ptr %[[ARG_0]], ptr %[[VAL_6]], align 8
+// CHECK:         %[[VAL_7:.*]] = getelementptr inbounds [1 x ptr], ptr %[[VAL_0]], i32 0, i32 0
+// CHECK:         %[[VAL_8:.*]] = getelementptr inbounds [1 x ptr], ptr %[[VAL_1]], i32 0, i32 0
+// CHECK:         call void @__tgt_target_data_begin_mapper(ptr @2, i64 -1, i32 1, ptr %[[VAL_7]], ptr %[[VAL_8]], ptr @.offload_sizes, ptr @.offload_maptypes, ptr @.offload_mapnames, ptr null)
+// CHECK:         %[[VAL_9:.*]] = getelementptr [1024 x i32], ptr %[[ARG_0]], i32 0, i64 0
+// CHECK:         store i32 10, ptr %[[VAL_9]], align 4
+// CHECK:         %[[VAL_10:.*]] = getelementptr inbounds [1 x ptr], ptr %[[VAL_0]], i32 0, i32 0
+// CHECK:         %[[VAL_11:.*]] = getelementptr inbounds [1 x ptr], ptr %[[VAL_1]], i32 0, i32 0
+// CHECK:         call void @__tgt_target_data_end_mapper(ptr @2, i64 -1, i32 1, ptr %[[VAL_10]], ptr %[[VAL_11]], ptr @.offload_sizes, ptr @.offload_maptypes, ptr @.offload_mapnames, ptr null)
 // CHECK:         ret void
 
 // -----
 
-llvm.func @_QPomp_target_enter_exit(%1 : !llvm.ptr<array<1024 x i32>>, %3 : !llvm.ptr<array<1024 x i32>>) {
+llvm.func @_QPomp_target_enter_exit(%a : !llvm.ptr<array<1024 x i32>>, %b : !llvm.ptr<array<512 x i32>>) {
   %4 = llvm.mlir.constant(1 : i64) : i64
   %5 = llvm.alloca %4 x i32 {bindc_name = "dvc", in_type = i32, operand_segment_sizes = array<i32: 0, 0>, uniq_name = "_QFomp_target_enter_exitEdvc"} : (i64) -> !llvm.ptr<i32>
   %6 = llvm.mlir.constant(1 : i64) : i64
   %7 = llvm.alloca %6 x i32 {bindc_name = "i", in_type = i32, operand_segment_sizes = array<i32: 0, 0>, uniq_name = "_QFomp_target_enter_exitEi"} : (i64) -> !llvm.ptr<i32>
   %8 = llvm.mlir.constant(5 : i32) : i32
   llvm.store %8, %7 : !llvm.ptr<i32>
   %9 = llvm.mlir.constant(2 : i32) : i32
   llvm.store %9, %5 : !llvm.ptr<i32>
   %10 = llvm.load %7 : !llvm.ptr<i32>
   %11 = llvm.mlir.constant(10 : i32) : i32
   %12 = llvm.icmp "slt" %10, %11 : i32
   %13 = llvm.load %5 : !llvm.ptr<i32>
-  omp.target_enter_data   if(%12 : i1) device(%13 : i32) map((to -> %1 : !llvm.ptr<array<1024 x i32>>), (alloc -> %3 : !llvm.ptr<array<1024 x i32>>))
+  omp.target_enter_data   if(%12 : i1) device(%13 : i32) map((to -> %a : !llvm.ptr<array<1024 x i32>>), (alloc -> %b : !llvm.ptr<array<512 x i32>>))
   %14 = llvm.load %7 : !llvm.ptr<i32>
   %15 = llvm.mlir.constant(10 : i32) : i32
   %16 = llvm.icmp "sgt" %14, %15 : i32
   %17 = llvm.load %5 : !llvm.ptr<i32>
-  omp.target_exit_data   if(%16 : i1) device(%17 : i32) map((from -> %1 : !llvm.ptr<array<1024 x i32>>), (release -> %3 : !llvm.ptr<array<1024 x i32>>))
+  omp.target_exit_data   if(%16 : i1) device(%17 : i32) map((from -> %a : !llvm.ptr<array<1024 x i32>>), (release -> %b : !llvm.ptr<array<512 x i32>>))
   llvm.return
 }
 
 // CHECK:         @.offload_maptypes = private unnamed_addr constant [2 x i64] [i64 1, i64 0]
-// CHECK:         @.offload_maptypes.1 = private unnamed_addr constant [2 x i64] [i64 2, i64 0]
+// CHECK:         @.offload_sizes = private unnamed_addr constant [2 x i64] [i64 4096, i64 2048]
+// CHECK:         @.offload_maptypes.2 = private unnamed_addr constant [2 x i64] [i64 2, i64 0]
+// CHECK:         @.offload_sizes.3 = private unnamed_addr constant [2 x i64] [i64 4096, i64 2048]
 // CHECK-LABEL: define void @_QPomp_target_enter_exit
 // CHECK:         (ptr %[[ARG_0:.*]], ptr %[[ARG_1:.*]]) {
 // CHECK:         %[[VAL_0:.*]] = alloca [2 x ptr], align 8
 // CHECK:         %[[VAL_1:.*]] = alloca [2 x ptr], align 8
-// CHECK:         %[[VAL_2:.*]] = alloca [2 x i64], align 8
+// CHECK:         %[[VAL_2:.*]] = alloca [2 x ptr], align 8
 // CHECK:         %[[VAL_3:.*]] = alloca [2 x ptr], align 8
-// CHECK:         %[[VAL_4:.*]] = alloca [2 x ptr], align 8
-// CHECK:         %[[VAL_5:.*]] = alloca [2 x i64], align 8
-// CHECK:         %[[VAL_6:.*]] = alloca i32, i64 1, align 4
-// CHECK:         %[[VAL_7:.*]] = alloca i32, i64 1, align 4
-// CHECK:         store i32 5, ptr %[[VAL_7]], align 4
-// CHECK:         store i32 2, ptr %[[VAL_6]], align 4
-// CHECK:         %[[VAL_8:.*]] = load i32, ptr %[[VAL_7]], align 4
-// CHECK:         %[[VAL_9:.*]] = icmp slt i32 %[[VAL_8]], 10
-// CHECK:         %[[VAL_10:.*]] = load i32, ptr %[[VAL_6]], align 4
-// CHECK:         br label %[[VAL_11:.*]]
-// CHECK:       entry:                                            ; preds = %[[VAL_12:.*]]
-// CHECK:         br i1 %[[VAL_9]], label %[[VAL_13:.*]], label %[[VAL_14:.*]]
-// CHECK:       omp_if.then:                                      ; preds = %[[VAL_11]]
+// CHECK:         %[[VAL_4:.*]] = alloca i32, i64 1, align 4
+// CHECK:         %[[VAL_5:.*]] = alloca i32, i64 1, align 4
+// CHECK:         store i32 5, ptr %[[VAL_5]], align 4
+// CHECK:         store i32 2, ptr %[[VAL_4]], align 4
+// CHECK:         %[[VAL_6:.*]] = load i32, ptr %[[VAL_5]], align 4
+// CHECK:         %[[VAL_7:.*]] = icmp slt i32 %[[VAL_6]], 10
+// CHECK:         %[[VAL_8:.*]] = load i32, ptr %[[VAL_4]], align 4
+// CHECK:         br label %[[VAL_9:.*]]
+// CHECK:       entry:                                            ; preds = %[[VAL_10:.*]]
+// CHECK:         br i1 %[[VAL_7]], label %[[VAL_11:.*]], label %[[VAL_12:.*]]
+// CHECK:       omp_if.then:                                      ; preds = %[[VAL_9]]
+// CHECK:         %[[VAL_13:.*]] = getelementptr inbounds [2 x ptr], ptr %[[VAL_2]], i32 0, i32 0
+// CHECK:         store ptr %[[ARG_0]], ptr %[[VAL_13]], align 8
 // CHECK:         %[[VAL_15:.*]] = getelementptr inbounds [2 x ptr], ptr %[[VAL_3]], i32 0, i32 0
-// CHECK:         store ptr %[[VAL_16:.*]], ptr %[[VAL_15]], align 8
-// CHECK:         %[[VAL_17:.*]] = getelementptr inbounds [2 x ptr], ptr %[[VAL_4]], i32 0, i32 0
-// CHECK:         store ptr %[[VAL_16]], ptr %[[VAL_17]], align 8
-// CHECK:         %[[VAL_18:.*]] = getelementptr inbounds [2 x i64], ptr %[[VAL_5]], i32 0, i32 0
-// CHECK:         store i64 ptrtoint (ptr getelementptr (ptr, ptr null, i32 1) to i64), ptr %[[VAL_18]], align 4
-// CHECK:         %[[VAL_19:.*]] = getelementptr inbounds [2 x ptr], ptr %[[VAL_3]], i32 0, i32 1
-// CHECK:         store ptr %[[VAL_20:.*]], ptr %[[VAL_19]], align 8
-// CHECK:         %[[VAL_21:.*]] = getelementptr inbounds [2 x ptr], ptr %[[VAL_4]], i32 0, i32 1
-// CHECK:         store ptr %[[VAL_20]], ptr %[[VAL_21]], align 8
-// CHECK:         %[[VAL_22:.*]] = getelementptr inbounds [2 x i64], ptr %[[VAL_5]], i32 0, i32 1
-// CHECK:         store i64 ptrtoint (ptr getelementptr (ptr, ptr null, i32 1) to i64), ptr %[[VAL_22]], align 4
-// CHECK:         %[[VAL_23:.*]] = getelementptr inbounds [2 x ptr], ptr %[[VAL_3]], i32 0, i32 0
-// CHECK:         %[[VAL_24:.*]] = getelementptr inbounds [2 x ptr], ptr %[[VAL_4]], i32 0, i32 0
-// CHECK:         %[[VAL_25:.*]] = getelementptr inbounds [2 x i64], ptr %[[VAL_5]], i32 0, i32 0
-// CHECK:         call void @__tgt_target_data_begin_mapper(ptr @3, i64 -1, i32 2, ptr %[[VAL_23]], ptr %[[VAL_24]], ptr %[[VAL_25]], ptr @.offload_maptypes, ptr @.offload_mapnames, ptr null)
-// CHECK:         br label %[[VAL_14]]
-// CHECK:       omp_if.end:                                       ; preds = %[[VAL_11]], %[[VAL_13]]
-// CHECK:         %[[VAL_26:.*]] = load i32, ptr %[[VAL_7]], align 4
-// CHECK:         %[[VAL_27:.*]] = icmp sgt i32 %[[VAL_26]], 10
-// CHECK:         %[[VAL_28:.*]] = load i32, ptr %[[VAL_6]], align 4
-// CHECK:         br i1 %[[VAL_27]], label %[[VAL_29:.*]], label %[[VAL_30:.*]]
-// CHECK:       omp_if.then4:                                     ; preds = %[[VAL_14]]
-// CHECK:         %[[VAL_31:.*]] = getelementptr inbounds [2 x ptr], ptr %[[VAL_0]], i32 0, i32 0
-// CHECK:         store ptr %[[VAL_16]], ptr %[[VAL_31]], align 8
-// CHECK:         %[[VAL_32:.*]] = getelementptr inbounds [2 x ptr], ptr %[[VAL_1]], i32 0, i32 0
-// CHECK:         store ptr %[[VAL_16]], ptr %[[VAL_32]], align 8
-// CHECK:         %[[VAL_33:.*]] = getelementptr inbounds [2 x i64], ptr %[[VAL_2]], i32 0, i32 0
-// CHECK:         store i64 ptrtoint (ptr getelementptr (ptr, ptr null, i32 1) to i64), ptr %[[VAL_33]], align 4
-// CHECK:         %[[VAL_34:.*]] = getelementptr inbounds [2 x ptr], ptr %[[VAL_0]], i32 0, i32 1
-// CHECK:         store ptr %[[VAL_20]], ptr %[[VAL_34]], align 8
-// CHECK:         %[[VAL_35:.*]] = getelementptr inbounds [2 x ptr], ptr %[[VAL_1]], i32 0, i32 1
-// CHECK:         store ptr %[[VAL_20]], ptr %[[VAL_35]], align 8
-// CHECK:         %[[VAL_36:.*]] = getelementptr inbounds [2 x i64], ptr %[[VAL_2]], i32 0, i32 1
-// CHECK:         store i64 ptrtoint (ptr getelementptr (ptr, ptr null, i32 1) to i64), ptr %[[VAL_36]], align 4
-// CHECK:         %[[VAL_37:.*]] = getelementptr inbounds [2 x ptr], ptr %[[VAL_0]], i32 0, i32 0
-// CHECK:         %[[VAL_38:.*]] = getelementptr inbounds [2 x ptr], ptr %[[VAL_1]], i32 0, i32 0
-// CHECK:         %[[VAL_39:.*]] = getelementptr inbounds [2 x i64], ptr %[[VAL_2]], i32 0, i32 0
-// CHECK:         call void @__tgt_target_data_end_mapper(ptr @3, i64 -1, i32 2, ptr %[[VAL_37]], ptr %[[VAL_38]], ptr %[[VAL_39]], ptr @.offload_maptypes.1, ptr @.offload_mapnames.2, ptr null)
-// CHECK:         br label %[[VAL_30]]
-// CHECK:       omp_if.end5:                                      ; preds = %[[VAL_14]], %[[VAL_29]]
+// CHECK:         store ptr %[[ARG_0]], ptr %[[VAL_15]], align 8
+// CHECK:         %[[VAL_16:.*]] = getelementptr inbounds [2 x ptr], ptr %[[VAL_2]], i32 0, i32 1
+// CHECK:         store ptr %[[ARG_1]], ptr %[[VAL_16]], align 8
+// CHECK:         %[[VAL_18:.*]] = getelementptr inbounds [2 x ptr], ptr %[[VAL_3]], i32 0, i32 1
+// CHECK:         store ptr %[[ARG_1]], ptr %[[VAL_18]], align 8
+// CHECK:         %[[VAL_19:.*]] = getelementptr inbounds [2 x ptr], ptr %[[VAL_2]], i32 0, i32 0
+// CHECK:         %[[VAL_20:.*]] = getelementptr inbounds [2 x ptr], ptr %[[VAL_3]], i32 0, i32 0
+// CHECK:         call void @__tgt_target_data_begin_mapper(ptr @3, i64 -1, i32 2, ptr %[[VAL_19]], ptr %[[VAL_20]], ptr @.offload_sizes, ptr @.offload_maptypes, ptr @.offload_mapnames, ptr null)
+// CHECK:         br label %[[VAL_12]]
+// CHECK:       omp_if.end:                                       ; preds = %[[VAL_9]], %[[VAL_11]]
+// CHECK:         %[[VAL_21:.*]] = load i32, ptr %[[VAL_5]], align 4
+// CHECK:         %[[VAL_22:.*]] = icmp sgt i32 %[[VAL_21]], 10
+// CHECK:         %[[VAL_23:.*]] = load i32, ptr %[[VAL_4]], align 4
+// CHECK:         br i1 %[[VAL_22]], label %[[VAL_24:.*]], label %[[VAL_25:.*]]
+// CHECK:       omp_if.then1:                                     ; preds = %[[VAL_12]]
+// CHECK:         %[[VAL_26:.*]] = getelementptr inbounds [2 x ptr], ptr %[[VAL_0]], i32 0, i32 0
+// CHECK:         store ptr %[[ARG_0]], ptr %[[VAL_26]], align 8
+// CHECK:         %[[VAL_27:.*]] = getelementptr inbounds [2 x ptr], ptr %[[VAL_1]], i32 0, i32 0
+// CHECK:         store ptr %[[ARG_0]], ptr %[[VAL_27]], align 8
+// CHECK:         %[[VAL_28:.*]] = getelementptr inbounds [2 x ptr], ptr %[[VAL_0]], i32 0, i32 1
+// CHECK:         store ptr %[[ARG_1]], ptr %[[VAL_28]], align 8
+// CHECK:         %[[VAL_29:.*]] = getelementptr inbounds [2 x ptr], ptr %[[VAL_1]], i32 0, i32 1
+// CHECK:         store ptr %[[ARG_1]], ptr %[[VAL_29]], align 8
+// CHECK:         %[[VAL_30:.*]] = getelementptr inbounds [2 x ptr], ptr %[[VAL_0]], i32 0, i32 0
+// CHECK:         %[[VAL_31:.*]] = getelementptr inbounds [2 x ptr], ptr %[[VAL_1]], i32 0, i32 0
+// CHECK:         call void @__tgt_target_data_end_mapper(ptr @3, i64 -1, i32 2, ptr %[[VAL_30]], ptr %[[VAL_31]], ptr @.offload_sizes.3, ptr @.offload_maptypes.2, ptr @.offload_mapnames.1, ptr null)
+// CHECK:         br label %[[VAL_25]]
+// CHECK:       omp_if.end4:                                      ; preds = %[[VAL_12]], %[[VAL_24]]
 // CHECK:         ret void
 
 // -----