// MLIR 操作格式:
%result = dialect.operation_name %operand1, %operand2 {attr = value} : (type1, type2) -> type3

// 示例:
%sum = arith.addi %a, %b : i32                    // 整数加法
%prod = arith.mulf %x, %y : f32                   // 浮点乘法
%cmp = arith.cmpi eq, %a, %b : i32                // 整数比较

// 函数定义
func.func @add(%arg0: i32, %arg1: i32) -> i32 {
  %result = arith.addi %arg0, %arg1 : i32
  return %result : i32
}

// 控制流
scf.for %i = %lb to %ub step %step {
  %val = memref.load %arr[%i] : memref<10xi32>
  scf.yield
}

// 张量操作
%c = linalg.matmul ins(%a, %b : tensor<4x8xf32>, tensor<8x16xf32>)
                   outs(%c : tensor<4x16xf32>) -> tensor<4x16xf32>

// Region 包含 Block
// Block 包含 Operation
// Operation 可以包含 Region (嵌套)

func.func @example(%cond: i1) -> i32 {
  // 这里是一个 Region
  // 包含一个 Block (entry block)

  cf.cond_br %cond, ^bb1, ^bb2  // 条件分支

^bb1:
  %x = arith.constant 42 : i32
  cf.br ^bb3(%x : i32)

^bb2:
  %y = arith.constant 0 : i32
  cf.br ^bb3(%y : i32)

^bb3(%result: i32):
  return %result : i32
}

// 基础类型
i32                     // 32位整数
f64                     // 64位浮点
index                   // 索引类型 (平台相关)

// 张量类型
tensor<4xf32>           // 1D张量，4个f32
tensor<3x4xf32>         // 2D张量
tensor<?x?xf32>         // 动态形状张量
tensor<4x?x8xi32>       // 部分动态

// 内存引用类型
memref<10xf32>          // 1D内存，10个f32
memref<3x4xf32>         // 2D内存
memref<?xf32>           // 动态大小
memref<10xf32, affine_map<(d0) -> (d0)>, 1>  // 带布局和地址空间

// 向量类型
vector<4xf32>           // SIMD向量
vector<4x8xf32>         // 2D向量

// 函数类型
(i32, i32) -> i32       // 两参数一返回值
(i32) -> ()             // 一参数无返回值

// 索引映射类型
affine_map<(d0, d1) -> (d0, d1)>    // 仿射映射

# 使用 mlir-opt 运行变换
mlir-opt input.mlir -pass-name -o output.mlir

# 常用变换
mlir-opt input.mlir \
  -linalg-bufferize \
  -tensor-bufferize \
  -func-bufferize \
  -convert-linalg-to-loops \
  -convert-scf-to-cf \
  -convert-memref-to-llvm \
  -convert-arith-to-llvm \
  -convert-func-to-llvm \
  -reconcile-unrealized-casts \
  -o output.mlir

# 一键降级到 LLVM 方言
mlir-opt input.mlir \
  -one-shot-bufferize \
  -convert-linalg-to-loops \
  -lower-affine \
  -convert-scf-to-cf \
  -finalize-memref-to-llvm \
  -convert-func-to-llvm \
  -convert-arith-to-llvm \
  -reconcile-unrealized-casts \
  -o output.mlir

// MyTransformPass.cpp
#include "mlir/IR/BuiltinOps.h"
#include "mlir/Pass/Pass.h"
#include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Transforms/GreedyPatternRewriteDriver.h"

using namespace mlir;

struct MyPattern : public OpRewritePattern<arith::AddIOp> {
    using OpRewritePattern::OpRewritePattern;

    LogicalResult matchAndRewrite(arith::AddIOp op,
                                   PatternRewriter &rewriter) const override {
        // 匹配 add x, 0 → x
        auto rhs = op.getRhs().getDefiningOp<arith::ConstantOp>();
        if (rhs && rhs.getValue().cast<IntegerAttr>().getInt() == 0) {
            rewriter.replaceOp(op, op.getLhs());
            return success();
        }
        return failure();
    }
};

struct MyPass : public PassWrapper<MyPass, OperationPass<ModuleOp>> {
    MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(MyPass)

    StringRef getArgument() const override { return "my-pass"; }
    StringRef getDescription() const override { return "My custom pass"; }

    void runOnOperation() override {
        MLIRContext *ctx = &getContext();
        RewritePatternSet patterns(ctx);
        patterns.add<MyPattern>(ctx);
        
        if (failed(applyPatternsAndFoldGreedily(
                getOperation(), std::move(patterns)))) {
            signalPassFailure();
        }
    }
};

// 注册 Pass
void registerMyPass() {
    PassRegistration<MyPass>();
}

# MLIR → LLVM IR
mlir-translate --mlir-to-llvmir input.mlir -o output.ll

# LLVM IR → MLIR
mlir-translate --import-llvm input.ll -o output.mlir

# 执行 MLIR
mlir-cpu-runner -e main -entry-point-result=i32 \
  -shared-libs=/usr/lib/libmlir_runner_utils.so input.mlir