[llvm-objcopy] Tidy up error messages

[abrachet]

Summary

This patch brings various error messages into line with each other, by removing trailing full stops, and making the first letter lower-case. This addresses https://bugs.llvm.org/show_bug.cgi?id=40859.

[jhenderson]

Thanks for the patch @abrachet! I have some comments that you may find useful both here and in the future, regarding the title/description:

In general, title the issue the same as you would the actual commit summary. It's also often useful to put a tag in front representing the tool/library that is being modified (this helps people with searches/email filters etc). Also, put in the description what would go in the commit body (excluding extra bits like the "Differential Revision" and reviewers list. Also, bugs tend to be referred to as PR123456 or simply by their URL in patches. Here's what I'd recommend:

Title: [llvm-objcopy]Tidy up error messages
Description: This patch brings various error messages into line with each other, by removing trailing full stops, and making the first letter lower-case. This addresses https://bugs.llvm.org/show_bug.cgi?id=40859.

It's also useful to put the link to the review request in the bug comments, so that anybody watching the bug can review the patch.

I'm expecting to see a number of test changes. Please make sure to run the lit tests contained within llvm/test/tools/llvm-objcopy with your changes built. This will likely show a number of test failures where we check the error message string, and you'll need to update those too.

llvm/tools/llvm-objcopy/COFF/Object.cpp

56 ↗

