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

diff --git a/include/llvm/ExecutionEngine/ObjectBuffer.h b/include/llvm/ExecutionEngine/ObjectBuffer.h
new file mode 100644 (file)
index 0000000..a0a77b8
--- /dev/null
+++ b/include/llvm/ExecutionEngine/ObjectBuffer.h
@@ -0,0 +1,80 @@
+//===---- ObjectBuffer.h - Utility class to wrap object image memory -----===//\r
+//\r
+//                     The LLVM Compiler Infrastructure\r
+//\r
+// This file is distributed under the University of Illinois Open Source\r
+// License. See LICENSE.TXT for details.\r
+//\r
+//===----------------------------------------------------------------------===//\r
+//\r
+// This file declares a wrapper class to hold the memory into which an\r
+// object will be generated.\r
+//\r
+//===----------------------------------------------------------------------===//\r
+\r
+#ifndef LLVM_EXECUTIONENGINE_OBJECTBUFFER_H\r
+#define LLVM_EXECUTIONENGINE_OBJECTBUFFER_H\r
+\r
+#include "llvm/ADT/SmallVector.h"\r
+#include "llvm/ADT/OwningPtr.h"\r
+#include "llvm/Support/raw_ostream.h"\r
+#include "llvm/Support/MemoryBuffer.h"\r
+\r
+namespace llvm {\r
+\r
+/// ObjectBuffer - This class acts as a container for the memory buffer used during\r
+/// generation and loading of executable objects using MCJIT and RuntimeDyld.  The\r
+/// underlying memory for the object will be owned by the ObjectBuffer instance\r
+/// throughout its lifetime.  The getMemBuffer() method provides a way to create a\r
+/// MemoryBuffer wrapper object instance to be owned by other classes (such as\r
+/// ObjectFile) as needed, but the MemoryBuffer instance returned does not own the\r
+/// actual memory it points to.\r
+class ObjectBuffer {\r
+public:\r
+  ObjectBuffer() {}\r
+  ObjectBuffer(MemoryBuffer* Buf) : Buffer(Buf) {}\r
+  virtual ~ObjectBuffer() {}\r
+\r
+  /// getMemBuffer - Like MemoryBuffer::getMemBuffer() this function\r
+  /// returns a pointer to an object that is owned by the caller. However,\r
+  /// the caller does not take ownership of the underlying memory.\r
+  MemoryBuffer *getMemBuffer() const {\r
+    return MemoryBuffer::getMemBuffer(Buffer->getBuffer(), "", false);\r
+  }\r
+\r
+  const char *getBufferStart() const { return Buffer->getBufferStart(); }\r
+  size_t getBufferSize() const { return Buffer->getBufferSize(); }\r
+\r
+protected:\r
+  // The memory contained in an ObjectBuffer\r
+  OwningPtr<MemoryBuffer> Buffer;\r
+};\r
+\r
+/// ObjectBufferStream - This class encapsulates the SmallVector and\r
+/// raw_svector_ostream needed to generate an object using MC code emission\r
+/// while providing a common ObjectBuffer interface for access to the\r
+/// memory once the object has been generated.\r
+class ObjectBufferStream : public ObjectBuffer {\r
+public:\r
+  ObjectBufferStream() : OS(SV) {}\r
+  virtual ~ObjectBufferStream() {}\r
+\r
+  raw_ostream &getOStream() { return OS; }\r
+  void flush()\r
+  {\r
+    OS.flush();\r
+\r
+    // Make the data accessible via the ObjectBuffer::Buffer\r
+    Buffer.reset(MemoryBuffer::getMemBuffer(StringRef(SV.data(), SV.size()),\r
+                                            "",\r
+                                            false));\r
+  }\r
+\r
+protected:\r
+  SmallVector<char, 4096> SV; // Working buffer into which we JIT.\r
+  raw_svector_ostream     OS; // streaming wrapper\r
+};\r
+\r
+} // namespace llvm\r
+\r
+#endif\r

diff --git a/include/llvm/ExecutionEngine/ObjectImage.h b/include/llvm/ExecutionEngine/ObjectImage.h
new file mode 100644 (file)
index 0000000..82549ad
--- /dev/null
+++ b/include/llvm/ExecutionEngine/ObjectImage.h
@@ -0,0 +1,61 @@
+//===---- ObjectImage.h - Format independent executuable object image -----===//\r
+//\r
+//                     The LLVM Compiler Infrastructure\r
+//\r
+// This file is distributed under the University of Illinois Open Source\r
+// License. See LICENSE.TXT for details.\r
+//\r
+//===----------------------------------------------------------------------===//\r
+//\r
+// This file declares a file format independent ObjectImage class.\r
+//\r
+//===----------------------------------------------------------------------===//\r
+\r
+#ifndef LLVM_EXECUTIONENGINE_OBJECTIMAGE_H\r
+#define LLVM_EXECUTIONENGINE_OBJECTIMAGE_H\r
+\r
+#include "llvm/Object/ObjectFile.h"\r
+#include "llvm/ExecutionEngine/ObjectBuffer.h"\r
+\r
+namespace llvm {\r
+\r
+\r
+/// ObjectImage - A container class that represents an ObjectFile that has been\r
+/// or is in the process of being loaded into memory for execution.\r
+class ObjectImage {\r
+  ObjectImage() LLVM_DELETED_FUNCTION;\r
+  ObjectImage(const ObjectImage &other) LLVM_DELETED_FUNCTION;\r
+\r
+protected:\r
+  OwningPtr<ObjectBuffer> Buffer;\r
+\r
+public:\r
+  ObjectImage(ObjectBuffer *Input) : Buffer(Input) {}\r
+  virtual ~ObjectImage() {}\r
+\r
+  virtual object::symbol_iterator begin_symbols() const = 0;\r
+  virtual object::symbol_iterator end_symbols() const = 0;\r
+\r
+  virtual object::section_iterator begin_sections() const = 0;\r
+  virtual object::section_iterator end_sections() const  = 0;\r
+\r
+  virtual /* Triple::ArchType */ unsigned getArch() const = 0;\r
+\r
+  // Subclasses can override these methods to update the image with loaded\r
+  // addresses for sections and common symbols\r
+  virtual void updateSectionAddress(const object::SectionRef &Sec,\r
+                                    uint64_t Addr) = 0;\r
+  virtual void updateSymbolAddress(const object::SymbolRef &Sym,\r
+                                   uint64_t Addr) = 0;\r
+\r
+  virtual StringRef getData() const = 0;\r
+\r
+  // Subclasses can override these methods to provide JIT debugging support\r
+  virtual void registerWithDebugger() = 0;\r
+  virtual void deregisterWithDebugger() = 0;\r
+};\r
+\r
+} // end namespace llvm\r
+\r
+#endif // LLVM_RUNTIMEDYLD_OBJECT_IMAGE_H\r
+\r

