[LLD] Fix Clang-tidy modernize-use-auto warnings, other minor fixes

[Eugene.Zelenko]

Summary

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

[ruiu]

LGTM with a nit.

lib/ReaderWriter/MachO/StubsPass.cpp

282–283

This can fit in one line. Please run clang-format-diff.

[Eugene.Zelenko]

lib/ReaderWriter/MachO/StubsPass.cpp

282–283

Will fix it manually. Clang-format run over entire file produces too much differences.

lib/Driver/Driver.cpp

-//===- lib/Driver/Driver.cpp - Linker Driver Emulator ---------------------===//
+//===- lib/Driver/Driver.cpp - Linker Driver Emulator -----------*- C++ -*-===//
 //
 //                             The LLVM Linker
 //

   // Honor -mllvm
   if (!ctx.llvmOptions().empty()) {
     unsigned numArgs = ctx.llvmOptions().size();
-    const char **args = new const char *[numArgs + 2];
+    auto **args = new const char *[numArgs + 2];
     args[0] = "lld (LLVM option parsing)";
     for (unsigned i = 0; i != numArgs; ++i)
       args[i + 1] = ctx.llvmOptions()[i];

   return true;
 }
 
-} // anonymous namespace
+} // namespace lld

lib/ReaderWriter/ELF/AMDGPU/AMDGPUTargetHandler.cpp

-//===- lib/ReaderWriter/ELF/AMDGPU/AMDGPUTargetHandler.cpp ----------------===//
+//===- lib/ReaderWriter/ELF/AMDGPU/AMDGPUTargetHandler.cpp -------*- C++ -*-===//
 //
 //                             The LLVM Linker
 //

       if (InputSectionName != ".hsatext")
         continue;
 
