The Tor Browser: comparison mozglue/linker/Utils.h

--1:000000000000
+:6890861894d6
+/* 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 / file comparison

comparison: mozglue/linker/Utils.h

mozglue/linker/Utils.h