Revert "Correctly pass ownership of MemoryBuffers."

llvm-svn: 178918

lld/include/lld/Core/TargetInfo.h

@@ -260,18 +260,17 @@ public:
   /// \param [out] result The instantiated lld::File object is returned here.
   /// The \p result is a vector because some input files parse into more than
   /// one lld::File (e.g. YAML). 
-  virtual error_code
+  virtual error_code parseFile(std::unique_ptr<MemoryBuffer> &inputBuff,
-  parseFile(std::unique_ptr<MemoryBuffer> inputBuff,
+                        std::vector<std::unique_ptr<File>> &result) const = 0;
-            std::vector<std::unique_ptr<File>> &result) const = 0;
+  
-
   /// This is a wrapper around parseFile() where the input file is specified
   /// by file system path.  The default implementation reads the input file
   /// into a memory buffer and calls parseFile().
   ///
   /// \param path This is the file system path to the input file.
   /// \param [out] result The instantiated lld::File object is returned here.
-  virtual error_code
+  virtual error_code readFile(StringRef path,
-  readFile(StringRef path, std::vector<std::unique_ptr<File>> &result) const;
+                        std::vector<std::unique_ptr<File>> &result) const;
 
   /// This method is called by core linking to give the Writer a chance
   /// to add file format specific "files" to set of files to be linked. This is

lld/include/lld/ReaderWriter/CoreTargetInfo.h

@@ -30,10 +30,10 @@ public:
   virtual ErrorOr<Reference::Kind>    relocKindFromString(StringRef str) const;
   virtual ErrorOr<std::string> stringFromRelocKind(Reference::Kind kind) const;
 
-  virtual error_code
-  parseFile(std::unique_ptr<MemoryBuffer> mb,
-            std::vector<std::unique_ptr<File>> &result) const;
 
+  virtual error_code parseFile(std::unique_ptr<MemoryBuffer> &mb,
+                        std::vector<std::unique_ptr<File>> &result) const;
+                        
   void addPassNamed(StringRef name) {
     _passNames.push_back(name);
   }

lld/include/lld/ReaderWriter/ELFTargetInfo.h

@@ -57,10 +57,10 @@ public:
   }
   virtual bool validate(raw_ostream &diagnostics);
 
-  virtual error_code
-  parseFile(std::unique_ptr<MemoryBuffer> mb,
-            std::vector<std::unique_ptr<File>> &result) const;
 
+  virtual error_code parseFile(std::unique_ptr<MemoryBuffer> &mb,
+                        std::vector<std::unique_ptr<File>> &result) const;
+   
   static std::unique_ptr<ELFTargetInfo> create(llvm::Triple);
 
   /// \brief Does this relocation belong in the dynamic plt relocation table?

lld/include/lld/ReaderWriter/MachOTargetInfo.h

@@ -31,10 +31,9 @@ public:
   virtual ErrorOr<Reference::Kind> relocKindFromString(StringRef str) const;
   virtual ErrorOr<std::string> stringFromRelocKind(Reference::Kind kind) const;
   virtual bool validate(raw_ostream &diagnostics);
-
+  
-  virtual error_code
+  virtual error_code parseFile(std::unique_ptr<MemoryBuffer> &mb,
-  parseFile(std::unique_ptr<MemoryBuffer> mb,
+                        std::vector<std::unique_ptr<File>> &result) const;
-            std::vector<std::unique_ptr<File>> &result) const;
 
   uint32_t getCPUType() const;
   uint32_t getCPUSubType() const;

lld/include/lld/ReaderWriter/Reader.h

@@ -39,9 +39,8 @@ public:
   /// file) and create a File object.
   ///
   /// On success, the resulting File object takes ownership of the MemoryBuffer.
-  virtual error_code
+  virtual error_code parseFile(std::unique_ptr<MemoryBuffer> &mb,
-  parseFile(std::unique_ptr<MemoryBuffer> mb,
+                          std::vector<std::unique_ptr<File>> &result) const = 0;
-            std::vector<std::unique_ptr<File>> &result) const = 0;
 
 protected:
   // only concrete subclasses can be instantiated

