connection between an [Encoder] and [Decoder], it is assigned a signed integer type
id. When [Encoder.Encode](v) is called, it makes sure there is an id assigned for
the type of v and all its elements and then it sends the pair (typeid, encoded-v)
where typeid is the type id of the encoded type of v and encoded-v is the gob
encoding of the value v.

To define a type, the encoder chooses an unused, positive type id and sends the

        "The output variant hasn't been initialized");
  }

  if (a.TypeId() != b.TypeId()) {
    return ::tensorflow::errors::Internal(
        "BinaryOpVariants: Variants a and b have different "
        "type ids.  Type names: '",
        a.TypeName(), "' vs. '", b.TypeName(), "'");
  }

  if (a.TypeId() == tensorflow::TypeIndex::Make<::tensorflow::TensorList>()) {

#include "tensorflow/compiler/mlir/tensorflow/ir/tpu_embedding_ops_registry.h"

#include <vector>

namespace mlir {
namespace TF {

const llvm::SmallDenseSet<mlir::TypeID>&
TPUEmbeddingOpsRegistry::GetOpsTypeIds() {
  return ops_type_ids_;
}

// static
TPUEmbeddingOpsRegistry& TPUEmbeddingOpsRegistry::Global() {
  static TPUEmbeddingOpsRegistry* registry = new TPUEmbeddingOpsRegistry;

           kCrossHardwareTransferFixedCost;
  }

  mlir::RewritePatternSet GetTransformations(
      MLIRContext* context) const override {
    return {context};
  }

  mlir::TypeID GetTypeId() const override {
    return mlir::TypeID::get<CpuHardware>();
  }

  bool IsOpSupported(mlir::Operation* op) const override {
    // All ops in TFL dialect are supported on CPU.
    if (op->getDialect() == nullptr) return false;

// TfrtDelegate Dialect
//===----------------------------------------------------------------------===//

RuntimeFallbackDialect::RuntimeFallbackDialect(MLIRContext *context)
    : Dialect(/*name=*/"tfd", context, TypeID::get<RuntimeFallbackDialect>()) {
  allowUnknownTypes();

  allowUnknownOperations();

  addOperations<
#define GET_OP_LIST
#include "tensorflow/compiler/mlir/tfrt/runtime_fallback_ops.cc.inc"
      >();
}

    patterns.add<LowerPackIntoConcatReshape, UnrollSplit, UnrollSplitV,
                  PadSlice>(context);
    return patterns;
  }

  mlir::TypeID GetTypeId() const override {
    return mlir::TypeID::get<FooHardware>();
  }

  // We can specify what ops are not supported here.
  bool IsNotSupportedOp(mlir::Operation* op) const override { return false; }

#include "tensorflow/compiler/mlir/tfrt/ir/tfrt_fallback.h"

namespace tfrt {
namespace gpu {

GpuRuntimeDialect::GpuRuntimeDialect(MLIRContext *context)
    : Dialect(/*name=*/"gpurt", context, TypeID::get<GpuRuntimeDialect>()) {
  addOperations<
#define GET_OP_LIST
#include "tensorflow/compiler/mlir/tfrt/ir/gpu_ops.cpp.inc"
      >();
}

}  // namespace gpu
}  // namespace tfrt

#include <utility>

#include "mlir/IR/MLIRContext.h"  // from @llvm-project
#include "mlir/IR/PatternMatch.h"  // from @llvm-project
#include "mlir/Support/LogicalResult.h"  // from @llvm-project
#include "mlir/Support/TypeID.h"  // from @llvm-project
#include "mlir/Transforms/GreedyPatternRewriteDriver.h"  // from @llvm-project
#include "tensorflow/compiler/mlir/quantization/stablehlo/passes/passes.h"
#include "xla/mlir_hlo/mhlo/transforms/rewriters.h"

namespace tensorflow {
namespace tf_mlrt_tpu {

TensorflowMlrtTpuDialect::TensorflowMlrtTpuDialect(mlir::MLIRContext *context)
    : mlir::Dialect(/*name=*/"tf_mlrt_tpu", context,
                    mlir::TypeID::get<TensorflowMlrtTpuDialect>()) {
  addOperations<
#define GET_OP_LIST
#include "tensorflow/compiler/mlir/tfrt/ir/mlrt/tf_mlrt_tpu_ops.cpp.inc"
      >();
}

}  // namespace tf_mlrt_tpu

#include <utility>

#include "mlir/IR/PatternMatch.h"  // from @llvm-project
#include "mlir/Support/LogicalResult.h"  // from @llvm-project
#include "mlir/Support/TypeID.h"  // from @llvm-project
#include "mlir/Transforms/GreedyPatternRewriteDriver.h"  // from @llvm-project
#include "stablehlo/dialect/StablehloOps.h"  // from @stablehlo  // IWYU pragma: keep