[ELF] - consistent spelling for error/warning messages

[grimar]

Summary

Previously error and warnings were not consistent in lld.
Some of them started from lowercase letter, others from
uppercase. Also there was one or two which had a dot at the end.
This patch changes all messages to start from uppercase letter if
they were not before.

[• rafael]

LGTM

[ruiu]

LGTM

lld/trunk/ELF/Driver.cpp

 }
 
 // Opens and parses a file. Path has to be resolved already.
 // Newly created memory buffers are owned by this driver.
 void LinkerDriver::addFile(StringRef Path) {
   using namespace llvm::sys::fs;
   log(Path);
   auto MBOrErr = MemoryBuffer::getFile(Path);
-  if (error(MBOrErr, "cannot open " + Path))
+  if (error(MBOrErr, "Cannot open " + Path))
     return;
   std::unique_ptr<MemoryBuffer> &MB = *MBOrErr;
   MemoryBufferRef MBRef = MB->getMemBufferRef();
   OwningMBs.push_back(std::move(MB)); // take MB ownership
 
   switch (identify_magic(MBRef.getBuffer())) {
   case file_magic::unknown:
     Script->read(MBRef);
case OPT_whole_archive:
       break;
     case OPT_no_whole_archive:
       WholeArchive = false;
       break;
     }
   }
 
   if (Files.empty() && !HasError)
