[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 ↗

(On Diff #39850)

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

[Eugene.Zelenko]

lib/ReaderWriter/MachO/StubsPass.cpp

282–283 ↗

(On Diff #39850)

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

lld/trunk/lib/Driver/Driver.cpp

-//===- lib/Driver/Driver.cpp - Linker Driver Emulator ---------------------===//
+//===- lib/Driver/Driver.cpp - Linker Driver Emulator -----------*- C++ -*-===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
FileVector loadFile(LinkingContext &ctx, StringRef path, bool wholeArchive) {
   return files;
 }
 
 /// This is where the link is actually performed.
 bool Driver::link(LinkingContext &ctx, raw_ostream &diagnostics) {
   // 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];
     args[numArgs + 1] = nullptr;
     llvm::cl::ParseCommandLineOptions(numArgs + 1, args);
   }
   if (ctx.getNodes().empty())
     return false;
if (std::error_code ec = ctx.writeFile(*merged)) {
     diagnostics << "Failed to write file '" << ctx.outputPath()
                 << "': " << ec.message() << "\n";
     return false;
   }
 
   return true;
 }
 
-} // anonymous namespace
+} // namespace lld

lld/trunk/lib/ReaderWriter/ELF/AMDGPU/AMDGPUTargetHandler.cpp

-//===- lib/ReaderWriter/ELF/AMDGPU/AMDGPUTargetHandler.cpp ----------------===//
+//===- lib/ReaderWriter/ELF/AMDGPU/AMDGPUTargetHandler.cpp -------*- C++ -*-===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
void AMDGPUTargetLayout::assignSectionsToSegments() {
 
   TargetLayout::assignSectionsToSegments();
   for (OutputSection<ELF64LE> *osi : _outputSections) {
     for (Section<ELF64LE> *section : osi->sections()) {
       StringRef InputSectionName = section->inputSectionName();
       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);
       segment->append(section);
     }
   }
 }
 
 } // namespace elf
 } // namespace lld

lld/trunk/lib/ReaderWriter/ELF/ELFFile.h

-//===- lib/ReaderWriter/ELF/ELFFile.h -------------------------------------===//
+//===- lib/ReaderWriter/ELF/ELFFile.h ---------------------------*- C++ -*-===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
return new (_readerStorage) ELFDefinedAtom<ELFT>(
         referenceStart, referenceEnd, referenceList);
   }
 
   /// Process the Merge string and create an atom for it.
   ELFMergeAtom<ELFT> *createMergedString(StringRef sectionName,
                                          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())
       _mergedSectionMap.insert(std::make_pair(mergedSectionKey, mergeAtom));
     return mergeAtom;
   }
 
   /// References to the sections comprising a group, from sections

lld/trunk/lib/ReaderWriter/ELF/ELFFile.cpp

-//===- lib/ReaderWriter/ELF/ELFFile.cpp -----------------------------------===//
+//===- lib/ReaderWriter/ELF/ELFFile.cpp -------------------------*- C++ -*-===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
if (std::error_code ec = sectionName.getError())
     return ec;
   if (!isGnuLinkOnceSection(*sectionName))
     return std::error_code();
 
   unsigned int referenceStart = _references.size();
   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);
   }
   atomsForSection[*sectionName].clear();
   // Create a gnu linkonce atom.
   ELFDefinedAtom<ELFT> *atom = createDefinedAtom(
       *sectionName, *sectionName, nullptr, section, ArrayRef<uint8_t>(),
std::error_code ELFFile<ELFT>::handleSectionGroup(
   if (std::error_code ec = symbolName.getError())
     return ec;
 
   unsigned int referenceStart = _references.size();
   std::vector<ELFReference<ELFT> *> refs;
   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);
     }
     atomsForSection[name].clear();
   }
 
   // Create an atom for comdat signature.
bool ELFFile<ELFT>::isMergeableStringSection(const Elf_Shdr *section) {
   }
   return false;
 }
 
 template <class ELFT>
 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;
   sym->st_shndx = 0;
   sym->st_value = 0;
   sym->st_size = 0;
   auto *newAtom = createDefinedAtomAndAssignRelocations(
       "", sectionName, sym, section, content, content);
bool ELFFile<ELFT>::redirectReferenceUsingUndefAtom(
   if (groupChildSource->second.second == groupChildTarget->second.second)
     return false;
   return true;
 }
 
 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;
   sym->setBindingAndType(llvm::ELF::STB_GLOBAL, llvm::ELF::STT_OBJECT);
   if (isHidden)
     sym->setVisibility(llvm::ELF::STV_HIDDEN);
   else
     sym->setVisibility(llvm::ELF::STV_DEFAULT);
   sym->st_size = 0;
   ELFAbsoluteAtom<ELFT> *atom = this->createAbsoluteAtom(symbolName, sym, -1);
   this->addAtom(*atom);
 }
 
 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;
   sym->setBindingAndType(llvm::ELF::STB_GLOBAL, llvm::ELF::STT_NOTYPE);
   sym->setVisibility(llvm::ELF::STV_DEFAULT);
   sym->st_size = 0;
   ELFUndefinedAtom<ELFT> *atom = this->createUndefinedAtom(symbolName, sym);
   this->addAtom(*atom);

lld/trunk/lib/ReaderWriter/ELF/HeaderChunks.cpp

