[LLD] Fix Clang-tidy modernize-use-emplace and Include What You Use warnings; other minor fixes

[Eugene.Zelenko]

Summary

I checked this patch on my own build on RHEL 6. Regressions were OK.

[• rafael]

I don't think we follow include-what-you-use in llvm/lld.

The emplace_back part is probably fine.

There are also other changes in the patch, like whitespace and adding
closing comments to namespaces. I am also not sold on their value.

COFF/Driver.cpp

 #include "SymbolTable.h"
 #include "Symbols.h"
 #include "Writer.h"
+#include "lld/Core/LLVM.h"
 #include "lld/Driver/Driver.h"
+#include "llvm/ADT/None.h"
 #include "llvm/ADT/Optional.h"
+#include "llvm/ADT/SmallString.h"
+#include "llvm/ADT/SmallVector.h"
+#include "llvm/ADT/Twine.h"
 #include "llvm/LibDriver/LibDriver.h"
 #include "llvm/Option/Arg.h"
 #include "llvm/Option/ArgList.h"
 #include "llvm/Option/Option.h"
+#include "llvm/Support/Casting.h"
 #include "llvm/Support/Debug.h"
+#include "llvm/Support/FileSystem.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/Process.h"
 #include "llvm/Support/TargetSelect.h"
 #include "llvm/Support/raw_ostream.h"
 #include <algorithm>
+#include <cassert>
+#include <cstdlib>
 #include <memory>
+#include <system_error>
+#include <tuple>
 
 using namespace llvm;
 using namespace llvm::COFF;

     error("no input files.");
 
   // Construct search path list.
-  SearchPaths.push_back("");
+  SearchPaths.emplace_back("");
   for (auto *Arg : Args.filtered(OPT_libpath))
-    SearchPaths.push_back(Arg->getValue());
+    SearchPaths.emplace_back(Arg->getValue());
   addLibSearchPaths();
 
   // Handle /out

ELF/Driver.cpp

 #include "Target.h"
 #include "Writer.h"
 #include "lld/Driver/Driver.h"
+#include "llvm/ADT/None.h"
+#include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/ADT/StringSwitch.h"
+#include "llvm/Object/Archive.h"
+#include "llvm/Object/ELFTypes.h"
+#include "llvm/Support/Casting.h"
+#include "llvm/Support/CommandLine.h"
+#include "llvm/Support/ELF.h"
+#include "llvm/Support/ErrorOr.h"
+#include "llvm/Support/FileSystem.h"
 #include "llvm/Support/TargetSelect.h"
 #include "llvm/Support/raw_ostream.h"
+#include <algorithm>
+#include <cstdint>
 #include <cstdlib>
+#include <tuple>
 #include <utility>
 
 using namespace llvm;

 // Initializes Config members by the command line options.
 void LinkerDriver::readConfigs(opt::InputArgList &Args) {
   for (auto *Arg : Args.filtered(OPT_L))
-    Config->SearchPaths.push_back(Arg->getValue());
+    Config->SearchPaths.emplace_back(Arg->getValue());
 
   std::vector<StringRef> RPaths;
   for (auto *Arg : Args.filtered(OPT_rpath))
-    RPaths.push_back(Arg->getValue());
+    RPaths.emplace_back(Arg->getValue());
   if (!RPaths.empty())
     Config->RPath = llvm::join(RPaths.begin(), RPaths.end(), ":");
 

   }
 
   for (auto *Arg : Args.filtered(OPT_undefined))
-    Config->Undefined.push_back(Arg->getValue());
+    Config->Undefined.emplace_back(Arg->getValue());
 
   if (auto *Arg = Args.getLastArg(OPT_dynamic_list))
     if (Optional<MemoryBufferRef> Buffer = readFile(Arg->getValue()))
       parseDynamicList(*Buffer);
 
   for (auto *Arg : Args.filtered(OPT_export_dynamic_symbol))
