const auto str_attr = cast<DenseStringElementsAttr>(const_value);

  // Sum the sizes of each string.
  return absl::c_accumulate(
      str_attr.getRawStringData(), 0,
      [](int64_t acc, const StringRef str_value) -> int64_t {
        return acc + str_value.size();
      });
}

// Arbitrarily calculate the size of const of type whose size is unkown or
// varying. Each element of such a type is considered to have

#include "mlir/Pass/Pass.h"  // from @llvm-project
#include "mlir/Pass/PassManager.h"  // from @llvm-project

namespace mlir {
namespace quant {

using OperationToName = std::function<llvm::StringRef(Operation* op)>;

// Creates an instance pass to import quantization stats to the operations in
// the function. A custom method to get the name from the op is used because

// will be returned.
// Note, caller is responsible for Unref the variable.
tensorflow::Var* GetVariableFromSession(mlir::TF::VarHandleOp var_handle_op,
                                        llvm::StringRef device_name,
                                        const tensorflow::DeviceMgr* mgr);

// Returns resource tensors from session for all variables in '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,
                             mlir::OwningOpRef<mlir::ModuleOp>* mlir_module) {
  TF_RET_CHECK(!serialized_mlir_module.empty())

// instantiated by the process_function_library_runtime (see
// FunctionOptimizationPass for details).
class MlirOptimizationPass {
 public:
  virtual ~MlirOptimizationPass() = default;
  virtual llvm::StringRef name() const = 0;

  // Returns an enum value:
  //   Enabled if the pass is enabled for the given graph with specified config.
  //   Disabled if the pass is disabled.

      .def("getNumResults", &mlir::Operation::getNumResults);

  py::class_<mlir::OperationState>(m, "OperationState")
      .def(py::init([](mlir::Location loc, std::string name) {
        return mlir::OperationState(loc, llvm::StringRef(name));
      }))
      .def("addTypes",
           [](mlir::OperationState& state, std::vector<mlir::Type> tys) {
             state.addTypes(mlir::ArrayRef<mlir::Type>(tys));
           })
      .def("addOperands",

#define GET_OP_LIST
#include "tensorflow/compiler/mlir/tfrt/ir/tfrt_fallback.cpp.inc"
      >();
}

/// Parse a type registered to this dialect.
Type FallbackDialect::parseType(DialectAsmParser &parser) const {
  StringRef keyword;
  if (parser.parseKeyword(&keyword)) return Type();

  if (keyword == "tf_tensor") return TFTensorType::get(getContext());
  if (keyword == "tf_allocator") return TFAllocatorType::get(getContext());

    return success();
  }
};

class FuseMhloConvolutionPass
    : public PassWrapper<FuseMhloConvolutionPass, OperationPass<func::FuncOp>> {
 public:
  StringRef getArgument() const final { return "fuse-mhlo-convolution-pass"; }
  StringRef getDescription() const final {
    return "Fuses MHLO binary element-wise ops and convolution op";
  }

  void runOnOperation() override {

#include "mlir/IR/OpImplementation.h"  // from @llvm-project

namespace mlrt {
namespace compiler {

class MlrtDialect : public mlir::Dialect {
 public:
  explicit MlrtDialect(mlir::MLIRContext *context);
  static llvm::StringRef getDialectNamespace() { return "mlrt"; }

  mlir::Type parseType(mlir::DialectAsmParser &parser) const override;
  void printType(mlir::Type type, mlir::DialectAsmPrinter &os) const override;
};

// pass later to transform them into Compile/Run op pairs, like XlaCompile and
// XlaRun.
class TensorFlowDeviceDialect : public Dialect {
 public:
  static StringRef getDialectNamespace() { return "tf_device"; }
  // Constructing TensorFlowDevice dialect under an non-null MLIRContext.
  explicit TensorFlowDeviceDialect(MLIRContext* context);
};

}  // namespace tf_device