[NFC] Optimize vector usage in lld

[gAlfonso-bit]

Summary

By using emplace_back, as well as converting some loops to for-each, we can do more efficient vectorization.

Make copy constructor for TemporaryFile noexcept.

[gAlfonso-bit]

Fix formatting

[int3]

lld/COFF/Writer.cpp

521

codebase convention is to use explicit type instead of auto as long as it's not too ugly

lld/ELF/InputFiles.cpp

1709

c seems like a better name for a char

also there's no need to take this by reference

lld/ELF/MapFile.cpp

248

let's keep this, seems like it was intentionally done to help readability

[int3]

clearing queue

[gAlfonso-bit]

Addressed! @MaskRay

[int3]

Thanks!

lld/COFF/DriverUtils.cpp

350

maybe add a remark about this noexcept to the commit message

[andrewng]

lld/ELF/InputFiles.cpp

1711

Just saw this in passing, I think c needs to be a reference as the intention is to change the character in s.

[gAlfonso-bit]

Done!

[gAlfonso-bit]

@int3 I do not have permission to merge this. Could you?

[int3]

Done :)

[int3]

Just noticed I'd messed up the author attribution in the commit. Sorry ):

lld/COFF/Chunks.cpp

if (sizeInBits == 0) {
       error("unable to automatically import from " + target->getName() +
             " with relocation type " +
             file->getCOFFObj()->getRelocationTypeName(rel.Type) + " in " +
             toString(file));
       continue;
     }
     // sizeInBits is used to initialize the Flags field; currently no
     // other flags are defined.
-    res.emplace_back(
-        RuntimePseudoReloc(target, this, rel.VirtualAddress, sizeInBits));
+    res.emplace_back(target, this, rel.VirtualAddress, sizeInBits);
   }
 }
 
 bool SectionChunk::isCOMDAT() const {
   return header->Characteristics & IMAGE_SCN_LNK_COMDAT;
 }
 
 void SectionChunk::printDiscardedMessage() const {

lld/COFF/Driver.cpp

void LinkerDriver::linkerMain(ArrayRef<const char *> argsArr) {
   if (!args.hasArg(OPT_INPUT, OPT_wholearchive_file)) {
     if (args.hasArg(OPT_deffile))
       config->noEntry = true;
     else
       fatal("no input files");
   }
 
   // Construct search path list.
-  searchPaths.push_back("");
+  searchPaths.emplace_back("");
   for (auto *arg : args.filtered(OPT_libpath))
     searchPaths.push_back(arg->getValue());
   detectWinSysRoot(args);
   if (!args.hasArg(OPT_lldignoreenv) && !args.hasArg(OPT_winsysroot))
     addLibSearchPaths();
 
   // Handle /ignore
   for (auto *arg : args.filtered(OPT_ignore)) {

lld/COFF/DriverUtils.cpp

if (!contents.empty()) {
       std::error_code ec;
       raw_fd_ostream os(path, ec, sys::fs::OF_None);
       if (ec)
         fatal("failed to open " + path + ": " + ec.message());
       os << contents;
     }
   }
 
-  TemporaryFile(TemporaryFile &&obj) {
-    std::swap(path, obj.path);
-  }
+  TemporaryFile(TemporaryFile &&obj) noexcept { std::swap(path, obj.path); }
 
   ~TemporaryFile() {
     if (path.empty())
       return;
     if (sys::fs::remove(path))
       fatal("failed to remove " + path);
   }
 
if (args.hasArg(OPT_verbose) && argv.size() != expandedArgv.size()) {
     message(msg);
   }
 
   // Save the command line after response file expansion so we can write it to
   // the PDB if necessary. Mimic MSVC, which skips input files.
   ctx.config.argv = {argv[0]};
   for (opt::Arg *arg : args) {
     if (arg->getOption().getKind() != opt::Option::InputClass) {
-      ctx.config.argv.push_back(args.getArgString(arg->getIndex()));
+      ctx.config.argv.emplace_back(args.getArgString(arg->getIndex()));
     }
   }
 
   // Handle /WX early since it converts missing argument warnings to errors.
   errorHandler().fatalWarnings = args.hasFlag(OPT_WX, OPT_WX_no, false);
 
   if (missingCount)
     fatal(Twine(args.getArgString(missingIndex)) + ": missing argument");

lld/COFF/MinGW.cpp

if (Defined *d = dyn_cast<Defined>(w.wrap)) {
         map[imp] = wrapimp;
       }
     }
   }
 
   // Update pointers in input files.
   parallelForEach(ctx.objFileInstances, [&](ObjFile *file) {
     MutableArrayRef<Symbol *> syms = file->getMutableSymbols();
-    for (size_t i = 0, e = syms.size(); i != e; ++i)
-      if (Symbol *s = map.lookup(syms[i]))
-        syms[i] = s;
+    for (auto &sym : syms)
+      if (Symbol *s = map.lookup(sym))
+        sym = s;
   });
 }

