class PassNode : public Object {

 public:

  virtual ~PassNode() {}

   * \brief Get the pass information/meta data. */

  virtual PassInfo Info() const = 0;

  IRModule operator()(IRModule mod) const {  

    return this->operator()(std::move(mod), PassContext::Current());  

  }

  virtual IRModule operator()(IRModule mod, const PassContext& pass_ctx) const = 0; 

  void VisitAttrs(AttrVisitor* v) {}

  static constexpr const char* _type_key = "transform.Pass";

  TVM_DECLARE_BASE_OBJECT_INFO(PassNode, Object);

};

class Pass : public ObjectRef {

 public:

  IRModule operator()(IRModule mod) const;

  IRModule operator()(IRModule mod, const PassContext& pass_ctx) const;

  TVM_DEFINE_OBJECT_REF_METHODS(Pass, ObjectRef, PassNode);

 private:

  IRModule static AssertImmutableModule(const IRModule& mod, const PassNode* node,

                                        const PassContext& pass_ctx);

};

IRModule Pass::operator()(IRModule mod) const {  

  return this->operator()(std::move(mod), PassContext::Current());

}

IRModule Pass::operator()(IRModule mod, const PassContext& pass_ctx) const {  

  const PassNode* node = operator->();

  ICHECK(node != nullptr);

  const PassInfo& pass_info = node->Info();

  if (!pass_ctx.InstrumentBeforePass(mod, pass_info)) {

    DLOG(INFO) << "Skipping pass : " << pass_info->name

               << " with opt level: " << pass_info->opt_level;

    return mod;

  }

  IRModule ret;

  if (pass_ctx->GetConfig<Bool>("testing.immutable_module", Bool(false)).value()) {

    ret = Pass::AssertImmutableModule(mod, node, pass_ctx);

  } else {

    ret = node->operator()(std::move(mod), pass_ctx);

  }

  pass_ctx.InstrumentAfterPass(ret, pass_info);

  return std::move(ret);

}

class FunctionPassNode : public PassNode {

 public:

  PassInfo pass_info;

  runtime::TypedPackedFunc<Function(Function, IRModule, PassContext)> pass_func;  

  FunctionPassNode() = default;

  void VisitAttrs(tvm::AttrVisitor* v) { v->Visit("pass_info", &pass_info); }

  IRModule operator()(IRModule mod, const PassContext& pass_ctx) const final;  

  PassInfo Info() const override { return pass_info; }

  static constexpr const char* _type_key = "relay.FunctionPass";

  TVM_DECLARE_FINAL_OBJECT_INFO(FunctionPassNode, PassNode);

};

IRModule FunctionPassNode::operator()(IRModule mod, const PassContext& pass_ctx) const {  

  DiagnosticContext previous = DiagnosticContext::Default(mod);

  IRModule updated_mod = mod->ShallowCopy();

  std::vector<std::pair<GlobalVar, Function>> updates;

  for (const auto& kv : mod->functions) {  

    if (const auto* function_node = AsOptimizableFunctionNode(kv.second)) {  

      Function updated_func = pass_func(GetRef<Function>(function_node), updated_mod, pass_ctx);  

      updates.push_back({kv.first, std::move(updated_func)});

    }

  }

  return transform::InferType()(updated_mod);

}

 * \brief Module-level passes are designed to implement global

 * analysis/optimizations, i.e. interprocedural optimizations (IPO), etc. Passes

 * at this level have the full control of a given Relay program including

 * addition and deletion of functions.

 */

class ModulePassNode : public PassNode {

 public:

  PassInfo pass_info;

  runtime::TypedPackedFunc<IRModule(IRModule, PassContext)> pass_func;  

  ModulePassNode() = default;

  void VisitAttrs(tvm::AttrVisitor* v) { v->Visit("pass_info", &pass_info); }

  IRModule operator()(IRModule mod, const PassContext& pass_ctx) const final;  

   * \brief Get the pass information/meta data.

   */

  PassInfo Info() const override { return pass_info; }

  static constexpr const char* _type_key = "transform.ModulePass";

  TVM_DECLARE_FINAL_OBJECT_INFO(ModulePassNode, PassNode);

};

IRModule ModulePassNode::operator()(IRModule mod, const PassContext& pass_ctx) const {

  DiagnosticContext previous = DiagnosticContext::Default(mod);

  const PassInfo& pass_info = Info();

  mod = pass_func(std::move(mod), pass_ctx);  

  pass_ctx->diag_ctx.value().Render();

  pass_ctx->diag_ctx = previous;

  return mod;

}

 * \brief The SequentialNode contains a set of passes that transform Relay/Relax

 * programs from one AST to another semantically equivalent one.

 *

 * One example of this level of pass is that the pass manager needs to correctly

 * perform a host of optimizations with a given optimization level and disabled

 * passes.

 */

class SequentialNode : public PassNode {

 public:

  PassInfo pass_info;

  tvm::Array<Pass> passes;  

  PassInfo Info() const override { return pass_info; }

  void ResolveDependency(const IRModule& mod);

  IRModule operator()(IRModule mod, const PassContext& pass_ctx) const final;

  static constexpr const char* _type_key = "transform.Sequential";

  TVM_DECLARE_FINAL_OBJECT_INFO(SequentialNode, PassNode);

};

IRModule SequentialNode::operator()(IRModule mod, const PassContext& pass_ctx) const {

  for (const Pass& pass : passes) {  

    for (const auto& it : pass_info->required) {

      mod = GetPass(it)(std::move(mod), pass_ctx);

    }

    if (pass_ctx->trace_stack.size() && !pass_info->traceable &&

        (!pass_ctx->make_traceable.defined() ||

         pass_ctx->make_traceable.value().count(pass_info->name))) {

      String transform_func_key = "relax.tuning_api.Choice.default_transform_func";

      String constr_func_key = "relax.tuning_api.Choice.default_constr_func";

      relax::Knob knob = relax::Knob(

          pass_info->name, <!--swig0-->);

      auto trace = Downcast<relax::Trace>(pass_ctx->trace_stack.back());

      trace->Add(knob, "Applied");

      mod = pass(std::move(mod), pass_ctx);  

      trace->SetOutMod(mod);

    } else {

      mod = pass(std::move(mod), pass_ctx);  

    }

  }

  return mod;

}