[lld][WebAssembly] Initial support merging string data

[sbc100]

Summary

This change adds support for a new WASM_SEG_FLAG_STRINGS flag in
the object format which works in a similar fashion to SHF_STRINGS
in the ELF world.

Unlike the ELF linker this support is currently limited:

• No support for SHF_MERGE (non-string merging)
• Always do full tail merging ("lo" can be merged with "hello")
• Only support single byte strings (p2align 0)

Like the ELF linker merging is only performed at -O1 and above.

This fixes part of https://bugs.llvm.org/show_bug.cgi?id=48828,
although crucially it doesn't not currently support debug sections
because they are not represented by data segments (they are custom
sections)

[sbc100]

rebase

[sbc100]

PTAL. This is almost ready to land now.

I've tested it against the ensure emscripten test suite: https://github.com/emscripten-core/emscripten/pull/14046. It improves all our microbenchmarks that measure code size.. there is just one strange code size regression that I'm still investigating but I don't think it will block this

[dschuff]

Still looking over this, but had a question more up front

lld/wasm/Driver.cpp

388

this means we optimize by default now?

lld/wasm/InputChunks.h

158

should this say "SegmentPiece" instead of "SectionPiece"?

llvm/include/llvm/MC/MCSectionWasm.h

44

I'm a bit fuzzy now on segments and sections. Is the reason we're calling these "segment flags" here and elswhere, just because we are using segments in the wasm binary to represent them?

[sbc100]

• feedback

[sbc100]

• added new MC test

[dschuff]

looks pretty good overall, a lot of this is making sure I understand everything

lld/wasm/InputChunks.cpp

374

This is dead because of the assertion above.

475

just to be clear, each thread has a different this object? When this function calls splitStrings, the emplaceBack will definitely allocate.

488

is the map checked somewhere else?

lld/wasm/InputChunks.h

42

Is "Merge" a segment that can be merged, and "MergedSegment" after merging? Would "MergeableSegment" better reflect what it means?

lld/wasm/InputFiles.cpp

435

Does clang explicitly pass -O0 to the linker to opt out, or does the user have to do that with -Wl?

lld/wasm/OutputSegment.cpp

43

the name mergeSegments is slightly confusing given (IIUC) that "merge segments" is used elsewhere to refer to segments before merging and here they are already-merged segments.

55

this capture could probably just be ms instead of =

llvm/lib/MC/MCObjectFileInfo.cpp

799

So this sets the section flag as a string section, but we just don't merge them yet?

llvm/lib/MC/MCParser/WasmAsmParser.cpp

107

Why this change? I don't see any new callers of this function, and the error message is worse now.

Edit: actually, does TokError print the token that it read? if so, then maybe it's no worse.

165

This should maybe clarify that it's a section flag (rather than the generic "flag")?

[sbc100]

lld/wasm/Driver.cpp

388

Sorry I should have mentioned that in the description. This doesn't change any existing behaviour since there were now users of config->optimize until now(!). And yes we optimize by default, like the ELF linker. Note that this is different to -lto-O2 which sets the LTO level.

lld/wasm/InputChunks.cpp

475

Again this is just cargo culted over.. I'm not sure what this comments means by "pools" but I think it must be refering to some linker specific pools, as opposed to malloc in general, which splitStrings clearly does.

488

This code comes directly from lld/ELF/InputSection.cpp ... I honestly didn't spend time trying to grok it its just cargo cults over :-/

lld/wasm/OutputSegment.cpp

43

Ah yes, perhaps mergedSegments is better.

43

Actually this also comes from ELF which has std::vector<MergeSyntheticSection *> mergeSections; but they have slightly different class naming going on.

55

I copied this from lld/ELF/OutputSections.cpp. Is there a runtime difference are you suggesting that for readability?

llvm/include/llvm/MC/MCSectionWasm.h

44

Indeed, this flag and the two above apply only to data segments.. maybe I can make that more clear, at least in comments.

llvm/lib/MC/MCObjectFileInfo.cpp

799

Yes, currently this will not get used anywhere, or written the binary format. If you prefer I can drop this part of the change and add it in the followup.

llvm/lib/MC/MCParser/WasmAsmParser.cpp

107

Mostly for consistency with ELFAsmParser.cpp that uses this pattern.

165

I copied these lines directly from ELFAsmParser.cpp so I'm fine with this as is. When the user sees this error it also shows them the location on the line where it happens so it pretty obvious.

[sbc100]

• feedback

[dschuff]

I think I'm generally fine with keeping things that are direct copies from ELF, although it would be nice if it were even easier to tell which pieces those are (there is one comment in a header; is it just that function though?)

lld/wasm/InputChunks.h

164

Do we care about these lint checks? (I guess lld already has different style than LLVM?)

lld/wasm/OutputSegment.cpp

43

I also had a question about the class naming above.

55

mostly just for readability. I think auto-capturing a simple local variable like that should end up the same in the code.

llvm/lib/MC/MCObjectFileInfo.cpp

799

I don't necessarily object; but you also mentioned above that the handling (or just the naming?) might be different for custom sections compared to custom sections.

[sbc100]

• feedback

[sbc100]

lld/wasm/InputChunks.h

42

Again taking my lead from ELF here which has enum Kind { Regular, EHFrame, Merge, Synthetic, Output };

164

We do care yes, but I'm having hard time seeing what is wrong here since we use lowerCamal case for locals and params in lld. i guess it must be the trailing _ .. in which case maybe its false positive because it thinks we are using snake_case which would indeed be wrong. I think we can ignore this one.

lld/wasm/InputFiles.cpp

435

I don't think clang ever injects that linker flag, you would need to use -Wl,

llvm/lib/MC/MCObjectFileInfo.cpp

799

Removed this... in fact I reverted this whole file!

[dblaikie]

lld/wasm/InputChunks.h

164

What's with the underscores though?

I don't think we usually do that in the LLVM codebase - I think we generally name the parameter the same as the variable & ideally use the ctor's initializer list to initialize members. (or use this->x = x in a pinch)

Hmm, I guess these members are members of a base class? Perhaps the base class should have a ctor that takes them?

[sbc100]

lld/wasm/InputChunks.h

164

In this case I'm initialize members of that superclass so I can't use the initializer list (I think).. so I need to disambiguate.. In the past I've used the underscore suffix disambiguate, but I'm happy to use the this->x = x method instead. I didn't know that was preferred here.

[sbc100]

• use this->member

[dblaikie]

lld/wasm/InputChunks.h

164

re: base class members: Ah, right, sorry, that's what I was trying to get at when I mentioned "perhaps the base class (aka superclass) should have a ctor that takes them" - if the base class doesn't have a ctor that takes flags and alignment, perhaps you could add one?

[sbc100]

lld/wasm/InputChunks.h

164

Thanks, that does make it a little cleaner.

[sbc100]

• feedback

[dschuff]

I think this is pretty much ok now, other than that I would like to make it more clear exactly which parts are more-or-less directly copied from ELF; that way if we need to understand more in the future, we know where to look (and also if there are changes to ELF in the future we would know to look at those to see if they make sense for us too)

lld/wasm/InputChunks.cpp

374

This comment still stands (the else cases is dead, right?)

[sbc100]

• feedback

lld/wasm/InputChunks.cpp

374

You are right.. for some reason the ELF code seem have code to handle the case when the parent is null.. but I don't see how that could ever happen, and least with wasm code.. removed the condition.

[thakis]

Looks like this breaks tests: http://45.33.8.238/macm1/9183/step_11.txt

[thakis]

Here too: https://lab.llvm.org/buildbot/#/builders/105/builds/9503

[thakis]

reverted for now in 061e071d8c9b98526f35cad55a918a4f1615afd4. repros locally with ninja check-llvm-mc-webassembly

[sbc100]

In D97657#2749151, @thakis wrote:

Looks like this breaks tests: http://45.33.8.238/macm1/9183/step_11.txt

Fixing now. Sorry about that. I need to learn to pay attention to the pre-commit builders.

[sbc100]

In D97657#2749185, @thakis wrote:

reverted for now in 061e071d8c9b98526f35cad55a918a4f1615afd4. repros locally with ninja check-llvm-mc-webassembly

What is the process for re-landing after revert? Do re-upload to this review?

[thakis]

If it's not a big change relative to the first commit, I'd just reland with the same phab link.

In addition to the precommit bot, I'd also recommend running tests locally.

[sbc100]

In D97657#2749260, @thakis wrote:

If it's not a big change relative to the first commit, I'd just reland with the same phab link.

