Cheri-research/snmalloc
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge pull request #188 from nwf/ptr-not-addr

Browse Source 
Use pointers, not addresses, in more places
This commit is contained in:
Matthew Parkinson
2020-05-19 20:34:29 +01:00
committed by GitHub
parent 497f9d9386 3f32f37e60
commit 958de73f5b
4 changed files with 55 additions and 52 deletions
Download Patch File Download Diff File Expand all files Collapse all files

36
src/ds/address.h
View File

@@ -42,16 +42,6 @@ namespace snmalloc
return reinterpret_cast<address_t>(ptr);
}
/**
* Cast from an address back to a pointer of the specified type. All uses of
* this will eventually need auditing for CHERI compatibility.
*/
template<typename T>
inline T* pointer_cast(address_t address)
{
return reinterpret_cast<T*>(address);
}
/**
* Test if a pointer is aligned to a given size, which must be a power of
* two.
@@ -81,7 +71,8 @@ namespace snmalloc
#if __has_builtin(__builtin_align_down)
return static_cast<T*>(__builtin_align_down(p, alignment));
#else
return pointer_cast<T>(bits::align_down(address_cast(p), alignment));
return reinterpret_cast<T*>(
bits::align_down(reinterpret_cast<uintptr_t>(p), alignment));
#endif
}
}
@@ -102,11 +93,29 @@ namespace snmalloc
#if __has_builtin(__builtin_align_up)
return static_cast<T*>(__builtin_align_up(p, alignment));
#else
return pointer_cast<T>(bits::align_up(address_cast(p), alignment));
return reinterpret_cast<T*>(
bits::align_up(reinterpret_cast<uintptr_t>(p), alignment));
#endif
}
}
/**
* Align a pointer down to a dynamically specified granularity, which must be
* a power of two.
*/
template<typename T = void>
SNMALLOC_FAST_PATH T* pointer_align_down(void* p, size_t alignment)
{
SNMALLOC_ASSERT(alignment > 0);
SNMALLOC_ASSERT(bits::next_pow2(alignment) == alignment);
#if __has_builtin(__builtin_align_down)
return static_cast<T*>(__builtin_align_down(p, alignment));
#else
return reinterpret_cast<T*>(
bits::align_down(reinterpret_cast<uintptr_t>(p), alignment));
#endif
}
/**
* Align a pointer up to a dynamically specified granularity, which must
* be a power of two.
@@ -119,7 +128,8 @@ namespace snmalloc
#if __has_builtin(__builtin_align_up)
return static_cast<T*>(__builtin_align_up(p, alignment));
#else
return pointer_cast<T>(bits::align_up(address_cast(p), alignment));
return reinterpret_cast<T*>(
bits::align_up(reinterpret_cast<uintptr_t>(p), alignment));
#endif
}

41
src/mem/alloc.h
View File

@@ -394,7 +394,7 @@ namespace snmalloc
}
template<Boundary location = Start>
static address_t external_address(void* p)
static void* external_pointer(void* p)
{
#ifdef USE_MALLOC
error("Unsupported");
@@ -423,12 +423,13 @@ namespace snmalloc
return external_pointer<location>(p, sc, slab_end);
}
auto ss = address_cast(super);
auto ss = super;
while (size > 64)
{
// This is a large alloc redirect.
ss = ss - (1ULL << (size - 64));
ss = pointer_offset_signed(
ss, -(static_cast<ptrdiff_t>(1) << (size - 64)));
size = ChunkMap::get(ss);
}
@@ -436,28 +437,22 @@ namespace snmalloc
{
if constexpr ((location == End) || (location == OnePastEnd))
// We don't know the End, so return MAX_PTR
return UINTPTR_MAX;
return pointer_offset<void>(nullptr, UINTPTR_MAX);
else
// We don't know the Start, so return MIN_PTR
return 0;
return nullptr;
}
// This is a large alloc, mask off to the slab size.
if constexpr (location == Start)
return ss;
else if constexpr (location == End)
return (ss + (1ULL << size) - 1ULL);
return pointer_offset(ss, (1ULL << size) - 1ULL);
else
return (ss + (1ULL << size));
return pointer_offset(ss, 1ULL << size);
#endif
}
template<Boundary location = Start>
static void* external_pointer(void* p)
{
return pointer_cast<void>(external_address<location>(p));
}
static size_t alloc_size(const void* p)
{
// This must be called on an external pointer.
@@ -824,24 +819,24 @@ namespace snmalloc
}
template<Boundary location>
static uintptr_t
static void*
external_pointer(void* p, sizeclass_t sizeclass, void* end_point)
{
size_t rsize = sizeclass_to_size(sizeclass);
void* end_point_correction = location == End ?
(static_cast<uint8_t*>(end_point) - 1) :
(location == OnePastEnd ? end_point :
(static_cast<uint8_t*>(end_point) - rsize));
pointer_offset_signed(end_point, -1) :
(location == OnePastEnd ?
end_point :
pointer_offset_signed(end_point, -static_cast<ptrdiff_t>(rsize)));
ptrdiff_t offset_from_end =
(static_cast<uint8_t*>(end_point) - 1) - static_cast<uint8_t*>(p);
size_t offset_from_end =
pointer_diff(p, pointer_offset_signed(end_point, -1));
size_t end_to_end =
round_by_sizeclass(rsize, static_cast<size_t>(offset_from_end));
size_t end_to_end = round_by_sizeclass(rsize, offset_from_end);
return address_cast<uint8_t>(
static_cast<uint8_t*>(end_point_correction) - end_to_end);
return pointer_offset_signed(
end_point_correction, -static_cast<ptrdiff_t>(end_to_end));
}
void init_message_queue()

26
src/mem/largealloc.h
View File

@@ -183,10 +183,9 @@ namespace snmalloc
lazy_decommit_guard.clear();
}
void push_space(address_t start, size_t large_class)
void push_space(void* p, size_t large_class)
{
// All fresh pages so can use "NoZero"
void* p = pointer_cast<void>(start);
if (large_class > 0)
PAL::template notify_using<NoZero>(p, OS_PAGE_SIZE);
else
@@ -284,24 +283,24 @@ namespace snmalloc
if (p == nullptr)
return nullptr;
address_t p0 = address_cast(p);
address_t start = bits::align_up(p0, align);
address_t p1 = p0 + request;
address_t end = start + size;
void* start = pointer_align_up(p, align);
void* p1 = pointer_offset(p, request);
void* end = pointer_offset(start, size);
for (; end < bits::align_down(p1, align); end += size)
for (; end < pointer_align_down(p1, align);
end = pointer_offset(end, size))
{
push_space(end, large_class);
}
// Put offcuts before alignment into the large stack
address_t offcut_end = start;
address_t offcut_start;
void* offcut_end = start;
void* offcut_start;
for (size_t i = large_class; i > 0;)
{
i--;
size_t offcut_align = bits::one_at_bit(SUPERSLAB_BITS) << i;
offcut_start = bits::align_up(p0, offcut_align);
offcut_start = pointer_align_up(p, offcut_align);
if (offcut_start != offcut_end)
{
push_space(offcut_start, i);
@@ -315,7 +314,7 @@ namespace snmalloc
{
i--;
auto offcut_align = bits::one_at_bit(SUPERSLAB_BITS) << i;
offcut_end = bits::align_down(p1, offcut_align);
offcut_end = pointer_align_down(p1, offcut_align);
if (offcut_start != offcut_end)
{
push_space(offcut_start, i);
@@ -323,11 +322,10 @@ namespace snmalloc
}
}
void* result = pointer_cast<void>(start);
if (committed)
PAL::template notify_using<NoZero>(result, size);
PAL::template notify_using<NoZero>(start, size);
return result;
return start;
}
}
};

4
src/mem/superslab.h
View File

@@ -181,8 +181,8 @@ namespace snmalloc
Slab* alloc_slab(sizeclass_t sizeclass)
{
uint8_t h = head;
Slab* slab = pointer_cast<Slab>(
address_cast(this) + (static_cast<size_t>(h) << SLAB_BITS));
Slab* slab = pointer_offset(
reinterpret_cast<Slab*>(this), (static_cast<size_t>(h) << SLAB_BITS));
uint8_t n = meta[h].next;