blob: 3e3da4139c10e2bb796dc1a2f844126288dd91ca (
plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
|
//===-- Support/MallocAllocator.h - Allocator using malloc/free -*- 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 SUPPORT_MALLOCALLOCATOR_H
#define 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
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
|
