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
86
87
88
89
90
91
92
93
|
//===-- MemoryManager.cpp -------------------------------------------------===//
//
// The KLEE Symbolic Virtual Machine
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#include "CoreStats.h"
#include "Memory.h"
#include "MemoryManager.h"
#include "klee/ExecutionState.h"
#include "klee/Expr.h"
#include "klee/Solver.h"
#include "klee/Internal/Support/ErrorHandling.h"
#include "llvm/Support/CommandLine.h"
using namespace klee;
/***/
MemoryManager::~MemoryManager() {
while (!objects.empty()) {
MemoryObject *mo = *objects.begin();
if (!mo->isFixed)
free((void *)mo->address);
objects.erase(mo);
delete mo;
}
}
MemoryObject *MemoryManager::allocate(uint64_t size, bool isLocal,
bool isGlobal,
const llvm::Value *allocSite,
size_t alignment) {
if (size>10*1024*1024)
klee_warning_once(0, "Large alloc: %lu bytes. KLEE may run out of memory.",
size);
uint64_t address = 0;
// Use malloc for the standard case
if (alignment <= 8)
address = (uint64_t)malloc(size);
else {
int res = posix_memalign((void **)&address, alignment, size);
if (res < 0) {
klee_warning("Allocating aligned memory failed.");
address = 0;
}
}
if (!address)
return 0;
++stats::allocations;
MemoryObject *res = new MemoryObject(address, size, isLocal, isGlobal, false,
allocSite, this);
objects.insert(res);
return res;
}
MemoryObject *MemoryManager::allocateFixed(uint64_t address, uint64_t size,
const llvm::Value *allocSite) {
#ifndef NDEBUG
for (objects_ty::iterator it = objects.begin(), ie = objects.end();
it != ie; ++it) {
MemoryObject *mo = *it;
if (address+size > mo->address && address < mo->address+mo->size)
klee_error("Trying to allocate an overlapping object");
}
#endif
++stats::allocations;
MemoryObject *res = new MemoryObject(address, size, false, true, true,
allocSite, this);
objects.insert(res);
return res;
}
void MemoryManager::deallocate(const MemoryObject *mo) {
assert(0);
}
void MemoryManager::markFreed(MemoryObject *mo) {
if (objects.find(mo) != objects.end())
{
if (!mo->isFixed)
free((void *)mo->address);
objects.erase(mo);
}
}
|
