Clean-up of memory buffer and object ownership model in MCJIT

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@165053 91177308-0d34-0410-b5e6-96231b3b80d8

3 files changed, 148 insertions, 3 deletions

diff --git a/include/llvm/ExecutionEngine/ObjectBuffer.h b/include/llvm/ExecutionEngine/ObjectBuffer.h
new file mode 100644
index 0000000000..a0a77b8ba8
--- /dev/null
+++ b/include/llvm/ExecutionEngine/ObjectBuffer.h
@@ -0,0 +1,80 @@
+//===---- ObjectBuffer.h - Utility class to wrap object image memory -----===//

+//

+//                     The LLVM Compiler Infrastructure

+//

+// This file is distributed under the University of Illinois Open Source

+// License. See LICENSE.TXT for details.

+//

+//===----------------------------------------------------------------------===//

+//

+// This file declares a wrapper class to hold the memory into which an

+// object will be generated.

+//

+//===----------------------------------------------------------------------===//

+

+#ifndef LLVM_EXECUTIONENGINE_OBJECTBUFFER_H

+#define LLVM_EXECUTIONENGINE_OBJECTBUFFER_H

+

+#include "llvm/ADT/SmallVector.h"

+#include "llvm/ADT/OwningPtr.h"

+#include "llvm/Support/raw_ostream.h"

+#include "llvm/Support/MemoryBuffer.h"

+

+namespace llvm {

+

+/// ObjectBuffer - This class acts as a container for the memory buffer used during

+/// generation and loading of executable objects using MCJIT and RuntimeDyld.  The

+/// underlying memory for the object will be owned by the ObjectBuffer instance

+/// throughout its lifetime.  The getMemBuffer() method provides a way to create a

+/// MemoryBuffer wrapper object instance to be owned by other classes (such as

+/// ObjectFile) as needed, but the MemoryBuffer instance returned does not own the

+/// actual memory it points to.

+class ObjectBuffer {

+public:

+  ObjectBuffer() {}

+  ObjectBuffer(MemoryBuffer* Buf) : Buffer(Buf) {}

+  virtual ~ObjectBuffer() {}

+

+  /// getMemBuffer - Like MemoryBuffer::getMemBuffer() this function

+  /// returns a pointer to an object that is owned by the caller. However,

+  /// the caller does not take ownership of the underlying memory.

+  MemoryBuffer *getMemBuffer() const {

+    return MemoryBuffer::getMemBuffer(Buffer->getBuffer(), "", false);

+  }

+

+  const char *getBufferStart() const { return Buffer->getBufferStart(); }

+  size_t getBufferSize() const { return Buffer->getBufferSize(); }

+

+protected:

+  // The memory contained in an ObjectBuffer

+  OwningPtr<MemoryBuffer> Buffer;

+};

+

+/// ObjectBufferStream - This class encapsulates the SmallVector and

+/// raw_svector_ostream needed to generate an object using MC code emission

+/// while providing a common ObjectBuffer interface for access to the

+/// memory once the object has been generated.

+class ObjectBufferStream : public ObjectBuffer {

+public:

+  ObjectBufferStream() : OS(SV) {}

+  virtual ~ObjectBufferStream() {}

+

+  raw_ostream &getOStream() { return OS; }

+  void flush()

+  {

+    OS.flush();

+

+    // Make the data accessible via the ObjectBuffer::Buffer

+    Buffer.reset(MemoryBuffer::getMemBuffer(StringRef(SV.data(), SV.size()),

+                                            "",

+                                            false));

+  }

+

+protected:

+  SmallVector<char, 4096> SV; // Working buffer into which we JIT.

+  raw_svector_ostream     OS; // streaming wrapper

+};

+

+} // namespace llvm

+

+#endif

diff --git a/include/llvm/ExecutionEngine/ObjectImage.h b/include/llvm/ExecutionEngine/ObjectImage.h
new file mode 100644
index 0000000000..82549add62
--- /dev/null
+++ b/include/llvm/ExecutionEngine/ObjectImage.h
@@ -0,0 +1,61 @@
+//===---- ObjectImage.h - Format independent executuable object image -----===//

