a85bd1b119
Part of https://discourse.llvm.org/t/rfc-switching-the-llvm-dialect-and-dialect-lowerings-to-opaque-pointers/68179 FuncToLLVM contains some logic working with Memrefs and their lowerings and in the process creating pointer types, loads and allocas. This patch ports the code of these to be compatible with opaque pointers and adds a pass option to enable the use of opaque pointers within the pass. For the migration effort, the tests have been rewritten to use opaque pointers with dedicated test files for typed pointer support Differential Revision: https://reviews.llvm.org/D143608
86 lines
2.8 KiB
C++
86 lines
2.8 KiB
C++
//===- TestConvertCallOp.cpp - Test LLVM Conversion of Func CallOp --------===//
|
|
//
|
|
// 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 "TestDialect.h"
|
|
#include "TestTypes.h"
|
|
#include "mlir/Conversion/FuncToLLVM/ConvertFuncToLLVM.h"
|
|
#include "mlir/Conversion/LLVMCommon/Pattern.h"
|
|
#include "mlir/Dialect/Func/IR/FuncOps.h"
|
|
#include "mlir/Dialect/LLVMIR/LLVMDialect.h"
|
|
#include "mlir/Pass/Pass.h"
|
|
|
|
using namespace mlir;
|
|
|
|
namespace {
|
|
|
|
class TestTypeProducerOpConverter
|
|
: public ConvertOpToLLVMPattern<test::TestTypeProducerOp> {
|
|
public:
|
|
using ConvertOpToLLVMPattern<
|
|
test::TestTypeProducerOp>::ConvertOpToLLVMPattern;
|
|
|
|
LogicalResult
|
|
matchAndRewrite(test::TestTypeProducerOp op, OpAdaptor adaptor,
|
|
ConversionPatternRewriter &rewriter) const override {
|
|
rewriter.replaceOpWithNewOp<LLVM::NullOp>(op, getVoidPtrType());
|
|
return success();
|
|
}
|
|
};
|
|
|
|
struct TestConvertCallOp
|
|
: public PassWrapper<TestConvertCallOp, OperationPass<ModuleOp>> {
|
|
MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(TestConvertCallOp)
|
|
|
|
void getDependentDialects(DialectRegistry ®istry) const final {
|
|
registry.insert<LLVM::LLVMDialect>();
|
|
}
|
|
StringRef getArgument() const final { return "test-convert-call-op"; }
|
|
StringRef getDescription() const final {
|
|
return "Tests conversion of `func.call` to `llvm.call` in "
|
|
"presence of custom types";
|
|
}
|
|
|
|
void runOnOperation() override {
|
|
ModuleOp m = getOperation();
|
|
|
|
LowerToLLVMOptions options(m.getContext());
|
|
options.useOpaquePointers = false;
|
|
|
|
// Populate type conversions.
|
|
LLVMTypeConverter typeConverter(m.getContext(), options);
|
|
typeConverter.addConversion([&](test::TestType type) {
|
|
return LLVM::LLVMPointerType::get(IntegerType::get(m.getContext(), 8));
|
|
});
|
|
typeConverter.addConversion([&](test::SimpleAType type) {
|
|
return IntegerType::get(type.getContext(), 42);
|
|
});
|
|
|
|
// Populate patterns.
|
|
RewritePatternSet patterns(m.getContext());
|
|
populateFuncToLLVMConversionPatterns(typeConverter, patterns);
|
|
patterns.add<TestTypeProducerOpConverter>(typeConverter);
|
|
|
|
// Set target.
|
|
ConversionTarget target(getContext());
|
|
target.addLegalDialect<LLVM::LLVMDialect>();
|
|
target.addIllegalDialect<test::TestDialect>();
|
|
target.addIllegalDialect<func::FuncDialect>();
|
|
|
|
if (failed(applyPartialConversion(m, target, std::move(patterns))))
|
|
signalPassFailure();
|
|
}
|
|
};
|
|
|
|
} // namespace
|
|
|
|
namespace mlir {
|
|
namespace test {
|
|
void registerConvertCallOpPass() { PassRegistration<TestConvertCallOp>(); }
|
|
} // namespace test
|
|
} // namespace mlir
|