The Tor Browser: mozglue/linker/Utils.h@b8a032363ba2 (annotated)

mozglue/linker/Utils.h@b8a032363ba2 (annotated)

mozglue/linker/Utils.h

Thu, 22 Jan 2015 13:21:57 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Thu, 22 Jan 2015 13:21:57 +0100
branch: TOR_BUG_9701
changeset 15: b8a032363ba2
permissions: -rw-r--r--

Incorporate requested changes from Mozilla in review:
https://bugzilla.mozilla.org/show_bug.cgi?id=1123480#c6

 /* 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 <stdint.h>
 #include <stddef.h>
 #include <sys/mman.h>
 #include <unistd.h>
 #include "mozilla/Assertions.h"
 #include "mozilla/Scoped.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() { }
   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
 /**
  * AutoCloseFD is a RAII wrapper for POSIX file descriptors
  */
 struct AutoCloseFDTraits
 {
   typedef int type;
   static int empty() { return -1; }
   static void release(int fd) { if (fd != -1) close(fd); }
 };
 typedef mozilla::Scoped<AutoCloseFDTraits> AutoCloseFD;
 /**
  * AutoCloseFILE is a RAII wrapper for POSIX streams
  */
 struct AutoCloseFILETraits
 {
   typedef FILE *type;
   static FILE *empty() { return nullptr; }
   static void release(FILE *f) { if (f) fclose(f); }
 };
 typedef mozilla::Scoped<AutoCloseFILETraits> AutoCloseFILE;
 /**
  * Page alignment helpers
  */
 static inline size_t PageSize()
 {
   return 4096;
 }
 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) { }
   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());
   }
 };
 struct MappedPtr: public GenericMappedPtr<MappedPtr>
 {
   MappedPtr(void *buf, size_t length)
   : GenericMappedPtr<MappedPtr>(buf, length) { }
   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) { }
   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
    */
   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.
    */
   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>;
     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>;
     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;
 }
 #endif /* Utils_h */

The Tor Browser / annotate

mozglue/linker/Utils.h@b8a032363ba2 (annotated)

mozglue/linker/Utils.h