-    Config->DynamicList.push_back(Arg->getValue());
+    Config->DynamicList.emplace_back(Arg->getValue());
 
   if (auto *Arg = Args.getLastArg(OPT_version_script)) {
     if (Optional<MemoryBufferRef> Buffer = readFile(Arg->getValue()))

ELF/InputFiles.cpp

 #include "InputSection.h"
 #include "SymbolTable.h"
 #include "Symbols.h"
+#include "llvm/ADT/SmallString.h"
 #include "llvm/ADT/STLExtras.h"
+#include "llvm/ADT/iterator_range.h"
 #include "llvm/CodeGen/Analysis.h"
+#include "llvm/IR/DataLayout.h"
+#include "llvm/IR/GlobalValue.h"
 #include "llvm/IR/LLVMContext.h"
 #include "llvm/IR/Module.h"
+#include "llvm/Object/SymbolicFile.h"
+#include "llvm/Support/Casting.h"
+#include "llvm/Support/Endian.h"
+#include "llvm/Support/ErrorHandling.h"
+#include "llvm/Support/FileSystem.h"
 #include "llvm/Support/raw_ostream.h"
+#include <algorithm>
+#include <cassert>
+#include <cstdint>
+#include <iterator>
+#include <system_error>
+#include <tuple>
 
 using namespace llvm;
 using namespace llvm::ELF;

     SmallString<64> Name;
     raw_svector_ostream OS(Name);
     Sym.printName(OS);
-    V.push_back(Saver.save(StringRef(Name)));
+    V.emplace_back(Saver.save(StringRef(Name)));
   }
   return V;
 }

ELF/OutputSections.cpp

 #include "OutputSections.h"
 #include "Config.h"
 #include "EhFrame.h"
+#include "Error.h"
+#include "InputFiles.h"
+#include "InputSection.h"
 #include "LinkerScript.h"
+#include "Symbols.h"
 #include "SymbolTable.h"
 #include "Target.h"
 #include "lld/Core/Parallel.h"
+#include "llvm/ADT/DenseMapInfo.h"
+#include "llvm/Support/Casting.h"
 #include "llvm/Support/Dwarf.h"
+#include "llvm/Support/ELF.h"
+#include "llvm/Support/Endian.h"
+#include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/MD5.h"
 #include "llvm/Support/MathExtras.h"
 #include "llvm/Support/SHA1.h"
-#include <map>
+#include <algorithm>
+#include <cassert>
+#include <cstring>
+#include <iterator>
+#include <memory>
 
 using namespace llvm;
 using namespace llvm::dwarf;

 template <class ELFT> void PltSection<ELFT>::addEntry(SymbolBody &Sym) {
   Sym.PltIndex = Entries.size();
   unsigned RelOff = Out<ELFT>::RelaPlt->getRelocOffset();
-  Entries.push_back(std::make_pair(&Sym, RelOff));
+  Entries.emplace_back(&Sym, RelOff);
 }
 
 template <class ELFT> void PltSection<ELFT>::finalize() {

 
   V.erase(Mid, V.end());
   for (const SymbolData &Sym : Symbols)
-    V.push_back({Sym.Body, Sym.STName});
+    V.emplace_back(Sym.Body, Sym.STName);
 }
 
 // Returns the number of version definition entries. Because the first entry

 
   std::vector<Pair> V;
   for (InputSection<ELFT> *S : Sections)
-    V.push_back({getPriority(S->getSectionName()), S});
+    V.emplace_back(getPriority(S->getSectionName()), S);
   std::stable_sort(V.begin(), V.end(), Comp);
   Sections.clear();
   for (Pair &P : V)

 
 template <class ELFT>
 void SymbolTableSection<ELFT>::addSymbol(SymbolBody *B) {
-  Symbols.push_back({B, StrTabSec.addString(B->getName(), false)});
+  Symbols.emplace_back(B, StrTabSec.addString(B->getName(), false));
 }
 
 template <class ELFT> void SymbolTableSection<ELFT>::writeTo(uint8_t *Buf) {

   // to create one by adding it to our needed list and creating a dynstr entry
   // for the soname.
   if (F->VerdefMap.empty())
-    Needed.push_back({F, Out<ELFT>::DynStrTab->addString(F->getSoName())});
+    Needed.emplace_back(F, Out<ELFT>::DynStrTab->addString(F->getSoName()));
   typename SharedFile<ELFT>::NeededVer &NV = F->VerdefMap[SS->Verdef];
   // If we don't already know that we need an Elf_Vernaux for this Elf_Verdef,
   // prepare to create one by allocating a version identifier and creating a

 
 namespace lld {
 namespace elf {
+
 template class OutputSectionBase<ELF32LE>;
 template class OutputSectionBase<ELF32BE>;
 template class OutputSectionBase<ELF64LE>;

 template class BuildIdHexstring<ELF32BE>;
 template class BuildIdHexstring<ELF64LE>;
 template class BuildIdHexstring<ELF64BE>;
-}
-}
+
+} // namespace elf
+} // namespace lld

