// Copyright 2014 PDFium Authors. All rights reserved.
|
// Use of this source code is governed by a BSD-style license that can be
|
// found in the LICENSE file.
|
|
// Original code copyright 2014 Foxit Software Inc. http://www.foxitsoftware.com
|
|
#include "xfa/fgas/crt/fgas_memory.h"
|
|
#ifndef MEMORY_TOOL_REPLACES_ALLOCATOR
|
#define MEMORY_TOOL_REPLACES_ALLOCATOR // Temporary, for CF testing.
|
#endif
|
|
#include <algorithm>
|
|
#ifdef MEMORY_TOOL_REPLACES_ALLOCATOR
|
|
namespace {
|
|
class CFX_DefStore : public IFX_MemoryAllocator, public CFX_Target {
|
public:
|
CFX_DefStore() {}
|
~CFX_DefStore() override {}
|
|
void* Alloc(size_t size) override { return FX_Alloc(uint8_t, size); }
|
void Free(void* pBlock) override { FX_Free(pBlock); }
|
};
|
|
} // namespace
|
|
IFX_MemoryAllocator* IFX_MemoryAllocator::Create(FX_ALLOCTYPE eType,
|
size_t chunkSize,
|
size_t blockSize) {
|
return new CFX_DefStore();
|
}
|
|
#else // MEMORY_TOOL_REPLACES_ALLOCATOR
|
|
namespace {
|
|
struct FX_STATICSTORECHUNK {
|
FX_STATICSTORECHUNK* pNextChunk;
|
size_t iChunkSize;
|
size_t iFreeSize;
|
};
|
|
class CFX_StaticStore : public IFX_MemoryAllocator, public CFX_Target {
|
public:
|
CFX_StaticStore(size_t iDefChunkSize);
|
~CFX_StaticStore() override;
|
|
void* Alloc(size_t size) override;
|
void Free(void* pBlock) override {}
|
|
private:
|
size_t m_iAllocatedSize;
|
size_t m_iDefChunkSize;
|
FX_STATICSTORECHUNK* m_pChunk;
|
FX_STATICSTORECHUNK* m_pLastChunk;
|
FX_STATICSTORECHUNK* AllocChunk(size_t size);
|
FX_STATICSTORECHUNK* FindChunk(size_t size);
|
};
|
|
struct FX_FIXEDSTORECHUNK {
|
uint8_t* FirstFlag() { return reinterpret_cast<uint8_t*>(this + 1); }
|
uint8_t* FirstBlock() { return FirstFlag() + iChunkSize; }
|
|
FX_FIXEDSTORECHUNK* pNextChunk;
|
size_t iChunkSize;
|
size_t iFreeNum;
|
};
|
|
class CFX_FixedStore : public IFX_MemoryAllocator, public CFX_Target {
|
public:
|
CFX_FixedStore(size_t iBlockSize, size_t iBlockNumsInChunk);
|
~CFX_FixedStore() override;
|
void* Alloc(size_t size) override;
|
void Free(void* pBlock) override;
|
|
private:
|
FX_FIXEDSTORECHUNK* AllocChunk();
|
|
size_t m_iBlockSize;
|
size_t m_iDefChunkSize;
|
FX_FIXEDSTORECHUNK* m_pChunk;
|
};
|
|
} // namespace
|
|
#define FX_4BYTEALIGN(size) (((size) + 3) & ~3)
|
|
IFX_MemoryAllocator* IFX_MemoryAllocator::Create(FX_ALLOCTYPE eType,
|
size_t chunkSize,
|
size_t blockSize) {
|
switch (eType) {
|
case FX_ALLOCTYPE_Static:
|
return new CFX_StaticStore(chunkSize);
|
case FX_ALLOCTYPE_Fixed:
|
return new CFX_FixedStore(blockSize, chunkSize);
|
default:
|
ASSERT(0);
|
return nullptr;
|
}
|
}
|
|
CFX_StaticStore::CFX_StaticStore(size_t iDefChunkSize)
|
: m_iAllocatedSize(0),
|
m_iDefChunkSize(iDefChunkSize),
|
m_pChunk(nullptr),
|
m_pLastChunk(nullptr) {
|
ASSERT(m_iDefChunkSize != 0);
|
}
|
CFX_StaticStore::~CFX_StaticStore() {
|
FX_STATICSTORECHUNK* pChunk = m_pChunk;
|
while (pChunk) {
|
FX_STATICSTORECHUNK* pNext = pChunk->pNextChunk;
|
FX_Free(pChunk);
|
pChunk = pNext;
|
}
|
}
|
FX_STATICSTORECHUNK* CFX_StaticStore::AllocChunk(size_t size) {
|
ASSERT(size != 0);
|
FX_STATICSTORECHUNK* pChunk = (FX_STATICSTORECHUNK*)FX_Alloc(
|
uint8_t, sizeof(FX_STATICSTORECHUNK) + size);
|
pChunk->iChunkSize = size;
|
pChunk->iFreeSize = size;
|
pChunk->pNextChunk = nullptr;
|
if (!m_pLastChunk) {
|
m_pChunk = pChunk;
|
} else {
|
m_pLastChunk->pNextChunk = pChunk;
|
}
|
m_pLastChunk = pChunk;
|
return pChunk;
|
}
|
FX_STATICSTORECHUNK* CFX_StaticStore::FindChunk(size_t size) {
|
ASSERT(size != 0);
|
if (!m_pLastChunk || m_pLastChunk->iFreeSize < size) {
|
return AllocChunk(std::max(m_iDefChunkSize, size));
|
}
|
return m_pLastChunk;
|
}
|
void* CFX_StaticStore::Alloc(size_t size) {
|
size = FX_4BYTEALIGN(size);
|
ASSERT(size != 0);
|
FX_STATICSTORECHUNK* pChunk = FindChunk(size);
|
ASSERT(pChunk->iFreeSize >= size);
|
uint8_t* p = (uint8_t*)pChunk;
|
p += sizeof(FX_STATICSTORECHUNK) + pChunk->iChunkSize - pChunk->iFreeSize;
|
pChunk->iFreeSize -= size;
|
m_iAllocatedSize += size;
|
return p;
|
}
|
size_t CFX_StaticStore::SetDefChunkSize(size_t size) {
|
ASSERT(size != 0);
|
size_t v = m_iDefChunkSize;
|
m_iDefChunkSize = size;
|
return v;
|
}
|
CFX_FixedStore::CFX_FixedStore(size_t iBlockSize, size_t iBlockNumsInChunk)
|
: m_iBlockSize(FX_4BYTEALIGN(iBlockSize)),
|
m_iDefChunkSize(FX_4BYTEALIGN(iBlockNumsInChunk)),
|
m_pChunk(nullptr) {
|
ASSERT(m_iBlockSize != 0 && m_iDefChunkSize != 0);
|
}
|
CFX_FixedStore::~CFX_FixedStore() {
|
FX_FIXEDSTORECHUNK* pChunk = m_pChunk;
|
while (pChunk) {
|
FX_FIXEDSTORECHUNK* pNext = pChunk->pNextChunk;
|
FX_Free(pChunk);
|
pChunk = pNext;
|
}
|
}
|
FX_FIXEDSTORECHUNK* CFX_FixedStore::AllocChunk() {
|
int32_t iTotalSize = sizeof(FX_FIXEDSTORECHUNK) + m_iDefChunkSize +
|
m_iBlockSize * m_iDefChunkSize;
|
FX_FIXEDSTORECHUNK* pChunk =
|
(FX_FIXEDSTORECHUNK*)FX_Alloc(uint8_t, iTotalSize);
|
if (!pChunk)
|
return nullptr;
|
|
FXSYS_memset(pChunk->FirstFlag(), 0, m_iDefChunkSize);
|
pChunk->pNextChunk = m_pChunk;
|
pChunk->iChunkSize = m_iDefChunkSize;
|
pChunk->iFreeNum = m_iDefChunkSize;
|
m_pChunk = pChunk;
|
return pChunk;
|
}
|
void* CFX_FixedStore::Alloc(size_t size) {
|
if (size > m_iBlockSize) {
|
return nullptr;
|
}
|
FX_FIXEDSTORECHUNK* pChunk = m_pChunk;
|
while (pChunk) {
|
if (pChunk->iFreeNum > 0) {
|
break;
|
}
|
pChunk = pChunk->pNextChunk;
|
}
|
if (!pChunk) {
|
pChunk = AllocChunk();
|
}
|
uint8_t* pFlags = pChunk->FirstFlag();
|
size_t i = 0;
|
for (; i < pChunk->iChunkSize; i++)
|
if (pFlags[i] == 0) {
|
break;
|
}
|
ASSERT(i < pChunk->iChunkSize);
|
pFlags[i] = 1;
|
pChunk->iFreeNum--;
|
return pChunk->FirstBlock() + i * m_iBlockSize;
|
}
|
void CFX_FixedStore::Free(void* pBlock) {
|
FX_FIXEDSTORECHUNK* pPrior = nullptr;
|
FX_FIXEDSTORECHUNK* pChunk = m_pChunk;
|
uint8_t* pStart = nullptr;
|
uint8_t* pEnd;
|
while (pChunk) {
|
pStart = pChunk->FirstBlock();
|
if (pBlock >= pStart) {
|
pEnd = pStart + m_iBlockSize * pChunk->iChunkSize;
|
if (pBlock < pEnd) {
|
break;
|
}
|
}
|
pPrior = pChunk, pChunk = pChunk->pNextChunk;
|
}
|
ASSERT(pChunk);
|
size_t iPos = ((uint8_t*)pBlock - pStart) / m_iBlockSize;
|
ASSERT(iPos < pChunk->iChunkSize);
|
uint8_t* pFlags = pChunk->FirstFlag();
|
if (pFlags[iPos] == 0) {
|
return;
|
}
|
pFlags[iPos] = 0;
|
pChunk->iFreeNum++;
|
if (pChunk->iFreeNum == pChunk->iChunkSize) {
|
if (!pPrior) {
|
m_pChunk = pChunk->pNextChunk;
|
} else {
|
pPrior->pNextChunk = pChunk->pNextChunk;
|
}
|
FX_Free(pChunk);
|
}
|
}
|
size_t CFX_FixedStore::SetDefChunkSize(size_t iChunkSize) {
|
ASSERT(iChunkSize != 0);
|
size_t v = m_iDefChunkSize;
|
m_iDefChunkSize = FX_4BYTEALIGN(iChunkSize);
|
return v;
|
}
|
|
#endif // MEMORY_TOOL_REPLACES_ALLOCATOR
|
