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/. */
8 * Implements a smart pointer asserted to remain within a range specified at
12 #ifndef mozilla_RangedPtr_h
13 #define mozilla_RangedPtr_h
15 #include "mozilla/ArrayUtils.h"
16 #include "mozilla/Assertions.h"
17 #include "mozilla/Attributes.h"
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.
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.
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.
46 friend class RangedPtr
;
50 #if defined(DEBUG) || defined(FUZZING)
56 MOZ_ASSERT_DEBUG_OR_FUZZING(mRangeStart
<= mPtr
);
57 MOZ_ASSERT_DEBUG_OR_FUZZING(mPtr
<= mRangeEnd
);
60 /* Creates a new pointer for |aPtr|, restricted to this pointer's range. */
61 RangedPtr
<T
> create(T
* aPtr
) const {
62 #if defined(DEBUG) || defined(FUZZING)
63 return RangedPtr
<T
>(aPtr
, mRangeStart
, mRangeEnd
);
65 return RangedPtr
<T
>(aPtr
, nullptr, size_t(0));
69 uintptr_t asUintptr() const { return reinterpret_cast<uintptr_t>(mPtr
); }
72 RangedPtr(T
* aPtr
, T
* aStart
, T
* aEnd
)
74 #if defined(DEBUG) || defined(FUZZING)
80 MOZ_ASSERT_DEBUG_OR_FUZZING(mRangeStart
<= mRangeEnd
);
83 RangedPtr(T
* aPtr
, T
* aStart
, size_t aLength
)
85 #if defined(DEBUG) || defined(FUZZING)
88 mRangeEnd(aStart
+ aLength
)
91 MOZ_ASSERT_DEBUG_OR_FUZZING(aLength
<= size_t(-1) / sizeof(T
));
92 MOZ_ASSERT_DEBUG_OR_FUZZING(reinterpret_cast<uintptr_t>(mRangeStart
) +
93 aLength
* sizeof(T
) >=
94 reinterpret_cast<uintptr_t>(mRangeStart
));
98 /* Equivalent to RangedPtr(aPtr, aPtr, aLength). */
99 RangedPtr(T
* aPtr
, size_t aLength
)
101 #if defined(DEBUG) || defined(FUZZING)
104 mRangeEnd(aPtr
+ aLength
)
107 MOZ_ASSERT_DEBUG_OR_FUZZING(aLength
<= size_t(-1) / sizeof(T
));
108 MOZ_ASSERT_DEBUG_OR_FUZZING(reinterpret_cast<uintptr_t>(mRangeStart
) +
109 aLength
* sizeof(T
) >=
110 reinterpret_cast<uintptr_t>(mRangeStart
));
114 /* Equivalent to RangedPtr(aArr, aArr, N). */
116 explicit RangedPtr(T (&aArr
)[N
])
118 #if defined(DEBUG) || defined(FUZZING)
127 RangedPtr(const RangedPtr
& aOther
)
129 #if defined(DEBUG) || defined(FUZZING)
131 mRangeStart(aOther
.mRangeStart
),
132 mRangeEnd(aOther
.mRangeEnd
)
138 template <typename U
>
139 MOZ_IMPLICIT
RangedPtr(const RangedPtr
<U
>& aOther
)
141 #if defined(DEBUG) || defined(FUZZING)
143 mRangeStart(aOther
.mRangeStart
),
144 mRangeEnd(aOther
.mRangeEnd
)
150 T
* get() const { return mPtr
; }
152 explicit operator bool() const { return mPtr
!= nullptr; }
154 void checkIdenticalRange(const RangedPtr
<T
>& aOther
) const {
155 MOZ_ASSERT_DEBUG_OR_FUZZING(mRangeStart
== aOther
.mRangeStart
);
156 MOZ_ASSERT_DEBUG_OR_FUZZING(mRangeEnd
== aOther
.mRangeEnd
);
159 template <typename U
>
160 RangedPtr
<U
> ReinterpretCast() const {
161 #if defined(DEBUG) || defined(FUZZING)
162 return {reinterpret_cast<U
*>(mPtr
), reinterpret_cast<U
*>(mRangeStart
),
163 reinterpret_cast<U
*>(mRangeEnd
)};
165 return {reinterpret_cast<U
*>(mPtr
), nullptr, nullptr};
170 * You can only assign one RangedPtr into another if the two pointers have
171 * the same valid range:
173 * char arr1[] = "hi";
174 * char arr2[] = "bye";
175 * RangedPtr<char> p1(arr1, 2);
176 * p1 = RangedPtr<char>(arr1 + 1, arr1, arr1 + 2); // works
177 * p1 = RangedPtr<char>(arr2, 3); // asserts
179 RangedPtr
<T
>& operator=(const RangedPtr
<T
>& aOther
) {
180 checkIdenticalRange(aOther
);
186 RangedPtr
<T
> operator+(size_t aInc
) const {
187 MOZ_ASSERT_DEBUG_OR_FUZZING(aInc
<= size_t(-1) / sizeof(T
));
188 MOZ_ASSERT_DEBUG_OR_FUZZING(asUintptr() + aInc
* sizeof(T
) >= asUintptr());
189 return create(mPtr
+ aInc
);
192 RangedPtr
<T
> operator-(size_t aDec
) const {
193 MOZ_ASSERT_DEBUG_OR_FUZZING(aDec
<= size_t(-1) / sizeof(T
));
194 MOZ_ASSERT_DEBUG_OR_FUZZING(asUintptr() - aDec
* sizeof(T
) <= asUintptr());
195 return create(mPtr
- aDec
);
199 * You can assign a raw pointer into a RangedPtr if the raw pointer is
200 * within the range specified at creation.
202 template <typename U
>
203 RangedPtr
<T
>& operator=(U
* aPtr
) {
204 *this = create(aPtr
);
208 template <typename U
>
209 RangedPtr
<T
>& operator=(const RangedPtr
<U
>& aPtr
) {
210 MOZ_ASSERT_DEBUG_OR_FUZZING(mRangeStart
<= aPtr
.mPtr
);
211 MOZ_ASSERT_DEBUG_OR_FUZZING(aPtr
.mPtr
<= mRangeEnd
);
217 RangedPtr
<T
>& operator++() { return (*this += 1); }
219 RangedPtr
<T
> operator++(int) {
220 RangedPtr
<T
> rcp
= *this;
225 RangedPtr
<T
>& operator--() { return (*this -= 1); }
227 RangedPtr
<T
> operator--(int) {
228 RangedPtr
<T
> rcp
= *this;
233 RangedPtr
<T
>& operator+=(size_t aInc
) {
234 *this = *this + aInc
;
238 RangedPtr
<T
>& operator-=(size_t aDec
) {
239 *this = *this - aDec
;
243 T
& operator[](ptrdiff_t aIndex
) const {
244 MOZ_ASSERT_DEBUG_OR_FUZZING(size_t(aIndex
> 0 ? aIndex
: -aIndex
) <=
245 size_t(-1) / sizeof(T
));
246 return *create(mPtr
+ aIndex
);
249 T
& operator*() const {
250 MOZ_ASSERT_DEBUG_OR_FUZZING(mPtr
>= mRangeStart
);
251 MOZ_ASSERT_DEBUG_OR_FUZZING(mPtr
< mRangeEnd
);
255 T
* operator->() const {
256 MOZ_ASSERT_DEBUG_OR_FUZZING(mPtr
>= mRangeStart
);
257 MOZ_ASSERT_DEBUG_OR_FUZZING(mPtr
< mRangeEnd
);
261 template <typename U
>
262 bool operator==(const RangedPtr
<U
>& aOther
) const {
263 return mPtr
== aOther
.mPtr
;
265 template <typename U
>
266 bool operator!=(const RangedPtr
<U
>& aOther
) const {
267 return !(*this == aOther
);
270 template <typename U
>
271 bool operator==(const U
* u
) const {
274 template <typename U
>
275 bool operator!=(const U
* u
) const {
276 return !(*this == u
);
279 bool operator==(std::nullptr_t
) const { return mPtr
== nullptr; }
280 bool operator!=(std::nullptr_t
) const { return mPtr
!= nullptr; }
282 template <typename U
>
283 bool operator<(const RangedPtr
<U
>& aOther
) const {
284 return mPtr
< aOther
.mPtr
;
286 template <typename U
>
287 bool operator<=(const RangedPtr
<U
>& aOther
) const {
288 return mPtr
<= aOther
.mPtr
;
291 template <typename U
>
292 bool operator>(const RangedPtr
<U
>& aOther
) const {
293 return mPtr
> aOther
.mPtr
;
295 template <typename U
>
296 bool operator>=(const RangedPtr
<U
>& aOther
) const {
297 return mPtr
>= aOther
.mPtr
;
300 size_t operator-(const RangedPtr
<T
>& aOther
) const {
301 MOZ_ASSERT_DEBUG_OR_FUZZING(mPtr
>= aOther
.mPtr
);
302 return PointerRangeSize(aOther
.mPtr
, mPtr
);
306 RangedPtr() = delete;
309 } /* namespace mozilla */
311 #endif /* mozilla_RangedPtr_h */