"the attribute `tf._noinline = true`. This attributes the function "
           "from being inlined by the `InlinerPass`.";
  }

  void runOnOperation() override;

 private:
  ListOption<std::string> CreateNoinlineFunctionsOption(
      const ArrayRef<std::string> noinline_functions) {
    return {*this, "noinline-functions",
            llvm::cl::desc(

#include "tensorflow/compiler/mlir/tensorflow/transforms/tf_savedmodel_passes.h.inc"

struct StripSavedModuleMetadataPass
    : public impl::StripSavedModuleMetadataPassBase<
          StripSavedModuleMetadataPass> {
  void runOnOperation() override;
};

bool ShouldStripAttr(NamedAttribute &namedAttr) {
  auto name = namedAttr.getName().strref();
  return name.starts_with("tf_saved_model.");
}

void StripModule(Operation *module) {

#define GEN_PASS_DEF_STRIPTFATTRIBUTESPASS
#include "tensorflow/compiler/mlir/tensorflow/transforms/tf_passes.h.inc"

struct StripTfAttributesPass
    : public impl::StripTfAttributesPassBase<StripTfAttributesPass> {
  void runOnOperation() override;
};

bool ShouldStripAttr(NamedAttribute &namedAttr) {
  StringRef name = namedAttr.getName().strref();
  if (name.starts_with("tf.") || name.starts_with("tf_")) return true;

 public:
  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(OrderByDialectPass)
  void runOnOperation() override;
};

int DialectOrdering(Operation* predecessor, Operation* op) {
  return predecessor && predecessor->getName().getDialectNamespace() ==
                            op->getName().getDialectNamespace();
}

void OrderByDialectPass::runOnOperation() {
  ModuleOp module = getOperation();

struct ConvertSessionInitializerToFunctionPass
    : public impl::ConvertSessionInitializerToFunctionPassBase<
          ConvertSessionInitializerToFunctionPass> {
  void runOnOperation() override;
};

void ConvertSessionInitializerToFunctionPass::runOnOperation() {
  ModuleOp module = getOperation();
  auto session_initializer = tf_saved_model::GetSessionInitializerOp(module);
  if (!session_initializer) return;

    : public impl::TestTFToStablehloPassBase<TestTFToStablehloPass> {
 public:
  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(TestTFToStablehloPass)

 private:
  void runOnOperation() override;
};

void TestTFToStablehloPass::runOnOperation() {
  ModuleOp module_op = getOperation();
  MLIRContext* ctx = &getContext();
  mlir::PassManager pm(ctx);

  AddTFToStablehloPasses(pm);
  if (!RunPassesOnModuleOp(

    return "Suitable transformation for gpu only.";
  }
  void getDependentDialects(DialectRegistry& registry) const override {
    registry.insert<TF::TensorFlowDialect>();
  }
  void runOnOperation() override;
};

void DeviceTransformGPUPass::runOnOperation() {
  auto func = getOperation();
  auto* ctx = &getContext();
  RewritePatternSet patterns = GetHardwareRewritePatternsGPU(ctx);

namespace {

#define GEN_PASS_DEF_XLAREWRITEPASS
#include "tensorflow/compiler/mlir/tensorflow/transforms/tf_device_passes.h.inc"

struct XlaRewritePass : public impl::XlaRewritePassBase<XlaRewritePass> {
  void runOnOperation() override;
};

void MoveResourceArgsToEnd(func::FuncOp callee) {
  llvm::DenseMap<BlockArgument, BlockArgument> mapping;
  unsigned num_params = callee.getNumArguments();
  llvm::BitVector removed_params(num_params);

// for CPU or GPU.
struct DeviceIndexSelector
    : public impl::DeviceIndexSelectorPassBase<DeviceIndexSelector> {
  void runOnOperation() override;
};

}  // namespace

void DeviceIndexSelector::runOnOperation() {
  func::FuncOp func = getOperation();
  // Convert all the DeviceIndex ops to constant values.
  func.getBody().walk([](TF::DeviceIndexOp op) {

  explicit RaiseCustomOpsPass() {}
  explicit RaiseCustomOpsPass(const std::vector<std::string> &target_ops) {
    this->target_ops_ = target_ops;
  }

  void runOnOperation() override;
};

void RaiseCustomOpsPass::runOnOperation() {
  auto fn = getOperation();
  OpBuilder builder(fn.getContext());

  absl::flat_hash_set<std::string> target_op_names(target_ops_.begin(),