mfbt/RangedPtr.h

   1 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* vim: set ts=8 sts=2 et sw=2 tw=80: */
   3 /* This Source Code Form is subject to the terms of the Mozilla Public
   4  * License, v. 2.0. If a copy of the MPL was not distributed with this
   5  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   6
   7 /*
   8  * Implements a smart pointer asserted to remain within a range specified at
   9  * construction.
  10  */
  11
  12 #ifndef mozilla_RangedPtr_h
  13 #define mozilla_RangedPtr_h
  14
  15 #include "mozilla/ArrayUtils.h"
  16 #include "mozilla/Assertions.h"
  17 #include "mozilla/Attributes.h"
  18 #include "mozilla/NullPtr.h"
  19
  20 #include <stdint.h>
  21
  22 namespace mozilla {
  23
  24 /*
  25  * RangedPtr is a smart pointer restricted to an address range specified at
  26  * creation.  The pointer (and any smart pointers derived from it) must remain
  27  * within the range [start, end] (inclusive of end to facilitate use as
  28  * sentinels).  Dereferencing or indexing into the pointer (or pointers derived
  29  * from it) must remain within the range [start, end).  All the standard pointer
  30  * operators are defined on it; in debug builds these operations assert that the
  31  * range specified at construction is respected.
  32  *
  33  * In theory passing a smart pointer instance as an argument can be slightly
  34  * slower than passing a T* (due to ABI requirements for passing structs versus
  35  * passing pointers), if the method being called isn't inlined.  If you are in
  36  * extremely performance-critical code, you may want to be careful using this
  37  * smart pointer as an argument type.
  38  *
  39  * RangedPtr<T> intentionally does not implicitly convert to T*.  Use get() to
  40  * explicitly convert to T*.  Keep in mind that the raw pointer of course won't
  41  * implement bounds checking in debug builds.
  42  */
  43 template<typename T>
  44 class RangedPtr
  45 {
  46   T* mPtr;
  47
  48 #ifdef DEBUG
  49   T* const mRangeStart;
  50   T* const mRangeEnd;
  51 #endif
  52
  53   typedef void (RangedPtr::* ConvertibleToBool)();
  54   void nonNull() {}
  55
  56   void checkSanity()
  57   {
  58     MOZ_ASSERT(mRangeStart <= mPtr);
  59     MOZ_ASSERT(mPtr <= mRangeEnd);
  60   }
  61
  62   /* Creates a new pointer for |aPtr|, restricted to this pointer's range. */
  63   RangedPtr<T> create(T* aPtr) const
  64   {
  65 #ifdef DEBUG
  66     return RangedPtr<T>(aPtr, mRangeStart, mRangeEnd);
  67 #else
  68     return RangedPtr<T>(aPtr, nullptr, size_t(0));
  69 #endif
  70   }
  71
  72   uintptr_t asUintptr() const { return reinterpret_cast<uintptr_t>(mPtr); }
  73
  74 public:
  75   RangedPtr(T* aPtr, T* aStart, T* aEnd)
  76     : mPtr(aPtr)
  77 #ifdef DEBUG
  78     , mRangeStart(aStart), mRangeEnd(aEnd)
  79 #endif
  80   {
  81     MOZ_ASSERT(mRangeStart <= mRangeEnd);
  82     checkSanity();
  83   }
  84   RangedPtr(T* aPtr, T* aStart, size_t aLength)
  85     : mPtr(aPtr)
  86 #ifdef DEBUG
  87     , mRangeStart(aStart), mRangeEnd(aStart + aLength)
  88 #endif
  89   {
  90     MOZ_ASSERT(aLength <= size_t(-1) / sizeof(T));
  91     MOZ_ASSERT(reinterpret_cast<uintptr_t>(mRangeStart) + aLength * sizeof(T) >=
  92                reinterpret_cast<uintptr_t>(mRangeStart));
  93     checkSanity();
  94   }
  95
  96   /* Equivalent to RangedPtr(aPtr, aPtr, aLength). */
  97   RangedPtr(T* aPtr, size_t aLength)
  98     : mPtr(aPtr)
  99 #ifdef DEBUG
 100     , mRangeStart(aPtr), mRangeEnd(aPtr + aLength)
 101 #endif
 102   {
 103     MOZ_ASSERT(aLength <= size_t(-1) / sizeof(T));
 104     MOZ_ASSERT(reinterpret_cast<uintptr_t>(mRangeStart) + aLength * sizeof(T) >=
 105                reinterpret_cast<uintptr_t>(mRangeStart));
 106     checkSanity();
 107   }
 108
 109   /* Equivalent to RangedPtr(aArr, aArr, N). */
 110   template<size_t N>
 111   RangedPtr(T (&aArr)[N])
 112     : mPtr(aArr)
 113 #ifdef DEBUG
 114     , mRangeStart(aArr), mRangeEnd(aArr + N)
 115 #endif
 116   {
 117     checkSanity();
 118   }
 119
 120   T* get() const { return mPtr; }
 121
 122   operator ConvertibleToBool() const { return mPtr ? &RangedPtr::nonNull : 0; }
 123
 124   /*
 125    * You can only assign one RangedPtr into another if the two pointers have
 126    * the same valid range:
 127    *
 128    *   char arr1[] = "hi";
 129    *   char arr2[] = "bye";
 130    *   RangedPtr<char> p1(arr1, 2);
 131    *   p1 = RangedPtr<char>(arr1 + 1, arr1, arr1 + 2); // works
 132    *   p1 = RangedPtr<char>(arr2, 3);                  // asserts
 133    */
 134   RangedPtr<T>& operator=(const RangedPtr<T>& aOther)
 135   {
 136     MOZ_ASSERT(mRangeStart == aOther.mRangeStart);
 137     MOZ_ASSERT(mRangeEnd == aOther.mRangeEnd);
 138     mPtr = aOther.mPtr;
 139     checkSanity();
 140     return *this;
 141   }
 142
 143   RangedPtr<T> operator+(size_t aInc)
 144   {
 145     MOZ_ASSERT(aInc <= size_t(-1) / sizeof(T));
 146     MOZ_ASSERT(asUintptr() + aInc * sizeof(T) >= asUintptr());
 147     return create(mPtr + aInc);
 148   }
 149
 150   RangedPtr<T> operator-(size_t aDec)
 151   {
 152     MOZ_ASSERT(aDec <= size_t(-1) / sizeof(T));
 153     MOZ_ASSERT(asUintptr() - aDec * sizeof(T) <= asUintptr());
 154     return create(mPtr - aDec);
 155   }
 156
 157   /*
 158    * You can assign a raw pointer into a RangedPtr if the raw pointer is
 159    * within the range specified at creation.
 160    */
 161   template <typename U>
 162   RangedPtr<T>& operator=(U* aPtr)
 163   {
 164     *this = create(aPtr);
 165     return *this;
 166   }
 167
 168   template <typename U>
 169   RangedPtr<T>& operator=(const RangedPtr<U>& aPtr)
 170   {
 171     MOZ_ASSERT(mRangeStart <= aPtr.mPtr);
 172     MOZ_ASSERT(aPtr.mPtr <= mRangeEnd);
 173     mPtr = aPtr.mPtr;
 174     checkSanity();
 175     return *this;
 176   }
 177
 178   RangedPtr<T>& operator++()
 179   {
 180     return (*this += 1);
 181   }
 182
 183   RangedPtr<T> operator++(int)
 184   {
 185     RangedPtr<T> rcp = *this;
 186     ++*this;
 187     return rcp;
 188   }
 189
 190   RangedPtr<T>& operator--()
 191   {
 192     return (*this -= 1);
 193   }
 194
 195   RangedPtr<T> operator--(int)
 196   {
 197     RangedPtr<T> rcp = *this;
 198     --*this;
 199     return rcp;
 200   }
 201
 202   RangedPtr<T>& operator+=(size_t aInc)
 203   {
 204     *this = *this + aInc;
 205     return *this;
 206   }
 207
 208   RangedPtr<T>& operator-=(size_t aDec)
 209   {
 210     *this = *this - aDec;
 211     return *this;
 212   }
 213
 214   T& operator[](int aIndex) const
 215   {
 216     MOZ_ASSERT(size_t(aIndex > 0 ? aIndex : -aIndex) <= size_t(-1) / sizeof(T));
 217     return *create(mPtr + aIndex);
 218   }
 219
 220   T& operator*() const
 221   {
 222     MOZ_ASSERT(mPtr >= mRangeStart);
 223     MOZ_ASSERT(mPtr < mRangeEnd);
 224     return *mPtr;
 225   }
 226
 227   template <typename U>
 228   bool operator==(const RangedPtr<U>& aOther) const
 229   {
 230     return mPtr == aOther.mPtr;
 231   }
 232   template <typename U>
 233   bool operator!=(const RangedPtr<U>& aOther) const
 234   {
 235     return !(*this == aOther);
 236   }
 237
 238   template<typename U>
 239   bool operator==(const U* u) const
 240   {
 241     return mPtr == u;
 242   }
 243   template<typename U>
 244   bool operator!=(const U* u) const
 245   {
 246     return !(*this == u);
 247   }
 248
 249   template <typename U>
 250   bool operator<(const RangedPtr<U>& aOther) const
 251   {
 252     return mPtr < aOther.mPtr;
 253   }
 254   template <typename U>
 255   bool operator<=(const RangedPtr<U>& aOther) const
 256   {
 257     return mPtr <= aOther.mPtr;
 258   }
 259
 260   template <typename U>
 261   bool operator>(const RangedPtr<U>& aOther) const
 262   {
 263     return mPtr > aOther.mPtr;
 264   }
 265   template <typename U>
 266   bool operator>=(const RangedPtr<U>& aOther) const
 267   {
 268     return mPtr >= aOther.mPtr;
 269   }
 270
 271   size_t operator-(const RangedPtr<T>& aOther) const
 272   {
 273     MOZ_ASSERT(mPtr >= aOther.mPtr);
 274     return PointerRangeSize(aOther.mPtr, mPtr);
 275   }
 276
 277 private:
 278   RangedPtr() MOZ_DELETE;
 279   T* operator&() MOZ_DELETE;
 280 };
 281
 282 } /* namespace mozilla */
 283
 284 #endif /* mozilla_RangedPtr_h */