[lld-link] Replace log(...) with Log

MaskRay · MaskRay · commit 4639a9a06387 · 2024-12-04T09:04:40.000-08:00
diff --git a/lld/COFF/DebugTypes.cpp b/lld/COFF/DebugTypes.cpp
@@ -241,10 +241,10 @@ void TpiSource::remapRecord(MutableArrayRef<uint8_t> rec,
           uint16_t kind =
               reinterpret_cast<const RecordPrefix *>(rec.data())->RecordKind;
           StringRef fname = file ? file->getName() : "<unknown PDB>";
-          log("failed to remap type index in record of kind 0x" +
-              utohexstr(kind) + " in " + fname + " with bad " +
-              (ref.Kind == TiRefKind::IndexRef ? "item" : "type") +
-              " index 0x" + utohexstr(ti.getIndex()));
+          Log(ctx) << "failed to remap type index in record of kind 0x"
+                   << utohexstr(kind) << " in " << fname << " with bad "
+                   << (ref.Kind == TiRefKind::IndexRef ? "item" : "type")
+                   << " index 0x" << utohexstr(ti.getIndex());
         }
         ti = TypeIndex(SimpleTypeKind::NotTranslated);
         continue;
@@ -1137,9 +1137,10 @@ void TypeMerger::mergeTypesWithGHash() {
       entries.push_back(cell);
   }
   parallelSort(entries, std::less<GHashCell>());
-  log(formatv("ghash table load factor: {0:p} (size {1} / capacity {2})\n",
-              tableSize ? double(entries.size()) / tableSize : 0,
-              entries.size(), tableSize));
+  Log(ctx) << formatv(
+      "ghash table load factor: {0:p} (size {1} / capacity {2})\n",
+      tableSize ? double(entries.size()) / tableSize : 0, entries.size(),
+      tableSize);
 
   // Find out how many type and item indices there are.
   auto mid = llvm::lower_bound(entries, GHashCell(true, 0, 0));
@@ -1148,8 +1149,8 @@ void TypeMerger::mergeTypesWithGHash() {
          "midpoint is not midpoint");
   uint32_t numTypes = std::distance(entries.begin(), mid);
   uint32_t numItems = std::distance(mid, entries.end());
-  log("Tpi record count: " + Twine(numTypes));
-  log("Ipi record count: " + Twine(numItems));
+  Log(ctx) << "Tpi record count: " << Twine(numTypes);
+  Log(ctx) << "Ipi record count: " << Twine(numItems);
 
   // Make a list of the "unique" type records to merge for each tpi source. Type
   // merging will skip indices not on this list. Store the destination PDB type
diff --git a/lld/COFF/Driver.cpp b/lld/COFF/Driver.cpp
@@ -779,7 +779,7 @@ StringRef LinkerDriver::mangleMaybe(Symbol *s) {
 
   // If we find a similar mangled symbol, make this an alias to it and return
   // its name.
-  log(unmangled->getName() + " aliased to " + mangled->getName());
+  Log(ctx) << unmangled->getName() << " aliased to " << mangled->getName();
   unmangled->setWeakAlias(ctx.symtab.addUndefined(mangled->getName()));
   return mangled->getName();
 }
@@ -2419,7 +2419,7 @@ void LinkerDriver::linkerMain(ArrayRef<const char *> argsArr) {
         if (s.empty())
           fatal("entry point must be defined");
         config->entry = addUndefined(s, true);
-        log("Entry name inferred: " + s);
+        Log(ctx) << "Entry name inferred: " << s;
       }
     }
   }
diff --git a/lld/COFF/ICF.cpp b/lld/COFF/ICF.cpp
@@ -314,16 +314,16 @@ void ICF::run() {
         [&](size_t begin, size_t end) { segregate(begin, end, false); });
   } while (repeat);
 
-  log("ICF needed " + Twine(cnt) + " iterations");
+  Log(ctx) << "ICF needed " << Twine(cnt) << " iterations";
 
   // Merge sections in the same classes.
   forEachClass([&](size_t begin, size_t end) {
     if (end - begin == 1)
       return;
 
-    log("Selected " + chunks[begin]->getDebugName());
+    Log(ctx) << "Selected " << chunks[begin]->getDebugName();
     for (size_t i = begin + 1; i < end; ++i) {
-      log("  Removed " + chunks[i]->getDebugName());
+      Log(ctx) << "  Removed " << chunks[i]->getDebugName();
       chunks[begin]->replace(chunks[i]);
     }
   });
