LegalizeHashTableImportOpPattern, LegalizeHashTableSizeOpPattern>(
            &getContext());
    if (failed(applyPatternsAndFoldGreedily(module, std::move(patterns)))) {
      signalPassFailure();
      return;
    }
  }
};

}  // namespace

std::unique_ptr<OperationPass<ModuleOp>> CreateLegalizeHashTablesPass() {
  return std::make_unique<LegalizeHashTablesPass>();
}

    patterns.add<FuseMhloMulAndConvolutionPattern>(&getContext());
    if (failed(applyPatternsAndFoldGreedily(getOperation(),
                                            std::move(patterns)))) {
      return signalPassFailure();
    }
  }
};

std::unique_ptr<Pass> createFuseConvolutionPass() {
  return std::make_unique<FuseMhloConvolutionPass>();
}

static PassRegistration<FuseMhloConvolutionPass> pass;

void LiftHashTableOpsAsArgsPass::runOnOperation() {
  auto module_op = getOperation();

  for (auto func_op : module_op.getOps<func::FuncOp>()) {
    if (failed(LiftHashTableOpsToArguments(module_op, func_op))) {
      signalPassFailure();
      return;
    }
  }
}

static PassRegistration<LiftHashTableOpsAsArgsPass> pass;

}  // namespace

std::unique_ptr<OperationPass<ModuleOp>> CreateLiftHashTableOpsAsArgsPass() {

  patterns.add<PrepareQuantStats>(bit_width, false, true,
                                  /*legacy_float_scale=*/false, ctx);
  if (failed(applyPatternsAndFoldGreedily(func, std::move(patterns)))) {
    signalPassFailure();
  }

  SanityCheckAndAdjustment(func);

  // Finally, the quantization parameters can be propagated to the rest of the
  // values (tensors).
  ApplyQuantizationParamsPropagation(

void ReplicateToIslandPass::runOnOperation() {
  const Dialect* tf_dialect = getContext().getLoadedDialect("tf");
  if (!tf_dialect) {
    getOperation().emitError() << "'tf' dialect is not registered";
    return signalPassFailure();
  }

  // Find islands with a single `tf_device.replicate` and create individual
  // islands per replica of the replicate.
  llvm::SmallVector<tf_executor::IslandOp, 4> replicate_op_islands;

  RewritePatternSet patterns(ctx);
  patterns.add<TransposeCommuteWithPad, TransposeCommuteWithReduceWindow>(ctx);
  if (failed(
          applyPatternsAndFoldGreedily(getOperation(), std::move(patterns)))) {
    return signalPassFailure();
  }
}

}  // end namespace

std::unique_ptr<OperationPass<ModuleOp>> CreateTransposeCommuteOpsPass() {
  return std::make_unique<TransposeCommuteOpsPass>();
}

  patterns.add<FoldTransposedConstantOp>(&ctx);
  if (failed(applyPatternsAndFoldGreedily(func_op, std::move(patterns)))) {
    func_op.emitError("Failed to fold constant->transpose pattern.");
    signalPassFailure();
  }
}

    if (failed(applyPatternsAndFoldGreedily(func, frozen_patterns))) {
      func.emitError()
          << "quant-lift-quantizable-spots-as-functions-drq failed.";
      signalPassFailure();
    }
  }
}

}  // namespace

std::unique_ptr<OperationPass<ModuleOp>>
CreateLiftQuantizableSpotsAsFunctionsDRQPass(
    const QuantMethod quantization_method, const OpSet target_opset,

  // Get runtime devices information from the closest parent module.
  auto module = getOperation();
  mlir::TF::RuntimeDevices devices;
  if (failed(tensorflow::GetDevicesFromOp(module, &devices)))
    return signalPassFailure();

  OpBuilder builder(&getContext());
  llvm::SmallVector<mlir::tf_device::ClusterOp, 4> clusters;
  module.walk(
      [&](mlir::tf_device::ClusterOp cluster) { clusters.push_back(cluster); });

                    ml_program::MLProgramDialect>();
  }

  void runOnOperation() override {
    if (failed(convertTFGlobals(getOperation()))) {
      signalPassFailure();
    }
  }
};

std::unique_ptr<Pass> CreateLowerGlobalsToMlProgramPass() {
  return std::make_unique<LowerGlobalsToMlProgram>();
}

void RegisterLowerGlobalsToMlProgramPass() {