-      Segment<ELF64LE> *segment = new (_allocator) Segment<ELF64LE>(
+      auto *segment = new (_allocator) Segment<ELF64LE>(
           _ctx, "PT_AMDGPU_HSA_LOAD_CODE_AGENT", PT_AMDGPU_HSA_LOAD_CODE_AGENT);
       _segments.push_back(segment);
       assert(segment);

lib/ReaderWriter/ELF/ELFFile.h

-//===- lib/ReaderWriter/ELF/ELFFile.h -------------------------------------===//
+//===- lib/ReaderWriter/ELF/ELFFile.h ---------------------------*- C++ -*-===//
 //
 //                             The LLVM Linker
 //

                                          const Elf_Shdr *sectionHdr,
                                          ArrayRef<uint8_t> contentData,
                                          unsigned int offset) {
-    ELFMergeAtom<ELFT> *mergeAtom = new (_readerStorage)
+    auto *mergeAtom = new (_readerStorage)
         ELFMergeAtom<ELFT>(*this, sectionName, sectionHdr, contentData, offset);
     const MergeSectionKey mergedSectionKey = {sectionHdr, offset};
     if (_mergedSectionMap.find(mergedSectionKey) == _mergedSectionMap.end())

lib/ReaderWriter/ELF/ELFFile.cpp

-//===- lib/ReaderWriter/ELF/ELFFile.cpp -----------------------------------===//
+//===- lib/ReaderWriter/ELF/ELFFile.cpp -------------------------*- C++ -*-===//
 //
 //                             The LLVM Linker
 //

   std::vector<ELFReference<ELFT> *> refs;
   for (auto ha : atomsForSection[*sectionName]) {
     _groupChild[ha->symbol()] = std::make_pair(*sectionName, section);
-    ELFReference<ELFT> *ref =
+    auto *ref =
         new (_readerStorage) ELFReference<ELFT>(Reference::kindGroupChild);
     ref->setTarget(ha);
     refs.push_back(ref);

   for (auto name : sectionNames) {
     for (auto ha : atomsForSection[name]) {
       _groupChild[ha->symbol()] = std::make_pair(*symbolName, section);
-      ELFReference<ELFT> *ref =
+      auto *ref =
           new (_readerStorage) ELFReference<ELFT>(Reference::kindGroupChild);
       ref->setTarget(ha);
       refs.push_back(ref);

 ELFDefinedAtom<ELFT> *
 ELFFile<ELFT>::createSectionAtom(const Elf_Shdr *section, StringRef sectionName,
                                  ArrayRef<uint8_t> content) {
-  Elf_Sym *sym = new (_readerStorage) Elf_Sym;
+  auto *sym = new (_readerStorage) Elf_Sym;
   sym->st_name = 0;
   sym->setBindingAndType(llvm::ELF::STB_LOCAL, llvm::ELF::STT_SECTION);
   sym->st_other = 0;

 template <class ELFT>
 void RuntimeFile<ELFT>::addAbsoluteAtom(StringRef symbolName, bool isHidden) {
   assert(!symbolName.empty() && "AbsoluteAtoms must have a name");
-  Elf_Sym *sym = new (this->_readerStorage) Elf_Sym;
+  auto *sym = new (this->_readerStorage) Elf_Sym;
   sym->st_name = 0;
   sym->st_value = 0;
   sym->st_shndx = llvm::ELF::SHN_ABS;

 template <class ELFT>
 void RuntimeFile<ELFT>::addUndefinedAtom(StringRef symbolName) {
   assert(!symbolName.empty() && "UndefinedAtoms must have a name");
-  Elf_Sym *sym = new (this->_readerStorage) Elf_Sym;
+  auto *sym = new (this->_readerStorage) Elf_Sym;
   sym->st_name = 0;
   sym->st_value = 0;
   sym->st_shndx = llvm::ELF::SHN_UNDEF;

lib/ReaderWriter/ELF/HeaderChunks.cpp

-//===- lib/ReaderWriter/ELF/HeaderChunks.cpp ------------------------------===//
+//===- lib/ReaderWriter/ELF/HeaderChunks.cpp --------------------*- C++ -*-===//
 //
 //                             The LLVM Linker
 //

   this->_alignment = 8;
   this->setOrder(order);
   // The first element in the list is always NULL
-  Elf_Shdr *nullshdr = new (_sectionAllocate.Allocate<Elf_Shdr>()) Elf_Shdr;
+  auto *nullshdr = new (_sectionAllocate.Allocate<Elf_Shdr>()) Elf_Shdr;
   ::memset(nullshdr, 0, sizeof(Elf_Shdr));
   _sectionInfo.push_back(nullshdr);
   this->_fsize += sizeof(Elf_Shdr);

 
 template <class ELFT>
 void SectionHeader<ELFT>::appendSection(OutputSection<ELFT> *section) {
-  Elf_Shdr *shdr = new (_sectionAllocate.Allocate<Elf_Shdr>()) Elf_Shdr;
+  auto *shdr = new (_sectionAllocate.Allocate<Elf_Shdr>()) Elf_Shdr;
   shdr->sh_name = _stringSection->addString(section->name());
   shdr->sh_type = section->type();
   shdr->sh_flags = section->flags();

lib/ReaderWriter/LinkerScript.cpp

-//===- ReaderWriter/LinkerScript.cpp --------------------------------------===//
+//===- ReaderWriter/LinkerScript.cpp ----------------------------*- C++ -*-===//
 //
 //                             The LLVM Linker
 //

   os << ")\n";
 }
 
-
 // Parser functions
 std::error_code Parser::parse() {
   // Get the first token.

   case Token::identifier: {
     if (peek()._kind== Token::l_paren)
       return parseFunctionCall();
-    Symbol *sym = new (_alloc) Symbol(*this, _tok._range);
+    auto *sym = new (_alloc) Symbol(*this, _tok._range);
     consumeToken();
     return sym;
   }

       error(_tok, "Unrecognized number constant");
       return nullptr;
     }
-    Constant *c = new (_alloc) Constant(*this, *val);
+    auto *c = new (_alloc) Constant(*this, *val);
     consumeToken();
     return c;
   }

       if (!length)
         return nullptr;
 
-      MemoryBlock *block =
-          new (_alloc) MemoryBlock(name, attrs, origin, length);
+      auto *block = new (_alloc) MemoryBlock(name, attrs, origin, length);
       blocks.push_back(block);
     } else {
       unrecognizedToken = true;

 
   // If we still couldn't find a rule for this input section, try to match
   // wildcards
-  for (auto I = _memberNameWildcards.begin(), E = _memberNameWildcards.end();
-       I != E; ++I) {
-    if (!wildcardMatch(I->first, key.memberPath))
+  for (const auto &I : _memberNameWildcards) {
+    if (!wildcardMatch(I.first, key.memberPath))
       continue;
-    int order = I->second;
+    int order = I.second;
     int exprOrder = -1;
 
     if ((exprOrder = matchSectionName(order, key)) >= 0) {

   }
 }
 
-} // End namespace script
+} // end namespace script
 } // end namespace lld

lib/ReaderWriter/MachO/CompactUnwindPass.cpp

-//===- lib/ReaderWriter/MachO/CompactUnwindPass.cpp -----------------------===//
+//===- lib/ReaderWriter/MachO/CompactUnwindPass.cpp -------------*- C++ -*-===//
 //
 //                             The LLVM Linker
 //

             << " has " << entriesInPage << " entries\n");
     } while (pageStart < unwindInfos.size());
 
-    UnwindInfoAtom *unwind = new (_file.allocator())
+    auto *unwind = new (_file.allocator())
         UnwindInfoAtom(_archHandler, _file, _isBig, personalities,
                        commonEncodings, pages, numLSDAs);
     mergedFile.addAtom(*unwind);

     });
   }
 