(On Diff #200070)

I'm not sure this needs to be quoted, as it is a number, rather than a string.

llvm/tools/llvm-objcopy/COFF/Reader.cpp

186 ↗

(On Diff #200070)

I think SymbolTableIndex is a variable name, based on the COFF file format, and so should match the actual name. It might be worth confirming this, and if it is, you shouldn't change the case here. If it isn't a part of the file format spec, then it should be something like "symbol table index".

llvm/tools/llvm-objcopy/ELF/ELFObjcopy.cpp

171 ↗

(On Diff #200070)

Remove the full stop here.

288 ↗

(On Diff #200070)

You need to run clang-format here to format this to the LLVM style.

llvm/tools/llvm-objcopy/ELF/Object.cpp

1260–1263 ↗

(On Diff #200070)

I don't think you need to quote numeric values. The main reason for quoting section/symbol names is because they theoretically can contain spaces.

1629 ↗

(On Diff #200070)

There's still a trailing full stop here.

[abrachet]

Updated tests, unified the use of 'can't' in error message to the more common 'cannot'

[abrachet]

Thanks for the comments @jhenderson!

llvm/tools/llvm-objcopy/ELF/ELFObjcopy.cpp

254 ↗

(On Diff #200358)

clang-format did this but I think the previous one looks better

[jhenderson]

LGTM, aside from the inline comments. I'd like @jakehehrlich to take a look, given he's the code owner and has final say on these things, but if he doesn't get around to it, I'm happy to commit it tomorrow.

With regards to clang-formatting, make sure to keep the changes to only areas you've touched, as this makes git blame etc harder otherwise (see also the Developer Policy).

llvm/test/tools/llvm-objcopy/ELF/strip-group-symbol.test

31 ↗

(On Diff #200358)

Not related to your change, but you can tidy it up whilst you're here. I think most people find it easier to read the lines with a space between '#' and 'CHECK', so please add it. Same applies to strip-reloc-symbol.test.

llvm/tools/llvm-objcopy/ELF/ELFObjcopy.cpp

189–190 ↗

(On Diff #200358)

If this isn't something you've touched directly, don't change the formatting, even if it's wrong (small changes like this are okay in separate commits though if you're working in the general area).

254 ↗

(On Diff #200358)

I'd revert it, since this isn't related to your change (see above comment).

538–540 ↗

(On Diff #200358)

See above, revert this.

[jhenderson]

Oh, to make landing this easier for somebody else, please update the description and title as I described in the earlier comment.

[rupprecht]

This is a super-nit, but the title should have a space, i.e. [llvm-objcopy] Tidy ...

LGTM modulo that and the clang-format thing James mentioned

llvm/tools/llvm-objcopy/ELF/ELFObjcopy.cpp

254 ↗

(On Diff #200358)

Specifically, git-clang-format handles this well. Editors can also usually be configured for this, depending on which one you use.

[jakehehrlich]

Thanks for fixing all of my mistakes!

I have the same nit about formatting but perhaps that just means we should clang-format the whole thing in a single patch as an NFC. We've done that in the past and I think doing it again would be good.

[jhenderson]

@abrachet, please make the requested updates and then one of us can commit it for you. Once your first patch lands, you should be able to request commit access as described in the documentation.

[abrachet]

Reverted a change made by clang-format

[abrachet]

Thanks so much for all the comments! Hopefully future patches will be smoother from me. Learned a lot about the process!

[abrachet]

Missed a couple changes that clang-format made

[abrachet]

Tidied up test files to make more readable. Put a space between '#CHECK'

[jhenderson]

LGTM! Thanks. I'll try to commit this later today.

llvm/trunk/test/tools/llvm-objcopy/COFF/remove-section.test

 # SYMBOLS-REMOVE-TEXT-NEXT: AUX scnlen {{.*}} assoc 2 comdat 2
 # SYMBOLS-REMOVE-TEXT-NEXT: {{.*}}(sec 2){{.*}} foo
 # SYMBOLS-REMOVE-TEXT-EMPTY:
 #
 #
 # Removing the .comdat section fails, since the .text section has relocations
 # against it.
 #
-# ERROR-RELOC: Relocation target 'foo' ({{.*}}) not found
+# ERROR-RELOC: relocation target 'foo' ({{.*}}) not found
 #
 #
 # Removing the .comdat section and .text (with a relocation against .comdat)
 # works, as it also removes the .associative section transitively.
 #
 # SECTIONS-REMOVE-TEXT-COMDAT: Sections:
 # SECTIONS-REMOVE-TEXT-COMDAT-NEXT: Idx Name
 # SECTIONS-REMOVE-TEXT-COMDAT-NEXT: 0 .bss

llvm/trunk/test/tools/llvm-objcopy/COFF/strip-reloc-symbol.test

 RUN: yaml2obj %p/Inputs/strip-symbols.yaml > %t.o
 RUN: not llvm-objcopy -N foo %t.o 2>&1 | FileCheck %s --check-prefix=ERROR
 RUN: not llvm-objcopy --strip-symbol foo %t.o 2>&1 | FileCheck %s --check-prefix=ERROR
 
-ERROR: error: '{{.*}}{{/|\\}}strip-reloc-symbol.test.tmp.o': not stripping symbol 'foo' because it is named in a relocation.
+ERROR: error: '{{.*}}{{/|\\}}strip-reloc-symbol.test.tmp.o': not stripping symbol 'foo' because it is named in a relocation

llvm/trunk/test/tools/llvm-objcopy/COFF/weak-external.test

 # SYMBOLS: SYMBOL TABLE:
 # SYMBOLS-PRE-NEXT: func
 # SYMBOLS-NEXT: .weak.foobar.file1
 # SYMBOLS-NEXT: foobar
 # SYMBOLS-PRE-NEXT: AUX indx 1
 # SYMBOLS-POST-NEXT: AUX indx 0
 # SYMBOLS-EMPTY:
 
-# ERROR: Symbol 'foobar' is missing its weak target
+# ERROR: symbol 'foobar' is missing its weak target
 
 --- !COFF
 header:          
   Machine:         IMAGE_FILE_MACHINE_AMD64
   Characteristics: [  ]
 sections:        
   - Name:            .text
     Characteristics: [  ]

llvm/trunk/test/tools/llvm-objcopy/ELF/bad-build-id.test

 # RUN: yaml2obj %s > %t
 # RUN: not llvm-objcopy --build-id-link-dir=%t-dir --build-id-link-input=.debug %t 2>&1 >/dev/null | FileCheck %s
 
-# CHECK: build ID is smaller than two bytes.
+# CHECK: build ID is smaller than two bytes
 
 --- !ELF
 FileHeader:
   Class:           ELFCLASS64
   Data:            ELFDATA2LSB
   Type:            ET_EXEC
   Machine:         EM_X86_64
 Sections:

llvm/trunk/test/tools/llvm-objcopy/ELF/binary-out-error.test

 # RUN: not llvm-objcopy -O binary %p/Inputs/alloc-symtab.o %t2 2>&1 >/dev/null | FileCheck %s --check-prefix=SYMTAB
-# SYMTAB: Cannot write symbol table '.symtab' out to binary
+# SYMTAB: cannot write symbol table '.symtab' out to binary

llvm/trunk/test/tools/llvm-objcopy/ELF/discard-locals-rel.test

Relocations:
       - Offset: 0x1000
         Symbol: .L.rel
         Type:   R_X86_64_PC32
 Symbols:
   - Name:     .L.rel
     Type:     STT_FUNC
     Section:  .text
 
-# CHECK: not stripping symbol '.L.rel' because it is named in a relocation.
+# CHECK: not stripping symbol '.L.rel' because it is named in a relocation

llvm/trunk/test/tools/llvm-objcopy/ELF/dump-section.test

Sections:
     - Section: .text
 
 #CHECK: 0000000 de ad be ef
 
 #NON-ALLOC: 0000000 ca fe
 
 #SIZE: 4
 
-#NOBITS: Can't dump section ".bar": it has no contents
+#NOBITS: cannot dump section '.bar': it has no contents

llvm/trunk/test/tools/llvm-objcopy/ELF/dynrelocsec-remove-shlink-reference.test

 # RUN: yaml2obj %s > %t
 
 ## Check we cannot remove the .dynsym symbol table because dynamic
 ## relocation section .rela.dyn still references it via sh_link field.
 # RUN: not llvm-objcopy -R .dynsym %t %t2 2>&1 >/dev/null | FileCheck %s --check-prefix=ERR
-# ERR: error: Symbol table .dynsym cannot be removed because it is referenced by the relocation section .rela.dyn.
+# ERR: error: symbol table '.dynsym' cannot be removed because it is referenced by the relocation section '.rela.dyn'
 
 ## Check we can remove .dynsym after removing the reference.
 # RUN: llvm-objcopy -R .dynsym -R .rela.dyn %t %t2
 # RUN: llvm-readelf --sections %t2 | FileCheck %s --implicit-check-not=".dynsym"
 
 ## Check we zero out sh_link field and allow producing output with the --allow-broken-links switch.
 # RUN: llvm-objcopy -R .dynsym --allow-broken-links %t %t2
 # RUN: llvm-readelf --sections %t2 | FileCheck %s --check-prefix=DROP-LINK

llvm/trunk/test/tools/llvm-objcopy/ELF/dynsym-error-remove-strtab.test

 # RUN: not llvm-objcopy -R .dynstr %p/Inputs/dynsym.so %t 2>&1 >/dev/null | FileCheck %s --check-prefix=ERR
 # RUN: cp  %p/Inputs/dynsym.so %t2
 # RUN: not llvm-strip --no-strip-all -R .dynstr %t2 2>&1 >/dev/null | FileCheck %s --check-prefix=ERR
 
-# ERR: Section .dynstr cannot be removed because it is referenced by the section .dynsym
+# ERR: section '.dynstr' cannot be removed because it is referenced by the section '.dynsym'
 
 # RUN: llvm-objcopy --allow-broken-links -R .dynstr %p/Inputs/dynsym.so %t3
 # RUN: llvm-objdump --section-headers %t3 | FileCheck %s --check-prefix=SECTIONS --implicit-check-not=.dynstr
 # RUN: cp  %p/Inputs/dynsym.so %t4
 # RUN: llvm-strip --no-strip-all --allow-broken-links -R .dynstr %t4
 # RUN: llvm-objdump --section-headers %t4 | FileCheck %s --check-prefix=SECTIONS --implicit-check-not=.dynstr
 
 # SECTIONS: .dynsym
 # SECTIONS: .dynamic

llvm/trunk/test/tools/llvm-objcopy/ELF/group-addr-misaligned.test

 # RUN: yaml2obj %s > %t
 # RUN: not llvm-objcopy %t %t2 2>&1 | FileCheck %s
-# CHECK: error: Invalid alignment 1 of group section .group.
+# CHECK: error: invalid alignment 1 of group section '.group'
 
 # In this test, we check that llvm-objcopy reports an error
 # for SHT_GROUP section with invalid alignment (not a multiple of 4). 
 
 --- !ELF
 FileHeader:
   Class:           ELFCLASS64
   Data:            ELFDATA2LSB

llvm/trunk/test/tools/llvm-objcopy/ELF/hexagon-unsupported-on-x86.test

 # RUN: yaml2obj %s > %t
 # RUN: not llvm-objcopy %t %t2 2>&1 >/dev/null | FileCheck %s
 
 !ELF
 FileHeader:
   Class:           ELFCLASS64
   Data:            ELFDATA2LSB
   Type:            ET_EXEC
   Machine:         EM_X86_64
 Symbols:
   - Name:     test
     Index:    SHN_HEXAGON_SCOMMON
     Binding:  STB_GLOBAL
 
-# CHECK: Symbol 'test' has unsupported value greater than or equal to SHN_LORESERVE: 65280
+# CHECK: symbol 'test' has unsupported value greater than or equal to SHN_LORESERVE: 65280

llvm/trunk/test/tools/llvm-objcopy/ELF/no-build-id-no-notes.test

 # RUN: yaml2obj %s > %t
 # RUN: not llvm-objcopy --build-id-link-dir=%t-dir --build-id-link-input=.debug %t 2>&1 >/dev/null | FileCheck %s
 
-# CHECK: Could not find build ID.
+# CHECK: could not find build ID
 
 --- !ELF
 FileHeader:
   Class:           ELFCLASS64
   Data:            ELFDATA2LSB
   Type:            ET_EXEC
   Machine:         EM_X86_64

llvm/trunk/test/tools/llvm-objcopy/ELF/no-build-id.test

 # RUN: yaml2obj %s > %t
 # RUN: not llvm-objcopy --build-id-link-dir=%t-dir --build-id-link-input=.debug %t 2>&1 >/dev/null | FileCheck %s
 
-# CHECK: Could not find build ID.
+# CHECK: could not find build ID
 
 --- !ELF
 FileHeader:
   Class:           ELFCLASS64
   Data:            ELFDATA2LSB
   Type:            ET_EXEC
   Machine:         EM_X86_64
 Sections:

llvm/trunk/test/tools/llvm-objcopy/ELF/reloc-error-remove-symtab.test

Relocations:
         Type:   R_X86_64_PC32
 
 Symbols:
   - Name:     foo
     Type:     STT_FUNC
     Size:     4
     Binding:  STB_GLOBAL
 
-# ERR: Symbol table .symtab cannot be removed because it is referenced by the relocation section .rel.text.
+# ERR: symbol table '.symtab' cannot be removed because it is referenced by the relocation section '.rel.text'
 
 # RUN: llvm-objcopy --allow-broken-links -R .symtab %t %t4
 # RUN: llvm-readobj --sections %t4 | FileCheck %s --check-prefix=SECTIONS --implicit-check-not=.symtab
 # RUN: cp %t %t5
 # RUN: llvm-strip --no-strip-all --allow-broken-links -R .symtab %t5
 # RUN: llvm-readobj --sections %t5 | FileCheck %s --check-prefix=SECTIONS --implicit-check-not=.symtab
 
 # SECTIONS:        Name: .rel.text
 # SECTIONS:        Link
 # SECTIONS-SAME: : 0

llvm/trunk/test/tools/llvm-objcopy/ELF/remove-linked-section.test

FileHeader:
   Machine:         EM_X86_64
 Sections:
   - Name:            .foo
     Type:            SHT_PROGBITS
   - Name:            .bar
     Type:            SHT_PROGBITS
     Link:            .foo
 
-# ERR: Section .foo cannot be removed because it is referenced by the section .bar
+# ERR: section '.foo' cannot be removed because it is referenced by the section '.bar'
 
 # RUN: llvm-objcopy --allow-broken-links -R .foo %t.o %t3
 # RUN: llvm-readobj --sections %t3 | FileCheck %s --check-prefix=SECTIONS --implicit-check-not=.foo
 # RUN: cp %t.o %t4
 # RUN: llvm-strip --no-strip-all --allow-broken-links -R .foo %t4
 # RUN: llvm-readobj --sections %t4 | FileCheck %s --check-prefix=SECTIONS --implicit-check-not=.foo
 
 # SECTIONS:      Name: .bar
 # SECTIONS:      Link
 # SECTIONS-SAME: : 0

llvm/trunk/test/tools/llvm-objcopy/ELF/remove-shstrtab-error.test

 # RUN: yaml2obj %s > %t
 # RUN: not llvm-objcopy -R .shstrtab %t %t2 2>&1 >/dev/null | FileCheck %s
 
 !ELF
 FileHeader:
   Class:           ELFCLASS64
   Data:            ELFDATA2LSB
   Type:            ET_REL
   Machine:         EM_X86_64
 
-# CHECK: Cannot write section header table because section header string table was removed.
+# CHECK: cannot write section header table because section header string table was removed

llvm/trunk/test/tools/llvm-objcopy/ELF/section-index-unsupported.test

 # RUN: yaml2obj %s > %t
 # RUN: not llvm-objcopy %t %t2 2>&1 >/dev/null | FileCheck %s
 
 !ELF
 FileHeader:
   Class:           ELFCLASS64
   Data:            ELFDATA2LSB
   Type:            ET_EXEC
   Machine:         EM_X86_64
 Symbols:
   - Name:     test
     Index:    0xff05
     Binding:  STB_GLOBAL
 
-# CHECK: Symbol 'test' has unsupported value greater than or equal to SHN_LORESERVE: 65285
+# CHECK: symbol 'test' has unsupported value greater than or equal to SHN_LORESERVE: 65285

llvm/trunk/test/tools/llvm-objcopy/ELF/strip-group-symbol.test

- Name:            .text
     AddressAlign:    0x0000000000000010
     Size:            64
 Symbols:
   - Name:    foo
     Type:    STT_FUNC
     Section: .text
     Binding: STB_WEAK
 
-#CHECK: Symbol foo cannot be removed because it is referenced by the section .group[1].
+# CHECK: symbol 'foo' cannot be removed because it is referenced by the section '.group[1]'

llvm/trunk/test/tools/llvm-objcopy/ELF/strip-reloc-symbol.test

Relocations:
         Type:   R_X86_64_PC32
 Symbols:
   - Name:     foo
     Type:     STT_FUNC
     Section:  .text
     Value:    0x1000
     Size:     8
 
-#CHECK: not stripping symbol 'foo' because it is named in a relocation.
+# CHECK: not stripping symbol 'foo' because it is named in a relocation

llvm/trunk/test/tools/llvm-objcopy/ELF/strip-section-err.test

 ## Check we cannot remove a section containing symbols
 ## referenced by relocations contained in the object.
 
 # RUN: yaml2obj %s > %t1
 # RUN: not llvm-objcopy -R .data %t1 2>&1 | FileCheck %s
-# CHECK: error: Section .data can't be removed: (.text+0x1) has relocation against symbol 'foo'
+# CHECK: error: section '.data' cannot be removed: (.text+0x1) has relocation against symbol 'foo'
 
 ## Check the behavior when we also remove the relocation section.
 ## We have no reference in this case and hence no error should be emitted.
 
 # RUN: yaml2obj %s > %t2
 # RUN: llvm-objcopy -R .data -R .rela.text %t2 %t3
 # RUN: llvm-objdump --section-headers %t3 | FileCheck %s --check-prefix=NOSEC
 # NOSEC-NOT: .data

llvm/trunk/test/tools/llvm-objcopy/ELF/symtab-error-on-remove-strtab.test

 # RUN: yaml2obj %s > %t
 # RUN: not llvm-objcopy -R .strtab %t %t2 2>&1 >/dev/null | FileCheck %s --check-prefix=ERR
 # RUN: cp %t %t3
 # RUN: not llvm-strip --no-strip-all -R .strtab %t3 2>&1 >/dev/null | FileCheck %s --check-prefix=ERR
 
 !ELF
 FileHeader:
   Class:           ELFCLASS64
   Data:            ELFDATA2LSB
   Type:            ET_REL
   Machine:         EM_X86_64
 
-# ERR: String table .strtab cannot be removed because it is referenced by the symbol table .symtab
+# ERR: string table '.strtab' cannot be removed because it is referenced by the symbol table '.symtab'
 
 # RUN: llvm-objcopy --allow-broken-links -R .strtab %t %t4
 # RUN: llvm-objdump --section-headers %t4 | FileCheck %s --check-prefix=SECTIONS --implicit-check-not=.strtab
 # RUN: cp %t %t5
 # RUN: llvm-strip --no-strip-all --allow-broken-links -R .strtab %t %t5
 # RUN: llvm-objdump --section-headers %t5 | FileCheck %s --check-prefix=SECTIONS --implicit-check-not=.strtab
 
 # SECTIONS: .symtab

llvm/trunk/tools/llvm-objcopy/COFF/COFFObjcopy.cpp

if (Config.StripAll || Config.StripAllGNU)
       return true;
 
     if (is_contained(Config.SymbolsToRemove, Sym.Name)) {
       // Explicitly removing a referenced symbol is an error.
       if (Sym.Referenced)
         reportError(Config.OutputFilename,
                     createStringError(llvm::errc::invalid_argument,
                                       "not stripping symbol '%s' because it is "
-                                      "named in a relocation.",
+                                      "named in a relocation",
                                       Sym.Name.str().c_str()));
       return true;
     }
 
     if (!Sym.Referenced) {
       // With --strip-unneeded, GNU objcopy removes all unreferenced local
       // symbols, and any unreferenced undefined external.
       // With --strip-unneeded-symbol we strip only specific unreferenced
if (Config.AllowBrokenLinks || !Config.BuildIdLinkDir.empty() ||
       !Config.SymbolsToKeepGlobal.empty() || !Config.SectionsToRename.empty() ||
       !Config.SetSectionFlags.empty() || !Config.SymbolsToRename.empty() ||
       Config.ExtractDWO || Config.KeepFileSymbols || Config.LocalizeHidden ||
       Config.PreserveDates || Config.StripDWO || Config.StripNonAlloc ||
       Config.StripSections || Config.Weaken || Config.DecompressDebugSections ||
       Config.DiscardMode == DiscardType::Locals ||
       !Config.SymbolsToAdd.empty() || Config.EntryExpr) {
     return createStringError(llvm::errc::invalid_argument,
-                             "Option not supported by llvm-objcopy for COFF");
+                             "option not supported by llvm-objcopy for COFF");
   }
 
   return Error::success();
 }
 
 Error executeObjcopyOnBinary(const CopyConfig &Config, COFFObjectFile &In,
                              Buffer &Out) {
   COFFReader Reader(In);

llvm/trunk/tools/llvm-objcopy/COFF/Object.cpp

 Error Object::markSymbols() {
   for (Symbol &Sym : Symbols)
     Sym.Referenced = false;
   for (const Section &Sec : Sections) {
     for (const Relocation &R : Sec.Relocs) {
       auto It = SymbolMap.find(R.Target);
       if (It == SymbolMap.end())
         return createStringError(object_error::invalid_symbol_index,
-                                 "Relocation target %zu not found", R.Target);
+                                 "relocation target %zu not found", R.Target);
       It->second->Referenced = true;
     }
   }
   return Error::success();
 }
 
 void Object::addSections(ArrayRef<Section> NewSections) {
   for (Section S : NewSections) {

llvm/trunk/tools/llvm-objcopy/COFF/Reader.cpp

for (size_t I = 1, E = COFFObj.getNumberOfSections(); I <= E; I++) {
     for (const coff_relocation &R : Relocs)
       S.Relocs.push_back(R);
     if (Expected<StringRef> NameOrErr = COFFObj.getSectionName(Sec))
       S.Name = *NameOrErr;
     else
       return NameOrErr.takeError();
     if (Sec->hasExtendedRelocations())
       return createStringError(object_error::parse_failed,
-                               "Extended relocations not supported yet");
+                               "extended relocations not supported yet");
   }
   Obj.addSections(Sections);
   return Error::success();
 }
 
 Error COFFReader::readSymbols(Object &Obj, bool IsBigObj) const {
   std::vector<Symbol> Symbols;
   Symbols.reserve(COFFObj.getRawNumberOfSymbols());
for (uint32_t I = 0, E = COFFObj.getRawNumberOfSymbols(); I < E;) {
     if (SymRef.getSectionNumber() <=
         0) // Special symbol (undefined/absolute/debug)
       Sym.TargetSectionId = SymRef.getSectionNumber();
     else if (static_cast<uint32_t>(SymRef.getSectionNumber() - 1) <
              Sections.size())
       Sym.TargetSectionId = Sections[SymRef.getSectionNumber() - 1].UniqueId;
     else
       return createStringError(object_error::parse_failed,
-                               "Section number out of range");
+                               "section number out of range");
     // For section definitions, check if it is comdat associative, and if
     // it is, find the target section unique id.
     const coff_aux_section_definition *SD = SymRef.getSectionDefinition();
     const coff_aux_weak_external *WE = SymRef.getWeakExternal();
     if (SD && SD->Selection == IMAGE_COMDAT_SELECT_ASSOCIATIVE) {
       int32_t Index = SD->getNumber(IsBigObj);
       if (Index <= 0 || static_cast<uint32_t>(Index - 1) >= Sections.size())
         return createStringError(object_error::parse_failed,
-                                 "Unexpected associative section index");
+                                 "unexpected associative section index");
       Sym.AssociativeComdatTargetSectionId = Sections[Index - 1].UniqueId;
     } else if (WE) {
       // This is a raw symbol index for now, but store it in the Symbol
       // until we've added them to the Object, which assigns the final
       // unique ids.
       Sym.WeakTargetSymbolId = WE->TagIndex;
     }
     I += 1 + SymRef.getNumberOfAuxSymbols();
for (size_t I = 0; I < Sym.Sym.NumberOfAuxSymbols; I++)
       RawSymbolTable.push_back(nullptr);
   }
   for (Symbol &Sym : Obj.getMutableSymbols()) {
     // Convert WeakTargetSymbolId from the original raw symbol index to
     // a proper unique id.
     if (Sym.WeakTargetSymbolId) {
       if (*Sym.WeakTargetSymbolId >= RawSymbolTable.size())
         return createStringError(object_error::parse_failed,
-                                 "Weak external reference out of range");
+                                 "weak external reference out of range");
       const Symbol *Target = RawSymbolTable[*Sym.WeakTargetSymbolId];
       if (Target == nullptr)
         return createStringError(object_error::parse_failed,
-                                 "Invalid SymbolTableIndex");
+                                 "invalid SymbolTableIndex");
       Sym.WeakTargetSymbolId = Target->UniqueId;
     }
   }
   for (Section &Sec : Obj.getMutableSections()) {
     for (Relocation &R : Sec.Relocs) {
       if (R.Reloc.SymbolTableIndex >= RawSymbolTable.size())
         return createStringError(object_error::parse_failed,
                                  "SymbolTableIndex out of range");
       const Symbol *Sym = RawSymbolTable[R.Reloc.SymbolTableIndex];
       if (Sym == nullptr)
         return createStringError(object_error::parse_failed,
-                                 "Invalid SymbolTableIndex");
+                                 "invalid SymbolTableIndex");
       R.Target = Sym->UniqueId;
       R.TargetName = Sym->Name;
     }
   }
   return Error::success();
 }
 
 Expected<std::unique_ptr<Object>> COFFReader::create() const {
   auto Obj = llvm::make_unique<Object>();
 
   const coff_file_header *CFH = nullptr;
   const coff_bigobj_file_header *CBFH = nullptr;
   COFFObj.getCOFFHeader(CFH);
   COFFObj.getCOFFBigObjHeader(CBFH);
   bool IsBigObj = false;
   if (CFH) {
     Obj->CoffFileHeader = *CFH;
   } else {
     if (!CBFH)
       return createStringError(object_error::parse_failed,
-                               "No COFF file header returned");
+                               "no COFF file header returned");
     // Only copying the few fields from the bigobj header that we need
     // and won't recreate in the end.
     Obj->CoffFileHeader.Machine = CBFH->Machine;
     Obj->CoffFileHeader.TimeDateStamp = CBFH->TimeDateStamp;
     IsBigObj = true;
   }
 
   if (Error E = readExecutableHeaders(*Obj))

llvm/trunk/tools/llvm-objcopy/COFF/Writer.cpp

 using namespace COFF;
 
 Error COFFWriter::finalizeRelocTargets() {
   for (Section &Sec : Obj.getMutableSections()) {
     for (Relocation &R : Sec.Relocs) {
       const Symbol *Sym = Obj.findSymbol(R.Target);
       if (Sym == nullptr)
         return createStringError(object_error::invalid_symbol_index,
-                                 "Relocation target '%s' (%zu) not found",
+                                 "relocation target '%s' (%zu) not found",
                                  R.TargetName.str().c_str(), R.Target);
       R.Reloc.SymbolTableIndex = Sym->RawIndex;
     }
   }
   return Error::success();
 }
 
 Error COFFWriter::finalizeSymbolContents() {
   for (Symbol &Sym : Obj.getMutableSymbols()) {
     if (Sym.TargetSectionId <= 0) {
       // Undefined, or a special kind of symbol. These negative values
       // are stored in the SectionNumber field which is unsigned.
       Sym.Sym.SectionNumber = static_cast<uint32_t>(Sym.TargetSectionId);
     } else {
       const Section *Sec = Obj.findSection(Sym.TargetSectionId);
       if (Sec == nullptr)
         return createStringError(object_error::invalid_symbol_index,
-                                 "Symbol '%s' points to a removed section",
+                                 "symbol '%s' points to a removed section",
                                  Sym.Name.str().c_str());
       Sym.Sym.SectionNumber = Sec->Index;
 
       if (Sym.Sym.NumberOfAuxSymbols == 1 &&
           Sym.Sym.StorageClass == IMAGE_SYM_CLASS_STATIC) {
         coff_aux_section_definition *SD =
             reinterpret_cast<coff_aux_section_definition *>(
                 Sym.AuxData[0].Opaque);
         uint32_t SDSectionNumber;
         if (Sym.AssociativeComdatTargetSectionId == 0) {
           // Not a comdat associative section; just set the Number field to
           // the number of the section itself.
           SDSectionNumber = Sec->Index;
         } else {
           Sec = Obj.findSection(Sym.AssociativeComdatTargetSectionId);
           if (Sec == nullptr)
             return createStringError(
                 object_error::invalid_symbol_index,
-                "Symbol '%s' is associative to a removed section",
+                "symbol '%s' is associative to a removed section",
                 Sym.Name.str().c_str());
           SDSectionNumber = Sec->Index;
         }
         // Update the section definition with the new section number.
         SD->NumberLowPart = static_cast<uint16_t>(SDSectionNumber);
         SD->NumberHighPart = static_cast<uint16_t>(SDSectionNumber >> 16);
       }
     }
     // Check that we actually have got AuxData to match the weak symbol target
     // we want to set. Only >= 1 would be required, but only == 1 makes sense.
     if (Sym.WeakTargetSymbolId && Sym.Sym.NumberOfAuxSymbols == 1) {
       coff_aux_weak_external *WE =
           reinterpret_cast<coff_aux_weak_external *>(Sym.AuxData[0].Opaque);
       const Symbol *Target = Obj.findSymbol(*Sym.WeakTargetSymbolId);
       if (Target == nullptr)
         return createStringError(object_error::invalid_symbol_index,
-                                 "Symbol '%s' is missing its weak target",
+                                 "symbol '%s' is missing its weak target",
                                  Sym.Name.str().c_str());
       WE->TagIndex = Target->RawIndex;
     }
   }
   return Error::success();
 }
 
 void COFFWriter::layoutSections() {
if (Dir->Size <= 0)
     return Error::success();
   for (const auto &S : Obj.getSections()) {
     if (Dir->RelativeVirtualAddress >= S.Header.VirtualAddress &&
         Dir->RelativeVirtualAddress <
             S.Header.VirtualAddress + S.Header.SizeOfRawData) {
       if (Dir->RelativeVirtualAddress + Dir->Size >
           S.Header.VirtualAddress + S.Header.SizeOfRawData)
         return createStringError(object_error::parse_failed,
-                                 "Debug directory extends past end of section");
+                                 "debug directory extends past end of section");
 
       size_t Offset = Dir->RelativeVirtualAddress - S.Header.VirtualAddress;
       uint8_t *Ptr = Buf.getBufferStart() + S.Header.PointerToRawData + Offset;
       uint8_t *End = Ptr + Dir->Size;
       while (Ptr < End) {
         debug_directory *Debug = reinterpret_cast<debug_directory *>(Ptr);
         Debug->PointerToRawData =
             S.Header.PointerToRawData + Offset + sizeof(debug_directory);
         Ptr += sizeof(debug_directory) + Debug->SizeOfData;
         Offset += sizeof(debug_directory) + Debug->SizeOfData;
       }
       // Debug directory found and patched, all done.
       return Error::success();
     }
   }
   return createStringError(object_error::parse_failed,
-                           "Debug directory not found");
+                           "debug directory not found");
 }
 
 Error COFFWriter::write() {
   bool IsBigObj = Obj.getSections().size() > MaxNumberOfSections16;
   if (IsBigObj && Obj.IsPE)
     return createStringError(object_error::parse_failed,
-                             "Too many sections for executable");
+                             "too many sections for executable");
   return write(IsBigObj);
 }
 
 } // end namespace coff
 } // end namespace objcopy
 } // end namespace llvm

llvm/trunk/tools/llvm-objcopy/ELF/ELFObjcopy.cpp

for (const auto &Phdr : unwrapOrError(In.program_headers())) {
     Error Err = Error::success();
     for (const auto &Note : In.notes(Phdr, Err))
       if (Note.getType() == NT_GNU_BUILD_ID && Note.getName() == ELF_NOTE_GNU)
         return Note.getDesc();
     if (Err)
       return std::move(Err);
   }
   return createStringError(llvm::errc::invalid_argument,
-                           "Could not find build ID.");
+                           "could not find build ID");
 }
 
 static Expected<ArrayRef<uint8_t>>
 findBuildID(const object::ELFObjectFileBase &In) {
   if (auto *O = dyn_cast<ELFObjectFile<ELF32LE>>(&In))
     return findBuildID(*O->getELFFile());
   else if (auto *O = dyn_cast<ELFObjectFile<ELF64LE>>(&In))
     return findBuildID(*O->getELFFile());
   else if (auto *O = dyn_cast<ELFObjectFile<ELF32BE>>(&In))
     return findBuildID(*O->getELFFile());
   else if (auto *O = dyn_cast<ELFObjectFile<ELF64BE>>(&In))
     return findBuildID(*O->getELFFile());
 
   llvm_unreachable("Bad file format");
 }
 
 template <class... Ts>