ELF/Writer.cpp

 
 #include "Writer.h"
 #include "Config.h"
+#include "Error.h"
+#include "InputFiles.h"
+#include "InputSection.h"
 #include "LinkerScript.h"
 #include "OutputSections.h"
 #include "Relocations.h"
+#include "Symbols.h"
 #include "SymbolTable.h"
 #include "Target.h"
-
-#include "llvm/ADT/StringMap.h"
+#include "llvm/ADT/ArrayRef.h"
+#include "llvm/ADT/DenseMap.h"
+#include "llvm/ADT/DenseMapInfo.h"
+#include "llvm/ADT/Hashing.h"
+#include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/StringSwitch.h"
+#include "llvm/Support/Allocator.h"
+#include "llvm/Support/Casting.h"
+#include "llvm/Support/ELF.h"
+#include "llvm/Support/Endian.h"
+#include "llvm/Support/ErrorOr.h"
 #include "llvm/Support/FileOutputBuffer.h"
+#include "llvm/Support/MathExtras.h"
 #include "llvm/Support/StringSaver.h"
 #include "llvm/Support/raw_ostream.h"
+#include <algorithm>
+#include <cassert>
+#include <cstdint>
+#include <cstring>
+#include <memory>
+#include <string>
+#include <tuple>
+#include <type_traits>
+#include <utility>
+#include <vector>
 
 using namespace llvm;
 using namespace llvm::ELF;

   typedef typename ELFT::Sym Elf_Sym;
   typedef typename ELFT::SymRange Elf_Sym_Range;
   typedef typename ELFT::Rela Elf_Rela;
+
   Writer(SymbolTable<ELFT> &S) : Symtab(S) {}
   void run();
 

   void writeBuildId();
   bool isDiscarded(InputSectionBase<ELFT> *IS) const;
   StringRef getOutputSectionName(InputSectionBase<ELFT> *S) const;
+
   bool needsInterpSection() const {
     return !Symtab.getSharedFiles().empty() && !Config->DynamicLinker.empty();
   }
+
   bool isOutputDynamic() const {
     return !Symtab.getSharedFiles().empty() || Config->Pic;
   }

   uintX_t Flags;
   uintX_t Alignment;
 };
-}
+} // anonymous namespace
+
 namespace llvm {
 template <bool Is64Bits> struct DenseMapInfo<SectionKey<Is64Bits>> {
   static SectionKey<Is64Bits> getEmptyKey() {
     return SectionKey<Is64Bits>{DenseMapInfo<StringRef>::getEmptyKey(), 0, 0,
                                 0};
   }
+
   static SectionKey<Is64Bits> getTombstoneKey() {
     return SectionKey<Is64Bits>{DenseMapInfo<StringRef>::getTombstoneKey(), 0,
                                 0, 0};
   }
+
   static unsigned getHashValue(const SectionKey<Is64Bits> &Val) {
     return hash_combine(Val.Name, Val.Type, Val.Flags, Val.Alignment);
   }
+
   static bool isEqual(const SectionKey<Is64Bits> &LHS,
                       const SectionKey<Is64Bits> &RHS) {
     return DenseMapInfo<StringRef>::isEqual(LHS.Name, RHS.Name) &&

            LHS.Alignment == RHS.Alignment;
   }
 };
-}
+} // namespace llvm
 
 template <class ELFT>
 static void reportUndefined(SymbolTable<ELFT> &Symtab, SymbolBody *Sym) {

       ++Out<ELFT>::SymTab->NumLocals;
       if (Config->Relocatable)
         B->DynsymIndex = Out<ELFT>::SymTab->NumLocals;
-      F->KeptLocalSyms.push_back(
-          std::make_pair(DR, Out<ELFT>::SymTab->StrTabSec.addString(SymName)));
+      F->KeptLocalSyms.emplace_back(
+          DR, Out<ELFT>::SymTab->StrTabSec.addString(SymName));
     }
   }
 }

 
   SmallDenseMap<SectionKey<ELFT::Is64Bits>, OutputSectionBase<ELFT> *> Map;
 };