In addition to the precommit bot, I'd also recommend running tests locally.

Of course yes. I do always run tests locally but since most of my changes only touch lld I often limit by test runs to lld-only. Forgot I touched common code with this one.

lld/test/wasm/merge-string.s

+// RUN: llvm-mc -filetype=obj -triple=wasm32-unknown-unknown %s -o %t.o
+// RUN: wasm-ld -O2 %t.o -o %t.wasm --no-gc-sections --no-entry
+// RUN: obj2yaml %t.wasm | FileCheck %s --check-prefixes=COMMON,MERGE
+// RUN: wasm-ld -O0 %t.o -o %t2.wasm --no-gc-sections --no-entry
+// RUN: obj2yaml %t2.wasm | FileCheck --check-prefixes=COMMON,NOMERGE %s
+
+        .section .rodata1,"S",@
+        .asciz "abc"
+foo:
+        .ascii "a"
+        .size foo, 1
+bar:
+        .asciz "bc"
+        .asciz "bc"
+        .size bar, 4
+
+.globl foo
+.globl bar
+.export_name    foo, foo
+.export_name    bar, bar
+
+//       COMMON:  - Type:            GLOBAL
+//  COMMON-NEXT:    Globals:
+//  COMMON-NEXT:      - Index:           0
+//  COMMON-NEXT:        Type:            I32
+//  COMMON-NEXT:        Mutable:         true
+//  COMMON-NEXT:        InitExpr:
+//  COMMON-NEXT:          Opcode:          I32_CONST
+//  COMMON-NEXT:          Value:           66576
+//  COMMON-NEXT:      - Index:           1
+//  COMMON-NEXT:        Type:            I32
+//  COMMON-NEXT:        Mutable:         false
+//  COMMON-NEXT:        InitExpr:
+//  COMMON-NEXT:          Opcode:          I32_CONST
+//   MERGE-NEXT:          Value:           1024
+// NOMERGE-NEXT:          Value:           1028
+//  COMMON-NEXT:      - Index:           2
+//  COMMON-NEXT:        Type:            I32
+//  COMMON-NEXT:        Mutable:         false
+//  COMMON-NEXT:        InitExpr:
+//  COMMON-NEXT:          Opcode:          I32_CONST
+//   MERGE-NEXT:          Value:           1025
+// NOMERGE-NEXT:          Value:           1029
+//  COMMON-NEXT:  - Type:            EXPORT
+//  COMMON-NEXT:    Exports:
+//  COMMON-NEXT:      - Name:            memory
+//  COMMON-NEXT:        Kind:            MEMORY
+//  COMMON-NEXT:        Index:           0
+//  COMMON-NEXT:      - Name:            foo
+//  COMMON-NEXT:        Kind:            GLOBAL
+//  COMMON-NEXT:        Index:           1
+//  COMMON-NEXT:      - Name:            bar
+//  COMMON-NEXT:        Kind:            GLOBAL
+//  COMMON-NEXT:        Index:           2
+
+//
+//       COMMON:  - Type:            DATA
+//  COMMON-NEXT:    Segments:
+//  COMMON-NEXT:      - SectionOffset:   7
+//  COMMON-NEXT:        InitFlags:       0
+//  COMMON-NEXT:        Offset:
+//  COMMON-NEXT:          Opcode:          I32_CONST
+//  COMMON-NEXT:          Value:           1024
+//   MERGE-NEXT:          Content:         '61626300'
+// NOMERGE-NEXT:          Content:         '6162630061626300626300'

lld/wasm/CMakeLists.txt

 set(LLVM_TARGET_DEFINITIONS Options.td)
 tablegen(LLVM Options.inc -gen-opt-parser-defs)
 add_public_tablegen_target(WasmOptionsTableGen)
 
 add_lld_library(lldWasm
   Driver.cpp
   InputChunks.cpp
   InputFiles.cpp
   LTO.cpp
   MapFile.cpp
   MarkLive.cpp
   OutputSections.cpp
+  OutputSegment.cpp
   Relocations.cpp
   SymbolTable.cpp
   Symbols.cpp
   SyntheticSections.cpp
   Writer.cpp
   WriterUtils.cpp
 
   LINK_COMPONENTS

lld/wasm/Driver.cpp

static void readConfigs(opt::InputArgList &args) {
   config->importTable = args.hasArg(OPT_import_table);
   config->ltoo = args::getInteger(args, OPT_lto_O, 2);
   config->ltoPartitions = args::getInteger(args, OPT_lto_partitions, 1);
   config->ltoNewPassManager =
       args.hasFlag(OPT_no_lto_legacy_pass_manager, OPT_lto_legacy_pass_manager,
                    LLVM_ENABLE_NEW_PASS_MANAGER);
   config->ltoDebugPassManager = args.hasArg(OPT_lto_debug_pass_manager);
   config->mapFile = args.getLastArgValue(OPT_Map);
-  config->optimize = args::getInteger(args, OPT_O, 0);
+  config->optimize = args::getInteger(args, OPT_O, 1);
   config->outputFile = args.getLastArgValue(OPT_o);
   config->relocatable = args.hasArg(OPT_relocatable);
   config->gcSections =
       args.hasFlag(OPT_gc_sections, OPT_no_gc_sections, !config->relocatable);
   config->mergeDataSegments =
       args.hasFlag(OPT_merge_data_segments, OPT_no_merge_data_segments,
                    !config->relocatable);
   config->pie = args.hasFlag(OPT_pie, OPT_no_pie, false);
for (size_t i = 0, e = syms.size(); i != e; ++i)
         syms[i] = s;
   });
 
   // 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
+  // before calling finalizeContents().
+  LLVM_DEBUG(llvm::dbgs() << "splitSections\n");
+  parallelForEach(symtab->objectFiles, [](ObjFile *file) {
+    for (InputSegment *seg : file->segments) {
+      if (auto *s = dyn_cast<MergeInputSegment>(seg))
+        s->splitIntoPieces();
+    }
+  });
+}
+
 void LinkerDriver::linkerMain(ArrayRef<const char *> argsArr) {
   WasmOptTable parser;
   opt::InputArgList args = parser.parse(argsArr.slice(1));
 
   // Handle --help
   if (args.hasArg(OPT_help)) {
     parser.PrintHelp(lld::outs(),
                      (std::string(argsArr[0]) + " [options] file...").c_str(),
void LinkerDriver::linkerMain(ArrayRef<const char *> argsArr) {
   }
 
   if (entrySym)
     entrySym->setHidden(false);
 
   if (errorCount())
     return;
 
+  // Split WASM_SEG_FLAG_STRINGS sections into pieces in preparation for garbage
+  // collection.
+  splitSections();
+
   // Do size optimizations: garbage collection
   markLive();
 
   // Provide the indirect function table if needed.
   WasmSym::indirectFunctionTable =
       symtab->resolveIndirectFunctionTable(/*required =*/false);
 
   if (errorCount())
     return;
 
   // Write the result to the file.
   writeResult();
 }
 
 } // namespace wasm
 } // namespace lld

lld/wasm/InputChunks.h

 
 #ifndef LLD_WASM_INPUT_CHUNKS_H
 #define LLD_WASM_INPUT_CHUNKS_H
 
 #include "Config.h"
 #include "InputFiles.h"
 #include "lld/Common/ErrorHandler.h"
 #include "lld/Common/LLVM.h"
