6502/llvm-6502
1
0
Fork 0
mirror of https://github.com/c64scene-ar/llvm-6502.git synced 2025-01-17 06:33:21 +00:00
Code Issues Projects Releases Wiki Activity

Moved into the poolalloc tree.

Browse Source 
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@18102 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
John Criswell 2004-11-22 16:32:35 +00:00
parent c1d035a881
commit 8fb51e4800
1 changed files with 0 additions and 93 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

93
include/llvm/Support/MallocAllocator.h
View File

@ -1,93 +0,0 @@
//===-- llvm/Support/MallocAllocator.h --------------------------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file was developed by the LLVM research group and is distributed under
// the University of Illinois Open Source License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// This file defines MallocAllocator class, an STL compatible allocator which
// just uses malloc/free to get and release memory. The default allocator uses
// the STL pool allocator runtime library, this explicitly avoids it.
//
// This file is used for variety of purposes, including the pool allocator
// project and testing, regardless of whether or not it's used directly in the
// LLVM code, so don't delete this from CVS if you think it's unused!
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_SUPPORT_MALLOCALLOCATOR_H
#define LLVM_SUPPORT_MALLOCALLOCATOR_H
#include <cstdlib>
#include <memory>
namespace llvm {
template<typename T>
struct MallocAllocator {
typedef size_t size_type;
typedef ptrdiff_t difference_type;
typedef T* pointer;
typedef const T* const_pointer;
typedef T& reference;
typedef const T& const_reference;
typedef T value_type;
template <class U> struct rebind {
typedef MallocAllocator<U> other;
};
template<typename R>
MallocAllocator(const MallocAllocator<R> &) {}
MallocAllocator() {}
pointer address(reference x) const { return &x; }
const_pointer address(const_reference x) const { return &x; }
size_type max_size() const { return ~0 / sizeof(T); }
static pointer allocate(size_t n, void* hint = 0) {
return static_cast<pointer>(malloc(n*sizeof(T)));
}
static void deallocate(pointer p, size_t n) {
free(static_cast<void*>(p));
}
void construct(pointer p, const T &val) {
new(static_cast<void*>(p)) T(val);
}
void destroy(pointer p) {
p->~T();
}
};
template<typename T>
inline bool operator==(const MallocAllocator<T> &, const MallocAllocator<T> &) {
return true;
}
template<typename T>
inline bool operator!=(const MallocAllocator<T>&, const MallocAllocator<T>&) {
return false;
}
} // End llvm namespace
/*
* This specialization was used for optimization earlier, but doesn't appear
* to work with newer versions of GCC, Linux or otherwise.
*
* This can be re-enabled if desired, but by default, it won't be included.
*/
#if 0
namespace std {
template<typename Type, typename Type2>
struct _Alloc_traits<Type, ::llvm::MallocAllocator<Type2> > {
static const bool _S_instanceless = true;
typedef ::llvm::MallocAllocator<Type> base_alloc_type;
typedef ::llvm::MallocAllocator<Type> _Alloc_type;
typedef ::llvm::MallocAllocator<Type> allocator_type;
};
}
#endif
#endif