1 //===-- llvm-jitlistener.cpp - Utility for testing MCJIT event listener ---===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // This program is a used by lit tests to verify the MCJIT JITEventListener
11 // interface. It registers a mock JIT event listener, generates a module from
12 // an input IR file and dumps the reported event information to stdout.
14 //===----------------------------------------------------------------------===//
16 #include "llvm/IR/LLVMContext.h"
17 #include "../../lib/ExecutionEngine/IntelJITEvents/IntelJITEventsWrapper.h"
18 #include "llvm/ADT/Triple.h"
19 #include "llvm/ExecutionEngine/JITEventListener.h"
20 #include "llvm/ExecutionEngine/JITMemoryManager.h"
21 #include "llvm/ExecutionEngine/MCJIT.h"
22 #include "llvm/ExecutionEngine/ObjectImage.h"
23 #include "llvm/IR/Module.h"
24 #include "llvm/IRReader/IRReader.h"
25 #include "llvm/Support/CommandLine.h"
26 #include "llvm/Support/Host.h"
27 #include "llvm/Support/ManagedStatic.h"
28 #include "llvm/Support/MemoryBuffer.h"
29 #include "llvm/Support/PrettyStackTrace.h"
30 #include "llvm/Support/Signals.h"
31 #include "llvm/Support/SourceMgr.h"
32 #include "llvm/Support/TargetSelect.h"
39 typedef std::vector<std::pair<std::string, unsigned int> > SourceLocations;
40 typedef std::map<uint64_t, SourceLocations> NativeCodeMap;
42 NativeCodeMap ReportedDebugFuncs;
44 int NotifyEvent(iJIT_JVM_EVENT EventType, void *EventSpecificData) {
46 case iJVM_EVENT_TYPE_METHOD_LOAD_FINISHED: {
47 if (!EventSpecificData) {
49 "Error: The JIT event listener did not provide a event data.";
52 iJIT_Method_Load* msg = static_cast<iJIT_Method_Load*>(EventSpecificData);
54 ReportedDebugFuncs[msg->method_id];
56 outs() << "Method load [" << msg->method_id << "]: " << msg->method_name
57 << ", Size = " << msg->method_size << "\n";
59 for(unsigned int i = 0; i < msg->line_number_size; ++i) {
60 if (!msg->line_number_table) {
61 errs() << "A function with a non-zero line count had no line table.";
64 std::pair<std::string, unsigned int> loc(
65 std::string(msg->source_file_name),
66 msg->line_number_table[i].LineNumber);
67 ReportedDebugFuncs[msg->method_id].push_back(loc);
68 outs() << " Line info @ " << msg->line_number_table[i].Offset
69 << ": " << msg->source_file_name
70 << ", line " << msg->line_number_table[i].LineNumber << "\n";
75 case iJVM_EVENT_TYPE_METHOD_UNLOAD_START: {
76 if (!EventSpecificData) {
78 "Error: The JIT event listener did not provide a event data.";
82 = *reinterpret_cast<unsigned int*>(EventSpecificData);
83 assert(1 == ReportedDebugFuncs.erase(UnloadId));
84 outs() << "Method unload [" << UnloadId << "]\n";
93 iJIT_IsProfilingActiveFlags IsProfilingActive(void) {
94 // for testing, pretend we have an Intel Parallel Amplifier XE 2011
96 return iJIT_SAMPLING_ON;
99 unsigned int GetNewMethodID(void) {
100 static unsigned int id = 0;
104 class JitEventListenerTest {
106 void InitEE(const std::string &IRFile) {
107 LLVMContext &Context = getGlobalContext();
109 // If we have a native target, initialize it to ensure it is linked in and
110 // usable by the JIT.
111 InitializeNativeTarget();
112 InitializeNativeTargetAsmPrinter();
114 // Parse the bitcode...
116 TheModule = ParseIRFile(IRFile, Err, Context);
118 errs() << Err.getMessage();
122 // FIXME: This is using the default legacy JITMemoryManager because it
123 // supports poison memory. At some point, we'll need to update this to
124 // use an MCJIT-specific memory manager. It might be nice to have the
125 // poison memory option there too.
126 JITMemoryManager *MemMgr = JITMemoryManager::CreateDefaultMemManager();
128 errs() << "Unable to create memory manager.";
132 // Tell the memory manager to poison freed memory so that accessing freed
133 // memory is more easily tested.
134 MemMgr->setPoisonMemory(true);
136 // Override the triple to generate ELF on Windows since that's supported
137 Triple Tuple(TheModule->getTargetTriple());
138 if (Tuple.getTriple().empty())
139 Tuple.setTriple(sys::getProcessTriple());
141 if (Tuple.isOSWindows() && !Tuple.isOSBinFormatELF()) {
142 Tuple.setObjectFormat(Triple::ELF);
143 TheModule->setTargetTriple(Tuple.getTriple());
148 TheJIT.reset(EngineBuilder(TheModule)
149 .setEngineKind(EngineKind::JIT)
151 .setJITMemoryManager(MemMgr)
154 if (Error.empty() == false)
162 LLVMContext Context; // Global ownership
163 Module *TheModule; // Owned by ExecutionEngine.
164 JITMemoryManager *JMM; // Owned by ExecutionEngine.
165 std::unique_ptr<ExecutionEngine> TheJIT;
168 void ProcessInput(const std::string &Filename) {
171 std::unique_ptr<llvm::JITEventListener> Listener(
172 JITEventListener::createIntelJITEventListener(new IntelJITEventsWrapper(
173 NotifyEvent, 0, IsProfilingActive, 0, 0, GetNewMethodID)));
175 TheJIT->RegisterJITEventListener(Listener.get());
177 TheJIT->finalizeObject();
179 // Destroy the JIT engine instead of unregistering to get unload events.
186 } // end anonymous namespace
188 static cl::opt<std::string>
189 InputFilename(cl::Positional, cl::desc("<input IR file>"),
192 int main(int argc, char **argv) {
193 // Print a stack trace if we signal out.
194 sys::PrintStackTraceOnErrorSignal();
195 PrettyStackTraceProgram X(argc, argv);
196 llvm_shutdown_obj Y; // Call llvm_shutdown() on exit.
198 cl::ParseCommandLineOptions(argc, argv, "llvm jit event listener test utility\n");
200 JitEventListenerTest Test;
202 Test.ProcessInput(InputFilename);