概述

MLIR Toy Tutorial 的目标是通过构建一门编程语言编译器的完整过程（包括前端和后端技术），教授如何使用 MLIR 的各个组件来实现语言的解析、转换和代码生成等功能。

终于来到了 codegen 这章，它介绍了如何将 Chapter 5 生成的 low-level IR lowering 成 LLVM IR，并通过 JIT 的方式来解释执行样例代码。

Full Lowering

applyFullConversion(module, target, patterns) 用于执行完整的、全局性的转换，目标是将方言的所有操作都完全转换为目标方言的等效操作。和 partial lowering 一样，它需要在 target 定义目标 IR -- LLVM，然后还要提供一套能生成 LLVM IR 的 rewrite patterns -- patterns。

Chapter 5 通过 partial lowering 已经将除 toy.print 以外的 IR 都 lowering 成了 affine，arith 和 std built-in IR，MLIR 提供有现成的 rewrite patterns 就可以很容易滴将它们转换成 LLVM IR：

  mlir::RewritePatternSet patterns(&getContext());
  mlir::populateAffineToStdConversionPatterns(patterns, &getContext());
  mlir::cf::populateSCFToControlFlowConversionPatterns(patterns, &getContext());
  mlir::arith::populateArithToLLVMConversionPatterns(typeConverter,
                                                          patterns);
  mlir::populateFuncToLLVMConversionPatterns(typeConverter, patterns);
  mlir::cf::populateControlFlowToLLVMConversionPatterns(patterns, &getContext());

  // The only remaining operation, to lower from the `toy` dialect, is the
  // PrintOp.
  patterns.add<PrintOpLowering>(&getContext());

唯一需要自己写转换规则的 op 就是 toy.print。PrintOpLowering 会创建 malloc、printf 符号，将 mlir.memref 数据类型的输入数据写入 malloc 得到的 buffer，再通过 printf 把 buffer 打印出来，对于 CPU 来说，在编译时 printf、malloc 会链接到 libc 中相应的库函数：

module {
  llvm.func @free(!llvm.ptr)
  llvm.mlir.global internal constant @nl("\0A\00") {addr_space = 0 : i32}
  llvm.mlir.global internal constant @frmt_spec("%f \00") {addr_space = 0 : i32}
  llvm.func @printf(!llvm.ptr<i8>, ...) -> i32
  llvm.func @malloc(i64) -> !llvm.ptr
  llvm.func @main() {
    %0 = llvm.mlir.constant(4.000000e+00 : f64) : f64
    %1 = llvm.mlir.constant(1.000000e+00 : f64) : f64
    ...
    %8 = llvm.call @malloc(%7) : (i64) -> !llvm.ptr
    %9 = llvm.mlir.undef : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
    %10 = llvm.insertvalue %8, %9[0] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)> 
    %11 = llvm.insertvalue %8, %10[1] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)> 
    ...
    %48 = llvm.call @printf(%30, %47) : (!llvm.ptr<i8>, f64) -> i32
    ...
    llvm.call @free(%52) : (!llvm.ptr) -> ()
    llvm.return
  }
}

CodeGen: Run JIT

前面几章的内容只是把 IR 打印出来，却从来没有运行过它们。通过 mlir::ExecutionEngine 可以创建MLIR JIT 执行引擎，engine->invoke("main") 会先编译 main 函数然后再执行：

int runJit(mlir::ModuleOp module) {
  // Initialize LLVM targets.
  llvm::InitializeNativeTarget();
  llvm::InitializeNativeTargetAsmPrinter();

  // An optimization pipeline to use within the execution engine.
  auto optPipeline = mlir::makeOptimizingTransformer(
      /*optLevel=*/EnableOpt ? 3 : 0, /*sizeLevel=*/0,
      /*targetMachine=*/nullptr);

  // Create an MLIR execution engine. The execution engine eagerly JIT-compiles
  // the module.
  auto maybeEngine = mlir::ExecutionEngine::create(module,
      /*llvmModuleBuilder=*/nullptr, optPipeline);
  assert(maybeEngine && "failed to construct an execution engine");
  auto &engine = maybeEngine.get();

  // Invoke the JIT-compiled function.
  auto invocationResult = engine->invoke("main");
  if (invocationResult) {
    llvm::errs() << "JIT invocation failed\n";
    return -1;
  }

  return 0;
}

总结

文章介绍了如何使用 applyFullConversion 执行全局转换，生成 LLVM IR，以及 JIT 引擎的创建和调用。

END