-}
+} // anonymous namespace
 
 template <class ELFT>
 std::pair<OutputSectionBase<ELFT> *, bool>

   for (OutputSectionBase<ELFT> *Sec : OutputSections) {
     uint8_t *End = Start + Sec->getFileOff();
     if (!Sec->getName().startswith(".debug_"))
-      Regions.push_back({Last, End});
+      Regions.emplace_back(Last, End);
     Last = End;
   }
-  Regions.push_back({Last, Start + FileSize});
+  Regions.emplace_back(Last, Start + FileSize);
   S->writeBuildId(Regions);
 }
 

lib/Driver/DarwinLdDriver.cpp

 //===----------------------------------------------------------------------===//
 
 #include "lld/Core/ArchiveLibraryFile.h"
+#include "lld/Core/Error.h"
 #include "lld/Core/File.h"
 #include "lld/Core/Instrumentation.h"
+#include "lld/Core/LinkingContext.h"
+#include "lld/Core/Node.h"
 #include "lld/Core/PassManager.h"
 #include "lld/Core/Resolver.h"
 #include "lld/Core/SharedLibraryFile.h"
+#include "lld/Core/Simple.h"
 #include "lld/Driver/Driver.h"
 #include "lld/ReaderWriter/MachOLinkingContext.h"
 #include "llvm/ADT/ArrayRef.h"
+#include "llvm/ADT/Optional.h"
+#include "llvm/ADT/SmallString.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/StringExtras.h"
-#include "llvm/ADT/Triple.h"
+#include "llvm/ADT/StringRef.h"
+#include "llvm/ADT/Twine.h"
 #include "llvm/Option/Arg.h"
+#include "llvm/Option/ArgList.h"
 #include "llvm/Option/Option.h"
+#include "llvm/Option/OptTable.h"
+#include "llvm/Support/Casting.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Error.h"
+#include "llvm/Support/ErrorOr.h"
 #include "llvm/Support/Format.h"
+#include "llvm/Support/MachO.h"
+#include "llvm/Support/MathExtras.h"
+#include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/raw_ostream.h"
+#include <algorithm>
+#include <cstdint>
+#include <memory>
+#include <string>
+#include <system_error>
+#include <utility>
+#include <vector>
 
 using namespace lld;
 

   return std::error_code();
 }
 
-
-
 /// Order files are one symbol per line. Blank lines are ignored.
 /// Trailing comments start with #. Symbol names can be prefixed with an
 /// architecture name and/or .o leaf name.  Examples:

   //   4. If { syslibroots } x path ==  {}, the original path is kept.
   std::vector<StringRef> sysLibRoots;
   for (auto syslibRoot : parsedArgs.filtered(OPT_syslibroot)) {
-    sysLibRoots.push_back(syslibRoot->getValue());
+    sysLibRoots.emplace_back(syslibRoot->getValue());
   }
   if (!sysLibRoots.empty()) {
     // Ignore all if last -syslibroot is "/".

 
   return true;
 }
+
 } // namespace mach_o
 } // namespace lld

lib/ReaderWriter/MachO/CompactUnwindPass.cpp

 #include "ArchHandler.h"
 #include "File.h"
 #include "MachONormalizedFileBinaryUtils.h"
-#include "MachOPasses.h"
 #include "lld/Core/DefinedAtom.h"
-#include "lld/Core/File.h"
 #include "lld/Core/LLVM.h"
+#include "lld/Core/Pass.h"
+#include "lld/Core/PassManager.h"
 #include "lld/Core/Reference.h"
 #include "lld/Core/Simple.h"
-#include "llvm/ADT/DenseMap.h"
+#include "lld/ReaderWriter/MachOLinkingContext.h"
+#include "llvm/ADT/ArrayRef.h"
+#include "llvm/ADT/STLExtras.h"
+#include "llvm/Support/Casting.h"
 #include "llvm/Support/Debug.h"
