void Cleanup(TF_RandomAccessFile* file);
int64_t Read(const TF_RandomAccessFile* file, uint64_t offset, size_t n,
             char* buffer, TF_Status* status);
}  // namespace tf_random_access_file

namespace tf_writable_file {
void Cleanup(TF_WritableFile* file);
void Append(const TF_WritableFile* file, const char* buffer, size_t n,
            TF_Status* status);
int64_t Tell(const TF_WritableFile* file, TF_Status* status);

#include "mlir/IR/Types.h"  // from @llvm-project
#include "mlir/Support/LogicalResult.h"  // from @llvm-project

namespace mlir {
namespace TF {

LogicalResult VerifyShapeOfReshapeOp(ArrayRef<int64_t> shape) {
  bool has_dynamic_dim = false;
  for (int64_t dim : shape) {
    if (dim != ShapedType::kDynamic) {
      if (dim < 0) return failure();
      continue;
    }
    if (has_dynamic_dim) return failure();
    has_dynamic_dim = true;

  const absl::StatusOr<std::string> checkpoint_prefix = MakeTempDir();
  EXPECT_TRUE(checkpoint_prefix.ok());

  const absl::Cleanup checkpoint_prefix_cleanup = [this, &checkpoint_prefix]() {
    int64_t undeleted_files, undeleted_dirs;
    TF_CHECK_OK(env_->DeleteRecursively(*checkpoint_prefix, &undeleted_files,
                                        &undeleted_dirs));
  };

static void AddEmbeddedProtocolBufferToLlvmModule(
    llvm::Module* module, const ::tensorflow::protobuf::MessageLite& proto,
    absl::string_view unique_identifier, string* protobuf_array_symbol_name,
    int64_t* protobuf_array_size) {
  string protobuf_array_contents = proto.SerializeAsString();
  *protobuf_array_symbol_name =
      absl::StrCat(unique_identifier, "_protobuf_array_contents");

TEST(TestUtil, MatchesFiltered) { ASSERT_THAT(filtered(), IsOkOrFiltered()); }

TEST(TestUtil, IncrementsOk) {
  CellReader<int64_t> reader(kMetric);
  counter->GetCell(kOkStatus)->IncrementBy(1);

  ASSERT_THAT(success(), IncrementedOrFiltered(reader.Delta(kOkStatus), 1));
}

TEST(TestUtil, FilteredDoesntIncrementsOk) {
  CellReader<int64_t> reader(kMetric);

  ASSERT_THAT(filtered(), IncrementedOrFiltered(reader.Delta(kOkStatus), 1));
}

}

// Helper struct holding a resource handle value and unique id associated to the
// resource handle.
struct ResourceHandleValueAndId {
  ResourceHandleValueAndId(Value value, int64_t id) : value(value), id(id) {}

  Value value;
  int64_t id = -1;
};

//===----------------------------------------------------------------------===//
// TF op helper functions for handling resource handles and ids.

        return true;
      }
    }
  }
  return false;
}

}  // namespace

constexpr int64_t ResourceAliasAnalysisInfo::kUnknownResourceId;

void IncrementResourceTypeId(int64_t& resource_type_id) {
  if (resource_type_id == ResourceAliasAnalysisInfo::kMaxResourceTypeId) {
    // We don't expect this to happen, currently there are 10 resource types in

  StringRef getDescription() const override {
    return "Unfreeze large constants.";
  }

  void runOnOperation() override;

 private:
  Option<int64_t> CreateSizeThresholdInBytesOption(const int64_t init_value) {
    return Option<int64_t>(
        *this, "size_threshold_in_bytes", llvm::cl::init(init_value),
        llvm::cl::desc(
            "Lower threshold of the constant size for unfreezing. Constants "

#include <cstdint>

namespace mlir {
namespace TFL {

// Converts a TF size (64-bit) to TFLite (32-bit) and properly converts TF's
// value for dynamic size (`std::numeric_limits<int64_t>::min()`) to the
// TFLite-specific value.
int32_t ConvertToTfliteSize(int64_t size);

}  // namespace TFL
}  // namespace mlir

                                                  Interface interface) {
  auto valid_operand = [&](int64_t idx) { return idx < op->getNumOperands(); };
  if (!llvm::all_of(interface.GetLayoutDependentArgs(), valid_operand)) {
    return op->emitOpError("layout dependent argument index is out of bound");
  }

  auto valid_result = [&](int64_t idx) { return idx < op->getNumResults(); };