[mlir][openacc] Add OpenACC translation to LLVM IR (enter_data op create/copyin)

[clementval]

Summary

This patch begins to translate acc.enter_data operation to call to tgt runtime call.
It currently only translate create/copyin operands of memref type. This acts as a basis to add support
for FIR types in the Flang/OpenACC support. It follows more or less a similar path than clang
with omp target enter data map directives.
This patch is taking a different approach than D100678 and perform a translation to LLVM IR
and make use of the OpenMPIRBuilder instead of doing a conversion to the LLVMIR dialect.

OpenACC support in Flang will rely on the current OpenMP runtime where 1:1 lowering can be
applied. Some extension will be added where features are not available yet.

Big part of this code will be shared for other standalone data operations in the OpenACC
dialect such as acc.exit_data and acc.update.

It is likely that parts of the lowering can also be shared later with the ops for
standalone data directives in the OpenMP dialect when they are introduced.

This is an initial translation and it probably needs more work.

[clementval]

Adapt call to builder after change in D101503

[clementval]

Add copyin operand

[clementval]

Fix clang-tidy warnings

[kiranchandramohan]

A few questions.

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

114

Is the current assumption that the operands will be of the memref type and later extend it to other types like llvm.pointer?
Would it be simpler to do llvm.pointer first?

114

isa<>?

117

Nit: remove commented code?

173

+1

194

Should there be a check for presence of createOperands here and for copyinoperands below?

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

2

Any particular reason we are starting from standard type? Can it just be a llvm.pointer?

[clementval]

Address some review comments

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

114

Yeah I just wanted to start with a type that is close to what the Fortran array will look like. The memref type seems to be quite close to a Fortran array with its descriptor. The idea is of course to handle more types than just memref types.

A simple llvm.pointer is missing the size information needed by the runtime. It likely to work only for pointer to scalar where we can infer the size.

173

I'll prepare a OMPIRBuilder patch for that.

194

We can check if there is any operands but the processOperands function will just return in case there is no operand.

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

2

Just to convert memref to LLVM IR dialect.

[kiranchandramohan]

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

114

I was thinking about the Flang flow and what would be available there. I guess there will not be any memrefs and the arrays will be converted to some llvm.ptr. How will we recover the array information there? Do we need to have an FIRToOpenACC/OpenACCToLLVMDialect conversion pass which will add additional information (as attributes) to the llvm.ptr so that we have enough information about the array?

134

Can you add some comments for the code above? Or add a code snippet to what the generated code would look like in LLVM IR.

[ftynse]

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

42

Please add comments for all top-level entities.

51

Is there a way to create a location from an arbitrary string? If so, we could print mlir::Location to a string stream and use that instead of the default location.

52

Nit: spurious semicolon

112

Nit: expand auto (we generally do this unless the type is long/irrepresentable or obvious from context)

115

This shouldn't just assume every LLVM struct used to be a memref, nothing guarantees that. I also expect the translation to work if the IR haven't ever had memrefs in it, i.e. translation shouldn't be aware of this type. If you really want to work with memrefs, this should start from openacc operations working on memrefs and lower them to openacc operations working on LLVM dialect types.

Also, this variable isn't used.

[ftynse]

I think the layering here is incorrect. It assumes translation has knowledge of higher-level types (memref), which defies the purpose of having LLVM dialect. Translation should only know about LLVM-level dialects.

[clementval]

Address some review comments

[clementval]

In D101504#2737318, @ftynse wrote:

I think the layering here is incorrect. It assumes translation has knowledge of higher-level types (memref), which defies the purpose of having LLVM dialect. Translation should only know about LLVM-level dialects.

Thanks for the review.

I was also thinking something is odd here. I think a better approach would be to have a conversion that handle higher-level types with their knowledge and convert that to LLVM dialect in a form that is understandable by the translation. Would it makes sense to you?

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

51

Yes there is. Just updated the patch to reflect that.

115

That was my understanding. I guess the final for should be a mix between this patch and my first attempt (D100678) where I did a conversion from OpenACC to LLVM dialect types.

Would it make sense to have a conversion that prepare the types from memref or from FIR types for examples and "format" them to LLVM dialect types (ptr + size) that can then be translated here to LLVM IR?

[ftynse]

In D101504#2737720, @clementval wrote:

In D101504#2737318, @ftynse wrote:

I think the layering here is incorrect. It assumes translation has knowledge of higher-level types (memref), which defies the purpose of having LLVM dialect. Translation should only know about LLVM-level dialects.

Thanks for the review.

I was also thinking something is odd here. I think a better approach would be to have a conversion that handle higher-level types with their knowledge and convert that to LLVM dialect in a form that is understandable by the translation. Would it makes sense to you?

This makes sense to me. OpenMP dialect has a similar approach where it can be expressed on higher-level types and a conversion pass converts those types to LLVM dialect types without otherwise changing the operations. Mind the potential difference in memref representation: if there are memref dialect ops inside OpenACC dialect ops, those would expect memref to be converted to the descriptor structure. If OpenACC converts memref to something different, it would have to recreated the expected descriptor structure at region entry so that other operations could still use it. We do this at function calls for the "bare pointer" convention.

You may also consider having a custom type in the OpenACC dialect that captures the necessary information (pointer + size, from what I understand) and auxiliary operations that "cast" from supported types to this custom type. Such a cast from memref to pointer+size could be then converted to the LLVM dialect by emitting IR that computes the size given the memref descriptor.

[ftynse]

Re-requesting changes to that this disappears from my phabricator "todo" list until there are further comments. It's a shame that phabricator doesn't just let me snooze a review until other people act on it.

[clementval]

Update code to translate from converted types (D102170)

[ftynse]

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

214

Ultra-nit: capitalize the first letter please.

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

2

I'd rather start from the LLVM dialect, running two tools makes this more of an integration test than a unit test: we won't know which of the tools is broken just by looking at it. It's okay to also have integration tests, but they shouldn't replace unit tests.

Also, I see quite some LLVM IR instructions being created but not tested. Are those moving to the OpenMPIRBuilder?

[clementval]

Address review comment.

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

2

Makes sense. I have updated the test to run just the translation from LLVM dialect and added the generated instructions as well.

[clementval]

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

114

As you said, Flang is likely not using memref. The idea is to have a similar conversion where we extract information from the array descriptor and place it into the "Data descriptor". This descriptor is then translated.

Simple llvm.ptr can also be translated but this unlikely to come from a Fortran array at this point. I'll also add llvm.array in follow up patches.

[clementval]

Address some more review comments

[clementval]

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

173

I'll do that in a follow up patch since the version in clang cannot be directly done within the OpenMPIRbuilder as is.

mlir/include/mlir/Target/LLVMIR/Dialect/All.h

 #ifndef MLIR_TARGET_LLVMIR_DIALECT_ALL_H
 #define MLIR_TARGET_LLVMIR_DIALECT_ALL_H
 
 #include "mlir/Target/LLVMIR/Dialect/AMX/AMXToLLVMIRTranslation.h"
 #include "mlir/Target/LLVMIR/Dialect/ArmNeon/ArmNeonToLLVMIRTranslation.h"
 #include "mlir/Target/LLVMIR/Dialect/ArmSVE/ArmSVEToLLVMIRTranslation.h"
 #include "mlir/Target/LLVMIR/Dialect/LLVMIR/LLVMToLLVMIRTranslation.h"
 #include "mlir/Target/LLVMIR/Dialect/NVVM/NVVMToLLVMIRTranslation.h"
+#include "mlir/Target/LLVMIR/Dialect/OpenACC/OpenACCToLLVMIRTranslation.h"
 #include "mlir/Target/LLVMIR/Dialect/OpenMP/OpenMPToLLVMIRTranslation.h"
 #include "mlir/Target/LLVMIR/Dialect/ROCDL/ROCDLToLLVMIRTranslation.h"
 #include "mlir/Target/LLVMIR/Dialect/X86Vector/X86VectorToLLVMIRTranslation.h"
 
 namespace mlir {
 class DialectRegistry;
 
 /// Registers all dialects that can be translated to LLVM IR and the
 /// corresponding translation interfaces.
 static inline void registerAllToLLVMIRTranslations(DialectRegistry &registry) {
   registerArmNeonDialectTranslation(registry);
   registerAMXDialectTranslation(registry);
   registerArmSVEDialectTranslation(registry);
   registerLLVMDialectTranslation(registry);
   registerNVVMDialectTranslation(registry);
+  registerOpenACCDialectTranslation(registry);
   registerOpenMPDialectTranslation(registry);
   registerROCDLDialectTranslation(registry);
   registerX86VectorDialectTranslation(registry);
 }
 } // namespace mlir
 
 #endif // MLIR_TARGET_LLVMIR_DIALECT_ALL_H

