/* 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 Utils_h
#define Utils_h

#include <pthread.h>
#include <stdint.h>
#include <stddef.h>
#include <sys/mman.h>
#include <unistd.h>
#include "mozilla/Assertions.h"
#include "mozilla/Atomics.h"

/**
 * On architectures that are little endian and that support unaligned reads,
 * we can use direct type, but on others, we want to have a special class
 * to handle conversion and alignment issues.
 */
#if !defined(DEBUG) && (defined(__i386__) || defined(__x86_64__))
typedef uint16_t le_uint16;
typedef uint32_t le_uint32;
#else

/**
 * Template that allows to find an unsigned int type from a (computed) bit size
 */
template <int s>
struct UInt {};
template <>
struct UInt<16> {
  typedef uint16_t Type;
};
template <>
struct UInt<32> {
  typedef uint32_t Type;
};

/**
 * Template to access 2 n-bit sized words as a 2*n-bit sized word, doing
 * conversion from little endian and avoiding alignment issues.
 */
template <typename T>
class le_to_cpu {
 public:
  typedef typename UInt<16 * sizeof(T)>::Type Type;

  operator Type() const { return (b << (sizeof(T) * 8)) | a; }

  const le_to_cpu& operator=(const Type& v) {
    a = v & ((1 << (sizeof(T) * 8)) - 1);
    b = v >> (sizeof(T) * 8);
    return *this;
  }

  le_to_cpu() {}
  explicit le_to_cpu(const Type& v) { operator=(v); }

  const le_to_cpu& operator+=(const Type& v) {
    return operator=(operator Type() + v);
  }

  const le_to_cpu& operator++(int) { return operator=(operator Type() + 1); }

 private:
  T a, b;
};

/**
 * Type definitions
 */
typedef le_to_cpu<unsigned char> le_uint16;
typedef le_to_cpu<le_uint16> le_uint32;
#endif

struct AutoCloseFD {
  const int fd;

  MOZ_IMPLICIT AutoCloseFD(int fd) : fd(fd) {}
  ~AutoCloseFD() {
    if (fd != -1) close(fd);
  }
  operator int() const { return fd; }
};

extern mozilla::Atomic<size_t, mozilla::ReleaseAcquire> gPageSize;

/**
 * Page alignment helpers
 */
static size_t PageSize() {
  if (!gPageSize) {
    gPageSize = sysconf(_SC_PAGESIZE);
  }

  return gPageSize;
}

static inline uintptr_t AlignedPtr(uintptr_t ptr, size_t alignment) {
  return ptr & ~(alignment - 1);
}

template <typename T>
static inline T* AlignedPtr(T* ptr, size_t alignment) {
  return reinterpret_cast<T*>(
      AlignedPtr(reinterpret_cast<uintptr_t>(ptr), alignment));
}

template <typename T>
static inline T PageAlignedPtr(T ptr) {
  return AlignedPtr(ptr, PageSize());
}

static inline uintptr_t AlignedEndPtr(uintptr_t ptr, size_t alignment) {
  return AlignedPtr(ptr + alignment - 1, alignment);
}

template <typename T>
static inline T* AlignedEndPtr(T* ptr, size_t alignment) {
  return reinterpret_cast<T*>(
      AlignedEndPtr(reinterpret_cast<uintptr_t>(ptr), alignment));
}

template <typename T>
static inline T PageAlignedEndPtr(T ptr) {
  return AlignedEndPtr(ptr, PageSize());
}

static inline size_t AlignedSize(size_t size, size_t alignment) {
  return (size + alignment - 1) & ~(alignment - 1);
}

static inline size_t PageAlignedSize(size_t size) {
  return AlignedSize(size, PageSize());
}

static inline bool IsAlignedPtr(uintptr_t ptr, size_t alignment) {
  return ptr % alignment == 0;
}

template <typename T>
static inline bool IsAlignedPtr(T* ptr, size_t alignment) {
  return IsAlignedPtr(reinterpret_cast<uintptr_t>(ptr), alignment);
}

template <typename T>
static inline bool IsPageAlignedPtr(T ptr) {
  return IsAlignedPtr(ptr, PageSize());
}

static inline bool IsAlignedSize(size_t size, size_t alignment) {
  return size % alignment == 0;
}

static inline bool IsPageAlignedSize(size_t size) {
  return IsAlignedSize(size, PageSize());
}

static inline size_t PageNumber(size_t size) {
  return (size + PageSize() - 1) / PageSize();
}

/**
 * MemoryRange stores a pointer, size pair.
 */
class MemoryRange {
 public:
  MemoryRange(void* buf, size_t length) : buf(buf), length(length) {}

