int main(int argc, char **argv) {

  // Register any command line options.

  mlir::registerAsmPrinterCLOptions();   // 注册汇编打印选项

  mlir::registerMLIRContextCLOptions();  // 注册 MLIR 上下文选项  

  mlir::registerPassManagerCLOptions();  // 注册 Pass 管理器选项

  cl::ParseCommandLineOptions(argc, argv, "toy compiler\n");  // 解析输入命令

  if (emitAction == Action::DumpAST)

    return dumpAST();

 // 生成 抽象语法树 AST，并打印出来。

  // If we aren't dumping the AST, then we are compiling with/to MLIR.

  mlir::DialectRegistry registry;

  mlir::func::registerAllExtensions(registry);

  mlir::LLVM::registerInlinerInterface(registry);

  mlir::MLIRContext context(registry);

  // Load our Dialect in this MLIR Context.

  context.getOrLoadDialect<mlir::toy::ToyDialect>();  // 加载 自定义方言

toy dialect，用到的其他方言延迟加载，即访问到对应方言的时候才加载

  mlir::OwningOpRef<mlir::ModuleOp> module;

  if (int error = loadAndProcessMLIR(context, module))  //ast -> affine dialect -> llvm dialect 降级过程

    return error;

  // If we aren't exporting to non-mlir, then we are done.

  bool isOutputingMLIR = emitAction <= Action::DumpMLIRLLVM;

  if (isOutputingMLIR) {

    module->dump();

    return 0;

  }

  // Check to see if we are compiling to LLVM IR.

  if (emitAction == Action::DumpLLVMIR)

    return dumpLLVMIR(*module);  // llvm dialect -> llvm IR

  // Otherwise, we must be running the jit.

  if (emitAction == Action::RunJIT)

    return runJit(*module);  //run 执行 jit

  llvm::errs() << "No action specified (parsing only?), use -emit=<action>\n";

  return -1;

}

mlir::ModuleOp mlirGen(ModuleAST &moduleAST) {  // 输入 AST

    // We create an empty MLIR module and codegen functions one at a time and

    // add them to the module.

    theModule = mlir::ModuleOp::create(builder.getUnknownLoc());

    for (FunctionAST &f : moduleAST)  // AST 是一系列 Function 的集合，包含 main 函数和其调用的函数，对这些函数构建 mlir

      mlirGen(f);

    // Verify the module after we have finished constructing it, this will check

    // the structural properties of the IR and invoke any specific verifiers we

    // have on the Toy operations.

    if (failed(mlir::verify(theModule))) {

      theModule.emitError("module verification error");

      return nullptr;

    }

    return theModule;  // 构建完成 的 toy dialect

  }

/// Emit a new function and add it to the MLIR module.

  mlir::toy::FuncOp mlirGen(FunctionAST &funcAST) {

    // Create a scope in the symbol table to hold variable declarations.

    ScopedHashTableScope<llvm::StringRef, mlir::Value> varScope(symbolTable);

    // Create an MLIR function for the given prototype.

    builder.setInsertionPointToEnd(theModule.getBody());

    mlir::toy::FuncOp function = mlirGen(*funcAST.getProto());  // 深度递归地构建 原型 部分

    if (!function)

      return nullptr;

    // Let's start the body of the function now!

    mlir::Block &entryBlock = function.front();

    auto protoArgs = funcAST.getProto()->getArgs();

    // Declare all the function arguments in the symbol table.

    for (const auto nameValue :

         llvm::zip(protoArgs, entryBlock.getArguments())) {

      if (failed(declare(std::get<0>(nameValue)->getName(),

                         std::get<1>(nameValue))))

        return nullptr;

    }

    // Set the insertion point in the builder to the beginning of the function

    // body, it will be used throughout the codegen to create operations in this

    // function.

    builder.setInsertionPointToStart(&entryBlock);  

    // Emit the body of the function.

    if (mlir::failed(mlirGen(*funcAST.getBody()))) {  // 深度递归地构建 躯干 部分

      function.erase();

      return nullptr;

    }

    // Implicitly return void if no return statement was emitted.

    // FIXME: we may fix the parser instead to always return the last expression

    // (this would possibly help the REPL case later)

    ReturnOp returnOp;

    if (!entryBlock.empty())

      returnOp = dyn_cast<ReturnOp>(entryBlock.back());

    if (!returnOp) {

      ReturnOp::create(builder, loc(funcAST.getProto()->loc()));

    } else if (returnOp.hasOperand()) {

      // Otherwise, if this return operation has an operand then add a result to

      // the function.

      function.setType(builder.getFunctionType(

          function.getFunctionType().getInputs(), getType(VarType{})));

    }

    // If this function isn't main, then set the visibility to private.

    if (funcAST.getProto()->getName() != "main")

      function.setPrivate();

    return function;

  }

/// This is a reference to a variable in an expression. The variable is

  /// expected to have been declared and so should have a value in the symbol

  /// table, otherwise emit an error and return nullptr.

  mlir::Value mlirGen(VariableExprAST &expr) {  // 递归到了底层表达式

    if (auto variable = symbolTable.lookup(expr.getName()))

      return variable;

    emitError(loc(expr.loc()), "error: unknown variable '")

        << expr.getName() << "'";

    return nullptr;

  }

// Provide a definition of the 'toy' dialect in the ODS framework so that we

// can define our operations.

def Toy_Dialect : Dialect {  // 方言名称为 toy 

  let name = "toy";

  let cppNamespace = "::mlir::toy";

}