-#include "llvm/Support/Format.h"
+#include "llvm/Support/Error.h"
+#include <algorithm>
+#include <cassert>
+#include <cstdint>
+#include <map>
+#include <set>
+#include <utility>
+#include <vector>
 
 #define DEBUG_TYPE "macho-compact-unwind"
 

 struct UnwindInfoPage {
   ArrayRef<CompactUnwindEntry> entries;
 };
-}
+} // end anonymous namespace
 
 class UnwindInfoAtom : public SimpleDefinedAtom {
 public:

     std::vector<UnwindInfoPage> pages;
     auto remainingInfos = llvm::makeArrayRef(unwindInfos);
     do {
-      pages.push_back(UnwindInfoPage());
+      pages.emplace_back();
 
       // FIXME: we only create regular pages at the moment. These can hold up to
       // 1021 entries according to the documentation.

 
     // Finally, delete all unreferenced CFI atoms.
     mergedFile.removeDefinedAtomsIf([&](const DefinedAtom *atom) {
-      if ((atom->contentType() == DefinedAtom::typeCFI) &&
-          !usedDwarfFrames.count(atom))
-        return true;
-      return false;
+      return ((atom->contentType() == DefinedAtom::typeCFI) &&
+              !usedDwarfFrames.count(atom));
     });
   }
 

     } else
       entry = unwindLoc->second;
 
-
     // If there's no __compact_unwind entry, or it explicitly says to use
     // __eh_frame, we need to try and fill in the correct DWARF atom.
     if (entry.encoding == _archHandler.dwarfCompactUnwindType() ||

   pm.add(llvm::make_unique<CompactUnwindPass>(ctx));
 }
 
-} // end namesapce mach_o
-} // end namesapce lld
+} // end namespace mach_o
+} // end namespace lld

lib/ReaderWriter/MachO/MachONormalizedFileBinaryReader.cpp

 
 #include "MachONormalizedFile.h"
 #include "ArchHandler.h"
+#include "File.h"
 #include "MachONormalizedFileBinaryUtils.h"
 #include "lld/Core/Error.h"
-#include "lld/Core/LLVM.h"
-#include "lld/Core/SharedLibraryFile.h"
-#include "llvm/ADT/SmallString.h"
+#include "lld/Core/Reader.h"
+#include "lld/Core/Reference.h"
+#include "lld/ReaderWriter/MachOLinkingContext.h"
+#include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/StringRef.h"
-#include "llvm/ADT/StringSwitch.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/Twine.h"
 #include "llvm/Object/MachO.h"
-#include "llvm/Support/Casting.h"
 #include "llvm/Support/Errc.h"
-#include "llvm/Support/ErrorHandling.h"
-#include "llvm/Support/FileOutputBuffer.h"
+#include "llvm/Support/Error.h"
+#include "llvm/Support/ErrorOr.h"
+#include "llvm/Support/FileSystem.h"
 #include "llvm/Support/Host.h"
 #include "llvm/Support/MachO.h"
 #include "llvm/Support/MemoryBuffer.h"
-#include "llvm/Support/raw_ostream.h"
+#include "llvm/Support/SwapByteOrder.h"
+#include <algorithm>
+#include <cstdint>
+#include <cstring>
 #include <functional>
+#include <memory>
 #include <system_error>
 
 using namespace llvm::MachO;

   return std::error_code();
 }
 
-
 template <typename T> static T readBigEndian(T t) {
   if (llvm::sys::IsLittleEndianHost)
     llvm::sys::swapByteOrder(t);
   return t;
 }
 
-
 static bool isMachOHeader(const mach_header *mh, bool &is64, bool &isBig) {
   switch (read32(&mh->magic, false)) {
   case llvm::MachO::MH_MAGIC:

   }
 }
 
-
 bool isThinObjectFile(StringRef path, MachOLinkingContext::Arch &arch) {
   // Try opening and mapping file at path.
   ErrorOr<std::unique_ptr<MemoryBuffer>> b = MemoryBuffer::getFileOrSTDIN(path);

       break;
     case LC_RPATH: {
       const rpath_command *rpc = reinterpret_cast<const rpath_command *>(lc);
-      f->rpaths.push_back(lc + read32(&rpc->path, isBig));
+      f->rpaths.emplace_back(lc + read32(&rpc->path, isBig));
      }
       break;
     case LC_DYLD_INFO:

                            new mach_o::MachOYamlIOTaggedDocumentHandler(arch)));
 }
 
