lib/ExecutionEngine/OProfileJIT/OProfileJITEventListener.cpp

   1 //===-- OProfileJITEventListener.cpp - Tell OProfile about JITted 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 that uses OProfileWrapper to tell
  11 // oprofile about JITted functions, including source line information.
  12 //
  13 //===----------------------------------------------------------------------===//
  14
  15 #include "llvm/Config/config.h"
  16 #include "llvm/CodeGen/MachineFunction.h"
  17 #include "llvm/ExecutionEngine/JITEventListener.h"
  18 #include "llvm/ExecutionEngine/OProfileWrapper.h"
  19 #include "llvm/ExecutionEngine/RuntimeDyld.h"
  20 #include "llvm/IR/DebugInfo.h"
  21 #include "llvm/IR/Function.h"
  22 #include "llvm/Object/ObjectFile.h"
  23 #include "llvm/Object/SymbolSize.h"
  24 #include "llvm/Support/Debug.h"
  25 #include "llvm/Support/Errno.h"
  26 #include "llvm/Support/raw_ostream.h"
  27 #include <dirent.h>
  28 #include <fcntl.h>
  29
  30 using namespace llvm;
  31 using namespace llvm::object;
  32
  33 #define DEBUG_TYPE "oprofile-jit-event-listener"
  34
  35 namespace {
  36
  37 class OProfileJITEventListener : public JITEventListener {
  38   std::unique_ptr<OProfileWrapper> Wrapper;
  39
  40   void initialize();
  41   std::map<const char*, OwningBinary<ObjectFile>> DebugObjects;
  42
  43 public:
  44   OProfileJITEventListener(std::unique_ptr<OProfileWrapper> LibraryWrapper)
  45     : Wrapper(std::move(LibraryWrapper)) {
  46     initialize();
  47   }
  48
  49   ~OProfileJITEventListener();
  50
  51   void NotifyObjectEmitted(const ObjectFile &Obj,
  52                            const RuntimeDyld::LoadedObjectInfo &L) override;
  53
  54   void NotifyFreeingObject(const ObjectFile &Obj) override;
  55 };
  56
  57 void OProfileJITEventListener::initialize() {
  58   if (!Wrapper->op_open_agent()) {
  59     const std::string err_str = sys::StrError();
  60     DEBUG(dbgs() << "Failed to connect to OProfile agent: " << err_str << "\n");
  61   } else {
  62     DEBUG(dbgs() << "Connected to OProfile agent.\n");
  63   }
  64 }
  65
  66 OProfileJITEventListener::~OProfileJITEventListener() {
  67   if (Wrapper->isAgentAvailable()) {
  68     if (Wrapper->op_close_agent() == -1) {
  69       const std::string err_str = sys::StrError();
  70       DEBUG(dbgs() << "Failed to disconnect from OProfile agent: "
  71                    << err_str << "\n");
  72     } else {
  73       DEBUG(dbgs() << "Disconnected from OProfile agent.\n");
  74     }
  75   }
  76 }
  77
  78 void OProfileJITEventListener::NotifyObjectEmitted(
  79                                        const ObjectFile &Obj,
  80                                        const RuntimeDyld::LoadedObjectInfo &L) {
  81   if (!Wrapper->isAgentAvailable()) {
  82     return;
  83   }
  84
  85   OwningBinary<ObjectFile> DebugObjOwner = L.getObjectForDebug(Obj);
  86   const ObjectFile &DebugObj = *DebugObjOwner.getBinary();
  87
  88   // Use symbol info to iterate functions in the object.
  89   for (const std::pair<SymbolRef, uint64_t> &P : computeSymbolSizes(DebugObj)) {
  90     SymbolRef Sym = P.first;
  91     if (Sym.getType() != SymbolRef::ST_Function)
  92       continue;
  93
  94     ErrorOr<StringRef> NameOrErr = Sym.getName();
  95     if (NameOrErr.getError())
  96       continue;
  97     StringRef Name = *NameOrErr;
  98     ErrorOr<uint64_t> AddrOrErr = Sym.getAddress();
  99     if (AddrOrErr.getError())
 100       continue;
 101     uint64_t Addr = *AddrOrErr;
 102     uint64_t Size = P.second;
 103
 104     if (Wrapper->op_write_native_code(Name.data(), Addr, (void *)Addr, Size) ==
 105         -1) {
 106       DEBUG(dbgs() << "Failed to tell OProfile about native function " << Name
 107                    << " at [" << (void *)Addr << "-" << ((char *)Addr + Size)
 108                    << "]\n");
 109       continue;
 110     }
 111     // TODO: support line number info (similar to IntelJITEventListener.cpp)
 112   }
 113
 114   DebugObjects[Obj.getData().data()] = std::move(DebugObjOwner);
 115 }
 116
 117 void OProfileJITEventListener::NotifyFreeingObject(const ObjectFile &Obj) {
 118   if (Wrapper->isAgentAvailable()) {
 119
 120     // If there was no agent registered when the original object was loaded then
 121     // we won't have created a debug object for it, so bail out.
 122     if (DebugObjects.find(Obj.getData().data()) == DebugObjects.end())
 123       return;
 124
 125     const ObjectFile &DebugObj = *DebugObjects[Obj.getData().data()].getBinary();
 126
 127     // Use symbol info to iterate functions in the object.
 128     for (symbol_iterator I = DebugObj.symbol_begin(),
 129                          E = DebugObj.symbol_end();
 130          I != E; ++I) {
 131       if (I->getType() == SymbolRef::ST_Function) {
 132         ErrorOr<uint64_t> AddrOrErr = I->getAddress();
 133         if (AddrOrErr.getError())
 134           continue;
 135         uint64_t Addr = *AddrOrErr;
 136
 137         if (Wrapper->op_unload_native_code(Addr) == -1) {
 138           DEBUG(dbgs()
 139                 << "Failed to tell OProfile about unload of native function at "
 140                 << (void*)Addr << "\n");
 141           continue;
 142         }
 143       }
 144     }
 145   }
 146
 147   DebugObjects.erase(Obj.getData().data());
 148 }
 149
 150 }  // anonymous namespace.
 151
 152 namespace llvm {
 153 JITEventListener *JITEventListener::createOProfileJITEventListener() {
 154   return new OProfileJITEventListener(llvm::make_unique<OProfileWrapper>());
 155 }
 156
 157 } // namespace llvm
 158