void GCLargeAlloc::Free(const void *item)
{
LargeBlock *b = GetLargeBlock(item);
#ifdef GCDEBUG
// RCObject have contract that they must clean themselves, since they
// have to scan themselves to decrement other RCObjects they might as well
// clean themselves too, better than suffering a memset later
if(b->rcobject)
m_gc->RCObjectZeroCheck((RCObject*)GetUserPointer(item));
#endif
// We can't allow free'ing something during Sweeping, otherwise alloc counters
// get decremented twice and destructors will be called twice.
GCAssert(m_gc->collecting == false || m_gc->marking == true);
if (m_gc->marking && (m_gc->collecting || IsProtectedAgainstFree(b))) {
m_gc->AbortFree(GetUserPointer(item));
return;
}
m_gc->policy.signalFreeWork(b->size);
#ifdef MMGC_HOOKS
GCHeap* heap = GCHeap::GetGCHeap();
if(heap->HooksEnabled())
{
const void* p = GetUserPointer(item);
size_t userSize = GC::Size(p);
#ifdef MMGC_MEMORY_PROFILER
if(heap->GetProfiler())
m_totalAskSize -= heap->GetProfiler()->GetAskSize(p);
#endif
heap->FinalizeHook(p, userSize);
heap->FreeHook(p, userSize, uint8_t(GCHeap::GCFreedPoison));
}
#endif
if(b->flags[0] & kHasWeakRef)
m_gc->ClearWeakRef(GetUserPointer(item));
LargeBlock **prev = &m_blocks;
while(*prev)
{
if(b == *prev)
{
*prev = Next(b);
size_t numBlocks = b->GetNumBlocks();
m_totalAllocatedBytes -= b->size;
VALGRIND_MEMPOOL_FREE(b, b);
VALGRIND_MEMPOOL_FREE(b, item);
VALGRIND_DESTROY_MEMPOOL(b);
m_gc->FreeBlock(b, (uint32_t)numBlocks, m_partitionIndex);
return;
}
prev = (LargeBlock**)(&(*prev)->next);
}
GCAssertMsg(false, "Bad free!");
}
/* static */
void GCAlloc::Free(const void *item)
{
GCBlock *b = GetBlock(item);
GCAlloc *a = b->alloc;
#ifdef MMGC_HOOKS
GCHeap* heap = GCHeap::GetGCHeap();
if(heap->HooksEnabled())
{
const void* p = GetUserPointer(item);
size_t userSize = GC::Size(p);
#ifdef MMGC_MEMORY_PROFILER
if(heap->GetProfiler())
a->m_totalAskSize -= heap->GetProfiler()->GetAskSize(p);
#endif
heap->FinalizeHook(p, userSize);
heap->FreeHook(p, userSize, 0xca);
}
#endif
#ifdef _DEBUG
// check that its not already been freed
void *free = b->firstFree;
while(free) {
GCAssert(free != item);
free = *((void**) free);
}
#endif
int index = GetIndex(b, item);
if(GetBit(b, index, kHasWeakRef)) {
b->gc->ClearWeakRef(GetUserPointer(item));
}
bool wasFull = b->IsFull();
if(b->needsSweeping) {
#ifdef _DEBUG
bool gone =
#endif
a->Sweep(b);
GCAssertMsg(!gone, "How can a page I'm about to free an item on be empty?");
wasFull = false;
}
if(wasFull) {
a->AddToFreeList(b);
}
b->FreeItem(item, index);
if(b->numItems == 0) {
a->UnlinkChunk(b);
a->FreeChunk(b);
}
}
/*static*/
void FixedAlloc::Free(void *item)
{
FixedBlock *b = (FixedBlock*) ((uintptr_t)item & ~0xFFF);
GCAssertMsg(b->alloc->m_heap->IsAddressInHeap(item), "Bogus pointer passed to free");
#ifdef MMGC_HOOKS
GCHeap *heap = b->alloc->m_heap;
if(heap->HooksEnabled()) {
#ifdef MMGC_MEMORY_PROFILER
if(heap->GetProfiler())
b->alloc->m_totalAskSize -= heap->GetProfiler()->GetAskSize(item);
#endif
heap->FinalizeHook(item, b->size - DebugSize());
heap->FreeHook(item, b->size - DebugSize(), 0xed);
}
#endif
item = GetRealPointer(item);
// Add this item to the free list
*((void**)item) = b->firstFree;
b->firstFree = item;
// We were full but now we have a free spot, add us to the free block list.
if (b->numAlloc == b->alloc->m_itemsPerBlock)
{
GCAssert(!b->nextFree && !b->prevFree);
b->nextFree = b->alloc->m_firstFree;
if (b->alloc->m_firstFree)
b->alloc->m_firstFree->prevFree = b;
b->alloc->m_firstFree = b;
}
#ifdef _DEBUG
else // we should already be on the free list
{
GCAssert ((b == b->alloc->m_firstFree) || b->prevFree);
}
#endif
b->numAlloc--;
if(b->numAlloc == 0) {
b->alloc->FreeChunk(b);
}
}
