Start using make() in COFF.

We don't want ELF and COFF to diverge too much.

llvm-svn: 289085

lld/COFF/Driver.cpp

@@ -15,6 +15,7 @@
 #include "Symbols.h"
 #include "Writer.h"
 #include "lld/Driver/Driver.h"
+#include "lld/Support/Memory.h"
 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/StringSwitch.h"
 #include "llvm/LibDriver/LibDriver.h"
@@ -43,10 +44,8 @@ Configuration *Config;
 LinkerDriver *Driver;
 
 bool link(llvm::ArrayRef<const char *> Args) {
-  Configuration C;
-  LinkerDriver D;
-  Config = &C;
-  Driver = &D;
+  Config = make<Configuration>();
+  Driver = make<LinkerDriver>();
   Driver->link(Args);
   return true;
 }
@@ -69,7 +68,7 @@ MemoryBufferRef LinkerDriver::openFile(StringRef Path) {
   return MBRef;
 }
 
-static std::unique_ptr<InputFile> createFile(MemoryBufferRef MB) {
+static InputFile *createFile(MemoryBufferRef MB) {
   if (Driver->Cpio)
     Driver->Cpio->append(relativeToRoot(MB.getBufferIdentifier()),
                          MB.getBuffer());
@@ -77,15 +76,15 @@ static std::unique_ptr<InputFile> createFile(MemoryBufferRef MB) {
   // File type is detected by contents, not by file extension.
   file_magic Magic = identify_magic(MB.getBuffer());
   if (Magic == file_magic::archive)
-    return std::unique_ptr<InputFile>(new ArchiveFile(MB));
+    return make<ArchiveFile>(MB);
   if (Magic == file_magic::bitcode)
-    return std::unique_ptr<InputFile>(new BitcodeFile(MB));
+    return make<BitcodeFile>(MB);
   if (Magic == file_magic::coff_cl_gl_object)
     fatal(MB.getBufferIdentifier() + ": is not a native COFF file. "
           "Recompile without /GL");
   if (Config->OutputFile == "")
     Config->OutputFile = getOutputPath(MB.getBufferIdentifier());
-  return std::unique_ptr<InputFile>(new ObjectFile(MB));
+  return make<ObjectFile>(MB);
 }
 
 static bool isDecorated(StringRef Sym) {
@@ -572,7 +571,7 @@ void LinkerDriver::link(llvm::ArrayRef<const char *> ArgsArr) {
   // Determine machine type and check if all object files are
   // for the same CPU type. Note that this needs to be done before
   // any call to mangle().
-  for (std::unique_ptr<InputFile> &File : Symtab.getFiles()) {
+  for (InputFile *File : Symtab.getFiles()) {
     MachineTypes MT = File->getMachineType();
     if (MT == IMAGE_FILE_MACHINE_UNKNOWN)
       continue;
@@ -581,7 +580,7 @@ void LinkerDriver::link(llvm::ArrayRef<const char *> ArgsArr) {
       continue;
     }
     if (Config->Machine != MT)
-      fatal(toString(File.get()) + ": machine type " + machineToStr(MT) +
+      fatal(toString(File) + ": machine type " + machineToStr(MT) +
             " conflicts with " + machineToStr(Config->Machine));
   }
   if (Config->Machine == IMAGE_FILE_MACHINE_UNKNOWN) {

lld/COFF/Error.cpp

@@ -14,6 +14,10 @@
 #include "llvm/Support/Process.h"
 #include "llvm/Support/raw_ostream.h"
 
+#if !defined(_MSC_VER) && !defined(__MINGW32__)
+#include <unistd.h>
+#endif
+
 using namespace llvm;
 
 namespace lld {
@@ -29,7 +33,10 @@ void fatal(const Twine &Msg) {
   }
 
   errs() << Msg << "\n";
-  exit(1);
+
+  outs().flush();
+  errs().flush();
+  _exit(1);
 }
 
 void fatal(std::error_code EC, const Twine &Msg) {

lld/COFF/InputFiles.cpp

@@ -7,12 +7,14 @@
 //
 //===----------------------------------------------------------------------===//
 
+#include "InputFiles.h"
 #include "Chunks.h"
 #include "Config.h"
 #include "Driver.h"
 #include "Error.h"
-#include "InputFiles.h"
 #include "Symbols.h"
+#include "lld/Support/Memory.h"
+#include "llvm-c/lto.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/Triple.h"
 #include "llvm/ADT/Twine.h"
@@ -27,7 +29,6 @@
 #include "llvm/Support/ErrorOr.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Target/TargetOptions.h"
-#include "llvm-c/lto.h"
 #include <cstring>
 #include <system_error>
 #include <utility>
@@ -97,14 +98,10 @@ MutableArrayRef<Lazy> ArchiveFile::getLazySymbols() { return LazySymbols; }
 
 void ObjectFile::parse() {
   // Parse a memory buffer as a COFF file.
-  std::unique_ptr<Binary> Bin = check(createBinary(MB), toString(this));
-
-  if (auto *Obj = dyn_cast<COFFObjectFile>(Bin.get())) {
-    Bin.release();
-    COFFObj.reset(Obj);
-  } else {
-    fatal(toString(this) + " is not a COFF file");
-  }
+  std::error_code EC;
+  COFFObj = new COFFObjectFile(MB, EC);
+  if (EC)
+    fatal(EC, "failed to parse object");
 
   // Read section and symbol tables.
   initializeChunks();

lld/COFF/InputFiles.h

@@ -127,7 +127,7 @@ public:
   }
 
   // Returns the underying COFF file.
-  COFFObjectFile *getCOFFObj() { return COFFObj.get(); }
+  COFFObjectFile *getCOFFObj() { return COFFObj; }
 
   // True if this object file is compatible with SEH.
   // COFF-specific and x86-only.
@@ -145,7 +145,7 @@ private:
   Defined *createDefined(COFFSymbolRef Sym, const void *Aux, bool IsFirst);
   Undefined *createUndefined(COFFSymbolRef Sym);
 
-  std::unique_ptr<COFFObjectFile> COFFObj;
+  COFFObjectFile *COFFObj;
   llvm::BumpPtrAllocator Alloc;
   const coff_section *SXData = nullptr;
 

lld/COFF/SymbolTable.cpp

@@ -24,15 +24,14 @@ using namespace llvm;
 namespace lld {
 namespace coff {
 
-void SymbolTable::addFile(std::unique_ptr<InputFile> FileP) {
+void SymbolTable::addFile(InputFile *File) {
 #if LLVM_ENABLE_THREADS
   std::launch Policy = std::launch::async;
 #else
   std::launch Policy = std::launch::deferred;
 #endif
 
-  InputFile *File = FileP.get();
-  Files.push_back(std::move(FileP));
+  Files.push_back(File);
   if (auto *F = dyn_cast<ArchiveFile>(File)) {
     ArchiveQueue.push_back(
         std::async(Policy, [=]() { F->parse(); return F; }));
@@ -156,11 +155,11 @@ void SymbolTable::reportRemainingUndefines(bool Resolve) {
   for (Undefined *U : Config->GCRoot)
     if (Undefs.count(U->repl()))
       llvm::errs() << "<root>: undefined symbol: " << U->getName() << "\n";
-  for (std::unique_ptr<InputFile> &File : Files)
-    if (!isa<ArchiveFile>(File.get()))
+  for (InputFile *File : Files)
+    if (!isa<ArchiveFile>(File))
       for (SymbolBody *Sym : File->getSymbols())
         if (Undefs.count(Sym->repl()))
-          llvm::errs() << toString(File.get())
+          llvm::errs() << toString(File)
                        << ": undefined symbol: " << Sym->getName() << "\n";
   if (!Config->Force)
     fatal("link failed");
@@ -230,16 +229,16 @@ Symbol *SymbolTable::insert(SymbolBody *New) {
 
 // Reads an archive member file pointed by a given symbol.
 void SymbolTable::addMemberFile(Lazy *Body) {
-  std::unique_ptr<InputFile> File = Body->getMember();
+  InputFile *File = Body->getMember();
 
   // getMember returns an empty buffer if the member was already
   // read from the library.
   if (!File)
     return;
   if (Config->Verbose)
-    llvm::outs() << "Loaded " << toString(File.get()) << " for "
-                 << Body->getName() << "\n";
-  addFile(std::move(File));
+    llvm::outs() << "Loaded " << toString(File) << " for " << Body->getName()
+                 << "\n";
+  addFile(File);
 }
 
 std::vector<Chunk *> SymbolTable::getChunks() {

lld/COFF/SymbolTable.h

@@ -49,8 +49,8 @@ struct Symbol;
 // to replace the lazy symbol. The logic is implemented in resolve().
 class SymbolTable {
 public:
-  void addFile(std::unique_ptr<InputFile> File);
-  std::vector<std::unique_ptr<InputFile>> &getFiles() { return Files; }
+  void addFile(InputFile *File);
+  std::vector<InputFile *> &getFiles() { return Files; }
   void step();
   void run();
   bool queueEmpty();
@@ -111,7 +111,7 @@ private:
 
   llvm::DenseMap<StringRef, Symbol *> Symtab;
 
-  std::vector<std::unique_ptr<InputFile>> Files;
+  std::vector<InputFile *> Files;
   std::vector<std::future<ArchiveFile *>> ArchiveQueue;
   std::vector<std::future<InputFile *>> ObjectQueue;
 

lld/COFF/Symbols.cpp

@@ -11,6 +11,7 @@
 #include "Error.h"
 #include "InputFiles.h"
 #include "Strings.h"
+#include "lld/Support/Memory.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/raw_ostream.h"
@@ -181,23 +182,23 @@ DefinedImportThunk::DefinedImportThunk(StringRef Name, DefinedImportData *S,
   }
 }
 
-std::unique_ptr<InputFile> Lazy::getMember() {
+InputFile *Lazy::getMember() {
   MemoryBufferRef MBRef = File->getMember(&Sym);
 
   // getMember returns an empty buffer if the member was already
   // read from the library.
   if (MBRef.getBuffer().empty())
-    return std::unique_ptr<InputFile>(nullptr);
+    return nullptr;
 
   file_magic Magic = identify_magic(MBRef.getBuffer());
   if (Magic == file_magic::coff_import_library)
-    return std::unique_ptr<InputFile>(new ImportFile(MBRef));
+    return make<ImportFile>(MBRef);
 
-  std::unique_ptr<InputFile> Obj;
+  InputFile *Obj;
   if (Magic == file_magic::coff_object)
-    Obj.reset(new ObjectFile(MBRef));
+    Obj = make<ObjectFile>(MBRef);
   else if (Magic == file_magic::bitcode)
-    Obj.reset(new BitcodeFile(MBRef));
+    Obj = make<BitcodeFile>(MBRef);
   else
     fatal("unknown file type: " + File->getName());
 

lld/COFF/Symbols.h

@@ -256,7 +256,7 @@ public:
 
   // Returns an object file for this symbol, or a nullptr if the file
   // was already returned.
-  std::unique_ptr<InputFile> getMember();
+  InputFile *getMember();
 
   int getFileIndex() { return File->Index; }