-//===- lib/ReaderWriter/ELF/HeaderChunks.cpp ------------------------------===//
+//===- lib/ReaderWriter/ELF/HeaderChunks.cpp --------------------*- C++ -*-===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 

 
 template <class ELFT>
 SectionHeader<ELFT>::SectionHeader(const ELFLinkingContext &ctx, int32_t order)
     : Chunk<ELFT>("shdr", Chunk<ELFT>::Kind::SectionHeader, ctx) {
   this->_fsize = 0;
   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();
   shdr->sh_offset = section->fileOffset();
   shdr->sh_addr = section->virtualAddr();
   if (section->isLoadableSection())
     shdr->sh_size = section->memSize();
   else

lld/trunk/lib/ReaderWriter/LinkerScript.cpp

-//===- ReaderWriter/LinkerScript.cpp --------------------------------------===//
+//===- ReaderWriter/LinkerScript.cpp ----------------------------*- C++ -*-===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 ///
void Extern::dump(raw_ostream &os) const {
   for (unsigned i = 0, e = _symbols.size(); i != e; ++i) {
     if (i)
       os << " ";
     os << _symbols[i];
   }
   os << ")\n";
 }
 
-
 // Parser functions
 std::error_code Parser::parse() {
   // Get the first token.
   _lex.lex(_tok);
   // Parse top level commands.
   while (true) {
     switch (_tok._kind) {
     case Token::eof:

 const Expression *Parser::parseExprOperand() {
   if (!expectExprOperand())
     return nullptr;
 
   switch (_tok._kind) {
   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;
   }
   case Token::kw_align:
     return parseFunctionCall();
   case Token::minus:
     consumeToken();
     return new (_alloc) Unary(*this, Unary::Minus, parseExprOperand());
   case Token::tilde:
     consumeToken();
     return new (_alloc) Unary(*this, Unary::Not, parseExprOperand());
   case Token::number: {
     auto val = parseNum(_tok._range);
     if (val.getError()) {
       error(_tok, "Unrecognized number constant");
       return nullptr;
     }
-    Constant *c = new (_alloc) Constant(*this, *val);
+    auto *c = new (_alloc) Constant(*this, *val);
     consumeToken();
     return c;
   }
   case Token::l_paren: {
     consumeToken();
     const Expression *expr = parseExpression();
     if (!expectAndConsume(Token::r_paren, "expected )"))
       return nullptr;
if (_tok._kind == Token::identifier) {
 
       if (!expectAndConsume(Token::equal, "expected ="))
         return nullptr;
 
       length = parseExpression();
       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 (!expectAndConsume(
           Token::r_brace,
           "expected memory block definition."))
if ((exprOrder = matchSectionName(order, key)) >= 0) {
       }
       _cacheExpressionOrder.insert(std::make_pair(key, exprOrder));
       return exprOrder;
     }
   }
 
   // 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) {
       if (coarse) {
         _cacheSectionOrder.insert(std::make_pair(key, order));
         return order;
       }
       _cacheExpressionOrder.insert(std::make_pair(key, exprOrder));
for (const Command *outSecCommand : *outSection) {
       if (!isa<InputSectionsCmd>(outSecCommand))
         continue;
 
       linearizeAST(dyn_cast<InputSectionsCmd>(outSecCommand));
     }
   }
 }
 
-} // End namespace script
+} // end namespace script
 } // end namespace lld

lld/trunk/lib/ReaderWriter/MachO/CompactUnwindPass.cpp

