[lld/win] Use C++17 structured bindings

[thakis]

Summary

No behavior change.

[mstorsjo]

LGTM - iirc the same was already landed for the macho side.

[thakis]

Yes, in D131355. Thanks!

lld/COFF/DriverUtils.cpp

private:
   StringRef prog;
   std::vector<StringRef> args;
 };
 
 } // anonymous namespace
 
 // Parses a string in the form of "<integer>[,<integer>]".
 void parseNumbers(StringRef arg, uint64_t *addr, uint64_t *size) {
-  StringRef s1, s2;
-  std::tie(s1, s2) = arg.split(',');
+  auto [s1, s2] = arg.split(',');
   if (s1.getAsInteger(0, *addr))
     fatal("invalid number: " + s1);
   if (size && !s2.empty() && s2.getAsInteger(0, *size))
     fatal("invalid number: " + s2);
 }
 
 // Parses a string in the form of "<integer>[.<integer>]".
 // If second number is not present, Minor is set to 0.
 void parseVersion(StringRef arg, uint32_t *major, uint32_t *minor) {
-  StringRef s1, s2;
-  std::tie(s1, s2) = arg.split('.');
+  auto [s1, s2] = arg.split('.');
   if (s1.getAsInteger(10, *major))
     fatal("invalid number: " + s1);
   *minor = 0;
   if (!s2.empty() && s2.getAsInteger(10, *minor))
     fatal("invalid number: " + s2);
 }
 
 void parseGuard(StringRef fullArg) {
for (StringRef arg : splitArgs) {
     else
       fatal("invalid argument to /guard: " + arg);
   }
 }
 
 // Parses a string in the form of "<subsystem>[,<integer>[.<integer>]]".
 void parseSubsystem(StringRef arg, WindowsSubsystem *sys, uint32_t *major,
                     uint32_t *minor, bool *gotVersion) {
-  StringRef sysStr, ver;
-  std::tie(sysStr, ver) = arg.split(',');
+  auto [sysStr, ver] = arg.split(',');
   std::string sysStrLower = sysStr.lower();
   *sys = StringSwitch<WindowsSubsystem>(sysStrLower)
     .Case("boot_application", IMAGE_SUBSYSTEM_WINDOWS_BOOT_APPLICATION)
     .Case("console", IMAGE_SUBSYSTEM_WINDOWS_CUI)
     .Case("default", IMAGE_SUBSYSTEM_UNKNOWN)
     .Case("efi_application", IMAGE_SUBSYSTEM_EFI_APPLICATION)
     .Case("efi_boot_service_driver", IMAGE_SUBSYSTEM_EFI_BOOT_SERVICE_DRIVER)
     .Case("efi_rom", IMAGE_SUBSYSTEM_EFI_ROM)
     .Case("efi_runtime_driver", IMAGE_SUBSYSTEM_EFI_RUNTIME_DRIVER)
     .Case("native", IMAGE_SUBSYSTEM_NATIVE)
     .Case("posix", IMAGE_SUBSYSTEM_POSIX_CUI)
     .Case("windows", IMAGE_SUBSYSTEM_WINDOWS_GUI)
     .Default(IMAGE_SUBSYSTEM_UNKNOWN);
   if (*sys == IMAGE_SUBSYSTEM_UNKNOWN && sysStrLower != "default")
     fatal("unknown subsystem: " + sysStr);
   if (!ver.empty())
     parseVersion(ver, major, minor);
   if (gotVersion)
     *gotVersion = !ver.empty();
 }
 
 // Parse a string of the form of "<from>=<to>".
 // Results are directly written to Config.
 void parseAlternateName(StringRef s) {
-  StringRef from, to;
-  std::tie(from, to) = s.split('=');
+  auto [from, to] = s.split('=');
   if (from.empty() || to.empty())
     fatal("/alternatename: invalid argument: " + s);
   auto it = config->alternateNames.find(from);
   if (it != config->alternateNames.end() && it->second != to)
     fatal("/alternatename: conflicts: " + s);
   config->alternateNames.insert(it, std::make_pair(from, to));
 }
 
 // Parse a string of the form of "<from>=<to>".
 // Results are directly written to Config.
 void parseMerge(StringRef s) {
-  StringRef from, to;
-  std::tie(from, to) = s.split('=');
+  auto [from, to] = s.split('=');
   if (from.empty() || to.empty())
     fatal("/merge: invalid argument: " + s);
   if (from == ".rsrc" || to == ".rsrc")
     fatal("/merge: cannot merge '.rsrc' with any section");
   if (from == ".reloc" || to == ".reloc")
     fatal("/merge: cannot merge '.reloc' with any section");
   auto pair = config->merge.insert(std::make_pair(from, to));
   bool inserted = pair.second;
default:
       fatal("/section: invalid argument: " + s);
     }
   }
   return ret;
 }
 
 // Parses /section option argument.
 void parseSection(StringRef s) {
-  StringRef name, attrs;
-  std::tie(name, attrs) = s.split(',');
+  auto [name, attrs] = s.split(',');
   if (name.empty() || attrs.empty())
     fatal("/section: invalid argument: " + s);
   config->section[name] = parseSectionAttributes(attrs);
 }
 
 // Parses /aligncomm option argument.
 void parseAligncomm(StringRef s) {
-  StringRef name, align;
-  std::tie(name, align) = s.split(',');
+  auto [name, align] = s.split(',');
   if (name.empty() || align.empty()) {
     error("/aligncomm: invalid argument: " + s);
     return;
   }
   int v;
   if (align.getAsInteger(0, v)) {
     error("/aligncomm: invalid argument: " + s);
     return;
for (;;) {
     fatal("invalid option " + arg);
   }
 }
 
 // Parses a string in the form of "cd|net[,(cd|net)]*"
 // Results are directly written to Config.
 void parseSwaprun(StringRef arg) {
   do {
-    StringRef swaprun, newArg;
-    std::tie(swaprun, newArg) = arg.split(',');
+    auto [swaprun, newArg] = arg.split(',');
     if (swaprun.equals_insensitive("cd"))
       config->swaprunCD = true;
     else if (swaprun.equals_insensitive("net"))
       config->swaprunNet = true;
     else if (swaprun.empty())
       error("/swaprun: missing argument");
     else
       error("/swaprun: invalid argument: " + swaprun);

 Export parseExport(StringRef arg) {
   Export e;
   StringRef rest;
   std::tie(e.name, rest) = arg.split(",");
   if (e.name.empty())
     goto err;
 
   if (e.name.contains('=')) {
-    StringRef x, y;
-    std::tie(x, y) = e.name.split("=");
+    auto [x, y] = e.name.split("=");
 
     // If "<name>=<dllname>.<name>".
     if (y.contains(".")) {
       e.name = x;
       e.forwardTo = y;
       return e;
     }
 
void assignExportOrdinals() {
   if (max > std::numeric_limits<uint16_t>::max())
     fatal("too many exported symbols (got " + Twine(max) + ", max " +
           Twine(std::numeric_limits<uint16_t>::max()) + ")");
 }
 
 // Parses a string in the form of "key=value" and check
 // if value matches previous values for the same key.
 void checkFailIfMismatch(StringRef arg, InputFile *source) {
-  StringRef k, v;
-  std::tie(k, v) = arg.split('=');
+  auto [k, v] = arg.split('=');
   if (k.empty() || v.empty())
     fatal("/failifmismatch: invalid argument: " + arg);
   std::pair<StringRef, InputFile *> existing = config->mustMatch[k];
   if (!existing.first.empty() && v != existing.first) {
     std::string sourceStr = source ? toString(source) : "cmd-line";
     std::string existingStr =
         existing.second ? toString(existing.second) : "cmd-line";
     fatal("/failifmismatch: mismatch detected for '" + k + "':\n>>> " +

lld/COFF/SymbolTable.cpp

 static void reportUndefinedSymbol(const UndefinedDiag &undefDiag) {
   std::string out;
   llvm::raw_string_ostream os(out);
   os << "undefined symbol: " << toString(*undefDiag.sym);
 
   const size_t maxUndefReferences = 3;
   size_t numDisplayedRefs = 0, numRefs = 0;
   for (const UndefinedDiag::File &ref : undefDiag.files) {
-    std::vector<std::string> symbolLocations;
-    size_t totalLocations = 0;
-    std::tie(symbolLocations, totalLocations) = getSymbolLocations(
+    auto [symbolLocations, totalLocations] = getSymbolLocations(
         ref.file, ref.symIndex, maxUndefReferences - numDisplayedRefs);
 
     numRefs += totalLocations;
     numDisplayedRefs += symbolLocations.size();
     for (const std::string &s : symbolLocations) {
       os << s;
     }
   }
std::pair<Symbol *, bool> SymbolTable::insert(StringRef name, InputFile *file) {
   std::pair<Symbol *, bool> result = insert(name);
   if (!file || !isa<BitcodeFile>(file))
     result.first->isUsedInRegularObj = true;
   return result;
 }
 
 Symbol *SymbolTable::addUndefined(StringRef name, InputFile *f,
                                   bool isWeakAlias) {
-  Symbol *s;
-  bool wasInserted;
-  std::tie(s, wasInserted) = insert(name, f);
+  auto [s, wasInserted] = insert(name, f);
   if (wasInserted || (s->isLazy() && isWeakAlias)) {
     replaceSymbol<Undefined>(s, name);
     return s;
   }
   if (s->isLazy())
     forceLazy(s);
   return s;
 }
 
 void SymbolTable::addLazyArchive(ArchiveFile *f, const Archive::Symbol &sym) {
   StringRef name = sym.getName();
-  Symbol *s;
-  bool wasInserted;
-  std::tie(s, wasInserted) = insert(name);
+  auto [s, wasInserted] = insert(name);
   if (wasInserted) {
     replaceSymbol<LazyArchive>(s, f, sym);
     return;
   }
   auto *u = dyn_cast<Undefined>(s);
   if (!u || u->weakAlias || s->pendingArchiveLoad)
     return;
   s->pendingArchiveLoad = true;
   f->addMember(sym);
 }
 
 void SymbolTable::addLazyObject(InputFile *f, StringRef n) {
   assert(f->lazy);
-  Symbol *s;
-  bool wasInserted;
-  std::tie(s, wasInserted) = insert(n, f);
+  auto [s, wasInserted] = insert(n, f);
   if (wasInserted) {
     replaceSymbol<LazyObject>(s, f, n);
     return;
   }
   auto *u = dyn_cast<Undefined>(s);
   if (!u || u->weakAlias || s->pendingArchiveLoad)
     return;
   s->pendingArchiveLoad = true;
   f->lazy = false;
   addFile(f);
 }
 
 void SymbolTable::addLazyDLLSymbol(DLLFile *f, DLLFile::Symbol *sym,
                                    StringRef n) {
-  Symbol *s;
-  bool wasInserted;
-  std::tie(s, wasInserted) = insert(n);
+  auto [s, wasInserted] = insert(n);
   if (wasInserted) {
     replaceSymbol<LazyDLLSymbol>(s, f, sym, n);
     return;
   }
   auto *u = dyn_cast<Undefined>(s);
   if (!u || u->weakAlias || s->pendingArchiveLoad)
     return;
   s->pendingArchiveLoad = true;
void SymbolTable::reportDuplicate(Symbol *existing, InputFile *newFile,
 
   if (config->forceMultiple)
     warn(os.str());
   else
     error(os.str());
 }
 
 Symbol *SymbolTable::addAbsolute(StringRef n, COFFSymbolRef sym) {
-  Symbol *s;
-  bool wasInserted;
-  std::tie(s, wasInserted) = insert(n, nullptr);
+  auto [s, wasInserted] = insert(n, nullptr);
   s->isUsedInRegularObj = true;
   if (wasInserted || isa<Undefined>(s) || s->isLazy())
     replaceSymbol<DefinedAbsolute>(s, n, sym);
   else if (auto *da = dyn_cast<DefinedAbsolute>(s)) {
     if (da->getVA() != sym.getValue())
       reportDuplicate(s, nullptr);
   } else if (!isa<DefinedCOFF>(s))
     reportDuplicate(s, nullptr);
   return s;
 }
 
 Symbol *SymbolTable::addAbsolute(StringRef n, uint64_t va) {
-  Symbol *s;
-  bool wasInserted;
-  std::tie(s, wasInserted) = insert(n, nullptr);
+  auto [s, wasInserted] = insert(n, nullptr);
   s->isUsedInRegularObj = true;
   if (wasInserted || isa<Undefined>(s) || s->isLazy())
     replaceSymbol<DefinedAbsolute>(s, n, va);
   else if (auto *da = dyn_cast<DefinedAbsolute>(s)) {
     if (da->getVA() != va)
       reportDuplicate(s, nullptr);
   } else if (!isa<DefinedCOFF>(s))
     reportDuplicate(s, nullptr);
   return s;
 }
 
 Symbol *SymbolTable::addSynthetic(StringRef n, Chunk *c) {
-  Symbol *s;
-  bool wasInserted;
-  std::tie(s, wasInserted) = insert(n, nullptr);
+  auto [s, wasInserted] = insert(n, nullptr);
   s->isUsedInRegularObj = true;
   if (wasInserted || isa<Undefined>(s) || s->isLazy())
     replaceSymbol<DefinedSynthetic>(s, n, c);
   else if (!isa<DefinedCOFF>(s))
     reportDuplicate(s, nullptr);
   return s;
 }
 
 Symbol *SymbolTable::addRegular(InputFile *f, StringRef n,
                                 const coff_symbol_generic *sym, SectionChunk *c,
                                 uint32_t sectionOffset) {
-  Symbol *s;
-  bool wasInserted;
-  std::tie(s, wasInserted) = insert(n, f);
+  auto [s, wasInserted] = insert(n, f);
   if (wasInserted || !isa<DefinedRegular>(s))
     replaceSymbol<DefinedRegular>(s, f, n, /*IsCOMDAT*/ false,
                                   /*IsExternal*/ true, sym, c);
   else
     reportDuplicate(s, f, c, sectionOffset);
   return s;
 }
 
 std::pair<DefinedRegular *, bool>
 SymbolTable::addComdat(InputFile *f, StringRef n,
                        const coff_symbol_generic *sym) {
-  Symbol *s;
-  bool wasInserted;
-  std::tie(s, wasInserted) = insert(n, f);
+  auto [s, wasInserted] = insert(n, f);
   if (wasInserted || !isa<DefinedRegular>(s)) {
     replaceSymbol<DefinedRegular>(s, f, n, /*IsCOMDAT*/ true,
                                   /*IsExternal*/ true, sym, nullptr);
     return {cast<DefinedRegular>(s), true};
   }
   auto *existingSymbol = cast<DefinedRegular>(s);
   if (!existingSymbol->isCOMDAT)
     reportDuplicate(s, f);
   return {existingSymbol, false};
 }
 
 Symbol *SymbolTable::addCommon(InputFile *f, StringRef n, uint64_t size,
                                const coff_symbol_generic *sym, CommonChunk *c) {
-  Symbol *s;
-  bool wasInserted;
-  std::tie(s, wasInserted) = insert(n, f);
+  auto [s, wasInserted] = insert(n, f);
   if (wasInserted || !isa<DefinedCOFF>(s))
     replaceSymbol<DefinedCommon>(s, f, n, size, sym, c);
   else if (auto *dc = dyn_cast<DefinedCommon>(s))
     if (size > dc->getSize())
       replaceSymbol<DefinedCommon>(s, f, n, size, sym, c);
   return s;
 }
 
 Symbol *SymbolTable::addImportData(StringRef n, ImportFile *f) {
-  Symbol *s;
-  bool wasInserted;
-  std::tie(s, wasInserted) = insert(n, nullptr);
+  auto [s, wasInserted] = insert(n, nullptr);
   s->isUsedInRegularObj = true;
   if (wasInserted || isa<Undefined>(s) || s->isLazy()) {
     replaceSymbol<DefinedImportData>(s, n, f);
     return s;
   }
 
   reportDuplicate(s, f);
   return nullptr;
 }
 
 Symbol *SymbolTable::addImportThunk(StringRef name, DefinedImportData *id,
                                     uint16_t machine) {
-  Symbol *s;
-  bool wasInserted;
-  std::tie(s, wasInserted) = insert(name, nullptr);
+  auto [s, wasInserted] = insert(name, nullptr);
   s->isUsedInRegularObj = true;
   if (wasInserted || isa<Undefined>(s) || s->isLazy()) {
     replaceSymbol<DefinedImportThunk>(s, name, id, machine);
     return s;
   }
 
   reportDuplicate(s, id->file);
   return nullptr;

lld/COFF/Writer.cpp

for (size_t j = 0, e = originalRelocs.size(); j < e; ++j) {
       if (!sym)
         continue;
 
       uint64_t s = sym->getRVA();
 
       if (isInRange(rel.Type, s, p, margin))
         continue;
 
-      // If the target isn't in range, hook it up to an existing or new
-      // thunk.
-      Defined *thunk;
-      bool wasNew;
-      std::tie(thunk, wasNew) = getThunk(lastThunks, sym, p, rel.Type, margin);
+      // If the target isn't in range, hook it up to an existing or new thunk.
+      auto [thunk, wasNew] = getThunk(lastThunks, sym, p, rel.Type, margin);
       if (wasNew) {
         Chunk *thunkChunk = thunk->getChunk();
         thunkChunk->setRVA(
             thunkInsertionRVA); // Estimate of where it will be located.
         os->chunks.insert(os->chunks.begin() + thunkInsertionSpot, thunkChunk);
         thunkInsertionSpot++;
         thunksSize += thunkChunk->getSize();
         thunkInsertionRVA += thunkChunk->getSize();