-
   CompactUnwindEntry finalizeUnwindInfoEntryForAtom(
       const DefinedAtom *function,
       const std::map<const Atom *, CompactUnwindEntry> &unwindLocs,

       }
     }
 
-
     auto personality = std::find(personalities.begin(), personalities.end(),
                                  entry.personalityFunction);
     uint32_t personalityIdx = personality == personalities.end()

lib/ReaderWriter/MachO/File.h

-//===- lib/ReaderWriter/MachO/File.h --------------------------------------===//
+//===- lib/ReaderWriter/MachO/File.h ----------------------------*- C++ -*-===//
 //
 //                             The LLVM Linker
 //

     DefinedAtom::Alignment align(
         inSection->alignment,
         sectionOffset % inSection->alignment);
-    MachODefinedAtom *atom =
+    auto *atom =
         new (allocator()) MachODefinedAtom(*this, name, scope, type, merge,
                                            thumb, noDeadStrip, content, align);
     addAtomForSection(inSection, atom, sectionOffset);

     DefinedAtom::Alignment align(
         inSection->alignment,
         sectionOffset % inSection->alignment);
-    MachODefinedCustomSectionAtom *atom =
+    auto *atom =
         new (allocator()) MachODefinedCustomSectionAtom(*this, name, scope, type,
                                                         merge, thumb,
                                                         noDeadStrip, content,

     DefinedAtom::Alignment align(
         inSection->alignment,
         sectionOffset % inSection->alignment);
-    MachODefinedAtom *atom =
+    auto *atom =
        new (allocator()) MachODefinedAtom(*this, name, scope, size, noDeadStrip,
                                           align);
     addAtomForSection(inSection, atom, sectionOffset);

       // Make a copy of the atom's name that is owned by this file.
       name = name.copy(allocator());
     }
-    SimpleUndefinedAtom *atom =
-        new (allocator()) SimpleUndefinedAtom(*this, name);
+    auto *atom = new (allocator()) SimpleUndefinedAtom(*this, name);
     addAtom(*atom);
     _undefAtoms[name] = atom;
   }

       // Make a copy of the atom's name that is owned by this file.
       name = name.copy(allocator());
     }
