[lld-macho][NFC] when reasonable, replace auto keyword with type names

[gkm]

Summary

lld policy discourages auto. Replace it with a type name whenever reasonable. Retain auto to avoid ...

• redundancy, as for decls such as auto *t = mumble_cast<TYPE *> or similar that specifies the result type on the RHS
• verbosity, as for iterators
• gratuitous suffering, as for lambdas

Along the way, add const when appropriate.

Note: a future diff will ...

• add more const qualifiers
• remove opt:: when we are already using llvm::opt

[int3]

Thanks!

[thakis]

Thank you for this change!

lld/MachO/Driver.cpp

for (StringRef path : args::getStrings(args, optionCode)) {
     if (!found && warnIfNotDirectory(optionLetter, path))
       paths.push_back(path);
   }
 
   // `-Z` suppresses the standard "system" search paths.
   if (args.hasArg(OPT_Z))
     return paths;
 
-  for (auto const &path : systemPaths) {
-    for (auto root : roots) {
+  for (const StringRef &path : systemPaths) {
+    for (const StringRef &root : roots) {
       SmallString<261> buffer(root);
       path::append(buffer, path);
       if (fs::is_directory(buffer))
         paths.push_back(saver.save(buffer.str()));
     }
   }
   return paths;
 }

 static InputFile *addFile(StringRef path, bool forceLoadArchive,
                           bool isBundleLoader = false) {
   Optional<MemoryBufferRef> buffer = readFile(path);
   if (!buffer)
     return nullptr;
   MemoryBufferRef mbref = *buffer;
   InputFile *newFile = nullptr;
 
-  auto magic = identify_magic(mbref.getBuffer());
+  file_magic magic = identify_magic(mbref.getBuffer());
   switch (magic) {
   case file_magic::archive: {
     std::unique_ptr<object::Archive> file = CHECK(
         object::Archive::create(mbref), path + ": failed to parse archive");
 
     if (!file->isEmpty() && !file->hasSymbolTable())
       error(path + ": archive has no index; run ranlib to add one");
 
void macho::parseLCLinkerOption(InputFile* f, unsigned argc, StringRef data) {
   if (argv.size() != argc || offset > data.size())
     fatal(toString(f) + ": invalid LC_LINKER_OPTION");
 
   MachOOptTable table;
   unsigned missingIndex, missingCount;
   opt::InputArgList args = table.ParseArgs(argv, missingIndex, missingCount);
   if (missingCount)
     fatal(Twine(args.getArgString(missingIndex)) + ": missing argument");
-  for (auto *arg : args.filtered(OPT_UNKNOWN))
+  for (const Arg *arg : args.filtered(OPT_UNKNOWN))
     error("unknown argument: " + arg->getAsString(args));
 
-  for (auto *arg : args) {
+  for (const Arg *arg : args) {
     switch (arg->getOption().getID()) {
     case OPT_l:
       addLibrary(arg->getValue(), false);
       break;
     case OPT_framework:
       addFramework(arg->getValue(), false);
       break;
     default:

 static void initLLVM() {
   InitializeAllTargets();
   InitializeAllTargetMCs();
   InitializeAllAsmPrinters();
   InitializeAllAsmParsers();
 }
 
 static void compileBitcodeFiles() {
-  auto lto = make<BitcodeCompiler>();
+  auto *lto = make<BitcodeCompiler>();
   for (InputFile *file : inputFiles)
     if (auto *bitcodeFile = dyn_cast<BitcodeFile>(file))
       lto->add(*bitcodeFile);
 
   for (ObjFile *file : lto->compile())
     inputFiles.insert(file);
 }
 
static void warnIfUnimplementedOption(const opt::Option &opt) {
   default:
     warn("Option `" + opt.getPrefixedName() +
          "' is not yet implemented. Stay tuned...");
     break;
   }
 }
 
 static const char *getReproduceOption(opt::InputArgList &args) {
-  if (auto *arg = args.getLastArg(OPT_reproduce))
+  if (const Arg *arg = args.getLastArg(OPT_reproduce))
     return arg->getValue();
   return getenv("LLD_REPRODUCE");
 }
 
 static bool isPie(opt::InputArgList &args) {
   if (config->outputType != MH_EXECUTE || args.hasArg(OPT_no_pie))
     return false;
   if (config->target.Arch == AK_arm64 || config->target.Arch == AK_arm64e)

 bool SymbolPatterns::match(StringRef symbolName) const {
   return matchLiteral(symbolName) || matchGlob(symbolName);
 }
 
 static void handleSymbolPatterns(opt::InputArgList &args,
                                  SymbolPatterns &symbolPatterns,
                                  unsigned singleOptionCode,
                                  unsigned listFileOptionCode) {
-  for (opt::Arg *arg : args.filtered(singleOptionCode))
+  for (const Arg *arg : args.filtered(singleOptionCode))
     symbolPatterns.insert(arg->getValue());
-  for (opt::Arg *arg : args.filtered(listFileOptionCode)) {
+  for (const Arg *arg : args.filtered(listFileOptionCode)) {
     StringRef path = arg->getValue();
     Optional<MemoryBufferRef> buffer = readFile(path);
     if (!buffer) {
       error("Could not read symbol file: " + path);
       continue;
     }
     MemoryBufferRef mbref = *buffer;
     for (StringRef line : args::getLines(mbref)) {
bool macho::link(ArrayRef<const char *> argsArr, bool canExitEarly,
 
   config = make<Configuration>();
   symtab = make<SymbolTable>();
   target = createTargetInfo(args);
 
   config->entry = symtab->addUndefined(args.getLastArgValue(OPT_e, "_main"),
                                        /*file=*/nullptr,
                                        /*isWeakRef=*/false);
-  for (auto *arg : args.filtered(OPT_u)) {
+  for (const Arg *arg : args.filtered(OPT_u)) {
     config->explicitUndefineds.push_back(symtab->addUndefined(
         arg->getValue(), /*file=*/nullptr, /*isWeakRef=*/false));
   }
 
-  for (auto *arg : args.filtered(OPT_U))
+  for (const Arg *arg : args.filtered(OPT_U))
     symtab->addDynamicLookup(arg->getValue());
 
   config->outputFile = args.getLastArgValue(OPT_o, "a.out");
   config->installName =
       args.getLastArgValue(OPT_install_name, config->outputFile);
   config->headerPad = args::getHex(args, OPT_headerpad, /*Default=*/32);
   config->headerPadMaxInstallNames =
       args.hasArg(OPT_headerpad_max_install_names);
bool macho::link(ArrayRef<const char *> argsArr, bool canExitEarly,
   // Reject every special character except '.' and '$'
   // TODO(gkm): verify that this is the proper set of invalid chars
   StringRef invalidNameChars("!\"#%&'()*+,-/:;<=>?@[\\]^`{|}~");
   auto validName = [invalidNameChars](StringRef s) {
     if (s.find_first_of(invalidNameChars) != StringRef::npos)
       error("invalid name for segment or section: " + s);
     return s;
   };
-  for (opt::Arg *arg : args.filtered(OPT_rename_section)) {
+  for (const Arg *arg : args.filtered(OPT_rename_section)) {
     config->sectionRenameMap[{validName(arg->getValue(0)),
                               validName(arg->getValue(1))}] = {
         validName(arg->getValue(2)), validName(arg->getValue(3))};
   }
-  for (opt::Arg *arg : args.filtered(OPT_rename_segment)) {
+  for (const Arg *arg : args.filtered(OPT_rename_segment)) {
     config->segmentRenameMap[validName(arg->getValue(0))] =
         validName(arg->getValue(1));
   }
 
   handleSymbolPatterns(args, config->exportedSymbols, OPT_exported_symbol,
                        OPT_exported_symbols_list);
   handleSymbolPatterns(args, config->unexportedSymbols, OPT_unexported_symbol,
                        OPT_unexported_symbols_list);
message(StringRef("Framework search paths:") +
                  ? "\n\t" + join(config->frameworkSearchPaths, "\n\t")
                  : ""));
   }
 
   initLLVM(); // must be run before any call to addFile()
 
   // This loop should be reserved for options whose exact ordering matters.
   // Other options should be handled via filtered() and/or getLastArg().
-  for (const auto &arg : args) {
-    const auto &opt = arg->getOption();
+  for (const Arg *arg : args) {
+    const Option &opt = arg->getOption();
     warnIfDeprecatedOption(opt);
     warnIfUnimplementedOption(opt);
 
     switch (opt.getID()) {
     case OPT_INPUT:
       addFile(arg->getValue(), false);
       break;
     case OPT_weak_library:
for (const Arg *arg : args) {
     }
   }
 
   config->isPic = config->outputType == MH_DYLIB ||
                   config->outputType == MH_BUNDLE || isPie(args);
 
   // Now that all dylibs have been loaded, search for those that should be
   // re-exported.
-  for (opt::Arg *arg : args.filtered(OPT_sub_library, OPT_sub_umbrella)) {
+  for (const Arg *arg : args.filtered(OPT_sub_library, OPT_sub_umbrella)) {
     config->hasReexports = true;
     StringRef searchName = arg->getValue();
     std::vector<StringRef> extensions;
     if (arg->getOption().getID() == OPT_sub_library)
       extensions = {".dylib", ".tbd"};
     else
       extensions = {".tbd"};
     if (!markReexport(searchName, extensions))
       error(arg->getSpelling() + " " + searchName +
             " does not match a supplied dylib");
   }
 
   // Parse LTO options.
-  if (auto *arg = args.getLastArg(OPT_mcpu))
+  if (const Arg *arg = args.getLastArg(OPT_mcpu))
     parseClangOption(saver.save("-mcpu=" + StringRef(arg->getValue())),
                      arg->getSpelling());
 
-  for (auto *arg : args.filtered(OPT_mllvm))
+  for (const Arg *arg : args.filtered(OPT_mllvm))
     parseClangOption(arg->getValue(), arg->getSpelling());
 
   compileBitcodeFiles();
   replaceCommonSymbols();
 
   StringRef orderFile = args.getLastArgValue(OPT_order_file);
   if (!orderFile.empty())
     parseOrderFile(orderFile);
 
   if (config->outputType == MH_EXECUTE && isa<Undefined>(config->entry)) {
     error("undefined symbol: " + toString(*config->entry));
     return false;
   }
   // FIXME: This prints symbols that are undefined both in input files and
   // via -u flag twice.
-  for (const auto *undefined : config->explicitUndefineds) {
+  for (const Symbol *undefined : config->explicitUndefineds) {
     if (isa<Undefined>(undefined)) {
       error("undefined symbol: " + toString(*undefined) +
             "\n>>> referenced by flag -u " + toString(*undefined));
       return false;
     }
   }
 
   createSyntheticSections();
   symtab->addDSOHandle(in.header);
 
-  for (opt::Arg *arg : args.filtered(OPT_sectcreate)) {
+  for (const Arg *arg : args.filtered(OPT_sectcreate)) {
     StringRef segName = arg->getValue(0);
     StringRef sectName = arg->getValue(1);
     StringRef fileName = arg->getValue(2);
     Optional<MemoryBufferRef> buffer = readFile(fileName);
     if (buffer)
       inputFiles.insert(make<OpaqueFile>(*buffer, segName, sectName));
   }
 
   // Initialize InputSections.
   for (InputFile *file : inputFiles) {
     for (SubsectionMap &map : file->subsections) {
-      for (auto &p : map) {
+      for (const auto &p : map) {
         InputSection *isec = p.second;
         inputSections.push_back(isec);
       }
     }
   }
 
   // Write to an output file.
   writeResult();
 
   if (canExitEarly)
     exitLld(errorCount() ? 1 : 0);
 
   return !errorCount();
 }

lld/MachO/DriverUtils.cpp

 #undef OPTION
 };
 
 MachOOptTable::MachOOptTable() : OptTable(optInfo) {}
 
 // Set color diagnostics according to --color-diagnostics={auto,always,never}
 // or --no-color-diagnostics flags.
 static void handleColorDiagnostics(opt::InputArgList &args) {
-  auto *arg = args.getLastArg(OPT_color_diagnostics, OPT_color_diagnostics_eq,
-                              OPT_no_color_diagnostics);
+  const Arg *arg =
+      args.getLastArg(OPT_color_diagnostics, OPT_color_diagnostics_eq,
   if (!arg)
     return;
   if (arg->getOption().getID() == OPT_color_diagnostics) {
     lld::errs().enable_colors(true);
   } else if (arg->getOption().getID() == OPT_no_color_diagnostics) {
     lld::errs().enable_colors(false);
   } else {
     StringRef s = arg->getValue();

 
 // Reconstructs command line arguments so that so that you can re-run
 // the same command with the same inputs. This is for --reproduce.
 std::string macho::createResponseFile(const opt::InputArgList &args) {
   SmallString<0> data;
   raw_svector_ostream os(data);
 
   // Copy the command line to the output while rewriting paths.
-  for (auto *arg : args) {
+  for (const Arg *arg : args) {
     switch (arg->getOption().getID()) {
     case OPT_reproduce:
       break;
     case OPT_INPUT:
       os << quote(rewritePath(arg->getValue())) << "\n";
       break;
     case OPT_o:
       os << "-o " << quote(path::filename(arg->getValue())) << "\n";

lld/MachO/InputFiles.cpp

 
 SetVector<InputFile *> macho::inputFiles;
 std::unique_ptr<TarWriter> macho::tar;
 int InputFile::idCount = 0;
 
 // Open a given file path and return it as a memory-mapped file.
 Optional<MemoryBufferRef> macho::readFile(StringRef path) {
   // Open a file.
-  auto mbOrErr = MemoryBuffer::getFile(path);
-  if (auto ec = mbOrErr.getError()) {
+  ErrorOr<std::unique_ptr<MemoryBuffer>> mbOrErr = MemoryBuffer::getFile(path);
+  if (std::error_code ec = mbOrErr.getError()) {
     error("cannot open " + path + ": " + ec.message());
     return None;
   }
 
   std::unique_ptr<MemoryBuffer> &mb = *mbOrErr;
   MemoryBufferRef mbref = mb->getMemBufferRef();
   make<std::unique_ptr<MemoryBuffer>>(std::move(mb)); // take mb ownership
 
DylibFile::DylibFile(const InterfaceFile &interface, DylibFile *umbrella,
   DylibFile *exportingFile = isImplicitlyLinked(dylibName) ? this : umbrella;
   auto addSymbol = [&](const Twine &name) -> void {
     symbols.push_back(symtab->addDylib(saver.save(name), exportingFile,
                                        /*isWeakDef=*/false,
                                        /*isTlv=*/false));
   };
   // TODO(compnerd) filter out symbols based on the target platform
   // TODO: handle weak defs, thread locals
-  for (const auto symbol : interface.symbols()) {
+  for (const auto *symbol : interface.symbols()) {
     if (!symbol->getArchitectures().has(config->target.Arch))
       continue;
 
     switch (symbol->getKind()) {
     case SymbolKind::GlobalSymbol:
       addSymbol(symbol->getName());
       break;
     case SymbolKind::ObjectiveCClass:
case SymbolKind::ObjectiveCInstanceVariable:
       break;
     }
   }
 
   const InterfaceFile *topLevel =
       interface.getParent() == nullptr ? &interface : interface.getParent();
 
   for (InterfaceFileRef intfRef : interface.reexportedLibraries()) {
-    auto targets = intfRef.targets();
+    InterfaceFile::const_target_range targets = intfRef.targets();
     if (is_contained(targets, config->target))
       loadReexport(intfRef.getInstallName(), exportingFile, topLevel);
   }
 }
 
 ArchiveFile::ArchiveFile(std::unique_ptr<object::Archive> &&f)
     : InputFile(ArchiveKind, f->getMemoryBufferRef()), file(std::move(f)) {
   for (const object::Archive::Symbol &sym : file->symbols())

lld/MachO/InputSection.cpp

 
 void InputSection::writeTo(uint8_t *buf) {
   if (getFileSize() == 0)
     return;
 
   memcpy(buf, data.data(), data.size());
 
   for (size_t i = 0; i < relocs.size(); i++) {
-    auto *fromSym = target->hasAttr(relocs[i].type, RelocAttrBits::SUBTRAHEND)
-                        ? relocs[i++].referent.get<Symbol *>()
-                        : nullptr;
+    const Symbol *fromSym =
+        target->hasAttr(relocs[i].type, RelocAttrBits::SUBTRAHEND)
     const Reloc &r = relocs[i];
     uint8_t *loc = buf + r.offset;
     uint64_t referentVA = 0;
     if (fromSym) {
-      auto *toSym = r.referent.get<Symbol *>();
+      const Symbol *toSym = r.referent.get<Symbol *>();
       referentVA = toSym->getVA() - fromSym->getVA();
     } else if (auto *referentSym = r.referent.dyn_cast<Symbol *>()) {
       if (target->hasAttr(r.type, RelocAttrBits::LOAD) &&
           !referentSym->isInGot())
         target->relaxGotLoad(loc, r.type);
       referentVA = resolveSymbolVA(loc, *referentSym, r.type);
 
       if (isThreadLocalVariables(flags)) {

lld/MachO/LTO.cpp

static lto::Config createConfig() {
   c.UseNewPM = config->ltoNewPassManager;
   c.PreCodeGenPassesHook = [](legacy::PassManager &pm) {
     pm.add(createObjCARCContractPass());
   };
   return c;
 }
 
 BitcodeCompiler::BitcodeCompiler() {
-  auto backend =
+  lto::ThinBackend backend =
       lto::createInProcessThinBackend(heavyweight_hardware_concurrency());
   ltoObj = std::make_unique<lto::LTO>(createConfig(), backend);
 }
 
 void BitcodeCompiler::add(BitcodeFile &f) {
   ArrayRef<lto::InputFile::Symbol> objSyms = f.obj->symbols();
   std::vector<lto::SymbolResolution> resols;
   resols.reserve(objSyms.size());

lld/MachO/SymbolTable.cpp

 }
 
 Symbol *SymbolTable::addUndefined(StringRef name, InputFile *file,
                                   bool isWeakRef) {
   Symbol *s;
   bool wasInserted;
   std::tie(s, wasInserted) = insert(name);
 
-  auto refState = isWeakRef ? RefState::Weak : RefState::Strong;
+  RefState refState = isWeakRef ? RefState::Weak : RefState::Strong;
 
   if (wasInserted)
     replaceSymbol<Undefined>(s, name, file, refState);
   else if (auto *lazy = dyn_cast<LazySymbol>(s))
     lazy->fetchArchiveMember();
   else if (auto *dynsym = dyn_cast<DylibSymbol>(s))
     dynsym->refState = std::max(dynsym->refState, refState);
   else if (auto *undefined = dyn_cast<Undefined>(s))

 }
 
 Symbol *SymbolTable::addDylib(StringRef name, DylibFile *file, bool isWeakDef,
                               bool isTlv) {
   Symbol *s;
   bool wasInserted;
   std::tie(s, wasInserted) = insert(name);
 
-  auto refState = RefState::Unreferenced;
+  RefState refState = RefState::Unreferenced;
   if (!wasInserted) {
     if (auto *defined = dyn_cast<Defined>(s)) {
       if (isWeakDef && !defined->isWeakDef())
         defined->overridesWeakDef = true;
     } else if (auto *undefined = dyn_cast<Undefined>(s)) {
       refState = undefined->refState;
     } else if (auto *dysym = dyn_cast<DylibSymbol>(s)) {
       refState = dysym->refState;

lld/MachO/SyntheticSections.cpp

void WeakBindingSection::finalizeContents() {
 
   // Since bindings are delta-encoded, sorting them allows for a more compact
   // result.
   llvm::sort(bindings,
              [](const WeakBindingEntry &a, const WeakBindingEntry &b) {
                return a.target.getVA() < b.target.getVA();
              });
   for (const WeakBindingEntry &b : bindings) {
-    if (auto *isec = b.target.section.dyn_cast<const InputSection *>()) {
+    if (const auto *isec = b.target.section.dyn_cast<const InputSection *>()) {
       encodeBinding(b.symbol, isec->parent, isec->outSecOff + b.target.offset,
                     b.addend, /*isWeakBinding=*/true, lastBinding, os);
     } else {
-      auto *osec = b.target.section.get<const OutputSection *>();
+      const auto *osec = b.target.section.get<const OutputSection *>();
       encodeBinding(b.symbol, osec, b.target.offset, b.addend,
                     /*isWeakBinding=*/true, lastBinding, os);
     }
   }
   if (!bindings.empty() || !definitions.empty())
     os << static_cast<uint8_t>(MachO::BIND_OPCODE_DONE);
 }
 

lld/MachO/UnwindInfoSection.cpp

for (auto foldBegin = cuPtrVector.begin(); foldBegin < cuPtrVector.end();) {
     foldBegin = foldEnd;
   }
   cuPtrVector.erase(foldWrite, cuPtrVector.end());
 
   encodePersonalities(cuPtrVector, personalities);
 
   // Count frequencies of the folded encodings
   EncodingMap encodingFrequencies;
-  for (auto cuPtrEntry : cuPtrVector)
+  for (const CompactUnwindEntry64 *cuPtrEntry : cuPtrVector)
     encodingFrequencies[cuPtrEntry->encoding]++;
 
   // Make a vector of encodings, sorted by descending frequency
   for (const auto &frequency : encodingFrequencies)
     commonEncodings.emplace_back(frequency);
   std::sort(commonEncodings.begin(), commonEncodings.end(),
             [](const std::pair<compact_unwind_encoding_t, size_t> &a,
                const std::pair<compact_unwind_encoding_t, size_t> &b) {
void UnwindInfoSection::finalize() {
   // (b) 24-bit difference between first & final function address
   // (c) 8-bit compact-encoding-table index,
   //     for which 0..126 references the global common-encodings table,
   //     and 127..255 references a local per-second-level-page table.
   // First we try the compact format and determine how many entries fit.
   // If more entries fit in the regular format, we use that.
   for (size_t i = 0; i < cuPtrVector.size();) {
     secondLevelPages.emplace_back();
-    auto &page = secondLevelPages.back();
+    UnwindInfoSection::SecondLevelPage &page = secondLevelPages.back();
     page.entryIndex = i;
     uintptr_t functionAddressMax =
         cuPtrVector[i]->functionAddress + COMPRESSED_ENTRY_FUNC_OFFSET_MASK;
     size_t n = commonEncodings.size();
     size_t wordsRemaining =
         SECOND_LEVEL_PAGE_WORDS -
         sizeof(unwind_info_compressed_second_level_page_header) /
             sizeof(uint32_t);
     while (wordsRemaining >= 1 && i < cuPtrVector.size()) {
-      const auto *cuPtr = cuPtrVector[i];
+      const CompactUnwindEntry64 *cuPtr = cuPtrVector[i];
       if (cuPtr->functionAddress >= functionAddressMax) {
         break;
       } else if (commonEncodingIndexes.count(cuPtr->encoding) ||
                  page.localEncodingIndexes.count(cuPtr->encoding)) {
         i++;
         wordsRemaining--;
       } else if (wordsRemaining >= 2 && n < COMPACT_ENCODINGS_MAX) {
         page.localEncodings.emplace_back(cuPtr->encoding);