1 //===-- llvm-jitlistener.cpp - Utility for testing MCJIT event listener ---===// 2 // 3 // The LLVM Compiler Infrastructure 4 // 5 // This file is distributed under the University of Illinois Open Source 6 // License. See LICENSE.TXT for details. 7 // 8 //===----------------------------------------------------------------------===// 9 // 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. 13 // 14 //===----------------------------------------------------------------------===// 15 16 #include "llvm/IR/LLVMContext.h" 17 #include "../../lib/ExecutionEngine/IntelJITEvents/IntelJITEventsWrapper.h" 18 #include "llvm/ADT/OwningPtr.h" 19 #include "llvm/ADT/Triple.h" 20 #include "llvm/ExecutionEngine/JITEventListener.h" 21 #include "llvm/ExecutionEngine/JITMemoryManager.h" 22 #include "llvm/ExecutionEngine/MCJIT.h" 23 #include "llvm/ExecutionEngine/ObjectImage.h" 24 #include "llvm/IR/Module.h" 25 #include "llvm/IRReader/IRReader.h" 26 #include "llvm/Support/CommandLine.h" 27 #include "llvm/Support/Host.h" 28 #include "llvm/Support/ManagedStatic.h" 29 #include "llvm/Support/MemoryBuffer.h" 30 #include "llvm/Support/PrettyStackTrace.h" 31 #include "llvm/Support/Signals.h" 32 #include "llvm/Support/SourceMgr.h" 33 #include "llvm/Support/TargetSelect.h" 34 #include <string> 35 36 using namespace llvm; 37 38 namespace { 39 40 typedef std::vector<std::pair<std::string, unsigned int> > SourceLocations; 41 typedef std::map<uint64_t, SourceLocations> NativeCodeMap; 42 43 NativeCodeMap ReportedDebugFuncs; 44 45 int NotifyEvent(iJIT_JVM_EVENT EventType, void *EventSpecificData) { 46 switch (EventType) { 47 case iJVM_EVENT_TYPE_METHOD_LOAD_FINISHED: { 48 if (!EventSpecificData) { 49 errs() << 50 "Error: The JIT event listener did not provide a event data."; 51 return -1; 52 } 53 iJIT_Method_Load* msg = static_cast<iJIT_Method_Load*>(EventSpecificData); 54 55 ReportedDebugFuncs[msg->method_id]; 56 57 outs() << "Method load [" << msg->method_id << "]: " << msg->method_name 58 << ", Size = " << msg->method_size << "\n"; 59 60 for(unsigned int i = 0; i < msg->line_number_size; ++i) { 61 if (!msg->line_number_table) { 62 errs() << "A function with a non-zero line count had no line table."; 63 return -1; 64 } 65 std::pair<std::string, unsigned int> loc( 66 std::string(msg->source_file_name), 67 msg->line_number_table[i].LineNumber); 68 ReportedDebugFuncs[msg->method_id].push_back(loc); 69 outs() << " Line info @ " << msg->line_number_table[i].Offset 70 << ": " << msg->source_file_name 71 << ", line " << msg->line_number_table[i].LineNumber << "\n"; 72 } 73 outs() << "\n"; 74 } 75 break; 76 case iJVM_EVENT_TYPE_METHOD_UNLOAD_START: { 77 if (!EventSpecificData) { 78 errs() << 79 "Error: The JIT event listener did not provide a event data."; 80 return -1; 81 } 82 unsigned int UnloadId 83 = *reinterpret_cast<unsigned int*>(EventSpecificData); 84 assert(1 == ReportedDebugFuncs.erase(UnloadId)); 85 outs() << "Method unload [" << UnloadId << "]\n"; 86 } 87 break; 88 default: 89 break; 90 } 91 return 0; 92 } 93 94 iJIT_IsProfilingActiveFlags IsProfilingActive(void) { 95 // for testing, pretend we have an Intel Parallel Amplifier XE 2011 96 // instance attached 97 return iJIT_SAMPLING_ON; 98 } 99 100 unsigned int GetNewMethodID(void) { 101 static unsigned int id = 0; 102 return ++id; 103 } 104 105 class JitEventListenerTest { 106 protected: 107 void InitEE(const std::string &IRFile) { 108 LLVMContext &Context = getGlobalContext(); 109 110 // If we have a native target, initialize it to ensure it is linked in and 111 // usable by the JIT. 112 InitializeNativeTarget(); 113 InitializeNativeTargetAsmPrinter(); 114 115 // Parse the bitcode... 116 SMDiagnostic Err; 117 TheModule = ParseIRFile(IRFile, Err, Context); 118 if (!TheModule) { 119 errs() << Err.getMessage(); 120 return; 121 } 122 123 // FIXME: This is using the default legacy JITMemoryManager because it 124 // supports poison memory. At some point, we'll need to update this to 125 // use an MCJIT-specific memory manager. It might be nice to have the 126 // poison memory option there too. 127 JITMemoryManager *MemMgr = JITMemoryManager::CreateDefaultMemManager(); 128 if (!MemMgr) { 129 errs() << "Unable to create memory manager."; 130 return; 131 } 132 133 // Tell the memory manager to poison freed memory so that accessing freed 134 // memory is more easily tested. 135 MemMgr->setPoisonMemory(true); 136 137 // Override the triple to generate ELF on Windows since that's supported 138 Triple Tuple(TheModule->getTargetTriple()); 139 if (Tuple.getTriple().empty()) 140 Tuple.setTriple(sys::getProcessTriple()); 141 142 if (Tuple.isOSWindows() && Triple::ELF != Tuple.getEnvironment()) { 143 Tuple.setEnvironment(Triple::ELF); 144 TheModule->setTargetTriple(Tuple.getTriple()); 145 } 146 147 // Compile the IR 148 std::string Error; 149 TheJIT.reset(EngineBuilder(TheModule) 150 .setEngineKind(EngineKind::JIT) 151 .setErrorStr(&Error) 152 .setJITMemoryManager(MemMgr) 153 .setUseMCJIT(true) 154 .create()); 155 if (Error.empty() == false) 156 errs() << Error; 157 } 158 159 void DestroyEE() { 160 TheJIT.reset(); 161 } 162 163 LLVMContext Context; // Global ownership 164 Module *TheModule; // Owned by ExecutionEngine. 165 JITMemoryManager *JMM; // Owned by ExecutionEngine. 166 OwningPtr<ExecutionEngine> TheJIT; 167 168 public: 169 void ProcessInput(const std::string &Filename) { 170 InitEE(Filename); 171 172 llvm::OwningPtr<llvm::JITEventListener> Listener(JITEventListener::createIntelJITEventListener( 173 new IntelJITEventsWrapper(NotifyEvent, 0, 174 IsProfilingActive, 0, 0, 175 GetNewMethodID))); 176 177 TheJIT->RegisterJITEventListener(Listener.get()); 178 179 TheJIT->finalizeObject(); 180 181 // Destroy the JIT engine instead of unregistering to get unload events. 182 DestroyEE(); 183 } 184 }; 185 186 187 188 } // end anonymous namespace 189 190 static cl::opt<std::string> 191 InputFilename(cl::Positional, cl::desc("<input IR file>"), 192 cl::Required); 193 194 int main(int argc, char **argv) { 195 // Print a stack trace if we signal out. 196 sys::PrintStackTraceOnErrorSignal(); 197 PrettyStackTraceProgram X(argc, argv); 198 llvm_shutdown_obj Y; // Call llvm_shutdown() on exit. 199 200 cl::ParseCommandLineOptions(argc, argv, "llvm jit event listener test utility\n"); 201 202 JitEventListenerTest Test; 203 204 Test.ProcessInput(InputFilename); 205 206 return 0; 207 } 208