-    MachOTentativeDefAtom *atom =
+    auto *atom =
         new (allocator()) MachOTentativeDefAtom(*this, name, scope, size, align);
     addAtom(*atom);
     _undefAtoms[name] = atom;

     addAtom(*atom);
   }
 
-
   typedef llvm::DenseMap<const normalized::Section *,
                          std::vector<SectionOffsetAndAtom>>  SectionToAtoms;
   typedef llvm::StringMap<const lld::Atom *> NameToAtom;

     return nullptr;
   }
 
-
   struct ReExportedDylib {
     ReExportedDylib(StringRef p) : path(p), file(nullptr) { }
     StringRef       path;

 } // end namespace mach_o
 } // end namespace lld
 
-#endif
+#endif // LLD_READER_WRITER_MACHO_FILE_H

lib/ReaderWriter/MachO/GOTPass.cpp

-//===- lib/ReaderWriter/MachO/GOTPass.cpp ---------------------------------===//
+//===- lib/ReaderWriter/MachO/GOTPass.cpp -----------------------*- C++ -*-===//
 //
 //                             The LLVM Linker
 //

 namespace lld {
 namespace mach_o {
 
-
 //
 //  GOT Entry Atom created by the GOT pass.
 //

   StringRef _name;
 };
 
-
 /// Pass for instantiating and optimizing GOT slots.
 ///
 class GOTPass : public Pass {

   const DefinedAtom *makeGOTEntry(const Atom *target) {
     auto pos = _targetToGOT.find(target);
     if (pos == _targetToGOT.end()) {
-      GOTEntryAtom *gotEntry = new (_file.allocator())
+      auto *gotEntry = new (_file.allocator())
           GOTEntryAtom(_file, _ctx.is64Bit(), target->name());
       _targetToGOT[target] = gotEntry;
       const ArchHandler::ReferenceInfo &nlInfo = _archHandler.stubInfo().

   llvm::DenseMap<const Atom*, const GOTEntryAtom*> _targetToGOT;
 };
 
-
-
 void addGOTPass(PassManager &pm, const MachOLinkingContext &ctx) {
   assert(ctx.needsGOTPass());
   pm.add(llvm::make_unique<GOTPass>(ctx));
 }
 
-
 } // end namesapce mach_o
 } // end namesapce lld

lib/ReaderWriter/MachO/MachONormalizedFileBinaryWriter.cpp

     const uint8_t *bytes() {
       return reinterpret_cast<const uint8_t*>(_ostream.str().data());
     }
+
   private:
     SmallVector<char, 128>        _bytes;
     // Stream ivar must be after SmallVector ivar to construct properly.

     TrieNode(StringRef s)
         : _cummulativeString(s), _address(0), _flags(0), _other(0),
           _trieOffset(0), _hasExportInfo(false) {}
-    ~TrieNode() {}
+    ~TrieNode() = default;
 
     void addSymbol(const Export &entry, BumpPtrAllocator &allocator,
                    std::vector<TrieNode *> &allNodes);
     bool updateOffset(uint32_t &offset);
     void appendToByteBuffer(ByteBuffer &out);
 
   private:
     StringRef                 _cummulativeString;
     std::list<TrieEdge>       _children;
     uint64_t                  _address;

   return _endOfLoadCommands;
 }
 
-
 MachOFileLayout::MachOFileLayout(const NormalizedFile &file)
     : _file(file),
       _is64(MachOLinkingContext::is64Bit(file.arch)),

   _startOfLinkEdit = fileOffset;
 }
 
-
 size_t MachOFileLayout::size() const {
   return _endOfSymbolStrings;
 }

   return ec;
 }
 
-
 void MachOFileLayout::writeSectionContent() {
   for (const Section &s : _file.sections) {
     // Copy all section content to output buffer.

   }
 }
 