lld/include/lld/ReaderWriter/ReaderArchive.h

@@ -35,7 +35,7 @@ public:
 
   /// \brief Returns a vector of Files that are contained in the archive file
   ///        pointed to by the Memorybuffer
-  error_code parseFile(std::unique_ptr<llvm::MemoryBuffer> mb,
+  error_code parseFile(std::unique_ptr<llvm::MemoryBuffer> &mb,
                        std::vector<std::unique_ptr<File>> &result) const;
 
 private:

lld/include/lld/ReaderWriter/ReaderLinkerScript.h

@@ -26,7 +26,7 @@ public:
 
   /// \brief Returns a vector of Files that are contained in the archive file
   ///        pointed to by the Memorybuffer
-  error_code parseFile(std::unique_ptr<llvm::MemoryBuffer> mb,
+  error_code parseFile(std::unique_ptr<llvm::MemoryBuffer> &mb,
                        std::vector<std::unique_ptr<File>> &result) const;
 };
 

lld/lib/Core/TargetInfo.cpp

@@ -38,7 +38,8 @@ error_code TargetInfo::readFile(StringRef path,
   if (error_code ec = llvm::MemoryBuffer::getFileOrSTDIN(path, opmb))
     return ec;
 
-  return this->parseFile(std::unique_ptr<MemoryBuffer>(opmb.take()), result);
+  std::unique_ptr<MemoryBuffer> mb(opmb.take());
+  return this->parseFile(mb, result);
 }
 
 error_code TargetInfo::writeFile(const File &linkedFile) const {

lld/lib/ReaderWriter/CoreTargetInfo.cpp

@@ -358,12 +358,11 @@ void CoreTargetInfo::addPasses(PassManager &pm) const {
   }
 }
 
-error_code
+error_code CoreTargetInfo::parseFile(std::unique_ptr<MemoryBuffer> &mb,
-CoreTargetInfo::parseFile(std::unique_ptr<MemoryBuffer> mb,
+                            std::vector<std::unique_ptr<File>> &result) const {
-                          std::vector<std::unique_ptr<File>> &result) const {
   if (!_reader)
     _reader = createReaderYAML(*this);
-  return _reader->parseFile(std::move(mb), result);
+  return _reader->parseFile(mb,result);
 }
 
 Writer &CoreTargetInfo::writer() const {

lld/lib/ReaderWriter/ELF/ELFTargetInfo.cpp

@@ -91,27 +91,27 @@ bool ELFTargetInfo::isDynamic() const {
   return false;
 }
 
-error_code
+error_code ELFTargetInfo::parseFile(std::unique_ptr<MemoryBuffer> &mb,
-ELFTargetInfo::parseFile(std::unique_ptr<MemoryBuffer> mb,
+                          std::vector<std::unique_ptr<File>> &result) const {
-                         std::vector<std::unique_ptr<File>> &result) const {
   if (!_elfReader)
     _elfReader = createReaderELF(*this);
-  std::string path = mb->getBufferIdentifier();
+  error_code ec = _elfReader->parseFile(mb, result);
-  auto magic = llvm::sys::fs::identify_magic(mb->getBuffer());
+  if (ec) {
-  if (magic == llvm::sys::fs::file_magic::elf_relocatable ||
+    // Not an ELF file, check file extension to see if it might be yaml
-      magic == llvm::sys::fs::file_magic::elf_shared_object ||
+    StringRef path = mb->getBufferIdentifier();
-      magic == llvm::sys::fs::file_magic::archive)
+    if ( path.endswith(".objtxt") ) {
-    return _elfReader->parseFile(std::move(mb), result);
+      if (!_yamlReader)
-  // Not an ELF file, check file extension to see if it might be yaml
+          _yamlReader = createReaderYAML(*this);
-  if (StringRef(path).endswith(".objtxt")) {
+      ec = _yamlReader->parseFile(mb, result);
-    if (!_yamlReader)
+    }
-      _yamlReader = createReaderYAML(*this);
+    if (ec) {
-    return _yamlReader->parseFile(std::move(mb), result);
+      // Not a yaml file, assume it is a linkerscript
+      if (!_linkerScriptReader)
+        _linkerScriptReader.reset(new ReaderLinkerScript(*this));
+      ec = _linkerScriptReader->parseFile(mb, result);
+    }
   }
-  // Not a yaml file, assume it is a linkerscript
+  return ec;
-  if (!_linkerScriptReader)
-    _linkerScriptReader.reset(new ReaderLinkerScript(*this));
-  return _linkerScriptReader->parseFile(std::move(mb), result);
 }
 
 Writer &ELFTargetInfo::writer() const {

lld/lib/ReaderWriter/ELF/Reader.cpp

@@ -82,8 +82,8 @@ public:
       : lld::Reader(ti), _elfTargetInfo(ti), _readerArchive(ti, *this) {
   }
 
-  error_code parseFile(std::unique_ptr<MemoryBuffer> mb,
+  error_code parseFile(std::unique_ptr<MemoryBuffer> &mb,
-                       std::vector<std::unique_ptr<File>> &result) const {
+                       std::vector<std::unique_ptr<File> > &result) const {
     using llvm::object::ELFType;
     llvm::sys::LLVMFileType fileType =
         llvm::sys::IdentifyFileType(mb->getBufferStart(),
@@ -96,7 +96,7 @@ public:
     switch (fileType) {
     case llvm::sys::ELF_Relocatable_FileType: {
       std::unique_ptr<File> f(createELF<ELFFileCreateELFTraits>(
-          getElfArchType(mb.get()), MaxAlignment, _elfTargetInfo, std::move(mb),
+          getElfArchType(&*mb), MaxAlignment, _elfTargetInfo, std::move(mb),
           ec));
       if (ec)
         return ec;
@@ -105,15 +105,14 @@ public:
     }
     case llvm::sys::ELF_SharedObject_FileType: {
       auto f = createELF<DynamicFileCreateELFTraits>(
-          getElfArchType(mb.get()), MaxAlignment, _elfTargetInfo,
+          getElfArchType(&*mb), MaxAlignment, _elfTargetInfo, std::move(mb));
-                         std::move(mb));
       if (!f)
         return f;
       result.push_back(std::move(*f));
       break;
     }
     case llvm::sys::Archive_FileType:
-      ec = _readerArchive.parseFile(std::move(mb), result);
+      ec = _readerArchive.parseFile(mb, result);
       break;
     default:
       return llvm::make_error_code(llvm::errc::executable_format_error);

lld/lib/ReaderWriter/MachO/MachOTargetInfo.cpp

@@ -209,16 +209,15 @@ void MachOTargetInfo::addPasses(PassManager &pm) const {
   pm.add(std::unique_ptr<Pass>(new LayoutPass()));
 }
 
-error_code MachOTargetInfo::parseFile(
+error_code MachOTargetInfo::parseFile(std::unique_ptr<MemoryBuffer> &mb,
-    std::unique_ptr<MemoryBuffer> mb,
+                          std::vector<std::unique_ptr<File>> &result) const {
-    std::vector<std::unique_ptr<File>> &result) const {
 //  if (!_machoReader)
 //    _machoReader = createReaderMachO(*this);
 //  error_code ec = _machoReader->parseFile(mb,result);
 //  if (ec) {
     if (!_yamlReader)
       _yamlReader = createReaderYAML(*this);
-    return _yamlReader->parseFile(std::move(mb), result);
+    return _yamlReader->parseFile(mb, result);
 //  }
 
   return error_code::success();

lld/lib/ReaderWriter/Native/ReaderNative.cpp

@@ -915,9 +915,9 @@ public:
   Reader(const TargetInfo &ti)
    : lld::Reader(ti) {}
 
-  virtual error_code
+  virtual error_code parseFile(
-  parseFile(std::unique_ptr<MemoryBuffer> mb,
+      std::unique_ptr<MemoryBuffer> &mb,
-            std::vector<std::unique_ptr<lld::File>> &result) const {
+      std::vector<std::unique_ptr<lld::File> > &result) const {
     return File::make(_targetInfo, mb, mb->getBufferIdentifier(), result);
   }
 };

lld/lib/ReaderWriter/PECOFF/ReaderCOFF.cpp

@@ -369,8 +369,8 @@ class ReaderCOFF : public Reader {
 public:
   ReaderCOFF(const TargetInfo &ti) : Reader(ti) {}
 
-  error_code parseFile(std::unique_ptr<MemoryBuffer> mb,
+  error_code parseFile(std::unique_ptr<MemoryBuffer> &mb,
-                       std::vector<std::unique_ptr<File>> &result) const {
+                       std::vector<std::unique_ptr<File> > &result) const {
     llvm::error_code ec;
     std::unique_ptr<File> f(new FileCOFF(_targetInfo, std::move(mb), ec));
     if (ec) {

lld/lib/ReaderWriter/Reader.cpp

@@ -24,6 +24,7 @@ error_code Reader::readFile(StringRef path,
   if (error_code ec = llvm::MemoryBuffer::getFileOrSTDIN(path, opmb))
     return ec;
 
-  return parseFile(std::unique_ptr<MemoryBuffer>(opmb.take()), result);
+  std::unique_ptr<MemoryBuffer> mb(opmb.take());
+  return this->parseFile(mb, result);
 }
 } // end namespace lld

lld/lib/ReaderWriter/ReaderArchive.cpp

@@ -48,7 +48,7 @@ public:
     if (_targetInfo.logInputFiles())
       llvm::outs() << buff->getBufferIdentifier() << "\n";
     std::unique_ptr<MemoryBuffer> mb(buff.take());
-    if (_targetInfo.parseFile(std::move(mb), result))
+    if (_targetInfo.parseFile(mb, result))
       return nullptr;
 
     assert(result.size() == 1);
@@ -159,9 +159,8 @@ public:
 
 // Returns a vector of Files that are contained in the archive file
 // pointed to by the MemoryBuffer
-error_code
+error_code ReaderArchive::parseFile(std::unique_ptr<llvm::MemoryBuffer> &mb,
-ReaderArchive::parseFile(std::unique_ptr<llvm::MemoryBuffer> mb,
+                            std::vector<std::unique_ptr<File>> &result) const {
-                         std::vector<std::unique_ptr<File>> &result) const {
   error_code ec;
 
   if (_targetInfo.forceLoadAllArchives()) {
@@ -177,7 +176,7 @@ ReaderArchive::parseFile(std::unique_ptr<llvm::MemoryBuffer> mb,
       std::unique_ptr<MemoryBuffer> mbc(buff.take());
       if (_targetInfo.logInputFiles())
         llvm::outs() << buff->getBufferIdentifier() << "\n";
-      if ((ec = _targetInfo.parseFile(std::move(mbc), result)))
+      if ((ec = _targetInfo.parseFile(mbc, result)))
         return ec;
     }
   } else {

lld/lib/ReaderWriter/ReaderLinkerScript.cpp

@@ -79,9 +79,9 @@ private:
 } // end anon namespace
 
 namespace lld {
-error_code ReaderLinkerScript::parseFile(
+error_code
-    std::unique_ptr<llvm::MemoryBuffer> mb,
+ReaderLinkerScript::parseFile(std::unique_ptr<llvm::MemoryBuffer> &mb,
-    std::vector<std::unique_ptr<File>> &result) const {
+                            std::vector<std::unique_ptr<File> > &result) const {
   auto lsf = LinkerScriptFile::create(_targetInfo, std::move(mb));
   if (!lsf)
     return lsf;

lld/lib/ReaderWriter/YAML/ReaderWriterYAML.cpp

@@ -1342,7 +1342,7 @@ class ReaderYAML : public Reader {
 public:
   ReaderYAML(const TargetInfo &ti) : Reader(ti) {}
 
-  error_code parseFile(std::unique_ptr<MemoryBuffer> mb,
+  error_code parseFile(std::unique_ptr<MemoryBuffer> &mb,
                        std::vector<std::unique_ptr<File>> &result) const {
     // Note: we do not take ownership of the MemoryBuffer.  That is
     // because yaml may produce multiple File objects, so there is no