[ELF] - Change all messages to be lowercase to be consistent.

[grimar]

Summary

That is directly opposite to http://reviews.llvm.org/D18045,
which is already reverted.

This patch changes all messages to start from lowercase letter if
they were not before.

That is done to be consistent with clang.

[grimar]

test/ELF/invalid-elf.test

22 ↗

(On Diff #50428)

I had to add INVALID-SECTION-INDEX-LLD check line. Because this text comes from lld,

26 ↗

(On Diff #50428)

while this comes from \llvm\lib\Object\error.cpp file

[• rafael]

LGTM

[ruiu]

lld/trunk/ELF/InputFiles.cpp

439–465

Isn't this an accidental change?

[• rafael]

Gah, this basically reverted my patch.

[grimar]

In D18085#373425, @rafael wrote:

Gah, this basically reverted my patch.

I am really sorry, don't sure how such thing happened.

lld/trunk/ELF/Driver.cpp

if (S == "elf64ppc" || S == "elf64ppc_fbsd")
     return {ELF64BEKind, EM_PPC64};
   if (S == "elf_i386")
     return {ELF32LEKind, EM_386};
   if (S == "elf_x86_64")
     return {ELF64LEKind, EM_X86_64};
   if (S == "aarch64linux")
     return {ELF64LEKind, EM_AARCH64};
   if (S == "i386pe" || S == "i386pep" || S == "thumb2pe")
-    error("Windows targets are not supported on the ELF frontend: " + S);
+    error("windows targets are not supported on the ELF frontend: " + S);
   else
-    error("Unknown emulation: " + S);
+    error("unknown emulation: " + S);
   return {ELFNoneKind, 0};
 }
 
 // Returns slices of MB by parsing MB as an archive file.
 // Each slice consists of a member file in the archive.
 static std::vector<MemoryBufferRef> getArchiveMembers(MemoryBufferRef MB) {
   std::unique_ptr<Archive> File =
       check(Archive::create(MB), "Failed to parse archive");
if (WholeArchive) {
       for (MemoryBufferRef MB : getArchiveMembers(MBRef))
         Files.push_back(createObjectFile(MB, Path));
       return;
     }
     Files.push_back(make_unique<ArchiveFile>(MBRef));
     return;
   case file_magic::elf_shared_object:
     if (Config->Relocatable) {
-      error("Attempted static link of dynamic object " + Path);
+      error("attempted static link of dynamic object " + Path);
       return;
     }
     Files.push_back(createSharedFile(MBRef));
     return;
   default:
     Files.push_back(createObjectFile(MBRef));
   }
 }
 
 // Add a given library by searching it from input search paths.
 void LinkerDriver::addLibrary(StringRef Name) {
   std::string Path = searchLibrary(Name);
   if (Path.empty())
-    error("Unable to find library -l" + Name);
+    error("unable to find library -l" + Name);
   else
     addFile(Path);
 }
 
 // Some command line options or some combinations of them are not allowed.
 // This function checks for such errors.
 static void checkOptions(opt::InputArgList &Args) {
   // The MIPS ABI as of 2016 does not support the GNU-style symbol lookup
   // table which is a relatively new feature.
   if (Config->EMachine == EM_MIPS && Config->GnuHash)
-    error("The .gnu.hash section is not compatible with the MIPS target.");
+    error("the .gnu.hash section is not compatible with the MIPS target.");
 
   if (Config->EMachine == EM_AMDGPU && !Config->Entry.empty())
     error("-e option is not valid for AMDGPU.");
 
   if (!Config->Relocatable)
     return;
 
   if (Config->Shared)
void LinkerDriver::readConfigs(opt::InputArgList &Args) {
   Config->ZRelro = !hasZOption(Args, "norelro");
 
   if (Config->Relocatable)
     Config->StripAll = false;
 
   if (auto *Arg = Args.getLastArg(OPT_O)) {
     StringRef Val = Arg->getValue();
     if (Val.getAsInteger(10, Config->Optimize))
-      error("Invalid optimization level");
+      error("invalid optimization level");
   }
 
   if (auto *Arg = Args.getLastArg(OPT_hash_style)) {
     StringRef S = Arg->getValue();
     if (S == "gnu") {
       Config->GnuHash = true;
       Config->SysvHash = false;
     } else if (S == "both") {
       Config->GnuHash = true;
     } else if (S != "sysv")
-      error("Unknown hash style: " + S);
+      error("unknown hash style: " + S);
   }
 
   for (auto *Arg : Args.filtered(OPT_undefined))
     Config->Undefined.push_back(Arg->getValue());
 }
 
 void LinkerDriver::createFiles(opt::InputArgList &Args) {
   for (auto *Arg : Args) {

lld/trunk/ELF/InputFiles.h

 #include "Config.h"
 #include "InputSection.h"
 #include "Error.h"
 #include "Symbols.h"
 
 #include "lld/Core/LLVM.h"
 #include "llvm/ADT/DenseSet.h"
 #include "llvm/ADT/STLExtras.h"
-#include "llvm/IR/Comdat.h"
 #include "llvm/Object/Archive.h"
 #include "llvm/Object/ELF.h"
-#include "llvm/Object/IRObjectFile.h"
 #include "llvm/Support/StringSaver.h"
 
 namespace lld {
 namespace elf {
 
 using llvm::object::Archive;
 
 class InputFile;

 };
 
 class BitcodeFile : public InputFile {
 public:
   explicit BitcodeFile(MemoryBufferRef M);
   static bool classof(const InputFile *F);
   void parse(llvm::DenseSet<StringRef> &ComdatGroups);
   ArrayRef<SymbolBody *> getSymbols() { return SymbolBodies; }
-  static bool shouldSkip(const llvm::object::BasicSymbolRef &Sym);
+  ArrayRef<StringRef> getExtraKeeps() { return ExtraKeeps; }
 
 private:
   std::vector<SymbolBody *> SymbolBodies;
+  // Some symbols like llvm.global_ctors are internal to the IR and so
+  // don't show up in SymbolBodies, but must be kept when creating the
+  // combined LTO module. We track them here.
+  // We currently use a different Module for creating SymbolBody's vs when
+  // we are creating the combined LTO module, and so we can't store IR
+  // pointers directly and must rely on the IR names.
+  std::vector<StringRef> ExtraKeeps;
   llvm::BumpPtrAllocator Alloc;
   llvm::StringSaver Saver{Alloc};
-  SymbolBody *
-  createSymbolBody(const llvm::DenseSet<const llvm::Comdat *> &KeptComdats,
-                   const llvm::object::IRObjectFile &Obj,
-                   const llvm::object::BasicSymbolRef &Sym);
 };
 
 // .so file.
 template <class ELFT> class SharedFile : public ELFFileBase<ELFT> {
   typedef ELFFileBase<ELFT> Base;
   typedef typename llvm::object::ELFFile<ELFT>::Elf_Shdr Elf_Shdr;
   typedef typename llvm::object::ELFFile<ELFT>::Elf_Sym Elf_Sym;
   typedef typename llvm::object::ELFFile<ELFT>::Elf_Word Elf_Word;

lld/trunk/ELF/InputFiles.cpp

 typename ELFFileBase<ELFT>::Elf_Sym_Range
 ELFFileBase<ELFT>::getElfSymbols(bool OnlyGlobals) {
   if (!Symtab)
     return Elf_Sym_Range(nullptr, nullptr);
   Elf_Sym_Range Syms = ELFObj.symbols(Symtab);
   uint32_t NumSymbols = std::distance(Syms.begin(), Syms.end());
   uint32_t FirstNonLocal = Symtab->sh_info;
   if (FirstNonLocal > NumSymbols)
-    fatal("Invalid sh_info in symbol table");
+    fatal("invalid sh_info in symbol table");
 
   if (OnlyGlobals)
     return make_range(Syms.begin() + FirstNonLocal, Syms.end());
   return make_range(Syms.begin(), Syms.end());
 }
 
 template <class ELFT>
 uint32_t ELFFileBase<ELFT>::getSectionIndex(const Elf_Sym &Sym) const {

 
 template <class ELFT>
 ArrayRef<typename elf::ObjectFile<ELFT>::uint32_X>
 elf::ObjectFile<ELFT>::getShtGroupEntries(const Elf_Shdr &Sec) {
   const ELFFile<ELFT> &Obj = this->ELFObj;
   ArrayRef<uint32_X> Entries =
       check(Obj.template getSectionContentsAsArray<uint32_X>(&Sec));
   if (Entries.empty() || Entries[0] != GRP_COMDAT)
-    fatal("Unsupported SHT_GROUP format");
+    fatal("unsupported SHT_GROUP format");
   return Entries.slice(1);
 }
 
 template <class ELFT>
 static bool shouldMerge(const typename ELFFile<ELFT>::Elf_Shdr &Sec) {
   typedef typename ELFFile<ELFT>::uintX_t uintX_t;
   uintX_t Flags = Sec.sh_flags;
   if (!(Flags & SHF_MERGE))
     return false;
   if (Flags & SHF_WRITE)
-    fatal("Writable SHF_MERGE sections are not supported");
+    fatal("writable SHF_MERGE sections are not supported");
   uintX_t EntSize = Sec.sh_entsize;
   if (!EntSize || Sec.sh_size % EntSize)
     fatal("SHF_MERGE section size must be a multiple of sh_entsize");
 
   // Don't try to merge if the aligment is larger than the sh_entsize and this
   // is not SHF_STRINGS.
   //
   // Since this is not a SHF_STRINGS, we would need to pad after every entity.
for (const Elf_Shdr &Sec : Obj.sections()) {
 
     switch (Sec.sh_type) {
     case SHT_GROUP:
       Sections[I] = InputSection<ELFT>::Discarded;
       if (ComdatGroups.insert(getShtGroupSignature(Sec)).second)
         continue;
       for (uint32_t SecIndex : getShtGroupEntries(Sec)) {
         if (SecIndex >= Size)
-          fatal("Invalid section index in group");
+          fatal("invalid section index in group");
         Sections[SecIndex] = InputSection<ELFT>::Discarded;
       }
       break;
     case SHT_SYMTAB:
       this->Symtab = &Sec;
       break;
     case SHT_SYMTAB_SHNDX:
       this->SymtabSHNDX = check(Obj.getSHNDXTable(Sec));
       break;
     case SHT_STRTAB:
     case SHT_NULL:
       break;
     case SHT_RELA:
     case SHT_REL: {
       uint32_t RelocatedSectionIndex = Sec.sh_info;
       if (RelocatedSectionIndex >= Size)
-        fatal("Invalid relocated section index");
+        fatal("invalid relocated section index");
       InputSectionBase<ELFT> *RelocatedSection =
           Sections[RelocatedSectionIndex];
       // Strictly speaking, a relocation section must be included in the
       // group of the section it relocates. However, LLVM 3.3 and earlier
       // would fail to do so, so we gracefully handle that case.
       if (RelocatedSection == InputSection<ELFT>::Discarded)
         continue;
       if (!RelocatedSection)
-        fatal("Unsupported relocation reference");
+        fatal("unsupported relocation reference");
       if (Config->Relocatable) {
         // For -r, relocation sections are handled as regular input sections.
         Sections[I] = new (Alloc) InputSection<ELFT>(this, &Sec);
       } else if (auto *S = dyn_cast<InputSection<ELFT>>(RelocatedSection)) {
         S->RelocSections.push_back(&Sec);
       } else if (auto *S = dyn_cast<EHInputSection<ELFT>>(RelocatedSection)) {
         if (S->RelocSection)
-          fatal("Multiple relocation sections to .eh_frame are not supported");
+          fatal("multiple relocation sections to .eh_frame are not supported");
         S->RelocSection = &Sec;
       } else {
-        fatal("Relocations pointing to SHF_MERGE are not supported");
+        fatal("relocations pointing to SHF_MERGE are not supported");
       }
       break;
     }
     default:
       Sections[I] = createInputSection(Sec);
     }
   }
 }
 
 template <class ELFT>
 InputSectionBase<ELFT> *
 elf::ObjectFile<ELFT>::createInputSection(const Elf_Shdr &Sec) {
   StringRef Name = check(this->ELFObj.getSectionName(&Sec));
 
   // .note.GNU-stack is a marker section to control the presence of
   // PT_GNU_STACK segment in outputs. Since the presence of the segment
   // is controlled only by the command line option (-z execstack) in LLD,
   // .note.GNU-stack is ignored.
   if (Name == ".note.GNU-stack")
     return InputSection<ELFT>::Discarded;
 
   if (Name == ".note.GNU-split-stack")
-    error("Objects using splitstacks are not supported");
+    error("objects using splitstacks are not supported");
 
   // A MIPS object file has a special section that contains register
   // usage info, which needs to be handled by the linker specially.
   if (Config->EMachine == EM_MIPS && Name == ".reginfo") {
     MipsReginfo = new (Alloc) MipsReginfoInputSection<ELFT>(this, &Sec);
     return MipsReginfo;
   }
 

 
 template <class ELFT>
 InputSectionBase<ELFT> *
 elf::ObjectFile<ELFT>::getSection(const Elf_Sym &Sym) const {
   uint32_t Index = this->getSectionIndex(Sym);
   if (Index == 0)
     return nullptr;
   if (Index >= Sections.size() || !Sections[Index])
-    fatal("Invalid section index");
+    fatal("invalid section index");
   InputSectionBase<ELFT> *S = Sections[Index];
   if (S == InputSectionBase<ELFT>::Discarded)
     return S;
   return S->Repl;
 }
 
 template <class ELFT>
 SymbolBody *elf::ObjectFile<ELFT>::createSymbolBody(const Elf_Sym *Sym) {
template <class ELFT> void SharedFile<ELFT>::parseSoName() {
   auto *Begin =
       reinterpret_cast<const Elf_Dyn *>(Obj.base() + DynamicSec->sh_offset);
   const Elf_Dyn *End = Begin + DynamicSec->sh_size / sizeof(Elf_Dyn);
 
   for (const Elf_Dyn &Dyn : make_range(Begin, End)) {
     if (Dyn.d_tag == DT_SONAME) {
       uintX_t Val = Dyn.getVal();
       if (Val >= this->StringTable.size())
-        fatal("Invalid DT_SONAME entry");
+        fatal("invalid DT_SONAME entry");
       SoName = StringRef(this->StringTable.data() + Val);
       return;
     }
   }
 }
 
 // Fully parse the shared object file. This must be called after parseSoName().
 template <class ELFT> void SharedFile<ELFT>::parseRest() {
static uint8_t getGvVisibility(const GlobalValue *GV) {
   switch (GV->getVisibility()) {
   case GlobalValue::DefaultVisibility:
     return STV_DEFAULT;
   case GlobalValue::HiddenVisibility:
     return STV_HIDDEN;
   case GlobalValue::ProtectedVisibility:
     return STV_PROTECTED;
   }
-  llvm_unreachable("Unknown visibility");
+  llvm_unreachable("unknown visibility");
 }
 
-SymbolBody *
-BitcodeFile::createSymbolBody(const DenseSet<const Comdat *> &KeptComdats,
-                              const IRObjectFile &Obj,
-                              const BasicSymbolRef &Sym) {
-  const GlobalValue *GV = Obj.getSymbolGV(Sym.getRawDataRefImpl());
+void BitcodeFile::parse(DenseSet<StringRef> &ComdatGroups) {
+  LLVMContext Context;
+  std::unique_ptr<IRObjectFile> Obj = check(IRObjectFile::create(MB, Context));
+  const Module &M = Obj->getModule();
+
+  DenseSet<const Comdat *> KeptComdats;
+  for (const auto &P : M.getComdatSymbolTable()) {
+    StringRef N = Saver.save(P.first());
+    if (ComdatGroups.insert(N).second)
+      KeptComdats.insert(&P.second);
+  }
+
+  for (const BasicSymbolRef &Sym : Obj->symbols()) {
+    const GlobalValue *GV = Obj->getSymbolGV(Sym.getRawDataRefImpl());
     assert(GV);
+    uint32_t Flags = Sym.getFlags();
     if (const Comdat *C = GV->getComdat())
       if (!KeptComdats.count(C))
-      return nullptr;
-
+        continue;
+    if (!(Flags & BasicSymbolRef::SF_Global))
+        continue;
+    if (GV->hasAppendingLinkage()) {
+      ExtraKeeps.push_back(GV->getName().copy(Alloc));
+      continue;
+    }
+    if (Flags & BasicSymbolRef::SF_FormatSpecific)
+      continue;
     uint8_t Visibility = getGvVisibility(GV);
 
     SmallString<64> Name;
     raw_svector_ostream OS(Name);
     Sym.printName(OS);
     StringRef NameRef = Saver.save(StringRef(Name));
 
-  const Module &M = Obj.getModule();
     SymbolBody *Body;
-  uint32_t Flags = Sym.getFlags();
     bool IsWeak = Flags & BasicSymbolRef::SF_Weak;
     if (Flags & BasicSymbolRef::SF_Undefined) {
       Body = new (Alloc) Undefined(NameRef, IsWeak, Visibility, false);
     } else if (Flags & BasicSymbolRef::SF_Common) {
       const DataLayout &DL = M.getDataLayout();
       uint64_t Size = DL.getTypeAllocSize(GV->getValueType());
       Body = new (Alloc)
           DefinedCommon(NameRef, Size, GV->getAlignment(), IsWeak, Visibility);
     } else {
       Body = new (Alloc) DefinedBitcode(NameRef, IsWeak, Visibility);
     }
     Body->IsTls = GV->isThreadLocal();
-  return Body;
-}
-
-bool BitcodeFile::shouldSkip(const BasicSymbolRef &Sym) {
-  uint32_t Flags = Sym.getFlags();
-  if (!(Flags & BasicSymbolRef::SF_Global))
-    return true;
-  if (Flags & BasicSymbolRef::SF_FormatSpecific)
-    return true;
-  return false;
-}
-
-void BitcodeFile::parse(DenseSet<StringRef> &ComdatGroups) {
-  LLVMContext Context;
-  std::unique_ptr<IRObjectFile> Obj = check(IRObjectFile::create(MB, Context));
-  const Module &M = Obj->getModule();
-
-  DenseSet<const Comdat *> KeptComdats;
-  for (const auto &P : M.getComdatSymbolTable()) {
-    StringRef N = Saver.save(P.first());
-    if (ComdatGroups.insert(N).second)
-      KeptComdats.insert(&P.second);
+    SymbolBodies.push_back(Body);
   }
-
-  for (const BasicSymbolRef &Sym : Obj->symbols())
-    if (!shouldSkip(Sym))
-      SymbolBodies.push_back(createSymbolBody(KeptComdats, *Obj, Sym));
 }
 
 template <typename T>
 static std::unique_ptr<InputFile> createELFFileAux(MemoryBufferRef MB) {
   std::unique_ptr<T> Ret = llvm::make_unique<T>(MB);
 
   if (!Config->FirstElf)
     Config->FirstElf = Ret.get();
 
   if (Config->EKind == ELFNoneKind) {
     Config->EKind = Ret->getELFKind();
     Config->EMachine = Ret->getEMachine();
   }
 
   return std::move(Ret);
 }
 
 template <template <class> class T>
 static std::unique_ptr<InputFile> createELFFile(MemoryBufferRef MB) {
   std::pair<unsigned char, unsigned char> Type = getElfArchType(MB.getBuffer());
   if (Type.second != ELF::ELFDATA2LSB && Type.second != ELF::ELFDATA2MSB)
-    fatal("Invalid data encoding: " + MB.getBufferIdentifier());
+    fatal("invalid data encoding: " + MB.getBufferIdentifier());
 
   if (Type.first == ELF::ELFCLASS32) {
     if (Type.second == ELF::ELFDATA2LSB)
       return createELFFileAux<T<ELF32LE>>(MB);
     return createELFFileAux<T<ELF32BE>>(MB);
   }
   if (Type.first == ELF::ELFCLASS64) {
     if (Type.second == ELF::ELFDATA2LSB)
       return createELFFileAux<T<ELF64LE>>(MB);
     return createELFFileAux<T<ELF64BE>>(MB);
   }
-  fatal("Invalid file class: " + MB.getBufferIdentifier());
+  fatal("invalid file class: " + MB.getBufferIdentifier());
 }
 
 std::unique_ptr<InputFile> elf::createObjectFile(MemoryBufferRef MB,
                                                  StringRef ArchiveName) {
   using namespace sys::fs;
   std::unique_ptr<InputFile> F;
   if (identify_magic(MB.getBuffer()) == file_magic::bitcode)
     F.reset(new BitcodeFile(MB));

lld/trunk/ELF/InputSection.cpp

 using namespace llvm::ELF;
 using namespace llvm::object;
 using namespace llvm::support::endian;
 
 using namespace lld;
 using namespace lld::elf;
 
 template <class ELFT>
-InputSectionBase<ELFT>::InputSectionBase(elf::ObjectFile<ELFT> *File,
+InputSectionBase<ELFT>::InputSectionBase(ObjectFile<ELFT> *File,
                                          const Elf_Shdr *Header,
                                          Kind SectionKind)
     : Header(Header), File(File), SectionKind(SectionKind), Repl(this) {
   // The garbage collector sets sections' Live bits.
   // If GC is disabled, all sections are considered live by default.
   Live = !Config->GcSections;
 
   // The ELF spec states that a value of 0 means the section has
case EHFrame:
     return cast<EHInputSection<ELFT>>(this)->getOffset(Offset);
   case Merge:
     return cast<MergeInputSection<ELFT>>(this)->getOffset(Offset);
   case MipsReginfo:
     // MIPS .reginfo sections are consumed by the linker,
     // so it should never be copied to output.
     llvm_unreachable("MIPS .reginfo reached writeTo().");
   }
-  llvm_unreachable("Invalid section kind");
+  llvm_unreachable("invalid section kind");
 }
 
 template <class ELFT>
 typename ELFFile<ELFT>::uintX_t
 InputSectionBase<ELFT>::getOffset(const Elf_Sym &Sym) {
   return getOffset(Sym.st_value);
 }
 

 
 template <class ELFT>
 InputSectionBase<ELFT> *
 InputSectionBase<ELFT>::getRelocTarget(const Elf_Rela &Rel) const {
   return getRelocTarget(reinterpret_cast<const Elf_Rel &>(Rel));
 }
 
 template <class ELFT>
-InputSection<ELFT>::InputSection(elf::ObjectFile<ELFT> *F,
-                                 const Elf_Shdr *Header)
+InputSection<ELFT>::InputSection(ObjectFile<ELFT> *F, const Elf_Shdr *Header)
     : InputSectionBase<ELFT>(F, Header, Base::Regular) {}
 
 template <class ELFT>
 bool InputSection<ELFT>::classof(const InputSectionBase<ELFT> *S) {
   return S->SectionKind == Base::Regular;
 }
 
 template <class ELFT>

 void InputSection<ELFT>::replace(InputSection<ELFT> *Other) {
   this->Align = std::max(this->Align, Other->Align);
   Other->Repl = this->Repl;
   Other->Live = false;
 }
 
 template <class ELFT>
 SplitInputSection<ELFT>::SplitInputSection(
-    elf::ObjectFile<ELFT> *File, const Elf_Shdr *Header,
+    ObjectFile<ELFT> *File, const Elf_Shdr *Header,
     typename InputSectionBase<ELFT>::Kind SectionKind)
     : InputSectionBase<ELFT>(File, Header, SectionKind) {}
 
 template <class ELFT>
-EHInputSection<ELFT>::EHInputSection(elf::ObjectFile<ELFT> *F,
+EHInputSection<ELFT>::EHInputSection(ObjectFile<ELFT> *F,
                                      const Elf_Shdr *Header)
     : SplitInputSection<ELFT>(F, Header, InputSectionBase<ELFT>::EHFrame) {
   // Mark .eh_frame sections as live by default because there are
   // usually no relocations that point to .eh_frames. Otherwise,
   // the garbage collector would drop all .eh_frame sections.
   this->Live = true;
 }
 

 std::pair<std::pair<typename ELFFile<ELFT>::uintX_t,
                     typename ELFFile<ELFT>::uintX_t> *,
           typename ELFFile<ELFT>::uintX_t>
 SplitInputSection<ELFT>::getRangeAndSize(uintX_t Offset) {
   ArrayRef<uint8_t> D = this->getSectionData();
   StringRef Data((const char *)D.data(), D.size());
   uintX_t Size = Data.size();
   if (Offset >= Size)
-    fatal("Entry is past the end of the section");
+    fatal("entry is past the end of the section");
 
   // Find the element this offset points to.
   auto I = std::upper_bound(
       Offsets.begin(), Offsets.end(), Offset,
       [](const uintX_t &A, const std::pair<uintX_t, uintX_t> &B) {
         return A < B.first;
       });
   uintX_t End = I == Offsets.end() ? Data.size() : I->first;
MergeInputSection<ELFT>::getOffset(uintX_t Offset) {
   StringRef Data((const char *)D.data(), D.size());
   StringRef Entry = Data.substr(Start, End - Start);
   Base =
       static_cast<MergeOutputSection<ELFT> *>(this->OutSec)->getOffset(Entry);
   return Base + Addend;
 }
 
 template <class ELFT>
-MipsReginfoInputSection<ELFT>::MipsReginfoInputSection(elf::ObjectFile<ELFT> *F,
+MipsReginfoInputSection<ELFT>::MipsReginfoInputSection(ObjectFile<ELFT> *F,
                                                        const Elf_Shdr *Hdr)
     : InputSectionBase<ELFT>(F, Hdr, InputSectionBase<ELFT>::MipsReginfo) {
   // Initialize this->Reginfo.
   ArrayRef<uint8_t> D = this->getSectionData();
   if (D.size() != sizeof(Elf_Mips_RegInfo<ELFT>))
-    fatal("Invalid size of .reginfo section");
+    fatal("invalid size of .reginfo section");
   Reginfo = reinterpret_cast<const Elf_Mips_RegInfo<ELFT> *>(D.data());
 }
 
 template <class ELFT>
 bool MipsReginfoInputSection<ELFT>::classof(const InputSectionBase<ELFT> *S) {
   return S->SectionKind == InputSectionBase<ELFT>::MipsReginfo;
 }
 

lld/trunk/ELF/LinkerScript.cpp

else
       Driver->addFile(Saver.save(Config->Sysroot + "/" + S.substr(1)));
   } else if (S.startswith("-l")) {
     Driver->addLibrary(S.substr(2));
   } else if (sys::fs::exists(S)) {
     Driver->addFile(S);
   } else {
     std::string Path = findFromSearchPaths(S);
     if (Path.empty())
-      setError("Unable to find " + S);
+      setError("unable to find " + S);
     else
       Driver->addFile(Saver.save(Path));
   }
 }
 
 void ScriptParser::readAsNeeded() {
   expect("(");
   bool Orig = Config->AsNeeded;

 
 std::vector<uint8_t> ScriptParser::parseHex(StringRef S) {
   std::vector<uint8_t> Hex;
   while (!S.empty()) {
     StringRef B = S.substr(0, 2);
     S = S.substr(2);
     uint8_t H;
     if (B.getAsInteger(16, H)) {
-      setError("Not a HEX value: " + B);
+      setError("not a HEX value: " + B);
       return {};
     }
     Hex.push_back(H);
   }
   return Hex;
 }
 
 void ScriptParser::readOutputSectionDescription() {
   StringRef OutSec = next();
   Script->SectionOrder.push_back(OutSec);
   expect(":");
   expect("{");
   while (!Error && !skip("}")) {
     StringRef Tok = next();
     if (Tok == "*") {
       readSectionPatterns(OutSec, false);
     } else if (Tok == "KEEP") {
       expect("(");
       next(); // Skip *
       readSectionPatterns(OutSec, true);
       expect(")");
     } else {
-      setError("Unknown command " + Tok);
+      setError("unknown command " + Tok);
     }
   }
   StringRef Tok = peek();
   if (Tok.startswith("=")) {
     if (!Tok.startswith("=0x")) {
-      setError("Filler should be a HEX value");
+      setError("filler should be a HEX value");
       return;
     }
     Tok = Tok.substr(3);
     Script->Filler[OutSec] = parseHex(Tok);
     next();
   }
 }
 

lld/trunk/ELF/OutputSections.cpp

case Off_Sec:
     return OffsetSec->getOffset(OffsetInSec) + OffsetSec->OutSec->getVA();
   case Off_Bss:
     return cast<SharedSymbol<ELFT>>(Sym)->OffsetInBss + Out<ELFT>::Bss->getVA();
   case Off_Got:
     return Sym->getGotVA<ELFT>();
   case Off_GotPlt:
     return Sym->getGotPltVA<ELFT>();
   }
-  llvm_unreachable("Invalid offset kind");
+  llvm_unreachable("invalid offset kind");
 }
 
 template <class ELFT> void RelocationSection<ELFT>::writeTo(uint8_t *Buf) {
   for (const DynamicReloc<ELFT> &Rel : Relocs) {
     auto *P = reinterpret_cast<Elf_Rel *>(Buf);
     Buf += IsRela ? sizeof(Elf_Rela) : sizeof(Elf_Rel);
     SymbolBody *Sym = Rel.Sym;
 
while (!D.empty()) {
     } else {
       if (!HasReloc)
         fatal("FDE doesn't reference another section");
       InputSectionBase<ELFT> *Target = S->getRelocTarget(*RelI);
       if (Target && Target->Live) {
         uint32_t CieOffset = Offset + 4 - ID;
         auto I = OffsetToIndex.find(CieOffset);
         if (I == OffsetToIndex.end())
-          fatal("Invalid CIE reference");
+          fatal("invalid CIE reference");
         Cies[I->second].Fdes.push_back(EHRegion<ELFT>(S, Index));
         Out<ELFT>::EhFrameHdr->reserveFde();
         this->Header.sh_size += alignTo(Length, sizeof(uintX_t));
       }
     }
 
     Offset = NextOffset;
     D = D.slice(Length);
void MergeOutputSection<ELFT>::addSection(InputSectionBase<ELFT> *C) {
   uintX_t EntSize = S->getSectionHdr()->sh_entsize;
 
   // If this is of type string, the contents are null-terminated strings.
   if (this->Header.sh_flags & SHF_STRINGS) {
     uintX_t Offset = 0;
     while (!Data.empty()) {
       size_t End = findNull(Data, EntSize);
       if (End == StringRef::npos)
-        fatal("String is not null terminated");
+        fatal("string is not null terminated");
       StringRef Entry = Data.substr(0, End + EntSize);
       uintX_t OutputOffset = Builder.add(Entry);
       if (shouldTailMerge())
         OutputOffset = -1;
       S->Offsets.push_back(std::make_pair(Offset, OutputOffset));
       uintX_t Size = End + EntSize;
       Data = Data.substr(Size);
       Offset += Size;
case SymbolBody::SharedKind:
     if (cast<SharedSymbol<ELFT>>(Sym)->needsCopy())
       return Out<ELFT>::Bss;
     break;
   case SymbolBody::UndefinedElfKind:
   case SymbolBody::UndefinedKind:
   case SymbolBody::LazyKind:
     break;
   case SymbolBody::DefinedBitcodeKind:
-    llvm_unreachable("Should have been replaced");
+    llvm_unreachable("should have been replaced");
   }
   return nullptr;
 }
 
 template <class ELFT>
 uint8_t SymbolTableSection<ELFT>::getSymbolBinding(SymbolBody *Body) {
   uint8_t Visibility = Body->getVisibility();
   if (Visibility != STV_DEFAULT && Visibility != STV_PROTECTED)

lld/trunk/ELF/SymbolTable.cpp

if (auto *F = dyn_cast<SharedFile<ELFT>>(FileP)) {
     return;
   }
 
   // LLVM bitcode file.
   if (auto *F = dyn_cast<BitcodeFile>(FileP)) {
     BitcodeFiles.emplace_back(cast<BitcodeFile>(File.release()));
     F->parse(ComdatGroups);
     for (SymbolBody *B : F->getSymbols())
-      if (B)
-        resolve(B);
     return;
   }
 
   // .o file
   auto *F = cast<ObjectFile<ELFT>>(FileP);
   ObjectFiles.emplace_back(cast<ObjectFile<ELFT>>(File.release()));
   F->parse(ComdatGroups);
   for (SymbolBody *B : F->getNonLocalSymbols())
std::unique_ptr<InputFile> SymbolTable<ELFT>::codegen(Module &M) {
 
   // FIXME: Should we have a default triple? The gold plugin uses
   // sys::getDefaultTargetTriple(), but that is probably wrong given that this
   // might be a cross linker.
 
   std::string ErrMsg;
   const Target *TheTarget = TargetRegistry::lookupTarget(TripleStr, ErrMsg);
   if (!TheTarget)
-    fatal("Target not found: " + ErrMsg);
+    fatal("target not found: " + ErrMsg);
 
   TargetOptions Options;
   Reloc::Model R = Config->Shared ? Reloc::PIC_ : Reloc::Static;
   std::unique_ptr<TargetMachine> TM(
       TheTarget->createTargetMachine(TripleStr, "", "", Options, R));
 
   raw_svector_ostream OS(OwningLTOData);
   legacy::PassManager CodeGenPasses;
   if (TM->addPassesToEmitFile(CodeGenPasses, OS,
                               TargetMachine::CGFT_ObjectFile))
-    fatal("Failed to setup codegen");
+    fatal("failed to setup codegen");
   CodeGenPasses.run(M);
   LtoBuffer = MemoryBuffer::getMemBuffer(OwningLTOData, "", false);
   if (Config->SaveTemps)
     saveLtoObjectFile(LtoBuffer->getBuffer());
   return createObjectFile(*LtoBuffer);
 }
 
 static void addBitcodeFile(IRMover &Mover, BitcodeFile &F,
                            LLVMContext &Context) {
-
-  std::unique_ptr<IRObjectFile> Obj =
-      check(IRObjectFile::create(F.MB, Context));
+  std::unique_ptr<MemoryBuffer> Buffer =
+      MemoryBuffer::getMemBuffer(F.MB, false);
+  std::unique_ptr<Module> M =
+      check(getLazyBitcodeModule(std::move(Buffer), Context,
+                                 /*ShouldLazyLoadMetadata*/ false));
   std::vector<GlobalValue *> Keep;
-  unsigned BodyIndex = 0;
-  ArrayRef<SymbolBody *> Bodies = F.getSymbols();
-
-  for (const BasicSymbolRef &Sym : Obj->symbols()) {
-    GlobalValue *GV = Obj->getSymbolGV(Sym.getRawDataRefImpl());
-    assert(GV);
-    if (GV->hasAppendingLinkage()) {
-      Keep.push_back(GV);
-      continue;
-    }
-    if (BitcodeFile::shouldSkip(Sym))
-      continue;
-    SymbolBody *B = Bodies[BodyIndex++];
-    if (!B || &B->repl() != B)
+  for (SymbolBody *B : F.getSymbols()) {
+    if (&B->repl() != B)
       continue;
     auto *DB = dyn_cast<DefinedBitcode>(B);
     if (!DB)
       continue;
+    GlobalValue *GV = M->getNamedValue(B->getName());
+    assert(GV);
     Keep.push_back(GV);
   }
-
-  Mover.move(Obj->takeModule(), Keep,
-             [](GlobalValue &, IRMover::ValueAdder) {});
+  for (StringRef S : F.getExtraKeeps()) {
+    GlobalValue *GV = M->getNamedValue(S);
+    assert(GV);
+    Keep.push_back(GV);
+  }
+  Mover.move(std::move(M), Keep, [](GlobalValue &, IRMover::ValueAdder) {});
 }
 
 // This is for use when debugging LTO.
 static void saveBCFile(Module &M) {
   std::error_code EC;
   raw_fd_ostream OS(Config->OutputFile.str() + ".lto.bc", EC,
                     sys::fs::OpenFlags::F_None);
   check(EC);

lld/trunk/ELF/Symbols.cpp

if (SS.IsFunc)
       return Body.getPltVA<ELFT>();
     else
       return Out<ELFT>::Bss->getVA() + SS.OffsetInBss;
   }
   case SymbolBody::UndefinedElfKind:
   case SymbolBody::UndefinedKind:
     return 0;
   case SymbolBody::LazyKind:
-    assert(Body.isUsedInRegularObj() && "Lazy symbol reached writer");
+    assert(Body.isUsedInRegularObj() && "lazy symbol reached writer");
     return 0;
   case SymbolBody::DefinedBitcodeKind:
-    llvm_unreachable("Should have been replaced");
+    llvm_unreachable("should have been replaced");
   }
-  llvm_unreachable("Invalid symbol kind");
+  llvm_unreachable("invalid symbol kind");
 }
 
 template <class ELFT>
 typename ELFFile<ELFT>::uintX_t
 SymbolBody::getVA(typename ELFFile<ELFT>::uintX_t Addend) const {
   return getSymVA<ELFT>(*this, Addend) + Addend;
 }
 

lld/trunk/ELF/Target.cpp

 
 static void add32le(uint8_t *P, int32_t V) { add32<support::little>(P, V); }
 static void or32le(uint8_t *P, int32_t V) { write32le(P, read32le(P) | V); }
 
 template <unsigned N> static void checkInt(int64_t V, uint32_t Type) {
   if (isInt<N>(V))
     return;
   StringRef S = getELFRelocationTypeName(Config->EMachine, Type);
-  error("Relocation " + S + " out of range");
+  error("relocation " + S + " out of range");
 }
 
 template <unsigned N> static void checkUInt(uint64_t V, uint32_t Type) {
   if (isUInt<N>(V))
     return;
   StringRef S = getELFRelocationTypeName(Config->EMachine, Type);
-  error("Relocation " + S + " out of range");
+  error("relocation " + S + " out of range");
 }
 
 template <unsigned N> static void checkIntUInt(uint64_t V, uint32_t Type) {
   if (isInt<N>(V) || isUInt<N>(V))
     return;
   StringRef S = getELFRelocationTypeName(Config->EMachine, Type);
-  error("Relocation " + S + " out of range");
+  error("relocation " + S + " out of range");
 }
 
 template <unsigned N> static void checkAlignment(uint64_t V, uint32_t Type) {
   if ((V & (N - 1)) == 0)
     return;
   StringRef S = getELFRelocationTypeName(Config->EMachine, Type);
-  error("Improper alignment for relocation " + S);
+  error("improper alignment for relocation " + S);
 }
 
 template <class ELFT> bool isGnuIFunc(const SymbolBody &S) {
   if (auto *SS = dyn_cast<DefinedElf<ELFT>>(&S))
     return SS->Sym.getType() == STT_GNU_IFUNC;
   return false;
 }
 
case EM_AMDGPU:
     return new AMDGPUTargetInfo();
   case EM_MIPS:
     switch (Config->EKind) {
     case ELF32LEKind:
       return new MipsTargetInfo<ELF32LE>();
     case ELF32BEKind:
       return new MipsTargetInfo<ELF32BE>();
     default:
-      fatal("Unsupported MIPS target");
+      fatal("unsupported MIPS target");
     }
   case EM_PPC:
     return new PPCTargetInfo();
   case EM_PPC64:
     return new PPC64TargetInfo();
   case EM_X86_64:
     return new X86_64TargetInfo();
   }
-  fatal("Unknown target machine");
+  fatal("unknown target machine");
 }
 
 TargetInfo::~TargetInfo() {}
 
 bool TargetInfo::canRelaxTls(uint32_t Type, const SymbolBody *S) const {
   if (Config->Shared || (S && !S->IsTls))
     return false;
 
size_t X86TargetInfo::relaxTls(uint8_t *Loc, uint8_t *BufEnd, uint32_t Type,
   case R_386_TLS_LDM:
     relocateTlsLdToLe(Loc, BufEnd, P, SA);
     // The next relocation should be against __tls_get_addr, so skip it
     return 1;
   case R_386_TLS_LDO_32:
     relocateOne(Loc, BufEnd, R_386_TLS_LE, P, SA);
     return 0;
   }
-  llvm_unreachable("Unknown TLS optimization");
+  llvm_unreachable("unknown TLS optimization");
 }
 
 // "Ulrich Drepper, ELF Handling For Thread-Local Storage" (5.1
 // IA-32 Linker Optimizations, http://www.akkadia.org/drepper/tls.pdf) shows
 // how GD can be optimized to IE:
 //   leal x@tlsgd(, %ebx, 1),
 //   call __tls_get_addr@plt
 // Is converted to:
case R_X86_64_TLSGD: {
     // The next relocation should be against __tls_get_addr, so skip it
     return 1;
   }
   case R_X86_64_TLSLD:
     relocateTlsLdToLe(Loc, BufEnd, P, SA);
     // The next relocation should be against __tls_get_addr, so skip it
     return 1;
   }
-  llvm_unreachable("Unknown TLS optimization");
+  llvm_unreachable("unknown TLS optimization");
 }
 
 void X86_64TargetInfo::relocateOne(uint8_t *Loc, uint8_t *BufEnd, uint32_t Type,
                                    uint64_t P, uint64_t SA, uint64_t ZA,
                                    uint8_t *PairedLoc) const {
   switch (Type) {
   case R_X86_64_32:
     checkUInt<32>(SA, Type);
size_t AArch64TargetInfo::relaxTls(uint8_t *Loc, uint8_t *BufEnd, uint32_t Type,
                                    uint64_t P, uint64_t SA,
                                    const SymbolBody &S) const {
   switch (Type) {
   case R_AARCH64_TLSDESC_ADR_PAGE21:
   case R_AARCH64_TLSDESC_LD64_LO12_NC:
   case R_AARCH64_TLSDESC_ADD_LO12_NC:
   case R_AARCH64_TLSDESC_CALL: {
     if (canBePreempted(S))
-      fatal("Unsupported TLS optimization");
+      fatal("unsupported TLS optimization");
     uint64_t X = S.getVA<ELF64LE>();
     relocateTlsGdToLe(Type, Loc, BufEnd, P, X);
     return 0;
   }
   case R_AARCH64_TLSIE_ADR_GOTTPREL_PAGE21:
   case R_AARCH64_TLSIE_LD64_GOTTPREL_LO12_NC:
     relocateTlsIeToLe(Type, Loc, BufEnd, P, S.getVA<ELF64LE>());
     return 0;
   }
-  llvm_unreachable("Unknown TLS optimization");
+  llvm_unreachable("unknown TLS optimization");
 }
 
 // Global-Dynamic relocations can be relaxed to Local-Exec if both binary is
 // an executable and target is final (can notbe preempted).
 void AArch64TargetInfo::relocateTlsGdToLe(uint32_t Type, uint8_t *Loc,
                                           uint8_t *BufEnd, uint64_t P,
                                           uint64_t SA) const {
   // TLSDESC Global-Dynamic relocation are in the form:
case R_AARCH64_TLSDESC_ADR_PAGE21:
     // movz
     NewInst = 0xd2a00000 | (((X >> 16) & 0xffff) << 5);
     break;
   case R_AARCH64_TLSDESC_LD64_LO12_NC:
     // movk
     NewInst = 0xf2800000 | ((X & 0xffff) << 5);
     break;
   default:
-    llvm_unreachable("Unsupported Relocation for TLS GD to LE relax");
+    llvm_unreachable("unsupported Relocation for TLS GD to LE relax");
   }
   write32le(Loc, NewInst);
 }
 
 // Initial-Exec relocations can be relaxed to Local-Exec if symbol is final
 // (can not be preempted).
 void AArch64TargetInfo::relocateTlsIeToLe(uint32_t Type, uint8_t *Loc,
                                           uint8_t *BufEnd, uint64_t P,
                                           uint64_t SA) const {
   uint64_t TPOff = llvm::alignTo(TcbSize, Out<ELF64LE>::TlsPhdr->p_align);
   uint64_t X = SA + TPOff;
   checkUInt<32>(X, Type);
 
   uint32_t Inst = read32le(Loc);
   uint32_t NewInst;
   if (Type == R_AARCH64_TLSIE_ADR_GOTTPREL_PAGE21) {
     // Generate movz.
     unsigned RegNo = (Inst & 0x1f);
     NewInst = (0xd2a00000 | RegNo) | (((X >> 16) & 0xffff) << 5);
   } else if (Type == R_AARCH64_TLSIE_LD64_GOTTPREL_LO12_NC) {
     // Generate movk
     unsigned RegNo = (Inst & 0x1f);
     NewInst = (0xf2800000 | RegNo) | ((X & 0xffff) << 5);
   } else {
-    llvm_unreachable("Invalid Relocation for TLS IE to LE Relax");
+    llvm_unreachable("invalid Relocation for TLS IE to LE Relax");
   }
   write32le(Loc, NewInst);
 }
 
 // Implementing relocations for AMDGPU is low priority since most
 // programs don't use relocations now. Thus, this function is not
 // actually called (relocateOne is called for each relocation).
 // That's why the AMDGPU port works without implementing this function.

lld/trunk/test/ELF/basic.s

 # RUN: not ld.lld --foo 2>&1 | FileCheck --check-prefix=UNKNOWN %s
 # UNKNOWN: unknown argument: --foo
 
 # RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t
 # RUN: not ld.lld %t %t -o %t2 2>&1 | FileCheck --check-prefix=DUP %s
 # DUP: duplicate symbol: _start in {{.*}} and {{.*}}
 
 # RUN: not ld.lld %t -o %t -m wrong_emul 2>&1 | FileCheck --check-prefix=UNKNOWN_EMUL %s
-# UNKNOWN_EMUL: Unknown emulation: wrong_emul
+# UNKNOWN_EMUL: unknown emulation: wrong_emul

lld/trunk/test/ELF/driver.test

 # REQUIRES: x86
 
 # RUN: not ld.lld --unknown1 --unknown2 -m foo /no/such/file -lnosuchlib \
 # RUN:   2>&1 | FileCheck -check-prefix=UNKNOWN %s
 
 # UNKNOWN: warning: unknown argument: --unknown1
 # UNKNOWN: warning: unknown argument: --unknown2
 # UNKNOWN: unknown argument(s) found
-# UNKNOWN: Unknown emulation: foo
+# UNKNOWN: unknown emulation: foo
 # UNKNOWN: cannot open /no/such/file
-# UNKNOWN: Unable to find library -lnosuchlib
+# UNKNOWN: unable to find library -lnosuchlib
 
 # RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t
 # RUN: not ld.lld %t -o /no/such/file 2>&1 | FileCheck -check-prefix=MISSING %s
 # MISSING: failed to open /no/such/file
 
 # RUN: ld.lld --help 2>&1 | FileCheck -check-prefix=HELP %s
 # HELP: USAGE:
 
 # RUN: ld.lld --version 2>&1 | FileCheck -check-prefix=VERSION %s
 # VERSION: LLD
 
 ## Attempt to link DSO with -r
 # RUN: ld.lld -shared %t -o %t.so
 # RUN: not ld.lld -r %t.so %t -o %tfail 2>&1 | FileCheck -check-prefix=ERR %s
-# ERR: Attempted static link of dynamic object
+# ERR: attempted static link of dynamic object
 
 ## Attempt to use -r and -shared together
 # RUN: not ld.lld -r -shared %t -o %tfail 2>&1 | FileCheck -check-prefix=ERR2 %s
 # ERR2: -r and -shared may not be used together
 
 ## Attempt to use -r and --gc-sections together
 # RUN: not ld.lld -r --gc-sections %t -o %tfail 2>&1 | FileCheck -check-prefix=ERR3 %s
 # ERR3: -r and --gc-sections may not be used together
 
 ## Attempt to use -r and --icf together
 # RUN: not ld.lld -r --icf=all %t -o %tfail 2>&1 | FileCheck -check-prefix=ERR4 %s
 # ERR4: -r and --icf may not be used together
 
 .globl _start
 _start:
   nop

lld/trunk/test/ELF/invalid-cie-reference.s

// RUN: not ld.lld %t -o %t2 2>&1 | FileCheck %s
 
         .long 0x14
         .long 0x1b
         .long .text
         .long 0x0
         .long 0x0
         .long 0x0
 
-// CHECK: Invalid CIE reference
+// CHECK: invalid CIE reference

lld/trunk/test/ELF/invalid-elf.test

 # RUN: llvm-mc %s -o %t -filetype=obj -triple x86_64-pc-linux
 
 # RUN: not ld.lld %t %p/Inputs/invalid-data-encoding.a -o %t2 2>&1 | \
 # RUN:   FileCheck --check-prefix=INVALID-DATA-ENC %s
-# INVALID-DATA-ENC: Invalid data encoding: test.o
+# INVALID-DATA-ENC: invalid data encoding: test.o
 
 # RUN: not ld.lld %t %p/Inputs/invalid-file-class.a -o %t2 2>&1 | \
 # RUN:   FileCheck --check-prefix=INVALID-FILE-CLASS %s
-# INVALID-FILE-CLASS: Invalid file class: test.o
+# INVALID-FILE-CLASS: invalid file class: test.o
 
 # RUN: not ld.lld %p/Inputs/invalid-symtab-sh_info.elf -o %t2 2>&1 | \
 # RUN:   FileCheck --check-prefix=INVALID-SYMTAB-SHINFO %s
-# INVALID-SYMTAB-SHINFO: Invalid sh_info in symbol table
+# INVALID-SYMTAB-SHINFO: invalid sh_info in symbol table
 
 # RUN: not ld.lld %p/Inputs/invalid-binding.elf -o %t2 2>&1 | \
 # RUN:   FileCheck --check-prefix=INVALID-BINDING %s
 # INVALID-BINDING: unexpected binding
 
 # RUN: not ld.lld %p/Inputs/invalid-section-index.elf -o %t2 2>&1 | \
-# RUN:   FileCheck --check-prefix=INVALID-SECTION-INDEX %s
-# INVALID-SECTION-INDEX: Invalid section index
+# RUN:   FileCheck --check-prefix=INVALID-SECTION-INDEX-LLD %s
+# INVALID-SECTION-INDEX-LLD: invalid section index
 
 # RUN: not ld.lld %p/Inputs/invalid-shstrndx.so -o %t2 2>&1 | \
 # RUN:   FileCheck --check-prefix=INVALID-SECTION-INDEX %s
+# INVALID-SECTION-INDEX: Invalid section index
 
 # RUN: not ld.lld %p/Inputs/invalid-shentsize-zero.elf -o %t2 2>&1 | \
 # RUN:   FileCheck --check-prefix=INVALID-SHENTSIZE-ZERO %s
 # INVALID-SHENTSIZE-ZERO: SHF_MERGE section size must be a multiple of sh_entsize
 
 # RUN: not ld.lld %p/Inputs/invalid-multiple-eh-relocs.elf -o %t2 2>&1 | \
 # RUN:   FileCheck --check-prefix=INVALID-EH-RELOCS %s
-# INVALID-EH-RELOCS: Multiple relocation sections to .eh_frame are not supported
+# INVALID-EH-RELOCS: multiple relocation sections to .eh_frame are not supported
 
 .long foo

lld/trunk/test/ELF/invalid-relocations.test

- Name:            .rela.text
     Relocations:
       - Offset:          0x0000000000000001
         Symbol:          lulz
         Type:            R_X86_64_PC32
 Symbols:
   Global:
     - Name:            lulz
 
-# CHECK: Invalid relocated section index
+# CHECK: invalid relocated section index

lld/trunk/test/ELF/libsearch.s

 // Should not link because of undefined symbol _bar
 // RUN: not ld.lld -o %t3 %t.o 2>&1 \
 // RUN:   | FileCheck --check-prefix=UNDEFINED %s
 // UNDEFINED: undefined symbol: _bar
 
 // Should fail if cannot find specified library (without -L switch)
 // RUN: not ld.lld -o %t3 %t.o -lls 2>&1 \
 // RUN:   | FileCheck --check-prefix=NOLIB %s
-// NOLIB: Unable to find library -lls
+// NOLIB: unable to find library -lls
 
 // Should use explicitly specified static library
 // Also ensure that we accept -L <arg>
 // RUN: ld.lld -o %t3 %t.o -L %t.dir -l:libls.a
 // RUN: llvm-readobj --symbols %t3 | FileCheck --check-prefix=STATIC %s
 // STATIC: Symbols [
 // STATIC: Name: _static
 // STATIC: ]

 // Check long forms as well
 // RUN: ld.lld -o %t3 %t.o --library-path=%t.dir --library=ls
 
 // Should not search for dynamic libraries if -Bstatic is specified
 // RUN: ld.lld -o %t3 %t.o -L%t.dir -Bstatic -lls
 // RUN: llvm-readobj --symbols %t3 | FileCheck --check-prefix=STATIC %s
 // RUN: not ld.lld -o %t3 %t.o -L%t.dir -Bstatic -lls2 2>&1 \
 // RUN:   | FileCheck --check-prefix=NOLIB2 %s
-// NOLIB2: Unable to find library -lls2
+// NOLIB2: unable to find library -lls2
 
 // -Bdynamic should restore default behaviour
 // RUN: ld.lld -o %t3 %t.o -L%t.dir -Bstatic -Bdynamic -lls
 // RUN: llvm-readobj --symbols %t3 | FileCheck --check-prefix=DYNAMIC %s
 
 // -Bstatic and -Bdynamic should affect only libraries which follow them
 // RUN: ld.lld -o %t3 %t.o -L%t.dir -lls -Bstatic -Bdynamic
 // RUN: llvm-readobj --symbols %t3 | FileCheck --check-prefix=DYNAMIC %s

lld/trunk/test/ELF/linkerscript-sections-padding.s

 # RUN: ld.lld -o %t.out --script %t.script %t
 # RUN: hexdump -C %t.out | FileCheck -check-prefix=NO %s
 # NO: 00000120  66 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
 
 ## Filler should be a hex value (1):
 # RUN: echo "SECTIONS { .mysec : { *(.mysec*) } =99 }" > %t.script
 # RUN: not ld.lld -o %t.out --script %t.script %t 2>&1 \
 # RUN:   | FileCheck --check-prefix=ERR %s
-# ERR: Filler should be a HEX value
+# ERR: filler should be a HEX value
 
 ## Filler should be a hex value (2):
 # RUN: echo "SECTIONS { .mysec : { *(.mysec*) } =0x99XX }" > %t.script
 # RUN: not ld.lld -o %t.out --script %t.script %t 2>&1 \
 # RUN:   | FileCheck --check-prefix=ERR2 %s
-# ERR2: Not a HEX value: XX
+# ERR2: not a HEX value: XX
 
 .section        .mysec.1,"a"
 .align  16
 .byte   0x66
 
 .section        .mysec.2,"a"
 .align  16
 .byte   0x66
 
 .globl _start
 _start:
  nop

lld/trunk/test/ELF/merge-string-error.s

 // REQUIRES: x86
 // RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %s -o %t.o
 // RUN: not ld.lld %t.o -o %t.so -shared 2>&1 | FileCheck %s
 
         .section  .rodata.str1.1,"aMS",@progbits,1
   .asciz  "abc"
 
         .text
         .long .rodata.str1.1 + 4
 
-// CHECK: Entry is past the end of the section
+// CHECK: entry is past the end of the section

lld/trunk/test/ELF/merge-string-no-null.s

 // REQUIRES: x86
 // RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %s -o %t.o
 // RUN: not ld.lld %t.o -o %t.so -shared 2>&1 | FileCheck %s
 
   .section  .rodata.str1.1,"aMS",@progbits,1
   .ascii  "abc"
 
-// CHECK: String is not null terminated
+// CHECK: string is not null terminated

lld/trunk/test/ELF/mips-gnu-hash.s

 # Shouldn't allow the GNU hash style to be selected with the MIPS target.
 
 # RUN: llvm-mc -filetype=obj -triple=mips-unknown-linux %s -o %t-be.o
 # RUN: not ld.lld -shared -hash-style=gnu %t-be.o -o %t-be.so 2>&1 | FileCheck %s
 
 # RUN: llvm-mc -filetype=obj -triple=mipsel-unknown-linux %s -o %t-el.o
 # RUN: not ld.lld -shared -hash-style=gnu %t-el.o -o %t-el.so 2>&1 | FileCheck %s
 
-# CHECK: The .gnu.hash section is not compatible with the MIPS target.
+# CHECK: the .gnu.hash section is not compatible with the MIPS target.
 
 # REQUIRES: mips
 
   .globl  __start
 __start:
   nop

lld/trunk/test/ELF/ppc64-addr16-error.s

 // RUN: llvm-mc -filetype=obj -triple=powerpc64-unknown-linux %s -o %t
 // RUN: llvm-mc -filetype=obj -triple=powerpc64-unknown-linux %p/Inputs/ppc64-addr16-error.s -o %t2
 // RUN: not ld.lld -shared %t %t2 -o %t3 2>&1 | FileCheck %s
 // REQUIRES: ppc
 
 .short sym+65539
 
-// CHECK: Relocation R_PPC64_ADDR16 out of range
+// CHECK: relocation R_PPC64_ADDR16 out of range

lld/trunk/test/ELF/relocation-in-merge.s

 // REQUIRES: x86
 // RUN: llvm-mc %s -o %t.o -filetype=obj -triple=x86_64-pc-linux
 // RUN: not ld.lld %t.o -o %t 2>&1 | FileCheck %s
-// CHECK: Relocations pointing to SHF_MERGE are not supported
+// CHECK: relocations pointing to SHF_MERGE are not supported
 
         .section  .foo,"aM",@progbits,4
         .long bar

lld/trunk/test/ELF/relocation-past-merge-end.s

 // REQUIRES: x86
 // RUN: llvm-mc %s -o %t.o -filetype=obj -triple=x86_64-pc-linux
 // RUN: not ld.lld %t.o -o %t.so -shared 2>&1 | FileCheck %s
-// CHECK: Entry is past the end of the section
+// CHECK: entry is past the end of the section
 
         .long .foo + 1
         .section  .foo,"aM",@progbits,4

lld/trunk/test/ELF/splitstacks.s

 # REQUIRES: x86
 # RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t1.o
 
 # RUN: not ld.lld %t1.o -o %t 2>&1 | FileCheck %s
-# CHECK: Objects using splitstacks are not supported
+# CHECK: objects using splitstacks are not supported
 
 .globl _start
 _start:
  nop
 
 .section .note.GNU-split-stack,"",@progbits

lld/trunk/test/ELF/sysroot.s

 // RUN: mkdir -p %t/lib
 // RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t/m.o
 // RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux \
 // RUN:     %p/Inputs/libsearch-st.s -o %t/st.o
 // RUN: rm -f %t/lib/libls.a
 // RUN: llvm-ar rcs %t/lib/libls.a %t/st.o
 // REQUIRES: x86
 
 // Should not link because of undefined symbol _bar
 // RUN: not ld.lld -o %t/r %t/m.o 2>&1 \
 // RUN:     | FileCheck --check-prefix=UNDEFINED %s
 // UNDEFINED: undefined symbol: _bar
 
 // We need to be sure that there is no suitable library in the /lib directory
 // RUN: not ld.lld -o %t/r %t/m.o -L/lib -l:libls.a 2>&1 \
 // RUN:     | FileCheck --check-prefix=NOLIB %s
-// NOLIB: Unable to find library -l:libls.a
+// NOLIB: unable to find library -l:libls.a
 
 // Should just remove the '=' symbol if --sysroot is not specified.
 // Case 1: relative path
 // RUN: cd %t && ld.lld -o %t/r %t/m.o -L=lib -l:libls.a
 // Case 2: absolute path
 // RUN: cd %p && ld.lld -o %t/r %t/m.o -L=%t/lib -l:libls.a
 
 // RUN: cd %p

lld/trunk/test/ELF/writable-merge.s

 // REQUIRES: x86
 // RUN: llvm-mc %s -o %t.o -filetype=obj -triple=x86_64-pc-linux
 // RUN: not ld.lld %t.o -o %t 2>&1 | FileCheck %s
-// CHECK: Writable SHF_MERGE sections are not supported
+// CHECK: writable SHF_MERGE sections are not supported
 
         .section  .foo,"awM",@progbits,4