-
 void MachOFileLayout::appendSymbols(const std::vector<Symbol> &symbols,
                                    uint32_t &symOffset, uint32_t &strOffset) {
   for (const Symbol &sym : symbols) {

         // Splice in new node:  was A -> C,  now A -> B -> C
         StringRef bNodeStr = edge._child->_cummulativeString;
         bNodeStr = bNodeStr.drop_back(edgeStr.size()-n).copy(allocator);
-        TrieNode* bNode = new (allocator) TrieNode(bNodeStr);
+        auto *bNode = new (allocator) TrieNode(bNodeStr);
         allNodes.push_back(bNode);
         TrieNode* cNode = edge._child;
         StringRef abEdgeStr = edgeStr.substr(0,n).copy(allocator);

         TrieEdge& abEdge = edge;
         abEdge._subString = abEdgeStr;
         abEdge._child = bNode;
-        TrieEdge *bcEdge = new (allocator) TrieEdge(bcEdgeStr, cNode);
+        auto *bcEdge = new (allocator) TrieEdge(bcEdgeStr, cNode);
         bNode->_children.push_back(std::move(*bcEdge));
         bNode->addSymbol(entry, allocator, allNodes);
         return;

     assert(entry.otherOffset != 0);
   }
   // No commonality with any existing child, make a new edge.
-  TrieNode* newNode = new (allocator) TrieNode(entry.name.copy(allocator));
-  TrieEdge *newEdge = new (allocator) TrieEdge(partialStr, newNode);
+  auto *newNode = new (allocator) TrieNode(entry.name.copy(allocator));
+  auto *newEdge = new (allocator) TrieEdge(partialStr, newNode);
   _children.push_back(std::move(*newEdge));
   DEBUG_WITH_TYPE("trie-builder", llvm::dbgs()
                    << "new TrieNode('" << entry.name << "') with edge '"

   BumpPtrAllocator allocator;
 
   // Build trie of all exported symbols.
-  TrieNode* rootNode = new (allocator) TrieNode(StringRef());
+  auto *rootNode = new (allocator) TrieNode(StringRef());
   std::vector<TrieNode*> allNodes;
   allNodes.reserve(_file.exportInfo.size()*2);
   allNodes.push_back(rootNode);

   _exportTrie.align(_is64 ? 8 : 4);
 }
 
-
 void MachOFileLayout::computeSymbolTableSizes() {
   // MachO symbol tables have three ranges: locals, globals, and undefines
   const size_t nlistSize = (_is64 ? sizeof(nlist_64) : sizeof(nlist));

   return std::error_code();
 }
 
-
 /// Takes in-memory normalized view and writes a mach-o object file.
 std::error_code writeBinary(const NormalizedFile &file, StringRef path) {
   MachOFileLayout layout(file);
   return layout.writeBinary(path);
 }
 
-
 } // namespace normalized
 } // namespace mach_o
 } // namespace lld

lib/ReaderWriter/MachO/MachONormalizedFileFromAtoms.cpp

  : name(n), address(0), size(0), access(0), normalizedSegmentIndex(0) {
 }
 
-
 class Util {
 public:
   Util(const MachOLinkingContext &ctxt)

     }
   }
   // Otherwise allocate new SectionInfo object.
-  SectionInfo *sect = new (_allocator)
+  auto *sect = new (_allocator)
       SectionInfo(segmentName, sectionName, sectionType, _ctx, sectionAttrs);
   _sectionInfos.push_back(sect);
   _sectionMap[type] = sect;

 };
 #undef ENTRY
 
-
 SectionInfo *Util::getFinalSection(DefinedAtom::ContentType atomType) {
   for (auto &p : sectsToAtomType) {
     if (p.atomType != atomType)

       }
     }
     // Otherwise allocate new SectionInfo object.
-    SectionInfo *sect = new (_allocator) SectionInfo(
+    auto *sect = new (_allocator) SectionInfo(
         p.segmentName, p.sectionName, p.sectionType, _ctx, sectionAttrs);
     _sectionInfos.push_back(sect);
     _sectionMap[atomType] = sect;

   llvm_unreachable("content type not yet supported");
 }
 
