[WebAssembly] Target features section

[tlively]

Summary

Implements a new target features section in assembly and object files
that records what features are used, required, and disallowed in
WebAssembly objects. The linker uses this information to ensure that
all objects participating in a link are feature-compatible and records
the set of used features in the output binary for use by optimizers
and other tools later in the toolchain.

The "atomics" feature is always required or disallowed to prevent
linking code with stripped atomics into multithreaded binaries. Other
features are marked used if they are enabled globally or on any
function in a module.

Future CLs will add linker flags for ignoring feature compatibility
checks and for specifying the set of allowed features, implement using
the presence of the "atomics" feature to control the type of memory
and segments in the linked binary, and add front-end flags for
relaxing the linkage policy for atomics.

[sbc100]

llvm/include/llvm/BinaryFormat/Wasm.h

262

char?

llvm/lib/Object/WasmObjectFile.cpp

677

Why this?

1600

This formatting looks worse IMHO. Skip clang-format here?

[tlively]

llvm/include/llvm/BinaryFormat/Wasm.h

262

Can do. Out of curiosity, what is the rationale for using char instead of uint8_t? It seems that uint8_t would give more predictable and portable results.

llvm/lib/Object/WasmObjectFile.cpp

677

I was having issues elsewhere with StringRef not owning the storage it references, so the contents of strings were being unexpectedly changed. I decided to retroactively play it safe and change these StringRefs to std::strings as well. From the manual:

StringRef doesn’t own or keep alive the underlying string bytes. As such it can easily lead to dangling pointers, and is not suitable for embedding in datastructures in most cases

1600

I agree. Will do.

[sbc100]

llvm/include/llvm/BinaryFormat/Wasm.h

262

It just seemed more natural because you are using ASCII value here. Alternatively you could just use 0, 1 and 2 as the values? Was there rational for using ASCII values?

llvm/lib/Object/WasmObjectFile.cpp

677

Right, but in this case the strings are all pointing into the binary file (Ctx) IIUC? And what is more they only need to live as long as this function?

Even if the StringRefs outlived this function I believe that would be fine as Ctx is valid as long as this here.

[tlively]

• address comments, add tests, fix bugs

[tlively]

llvm/include/llvm/BinaryFormat/Wasm.h

262

Most of the enums in this file have values that correspond directly to the values found in the binary file, so I wanted to use the exact prefix values that are allowed in the binary. The intent of the spec is reflected by using the ascii literals instead of hex literals. Actually, I think using uint8_t is better here as well because there are exactly eight bits in the binary format.

llvm/lib/Object/WasmObjectFile.cpp

677

Ok, I'll change it back. It's unfortunate that there is no way to tell this is safe by the signature of readString.

[tlively]

@sbc100 Do you have any further comments or concerns with this CL? Are you ok using uint8_t for the BinaryFormat enum?

[sbc100]

llvm/lib/Target/WebAssembly/WebAssemblyAsmPrinter.cpp

231

Doesn't this duplicate the values from Wasm.h?

[tlively]

llvm/lib/Target/WebAssembly/WebAssemblyAsmPrinter.cpp

231

Yes, fixed.

lld/wasm/InputFiles.h

public:
 
   uint32_t calcNewIndex(const WasmRelocation &Reloc) const;
   uint32_t calcNewValue(const WasmRelocation &Reloc) const;
   uint32_t calcNewAddend(const WasmRelocation &Reloc) const;
   uint32_t calcExpectedValue(const WasmRelocation &Reloc) const;
 
   const WasmSection *CodeSection = nullptr;
   const WasmSection *DataSection = nullptr;
-  const WasmSection *ProducersSection = nullptr;
 
   // Maps input type indices to output type indices
   std::vector<uint32_t> TypeMap;
   std::vector<bool> TypeIsUsed;
   // Maps function indices to table indices
   std::vector<uint32_t> TableEntries;
   std::vector<bool> UsedComdats;
   std::vector<InputSegment *> Segments;

lld/wasm/InputFiles.cpp

for (const SectionRef &Sec : WasmObj->sections()) {
     if (Section.Type == WASM_SEC_CODE) {
       CodeSection = &Section;
     } else if (Section.Type == WASM_SEC_DATA) {
       DataSection = &Section;
     } else if (Section.Type == WASM_SEC_CUSTOM) {
       CustomSections.emplace_back(make<InputSection>(Section, this));
       CustomSections.back()->setRelocations(Section.Relocations);
       CustomSectionsByIndex[SectionIndex] = CustomSections.back();
-      if (Section.Name == "producers")
-        ProducersSection = &Section;
     }
     SectionIndex++;
   }
 
   TypeMap.resize(getWasmObj()->types().size());
   TypeIsUsed.resize(getWasmObj()->types().size(), false);
 
   ArrayRef<StringRef> Comdats = WasmObj->linkingData().Comdats;

lld/wasm/Writer.cpp

 #include "OutputSegment.h"
 #include "SymbolTable.h"
 #include "WriterUtils.h"
 #include "lld/Common/ErrorHandler.h"
 #include "lld/Common/Memory.h"
 #include "lld/Common/Strings.h"
 #include "lld/Common/Threads.h"
 #include "llvm/ADT/DenseSet.h"
+#include "llvm/ADT/SmallSet.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringMap.h"
 #include "llvm/BinaryFormat/Wasm.h"
 #include "llvm/Object/WasmTraits.h"
 #include "llvm/Support/FileOutputBuffer.h"
 #include "llvm/Support/Format.h"
 #include "llvm/Support/FormatVariadic.h"
 #include "llvm/Support/LEB128.h"
private:
   void openFile();
 
   uint32_t lookupType(const WasmSignature &Sig);
   uint32_t registerType(const WasmSignature &Sig);
 
   void createCtorFunction();
   void calculateInitFunctions();
   void assignIndexes();
+  void calculateTargetFeatures();
   void calculateImports();
   void calculateExports();
   void calculateCustomSections();
   void assignSymtab();
   void calculateTypes();
   void createOutputSegments();
   void layoutMemory();
   void createHeader();
private:
   void createCustomSections();
 
   // Custom sections
   void createDylinkSection();
   void createRelocSections();
   void createLinkingSection();
   void createNameSection();
   void createProducersSection();
+  void createTargetFeaturesSection();
 
   void writeHeader();
   void writeSections();
 
   uint64_t FileSize = 0;
   uint32_t TableBase = 0;
   uint32_t NumMemoryPages = 0;
   uint32_t MaxMemoryPages = 0;
private:
   std::vector<InputFunction *> InputFunctions;
   std::vector<InputEvent *> InputEvents;
   std::vector<const FunctionSymbol *> IndirectFunctions;
   std::vector<const Symbol *> SymtabEntries;
   std::vector<WasmInitEntry> InitFunctions;
 
   llvm::StringMap<std::vector<InputSection *>> CustomSectionMapping;
   llvm::StringMap<SectionSymbol *> CustomSectionSymbols;
+  llvm::SmallSet<std::string, 8> TargetFeatures;
 
   // 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;
