/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*-
 * vim: set ts=8 sts=2 et sw=2 tw=80:
 * This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

#ifndef js_GCArray_h
#define js_GCArray_h

#include "mozilla/Assertions.h"

#include "gc/Barrier.h"
#include "gc/Tracer.h"
#include "js/Value.h"

namespace js {

/*
 * A fixed size array of |T| for use with GC things.
 *
 * Must be allocated manually to allow space for the trailing elements
 * data. Call bytesRequired to get the required allocation size.
 *
 * Does not provide any barriers by default.
 */
template <typename T>
class GCArray {
  const uint32_t size_;
  T elements_[1];

 public:
  explicit GCArray(uint32_t size) : size_(size) {
    // The array contents following the first element are not initialized.
  }

  uint32_t size() const { return size_; }

  const T& operator[](uint32_t i) const {
    MOZ_ASSERT(i < size_);
    return elements_[i];
  }
  T& operator[](uint32_t i) {
    MOZ_ASSERT(i < size_);
    return elements_[i];
  }

  const T* begin() const { return elements_; }
  T* begin() { return elements_; }
  const T* end() const { return elements_ + size_; }
  T* end() { return elements_ + size_; }

  void trace(JSTracer* trc) {
    TraceRange(trc, size(), begin(), "array element");
  }

  static constexpr ptrdiff_t offsetOfElements() {
    return offsetof(GCArray, elements_);
  }

  static size_t bytesRequired(size_t size) {
    return offsetOfElements() + std::max(size, size_t(1)) * sizeof(T);
  }
};

/*
 * A fixed size array of GC things owned by a GC thing.
 *
 * Uses the appropriate barriers depending on whether the owner is in the
 * nursery or the tenured heap. If the owner cannot be allocated in the nursery
 * then this class is not required.
 */
template <typename T>
class GCOwnedArray {
  using StorageType = GCArray<PreAndPostBarrierWrapper<T>>;
  using TenuredInterface = StorageType;
  using NurseryInterface = GCArray<PreBarrierWrapper<T>>;

  StorageType array;

 public:
  explicit GCOwnedArray(uint32_t size) : array(size) {}

  uint32_t size() const { return array.size(); }
  const T& operator[](uint32_t i) const { return array[i].get(); }

  // Apply |f| to a view of the data with appropriate barriers given |owner|.
  template <typename F>
  void withOwner(gc::Cell* owner, F&& f) {
    if (gc::IsInsideNursery(owner)) {
      f(nurseryOwned());
    } else {
      f(tenuredOwned());
    }
  }

  // For convenience, special case setElement.
  void setElement(gc::Cell* owner, uint32_t i, const T& newValue) {
    withOwner(owner, [&](auto& self) { self[i] = newValue; });
  }

  void trace(JSTracer* trc) { array.trace(trc); }

  static constexpr ptrdiff_t offsetOfElements() {
    return offsetof(GCOwnedArray, array) + StorageType::offsetOfElements();
  }

  static size_t bytesRequired(size_t size) {
    return offsetof(GCOwnedArray, array) + StorageType::bytesRequired(size);
  }

 private:
  TenuredInterface& tenuredOwned() { return array; }
  NurseryInterface& nurseryOwned() {
    return reinterpret_cast<NurseryInterface&>(array);
  }
};

}  // namespace js

#endif  // js_GCArray_h