[lld-macho][nfc] Run clang-format on lld/MachO/*.{h,cpp}

[oontvoo]

Summary

• fixed inconsistent indents and spaces
• prevent extraneous formatting changes in other patches

[smeenai]

LGTM, thanks. I'm surprised these weren't caught by the lint running on the diffs where they were introduced.

[oontvoo]

thanks!

lld/MachO/ConcatOutputSection.cpp

for (Reloc &r : reverse(relocs)) {
       // on the thunk isec so that asserts that check that only live sections
       // get written are happy.
       thunkInfo.isec->live = true;
 
       StringRef thunkName = saver().save(funcSym->getName() + ".thunk." +
                                          std::to_string(thunkInfo.sequence++));
       if (!isa<Defined>(funcSym) || cast<Defined>(funcSym)->isExternal()) {
         r.referent = thunkInfo.sym = symtab->addDefined(
-            thunkName, /*file=*/nullptr, thunkInfo.isec, /*value=*/0,
-            thunkSize, /*isWeakDef=*/false, /*isPrivateExtern=*/true,
+            thunkName, /*file=*/nullptr, thunkInfo.isec, /*value=*/0, thunkSize,
+            /*isWeakDef=*/false, /*isPrivateExtern=*/true,
             /*isThumb=*/false, /*isReferencedDynamically=*/false,
             /*noDeadStrip=*/false, /*isWeakDefCanBeHidden=*/false);
       } else {
         r.referent = thunkInfo.sym = make<Defined>(
             thunkName, /*file=*/nullptr, thunkInfo.isec, /*value=*/0, thunkSize,
             /*isWeakDef=*/false, /*isExternal=*/false, /*isPrivateExtern=*/true,
             /*includeInSymtab=*/true, /*isThumb=*/false,
             /*isReferencedDynamically=*/false, /*noDeadStrip=*/false,

lld/MachO/InputFiles.cpp

 // symbol boundaries, we split them based on size. Records are distinct from
 // literals in that they may contain references to other sections, instead of
 // being leaf nodes in the InputSection graph.
 //
 // Note that "record" is a term I came up with. In contrast, "literal" is a term
 // used by the Mach-O format.
 static Optional<size_t> getRecordSize(StringRef segname, StringRef name) {
   if (name == section_names::compactUnwind) {
-      if (segname == segment_names::ld)
-        return target->wordSize == 8 ? 32 : 20;
   }
   if (config->icfLevel == ICFLevel::none)
     return {};
 
   if (name == section_names::cfString && segname == segment_names::data)
     return target->wordSize == 8 ? 32 : 16;
   if (name == section_names::objcClassRefs && segname == segment_names::data)
     return target->wordSize;
error(message("has width " + std::to_string(1 << rel.r_length) +
                   widths[(static_cast<int>(relocAttrs.bits) >> 2) & 3] +
                   " bytes"));
   }
   return valid;
 }
 
 template <class SectionHeader>
 void ObjFile::parseRelocations(ArrayRef<SectionHeader> sectionHeaders,
-                               const SectionHeader &sec,
-                               Section &section) {
+                               const SectionHeader &sec, Section &section) {
   auto *buf = reinterpret_cast<const uint8_t *>(mb.getBufferStart());
   ArrayRef<relocation_info> relInfos(
       reinterpret_cast<const relocation_info *>(buf + sec.reloff), sec.nreloc);
 
   Subsections &subsections = section.subsections;
   auto subsecIt = subsections.rbegin();
   for (size_t i = 0; i < relInfos.size(); i++) {
     // Paired relocations serve as Mach-O's method for attaching a

lld/MachO/InputSection.h

InputSection(const InputSection &rhs)
       : sectionKind(rhs.sectionKind), align(rhs.align), data(rhs.data),
         section(rhs.section) {}
 
   Kind sectionKind;
 
 public:
   // is address assigned?
   bool isFinal = false;
-  // keep the address of the symbol(s) in this section unique in the final binary ?
+  // keep the address of the symbol(s) in this section unique in the final
+  // binary ?
   bool keepUnique = false;
   uint32_t align = 1;
 
   OutputSection *parent = nullptr;
   ArrayRef<uint8_t> data;
   std::vector<Reloc> relocs;
   // The symbols that belong to this InputSection, sorted by value. With
   // .subsections_via_symbols, there is typically only one element here.

lld/MachO/MarkLive.cpp

do {
     // Mark things reachable from GC roots as live.
     while (!worklist.empty()) {
       WorklistEntry *entry = worklist.pop_back_val();
       // Entries that get placed onto the worklist always contain
       // ConcatInputSections. `WhyLiveEntry::prev` may point to entries that
       // contain other types of InputSections (due to S_ATTR_LIVE_SUPPORT), but
       // those entries should never be pushed onto the worklist.
       auto *isec = cast<ConcatInputSection>(getInputSection(entry));
-      assert(isec->live &&
-             "We mark as live when pushing onto the worklist!");
+      assert(isec->live && "We mark as live when pushing onto the worklist!");
 
       // Mark all symbols listed in the relocation table for this section.
       for (const Reloc &r : isec->relocs) {
         if (auto *s = r.referent.dyn_cast<Symbol *>())
           addSym(s, entry);
         else
           enqueue(r.referent.get<InputSection *>(), r.addend, entry);
       }

lld/MachO/OutputSection.cpp

 //===- OutputSection.cpp --------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "OutputSection.h"
 #include "OutputSegment.h"
 
 using namespace llvm;
 using namespace lld;
 using namespace lld::macho;
 
-uint64_t OutputSection::getSegmentOffset() const {
-  return addr - parent->addr;
-}
+uint64_t OutputSection::getSegmentOffset() const { return addr - parent->addr; }
 
 void OutputSection::assignAddressesToStartEndSymbols() {
   for (Defined *d : sectionStartSymbols)
     d->value = addr;
   for (Defined *d : sectionEndSymbols)
     d->value = addr + getSize();
 }

lld/MachO/SyntheticSections.cpp

 // BIND_OPCODE_DONE terminator. As such, unlike in the non-lazy-binding case,
 // we cannot encode just the differences between symbols; we have to emit the
 // complete bind information for each symbol.
 uint32_t LazyBindingSection::encode(const Symbol &sym) {
   uint32_t opstreamOffset = contents.size();
   OutputSegment *dataSeg = in.lazyPointers->parent;
   os << static_cast<uint8_t>(BIND_OPCODE_SET_SEGMENT_AND_OFFSET_ULEB |
                              dataSeg->index);
-  uint64_t offset = in.lazyPointers->addr - dataSeg->addr +
-                    sym.stubsIndex * target->wordSize;
+  uint64_t offset =
+      in.lazyPointers->addr - dataSeg->addr + sym.stubsIndex * target->wordSize;
   encodeULEB128(offset, os);
   encodeDylibOrdinal(ordinalForSymbol(sym), os);
 
   uint8_t flags = BIND_OPCODE_SET_SYMBOL_TRAILING_FLAGS_IMM;
   if (sym.isWeakRef())
     flags |= BIND_SYMBOL_FLAGS_WEAK_IMPORT;
 
   os << flags << sym.getName() << '\0'

lld/MachO/Writer.cpp

void Writer::finalizeAddresses() {
   for (OutputSegment *seg : outputSegments) {
     if (seg == linkEditSegment)
       continue;
     for (OutputSection *osec : seg->getSections()) {
       if (!osec->isNeeded())
         continue;
       // Other kinds of OutputSections have already been finalized.
       if (auto concatOsec = dyn_cast<ConcatOutputSection>(osec))
-          concatOsec->finalizeContents();
     }
   }
 
   // Ensure that segments (and the sections they contain) are allocated
   // addresses in ascending order, which dyld requires.
   //
   // Note that at this point, __LINKEDIT sections are empty, but we need to
   // determine addresses of other segments/sections before generating its