[lld][WebAssembly] Remove unnecessary accessor methods. NFC

[sbc100]

Summary

This is less code, and matches more closely the ELF linker.

lld/wasm/InputChunks.h

enum Kind {
     Function,
     SyntheticFunction,
     Section,
   };
 
   StringRef name;
   StringRef debugName;
 
-  StringRef getName() const { return name; }
-  StringRef getDebugName() const { return debugName; }
   Kind kind() const { return (Kind)sectionKind; }
 
   uint32_t getSize() const;
   uint32_t getInputSize() const;
 
   void writeTo(uint8_t *buf) const;
   void relocate(uint8_t *buf) const;
 

lld/wasm/InputChunks.cpp

bool relocIs64(uint8_t relocType) {
   case R_WASM_MEMORY_ADDR_TLS_SLEB64:
     return true;
   default:
     return false;
   }
 }
 
 std::string toString(const wasm::InputChunk *c) {
-  return (toString(c->file) + ":(" + c->getName() + ")").str();
+  return (toString(c->file) + ":(" + c->name + ")").str();
 }
 
 namespace wasm {
 StringRef InputChunk::getComdatName() const {
   uint32_t index = getComdat();
   if (index == UINT32_MAX)
     return StringRef();
   return file->getWasmObj()->linkingData().Comdats[index];
uint64_t InputChunk::getTombstone() const {
   if (const auto *s = dyn_cast<InputSection>(this)) {
     return s->tombstoneValue;
   }
 
   return 0;
 }
 
 void InputFunction::setFunctionIndex(uint32_t index) {
-  LLVM_DEBUG(dbgs() << "InputFunction::setFunctionIndex: " << getName()
-                    << " -> " << index << "\n");
+  LLVM_DEBUG(dbgs() << "InputFunction::setFunctionIndex: " << name << " -> "
+                    << index << "\n");
   assert(!hasFunctionIndex());
   functionIndex = index;
 }
 
 void InputFunction::setTableIndex(uint32_t index) {
-  LLVM_DEBUG(dbgs() << "InputFunction::setTableIndex: " << getName() << " -> "
+  LLVM_DEBUG(dbgs() << "InputFunction::setTableIndex: " << name << " -> "
                     << index << "\n");
   assert(!hasTableIndex());
   tableIndex = index;
 }
 
 // Write a relocation value without padding and return the number of bytes
 // witten.
 static unsigned writeCompressedReloc(uint8_t *buf, const WasmRelocation &rel,

 // relocation.  At best we end up saving 4 bytes for each relocation entry.
 //
 // This function only computes the final output size.  It must be called
 // before getSize() is used to calculate of layout of the code section.
 void InputFunction::calculateSize() {
   if (!file || !config->compressRelocations)
     return;
 
-  LLVM_DEBUG(dbgs() << "calculateSize: " << getName() << "\n");
+  LLVM_DEBUG(dbgs() << "calculateSize: " << name << "\n");
 
   const uint8_t *secStart = file->codeSection->Content.data();
   const uint8_t *funcStart = secStart + getInputSectionOffset();
   uint32_t functionSizeLength;
   decodeULEB128(funcStart, &functionSizeLength);
 
   uint32_t start = getInputSectionOffset();
   uint32_t end = start + function->Size;
void InputFunction::writeCompressed(uint8_t *buf) const {
   const uint8_t *secStart = file->codeSection->Content.data();
   const uint8_t *funcStart = secStart + getInputSectionOffset();
   const uint8_t *end = funcStart + function->Size;
   uint64_t tombstone = getTombstone();
   uint32_t count;
   decodeULEB128(funcStart, &count);
   funcStart += count;
 
-  LLVM_DEBUG(dbgs() << "write func: " << getName() << "\n");
+  LLVM_DEBUG(dbgs() << "write func: " << name << "\n");
   buf += encodeULEB128(compressedFuncSize, buf);
   const uint8_t *lastRelocEnd = funcStart;
   for (const WasmRelocation &rel : relocations) {
     unsigned chunkSize = (secStart + rel.Offset) - lastRelocEnd;
     LLVM_DEBUG(dbgs() << "  write chunk: " << chunkSize << "\n");
     memcpy(buf, lastRelocEnd, chunkSize);
     buf += chunkSize;
     buf += writeCompressedReloc(buf, rel,
                                 file->calcNewValue(rel, tombstone, this));
     lastRelocEnd = secStart + rel.Offset + getRelocWidthPadded(rel);
   }
 
   unsigned chunkSize = end - lastRelocEnd;
   LLVM_DEBUG(dbgs() << "  write final chunk: " << chunkSize << "\n");
   memcpy(buf, lastRelocEnd, chunkSize);
   LLVM_DEBUG(dbgs() << "  total: " << (buf + chunkSize - orig) << "\n");
 }
 
 uint64_t InputChunk::getChunkOffset(uint64_t offset) const {
   if (const auto *ms = dyn_cast<MergeInputChunk>(this)) {
-    LLVM_DEBUG(dbgs() << "getChunkOffset(merged): " << getName() << "\n");
+    LLVM_DEBUG(dbgs() << "getChunkOffset(merged): " << name << "\n");
     LLVM_DEBUG(dbgs() << "offset: " << offset << "\n");
     LLVM_DEBUG(dbgs() << "parentOffset: " << ms->getParentOffset(offset)
                       << "\n");
     assert(ms->parent);
     return ms->parent->getChunkOffset(ms->getParentOffset(offset));
   }
   return outputSegmentOffset + offset;
 }
 
 uint64_t InputChunk::getOffset(uint64_t offset) const {
   return outSecOff + getChunkOffset(offset);
 }
 
 uint64_t InputChunk::getVA(uint64_t offset) const {
   return (outputSeg ? outputSeg->startVA : 0) + getChunkOffset(offset);
 }
 
 // Generate code to apply relocations to the data section at runtime.
 // This is only called when generating shared libraries (PIC) where address are
 // not known at static link time.
 void InputChunk::generateRelocationCode(raw_ostream &os) const {
-  LLVM_DEBUG(dbgs() << "generating runtime relocations: " << getName()
+  LLVM_DEBUG(dbgs() << "generating runtime relocations: " << name
                     << " count=" << relocations.size() << "\n");
 
   bool is64 = config->is64.getValueOr(false);
   unsigned opcode_ptr_const = is64 ? WASM_OPCODE_I64_CONST
                                    : WASM_OPCODE_I32_CONST;
   unsigned opcode_ptr_add = is64 ? WASM_OPCODE_I64_ADD
                                  : WASM_OPCODE_I32_ADD;
 

lld/wasm/OutputSegment.cpp

 namespace lld {
 
 namespace wasm {
 
 void OutputSegment::addInputSegment(InputChunk *inSeg) {
   alignment = std::max(alignment, inSeg->alignment);
   inputSegments.push_back(inSeg);
   size = llvm::alignTo(size, 1ULL << inSeg->alignment);
-  LLVM_DEBUG(dbgs() << "addInputSegment: " << inSeg->getName()
-                    << " oname=" << name << " size=" << inSeg->getSize()
+  LLVM_DEBUG(dbgs() << "addInputSegment: " << inSeg->name << " oname=" << name
+                    << " size=" << inSeg->getSize()
                     << " align=" << inSeg->alignment << " at:" << size << "\n");
   inSeg->outputSeg = this;
   inSeg->outputSegmentOffset = size;
   size += inSeg->getSize();
 }
 
 // This function scans over the input segments.
 //
void OutputSegment::finalizeInputSegments() {
 
   for (auto *ms : mergedSegments)
     ms->finalizeContents();
 
   inputSegments = newSegments;
   size = 0;
   for (InputChunk *seg : inputSegments) {
     size = llvm::alignTo(size, 1ULL << seg->alignment);
-    LLVM_DEBUG(llvm::dbgs() << "outputSegmentOffset set: " << seg->getName()
+    LLVM_DEBUG(llvm::dbgs() << "outputSegmentOffset set: " << seg->name
                             << " -> " << size << "\n");
     seg->outputSegmentOffset = size;
     size += seg->getSize();
   }
 }
 
 } // namespace wasm
 } // namespace lld

lld/wasm/SyntheticSections.cpp

void LinkingSection::addToSymtab(Symbol *sym) {
   sym->setOutputSymbolIndex(symtabEntries.size());
   symtabEntries.emplace_back(sym);
 }
 
 unsigned NameSection::numNamedFunctions() const {
   unsigned numNames = out.importSec->getNumImportedFunctions();
 
   for (const InputFunction *f : out.functionSec->inputFunctions)
-    if (!f->getName().empty() || !f->getDebugName().empty())
+    if (!f->name.empty() || !f->debugName.empty())
       ++numNames;
 
   return numNames;
 }
 
 unsigned NameSection::numNamedGlobals() const {
   unsigned numNames = out.importSec->getNumImportedGlobals();
 
if (count) {
     // functions coming first.
     for (const Symbol *s : out.importSec->importedSymbols) {
       if (auto *f = dyn_cast<FunctionSymbol>(s)) {
         writeUleb128(sub.os, f->getFunctionIndex(), "func index");
         writeStr(sub.os, toString(*s), "symbol name");
       }
     }
     for (const InputFunction *f : out.functionSec->inputFunctions) {
-      if (!f->getName().empty()) {
+      if (!f->name.empty()) {
         writeUleb128(sub.os, f->getFunctionIndex(), "func index");
-        if (!f->getDebugName().empty()) {
-          writeStr(sub.os, f->getDebugName(), "symbol name");
+        if (!f->debugName.empty()) {
+          writeStr(sub.os, f->debugName, "symbol name");
         } else {
-          writeStr(sub.os, maybeDemangleSymbol(f->getName()), "symbol name");
+          writeStr(sub.os, maybeDemangleSymbol(f->name), "symbol name");
         }
       }
     }
     sub.writeTo(bodyOutputStream);
   }
 
   count = numNamedGlobals();
   if (count) {

lld/wasm/Writer.cpp

 void Writer::calculateCustomSections() {
   log("calculateCustomSections");
   bool stripDebug = config->stripDebug || config->stripAll;
   for (ObjFile *file : symtab->objectFiles) {
     for (InputChunk *section : file->customSections) {
       // Exclude COMDAT sections that are not selected for inclusion
       if (section->discarded)
         continue;
-      StringRef name = section->getName();
+      StringRef name = section->name;
       // These custom sections are known the linker and synthesized rather than
       // blindly copied.
       if (name == "linking" || name == "name" || name == "producers" ||
           name == "target_features" || name.startswith("reloc."))
         continue;
       // These custom sections are generated by `clang -fembed-bitcode`.
       // These are used by the rust toolchain to ship LTO data along with
       // compiled object code, but they don't want this included in the linker
void Writer::assignIndexes() {
   out.tableSec->assignIndexes();
 }
 
 static StringRef getOutputDataSegmentName(const InputChunk &seg) {
   // We always merge .tbss and .tdata into a single TLS segment so all TLS
   // symbols are be relative to single __tls_base.
   if (seg.isTLS())
     return ".tdata";
-  StringRef name = seg.getName();
   if (!config->mergeDataSegments)
-    return name;
-  if (name.startswith(".text."))
+    return seg.name;
+  if (seg.name.startswith(".text."))
     return ".text";
-  if (name.startswith(".data."))
+  if (seg.name.startswith(".data."))
     return ".data";
-  if (name.startswith(".bss."))
+  if (seg.name.startswith(".bss."))
     return ".bss";
-  if (name.startswith(".rodata."))
+  if (seg.name.startswith(".rodata."))
     return ".rodata";
-  return name;
+  return seg.name;
 }
 
 OutputSegment *Writer::createOutputSegment(StringRef name) {
   LLVM_DEBUG(dbgs() << "new segment: " << name << "\n");
   OutputSegment *s = make<OutputSegment>(name);
   if (config->sharedMemory)
     s->initFlags = WASM_DATA_SEGMENT_IS_PASSIVE;
   if (!config->relocatable && name.startswith(".bss"))
for (InputChunk *inSeg : s->inputSegments) {
         inSeg->alignment = std::max(inSeg->alignment, s->alignment);
       first = false;
 #ifndef NDEBUG
       uint64_t oldVA = inSeg->getVA();
 #endif
       combined->addInputSegment(inSeg);
 #ifndef NDEBUG
       uint64_t newVA = inSeg->getVA();
-      LLVM_DEBUG(dbgs() << "added input segment. name=" << inSeg->getName()
+      LLVM_DEBUG(dbgs() << "added input segment. name=" << inSeg->name
                         << " oldVA=" << oldVA << " newVA=" << newVA << "\n");
       assert(oldVA == newVA);
 #endif
     }
   }
 
   segments = {combined};
 }