-//===- lib/ReaderWriter/MachO/CompactUnwindPass.cpp -----------------------===//
+//===- lib/ReaderWriter/MachO/CompactUnwindPass.cpp -------------*- C++ -*-===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 ///
do {
 
       DEBUG(llvm::dbgs()
             << "    Page from " << pages.back().entries[0].rangeStart->name()
             << " to " << pages.back().entries.back().rangeStart->name() << " + "
             << llvm::format("0x%x", pages.back().entries.back().rangeLength)
             << " 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);
 
     // Finally, remove all __compact_unwind atoms now that we've processed them.
     mergedFile.removeDefinedAtomsIf([](const DefinedAtom *atom) {
       return atom->contentType() == DefinedAtom::typeCompactUnwindInfo;
     });
void pruneUnusedEHFrames(
     mergedFile.removeDefinedAtomsIf([&](const DefinedAtom *atom) {
       if ((atom->contentType() == DefinedAtom::typeCFI) &&
           !usedDwarfFrames.count(atom))
         return true;
       return false;
     });
   }
 
-
   CompactUnwindEntry finalizeUnwindInfoEntryForAtom(
       const DefinedAtom *function,
       const std::map<const Atom *, CompactUnwindEntry> &unwindLocs,
       const std::vector<const Atom *> &personalities,
       const std::map<const Atom *, const Atom *> &dwarfFrames) {
     auto unwindLoc = unwindLocs.find(function);
 
     CompactUnwindEntry entry;
if (entry.encoding == _archHandler.dwarfCompactUnwindType() ||
         entry.encoding == 0) {
       auto dwarfFrame = dwarfFrames.find(function);
       if (dwarfFrame != dwarfFrames.end()) {
         entry.encoding = _archHandler.dwarfCompactUnwindType();
         entry.ehFrame = dwarfFrame->second;
       }
     }
 
-
     auto personality = std::find(personalities.begin(), personalities.end(),
                                  entry.personalityFunction);
     uint32_t personalityIdx = personality == personalities.end()
                                   ? 0
                                   : personality - personalities.begin() + 1;
 
     // FIXME: We should also use DWARF when there isn't enough room for the
     // personality function in the compact encoding.

lld/trunk/lib/ReaderWriter/MachO/File.h

-//===- lib/ReaderWriter/MachO/File.h --------------------------------------===//
+//===- lib/ReaderWriter/MachO/File.h ----------------------------*- C++ -*-===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
void addDefinedAtom(StringRef name, Atom::Scope scope,
     if (copyRefs) {
       // Make a copy of the atom's name and content that is owned by this file.
       name = name.copy(allocator());
       content = content.copy(allocator());
     }
     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);
   }
 
   void addDefinedAtomInCustomSection(StringRef name, Atom::Scope scope,
                       DefinedAtom::ContentType type, DefinedAtom::Merge merge,
                       bool thumb, bool noDeadStrip, uint64_t sectionOffset,
                       uint64_t contentSize, StringRef sectionName,
                       bool copyRefs, const Section *inSection) {
     assert(sectionOffset+contentSize <= inSection->content.size());
     ArrayRef<uint8_t> content = inSection->content.slice(sectionOffset,
                                                         contentSize);
    if (copyRefs) {
       // Make a copy of the atom's name and content that is owned by this file.
       name = name.copy(allocator());
       content = content.copy(allocator());
       sectionName = sectionName.copy(allocator());
     }
     DefinedAtom::Alignment align(
         inSection->alignment,
         sectionOffset % inSection->alignment);
-    MachODefinedCustomSectionAtom *atom =
+    auto *atom =
         new (allocator()) MachODefinedCustomSectionAtom(*this, name, scope, type,
                                                         merge, thumb,
                                                         noDeadStrip, content,
                                                         sectionName, align);
     addAtomForSection(inSection, atom, sectionOffset);
   }
 
   void addZeroFillDefinedAtom(StringRef name, Atom::Scope scope,
                               uint64_t sectionOffset, uint64_t size,
                               bool noDeadStrip, bool copyRefs,
                               const Section *inSection) {
     if (copyRefs) {
       // Make a copy of the atom's name and content that is owned by this file.
       name = name.copy(allocator());
     }
     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);
   }
 
   void addUndefinedAtom(StringRef name, bool copyRefs) {
     if (copyRefs) {
       // 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;
   }
 
   void addTentativeDefAtom(StringRef name, Atom::Scope scope, uint64_t size,
                            DefinedAtom::Alignment align, bool copyRefs) {
     if (copyRefs) {
       // 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;
   }
 
   /// Search this file for an the atom from 'section' that covers
   /// 'offsetInSect'.  Returns nullptr is no atom found.
   MachODefinedAtom *findAtomCoveringAddress(const Section &section,
void addAtomForSection(const Section *inSection, MachODefinedAtom* atom,
                          uint64_t sectionOffset) {
     SectionOffsetAndAtom offAndAtom;
     offAndAtom.offset = sectionOffset;
     offAndAtom.atom   = atom;
      _sectionAtoms[inSection].push_back(offAndAtom);
     addAtom(*atom);
   }
 
-
   typedef llvm::DenseMap<const normalized::Section *,
                          std::vector<SectionOffsetAndAtom>>  SectionToAtoms;
   typedef llvm::StringMap<const lld::Atom *> NameToAtom;
 
   std::unique_ptr<MemoryBuffer> _mb;
   MachOLinkingContext          *_ctx;
   SectionToAtoms                _sectionAtoms;
   NameToAtom                     _undefAtoms;
for (const ReExportedDylib &dylib : _reExportedDylibs) {
       if (atom)
         return atom;
     }
 
     // Symbol not exported or re-exported by this dylib.
     return nullptr;
   }
 
-
   struct ReExportedDylib {
     ReExportedDylib(StringRef p) : path(p), file(nullptr) { }
     StringRef       path;
     MachODylibFile *file;
   };
 
   struct AtomAndFlags {
     AtomAndFlags() : atom(nullptr), weakDef(false) { }
private:
   uint32_t                                   _compatVersion;
   std::vector<ReExportedDylib>               _reExportedDylibs;
   mutable std::unordered_map<StringRef, AtomAndFlags> _nameToAtom;
 };
 
 } // end namespace mach_o
 } // end namespace lld
 
-#endif
+#endif // LLD_READER_WRITER_MACHO_FILE_H

lld/trunk/lib/ReaderWriter/MachO/GOTPass.cpp

-//===- lib/ReaderWriter/MachO/GOTPass.cpp ---------------------------------===//
+//===- lib/ReaderWriter/MachO/GOTPass.cpp -----------------------*- C++ -*-===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 ///

 #include "lld/Core/Reference.h"
 #include "lld/Core/Simple.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/STLExtras.h"
 
 namespace lld {
 namespace mach_o {
 
-
 //
 //  GOT Entry Atom created by the GOT pass.
 //
 class GOTEntryAtom : public SimpleDefinedAtom {
 public:
   GOTEntryAtom(const File &file, bool is64, StringRef name)
     : SimpleDefinedAtom(file), _is64(is64), _name(name) { }
 
StringRef slotName() const {
     return _name;
   }
 
 private:
   const bool _is64;
   StringRef _name;
 };
 
-
 /// Pass for instantiating and optimizing GOT slots.
 ///
 class GOTPass : public Pass {
 public:
   GOTPass(const MachOLinkingContext &context)
       : _ctx(context), _archHandler(_ctx.archHandler()),
         _file("<mach-o GOT Pass>") {}
 
bool shouldReplaceTargetWithGOTAtom(const Atom *target, bool canBypassGOT) {
     // Target does not require indirection.  So, if instruction allows GOT to be
     // by-passed, do that optimization and don't create GOT entry.
     return !canBypassGOT;
   }
 
   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().
                                                 nonLazyPointerReferenceToBinder;
       gotEntry->addReference(Reference::KindNamespace::mach_o, nlInfo.arch,
                              nlInfo.kind, 0, target, 0);
       return gotEntry;
     }
     return pos->second;
   }
 
   const MachOLinkingContext &_ctx;
   mach_o::ArchHandler                             &_archHandler;
   MachOFile                                        _file;
   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

lld/trunk/lib/ReaderWriter/MachO/MachONormalizedFileBinaryWriter.cpp

void align(unsigned alignment) {
         append_byte(0);
     }
     size_t size() {
       return _ostream.tell();
     }
     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.
     llvm::raw_svector_ostream     _ostream;
   };
 
   struct TrieNode; // Forward declaration.
 
   struct TrieEdge {
     TrieEdge(StringRef s, TrieNode *node) : _subString(s), _child(node) {}
 
     StringRef          _subString;
     struct TrieNode   *_child;
   };
 
   struct TrieNode {
     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;
     uint64_t                  _flags;
     uint64_t                  _other;
     StringRef                 _importedName;
     uint32_t                  _trieOffset;
     bool                      _hasExportInfo;
uint32_t MachOFileLayout::pointerAlign(uint32_t value) {
   return llvm::RoundUpToAlignment(value, _is64 ? 8 : 4);
 }
 
 
 size_t MachOFileLayout::headerAndLoadCommandsSize() const {
   return _endOfLoadCommands;
 }
 
-
 MachOFileLayout::MachOFileLayout(const NormalizedFile &file)
     : _file(file),
       _is64(MachOLinkingContext::is64Bit(file.arch)),
       _swap(!MachOLinkingContext::isHostEndian(file.arch)),
       _bigEndianArch(MachOLinkingContext::isBigEndian(file.arch)),
       _seg1addr(INT64_MAX) {
   _startOfLoadCommands = _is64 ? sizeof(mach_header_64) : sizeof(mach_header);
   const size_t segCommandBaseSize =
_segInfo[&sg].fileSize = llvm::RoundUpToAlignment(segFileSize,
                                                       _file.pageSize);
     fileOffset = llvm::RoundUpToAlignment(fileOffset + segFileSize,
                                           _file.pageSize);
     _addressOfLinkEdit = sg.address + sg.size;
   }
   _startOfLinkEdit = fileOffset;
 }
 
-
 size_t MachOFileLayout::size() const {
   return _endOfSymbolStrings;
 }
 
 void MachOFileLayout::writeMachHeader() {
   mach_header *mh = reinterpret_cast<mach_header*>(_buffer);
   mh->magic = _is64 ? llvm::MachO::MH_MAGIC_64 : llvm::MachO::MH_MAGIC;
   mh->cputype =  MachOLinkingContext::cpuTypeFromArch(_file.arch);
if (_dataInCodeSize != 0) {
       if (_swap)
         swapStruct(*dl);
       lc += sizeof(linkedit_data_command);
     }
   }
   return ec;
 }
 
