mirror of
https://github.com/c64scene-ar/llvm-6502.git
synced 2025-11-03 14:21:30 +00:00
9ba883c22f
supported by specific versions of GCC. It is left in place in case anyone wants to updated it for GCC 3.4 or re-use it for earlier versions of GCC where it works. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@17324 91177308-0d34-0410-b5e6-96231b3b80d8
94 lines
2.8 KiB
C++
94 lines
2.8 KiB
C++
//===-- 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
|