-
-
 SectionInfo *Util::sectionForAtom(const DefinedAtom *atom) {
   if (atom->sectionChoice() == DefinedAtom::sectionBasedOnContent) {
     // Section for this atom is derived from content type.

     assert(seperatorIndex != StringRef::npos);
     StringRef segName = customName.slice(0, seperatorIndex);
     StringRef sectName = customName.drop_front(seperatorIndex + 1);
-    SectionInfo *sect =
+    auto *sect =
         new (_allocator) SectionInfo(segName, sectName, S_REGULAR, _ctx);
     _customSections.push_back(sect);
     _sectionInfos.push_back(sect);

   }
 }
 
-
 void Util::appendAtom(SectionInfo *sect, const DefinedAtom *atom) {
   // Figure out offset for atom in this section given alignment constraints.
   uint64_t offset = sect->size;

     if ( si->name.equals(segName) )
       return si;
   }
-  SegmentInfo *info = new (_allocator) SegmentInfo(segName);
+  auto *info = new (_allocator) SegmentInfo(segName);
   if (segName.equals("__TEXT"))
     info->access = VM_PROT_READ | VM_PROT_EXECUTE;
   else if (segName.equals("__DATA"))

   return (weight(left) < weight(right));
 }
 
-
 void Util::organizeSections() {
   if (_ctx.outputMachOType() == llvm::MachO::MH_OBJECT) {
     // Leave sections ordered as normalized file specified.

       }
     }
   }
-
 }
 
-
 void Util::layoutSectionsInSegment(SegmentInfo *seg, uint64_t &addr) {
   seg->address = addr;
   for (SectionInfo *sect : seg->sections) {

   seg->size = llvm::RoundUpToAlignment(addr - seg->address, _ctx.pageSize());
 }
 
-
 // __TEXT segment lays out backwards so padding is at front after load commands.
 void Util::layoutSectionsInTextSegment(size_t hlcSize, SegmentInfo *seg,
                                                                uint64_t &addr) {

   seg->size = llvm::RoundUpToAlignment(addr - seg->address, _ctx.pageSize());
 }
 
-
 void Util::assignAddressesToSections(const NormalizedFile &file) {
   size_t hlcSize = headerAndLoadCommandsSize(file);
   uint64_t address = 0;

   }
 }
 
-
 void Util::copySegmentInfo(NormalizedFile &file) {
   for (SegmentInfo *sgi : _segmentInfos) {
     Segment seg;

   }
 }
 
-
 void Util::copySectionInfo(NormalizedFile &file) {
   file.sections.reserve(_sectionInfos.size());
   // For final linked images, write sections grouped by segment.

   return desc;
 }
 
-
 bool Util::AtomSorter::operator()(const AtomAndIndex &left,
                                   const AtomAndIndex &right) {
   return (left.atom->name().compare(right.atom->name()) < 0);
 }
 
-
 std::error_code Util::getSymbolTableRegion(const DefinedAtom* atom,
                                            bool &inGlobalsRegion,
                                            SymbolScope &scope) {

     file.globalSymbols.push_back(sym);
   }
 
-
   // Sort undefined symbol alphabetically, then add to symbol table.
   std::vector<AtomAndIndex> undefs;
   undefs.reserve(128);

   return nullptr;
 }
 
-
 void Util::addIndirectSymbols(const lld::File &atomFile, NormalizedFile &file) {
   for (SectionInfo *si : _sectionInfos) {
     Section &normSect = file.sections[si->normalizedSectionIndex];

       break;
     }
   }
-
 }
 
 void Util::addDependentDylibs(const lld::File &atomFile,NormalizedFile &nFile) {

   }
 }
 
-
 int Util::dylibOrdinal(const SharedLibraryAtom *sa) {
   return _dylibInfo[sa->loadName()].ordinal;
 }

   llvm_unreachable("section not in any segment");
 }
 
