Implement LLVM JIT side of GDB JIT debugging interface

lib/ExecutionEngine/JIT/JITDebugRegisterer.cpp

 //===-- JITDebugRegisterer.cpp - Register debug symbols for JIT -----------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file defines a JITDebugRegisterer object that is used by the JIT to
 // register debug info with debuggers like GDB.
 //
 //===----------------------------------------------------------------------===//
 
 #include "JITDebugRegisterer.h"
 #include "../../CodeGen/ELF.h"

[Jeffrey Yasskin, 2009/07/03 22:01:52]

Nice.

 #include "../../CodeGen/ELFWriter.h"
 #include "llvm/LLVMContext.h"
 #include "llvm/Function.h"
 #include "llvm/Module.h"
 #include "llvm/Target/TargetMachine.h"
+#include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/OwningPtr.h"
+#include "llvm/Support/MutexGuard.h"
 #include "llvm/Support/raw_ostream.h"
+#include "llvm/System/Mutex.h"
+#include <string>
+#include <vector>
 
 namespace llvm {
 
-JITDebugRegisterer::JITDebugRegisterer(TargetMachine &tm) : TM(tm) {
-}
-
-std::string JITDebugRegisterer::MakeFilename(const Function *F,
-                                             uint8_t *FnStart) {
-  std::string Filename;
-  raw_string_ostream O(Filename);
-  O << "/tmp/llvm_function_" << FnStart << "_" << F->getNameStr() << ".o";

[Jeffrey Yasskin, 2009/07/03 22:01:52]

"/tmp" is probably wrong in general. llvm/System/Path.h defines
llvm::sys::Path::GetTemporaryDirectory(), which should give the right temporary
path.

[Reid Kleckner, 2009/07/06 21:07:01]

On 2009/07/03 22:01:52, Jeffrey Yasskin wrote:
> "/tmp" is probably wrong in general. llvm/System/Path.h defines
> llvm::sys::Path::GetTemporaryDirectory(), which should give the right
temporary
> path.

Done.

-  O.flush();
-  return Filename;
-}
-
-void JITDebugRegisterer::MemCpySection(ELFSection &ES,

[Jeffrey Yasskin, 2009/07/03 22:01:52]

I think this should be MemCpyToSection. Or maybe FillSectionFromRange.

-                                       uint8_t* Start, uint8_t* End) {

[nlewycky, 2009/07/04 01:27:07]

Please be consistent with whether you put '* ' or ' *'. And I mean that you
should use the latter.

-  uintptr_t Size = (uintptr_t)End - (uintptr_t)Start;

[Jeffrey Yasskin, 2009/07/03 22:01:52]

For future reference, End-Start would be of type ptrdiff_t, which is a signed
type that you could implicitly convert to vector::size_type. Casting pointers to
uintptr_t explicitly is sketchy unless you really need to do it.

-  std::vector<uint8_t> &Data = ES.getData();
-  Data.resize(Size);
-  unsigned char *BuffBegin = &Data[0];

[Jeffrey Yasskin, 2009/07/03 22:01:52]

This would be undefined if Start==End.

[nlewycky, 2009/07/04 01:27:07]

On 2009/07/03 22:01:52, Jeffrey Yasskin wrote:
> This would be undefined if Start==End.

Right. Try using "Data.data()".

-  memcpy(BuffBegin, Start, Size);

[Jeffrey Yasskin, 2009/07/03 22:01:52]

Instead of this dance, use ES.getData().assign(Start, End). Then it might be
worth just removing this function, since the replacement is so short.

[Reid Kleckner, 2009/07/06 21:07:01]

On 2009/07/03 22:01:52, Jeffrey Yasskin wrote:
> Instead of this dance, use ES.getData().assign(Start, End). Then it might be
> worth just removing this function, since the replacement is so short.

Aha, that is much nicer.  Done.

-}
-
-void JITDebugRegisterer::RegisterDebugInfo(const Function *F,
-                                           uint8_t* FnStart, uint8_t* FnEnd,

[nlewycky, 2009/07/04 01:27:07]

'uint8_t *' again.

[Reid Kleckner, 2009/07/06 21:07:01]

On 2009/07/04 01:27:07, nlewycky wrote:
> 'uint8_t *' again.

Done.

-                                           uint8_t* EhStart, uint8_t* EhEnd) {

[Jeffrey Yasskin, 2009/07/03 22:01:52]

This interface isn't as extensible as we'll eventually want it, since we'll have
to add more pairs for things like line numbers, variable locations, etc. But
it's probably good enough for now.

-  // Pick the filename for the function.
-  std::string Filename = MakeFilename(F, FnStart);
-
-  // Stack allocate an empty module for the ELFWriter API.

[Jeffrey Yasskin, 2009/07/03 22:01:52]

Please explain here why you can't just use the Function's Module.

[Reid Kleckner, 2009/07/06 21:07:01]

On 2009/07/03 22:01:52, Jeffrey Yasskin wrote:
> Please explain here why you can't just use the Function's Module.

Done.

-  Module M("", getGlobalContext());
-
-  // Open the ELF file.
-  std::string Error;
-  raw_fd_ostream O(Filename.c_str(), true, Error);

[Jeffrey Yasskin, 2009/07/03 22:01:52]

Please comment what "true" means. ", true /* Binary */" would be fine.

[Reid Kleckner, 2009/07/06 21:07:01]

On 2009/07/03 22:01:52, Jeffrey Yasskin wrote:
> Please comment what "true" means. ", true /* Binary */" would be fine.

Done.  I've seen this style elsewhere in LLVM.

+// This must be kept in sync with gdb/gdb/jit.h .
+extern "C" {
+
+  // Debuggers puts a breakpoint in this function.
+  void __attribute__((noinline)) __jit_debug_register_code() { }
+
+  // We put information about the JITed function in this global, which the
+  // debugger reads.  Make sure to specify the version statically, because the
+  // debugger checks the version before we can set it during runtime.
+  struct jit_descriptor __jit_debug_descriptor = { 1, 0, 0, 0 };
+
+}
+
+namespace {
+
+  /// JITDebugLock - Used to serialize all code registration events, since they
+  /// modify global variables.
+  sys::Mutex JITDebugLock;
+
+}
+
+JITDebugRegisterer::JITDebugRegisterer(TargetMachine &tm) : TM(tm), FnMap() { }
+
+JITDebugRegisterer::~JITDebugRegisterer() {
+  // Free all ELF memory.
+  for (RegisteredFunctionsMap::iterator I = FnMap.begin(), E = FnMap.end();
+       I != E; ++I) {
+    // Call the private method that doesn't update the map so our iterator
+    // doesn't break.
+    UnregisterFunctionInternal(I);
+  }
+  FnMap.clear();
+}
+
+std::string JITDebugRegisterer::MakeELF(const Function *F, DebugInfo &I) {
+  // Stack allocate an empty module with an empty LLVMContext for the ELFWriter
+  // API.  We don't use the real module because then the ELFWriter would write
+  // out unnecessary GlobalValues during finalization.
+  LLVMContext Context;
+  Module M("", Context);
+
+  // Make a buffer for the ELF in memory.
+  std::string Buffer;
+  raw_string_ostream O(Buffer);
   ELFWriter EW(O, TM);

[Jeffrey Yasskin, 2009/07/03 22:01:52]

Move this below the Error if.

[Reid Kleckner, 2009/07/06 21:07:01]

On 2009/07/03 22:01:52, Jeffrey Yasskin wrote:
> Move this below the Error if.

Done.

-  if (Error != "") {
-    fprintf(stderr, "Error opening file '%s': %s",
-            Filename.c_str(), Error.c_str());
-  }
   EW.doInitialization(M);
 
-  // Copy the binary into the .text section.  This probably isn't critical, but

[Jeffrey Yasskin, 2009/07/03 22:01:52]

If it's not critical, I'd rather not do it, since copying more data will slow
down debug emission.

[Reid Kleckner, 2009/07/06 21:07:01]

On 2009/07/03 22:01:52, Jeffrey Yasskin wrote:
> If it's not critical, I'd rather not do it, since copying more data will slow
> down debug emission.

It isn't critical, but it's been really useful to be able to dump the binary and
DWARF info from the same ELF side by side.  I'd like to keep it until we move
everything back into memory.

[Jeffrey Yasskin, 2009/07/08 00:40:45]

On 2009/07/06 21:07:01, Reid Kleckner wrote:
> On 2009/07/03 22:01:52, Jeffrey Yasskin wrote:
> > If it's not critical, I'd rather not do it, since copying more data will
slow
> > down debug emission.
> 
> It isn't critical, but it's been really useful to be able to dump the binary
and
> DWARF info from the same ELF side by side.  I'd like to keep it until we move
> everything back into memory.

Ok.

-  // we put it there for completeness.
-  ELFSection &Text = EW.getTextSection();
-  Text.Addr = (uint64_t)FnStart;
-  MemCpySection(Text, FnStart, FnEnd);
+  // Copy the binary into the .text section.  This isn't necessary, but it's
+  // useful to be able to disassemble the ELF by hand.
+  ELFSection &Text = EW.getTextSection((Function *)F);
+  Text.Addr = (uint64_t)I.FnStart;
+  // TODO: We could eliminate this copy if we somehow used a pointer/size pair
+  // instead of a vector.
+  Text.getData().assign(I.FnStart, I.FnEnd);
 
   // Copy the exception handling call frame information into the .eh_frame
-  // section.  This allows GDB to get a good stack trace.
+  // section.  This allows GDB to get a good stack trace, particularly on
+  // linux x86_64.  Mark this as a PROGBITS section that needs to be loaded
+  // into memory at runtime.
   ELFSection &EH = EW.getSection(".eh_frame", ELFSection::SHT_PROGBITS,

[Jeffrey Yasskin, 2009/07/03 22:01:52]

Could you mention where you got these flags for getSection?

[Reid Kleckner, 2009/07/06 21:07:01]

On 2009/07/03 22:01:52, Jeffrey Yasskin wrote:
> Could you mention where you got these flags for getSection?

I guessed?  Pretty much every section that isn't a string table, symbol table,
or some other very specific stuff is a PROGBITS section, and the section needs
to be allocated at runtime.

Added more comments.

                                  ELFSection::SHF_ALLOC);
-  // Pointers in the DWARF call frame info are all relative to the EH frame
-  // start, so the next line is actually critical for GDB.
-  EH.Addr = (uint64_t)EhStart;
-  MemCpySection(EH, EhStart, EhEnd);
-
-  // Add this single function to the symbol table, so GDB prints the name
-  // instead of '???'.
-  ELFSym FnSym(F);
-  FnSym.setBind(ELFSym::STB_GLOBAL);  // Just guessing about visibility.

[nlewycky, 2009/07/04 01:27:07]

Global should always be fine here except on exotic systems that actually use
STB_LOPROC or STB_HIPROC.

[Reid Kleckner, 2009/07/06 21:07:01]

On 2009/07/04 01:27:07, nlewycky wrote:
> Global should always be fine here except on exotic systems that actually use
> STB_LOPROC or STB_HIPROC.

Changed the comment.

-  FnSym.setType(ELFSym::STT_FUNC);
-  FnSym.SectionIdx = Text.SectionIdx;
-  FnSym.Size = FnEnd - FnStart;
-  FnSym.Value = 0;  // Offset from start of section.
+  // Pointers in the DWARF EH info are all relative to the EH frame start,
+  // which is stored here.
+  EH.Addr = (uint64_t)I.EhStart;
+  // TODO: We could eliminate this copy if we somehow used a pointer/size pair
+  // instead of a vector.
+  EH.getData().assign(I.EhStart, I.EhEnd);
+
+  // Add this single function to the symbol table, so the debugger prints the
+  // name instead of '???'.  We give the symbol default global visibility.
+  ELFSym *FnSym = ELFSym::getGV(F,
+                                ELFSym::STB_GLOBAL,
+                                ELFSym::STT_FUNC,
+                                ELFSym::STV_DEFAULT);
+  FnSym->SectionIdx = Text.SectionIdx;
+  FnSym->Size = I.FnEnd - I.FnStart;
+  FnSym->Value = 0;  // Offset from start of section.
   EW.SymbolList.push_back(FnSym);
 
   EW.doFinalization(M);
+  O.flush();
+
+  // When trying to debug this code, it's awfully helpful to write the object
+  // file to disk.
+  std::string Filename;
+  raw_string_ostream O2(Filename);
+  O2 << "/tmp/llvm_function_" << I.FnStart << "_" << F->getNameStr() << ".o";
+  O2.flush();
+  std::string Errors;
+  raw_fd_ostream O3(Filename.c_str(), Errors);
+  O3 << Buffer;
+  O3.close();
+
+  return Buffer;
+}
+
+void JITDebugRegisterer::RegisterFunction(const Function *F, DebugInfo &I) {
+  // TODO: Support non-ELF platforms.
+  if (!TM.getELFWriterInfo())
+    return;
+
+  std::string Buffer = MakeELF(F, I);
+
+  jit_code_entry *JITCodeEntry = new jit_code_entry();
+  JITCodeEntry->symfile_addr = Buffer.c_str();
+  JITCodeEntry->symfile_size = Buffer.size();
+
+  // Add a mapping from F to the entry and buffer, so we can delete this
+  // info later.
+  FnMap[F] = std::make_pair<std::string, jit_code_entry*>(Buffer, JITCodeEntry);
+
+  // Acquire the lock and do the registration.
+  {
+    MutexGuard locked(JITDebugLock);
+    __jit_debug_descriptor.action_flag = JIT_REGISTER_FN;
+
+    // Insert this entry at the head of the list.
+    JITCodeEntry->prev_entry = NULL;
+    jit_code_entry *NextEntry = __jit_debug_descriptor.first_entry;
+    JITCodeEntry->next_entry = NextEntry;
+    if (NextEntry != NULL) {
+      NextEntry->prev_entry = JITCodeEntry;
+    }
+    __jit_debug_descriptor.first_entry = JITCodeEntry;
+    __jit_debug_descriptor.relevant_entry = JITCodeEntry;
+    __jit_debug_register_code();
+  }
+}
+
+void JITDebugRegisterer::UnregisterFunctionInternal(
+    RegisteredFunctionsMap::iterator I) {
+  jit_code_entry *JITCodeEntry = I->second.second;
+
+  // Acquire the lock and do the unregistration.
+  {
+    MutexGuard locked(JITDebugLock);
+    __jit_debug_descriptor.action_flag = JIT_UNREGISTER_FN;
+
+    // Remove the jit_code_entry from the linked list.
+    jit_code_entry *PrevEntry = JITCodeEntry->prev_entry;
+    jit_code_entry *NextEntry = JITCodeEntry->next_entry;
+    if (NextEntry) {
+      NextEntry->prev_entry = PrevEntry;
+    }
+    if (PrevEntry) {
+      PrevEntry->next_entry = NextEntry;
+    } else {
+      assert(__jit_debug_descriptor.first_entry == JITCodeEntry);
+      __jit_debug_descriptor.first_entry = NextEntry;
+    }
+
+    // Tell GDB which entry we removed, and unregister the code.
+    __jit_debug_descriptor.relevant_entry = JITCodeEntry;
+    __jit_debug_register_code();
+  }
+
+  // Free the ELF file in memory.
+  std::string &Buffer = I->second.first;
+  Buffer.clear();
+}
+
+void JITDebugRegisterer::UnregisterFunction(const Function *F) {
+  // TODO: Support non-ELF platforms.
+  if (!TM.getELFWriterInfo())
+    return;
+
+  RegisteredFunctionsMap::iterator I = FnMap.find(F);
+  if (I == FnMap.end()) return;
+  UnregisterFunctionInternal(I);
+  FnMap.erase(I);
 }
 
 } // end namespace llvm