-    error("no input files.");
+    error("No input files");
 }
 
 template <class ELFT> void LinkerDriver::link(opt::InputArgList &Args) {
   // For LTO
   InitializeAllTargets();
   InitializeAllTargetMCs();
   InitializeAllAsmPrinters();
   InitializeAllAsmParsers();

lld/trunk/ELF/DriverUtils.cpp

opt::InputArgList elf::parseArgs(llvm::BumpPtrAllocator *A,
   // Expand response files. '@<filename>' is replaced by the file's contents.
   SmallVector<const char *, 256> Vec(Argv.data(), Argv.data() + Argv.size());
   StringSaver Saver(*A);
   llvm::cl::ExpandResponseFiles(Saver, llvm::cl::TokenizeGNUCommandLine, Vec);
 
   // Parse options and then do error checking.
   opt::InputArgList Args = Table.ParseArgs(Vec, MissingIndex, MissingCount);
   if (MissingCount)
-    error(Twine("missing arg value for \"") + Args.getArgString(MissingIndex) +
+    error(Twine("Missing arg value for \"") + Args.getArgString(MissingIndex) +
           "\", expected " + Twine(MissingCount) +
           (MissingCount == 1 ? " argument.\n" : " arguments"));
 
   iterator_range<opt::arg_iterator> Unknowns = Args.filtered(OPT_UNKNOWN);
   for (auto *Arg : Unknowns)
-    warning("warning: unknown argument: " + Arg->getSpelling());
+    warning("Warning: unknown argument: " + Arg->getSpelling());
   if (Unknowns.begin() != Unknowns.end())
-    error("unknown argument(s) found");
+    error("Unknown argument(s) found");
   return Args;
 }
 
 void elf::printHelp(const char *Argv0) {
   ELFOptTable Table;
   Table.PrintHelp(outs(), Argv0, "lld", false);
 }
 

lld/trunk/ELF/InputFiles.cpp

SymbolBody *elf::ObjectFile<ELFT>::createSymbolBody(const Elf_Sym *Sym) {
   case SHN_COMMON:
     return new (Alloc) DefinedCommon(Name, Sym->st_size, Sym->st_value,
                                      Sym->getBinding() == llvm::ELF::STB_WEAK,
                                      Sym->getVisibility());
   }
 
   switch (Sym->getBinding()) {
   default:
-    fatal("unexpected binding");
+    fatal("Unexpected binding");
   case STB_GLOBAL:
   case STB_WEAK:
   case STB_GNU_UNIQUE: {
     InputSectionBase<ELFT> *Sec = getSection(*Sym);
     if (Sec == InputSection<ELFT>::Discarded)
       return new (Alloc) UndefinedElf<ELFT>(Name, *Sym);
     return new (Alloc) DefinedRegular<ELFT>(Name, *Sym, Sec);
   }

lld/trunk/ELF/LinkerScript.cpp

const StringMap<elf::ScriptParser::Handler> elf::ScriptParser::Cmd = {
     {";", &ScriptParser::readNothing}};
 
 void ScriptParser::run() {
   while (!atEOF()) {
     StringRef Tok = next();
     if (Handler Fn = Cmd.lookup(Tok))
       (this->*Fn)();
     else
-      setError("unknown directive: " + Tok);
+      setError("Unknown directive: " + Tok);
   }
 }
 
 // We don't want to record cascading errors. Keep only the first one.
 void ScriptParser::setError(const Twine &Msg) {
   if (Error)
     return;
   error(Msg);
   Error = true;
 }
 
 // Split S into linker script tokens.
 std::vector<StringRef> ScriptParser::tokenize(StringRef S) {
   std::vector<StringRef> Ret;
   for (;;) {
     S = skipSpace(S);
     if (S.empty())
       return Ret;
 
     // Quoted token
     if (S.startswith("\"")) {
       size_t E = S.find("\"", 1);
       if (E == StringRef::npos) {
-        error("unclosed quote");
+        error("Unclosed quote");
         return {};
       }
       Ret.push_back(S.substr(1, E - 1));
       S = S.substr(E + 1);
       continue;
     }
 
     // Unquoted token

 }
 
 // Skip leading whitespace characters or /**/-style comments.
 StringRef ScriptParser::skipSpace(StringRef S) {
   for (;;) {
     if (S.startswith("/*")) {
       size_t E = S.find("*/", 2);
       if (E == StringRef::npos) {
-        error("unclosed comment in a linker script");
+        error("Unclosed comment in a linker script");
         return "";
       }
       S = S.substr(E + 2);
       continue;
     }
     size_t Size = S.size();
     S = S.ltrim();
     if (S.size() == Size)
       return S;
   }
 }
 
 // An errneous token is handled as if it were the last token before EOF.
 bool ScriptParser::atEOF() { return Error || Tokens.size() == Pos; }
 
 StringRef ScriptParser::next() {
   if (Error)
     return "";
   if (atEOF()) {
-    setError("unexpected EOF");
+    setError("Unexpected EOF");
     return "";
   }
   return Tokens[Pos++];
 }
 
 StringRef ScriptParser::peek() {
   StringRef Tok = next();
   if (Error)
     return "";
   --Pos;
   return Tok;
 }
 
 bool ScriptParser::skip(StringRef Tok) {
   if (Error)
     return false;
   if (atEOF()) {
-    setError("unexpected EOF");
+    setError("Unexpected EOF");
     return false;
   }
   if (Tok != Tokens[Pos])
     return false;
   ++Pos;
   return true;
 }
 
while (!Error) {
     addFile(Tok);
   }
 }
 
 void ScriptParser::readInclude() {
   StringRef Tok = next();
   auto MBOrErr = MemoryBuffer::getFile(Tok);
   if (!MBOrErr) {
-    setError("cannot open " + Tok);
+    setError("Cannot open " + Tok);
     return;
   }
   std::unique_ptr<MemoryBuffer> &MB = *MBOrErr;
   StringRef S = Saver.save(MB->getMemBufferRef().getBuffer());
   std::vector<StringRef> V = tokenize(S);
   Tokens.insert(Tokens.begin() + Pos, V.begin(), V.end());
 }
 

 void ScriptParser::readOutputFormat() {
   // Error checking only for now.
   expect("(");
   next();
   StringRef Tok = next();
   if (Tok == ")")
    return;
   if (Tok != ",") {
-    setError("unexpected token: " + Tok);
+    setError("Unexpected token: " + Tok);
     return;
   }
   next();
   expect(",");
   next();
   expect(")");
 }
 

lld/trunk/ELF/OutputSections.cpp

case DW_EH_PE_udata2:
     break;
   case DW_EH_PE_udata4:
     PC = read32<E>(F.PCRel);
     break;
   case DW_EH_PE_udata8:
     PC = read64<E>(F.PCRel);
     break;
   default:
-    fatal("unknown FDE size encoding");
+    fatal("Unknown FDE size encoding");
   }
   switch (F.Enc & 0x70) {
   case DW_EH_PE_absptr:
     return PC;
   case DW_EH_PE_pcrel:
     return PC + EhVA + F.Off + 8;
   default:
-    fatal("unknown FDE size relative encoding");
+    fatal("Unknown FDE size relative encoding");
   }
 }
 
 template <class ELFT> void EhFrameHeader<ELFT>::writeTo(uint8_t *Buf) {
   const endianness E = ELFT::TargetEndianness;
 
   const uint8_t Header[] = {1, DW_EH_PE_pcrel | DW_EH_PE_sdata4,
                             DW_EH_PE_udata4,

 
 template <class ELFT>
 Cie<ELFT>::Cie(EHInputSection<ELFT> *S, unsigned Index)
     : EHRegion<ELFT>(S, Index) {}
 
 // Read a byte and advance D by one byte.
 static uint8_t readByte(ArrayRef<uint8_t> &D) {
   if (D.empty())
-    fatal("corrupted or unsupported CIE information");
+    fatal("Corrupted or unsupported CIE information");
   uint8_t B = D.front();
   D = D.slice(1);
   return B;
 }
 
 static void skipLeb128(ArrayRef<uint8_t> &D) {
   while (!D.empty()) {
     uint8_t Val = D.front();
     D = D.slice(1);
     if ((Val & 0x80) == 0)
       return;
   }
-  fatal("corrupted or unsupported CIE information");
+  fatal("Corrupted or unsupported CIE information");
 }
 
 template <class ELFT> static size_t getAugPSize(unsigned Enc) {
   switch (Enc & 0x0f) {
   case DW_EH_PE_absptr:
   case DW_EH_PE_signed:
     return ELFT::Is64Bits ? 8 : 4;
   case DW_EH_PE_udata2:
   case DW_EH_PE_sdata2:
     return 2;
   case DW_EH_PE_udata4:
   case DW_EH_PE_sdata4:
     return 4;
   case DW_EH_PE_udata8:
   case DW_EH_PE_sdata8:
     return 8;
   }
-  fatal("unknown FDE encoding");
+  fatal("Unknown FDE encoding");
 }
 
 template <class ELFT> static void skipAugP(ArrayRef<uint8_t> &D) {
   uint8_t Enc = readByte(D);
   if ((Enc & 0xf0) == DW_EH_PE_aligned)
     fatal("DW_EH_PE_aligned encoding is not supported");
   size_t Size = getAugPSize<ELFT>(Enc);
   if (Size >= D.size())
-    fatal("corrupted CIE");
+    fatal("Corrupted CIE");
   D = D.slice(Size);
 }
 
 template <class ELFT>
 uint8_t EHOutputSection<ELFT>::getFdeEncoding(ArrayRef<uint8_t> D) {
   if (D.size() < 8)
     fatal("CIE too small");
   D = D.slice(8);
 
   uint8_t Version = readByte(D);
   if (Version != 1 && Version != 3)
     fatal("FDE version 1 or 3 expected, but got " + Twine((unsigned)Version));
 
   const unsigned char *AugEnd = std::find(D.begin() + 1, D.end(), '\0');
   if (AugEnd == D.end())
-    fatal("corrupted CIE");
+    fatal("Corrupted CIE");
   StringRef Aug(reinterpret_cast<const char *>(D.begin()), AugEnd - D.begin());
   D = D.slice(Aug.size() + 1);
 
   // Code alignment factor should always be 1 for .eh_frame.
   if (readByte(D) != 1)
     fatal("CIE code alignment must be 1");
 
   // Skip data alignment factor.
for (char C : Aug) {
     if (C == 'P') {
       skipAugP<ELFT>(D);
       continue;
     }
     if (C == 'L') {
       readByte(D);
       continue;
     }
-    fatal("unknown .eh_frame augmentation string: " + Aug);
+    fatal("Unknown .eh_frame augmentation string: " + Aug);
   }
   return DW_EH_PE_absptr;
 }
 
 template <class ELFT>
 static typename ELFFile<ELFT>::uintX_t readEntryLength(ArrayRef<uint8_t> D) {
   const endianness E = ELFT::TargetEndianness;
   if (D.size() < 4)

lld/trunk/ELF/SymbolTable.cpp

if (New->IsTls != Existing->IsTls) {
     error("TLS attribute mismatch for symbol: " + conflictMsg(Existing, New));
     return;
   }
 
   // compare() returns -1, 0, or 1 if the lhs symbol is less preferable,
   // equivalent (conflicting), or more preferable, respectively.
   int Comp = Existing->compare<ELFT>(New);
   if (Comp == 0) {
-    std::string S = "duplicate symbol: " + conflictMsg(Existing, New);
+    std::string S = "Duplicate symbol: " + conflictMsg(Existing, New);
     if (Config->AllowMultipleDefinition)
       warning(S);
     else
       error(S);
     return;
   }
   if (Comp < 0)
     Sym->Body = New;

lld/trunk/ELF/Target.cpp

case R_386_TLS_LDO_32:
     break;
   case R_386_TLS_LE:
     write32le(Loc, SA - Out<ELF32LE>::TlsPhdr->p_memsz);
     break;
   case R_386_TLS_LE_32:
     write32le(Loc, Out<ELF32LE>::TlsPhdr->p_memsz - SA);
     break;
   default:
-    fatal("unrecognized reloc " + Twine(Type));
+    fatal("Unrecognized reloc " + Twine(Type));
   }
 }
 
 bool X86TargetInfo::needsDynRelative(uint32_t Type) const {
   return Config->Shared && Type == R_386_TLS_IE;
 }
 
 size_t X86TargetInfo::relaxTls(uint8_t *Loc, uint8_t *BufEnd, uint32_t Type,
case R_X86_64_SIZE64:
     break;
   case R_X86_64_TPOFF32: {
     uint64_t Val = SA - Out<ELF64LE>::TlsPhdr->p_memsz;
     checkInt<32>(Val, Type);
     write32le(Loc, Val);
     break;
   }
   default:
-    fatal("unrecognized reloc " + Twine(Type));
+    fatal("Unrecognized reloc " + Twine(Type));
   }
 }
 
 // Relocation masks following the #lo(value), #hi(value), #ha(value),
 // #higher(value), #highera(value), #highest(value), and #highesta(value)
 // macros defined in section 4.5.1. Relocation Types of the PPC-elf64abi
 // document.
 static uint16_t applyPPCLo(uint64_t V) { return V; }
void PPCTargetInfo::relocateOne(uint8_t *Loc, uint8_t *BufEnd, uint32_t Type,
   switch (Type) {
   case R_PPC_ADDR16_HA:
     write16be(Loc, applyPPCHa(SA));
     break;
   case R_PPC_ADDR16_LO:
     write16be(Loc, applyPPCLo(SA));
     break;
   default:
-    fatal("unrecognized reloc " + Twine(Type));
+    fatal("Unrecognized reloc " + Twine(Type));
   }
 }
 
 PPC64TargetInfo::PPC64TargetInfo() {
   GotRel = R_PPC64_GLOB_DAT;
   RelativeRel = R_PPC64_RELATIVE;
   PltEntrySize = 32;
 
case R_PPC64_REL32:
     break;
   case R_PPC64_REL64:
     write64be(Loc, SA - P);
     break;
   case R_PPC64_TOC:
     write64be(Loc, SA);
     break;
   default:
-    fatal("unrecognized reloc " + Twine(Type));
+    fatal("Unrecognized reloc " + Twine(Type));
   }
 }
 
 AArch64TargetInfo::AArch64TargetInfo() {
   CopyRel = R_AARCH64_COPY;
   RelativeRel = R_AARCH64_RELATIVE;
   IRelativeRel = R_AARCH64_IRELATIVE;
   GotRel = R_AARCH64_GLOB_DAT;
case R_AARCH64_TLSLE_ADD_TPREL_HI12: {
     break;
   }
   case R_AARCH64_TLSLE_ADD_TPREL_LO12_NC: {
     uint64_t V = llvm::alignTo(TcbSize, Out<ELF64LE>::TlsPhdr->p_align) + SA;
     updateAArch64Add(Loc, V & 0xFFF);
     break;
   }
   default:
-    fatal("unrecognized reloc " + Twine(Type));
+    fatal("Unrecognized reloc " + Twine(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:

 
 // 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.
 void AMDGPUTargetInfo::relocateOne(uint8_t *Loc, uint8_t *BufEnd, uint32_t Type,
                                    uint64_t P, uint64_t SA, uint64_t ZA,
                                    uint8_t *PairedLoc) const {
-  llvm_unreachable("not implemented");
+  llvm_unreachable("Not implemented");
 }
 
 template <class ELFT> MipsTargetInfo<ELFT>::MipsTargetInfo() {
   GotHeaderEntriesNum = 2;
   GotPltHeaderEntriesNum = 2;
   PageSize = 65536;
   PltEntrySize = 16;
   PltZeroSize = 32;
else {
       warning("Can't find matching R_MIPS_PCLO16 relocation for R_MIPS_PCHI16");
       writeMipsHi16<E>(Loc, S - P);
     }
     break;
   case R_MIPS_PCLO16:
     writeMipsLo16<E>(Loc, S + readSignedLo16<E>(Loc) - P);
     break;
   default:
-    fatal("unrecognized reloc " + Twine(Type));
+    fatal("Unrecognized reloc " + Twine(Type));
   }
 }
 
 template <class ELFT>
 bool MipsTargetInfo<ELFT>::isHintRel(uint32_t Type) const {
   return Type == R_MIPS_JALR;
 }
 

lld/trunk/ELF/Writer.cpp

else
     scanRelocs(S, EObj.rels(&RelSec));
 }
 
 template <class ELFT>
 static void reportUndefined(SymbolTable<ELFT> &Symtab, SymbolBody *Sym) {
   if ((Config->Relocatable || Config->Shared) && !Config->NoUndefined)
     return;
 
-  std::string Msg = "undefined symbol: " + Sym->getName().str();
+  std::string Msg = "Undefined symbol: " + Sym->getName().str();
   if (InputFile *File = Symtab.findFile(Sym))
     Msg += " in " + File->getName().str();
   if (Config->NoinhibitExec)
     warning(Msg);
   else
     error(Msg);
 }
 
template <class ELFT> void Writer<ELFT>::writeHeader() {
   for (OutputSectionBase<ELFT> *Sec : getSections())
     Sec->writeHeaderTo(++SHdrs);
 }
 
 template <class ELFT> bool Writer<ELFT>::openFile() {
   ErrorOr<std::unique_ptr<FileOutputBuffer>> BufferOrErr =
       FileOutputBuffer::create(Config->OutputFile, FileSize,
                                FileOutputBuffer::F_executable);
-  if (error(BufferOrErr, "failed to open " + Config->OutputFile))
+  if (error(BufferOrErr, "Failed to open " + Config->OutputFile))
     return false;
   Buffer = std::move(*BufferOrErr);
   return true;
 }
 
 // Write section contents to a mmap'ed file.
 template <class ELFT> void Writer<ELFT>::writeSections() {
   uint8_t *Buf = Buffer->getBufferStart();

lld/trunk/test/ELF/basic.s

 # Test for the response file
 # RUN: echo " -o %t2" > %t.responsefile
 # RUN: ld.lld %t @%t.responsefile
 # RUN: llvm-readobj -file-headers -sections -program-headers -symbols %t2 \
 # RUN:   | FileCheck %s
 
 # RUN: not ld.lld %t.foo -o %t2 2>&1 | \
 # RUN:  FileCheck --check-prefix=MISSING %s
-# MISSING: cannot open {{.*}}.foo: {{[Nn]}}o such file or directory
+# MISSING: Cannot open {{.*}}.foo: {{[Nn]}}o such file or directory
 
 # RUN: not ld.lld -o %t2 2>&1 | \
 # RUN:  FileCheck --check-prefix=NO_INPUT %s
-# NO_INPUT: no input files.
+# NO_INPUT: No input files
 
 # RUN: not ld.lld %t.no.such.file -o %t2 2>&1 | \
 # RUN:  FileCheck --check-prefix=CANNOT_OPEN %s
-# CANNOT_OPEN: cannot open {{.*}}.no.such.file: {{[Nn]}}o such file or directory
+# CANNOT_OPEN: Cannot open {{.*}}.no.such.file: {{[Nn]}}o such file or directory
 
 # RUN: not ld.lld %t -o 2>&1 | FileCheck --check-prefix=NO_O_VAL %s
-# NO_O_VAL: missing arg value for "-o", expected 1 argument.
+# NO_O_VAL: Missing arg value for "-o", expected 1 argument.
 
 # RUN: not ld.lld --foo 2>&1 | FileCheck --check-prefix=UNKNOWN %s
-# UNKNOWN: unknown argument: --foo
+# UNKNOWN: Warning: 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 {{.*}}
+# 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

lld/trunk/test/ELF/conflict.s

 # REQUIRES: x86
 
 # RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t1.o
 # RUN: not ld.lld %t1.o %t1.o -o %t2 2>&1 | FileCheck -check-prefix=DEMANGLE %s
 
-# DEMANGLE:    duplicate symbol: {{mul\(double, double\)|_Z3muldd}} in
-# DEMANGLE:    duplicate symbol: foo in
+# DEMANGLE:    Duplicate symbol: {{mul\(double, double\)|_Z3muldd}} in
+# DEMANGLE:    Duplicate symbol: foo in
 
 # RUN: not ld.lld %t1.o %t1.o -o %t2 --no-demangle 2>&1 | \
 # RUN:   FileCheck -check-prefix=NO_DEMANGLE %s
 
-# NO_DEMANGLE: duplicate symbol: _Z3muldd in
-# NO_DEMANGLE: duplicate symbol: foo in
+# NO_DEMANGLE: Duplicate symbol: _Z3muldd in
+# NO_DEMANGLE: Duplicate symbol: foo in
 
 # RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %S/Inputs/conflict.s -o %t2.o
 # RUN: llvm-ar rcs %t3.a %t2.o
 # RUN: not ld.lld %t1.o %t3.a -u baz -o %t2 2>&1 | FileCheck -check-prefix=ARCHIVE %s
 
-# ARCHIVE: duplicate symbol: foo in {{.*}}1.o and {{.*}}3.a({{.*}}2.o)
+# ARCHIVE: Duplicate symbol: foo in {{.*}}1.o and {{.*}}3.a({{.*}}2.o)
 
 .globl _Z3muldd, foo
 _Z3muldd:
 foo:
   mov $60, %rax
   mov $42, %rdi
   syscall

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: Warning: unknown argument: --unknown1
+# UNKNOWN: Warning: unknown argument: --unknown2
+# UNKNOWN: Unknown argument(s) found
 # UNKNOWN: Unknown emulation: foo
-# UNKNOWN: cannot open /no/such/file
+# UNKNOWN: Cannot open /no/such/file
 # 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
+# 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

lld/trunk/test/ELF/duplicate-internal.s

 # Should print an expected message in case of conflict with an internally generated symbol.
 
 # RUN: llvm-mc -filetype=obj -triple=mips-unknown-linux %s -o %t.o
 # RUN: not ld.lld -shared %t.o -o %t.so 2>&1 | FileCheck %s
 
-# CHECK: duplicate symbol: _gp in (internal) and {{.*}}
+# CHECK: Duplicate symbol: _gp in (internal) and {{.*}}
 
 # REQUIRES: mips
 
   .globl  _gp
 _gp = 0

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
 
 # 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
 
 # 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
 
 # RUN: not ld.lld %p/Inputs/invalid-binding.elf -o %t2 2>&1 | \
 # RUN:   FileCheck --check-prefix=INVALID-BINDING %s
-# INVALID-BINDING: unexpected binding
+# 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: not ld.lld %p/Inputs/invalid-shstrndx.so -o %t2 2>&1 | \
 # RUN:   FileCheck --check-prefix=INVALID-SECTION-INDEX %s
 

lld/trunk/test/ELF/libsearch.s

 // RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t.o
 // RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux \
 // RUN:   %p/Inputs/libsearch-dyn.s -o %tdyn.o
 // RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux \
 // RUN:   %p/Inputs/libsearch-st.s -o %tst.o
 // RUN: mkdir -p %t.dir
 // RUN: ld.lld -shared %tdyn.o -o %t.dir/libls.so
 // RUN: cp -f %t.dir/libls.so %t.dir/libls2.so
 // RUN: rm -f %t.dir/libls.a
 // RUN: llvm-ar rcs %t.dir/libls.a %tst.o
 // REQUIRES: x86
 
 // Should fail if no library specified
 // RUN: not ld.lld -l 2>&1 \
 // RUN:   | FileCheck --check-prefix=NOLIBRARY %s
-// NOLIBRARY: missing arg value for "-l", expected 1 argument.
+// NOLIBRARY: Missing arg value for "-l", expected 1 argument.
 
 // 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
+// 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
 
 // Should use explicitly specified static library
 // Also ensure that we accept -L <arg>

lld/trunk/test/ELF/linkerscript.s

 # RUN: echo "ENTRY(_label)" > %t.script
 # RUN: ld.lld -o %t2 %t.script %t
 # RUN: llvm-readobj %t2 > /dev/null
 
 # RUN: echo "ENTRY(_wrong_label)" > %t.script
 # RUN: not ld.lld -o %t2 %t.script %t > %t.log 2>&1
 # RUN: FileCheck -check-prefix=ERR-ENTRY %s < %t.log
 
-# ERR-ENTRY: undefined symbol: _wrong_label
+# ERR-ENTRY: Undefined symbol: _wrong_label
 
 # -e has precedence over linker script's ENTRY.
 # RUN: echo "ENTRY(_label)" > %t.script
 # RUN: ld.lld -e _start -o %t2 %t.script %t
 # RUN: llvm-readobj -file-headers -symbols %t2 | \
 # RUN:   FileCheck -check-prefix=ENTRY-OVERLOAD %s
 
 # ENTRY-OVERLOAD: Entry: [[ENTRY:0x[0-9A-F]+]]

 # RUN: echo "GROUP(\"%t\")" > %t.script2
 # RUN: ld.lld %t.script1
 # RUN: llvm-readobj %t2 > /dev/null
 
 # RUN: echo "FOO(BAR)" > %t.script
 # RUN: not ld.lld -o foo %t.script > %t.log 2>&1
 # RUN: FileCheck -check-prefix=ERR1 %s < %t.log
 
-# ERR1: unknown directive: FOO
+# ERR1: Unknown directive: FOO
 
 .globl _start, _label;
 _start:
   mov $60, %rax
   mov $42, %rdi
 _label:
   syscall

lld/trunk/test/ELF/lto/duplicated.ll

 ; REQUIRES: x86
 ; RUN: llvm-as %s -o %t.o
 ; RUN: not ld.lld -m elf_x86_64 %t.o %t.o -o %t.so -shared 2>&1 | FileCheck %s
-; CHECK: duplicate symbol: f in {{.*}}.o and {{.*}}.o
+; CHECK: Duplicate symbol: f in {{.*}}.o and {{.*}}.o
 target triple = "x86_64-unknown-linux-gnu"
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 
 define void @f() {
   ret void
 }

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
+// 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
 
 // Should just remove the '=' symbol if --sysroot is not specified.
 // Case 1: relative path

lld/trunk/test/ELF/tls-static.s

 // RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %s -o %t
 // RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %S/Inputs/shared.s -o %tso
 // RUN: ld.lld -static %t -o %tout
 // RUN: ld.lld %t -o %tout
 // RUN: ld.lld -shared %tso -o %tshared
 // RUN: not ld.lld -static %t %tshared -o %tout 2>&1 | FileCheck %s
 // REQUIRES: x86
 
 .global _start
 _start:
   call __tls_get_addr
 
-// CHECK: undefined symbol: __tls_get_addr
+// CHECK: Undefined symbol: __tls_get_addr

lld/trunk/test/ELF/undef-start.s

 # RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t
 # RUN: not ld.lld %t -o %t2 2>&1 | FileCheck %s
-# CHECK: undefined symbol: _start
+# CHECK: Undefined symbol: _start
 # REQUIRES: x86

lld/trunk/test/ELF/undef.s

 # RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t
 # RUN: not ld.lld %t -o %t2 2>&1 | FileCheck %s
-# CHECK: undefined symbol: bar in {{.*}}
-# CHECK: undefined symbol: foo in {{.*}}
+# CHECK: Undefined symbol: bar in {{.*}}
+# CHECK: Undefined symbol: foo in {{.*}}
 # REQUIRES: x86
 
   .globl _start
 _start:
   call foo
   call bar