+#include "llvm/ADT/CachedHashString.h"
+#include "llvm/MC/StringTableBuilder.h"
 #include "llvm/Object/Wasm.h"
 
 namespace lld {
 namespace wasm {
 
 class ObjFile;
 class OutputSegment;
 class OutputSection;
 
 class InputChunk {
 public:
-  enum Kind { DataSegment, Function, SyntheticFunction, Section };
+  enum Kind {
+    DataSegment,
+    Merge,
+    MergedSegment,
+    Function,
+    SyntheticFunction,
+    Section
+  };
 
   Kind kind() const { return sectionKind; }
 
   virtual uint32_t getSize() const { return data().size(); }
   virtual uint32_t getInputSize() const { return getSize(); };
 
   virtual 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; }
 
   uint64_t getOffset(uint64_t offset) const { return outSecOff + offset; }
   virtual StringRef getName() const = 0;
   virtual StringRef getDebugName() const = 0;
   virtual uint32_t getComdat() const = 0;

 // 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)
+  InputSegment(const WasmSegment *seg, ObjFile *f)
       : InputChunk(f, InputChunk::DataSegment), segment(seg) {
-    alignment = segment.Data.Alignment;
+    alignment = segment->Data.Alignment;
+    flags = segment->Data.LinkingFlags;
   }
 
-  static bool classof(const InputChunk *c) { return c->kind() == DataSegment; }
+  InputSegment(uint32_t alignment, uint32_t flags)
+      : InputChunk(nullptr, InputChunk::DataSegment), alignment(alignment),
+        flags(flags) {}
+
+  static bool classof(const InputChunk *c) {
+    return c->kind() == DataSegment || c->kind() == Merge ||
+           c->kind() == MergedSegment;
+  }
 
   void generateRelocationCode(raw_ostream &os) const;
 
-  StringRef getName() const override { return segment.Data.Name; }
+  StringRef getName() const override { return segment->Data.Name; }
   StringRef getDebugName() const override { return StringRef(); }
-  uint32_t getComdat() const override { return segment.Data.Comdat; }
+  uint32_t getComdat() const override { return segment->Data.Comdat; }
   uint32_t getInputSectionOffset() const override {
-    return segment.SectionOffset;
+    return segment->SectionOffset;
   }
+
+  // Translate an offset in the input section to an offset in the output
+  // section.
+  uint64_t getOffset(uint64_t offset) const;
+
   uint64_t getVA(uint64_t offset = 0) const;
 
-  const OutputSegment *outputSeg = nullptr;
-  uint32_t outputSegmentOffset = 0;
-  uint32_t alignment = 0;
   bool isTLS() {
     return getName().startswith(".tdata") || getName().startswith(".tbss");
   }
 
+  const OutputSegment *outputSeg = nullptr;
+  uint32_t outputSegmentOffset = 0;
+  uint32_t alignment = 0;
+  uint32_t flags = 0;
+
 protected:
-  ArrayRef<uint8_t> data() const override { return segment.Data.Content; }
+  ArrayRef<uint8_t> data() const override { return segment->Data.Content; }
+
+  const WasmSegment *segment = nullptr;
+};
+
+class SyntheticMergedDataSegment;
+
+// Merge segment handling copied from lld/ELF/InputSection.h.  Keep in sync
+// where possible.
+
+// SegmentPiece represents a piece of splittable segment contents.
+// We allocate a lot of these and binary search on them. This means that they
+// have to be as compact as possible, which is why we don't store the size (can
+// be found by looking at the next one).
+struct SegmentPiece {
+  SegmentPiece(size_t off, uint32_t hash, bool live)
+      : inputOff(off), live(live || !config->gcSections), hash(hash >> 1) {}
+
+  uint32_t inputOff;
+  uint32_t live : 1;
+  uint32_t hash : 31;
+  uint64_t outputOff = 0;
+};
+
+static_assert(sizeof(SegmentPiece) == 16, "SectionPiece is too big");
+
+// This corresponds segments marked as WASM_SEG_FLAG_STRINGS.
+class MergeInputSegment : public InputSegment {
+public:
+  MergeInputSegment(const WasmSegment *seg, ObjFile *f) : InputSegment(seg, f) {
+    sectionKind = Merge;
+  }
+
+  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;
 
-  const WasmSegment &segment;
+  // Splittable sections are handled as a sequence of data
+  // rather than a single large blob of data.
+  std::vector<SegmentPiece> pieces;
+
+  // Returns I'th piece's data. This function is very hot when
+  // string merging is enabled, so we want to inline.
+  LLVM_ATTRIBUTE_ALWAYS_INLINE
+  llvm::CachedHashStringRef getData(size_t i) const {
+    size_t begin = pieces[i].inputOff;
+    size_t end =
+        (pieces.size() - 1 == i) ? data().size() : pieces[i + 1].inputOff;
+    return {toStringRef(data().slice(begin, end - begin)), pieces[i].hash};
+  }
+
+  // Returns the SectionPiece at a given input section offset.
+  SegmentPiece *getSegmentPiece(uint64_t offset);
+  const SegmentPiece *getSegmentPiece(uint64_t offset) const {
+    return const_cast<MergeInputSegment *>(this)->getSegmentPiece(offset);
+  }
+
+  SyntheticMergedDataSegment *parent = nullptr;
+
+private:
+  void splitStrings(ArrayRef<uint8_t> a);
+};
+
+// SyntheticMergedDataSegment is a class that allows us to put mergeable
+// sections with different attributes in a single output sections. To do that we
+// put them into SyntheticMergedDataSegment synthetic input sections which are
+// attached to regular output sections.
+class SyntheticMergedDataSegment : public InputSegment {
+public:
+  SyntheticMergedDataSegment(StringRef name, uint32_t alignment, uint32_t flags)
+      : InputSegment(alignment, flags), name(name),
+        builder(llvm::StringTableBuilder::RAW, 1ULL << alignment) {
+    sectionKind = InputChunk::MergedSegment;
+  }
+
+  static bool classof(const InputChunk *c) {
+    return c->kind() == InputChunk::MergedSegment;
+  }
+
+  uint32_t getSize() const override;
+
+  StringRef getName() const override { return name; }
+
+  uint32_t getComdat() const override { return segments[0]->getComdat(); }
+
+  void writeTo(uint8_t *buf) const override;
+
+  void addMergeSegment(MergeInputSegment *ms) {
+    ms->parent = this;
+    segments.push_back(ms);
+  }
+
+  void finalizeContents();
+
+protected:
+  std::vector<MergeInputSegment *> segments;
+  StringRef name;
+  llvm::StringTableBuilder builder;
 };
 
 // Represents a single wasm function within and input file.  These are
 // combined to create the final output CODE section.
 class InputFunction : public InputChunk {
 public:
   InputFunction(const WasmSignature &s, const WasmFunction *func, ObjFile *f)
       : InputChunk(f, InputChunk::Function), signature(s), function(func),

lld/wasm/InputChunks.cpp

 //===- InputChunks.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 "InputChunks.h"
 #include "Config.h"
 #include "OutputSegment.h"
 #include "WriterUtils.h"
 #include "lld/Common/ErrorHandler.h"
 #include "lld/Common/LLVM.h"
 #include "llvm/Support/LEB128.h"
+#include "llvm/Support/xxhash.h"
 
 #define DEBUG_TYPE "lld"
 
 using namespace llvm;
 using namespace llvm::wasm;
 using namespace llvm::support::endian;
 
 namespace lld {

 }
 
 // Copy this input chunk to an mmap'ed output file and apply relocations.
 void InputChunk::writeTo(uint8_t *buf) const {
   // Copy contents
   memcpy(buf + outSecOff, data().data(), data().size());
 
   // Apply relocations
+  relocate(buf + outSecOff);
+}
+
+void InputChunk::relocate(uint8_t *buf) const {
   if (relocations.empty())
     return;
 
 #ifndef NDEBUG
   verifyRelocTargets();
 #endif
 
   LLVM_DEBUG(dbgs() << "applying relocations: " << toString(this)
                     << " count=" << relocations.size() << "\n");
-  int32_t off = outSecOff - getInputSectionOffset();
+  int32_t inputSectionOffset = getInputSectionOffset();
   auto tombstone = getTombstone();
 
   for (const WasmRelocation &rel : relocations) {
-    uint8_t *loc = buf + rel.Offset + off;
+    uint8_t *loc = buf + rel.Offset - inputSectionOffset;
     auto value = file->calcNewValue(rel, tombstone, this);
     LLVM_DEBUG(dbgs() << "apply reloc: type=" << relocTypeToString(rel.Type));
     if (rel.Type != R_WASM_TYPE_INDEX_LEB)
       LLVM_DEBUG(dbgs() << " sym=" << file->getSymbols()[rel.Index]->getName());
     LLVM_DEBUG(dbgs() << " addend=" << rel.Addend << " index=" << rel.Index
                       << " value=" << value << " offset=" << rel.Offset
                       << "\n");
 
void InputFunction::writeTo(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 InputSegment::getOffset(uint64_t offset) const {
+  if (const MergeInputSegment *ms = dyn_cast<MergeInputSegment>(this)) {
+    LLVM_DEBUG(dbgs() << "getOffset(merged): " << getName() << "\n");
+    LLVM_DEBUG(dbgs() << "offset: " << offset << "\n");
+    LLVM_DEBUG(dbgs() << "parentOffset: " << ms->getParentOffset(offset)
+                      << "\n");
+    assert(ms->parent);
+    return ms->parent->getOffset(ms->getParentOffset(offset));
+  }
+  return outputSegmentOffset + offset;
+}
+
 uint64_t InputSegment::getVA(uint64_t offset) const {
-  return outputSeg->startVA + outputSegmentOffset + offset;
+  return (outputSeg ? outputSeg->startVA : 0) + getOffset(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 InputSegment::generateRelocationCode(raw_ostream &os) const {
   LLVM_DEBUG(dbgs() << "generating runtime relocations: " << getName()
                     << " count=" << relocations.size() << "\n");
for (const WasmRelocation &rel : relocations) {
 
     // Store that value at the virtual address
     writeU8(os, opcode_reloc_store, "I32_STORE");
     writeUleb128(os, 2, "align");
     writeUleb128(os, 0, "offset");
   }
 }
 
+// Split WASM_SEG_FLAG_STRINGS section. Such a section is a sequence of
+// null-terminated strings.
+void MergeInputSegment::splitStrings(ArrayRef<uint8_t> data) {
+  LLVM_DEBUG(llvm::dbgs() << "splitStrings\n");
+  size_t off = 0;
+  StringRef s = toStringRef(data);
+
+  while (!s.empty()) {
+    size_t end = s.find(0);
+    if (end == StringRef::npos)
+      fatal(toString(this) + ": string is not null terminated");
+    size_t size = end + 1;
+
+    pieces.emplace_back(off, xxHash64(s.substr(0, size)), true);
+    s = s.substr(size);
+    off += size;
+  }
+}
+
+// This function is called after we obtain a complete list of input sections
+// that need to be linked. This is responsible to split section contents
+// into small chunks for further processing.
+//
+// Note that this function is called from parallelForEach. This must be
+// thread-safe (i.e. no memory allocation from the pools).
+void MergeInputSegment::splitIntoPieces() {
+  assert(pieces.empty());
+  // As of now we only support WASM_SEG_FLAG_STRINGS but in the future we
+  // could add other types of splitting (see ELF's splitIntoPieces).
+  assert(segment->Data.LinkingFlags & WASM_SEG_FLAG_STRINGS);
+  splitStrings(data());
+}
+
+SegmentPiece *MergeInputSegment::getSegmentPiece(uint64_t offset) {
+  if (this->data().size() <= offset)
+    fatal(toString(this) + ": offset is outside the section");
+
+  // If Offset is not at beginning of a section piece, it is not in the map.
+  // In that case we need to  do a binary search of the original section piece
+  // vector.
+  auto it = partition_point(
+      pieces, [=](SegmentPiece p) { return p.inputOff <= offset; });
+  return &it[-1];
+}
+
+// Returns the offset in an output section for a given input offset.
+// Because contents of a mergeable section is not contiguous in output,
+// it is not just an addition to a base output offset.
+uint64_t MergeInputSegment::getParentOffset(uint64_t offset) const {
+  // If Offset is not at beginning of a section piece, it is not in the map.
+  // In that case we need to search from the original section piece vector.
+  const SegmentPiece *piece = getSegmentPiece(offset);
+  uint64_t addend = offset - piece->inputOff;
+  return piece->outputOff + addend;
+}
+
+uint32_t SyntheticMergedDataSegment::getSize() const {
+  return builder.getSize();
+}
+
+void SyntheticMergedDataSegment::writeTo(uint8_t *buf) const {
+  builder.write(buf + outSecOff);
+
+  // Apply relocations
+  relocate(buf + outSecOff);
+}
+
+void SyntheticMergedDataSegment::finalizeContents() {
+  // Add all string pieces to the string table builder to create section
+  // contents.
+  for (MergeInputSegment *sec : segments)
+    for (size_t i = 0, e = sec->pieces.size(); i != e; ++i)
+      if (sec->pieces[i].live)
+        builder.add(sec->getData(i));
+
+  // Fix the string table content. After this, the contents will never change.
+  builder.finalize();
+
+  // finalize() fixed tail-optimized strings, so we can now get
+  // offsets of strings. Get an offset for each string and save it
+  // to a corresponding SectionPiece for easy access.
+  for (MergeInputSegment *sec : segments)
+    for (size_t i = 0, e = sec->pieces.size(); i != e; ++i)
+      if (sec->pieces[i].live)
+        sec->pieces[i].outputOff = builder.getOffset(sec->getData(i));
+}
+
 uint64_t InputSection::getTombstoneForSection(StringRef name) {
   // When a function is not live we need to update relocations referring to it.
   // If they occur in DWARF debug symbols, we want to change the pc of the
   // function to -1 to avoid overlapping with a valid range. However for the
   // debug_ranges and debug_loc sections that would conflict with the existing
   // meaning of -1 so we use -2.
   // Returning 0 means there is no tombstone value for this section, and relocation
   // will just use the addend.

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 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
+  // sometimes makes the linker significantly faster, although the output will
+  // be bigger.
+  if (config->optimize == 0)
+    return false;
+
+  // A mergeable section with size 0 is useless because they don't have
+  // any data to merge. A mergeable string section with size 0 can be
+  // argued as invalid because it doesn't end with a null character.
+  // We'll avoid a mess by handling them as if they were non-mergeable.
+  if (seg.Data.Content.size() == 0)
+    return false;
+
+  return true;
+}
+
 void ObjFile::parse(bool ignoreComdats) {
   // Parse a memory buffer as a wasm file.
   LLVM_DEBUG(dbgs() << "Parsing object: " << toString(this) << "\n");
   std::unique_ptr<Binary> bin = CHECK(createBinary(mb), toString(this));
 
   auto *obj = dyn_cast<WasmObjectFile>(bin.get());
   if (!obj)
     fatal(toString(this) + ": not a wasm file");
void ObjFile::parse(bool ignoreComdats) {
   }
 
   typeMap.resize(getWasmObj()->types().size());
   typeIsUsed.resize(getWasmObj()->types().size(), false);
 
 
   // Populate `Segments`.
   for (const WasmSegment &s : wasmObj->dataSegments()) {
-    auto* seg = make<InputSegment>(s, this);
+    InputSegment *seg;
+    if (shouldMerge(s)) {
+      seg = make<MergeInputSegment>(&s, this);
+    } else
+      seg = make<InputSegment>(&s, this);
     seg->discarded = isExcludedByComdat(seg);
+
     segments.emplace_back(seg);
   }
   setRelocs(segments, dataSection);
 
   // Populate `Functions`.
   ArrayRef<WasmFunction> funcs = wasmObj->functions();
   ArrayRef<uint32_t> funcTypes = wasmObj->functionTypes();
   ArrayRef<WasmSignature> types = wasmObj->types();

lld/wasm/OutputSegment.h

 namespace wasm {
 
 class InputSegment;
 
 class OutputSegment {
 public:
   OutputSegment(StringRef n) : name(n) {}
 
-  void addInputSegment(InputSegment *inSeg) {
-    uint32_t segAlign = inSeg->alignment;
-    alignment = std::max(alignment, segAlign);
-    inputSegments.push_back(inSeg);
-    size = llvm::alignTo(size, 1ULL << segAlign);
-    inSeg->outputSeg = this;
-    inSeg->outputSegmentOffset = size;
-    size += inSeg->getSize();
-  }
+  void addInputSegment(InputSegment *inSeg);
+  void finalizeInputSegments();
 
   bool isTLS() const { return name == ".tdata"; }
 
   StringRef name;
   bool isBss = false;
   uint32_t index = 0;
+  uint32_t linkingFlags = 0;
   uint32_t initFlags = 0;
   uint32_t sectionOffset = 0;
   uint32_t alignment = 0;
   uint64_t startVA = 0;
   std::vector<InputSegment *> inputSegments;
 
   // Sum of the size of the all the input segments
   uint32_t size = 0;

lld/wasm/OutputSegment.cpp

+//===- OutputSegment.h -----------------------------------------*- C++ -*-===//
+//
+// 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 "OutputSegment.h"
+#include "InputChunks.h"
+#include "lld/Common/Memory.h"
+
+#define DEBUG_TYPE "lld"
+
+using namespace llvm;
+using namespace llvm::wasm;
+
+namespace lld {
+
+namespace wasm {
+
+void OutputSegment::addInputSegment(InputSegment *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()
+                    << " align=" << inSeg->alignment << " at:" << size << "\n");
+  inSeg->outputSeg = this;
+  inSeg->outputSegmentOffset = size;
+  size += inSeg->getSize();
+}
+
+// This function scans over the input segments.
+//
+// It removes MergeInputSegments from the input section array and adds
+// new synthetic sections at the location of the first input section
+// that it replaces. It then finalizes each synthetic section in order
+// to compute an output offset for each piece of each input section.
+void OutputSegment::finalizeInputSegments() {
+  LLVM_DEBUG(llvm::dbgs() << "finalizeInputSegments: " << name << "\n");
+  std::vector<SyntheticMergedDataSegment *> mergedSegments;
+  std::vector<InputSegment *> newSegments;
+  for (InputSegment *s : inputSegments) {
+    MergeInputSegment *ms = dyn_cast<MergeInputSegment>(s);
+    if (!ms) {
+      newSegments.push_back(s);
+      continue;
+    }
+
+    // A segment should not make it here unless its alive
+    assert(ms->live);
+
+    auto i =
+        llvm::find_if(mergedSegments, [=](SyntheticMergedDataSegment *seg) {
+          return seg->flags == ms->flags && seg->alignment == ms->alignment;
+        });
+    if (i == mergedSegments.end()) {
+      LLVM_DEBUG(llvm::dbgs() << "new merge section: " << name
+                              << " alignment=" << ms->alignment << "\n");
+      SyntheticMergedDataSegment *syn =
+          make<SyntheticMergedDataSegment>(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");
+    }
+    (*i)->addMergeSegment(ms);
+  }
+
+  for (auto *ms : mergedSegments)
+    ms->finalizeContents();
+
+  inputSegments = newSegments;
+  size = 0;
+  for (InputSegment *seg : inputSegments) {
+    size = llvm::alignTo(size, 1ULL << seg->alignment);
+    LLVM_DEBUG(llvm::dbgs() << "outputSegmentOffset set: " << seg->getName()
+                            << " -> " << size << "\n");
+    seg->outputSegmentOffset = size;
+    size += seg->getSize();
+  }
+}
+
+} // namespace wasm
+} // namespace lld

lld/wasm/Symbols.cpp

if (auto *t = dyn_cast<DefinedTable>(this))
     return t->table->live;
   if (InputChunk *c = getChunk())
     return c->live;
   return referenced;
 }
 
 void Symbol::markLive() {
   assert(!isDiscarded());
+  referenced = true;
   if (file != NULL && isDefined())
     file->markLive();
   if (auto *g = dyn_cast<DefinedGlobal>(this))
     g->global->live = true;
   if (auto *e = dyn_cast<DefinedEvent>(this))
     e->event->live = true;
   if (auto *t = dyn_cast<DefinedTable>(this))
     t->table->live = true;
-  if (InputChunk *c = getChunk())
+  if (InputChunk *c = getChunk()) {
+    // Usually, a whole chunk is marked as live or dead, but in mergeable
+    // (splittable) sections, each piece of data has independent liveness bit.
+    // So we explicitly tell it which offset is in use.
+    if (auto *d = dyn_cast<DefinedData>(this)) {
+      if (auto *ms = dyn_cast<MergeInputSegment>(c)) {
+        ms->getSegmentPiece(d->value)->live = true;
+      }
+    }
     c->live = true;
-  referenced = true;
+  }
 }
 
 uint32_t Symbol::getOutputSymbolIndex() const {
   assert(outputSymbolIndex != INVALID_INDEX);
   return outputSymbolIndex;
 }
 
 void Symbol::setOutputSymbolIndex(uint32_t index) {

lld/wasm/SyntheticSections.cpp

void LinkingSection::writeBody() {
   }
 
   if (dataSegments.size()) {
     SubSection sub(WASM_SEGMENT_INFO);
     writeUleb128(sub.os, dataSegments.size(), "num data segments");
     for (const OutputSegment *s : dataSegments) {
       writeStr(sub.os, s->name, "segment name");
       writeUleb128(sub.os, s->alignment, "alignment");
-      writeUleb128(sub.os, 0, "flags");
+      writeUleb128(sub.os, s->linkingFlags, "flags");
     }
     sub.writeTo(os);
   }
 
   if (!initFunctions.empty()) {
     SubSection sub(WASM_INIT_FUNCS);
     writeUleb128(sub.os, initFunctions.size(), "num init functions");
     for (const WasmInitEntry &f : initFunctions) {

lld/wasm/Writer.cpp

for (InputSegment *segment : file->segments) {
       if (config->relocatable && !segment->getComdatName().empty()) {
         s = createOutputSegment(name);
       } else {
         if (segmentMap.count(name) == 0)
           segmentMap[name] = createOutputSegment(name);
         s = segmentMap[name];
       }
       s->addInputSegment(segment);
-      LLVM_DEBUG(dbgs() << "added data: " << name << ": " << s->size << "\n");
     }
   }
 
   // Sort segments by type, placing .bss last
   std::stable_sort(segments.begin(), segments.end(),
                    [](const OutputSegment *a, const OutputSegment *b) {
                      auto order = [](StringRef name) {
                        return StringSwitch<int>(name)
                            .StartsWith(".tdata", 0)
                            .StartsWith(".rodata", 1)
                            .StartsWith(".data", 2)
                            .StartsWith(".bss", 4)
                            .Default(3);
                      };
                      return order(a->name) < order(b->name);
                    });
 
   for (size_t i = 0; i < segments.size(); ++i)
     segments[i]->index = i;
+
+  // Merge MergeInputSections into a single MergeSyntheticSection.
+  LLVM_DEBUG(dbgs() << "-- finalize input semgments\n");
+  for (OutputSegment *seg : segments)
+    seg->finalizeInputSegments();
 }
 
 void Writer::combineOutputSegments() {
   // With PIC code we currently only support a single data segment since
   // we only have a single __memory_base to use as our base address.
   // This pass combines all non-TLS data segments into a single .data
   // segment.
   // This restructions can be relaxed once we have extended constant
   // expressions available:
   // https://github.com/WebAssembly/extended-const
   assert(config->isPic);
   if (segments.size() <= 1)
     return;
   OutputSegment *combined = nullptr;
   std::vector<OutputSegment *> new_segments;
   for (OutputSegment *s : segments) {
     if (s->isTLS()) {
       new_segments.push_back(s);
     } else {
       if (!combined) {
+        LLVM_DEBUG(dbgs() << "created combined output segment: .data\n");
         combined = make<OutputSegment>(".data");
         combined->startVA = s->startVA;
         if (config->sharedMemory)
           combined->initFlags = WASM_DATA_SEGMENT_IS_PASSIVE;
       }
       bool first = true;
       for (InputSegment *inSeg : s->inputSegments) {
         if (first)
           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()
+                          << " oldVA=" << oldVA << " newVA=" << newVA << "\n");
         assert(oldVA == newVA);
 #endif
       }
     }
   }
   if (combined) {
     new_segments.push_back(combined);
     segments = new_segments;

llvm/include/llvm/BinaryFormat/Wasm.h

struct WasmDataSegment {
   // Present if InitFlags & WASM_DATA_SEGMENT_HAS_MEMINDEX.
   uint32_t MemoryIndex;
   // Present if InitFlags & WASM_DATA_SEGMENT_IS_PASSIVE == 0.
   WasmInitExpr Offset;
 
   ArrayRef<uint8_t> Content;
   StringRef Name; // from the "segment info" section
   uint32_t Alignment;
-  uint32_t LinkerFlags;
+  uint32_t LinkingFlags;
   uint32_t Comdat; // from the "comdat info" section
 };
 
 struct WasmElemSegment {
   uint32_t Flags;
   uint32_t TableNumber;
   uint8_t ElemKind;
   WasmInitExpr Offset;
enum WasmSymbolType : unsigned {
   WASM_SYMBOL_TYPE_FUNCTION = 0x0,
   WASM_SYMBOL_TYPE_DATA = 0x1,
   WASM_SYMBOL_TYPE_GLOBAL = 0x2,
   WASM_SYMBOL_TYPE_SECTION = 0x3,
   WASM_SYMBOL_TYPE_EVENT = 0x4,
   WASM_SYMBOL_TYPE_TABLE = 0x5,
 };
 
+enum WasmSegmentFlag : unsigned {
+  WASM_SEG_FLAG_STRINGS = 0x1,
+};
+
 // Kinds of event attributes.
 enum WasmEventAttribute : unsigned {
   WASM_EVENT_ATTRIBUTE_EXCEPTION = 0x0,
 };
 
 const unsigned WASM_SYMBOL_BINDING_MASK = 0x3;
 const unsigned WASM_SYMBOL_VISIBILITY_MASK = 0xc;
 

llvm/include/llvm/MC/MCContext.h

public:
     /// 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, nullptr);
+      return getWasmSection(Section, K, 0, nullptr);
     }
 
     MCSectionWasm *getWasmSection(const Twine &Section, SectionKind K,
-                                  const char *BeginSymName) {
-      return getWasmSection(Section, K, "", ~0, BeginSymName);
+                                  unsigned Flags, const char *BeginSymName) {
+      return getWasmSection(Section, K, Flags, "", ~0, BeginSymName);
     }
 
     MCSectionWasm *getWasmSection(const Twine &Section, SectionKind K,
-                                  const Twine &Group, unsigned UniqueID) {
-      return getWasmSection(Section, K, Group, UniqueID, nullptr);
+                                  unsigned Flags, const Twine &Group,
+                                  unsigned UniqueID) {
+      return getWasmSection(Section, K, Flags, Group, UniqueID, nullptr);
     }
 
     MCSectionWasm *getWasmSection(const Twine &Section, SectionKind K,
-                                  const Twine &Group, unsigned UniqueID,
-                                  const char *BeginSymName);
+                                  unsigned Flags, const Twine &Group,
+                                  unsigned UniqueID, const char *BeginSymName);
 
     MCSectionWasm *getWasmSection(const Twine &Section, SectionKind K,
-                                  const MCSymbolWasm *Group, unsigned UniqueID,
-                                  const char *BeginSymName);
+                                  unsigned Flags, const MCSymbolWasm *Group,
+                                  unsigned UniqueID, const char *BeginSymName);
 
     MCSectionXCOFF *getXCOFFSection(
         StringRef Section, SectionKind K,
         Optional<XCOFF::CsectProperties> CsectProp = None,
         bool MultiSymbolsAllowed = false, const char *BeginSymName = nullptr,
         Optional<XCOFF::DwarfSectionSubtypeFlags> DwarfSubtypeFlags = None);
 
     // Create and save a copy of STI and return a reference to the copy.

llvm/include/llvm/MC/MCSectionWasm.h

class MCSectionWasm final : public MCSection {
   // For data relocations the offset is relative to start of the data payload
   // itself and does not include the size of the section header.
   uint64_t SectionOffset = 0;
 
   // For data sections, this is the index of of the corresponding wasm data
   // segment
   uint32_t SegmentIndex = 0;
 
-  // Whether this data segment is passive
+  // For data sections, whether to use a passive segment
   bool IsPassive = false;
 
+  // For data sections, bitfield of WasmSegmentFlag
+  unsigned SegmentFlags;
+
   // The storage of Name is owned by MCContext's WasmUniquingMap.
   friend class MCContext;
-  MCSectionWasm(StringRef Name, SectionKind K, const MCSymbolWasm *group,
-                unsigned UniqueID, MCSymbol *Begin)
-      : MCSection(SV_Wasm, Name, K, Begin), UniqueID(UniqueID), Group(group) {}
+  MCSectionWasm(StringRef Name, SectionKind K, unsigned SegmentFlags,
+                const MCSymbolWasm *Group, unsigned UniqueID, MCSymbol *Begin)
+      : MCSection(SV_Wasm, Name, K, Begin), UniqueID(UniqueID), Group(Group),
+        SegmentFlags(SegmentFlags) {}
 
 public:
   /// Decides whether a '.section' directive should be printed before the
   /// section name
   bool shouldOmitSectionDirective(StringRef Name, const MCAsmInfo &MAI) const;
 
   const MCSymbolWasm *getGroup() const { return Group; }
+  unsigned getSegmentFlags() const { return SegmentFlags; }
 
   void PrintSwitchToSection(const MCAsmInfo &MAI, const Triple &T,
                             raw_ostream &OS,
                             const MCExpr *Subsection) const override;
   bool UseCodeAlign() const override;
   bool isVirtualSection() const override;
 
   bool isWasmData() const {

llvm/lib/CodeGen/TargetLoweringObjectFileImpl.cpp

 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/Triple.h"
 #include "llvm/BinaryFormat/COFF.h"
 #include "llvm/BinaryFormat/Dwarf.h"
 #include "llvm/BinaryFormat/ELF.h"
 #include "llvm/BinaryFormat/MachO.h"
+#include "llvm/BinaryFormat/Wasm.h"
 #include "llvm/CodeGen/BasicBlockSectionUtils.h"
 #include "llvm/CodeGen/MachineBasicBlock.h"
 #include "llvm/CodeGen/MachineFunction.h"
 #include "llvm/CodeGen/MachineModuleInfo.h"
 #include "llvm/CodeGen/MachineModuleInfoImpls.h"
 #include "llvm/IR/Comdat.h"
 #include "llvm/IR/Constants.h"
 #include "llvm/IR/DataLayout.h"
static const Comdat *getWasmComdat(const GlobalValue *GV) {
   if (C->getSelectionKind() != Comdat::Any)
     report_fatal_error("WebAssembly COMDATs only support "
                        "SelectionKind::Any, '" + C->getName() + "' cannot be "
                        "lowered.");
 
   return C;
 }
 
+static unsigned getWasmSectionFlags(SectionKind K) {
+  unsigned Flags = 0;
+
+  // TODO(sbc): Add suport for K.isMergeableConst()
+
+  if (K.isMergeableCString())
+    Flags |= wasm::WASM_SEG_FLAG_STRINGS;
+
+  return Flags;
+}
+
 MCSection *TargetLoweringObjectFileWasm::getExplicitSectionGlobal(
     const GlobalObject *GO, SectionKind Kind, const TargetMachine &TM) const {
   // We don't support explict section names for functions in the wasm object
   // format.  Each function has to be in its own unique section.
   if (isa<Function>(GO)) {
     return SelectSectionForGlobal(GO, Kind, TM);
   }
 
   StringRef Name = GO->getSection();
 
   // Certain data sections we treat as named custom sections rather than
   // segments within the data section.
   // This could be avoided if all data segements (the wasm sense) were
   // represented as their own sections (in the llvm sense).
   // TODO(sbc): https://github.com/WebAssembly/tool-conventions/issues/138
   if (Name == ".llvmcmd" || Name == ".llvmbc")
     Kind = SectionKind::getMetadata();
 
   StringRef Group = "";
   if (const Comdat *C = getWasmComdat(GO)) {
     Group = C->getName();
   }
 
-  MCSectionWasm* Section =
-      getContext().getWasmSection(Name, Kind, Group,
-                                  MCContext::GenericSectionID);
+  unsigned Flags = getWasmSectionFlags(Kind);
+  MCSectionWasm *Section = getContext().getWasmSection(
+      Name, Kind, Flags, Group, MCContext::GenericSectionID);
 
   return Section;
 }
 
 static MCSectionWasm *selectWasmSectionForGlobal(
     MCContext &Ctx, const GlobalObject *GO, SectionKind Kind, Mangler &Mang,
     const TargetMachine &TM, bool EmitUniqueSection, unsigned *NextUniqueID) {
   StringRef Group = "";
if (EmitUniqueSection && UniqueSectionNames) {
     TM.getNameWithPrefix(Name, GO, Mang, true);
   }
   unsigned UniqueID = MCContext::GenericSectionID;
   if (EmitUniqueSection && !UniqueSectionNames) {
     UniqueID = *NextUniqueID;
     (*NextUniqueID)++;
   }
 
-  return Ctx.getWasmSection(Name, Kind, Group, UniqueID);
+  unsigned Flags = getWasmSectionFlags(Kind);
+  return Ctx.getWasmSection(Name, Kind, Flags, Group, UniqueID);
 }
 
 MCSection *TargetLoweringObjectFileWasm::SelectSectionForGlobal(
     const GlobalObject *GO, SectionKind Kind, const TargetMachine &TM) const {
 
   if (Kind.isCommon())
     report_fatal_error("mergable sections not supported yet on wasm");
 

llvm/lib/MC/MCContext.cpp

return getCOFFSection(Sec->getName(), Characteristics, Sec->getKind(),
                           COFF::IMAGE_COMDAT_SELECT_ASSOCIATIVE, UniqueID);
   }
 
   return getCOFFSection(Sec->getName(), Characteristics, Sec->getKind(), "", 0,
                         UniqueID);
 }
 
 MCSectionWasm *MCContext::getWasmSection(const Twine &Section, SectionKind K,
-                                         const Twine &Group, unsigned UniqueID,
+                                         unsigned Flags, const Twine &Group,
+                                         unsigned UniqueID,
                                          const char *BeginSymName) {
   MCSymbolWasm *GroupSym = nullptr;
   if (!Group.isTriviallyEmpty() && !Group.str().empty()) {
     GroupSym = cast<MCSymbolWasm>(getOrCreateSymbol(Group));
     GroupSym->setComdat(true);
   }
 
-  return getWasmSection(Section, K, GroupSym, UniqueID, BeginSymName);
+  return getWasmSection(Section, K, Flags, GroupSym, UniqueID, BeginSymName);
 }
 
 MCSectionWasm *MCContext::getWasmSection(const Twine &Section, SectionKind Kind,
+                                         unsigned Flags,
                                          const MCSymbolWasm *GroupSym,
                                          unsigned UniqueID,
                                          const char *BeginSymName) {
   StringRef Group = "";
   if (GroupSym)
     Group = GroupSym->getName();
   // Do the lookup, if we have a hit, return it.
   auto IterBool = WasmUniquingMap.insert(
       std::make_pair(WasmSectionKey{Section.str(), Group, UniqueID}, nullptr));
   auto &Entry = *IterBool.first;
   if (!IterBool.second)
     return Entry.second;
 
   StringRef CachedName = Entry.first.SectionName;
 
   MCSymbol *Begin = createSymbol(CachedName, true, false);
   Symbols[Begin->getName()] = Begin;
   cast<MCSymbolWasm>(Begin)->setType(wasm::WASM_SYMBOL_TYPE_SECTION);
 
   MCSectionWasm *Result = new (WasmAllocator.Allocate())
-      MCSectionWasm(CachedName, Kind, GroupSym, UniqueID, Begin);
+      MCSectionWasm(CachedName, Kind, Flags, GroupSym, UniqueID, Begin);
   Entry.second = Result;
 
   auto *F = new MCDataFragment();
   Result->getFragmentList().insert(Result->begin(), F);
   F->setParent(Result);
   Begin->setFragment(F);
 
   return Result;

llvm/lib/MC/MCObjectFileInfo.cpp

void MCObjectFileInfo::initWasmMCObjectFileInfo(const Triple &T) {
   DwarfLineSection =
       Ctx->getWasmSection(".debug_line", SectionKind::getMetadata());
   DwarfLineStrSection =
       Ctx->getWasmSection(".debug_line_str", SectionKind::getMetadata());
   DwarfStrSection =
       Ctx->getWasmSection(".debug_str", SectionKind::getMetadata());
   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 =
       Ctx->getWasmSection(".debug_macinfo", SectionKind::getMetadata());
   DwarfMacroSection =
       Ctx->getWasmSection(".debug_macro", SectionKind::getMetadata());
void MCObjectFileInfo::initWasmMCObjectFileInfo(const Triple &T) {
   DwarfMacroDWOSection =
       Ctx->getWasmSection(".debug_macro.dwo", SectionKind::getMetadata());
 
   DwarfLoclistsDWOSection =
       Ctx->getWasmSection(".debug_loclists.dwo", SectionKind::getMetadata());
 
   // DWP Sections
   DwarfCUIndexSection =
-      Ctx->getWasmSection(".debug_cu_index", SectionKind::getMetadata(), 0);
+      Ctx->getWasmSection(".debug_cu_index", SectionKind::getMetadata());
   DwarfTUIndexSection =
-      Ctx->getWasmSection(".debug_tu_index", SectionKind::getMetadata(), 0);
+      Ctx->getWasmSection(".debug_tu_index", SectionKind::getMetadata());
 
   // Wasm use data section for LSDA.
   // TODO Consider putting each function's exception table in a separate
   // section, as in -function-sections, to facilitate lld's --gc-section.
   LSDASection = Ctx->getWasmSection(".rodata.gcc_except_table",
                                     SectionKind::getReadOnlyWithRel());
 
   // TODO: Define more sections.

 
 MCSection *MCObjectFileInfo::getDwarfComdatSection(const char *Name,
                                                    uint64_t Hash) const {
   switch (Ctx->getTargetTriple().getObjectFormat()) {
   case Triple::ELF:
     return Ctx->getELFSection(Name, ELF::SHT_PROGBITS, ELF::SHF_GROUP, 0,
                               utostr(Hash), /*IsComdat=*/true);
   case Triple::Wasm:
-    return Ctx->getWasmSection(Name, SectionKind::getMetadata(), utostr(Hash),
-                               MCContext::GenericSectionID);
+    return Ctx->getWasmSection(Name, SectionKind::getMetadata(), 0,
+                               utostr(Hash), MCContext::GenericSectionID);
   case Triple::MachO:
   case Triple::COFF:
   case Triple::GOFF:
   case Triple::XCOFF:
   case Triple::UnknownObjectFormat:
     report_fatal_error("Cannot get DWARF comdat section for this object file "
                        "format: not implemented.");
     break;

llvm/lib/MC/MCParser/WasmAsmParser.cpp

bool expect(AsmToken::TokenKind Kind, const char *KindName) {
     return false;
   }
 
   bool parseSectionDirectiveText(StringRef, SMLoc) {
     // FIXME: .text currently no-op.
     return false;
   }
 
-  bool parseSectionFlags(StringRef FlagStr, bool &Passive, bool &Group) {
+  uint32_t parseSectionFlags(StringRef FlagStr, bool &Passive, bool &Group) {
+    uint32_t flags = 0;
     for (char C : FlagStr) {
       switch (C) {
       case 'p':
         Passive = true;
         break;
       case 'G':
         Group = true;
         break;
+      case 'S':
+        flags |= wasm::WASM_SEG_FLAG_STRINGS;
+        break;
       default:
-        return Parser->Error(getTok().getLoc(),
-                             StringRef("Unexepcted section flag: ") + FlagStr);
+        return -1U;
       }
     }
-    return false;
+    return flags;
   }
 
   bool parseGroup(StringRef &GroupName) {
     if (Lexer->isNot(AsmToken::Comma))
       return TokError("expected group name");
     Lex();
     if (Lexer->is(AsmToken::Integer)) {
       GroupName = getTok().getString();
       Lex();
     } else if (Parser->parseIdentifier(GroupName)) {
       return TokError("invalid group name");
     }
     if (Lexer->is(AsmToken::Comma)) {
       Lex();
       StringRef Linkage;
       if (Parser->parseIdentifier(Linkage))
         return TokError("invalid linkage");
       if (Linkage != "comdat")
         return TokError("Linkage must be 'comdat'");
     }
     return false;
   }
 
-  bool parseSectionDirective(StringRef, SMLoc) {
+  bool parseSectionDirective(StringRef, SMLoc loc) {
     StringRef Name;
     if (Parser->parseIdentifier(Name))
       return TokError("expected identifier in directive");
 
     if (expect(AsmToken::Comma, ","))
       return true;
 
     if (Lexer->isNot(AsmToken::String))
auto Kind = StringSwitch<Optional<SectionKind>>(Name)
                     // TargetLoweringObjectFileWasm
                     .StartsWith(".init_array", SectionKind::getData())
                     .StartsWith(".debug_", SectionKind::getMetadata())
                     .Default(SectionKind::getData());
 
     // Update section flags if present in this .section directive
     bool Passive = false;
     bool Group = false;
-    if (parseSectionFlags(getTok().getStringContents(), Passive, Group))
-      return true;
+    uint32_t Flags =
+        parseSectionFlags(getTok().getStringContents(), Passive, Group);
+    if (Flags == -1U)
+      return TokError("unknown flag");
 
     Lex();
 
     if (expect(AsmToken::Comma, ",") || expect(AsmToken::At, "@"))
       return true;
 
     StringRef GroupName;
     if (Group && parseGroup(GroupName))
       return true;
 
     if (expect(AsmToken::EndOfStatement, "eol"))
       return true;
 
     // TODO: Parse UniqueID
     MCSectionWasm *WS = getContext().getWasmSection(
-        Name, Kind.getValue(), GroupName, MCContext::GenericSectionID);
+        Name, Kind.getValue(), Flags, GroupName, MCContext::GenericSectionID);
+
+    if (WS->getSegmentFlags() != Flags)
+      Parser->Error(loc, "changed section flags for " + Name +
+                             ", expected: 0x" +
+                             utohexstr(WS->getSegmentFlags()));
+
     if (Passive) {
       if (!WS->isWasmData())
-        return Parser->Error(getTok().getLoc(),
-                             "Only data sections can be passive");
+        return Parser->Error(loc, "Only data sections can be passive");
       WS->setPassive();
     }
+
     getStreamer().SwitchSection(WS);
     return false;
   }
 
   // TODO: This function is almost the same as ELFAsmParser::ParseDirectiveSize
   // so maybe could be shared somehow.
   bool parseDirectiveSize(StringRef, SMLoc) {
     StringRef Name;

llvm/lib/MC/MCSectionWasm.cpp

if (shouldOmitSectionDirective(getName(), MAI)) {
     return;
   }
 
   OS << "\t.section\t";
   printName(OS, getName());
   OS << ",\"";
 
   if (IsPassive)
-    OS << "p";
+    OS << 'p';
   if (Group)
-    OS << "G";
+    OS << 'G';
+  if (SegmentFlags & wasm::WASM_SEG_FLAG_STRINGS)
+    OS << 'S';
 
   OS << '"';
 
   OS << ',';
 
   // If comment string is '@', e.g. as on ARM - use '%' instead
   if (MAI.getCommentString()[0] == '@')
     OS << '%';

llvm/lib/MC/WasmObjectWriter.cpp

 // in memory.  Each MCSection data created by llvm is modeled as its own
 // wasm data segment.
 struct WasmDataSegment {
   MCSectionWasm *Section;
   StringRef Name;
   uint32_t InitFlags;
   uint64_t Offset;
   uint32_t Alignment;
-  uint32_t LinkerFlags;
+  uint32_t LinkingFlags;
   SmallVector<char, 4> Data;
 };
 
 // A wasm function to be written into the function section.
 struct WasmFunction {
   uint32_t SigIndex;
   const MCSymbolWasm *Sym;
 };
void WasmObjectWriter::writeLinkingMetaDataSection(
   }
 
   if (DataSegments.size()) {
     startSection(SubSection, wasm::WASM_SEGMENT_INFO);
     encodeULEB128(DataSegments.size(), W->OS);
     for (const WasmDataSegment &Segment : DataSegments) {
       writeString(Segment.Name);
       encodeULEB128(Segment.Alignment, W->OS);
-      encodeULEB128(Segment.LinkerFlags, W->OS);
+      encodeULEB128(Segment.LinkingFlags, W->OS);
     }
     endSection(SubSection);
   }
 
   if (!InitFuncs.empty()) {
     startSection(SubSection, wasm::WASM_INIT_FUNCS);
     encodeULEB128(InitFuncs.size(), W->OS);
     for (auto &StartFunc : InitFuncs) {
if (Section.isWasmData()) {
       Segment.Name = SectionName;
       Segment.InitFlags = Section.getPassive()
                               ? (uint32_t)wasm::WASM_DATA_SEGMENT_IS_PASSIVE
                               : 0;
       Segment.Offset = DataSize;
       Segment.Section = &Section;
       addData(Segment.Data, Section);
       Segment.Alignment = Log2_32(Section.getAlignment());
-      Segment.LinkerFlags = 0;
+      Segment.LinkingFlags = Section.getSegmentFlags();
       DataSize += Segment.Data.size();
       Section.setSegmentIndex(SegmentIndex);
 
       if (const MCSymbolWasm *C = Section.getGroup()) {
         Comdats[C->getName()].emplace_back(
             WasmComdatEntry{wasm::WASM_COMDAT_DATA, SegmentIndex});
       }
     } else {

llvm/lib/Object/WasmObjectFile.cpp

while (Ctx.Ptr < OrigEnd) {
     case wasm::WASM_SEGMENT_INFO: {
       uint32_t Count = readVaruint32(Ctx);
       if (Count > DataSegments.size())
         return make_error<GenericBinaryError>("too many segment names",
                                               object_error::parse_failed);
       for (uint32_t I = 0; I < Count; I++) {
         DataSegments[I].Data.Name = readString(Ctx);
         DataSegments[I].Data.Alignment = readVaruint32(Ctx);
-        DataSegments[I].Data.LinkerFlags = readVaruint32(Ctx);
+        DataSegments[I].Data.LinkingFlags = readVaruint32(Ctx);
       }
       break;
     }
     case wasm::WASM_INIT_FUNCS: {
       uint32_t Count = readVaruint32(Ctx);
       LinkingData.InitFunctions.reserve(Count);
       for (uint32_t I = 0; I < Count; I++) {
         wasm::WasmInitFunc Init;
while (Count--) {
     uint32_t Size = readVaruint32(Ctx);
     if (Size > (size_t)(Ctx.End - Ctx.Ptr))
       return make_error<GenericBinaryError>("invalid segment size",
                                             object_error::parse_failed);
     Segment.Data.Content = ArrayRef<uint8_t>(Ctx.Ptr, Size);
     // The rest of these Data fields are set later, when reading in the linking
     // metadata section.
     Segment.Data.Alignment = 0;
-    Segment.Data.LinkerFlags = 0;
+    Segment.Data.LinkingFlags = 0;
     Segment.Data.Comdat = UINT32_MAX;
     Segment.SectionOffset = Ctx.Ptr - Ctx.Start;
     Ctx.Ptr += Size;
     DataSegments.push_back(Segment);
   }
   if (Ctx.Ptr != Ctx.End)
     return make_error<GenericBinaryError>("data section ended prematurely",
                                           object_error::parse_failed);

llvm/lib/ObjectYAML/WasmYAML.cpp

 #define BCase(X) IO.bitSetCase(Value, #X, wasm::WASM_LIMITS_FLAG_##X)
   BCase(HAS_MAX);
   BCase(IS_SHARED);
   BCase(IS_64);
 #undef BCase
 }
 
 void ScalarBitSetTraits<WasmYAML::SegmentFlags>::bitset(
-    IO &IO, WasmYAML::SegmentFlags &Value) {}
+    IO &IO, WasmYAML::SegmentFlags &Value) {
+#define BCase(X) IO.bitSetCase(Value, #X, wasm::WASM_SEG_FLAG_##X)
+  BCase(STRINGS);
+#undef BCase
+}
 
 void ScalarBitSetTraits<WasmYAML::SymbolFlags>::bitset(
     IO &IO, WasmYAML::SymbolFlags &Value) {
 #define BCaseMask(M, X)                                                        \
   IO.maskedBitSetCase(Value, #X, wasm::WASM_SYMBOL_##X, wasm::WASM_SYMBOL_##M)
   // BCaseMask(BINDING_MASK, BINDING_GLOBAL);
   BCaseMask(BINDING_MASK, BINDING_WEAK);
   BCaseMask(BINDING_MASK, BINDING_LOCAL);

llvm/lib/Target/WebAssembly/AsmParser/WebAssemblyAsmParser.cpp

void doBeforeLabelEmit(MCSymbol *Symbol) override {
     auto *Group = CWS->getGroup();
     // If the current section is a COMDAT, also set the flag on the symbol.
     // TODO: Currently the only place that the symbols' comdat flag matters is
     // for importing comdat functions. But there's no way to specify that in
     // assembly currently.
     if (Group)
       WasmSym->setComdat(true);
     auto *WS =
-        getContext().getWasmSection(SecName, SectionKind::getText(), Group,
+        getContext().getWasmSection(SecName, SectionKind::getText(), 0, Group,
                                     MCContext::GenericSectionID, nullptr);
     getStreamer().SwitchSection(WS);
     // Also generate DWARF for this section if requested.
     if (getContext().getGenDwarfForAssembly())
       getContext().addGenDwarfSection(WS);
   }
 
   void onEndOfFunction() {

llvm/test/MC/WebAssembly/section-flags-changed.s

+# RUN: not llvm-mc -triple=wasm32-unknown-unknown %s -o /dev/null 2>&1 | FileCheck %s --implicit-check-not=error:
+
+foo:
+.section .foo,"S",@
+
+# CHECK: {{.*}}.s:[[# @LINE+1]]:1: error: changed section flags for .foo, expected: 0x1
+.section .foo,"",@

llvm/tools/obj2yaml/wasm2yaml.cpp

if (WasmSec.Name == "dylink") {
 
     uint32_t SegmentIndex = 0;
     for (const object::WasmSegment &Segment : Obj.dataSegments()) {
       if (!Segment.Data.Name.empty()) {
         WasmYAML::SegmentInfo SegmentInfo;
         SegmentInfo.Name = Segment.Data.Name;
         SegmentInfo.Index = SegmentIndex;
         SegmentInfo.Alignment = Segment.Data.Alignment;
-        SegmentInfo.Flags = Segment.Data.LinkerFlags;
+        SegmentInfo.Flags = Segment.Data.LinkingFlags;
         LinkingSec->SegmentInfos.push_back(SegmentInfo);
       }
       if (Segment.Data.Comdat != UINT32_MAX) {
         LinkingSec->Comdats[Segment.Data.Comdat].Entries.emplace_back(
             WasmYAML::ComdatEntry{wasm::WASM_COMDAT_DATA, SegmentIndex});
       }
       SegmentIndex++;
     }