Remove Value::getName{Start,End}, the last of the old Name APIs.
[oota-llvm.git] / lib / ExecutionEngine / JIT / 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 calls into OProfile to tell
11 // it about JITted functions.  For now, we only record function names and sizes,
12 // but eventually we'll also record line number information.
13 //
14 // See http://oprofile.sourceforge.net/doc/devel/jit-interface.html for the
15 // definition of the interface we're using.
16 //
17 //===----------------------------------------------------------------------===//
18
19 #define DEBUG_TYPE "oprofile-jit-event-listener"
20 #include "llvm/Function.h"
21 #include "llvm/Analysis/DebugInfo.h"
22 #include "llvm/CodeGen/MachineFunction.h"
23 #include "llvm/ExecutionEngine/JITEventListener.h"
24 #include "llvm/Support/Debug.h"
25 #include "llvm/System/Errno.h"
26 #include "llvm/Config/config.h"
27 #include <stddef.h>
28 using namespace llvm;
29
30 #if USE_OPROFILE
31
32 #include <opagent.h>
33
34 namespace {
35
36 class OProfileJITEventListener : public JITEventListener {
37   op_agent_t Agent;
38 public:
39   OProfileJITEventListener();
40   ~OProfileJITEventListener();
41
42   virtual void NotifyFunctionEmitted(const Function &F,
43                                      void *FnStart, size_t FnSize,
44                                      const EmittedFunctionDetails &Details);
45   virtual void NotifyFreeingMachineCode(const Function &F, void *OldPtr);
46 };
47
48 OProfileJITEventListener::OProfileJITEventListener()
49     : Agent(op_open_agent()) {
50   if (Agent == NULL) {
51     const std::string err_str = sys::StrError();
52     DOUT << "Failed to connect to OProfile agent: " << err_str << "\n";
53   } else {
54     DOUT << "Connected to OProfile agent.\n";
55   }
56 }
57
58 OProfileJITEventListener::~OProfileJITEventListener() {
59   if (Agent != NULL) {
60     if (op_close_agent(Agent) == -1) {
61       const std::string err_str = sys::StrError();
62       DOUT << "Failed to disconnect from OProfile agent: " << err_str << "\n";
63     } else {
64       DOUT << "Disconnected from OProfile agent.\n";
65     }
66   }
67 }
68
69 class FilenameCache {
70   // Holds the filename of each CompileUnit, so that we can pass the
71   // pointer into oprofile.  These char*s are freed in the destructor.
72   DenseMap<GlobalVariable*, char*> Filenames;
73   // Used as the scratch space in DICompileUnit::getFilename().
74   std::string TempFilename;
75
76  public:
77   const char* getFilename(GlobalVariable *CompileUnit) {
78     char *&Filename = Filenames[CompileUnit];
79     if (Filename == NULL) {
80       DICompileUnit CU(CompileUnit);
81       Filename = strdup(CU.getFilename(TempFilename).c_str());
82     }
83     return Filename;
84   }
85   ~FilenameCache() {
86     for (DenseMap<GlobalVariable*, char*>::iterator
87              I = Filenames.begin(), E = Filenames.end(); I != E;++I) {
88       free(I->second);
89     }
90   }
91 };
92
93 static debug_line_info LineStartToOProfileFormat(
94     const MachineFunction &MF, FilenameCache &Filenames,
95     uintptr_t Address, DebugLoc Loc) {
96   debug_line_info Result;
97   Result.vma = Address;
98   const DebugLocTuple& tuple = MF.getDebugLocTuple(Loc);
99   Result.lineno = tuple.Line;
100   Result.filename = Filenames.getFilename(tuple.CompileUnit);
101   DOUT << "Mapping " << reinterpret_cast<void*>(Result.vma) << " to "
102        << Result.filename << ":" << Result.lineno << "\n";
103   return Result;
104 }
105
106 // Adds the just-emitted function to the symbol table.
107 void OProfileJITEventListener::NotifyFunctionEmitted(
108     const Function &F, void *FnStart, size_t FnSize,
109     const EmittedFunctionDetails &Details) {
110   assert(F.hasName() && FnStart != 0 && "Bad symbol to add");
111   if (op_write_native_code(Agent, F.getName().data(),
112                            reinterpret_cast<uint64_t>(FnStart),
113                            FnStart, FnSize) == -1) {
114     DEBUG(errs() << "Failed to tell OProfile about native function " 
115           << Fn.getName() << " at [" 
116           << FnStart << "-" << ((char*)FnStart + FnSize) << "]\n");
117     return;
118   }
119
120   // Now we convert the line number information from the address/DebugLoc format
121   // in Details to the address/filename/lineno format that OProfile expects.
122   // OProfile 0.9.4 (and maybe later versions) has a bug that causes it to
123   // ignore line numbers for addresses above 4G.
124   FilenameCache Filenames;
125   std::vector<debug_line_info> LineInfo;
126   LineInfo.reserve(1 + Details.LineStarts.size());
127   if (!Details.MF->getDefaultDebugLoc().isUnknown()) {
128     LineInfo.push_back(LineStartToOProfileFormat(
129         *Details.MF, Filenames,
130         reinterpret_cast<uintptr_t>(FnStart),
131         Details.MF->getDefaultDebugLoc()));
132   }
133   for (std::vector<EmittedFunctionDetails::LineStart>::const_iterator
134            I = Details.LineStarts.begin(), E = Details.LineStarts.end();
135        I != E; ++I) {
136     LineInfo.push_back(LineStartToOProfileFormat(
137         *Details.MF, Filenames, I->Address, I->Loc));
138   }
139   if (!LineInfo.empty()) {
140     if (op_write_debug_line_info(Agent, FnStart,
141                                  LineInfo.size(), &*LineInfo.begin()) == -1) {
142       DEBUG(errs() 
143             << "Failed to tell OProfile about line numbers for native function "
144             << F.getName() << " at [" 
145             << FnStart << "-" << ((char*)FnStart + FnSize) << "]\n");
146     }
147   }
148 }
149
150 // Removes the to-be-deleted function from the symbol table.
151 void OProfileJITEventListener::NotifyFreeingMachineCode(
152     const Function &F, void *FnStart) {
153   assert(FnStart && "Invalid function pointer");
154   if (op_unload_native_code(Agent, reinterpret_cast<uint64_t>(FnStart)) == -1) {
155     DOUT << "Failed to tell OProfile about unload of native function "
156          << F.getName() << " at " << FnStart << "\n";
157   }
158 }
159
160 }  // anonymous namespace.
161
162 namespace llvm {
163 JITEventListener *createOProfileJITEventListener() {
164   return new OProfileJITEventListener;
165 }
166 }
167
168 #else  // USE_OPROFILE
169
170 namespace llvm {
171 // By defining this to return NULL, we can let clients call it unconditionally,
172 // even if they haven't configured with the OProfile libraries.
173 JITEventListener *createOProfileJITEventListener() {
174   return NULL;
175 }
176 }  // namespace llvm
177
178 #endif  // USE_OPROFILE