[lld][WebAssembly] Enable string merging for debug sections

[sbc100]

• rebased on top of refactor

[sbc100]

rebase

[dschuff]

lld/wasm/InputChunks.h

144

can this be deleted?

lld/wasm/InputFiles.cpp

368

this doesn't include .debug_line_str.

Also, I guess the current situation is that we are creating the sections with the flags on the LLVM side, but we don't currently have a way to encode custom section flags?

lld/wasm/OutputSections.cpp

251

does this not apply to generic chunks the same way?

256

is this needed?

[sbc100]

• feedback & rebase

[sbc100]

• feedback

[sbc100]

lld/wasm/InputFiles.cpp

368

Yes, sadly that is the current situation. I hope to improve that by adding flag that can apply to custom sections as well as data segments.

lld/wasm/OutputSections.cpp

251

For now at least it looks like we don't need. Removed.

256

I turns out for custom sections this is not currently needed. Removed.

[dschuff]

lld/wasm/InputChunks.h

68

68

Actually, does this comment now also apply to custom sections as well as data segments?

69

[sbc100]

• feedback

lld/test/wasm/Inputs/merge-string-debug2.s

+.section .debug_str,"S",@
+  .asciz "clang version 13.0.0"
+  .asciz "bar"
+  .asciz "foo"

lld/test/wasm/merge-string-debug.s

+# RUN: llvm-mc -filetype=obj -triple=wasm32-unknown-unknown %s -o %t.o
+# RUN: llvm-mc -filetype=obj -triple=wasm32-unknown-unknown %p/Inputs/merge-string-debug2.s -o %t2.o
+
+# RUN: wasm-ld %t.o %t2.o -o %t.wasm --no-entry
+# RUN: llvm-readobj -x .debug_str %t.wasm | FileCheck %s --check-prefixes CHECK,CHECK-O1
+
+# RUN: wasm-ld -O0 %t.o %t2.o -o %tO0.wasm --no-entry
+# RUN: llvm-readobj -x .debug_str %tO0.wasm | FileCheck %s --check-prefixes CHECK,CHECK-O0
+
+.section .debug_str,"S",@
+  .asciz "clang version 13.0.0"
+  .asciz "foobar"
+
+# CHECK: Hex dump of section '.debug_str':
+
+# CHECK-O0: 0x00000000 636c616e 67207665 7273696f 6e203133 clang version 13
+# CHECK-O0: 0x00000010 2e302e30 00666f6f 62617200 636c616e .0.0.foobar.clan
+# CHECK-O0: 0x00000020 67207665 7273696f 6e203133 2e302e30 g version 13.0.0
+# CHECK-O0: 0x00000030 00626172 00666f6f 00                .bar.foo.
+
+# CHECK-O1: 0x00000000 666f6f62 61720066 6f6f0063 6c616e67 foobar.foo.clang
+# CHECK-O1: 0x00000010 20766572 73696f6e 2031332e 302e3000  version 13.0.0.

lld/wasm/Driver.cpp