diff --git a/include/llvm/ExecutionEngine/RuntimeDyld.h b/include/llvm/ExecutionEngine/RuntimeDyld.h
index a02cbe2d908b14e87e74be06eb14e1cb0761ce13..7da4a4e09a3855c452d011b8ac9b86edb7f5e2f7 100644 (file)
--- 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"
 #define LLVM_RUNTIME_DYLD_H
 
 #include "llvm/ADT/StringRef.h"

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

 #include "llvm/Support/Memory.h"
 
 namespace llvm {
 
 class RuntimeDyldImpl;
 #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
 
 // 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();
 
   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
 
   /// 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

diff --git a/lib/ExecutionEngine/MCJIT/MCJIT.cpp b/lib/ExecutionEngine/MCJIT/MCJIT.cpp
index fa71305145e5abf41e95bc9ee5dfe03c48780bfc..15cbae92f8de9353a1c57eb4e11ddc924a44b8ff 100644 (file)
--- a/lib/ExecutionEngine/MCJIT/MCJIT.cpp
+++ b/lib/ExecutionEngine/MCJIT/MCJIT.cpp
@@ -12,8 +12,10 @@
 #include "llvm/DerivedTypes.h"
 #include "llvm/Function.h"
 #include "llvm/ExecutionEngine/GenericValue.h"
 #include "llvm/DerivedTypes.h"
 #include "llvm/Function.h"
 #include "llvm/ExecutionEngine/GenericValue.h"

-#include "llvm/ExecutionEngine/MCJIT.h"

 #include "llvm/ExecutionEngine/JITMemoryManager.h"
 #include "llvm/ExecutionEngine/JITMemoryManager.h"

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

 #include "llvm/MC/MCAsmInfo.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/DynamicLibrary.h"
 #include "llvm/MC/MCAsmInfo.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/DynamicLibrary.h"


@@ -50,7 +52,7 @@ ExecutionEngine *MCJIT::createJIT(Module *M,
 MCJIT::MCJIT(Module *m, TargetMachine *tm, RTDyldMemoryManager *MM,
              bool AllocateGVsWithCode)
   : ExecutionEngine(m), TM(tm), Ctx(0), MemMgr(MM), Dyld(MM),
 MCJIT::MCJIT(Module *m, TargetMachine *tm, RTDyldMemoryManager *MM,
              bool AllocateGVsWithCode)
   : ExecutionEngine(m), TM(tm), Ctx(0), MemMgr(MM), Dyld(MM),

-    isCompiled(false), M(m), OS(Buffer)  {
+    isCompiled(false), M(m)  {

 
   setTargetData(TM->getTargetData());
 }
 
   setTargetData(TM->getTargetData());
 }


@@ -63,7 +65,7 @@ MCJIT::~MCJIT() {
 void MCJIT::emitObject(Module *m) {
   /// Currently, MCJIT only supports a single module and the module passed to
   /// this function call is expected to be the contained module.  The module
 void MCJIT::emitObject(Module *m) {
   /// Currently, MCJIT only supports a single module and the module passed to
   /// this function call is expected to be the contained module.  The module

-  /// is passed as a parameter here to prepare for multiple module support in 
+  /// is passed as a parameter here to prepare for multiple module support in

   /// the future.
   assert(M == m);
 
   /// the future.
   assert(M == m);
 


@@ -80,30 +82,32 @@ void MCJIT::emitObject(Module *m) {
 
   PM.add(new TargetData(*TM->getTargetData()));
 
 
   PM.add(new TargetData(*TM->getTargetData()));
 

+  // The RuntimeDyld will take ownership of this shortly
+  OwningPtr<ObjectBufferStream> Buffer(new ObjectBufferStream());
+

   // Turn the machine code intermediate representation into bytes in memory
   // that may be executed.
   // Turn the machine code intermediate representation into bytes in memory
   // that may be executed.

-  if (TM->addPassesToEmitMC(PM, Ctx, OS, false)) {
+  if (TM->addPassesToEmitMC(PM, Ctx, Buffer->getOStream(), false)) {

     report_fatal_error("Target does not support MC emission!");
   }
 
   // Initialize passes.
     report_fatal_error("Target does not support MC emission!");
   }
 
   // Initialize passes.

-  // FIXME: When we support multiple modules, we'll want to move the code
-  // gen and finalization out of the constructor here and do it more
-  // on-demand as part of getPointerToFunction().

   PM.run(*m);
   PM.run(*m);

-  // Flush the output buffer so the SmallVector gets its data.
-  OS.flush();
+  // Flush the output buffer to get the generated code into memory
+  Buffer->flush();

 
   // Load the object into the dynamic linker.
 
   // Load the object into the dynamic linker.

-  MemoryBuffer* MB = MemoryBuffer::getMemBuffer(StringRef(Buffer.data(),
-                                                          Buffer.size()),
-                                                "", false);
-  if (Dyld.loadObject(MB))
+  // handing off ownership of the buffer
+  LoadedObject.reset(Dyld.loadObject(Buffer.take()));
+  if (!LoadedObject)

     report_fatal_error(Dyld.getErrorString());
 
   // Resolve any relocations.
   Dyld.resolveRelocations();
 
     report_fatal_error(Dyld.getErrorString());
 
   // Resolve any relocations.
   Dyld.resolveRelocations();
 

+  // FIXME: Make this optional, maybe even move it to a JIT event listener
+  LoadedObject->registerWithDebugger();
+

   // FIXME: Add support for per-module compilation state
   isCompiled = true;
 }
   // FIXME: Add support for per-module compilation state
   isCompiled = true;
 }

diff --git a/lib/ExecutionEngine/MCJIT/MCJIT.h b/lib/ExecutionEngine/MCJIT/MCJIT.h
index d5c5d77574594d37bf452feba21c29f365949e35..b9ff06e701f0fe2b1dfba19270f52eafafec633f 100644 (file)
--- a/lib/ExecutionEngine/MCJIT/MCJIT.h
+++ b/lib/ExecutionEngine/MCJIT/MCJIT.h
@@ -13,11 +13,11 @@
 #include "llvm/PassManager.h"
 #include "llvm/ExecutionEngine/ExecutionEngine.h"
 #include "llvm/ExecutionEngine/RuntimeDyld.h"
 #include "llvm/PassManager.h"
 #include "llvm/ExecutionEngine/ExecutionEngine.h"
 #include "llvm/ExecutionEngine/RuntimeDyld.h"

-#include "llvm/ADT/SmallVector.h"
-#include "llvm/Support/raw_ostream.h"

 
 namespace llvm {
 
 
 namespace llvm {
 

+class ObjectImage;
+

 // FIXME: This makes all kinds of horrible assumptions for the time being,
 // like only having one module, not needing to worry about multi-threading,
 // blah blah. Purely in get-it-up-and-limping mode for now.
 // FIXME: This makes all kinds of horrible assumptions for the time being,
 // like only having one module, not needing to worry about multi-threading,
 // blah blah. Purely in get-it-up-and-limping mode for now.


@@ -34,10 +34,7 @@ class MCJIT : public ExecutionEngine {
   // FIXME: Add support for multiple modules
   bool isCompiled;
   Module *M;
   // FIXME: Add support for multiple modules
   bool isCompiled;
   Module *M;

-
-  // FIXME: Move these to a single container which manages JITed objects
-  SmallVector<char, 4096> Buffer; // Working buffer into which we JIT.
-  raw_svector_ostream OS;
+  OwningPtr<ObjectImage> LoadedObject;

 
 public:
   ~MCJIT();
 
 public:
   ~MCJIT();

diff --git a/lib/ExecutionEngine/RuntimeDyld/GDBRegistrar.cpp b/lib/ExecutionEngine/RuntimeDyld/GDBRegistrar.cpp
index 8b50101422419fddfce9e04e4982b938b0129d47..50cd0724ea4fc4528bdc663237db2acf990acaed 100644 (file)
--- a/lib/ExecutionEngine/RuntimeDyld/GDBRegistrar.cpp
+++ b/lib/ExecutionEngine/RuntimeDyld/GDBRegistrar.cpp
@@ -78,12 +78,12 @@ public:
   /// Creates an entry in the JIT registry for the buffer @p Object,
   /// which must contain an object file in executable memory with any
   /// debug information for the debugger.
   /// Creates an entry in the JIT registry for the buffer @p Object,
   /// which must contain an object file in executable memory with any
   /// debug information for the debugger.

-  void registerObject(const MemoryBuffer &Object);
+  void registerObject(const ObjectBuffer &Object);

 
   /// Removes the internal registration of @p Object, and
   /// frees associated resources.
   /// Returns true if @p Object was found in ObjectBufferMap.
 
   /// Removes the internal registration of @p Object, and
   /// frees associated resources.
   /// Returns true if @p Object was found in ObjectBufferMap.

-  bool deregisterObject(const MemoryBuffer &Object);
+  bool deregisterObject(const ObjectBuffer &Object);

 
 private:
   /// Deregister the debug info for the given object file from the debugger
 
 private:
   /// Deregister the debug info for the given object file from the debugger


@@ -124,7 +124,7 @@ GDBJITRegistrar::~GDBJITRegistrar() {
   ObjectBufferMap.clear();
 }
 
   ObjectBufferMap.clear();
 }
 

-void GDBJITRegistrar::registerObject(const MemoryBuffer &Object) {
+void GDBJITRegistrar::registerObject(const ObjectBuffer &Object) {

 
   const char *Buffer = Object.getBufferStart();
   size_t      Size = Object.getBufferSize();
 
   const char *Buffer = Object.getBufferStart();
   size_t      Size = Object.getBufferSize();


@@ -147,7 +147,7 @@ void GDBJITRegistrar::registerObject(const MemoryBuffer &Object) {
   }
 }
 
   }
 }
 

-bool GDBJITRegistrar::deregisterObject(const MemoryBuffer& Object) {
+bool GDBJITRegistrar::deregisterObject(const ObjectBuffer& Object) {

   const char *Buffer = Object.getBufferStart();
   RegisteredObjectBufferMap::iterator I = ObjectBufferMap.find(Buffer);
 
   const char *Buffer = Object.getBufferStart();
   RegisteredObjectBufferMap::iterator I = ObjectBufferMap.find(Buffer);
 

diff --git a/lib/ExecutionEngine/RuntimeDyld/JITRegistrar.h b/lib/ExecutionEngine/RuntimeDyld/JITRegistrar.h
index f964bc61829be0fc736904f73234eefa59378e3d..69e9dbe490d62302f2a489b5fff07af176618af5 100644 (file)
--- a/lib/ExecutionEngine/RuntimeDyld/JITRegistrar.h
+++ b/lib/ExecutionEngine/RuntimeDyld/JITRegistrar.h
@@ -10,7 +10,7 @@
 #ifndef LLVM_EXECUTION_ENGINE_JIT_REGISTRAR_H
 #define LLVM_EXECUTION_ENGINE_JIT_REGISTRAR_H
 
 #ifndef LLVM_EXECUTION_ENGINE_JIT_REGISTRAR_H
 #define LLVM_EXECUTION_ENGINE_JIT_REGISTRAR_H
 

-#include "llvm/Support/MemoryBuffer.h"
+#include "llvm/ExecutionEngine/ObjectBuffer.h"

 
 namespace llvm {
 
 
 namespace llvm {
 


@@ -27,12 +27,12 @@ public:
   /// Creates an entry in the JIT registry for the buffer @p Object,
   /// which must contain an object file in executable memory with any
   /// debug information for the debugger.
   /// Creates an entry in the JIT registry for the buffer @p Object,
   /// which must contain an object file in executable memory with any
   /// debug information for the debugger.

-  virtual void registerObject(const MemoryBuffer &Object) = 0;
+  virtual void registerObject(const ObjectBuffer &Object) = 0;

 
   /// Removes the internal registration of @p Object, and
   /// frees associated resources.
   /// Returns true if @p Object was previously registered.
 
   /// Removes the internal registration of @p Object, and
   /// frees associated resources.
   /// Returns true if @p Object was previously registered.

-  virtual bool deregisterObject(const MemoryBuffer &Object) = 0;
+  virtual bool deregisterObject(const ObjectBuffer &Object) = 0;

 
   /// Returns a reference to a GDB JIT registrar singleton
   static JITRegistrar& getGDBRegistrar();
 
   /// Returns a reference to a GDB JIT registrar singleton
   static JITRegistrar& getGDBRegistrar();

diff --git a/lib/ExecutionEngine/RuntimeDyld/ObjectImage.h b/lib/ExecutionEngine/RuntimeDyld/ObjectImage.h
deleted file mode 100644 (file)
index 4fa5c1c..0000000
--- a/lib/ExecutionEngine/RuntimeDyld/ObjectImage.h
+++ /dev/null
@@ -1,59 +0,0 @@
-//===---- 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_RUNTIMEDYLD_OBJECT_IMAGE_H
-#define LLVM_RUNTIMEDYLD_OBJECT_IMAGE_H
-
-#include "llvm/Object/ObjectFile.h"
-
-namespace llvm {
-
-class ObjectImage {
-  ObjectImage() LLVM_DELETED_FUNCTION;
-  ObjectImage(const ObjectImage &other) LLVM_DELETED_FUNCTION;
-protected:
-  object::ObjectFile *ObjFile;
-
-public:
-  ObjectImage(object::ObjectFile *Obj) { ObjFile = Obj; }
-  virtual ~ObjectImage() {}
-
-  virtual object::symbol_iterator begin_symbols() const
-              { return ObjFile->begin_symbols(); }
-  virtual object::symbol_iterator end_symbols() const
-              { return ObjFile->end_symbols(); }
-
-  virtual object::section_iterator begin_sections() const
-              { return ObjFile->begin_sections(); }
-  virtual object::section_iterator end_sections() const
-              { return ObjFile->end_sections(); }
-
-  virtual /* Triple::ArchType */ unsigned getArch() const
-              { return ObjFile->getArch(); }
-
-  // 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) {}
-  virtual void updateSymbolAddress(const object::SymbolRef &Sym, uint64_t Addr)
-              {}
-
-  // Subclasses can override these methods to provide JIT debugging support
-  virtual void registerWithDebugger() {}
-  virtual void deregisterWithDebugger() {}
-};
-
-} // end namespace llvm
-
-#endif // LLVM_RUNTIMEDYLD_OBJECT_IMAGE_H
-

diff --git a/lib/ExecutionEngine/RuntimeDyld/ObjectImageCommon.h b/lib/ExecutionEngine/RuntimeDyld/ObjectImageCommon.h
new file mode 100644 (file)
index 0000000..17f3a21
--- /dev/null
+++ b/lib/ExecutionEngine/RuntimeDyld/ObjectImageCommon.h
@@ -0,0 +1,76 @@
+//===-- ObjectImageCommon.h - Format independent executuable object image -===//\r
+//\r
+//                     The LLVM Compiler Infrastructure\r
+//\r
+// This file is distributed under the University of Illinois Open Source\r
+// License. See LICENSE.TXT for details.\r
+//\r
+//===----------------------------------------------------------------------===//\r
+//\r
+// This file declares a file format independent ObjectImage class.\r
+//\r
+//===----------------------------------------------------------------------===//\r
+\r
+#ifndef LLVM_RUNTIMEDYLD_OBJECTIMAGECOMMON_H\r
+#define LLVM_RUNTIMEDYLD_OBJECTIMAGECOMMON_H\r
+\r
+#include "llvm/Object/ObjectFile.h"\r
+#include "llvm/ExecutionEngine/ObjectImage.h"\r
+#include "llvm/ExecutionEngine/ObjectBuffer.h"\r
+\r
+namespace llvm {\r
+\r
+class ObjectImageCommon : public ObjectImage {\r
+  ObjectImageCommon(); // = delete\r
+  ObjectImageCommon(const ObjectImageCommon &other); // = delete\r
+\r
+protected:\r
+  object::ObjectFile *ObjFile;\r
+\r
+  // This form of the constructor allows subclasses to use\r
+  // format-specific subclasses of ObjectFile directly\r
+  ObjectImageCommon(ObjectBuffer *Input, object::ObjectFile *Obj)\r
+  : ObjectImage(Input), // saves Input as Buffer and takes ownership\r
+    ObjFile(Obj)\r
+  {\r
+  }\r
+\r
+public:\r
+  ObjectImageCommon(ObjectBuffer* Input)\r
+  : ObjectImage(Input) // saves Input as Buffer and takes ownership\r
+  {\r
+    ObjFile = object::ObjectFile::createObjectFile(Buffer->getMemBuffer());\r
+  }\r
+  virtual ~ObjectImageCommon() { delete ObjFile; }\r
+\r
+  virtual object::symbol_iterator begin_symbols() const\r
+              { return ObjFile->begin_symbols(); }\r
+  virtual object::symbol_iterator end_symbols() const\r
+              { return ObjFile->end_symbols(); }\r
+\r
+  virtual object::section_iterator begin_sections() const\r
+              { return ObjFile->begin_sections(); }\r
+  virtual object::section_iterator end_sections() const\r
+              { return ObjFile->end_sections(); }\r
+\r
+  virtual /* Triple::ArchType */ unsigned getArch() const\r
+              { return ObjFile->getArch(); }\r
+\r
+  virtual StringRef getData() const { return ObjFile->getData(); }\r
+\r
+  // Subclasses can override these methods to update the image with loaded\r
+  // addresses for sections and common symbols\r
+  virtual void updateSectionAddress(const object::SectionRef &Sec,\r
+                                    uint64_t Addr) {}\r
+  virtual void updateSymbolAddress(const object::SymbolRef &Sym, uint64_t Addr)\r
+              {}\r
+\r
+  // Subclasses can override these methods to provide JIT debugging support\r
+  virtual void registerWithDebugger() {}\r
+  virtual void deregisterWithDebugger() {}\r
+};\r
+\r
+} // end namespace llvm\r
+\r
+#endif // LLVM_RUNTIMEDYLD_OBJECT_IMAGE_H\r
+\r

diff --git a/lib/ExecutionEngine/RuntimeDyld/RuntimeDyld.cpp b/lib/ExecutionEngine/RuntimeDyld/RuntimeDyld.cpp
index d06a1fc98467c1f20f721594116c1092fd75b079..eb69693359d20bf6c2ae03c24f367dcd3630b162 100644 (file)
--- a/lib/ExecutionEngine/RuntimeDyld/RuntimeDyld.cpp
+++ b/lib/ExecutionEngine/RuntimeDyld/RuntimeDyld.cpp
@@ -12,6 +12,7 @@
 //===----------------------------------------------------------------------===//
 
 #define DEBUG_TYPE "dyld"
 //===----------------------------------------------------------------------===//
 
 #define DEBUG_TYPE "dyld"

+#include "ObjectImageCommon.h"

 #include "RuntimeDyldImpl.h"
 #include "RuntimeDyldELF.h"
 #include "RuntimeDyldMachO.h"
 #include "RuntimeDyldImpl.h"
 #include "RuntimeDyldELF.h"
 #include "RuntimeDyldMachO.h"


@@ -61,14 +62,11 @@ void RuntimeDyldImpl::mapSectionAddress(const void *LocalAddress,
 
 // Subclasses can implement this method to create specialized image instances.
 // The caller owns the pointer that is returned.
 
 // Subclasses can implement this method to create specialized image instances.
 // The caller owns the pointer that is returned.

-ObjectImage *RuntimeDyldImpl::createObjectImage(const MemoryBuffer *InputBuffer) {
-  ObjectFile *ObjFile = ObjectFile::createObjectFile(const_cast<MemoryBuffer*>
-                                                                 (InputBuffer));
-  ObjectImage *Obj = new ObjectImage(ObjFile);
-  return Obj;
+ObjectImage *RuntimeDyldImpl::createObjectImage(ObjectBuffer *InputBuffer) {
+  return new ObjectImageCommon(InputBuffer);

 }
 
 }
 

-bool RuntimeDyldImpl::loadObject(const MemoryBuffer *InputBuffer) {
+ObjectImage *RuntimeDyldImpl::loadObject(ObjectBuffer *InputBuffer) {

   OwningPtr<ObjectImage> obj(createObjectImage(InputBuffer));
   if (!obj)
     report_fatal_error("Unable to create object image from memory buffer!");
   OwningPtr<ObjectImage> obj(createObjectImage(InputBuffer));
   if (!obj)
     report_fatal_error("Unable to create object image from memory buffer!");


@@ -178,9 +176,7 @@ bool RuntimeDyldImpl::loadObject(const MemoryBuffer *InputBuffer) {
     }
   }
 
     }
   }
 

-  handleObjectLoaded(obj.take());
-
-  return false;
+  return obj.take();

 }
 
 void RuntimeDyldImpl::emitCommonSymbols(ObjectImage &Obj,
 }
 
 void RuntimeDyldImpl::emitCommonSymbols(ObjectImage &Obj,


@@ -437,7 +433,7 @@ RuntimeDyld::~RuntimeDyld() {
   delete Dyld;
 }
 
   delete Dyld;
 }
 

-bool RuntimeDyld::loadObject(MemoryBuffer *InputBuffer) {
+ObjectImage *RuntimeDyld::loadObject(ObjectBuffer *InputBuffer) {

   if (!Dyld) {
     sys::LLVMFileType type = sys::IdentifyFileType(
             InputBuffer->getBufferStart(),
   if (!Dyld) {
     sys::LLVMFileType type = sys::IdentifyFileType(
             InputBuffer->getBufferStart(),

diff --git a/lib/ExecutionEngine/RuntimeDyld/RuntimeDyldELF.cpp b/lib/ExecutionEngine/RuntimeDyld/RuntimeDyldELF.cpp
index a1c0e4020fc599b2e170140f826e1ba5752ca61d..597c5cb131f34ab7d4567aaebaf7a1a7d138c903 100644 (file)
--- a/lib/ExecutionEngine/RuntimeDyld/RuntimeDyldELF.cpp
+++ b/lib/ExecutionEngine/RuntimeDyld/RuntimeDyldELF.cpp
@@ -12,16 +12,19 @@
 //===----------------------------------------------------------------------===//
 
 #define DEBUG_TYPE "dyld"
 //===----------------------------------------------------------------------===//
 
 #define DEBUG_TYPE "dyld"

+#include "RuntimeDyldELF.h"
+#include "JITRegistrar.h"
+#include "ObjectImageCommon.h"

 #include "llvm/ADT/OwningPtr.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/IntervalMap.h"
 #include "llvm/ADT/OwningPtr.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/IntervalMap.h"

-#include "RuntimeDyldELF.h"

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

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

 #include "llvm/Support/ELF.h"
 #include "llvm/ADT/Triple.h"
 #include "llvm/Object/ELF.h"
 #include "llvm/Support/ELF.h"
 #include "llvm/ADT/Triple.h"
 #include "llvm/Object/ELF.h"

-#include "JITRegistrar.h"

 using namespace llvm;
 using namespace llvm::object;
 
 using namespace llvm;
 using namespace llvm::object;
 


@@ -41,19 +44,12 @@ class DyldELFObject : public ELFObjectFile<target_endianness, is64Bits> {
   typedef typename ELFDataTypeTypedefHelper<
           target_endianness, is64Bits>::value_type addr_type;
 
   typedef typename ELFDataTypeTypedefHelper<
           target_endianness, is64Bits>::value_type addr_type;
 

-protected:
-  // This duplicates the 'Data' member in the 'Binary' base class
-  // but it is necessary to workaround a bug in gcc 4.2
-  MemoryBuffer *InputData;
-

 public:
 public:

-  DyldELFObject(MemoryBuffer *Object, error_code &ec);
+  DyldELFObject(MemoryBuffer *Wrapper, error_code &ec);

 
   void updateSectionAddress(const SectionRef &Sec, uint64_t Addr);
   void updateSymbolAddress(const SymbolRef &Sym, uint64_t Addr);
 
 
   void updateSectionAddress(const SectionRef &Sec, uint64_t Addr);
   void updateSymbolAddress(const SymbolRef &Sym, uint64_t Addr);
 

-  const MemoryBuffer& getBuffer() const { return *InputData; }
-

   // Methods for type inquiry through isa, cast and dyn_cast
   static inline bool classof(const Binary *v) {
     return (isa<ELFObjectFile<target_endianness, is64Bits> >(v)
   // Methods for type inquiry through isa, cast and dyn_cast
   static inline bool classof(const Binary *v) {
     return (isa<ELFObjectFile<target_endianness, is64Bits> >(v)


@@ -69,14 +65,15 @@ public:
 };
 
 template<support::endianness target_endianness, bool is64Bits>
 };
 
 template<support::endianness target_endianness, bool is64Bits>

-class ELFObjectImage : public ObjectImage {
+class ELFObjectImage : public ObjectImageCommon {

   protected:
     DyldELFObject<target_endianness, is64Bits> *DyldObj;
     bool Registered;
 
   public:
   protected:
     DyldELFObject<target_endianness, is64Bits> *DyldObj;
     bool Registered;
 
   public:

-    ELFObjectImage(DyldELFObject<target_endianness, is64Bits> *Obj)
-    : ObjectImage(Obj),
+    ELFObjectImage(ObjectBuffer *Input,
+                   DyldELFObject<target_endianness, is64Bits> *Obj)
+    : ObjectImageCommon(Input, Obj),

       DyldObj(Obj),
       Registered(false) {}
 
       DyldObj(Obj),
       Registered(false) {}
 


@@ -99,20 +96,22 @@ class ELFObjectImage : public ObjectImage {
 
     virtual void registerWithDebugger()
     {
 
     virtual void registerWithDebugger()
     {

-      JITRegistrar::getGDBRegistrar().registerObject(DyldObj->getBuffer());
+      JITRegistrar::getGDBRegistrar().registerObject(*Buffer);

       Registered = true;
     }
     virtual void deregisterWithDebugger()
     {
       Registered = true;
     }
     virtual void deregisterWithDebugger()
     {

-      JITRegistrar::getGDBRegistrar().deregisterObject(DyldObj->getBuffer());
+      JITRegistrar::getGDBRegistrar().deregisterObject(*Buffer);

     }
 };
 
     }
 };
 

+// The MemoryBuffer passed into this constructor is just a wrapper around the
+// actual memory.  Ultimately, the Binary parent class will take ownership of
+// this MemoryBuffer object but not the underlying memory.

 template<support::endianness target_endianness, bool is64Bits>
 template<support::endianness target_endianness, bool is64Bits>

-DyldELFObject<target_endianness, is64Bits>::DyldELFObject(MemoryBuffer *Object,
+DyldELFObject<target_endianness, is64Bits>::DyldELFObject(MemoryBuffer *Wrapper,

                                                           error_code &ec)
                                                           error_code &ec)

-  : ELFObjectFile<target_endianness, is64Bits>(Object, ec),
-    InputData(Object) {
+  : ELFObjectFile<target_endianness, is64Bits>(Wrapper, ec) {

   this->isDyldELFObject = true;
 }
 
   this->isDyldELFObject = true;
 }
 


@@ -148,46 +147,39 @@ void DyldELFObject<target_endianness, is64Bits>::updateSymbolAddress(
 
 namespace llvm {
 
 
 namespace llvm {
 

-ObjectImage *RuntimeDyldELF::createObjectImage(
-                                         const MemoryBuffer *ConstInputBuffer) {
-  MemoryBuffer *InputBuffer = const_cast<MemoryBuffer*>(ConstInputBuffer);
-  std::pair<unsigned char, unsigned char> Ident = getElfArchType(InputBuffer);
+ObjectImage *RuntimeDyldELF::createObjectImage(ObjectBuffer *Buffer) {
+  if (Buffer->getBufferSize() < ELF::EI_NIDENT)
+    llvm_unreachable("Unexpected ELF object size");
+  std::pair<unsigned char, unsigned char> Ident = std::make_pair(
+                         (uint8_t)Buffer->getBufferStart()[ELF::EI_CLASS],
+                         (uint8_t)Buffer->getBufferStart()[ELF::EI_DATA]);

   error_code ec;
 
   if (Ident.first == ELF::ELFCLASS32 && Ident.second == ELF::ELFDATA2LSB) {
     DyldELFObject<support::little, false> *Obj =
   error_code ec;
 
   if (Ident.first == ELF::ELFCLASS32 && Ident.second == ELF::ELFDATA2LSB) {
     DyldELFObject<support::little, false> *Obj =

-           new DyldELFObject<support::little, false>(InputBuffer, ec);
-    return new ELFObjectImage<support::little, false>(Obj);
+           new DyldELFObject<support::little, false>(Buffer->getMemBuffer(), ec);
+    return new ELFObjectImage<support::little, false>(Buffer, Obj);

   }
   else if (Ident.first == ELF::ELFCLASS32 && Ident.second == ELF::ELFDATA2MSB) {
     DyldELFObject<support::big, false> *Obj =
   }
   else if (Ident.first == ELF::ELFCLASS32 && Ident.second == ELF::ELFDATA2MSB) {
     DyldELFObject<support::big, false> *Obj =

-           new DyldELFObject<support::big, false>(InputBuffer, ec);
-    return new ELFObjectImage<support::big, false>(Obj);
+           new DyldELFObject<support::big, false>(Buffer->getMemBuffer(), ec);
+    return new ELFObjectImage<support::big, false>(Buffer, Obj);

   }
   else if (Ident.first == ELF::ELFCLASS64 && Ident.second == ELF::ELFDATA2MSB) {
     DyldELFObject<support::big, true> *Obj =
   }
   else if (Ident.first == ELF::ELFCLASS64 && Ident.second == ELF::ELFDATA2MSB) {
     DyldELFObject<support::big, true> *Obj =

-           new DyldELFObject<support::big, true>(InputBuffer, ec);
-    return new ELFObjectImage<support::big, true>(Obj);
+           new DyldELFObject<support::big, true>(Buffer->getMemBuffer(), ec);
+    return new ELFObjectImage<support::big, true>(Buffer, Obj);

   }
   else if (Ident.first == ELF::ELFCLASS64 && Ident.second == ELF::ELFDATA2LSB) {
     DyldELFObject<support::little, true> *Obj =
   }
   else if (Ident.first == ELF::ELFCLASS64 && Ident.second == ELF::ELFDATA2LSB) {
     DyldELFObject<support::little, true> *Obj =

-           new DyldELFObject<support::little, true>(InputBuffer, ec);
-    return new ELFObjectImage<support::little, true>(Obj);
+           new DyldELFObject<support::little, true>(Buffer->getMemBuffer(), ec);
+    return new ELFObjectImage<support::little, true>(Buffer, Obj);

   }
   else
     llvm_unreachable("Unexpected ELF format");
 }
 
   }
   else
     llvm_unreachable("Unexpected ELF format");
 }
 

-void RuntimeDyldELF::handleObjectLoaded(ObjectImage *Obj)
-{
-  Obj->registerWithDebugger();
-  // Save the loaded object.  It will deregister itself when deleted
-  LoadedObject = Obj;
-}
-

 RuntimeDyldELF::~RuntimeDyldELF() {
 RuntimeDyldELF::~RuntimeDyldELF() {

-  if (LoadedObject)
-    delete LoadedObject;

 }
 
 void RuntimeDyldELF::resolveX86_64Relocation(uint8_t *LocalAddress,
 }
 
 void RuntimeDyldELF::resolveX86_64Relocation(uint8_t *LocalAddress,


@@ -522,8 +514,9 @@ void RuntimeDyldELF::processRelocationRef(const ObjRelocationInfo &Rel,
   }
 }
 
   }
 }
 

-bool RuntimeDyldELF::isCompatibleFormat(const MemoryBuffer *InputBuffer) const {
-  StringRef Magic = InputBuffer->getBuffer().slice(0, ELF::EI_NIDENT);
-  return (memcmp(Magic.data(), ELF::ElfMagic, strlen(ELF::ElfMagic))) == 0;
+bool RuntimeDyldELF::isCompatibleFormat(const ObjectBuffer *Buffer) const {
+  if (Buffer->getBufferSize() < strlen(ELF::ElfMagic))
+    return false;
+  return (memcmp(Buffer->getBufferStart(), ELF::ElfMagic, strlen(ELF::ElfMagic))) == 0;

 }
 } // namespace llvm
 }
 } // namespace llvm

diff --git a/lib/ExecutionEngine/RuntimeDyld/RuntimeDyldELF.h b/lib/ExecutionEngine/RuntimeDyld/RuntimeDyldELF.h
index eade49ee250f56616b981789d9dce823ca7d34ee..3011a06537dc4ef12b6ec33be0126cd04d146df5 100644 (file)
--- a/lib/ExecutionEngine/RuntimeDyld/RuntimeDyldELF.h
+++ b/lib/ExecutionEngine/RuntimeDyld/RuntimeDyldELF.h
@@ -22,8 +22,6 @@ using namespace llvm;
 namespace llvm {
 class RuntimeDyldELF : public RuntimeDyldImpl {
 protected:
 namespace llvm {
 class RuntimeDyldELF : public RuntimeDyldImpl {
 protected:

-  ObjectImage *LoadedObject;
-

   void resolveX86_64Relocation(uint8_t *LocalAddress,
                                uint64_t FinalAddress,
                                uint64_t Value,
   void resolveX86_64Relocation(uint8_t *LocalAddress,
                                uint64_t FinalAddress,
                                uint64_t Value,


@@ -60,16 +58,15 @@ protected:
                                     const SymbolTableMap &Symbols,
                                     StubMap &Stubs);
 
                                     const SymbolTableMap &Symbols,
                                     StubMap &Stubs);
 

-  virtual ObjectImage *createObjectImage(const MemoryBuffer *InputBuffer);
-  virtual void handleObjectLoaded(ObjectImage *Obj);
+  virtual ObjectImage *createObjectImage(ObjectBuffer *InputBuffer);

 
 public:
   RuntimeDyldELF(RTDyldMemoryManager *mm)
 
 public:
   RuntimeDyldELF(RTDyldMemoryManager *mm)

-      : RuntimeDyldImpl(mm), LoadedObject(0) {}
+      : RuntimeDyldImpl(mm) {}

 
   virtual ~RuntimeDyldELF();
 
 
   virtual ~RuntimeDyldELF();
 

-  bool isCompatibleFormat(const MemoryBuffer *InputBuffer) const;
+  bool isCompatibleFormat(const ObjectBuffer *Buffer) const;

 };
 
 } // end namespace llvm
 };
 
 } // end namespace llvm

diff --git a/lib/ExecutionEngine/RuntimeDyld/RuntimeDyldImpl.h b/lib/ExecutionEngine/RuntimeDyld/RuntimeDyldImpl.h
index d56cab293ca4fc3075875ddc4a9f6e10a47b1c2c..a9733407ec7ff9c11bd98ed7b808cfc29f982e8c 100644 (file)
--- a/lib/ExecutionEngine/RuntimeDyld/RuntimeDyldImpl.h
+++ b/lib/ExecutionEngine/RuntimeDyld/RuntimeDyldImpl.h
@@ -14,8 +14,8 @@
 #ifndef LLVM_RUNTIME_DYLD_IMPL_H
 #define LLVM_RUNTIME_DYLD_IMPL_H
 
 #ifndef LLVM_RUNTIME_DYLD_IMPL_H
 #define LLVM_RUNTIME_DYLD_IMPL_H
 

-#include "ObjectImage.h"

 #include "llvm/ExecutionEngine/RuntimeDyld.h"
 #include "llvm/ExecutionEngine/RuntimeDyld.h"

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

 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringMap.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringMap.h"


@@ -33,7 +33,7 @@ using namespace llvm::object;
 
 namespace llvm {
 
 
 namespace llvm {
 

-class MemoryBuffer;
+class ObjectBuffer;

 class Twine;
 
 
 class Twine;
 
 


@@ -251,19 +251,13 @@ protected:
 
   /// \brief Resolve relocations to external symbols.
   void resolveExternalSymbols();
 
   /// \brief Resolve relocations to external symbols.
   void resolveExternalSymbols();

-  virtual ObjectImage *createObjectImage(const MemoryBuffer *InputBuffer);
-  virtual void handleObjectLoaded(ObjectImage *Obj)
-  {
-    // Subclasses may choose to retain this image if they have a use for it
-    delete Obj;
-  }
-
+  virtual ObjectImage *createObjectImage(ObjectBuffer *InputBuffer);

 public:
   RuntimeDyldImpl(RTDyldMemoryManager *mm) : MemMgr(mm), HasError(false) {}
 
   virtual ~RuntimeDyldImpl();
 
 public:
   RuntimeDyldImpl(RTDyldMemoryManager *mm) : MemMgr(mm), HasError(false) {}
 
   virtual ~RuntimeDyldImpl();
 

-  bool loadObject(const MemoryBuffer *InputBuffer);
+  ObjectImage *loadObject(ObjectBuffer *InputBuffer);

 
   void *getSymbolAddress(StringRef Name) {
     // FIXME: Just look up as a function for now. Overly simple of course.
 
   void *getSymbolAddress(StringRef Name) {
     // FIXME: Just look up as a function for now. Overly simple of course.


@@ -298,8 +292,7 @@ public:
   // Get the error message.
   StringRef getErrorString() { return ErrorStr; }
 
   // Get the error message.
   StringRef getErrorString() { return ErrorStr; }
 

-  virtual bool isCompatibleFormat(const MemoryBuffer *InputBuffer) const = 0;
-
+  virtual bool isCompatibleFormat(const ObjectBuffer *Buffer) const = 0;

 };
 
 } // end namespace llvm
 };
 
 } // end namespace llvm

diff --git a/lib/ExecutionEngine/RuntimeDyld/RuntimeDyldMachO.cpp b/lib/ExecutionEngine/RuntimeDyld/RuntimeDyldMachO.cpp
index 465e85d7d91941335dce0c739318b62c5b7743e2..56540c23dac3b444b880bbe35aa3bf6816ba7023 100644 (file)
--- a/lib/ExecutionEngine/RuntimeDyld/RuntimeDyldMachO.cpp
+++ b/lib/ExecutionEngine/RuntimeDyld/RuntimeDyldMachO.cpp
@@ -295,8 +295,10 @@ void RuntimeDyldMachO::processRelocationRef(const ObjRelocationInfo &Rel,
 
 
 bool RuntimeDyldMachO::isCompatibleFormat(
 
 
 bool RuntimeDyldMachO::isCompatibleFormat(

-        const MemoryBuffer *InputBuffer) const {
-  StringRef Magic = InputBuffer->getBuffer().slice(0, 4);
+        const ObjectBuffer *InputBuffer) const {
+  if (InputBuffer->getBufferSize() < 4)
+    return false;
+  StringRef Magic(InputBuffer->getBufferStart(), 4);

   if (Magic == "\xFE\xED\xFA\xCE") return true;
   if (Magic == "\xCE\xFA\xED\xFE") return true;
   if (Magic == "\xFE\xED\xFA\xCF") return true;
   if (Magic == "\xFE\xED\xFA\xCE") return true;
   if (Magic == "\xCE\xFA\xED\xFE") return true;
   if (Magic == "\xFE\xED\xFA\xCF") return true;

diff --git a/lib/ExecutionEngine/RuntimeDyld/RuntimeDyldMachO.h b/lib/ExecutionEngine/RuntimeDyld/RuntimeDyldMachO.h
index 707664c73278cd3f1f9840b5711ac8802b0b2186..ef56f551fc893d3a47c2b228289b85347e2a1bbf 100644 (file)
--- a/lib/ExecutionEngine/RuntimeDyld/RuntimeDyldMachO.h
+++ b/lib/ExecutionEngine/RuntimeDyld/RuntimeDyldMachO.h
@@ -63,7 +63,7 @@ public:
 
   RuntimeDyldMachO(RTDyldMemoryManager *mm) : RuntimeDyldImpl(mm) {}
 
 
   RuntimeDyldMachO(RTDyldMemoryManager *mm) : RuntimeDyldImpl(mm) {}
 

-  bool isCompatibleFormat(const MemoryBuffer *InputBuffer) const;
+  bool isCompatibleFormat(const ObjectBuffer *Buffer) const;

 };
 
 } // end namespace llvm
 };
 
 } // end namespace llvm

diff --git a/tools/llvm-rtdyld/llvm-rtdyld.cpp b/tools/llvm-rtdyld/llvm-rtdyld.cpp
index 95de8d8a4d5323aa2164e5d11eed46d76ec35e72..7b5bd0388d882d58424c4aa754ea0096a18c89b8 100644 (file)
--- a/tools/llvm-rtdyld/llvm-rtdyld.cpp
+++ b/tools/llvm-rtdyld/llvm-rtdyld.cpp
@@ -14,6 +14,8 @@
 #include "llvm/ADT/StringMap.h"
 #include "llvm/ADT/OwningPtr.h"
 #include "llvm/ExecutionEngine/RuntimeDyld.h"
 #include "llvm/ADT/StringMap.h"
 #include "llvm/ADT/OwningPtr.h"
 #include "llvm/ExecutionEngine/RuntimeDyld.h"

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

 #include "llvm/Object/MachOObject.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/ManagedStatic.h"
 #include "llvm/Object/MachOObject.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/ManagedStatic.h"


@@ -120,12 +122,14 @@ static int executeInput() {
   for(unsigned i = 0, e = InputFileList.size(); i != e; ++i) {
     // Load the input memory buffer.
     OwningPtr<MemoryBuffer> InputBuffer;
   for(unsigned i = 0, e = InputFileList.size(); i != e; ++i) {
     // Load the input memory buffer.
     OwningPtr<MemoryBuffer> InputBuffer;

+    OwningPtr<ObjectImage>  LoadedObject;

     if (error_code ec = MemoryBuffer::getFileOrSTDIN(InputFileList[i],
                                                      InputBuffer))
       return Error("unable to read input: '" + ec.message() + "'");
 
     if (error_code ec = MemoryBuffer::getFileOrSTDIN(InputFileList[i],
                                                      InputBuffer))
       return Error("unable to read input: '" + ec.message() + "'");
 

-    // Load the object file into it.
-    if (Dyld.loadObject(InputBuffer.take())) {
+    // Load the object file
+    LoadedObject.reset(Dyld.loadObject(new ObjectBuffer(InputBuffer.take())));
+    if (!LoadedObject) {

       return Error(Dyld.getErrorString());
     }
   }
       return Error(Dyld.getErrorString());
     }
   }