+//

+//                     The LLVM Compiler Infrastructure

+//

+// This file is distributed under the University of Illinois Open Source

+// License. See LICENSE.TXT for details.

+//

+//===----------------------------------------------------------------------===//

+//

+// This file declares a file format independent ObjectImage class.

+//

+//===----------------------------------------------------------------------===//

+

+#ifndef LLVM_EXECUTIONENGINE_OBJECTIMAGE_H

+#define LLVM_EXECUTIONENGINE_OBJECTIMAGE_H

+

+#include "llvm/Object/ObjectFile.h"

+#include "llvm/ExecutionEngine/ObjectBuffer.h"

+

+namespace llvm {

+

+

+/// ObjectImage - A container class that represents an ObjectFile that has been

+/// or is in the process of being loaded into memory for execution.

+class ObjectImage {

+  ObjectImage() LLVM_DELETED_FUNCTION;

+  ObjectImage(const ObjectImage &other) LLVM_DELETED_FUNCTION;

+

+protected:

+  OwningPtr<ObjectBuffer> Buffer;

+

+public:

+  ObjectImage(ObjectBuffer *Input) : Buffer(Input) {}

+  virtual ~ObjectImage() {}

+

+  virtual object::symbol_iterator begin_symbols() const = 0;

+  virtual object::symbol_iterator end_symbols() const = 0;

+

+  virtual object::section_iterator begin_sections() const = 0;

+  virtual object::section_iterator end_sections() const  = 0;

+

+  virtual /* Triple::ArchType */ unsigned getArch() const = 0;

+

+  // Subclasses can override these methods to update the image with loaded

+  // addresses for sections and common symbols

+  virtual void updateSectionAddress(const object::SectionRef &Sec,

+                                    uint64_t Addr) = 0;

+  virtual void updateSymbolAddress(const object::SymbolRef &Sym,

+                                   uint64_t Addr) = 0;

+

+  virtual StringRef getData() const = 0;

+

+  // Subclasses can override these methods to provide JIT debugging support

+  virtual void registerWithDebugger() = 0;

+  virtual void deregisterWithDebugger() = 0;

+};

+

+} // end namespace llvm

+

+#endif // LLVM_RUNTIMEDYLD_OBJECT_IMAGE_H

+

diff --git a/include/llvm/ExecutionEngine/RuntimeDyld.h b/include/llvm/ExecutionEngine/RuntimeDyld.h
index a02cbe2d90..7da4a4e09a 100644
--- a/include/llvm/ExecutionEngine/RuntimeDyld.h
+++ b/include/llvm/ExecutionEngine/RuntimeDyld.h
@@ -15,12 +15,13 @@
 #define LLVM_RUNTIME_DYLD_H
 
 #include "llvm/ADT/StringRef.h"
+#include "llvm/ExecutionEngine/ObjectBuffer.h"
 #include "llvm/Support/Memory.h"
 
 namespace llvm {
 
 class RuntimeDyldImpl;
-class MemoryBuffer;
+class ObjectImage;
 
 // RuntimeDyld clients often want to handle the memory management of
 // what gets placed where. For JIT clients, this is an abstraction layer
@@ -65,8 +66,11 @@ public:
   RuntimeDyld(RTDyldMemoryManager*);
   ~RuntimeDyld();
 
-  /// Load an in-memory object file into the dynamic linker.
-  bool loadObject(MemoryBuffer *InputBuffer);
+  /// loadObject - prepare the object contained in the input buffer for
+  /// execution.  Ownership of the input buffer is transferred to the
+  /// ObjectImage instance returned from this function if successful.
+  /// In the case of load failure, the input buffer will be deleted.
+  ObjectImage *loadObject(ObjectBuffer *InputBuffer);
 
   /// Get the address of our local copy of the symbol. This may or may not
   /// be the address used for relocation (clients can copy the data around