// on TPU.

  // Optimizes TF graph via cleanups, merges, rewrites, constant folding,
  // and edge case handling where possible.
  pm.addNestedPass<func::FuncOp>(TF::CreateDropWhileShapeInvariantPass());
  pm.addNestedPass<func::FuncOp>(
      tf_executor::CreateTFExecutorGraphPruningPass());
  pm.addNestedPass<func::FuncOp>(
      tf_executor::CreateTFExecutorIslandCoarseningPass());
  pm.addPass(TF::CreateTFFunctionalControlFlowToRegions());

  pm.addNestedPass<func::FuncOp>(mhlo::createMhloQuantLegalizeToIntPass());
  pm.addNestedPass<func::FuncOp>(createCanonicalizerPass());
  // Integer graph optimization relies on chlo broadcast ops for easier handling
  // of dynamic shapes. Therefore we lower chlo ops after optimization.
  pm.addNestedPass<func::FuncOp>(CreateOptimizeIntGraphPass());
  pm.addNestedPass<func::FuncOp>(mhlo::createChloLegalizeToHloPass());

  // First, we need to convert from functional, to executor dialect.
  pm.addNestedPass<FuncOp>(
      mlir::CreateFunctionalToExecutorDialectConversionPass());

  // Do a single pass to split the graph's single island op into an island per
  // op as expected by the following passes.
  pm.addNestedPass<FuncOp>(mlir::TF::CreateSplitIntoIslandPerOpPass());

  pm.addNestedPass<FuncOp>(mlir::TFDevice::CreateReplicateToIslandPass(

  pm.addPass(mlir::createSymbolDCEPass());
  pm.addNestedPass<FuncOp>(
      mlir::TFDevice::CreateReplicateInvariantOpHoistingPass());
  pm.addNestedPass<FuncOp>(mlir::TFDevice::CreateEmbeddingProgramKeyPass());
  pm.addPass(mlir::TFTPU::CreateTPUMergeVariablesWithExecutePass());
  pm.addNestedPass<FuncOp>(
      mlir::TFTPU::CreateExtractTPUCopyWithDynamicShapeOpPass());
  pm.addNestedPass<FuncOp>(

  // Change this to user-given bit width once we have custom configuration.
  options.bit_width_ = 8;

  // Insert quantization parameters for weights for ops with `weight_only_ptq`
  // attribute.
  pm.addNestedPass<func::FuncOp>(createInsertWeightParamPass());

  // PrepareQuantizePass uses SymbolTable to fetch relevant GEMM ops for
  // determining quantization attributes. This requires module-level context.

  pm.addPass(CreateTFShapeInferencePass());
  if (options.enable_inliner) {
    pm.addPass(createInlinerPass());
  }
  pm.addPass(createSymbolDCEPass());
  pm.addNestedPass<func::FuncOp>(CreateTFOptimizePass());
  pm.addNestedPass<func::FuncOp>(createCSEPass());
}

std::unique_ptr<OperationPass<func::FuncOp>> CreateTFOptimizePass() {
  return std::make_unique<TensorFlowOptimizePass>();
}

  ::tensorflow::applyTensorflowAndCLOptions(pm);

  // Run island coarsening before shape inference to allow more exact shape
  // inference using constant folding within islands.
  pm.addNestedPass<func::FuncOp>(
      tf_executor::CreateTFExecutorIslandCoarseningPass());
  pm.addPass(CreateTFShapeInferencePass());

  // Assign optimal data layout to layout sensitive operations and delete

  TF_ASSERT_OK(env_->GetChildren(test_dir_, &files));
  EXPECT_THAT(files, ::testing::IsEmpty());

  TF_ASSERT_OK(CreateMlirModule("dead_const.mlir"));
  PassManager pass_manager(&context_);
  pass_manager.addNestedPass<FuncOp>(mlir::createCanonicalizerPass());

  EnablePassIRPrinting(pass_manager, test_group_name_);

  LogicalResult pass_status = pass_manager.run(mlir_module_.get());
  EXPECT_TRUE(pass_status.succeeded());

  // by aligning with the TF/XLA bridge on the corresponding functionality and
  // reusing their work, perhaps through `LowerToMlProgramAndHlo`.
  pm.addNestedPass<func::FuncOp>(std::make_unique<TFToMhloPass>(
      options.skip_quantization_ops, options.skip_resize,
      options.skip_partitioned_calls));
  pm.addPass(mlir::createCanonicalizerPass());

                                             /*skip_resize=*/false,
                                             /*skip_partitioned_calls=*/false);
  pm.addNestedPass<mlir::func::FuncOp>(
      mlir::quant::stablehlo::createRemoveShardingCustomCallPass());
  if (failed(pm.run(module_op))) {
    return absl::InternalError("Failed to run legalize TF to StableHLO.");
  }