[mlir][flang][openacc] Remove obsolete operand legalization passes

[clementval]

Summary

The information needed for translation is now encoded in the dialect
operations and does not require a dedicated pass to be extracted.
Remove the obsolete passes that were performing operand legalization.

[jeanPerier]

LGTM

flang/include/flang/Optimizer/Transforms/Passes.h

 std::unique_ptr<mlir::Pass>
 createMemoryAllocationPass(bool dynOnHeap, std::size_t maxStackSize);
 std::unique_ptr<mlir::Pass> createAnnotateConstantOperandsPass();
 std::unique_ptr<mlir::Pass> createSimplifyRegionLitePass();
 std::unique_ptr<mlir::Pass> createAlgebraicSimplificationPass();
 std::unique_ptr<mlir::Pass>
 createAlgebraicSimplificationPass(const mlir::GreedyRewriteConfig &config);
 std::unique_ptr<mlir::Pass> createPolymorphicOpConversionPass();
-std::unique_ptr<mlir::Pass> createOpenACCDataOperandConversionPass();
 
 // declarative passes
 #define GEN_PASS_REGISTRATION
 #include "flang/Optimizer/Transforms/Passes.h.inc"
 
 } // namespace fir
 
 #endif // FORTRAN_OPTIMIZER_TRANSFORMS_PASSES_H

flang/include/flang/Optimizer/Transforms/Passes.td

let description = [{
     introducing an intermediate FIR level that simplifies code geneation. 
   }];
   let constructor = "::fir::createPolymorphicOpConversionPass()";
   let dependentDialects = [
     "fir::FIROpsDialect", "mlir::func::FuncDialect"
   ];
 }
 
-def OpenACCDataOperandConversion : Pass<"fir-openacc-data-operand-conversion", "::mlir::func::FuncOp"> {
-  let summary = "Convert the FIR operands in OpenACC ops to LLVM dialect";
-  let dependentDialects = ["mlir::LLVM::LLVMDialect"];
-  let options = [
-    Option<"useOpaquePointers", "use-opaque-pointers", "bool",
-           /*default=*/"true", "Generate LLVM IR using opaque pointers "
-           "instead of typed pointers">,
-  ];
-}
-
 def LoopVersioning : Pass<"loop-versioning", "mlir::func::FuncOp"> {
   let summary = "Loop Versioning";
   let description = [{
     Loop Versioning pass adds a check and two variants of a loop when the input
     array is an assumed shape array, to optimize for the (often common) case where
     an array has element sized stride. The element sizes stride allows some
     loops to be vectorized as well as other loop optimizations.
   }];
   let constructor = "::fir::createLoopVersioningPass()";
   let dependentDialects = [ "fir::FIROpsDialect" ];
 }
 
 #endif // FLANG_OPTIMIZER_TRANSFORMS_PASSES

flang/lib/Optimizer/CodeGen/CMakeLists.txt

add_flang_library(FIRCodeGen
   FIRDialect
   FIRDialectSupport
   FIRSupport
   MLIRComplexToLLVM
   MLIRComplexToStandard
   MLIRMathToFuncs
   MLIRMathToLLVM
   MLIRMathToLibm
-  MLIROpenACCToLLVM
   MLIROpenMPToLLVM
   MLIRBuiltinToLLVMIRTranslation
   MLIRLLVMToLLVMIRTranslation
   MLIRTargetLLVMIRExport
 
   LINK_COMPONENTS
   AsmParser
   AsmPrinter
   Remarks
   TargetParser
 )

flang/lib/Optimizer/CodeGen/CodeGen.cpp

 #include "mlir/Conversion/ComplexToLLVM/ComplexToLLVM.h"
 #include "mlir/Conversion/ComplexToStandard/ComplexToStandard.h"
 #include "mlir/Conversion/ControlFlowToLLVM/ControlFlowToLLVM.h"
 #include "mlir/Conversion/FuncToLLVM/ConvertFuncToLLVM.h"
 #include "mlir/Conversion/LLVMCommon/Pattern.h"
 #include "mlir/Conversion/MathToFuncs/MathToFuncs.h"
 #include "mlir/Conversion/MathToLLVM/MathToLLVM.h"
 #include "mlir/Conversion/MathToLibm/MathToLibm.h"
