std::string OpAsString(mlir::Operation& op) {
  std::string out;
  llvm::raw_string_ostream op_stream(out);
  op.print(op_stream, mlir::OpPrintingFlags()
                          .elideLargeElementsAttrs()
                          .assumeVerified()
                          .skipRegions()
                          .printGenericOpForm());
  return out;
}

std::string AttrAsString(mlir::Attribute& attr) {

PrintPass::PrintPass(const PrintPass& other) : PrintPass(other.os_) {}

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

  std::string mlir_output;
  llvm::raw_string_ostream output_stream(mlir_output);
  // Dump MLIR with eliding large elements.
  module->print(
      output_stream,
      mlir::OpPrintingFlags().useLocalScope().elideLargeElementsAttrs());
  return mlir_output;
}

    // Tensorflow Graph Dialect
    kTFG,
  };

  // The limit of element size that gets printed.
  MlirDumpConfig& elide_large_attributes(int large_element_limit = 16) {
    this->op_printing_flags.elideLargeElementsAttrs(large_element_limit);
    return *this;
  }

  // Enable printing of debug information. If 'pretty_form' is set to true,
  // debug information is printed in a more readable 'pretty' form but this

namespace tensorflow {

Status CompileTFMLIRToBEF(const TfrtFunctionCompileOptions& options,
                          mlir::ModuleOp module, tfrt::BefBuffer* bef_buffer) {
  mlir::OpPrintingFlags print_flags;
  print_flags.elideLargeElementsAttrs();

  if (VLOG_IS_ON(1)) {
    VLOG(1) << "Input TF Executor dialect:";
    DumpMlirOpToFile("tf_to_tfrt_tf_executor_dialect", module);
  }

  }

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

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

  return absl::OkStatus();
}

}  // namespace
}  // namespace mlir

  }
};

}  // 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

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

  return absl::OkStatus();
}

tensorflow::Status ConvertTFToStableHLO(

    mlir::OpPrintingFlags opPrintingFlags = mlir::OpPrintingFlags();

    if (options.has_elide_elementsattrs_if_larger()) {
      opPrintingFlags.elideLargeElementsAttrs(
          options.elide_elementsattrs_if_larger());
    }

    pm.enableIRPrinting(should_print_ir_before_pass, should_print_ir_after_pass,
                        options.print_ir_module_scope(),