-
 } // namespace lld

lib/ReaderWriter/MachO/MachONormalizedFileYAML.cpp

 
 #include "MachONormalizedFile.h"
 #include "lld/Core/Error.h"
-#include "lld/Core/LLVM.h"
+#include "lld/ReaderWriter/MachOLinkingContext.h"
 #include "lld/ReaderWriter/YamlContext.h"
-#include "llvm/ADT/SmallString.h"
+#include "llvm/ADT/ArrayRef.h"
+#include "llvm/ADT/None.h"
 #include "llvm/ADT/StringRef.h"
-#include "llvm/ADT/StringSwitch.h"
 #include "llvm/ADT/Twine.h"
-#include "llvm/Support/Casting.h"
+#include "llvm/Support/Error.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/Format.h"
 #include "llvm/Support/MachO.h"
+#include "llvm/Support/MathExtras.h"
 #include "llvm/Support/MemoryBuffer.h"
-#include "llvm/Support/SourceMgr.h"
 #include "llvm/Support/YAMLTraits.h"
 #include "llvm/Support/raw_ostream.h"
+#include <algorithm>
+#include <cassert>
+#include <cstddef>
+#include <cstdint>
+#include <memory>
+#include <string>
 #include <system_error>
+#include <vector>
 
-
 using llvm::StringRef;
 using namespace llvm::yaml;
 using namespace llvm::MachO;

 LLVM_YAML_IS_SEQUENCE_VECTOR(StringRef)
 LLVM_YAML_IS_SEQUENCE_VECTOR(DataInCode)
 
-
 // for compatibility with gcc-4.7 in C++11 mode, add extra namespace
 namespace llvm {
 namespace yaml {

   static size_t size(IO &io, std::vector<Section> &seq) {
     return seq.size();
   }
+
   static Section& element(IO &io, std::vector<Section> &seq, size_t index) {
     if ( index >= seq.size() )
       seq.resize(index+1);

   static size_t size(IO &io, std::vector<Symbol> &seq) {
     return seq.size();
   }
+
   static Symbol& element(IO &io, std::vector<Symbol> &seq, size_t index) {
     if ( index >= seq.size() )
       seq.resize(index+1);

   static size_t size(IO &io, Relocations &seq) {
     return seq.size();
   }
+
   static Relocation& element(IO &io, Relocations &seq, size_t index) {
     if ( index >= seq.size() )
       seq.resize(index+1);

   static size_t size(IO &io, ContentBytes &seq) {
     return seq.size();
   }
+
   static Hex8& element(IO &io, ContentBytes &seq, size_t index) {
     if ( index >= seq.size() )
       seq.resize(index+1);
     return seq[index];
   }
+
   static const bool flow = true;
 };
 

   static size_t size(IO &io, IndirectSymbols &seq) {
     return seq.size();
   }
+
   static uint32_t& element(IO &io, IndirectSymbols &seq, size_t index) {
     if ( index >= seq.size() )
       seq.resize(index+1);
     return seq[index];
   }
+
   static const bool flow = true;
 };
 

   }
 };
 
-
 template <>
 struct ScalarEnumerationTraits<HeaderFileType> {
   static void enumeration(IO &io, HeaderFileType &value) {

   }
 };
 
-
 template <>
 struct ScalarBitSetTraits<FileFlags> {
   static void bitset(IO &io, FileFlags &value) {

   }
 };
 
-
 template <>
 struct ScalarEnumerationTraits<SectionType> {
   static void enumeration(IO &io, SectionType &value) {

   }
 };
 
-
 template <>
 struct MappingTraits<Section> {
   struct NormalizedContentBytes;
+
   static void mapping(IO &io, Section &sect) {
     io.mapRequired("segment",         sect.segmentName);
     io.mapRequired("section",         sect.sectionName);

     NormalizedContent(IO &io, ArrayRef<uint8_t> content) : _io(io) {
       // When writing yaml, copy content byte array to Hex8 vector.
       for (auto &c : content) {
-        _normalizedContent.push_back(c);
+        _normalizedContent.emplace_back(c);
       }
     }
     ArrayRef<uint8_t> denormalize(IO &io) {

   };
 };
 
-
 template <>
 struct MappingTraits<Relocation> {
   static void mapping(IO &io, Relocation &reloc) {

   }
 };
 
-
 template <>
 struct ScalarEnumerationTraits<RelocationInfoType> {
   static void enumeration(IO &io, RelocationInfoType &value) {

  }
 };
 
-
 template <>
 struct MappingTraits<Symbol> {
   static void mapping(IO &io, Symbol& sym) {

   static bool mustQuote(StringRef) { return false; }
 };
 
-
 template <>
 struct MappingTraits<Segment> {
   static void mapping(IO &io, Segment& seg) {

   }
 };
 
-
 template <>
 struct MappingTraits<RebaseLocation> {
   static void mapping(IO &io, RebaseLocation& rebase) {

   }
 };
 
-
-
 template <>
 struct ScalarEnumerationTraits<BindType> {
   static void enumeration(IO &io, BindType &value) {

   }
 };
 
-
 template <>
 struct ScalarEnumerationTraits<ExportSymbolKind> {
   static void enumeration(IO &io, ExportSymbolKind &value) {

   }
 };
 
-
 template <>
 struct MappingTraits<Export> {
   static void mapping(IO &io, Export &exp) {

       out << llvm::format(".%d", (value & 0xFF));
     }
   }
+
   static StringRef input(StringRef scalar, void*, PackedVersion &result) {
     uint32_t value;
     if (lld::MachOLinkingContext::parsePackedVersion(scalar, value))

     // Return the empty string on success,
     return StringRef();
   }
+
   static bool mustQuote(StringRef) { return false; }
 };
 

     io.mapOptional("exports",          file.exportInfo);
     io.mapOptional("dataInCode",       file.dataInCode);
   }
+
   static StringRef validate(IO &io, NormalizedFile &file) {
     return StringRef();
   }

 } // namespace llvm
 } // namespace yaml
 