mlir/include/mlir/Target/LLVMIR/Dialect/OpenACC/OpenACCToLLVMIRTranslation.h

+//===- OpenACCToLLVMIRTranslation.h - OpenACC Dialect to LLVM IR -- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// This provides registration calls for OpenACC dialect to LLVM IR translation.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef MLIR_TARGET_LLVMIR_DIALECT_OPENACC_OPENACCTOLLVMIRTRANSLATION_H
+#define MLIR_TARGET_LLVMIR_DIALECT_OPENACC_OPENACCTOLLVMIRTRANSLATION_H
+
+namespace mlir {
+
+class DialectRegistry;
+class MLIRContext;
+
+/// Register the OpenACC dialect and the translation to the LLVM IR in
+/// the given registry;
+void registerOpenACCDialectTranslation(DialectRegistry &registry);
+
+/// Register the OpenACC dialect and the translation in the registry
+/// associated with the given context.
+void registerOpenACCDialectTranslation(MLIRContext &context);
+
+} // namespace mlir
+
+#endif // MLIR_TARGET_LLVMIR_DIALECT_OPENACC_OPENACCTOLLVMIRTRANSLATION_H

mlir/lib/Target/LLVMIR/CMakeLists.txt

add_mlir_translation_library(MLIRTargetLLVMIRExport
 
   LINK_COMPONENTS
   Core
   FrontendOpenMP
   TransformUtils
 
   LINK_LIBS PUBLIC
   MLIRLLVMIR
+  MLIROpenACC
   MLIROpenMP
   MLIRLLVMIRTransforms
   MLIRTranslation
   )
 
 add_mlir_translation_library(MLIRToLLVMIRTranslationRegistration
   ConvertToLLVMIR.cpp
 
   LINK_LIBS PUBLIC
   MLIRArmNeonToLLVMIRTranslation
   MLIRArmSVEToLLVMIRTranslation
   MLIRAMXToLLVMIRTranslation
   MLIRX86VectorToLLVMIRTranslation
   MLIRLLVMToLLVMIRTranslation
   MLIRNVVMToLLVMIRTranslation
+  MLIROpenACCToLLVMIRTranslation
   MLIROpenMPToLLVMIRTranslation
   MLIRROCDLToLLVMIRTranslation
   )
 
 add_mlir_translation_library(MLIRTargetLLVMIRImport
   ConvertFromLLVMIR.cpp
 
   ADDITIONAL_HEADER_DIRS

mlir/lib/Target/LLVMIR/Dialect/CMakeLists.txt

 add_subdirectory(ArmNeon)
 add_subdirectory(ArmSVE)
 add_subdirectory(AMX)
 add_subdirectory(LLVMIR)
 add_subdirectory(NVVM)
+add_subdirectory(OpenACC)
 add_subdirectory(OpenMP)
 add_subdirectory(ROCDL)
 add_subdirectory(X86Vector)

mlir/lib/Target/LLVMIR/Dialect/OpenACC/CMakeLists.txt

+add_mlir_translation_library(MLIROpenACCToLLVMIRTranslation
+  OpenACCToLLVMIRTranslation.cpp
+
+  LINK_COMPONENTS
+  Core
+
+  LINK_LIBS PUBLIC
+  MLIRIR
+  MLIRLLVMIR
+  MLIROpenACC
+  MLIROpenACCToLLVM
+  MLIRSupport
+  MLIRTargetLLVMIRExport
+  )

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

+//===- OpenACCToLLVMIRTranslation.cpp -------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// This file implements a translation between the MLIR OpenACC dialect and LLVM
+// IR.
+//
+//===----------------------------------------------------------------------===//
+
+#include "mlir/Target/LLVMIR/Dialect/OpenACC/OpenACCToLLVMIRTranslation.h"
+#include "mlir/Conversion/OpenACCToLLVM/ConvertOpenACCToLLVM.h"
+#include "mlir/Dialect/LLVMIR/LLVMDialect.h"
+#include "mlir/Dialect/OpenACC/OpenACC.h"
+#include "mlir/IR/BuiltinOps.h"
+#include "mlir/IR/Operation.h"
+#include "mlir/Support/LLVM.h"
+#include "mlir/Target/LLVMIR/ModuleTranslation.h"
+
+#include "llvm/ADT/TypeSwitch.h"
+#include "llvm/Frontend/OpenMP/OMPConstants.h"
+#include "llvm/Support/FormatVariadic.h"
+
+using namespace mlir;
+
+using OpenACCIRBuilder = llvm::OpenMPIRBuilder;
+
+//===----------------------------------------------------------------------===//
+// Utility functions
+//===----------------------------------------------------------------------===//
+
+/// 0 = alloc/create
+static constexpr uint64_t createFlag = 0;
+/// 1 = to/copyin
+static constexpr uint64_t copyinFlag = 1;
+/// 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>();
+  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))
+    return builder.getOrCreateRuntimeFunctionPtr(
+        llvm::omp::OMPRTL___tgt_target_data_begin_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,
+                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);
+  auto *arrI8PtrTy = llvm::ArrayType::get(i8PtrTy, totalNbOperand);
+  auto *i64Ty = llvm::Type::getInt64Ty(ctx);
+  auto *arrI64Ty = llvm::ArrayType::get(i64Ty, totalNbOperand);
+
+  for (Value data : operands) {
+    llvm::Value *dataValue = moduleTranslation.lookupValue(data);
+
+    llvm::Value *dataPtrBase;
+    llvm::Value *dataPtr;
+    llvm::Value *dataSize;
+
+    // Handle operands that were converted to DataDescriptor.
+    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 = 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.
+    llvm::Value *ptrBaseGEP = builder.CreateInBoundsGEP(
+        arrI8PtrTy, argsBase, {builder.getInt32(0), builder.getInt32(index)});
+    llvm::Value *ptrBaseCast = builder.CreateBitCast(
+        ptrBaseGEP, dataPtrBase->getType()->getPointerTo());
+    builder.CreateStore(dataPtrBase, ptrBaseCast);
+
+    // Store pointer extracted from operand into the i-th position of args.
+    llvm::Value *ptrGEP = builder.CreateInBoundsGEP(
+        arrI8PtrTy, args, {builder.getInt32(0), builder.getInt32(index)});
+    llvm::Value *ptrCast =
+        builder.CreateBitCast(ptrGEP, dataPtr->getType()->getPointerTo());
+    builder.CreateStore(dataPtr, ptrCast);
+
+    // Store size extracted from operand into the i-th position of argSizes.
+    llvm::Value *sizeGEP = builder.CreateInBoundsGEP(
+        arrI64Ty, argSizes, {builder.getInt32(0), builder.getInt32(index)});
+    builder.CreateStore(dataSize, sizeGEP);
+
+    flags.push_back(operandFlag);
+    llvm::Constant *mapName =
+        createMappingInformation(data.getLoc(), *accBuilder);
+    names.push_back(mapName);
+    ++index;
+  }
+  return success();
+}
+
+//===----------------------------------------------------------------------===//
+// Conversion functions
+//===----------------------------------------------------------------------===//
+
+/// Converts an OpenACC enter_data operartion into LLVM IR.
+static LogicalResult
+convertEnterDataOp(Operation &op, llvm::IRBuilderBase &builder,
+                   LLVM::ModuleTranslation &moduleTranslation) {
+  auto enterDataOp = cast<acc::EnterDataOp>(op);
+  auto enclosingFuncOp = op.getParentOfType<LLVM::LLVMFuncOp>();
+  llvm::Function *enclosingFunction =
+      moduleTranslation.lookupFunction(enclosingFuncOp.getName());
+
+  OpenACCIRBuilder *accBuilder = moduleTranslation.getOpenMPBuilder();
+
+  auto *srcLocInfo = createSourceLocationInfo(enterDataOp, *accBuilder);
+  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();
+
+  // 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)))
+    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);
+
+  llvm::GlobalVariable *mapnames =
+      accBuilder->createOffloadMapnames(names, ".offload_mapnames");
+  llvm::Value *mapnamesArg = builder.CreateConstInBoundsGEP2_32(
+      llvm::ArrayType::get(llvm::Type::getInt8PtrTy(ctx), totalNbOperand),
+      mapnames, /*Idx0=*/0, /*Idx1=*/0);
+
+  llvm::Value *argsBaseGEP = builder.CreateInBoundsGEP(
+      arrI8PtrTy, argsBase, {builder.getInt32(0), builder.getInt32(0)});
+  llvm::Value *argsGEP = builder.CreateInBoundsGEP(
+      arrI8PtrTy, args, {builder.getInt32(0), builder.getInt32(0)});
+  llvm::Value *argSizesGEP = builder.CreateInBoundsGEP(
+      arrI64Ty, argSizes, {builder.getInt32(0), builder.getInt32(0)});
+  llvm::Value *nullPtr = llvm::Constant::getNullValue(
+      llvm::Type::getInt8PtrTy(ctx)->getPointerTo());
+
+  builder.CreateCall(mapperFunc,
+                     {srcLocInfo, builder.getInt64(defaultDevice),
+                      builder.getInt32(totalNbOperand), argsBaseGEP, argsGEP,
+                      argSizesGEP, maptypesArg, mapnamesArg, nullPtr});
+
+  return success();
+}
+
+namespace {
+
+/// Implementation of the dialect interface that converts operations belonging
+/// to the OpenACC dialect to LLVM IR.
+class OpenACCDialectLLVMIRTranslationInterface
+    : public LLVMTranslationDialectInterface {
+public:
+  using LLVMTranslationDialectInterface::LLVMTranslationDialectInterface;
+
+  /// Translates the given operation to LLVM IR using the provided IR builder
+  /// and saving the state in `moduleTranslation`.
+  LogicalResult
+  convertOperation(Operation *op, llvm::IRBuilderBase &builder,
+                   LLVM::ModuleTranslation &moduleTranslation) const final;
+};
+
+} // end namespace
+
+/// 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);
+      })
+      .Default([&](Operation *op) {
+        return op->emitError("unsupported OpenACC operation: ")
+               << op->getName();
+      });
+}
+
+void mlir::registerOpenACCDialectTranslation(DialectRegistry &registry) {
+  registry.insert<acc::OpenACCDialect>();
+  registry.addDialectInterface<acc::OpenACCDialect,
+                               OpenACCDialectLLVMIRTranslationInterface>();
+}
+
+void mlir::registerOpenACCDialectTranslation(MLIRContext &context) {
+  DialectRegistry registry;
+  registerOpenACCDialectTranslation(registry);
+  context.appendDialectRegistry(registry);
+}

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

