static int loadAndProcessMLIR(mlir::MLIRContext &context,

                              mlir::OwningOpRef<mlir::ModuleOp> &module) {

  if (int error = loadMLIR(context, module))

    return error;

  mlir::PassManager pm(module.get()->getName());

  // Apply any generic pass manager command line options and run the pipeline.

  if (mlir::failed(mlir::applyPassManagerCLOptions(pm)))

    return 4;

  // Check to see what granularity of MLIR we are compiling to.

  bool isLoweringToAffine = emitAction >= Action::DumpMLIRAffine;

  bool isLoweringToLLVM = emitAction >= Action::DumpMLIRLLVM;

  if (enableOpt || isLoweringToAffine) {  // 包含一些优化 pass，降级到 affine 也是必要的

    // Inline all functions into main and then delete them.

    pm.addPass(mlir::createInlinerPass());

 // 将所有函数进行 inline 操作，降低后续优化的复杂性

    // Now that there is only one function, we can infer the shapes of each of

    // the operations.

    mlir::OpPassManager &optPM = pm.nest<mlir::toy::FuncOp>();

 // 优化 pass 容器

    optPM.addPass(mlir::toy::createShapeInferencePass());

  // 自定义 Pass 用于推理 shape，包含 OPS 生成默认 + 自定义的 shape 推理

    optPM.addPass(mlir::createCanonicalizerPass());  // [规范化 IR：消除冗余操作、简化常量表达式、应用简单的重写规则]

    optPM.addPass(mlir::createCSEPass());  // 死代码消除 pass

  }

  if (isLoweringToAffine) {  // toy dialect -> affine dialect

    // Partially lower the toy dialect.

    pm.addPass(mlir::toy::createLowerToAffinePass());

  // 自定义降级 pass

    // Add a few cleanups post lowering.

    mlir::OpPassManager &optPM = pm.nest<mlir::func::FuncOp>();

    optPM.addPass(mlir::createCanonicalizerPass());

    optPM.addPass(mlir::createCSEPass());

    // Add optimizations if enabled.

    if (enableOpt) {  

      optPM.addPass(mlir::affine::createLoopFusionPass());

      optPM.addPass(mlir::affine::createAffineScalarReplacementPass());

    }

  }

  if (isLoweringToLLVM) {  // affine dialect -> llvm dialect

    // Finish lowering the toy IR to the LLVM dialect.

    pm.addPass(mlir::toy::createLowerToLLVMPass());

 //  降级 pass

    // This is necessary to have line tables emitted and basic

    // debugger working. In the future we will add proper debug information

    // emission directly from our frontend.

    pm.addPass(mlir::LLVM::createDIScopeForLLVMFuncOpPass());

  }

  if (mlir::failed(pm.run(*module)))

  // 执行 pass

    return 4;

  return 0;

}

def transpose_transpose(x) {  // 双重转置 应当消除这种无意义的操作

  return transpose(transpose(x));

}

toy.func @transpose_transpose(%arg0: tensor<*xf64>) -> tensor<*xf64> {

  %0 = toy.transpose(%arg0 : tensor<*xf64>) to tensor<*xf64>

  %1 = toy.transpose(%0 : tensor<*xf64>) to tensor<*xf64>

  toy.return %1 : tensor<*xf64>

}

#define N 100

#define M 100

// 当前状态 匹配 将非常困难

void sink(void *);

void double_transpose(int A[N][M]) {

  int B[M][N];

  for(int i = 0; i < N; ++i) {

    for(int j = 0; j < M; ++j) {

       B[j][i] = A[i][j];

    }

  }

  for(int i = 0; i < N; ++i) {

    for(int j = 0; j < M; ++j) {

       A[i][j] = B[j][i];

    }

  }

  sink(A);

}

/// Fold transpose(transpose(x)) -> x

struct SimplifyRedundantTranspose : public mlir::OpRewritePattern<TransposeOp> {  // 创建一个优化规则， 其继承一个模板类，专门用于匹配和重写 TransposeOp 操作

  /// We register this pattern to match every toy.transpose in the IR.

  /// The "benefit" is used by the framework to order the patterns and process

  /// them in order of profitability.

  SimplifyRedundantTranspose(mlir::MLIRContext *context)

      : OpRewritePattern<TransposeOp>(context, /*benefit=*/1) {}

  /// This method is attempting to match a pattern and rewrite it. The rewriter

  /// argument is the orchestrator of the sequence of rewrites. It is expected

  /// to interact with it to perform any changes to the IR from here.

