// Copyright 2020 the V8 project authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#ifndef V8_EXECUTION_EXTERNAL_POINTER_TABLE_H_
#define V8_EXECUTION_EXTERNAL_POINTER_TABLE_H_

#include "src/base/platform/wrappers.h"
#include "src/common/external-pointer.h"
#include "src/utils/utils.h"

namespace v8 {
namespace internal {

class V8_EXPORT_PRIVATE ExternalPointerTable {
 public:
  static const int kExternalPointerTableInitialCapacity = 1024;

  ExternalPointerTable()
      : buffer_(reinterpret_cast<Address*>(base::Calloc(
            kExternalPointerTableInitialCapacity, sizeof(Address)))),
        length_(1),
        capacity_(kExternalPointerTableInitialCapacity),
        freelist_head_(0) {
    // Explicitly setup the invalid nullptr entry.
    STATIC_ASSERT(kNullExternalPointer == 0);
    buffer_[kNullExternalPointer] = kNullAddress;
  }

  ~ExternalPointerTable() { base::Free(buffer_); }

  Address get(uint32_t index) const {
    CHECK_LT(index, length_);
    return buffer_[index];
  }

  void set(uint32_t index, Address value) {
    DCHECK_NE(kNullExternalPointer, index);
    CHECK_LT(index, length_);
    buffer_[index] = value;
  }

  uint32_t allocate() {
    uint32_t index = length_++;
    if (index >= capacity_) {
      GrowTable(this);
    }
    DCHECK_NE(kNullExternalPointer, index);
    return index;
  }

  // Returns true if the entry exists in the table and therefore it can be read.
  bool is_valid_index(uint32_t index) const {
    // TODO(v8:10391, saelo): also check here if entry is free
    return index < length_;
  }

  uint32_t size() const { return length_; }

  static void GrowTable(ExternalPointerTable* table);

 private:
  friend class Isolate;

  Address* buffer_;
  uint32_t length_;
  uint32_t capacity_;
  uint32_t freelist_head_;
};

}  // namespace internal
}  // namespace v8

#endif  // V8_EXECUTION_EXTERNAL_POINTER_TABLE_H_