+// RUN: mlir-translate -mlir-to-llvmir %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>)>
+  %6 = llvm.mlir.constant(10 : index) : i64
+  %7 = llvm.mlir.constant(1 : index) : i64
+  %8 = llvm.mlir.null : !llvm.ptr<f32>
+  %9 = llvm.getelementptr %8[%6] : (!llvm.ptr<f32>, i64) -> !llvm.ptr<f32>
+  %10 = llvm.ptrtoint %9 : !llvm.ptr<f32> to i64
+  %11 = llvm.extractvalue %5[1] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<1 x i64>, array<1 x i64>)>
+  %12 = llvm.mlir.undef : !llvm.struct<"openacc_data", (struct<(ptr<f32>, ptr<f32>, i64, array<1 x i64>, array<1 x i64>)>, ptr<f32>, i64)>
+  %13 = llvm.insertvalue %5, %12[0] : !llvm.struct<"openacc_data", (struct<(ptr<f32>, ptr<f32>, i64, array<1 x i64>, array<1 x i64>)>, ptr<f32>, i64)>
+  %14 = llvm.insertvalue %11, %13[1] : !llvm.struct<"openacc_data", (struct<(ptr<f32>, ptr<f32>, i64, array<1 x i64>, array<1 x i64>)>, ptr<f32>, i64)>
+  %15 = llvm.insertvalue %10, %14[2] : !llvm.struct<"openacc_data", (struct<(ptr<f32>, ptr<f32>, i64, array<1 x i64>, array<1 x i64>)>, ptr<f32>, i64)>
+  acc.enter_data copyin(%arg5 : !llvm.ptr<f32>) create(%15 : !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";{{.*}};testenterdataop;{{[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 0, i64 1]
+// 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 @testenterdataop(float* %{{.*}}, float* %{{.*}}, i64 %{{.*}}, i64 %{{.*}}, 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_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