-static Error makeStringError(std::error_code EC, const Twine &Msg, Ts&&... Args) {
+static Error makeStringError(std::error_code EC, const Twine &Msg, Ts &&... Args) {
   std::string FullMsg = (EC.message() + ": " + Msg).str();
   return createStringError(EC, FullMsg.c_str(), std::forward<Ts>(Args)...);
 }
 
 #define MODEL_8 "%%%%%%%%"
 #define MODEL_16 MODEL_8 MODEL_8
 #define MODEL_32 (MODEL_16 MODEL_16)
 
static Error linkToBuildIdDir(const CopyConfig &Config, StringRef ToLink,
   // Additionally we prepend the original Path for debugging but also
   // because it ensures that we're linking within a directory on the same
   // partition on the same device which is critical. It has the added
   // win of yet further decreasing the odds of a conflict.
   sys::fs::createUniquePath(Twine(Path) + "-" + MODEL_32 + ".tmp", TmpPath,
                             /*MakeAbsolute*/ false);
   if (auto EC = sys::fs::create_hard_link(ToLink, TmpPath)) {
     Path.push_back('\0');
-    return makeStringError(EC, "cannot link %s to %s", ToLink.data(),
-                             Path.data());
+    return makeStringError(EC, "cannot link '%s' to '%s'", ToLink.data(),
   }
   // We then atomically rename the link into place which will just move the
   // link. If rename fails something is more seriously wrong so just return
   // an error.
   if (auto EC = sys::fs::rename(TmpPath, Path)) {
     Path.push_back('\0');
-    return makeStringError(EC, "cannot link %s to %s", ToLink.data(),
-                             Path.data());
+    return makeStringError(EC, "cannot link '%s' to '%s'", ToLink.data(),
   }
   // If `Path` was already a hard-link to the same underlying file then the
   // temp file will be left so we need to remove it. Remove will not cause
   // an error by default if the file is already gone so just blindly remove
   // it rather than checking.
   if (auto EC = sys::fs::remove(TmpPath)) {
     TmpPath.push_back('\0');
-    return makeStringError(EC, "could not remove %s", TmpPath.data());
+    return makeStringError(EC, "could not remove '%s'", TmpPath.data());
   }
   return Error::success();
 }
 
 static Error splitDWOToFile(const CopyConfig &Config, const Reader &Reader,
                             StringRef File, ElfType OutputElfType) {
   auto DWOFile = Reader.create();
   auto OnlyKeepDWOPred = [&DWOFile](const SectionBase &Sec) {
     return onlyKeepDWOPred(*DWOFile, Sec);
   };
-  if (Error E = DWOFile->removeSections(Config.AllowBrokenLinks,
+  if (Error E = DWOFile->removeSections(Config.AllowBrokenLinks, 
                                         OnlyKeepDWOPred))
     return E;
   if (Config.OutputArch) {
     DWOFile->Machine = Config.OutputArch.getValue().EMachine;
     DWOFile->OSABI = Config.OutputArch.getValue().OSABI;
   }
   FileBuffer FB(File);
   auto Writer = createWriter(Config, *DWOFile, FB, OutputElfType);
   if (Error E = Writer->finalize())
     return E;
   return Writer->write();
 }
 
 static Error dumpSectionToFile(StringRef SecName, StringRef Filename,
                                Object &Obj) {
   for (auto &Sec : Obj.sections()) {
     if (Sec.Name == SecName) {
       if (Sec.OriginalData.empty())
-        return createStringError(
-            object_error::parse_failed,
-            "Can't dump section \"%s\": it has no contents",
+        return createStringError(object_error::parse_failed,
+                                 "cannot dump section '%s': it has no contents",
                                  SecName.str().c_str());
       Expected<std::unique_ptr<FileOutputBuffer>> BufferOrErr =
           FileOutputBuffer::create(Filename, Sec.OriginalData.size());
       if (!BufferOrErr)
         return BufferOrErr.takeError();
       std::unique_ptr<FileOutputBuffer> Buf = std::move(*BufferOrErr);
       std::copy(Sec.OriginalData.begin(), Sec.OriginalData.end(),
                 Buf->getBufferStart());
       if (Error E = Buf->commit())
         return E;
       return Error::success();
     }
   }
-  return createStringError(object_error::parse_failed, "Section not found");
+  return createStringError(object_error::parse_failed, "section '%s' not found",
+                           SecName.str().c_str());
 }
 
 static bool isCompressable(const SectionBase &Section) {
   return !(Section.Flags & ELF::SHF_COMPRESSED) &&
          StringRef(Section.Name).startswith(".debug");
 }
 
 static void replaceDebugSections(
if ((!Config.SymbolsToKeep.empty() || Config.KeepFileSymbols) &&
     RemovePred = [&Obj, RemovePred](const SectionBase &Sec) {
       if (&Sec == Obj.SymbolTable || &Sec == Obj.SymbolTable->getStrTab())
         return false;
       return RemovePred(Sec);
     };
   }
 
   if (Config.CompressionType != DebugCompressionType::None)
-    replaceDebugSections(Obj, RemovePred, isCompressable,
+    replaceDebugSections(Obj, RemovePred, isCompressable, 
                          [&Config, &Obj](const SectionBase *S) {
                            return &Obj.addSection<CompressedSection>(
                                 *S, Config.CompressionType);
-                         });
   else if (Config.DecompressDebugSections)
     replaceDebugSections(
         Obj, RemovePred,
         [](const SectionBase &S) { return isa<CompressedSection>(&S); },
         [&Obj](const SectionBase *S) {
           auto CS = cast<CompressedSection>(S);
           return &Obj.addSection<DecompressedSection>(*CS);
         });
for (auto &Sec : Obj.sections()) {
       // Add a prefix to allocated sections and their relocation sections. This
       // should be done after renaming the section by Config.SectionToRename to
       // imitate the GNU objcopy behavior.
       if (!Config.AllocSectionsPrefix.empty()) {
         if (Sec.Flags & SHF_ALLOC) {
           Sec.Name = (Config.AllocSectionsPrefix + Sec.Name).str();
           PrefixedSections.insert(&Sec);
 
           // Rename relocation sections associated to the allocated sections.
           // For example, if we rename .text to .prefix.text, we also rename
           // .rel.text to .rel.prefix.text.
           //
           // Dynamic relocation sections (SHT_REL[A] with SHF_ALLOC) are handled
           // above, e.g., .rela.plt is renamed to .prefix.rela.plt, not
           // .rela.prefix.plt since GNU objcopy does so.
         } else if (auto *RelocSec = dyn_cast<RelocationSectionBase>(&Sec)) {
           auto *TargetSec = RelocSec->getSection();
           if (TargetSec && (TargetSec->Flags & SHF_ALLOC)) {
             StringRef prefix;
             switch (Sec.Type) {
             case SHT_REL:
               prefix = ".rel";
               break;
Error executeObjcopyOnBinary(const CopyConfig &Config,
   ArrayRef<uint8_t> BuildIdBytes;
 
   if (!Config.BuildIdLinkDir.empty()) {
     BuildIdBytes = unwrapOrError(findBuildID(In));
     if (BuildIdBytes.size() < 2)
       return createFileError(
           Config.InputFilename,
           createStringError(object_error::parse_failed,
-                            "build ID is smaller than two bytes."));
+                            "build ID is smaller than two bytes"));
   }
 
   if (!Config.BuildIdLinkDir.empty() && Config.BuildIdLinkInput)
     if (Error E =
             linkToBuildIdDir(Config, Config.InputFilename,
                              Config.BuildIdLinkInput.getValue(), BuildIdBytes))
       return E;
 

llvm/trunk/tools/llvm-objcopy/ELF/Object.cpp

 
 template <class ELFT>
 void ELFSectionSizer<ELFT>::visit(CompressedSection &Sec) {}
 
 template <class ELFT>
 void ELFSectionSizer<ELFT>::visit(DecompressedSection &Sec) {}
 
 void BinarySectionWriter::visit(const SectionIndexSection &Sec) {
-  error("Cannot write symbol section index table '" + Sec.Name + "' ");
+  error("cannot write symbol section index table '" + Sec.Name + "' ");
 }
 
 void BinarySectionWriter::visit(const SymbolTableSection &Sec) {
-  error("Cannot write symbol table '" + Sec.Name + "' out to binary");
+  error("cannot write symbol table '" + Sec.Name + "' out to binary");
 }
 
 void BinarySectionWriter::visit(const RelocationSection &Sec) {
-  error("Cannot write relocation section '" + Sec.Name + "' out to binary");
+  error("cannot write relocation section '" + Sec.Name + "' out to binary");
 }
 
 void BinarySectionWriter::visit(const GnuDebugLinkSection &Sec) {
-  error("Cannot write '" + Sec.Name + "' out to binary");
+  error("cannot write '" + Sec.Name + "' out to binary");
 }
 
 void BinarySectionWriter::visit(const GroupSection &Sec) {
-  error("Cannot write '" + Sec.Name + "' out to binary");
+  error("cannot write '" + Sec.Name + "' out to binary");
 }
 
 void SectionWriter::visit(const Section &Sec) {
   if (Sec.Type == SHT_NOBITS)
     return;
   uint8_t *Buf = Out.getBufferStart() + Sec.Offset;
   llvm::copy(Sec.Contents, Buf);
 }
if (Error E = zlib::uncompress(CompressedContent, DecompressedContent,
                                  static_cast<size_t>(Sec.Size)))
     reportError(Sec.Name, std::move(E));
 
   uint8_t *Buf = Out.getBufferStart() + Sec.Offset;
   std::copy(DecompressedContent.begin(), DecompressedContent.end(), Buf);
 }
 
 void BinarySectionWriter::visit(const DecompressedSection &Sec) {
-  error("Cannot write compressed section '" + Sec.Name + "' ");
+  error("cannot write compressed section '" + Sec.Name + "' ");
 }
 
 void DecompressedSection::accept(SectionVisitor &Visitor) const {
   Visitor.visit(*this);
 }
 
 void DecompressedSection::accept(MutableSectionVisitor &Visitor) {
   Visitor.visit(*this);
 }
 
 void OwnedDataSection::accept(SectionVisitor &Visitor) const {
   Visitor.visit(*this);
 }
 
 void OwnedDataSection::accept(MutableSectionVisitor &Visitor) {
   Visitor.visit(*this);
 }
 
 void BinarySectionWriter::visit(const CompressedSection &Sec) {
-  error("Cannot write compressed section '" + Sec.Name + "' ");
+  error("cannot write compressed section '" + Sec.Name + "' ");
 }
 
 template <class ELFT>
 void ELFSectionWriter<ELFT>::visit(const CompressedSection &Sec) {
   uint8_t *Buf = Out.getBufferStart();
   Buf += Sec.Offset;
 
   if (Sec.CompressionType == DebugCompressionType::None) {
Error SymbolTableSection::removeSectionReferences(
     bool AllowBrokenLinks,
     function_ref<bool(const SectionBase *)> ToRemove) {
   if (ToRemove(SectionIndexTable))
     SectionIndexTable = nullptr;
   if (ToRemove(SymbolNames)) {
     if (!AllowBrokenLinks)
       return createStringError(
           llvm::errc::invalid_argument,
-          "String table %s cannot be removed because it is "
-          "referenced by the symbol table %s",
+          "string table '%s' cannot be removed because it is "
+          "referenced by the symbol table '%s'",
           SymbolNames->Name.data(), this->Name.data());
     SymbolNames = nullptr;
   }
   return removeSymbols(
       [ToRemove](const Symbol &Sym) { return ToRemove(Sym.DefinedIn); });
 }
 
 void SymbolTableSection::updateSymbols(function_ref<void(Symbol &)> Callable) {
if (Sym->DefinedIn != nullptr && Sym->DefinedIn->Index >= SHN_LORESERVE)
       SectionIndexTable->addIndex(Sym->DefinedIn->Index);
     else
       SectionIndexTable->addIndex(SHN_UNDEF);
   }
 }
 
 const Symbol *SymbolTableSection::getSymbolByIndex(uint32_t Index) const {
   if (Symbols.size() <= Index)
-    error("Invalid symbol index: " + Twine(Index));
+    error("invalid symbol index: " + Twine(Index));
   return Symbols[Index].get();
 }
 
 Symbol *SymbolTableSection::getSymbolByIndex(uint32_t Index) {
   return const_cast<Symbol *>(
       static_cast<const SymbolTableSection *>(this)->getSymbolByIndex(Index));
 }
 

 
 Error RelocationSection::removeSectionReferences(
     bool AllowBrokenLinks,
     function_ref<bool(const SectionBase *)> ToRemove) {
   if (ToRemove(Symbols)) {
     if (!AllowBrokenLinks)
       return createStringError(
           llvm::errc::invalid_argument,
-          "Symbol table %s cannot be removed because it is "
-          "referenced by the relocation section %s.",
+          "symbol table '%s' cannot be removed because it is "
+          "referenced by the relocation section '%s'",
           Symbols->Name.data(), this->Name.data());
     Symbols = nullptr;
   }
 
   for (const Relocation &R : Relocations) {
     if (!R.RelocSymbol->DefinedIn || !ToRemove(R.RelocSymbol->DefinedIn))
       continue;
     return createStringError(llvm::errc::invalid_argument,
-                             "Section %s can't be removed: (%s+0x%" PRIx64
+                             "section '%s' cannot be removed: (%s+0x%" PRIx64
                              ") has relocation against symbol '%s'",
                              R.RelocSymbol->DefinedIn->Name.data(),
                              SecToApplyRel->Name.data(), R.Offset,
                              R.RelocSymbol->Name.c_str());
   }
 
   return Error::success();
 }

 }
 
 Error RelocationSection::removeSymbols(
     function_ref<bool(const Symbol &)> ToRemove) {
   for (const Relocation &Reloc : Relocations)
     if (ToRemove(*Reloc.RelocSymbol))
       return createStringError(
           llvm::errc::invalid_argument,
-          "not stripping symbol '%s' because it is named in a relocation.",
+          "not stripping symbol '%s' because it is named in a relocation",
           Reloc.RelocSymbol->Name.data());
   return Error::success();
 }
 
 void RelocationSection::markSymbols() {
   for (const Relocation &Reloc : Relocations)
     Reloc.RelocSymbol->Referenced = true;
 }
llvm::copy(Sec.Contents,
             Out.getBufferStart() + Sec.Offset);
 }
 
 void DynamicRelocationSection::accept(SectionVisitor &Visitor) const {
   Visitor.visit(*this);
 }
 
 void DynamicRelocationSection::accept(MutableSectionVisitor &Visitor) {
-  Visitor.visit(*this);
-}
-
-Error DynamicRelocationSection::removeSectionReferences(
-    bool AllowBrokenLinks, function_ref<bool(const SectionBase *)> ToRemove) {
-  if (ToRemove(Symbols)) {
-    if (!AllowBrokenLinks)
-      return createStringError(
-          llvm::errc::invalid_argument,
-          "Symbol table %s cannot be removed because it is "
-          "referenced by the relocation section %s.",
-          Symbols->Name.data(), this->Name.data());
-    Symbols = nullptr;
-  }
-
-  // SecToApplyRel contains a section referenced by sh_info field. It keeps
-  // a section to which the relocation section applies. When we remove any
-  // sections we also remove their relocation sections. Since we do that much
-  // earlier, this assert should never be triggered.
-  assert(!SecToApplyRel || !ToRemove(SecToApplyRel));
-
-  return Error::success();
-}
-
-Error Section::removeSectionReferences(bool AllowBrokenDependency,
-    function_ref<bool(const SectionBase *)> ToRemove) {
-  if (ToRemove(LinkSection)) {
+  Visitor.visit(*this);
+}
+
+Error DynamicRelocationSection::removeSectionReferences(
+    bool AllowBrokenLinks, function_ref<bool(const SectionBase *)> ToRemove) {
+  if (ToRemove(Symbols)) {
+    if (!AllowBrokenLinks)
+      return createStringError(
+          llvm::errc::invalid_argument,
+          "symbol table '%s' cannot be removed because it is "
+          "referenced by the relocation section '%s'",
+          Symbols->Name.data(), this->Name.data());
+    Symbols = nullptr;
+  }
+
+  // SecToApplyRel contains a section referenced by sh_info field. It keeps
+  // a section to which the relocation section applies. When we remove any
+  // sections we also remove their relocation sections. Since we do that much
+  // earlier, this assert should never be triggered.
+  assert(!SecToApplyRel || !ToRemove(SecToApplyRel));
+
+  return Error::success();
+}
+
+Error Section::removeSectionReferences(bool AllowBrokenDependency,
+    function_ref<bool(const SectionBase *)> ToRemove) {
+  if (ToRemove(LinkSection)) {
     if (!AllowBrokenDependency)
       return createStringError(llvm::errc::invalid_argument,
-                               "Section %s cannot be removed because it is "
-                               "referenced by the section %s",
+                               "section '%s' cannot be removed because it is "
+                               "referenced by the section '%s'",
                                LinkSection->Name.data(), this->Name.data());
     LinkSection = nullptr;
   }
   return Error::success();
 }
 
 void GroupSection::finalize() {
   this->Info = Sym->Index;
   this->Link = SymTab->Index;
 }
 
 Error GroupSection::removeSymbols(function_ref<bool(const Symbol &)> ToRemove) {
   if (ToRemove(*Sym))
     return createStringError(llvm::errc::invalid_argument,
-                             "Symbol %s cannot be removed because it is "
-                             "referenced by the section %s[%d].",
+                             "symbol '%s' cannot be removed because it is "
+                             "referenced by the section '%s[%d]'",
                              Sym->Name.data(), this->Name.data(), this->Index);
   return Error::success();
 }
 
 void GroupSection::markSymbols() {
   if (Sym)
     Sym->Referenced = true;
 }
for (auto &Child : Obj.segments())
     setParentSegment(Child);
   setParentSegment(ElfHdr);
   setParentSegment(PrHdr);
 }
 
 template <class ELFT>
 void ELFBuilder<ELFT>::initGroupSection(GroupSection *GroupSec) {
   if (GroupSec->Align % sizeof(ELF::Elf32_Word) != 0)
-    error("Invalid alignment " + Twine(GroupSec->Align) + " of group section " +
-          GroupSec->Name);
+    error("invalid alignment " + Twine(GroupSec->Align) + " of group section '" +
+          GroupSec->Name + "'");
   auto SecTable = Obj.sections();
   auto SymTab = SecTable.template getSectionOfType<SymbolTableSection>(
       GroupSec->Link,
-      "Link field value " + Twine(GroupSec->Link) + " in section " +
-          GroupSec->Name + " is invalid",
-      "Link field value " + Twine(GroupSec->Link) + " in section " +
-          GroupSec->Name + " is not a symbol table");
+      "link field value '" + Twine(GroupSec->Link) + "' in section '" +
+          GroupSec->Name + "' is invalid",
+      "link field value '" + Twine(GroupSec->Link) + "' in section '" +
+          GroupSec->Name + "' is not a symbol table");
   auto Sym = SymTab->getSymbolByIndex(GroupSec->Info);
   if (!Sym)
-    error("Info field value " + Twine(GroupSec->Info) + " in section " +
-          GroupSec->Name + " is not a valid symbol index");
+    error("info field value '" + Twine(GroupSec->Info) + "' in section '" +
+          GroupSec->Name + "' is not a valid symbol index");
   GroupSec->setSymTab(SymTab);
   GroupSec->setSymbol(Sym);
   if (GroupSec->Contents.size() % sizeof(ELF::Elf32_Word) ||
       GroupSec->Contents.empty())
-    error("The content of the section " + GroupSec->Name + " is malformed");
+    error("the content of the section " + GroupSec->Name + " is malformed");
   const ELF::Elf32_Word *Word =
       reinterpret_cast<const ELF::Elf32_Word *>(GroupSec->Contents.data());
   const ELF::Elf32_Word *End =
       Word + GroupSec->Contents.size() / sizeof(ELF::Elf32_Word);
   GroupSec->setFlagWord(*Word++);
   for (; Word != End; ++Word) {
     uint32_t Index = support::endian::read32<ELFT::TargetEndianness>(Word);
     GroupSec->addMember(SecTable.getSection(
-        Index, "Group member index " + Twine(Index) + " in section " +
-                   GroupSec->Name + " is invalid"));
+        Index, "group member index " + Twine(Index) + " in section '" +
+                   GroupSec->Name + "' is invalid"));
   }
 }
 
 template <class ELFT>
 void ELFBuilder<ELFT>::initSymbolTable(SymbolTableSection *SymTab) {
   const Elf_Shdr &Shdr = *unwrapOrError(ElfFile.getSection(SymTab->Index));
   StringRef StrTabData = unwrapOrError(ElfFile.getStringTableForSymtab(Shdr));
   ArrayRef<Elf_Word> ShndxData;
 
   auto Symbols = unwrapOrError(ElfFile.symbols(&Shdr));
   for (const auto &Sym : Symbols) {
     SectionBase *DefSection = nullptr;
     StringRef Name = unwrapOrError(Sym.getName(StrTabData));
 
     if (Sym.st_shndx == SHN_XINDEX) {
       if (SymTab->getShndxTable() == nullptr)
-        error("Symbol '" + Name +
-              "' has index SHN_XINDEX but no SHT_SYMTAB_SHNDX section exists.");
+        error("symbol '" + Name +
+              "' has index SHN_XINDEX but no SHT_SYMTAB_SHNDX section exists");
       if (ShndxData.data() == nullptr) {
         const Elf_Shdr &ShndxSec =
             *unwrapOrError(ElfFile.getSection(SymTab->getShndxTable()->Index));
         ShndxData = unwrapOrError(
             ElfFile.template getSectionContentsAsArray<Elf_Word>(&ShndxSec));
         if (ShndxData.size() != Symbols.size())
-          error("Symbol section index table does not have the same number of "
-                "entries as the symbol table.");
+          error("symbol section index table does not have the same number of "
+                "entries as the symbol table");
       }
       Elf_Word Index = ShndxData[&Sym - Symbols.begin()];
       DefSection = Obj.sections().getSection(
           Index,
-          "Symbol '" + Name + "' has invalid section index " + Twine(Index));
+          "symbol '" + Name + "' has invalid section index " + Twine(Index));
     } else if (Sym.st_shndx >= SHN_LORESERVE) {
       if (!isValidReservedSectionIndex(Sym.st_shndx, Obj.Machine)) {
         error(
-            "Symbol '" + Name +
+            "symbol '" + Name +
             "' has unsupported value greater than or equal to SHN_LORESERVE: " +
             Twine(Sym.st_shndx));
       }
     } else if (Sym.st_shndx != SHN_UNDEF) {
       DefSection = Obj.sections().getSection(
-          Sym.st_shndx, "Symbol '" + Name +
+          Sym.st_shndx, "symbol '" + Name +
                             "' is defined has invalid section index " +
                             Twine(Sym.st_shndx));
     }
 
     SymTab->addSymbol(Name, Sym.getBinding(), Sym.getType(), DefSection,
                       Sym.getValue(), Sym.st_other, Sym.st_shndx, Sym.st_size);
   }
 }
if (auto *O = dyn_cast<ELFObjectFile<ELF32LE>>(Bin)) {
     ELFBuilder<ELF32BE> Builder(*O, *Obj);
     Builder.build();
     return Obj;
   } else if (auto *O = dyn_cast<ELFObjectFile<ELF64BE>>(Bin)) {
     ELFBuilder<ELF64BE> Builder(*O, *Obj);
     Builder.build();
     return Obj;
   }
-  error("Invalid file type");
+  error("invalid file type");
 }
 
 template <class ELFT> void ELFWriter<ELFT>::writeEhdr() {
   uint8_t *B = Buf.getBufferStart();
   Elf_Ehdr &Ehdr = *reinterpret_cast<Elf_Ehdr *>(B);
   std::fill(Ehdr.e_ident, Ehdr.e_ident + 16, 0);
   Ehdr.e_ident[EI_MAG0] = 0x7f;
   Ehdr.e_ident[EI_MAG1] = 'E';

 }
 
 template <class ELFT> Error ELFWriter<ELFT>::finalize() {
   // It could happen that SectionNames has been removed and yet the user wants
   // a section header table output. We need to throw an error if a user tries
   // to do that.
   if (Obj.SectionNames == nullptr && WriteSectionHeaders)
     return createStringError(llvm::errc::invalid_argument,
-                             "Cannot write section header table because "
-                             "section header string table was removed.");
+                             "cannot write section header table because "
+                             "section header string table was removed");
 
   Obj.sortSections();
 
   // We need to assign indexes before we perform layout because we need to know
   // if we need large indexes or not. We can assign indexes first and check as
   // we go to see if we will actully need large indexes.
   bool NeedsLargeIndexes = false;
   if (Obj.sections().size() >= SHN_LORESERVE) {