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. 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 54 JITDebugRegisterer::JITDebugRegisterer(TargetMachine &tm) : TM(tm), FnMap() { } 55 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 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 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 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 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