-
 uint32_t Util::sectionIndexForAtom(const Atom *atom) {
   uint64_t address = _atomToAddress[atom];
   uint32_t index = 1;

   if (_ctx.outputMachOType() != llvm::MachO::MH_OBJECT)
     return;
 
-
   // Utility function for ArchHandler to find symbol index for an atom.
   auto symIndexForAtom = [&] (const Atom &atom) -> uint32_t {
     auto pos = _atomToSymbolIndex.find(&atom);

 
 } // end anonymous namespace
 
-
 namespace lld {
 namespace mach_o {
 namespace normalized {

   return std::move(f);
 }
 
-
 } // namespace normalized
 } // namespace mach_o
 } // namespace lld

lib/ReaderWriter/MachO/StubsPass.cpp

-//===- lib/ReaderWriter/MachO/StubsPass.cpp -------------------------------===//
+//===- lib/ReaderWriter/MachO/StubsPass.cpp ---------------------*- C++ -*-===//
 //
 //                             The LLVM Linker
 //

 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/SmallVector.h"
 
-
 namespace lld {
 namespace mach_o {
 
-
 //
 //  Lazy Pointer Atom created by the stubs pass.
 //

   const bool _is64;
 };
 
-
 //
 //  NonLazyPointer (GOT) Atom created by the stubs pass.
 //

   const bool _is64;
 };
 
-
-
 //
 // Stub Atom created by the stubs pass.
 //

   const ArchHandler::StubInfo   &_stubInfo;
 };
 
-
 //
 // Stub Helper Atom created by the stubs pass.
 //

   const ArchHandler::StubInfo   &_stubInfo;
 };
 
-
 //
 // Stub Helper Common Atom created by the stubs pass.
 //

   const ArchHandler::StubInfo   &_stubInfo;
 };
 
-
 class StubsPass : public Pass {
 public:
   StubsPass(const MachOLinkingContext &context)

     // Make and append stubs, lazy pointers, and helpers in alphabetical order.
     unsigned lazyOffset = 0;
     for (const Atom *target : targetsNeedingStubs) {
-      StubAtom *stub = new (_file.allocator()) StubAtom(_file, _stubInfo);
-      LazyPointerAtom *lp =
+      auto *stub = new (_file.allocator()) StubAtom(_file, _stubInfo);
+      auto *lp =
           new (_file.allocator()) LazyPointerAtom(_file, _ctx.is64Bit());
-      StubHelperAtom *helper =
+      auto *helper =
           new (_file.allocator()) StubHelperAtom(_file, _stubInfo);
 
       addReference(stub, _stubInfo.stubReferenceToLP, lp);

   }
 
 private:
-
   bool noTextRelocs() {
     return true;
   }

   TargetToUses                                    _targetToUses;
 };
 
-
-
 void addStubsPass(PassManager &pm, const MachOLinkingContext &ctx) {
   pm.add(std::unique_ptr<Pass>(new StubsPass(ctx)));
 }

lib/ReaderWriter/MachO/TLVPass.cpp

-//===- lib/ReaderWriter/MachO/TLVPass.cpp ---------------------------------===//
+//===- lib/ReaderWriter/MachO/TLVPass.cpp -----------------------*- C++ -*-===//
 //
 //                             The LLVM Linker
 //

         _file("<mach-o TLV Pass>") {}
 
 private:
-
   std::error_code perform(SimpleFile &mergedFile) override {
-
     bool allowTLV = _ctx.minOS("10.7", "1.0");
 
     for (const DefinedAtom *atom : mergedFile.defined()) {

     if (pos != _targetToTLVP.end())
       return pos->second;
 
-    TLVPEntryAtom *tlvpEntry = new (_file.allocator())
+    auto *tlvpEntry = new (_file.allocator())
       TLVPEntryAtom(_file, _ctx.is64Bit(), target->name());
     _targetToTLVP[target] = tlvpEntry;
     const ArchHandler::ReferenceInfo &nlInfo =

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