  void Assign(void* b, size_t len) {
    buf = b;
    length = len;
  }

  void Assign(const MemoryRange& other) {
    buf = other.buf;
    length = other.length;
  }

  void* get() const { return buf; }

  operator void*() const { return buf; }

  operator unsigned char*() const {
    return reinterpret_cast<unsigned char*>(buf);
  }

  bool operator==(void* ptr) const { return buf == ptr; }

  bool operator==(unsigned char* ptr) const { return buf == ptr; }

  void* operator+(off_t offset) const {
    return reinterpret_cast<char*>(buf) + offset;
  }

  /**
   * Returns whether the given address is within the mapped range
   */
  bool Contains(void* ptr) const {
    return (ptr >= buf) && (ptr < reinterpret_cast<char*>(buf) + length);
  }

  /**
   * Returns the length of the mapped range
   */
  size_t GetLength() const { return length; }

  static MemoryRange mmap(void* addr, size_t length, int prot, int flags,
                          int fd, off_t offset) {
    return MemoryRange(::mmap(addr, length, prot, flags, fd, offset), length);
  }

 private:
  void* buf;
  size_t length;
};

/**
 * MappedPtr is a RAII wrapper for mmap()ed memory. It can be used as
 * a simple void * or unsigned char *.
 *
 * It is defined as a derivative of a template that allows to use a
 * different unmapping strategy.
 */
template <typename T>
class GenericMappedPtr : public MemoryRange {
 public:
  GenericMappedPtr(void* buf, size_t length) : MemoryRange(buf, length) {}
  explicit GenericMappedPtr(const MemoryRange& other) : MemoryRange(other) {}
  GenericMappedPtr() : MemoryRange(MAP_FAILED, 0) {}

  void Assign(void* b, size_t len) {
    if (get() != MAP_FAILED) static_cast<T*>(this)->munmap(get(), GetLength());
    MemoryRange::Assign(b, len);
  }

  void Assign(const MemoryRange& other) {
    Assign(other.get(), other.GetLength());
  }

  ~GenericMappedPtr() {
    if (get() != MAP_FAILED) static_cast<T*>(this)->munmap(get(), GetLength());
  }

  void release() { MemoryRange::Assign(MAP_FAILED, 0); }
};

struct MappedPtr : public GenericMappedPtr<MappedPtr> {
  MappedPtr(void* buf, size_t length)
      : GenericMappedPtr<MappedPtr>(buf, length) {}
  MOZ_IMPLICIT MappedPtr(const MemoryRange& other)
      : GenericMappedPtr<MappedPtr>(other) {}
  MappedPtr() : GenericMappedPtr<MappedPtr>() {}

 private:
  friend class GenericMappedPtr<MappedPtr>;
  void munmap(void* buf, size_t length) { ::munmap(buf, length); }
};

/**
 * UnsizedArray is a way to access raw arrays of data in memory.
 *
 *   struct S { ... };
 *   UnsizedArray<S> a(buf);
 *   UnsizedArray<S> b; b.Init(buf);
 *
 * This is roughly equivalent to
 *   const S *a = reinterpret_cast<const S *>(buf);
 *   const S *b = nullptr; b = reinterpret_cast<const S *>(buf);
 *
 * An UnsizedArray has no known length, and it's up to the caller to make
 * sure the accessed memory is mapped and makes sense.
 */
template <typename T>
class UnsizedArray {
 public:
  typedef size_t idx_t;

  /**
   * Constructors and Initializers
   */
  UnsizedArray() : contents(nullptr) {}
  explicit UnsizedArray(const void* buf)
      : contents(reinterpret_cast<const T*>(buf)) {}

  void Init(const void* buf) {
    MOZ_ASSERT(contents == nullptr);
    contents = reinterpret_cast<const T*>(buf);
  }

  /**
   * Returns the nth element of the array
   */
  const T& operator[](const idx_t index) const {
    MOZ_ASSERT(contents);
    return contents[index];
  }

  operator const T*() const { return contents; }
  /**
   * Returns whether the array points somewhere
   */
  explicit operator bool() const { return contents != nullptr; }

 private:
  const T* contents;
};

/**
 * Array, like UnsizedArray, is a way to access raw arrays of data in memory.
 * Unlike UnsizedArray, it has a known length, and is enumerable with an
 * iterator.
 *
 *   struct S { ... };
 *   Array<S> a(buf, len);
 *   UnsizedArray<S> b; b.Init(buf, len);
 *
 * In the above examples, len is the number of elements in the array. It is
 * also possible to initialize an Array with the buffer size:
 *
 *   Array<S> c; c.InitSize(buf, size);
 *
 * It is also possible to initialize an Array in two steps, only providing
 * one data at a time:
 *
 *   Array<S> d;
 *   d.Init(buf);
 *   d.Init(len); // or d.InitSize(size);
 *
 */
