#pragma once
namespace JSC {
class HeapUtil {
public:
template<typename Func>
static void findGCObjectPointersForMarking(
Heap& heap, HeapVersion markingVersion, TinyBloomFilter filter, void* passedPointer,
const Func& func)
{
const HashSet<MarkedBlock*>& set = heap.objectSpace().blocks().set();
ASSERT(heap.objectSpace().isMarking());
static const bool isMarking = true;
char* pointer = static_cast<char*>(passedPointer);
if (heap.objectSpace().largeAllocationsForThisCollectionSize()) {
if (heap.objectSpace().largeAllocationsForThisCollectionBegin()[0]->aboveLowerBound(pointer)
&& heap.objectSpace().largeAllocationsForThisCollectionEnd()[-1]->belowUpperBound(pointer)) {
LargeAllocation** result = approximateBinarySearch<LargeAllocation*>(
heap.objectSpace().largeAllocationsForThisCollectionBegin(),
heap.objectSpace().largeAllocationsForThisCollectionSize(),
LargeAllocation::fromCell(pointer),
[] (LargeAllocation** ptr) -> LargeAllocation* { return *ptr; });
if (result) {
if (result > heap.objectSpace().largeAllocationsForThisCollectionBegin()
&& result[-1]->contains(pointer))
func(result[-1]->cell());
if (result[0]->contains(pointer))
func(result[0]->cell());
if (result + 1 < heap.objectSpace().largeAllocationsForThisCollectionEnd()
&& result[1]->contains(pointer))
func(result[1]->cell());
}
}
}
MarkedBlock* candidate = MarkedBlock::blockFor(pointer);
if (pointer <= bitwise_cast<char*>(candidate) + sizeof(IndexingHeader)) {
char* previousPointer = pointer - sizeof(IndexingHeader) - 1;
MarkedBlock* previousCandidate = MarkedBlock::blockFor(previousPointer);
if (!filter.ruleOut(bitwise_cast<Bits>(previousCandidate))
&& set.contains(previousCandidate)
&& previousCandidate->handle().cellKind() == HeapCell::Auxiliary) {
previousPointer = static_cast<char*>(previousCandidate->handle().cellAlign(previousPointer));
if (previousCandidate->handle().isLiveCell(markingVersion, isMarking, previousPointer))
func(previousPointer);
}
}
if (filter.ruleOut(bitwise_cast<Bits>(candidate))) {
ASSERT(!candidate || !set.contains(candidate));
return;
}
if (!set.contains(candidate))
return;
auto tryPointer = [&] (void* pointer) {
if (candidate->handle().isLiveCell(markingVersion, isMarking, pointer))
func(pointer);
};
if (candidate->handle().cellKind() == HeapCell::JSCell) {
if (!MarkedBlock::isAtomAligned(pointer))
return;
tryPointer(pointer);
return;
}
char* alignedPointer = static_cast<char*>(candidate->handle().cellAlign(pointer));
tryPointer(alignedPointer);
if (candidate->atomNumber(alignedPointer) > MarkedBlock::firstAtom()
&& pointer <= alignedPointer + sizeof(IndexingHeader))
tryPointer(alignedPointer - candidate->cellSize());
}
static bool isPointerGCObjectJSCell(
Heap& heap, TinyBloomFilter filter, const void* pointer)
{
const Vector<LargeAllocation*>& largeAllocations = heap.objectSpace().largeAllocations();
if (!largeAllocations.isEmpty()) {
if (largeAllocations[0]->aboveLowerBound(pointer)
&& largeAllocations.last()->belowUpperBound(pointer)) {
LargeAllocation*const* result = approximateBinarySearch<LargeAllocation*const>(
largeAllocations.begin(), largeAllocations.size(),
LargeAllocation::fromCell(pointer),
[] (LargeAllocation*const* ptr) -> LargeAllocation* { return *ptr; });
if (result) {
if (result > largeAllocations.begin()
&& result[-1]->cell() == pointer
&& result[-1]->attributes().cellKind == HeapCell::JSCell)
return true;
if (result[0]->cell() == pointer
&& result[0]->attributes().cellKind == HeapCell::JSCell)
return true;
if (result + 1 < largeAllocations.end()
&& result[1]->cell() == pointer
&& result[1]->attributes().cellKind == HeapCell::JSCell)
return true;
}
}
}
const HashSet<MarkedBlock*>& set = heap.objectSpace().blocks().set();
MarkedBlock* candidate = MarkedBlock::blockFor(pointer);
if (filter.ruleOut(bitwise_cast<Bits>(candidate))) {
ASSERT(!candidate || !set.contains(candidate));
return false;
}
if (!MarkedBlock::isAtomAligned(pointer))
return false;
if (!set.contains(candidate))
return false;
if (candidate->handle().cellKind() != HeapCell::JSCell)
return false;
if (!candidate->handle().isLiveCell(pointer))
return false;
return true;
}
static bool isValueGCObject(
Heap& heap, TinyBloomFilter filter, JSValue value)
{
if (!value.isCell())
return false;
return isPointerGCObjectJSCell(heap, filter, static_cast<void*>(value.asCell()));
}
};
}