[lld][WebAssembly] Cleanup output of --verbose

[sbc100]

Summary

Remove some unnecessary logging from wasm-ld when running under
--verbose. Unlike -debug this logging is available in release
builds. This change makes it little more minimal/readable.

Also, avoid compiling the debugWrite function in releaase builds
where it does nothing. This should remove a lot debug strings from
the binary, and avoid having to construct unused debug strings at
runtime.

lld/wasm/InputFiles.h

public:
   }
   static bool classof(const InputFile *f) { return f->kind() == ObjectKind; }
 
   void parse(bool ignoreComdats = false);
 
   // Returns the underlying wasm file.
   const WasmObjectFile *getWasmObj() const { return wasmObj.get(); }
 
-  void dumpInfo() const;
-
   uint32_t calcNewIndex(const WasmRelocation &reloc) const;
   uint64_t calcNewValue(const WasmRelocation &reloc, uint64_t tombstone,
                         const InputChunk *chunk) const;
   uint64_t calcNewAddend(const WasmRelocation &reloc) const;
   Symbol *getSymbol(const WasmRelocation &reloc) const {
     return symbols[reloc.Index];
   };
 

lld/wasm/InputFiles.cpp

InputFile *createObjectFile(MemoryBufferRef mb, StringRef archiveName) {
   }
 
   if (magic == file_magic::bitcode)
     return make<BitcodeFile>(mb, archiveName);
 
   fatal("unknown file type: " + mb.getBufferIdentifier());
 }
 
