• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 //===-- JITDebugRegisterer.cpp - Register debug symbols for JIT -----------===//
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 JITDebugRegisterer object that is used by the JIT to
11 // register debug info with debuggers like GDB.
12 //
13 //===----------------------------------------------------------------------===//
14 
15 #include "JITDebugRegisterer.h"
16 #include "../../CodeGen/ELF.h"
17 #include "../../CodeGen/ELFWriter.h"
18 #include "llvm/LLVMContext.h"
19 #include "llvm/Function.h"
20 #include "llvm/Module.h"
21 #include "llvm/Target/TargetMachine.h"
22 #include "llvm/Target/TargetOptions.h"
23 #include "llvm/ADT/DenseMap.h"
24 #include "llvm/ADT/OwningPtr.h"
25 #include "llvm/Support/Compiler.h"
26 #include "llvm/Support/MutexGuard.h"
27 #include "llvm/Support/raw_ostream.h"
28 #include "llvm/Support/Mutex.h"
29 #include <string>
30 
31 namespace llvm {
32 
33 // This must be kept in sync with gdb/gdb/jit.h .
34 extern "C" {
35 
36   // Debuggers puts a breakpoint in this function.
__jit_debug_register_code()37   LLVM_ATTRIBUTE_NOINLINE void __jit_debug_register_code() { }
38 
39   // We put information about the JITed function in this global, which the
40   // debugger reads.  Make sure to specify the version statically, because the
41   // debugger checks the version before we can set it during runtime.
42   struct jit_descriptor __jit_debug_descriptor = { 1, 0, 0, 0 };
43 
44 }
45 
46 namespace {
47 
48   /// JITDebugLock - Used to serialize all code registration events, since they
49   /// modify global variables.
50   sys::Mutex JITDebugLock;
51 
52 }
53 
JITDebugRegisterer(TargetMachine & tm)54 JITDebugRegisterer::JITDebugRegisterer(TargetMachine &tm) : TM(tm), FnMap() { }
55 
~JITDebugRegisterer()56 JITDebugRegisterer::~JITDebugRegisterer() {
57   // Free all ELF memory.
58   for (RegisteredFunctionsMap::iterator I = FnMap.begin(), E = FnMap.end();
59        I != E; ++I) {
60     // Call the private method that doesn't update the map so our iterator
61     // doesn't break.
62     UnregisterFunctionInternal(I);
63   }
64   FnMap.clear();
65 }
66 
MakeELF(const Function * F,DebugInfo & I)67 std::string JITDebugRegisterer::MakeELF(const Function *F, DebugInfo &I) {
68   // Stack allocate an empty module with an empty LLVMContext for the ELFWriter
69   // API.  We don't use the real module because then the ELFWriter would write
70   // out unnecessary GlobalValues during finalization.
71   LLVMContext Context;
72   Module M("", Context);
73 
74   // Make a buffer for the ELF in memory.
75   std::string Buffer;
76   raw_string_ostream O(Buffer);
77   ELFWriter EW(O, TM);
78   EW.doInitialization(M);
79 
80   // Copy the binary into the .text section.  This isn't necessary, but it's
81   // useful to be able to disassemble the ELF by hand.
82   ELFSection &Text = EW.getTextSection(const_cast<Function *>(F));
83   Text.Addr = (uint64_t)I.FnStart;
84   // TODO: We could eliminate this copy if we somehow used a pointer/size pair
85   // instead of a vector.
86   Text.getData().assign(I.FnStart, I.FnEnd);
87 
88   // Copy the exception handling call frame information into the .eh_frame
89   // section.  This allows GDB to get a good stack trace, particularly on
90   // linux x86_64.  Mark this as a PROGBITS section that needs to be loaded
91   // into memory at runtime.
92   ELFSection &EH = EW.getSection(".eh_frame", ELF::SHT_PROGBITS,
93                                  ELF::SHF_ALLOC);
94   // Pointers in the DWARF EH info are all relative to the EH frame start,
95   // which is stored here.
96   EH.Addr = (uint64_t)I.EhStart;
97   // TODO: We could eliminate this copy if we somehow used a pointer/size pair
98   // instead of a vector.
99   EH.getData().assign(I.EhStart, I.EhEnd);
100 
101   // Add this single function to the symbol table, so the debugger prints the
102   // name instead of '???'.  We give the symbol default global visibility.
103   ELFSym *FnSym = ELFSym::getGV(F,
104                                 ELF::STB_GLOBAL,
105                                 ELF::STT_FUNC,
106                                 ELF::STV_DEFAULT);
107   FnSym->SectionIdx = Text.SectionIdx;
108   FnSym->Size = I.FnEnd - I.FnStart;
109   FnSym->Value = 0;  // Offset from start of section.
110   EW.SymbolList.push_back(FnSym);
111 
112   EW.doFinalization(M);
113   O.flush();
114 
115   // When trying to debug why GDB isn't getting the debug info right, it's
116   // awfully helpful to write the object file to disk so that it can be
117   // inspected with readelf and objdump.
118   if (JITEmitDebugInfoToDisk) {
119     std::string Filename;
120     raw_string_ostream O2(Filename);
121     O2 << "/tmp/llvm_function_" << I.FnStart << "_" << F->getNameStr() << ".o";
122     O2.flush();
123     std::string Errors;
124     raw_fd_ostream O3(Filename.c_str(), Errors);
125     O3 << Buffer;
126     O3.close();
127   }
128 
129   return Buffer;
130 }
131 
RegisterFunction(const Function * F,DebugInfo & I)132 void JITDebugRegisterer::RegisterFunction(const Function *F, DebugInfo &I) {
133   // TODO: Support non-ELF platforms.
134   if (!TM.getELFWriterInfo())
135     return;
136 
137   std::string Buffer = MakeELF(F, I);
138 
139   jit_code_entry *JITCodeEntry = new jit_code_entry();
140   JITCodeEntry->symfile_addr = Buffer.c_str();
141   JITCodeEntry->symfile_size = Buffer.size();
142 
143   // Add a mapping from F to the entry and buffer, so we can delete this
144   // info later.
145   FnMap[F] = std::make_pair(Buffer, JITCodeEntry);
146 
147   // Acquire the lock and do the registration.
148   {
149     MutexGuard locked(JITDebugLock);
150     __jit_debug_descriptor.action_flag = JIT_REGISTER_FN;
151 
152     // Insert this entry at the head of the list.
153     JITCodeEntry->prev_entry = NULL;
154     jit_code_entry *NextEntry = __jit_debug_descriptor.first_entry;
155     JITCodeEntry->next_entry = NextEntry;
156     if (NextEntry != NULL) {
157       NextEntry->prev_entry = JITCodeEntry;
158     }
159     __jit_debug_descriptor.first_entry = JITCodeEntry;
160     __jit_debug_descriptor.relevant_entry = JITCodeEntry;
161     __jit_debug_register_code();
162   }
163 }
164 
UnregisterFunctionInternal(RegisteredFunctionsMap::iterator I)165 void JITDebugRegisterer::UnregisterFunctionInternal(
166     RegisteredFunctionsMap::iterator I) {
167   jit_code_entry *&JITCodeEntry = I->second.second;
168 
169   // Acquire the lock and do the unregistration.
170   {
171     MutexGuard locked(JITDebugLock);
172     __jit_debug_descriptor.action_flag = JIT_UNREGISTER_FN;
173 
174     // Remove the jit_code_entry from the linked list.
175     jit_code_entry *PrevEntry = JITCodeEntry->prev_entry;
176     jit_code_entry *NextEntry = JITCodeEntry->next_entry;
177     if (NextEntry) {
178       NextEntry->prev_entry = PrevEntry;
179     }
180     if (PrevEntry) {
181       PrevEntry->next_entry = NextEntry;
182     } else {
183       assert(__jit_debug_descriptor.first_entry == JITCodeEntry);
184       __jit_debug_descriptor.first_entry = NextEntry;
185     }
186 
187     // Tell GDB which entry we removed, and unregister the code.
188     __jit_debug_descriptor.relevant_entry = JITCodeEntry;
189     __jit_debug_register_code();
190   }
191 
192   delete JITCodeEntry;
193   JITCodeEntry = NULL;
194 
195   // Free the ELF file in memory.
196   std::string &Buffer = I->second.first;
197   Buffer.clear();
198 }
199 
UnregisterFunction(const Function * F)200 void JITDebugRegisterer::UnregisterFunction(const Function *F) {
201   // TODO: Support non-ELF platforms.
202   if (!TM.getELFWriterInfo())
203     return;
204 
205   RegisteredFunctionsMap::iterator I = FnMap.find(F);
206   if (I == FnMap.end()) return;
207   UnregisterFunctionInternal(I);
208   FnMap.erase(I);
209 }
210 
211 } // end namespace llvm
212