diff --git a/lld/COFF/InputFiles.cpp b/lld/COFF/InputFiles.cpp
@@ -518,8 +518,8 @@ void ObjFile::initializeSymbols() {
     }
     if (sparseChunks[sym.getSectionNumber()] == pendingComdat) {
       StringRef name = check(coffObj->getSymbolName(sym));
-      log("comdat section " + name +
-          " without leader and unassociated, discarding");
+      Log(ctx) << "comdat section " << name
+               << " without leader and unassociated, discarding";
       continue;
     }
     symbols[i] = createRegular(sym);
@@ -620,10 +620,9 @@ void ObjFile::handleComdatSelection(
   // seems better though.
   // (This behavior matches ModuleLinker::getComdatResult().)
   if (selection != leaderSelection) {
-    log(("conflicting comdat type for " + toString(ctx, *leader) + ": " +
-         Twine((int)leaderSelection) + " in " + toString(leader->getFile()) +
-         " and " + Twine((int)selection) + " in " + toString(this))
-            .str());
+    Log(ctx) << "conflicting comdat type for " << toString(ctx, *leader) << ": "
+             << (int)leaderSelection << " in " << leader->getFile() << " and "
+             << (int)selection << " in " << this;
     ctx.symtab.reportDuplicate(leader, this);
     return;
   }
diff --git a/lld/COFF/PDB.cpp b/lld/COFF/PDB.cpp
@@ -569,7 +569,8 @@ void PDBLinker::writeSymbolRecord(SectionChunk *debugChunk,
   // Re-map all the type index references.
   TpiSource *source = debugChunk->file->debugTypesObj;
   if (!source->remapTypesInSymbolRecord(recordBytes)) {
-    log("ignoring unknown symbol record with kind 0x" + utohexstr(sym.kind()));
+    Log(ctx) << "ignoring unknown symbol record with kind 0x"
+             << utohexstr(sym.kind());
     replaceWithSkipRecord(recordBytes);
   }
 
diff --git a/lld/COFF/SymbolTable.cpp b/lld/COFF/SymbolTable.cpp
@@ -54,7 +54,7 @@ static bool compatibleMachineType(COFFLinkerContext &ctx, MachineTypes mt) {
 }
 
 void SymbolTable::addFile(InputFile *file) {
-  log("Reading " + toString(file));
+  Log(ctx) << "Reading " << toString(file);
   if (file->lazy) {
     if (auto *f = dyn_cast<BitcodeFile>(file))
       f->parseLazy();
@@ -320,8 +320,8 @@ void SymbolTable::loadMinGWSymbols() {
       if (newName != origName && (l = find(newName)) != nullptr) {
         // If we found a symbol and it is lazy; load it.
         if (l->isLazy() && !l->pendingArchiveLoad) {
-          log("Loading lazy " + l->getName() + " from " +
-              l->getFile()->getName() + " for stdcall fixup");
+          Log(ctx) << "Loading lazy " << l->getName() << " from "
+                   << l->getFile()->getName() << " for stdcall fixup";
           forceLazy(l);
         }
         // If it's lazy or already defined, hook it up as weak alias.
@@ -330,7 +330,8 @@ void SymbolTable::loadMinGWSymbols() {
             Warn(ctx) << "Resolving " << origName << " by linking to "
                       << newName;
           else
-            log("Resolving " + origName + " by linking to " + newName);
+            Log(ctx) << "Resolving " << origName << " by linking to "
+                     << newName;
           undef->setWeakAlias(l);
           continue;
         }
@@ -346,8 +347,8 @@ void SymbolTable::loadMinGWSymbols() {
       if (!l || l->pendingArchiveLoad || !l->isLazy())
         continue;
 
-      log("Loading lazy " + l->getName() + " from " + l->getFile()->getName() +
-          " for automatic import");
+      Log(ctx) << "Loading lazy " << l->getName() << " from "
+               << l->getFile()->getName() << " for automatic import";
       forceLazy(l);
     }
   }
@@ -372,12 +373,12 @@ bool SymbolTable::handleMinGWAutomaticImport(Symbol *sym, StringRef name) {
   // reference itself to point at the IAT entry.
   size_t impSize = 0;
   if (isa<DefinedImportData>(imp)) {
-    log("Automatically importing " + name + " from " +
-        cast<DefinedImportData>(imp)->getDLLName());
+    Log(ctx) << "Automatically importing " << name << " from "
+             << cast<DefinedImportData>(imp)->getDLLName();
     impSize = sizeof(DefinedImportData);
   } else if (isa<DefinedRegular>(imp)) {
-    log("Automatically importing " + name + " from " +
-        toString(cast<DefinedRegular>(imp)->file));
+    Log(ctx) << "Automatically importing " << name << " from "
+             << toString(cast<DefinedRegular>(imp)->file);
     impSize = sizeof(DefinedRegular);
   } else {
     Warn(ctx) << "unable to automatically import " << name << " from "
@@ -398,7 +399,7 @@ bool SymbolTable::handleMinGWAutomaticImport(Symbol *sym, StringRef name) {
   if (refptr && refptr->getChunk()->getSize() == ctx.config.wordsize) {
     SectionChunk *sc = dyn_cast_or_null<SectionChunk>(refptr->getChunk());
     if (sc && sc->getRelocs().size() == 1 && *sc->symbols().begin() == sym) {
-      log("Replacing .refptr." + name + " with " + imp->getName());
+      Log(ctx) << "Replacing .refptr." << name << " with " << imp->getName();
       refptr->getChunk()->live = false;
       refptr->replaceKeepingName(imp, impSize);
     }
diff --git a/lld/COFF/Writer.cpp b/lld/COFF/Writer.cpp
@@ -670,8 +670,9 @@ void Writer::finalizeAddresses() {
     }
     if (rangesOk) {
       if (pass > 0)
-        log("Added " + Twine(numChunks - origNumChunks) + " thunks with " +
-            "margin " + Twine(margin) + " in " + Twine(pass) + " passes");
+        Log(ctx) << "Added " << Twine(numChunks - origNumChunks)
+                 << " thunks with " << "margin " << Twine(margin) << " in "
+                 << Twine(pass) << " passes";
       return;
     }
 
@@ -1116,7 +1117,7 @@ void Writer::createSections() {
       // special case for all architectures.
       outChars = data | r;
 
-      log("Processing section " + pSec->name + " -> " + name);
+      Log(ctx) << "Processing section " << pSec->name << " -> " << name;
 
       sortCRTSectionChunks(pSec->chunks);
     }
@@ -2221,7 +2222,8 @@ void Writer::createRuntimePseudoRelocs() {
   }
 
   if (!rels.empty()) {
-    log("Writing " + Twine(rels.size()) + " runtime pseudo relocations");
+    Log(ctx) << "Writing " << Twine(rels.size())
+             << " runtime pseudo relocations";
     const char *symbolName = "_pei386_runtime_relocator";
     Symbol *relocator = ctx.symtab.findUnderscore(symbolName);
     if (!relocator)
@@ -2496,8 +2498,8 @@ void Writer::sortCRTSectionChunks(std::vector<Chunk *> &chunks) {
   if (ctx.config.verbose) {
     for (auto &c : chunks) {
       auto sc = dyn_cast<SectionChunk>(c);
-      log("  " + sc->file->mb.getBufferIdentifier().str() +
-          ", SectionID: " + Twine(sc->getSectionNumber()));
+      Log(ctx) << "  " << sc->file->mb.getBufferIdentifier().str()
+               << ", SectionID: " << Twine(sc->getSectionNumber());
     }
   }
 }

Original file line number	Diff line number	Diff line change
`@@ -779,7 +779,7 @@ StringRef LinkerDriver::mangleMaybe(Symbol *s) {`
`779`	`779`
`780`	`780`	`// If we find a similar mangled symbol, make this an alias to it and return`
`781`	`781`	`// its name.`
`782`		`- log(unmangled->getName() + " aliased to " + mangled->getName());`
	`782`	`+ Log(ctx) << unmangled->getName() << " aliased to " << mangled->getName();`
`783`	`783`	`unmangled->setWeakAlias(ctx.symtab.addUndefined(mangled->getName()));`
`784`	`784`	`return mangled->getName();`
`785`	`785`	`}`
`@@ -2419,7 +2419,7 @@ void LinkerDriver::linkerMain(ArrayRef<const char *> argsArr) {`
`2419`	`2419`	`if (s.empty())`
`2420`	`2420`	`fatal("entry point must be defined");`
`2421`	`2421`	`config->entry = addUndefined(s, true);`
`2422`		`- log("Entry name inferred: " + s);`
	`2422`	`+ Log(ctx) << "Entry name inferred: " << s;`
`2423`	`2423`	`}`
`2424`	`2424`	`}`
`2425`	`2425`	`}`
Original file line number	Diff line number	Diff line change
`@@ -569,7 +569,8 @@ void PDBLinker::writeSymbolRecord(SectionChunk *debugChunk,`
`569`	`569`	`// Re-map all the type index references.`
`570`	`570`	`TpiSource *source = debugChunk->file->debugTypesObj;`
`571`	`571`	`if (!source->remapTypesInSymbolRecord(recordBytes)) {`
`572`		`- log("ignoring unknown symbol record with kind 0x" + utohexstr(sym.kind()));`
	`572`	`+ Log(ctx) << "ignoring unknown symbol record with kind 0x"`
	`573`	`+ << utohexstr(sym.kind());`
`573`	`574`	`replaceWithSkipRecord(recordBytes);`
`574`	`575`	`}`
`575`	`576`
Original file line number	Diff line number	Diff line change
`@@ -670,8 +670,9 @@ void Writer::finalizeAddresses() {`
`670`	`670`	`}`
`671`	`671`	`if (rangesOk) {`
`672`	`672`	`if (pass > 0)`
`673`		`- log("Added " + Twine(numChunks - origNumChunks) + " thunks with " +`
`674`		`- "margin " + Twine(margin) + " in " + Twine(pass) + " passes");`
	`673`	`+ Log(ctx) << "Added " << Twine(numChunks - origNumChunks)`
	`674`	`+ << " thunks with " << "margin " << Twine(margin) << " in "`
	`675`	`+ << Twine(pass) << " passes";`
`675`	`676`	`return;`
`676`	`677`	`}`
`677`	`678`
`@@ -1116,7 +1117,7 @@ void Writer::createSections() {`
`1116`	`1117`	`// special case for all architectures.`
`1117`	`1118`	`outChars = data \| r;`
`1118`	`1119`
`1119`		`- log("Processing section " + pSec->name + " -> " + name);`
	`1120`	`+ Log(ctx) << "Processing section " << pSec->name << " -> " << name;`
`1120`	`1121`
`1121`	`1122`	`sortCRTSectionChunks(pSec->chunks);`
`1122`	`1123`	`}`
`@@ -2221,7 +2222,8 @@ void Writer::createRuntimePseudoRelocs() {`
`2221`	`2222`	`}`
`2222`	`2223`
`2223`	`2224`	`if (!rels.empty()) {`
`2224`		`- log("Writing " + Twine(rels.size()) + " runtime pseudo relocations");`
	`2225`	`+ Log(ctx) << "Writing " << Twine(rels.size())`
	`2226`	`+ << " runtime pseudo relocations";`
`2225`	`2227`	`const char *symbolName = "_pei386_runtime_relocator";`
`2226`	`2228`	`Symbol *relocator = ctx.symtab.findUnderscore(symbolName);`
`2227`	`2229`	`if (!relocator)`
`@@ -2496,8 +2498,8 @@ void Writer::sortCRTSectionChunks(std::vector<Chunk *> &chunks) {`
`2496`	`2498`	`if (ctx.config.verbose) {`
`2497`	`2499`	`for (auto &c : chunks) {`
`2498`	`2500`	`auto sc = dyn_cast<SectionChunk>(c);`
`2499`		`- log(" " + sc->file->mb.getBufferIdentifier().str() +`
`2500`		`- ", SectionID: " + Twine(sc->getSectionNumber()));`
	`2501`	`+ Log(ctx) << " " << sc->file->mb.getBufferIdentifier().str()`
	`2502`	`+ << ", SectionID: " << Twine(sc->getSectionNumber());`
`2501`	`2503`	`}`
`2502`	`2504`	`}`
`2503`	`2505`	`}`