// Base class for toy dialect operations. This operation inherits from the base

// `Op` class in OpBase.td, and provides:

//   * The parent dialect of the operation.

//   * The mnemonic for the operation, or the name without the dialect prefix.

//   * A list of traits for the operation.

class Toy_Op<string mnemonic, list<Trait> traits = []> :

  // 有名称 mnemonic 和 traits 特性列表两个参数，分别指明自己的名称和特性

    Op<Toy_Dialect, mnemonic, traits>;  //

// We define a toy operation by inheriting from our base 'Toy_Op' class above.

// Here we provide the mnemonic and a list of traits for the operation. The

// constant operation is marked as 'Pure' as it is a pure operation

// and may be removed if dead.

def ConstantOp : Toy_Op<"constant", [Pure]> {

  // Provide a summary and description for this operation. This can be used to

  // auto-generate documentation of the operations within our dialect.

  let summary = "constant";

  let description = [{

    Constant operation turns a literal into an SSA value. The data is attached

    to the operation as an attribute. For example:

    ```mlir

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

                        : tensor<2x3xf64>

    ```

  }];

  // The constant operation takes an attribute as the only input.

  let arguments = (ins F64ElementsAttr:$value);  // 声明输入，ins 表示输入，F64ElementsAttr 表示类型，$value 表示名称

  // The constant operation returns a single value of TensorType.

  let results = (outs F64Tensor);

 // 声明输出， outs 表示输出， F64Tensor 表示类型。ConstantOp 产生一个 F64Tensor 类型的值

  // Indicate that the operation has a custom parser and printer method.

  let hasCustomAssemblyFormat = 1;

  // Add custom build methods for the constant operation. These method populates

  // the `state` that MLIR uses to create operations, i.e. these are used when

  // using `ConstantOp::create(builder, ...)`.

  let builders = [

    // Build a constant with a given constant tensor value.

    OpBuilder<(ins "DenseElementsAttr":$value), [{

      build($_builder, $_state, value.getType(), value);

    }]>,

    // Build a constant with a given constant floating-point value.

    OpBuilder<(ins "double":$value)>

  ];

  // Indicate that additional verification for this operation is necessary.

  let hasVerifier = 1;

}

//td 定义

def ConstantOp : Toy_Op<"constant", [Pure]>  

// 会生成类似的代码

class ConstantOp : public Op<...> { ... };  // 定义该操作

static StringRef getOperationName() { return "toy.constant"; }  // 获取该操作的名字

//td 定义

let arguments = (ins F64ElementsAttr:$value);

// 会生成类似的代码

DenseElementsAttr getValue();  // 获取输入

void setValue(DenseElementsAttr newValue);  // 设置输入

//td 定义

let results = (outs F64Tensor);

// 会生成类似的代码

Type getType();

void setType(Type newType);

OpBuilder<(ins "double":$value)>

  // OpBuilder<(ins "double":$value)> 生成的

  static void build(::mlir::OpBuilder &odsBuilder,::mlir::OperationState &odsState, double value);  // 定义生成的 build

  static ConstantOp create(::mlir::OpBuilder &builder, ::mlir::Location location, double value);

  //create 调用 build

  static ConstantOp create(::mlir::ImplicitLocOpBuilder &builder, double value);  

  // 位于 Dialect.cpp

  /// Build a constant operation.

/// The builder is passed as an argument, so is the state that this method is

/// expected to fill in order to build the operation.

void ConstantOp::build(mlir::OpBuilder &builder, mlir::OperationState &state,

                       double value) {

  auto dataType = RankedTensorType::get({}, builder.getF64Type());

  auto dataAttribute = DenseElementsAttr::get(dataType, value);

  ConstantOp::build(builder, state, dataType, dataAttribute);

}

// Indicate that the operation has a custom parser and printer method.

  let hasCustomAssemblyFormat = 1;

  // Indicate that additional verification for this operation is necessary.

  let hasVerifier = 1;

/// The 'OpAsmPrinter' class is a stream that allows for formatting

/// strings, attributes, operands, types, etc.

void ConstantOp::print(mlir::OpAsmPrinter &printer) {

  printer << " ";

  printer.printOptionalAttrDict((*this)->getAttrs(), /*elidedAttrs=*/{"value"});

  printer << getValue();

}

/// Verifier for the constant operation. This corresponds to the

/// `let hasVerifier = 1` in the op definition.

llvm::LogicalResult ConstantOp::verify() {

  // If the return type of the constant is not an unranked tensor, the shape

  // must match the shape of the attribute holding the data.

  auto resultType =

      llvm::dyn_cast<mlir::RankedTensorType>(getResult().getType());

  if (!resultType)

    return success();

  // Check that the rank of the attribute type matches the rank of the constant

  // result type.

  auto attrType = llvm::cast<mlir::RankedTensorType>(getValue().getType());

  if (attrType.getRank() != resultType.getRank()) {

    return emitOpError("return type must match the one of the attached value "

                       "attribute: ")

           << attrType.getRank() << " != " << resultType.getRank();

  }

  // Check that each of the dimensions match between the two types.

  for (int dim = 0, dimE = attrType.getRank(); dim < dimE; ++dim) {

    if (attrType.getShape()[dim] != resultType.getShape()[dim]) {

      return emitOpError(

                 "return type shape mismatches its attribute at dimension ")

             << dim << ": " << attrType.getShape()[dim]

             << " != " << resultType.getShape()[dim];

    }

  }

  return mlir::success();

}