lld/COFF/Writer.cpp

for (size_t j = 0, e = originalRelocs.size(); j < e; ++j) {
 
       // To redirect the relocation, add a symbol to the parent object file's
       // symbol table, and replace the relocation symbol table index with the
       // new index.
       auto insertion = thunkSymtabIndices.insert({{file, thunk}, ~0U});
       uint32_t &thunkSymbolIndex = insertion.first->second;
       if (insertion.second)
         thunkSymbolIndex = file->addRangeThunkSymbol(thunk);
-      relocReplacements.push_back({j, thunkSymbolIndex});
+      relocReplacements.emplace_back(j, thunkSymbolIndex);
     }
 
     // Get a writable copy of this section's relocations so they can be
     // modified. If the relocations point into the object file, allocate new
     // memory. Otherwise, this must be previously allocated memory that can be
     // modified in place.
     ArrayRef<coff_relocation> curRelocs = sc->getRelocs();
     MutableArrayRef<coff_relocation> newRelocs;
for (size_t i = 0; i != os->chunks.size(); ++i) {
     for (size_t i = 0, e = originalRelocs.size(); i != e; ++i) {
       newRelocs[i] = originalRelocs[i];
       if (nextReplacement != endReplacement && nextReplacement->first == i) {
         newRelocs[i].SymbolTableIndex = nextReplacement->second;
         ++nextReplacement;
       }
     }
 
     sc->setRelocs(newRelocs);
   }
   return addressesChanged;
 }
 
 // Verify that all relocations are in range, with no extra margin requirements.
 bool Writer::verifyRanges(const std::vector<Chunk *> chunks) {
   for (Chunk *c : chunks) {
     SectionChunk *sc = dyn_cast_or_null<SectionChunk>(c);
     if (!sc)
       continue;
 
     ArrayRef<coff_relocation> relocs = sc->getRelocs();
-    for (size_t j = 0, e = relocs.size(); j < e; ++j) {
-      const coff_relocation &rel = relocs[j];
+    for (const coff_relocation &rel : relocs) {
       Symbol *relocTarget = sc->file->getSymbol(rel.SymbolTableIndex);
 
       Defined *sym = dyn_cast_or_null<Defined>(relocTarget);
       if (!sym)
         continue;
 
       uint64_t p = sc->getRVA() + rel.VirtualAddress;
       uint64_t s = sym->getRVA();
void Writer::createMiscChunks() {
   }
 
   if (config->debug) {
     // Make a CVDebugRecordChunk even when /DEBUG:CV is not specified.  We
     // output a PDB no matter what, and this chunk provides the only means of
     // allowing a debugger to match a PDB and an executable.  So we need it even
     // if we're ultimately not going to write CodeView data to the PDB.
     buildId = make<CVDebugRecordChunk>(ctx);
-    debugRecords.push_back({COFF::IMAGE_DEBUG_TYPE_CODEVIEW, buildId});
+    debugRecords.emplace_back(COFF::IMAGE_DEBUG_TYPE_CODEVIEW, buildId);
   }
 
   if (config->cetCompat) {
-    debugRecords.push_back({COFF::IMAGE_DEBUG_TYPE_EX_DLLCHARACTERISTICS,
+    debugRecords.emplace_back(COFF::IMAGE_DEBUG_TYPE_EX_DLLCHARACTERISTICS,
                               make<ExtendedDllCharacteristicsChunk>(
-                                IMAGE_DLL_CHARACTERISTICS_EX_CET_COMPAT)});
+                                  IMAGE_DLL_CHARACTERISTICS_EX_CET_COMPAT));
   }
 
   // Align and add each chunk referenced by the debug data directory.
   for (std::pair<COFF::DebugType, Chunk *> r : debugRecords) {
     r.second->setAlignment(4);
     debugInfoSec->addChunk(r.second);
   }
 

lld/ELF/InputFiles.cpp

auto *section = make<InputSection>(this, SHF_ALLOC | SHF_WRITE, SHT_PROGBITS,
                                      8, data, ".data");
   sections.push_back(section);
 
   // For each input file foo that is embedded to a result as a binary
   // blob, we define _binary_foo_{start,end,size} symbols, so that
   // user programs can access blobs by name. Non-alphanumeric
   // characters in a filename are replaced with underscore.
   std::string s = "_binary_" + mb.getBufferIdentifier().str();
-  for (size_t i = 0; i < s.size(); ++i)
-    if (!isAlnum(s[i]))
-      s[i] = '_';
+  for (char &c : s)
+    if (!isAlnum(c))
+      c = '_';
 
   llvm::StringSaver &saver = lld::saver();
 
   symtab.addAndCheckDuplicate(Defined{nullptr, saver.save(s + "_start"),
                                       STB_GLOBAL, STV_DEFAULT, STT_OBJECT, 0, 0,
                                       section});
   symtab.addAndCheckDuplicate(Defined{nullptr, saver.save(s + "_end"),
                                       STB_GLOBAL, STV_DEFAULT, STT_OBJECT,

lld/ELF/MapFile.cpp

static void writeMapFile(raw_fd_ostream &os) {
   SymbolMapTy sectionSyms = getSectionSyms(syms);
   DenseMap<Symbol *, std::string> symStr = getSymbolStrings(syms);
 
   // Print out the header line.
   int w = config->is64 ? 16 : 8;
   os << right_justify("VMA", w) << ' ' << right_justify("LMA", w)
      << "     Size Align Out     In      Symbol\n";
 
-  OutputSection* osec = nullptr;
+  OutputSection *osec = nullptr;
   for (SectionCommand *cmd : script->sectionCommands) {
     if (auto *assign = dyn_cast<SymbolAssignment>(cmd)) {
       if (assign->provide && !assign->sym)
         continue;
       uint64_t lma = osec ? osec->getLMA() + assign->addr - osec->getVA(0) : 0;
       writeHeader(os, assign->addr, lma, assign->size, 1);
       os << assign->commandString << '\n';
       continue;
static void writeCref(raw_fd_ostream &os) {
 
   // Print a blank line and a header. The format matches GNU ld.
   os << "\nCross Reference Table\n\n";
   print("Symbol", "File");
 
   // Print out a table.
   for (auto kv : map) {
     Symbol *sym = kv.first;
     SetVector<InputFile *> &files = kv.second;
 
     print(toString(*sym), toString(sym->file));
     for (InputFile *file : files)
       if (file != sym->file)
         print("", toString(file));
   }
 }
 

lld/ELF/OutputSections.cpp

void OutputSection::finalizeInputSections() {
   for (auto *ms : mergeSections)
     ms->finalizeContents();
 }
 
 static void sortByOrder(MutableArrayRef<InputSection *> in,
                         llvm::function_ref<int(InputSectionBase *s)> order) {
   std::vector<std::pair<int, InputSection *>> v;
   for (InputSection *s : in)
-    v.push_back({order(s), s});
+    v.emplace_back(order(s), s);
   llvm::stable_sort(v, less_first());
 
   for (size_t i = 0; i < v.size(); ++i)
     in[i] = v[i].second;
 }
 
 uint64_t elf::getHeaderSize() {
   if (config->oFormatBinary)

lld/MachO/Arch/ARM64.cpp

static constexpr uint32_t thunkCode[] = {
     0x91000210, // 04: add   x16, [x16,<thunk.ptr>@pageoff]
     0xd61f0200, // 08: br    x16
 };
 
 void ARM64::populateThunk(InputSection *thunk, Symbol *funcSym) {
   thunk->align = 4;
   thunk->data = {reinterpret_cast<const uint8_t *>(thunkCode),
                  sizeof(thunkCode)};
-  thunk->relocs.push_back({/*type=*/ARM64_RELOC_PAGEOFF12,
+  thunk->relocs.emplace_back(/*type=*/ARM64_RELOC_PAGEOFF12,
                              /*pcrel=*/false, /*length=*/2,
                              /*offset=*/4, /*addend=*/0,
-                           /*referent=*/funcSym});
-  thunk->relocs.push_back({/*type=*/ARM64_RELOC_PAGE21,
+                             /*referent=*/funcSym);
+  thunk->relocs.emplace_back(/*type=*/ARM64_RELOC_PAGE21,
                              /*pcrel=*/true, /*length=*/2,
                              /*offset=*/0, /*addend=*/0,
-                           /*referent=*/funcSym});
+                             /*referent=*/funcSym);
 }
 
 ARM64::ARM64() : ARM64Common(LP64()) {
   cpuType = CPU_TYPE_ARM64;
   cpuSubtype = CPU_SUBTYPE_ARM64_ALL;
 
   stubSize = sizeof(stubCode);
   thunkSize = sizeof(thunkCode);

lld/MachO/SyntheticSections.h

public:
   RebaseSection();
   void finalizeContents() override;
   uint64_t getRawSize() const override { return contents.size(); }
   bool isNeeded() const override { return !locations.empty(); }
   void writeTo(uint8_t *buf) const override;
 
   void addEntry(const InputSection *isec, uint64_t offset) {
     if (config->isPic)
-      locations.push_back({isec, offset});
+      locations.emplace_back(isec, offset);
   }
 
 private:
   std::vector<Location> locations;
   SmallVector<char, 128> contents;
 };
 
 struct BindingEntry {
   int64_t addend;
   Location target;
   BindingEntry(int64_t addend, Location target)
-      : addend(addend), target(std::move(target)) {}
+      : addend(addend), target(target) {}
 };
 
 template <class Sym>
 using BindingsMap = llvm::DenseMap<Sym, std::vector<BindingEntry>>;
 
 // Stores bind opcodes for telling dyld which symbols to load non-lazily.
 class BindingSection final : public LinkEditSection {
 public: