[lld-macho][nfc][cleanup] Fix a few code style lints and clang-tidy findings - Use .empty() instead of `size() == 0` when possible. - Use const-ref to avoid copying

[int3]

Thanks!

lld/MachO/ConcatOutputSection.cpp

log("thunks for " + parent->name + "," + name +
       ", thunks = " + std::to_string(thunkCount));
 }
 
 void ConcatOutputSection::writeTo(uint8_t *buf) const {
   // Merge input sections from thunk & ordinary vectors
   size_t i = 0, ie = inputs.size();
   size_t t = 0, te = thunks.size();
   while (i < ie || t < te) {
-    while (i < ie && (t == te || inputs[i]->getSize() == 0 ||
+    while (i < ie && (t == te || inputs[i]->empty() ||
                       inputs[i]->outSecOff < thunks[t]->outSecOff)) {
       inputs[i]->writeTo(buf + inputs[i]->outSecOff);
       ++i;
     }
     while (t < te && (i == ie || thunks[t]->outSecOff < inputs[i]->outSecOff)) {
       thunks[t]->writeTo(buf + thunks[t]->outSecOff);
       ++t;
     }

lld/MachO/Driver.cpp

getSearchPaths(unsigned optionCode, InputArgList &args,
   return paths;
 }
 
 static std::vector<StringRef> getSystemLibraryRoots(InputArgList &args) {
   std::vector<StringRef> roots;
   for (const Arg *arg : args.filtered(OPT_syslibroot))
     roots.push_back(arg->getValue());
   // NOTE: the final `-syslibroot` being `/` will ignore all roots
-  if (roots.size() && roots.back() == "/")
+  if (!roots.empty() && roots.back() == "/")
     roots.clear();
   // NOTE: roots can never be empty - add an empty root to simplify the library
   // and framework search path computation.
   if (roots.empty())
     roots.emplace_back("");
   return roots;
 }
 
auto add = [&ltoPolicy](Twine val) {
     if (!ltoPolicy.empty())
       ltoPolicy += ":";
     val.toVector(ltoPolicy);
   };
   for (const Arg *arg :
        args.filtered(OPT_thinlto_cache_policy, OPT_prune_interval_lto,
                      OPT_prune_after_lto, OPT_max_relative_cache_size_lto)) {
     switch (arg->getOption().getID()) {
-    case OPT_thinlto_cache_policy: add(arg->getValue()); break;
+    case OPT_thinlto_cache_policy:
+      add(arg->getValue());
+      break;
     case OPT_prune_interval_lto:
       if (!strcmp("-1", arg->getValue()))
         add("prune_interval=87600h"); // 10 years
       else
         add(Twine("prune_interval=") + arg->getValue() + "s");
       break;
     case OPT_prune_after_lto:
       add(Twine("prune_after=") + arg->getValue() + "s");

lld/MachO/InputFiles.cpp

if (sec.align >= 32) {
       subsections.push_back({});
       continue;
     }
     uint32_t align = 1 << sec.align;
     uint32_t flags = sec.flags;
 
     auto splitRecords = [&](int recordSize) -> void {
       subsections.push_back({});
-      if (data.size() == 0)
+      if (data.empty())
         return;
 
       SubsectionMap &subsecMap = subsections.back();
       subsecMap.reserve(data.size() / recordSize);
       auto *isec = make<ConcatInputSection>(
           segname, name, this, data.slice(0, recordSize), align, flags);
       subsecMap.push_back({0, isec});
       for (uint64_t off = recordSize; off < data.size(); off += recordSize) {
macho::Symbol *ObjFile::parseNonSectionSymbol(const NList &sym,
   case N_SECT:
     llvm_unreachable(
         "N_SECT symbols should not be passed to parseNonSectionSymbol");
   default:
     llvm_unreachable("invalid symbol type");
   }
 }
 
-template <class NList>
-static bool isUndef(const NList &sym) {
+template <class NList> static bool isUndef(const NList &sym) {
   return (sym.n_type & N_TYPE) == N_UNDF && sym.n_value == 0;
 }
 
 template <class LP>
 void ObjFile::parseSymbols(ArrayRef<typename LP::section> sectionHeaders,
                            ArrayRef<typename LP::nlist> nList,
                            const char *strtab, bool subsectionsViaSymbols) {
   using NList = typename LP::nlist;
case SymbolKind::ObjectiveCInstanceVariable:
       break;
     }
   }
 }
 
 void DylibFile::parseReexports(const InterfaceFile &interface) {
   const InterfaceFile *topLevel =
       interface.getParent() == nullptr ? &interface : interface.getParent();
-  for (InterfaceFileRef intfRef : interface.reexportedLibraries()) {
+  for (const InterfaceFileRef &intfRef : interface.reexportedLibraries()) {
     InterfaceFile::const_target_range targets = intfRef.targets();
     if (is_contained(skipPlatformChecks, intfRef.getInstallName()) ||
         is_contained(targets, config->platformInfo.target))
       loadReexport(intfRef.getInstallName(), exportingFile, topLevel);
   }
 }
 
 // $ld$ symbols modify the properties/behavior of the library (e.g. its install

lld/MachO/InputSection.h

enum Kind {
     ConcatKind,
     CStringLiteralKind,
     WordLiteralKind,
   };
 
   Kind kind() const { return shared->sectionKind; }
   virtual ~InputSection() = default;
   virtual uint64_t getSize() const { return data.size(); }
+  virtual bool empty() const { return data.empty(); }
   InputFile *getFile() const { return shared->file; }
   StringRef getName() const { return shared->name; }
   StringRef getSegName() const { return shared->segname; }
   uint32_t getFlags() const { return shared->flags; }
   uint64_t getFileSize() const;
   // Translates \p off -- an offset relative to this InputSection -- into an
   // offset from the beginning of its parent OutputSection.
   virtual uint64_t getOffset(uint64_t off) const = 0;
ConcatInputSection(StringRef segname, StringRef name)
                            /*data=*/{},
                            /*align=*/1, /*flags=*/0) {}
 
   uint64_t getOffset(uint64_t off) const override { return outSecOff + off; }
   uint64_t getVA() const { return InputSection::getVA(0); }
   // ConcatInputSections are entirely live or dead, so the offset is irrelevant.
   bool isLive(uint64_t off) const override { return live; }
   void markLive(uint64_t off) override { live = true; }
-  bool isCoalescedWeak() const { return wasCoalesced && symbols.size() == 0; }
+  bool isCoalescedWeak() const { return wasCoalesced && symbols.empty(); }
   bool shouldOmitFromOutput() const { return !live || isCoalescedWeak(); }
   bool isHashableForICF() const;
   void hashForICF();
   void writeTo(uint8_t *buf);
 
   void foldIdentical(ConcatInputSection *redundant);
   ConcatInputSection *canonical() override {
     return replacement ? replacement : this;

lld/MachO/InputSection.cpp

if (it == symbols.end()) {
       std::swap(*it++, *copyIt);
     } else {
       ++it;
     }
   }
   copy->symbols.clear();
 
   // Remove duplicate compact unwind info for symbols at the same address.
-  if (symbols.size() == 0)
+  if (symbols.empty())
     return;
   it = symbols.begin();
   uint64_t v = (*it)->value;
   for (++it; it != symbols.end(); ++it) {
     if ((*it)->value == v)
       (*it)->compactUnwind = nullptr;
     else
       v = (*it)->value;

lld/MachO/UnwindInfoSection.cpp

if (page.kind == UNWIND_SECOND_LEVEL_COMPRESSED) {
       for (size_t i = 0; i < page.entryCount; i++) {
         const CompactUnwindEntry<Ptr> *cuep = cuPtrVector[page.entryIndex + i];
         auto it = commonEncodingIndexes.find(cuep->encoding);
         if (it == commonEncodingIndexes.end())
           it = page.localEncodingIndexes.find(cuep->encoding);
         *ep++ = (it->second << COMPRESSED_ENTRY_FUNC_OFFSET_BITS) |
                 (cuep->functionAddress - functionAddressBase);
       }
-      if (page.localEncodings.size() != 0)
+      if (!page.localEncodings.empty())
         memcpy(ep, page.localEncodings.data(),
                page.localEncodings.size() * sizeof(uint32_t));
     } else {
       auto *p2p =
           reinterpret_cast<unwind_info_regular_second_level_page_header *>(pp);
       p2p->kind = page.kind;
       p2p->entryPageOffset =
           sizeof(unwind_info_regular_second_level_page_header);