  llvm::LogicalResult  matchAndRewrite(TransposeOp op,  // 核心方法 matchAndRewrite

                  mlir::PatternRewriter &rewriter) const override {

    // Look through the input of the current transpose.

    mlir::Value transposeInput = op.getOperand();  // 1. 获取当前转置的输入

    TransposeOp transposeInputOp = transposeInput.getDefiningOp<TransposeOp>(); // 2. 尝试查看这个输入是否由另一个转置定义

    // Input defined by another transpose? If not, no match.

    if (!transposeInputOp)  // 3. 如果不是，匹配失败

      return failure();

    // Otherwise, we have a redundant transpose. Use the rewriter.

    rewriter.replaceOp(op, {transposeInputOp.getOperand()});  // 4. 如果是，替换当前转置为它的输入

    return success();

  }

};

// Register our patterns for rewrite by the Canonicalization framework.

void TransposeOp::getCanonicalizationPatterns(

    RewritePatternSet &results, MLIRContext *context) {

  results.add<SimplifyRedundantTranspose>(context);

}

//===- ToyCombine.td - Pattern Match Optimizations for Toy -*- tablegen -*-===//

//

// 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

//

//===----------------------------------------------------------------------===//

//

// Defines language-specific pattern match optimizations for Toy using

// Declarative Rewrite Rules (DRR) specified using TableGen records.

//

//===----------------------------------------------------------------------===//

#ifndef TOY_COMBINE

#define TOY_COMBINE

include "mlir/IR/PatternBase.td"

include "toy/Ops.td"

/// Note: The DRR definition used for defining patterns is shown below:

///

/// class Pattern<

///    dag sourcePattern, list<dag> resultPatterns,

///    list<dag> additionalConstraints = [],

//     list<dag> supplementalPatterns = [],

///    dag benefitsAdded = (addBenefit 0)

/// >;

//===----------------------------------------------------------------------===//

// Basic Pattern-Match and Rewrite

//===----------------------------------------------------------------------===//

// Reshape(Reshape(x)) = Reshape(x)

def ReshapeReshapeOptPattern : Pat<(ReshapeOp(ReshapeOp $arg)),

                                   (ReshapeOp $arg)>;

//===----------------------------------------------------------------------===//

// Pattern-Match and Rewrite using Native Code Call

//===----------------------------------------------------------------------===//

// Native Code Calls may be used for more complex transformations using inline

// C++ and C++ helper functions.

// Reshape(Constant(x)) = x'

def ReshapeConstant :

  NativeCodeCall<"$0.reshape(::llvm::cast<ShapedType>($1.getType()))">;

def FoldConstantReshapeOptPattern : Pat<

  (ReshapeOp:$res (ConstantOp $arg)),

  (ConstantOp (ReshapeConstant $arg, $res))>;

//===----------------------------------------------------------------------===//

// Pattern-Match and Rewrite with Constraints

//===----------------------------------------------------------------------===//

// DRR allows for constraint checking when the transformation is conditional

// on operand properties.

// Reshape(x) = x, where input and output shapes are identical

def TypesAreIdentical : Constraint<CPred<"$0.getType() == $1.getType()">>;

def RedundantReshapeOptPattern : Pat<

  (ReshapeOp:$res $arg), (replaceWithValue $arg),

  [(TypesAreIdentical $res, $arg)]>;

#endif // TOY_COMBINE

// Reshape(Reshape(x)) = Reshape(x)

def ReshapeReshapeOptPattern : Pat<(ReshapeOp(ReshapeOp $arg)),

                                   (ReshapeOp $arg)>; // 将外层输入替换为内层

// Reshape(Constant(x)) = x'

def ReshapeConstant :  // NativeCodeCall 调用一段手写的 C++ 代码片段

  NativeCodeCall<"$0.reshape(::llvm::cast<ShapedType>($1.getType()))">;

def FoldConstantReshapeOptPattern : Pat<

  (ReshapeOp:$res (ConstantOp $arg)),  // 匹配的是 Reshape (Constant (x)) 结构

  (ConstantOp (ReshapeConstant $arg, $res))>;

// 1. 常量定义

%0 = toy.constant dense<[1.0, 2.0, 3.0, 4.0, 5.0, 6.0]> : tensor<6xf64>

// 2. Reshape 操作

%1 = toy.reshape(%0) : tensor<6xf64> -> tensor<2x3xf64>

// 原来的 %0 不变（但可能变为死代码，被其他优化 pass 清除）

%0 = toy.constant dense<[1.0, 2.0, 3.0, 4.0, 5.0, 6.0]> : tensor<6xf64>

// 新的常量

%1 = toy.constant dense<[[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]]> : tensor<2x3xf64>

// Reshape(x) = x, where input and output shapes are identical

def TypesAreIdentical : Constraint<CPred<"$0.getType() == $1.getType()">>;

def RedundantReshapeOptPattern : Pat<

  (ReshapeOp:$res $arg), (replaceWithValue $arg),

  [(TypesAreIdentical $res, $arg)]>;

// 匹配前

%0 = toy.reshape(%arg0) : tensor<2x3xf64> -> tensor<2x3xf64>

// 匹配后

// %0 被完全移除，所有使用 %0 的地方都被替换为 % arg0