lib/ExecutionEngine/IntelJITEvents/IntelJITEventListener.cpp - llvm-project/llvm - Git at Google

 //===-- IntelJITEventListener.cpp - Tell Intel profiler about JITed code --===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // This file defines a JITEventListener object to tell Intel(R) VTune(TM)
 // Amplifier XE 2011 about JITted functions.
 //
 //===----------------------------------------------------------------------===//

 #include "IntelJITEventsWrapper.h"
 #include "ittnotify.h"
 #include "llvm-c/ExecutionEngine.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/CodeGen/MachineFunction.h"
 #include "llvm/Config/config.h"
 #include "llvm/DebugInfo/DIContext.h"
 #include "llvm/DebugInfo/DWARF/DWARFContext.h"
 #include "llvm/ExecutionEngine/JITEventListener.h"
 #include "llvm/IR/DebugInfo.h"
 #include "llvm/IR/Function.h"
 #include "llvm/IR/Metadata.h"
 #include "llvm/IR/ValueHandle.h"
 #include "llvm/Object/ObjectFile.h"
 #include "llvm/Object/SymbolSize.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/Errno.h"
 #include "llvm/Support/raw_ostream.h"

 using namespace llvm;
 using namespace llvm::object;

 #define DEBUG_TYPE "amplifier-jit-event-listener"

 namespace {

 class IntelIttnotifyInfo {
   std::string ModuleName;
   std::vector<std::string> SectionNamesVector;
   std::vector<__itt_section_info> SectionInfoVector;
   __itt_module_object *ModuleObject;
   IntelJITEventsWrapper &WrapperRef;

 public:
   IntelIttnotifyInfo(IntelJITEventsWrapper &Wrapper)
       : ModuleObject(NULL), WrapperRef(Wrapper){};
   ~IntelIttnotifyInfo() { delete ModuleObject; };

   void setModuleName(const char *Name) { ModuleName = std::string(Name); }

   const char *getModuleName() { return ModuleName.c_str(); }

   void setModuleObject(__itt_module_object *ModuleObj) {
     ModuleObject = ModuleObj;
   }

   __itt_module_object *getModuleObject() { return ModuleObject; }

   __itt_section_info *getSectionInfoVectorBegin() {
     if (SectionInfoVector.size())
       return &SectionInfoVector[0];
     return NULL;
   }

   void reportSection(llvm::IttEventType EventType, const char *SectionName,
                      unsigned int SectionSize) {
     WrapperRef.iJitIttNotifyInfo(EventType, SectionName, SectionSize);
   }

   int fillSectionInformation(const ObjectFile &Obj,
                              const RuntimeDyld::LoadedObjectInfo &L) {

     int SectionCounter = 0;

     for (auto &Section : Obj.sections()) {
       uint64_t SectionLoadAddr = L.getSectionLoadAddress(Section);
       if (SectionLoadAddr) {
         object::ELFSectionRef ElfSection(Section);

         __itt_section_info SectionInfo;
         memset(&SectionInfo, 0, sizeof(SectionInfo));
         SectionInfo.start_addr = reinterpret_cast<void *>(SectionLoadAddr);
         SectionInfo.file_offset = ElfSection.getOffset();
         SectionInfo.flags = ElfSection.getFlags();

         StringRef SectionName("");
         auto SectionNameOrError = ElfSection.getName();
         if (SectionNameOrError)
           SectionName = *SectionNameOrError;

         SectionNamesVector.push_back(SectionName.str());
         SectionInfo.size = ElfSection.getSize();
         reportSection(llvm::LoadBinarySection, SectionName.str().c_str(),
                       SectionInfo.size);

         if (ElfSection.isBSS()) {
           SectionInfo.type = itt_section_type_bss;
         } else if (ElfSection.isData()) {
           SectionInfo.type = itt_section_type_data;
         } else if (ElfSection.isText()) {
           SectionInfo.type = itt_section_type_text;
         }
         SectionInfoVector.push_back(SectionInfo);
         ++SectionCounter;
       }
     }
     // Hereinafter: don't change SectionNamesVector content to avoid vector
     // reallocation - reallocation invalidates all the references, pointers, and
     // iterators referring to the elements in the sequence.
     for (int I = 0; I < SectionCounter; ++I) {
       SectionInfoVector[I].name = SectionNamesVector[I].c_str();
     }
     return SectionCounter;
   }
 };

 class IntelJITEventListener : public JITEventListener {
   typedef DenseMap<void*, unsigned int> MethodIDMap;

   std::unique_ptr<IntelJITEventsWrapper> Wrapper;
   MethodIDMap MethodIDs;

   typedef SmallVector<const void *, 64> MethodAddressVector;
   typedef DenseMap<const void *, MethodAddressVector>  ObjectMap;

   ObjectMap  LoadedObjectMap;
   std::map<ObjectKey, OwningBinary<ObjectFile>> DebugObjects;

   std::map<ObjectKey, std::unique_ptr<IntelIttnotifyInfo>> KeyToIttnotify;

 public:
   IntelJITEventListener(IntelJITEventsWrapper* libraryWrapper) {
       Wrapper.reset(libraryWrapper);
   }

   ~IntelJITEventListener() {
   }

   void notifyObjectLoaded(ObjectKey Key, const ObjectFile &Obj,
                           const RuntimeDyld::LoadedObjectInfo &L) override;

   void notifyFreeingObject(ObjectKey Key) override;
 };

 static LineNumberInfo DILineInfoToIntelJITFormat(uintptr_t StartAddress,
                                                  uintptr_t Address,
                                                  DILineInfo Line) {
   LineNumberInfo Result;

   Result.Offset = Address - StartAddress;
   Result.LineNumber = Line.Line;

   return Result;
 }

 static iJIT_Method_Load FunctionDescToIntelJITFormat(
     IntelJITEventsWrapper& Wrapper,
     const char* FnName,
     uintptr_t FnStart,
     size_t FnSize) {
   iJIT_Method_Load Result;
   memset(&Result, 0, sizeof(iJIT_Method_Load));

   Result.method_id = Wrapper.iJIT_GetNewMethodID();
   Result.method_name = const_cast<char*>(FnName);
   Result.method_load_address = reinterpret_cast<void*>(FnStart);
   Result.method_size = FnSize;

   Result.class_id = 0;
   Result.class_file_name = NULL;
   Result.user_data = NULL;
   Result.user_data_size = 0;
   Result.env = iJDE_JittingAPI;

   return Result;
 }

 int getBackwardCompatibilityMode() {

   char *BackwardCompatibilityEnv = getenv("INTEL_JIT_BACKWARD_COMPATIBILITY");
   int BackwardCompatibilityMode = 0;
   if (BackwardCompatibilityEnv) {
     StringRef(BackwardCompatibilityEnv)
         .getAsInteger(10, BackwardCompatibilityMode);
   }
   return BackwardCompatibilityMode;
 }

 void IntelJITEventListener::notifyObjectLoaded(
     ObjectKey Key, const ObjectFile &Obj,
     const RuntimeDyld::LoadedObjectInfo &L) {

   int BackwardCompatibilityMode = getBackwardCompatibilityMode();
   if (BackwardCompatibilityMode == 0) {
     if (Obj.isELF()) {
       std::unique_ptr<IntelIttnotifyInfo> ModuleIttnotify =
           std::make_unique<IntelIttnotifyInfo>(*Wrapper);
       ModuleIttnotify->setModuleName(
           StringRef(llvm::utohexstr(
                         MD5Hash(Obj.getMemoryBufferRef().getBuffer()), true))
               .str()
               .c_str());

       __itt_module_object *ModuleObject = new __itt_module_object();
       ModuleObject->module_name = ModuleIttnotify->getModuleName();
       ModuleObject->module_size = Obj.getMemoryBufferRef().getBufferSize();
       Wrapper->iJitIttNotifyInfo(llvm::LoadBinaryModule,
                                  ModuleObject->module_name,
                                  ModuleObject->module_size);
       ModuleObject->module_type = __itt_module_type_elf;
       ModuleObject->section_number =
           ModuleIttnotify->fillSectionInformation(Obj, L);
       ModuleObject->module_buffer =
           (void *)const_cast<char *>(Obj.getMemoryBufferRef().getBufferStart());
       ModuleObject->module_id =
           __itt_id_make((void *)&(*ModuleObject), ModuleObject->module_size);
       ModuleObject->section_array =
           ModuleIttnotify->getSectionInfoVectorBegin();
       ModuleIttnotify->setModuleObject(ModuleObject);

       __itt_module_load_with_sections(ModuleObject);

       KeyToIttnotify[Key] = std::move(ModuleIttnotify);
     }
   } else if (BackwardCompatibilityMode == 1) {

     OwningBinary<ObjectFile> DebugObjOwner = L.getObjectForDebug(Obj);
     const ObjectFile *DebugObj = DebugObjOwner.getBinary();
     if (!DebugObj)
       return;

     // Get the address of the object image for use as a unique identifier
     const void *ObjData = DebugObj->getData().data();
     std::unique_ptr<DIContext> Context = DWARFContext::create(*DebugObj);
     MethodAddressVector Functions;

     // Use symbol info to iterate functions in the object.
     for (const std::pair<SymbolRef, uint64_t> &P :
          computeSymbolSizes(*DebugObj)) {
       SymbolRef Sym = P.first;
       std::vector<LineNumberInfo> LineInfo;
       std::string SourceFileName;

       Expected<SymbolRef::Type> SymTypeOrErr = Sym.getType();
       if (!SymTypeOrErr) {
         // TODO: Actually report errors helpfully.
         consumeError(SymTypeOrErr.takeError());
         continue;
       }
       SymbolRef::Type SymType = *SymTypeOrErr;
       if (SymType != SymbolRef::ST_Function)
         continue;

       Expected<StringRef> Name = Sym.getName();
       if (!Name) {
         // TODO: Actually report errors helpfully.
         consumeError(Name.takeError());
         continue;
       }

       Expected<uint64_t> AddrOrErr = Sym.getAddress();
       if (!AddrOrErr) {
         // TODO: Actually report errors helpfully.
         consumeError(AddrOrErr.takeError());
         continue;
       }
       uint64_t Addr = *AddrOrErr;
       uint64_t Size = P.second;

       auto SecOrErr = Sym.getSection();
       if (!SecOrErr) {
         // TODO: Actually report errors helpfully.
         consumeError(SecOrErr.takeError());
         continue;
       }
       object::section_iterator Sec = *SecOrErr;
       if (Sec == Obj.section_end())
         continue;
       uint64_t Index = Sec->getIndex();

       // Record this address in a local vector
       Functions.push_back((void *)Addr);

       // Build the function loaded notification message
       iJIT_Method_Load FunctionMessage =
           FunctionDescToIntelJITFormat(*Wrapper, Name->data(), Addr, Size);
       DILineInfoTable Lines =
           Context->getLineInfoForAddressRange({Addr, Index}, Size);
       DILineInfoTable::iterator Begin = Lines.begin();
       DILineInfoTable::iterator End = Lines.end();
       for (DILineInfoTable::iterator It = Begin; It != End; ++It) {
         LineInfo.push_back(
             DILineInfoToIntelJITFormat((uintptr_t)Addr, It->first, It->second));
       }
       if (LineInfo.size() == 0) {
         FunctionMessage.source_file_name = 0;
         FunctionMessage.line_number_size = 0;
         FunctionMessage.line_number_table = 0;
       } else {
         // Source line information for the address range is provided as
         // a code offset for the start of the corresponding sub-range and
         // a source line. JIT API treats offsets in LineNumberInfo structures
         // as the end of the corresponding code region. The start of the code
         // is taken from the previous element. Need to shift the elements.

         LineNumberInfo last = LineInfo.back();
         last.Offset = FunctionMessage.method_size;
         LineInfo.push_back(last);
         for (size_t i = LineInfo.size() - 2; i > 0; --i)
           LineInfo[i].LineNumber = LineInfo[i - 1].LineNumber;

         SourceFileName = Lines.front().second.FileName;
         FunctionMessage.source_file_name =
             const_cast<char *>(SourceFileName.c_str());
         FunctionMessage.line_number_size = LineInfo.size();
         FunctionMessage.line_number_table = &*LineInfo.begin();
       }

       Wrapper->iJIT_NotifyEvent(iJVM_EVENT_TYPE_METHOD_LOAD_FINISHED,
                                 &FunctionMessage);
       MethodIDs[(void *)Addr] = FunctionMessage.method_id;
     }

     // To support object unload notification, we need to keep a list of
     // registered function addresses for each loaded object.  We will
     // use the MethodIDs map to get the registered ID for each function.
     LoadedObjectMap[ObjData] = Functions;
     DebugObjects[Key] = std::move(DebugObjOwner);
   }
 }

 void IntelJITEventListener::notifyFreeingObject(ObjectKey Key) {

   int BackwardCompatibilityMode = getBackwardCompatibilityMode();
   if (BackwardCompatibilityMode == 0) {
     if (KeyToIttnotify.find(Key) == KeyToIttnotify.end())
       return;
     __itt_module_unload_with_sections(KeyToIttnotify[Key]->getModuleObject());
     Wrapper->iJitIttNotifyInfo(
         llvm::UnloadBinaryModule,
         KeyToIttnotify[Key]->getModuleObject()->module_name,
         KeyToIttnotify[Key]->getModuleObject()->module_size);
     KeyToIttnotify.erase(Key);
   } else if (BackwardCompatibilityMode == 1) {
     // This object may not have been registered with the listener. If it wasn't,
     // bail out.
     if (DebugObjects.find(Key) == DebugObjects.end())
       return;

     // Get the address of the object image for use as a unique identifier
     const ObjectFile &DebugObj = *DebugObjects[Key].getBinary();
     const void *ObjData = DebugObj.getData().data();

     // Get the object's function list from LoadedObjectMap
     ObjectMap::iterator OI = LoadedObjectMap.find(ObjData);
     if (OI == LoadedObjectMap.end())
       return;
     MethodAddressVector &Functions = OI->second;

     // Walk the function list, unregistering each function
     for (MethodAddressVector::iterator FI = Functions.begin(),
                                        FE = Functions.end();
          FI != FE; ++FI) {
       void *FnStart = const_cast<void *>(*FI);
       MethodIDMap::iterator MI = MethodIDs.find(FnStart);
       if (MI != MethodIDs.end()) {
         Wrapper->iJIT_NotifyEvent(iJVM_EVENT_TYPE_METHOD_UNLOAD_START,
                                   &MI->second);
         MethodIDs.erase(MI);
       }
     }

     // Erase the object from LoadedObjectMap
     LoadedObjectMap.erase(OI);
     DebugObjects.erase(Key);
   }
 }

 }  // anonymous namespace.

 namespace llvm {
 JITEventListener *JITEventListener::createIntelJITEventListener() {
   return new IntelJITEventListener(new IntelJITEventsWrapper);
 }

 // for testing
 JITEventListener *JITEventListener::createIntelJITEventListener(
                                       IntelJITEventsWrapper* TestImpl) {
   return new IntelJITEventListener(TestImpl);
 }

 } // namespace llvm

 LLVMJITEventListenerRef LLVMCreateIntelJITEventListener(void)
 {
   return wrap(JITEventListener::createIntelJITEventListener());
 }
	//===-- IntelJITEventListener.cpp - Tell Intel profiler about JITed code --===//
	//
	// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
	// See https://llvm.org/LICENSE.txt for license information.
	// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
	//
	//===----------------------------------------------------------------------===//
	//
	// This file defines a JITEventListener object to tell Intel(R) VTune(TM)
	// Amplifier XE 2011 about JITted functions.
	//
	//===----------------------------------------------------------------------===//

	#include "IntelJITEventsWrapper.h"
	#include "ittnotify.h"
	#include "llvm-c/ExecutionEngine.h"
	#include "llvm/ADT/DenseMap.h"
	#include "llvm/CodeGen/MachineFunction.h"
	#include "llvm/Config/config.h"
	#include "llvm/DebugInfo/DIContext.h"
	#include "llvm/DebugInfo/DWARF/DWARFContext.h"
	#include "llvm/ExecutionEngine/JITEventListener.h"
	#include "llvm/IR/DebugInfo.h"
	#include "llvm/IR/Function.h"
	#include "llvm/IR/Metadata.h"
	#include "llvm/IR/ValueHandle.h"
	#include "llvm/Object/ObjectFile.h"
	#include "llvm/Object/SymbolSize.h"
	#include "llvm/Support/Debug.h"
	#include "llvm/Support/Errno.h"
	#include "llvm/Support/raw_ostream.h"

	using namespace llvm;
	using namespace llvm::object;

	#define DEBUG_TYPE "amplifier-jit-event-listener"

	namespace {

	class IntelIttnotifyInfo {
	std::string ModuleName;
	std::vector<std::string> SectionNamesVector;
	std::vector<__itt_section_info> SectionInfoVector;
	__itt_module_object *ModuleObject;
	IntelJITEventsWrapper &WrapperRef;

	public:
	IntelIttnotifyInfo(IntelJITEventsWrapper &Wrapper)
	: ModuleObject(NULL), WrapperRef(Wrapper){};
	~IntelIttnotifyInfo() { delete ModuleObject; };

	void setModuleName(const char *Name) { ModuleName = std::string(Name); }

	const char *getModuleName() { return ModuleName.c_str(); }

	void setModuleObject(__itt_module_object *ModuleObj) {
	ModuleObject = ModuleObj;
	}

	__itt_module_object *getModuleObject() { return ModuleObject; }

	__itt_section_info *getSectionInfoVectorBegin() {
	if (SectionInfoVector.size())
	return &SectionInfoVector[0];
	return NULL;
	}

	void reportSection(llvm::IttEventType EventType, const char *SectionName,
	unsigned int SectionSize) {
	WrapperRef.iJitIttNotifyInfo(EventType, SectionName, SectionSize);
	}

	int fillSectionInformation(const ObjectFile &Obj,
	const RuntimeDyld::LoadedObjectInfo &L) {

	int SectionCounter = 0;

	for (auto &Section : Obj.sections()) {
	uint64_t SectionLoadAddr = L.getSectionLoadAddress(Section);
	if (SectionLoadAddr) {
	object::ELFSectionRef ElfSection(Section);

	__itt_section_info SectionInfo;
	memset(&SectionInfo, 0, sizeof(SectionInfo));
	SectionInfo.start_addr = reinterpret_cast<void *>(SectionLoadAddr);
	SectionInfo.file_offset = ElfSection.getOffset();
	SectionInfo.flags = ElfSection.getFlags();

	StringRef SectionName("");
	auto SectionNameOrError = ElfSection.getName();
	if (SectionNameOrError)
	SectionName = *SectionNameOrError;

	SectionNamesVector.push_back(SectionName.str());
	SectionInfo.size = ElfSection.getSize();
	reportSection(llvm::LoadBinarySection, SectionName.str().c_str(),
	SectionInfo.size);

	if (ElfSection.isBSS()) {
	SectionInfo.type = itt_section_type_bss;
	} else if (ElfSection.isData()) {
	SectionInfo.type = itt_section_type_data;
	} else if (ElfSection.isText()) {
	SectionInfo.type = itt_section_type_text;
	}
	SectionInfoVector.push_back(SectionInfo);
	++SectionCounter;
	}
	}
	// Hereinafter: don't change SectionNamesVector content to avoid vector
	// reallocation - reallocation invalidates all the references, pointers, and
	// iterators referring to the elements in the sequence.
	for (int I = 0; I < SectionCounter; ++I) {
	SectionInfoVector[I].name = SectionNamesVector[I].c_str();
	}
	return SectionCounter;
	}
	};

	class IntelJITEventListener : public JITEventListener {
	typedef DenseMap<void*, unsigned int> MethodIDMap;

	std::unique_ptr<IntelJITEventsWrapper> Wrapper;
	MethodIDMap MethodIDs;

	typedef SmallVector<const void *, 64> MethodAddressVector;
	typedef DenseMap<const void *, MethodAddressVector> ObjectMap;

	ObjectMap LoadedObjectMap;
	std::map<ObjectKey, OwningBinary<ObjectFile>> DebugObjects;

	std::map<ObjectKey, std::unique_ptr<IntelIttnotifyInfo>> KeyToIttnotify;

	public:
	IntelJITEventListener(IntelJITEventsWrapper* libraryWrapper) {
	Wrapper.reset(libraryWrapper);
	}

	~IntelJITEventListener() {
	}

	void notifyObjectLoaded(ObjectKey Key, const ObjectFile &Obj,
	const RuntimeDyld::LoadedObjectInfo &L) override;

	void notifyFreeingObject(ObjectKey Key) override;
	};

	static LineNumberInfo DILineInfoToIntelJITFormat(uintptr_t StartAddress,
	uintptr_t Address,
	DILineInfo Line) {
	LineNumberInfo Result;

	Result.Offset = Address - StartAddress;
	Result.LineNumber = Line.Line;

	return Result;
	}

	static iJIT_Method_Load FunctionDescToIntelJITFormat(
	IntelJITEventsWrapper& Wrapper,
	const char* FnName,
	uintptr_t FnStart,
	size_t FnSize) {
	iJIT_Method_Load Result;
	memset(&Result, 0, sizeof(iJIT_Method_Load));

	Result.method_id = Wrapper.iJIT_GetNewMethodID();
	Result.method_name = const_cast<char*>(FnName);
	Result.method_load_address = reinterpret_cast<void*>(FnStart);
	Result.method_size = FnSize;

	Result.class_id = 0;
	Result.class_file_name = NULL;
	Result.user_data = NULL;
	Result.user_data_size = 0;
	Result.env = iJDE_JittingAPI;

	return Result;
	}

	int getBackwardCompatibilityMode() {

	char *BackwardCompatibilityEnv = getenv("INTEL_JIT_BACKWARD_COMPATIBILITY");
	int BackwardCompatibilityMode = 0;
	if (BackwardCompatibilityEnv) {
	StringRef(BackwardCompatibilityEnv)
	.getAsInteger(10, BackwardCompatibilityMode);
	}
	return BackwardCompatibilityMode;
	}

	void IntelJITEventListener::notifyObjectLoaded(
	ObjectKey Key, const ObjectFile &Obj,
	const RuntimeDyld::LoadedObjectInfo &L) {

	int BackwardCompatibilityMode = getBackwardCompatibilityMode();
	if (BackwardCompatibilityMode == 0) {
	if (Obj.isELF()) {
	std::unique_ptr<IntelIttnotifyInfo> ModuleIttnotify =
	std::make_unique<IntelIttnotifyInfo>(*Wrapper);
	ModuleIttnotify->setModuleName(
	StringRef(llvm::utohexstr(
	MD5Hash(Obj.getMemoryBufferRef().getBuffer()), true))
	.str()
	.c_str());

	__itt_module_object *ModuleObject = new __itt_module_object();
	ModuleObject->module_name = ModuleIttnotify->getModuleName();
	ModuleObject->module_size = Obj.getMemoryBufferRef().getBufferSize();
	Wrapper->iJitIttNotifyInfo(llvm::LoadBinaryModule,
	ModuleObject->module_name,
	ModuleObject->module_size);
	ModuleObject->module_type = __itt_module_type_elf;
	ModuleObject->section_number =
	ModuleIttnotify->fillSectionInformation(Obj, L);
	ModuleObject->module_buffer =
	(void )const_cast<char >(Obj.getMemoryBufferRef().getBufferStart());
	ModuleObject->module_id =
	__itt_id_make((void )&(ModuleObject), ModuleObject->module_size);
	ModuleObject->section_array =
	ModuleIttnotify->getSectionInfoVectorBegin();
	ModuleIttnotify->setModuleObject(ModuleObject);

	__itt_module_load_with_sections(ModuleObject);

	KeyToIttnotify[Key] = std::move(ModuleIttnotify);
	}
	} else if (BackwardCompatibilityMode == 1) {

	OwningBinary<ObjectFile> DebugObjOwner = L.getObjectForDebug(Obj);
	const ObjectFile *DebugObj = DebugObjOwner.getBinary();
	if (!DebugObj)
	return;

	// Get the address of the object image for use as a unique identifier
	const void *ObjData = DebugObj->getData().data();
	std::unique_ptr<DIContext> Context = DWARFContext::create(*DebugObj);
	MethodAddressVector Functions;

	// Use symbol info to iterate functions in the object.
	for (const std::pair<SymbolRef, uint64_t> &P :
	computeSymbolSizes(*DebugObj)) {
	SymbolRef Sym = P.first;
	std::vector<LineNumberInfo> LineInfo;
	std::string SourceFileName;

	Expected<SymbolRef::Type> SymTypeOrErr = Sym.getType();
	if (!SymTypeOrErr) {
	// TODO: Actually report errors helpfully.
	consumeError(SymTypeOrErr.takeError());
	continue;
	}
	SymbolRef::Type SymType = *SymTypeOrErr;
	if (SymType != SymbolRef::ST_Function)
	continue;

	Expected<StringRef> Name = Sym.getName();
	if (!Name) {
	// TODO: Actually report errors helpfully.
	consumeError(Name.takeError());
	continue;
	}

	Expected<uint64_t> AddrOrErr = Sym.getAddress();
	if (!AddrOrErr) {
	// TODO: Actually report errors helpfully.
	consumeError(AddrOrErr.takeError());
	continue;
	}
	uint64_t Addr = *AddrOrErr;
	uint64_t Size = P.second;

	auto SecOrErr = Sym.getSection();
	if (!SecOrErr) {
	// TODO: Actually report errors helpfully.
	consumeError(SecOrErr.takeError());
	continue;
	}
	object::section_iterator Sec = *SecOrErr;
	if (Sec == Obj.section_end())
	continue;
	uint64_t Index = Sec->getIndex();

	// Record this address in a local vector
	Functions.push_back((void *)Addr);

	// Build the function loaded notification message
	iJIT_Method_Load FunctionMessage =
	FunctionDescToIntelJITFormat(*Wrapper, Name->data(), Addr, Size);
	DILineInfoTable Lines =
	Context->getLineInfoForAddressRange({Addr, Index}, Size);
	DILineInfoTable::iterator Begin = Lines.begin();
	DILineInfoTable::iterator End = Lines.end();
	for (DILineInfoTable::iterator It = Begin; It != End; ++It) {
	LineInfo.push_back(
	DILineInfoToIntelJITFormat((uintptr_t)Addr, It->first, It->second));
	}
	if (LineInfo.size() == 0) {
	FunctionMessage.source_file_name = 0;
	FunctionMessage.line_number_size = 0;
	FunctionMessage.line_number_table = 0;
	} else {
	// Source line information for the address range is provided as
	// a code offset for the start of the corresponding sub-range and
	// a source line. JIT API treats offsets in LineNumberInfo structures
	// as the end of the corresponding code region. The start of the code
	// is taken from the previous element. Need to shift the elements.

	LineNumberInfo last = LineInfo.back();
	last.Offset = FunctionMessage.method_size;
	LineInfo.push_back(last);
	for (size_t i = LineInfo.size() - 2; i > 0; --i)
	LineInfo[i].LineNumber = LineInfo[i - 1].LineNumber;

	SourceFileName = Lines.front().second.FileName;
	FunctionMessage.source_file_name =
	const_cast<char *>(SourceFileName.c_str());
	FunctionMessage.line_number_size = LineInfo.size();
	FunctionMessage.line_number_table = &*LineInfo.begin();
	}

	Wrapper->iJIT_NotifyEvent(iJVM_EVENT_TYPE_METHOD_LOAD_FINISHED,
	&FunctionMessage);
	MethodIDs[(void *)Addr] = FunctionMessage.method_id;
	}

	// To support object unload notification, we need to keep a list of
	// registered function addresses for each loaded object. We will
	// use the MethodIDs map to get the registered ID for each function.
	LoadedObjectMap[ObjData] = Functions;
	DebugObjects[Key] = std::move(DebugObjOwner);
	}
	}

	void IntelJITEventListener::notifyFreeingObject(ObjectKey Key) {

	int BackwardCompatibilityMode = getBackwardCompatibilityMode();
	if (BackwardCompatibilityMode == 0) {
	if (KeyToIttnotify.find(Key) == KeyToIttnotify.end())
	return;
	__itt_module_unload_with_sections(KeyToIttnotify[Key]->getModuleObject());
	Wrapper->iJitIttNotifyInfo(
	llvm::UnloadBinaryModule,
	KeyToIttnotify[Key]->getModuleObject()->module_name,
	KeyToIttnotify[Key]->getModuleObject()->module_size);
	KeyToIttnotify.erase(Key);
	} else if (BackwardCompatibilityMode == 1) {
	// This object may not have been registered with the listener. If it wasn't,
	// bail out.
	if (DebugObjects.find(Key) == DebugObjects.end())
	return;

	// Get the address of the object image for use as a unique identifier
	const ObjectFile &DebugObj = *DebugObjects[Key].getBinary();
	const void *ObjData = DebugObj.getData().data();

	// Get the object's function list from LoadedObjectMap
	ObjectMap::iterator OI = LoadedObjectMap.find(ObjData);
	if (OI == LoadedObjectMap.end())
	return;
	MethodAddressVector &Functions = OI->second;

	// Walk the function list, unregistering each function
	for (MethodAddressVector::iterator FI = Functions.begin(),
	FE = Functions.end();
	FI != FE; ++FI) {
	void FnStart = const_cast<void >(*FI);
	MethodIDMap::iterator MI = MethodIDs.find(FnStart);
	if (MI != MethodIDs.end()) {
	Wrapper->iJIT_NotifyEvent(iJVM_EVENT_TYPE_METHOD_UNLOAD_START,
	&MI->second);
	MethodIDs.erase(MI);
	}
	}

	// Erase the object from LoadedObjectMap
	LoadedObjectMap.erase(OI);
	DebugObjects.erase(Key);
	}
	}

	} // anonymous namespace.

	namespace llvm {
	JITEventListener *JITEventListener::createIntelJITEventListener() {
	return new IntelJITEventListener(new IntelJITEventsWrapper);
	}

	// for testing
	JITEventListener *JITEventListener::createIntelJITEventListener(
	IntelJITEventsWrapper* TestImpl) {
	return new IntelJITEventListener(TestImpl);
	}

	} // namespace llvm

	LLVMJITEventListenerRef LLVMCreateIntelJITEventListener(void)
	{
	return wrap(JITEventListener::createIntelJITEventListener());
	}