这篇文章继续处理上一章留下的 print 操作,将它降级为 LLVM IR。
传递式降级
所谓传递式降级,就是 A→B→C:通过连续应用多条模式,将非法操作最终转换成一组合法操作。
这意味着单次改写不必立刻让所有操作完全合法。本例先生成结构化嵌套循环,而不是直接生成 LLVM 方言的分支结构。只要之后还能将循环操作降级到 LLVM,整个转换就能成功。
降级到 LLVM
下面构建完整降级 Toy 方言的 pass。先实现转换模式 PrintOpLowering。对于 toy.print:
- 做准备工作,例如通过
getOrInsertPrintf获取或声明 LLVM printf 函数,并初始化格式字符串。 - 创建遍历各个维度的循环。
- 在循环体中插入加载和打印操作。
注意以下几点:
- 先创建循环,再用
rewriter.eraseOp(&nested);清空循环体,因为有些循环构造函数会自动创建yield。使用make_early_inc_range可以在遍历时安全修改内容。 - 把插入点设置在最内层循环体的开头,才能在循环中创建打印操作。无需手动恢复插入点,因为它被限制在当前模式匹配的作用域内。
class PrintOpLowering : public OpConversionPattern<toy::PrintOp> {
public:
using OpConversionPattern<toy::PrintOp>::OpConversionPattern;
LogicalResult matchAndRewrite(toy::PrintOp op, OpAdaptor adaptor,
ConversionPatternRewriter &rewriter) const override {
auto *context = rewriter.getContext();
auto memRefType = llvm::cast<MemRefType>((*op->operand_type_begin()));
auto memRefShape = memRefType.getShape();
auto loc = op->getLoc();
ModuleOp parentModule = op->getParentOfType<ModuleOp>();
// Get a symbol reference to the printf function, inserting it if necessary.
auto printfRef = getOrInsertPrintf(rewriter, parentModule);
Value formatSpecifierCst = getOrCreateGlobalString(
loc, rewriter, "frmt_spec", StringRef("%f \0", 4), parentModule);
Value newLineCst = getOrCreateGlobalString(
loc, rewriter, "nl", StringRef("\n\0", 2), parentModule);
// Create a loop for each of the dimensions within the shape.
SmallVector<Value, 4> loopIvs;
for (unsigned i = 0, e = memRefShape.size(); i != e; ++i) {
auto lowerBound = arith::ConstantIndexOp::create(rewriter, loc, 0);
auto upperBound =
arith::ConstantIndexOp::create(rewriter, loc, memRefShape[i]);
auto step = arith::ConstantIndexOp::create(rewriter, loc, 1);
auto loop =
scf::ForOp::create(rewriter, loc, lowerBound, upperBound, step);
for (Operation &nested : make_early_inc_range(*loop.getBody()))
rewriter.eraseOp(&nested);
loopIvs.push_back(loop.getInductionVar());
// Terminate the loop body.
rewriter.setInsertionPointToEnd(loop.getBody());
// Insert a newline after each of the inner dimensions of the shape.
if (i != e - 1)
LLVM::CallOp::create(rewriter, loc, getPrintfType(context), printfRef,
newLineCst);
scf::YieldOp::create(rewriter, loc);
rewriter.setInsertionPointToStart(loop.getBody());
}
// Generate a call to printf for the current element of the loop.
auto elementLoad =
memref::LoadOp::create(rewriter, loc, op.getInput(), loopIvs);
LLVM::CallOp::create(rewriter, loc, getPrintfType(context), printfRef,
ArrayRef<Value>({formatSpecifierCst, elementLoad}));
// Notify the rewriter that this operation has been removed.
rewriter.eraseOp(op);
return success();
}
最后定义使用上述转换模式的 pass,同时加入 populateAffineToStdConversionPatterns 等内置降级模式。多个模式竞争时,MLIR 使用每条模式的 benefit 参数决定优先级。
大致流程如下:
- 将操作放入工作列表。
- 取出一个操作。
- 查找根操作类型匹配的模式。
- 优先尝试 benefit 较高的模式,改写并更新 IR。
- 将受影响的操作重新放入工作列表。
- 重复执行,直到没有可应用的改写。
namespace {
struct ToyToLLVMLoweringPass
: public PassWrapper<ToyToLLVMLoweringPass, OperationPass<ModuleOp>> {
MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(ToyToLLVMLoweringPass)
StringRef getArgument() const override { return "toy-to-llvm"; }
void getDependentDialects(DialectRegistry ®istry) const override {
registry.insert<LLVM::LLVMDialect, scf::SCFDialect>();
}
void runOnOperation() final;
};
} // namespace
void ToyToLLVMLoweringPass::runOnOperation() {
// The first thing to define is the conversion target. This will define the
// final target for this lowering. For this lowering, we are only targeting
// the LLVM dialect.
LLVMConversionTarget target(getContext());
target.addLegalOp<ModuleOp>();
// During this lowering, we will also be lowering the MemRef types, that are
// currently being operated on, to a representation in LLVM. To perform this
// conversion we use a TypeConverter as part of the lowering. This converter
// details how one type maps to another. This is necessary now that we will be
// doing more complicated lowerings, involving loop region arguments.
LLVMTypeConverter typeConverter(&getContext());
// Now that the conversion target has been defined, we need to provide the
// patterns used for lowering. At this point of the compilation process, we
// have a combination of `toy`, `affine`, and `std` operations. Luckily, there
// are already exists a set of patterns to transform `affine` and `std`
// dialects. These patterns lowering in multiple stages, relying on transitive
// lowerings. Transitive lowering, or A->B->C lowering, is when multiple
// patterns must be applied to fully transform an illegal operation into a
// set of legal ones.
RewritePatternSet patterns(&getContext());
populateAffineToStdConversionPatterns(patterns);
populateSCFToControlFlowConversionPatterns(patterns);
mlir::arith::populateArithToLLVMConversionPatterns(typeConverter, patterns);
populateFinalizeMemRefToLLVMConversionPatterns(typeConverter, patterns);
cf::populateControlFlowToLLVMConversionPatterns(typeConverter, patterns);
populateFuncToLLVMConversionPatterns(typeConverter, patterns);
// The only remaining operation to lower from the `toy` dialect, is the
// PrintOp.
patterns.add<PrintOpLowering>(&getContext());
// We want to completely lower to LLVM, so we use a `FullConversion`. This
// ensures that only legal operations will remain after the conversion.
auto module = getOperation();
if (failed(applyFullConversion(module, target, std::move(patterns))))
signalPassFailure();
}