1 //===-- IntelJITEventListener.cpp - Tell Intel profiler about JITed code --===// 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 file defines a JITEventListener object to tell Intel(R) VTune(TM) 11 // Amplifier XE 2011 about JITted functions. 12 // 13 //===----------------------------------------------------------------------===// 14 15 #include "llvm/Config/config.h" 16 #include "llvm/ExecutionEngine/JITEventListener.h" 17 18 #include "llvm/IR/DebugInfo.h" 19 #include "llvm/IR/Function.h" 20 #include "llvm/IR/Metadata.h" 21 #include "llvm/ADT/DenseMap.h" 22 #include "llvm/CodeGen/MachineFunction.h" 23 #include "llvm/DebugInfo/DIContext.h" 24 #include "llvm/ExecutionEngine/ObjectImage.h" 25 #include "llvm/Object/ObjectFile.h" 26 #include "llvm/Support/Debug.h" 27 #include "llvm/Support/raw_ostream.h" 28 #include "llvm/Support/Errno.h" 29 #include "llvm/IR/ValueHandle.h" 30 #include "EventListenerCommon.h" 31 #include "IntelJITEventsWrapper.h" 32 33 using namespace llvm; 34 using namespace llvm::jitprofiling; 35 36 #define DEBUG_TYPE "amplifier-jit-event-listener" 37 38 namespace { 39 40 class IntelJITEventListener : public JITEventListener { 41 typedef DenseMap<void*, unsigned int> MethodIDMap; 42 43 std::unique_ptr<IntelJITEventsWrapper> Wrapper; 44 MethodIDMap MethodIDs; 45 FilenameCache Filenames; 46 47 typedef SmallVector<const void *, 64> MethodAddressVector; 48 typedef DenseMap<const void *, MethodAddressVector> ObjectMap; 49 50 ObjectMap LoadedObjectMap; 51 52 public: 53 IntelJITEventListener(IntelJITEventsWrapper* libraryWrapper) { 54 Wrapper.reset(libraryWrapper); 55 } 56 57 ~IntelJITEventListener() { 58 } 59 60 virtual void NotifyFunctionEmitted(const Function &F, 61 void *FnStart, size_t FnSize, 62 const EmittedFunctionDetails &Details); 63 64 virtual void NotifyFreeingMachineCode(void *OldPtr); 65 66 virtual void NotifyObjectEmitted(const ObjectImage &Obj); 67 68 virtual void NotifyFreeingObject(const ObjectImage &Obj); 69 }; 70 71 static LineNumberInfo LineStartToIntelJITFormat( 72 uintptr_t StartAddress, 73 uintptr_t Address, 74 DebugLoc Loc) { 75 LineNumberInfo Result; 76 77 Result.Offset = Address - StartAddress; 78 Result.LineNumber = Loc.getLine(); 79 80 return Result; 81 } 82 83 static LineNumberInfo DILineInfoToIntelJITFormat(uintptr_t StartAddress, 84 uintptr_t Address, 85 DILineInfo Line) { 86 LineNumberInfo Result; 87 88 Result.Offset = Address - StartAddress; 89 Result.LineNumber = Line.Line; 90 91 return Result; 92 } 93 94 static iJIT_Method_Load FunctionDescToIntelJITFormat( 95 IntelJITEventsWrapper& Wrapper, 96 const char* FnName, 97 uintptr_t FnStart, 98 size_t FnSize) { 99 iJIT_Method_Load Result; 100 memset(&Result, 0, sizeof(iJIT_Method_Load)); 101 102 Result.method_id = Wrapper.iJIT_GetNewMethodID(); 103 Result.method_name = const_cast<char*>(FnName); 104 Result.method_load_address = reinterpret_cast<void*>(FnStart); 105 Result.method_size = FnSize; 106 107 Result.class_id = 0; 108 Result.class_file_name = NULL; 109 Result.user_data = NULL; 110 Result.user_data_size = 0; 111 Result.env = iJDE_JittingAPI; 112 113 return Result; 114 } 115 116 // Adds the just-emitted function to the symbol table. 117 void IntelJITEventListener::NotifyFunctionEmitted( 118 const Function &F, void *FnStart, size_t FnSize, 119 const EmittedFunctionDetails &Details) { 120 iJIT_Method_Load FunctionMessage = FunctionDescToIntelJITFormat(*Wrapper, 121 F.getName().data(), 122 reinterpret_cast<uint64_t>(FnStart), 123 FnSize); 124 125 std::vector<LineNumberInfo> LineInfo; 126 127 if (!Details.LineStarts.empty()) { 128 // Now convert the line number information from the address/DebugLoc 129 // format in Details to the offset/lineno in Intel JIT API format. 130 131 LineInfo.reserve(Details.LineStarts.size() + 1); 132 133 DebugLoc FirstLoc = Details.LineStarts[0].Loc; 134 assert(!FirstLoc.isUnknown() 135 && "LineStarts should not contain unknown DebugLocs"); 136 137 MDNode *FirstLocScope = FirstLoc.getScope(F.getContext()); 138 DISubprogram FunctionDI = getDISubprogram(FirstLocScope); 139 if (FunctionDI.Verify()) { 140 FunctionMessage.source_file_name = const_cast<char*>( 141 Filenames.getFullPath(FirstLocScope)); 142 143 LineNumberInfo FirstLine; 144 FirstLine.Offset = 0; 145 FirstLine.LineNumber = FunctionDI.getLineNumber(); 146 LineInfo.push_back(FirstLine); 147 } 148 149 for (std::vector<EmittedFunctionDetails::LineStart>::const_iterator I = 150 Details.LineStarts.begin(), E = Details.LineStarts.end(); 151 I != E; ++I) { 152 // This implementation ignores the DebugLoc filename because the Intel 153 // JIT API does not support multiple source files associated with a single 154 // JIT function 155 LineInfo.push_back(LineStartToIntelJITFormat( 156 reinterpret_cast<uintptr_t>(FnStart), 157 I->Address, 158 I->Loc)); 159 160 // If we have no file name yet for the function, use the filename from 161 // the first instruction that has one 162 if (FunctionMessage.source_file_name == 0) { 163 MDNode *scope = I->Loc.getScope( 164 Details.MF->getFunction()->getContext()); 165 FunctionMessage.source_file_name = const_cast<char*>( 166 Filenames.getFullPath(scope)); 167 } 168 } 169 170 FunctionMessage.line_number_size = LineInfo.size(); 171 FunctionMessage.line_number_table = &*LineInfo.begin(); 172 } else { 173 FunctionMessage.line_number_size = 0; 174 FunctionMessage.line_number_table = 0; 175 } 176 177 Wrapper->iJIT_NotifyEvent(iJVM_EVENT_TYPE_METHOD_LOAD_FINISHED, 178 &FunctionMessage); 179 MethodIDs[FnStart] = FunctionMessage.method_id; 180 } 181 182 void IntelJITEventListener::NotifyFreeingMachineCode(void *FnStart) { 183 MethodIDMap::iterator I = MethodIDs.find(FnStart); 184 if (I != MethodIDs.end()) { 185 Wrapper->iJIT_NotifyEvent(iJVM_EVENT_TYPE_METHOD_UNLOAD_START, &I->second); 186 MethodIDs.erase(I); 187 } 188 } 189 190 void IntelJITEventListener::NotifyObjectEmitted(const ObjectImage &Obj) { 191 // Get the address of the object image for use as a unique identifier 192 const void* ObjData = Obj.getData().data(); 193 DIContext* Context = DIContext::getDWARFContext(Obj.getObjectFile()); 194 MethodAddressVector Functions; 195 196 // Use symbol info to iterate functions in the object. 197 for (object::symbol_iterator I = Obj.begin_symbols(), 198 E = Obj.end_symbols(); 199 I != E; 200 ++I) { 201 std::vector<LineNumberInfo> LineInfo; 202 std::string SourceFileName; 203 204 object::SymbolRef::Type SymType; 205 if (I->getType(SymType)) continue; 206 if (SymType == object::SymbolRef::ST_Function) { 207 StringRef Name; 208 uint64_t Addr; 209 uint64_t Size; 210 if (I->getName(Name)) continue; 211 if (I->getAddress(Addr)) continue; 212 if (I->getSize(Size)) continue; 213 214 // Record this address in a local vector 215 Functions.push_back((void*)Addr); 216 217 // Build the function loaded notification message 218 iJIT_Method_Load FunctionMessage = FunctionDescToIntelJITFormat(*Wrapper, 219 Name.data(), 220 Addr, 221 Size); 222 if (Context) { 223 DILineInfoTable Lines = Context->getLineInfoForAddressRange(Addr, Size); 224 DILineInfoTable::iterator Begin = Lines.begin(); 225 DILineInfoTable::iterator End = Lines.end(); 226 for (DILineInfoTable::iterator It = Begin; It != End; ++It) { 227 LineInfo.push_back(DILineInfoToIntelJITFormat((uintptr_t)Addr, 228 It->first, 229 It->second)); 230 } 231 if (LineInfo.size() == 0) { 232 FunctionMessage.source_file_name = 0; 233 FunctionMessage.line_number_size = 0; 234 FunctionMessage.line_number_table = 0; 235 } else { 236 SourceFileName = Lines.front().second.FileName; 237 FunctionMessage.source_file_name = const_cast<char *>(SourceFileName.c_str()); 238 FunctionMessage.line_number_size = LineInfo.size(); 239 FunctionMessage.line_number_table = &*LineInfo.begin(); 240 } 241 } else { 242 FunctionMessage.source_file_name = 0; 243 FunctionMessage.line_number_size = 0; 244 FunctionMessage.line_number_table = 0; 245 } 246 247 Wrapper->iJIT_NotifyEvent(iJVM_EVENT_TYPE_METHOD_LOAD_FINISHED, 248 &FunctionMessage); 249 MethodIDs[(void*)Addr] = FunctionMessage.method_id; 250 } 251 } 252 253 // To support object unload notification, we need to keep a list of 254 // registered function addresses for each loaded object. We will 255 // use the MethodIDs map to get the registered ID for each function. 256 LoadedObjectMap[ObjData] = Functions; 257 } 258 259 void IntelJITEventListener::NotifyFreeingObject(const ObjectImage &Obj) { 260 // Get the address of the object image for use as a unique identifier 261 const void* ObjData = Obj.getData().data(); 262 263 // Get the object's function list from LoadedObjectMap 264 ObjectMap::iterator OI = LoadedObjectMap.find(ObjData); 265 if (OI == LoadedObjectMap.end()) 266 return; 267 MethodAddressVector& Functions = OI->second; 268 269 // Walk the function list, unregistering each function 270 for (MethodAddressVector::iterator FI = Functions.begin(), 271 FE = Functions.end(); 272 FI != FE; 273 ++FI) { 274 void* FnStart = const_cast<void*>(*FI); 275 MethodIDMap::iterator MI = MethodIDs.find(FnStart); 276 if (MI != MethodIDs.end()) { 277 Wrapper->iJIT_NotifyEvent(iJVM_EVENT_TYPE_METHOD_UNLOAD_START, 278 &MI->second); 279 MethodIDs.erase(MI); 280 } 281 } 282 283 // Erase the object from LoadedObjectMap 284 LoadedObjectMap.erase(OI); 285 } 286 287 } // anonymous namespace. 288 289 namespace llvm { 290 JITEventListener *JITEventListener::createIntelJITEventListener() { 291 return new IntelJITEventListener(new IntelJITEventsWrapper); 292 } 293 294 // for testing 295 JITEventListener *JITEventListener::createIntelJITEventListener( 296 IntelJITEventsWrapper* TestImpl) { 297 return new IntelJITEventListener(TestImpl); 298 } 299 300 } // namespace llvm 301 302