-
 void MachOFileLayout::writeSectionContent() {
   for (const Section &s : _file.sections) {
     // Copy all section content to output buffer.
     if (s.type == llvm::MachO::S_ZEROFILL)
       continue;
     if (s.content.empty())
       continue;
     uint32_t offset = _sectInfo[&s].fileOffset;
for (Relocation r : sect.relocations) {
       any_relocation_info* rb = reinterpret_cast<any_relocation_info*>(
                                                            &_buffer[relOffset]);
       *rb = packRelocation(r, _swap, _bigEndianArch);
       relOffset += sizeof(any_relocation_info);
     }
   }
 }
 
-
 void MachOFileLayout::appendSymbols(const std::vector<Symbol> &symbols,
                                    uint32_t &symOffset, uint32_t &strOffset) {
   for (const Symbol &sym : symbols) {
     if (_is64) {
       nlist_64* nb = reinterpret_cast<nlist_64*>(&_buffer[symOffset]);
       nb->n_strx = strOffset - _startOfSymbolStrings;
       nb->n_type = sym.type | sym.scope;
       nb->n_sect = sym.sect;
if (partialStr.startswith(edgeStr)) {
       return;
     }
     // See if string has commmon prefix with existing edge.
     for (int n=edgeStr.size()-1; n > 0; --n) {
       if (partialStr.substr(0, n).equals(edgeStr.substr(0, n))) {
         // 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);
         StringRef bcEdgeStr = edgeStr.substr(n).copy(allocator);
         DEBUG_WITH_TYPE("trie-builder", llvm::dbgs()
                         << "splice in TrieNode('" << bNodeStr
                         << "') between edge '"
                         << abEdgeStr << "' and edge='"
                         << bcEdgeStr<< "'\n");
         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;
       }
     }
   }
   if (entry.flags & EXPORT_SYMBOL_FLAGS_REEXPORT) {
     assert(entry.otherOffset != 0);
   }
   if (entry.flags & EXPORT_SYMBOL_FLAGS_STUB_AND_RESOLVER) {
     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 '"
                    << partialStr << "' from node='"
                    << _cummulativeString << "'\n");
   newNode->_address = entry.offset;
   newNode->_flags = entry.flags | entry.kind;
   newNode->_other = entry.otherOffset;

 void MachOFileLayout::buildExportTrie() {
   if (_file.exportInfo.empty())
     return;
 
   // For all temporary strings and objects used building trie.
   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);
   for (const Export& entry : _file.exportInfo) {
     rootNode->addSymbol(entry, allocator, allNodes);
   }
 
   // Assign each node in the vector an offset in the trie stream, iterating
void MachOFileLayout::buildExportTrie() {
 
   // Serialize trie to ByteBuffer.
   for (TrieNode* node : allNodes) {
     node->appendToByteBuffer(_exportTrie);
   }
   _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));
   _symbolTableSize = nlistSize * (_file.localSymbols.size()
                                 + _file.globalSymbols.size()
                                 + _file.undefinedSymbols.size());
   _symbolStringPoolSize = 0;
   for (const Symbol &sym : _file.localSymbols) {
if (ec)
     return ec;
   writeSectionContent();
   writeLinkEditContent();
   fob->commit();
 
   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

lld/trunk/lib/ReaderWriter/MachO/MachONormalizedFileFromAtoms.cpp

struct SegmentInfo {
   std::vector<SectionInfo*>  sections;
   uint32_t                   normalizedSegmentIndex;
 };
 
 SegmentInfo::SegmentInfo(StringRef n)
  : name(n), address(0), size(0), access(0), normalizedSegmentIndex(0) {
 }
 
-
 class Util {
 public:
   Util(const MachOLinkingContext &ctxt)
       : _ctx(ctxt), _archHandler(ctxt.archHandler()), _entryAtom(nullptr),
         _hasTLVDescriptors(false) {}
   ~Util();
 
   void      assignAtomsToSections(const lld::File &atomFile);
SectionInfo *Util::getRelocatableSection(DefinedAtom::ContentType type) {
   // This can happen if two ContentType map to the same mach-o section.
   for (auto sect : _sectionMap) {
     if (sect.second->sectionName.equals(sectionName) &&
         sect.second->segmentName.equals(segmentName)) {
       return sect.second;
     }
   }
   // 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;
   return sect;
 }
 
 #define ENTRY(seg, sect, type, atomType) \
   {seg, sect, type, DefinedAtom::atomType }
ENTRY("__DATA", "__thread_data",    S_THREAD_LOCAL_REGULAR,
                                                           typeTLVInitialData),
   ENTRY("__DATA", "__thread_ptrs",    S_THREAD_LOCAL_VARIABLE_POINTERS,
                                                           typeTLVInitializerPtr),
   ENTRY("__DATA", "__bss",            S_ZEROFILL,         typeZeroFill),
   ENTRY("__DATA", "__interposing",    S_INTERPOSING,      typeInterposingTuples),
 };
 #undef ENTRY
 
-
 SectionInfo *Util::getFinalSection(DefinedAtom::ContentType atomType) {
   for (auto &p : sectsToAtomType) {
     if (p.atomType != atomType)
       continue;
     SectionAttr sectionAttrs = 0;
     switch (atomType) {
     case DefinedAtom::typeCode:
     case DefinedAtom::typeStub:
for (auto &p : sectsToAtomType) {
     // This can happen if two ContentType map to the same mach-o section.
     for (auto sect : _sectionMap) {
       if (sect.second->sectionName.equals(p.sectionName) &&
           sect.second->segmentName.equals(p.segmentName)) {
         return sect.second;
       }
     }
     // 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;
     return 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.
     DefinedAtom::ContentType type = atom->contentType();
     auto pos = _sectionMap.find(type);
     if ( pos != _sectionMap.end() )
       return pos->second;
     bool rMode = (_ctx.outputMachOType() == llvm::MachO::MH_OBJECT);
     return rMode ? getRelocatableSection(type) : getFinalSection(type);
   } else {
     // This atom needs to be in a custom section.
     StringRef customName = atom->customSectionName();
     // Look to see if we have already allocated the needed custom section.
     for(SectionInfo *sect : _customSections) {
       const DefinedAtom *firstAtom = sect->atomsAndOffsets.front().atom;
       if (firstAtom->customSectionName().equals(customName)) {
         return sect;
       }
     }
     // Not found, so need to create a new custom section.
     size_t seperatorIndex = customName.find('/');
     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);
     return 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;
   DefinedAtom::Alignment atomAlign = atom->alignment();
   uint64_t align = atomAlign.value;
   uint64_t requiredModulus = atomAlign.modulus;
   uint64_t currentModulus = (offset % align);
   if ( currentModulus != requiredModulus ) {
void Util::assignAtomsToSections(const lld::File &atomFile) {
   }
 }
 
 SegmentInfo *Util::segmentForName(StringRef segName) {
   for (SegmentInfo *si : _segmentInfos) {
     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"))
     info->access = VM_PROT_READ | VM_PROT_WRITE;
   else if (segName.equals("__PAGEZERO"))
     info->access = 0;
   _segmentInfos.push_back(info);
   return info;
return llvm::StringSwitch<unsigned>(sect->sectionName)
     .Default(10);
 }
 
 bool Util::TextSectionSorter::operator()(const SectionInfo *left,
                                          const SectionInfo *right) {
   return (weight(left) < weight(right));
 }
 
-
 void Util::organizeSections() {
   if (_ctx.outputMachOType() == llvm::MachO::MH_OBJECT) {
     // Leave sections ordered as normalized file specified.
     uint32_t sectionIndex = 1;
     for (SectionInfo *si : _sectionInfos) {
       si->finalSectionIndex = sectionIndex++;
     }
   } else {
if (_ctx.outputMachOType() == llvm::MachO::MH_OBJECT) {
     uint32_t sectionIndex = 1;
     for (SegmentInfo *seg : _segmentInfos) {
       seg->normalizedSegmentIndex = segmentIndex++;
       for (SectionInfo *sect : seg->sections) {
         sect->finalSectionIndex = sectionIndex++;
       }
     }
   }
-
 }
 
-
 void Util::layoutSectionsInSegment(SegmentInfo *seg, uint64_t &addr) {
   seg->address = addr;
   for (SectionInfo *sect : seg->sections) {
     sect->address = llvm::RoundUpToAlignment(addr, sect->alignment);
     addr = sect->address + sect->size;
   }
   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->address = addr;
   // Walks sections starting at end to calculate padding for start.
   int64_t taddr = 0;
   for (auto it = seg->sections.rbegin(); it != seg->sections.rend(); ++it) {
     SectionInfo *sect = *it;
     taddr -= sect->size;
     taddr = taddr & (0 - sect->alignment);
   }
   int64_t padding = taddr - hlcSize;
   while (padding < 0)
     padding += _ctx.pageSize();
   // Start assigning section address starting at padded offset.
   addr += (padding + hlcSize);
   for (SectionInfo *sect : seg->sections) {
     sect->address = llvm::RoundUpToAlignment(addr, sect->alignment);
     addr = sect->address + sect->size;
   }
   seg->size = llvm::RoundUpToAlignment(addr - seg->address, _ctx.pageSize());
 }
 
-
 void Util::assignAddressesToSections(const NormalizedFile &file) {
   size_t hlcSize = headerAndLoadCommandsSize(file);
   uint64_t address = 0;
   if (_ctx.outputMachOType() != llvm::MachO::MH_OBJECT) {
     for (SegmentInfo *seg : _segmentInfos) {
       if (seg->name.equals("__PAGEZERO")) {
         seg->size = _ctx.pageZeroSize();
         address += seg->size;
DEBUG_WITH_TYPE("WriterMachO-norm",
                       << " address= "  << llvm::format("0x%08X", si->address)
                       << " size= "  << llvm::format("0x%08X", si->size)
                       << "\n";
       }
     );
   }
 }
 
-
 void Util::copySegmentInfo(NormalizedFile &file) {
   for (SegmentInfo *sgi : _segmentInfos) {
     Segment seg;
     seg.name    = sgi->name;
     seg.address = sgi->address;
     seg.size    = sgi->size;
     seg.access  = sgi->access;
     file.segments.push_back(seg);
for (AtomInfo &ai : si->atomsAndOffsets) {
                                           (&sectionContent[ai.offsetInSection]);
       _archHandler.generateAtomContent(*ai.atom, r, addrForAtom,
                                        sectionAddrForAtom, _ctx.baseAddress(),
                                        atomContent);
     }
   }
 }
 
-
 void Util::copySectionInfo(NormalizedFile &file) {
   file.sections.reserve(_sectionInfos.size());
   // For final linked images, write sections grouped by segment.
   if (_ctx.outputMachOType() != llvm::MachO::MH_OBJECT) {
     for (SegmentInfo *sgi : _segmentInfos) {
       for (SectionInfo *si : sgi->sections) {
         appendSection(si, file);
       }
uint16_t Util::descBits(const DefinedAtom* atom) {
   if (atom->deadStrip() == DefinedAtom::deadStripNever) {
     if ((atom->contentType() != DefinedAtom::typeInitializerPtr)
      && (atom->contentType() != DefinedAtom::typeTerminatorPtr))
     desc |= N_NO_DEAD_STRIP;
   }
   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) {
   bool rMode = (_ctx.outputMachOType() == llvm::MachO::MH_OBJECT);
   switch (atom->scope()) {
   case Atom::scopeTranslationUnit:
     scope = 0;
     inGlobalsRegion = false;
for (AtomAndIndex &ai : globals) {
     sym.scope = ai.scope;
     sym.sect  = ai.index;
     sym.desc  = descBits(static_cast<const DefinedAtom*>(ai.atom));
     sym.value = _atomToAddress[ai.atom];
     _atomToSymbolIndex[ai.atom] = globalStartIndex + file.globalSymbols.size();
     file.globalSymbols.push_back(sym);
   }
 
-
   // Sort undefined symbol alphabetically, then add to symbol table.
   std::vector<AtomAndIndex> undefs;
   undefs.reserve(128);
   for (const UndefinedAtom *atom : atomFile.undefined()) {
     AtomAndIndex ai = { atom, 0, N_EXT };
     undefs.push_back(ai);
   }
   for (const SharedLibraryAtom *atom : atomFile.sharedLibrary()) {
if (const Atom *ta = ref->target()) {
         if (target)
           return target;
       }
     }
   }
   return nullptr;
 }
 
-
 void Util::addIndirectSymbols(const lld::File &atomFile, NormalizedFile &file) {
   for (SectionInfo *si : _sectionInfos) {
     Section &normSect = file.sections[si->normalizedSectionIndex];
     switch (si->type) {
     case llvm::MachO::S_NON_LAZY_SYMBOL_POINTERS:
       for (const AtomInfo &info : si->atomsAndOffsets) {
         bool foundTarget = false;
         for (const Reference *ref : *info.atom) {
case llvm::MachO::S_SYMBOL_STUBS:
           normSect.indirectSymbols.push_back(index);
         }
       }
       break;
     default:
       break;
     }
   }
-
 }
 
 void Util::addDependentDylibs(const lld::File &atomFile,NormalizedFile &nFile) {
   // Scan all imported symbols and build up list of dylibs they are from.
   int ordinal = 1;
   for (const SharedLibraryAtom *slAtom : atomFile.sharedLibrary()) {
     StringRef loadPath = slAtom->loadName();
     DylibPathToInfo::iterator pos = _dylibInfo.find(loadPath);
for (DependentDylib &dep : nFile.dependentDylibs) {
     DylibInfo &info = _dylibInfo[dep.path];
     if (info.hasWeak && !info.hasNonWeak)
       dep.kind = llvm::MachO::LC_LOAD_WEAK_DYLIB;
     else if (_ctx.isUpwardDylib(dep.path))
       dep.kind = llvm::MachO::LC_LOAD_UPWARD_DYLIB;
   }
 }
 
-
 int Util::dylibOrdinal(const SharedLibraryAtom *sa) {
   return _dylibInfo[sa->loadName()].ordinal;
 }
 
 void Util::segIndexForSection(const SectionInfo *sect, uint8_t &segmentIndex,
                                                   uint64_t &segmentStartAddr) {
   segmentIndex = 0;
   for (const SegmentInfo *seg : _segmentInfos) {
     if ((seg->address <= sect->address)
       && (seg->address+seg->size >= sect->address+sect->size)) {
       segmentStartAddr = seg->address;
       return;
     }
     ++segmentIndex;
   }
   llvm_unreachable("section not in any segment");
 }
 
-
 uint32_t Util::sectionIndexForAtom(const Atom *atom) {
   uint64_t address = _atomToAddress[atom];
   uint32_t index = 1;
   for (const SectionInfo *si : _sectionInfos) {
     if ((si->address <= address) && (address < si->address+si->size))
       return index;
     ++index;
   }
   llvm_unreachable("atom not in any section");
 }
 
 void Util::addSectionRelocs(const lld::File &, NormalizedFile &file) {
   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);
     assert(pos != _atomToSymbolIndex.end());
     return pos->second;
   };
 
   // Utility function for ArchHandler to find section index for an atom.
if (_ctx.outputMachOType() == MH_OBJECT) {
     if (_hasTLVDescriptors)
       flags |= (MH_PIE | MH_HAS_TLV_DESCRIPTORS);
     return flags;
   }
 }
 
 } // end anonymous namespace
 
-
 namespace lld {
 namespace mach_o {
 namespace normalized {
 
 /// Convert a set of Atoms into a normalized mach-o file.
 ErrorOr<std::unique_ptr<NormalizedFile>>
 normalizedFromAtoms(const lld::File &atomFile,
                                            const MachOLinkingContext &context) {
normalizedFromAtoms(const lld::File &atomFile,
   util.addExportInfo(atomFile, normFile);
   util.addSectionRelocs(atomFile, normFile);
   util.buildDataInCodeArray(atomFile, normFile);
   util.copyEntryPointAddress(normFile);
 
   return std::move(f);
 }
 
-
 } // namespace normalized
 } // namespace mach_o
 } // namespace lld

lld/trunk/lib/ReaderWriter/MachO/StubsPass.cpp

-//===- lib/ReaderWriter/MachO/StubsPass.cpp -------------------------------===//
+//===- lib/ReaderWriter/MachO/StubsPass.cpp ---------------------*- C++ -*-===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //

 #include "lld/Core/File.h"
 #include "lld/Core/LLVM.h"
 #include "lld/Core/Reference.h"
 #include "lld/Core/Simple.h"
 #include "lld/ReaderWriter/MachOLinkingContext.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/SmallVector.h"
 
-
 namespace lld {
 namespace mach_o {
 
-
 //
 //  Lazy Pointer Atom created by the stubs pass.
 //
 class LazyPointerAtom : public SimpleDefinedAtom {
 public:
   LazyPointerAtom(const File &file, bool is64)
     : SimpleDefinedAtom(file), _is64(is64) { }
 
static const uint8_t zeros[] =
         { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
     return llvm::makeArrayRef(zeros, size());
   }
 
 private:
   const bool _is64;
 };
 
-
 //
 //  NonLazyPointer (GOT) Atom created by the stubs pass.
 //
 class NonLazyPointerAtom : public SimpleDefinedAtom {
 public:
   NonLazyPointerAtom(const File &file, bool is64)
     : SimpleDefinedAtom(file), _is64(is64) { }
 
static const uint8_t zeros[] =
         { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
     return llvm::makeArrayRef(zeros, size());
   }
 
 private:
   const bool _is64;
 };
 
-
-
 //
 // Stub Atom created by the stubs pass.
 //
 class StubAtom : public SimpleDefinedAtom {
 public:
   StubAtom(const File &file, const ArchHandler::StubInfo &stubInfo)
       : SimpleDefinedAtom(file), _stubInfo(stubInfo){ }
 
public:
   ArrayRef<uint8_t> rawContent() const override {
     return llvm::makeArrayRef(_stubInfo.stubBytes, _stubInfo.stubSize);
   }
 
 private:
   const ArchHandler::StubInfo   &_stubInfo;
 };
 
-
 //
 // Stub Helper Atom created by the stubs pass.
 //
 class StubHelperAtom : public SimpleDefinedAtom {
 public:
   StubHelperAtom(const File &file, const ArchHandler::StubInfo &stubInfo)
       : SimpleDefinedAtom(file), _stubInfo(stubInfo) { }
 
ArrayRef<uint8_t> rawContent() const override {
     return llvm::makeArrayRef(_stubInfo.stubHelperBytes,
                               _stubInfo.stubHelperSize);
   }
 
 private:
   const ArchHandler::StubInfo   &_stubInfo;
 };
 
-
 //
 // Stub Helper Common Atom created by the stubs pass.
 //
 class StubHelperCommonAtom : public SimpleDefinedAtom {
 public:
   StubHelperCommonAtom(const File &file, const ArchHandler::StubInfo &stubInfo)
       : SimpleDefinedAtom(file), _stubInfo(stubInfo) { }
 
ArrayRef<uint8_t> rawContent() const override {
     return llvm::makeArrayRef(_stubInfo.stubHelperCommonBytes,
                         _stubInfo.stubHelperCommonSize);
   }
 
 private:
   const ArchHandler::StubInfo   &_stubInfo;
 };
 
-
 class StubsPass : public Pass {
 public:
   StubsPass(const MachOLinkingContext &context)
       : _ctx(context), _archHandler(_ctx.archHandler()),
         _stubInfo(_archHandler.stubInfo()), _file("<mach-o Stubs pass>") {}
 
   std::error_code perform(SimpleFile &mergedFile) override {
     // Skip this pass if output format uses text relocations instead of stubs.
std::error_code perform(SimpleFile &mergedFile) override {
     std::sort(targetsNeedingStubs.begin(), targetsNeedingStubs.end(),
               [](const Atom * left, const Atom * right) {
       return (left->name().compare(right->name()) < 0);
     });
 
     // 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 =
-          new (_file.allocator()) StubHelperAtom(_file, _stubInfo);
+      auto *helper = new (_file.allocator()) StubHelperAtom(_file, _stubInfo);
 
       addReference(stub, _stubInfo.stubReferenceToLP, lp);
       addOptReference(stub, _stubInfo.stubReferenceToLP,
                       _stubInfo.optStubReferenceToLP, lp);
       addReference(lp, _stubInfo.lazyPointerReferenceToHelper, helper);
       addReference(lp, _stubInfo.lazyPointerReferenceToFinal, target);
       addReference(helper, _stubInfo.stubHelperReferenceToImm, helper);
       addReferenceAddend(helper, _stubInfo.stubHelperReferenceToImm, helper,
for (const Atom *target : targetsNeedingStubs) {
       // Calculate new offset
       lazyOffset += target->name().size() + 12;
     }
 
     return std::error_code();
   }
 
 private:
-
   bool noTextRelocs() {
     return true;
   }
 
   bool isCallSite(const Reference &ref) {
     return _archHandler.isCallSite(ref);
   }
 
private:
 
   const MachOLinkingContext &_ctx;
   mach_o::ArchHandler                            &_archHandler;
   const ArchHandler::StubInfo                    &_stubInfo;
   MachOFile                                       _file;
   TargetToUses                                    _targetToUses;
 };
 
-
-
 void addStubsPass(PassManager &pm, const MachOLinkingContext &ctx) {
   pm.add(std::unique_ptr<Pass>(new StubsPass(ctx)));
 }
 
 } // end namespace mach_o
 } // end namespace lld

lld/trunk/lib/ReaderWriter/MachO/TLVPass.cpp

-//===- lib/ReaderWriter/MachO/TLVPass.cpp ---------------------------------===//
+//===- lib/ReaderWriter/MachO/TLVPass.cpp -----------------------*- C++ -*-===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 ///

 
 class TLVPass : public Pass {
 public:
   TLVPass(const MachOLinkingContext &context)
       : _ctx(context), _archHandler(_ctx.archHandler()),
         _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()) {
       for (const Reference *ref : *atom) {
         if (!_archHandler.isTLVAccess(*ref))
           continue;
 
         if (!allowTLV)
private:
   }
 
   const DefinedAtom *makeTLVPEntry(const Atom *target) {
     auto pos = _targetToTLVP.find(target);
 
     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 =
       _archHandler.stubInfo().nonLazyPointerReferenceToBinder;
     tlvpEntry->addReference(Reference::KindNamespace::mach_o, nlInfo.arch,
                             nlInfo.kind, 0, target, 0);
     return tlvpEntry;
   }
 
   const MachOLinkingContext &_ctx;
   mach_o::ArchHandler &_archHandler;
   MachOFile _file;
   llvm::DenseMap<const Atom*, const TLVPEntryAtom*> _targetToTLVP;
 };
 
 void addTLVPass(PassManager &pm, const MachOLinkingContext &ctx) {
   assert(ctx.needsTLVPass());
   pm.add(llvm::make_unique<TLVPass>(ctx));
 }
 
-
 } // end namesapce mach_o
 } // end namesapce lld