1 //
2 // Tests for
3 // T* unsafe_discard_bounds() const;
4 //
5
6 #include <libkern/c++/bounded_ptr.h>
7 #include <array>
8 #include <cstddef>
9 #include <cstdint>
10 #include <limits>
11 #include <darwintest.h>
12 #include <darwintest_utils.h>
13 #include "test_utils.h"
14
15 #define _assert(...) T_ASSERT_TRUE((__VA_ARGS__), # __VA_ARGS__)
16
17 namespace {
18 struct tracking_policy {
19 static bool did_trap;
20 static void
trap__anond1ef16500111::tracking_policy21 trap(char const*)
22 {
23 did_trap = true;
24 }
25 };
26 bool tracking_policy::did_trap = false;
27 }
28
29 struct T { int i; };
30
31 template <typename T, typename QualT>
32 static void
tests()33 tests()
34 {
35 std::array<T, 5> array = {T{0}, T{1}, T{2}, T{3}, T{4}};
36
37 {
38 // T{0} T{1} T{2} T{3} T{4} <one-past-last>
39 // ^ ^
40 // | |
41 // begin, ptr end
42 test_bounded_ptr<QualT> const ptr(array.begin() + 0, array.begin(), array.end());
43 QualT* raw = ptr.unsafe_discard_bounds();
44 _assert(raw == &array[0]);
45 }
46 {
47 // T{0} T{1} T{2} T{3} T{4} <one-past-last>
48 // ^ ^ ^
49 // | | |
50 // begin ptr end
51 test_bounded_ptr<QualT> const ptr(array.begin() + 1, array.begin(), array.end());
52 QualT* raw = ptr.unsafe_discard_bounds();
53 _assert(raw == &array[1]);
54 }
55 {
56 // T{0} T{1} T{2} T{3} T{4} <one-past-last>
57 // ^ ^ ^
58 // | | |
59 // begin ptr end
60 test_bounded_ptr<QualT> const ptr(array.begin() + 2, array.begin(), array.end());
61 QualT* raw = ptr.unsafe_discard_bounds();
62 _assert(raw == &array[2]);
63 }
64 {
65 // T{0} T{1} T{2} T{3} T{4} <one-past-last>
66 // ^ ^ ^
67 // | | |
68 // begin ptr end
69 test_bounded_ptr<QualT> const ptr(array.begin() + 4, array.begin(), array.end());
70 QualT* raw = ptr.unsafe_discard_bounds();
71 _assert(raw == &array[4]);
72 }
73 {
74 // T{0} T{1} T{2} T{3} T{4} <one-past-last>
75 // ^ ^
76 // | |
77 // begin end,ptr
78 test_bounded_ptr<QualT> const ptr(array.end(), array.begin(), array.end());
79 QualT* raw = ptr.unsafe_discard_bounds();
80 _assert(raw == array.end());
81 }
82 {
83 // T{0} T{1} T{2} T{3} T{4} <one-past-last>
84 // ^ ^ ^
85 // | | |
86 // begin end ptr
87 test_bounded_ptr<QualT> ptr(array.end() - 1, array.begin(), array.end() - 2);
88 QualT* raw = ptr.unsafe_discard_bounds();
89 _assert(raw == &array[4]);
90 }
91 {
92 // T{0} T{1} T{2} T{3} T{4} <one-past-last>
93 // ^ ^ ^
94 // | | |
95 // begin ptr end
96 test_bounded_ptr<QualT> ptr(array.begin() + 1, array.begin(), array.end());
97 QualT* raw = ptr.unsafe_discard_bounds();
98 _assert(raw == &array[1]);
99 }
100 {
101 // T{0} T{1} T{2} T{3} T{4} <one-past-last>
102 // ^ ^ ^
103 // | | |
104 // ptr begin end
105 test_bounded_ptr<QualT> ptr(array.begin(), array.begin() + 1, array.end());
106 QualT* raw = ptr.unsafe_discard_bounds();
107 _assert(raw == &array[0]);
108 }
109
110 // Test discarding the bounds of a null pointer
111 {
112 test_bounded_ptr<QualT> const ptr(nullptr, nullptr, nullptr);
113 QualT* raw = ptr.unsafe_discard_bounds();
114 _assert(raw == nullptr);
115 }
116
117 // Test discarding the bounds on a pointer outside of representable memory.
118 // Even `unsafe_discard_bounds()` will trap in such conditions.
119 //
120 // To do this, we setup an imaginary object with a very high address, and
121 // we add a large-ish offset to it, such that adding the base to the offset
122 // would fall outside of the representable memory.
123 {
124 tracking_policy::did_trap = false;
125
126 QualT* end_of_memory = reinterpret_cast<QualT*>(std::numeric_limits<std::uintptr_t>::max());
127 QualT* base = end_of_memory - 500; // yeah, technically UB
128 std::ptrdiff_t offset = 501;
129
130 libkern::bounded_ptr<QualT, tracking_policy> ptr(base, base, base + 1);
131 ptr += offset; // now, `base_ + offset_` points outside of representable memory
132
133 _assert(!tracking_policy::did_trap);
134 (void)ptr.unsafe_discard_bounds();
135 _assert(tracking_policy::did_trap);
136 }
137 }
138
139 T_DECL(unsafe_discard_bounds, "bounded_ptr.unsafe_discard_bounds", T_META_TAG_VM_PREFERRED) {
140 tests<T, T>();
141 tests<T, T const>();
142 tests<T, T volatile>();
143 tests<T, T const volatile>();
144 }
145