void PrintPass::runOnOperation() {
  llvm::sys::SmartScopedLock<true> instrumentationLock(mutex_);
  OpPrintingFlags flags =
      OpPrintingFlags().elideLargeElementsAttrs().enableDebugInfo(false);
  getOperation()->print(*os_, flags);
}
}  // namespace

std::unique_ptr<OperationPass<ModuleOp>> CreatePrintPass(raw_ostream* os) {
  return std::make_unique<PrintPass>(os);
}

}  // namespace TF

std::string SerializeMlirModule(mlir::ModuleOp module_op) {
  std::string serialized_mlir_module;
  llvm::raw_string_ostream os(serialized_mlir_module);
  mlir::OpPrintingFlags print_flags;
  print_flags.enableDebugInfo();
  module_op.print(os, print_flags);
  return std::move(os.str());
}

Status DeserializeMlirModule(llvm::StringRef serialized_mlir_module,
                             mlir::MLIRContext* mlir_context,

};

}  // namespace

void EnableIrPrinting(mlir::PassManager& pm,
                      absl::string_view file_name_prefix) {
  mlir::OpPrintingFlags flag{};
  flag.useLocalScope().elideLargeElementsAttrs().enableDebugInfo();

  // IR printing requires multithreading disabled.
  // Even if multithreading is already disabled, if we are executing within a
  // pass-manager,  disableMultithreading throws assertion fail. Below if

  }

  // Export StableHLO MLIR as output
  std::string result;
  llvm::raw_string_ostream os(result);
  OpPrintingFlags printing_flags;
  if (debug_info) {
    printing_flags.enableDebugInfo();
  }
  if (elide_large_elements_attrs) {
    printing_flags.elideLargeElementsAttrs();
  }
  module.print(os, printing_flags);
  os.flush();

  output->os() << result;
  output->keep();

    module.print(os, flags);
  }
  return txt_module;
}

std::string MlirModuleToString(mlir::ModuleOp module, bool show_debug_info) {
  mlir::OpPrintingFlags flags;
  if (show_debug_info) flags.enableDebugInfo();
  return MlirModuleToString(module, flags);
}