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
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
|
//===-- llvm-jitlistener.cpp - Utility for testing MCJIT event listener ---===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// This program is a used by lit tests to verify the MCJIT JITEventListener
// interface. It registers a mock JIT event listener, generates a module from
// an input IR file and dumps the reported event information to stdout.
//
//===----------------------------------------------------------------------===//
#include "llvm/IR/LLVMContext.h"
#include "../../lib/ExecutionEngine/IntelJITEvents/IntelJITEventsWrapper.h"
#include "llvm/ADT/OwningPtr.h"
#include "llvm/ADT/Triple.h"
#include "llvm/ExecutionEngine/JITEventListener.h"
#include "llvm/ExecutionEngine/JITMemoryManager.h"
#include "llvm/ExecutionEngine/MCJIT.h"
#include "llvm/ExecutionEngine/ObjectImage.h"
#include "llvm/IR/Module.h"
#include "llvm/IRReader/IRReader.h"
#include "llvm/Support/CommandLine.h"
#include "llvm/Support/Host.h"
#include "llvm/Support/ManagedStatic.h"
#include "llvm/Support/MemoryBuffer.h"
#include "llvm/Support/PrettyStackTrace.h"
#include "llvm/Support/Signals.h"
#include "llvm/Support/SourceMgr.h"
#include "llvm/Support/TargetSelect.h"
#include <string>
using namespace llvm;
namespace {
typedef std::vector<std::pair<std::string, unsigned int> > SourceLocations;
typedef std::map<uint64_t, SourceLocations> NativeCodeMap;
NativeCodeMap ReportedDebugFuncs;
int NotifyEvent(iJIT_JVM_EVENT EventType, void *EventSpecificData) {
switch (EventType) {
case iJVM_EVENT_TYPE_METHOD_LOAD_FINISHED: {
if (!EventSpecificData) {
errs() <<
"Error: The JIT event listener did not provide a event data.";
return -1;
}
iJIT_Method_Load* msg = static_cast<iJIT_Method_Load*>(EventSpecificData);
ReportedDebugFuncs[msg->method_id];
outs() << "Method load [" << msg->method_id << "]: " << msg->method_name
<< ", Size = " << msg->method_size << "\n";
for(unsigned int i = 0; i < msg->line_number_size; ++i) {
if (!msg->line_number_table) {
errs() << "A function with a non-zero line count had no line table.";
return -1;
}
std::pair<std::string, unsigned int> loc(
std::string(msg->source_file_name),
msg->line_number_table[i].LineNumber);
ReportedDebugFuncs[msg->method_id].push_back(loc);
outs() << " Line info @ " << msg->line_number_table[i].Offset
<< ": " << msg->source_file_name
<< ", line " << msg->line_number_table[i].LineNumber << "\n";
}
outs() << "\n";
}
break;
case iJVM_EVENT_TYPE_METHOD_UNLOAD_START: {
if (!EventSpecificData) {
errs() <<
"Error: The JIT event listener did not provide a event data.";
return -1;
}
unsigned int UnloadId
= *reinterpret_cast<unsigned int*>(EventSpecificData);
assert(1 == ReportedDebugFuncs.erase(UnloadId));
outs() << "Method unload [" << UnloadId << "]\n";
}
break;
default:
break;
}
return 0;
}
iJIT_IsProfilingActiveFlags IsProfilingActive(void) {
// for testing, pretend we have an Intel Parallel Amplifier XE 2011
// instance attached
return iJIT_SAMPLING_ON;
}
unsigned int GetNewMethodID(void) {
static unsigned int id = 0;
return ++id;
}
class JitEventListenerTest {
protected:
void InitEE(const std::string &IRFile) {
LLVMContext &Context = getGlobalContext();
// If we have a native target, initialize it to ensure it is linked in and
// usable by the JIT.
InitializeNativeTarget();
InitializeNativeTargetAsmPrinter();
// Parse the bitcode...
SMDiagnostic Err;
TheModule = ParseIRFile(IRFile, Err, Context);
if (!TheModule) {
errs() << Err.getMessage();
return;
}
// FIXME: This is using the default legacy JITMemoryManager because it
// supports poison memory. At some point, we'll need to update this to
// use an MCJIT-specific memory manager. It might be nice to have the
// poison memory option there too.
JITMemoryManager *MemMgr = JITMemoryManager::CreateDefaultMemManager();
if (!MemMgr) {
errs() << "Unable to create memory manager.";
return;
}
// Tell the memory manager to poison freed memory so that accessing freed
// memory is more easily tested.
MemMgr->setPoisonMemory(true);
// Override the triple to generate ELF on Windows since that's supported
Triple Tuple(TheModule->getTargetTriple());
if (Tuple.getTriple().empty())
Tuple.setTriple(sys::getProcessTriple());
if (Tuple.isOSWindows() && Triple::ELF != Tuple.getEnvironment()) {
Tuple.setEnvironment(Triple::ELF);
TheModule->setTargetTriple(Tuple.getTriple());
}
// Compile the IR
std::string Error;
TheJIT.reset(EngineBuilder(TheModule)
.setEngineKind(EngineKind::JIT)
.setErrorStr(&Error)
.setJITMemoryManager(MemMgr)
.setUseMCJIT(true)
.create());
if (Error.empty() == false)
errs() << Error;
}
void DestroyEE() {
TheJIT.reset();
}
LLVMContext Context; // Global ownership
Module *TheModule; // Owned by ExecutionEngine.
JITMemoryManager *JMM; // Owned by ExecutionEngine.
OwningPtr<ExecutionEngine> TheJIT;
public:
void ProcessInput(const std::string &Filename) {
InitEE(Filename);
llvm::OwningPtr<llvm::JITEventListener> Listener(JITEventListener::createIntelJITEventListener(
new IntelJITEventsWrapper(NotifyEvent, 0,
IsProfilingActive, 0, 0,
GetNewMethodID)));
TheJIT->RegisterJITEventListener(Listener.get());
TheJIT->finalizeObject();
// Destroy the JIT engine instead of unregistering to get unload events.
DestroyEE();
}
};
} // end anonymous namespace
static cl::opt<std::string>
InputFilename(cl::Positional, cl::desc("<input IR file>"),
cl::Required);
int main(int argc, char **argv) {
// Print a stack trace if we signal out.
sys::PrintStackTraceOnErrorSignal();
PrettyStackTraceProgram X(argc, argv);
llvm_shutdown_obj Y; // Call llvm_shutdown() on exit.
cl::ParseCommandLineOptions(argc, argv, "llvm jit event listener test utility\n");
JitEventListenerTest Test;
Test.ProcessInput(InputFilename);
return 0;
}
|
