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
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
|
//===-- KModule.h -----------------------------------------------*- C++ -*-===//
//
// The KLEE Symbolic Virtual Machine
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#ifndef KLEE_KMODULE_H
#define KLEE_KMODULE_H
#include "klee/Config/Version.h"
#include "klee/Core/Interpreter.h"
#include "klee/Module/KCallable.h"
#include "llvm/ADT/ArrayRef.h"
#include <map>
#include <memory>
#include <set>
#include <vector>
namespace llvm {
class BasicBlock;
class Constant;
class Function;
class Instruction;
class Module;
class DataLayout;
}
namespace klee {
struct Cell;
class Executor;
class Expr;
class InterpreterHandler;
class InstructionInfoTable;
struct KInstruction;
class KModule;
template<class T> class ref;
struct KFunction : public KCallable {
llvm::Function *function;
unsigned numArgs, numRegisters;
unsigned numInstructions;
KInstruction **instructions;
std::map<llvm::BasicBlock*, unsigned> basicBlockEntry;
/// Whether instructions in this function should count as
/// "coverable" for statistics and search heuristics.
bool trackCoverage;
explicit KFunction(llvm::Function*, KModule*);
KFunction(const KFunction &) = delete;
KFunction &operator=(const KFunction &) = delete;
~KFunction();
unsigned getArgRegister(unsigned index) { return index; }
llvm::StringRef getName() const override { return function->getName(); }
llvm::PointerType *getType() const override { return function->getType(); }
llvm::Value *getValue() override { return function; }
static bool classof(const KCallable *callable) {
return callable->getKind() == CK_Function;
}
};
class KConstant {
public:
/// Actual LLVM constant this represents.
llvm::Constant* ct;
/// The constant ID.
unsigned id;
/// First instruction where this constant was encountered, or NULL
/// if not applicable/unavailable.
KInstruction *ki;
KConstant(llvm::Constant*, unsigned, KInstruction*);
};
class KModule {
public:
std::unique_ptr<llvm::Module> module;
std::unique_ptr<llvm::DataLayout> targetData;
// Our shadow versions of LLVM structures.
std::vector<std::unique_ptr<KFunction>> functions;
std::map<llvm::Function*, KFunction*> functionMap;
// Functions which escape (may be called indirectly)
// XXX change to KFunction
std::set<llvm::Function*> escapingFunctions;
std::unique_ptr<InstructionInfoTable> infos;
std::vector<llvm::Constant*> constants;
std::map<const llvm::Constant *, std::unique_ptr<KConstant>> constantMap;
KConstant* getKConstant(const llvm::Constant *c);
std::unique_ptr<Cell[]> constantTable;
// Functions which are part of KLEE runtime
std::set<const llvm::Function*> internalFunctions;
private:
// Mark function with functionName as part of the KLEE runtime
void addInternalFunction(const char* functionName);
public:
KModule() = default;
/// Optimise and prepare module such that KLEE can execute it
//
void optimiseAndPrepare(const Interpreter::ModuleOptions &opts,
llvm::ArrayRef<const char *>);
/// Manifest the generated module (e.g. assembly.ll, output.bc) and
/// prepares KModule
///
/// @param ih
/// @param forceSourceOutput true if assembly.ll should be created
///
// FIXME: ihandler should not be here
void manifest(InterpreterHandler *ih, bool forceSourceOutput);
/// Link the provided modules together as one KLEE module.
///
/// If the entry point is empty, all modules are linked together.
/// If the entry point is not empty, all modules are linked which resolve
/// the dependencies of the module containing entryPoint
///
/// @param modules list of modules to be linked together
/// @param entryPoint name of the function which acts as the program's entry
/// point
/// @return true if at least one module has been linked in, false if nothing
/// changed
bool link(std::vector<std::unique_ptr<llvm::Module>> &modules,
const std::string &entryPoint);
void instrument(const Interpreter::ModuleOptions &opts);
/// Return an id for the given constant, creating a new one if necessary.
unsigned getConstantID(llvm::Constant *c, KInstruction* ki);
/// Run passes that check if module is valid LLVM IR and if invariants
/// expected by KLEE's Executor hold.
void checkModule();
};
} // End klee namespace
#endif /* KLEE_KMODULE_H */
|