static void wrapSymbols(ArrayRef<WrappedSymbol> wrapped) {
   });
 
   // Update pointers in the symbol table.
   for (const WrappedSymbol &w : wrapped)
     symtab->wrap(w.sym, w.real, w.wrap);
 }
 
 static void splitSections() {
-  // splitIntoPieces needs to be called on each MergeInputSection
+  // splitIntoPieces needs to be called on each MergeInputChunk
   // before calling finalizeContents().
   LLVM_DEBUG(llvm::dbgs() << "splitSections\n");
   parallelForEach(symtab->objectFiles, [](ObjFile *file) {
     for (InputChunk *seg : file->segments) {
       if (auto *s = dyn_cast<MergeInputChunk>(seg))
         s->splitIntoPieces();
     }
+    for (InputChunk *sec : file->customSections) {
+      if (auto *s = dyn_cast<MergeInputChunk>(sec))
+        s->splitIntoPieces();
+    }
   });
 }
 
 void LinkerDriver::linkerMain(ArrayRef<const char *> argsArr) {
   WasmOptTable parser;
   opt::InputArgList args = parser.parse(argsArr.slice(1));
 
   // Handle --help

lld/wasm/InputChunks.h

 class InputChunk {
 public:
   enum Kind {
     DataSegment,
     Merge,
     MergedChunk,
     Function,
     SyntheticFunction,
-    Section
+    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;
 
   ArrayRef<WasmRelocation> getRelocations() const { return relocations; }
   void setRelocations(ArrayRef<WasmRelocation> rs) { relocations = rs; }
 
   // Translate an offset in the input section to an offset in the output
   // section.
   uint64_t getOffset(uint64_t offset) const;
-  // For data segments, translate and offset into the input segment into
-  // an offset into the output segment
-  uint64_t getSegmentOffset(uint64_t offset) const;
+  // For data segments translate and offset into the input segment into
+  // and offset into the output segment
+  uint64_t getChunkOffset(uint64_t offset) const;
   uint64_t getVA(uint64_t offset = 0) const;
 
   uint32_t getComdat() const { return comdat; }
   StringRef getComdatName() const;
   uint32_t getInputSectionOffset() const { return inputSectionOffset; }
 
   size_t getNumRelocations() const { return relocations.size(); }
   void writeRelocations(llvm::raw_ostream &os) const;

 // formats, used the term "data segment" to refer to the continuous regions of
 // memory that make on the data section. See:
 // https://webassembly.github.io/spec/syntax/modules.html#syntax-data
 //
 // For example, by default, clang will produce a separate data section for
 // each global variable.
 class InputSegment : public InputChunk {
 public:
-  InputSegment(const WasmSegment *seg, ObjFile *f)
-      : InputChunk(f, InputChunk::DataSegment, seg->Data.Name,
-                   seg->Data.Alignment, seg->Data.LinkingFlags),
+  InputSegment(const WasmSegment &seg, ObjFile *f)
+      : InputChunk(f, InputChunk::DataSegment, seg.Data.Name,
+                   seg.Data.Alignment, seg.Data.LinkingFlags),
         segment(seg) {
-    rawData = segment->Data.Content;
-    comdat = segment->Data.Comdat;
-    inputSectionOffset = segment->SectionOffset;
+    rawData = segment.Data.Content;
+    comdat = segment.Data.Comdat;
+    inputSectionOffset = segment.SectionOffset;
   }
 
-  InputSegment(StringRef name, uint32_t alignment, uint32_t flags)
-      : InputChunk(nullptr, InputChunk::DataSegment, name, alignment, flags) {}
-
   static bool classof(const InputChunk *c) { return c->kind() == DataSegment; }
 
 protected:
-  const WasmSegment *segment = nullptr;
+  const WasmSegment &segment;
 };
 
 class SyntheticMergedChunk;
 
 // Merge segment handling copied from lld/ELF/InputSection.h.  Keep in sync
 // where possible.
 
 // SectionPiece represents a piece of splittable segment contents.
struct SectionPiece {
   uint64_t outputOff = 0;
 };
 
 static_assert(sizeof(SectionPiece) == 16, "SectionPiece is too big");
 
 // This corresponds segments marked as WASM_SEG_FLAG_STRINGS.
 class MergeInputChunk : public InputChunk {
 public:
-  MergeInputChunk(const WasmSegment *seg, ObjFile *f)
-      : InputChunk(f, Merge, seg->Data.Name, seg->Data.Alignment,
-                   seg->Data.LinkingFlags) {
-    rawData = seg->Data.Content;
-    comdat = seg->Data.Comdat;
-    inputSectionOffset = seg->SectionOffset;
+  MergeInputChunk(const WasmSegment &seg, ObjFile *f)
+      : InputChunk(f, Merge, seg.Data.Name, seg.Data.Alignment,
+                   seg.Data.LinkingFlags) {
+    rawData = seg.Data.Content;
+    comdat = seg.Data.Comdat;
+    inputSectionOffset = seg.SectionOffset;
+  }
+
+  MergeInputChunk(const WasmSection &s, ObjFile *f)
+      : InputChunk(f, Merge, s.Name, 0, llvm::wasm::WASM_SEG_FLAG_STRINGS) {
+    assert(s.Type == llvm::wasm::WASM_SEC_CUSTOM);
+    comdat = s.Comdat;
+    rawData = s.Content;
   }
 
   static bool classof(const InputChunk *s) { return s->kind() == Merge; }
   void splitIntoPieces();
 
   // Translate an offset in the input section to an offset in the parent
   // MergeSyntheticSection.
   uint64_t getParentOffset(uint64_t offset) const;

lld/wasm/InputChunks.cpp

void InputFunction::writeCompressed(uint8_t *buf) const {
   }
 
   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::getOffset(uint64_t offset) const {
-  return outSecOff + offset;
-}
-
-uint64_t InputChunk::getSegmentOffset(uint64_t offset) const {
+uint64_t InputChunk::getChunkOffset(uint64_t offset) const {
   if (const auto *ms = dyn_cast<MergeInputChunk>(this)) {
     LLVM_DEBUG(dbgs() << "getSegmentOffset(merged): " << getName() << "\n");
     LLVM_DEBUG(dbgs() << "offset: " << offset << "\n");
     LLVM_DEBUG(dbgs() << "parentOffset: " << ms->getParentOffset(offset)
                       << "\n");
     assert(ms->parent);
-    return ms->parent->getSegmentOffset(ms->getParentOffset(offset));
+    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) + getSegmentOffset(offset);
+  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 libaries (PIC) where address are
 // not known at static link time.
 void InputChunk::generateRelocationCode(raw_ostream &os) const {
   LLVM_DEBUG(dbgs() << "generating runtime relocations: " << getName()
                     << " count=" << relocations.size() << "\n");

lld/wasm/InputFiles.h

public:
   std::vector<uint32_t> tableEntries;
   std::vector<uint32_t> tableEntriesRel;
   std::vector<bool> keptComdats;
   std::vector<InputChunk *> segments;
   std::vector<InputFunction *> functions;
   std::vector<InputGlobal *> globals;
   std::vector<InputEvent *> events;
   std::vector<InputTable *> tables;
-  std::vector<InputSection *> customSections;
-  llvm::DenseMap<uint32_t, InputSection *> customSectionsByIndex;
+  std::vector<InputChunk *> customSections;
+  llvm::DenseMap<uint32_t, InputChunk *> customSectionsByIndex;
 
   Symbol *getSymbol(uint32_t index) const { return symbols[index]; }
   FunctionSymbol *getFunctionSymbol(uint32_t index) const;
   DataSymbol *getDataSymbol(uint32_t index) const;
   GlobalSymbol *getGlobalSymbol(uint32_t index) const;
   SectionSymbol *getSectionSymbol(uint32_t index) const;
   EventSymbol *getEventSymbol(uint32_t index) const;
   TableSymbol *getTableSymbol(uint32_t index) const;

lld/wasm/InputFiles.cpp

void ObjFile::addLegacyIndirectFunctionTableIfNeeded(
   // liveness info; instead, just mark the symbol as always live.
   sym->markLive();
 
   // We assume that this compilation unit has unrelocatable references to
   // this table.
   config->legacyFunctionTable = true;
 }
 
+static bool shouldMerge(const WasmSection &sec) {
+  if (config->optimize == 0)
+    return false;
+  // Sadly we don't have section attributes yet for custom sections, so we
+  // currently go by the name alone.
+  // TODO(sbc): Add ability for wasm sections to carry flags so we don't
+  // need to use names here.
+  return sec.Name.startswith(".debug_str") ||
+         sec.Name.startswith(".debug_line_str");
+}
+
 static bool shouldMerge(const WasmSegment &seg) {
   // As of now we only support merging strings, and only with single byte
   // alignment (2^0).
   if (!(seg.Data.LinkingFlags & WASM_SEG_FLAG_STRINGS) ||
       (seg.Data.Alignment != 0))
     return false;
 
   // On a regular link we don't merge sections if -O0 (default is -O1). This
for (const SectionRef &sec : wasmObj->sections()) {
     // Wasm objects can have at most one code and one data section.
     if (section.Type == WASM_SEC_CODE) {
       assert(!codeSection);
       codeSection = &section;
     } else if (section.Type == WASM_SEC_DATA) {
       assert(!dataSection);
       dataSection = &section;
     } else if (section.Type == WASM_SEC_CUSTOM) {
-      auto *customSec = make<InputSection>(section, this);
+      InputChunk *customSec;
+      if (shouldMerge(section))
+        customSec = make<MergeInputChunk>(section, this);
+      else
+        customSec = make<InputSection>(section, this);
       customSec->discarded = isExcludedByComdat(customSec);
       customSections.emplace_back(customSec);
       customSections.back()->setRelocations(section.Relocations);
       customSectionsByIndex[sectionIndex] = customSections.back();
     }
     sectionIndex++;
     // Scans relocations to determine if a function symbol is called directly.
     for (const WasmRelocation &reloc : section.Relocations)
       if (reloc.Type == R_WASM_FUNCTION_INDEX_LEB)
         isCalledDirectly[reloc.Index] = true;
   }
 
   typeMap.resize(getWasmObj()->types().size());
   typeIsUsed.resize(getWasmObj()->types().size(), false);
 
 
   // Populate `Segments`.
   for (const WasmSegment &s : wasmObj->dataSegments()) {
     InputChunk *seg;
     if (shouldMerge(s)) {
-      seg = make<MergeInputChunk>(&s, this);
+      seg = make<MergeInputChunk>(s, this);
     } else
-      seg = make<InputSegment>(&s, this);
+      seg = make<InputSegment>(s, this);
     seg->discarded = isExcludedByComdat(seg);
 
     segments.emplace_back(seg);
   }
   setRelocs(segments, dataSection);
 
   // Populate `Functions`.
   ArrayRef<WasmFunction> funcs = wasmObj->functions();
Symbol *ObjFile::createDefined(const WasmSymbol &sym) {
   case WASM_SYMBOL_TYPE_GLOBAL: {
     InputGlobal *global =
         globals[sym.Info.ElementIndex - wasmObj->getNumImportedGlobals()];
     if (sym.isBindingLocal())
       return make<DefinedGlobal>(name, flags, this, global);
     return symtab->addDefinedGlobal(name, flags, this, global);
   }
   case WASM_SYMBOL_TYPE_SECTION: {
-    InputSection *section = customSectionsByIndex[sym.Info.ElementIndex];
+    InputChunk *section = customSectionsByIndex[sym.Info.ElementIndex];
     assert(sym.isBindingLocal());
     // Need to return null if discarded here? data and func only do that when
     // binding is not local.
     if (section->discarded)
       return nullptr;
     return make<SectionSymbol>(flags, section, this);
   }
   case WASM_SYMBOL_TYPE_EVENT: {

lld/wasm/OutputSections.h

 // used for storing user-defined metadata.  Unlike the core sections types
 // they are identified by their string name.
 // The linker combines custom sections that have the same name by simply
 // concatenating them.
 // Note that some custom sections such as "name" and "linking" are handled
 // separately and are instead synthesized by the linker.
 class CustomSection : public OutputSection {
 public:
-  CustomSection(std::string name, ArrayRef<InputSection *> inputSections)
+  CustomSection(std::string name, ArrayRef<InputChunk *> inputSections)
       : OutputSection(llvm::wasm::WASM_SEC_CUSTOM, name),
         inputSections(inputSections) {}
 
   static bool classof(const OutputSection *sec) {
     return sec->type == llvm::wasm::WASM_SEC_CUSTOM;
   }
 
   size_t getSize() const override {
     return header.size() + nameData.size() + payloadSize;
   }
   void writeTo(uint8_t *buf) override;
   uint32_t getNumRelocations() const override;
   void writeRelocations(raw_ostream &os) const override;
   void finalizeContents() override;
 
 protected:
+  void finalizeInputSections();
   size_t payloadSize = 0;
-  ArrayRef<InputSection *> inputSections;
+  std::vector<InputChunk *> inputSections;
   std::string nameData;
 };
 
 } // namespace wasm
 } // namespace lld
 
 #endif // LLD_WASM_OUTPUT_SECTIONS_H

lld/wasm/OutputSections.cpp

 //===- OutputSections.cpp -------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "OutputSections.h"
 #include "InputChunks.h"
 #include "InputFiles.h"
 #include "OutputSegment.h"
 #include "WriterUtils.h"
 #include "lld/Common/ErrorHandler.h"
+#include "lld/Common/Memory.h"
 #include "llvm/ADT/Twine.h"
 #include "llvm/Support/LEB128.h"
 #include "llvm/Support/Parallel.h"
 
 #define DEBUG_TYPE "lld"
 
 using namespace llvm;
 using namespace llvm::wasm;

 
 bool DataSection::isNeeded() const {
   for (const OutputSegment *seg : segments)
     if (!seg->isBss)
       return true;
   return false;
 }
 
+// Lots of duplication here with OutputSegment::finalizeInputSegments
+void CustomSection::finalizeInputSections() {
+  SyntheticMergedChunk *mergedSection = nullptr;
+  std::vector<InputChunk *> newSections;
+
+  for (InputChunk *s : inputSections) {
+    MergeInputChunk *ms = dyn_cast<MergeInputChunk>(s);
+    if (!ms) {
+      newSections.push_back(s);
+      continue;
+    }
+
+    if (!mergedSection) {
+      mergedSection =
+          make<SyntheticMergedChunk>(name, 0, WASM_SEG_FLAG_STRINGS);
+      newSections.push_back(mergedSection);
+    }
+    mergedSection->addMergeChunk(ms);
+  }
+
+  if (!mergedSection)
+    return;
+
+  mergedSection->finalizeContents();
+  inputSections = newSections;
+}
+
 void CustomSection::finalizeContents() {
+  finalizeInputSections();
+
   raw_string_ostream os(nameData);
   encodeULEB128(name.size(), os);
   os << name;
   os.flush();
 
-  for (InputSection *section : inputSections) {
+  for (InputChunk *section : inputSections) {
     assert(!section->discarded);
     section->outputSec = this;
     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()));
 
   assert(offset);
   buf += offset;
 
   // Write section header
   memcpy(buf, header.data(), header.size());
   buf += header.size();
   memcpy(buf, nameData.data(), nameData.size());
   buf += nameData.size();
 
   // Write custom sections payload
-  for (const InputSection *section : inputSections)
+  for (const InputChunk *section : inputSections)
     section->writeTo(buf);
 }
 
 uint32_t CustomSection::getNumRelocations() const {
   uint32_t count = 0;
-  for (const InputSection *inputSect : inputSections)
+  for (const InputChunk *inputSect : inputSections)
     count += inputSect->getNumRelocations();
   return count;
 }
 
 void CustomSection::writeRelocations(raw_ostream &os) const {
-  for (const InputSection *s : inputSections)
+  for (const InputChunk *s : inputSections)
     s->writeRelocations(os);
 }
 
 } // namespace wasm
 } // namespace lld

lld/wasm/OutputSegment.cpp

for (InputChunk *s : inputSegments) {
 
     // A segment should not make it here unless its alive
     assert(ms->live);
 
     auto i = llvm::find_if(mergedSegments, [=](SyntheticMergedChunk *seg) {
       return seg->flags == ms->flags && seg->alignment == ms->alignment;
     });
     if (i == mergedSegments.end()) {
-      LLVM_DEBUG(llvm::dbgs() << "new merge section: " << name
+      LLVM_DEBUG(llvm::dbgs() << "new merge segment: " << name
                               << " alignment=" << ms->alignment << "\n");
-      SyntheticMergedChunk *syn =
-          make<SyntheticMergedChunk>(name, ms->alignment, ms->flags);
+      auto *syn = make<SyntheticMergedChunk>(name, ms->alignment, ms->flags);
       syn->outputSeg = this;
       mergedSegments.push_back(syn);
       i = std::prev(mergedSegments.end());
       newSegments.push_back(syn);
     } else {
-      LLVM_DEBUG(llvm::dbgs() << "adding to merge section: " << name << "\n");
+      LLVM_DEBUG(llvm::dbgs() << "adding to merge segment: " << name << "\n");
     }
     (*i)->addMergeChunk(ms);
   }
 
   for (auto *ms : mergedSegments)
     ms->finalizeContents();
 
   inputSegments = newSegments;

lld/wasm/Symbols.h

static bool classof(const Symbol *s) {
     return s->kind() == OutputSectionKind;
   }
 
   const OutputSection *section;
 };
 
 class SectionSymbol : public Symbol {
 public:
-  SectionSymbol(uint32_t flags, const InputSection *s, InputFile *f = nullptr)
+  SectionSymbol(uint32_t flags, const InputChunk *s, InputFile *f = nullptr)
       : Symbol("", SectionKind, flags, f), section(s) {}
 
   static bool classof(const Symbol *s) { return s->kind() == SectionKind; }
 
   const OutputSectionSymbol *getOutputSectionSymbol() const;
 
-  const InputSection *section;
+  const InputChunk *section;
 };
 
 class DataSymbol : public Symbol {
 public:
   static bool classof(const Symbol *s) {
     return s->kind() == DefinedDataKind || s->kind() == UndefinedDataKind;
   }
 

lld/wasm/Symbols.cpp

 void DefinedData::setVA(uint64_t value_) {
   LLVM_DEBUG(dbgs() << "setVA " << name << " -> " << value_ << "\n");
   assert(!segment);
   value = value_;
 }
 
 uint64_t DefinedData::getOutputSegmentOffset() const {
   LLVM_DEBUG(dbgs() << "getOutputSegmentOffset: " << getName() << "\n");
-  return segment->getSegmentOffset(value);
+  return segment->getChunkOffset(value);
 }
 
 uint64_t DefinedData::getOutputSegmentIndex() const {
   LLVM_DEBUG(dbgs() << "getOutputSegmentIndex: " << getName() << "\n");
   return segment->outputSeg->index;
 }
 
 uint32_t GlobalSymbol::getGlobalIndex() const {

lld/wasm/Writer.cpp

private:
   void createRelocSections();
 
   void writeHeader();
   void writeSections();
 
   uint64_t fileSize = 0;
 
   std::vector<WasmInitEntry> initFunctions;
-  llvm::StringMap<std::vector<InputSection *>> customSectionMapping;
+  llvm::StringMap<std::vector<InputChunk *>> customSectionMapping;
 
   // Stable storage for command export wrapper function name strings.
   std::list<std::string> commandExportWrapperNames;
 
   // Elements that are used to construct the final output
   std::string header;
   std::vector<OutputSection *> outputSections;
 
   std::unique_ptr<FileOutputBuffer> buffer;
 
   std::vector<OutputSegment *> segments;
   llvm::SmallDenseMap<StringRef, OutputSegment *> segmentMap;
 };
 
 } // anonymous namespace
 
 void Writer::calculateCustomSections() {
   log("calculateCustomSections");
   bool stripDebug = config->stripDebug || config->stripAll;
   for (ObjFile *file : symtab->objectFiles) {
-    for (InputSection *section : file->customSections) {
+    for (InputChunk *section : file->customSections) {
       // Exclude COMDAT sections that are not selected for inclusion
       if (section->discarded)
         continue;
       StringRef name = section->getName();
       // 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."))

llvm/include/llvm/MC/MCContext.h

public:
     /// Gets or creates a section equivalent to Sec that is associated with the
     /// section containing KeySym. For example, to create a debug info section
     /// associated with an inline function, pass the normal debug info section
     /// as Sec and the function symbol as KeySym.
     MCSectionCOFF *
     getAssociativeCOFFSection(MCSectionCOFF *Sec, const MCSymbol *KeySym,
                               unsigned UniqueID = GenericSectionID);
 
-    MCSectionWasm *getWasmSection(const Twine &Section, SectionKind K) {
-      return getWasmSection(Section, K, 0, nullptr);
+    MCSectionWasm *getWasmSection(const Twine &Section, SectionKind K,
+                                  unsigned Flags = 0) {
+      return getWasmSection(Section, K, Flags, nullptr);
     }
 
     MCSectionWasm *getWasmSection(const Twine &Section, SectionKind K,
                                   unsigned Flags, const char *BeginSymName) {
       return getWasmSection(Section, K, Flags, "", ~0, BeginSymName);
     }
 
     MCSectionWasm *getWasmSection(const Twine &Section, SectionKind K,

llvm/lib/MC/MCObjectFileInfo.cpp

 //===-- MCObjectFileInfo.cpp - Object File Information --------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/MC/MCObjectFileInfo.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/ADT/Triple.h"
 #include "llvm/BinaryFormat/COFF.h"
 #include "llvm/BinaryFormat/ELF.h"
+#include "llvm/BinaryFormat/Wasm.h"
 #include "llvm/MC/MCAsmInfo.h"
 #include "llvm/MC/MCContext.h"
 #include "llvm/MC/MCSection.h"
 #include "llvm/MC/MCSectionCOFF.h"
 #include "llvm/MC/MCSectionELF.h"
 #include "llvm/MC/MCSectionMachO.h"
 #include "llvm/MC/MCSectionWasm.h"
 #include "llvm/MC/MCSectionXCOFF.h"

 
 void MCObjectFileInfo::initWasmMCObjectFileInfo(const Triple &T) {
   TextSection = Ctx->getWasmSection(".text", SectionKind::getText());
   DataSection = Ctx->getWasmSection(".data", SectionKind::getData());
 
   DwarfLineSection =
       Ctx->getWasmSection(".debug_line", SectionKind::getMetadata());
   DwarfLineStrSection =
-      Ctx->getWasmSection(".debug_line_str", SectionKind::getMetadata());
-  DwarfStrSection =
-      Ctx->getWasmSection(".debug_str", SectionKind::getMetadata());
+      Ctx->getWasmSection(".debug_line_str", SectionKind::getMetadata(),
+                          wasm::WASM_SEG_FLAG_STRINGS);
+  DwarfStrSection = Ctx->getWasmSection(
+      ".debug_str", SectionKind::getMetadata(), wasm::WASM_SEG_FLAG_STRINGS);
   DwarfLocSection =
       Ctx->getWasmSection(".debug_loc", SectionKind::getMetadata());
   DwarfAbbrevSection =
       Ctx->getWasmSection(".debug_abbrev", SectionKind::getMetadata());
   DwarfARangesSection = Ctx->getWasmSection(".debug_aranges", SectionKind::getMetadata());
   DwarfRangesSection =
       Ctx->getWasmSection(".debug_ranges", SectionKind::getMetadata());
   DwarfMacinfoSection =
void MCObjectFileInfo::initWasmMCObjectFileInfo(const Triple &T) {
   // Fission Sections
   DwarfInfoDWOSection =
       Ctx->getWasmSection(".debug_info.dwo", SectionKind::getMetadata());
   DwarfTypesDWOSection =
       Ctx->getWasmSection(".debug_types.dwo", SectionKind::getMetadata());
   DwarfAbbrevDWOSection =
       Ctx->getWasmSection(".debug_abbrev.dwo", SectionKind::getMetadata());
   DwarfStrDWOSection =
-      Ctx->getWasmSection(".debug_str.dwo", SectionKind::getMetadata());
+      Ctx->getWasmSection(".debug_str.dwo", SectionKind::getMetadata(),
+                          wasm::WASM_SEG_FLAG_STRINGS);
   DwarfLineDWOSection =
       Ctx->getWasmSection(".debug_line.dwo", SectionKind::getMetadata());
   DwarfLocDWOSection =
       Ctx->getWasmSection(".debug_loc.dwo", SectionKind::getMetadata());
   DwarfStrOffDWOSection =
       Ctx->getWasmSection(".debug_str_offsets.dwo", SectionKind::getMetadata());
   DwarfRnglistsDWOSection =
       Ctx->getWasmSection(".debug_rnglists.dwo", SectionKind::getMetadata());