-void ObjFile::dumpInfo() const {
-  log("info for: " + toString(this) +
-      "\n              Symbols : " + Twine(symbols.size()) +
-      "\n     Function Imports : " + Twine(wasmObj->getNumImportedFunctions()) +
-      "\n       Global Imports : " + Twine(wasmObj->getNumImportedGlobals()) +
-      "\n          Tag Imports : " + Twine(wasmObj->getNumImportedTags()) +
-      "\n        Table Imports : " + Twine(wasmObj->getNumImportedTables()));
-}
-
 // Relocations contain either symbol or type indices.  This function takes a
 // relocation and returns relocated index (i.e. translates from the input
 // symbol/type space to the output symbol/type space).
 uint32_t ObjFile::calcNewIndex(const WasmRelocation &reloc) const {
   if (reloc.Type == R_WASM_TYPE_INDEX_LEB) {
     assert(typeIsUsed[reloc.Index]);
     return typeMap[reloc.Index];
   }

lld/wasm/OutputSections.h

 
 class OutputSection {
 public:
   OutputSection(uint32_t type, std::string name = "")
       : type(type), name(name) {}
   virtual ~OutputSection() = default;
 
   StringRef getSectionName() const;
-  void setOffset(size_t newOffset) {
-    log("setOffset: " + toString(*this) + ": " + Twine(newOffset));
-    offset = newOffset;
-  }
+  void setOffset(size_t newOffset) { offset = newOffset; }
   void createHeader(size_t bodySize);
   virtual bool isNeeded() const { return true; }
   virtual size_t getSize() const = 0;
   virtual size_t getOffset() { return offset; }
   virtual void writeTo(uint8_t *buf) = 0;
   virtual void finalizeContents() = 0;
   virtual uint32_t getNumRelocations() const { return 0; }
   virtual void writeRelocations(raw_ostream &os) const {}

lld/wasm/OutputSections.cpp

for (InputFunction *func : functions) {
     assert(func->getSize());
     bodySize += func->getSize();
   }
 
   createHeader(bodySize);
 }
 
 void CodeSection::writeTo(uint8_t *buf) {
-  log("writing " + toString(*this));
-  log(" size=" + Twine(getSize()));
+  log("writing " + toString(*this) + " offset=" + Twine(offset) +
+      " size=" + Twine(getSize()));
   log(" headersize=" + Twine(header.size()));
   log(" codeheadersize=" + Twine(codeSectionHeader.size()));
   buf += offset;
 
   // Write section header
   memcpy(buf, header.data(), header.size());
   buf += header.size();
 
for (InputChunk *inputSeg : segment->inputSegments) {
                             inputSeg->outputSegmentOffset;
     }
   }
 
   createHeader(bodySize);
 }
 
 void DataSection::writeTo(uint8_t *buf) {
-  log("writing " + toString(*this) + " size=" + Twine(getSize()) +
-      " body=" + Twine(bodySize));
+  log("writing " + toString(*this) + " offset=" + Twine(offset) +
+      " size=" + Twine(getSize()) + " body=" + Twine(bodySize));
   buf += offset;
 
   // Write section header
   memcpy(buf, header.data(), header.size());
   buf += header.size();
 
   // Write data section headers
   memcpy(buf, dataSectionHeader.data(), dataSectionHeader.size());
for (InputChunk *section : inputSections) {
     section->outSecOff = payloadSize;
     payloadSize += section->getSize();
   }
 
   createHeader(payloadSize + nameData.size());
 }
 
 void CustomSection::writeTo(uint8_t *buf) {
-  log("writing " + toString(*this) + " size=" + Twine(getSize()) +
-      " chunks=" + Twine(inputSections.size()));
+  log("writing " + toString(*this) + " offset=" + Twine(offset) +
+      " size=" + Twine(getSize()) + " chunks=" + Twine(inputSections.size()));
 
   assert(offset);
   buf += offset;
 
   // Write section header
   memcpy(buf, header.data(), header.size());
   buf += header.size();
   memcpy(buf, nameData.data(), nameData.size());

lld/wasm/Writer.cpp

if (errorHandler().verbose) {
     log("Defined Globals  : " + Twine(out.globalSec->numGlobals()));
     log("Defined Tags     : " + Twine(out.tagSec->inputTags.size()));
     log("Defined Tables   : " + Twine(out.tableSec->inputTables.size()));
     log("Function Imports : " +
         Twine(out.importSec->getNumImportedFunctions()));
     log("Global Imports   : " + Twine(out.importSec->getNumImportedGlobals()));
     log("Tag Imports      : " + Twine(out.importSec->getNumImportedTags()));
     log("Table Imports    : " + Twine(out.importSec->getNumImportedTables()));
-    for (ObjFile *file : symtab->objectFiles)
-      file->dumpInfo();
   }
 
   createHeader();
   log("-- finalizeSections");
   finalizeSections();
 
   log("-- writeMapFile");
   writeMapFile(outputSections);

lld/wasm/WriterUtils.h

 
 #include "lld/Common/LLVM.h"
 #include "llvm/ADT/Twine.h"
 #include "llvm/Object/Wasm.h"
 
 namespace lld {
 namespace wasm {
 
+#ifdef LLVM_DEBUG
 void debugWrite(uint64_t offset, const Twine &msg);
+#else
+#define debugWrite(...) (void *)0
+#endif
 
 void writeUleb128(raw_ostream &os, uint64_t number, const Twine &msg);
 
 void writeSleb128(raw_ostream &os, int64_t number, const Twine &msg);
 
 void writeBytes(raw_ostream &os, const char *bytes, size_t count,
                 const Twine &msg);
 

lld/wasm/WriterUtils.cpp

 
 std::string toString(const WasmTableType &type) {
   SmallString<128> ret("");
   return "type=" + toString(static_cast<ValType>(type.ElemType)) +
          "; limits=[" + toString(type.Limits) + "]";
 }
 
 namespace wasm {
+#ifdef LLVM_DEBUG
 void debugWrite(uint64_t offset, const Twine &msg) {
   LLVM_DEBUG(dbgs() << format("  | %08lld: ", offset) << msg << "\n");
 }
+#endif
 
 void writeUleb128(raw_ostream &os, uint64_t number, const Twine &msg) {
   debugWrite(os.tell(), msg + "[" + utohexstr(number) + "]");
   encodeULEB128(number, os);
 }
 
 void writeSleb128(raw_ostream &os, int64_t number, const Twine &msg) {
   debugWrite(os.tell(), msg + "[" + utohexstr(number) + "]");