-
 namespace lld {
 namespace mach_o {
 

   return true;
 }
 
-
-
 namespace normalized {
 
 /// Parses a yaml encoded mach-o file to produce an in-memory normalized view.

   return std::move(f);
 }
 
-
 /// Writes a yaml encoded mach-o files from an in-memory normalized view.
 std::error_code writeYaml(const NormalizedFile &file, raw_ostream &out) {
   // YAML I/O is not const aware, so need to cast away ;-(

lib/ReaderWriter/YAML/ReaderWriterYAML.cpp

   static size_t size(IO &io, std::vector<const lld::File *> &seq) {
     return seq.size();
   }
+
   static const lld::File *&element(IO &io, std::vector<const lld::File *> &seq,
                                    size_t index) {
     if (index >= seq.size())

       setKindValue(_mappedKind.value);
       return this;
     }
+
     void bind(const RefNameResolver &);
     static StringRef targetName(IO &io, const lld::Reference *ref);
 

       ArrayRef<uint8_t> cont = atom->rawContent();
       _content.reserve(cont.size());
       for (uint8_t x : cont)
-        _content.push_back(x);
+        _content.emplace_back(x);
     }
 
     ~NormalizedAtom() override = default;

     DynamicExport dynamicExport() const override { return _dynamicExport; }
     CodeModel codeModel() const override { return _codeModel; }
     ContentPermissions permissions() const override { return _permissions; }
+
     ArrayRef<uint8_t> rawContent() const override {
       if (!occupiesDiskSpace())
         return ArrayRef<uint8_t>();

       const void *it = reinterpret_cast<const void *>(index);
       return reference_iterator(*this, it);
     }
+
     reference_iterator end() const override {
       uintptr_t index = _references.size();
       const void *it = reinterpret_cast<const void *>(index);
       return reference_iterator(*this, it);
     }
+
     const lld::Reference *derefIterator(const void *it) const override {
       uintptr_t index = reinterpret_cast<uintptr_t>(it);
       assert(index < _references.size());
       return _references[index];
     }
+
     void incrementIterator(const void *&it) const override {
       uintptr_t index = reinterpret_cast<uintptr_t>(it);
       ++index;

                                    << ", " << _name.size() << ")\n");
       return this;
     }
+
     // Extract current File object from YAML I/O parsing context
     const lld::File &fileFromContext(IO &io) {
       YamlContext *info = reinterpret_cast<YamlContext *>(io.getContext());