-#include "mlir/Conversion/OpenACCToLLVM/ConvertOpenACCToLLVM.h"
 #include "mlir/Conversion/OpenMPToLLVM/ConvertOpenMPToLLVM.h"
 #include "mlir/Conversion/ReconcileUnrealizedCasts/ReconcileUnrealizedCasts.h"
 #include "mlir/Dialect/LLVMIR/LLVMDialect.h"
 #include "mlir/Dialect/OpenACC/OpenACC.h"
 #include "mlir/Dialect/OpenMP/OpenMPDialect.h"
 #include "mlir/IR/BuiltinTypes.h"
 #include "mlir/IR/Matchers.h"
 #include "mlir/Pass/Pass.h"
pattern.insert<
         ShapeOpConversion, ShapeShiftOpConversion, ShiftOpConversion,
         SliceOpConversion, StoreOpConversion, StringLitOpConversion,
         SubcOpConversion, TypeDescOpConversion, UnboxCharOpConversion,
         UnboxProcOpConversion, UndefOpConversion, UnreachableOpConversion,
         UnrealizedConversionCastOpConversion, XArrayCoorOpConversion,
         XEmboxOpConversion, XReboxOpConversion, ZeroOpConversion>(typeConverter,
                                                                   options);
     mlir::populateFuncToLLVMConversionPatterns(typeConverter, pattern);
-    mlir::populateOpenACCToLLVMConversionPatterns(typeConverter, pattern);
     mlir::populateOpenMPToLLVMConversionPatterns(typeConverter, pattern);
     mlir::arith::populateArithToLLVMConversionPatterns(typeConverter, pattern);
     mlir::cf::populateControlFlowToLLVMConversionPatterns(typeConverter,
                                                           pattern);
     // Math operations that have not been converted yet must be converted
     // to Libm.
     mlir::populateMathToLibmConversionPatterns(pattern);
     mlir::populateComplexToLLVMConversionPatterns(typeConverter, pattern);

flang/lib/Optimizer/Transforms/CMakeLists.txt