template <typename T>
class Array : public UnsizedArray<T> {
 public:
  typedef typename UnsizedArray<T>::idx_t idx_t;

  /**
   * Constructors and Initializers
   */
  Array() : UnsizedArray<T>(), length(0) {}
  Array(const void* buf, const idx_t length)
      : UnsizedArray<T>(buf), length(length) {}

  void Init(const void* buf) { UnsizedArray<T>::Init(buf); }

  void Init(const idx_t len) {
    MOZ_ASSERT(length == 0);
    length = len;
  }

  void InitSize(const idx_t size) { Init(size / sizeof(T)); }

  void Init(const void* buf, const idx_t len) {
    UnsizedArray<T>::Init(buf);
    Init(len);
  }

  void InitSize(const void* buf, const idx_t size) {
    UnsizedArray<T>::Init(buf);
    InitSize(size);
  }

  /**
   * Returns the nth element of the array
   */
  const T& operator[](const idx_t index) const {
    MOZ_ASSERT(index < length);
    MOZ_ASSERT(operator bool());
    return UnsizedArray<T>::operator[](index);
  }

  /**
   * Returns the number of elements in the array
   */
  idx_t numElements() const { return length; }

  /**
   * Returns whether the array points somewhere and has at least one element.
   */
  explicit operator bool() const {
    return (length > 0) && UnsizedArray<T>::operator bool();
  }

  /**
   * Iterator for an Array. Use is similar to that of STL const_iterators:
   *
   *   struct S { ... };
   *   Array<S> a(buf, len);
   *   for (Array<S>::iterator it = a.begin(); it < a.end(); ++it) {
   *     // Do something with *it.
   *   }
   */
  class iterator {
   public:
    iterator() : item(nullptr) {}

    const T& operator*() const { return *item; }

    const T* operator->() const { return item; }

    iterator& operator++() {
      ++item;
      return *this;
    }

    bool operator<(const iterator& other) const { return item < other.item; }

   protected:
    friend class Array<T>;
    explicit iterator(const T& item) : item(&item) {}

   private:
    const T* item;
  };

  /**
   * Returns an iterator pointing at the beginning of the Array
   */
  iterator begin() const {
    if (length) return iterator(UnsizedArray<T>::operator[](0));
    return iterator();
  }

  /**
   * Returns an iterator pointing past the end of the Array
   */
  iterator end() const {
    if (length) return iterator(UnsizedArray<T>::operator[](length));
    return iterator();
  }

  /**
   * Reverse iterator for an Array. Use is similar to that of STL
   * const_reverse_iterators:
   *
   *   struct S { ... };
   *   Array<S> a(buf, len);
   *   for (Array<S>::reverse_iterator it = a.rbegin(); it < a.rend(); ++it) {
   *     // Do something with *it.
   *   }
   */
  class reverse_iterator {
   public:
    reverse_iterator() : item(nullptr) {}

    const T& operator*() const {
      const T* tmp = item;
      return *--tmp;
    }

    const T* operator->() const { return &operator*(); }

    reverse_iterator& operator++() {
      --item;
      return *this;
    }

    bool operator<(const reverse_iterator& other) const {
      return item > other.item;
    }

   protected:
    friend class Array<T>;
    explicit reverse_iterator(const T& item) : item(&item) {}

   private:
    const T* item;
  };

  /**
   * Returns a reverse iterator pointing at the end of the Array
   */
  reverse_iterator rbegin() const {
    if (length) return reverse_iterator(UnsizedArray<T>::operator[](length));
    return reverse_iterator();
  }

  /**
   * Returns a reverse iterator pointing past the beginning of the Array
   */
  reverse_iterator rend() const {
    if (length) return reverse_iterator(UnsizedArray<T>::operator[](0));
    return reverse_iterator();
  }

 private:
  idx_t length;
};

/**
 * Transforms a pointer-to-function to a pointer-to-object pointing at the
 * same address.
 */
template <typename T>
void* FunctionPtr(T func) {
  union {
    void* ptr;
    T func;
  } f;
  f.func = func;
  return f.ptr;
}

class AutoLock {
 public:
  explicit AutoLock(pthread_mutex_t* mutex) : mutex(mutex) {
    if (pthread_mutex_lock(mutex)) MOZ_CRASH("pthread_mutex_lock failed");
  }
  ~AutoLock() {
    if (pthread_mutex_unlock(mutex)) MOZ_CRASH("pthread_mutex_unlock failed");
  }

 private:
  pthread_mutex_t* mutex;
};

#endif /* Utils_h */