(demo) lld diag changes

[ruiu]

Oops, sorry, I have submitted a series of patches that conflict with yours. You want to rebase to head.

[thakis]

This is not meant for review, I only uploaded it so I could link to it from https://llvm.org/bugs/show_bug.cgi?id=28553

COFF/InputFiles.cpp

std::string InputFile::getShortName() {
   std::string Res = (getBasename(ParentName) + "(" +
                      getBasename(getName()) + ")").str();
   return StringRef(Res).lower();
 }
 
 void ArchiveFile::parse() {
   // Parse a MemoryBufferRef as an archive file.
   auto ArchiveOrErr = Archive::create(MB);
-  error(errorToErrorCode(ArchiveOrErr.takeError()),
-        "Failed to parse static library");
+  error(errorToErrorCode(ArchiveOrErr.takeError()), getShortName());
   File = std::move(*ArchiveOrErr);
 
   // Allocate a buffer for Lazy objects.
   size_t NumSyms = File->getNumberOfSymbols();
   LazySymbols.reserve(NumSyms);
 
   // Read the symbol table to construct Lazy objects.
   for (const Archive::Symbol &Sym : File->symbols())
     LazySymbols.emplace_back(this, Sym);
 
   // Seen is a map from member files to boolean values. Initially
   // all members are mapped to false, which indicates all these files
   // are not read yet.
   Error Err;
   for (auto &Child : File->children(Err))
     Seen[Child.getChildOffset()].clear();
-  error(std::move(Err), "Failed to parse static library");
+  error(std::move(Err), getShortName());
 }
 
 // Returns a buffer pointing to a member file containing a given symbol.
 // This function is thread-safe.
 MemoryBufferRef ArchiveFile::getMember(const Archive::Symbol *Sym) {
   auto COrErr = Sym->getMember();
-  error(COrErr, Twine("Could not get the member for symbol ") + Sym->getName());
+  error(COrErr, Sym->getName() + Twine(": Could not get member for symbol"));
   const Archive::Child &C = *COrErr;
 
   // Return an empty buffer if we have already returned the same buffer.
   if (Seen[C.getChildOffset()].test_and_set())
     return MemoryBufferRef();
   ErrorOr<MemoryBufferRef> Ret = C.getMemoryBufferRef();
-  error(Ret, Twine("Could not get the buffer for the member defining symbol ") +
-                 Sym->getName());
+  error(Ret, Sym->getName() +
+                 Twine(": Could not get buffer for member defining symbol"));
   return *Ret;
 }
 
 void ObjectFile::parse() {
   // Parse a memory buffer as a COFF file.
   auto BinOrErr = createBinary(MB);
   if (!BinOrErr)
-    error(errorToErrorCode(BinOrErr.takeError()),
-                           "Failed to parse object file");
+    error(errorToErrorCode(BinOrErr.takeError()), getShortName());
   std::unique_ptr<Binary> Bin = std::move(*BinOrErr);
 
   if (auto *Obj = dyn_cast<COFFObjectFile>(Bin.get())) {
     Bin.release();
     COFFObj.reset(Obj);
   } else {
-    error(Twine(getName()) + " is not a COFF file.");
+    error(getShortName() + ": not a COFF file");
   }
 
   // Read section and symbol tables.
   initializeChunks();
   initializeSymbols();
   initializeSEH();
 }
 
void ObjectFile::initializeSymbols() {
   uint32_t NumSymbols = COFFObj->getNumberOfSymbols();
   SymbolBodies.reserve(NumSymbols);
   SparseSymbolBodies.resize(NumSymbols);
   llvm::SmallVector<std::pair<Undefined *, uint32_t>, 8> WeakAliases;
   int32_t LastSectionNumber = 0;
   for (uint32_t I = 0; I < NumSymbols; ++I) {
     // Get a COFFSymbolRef object.
     auto SymOrErr = COFFObj->getSymbol(I);
-    error(SymOrErr, Twine("broken object file: ") + getName());
+    error(SymOrErr, getShortName());
 
     COFFSymbolRef Sym = *SymOrErr;
 
     const void *AuxP = nullptr;
     if (Sym.getNumberOfAuxSymbols())
       AuxP = COFFObj->getSymbol(I + 1)->getRawPtr();
     bool IsFirst = (LastSectionNumber != Sym.getSectionNumber());
 
if (Sym.isAbsolute()) {
     return new (Alloc) DefinedAbsolute(Name, Sym);
   }
   int32_t SectionNumber = Sym.getSectionNumber();
   if (SectionNumber == llvm::COFF::IMAGE_SYM_DEBUG)
     return nullptr;
 
   // Reserved sections numbers don't have contents.
   if (llvm::COFF::isReservedSectionNumber(SectionNumber))
-    error(Twine("broken object file: ") + getName());
+    error(getShortName() + Twine(": broken object file"));
 
   // This symbol references a section which is not present in the section
   // header.
   if ((uint32_t)SectionNumber >= SparseChunks.size())
-    error(Twine("broken object file: ") + getName());
+    error(getShortName() + Twine(": broken object file"));
 
   // Nothing else to do without a section chunk.
   auto *SC = cast_or_null<SectionChunk>(SparseChunks[SectionNumber]);
   if (!SC)
     return nullptr;
 
   // Handle section definitions
   if (IsFirst && AuxP) {

COFF/Librarian.cpp

std::string Name = E.ExtName.empty()
                            ? std::string(E.SymbolName)
                            : replace(E.SymbolName, E.Name, E.ExtName);
     Members.push_back(OF.createShortImport(Name, E.Ordinal, Type, E.Data));
   }
 
   std::pair<StringRef, std::error_code> Result =
       writeArchive(Path, Members, /*WriteSymtab*/ true, object::Archive::K_GNU,
                    /*Deterministic*/ true, /*Thin*/ false);
-  error(Result.second, Twine("Failed to write ") + Path);
+  error(Result.second, Path);
 }
 

COFF/Writer.cpp

template <typename PEHeaderTy> void Writer::writeHeader() {
   write32le(Buf, Strtab.size() + 4);
   if (!Strtab.empty())
     memcpy(Buf + 4, Strtab.data(), Strtab.size());
 }
 
 void Writer::openFile(StringRef Path) {
   ErrorOr<std::unique_ptr<FileOutputBuffer>> BufferOrErr =
       FileOutputBuffer::create(Path, FileSize, FileOutputBuffer::F_executable);
-  error(BufferOrErr, Twine("failed to open ") + Path);
+  error(BufferOrErr, Path);
   Buffer = std::move(*BufferOrErr);
 }
 
 void Writer::fixSafeSEHSymbols() {
   if (!SEHTable)
     return;
   Config->SEHTable->setRVA(SEHTable->getRVA());
   Config->SEHCount->setVA(SEHTable->getSize() / 4);