llvm-6502/lib/Support/Allocator.cpp
Dan Gohman fed90b6d09 Fold the useful features of alist and alist_node into ilist, and
a new ilist_node class, and remove them. Unlike alist_node,
ilist_node doesn't attempt to manage storage itself, so it avoids
the associated problems, including being opaque in gdb.

Adjust the Recycler class so that it doesn't depend on alist_node.
Also, change it to use explicit Size and Align parameters, allowing
it to work when the largest-sized node doesn't have the greatest
alignment requirement.

Change MachineInstr's MachineMemOperand list from a pool-backed
alist to a std::list for now.


git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@54146 91177308-0d34-0410-b5e6-96231b3b80d8
2008-07-28 21:51:04 +00:00

142 lines
4.3 KiB
C++

//===--- Allocator.cpp - Simple memory allocation abstraction -------------===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// This file implements the BumpPtrAllocator interface.
//
//===----------------------------------------------------------------------===//
#include "llvm/Support/Allocator.h"
#include "llvm/Support/Recycler.h"
#include "llvm/Support/DataTypes.h"
#include "llvm/Support/Streams.h"
#include <ostream>
using namespace llvm;
//===----------------------------------------------------------------------===//
// MemRegion class implementation
//===----------------------------------------------------------------------===//
namespace {
/// MemRegion - This is one chunk of the BumpPtrAllocator.
class MemRegion {
unsigned RegionSize;
MemRegion *Next;
char *NextPtr;
public:
void Init(unsigned size, unsigned Alignment, MemRegion *next) {
RegionSize = size;
Next = next;
NextPtr = (char*)(this+1);
// Align NextPtr.
NextPtr = (char*)((intptr_t)(NextPtr+Alignment-1) &
~(intptr_t)(Alignment-1));
}
const MemRegion *getNext() const { return Next; }
unsigned getNumBytesAllocated() const {
return NextPtr-(const char*)this;
}
/// Allocate - Allocate and return at least the specified number of bytes.
///
void *Allocate(size_t AllocSize, size_t Alignment, MemRegion **RegPtr) {
char* Result = (char*) (((uintptr_t) (NextPtr+Alignment-1))
& ~((uintptr_t) Alignment-1));
// Speculate the new value of NextPtr.
char* NextPtrTmp = Result + AllocSize;
// If we are still within the current region, return Result.
if (unsigned (NextPtrTmp - (char*) this) <= RegionSize) {
NextPtr = NextPtrTmp;
return Result;
}
// Otherwise, we have to allocate a new chunk. Create one twice as big as
// this one.
MemRegion *NewRegion = (MemRegion *)malloc(RegionSize*2);
NewRegion->Init(RegionSize*2, Alignment, this);
// Update the current "first region" pointer to point to the new region.
*RegPtr = NewRegion;
// Try allocating from it now.
return NewRegion->Allocate(AllocSize, Alignment, RegPtr);
}
/// Deallocate - Recursively release all memory for this and its next regions
/// to the system.
void Deallocate() {
MemRegion *next = Next;
free(this);
if (next)
next->Deallocate();
}
/// DeallocateAllButLast - Recursively release all memory for this and its
/// next regions to the system stopping at the last region in the list.
/// Returns the pointer to the last region.
MemRegion *DeallocateAllButLast() {
MemRegion *next = Next;
if (!next)
return this;
free(this);
return next->DeallocateAllButLast();
}
};
}
//===----------------------------------------------------------------------===//
// BumpPtrAllocator class implementation
//===----------------------------------------------------------------------===//
BumpPtrAllocator::BumpPtrAllocator() {
TheMemory = malloc(4096);
((MemRegion*)TheMemory)->Init(4096, 1, 0);
}
BumpPtrAllocator::~BumpPtrAllocator() {
((MemRegion*)TheMemory)->Deallocate();
}
void BumpPtrAllocator::Reset() {
MemRegion *MRP = (MemRegion*)TheMemory;
MRP = MRP->DeallocateAllButLast();
MRP->Init(4096, 1, 0);
TheMemory = MRP;
}
void *BumpPtrAllocator::Allocate(size_t Size, size_t Align) {
MemRegion *MRP = (MemRegion*)TheMemory;
void *Ptr = MRP->Allocate(Size, Align, &MRP);
TheMemory = MRP;
return Ptr;
}
void BumpPtrAllocator::PrintStats() const {
unsigned BytesUsed = 0;
unsigned NumRegions = 0;
const MemRegion *R = (MemRegion*)TheMemory;
for (; R; R = R->getNext(), ++NumRegions)
BytesUsed += R->getNumBytesAllocated();
cerr << "\nNumber of memory regions: " << NumRegions << "\n";
cerr << "Bytes allocated: " << BytesUsed << "\n";
}
void llvm::PrintRecyclerStats(size_t Size,
size_t Align,
size_t FreeListSize) {
cerr << "Recycler element size: " << Size << '\n';
cerr << "Recycler element alignment: " << Align << '\n';
cerr << "Number of elements free for recycling: " << FreeListSize << '\n';
}