void runOnOperation() override {
    ModuleOp op = this->getOperation();
    DerivedT& derived = *static_cast<DerivedT*>(this);
    auto& analysis = this->template getAnalysis<AnalysisT>();

    for (auto func : op.getOps<func::FuncOp>())
      if (!func.isExternal())
        derived.runOnFunction(func, analysis.GetAnalysisForFunc(func));
  }
};

}  // namespace TF
}  // namespace mlir

  }
}

void ForEachArgConsumedByFallback(
    mlir::ModuleOp module,
    llvm::function_ref<void(llvm::StringRef func_name, int arg_index)> action) {
  for (auto func : module.getOps<mlir::func::FuncOp>()) {
    ForEachArgConsumedByFallback(
        func, [func_name = func.getName(), action](int arg_index) {
          action(func_name, arg_index);
        });
  }
}

    builder.create<YieldOp>(island_op.getLoc(), yield_operands);
  }

  // Outline all the transitively called functions by moving them in the
  // outlined module.
  for (func::FuncOp func : outlined_module.getOps<func::FuncOp>()) {
    func.walk([&](Operation *op) {
      for (NamedAttribute attr : op->getAttrs()) {
        if (auto symbol_ref =
                mlir::dyn_cast<FlatSymbolRefAttr>(attr.getValue())) {

void FreezeAssetsPass::runOnOperation() {
  auto module = getOperation();
  if (!tf_saved_model::HasTfSavedModelSemantics(module)) {
    return;
  }
  SymbolTable symbol_table(module);

  for (auto func : module.getOps<func::FuncOp>()) {
    llvm::BitVector args_to_erase(func.getNumArguments());
    OpBuilder builder(func.getBody());

    for (int i = 0, e = func.getNumArguments(); i < e; ++i) {

                            op->getName().getDialectNamespace();
}

void OrderByDialectPass::runOnOperation() {
  ModuleOp module = getOperation();
  for (func::FuncOp func : module.getOps<func::FuncOp>()) {
    std::vector<std::pair<Operation*, Operation*>> side_effect_data;
    const detail::SideEffectAnalysisInfo* info = nullptr;
    auto extra_dependencies =
        [&](Operation* op,

  FailureOr<OpT> FindFirstOpFromMainFunc(ModuleOp module_op) {
    func::FuncOp main_func_op = FindMainFuncOp(module_op);
    if (main_func_op == nullptr) return failure();

    auto ops = main_func_op.getOps<OpT>();
    if (ops.empty()) return failure();

    return *ops.begin();
  }

  std::unique_ptr<MLIRContext> ctx_;
  OpBuilder builder_;
};

}  // namespace mlir::quant

    return "Compute the total cost for each available subgraph.";
  }
  void runOnOperation() override;
};

void ComputeCostPass::runOnOperation() {
  auto module = getOperation();

  for (auto func : module.getOps<func::FuncOp>()) {
    // We only care about those functions annotated with "tac.interface_name".
    auto interface_name = GetInterFaceName(func);
    if (!interface_name.has_value()) continue;

  // Move all remaining nested functions back into the parent module.
  Block &nested_block = nested_module->getRegion(0).front();
  for (func::FuncOp func_op :
       llvm::make_early_inc_range(nested_block.getOps<func::FuncOp>())) {
    if (!symbol_table.lookupSymbolIn(getOperation(), func_op.getName())) {
      nested_block.getOperations().remove(func_op.getOperation());
      symbol_table.insert(func_op.getOperation());
    }
  }

      init_func_op.emitError("expects exactly one block in the MLIR function");
      return signalPassFailure();
    }

    auto var_handle_ops =
        init_func_op.getBlocks().front().getOps<VarHandleOp>();
    llvm::SmallVector<VarHandleOp, 4> init_vars(var_handle_ops.begin(),
                                                var_handle_ops.end());
    RemoveVariables(init_vars);
  }
}

}  // namespace

      }
    }
  }
}

void AddFunctionsForExportedNamesPass::runOnOperation() {
  Block& module_body = getOperation().getRegion().front();
  for (auto f :
       llvm::make_early_inc_range(getOperation().getOps<func::FuncOp>())) {
    auto exported_names = GetExportedNames(f);
    if (exported_names.empty() || !f.isPublic()) continue;

    if (exported_names.size() == 1 && exported_names[0] == f.getName()) {