void Writer::calculateCustomSections() {
   log("calculateCustomSections");
   bool StripDebug = Config->StripDebug || Config->StripAll;
   for (ObjFile *File : Symtab->ObjectFiles) {
     for (InputSection *Section : File->CustomSections) {
       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.startswith("reloc."))
+          Name == "target_features" || Name.startswith("reloc."))
         continue;
       // .. or it is a debug section
       if (StripDebug && Name.startswith(".debug_"))
         continue;
       CustomSectionMapping[Name].push_back(Section);
     }
   }
 }
for (auto &Field :
     writeUleb128(OS, Field.second.size(), "number of entries");
     for (auto &Entry : Field.second) {
       writeStr(OS, Entry.first, "producer name");
       writeStr(OS, Entry.second, "producer version");
     }
   }
 }
 
+void Writer::createTargetFeaturesSection() {
+  if (TargetFeatures.size() == 0)
+    return;
+
+  SmallVector<std::string, 8> Emitted(TargetFeatures.begin(),
+                                      TargetFeatures.end());
+  std::sort(Emitted.begin(), Emitted.end());
+  SyntheticSection *Section =
+      createSyntheticSection(WASM_SEC_CUSTOM, "target_features");
+  auto &OS = Section->getStream();
+  writeUleb128(OS, Emitted.size(), "feature count");
+  for (auto &Feature : Emitted) {
+    writeU8(OS, WASM_FEATURE_PREFIX_USED, "feature used prefix");
+    writeStr(OS, Feature, "feature name");
+  }
+}
+
 void Writer::writeHeader() {
   memcpy(Buffer->getBufferStart(), Header.data(), Header.size());
 }
 
 void Writer::writeSections() {
   uint8_t *Buf = Buffer->getBufferStart();
   parallelForEach(OutputSections, [Buf](OutputSection *S) { S->writeTo(Buf); });
 }
void Writer::createSections() {
   if (Config->Relocatable) {
     createLinkingSection();
     createRelocSections();
   }
 
   if (!Config->StripDebug && !Config->StripAll)
     createNameSection();
 
-  if (!Config->StripAll)
+  if (!Config->StripAll) {
     createProducersSection();
+    createTargetFeaturesSection();
+  }
 
   for (OutputSection *S : OutputSections) {
     S->setOffset(FileSize);
     S->finalizeContents();
     FileSize += S->getSize();
   }
 }
 
+void Writer::calculateTargetFeatures() {
+  SmallSet<std::string, 8> Required;
+  SmallSet<std::string, 8> Disallowed;
+
+  // Find the sets of used, required, and disallowed features
+  for (ObjFile *File : Symtab->ObjectFiles) {
+    for (auto &Feature : File->getWasmObj()->getTargetFeatures()) {
+      switch (Feature.Prefix) {
+      case WASM_FEATURE_PREFIX_USED:
+        TargetFeatures.insert(Feature.Name);
+        break;
+      case WASM_FEATURE_PREFIX_REQUIRED:
+        TargetFeatures.insert(Feature.Name);
+        Required.insert(Feature.Name);
+        break;
+      case WASM_FEATURE_PREFIX_DISALLOWED:
+        Disallowed.insert(Feature.Name);
+        break;
+      default:
+        error("Unrecognized feature policy prefix " +
+              std::to_string(Feature.Prefix));
+      }
+    }
+  }
+
+  // Validate the required and disallowed constraints for each file
+  for (ObjFile *File : Symtab->ObjectFiles) {
+    SmallSet<std::string, 8> ObjectFeatures;
+    for (auto &Feature : File->getWasmObj()->getTargetFeatures()) {
+      if (Feature.Prefix == WASM_FEATURE_PREFIX_DISALLOWED)
+        continue;
+      ObjectFeatures.insert(Feature.Name);
+      if (Disallowed.count(Feature.Name))
+        error("Target feature \"" + Feature.Name + "\" is disallowed");
+    }
+    for (auto &Feature : Required) {
+      if (!ObjectFeatures.count(Feature))
+        error(Twine("Missing required target feature \"") + Feature + "\"");
+    }
+  }
+}
+
 void Writer::calculateImports() {
   for (Symbol *Sym : Symtab->getSymbols()) {
     if (!Sym->isUndefined())
       continue;
     if (isa<DataSymbol>(Sym))
       continue;
     if (Sym->isWeak() && !Config->Relocatable)
       continue;
void Writer::run() {
   if (Config->Relocatable || Config->Pic)
     Config->GlobalBase = 0;
 
   // For PIC code the table base is assigned dynamically by the loader.
   // For non-PIC, we start at 1 so that accessing table index 0 always traps.
   if (!Config->Pic)
     TableBase = 1;
 
+  log("-- calculateTargetFeatures");
+  calculateTargetFeatures();
   log("-- calculateImports");
   calculateImports();
   log("-- assignIndexes");
   assignIndexes();
   log("-- calculateInitFunctions");
   calculateInitFunctions();
   if (!Config->Relocatable)
     createCtorFunction();

llvm/include/llvm/BinaryFormat/Wasm.h

 };
 
 struct WasmProducerInfo {
   std::vector<std::pair<std::string, std::string>> Languages;
   std::vector<std::pair<std::string, std::string>> Tools;
   std::vector<std::pair<std::string, std::string>> SDKs;
 };
 
+struct WasmFeatureEntry {
+  uint8_t Prefix;
+  std::string Name;
+};
+
 struct WasmExport {
   StringRef Name;
   uint8_t Kind;
   uint32_t Index;
 };
 
 struct WasmLimits {
   uint8_t Flags;
enum : unsigned {
   WASM_LIMITS_FLAG_IS_SHARED = 0x2,
 };
 
 enum : unsigned {
   WASM_SEGMENT_IS_PASSIVE = 0x01,
   WASM_SEGMENT_HAS_MEMINDEX = 0x02,
 };
 
+// Feature policy prefixes used in the custom "target_features" section
+enum : uint8_t {
+  WASM_FEATURE_PREFIX_USED = '+',
+  WASM_FEATURE_PREFIX_REQUIRED = '=',
+  WASM_FEATURE_PREFIX_DISALLOWED = '-',
+};
+
 // Kind codes used in the custom "name" section
 enum : unsigned {
   WASM_NAMES_FUNCTION = 0x1,
   WASM_NAMES_LOCAL = 0x2,
 };
 
 // Kind codes used in the custom "linking" section
 enum : unsigned {

llvm/include/llvm/Object/Wasm.h

public:
   const WasmSymbol &getWasmSymbol(const SymbolRef &Symbol) const;
   const WasmSection &getWasmSection(const SectionRef &Section) const;
   const wasm::WasmRelocation &getWasmRelocation(const RelocationRef &Ref) const;
 
   static bool classof(const Binary *v) { return v->isWasm(); }
 
   const wasm::WasmDylinkInfo &dylinkInfo() const { return DylinkInfo; }
   const wasm::WasmProducerInfo &getProducerInfo() const { return ProducerInfo; }
+  ArrayRef<wasm::WasmFeatureEntry> getTargetFeatures() const {
+    return TargetFeatures;
+  }
   ArrayRef<wasm::WasmSignature> types() const { return Signatures; }
   ArrayRef<uint32_t> functionTypes() const { return FunctionTypes; }
   ArrayRef<wasm::WasmImport> imports() const { return Imports; }
   ArrayRef<wasm::WasmTable> tables() const { return Tables; }
   ArrayRef<wasm::WasmLimits> memories() const { return Memories; }
   ArrayRef<wasm::WasmGlobal> globals() const { return Globals; }
   ArrayRef<wasm::WasmEvent> events() const { return Events; }
   ArrayRef<wasm::WasmExport> exports() const { return Exports; }
private:
 
   // Custom section types
   Error parseDylinkSection(ReadContext &Ctx);
   Error parseNameSection(ReadContext &Ctx);
   Error parseLinkingSection(ReadContext &Ctx);
   Error parseLinkingSectionSymtab(ReadContext &Ctx);
   Error parseLinkingSectionComdat(ReadContext &Ctx);
   Error parseProducersSection(ReadContext &Ctx);
+  Error parseTargetFeaturesSection(ReadContext &Ctx);
   Error parseRelocSection(StringRef Name, ReadContext &Ctx);
 
   wasm::WasmObjectHeader Header;
   std::vector<WasmSection> Sections;
   wasm::WasmDylinkInfo DylinkInfo;
   wasm::WasmProducerInfo ProducerInfo;
+  std::vector<wasm::WasmFeatureEntry> TargetFeatures;
   std::vector<wasm::WasmSignature> Signatures;
   std::vector<uint32_t> FunctionTypes;
   std::vector<wasm::WasmTable> Tables;
   std::vector<wasm::WasmLimits> Memories;
   std::vector<wasm::WasmGlobal> Globals;
   std::vector<wasm::WasmEvent> Events;
   std::vector<wasm::WasmImport> Imports;
   std::vector<wasm::WasmExport> Exports;
enum : int {
     WASM_SEC_ORDER_LINKING,
     // Must come after "linking" section in order to validate reloc indexes.
     WASM_SEC_ORDER_RELOC,
     // "name" section must appear after DATA. Comes after "linking" to allow
     // symbol table to set default function name.
     WASM_SEC_ORDER_NAME,
     // "producers" section must appear after "name" section.
     WASM_SEC_ORDER_PRODUCERS,
+    // "target_features" section must appear after producers section
+    WASM_SEC_ORDER_TARGET_FEATURES,
 
     // Must be last
     WASM_NUM_SEC_ORDERS
 
   };
 
   // Sections that may or may not be present, but cannot be predecessors
   static int DisallowedPredecessors[WASM_NUM_SEC_ORDERS][WASM_NUM_SEC_ORDERS];

llvm/include/llvm/ObjectYAML/WasmYAML.h

 LLVM_YAML_STRONG_TYPEDEF(uint32_t, ExportKind)
 LLVM_YAML_STRONG_TYPEDEF(uint32_t, Opcode)
 LLVM_YAML_STRONG_TYPEDEF(uint32_t, RelocType)
 LLVM_YAML_STRONG_TYPEDEF(uint32_t, SymbolFlags)
 LLVM_YAML_STRONG_TYPEDEF(uint32_t, SymbolKind)
 LLVM_YAML_STRONG_TYPEDEF(uint32_t, SegmentFlags)
 LLVM_YAML_STRONG_TYPEDEF(uint32_t, LimitFlags)
 LLVM_YAML_STRONG_TYPEDEF(uint32_t, ComdatKind)
+LLVM_YAML_STRONG_TYPEDEF(uint32_t, FeaturePolicyPrefix)
 
 struct FileHeader {
   yaml::Hex32 Version;
 };
 
 struct Limits {
   LimitFlags Flags;
   yaml::Hex32 Initial;
struct NameEntry {
   StringRef Name;
 };
 
 struct ProducerEntry {
   std::string Name;
   std::string Version;
 };
 
+struct FeatureEntry {
+  FeaturePolicyPrefix Prefix;
+  std::string Name;
+};
+
 struct SegmentInfo {
   uint32_t Index;
   StringRef Name;
   uint32_t Alignment;
   SegmentFlags Flags;
 };
 
 struct Signature {
static bool classof(const Section *S) {
     return C && C->Name == "producers";
   }
 
   std::vector<ProducerEntry> Languages;
   std::vector<ProducerEntry> Tools;
   std::vector<ProducerEntry> SDKs;
 };
 
+struct TargetFeaturesSection : CustomSection {
+  TargetFeaturesSection() : CustomSection("target_features") {}
+
+  static bool classof(const Section *S) {
+    auto C = dyn_cast<CustomSection>(S);
+    return C && C->Name == "target_features";
+  }
+
+  std::vector<FeatureEntry> Features;
+};
+
 struct TypeSection : Section {
   TypeSection() : Section(wasm::WASM_SEC_TYPE) {}
 
   static bool classof(const Section *S) {
     return S->Type == wasm::WASM_SEC_TYPE;
   }
 
   std::vector<Signature> Signatures;

 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::WasmYAML::Limits)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::WasmYAML::DataSegment)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::WasmYAML::Global)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::WasmYAML::Function)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::WasmYAML::LocalDecl)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::WasmYAML::Relocation)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::WasmYAML::NameEntry)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::WasmYAML::ProducerEntry)
+LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::WasmYAML::FeatureEntry)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::WasmYAML::SegmentInfo)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::WasmYAML::SymbolInfo)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::WasmYAML::InitFunction)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::WasmYAML::ComdatEntry)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::WasmYAML::Comdat)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::WasmYAML::Event)
 
 namespace llvm {

 template <> struct MappingTraits<WasmYAML::NameEntry> {
   static void mapping(IO &IO, WasmYAML::NameEntry &NameEntry);
 };
 
 template <> struct MappingTraits<WasmYAML::ProducerEntry> {
   static void mapping(IO &IO, WasmYAML::ProducerEntry &ProducerEntry);
 };
 
+template <> struct ScalarEnumerationTraits<WasmYAML::FeaturePolicyPrefix> {
+  static void enumeration(IO &IO, WasmYAML::FeaturePolicyPrefix &Prefix);
+};
+
+template <> struct MappingTraits<WasmYAML::FeatureEntry> {
+  static void mapping(IO &IO, WasmYAML::FeatureEntry &FeatureEntry);
+};
+
 template <> struct MappingTraits<WasmYAML::SegmentInfo> {
   static void mapping(IO &IO, WasmYAML::SegmentInfo &SegmentInfo);
 };
 
 template <> struct MappingTraits<WasmYAML::LocalDecl> {
   static void mapping(IO &IO, WasmYAML::LocalDecl &LocalDecl);
 };
 

llvm/lib/MC/MCParser/WasmAsmParser.cpp

bool parseSectionDirective(StringRef, SMLoc) {
     if (expect(AsmToken::Comma, ",") || expect(AsmToken::At, "@") ||
         expect(AsmToken::EndOfStatement, "eol"))
       return true;
     struct SectionType {
       const char *Name;
       SectionKind Kind;
     };
     static SectionType SectionTypes[] = {
-        { ".text", SectionKind::getText() },
-        { ".rodata", SectionKind::getReadOnly() },
-        { ".data", SectionKind::getData() },
+        {".text", SectionKind::getText()},
+        {".rodata", SectionKind::getReadOnly()},
+        {".data", SectionKind::getData()},
+        {".custom_section", SectionKind::getMetadata()},
         // TODO: add more types.
     };
     for (size_t I = 0; I < sizeof(SectionTypes) / sizeof(SectionType); I++) {
       if (Name.startswith(SectionTypes[I].Name)) {
         auto WS = getContext().getWasmSection(Name, SectionTypes[I].Kind);
         getStreamer().SwitchSection(WS);
         return false;
       }

llvm/lib/MC/WasmObjectWriter.cpp

class WasmObjectWriter : public MCObjectWriter {
   DenseMap<const MCSymbolWasm *, uint32_t> WasmIndices;
   // Maps data symbols to the Wasm segment and offset/size with the segment.
   DenseMap<const MCSymbolWasm *, wasm::WasmDataReference> DataLocations;
 
   // Stores output data (index, relocations, content offset) for custom
   // section.
   std::vector<WasmCustomSection> CustomSections;
   std::unique_ptr<WasmCustomSection> ProducersSection;
+  std::unique_ptr<WasmCustomSection> TargetFeaturesSection;
   // Relocations for fixing up references in the custom sections.
   DenseMap<const MCSectionWasm *, std::vector<WasmRelocationEntry>>
       CustomSectionsRelocations;
 
   // Map from section to defining function symbol.
   DenseMap<const MCSection *, const MCSymbol *> SectionFunctions;
 
   DenseMap<WasmSignature, uint32_t, WasmSignatureDenseMapInfo> SignatureIndices;
void reset() override {
     CodeRelocations.clear();
     DataRelocations.clear();
     TypeIndices.clear();
     WasmIndices.clear();
     TableIndices.clear();
     DataLocations.clear();
     CustomSections.clear();
     ProducersSection.reset();
+    TargetFeaturesSection.reset();
     CustomSectionsRelocations.clear();
     SignatureIndices.clear();
     Signatures.clear();
     Globals.clear();
     DataSegments.clear();
     SectionFunctions.clear();
     NumFunctionImports = 0;
     NumGlobalImports = 0;
if (Section.isWasmData()) {
       MCSymbol *Begin = Sec.getBeginSymbol();
       if (Begin) {
         WasmIndices[cast<MCSymbolWasm>(Begin)] = CustomSections.size();
         if (SectionName != Begin->getName())
           report_fatal_error("section name and begin symbol should match: " +
                              Twine(SectionName));
       }
 
-      // Separate out the producers section
+      // Separate out the producers and target features sections
       if (Name == "producers") {
         ProducersSection = llvm::make_unique<WasmCustomSection>(Name, &Section);
         continue;
       }
+      if (Name == "target_features") {
+        TargetFeaturesSection =
+            llvm::make_unique<WasmCustomSection>(Name, &Section);
+        continue;
+      }
 
       CustomSections.emplace_back(Name, &Section);
     }
   }
 
   // Populate WasmIndices and DataLocations for defined symbols.
   for (const MCSymbol &S : Asm.symbols()) {
     // Ignore unnamed temporary symbols, which aren't ever exported, imported,
uint64_t WasmObjectWriter::writeObject(MCAssembler &Asm,
   for (auto &CustomSection : CustomSections)
     writeCustomSection(CustomSection, Asm, Layout);
   writeLinkingMetaDataSection(SymbolInfos, InitFuncs, Comdats);
   writeRelocSection(CodeSectionIndex, "CODE", CodeRelocations);
   writeRelocSection(DataSectionIndex, "DATA", DataRelocations);
   writeCustomRelocSections();
   if (ProducersSection)
     writeCustomSection(*ProducersSection, Asm, Layout);
+  if (TargetFeaturesSection)
+    writeCustomSection(*TargetFeaturesSection, Asm, Layout);
 
   // TODO: Translate the .comment section to the output.
   return W.OS.tell() - StartOffset;
 }
 
 std::unique_ptr<MCObjectWriter>
 llvm::createWasmObjectWriter(std::unique_ptr<MCWasmObjectTargetWriter> MOTW,
                              raw_pwrite_stream &OS) {
   return llvm::make_unique<WasmObjectWriter>(std::move(MOTW), OS);
 }

llvm/lib/Object/WasmObjectFile.cpp

while (EntryCount--) {
         break;
       }
     }
   }
   return Error::success();
 }
 
 Error WasmObjectFile::parseProducersSection(ReadContext &Ctx) {
-  llvm::SmallSet<StringRef, 3> FieldsSeen;
+  llvm::SmallSet<std::string, 3> FieldsSeen;
   uint32_t Fields = readVaruint32(Ctx);
   for (size_t I = 0; I < Fields; ++I) {
     StringRef FieldName = readString(Ctx);
     if (!FieldsSeen.insert(FieldName).second)
       return make_error<GenericBinaryError>(
           "Producers section does not have unique fields",
           object_error::parse_failed);
     std::vector<std::pair<std::string, std::string>> *ProducerVec = nullptr;
for (size_t I = 0; I < Fields; ++I) {
     }
   }
   if (Ctx.Ptr != Ctx.End)
     return make_error<GenericBinaryError>("Producers section ended prematurely",
                                           object_error::parse_failed);
   return Error::success();
 }
 
+Error WasmObjectFile::parseTargetFeaturesSection(ReadContext &Ctx) {
+  llvm::SmallSet<std::string, 8> FeaturesSeen;
+  uint32_t FeatureCount = readVaruint32(Ctx);
+  for (size_t I = 0; I < FeatureCount; ++I) {
+    wasm::WasmFeatureEntry Feature;
+    Feature.Prefix = readUint8(Ctx);
+    switch (Feature.Prefix) {
+    case wasm::WASM_FEATURE_PREFIX_USED:
+    case wasm::WASM_FEATURE_PREFIX_REQUIRED:
+    case wasm::WASM_FEATURE_PREFIX_DISALLOWED:
+      break;
+    default:
+      return make_error<GenericBinaryError>("Unknown feature policy prefix",
+                                            object_error::parse_failed);
+    }
+    Feature.Name = readString(Ctx);
+    if (!FeaturesSeen.insert(Feature.Name).second)
+      return make_error<GenericBinaryError>(
+          "Target features section contains repeated feature \"" +
+              Feature.Name + "\"",
+          object_error::parse_failed);
+    TargetFeatures.push_back(Feature);
+  }
+  if (Ctx.Ptr != Ctx.End)
+    return make_error<GenericBinaryError>(
+        "Target features section ended prematurely",
+        object_error::parse_failed);
+  return Error::success();
+}
+
 Error WasmObjectFile::parseRelocSection(StringRef Name, ReadContext &Ctx) {
   uint32_t SectionIndex = readVaruint32(Ctx);
   if (SectionIndex >= Sections.size())
     return make_error<GenericBinaryError>("Invalid section index",
                                           object_error::parse_failed);
   WasmSection &Section = Sections[SectionIndex];
   uint32_t RelocCount = readVaruint32(Ctx);
   uint32_t EndOffset = Section.Content.size();
if (Sec.Name == "dylink") {
     if (Error Err = parseNameSection(Ctx))
       return Err;
   } else if (Sec.Name == "linking") {
     if (Error Err = parseLinkingSection(Ctx))
       return Err;
   } else if (Sec.Name == "producers") {
     if (Error Err = parseProducersSection(Ctx))
       return Err;
+  } else if (Sec.Name == "target_features") {
+    if (Error Err = parseTargetFeaturesSection(Ctx))
+      return Err;
   } else if (Sec.Name.startswith("reloc.")) {
     if (Error Err = parseRelocSection(Sec.Name, Ctx))
       return Err;
   }
   return Error::success();
 }
 
 Error WasmObjectFile::parseTypeSection(ReadContext &Ctx) {
int WasmSectionOrderChecker::getSectionOrder(unsigned ID,
   switch (ID) {
   case wasm::WASM_SEC_CUSTOM:
     return StringSwitch<unsigned>(CustomSectionName)
         .Case("dylink", WASM_SEC_ORDER_DYLINK)
         .Case("linking", WASM_SEC_ORDER_LINKING)
         .StartsWith("reloc.", WASM_SEC_ORDER_RELOC)
         .Case("name", WASM_SEC_ORDER_NAME)
         .Case("producers", WASM_SEC_ORDER_PRODUCERS)
+        .Case("target_features", WASM_SEC_ORDER_TARGET_FEATURES)
         .Default(WASM_SEC_ORDER_NONE);
   case wasm::WASM_SEC_TYPE:
     return WASM_SEC_ORDER_TYPE;
   case wasm::WASM_SEC_IMPORT:
     return WASM_SEC_ORDER_IMPORT;
   case wasm::WASM_SEC_FUNCTION:
     return WASM_SEC_ORDER_FUNCTION;
   case wasm::WASM_SEC_TABLE:
int WasmSectionOrderChecker::getSectionOrder(unsigned ID,
   default:
     llvm_unreachable("invalid section");
   }
 }
 
 // Represents the edges in a directed graph where any node B reachable from node
 // A is not allowed to appear before A in the section ordering, but may appear
 // afterward.
-int WasmSectionOrderChecker::DisallowedPredecessors[WASM_NUM_SEC_ORDERS][WASM_NUM_SEC_ORDERS] = {
-  {}, // WASM_SEC_ORDER_NONE
+int WasmSectionOrderChecker::DisallowedPredecessors
+    [WASM_NUM_SEC_ORDERS][WASM_NUM_SEC_ORDERS] = {
+        {},                                           // WASM_SEC_ORDER_NONE
         {WASM_SEC_ORDER_TYPE, WASM_SEC_ORDER_IMPORT}, // WASM_SEC_ORDER_TYPE,
-  {WASM_SEC_ORDER_IMPORT, WASM_SEC_ORDER_FUNCTION}, // WASM_SEC_ORDER_IMPORT,
-  {WASM_SEC_ORDER_FUNCTION, WASM_SEC_ORDER_TABLE}, // WASM_SEC_ORDER_FUNCTION,
+        {WASM_SEC_ORDER_IMPORT,
+         WASM_SEC_ORDER_FUNCTION}, // WASM_SEC_ORDER_IMPORT,
+        {WASM_SEC_ORDER_FUNCTION,
+         WASM_SEC_ORDER_TABLE}, // WASM_SEC_ORDER_FUNCTION,
         {WASM_SEC_ORDER_TABLE, WASM_SEC_ORDER_MEMORY}, // WASM_SEC_ORDER_TABLE,
-  {WASM_SEC_ORDER_MEMORY, WASM_SEC_ORDER_GLOBAL}, // WASM_SEC_ORDER_MEMORY,
+        {WASM_SEC_ORDER_MEMORY,
+         WASM_SEC_ORDER_GLOBAL},                       // WASM_SEC_ORDER_MEMORY,
         {WASM_SEC_ORDER_GLOBAL, WASM_SEC_ORDER_EVENT}, // WASM_SEC_ORDER_GLOBAL,
         {WASM_SEC_ORDER_EVENT, WASM_SEC_ORDER_EXPORT}, // WASM_SEC_ORDER_EVENT,
         {WASM_SEC_ORDER_EXPORT, WASM_SEC_ORDER_START}, // WASM_SEC_ORDER_EXPORT,
-  {WASM_SEC_ORDER_START, WASM_SEC_ORDER_ELEM}, // WASM_SEC_ORDER_START,
+        {WASM_SEC_ORDER_START, WASM_SEC_ORDER_ELEM},   // WASM_SEC_ORDER_START,
         {WASM_SEC_ORDER_ELEM, WASM_SEC_ORDER_DATACOUNT}, // WASM_SEC_ORDER_ELEM,
-  {WASM_SEC_ORDER_DATACOUNT, WASM_SEC_ORDER_CODE}, // WASM_SEC_ORDER_DATACOUNT,
+        {WASM_SEC_ORDER_DATACOUNT,
+         WASM_SEC_ORDER_CODE},                      // WASM_SEC_ORDER_DATACOUNT,
         {WASM_SEC_ORDER_CODE, WASM_SEC_ORDER_DATA}, // WASM_SEC_ORDER_CODE,
         {WASM_SEC_ORDER_DATA, WASM_SEC_ORDER_LINKING}, // WASM_SEC_ORDER_DATA,
 
         // Custom Sections
         {WASM_SEC_ORDER_DYLINK, WASM_SEC_ORDER_TYPE}, // WASM_SEC_ORDER_DYLINK,
-  {WASM_SEC_ORDER_LINKING, WASM_SEC_ORDER_RELOC, WASM_SEC_ORDER_NAME}, // WASM_SEC_ORDER_LINKING,
-  {}, // WASM_SEC_ORDER_RELOC (can be repeated),
+        {WASM_SEC_ORDER_LINKING, WASM_SEC_ORDER_RELOC,
+         WASM_SEC_ORDER_NAME}, // WASM_SEC_ORDER_LINKING,
+        {},                    // WASM_SEC_ORDER_RELOC (can be repeated),
         {WASM_SEC_ORDER_NAME, WASM_SEC_ORDER_PRODUCERS}, // WASM_SEC_ORDER_NAME,
-  {WASM_SEC_ORDER_PRODUCERS}, // WASM_SEC_ORDER_PRODUCERS,
+        {WASM_SEC_ORDER_PRODUCERS,
+         WASM_SEC_ORDER_TARGET_FEATURES}, // WASM_SEC_ORDER_PRODUCERS,
+        {WASM_SEC_ORDER_TARGET_FEATURES}  // WASM_SEC_ORDER_TARGET_FEATURES
 };
 
 bool WasmSectionOrderChecker::isValidSectionOrder(unsigned ID,
                                                   StringRef CustomSectionName) {
   int Order = getSectionOrder(ID, CustomSectionName);
   if (Order == WASM_SEC_ORDER_NONE)
     return true;
 

llvm/lib/ObjectYAML/WasmYAML.cpp

 static void sectionMapping(IO &IO, WasmYAML::ProducersSection &Section) {
   commonSectionMapping(IO, Section);
   IO.mapRequired("Name", Section.Name);
   IO.mapOptional("Languages", Section.Languages);
   IO.mapOptional("Tools", Section.Tools);
   IO.mapOptional("SDKs", Section.SDKs);
 }
 
+static void sectionMapping(IO &IO, WasmYAML::TargetFeaturesSection &Section) {
+  commonSectionMapping(IO, Section);
+  IO.mapRequired("Features", Section.Features);
+}
+
 static void sectionMapping(IO &IO, WasmYAML::CustomSection &Section) {
   commonSectionMapping(IO, Section);
   IO.mapRequired("Name", Section.Name);
   IO.mapRequired("Payload", Section.Payload);
 }
 
 static void sectionMapping(IO &IO, WasmYAML::TypeSection &Section) {
   commonSectionMapping(IO, Section);
case wasm::WASM_SEC_CUSTOM: {
     } else if (SectionName == "name") {
       if (!IO.outputting())
         Section.reset(new WasmYAML::NameSection());
       sectionMapping(IO, *cast<WasmYAML::NameSection>(Section.get()));
     } else if (SectionName == "producers") {
       if (!IO.outputting())
         Section.reset(new WasmYAML::ProducersSection());
       sectionMapping(IO, *cast<WasmYAML::ProducersSection>(Section.get()));
+    } else if (SectionName == "target_features") {
+      if (!IO.outputting())
+        Section.reset(new WasmYAML::TargetFeaturesSection());
+      sectionMapping(IO, *cast<WasmYAML::TargetFeaturesSection>(Section.get()));
     } else {
       if (!IO.outputting())
         Section.reset(new WasmYAML::CustomSection(SectionName));
       sectionMapping(IO, *cast<WasmYAML::CustomSection>(Section.get()));
     }
     break;
   }
   case wasm::WASM_SEC_TYPE:

 }
 
 void MappingTraits<WasmYAML::ProducerEntry>::mapping(
     IO &IO, WasmYAML::ProducerEntry &ProducerEntry) {
   IO.mapRequired("Name", ProducerEntry.Name);
   IO.mapRequired("Version", ProducerEntry.Version);
 }
 
+void ScalarEnumerationTraits<WasmYAML::FeaturePolicyPrefix>::enumeration(
+    IO &IO, WasmYAML::FeaturePolicyPrefix &Kind) {
+#define ECase(X) IO.enumCase(Kind, #X, wasm::WASM_FEATURE_PREFIX_##X);
+  ECase(USED);
+  ECase(REQUIRED);
+  ECase(DISALLOWED);
+#undef ECase
+}
+
+void MappingTraits<WasmYAML::FeatureEntry>::mapping(
+    IO &IO, WasmYAML::FeatureEntry &FeatureEntry) {
+  IO.mapRequired("Prefix", FeatureEntry.Prefix);
+  IO.mapRequired("Name", FeatureEntry.Name);
+}
+
 void MappingTraits<WasmYAML::SegmentInfo>::mapping(
     IO &IO, WasmYAML::SegmentInfo &SegmentInfo) {
   IO.mapRequired("Index", SegmentInfo.Index);
   IO.mapRequired("Name", SegmentInfo.Name);
   IO.mapRequired("Alignment", SegmentInfo.Alignment);
   IO.mapRequired("Flags", SegmentInfo.Flags);
 }
 

llvm/lib/Target/WebAssembly/WebAssemblyAsmPrinter.h

public:
   }
 
   //===------------------------------------------------------------------===//
   // AsmPrinter Implementation.
   //===------------------------------------------------------------------===//
 
   void EmitEndOfAsmFile(Module &M) override;
   void EmitProducerInfo(Module &M);
+  void EmitTargetFeatures();
   void EmitJumpTableInfo() override;
   void EmitConstantPool() override;
   void EmitFunctionBodyStart() override;
   void EmitInstruction(const MachineInstr *MI) override;
   bool PrintAsmOperand(const MachineInstr *MI, unsigned OpNo,
                        unsigned AsmVariant, const char *ExtraCode,
                        raw_ostream &OS) override;
   bool PrintAsmMemoryOperand(const MachineInstr *MI, unsigned OpNo,

llvm/lib/Target/WebAssembly/WebAssemblyAsmPrinter.cpp

 #include "WebAssemblyAsmPrinter.h"
 #include "InstPrinter/WebAssemblyInstPrinter.h"
 #include "MCTargetDesc/WebAssemblyMCTargetDesc.h"
 #include "MCTargetDesc/WebAssemblyTargetStreamer.h"
 #include "WebAssembly.h"
 #include "WebAssemblyMCInstLower.h"
 #include "WebAssemblyMachineFunctionInfo.h"
 #include "WebAssemblyRegisterInfo.h"
+#include "WebAssemblyTargetMachine.h"
 #include "llvm/ADT/SmallSet.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/CodeGen/Analysis.h"
 #include "llvm/CodeGen/AsmPrinter.h"
 #include "llvm/CodeGen/MachineConstantPool.h"
 #include "llvm/CodeGen/MachineInstr.h"
 #include "llvm/CodeGen/MachineModuleInfoImpls.h"
 #include "llvm/IR/DataLayout.h"
for (const Metadata *MD : Named->operands()) {
           OutContext.getWasmSection(SectionName, SectionKind::getMetadata());
       OutStreamer->SwitchSection(MySection);
       OutStreamer->EmitBytes(Contents->getString());
       OutStreamer->PopSection();
     }
   }
 
   EmitProducerInfo(M);
+  EmitTargetFeatures();
 }
 
 void WebAssemblyAsmPrinter::EmitProducerInfo(Module &M) {
   llvm::SmallVector<std::pair<std::string, std::string>, 4> Languages;
   if (const NamedMDNode *Debug = M.getNamedMetadata("llvm.dbg.cu")) {
     llvm::SmallSet<StringRef, 4> SeenLanguages;
     for (size_t I = 0, E = Debug->getNumOperands(); I < E; ++I) {
       const auto *CU = cast<DICompileUnit>(Debug->getOperand(I));
for (auto &Producers : {std::make_pair("language", &Languages),
         OutStreamer->EmitULEB128IntValue(Producer.second.size());
         OutStreamer->EmitBytes(Producer.second);
       }
     }
     OutStreamer->PopSection();
   }
 }
 
+void WebAssemblyAsmPrinter::EmitTargetFeatures() {
+  static const std::pair<unsigned, const char *> FeaturePairs[] = {
+      {WebAssembly::FeatureAtomics, "atomics"},
+      {WebAssembly::FeatureBulkMemory, "bulk-memory"},
+      {WebAssembly::FeatureExceptionHandling, "exception-handling"},
+      {WebAssembly::FeatureNontrappingFPToInt, "nontrapping-fptoint"},
+      {WebAssembly::FeatureSignExt, "sign-ext"},
+      {WebAssembly::FeatureSIMD128, "simd128"},
+  };
+
+  struct FeatureEntry {
+    enum : uint8_t {
+      Used = '+',
+      Required = '=',
+      Disallowed = '-',
+    } Prefix;
+    StringRef Name;
+  };
+
+  FeatureBitset UsedFeatures =
+      static_cast<WebAssemblyTargetMachine &>(TM).getUsedFeatures();
+
+  // Calculate the features and linkage policies to emit
+  SmallVector<FeatureEntry, 4> EmittedFeatures;
+  for (auto &F : FeaturePairs) {
+    FeatureEntry Entry;
+    Entry.Name = F.second;
+    if (F.first == WebAssembly::FeatureAtomics) {
+      // "atomics" is special: code compiled without atomics may have had its
+      // atomics lowered to nonatomic operations. Such code would be dangerous
+      // to mix with proper atomics, so it is always Required or Disallowed.
+      Entry.Prefix = UsedFeatures[F.first] ? FeatureEntry::Required
+                                           : FeatureEntry::Disallowed;
+      EmittedFeatures.push_back(Entry);
+    } else {
+      // Other features are marked Used or not mentioned
+      if (UsedFeatures[F.first]) {
+        Entry.Prefix = FeatureEntry::Used;
+        EmittedFeatures.push_back(Entry);
+      }
+    }
+  }
+
+  // Emit features and linkage policies into the "target_features" section
+  MCSectionWasm *FeaturesSection = OutContext.getWasmSection(
+      ".custom_section.target_features", SectionKind::getMetadata());
+  OutStreamer->PushSection();
+  OutStreamer->SwitchSection(FeaturesSection);
+
+  OutStreamer->EmitULEB128IntValue(EmittedFeatures.size());
+  for (auto &F : EmittedFeatures) {
+    OutStreamer->EmitIntValue(F.Prefix, 1);
+    OutStreamer->EmitULEB128IntValue(F.Name.size());
+    OutStreamer->EmitBytes(F.Name);
+  }
+
+  OutStreamer->PopSection();
+}
+
 void WebAssemblyAsmPrinter::EmitConstantPool() {
   assert(MF->getConstantPool()->getConstants().empty() &&
          "WebAssembly disables constant pools");
 }
 
 void WebAssemblyAsmPrinter::EmitJumpTableInfo() {
   // Nothing to do; jump tables are incorporated into the instruction stream.
 }

llvm/test/MC/WebAssembly/array-fill.ll

 ; CHECK-NEXT:         Flags:           [ VISIBILITY_HIDDEN ]
 ; CHECK-NEXT:         Segment:         0
 ; CHECK-NEXT:         Size:            2
 ; CHECK-NEXT:     SegmentInfo:
 ; CHECK-NEXT:       - Index:           0
 ; CHECK-NEXT:         Name:            .data
 ; CHECK-NEXT:         Alignment:       0
 ; CHECK-NEXT:         Flags:           [ ]
+; CHECK-NEXT:   - Type:            CUSTOM
+; CHECK-NEXT:     Features:
+; CHECK-NEXT:       - Prefix:          DISALLOWED
+; CHECK-NEXT:         Name:            atomics
 ; CHECK-NEXT: ...

llvm/test/MC/WebAssembly/assembler-binary.ll

 ; CHECK-NEXT:         Name:            foo
 ; CHECK-NEXT:         Flags:           [  ]
 ; CHECK-NEXT:         Function:        1
 ; CHECK-NEXT:       - Index:           1
 ; CHECK-NEXT:         Kind:            FUNCTION
 ; CHECK-NEXT:         Name:            bar
 ; CHECK-NEXT:         Flags:           [ UNDEFINED ]
 ; CHECK-NEXT:         Function:        0
+; CHECK-NEXT:   - Type:            CUSTOM
+; CHECK-NEXT:     Features:
+; CHECK-NEXT:       - Prefix:          DISALLOWED
+; CHECK-NEXT:         Name:            atomics
 ; CHECK-NEXT: ...

llvm/test/MC/WebAssembly/bss.ll

 ; CHECK-NEXT:       - Index:           2
 ; CHECK-NEXT:         Name:            .bss.foo
 ; CHECK-NEXT:         Alignment:       0
 ; CHECK-NEXT:         Flags:           [ ]
 ; CHECK-NEXT:       - Index:           3
 ; CHECK-NEXT:         Name:            .bss.bar
 ; CHECK-NEXT:         Alignment:       0
 ; CHECK-NEXT:         Flags:           [ ]
+; CHECK-NEXT:   - Type:            CUSTOM
+; CHECK-NEXT:     Features:
+; CHECK-NEXT:       - Prefix:          DISALLOWED
+; CHECK-NEXT:         Name:            atomics
 ; CHECK-NEXT: ...

llvm/test/MC/WebAssembly/comdat.ll

 ; CHECK-NEXT:          - Kind:            FUNCTION
 ; CHECK-NEXT:            Index:           2
 ; CHECK-NEXT:        Name:            sharedComdat
 ; CHECK-NEXT:        Entries:
 ; CHECK-NEXT:          - Kind:            FUNCTION
 ; CHECK-NEXT:            Index:           3
 ; CHECK-NEXT:          - Kind:            DATA
 ; CHECK-NEXT:            Index:           0
+; CHECK-NEXT:   - Type:            CUSTOM
+; CHECK-NEXT:     Features:
+; CHECK-NEXT:       - Prefix:          DISALLOWED
+; CHECK-NEXT:         Name:            atomics
 ; CHECK-NEXT: ...

llvm/test/MC/WebAssembly/debug-info.ll

 ; CHECK-NEXT:    Name: reloc..debug_line
 ; CHECK-NEXT:  }
 ; CHECK-NEXT:  Section {
 ; CHECK-NEXT:    Type: CUSTOM (0x0)
 ; CHECK-NEXT:    Size: 77
 ; CHECK-NEXT:    Offset: 1021
 ; CHECK-NEXT:    Name: producers
 ; CHECK-NEXT:  }
+; CHECK-NEXT:  Section {
+; CHECK-NEXT:    Type: CUSTOM (0x0)
+; CHECK-NEXT:    Size: 10
+; CHECK-NEXT:    Offset: 1114
+; CHECK-NEXT:    Name: target_features
+; CHECK-NEXT:  }
 ; CHECK-NEXT:]
 ; CHECK-NEXT:Relocations [
 ; CHECK-NEXT:  Section (6) DATA {
 ; CHECK-NEXT:    0x6 R_WASM_MEMORY_ADDR_I32 myextern 0
 ; CHECK-NEXT:    0xF R_WASM_TABLE_INDEX_I32 f2
 ; CHECK-NEXT:  }
 ; CHECK-NEXT:  Section (9) .debug_info {
 ; CHECK-NEXT:    0x6 R_WASM_SECTION_OFFSET_I32 .debug_abbrev 0

llvm/test/MC/WebAssembly/explicit-sections.ll

 ; CHECK-NEXT:       - Index:           1
 ; CHECK-NEXT:         Name:            .sec1
 ; CHECK-NEXT:         Alignment:       3
 ; CHECK-NEXT:         Flags:           [ ]
 ; CHECK-NEXT:       - Index:           2
 ; CHECK-NEXT:         Name:            .sec2
 ; CHECK-NEXT:         Alignment:       3
 ; CHECK-NEXT:         Flags:           [ ]
+; CHECK-NEXT:   - Type:            CUSTOM
+; CHECK-NEXT:     Features:
+; CHECK-NEXT:       - Prefix:          DISALLOWED
+; CHECK-NEXT:         Name:            atomics
 ; CHECK-NEXT: ...

llvm/test/MC/WebAssembly/global-ctor-dtor.ll

 ; CHECK-NEXT:       - Priority: 42
 ; CHECK-NEXT:         Symbol: 9
 ; CHECK-NEXT:       - Priority: 42
 ; CHECK-NEXT:         Symbol: 2
 ; CHECK-NEXT:       - Priority: 65535
 ; CHECK-NEXT:         Symbol: 10
 ; CHECK-NEXT:       - Priority: 65535
 ; CHECK-NEXT:         Symbol: 7
+; CHECK-NEXT:   - Type:            CUSTOM
+; CHECK-NEXT:     Features:
+; CHECK-NEXT:       - Prefix:          DISALLOWED
+; CHECK-NEXT:         Name:            atomics
 ; CHECK-NEXT: ...

llvm/test/MC/WebAssembly/visibility.ll

 ; CHECK-NEXT:         Name:            defaultVis
 ; CHECK-NEXT:         Flags:           [  ]
 ; CHECK-NEXT:         Function:        0
 ; CHECK-NEXT:       - Index:           1
 ; CHECK-NEXT:         Kind:            FUNCTION
 ; CHECK-NEXT:         Name:            hiddenVis
 ; CHECK-NEXT:         Flags:           [ VISIBILITY_HIDDEN ]
 ; CHECK-NEXT:         Function:        1
+; CHECK-NEXT:   - Type:            CUSTOM
+; CHECK-NEXT:     Features:
+; CHECK-NEXT:       - Prefix:          DISALLOWED
+; CHECK-NEXT:         Name:            atomics
 ; CHECK-NEXT: ...

llvm/test/MC/WebAssembly/weak-alias.ll

 ; CHECK-NEXT:       - Index:           1
 ; CHECK-NEXT:         Name:            .data.direct_address
 ; CHECK-NEXT:         Alignment:       3
 ; CHECK-NEXT:         Flags:           [ ]
 ; CHECK-NEXT:       - Index:           2
 ; CHECK-NEXT:         Name:            .data.alias_address
 ; CHECK-NEXT:         Alignment:       3
 ; CHECK-NEXT:         Flags:           [ ]
+; CHECK-NEXT:   - Type:            CUSTOM
+; CHECK-NEXT:     Features:
+; CHECK-NEXT:       - Prefix:          DISALLOWED
+; CHECK-NEXT:         Name:            atomics
 ; CHECK-NEXT: ...
 
 ; CHECK-SYMS: SYMBOL TABLE:
 ; CHECK-SYMS-NEXT: 00000001 g     F CODE  .hidden foo
 ; CHECK-SYMS-NEXT: 00000006 g     F CODE  .hidden call_direct
 ; CHECK-SYMS-NEXT: 0000000f g     F CODE  .hidden call_alias
 ; CHECK-SYMS-NEXT: 00000001 gw    F CODE  .hidden foo_alias
 ; CHECK-SYMS-NEXT: 00000018 g     F CODE  .hidden call_direct_ptr
 ; CHECK-SYMS-NEXT: 00000008 g     O DATA  direct_address
 ; CHECK-SYMS-NEXT: 0000002b g     F CODE  .hidden call_alias_ptr
 ; CHECK-SYMS-NEXT: 00000010 g     O DATA  alias_address
 ; CHECK-SYMS-NEXT: 00000000 g     O DATA  bar
 ; CHECK-SYMS-NEXT: 00000000 gw    O DATA  .hidden bar_alias

llvm/test/MC/WebAssembly/weak.ll

 ; CHECK-NEXT:         Kind:            FUNCTION
 ; CHECK-NEXT:         Name:            weak_function
 ; CHECK-NEXT:         Flags:           [ BINDING_WEAK, VISIBILITY_HIDDEN ]
 ; CHECK-NEXT:         Function:        0
 ; CHECK-NEXT:       - Index:           1
 ; CHECK-NEXT:         Kind:            DATA
 ; CHECK-NEXT:         Name:            weak_external_data
 ; CHECK-NEXT:         Flags:           [ BINDING_WEAK, UNDEFINED ]
+; CHECK-NEXT:   - Type:            CUSTOM
+; CHECK-NEXT:     Features:
+; CHECK-NEXT:       - Prefix:          DISALLOWED
+; CHECK-NEXT:         Name:            atomics
 ; CHECK-NEXT: ...

llvm/tools/obj2yaml/wasm2yaml.cpp

if (WasmSec.Name == "dylink") {
     }
     for (auto &E : Info.SDKs) {
       WasmYAML::ProducerEntry Producer;
       Producer.Name = E.first;
       Producer.Version = E.second;
       ProducersSec->SDKs.push_back(Producer);
     }
     CustomSec = std::move(ProducersSec);
+  } else if (WasmSec.Name == "target_features") {
+    std::unique_ptr<WasmYAML::TargetFeaturesSection> TargetFeaturesSec =
+        make_unique<WasmYAML::TargetFeaturesSection>();
+    for (auto &E : Obj.getTargetFeatures()) {
+      WasmYAML::FeatureEntry Feature;
+      Feature.Prefix = E.Prefix;
+      Feature.Name = E.Name;
+      TargetFeaturesSec->Features.push_back(Feature);
+    }
+    CustomSec = std::move(TargetFeaturesSec);
   } else {
     CustomSec = make_unique<WasmYAML::CustomSection>(WasmSec.Name);
   }
   CustomSec->Payload = yaml::BinaryRef(WasmSec.Content);
   return CustomSec;
 }
 
 ErrorOr<WasmYAML::Object *> WasmDumper::dump() {

llvm/tools/yaml2obj/yaml2wasm.cpp

private:
   int writeSectionContent(raw_ostream &OS, WasmYAML::CodeSection &Section);
   int writeSectionContent(raw_ostream &OS, WasmYAML::DataSection &Section);
 
   // Custom section types
   int writeSectionContent(raw_ostream &OS, WasmYAML::DylinkSection &Section);
   int writeSectionContent(raw_ostream &OS, WasmYAML::NameSection &Section);
   int writeSectionContent(raw_ostream &OS, WasmYAML::LinkingSection &Section);
   int writeSectionContent(raw_ostream &OS, WasmYAML::ProducersSection &Section);
+  int writeSectionContent(raw_ostream &OS,
+                          WasmYAML::TargetFeaturesSection &Section);
   WasmYAML::Object &Obj;
   uint32_t NumImportedFunctions = 0;
   uint32_t NumImportedGlobals = 0;
   uint32_t NumImportedEvents = 0;
 };
 
 static int writeUint64(raw_ostream &OS, uint64_t Value) {
   char Data[sizeof(Value)];
for (auto &Entry : *Field.second) {
       writeStringRef(Entry.Name, OS);
       writeStringRef(Entry.Version, OS);
     }
   }
   return 0;
 }
 
 int WasmWriter::writeSectionContent(raw_ostream &OS,
+                                    WasmYAML::TargetFeaturesSection &Section) {
+  writeStringRef(Section.Name, OS);
+  encodeULEB128(Section.Features.size(), OS);
+  for (auto &E : Section.Features) {
+    writeUint8(OS, E.Prefix);
+    encodeULEB128(E.Name.size(), OS);
+    writeStringRef(E.Name, OS);
+  }
+  return 0;
+}
+
+int WasmWriter::writeSectionContent(raw_ostream &OS,
                                     WasmYAML::CustomSection &Section) {
   if (auto S = dyn_cast<WasmYAML::DylinkSection>(&Section)) {
     if (auto Err = writeSectionContent(OS, *S))
       return Err;
   } else if (auto S = dyn_cast<WasmYAML::NameSection>(&Section)) {
     if (auto Err = writeSectionContent(OS, *S))
       return Err;
   } else if (auto S = dyn_cast<WasmYAML::LinkingSection>(&Section)) {