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());

    TF_ASSERT_OK_AND_ASSIGN(module_,
                            GetMlirModuleFromString(module_string, &context_));

    pm_ = std::make_unique<mlir::PassManager>(&context_);
    pm_->addNestedPass<func::FuncOp>(
        CreateVerifyNoOutsideCompilationMarkersPass());
  }

  mlir::LogicalResult Run() { return pm_->run(module_.get()); }

 private:
  MLIRContext context_;
  OwningOpRef<ModuleOp> module_;

    TF_ASSERT_OK_AND_ASSIGN(module_,
                            GetMlirModuleFromString(module_string, &context_));
    pm_ = std::make_unique<mlir::PassManager>(&context_);
    pm_->addNestedPass<mlir::func::FuncOp>(CreateInputLoweringMetricsPass());
  }

  bool ModulesEqual(const ModuleOp& module_before,
                    const ModuleOp& module_after) {
    return mlir::OperationEquivalence::isEquivalentTo(

    context_.appendDialectRegistry(mlir_registry);
    TF_ASSERT_OK(
        tensorflow::DeserializeMlirModule(module_string, &context_, &module_));

    pm_ = std::make_unique<mlir::PassManager>(&context_);
    pm_->addNestedPass<mlir::func::FuncOp>(
        quant::stablehlo::CreateConvertTFQuantTypesPass());
  }
  mlir::LogicalResult Run() { return pm_->run(module_.get()); }

 private:
  MLIRContext context_;

      mlir::stablehlo::deserializePortableArtifact(serialized_stablehlo_module,
                                                   &context);

  // Convert the StableHLO module to bfloat16.
  PassManager pm(&context);
  pm.addNestedPass<func::FuncOp>(createConvertFuncToBfloat16Pass());
  if (failed(pm.run(stablehlo_module_op.get()))) {
    return absl::InternalError(
        "Failed to convert StableHLO module to bfloat16.");
  }

    // For XLA case, weight quantization will be applied for the remaining f32
    // weights even in SRQ.
    pm.addNestedPass<func::FuncOp>(
        CreatePrepareQuantizePass(quant_specs, quantization_method_));
    pm.addNestedPass<func::FuncOp>(
        CreateQuantizePass(quant_specs, target_opset_));
    pm.addNestedPass<func::FuncOp>(CreatePostQuantizePass());
  } else {
    // Apply weight quantization.

    TF_ASSERT_OK_AND_ASSIGN(module_,
                            GetMlirModuleFromString(module_string, &context_));

    pm_ = std::make_unique<mlir::PassManager>(&context_);
    pm_->addNestedPass<mlir::func::FuncOp>(
        mlir::mhlo::CreateVerifyTFXLALegalizationPass(/*legalize_chlo=*/false));
  }
  mlir::LogicalResult Run() { return pm_->run(module_.get()); }

 private:
  MLIRContext context_;

  // 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.");
  }

namespace {

void CreateReplicatedBridgePipelineV1(OpPassManager &pm) {
  pm.addPass(mlir::tf2xla::internal::CreateInferenceMetricsPass());

  // Convert to unified compilation and replication attributes.
  pm.addNestedPass<FuncOp>(
      mlir::TF::CreateCanonicalizeCompileAndReplicateAttributesPass());
  // Guarantee all functions have one use, which enables more exact shape
  // inference.