add_flang_library(FIRTransforms
   MemoryAllocation.cpp
   StackArrays.cpp
   MemRefDataFlowOpt.cpp
   SimplifyRegionLite.cpp
   AlgebraicSimplification.cpp
   SimplifyIntrinsics.cpp
   AddDebugFoundation.cpp
   PolymorphicOpConversion.cpp
-  OpenACC/OpenACCDataOperandConversion.cpp
   LoopVersioning.cpp
 
   DEPENDS
   FIRDialect
   FIROptTransformsPassIncGen
 
   LINK_LIBS
   FIRBuilder

flang/lib/Optimizer/Transforms/OpenACC/OpenACCDataOperandConversion.cpp

-//===- OpenACCDataOperandConversion.cpp - OpenACC data operand conversion -===//
-//
-// 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
-//
-//===----------------------------------------------------------------------===//
-
-#include "flang/Optimizer/Dialect/FIRDialect.h"
-#include "flang/Optimizer/Transforms/Passes.h"
-#include "mlir/Conversion/LLVMCommon/Pattern.h"
-#include "mlir/Conversion/OpenACCToLLVM/ConvertOpenACCToLLVM.h"
-#include "mlir/Dialect/Func/IR/FuncOps.h"
-#include "mlir/Dialect/LLVMIR/LLVMDialect.h"
-#include "mlir/Dialect/OpenACC/OpenACC.h"
-#include "mlir/IR/Builders.h"
-#include "mlir/IR/BuiltinOps.h"
-#include "mlir/Pass/Pass.h"
-
-namespace fir {
-#define GEN_PASS_DEF_OPENACCDATAOPERANDCONVERSION
-#include "flang/Optimizer/Transforms/Passes.h.inc"
-} // namespace fir
-
-#define DEBUG_TYPE "flang-openacc-conversion"
-#include "flang/Optimizer/CodeGen/TypeConverter.h"
-
-using namespace fir;
-using namespace mlir;
-
-//===----------------------------------------------------------------------===//
-// Conversion patterns
-//===----------------------------------------------------------------------===//
-
-namespace {
-
-template <typename Op>
-class LegalizeDataOpForLLVMTranslation : public ConvertOpToLLVMPattern<Op> {
-  using ConvertOpToLLVMPattern<Op>::ConvertOpToLLVMPattern;
-
-  LogicalResult
-  matchAndRewrite(Op op, typename Op::Adaptor adaptor,
-                  ConversionPatternRewriter &builder) const override {
-    Location loc = op.getLoc();
-    fir::LLVMTypeConverter &converter =
-        *static_cast<fir::LLVMTypeConverter *>(this->getTypeConverter());
-
-    unsigned numDataOperands = op.getNumDataOperands();
-
-    // Keep the non data operands without modification.
-    auto nonDataOperands = adaptor.getOperands().take_front(
-        adaptor.getOperands().size() - numDataOperands);
-    SmallVector<Value> convertedOperands;
-    convertedOperands.append(nonDataOperands.begin(), nonDataOperands.end());
-
-    // Go over the data operand and legalize them for translation.
-    for (unsigned idx = 0; idx < numDataOperands; ++idx) {
-      Value originalDataOperand = op.getDataOperand(idx);
-      if (auto refTy =
-              originalDataOperand.getType().dyn_cast<fir::ReferenceType>()) {
-        if (refTy.getEleTy().isa<fir::BaseBoxType>())
-          return builder.notifyMatchFailure(op, "BaseBoxType not supported");
-        mlir::Type convertedType =
-            converter.convertType(refTy).cast<mlir::LLVM::LLVMPointerType>();
-        mlir::Value castedOperand =
-            builder
-                .create<mlir::UnrealizedConversionCastOp>(loc, convertedType,
-                                                          originalDataOperand)
-                .getResult(0);
-        convertedOperands.push_back(castedOperand);
-      } else {
-        // Type not supported.
-        return builder.notifyMatchFailure(op, "expecting a reference type");
-      }
-    }
-
-    if constexpr (std::is_same_v<Op, acc::ParallelOp> ||
-                  std::is_same_v<Op, acc::DataOp>) {
-      auto newOp =
-          builder.create<Op>(op.getLoc(), TypeRange(), convertedOperands,
-                             op.getOperation()->getAttrs());
-      builder.inlineRegionBefore(op.getRegion(), newOp.getRegion(),
-                                 newOp.getRegion().end());
-      if (failed(builder.convertRegionTypes(&newOp.getOperation()->getRegion(0),
-                                            *this->getTypeConverter())))
-        return failure();
-      builder.eraseOp(op);
-    } else {
-      builder.replaceOpWithNewOp<Op>(op, TypeRange(), convertedOperands,
-                                     op.getOperation()->getAttrs());
-    }
-
-    return success();
-  }
-};
-} // namespace
-
-namespace {
-struct OpenACCDataOperandConversion
-    : public fir::impl::OpenACCDataOperandConversionBase<
-          OpenACCDataOperandConversion> {
-  using Base::Base;
-
-  void runOnOperation() override;
-};
-} // namespace
-
-void OpenACCDataOperandConversion::runOnOperation() {
-  auto op = getOperation();
-  auto *context = op.getContext();
-
-  // Convert to OpenACC operations with LLVM IR dialect
-  RewritePatternSet patterns(context);
-  LowerToLLVMOptions options(context);
-  options.useOpaquePointers = useOpaquePointers;
-  fir::LLVMTypeConverter converter(
-      op.getOperation()->getParentOfType<mlir::ModuleOp>(), true);
-  patterns.add<LegalizeDataOpForLLVMTranslation<acc::ParallelOp>>(converter);
-
-  ConversionTarget target(*context);
-  target.addLegalDialect<fir::FIROpsDialect>();
-  target.addLegalDialect<LLVM::LLVMDialect>();
-  target.addLegalOp<mlir::UnrealizedConversionCastOp>();
-
-  auto allDataOperandsAreConverted = [](ValueRange operands) {
-    for (Value operand : operands) {
-      if (!operand.getType().isa<LLVM::LLVMPointerType>())
-        return false;
-    }
-    return true;
-  };
-
-  target.addDynamicallyLegalOp<acc::ParallelOp>(
-      [allDataOperandsAreConverted](acc::ParallelOp op) {
-        return allDataOperandsAreConverted(op.getReductionOperands()) &&
-               allDataOperandsAreConverted(op.getGangPrivateOperands()) &&
-               allDataOperandsAreConverted(op.getGangFirstPrivateOperands());
-      });
-
-  if (failed(applyPartialConversion(op, target, std::move(patterns))))
-    signalPassFailure();
-}

mlir/include/mlir/Conversion/OpenACCToLLVM/ConvertOpenACCToLLVM.h

-//===- ConvertOpenACCToLLVM.h - OpenACC conversion pass entrypoint --------===//
-//
-// 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
-//
-//===----------------------------------------------------------------------===//
-#ifndef MLIR_CONVERSION_OPENACCTOLLVM_CONVERTOPENACCTOLLVM_H
-#define MLIR_CONVERSION_OPENACCTOLLVM_CONVERTOPENACCTOLLVM_H
-
-#include "mlir/Conversion/LLVMCommon/StructBuilder.h"
-#include <memory>
-
-namespace mlir {
-class LLVMTypeConverter;
-class Pass;
-class RewritePatternSet;
-
-#define GEN_PASS_DECL_CONVERTOPENACCTOLLVMPASS
-#include "mlir/Conversion/Passes.h.inc"
-
-static constexpr unsigned kPtrBasePosInDataDescriptor = 0;
-static constexpr unsigned kPtrPosInDataDescriptor = 1;
-static constexpr unsigned kSizePosInDataDescriptor = 2;
-
-/// Helper class to produce LLVM dialect operations inserting
-/// elements to a Data descriptor. Wraps a Value pointing to the descriptor.
-/// The Value may be null, in which case none of the operations are valid.
-///
-/// The data descriptor holds information needed to perform data operations
-/// and movements with the runtime.
-/// `BasePointer`: base of the pointer being mapped.
-/// `Pointer`: actual pointer of the data being mapped.
-/// `Size`: size of the data being mapped.
-///
-/// Example:
-///
-/// ```c
-/// struct S {
-///   int x;
-///   int y;
-/// };
-/// ```
-///
-/// Mapping `s.y` will result if the following information in the data
-/// descriptor:
-/// - `BasePointer`: address of `s`
-/// - `Pointer`: address of `s.y`
-/// - `Size`: size of `s.y`
-///
-/// For a scalar variable BasePointer and Pointer will be the same.
-class DataDescriptor : public StructBuilder {
-public:
-  /// Construct a helper for the given descriptor value.
-  explicit DataDescriptor(Value descriptor);
-  /// Builds IR creating an `undef` value of the descriptor type.
-  static DataDescriptor undef(OpBuilder &builder, Location loc, Type basePtrTy,
-                              Type ptrTy);
-
-  static bool isValid(Value descriptor);
-
-  void setPointer(OpBuilder &builder, Location loc, Value ptr);
-  void setBasePointer(OpBuilder &builder, Location loc, Value basePtr);
-  void setSize(OpBuilder &builder, Location loc, Value size);
-};
-
-/// Collect the patterns to convert from the OpenACC dialect LLVMIR dialect.
-void populateOpenACCToLLVMConversionPatterns(LLVMTypeConverter &converter,
-                                             RewritePatternSet &patterns);
-} // namespace mlir
-
-#endif // MLIR_CONVERSION_OPENACCTOLLVM_CONVERTOPENACCTOLLVM_H

mlir/include/mlir/Conversion/Passes.h

 #include "mlir/Conversion/LinalgToStandard/LinalgToStandard.h"
 #include "mlir/Conversion/MathToFuncs/MathToFuncs.h"
 #include "mlir/Conversion/MathToLLVM/MathToLLVM.h"
 #include "mlir/Conversion/MathToLibm/MathToLibm.h"
 #include "mlir/Conversion/MathToSPIRV/MathToSPIRVPass.h"
 #include "mlir/Conversion/MemRefToLLVM/MemRefToLLVM.h"
 #include "mlir/Conversion/MemRefToSPIRV/MemRefToSPIRVPass.h"
 #include "mlir/Conversion/NVGPUToNVVM/NVGPUToNVVM.h"
-#include "mlir/Conversion/OpenACCToLLVM/ConvertOpenACCToLLVM.h"
 #include "mlir/Conversion/OpenACCToSCF/ConvertOpenACCToSCF.h"
 #include "mlir/Conversion/OpenMPToLLVM/ConvertOpenMPToLLVM.h"
 #include "mlir/Conversion/PDLToPDLInterp/PDLToPDLInterp.h"
 #include "mlir/Conversion/ReconcileUnrealizedCasts/ReconcileUnrealizedCasts.h"
 #include "mlir/Conversion/SCFToControlFlow/SCFToControlFlow.h"
 #include "mlir/Conversion/SCFToGPU/SCFToGPUPass.h"
 #include "mlir/Conversion/SCFToOpenMP/SCFToOpenMP.h"
 #include "mlir/Conversion/SCFToSPIRV/SCFToSPIRVPass.h"

mlir/include/mlir/Conversion/Passes.td

 
 def ConvertOpenACCToSCF : Pass<"convert-openacc-to-scf", "ModuleOp"> {
   let summary = "Convert the OpenACC ops to OpenACC with SCF dialect";
   let constructor = "mlir::createConvertOpenACCToSCFPass()";
   let dependentDialects = ["scf::SCFDialect", "acc::OpenACCDialect"];
 }
 
 //===----------------------------------------------------------------------===//
-// OpenACCToLLVM
-//===----------------------------------------------------------------------===//
-
-def ConvertOpenACCToLLVMPass : Pass<"convert-openacc-to-llvm", "ModuleOp"> {
-  let summary = "Convert the OpenACC ops to LLVM dialect";
-  let dependentDialects = ["LLVM::LLVMDialect"];
-  let options = [
-    Option<"useOpaquePointers", "use-opaque-pointers", "bool",
-           /*default=*/"true", "Generate LLVM IR using opaque pointers "
-           "instead of typed pointers">,
-  ];
-}
-
-//===----------------------------------------------------------------------===//
 // OpenMPToLLVM
 //===----------------------------------------------------------------------===//
 
 def ConvertOpenMPToLLVMPass : Pass<"convert-openmp-to-llvm", "ModuleOp"> {
   let summary = "Convert the OpenMP ops to OpenMP ops with LLVM dialect";
   let dependentDialects = ["LLVM::LLVMDialect"];
 }
 

mlir/lib/Conversion/CMakeLists.txt

 add_subdirectory(LLVMCommon)
 add_subdirectory(MathToFuncs)
 add_subdirectory(MathToLibm)
 add_subdirectory(MathToLLVM)
 add_subdirectory(MathToSPIRV)
 add_subdirectory(MemRefToLLVM)
 add_subdirectory(MemRefToSPIRV)
 add_subdirectory(NVGPUToNVVM)
-add_subdirectory(OpenACCToLLVM)
 add_subdirectory(OpenACCToSCF)
 add_subdirectory(OpenMPToLLVM)
 add_subdirectory(PDLToPDLInterp)
 add_subdirectory(ReconcileUnrealizedCasts)
 add_subdirectory(SCFToControlFlow)
 add_subdirectory(SCFToGPU)
 add_subdirectory(SCFToOpenMP)
 add_subdirectory(SCFToSPIRV)

mlir/lib/Conversion/OpenACCToLLVM/CMakeLists.txt

-add_mlir_conversion_library(MLIROpenACCToLLVM
-  OpenACCToLLVM.cpp
-
-  ADDITIONAL_HEADER_DIRS
-  ${MLIR_MAIN_INCLUDE_DIR}/mlir/Conversion/OpenACCToLLVM
-
-  DEPENDS
-  MLIRConversionPassIncGen
-
-  LINK_LIBS PUBLIC
-  MLIRIR
-  MLIRLLVMDialect
-  MLIRMemRefToLLVM
-  MLIROpenACCDialect
-  MLIRTransforms
-  )

mlir/lib/Conversion/OpenACCToLLVM/OpenACCToLLVM.cpp

-//===- OpenACCToLLVM.cpp - Prepare OpenACC data for LLVM translation ------===//
-//
-// 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
-//
-//===----------------------------------------------------------------------===//
-
-#include "mlir/Conversion/OpenACCToLLVM/ConvertOpenACCToLLVM.h"
-
-#include "mlir/Conversion/LLVMCommon/Pattern.h"
-#include "mlir/Dialect/LLVMIR/LLVMDialect.h"
-#include "mlir/Dialect/OpenACC/OpenACC.h"
-#include "mlir/IR/Builders.h"
-#include "mlir/Pass/Pass.h"
-
-namespace mlir {
-#define GEN_PASS_DEF_CONVERTOPENACCTOLLVMPASS
-#include "mlir/Conversion/Passes.h.inc"
-} // namespace mlir
-
-using namespace mlir;
-
-//===----------------------------------------------------------------------===//
-// DataDescriptor implementation
-//===----------------------------------------------------------------------===//
-
-constexpr StringRef getStructName() { return "openacc_data"; }
-
-/// Construct a helper for the given descriptor value.
-DataDescriptor::DataDescriptor(Value descriptor) : StructBuilder(descriptor) {
-  assert(value != nullptr && "value cannot be null");
-}
-
-/// Builds IR creating an `undef` value of the data descriptor.
-DataDescriptor DataDescriptor::undef(OpBuilder &builder, Location loc,
-                                     Type basePtrTy, Type ptrTy) {
-  Type descriptorType = LLVM::LLVMStructType::getNewIdentified(
-      builder.getContext(), getStructName(),
-      {basePtrTy, ptrTy, builder.getI64Type()});
-  Value descriptor = builder.create<LLVM::UndefOp>(loc, descriptorType);
-  return DataDescriptor(descriptor);
-}
-
-/// Check whether the type is a valid data descriptor.
-bool DataDescriptor::isValid(Value descriptor) {
-  if (auto type = descriptor.getType().dyn_cast<LLVM::LLVMStructType>()) {
-    if (type.isIdentified() && type.getName().startswith(getStructName()) &&
-        type.getBody().size() == 3 &&
-        (type.getBody()[kPtrBasePosInDataDescriptor]
-             .isa<LLVM::LLVMPointerType>() ||
-         type.getBody()[kPtrBasePosInDataDescriptor]
-             .isa<LLVM::LLVMStructType>()) &&
-        type.getBody()[kPtrPosInDataDescriptor].isa<LLVM::LLVMPointerType>() &&
-        type.getBody()[kSizePosInDataDescriptor].isInteger(64))
-      return true;
-  }
-  return false;
-}
-
-/// Builds IR inserting the base pointer value into the descriptor.
-void DataDescriptor::setBasePointer(OpBuilder &builder, Location loc,
-                                    Value basePtr) {
-  setPtr(builder, loc, kPtrBasePosInDataDescriptor, basePtr);
-}
-
-/// Builds IR inserting the pointer value into the descriptor.
-void DataDescriptor::setPointer(OpBuilder &builder, Location loc, Value ptr) {
-  setPtr(builder, loc, kPtrPosInDataDescriptor, ptr);
-}
-
-/// Builds IR inserting the size value into the descriptor.
-void DataDescriptor::setSize(OpBuilder &builder, Location loc, Value size) {
-  setPtr(builder, loc, kSizePosInDataDescriptor, size);
-}
-
-//===----------------------------------------------------------------------===//
-// Conversion patterns
-//===----------------------------------------------------------------------===//
-
-namespace {
-
-template <typename Op>
-class LegalizeDataOpForLLVMTranslation : public ConvertOpToLLVMPattern<Op> {
-  using ConvertOpToLLVMPattern<Op>::ConvertOpToLLVMPattern;
-
-  LogicalResult
-  matchAndRewrite(Op op, typename Op::Adaptor adaptor,
-                  ConversionPatternRewriter &builder) const override {
-    Location loc = op.getLoc();
-    TypeConverter *converter = ConvertToLLVMPattern::getTypeConverter();
-
-    unsigned numDataOperand = op.getNumDataOperands();
-
-    // Keep the non data operands without modification.
-    auto nonDataOperands = adaptor.getOperands().take_front(
-        adaptor.getOperands().size() - numDataOperand);
-    SmallVector<Value> convertedOperands;
-    convertedOperands.append(nonDataOperands.begin(), nonDataOperands.end());
-
-    // Go over the data operand and legalize them for translation.
-    for (unsigned idx = 0; idx < numDataOperand; ++idx) {
-      Value originalDataOperand = op.getDataOperand(idx);
-
-      // Traverse operands that were converted to MemRefDescriptors.
-      if (auto memRefType =
-              originalDataOperand.getType().dyn_cast<MemRefType>()) {
-        Type structType = converter->convertType(memRefType);
-        Value memRefDescriptor = builder
-                                     .create<UnrealizedConversionCastOp>(
-                                         loc, structType, originalDataOperand)
-                                     .getResult(0);
-
-        // Calculate the size of the memref and get the pointer to the allocated
-        // buffer.
-        SmallVector<Value> sizes;
-        SmallVector<Value> strides;
-        Value sizeBytes;
-        ConvertToLLVMPattern::getMemRefDescriptorSizes(
-            loc, memRefType, {}, builder, sizes, strides, sizeBytes);
-        MemRefDescriptor descriptor(memRefDescriptor);
-        Value dataPtr = descriptor.alignedPtr(builder, loc);
-        auto ptrType = descriptor.getElementPtrType();
-
-        auto descr = DataDescriptor::undef(builder, loc, structType, ptrType);
-        descr.setBasePointer(builder, loc, memRefDescriptor);
-        descr.setPointer(builder, loc, dataPtr);
-        descr.setSize(builder, loc, sizeBytes);
-        convertedOperands.push_back(descr);
-      } else if (originalDataOperand.getType().isa<LLVM::LLVMPointerType>()) {
-        convertedOperands.push_back(originalDataOperand);
-      } else {
-        // Type not supported.
-        return builder.notifyMatchFailure(op, "unsupported type");
-      }
-    }
-
-    if constexpr (std::is_same_v<Op, acc::ParallelOp> ||
-                  std::is_same_v<Op, acc::DataOp>) {
-      auto newOp =
-          builder.create<Op>(op.getLoc(), TypeRange(), convertedOperands,
-                             op.getOperation()->getAttrs());
-      builder.inlineRegionBefore(op.getRegion(), newOp.getRegion(),
-                                 newOp.getRegion().end());
-      builder.eraseOp(op);
-    } else {
-      builder.replaceOpWithNewOp<Op>(op, TypeRange(), convertedOperands,
-                                     op.getOperation()->getAttrs());
-    }
-
-    return success();
-  }
-};
-} // namespace
-
-void mlir::populateOpenACCToLLVMConversionPatterns(
-    LLVMTypeConverter &converter, RewritePatternSet &patterns) {
-  patterns.add<LegalizeDataOpForLLVMTranslation<acc::ParallelOp>>(converter);
-}
-
-namespace {
-struct ConvertOpenACCToLLVMPass
-    : public impl::ConvertOpenACCToLLVMPassBase<ConvertOpenACCToLLVMPass> {
-  using Base::Base;
-
-  void runOnOperation() override;
-};
-} // namespace
-
-void ConvertOpenACCToLLVMPass::runOnOperation() {
-  auto op = getOperation();
-  auto *context = op.getContext();
-
-  // Convert to OpenACC operations with LLVM IR dialect
-  RewritePatternSet patterns(context);
-  LowerToLLVMOptions options(context);
-  options.useOpaquePointers = useOpaquePointers;
-  LLVMTypeConverter converter(context, options);
-  populateOpenACCToLLVMConversionPatterns(converter, patterns);
-
-  ConversionTarget target(*context);
-  target.addLegalDialect<LLVM::LLVMDialect>();
-  target.addLegalOp<UnrealizedConversionCastOp>();
-
-  auto allDataOperandsAreConverted = [](ValueRange operands) {
-    for (Value operand : operands) {
-      if (!DataDescriptor::isValid(operand) &&
-          !operand.getType().isa<LLVM::LLVMPointerType>())
-        return false;
-    }
-    return true;
-  };
-
-  target.addDynamicallyLegalOp<acc::ParallelOp>(
-      [allDataOperandsAreConverted](acc::ParallelOp op) {
-        return allDataOperandsAreConverted(op.getReductionOperands()) &&
-               allDataOperandsAreConverted(op.getGangPrivateOperands()) &&
-               allDataOperandsAreConverted(op.getGangFirstPrivateOperands());
-      });
-
-  if (failed(applyPartialConversion(op, target, std::move(patterns))))
-    signalPassFailure();
-}

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

 add_mlir_translation_library(MLIROpenACCToLLVMIRTranslation
   OpenACCToLLVMIRTranslation.cpp
 
   LINK_COMPONENTS
   Core
 
   LINK_LIBS PUBLIC
   MLIRIR
   MLIRLLVMDialect
   MLIROpenACCDialect
-  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/Dialect/OpenMPCommon.h"
 #include "mlir/Target/LLVMIR/ModuleTranslation.h"
 
processOperands(llvm::IRBuilderBase &builder,
 
   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>()) {
+    if (data.getType().isa<LLVM::LLVMPointerType>()) {
       dataPtrBase = dataValue;
       dataPtr = dataValue;
       dataSize = accBuilder->getSizeInBytes(dataValue);
     } else {
       return op->emitOpError()
              << "Data operand must be legalized before translation."
              << "Unsupported type: " << data.getType();
     }