Add initial support for WebAssembly binary format

[sbc100]

Summary

Initial support for wasm object file format

Support for the wasm binary format in the following tools:

• obj2yaml
• yaml2obj
• llvm-readobj
• llvm-objdump
• llvm-size

[dschuff]

include/llvm/Object/Wasm.h

11

implement->implements

12

Probably worth putting a link here to the design doc for the wasm binary format: https://github.com/WebAssembly/design/blob/master/BinaryEncoding.md (and later the text spec/standard once we have it)

36

We should implement classof so that isa/cast etc will work.

42

I guess most of the things in protected are the necessary overrides to implement ObjectFile. But do we need e.g. these data members there? Should they be private?

60

commented-out code.

70

These comments don't make sense without also having the one from SymbolRef

include/llvm/ObjectYAML/WasmYAML.h

42

WasmYAML

58

Commented.

include/llvm/Support/FileSystem.h

265

Do you know what the difference is between the various object vs executable file types is in this context? To the extent that it matters, we should probably start with focusing on executables, since that's well-specified, whereas we haven't got the details of what we want for object files nailed down (e.g. symbols, relocations, etc, including even how we will differentiate an object file from an executable).

lib/Object/WasmObjectFile.cpp

12

alphabetize includes.

23

What does R stand for? return value?

27

should this be return std::move(Err)?

32

Can any of these be static or anonymous namespace?

47

Does this function have any way to fail?

58

How do we handle running out of bytes/off the end of the buffer early? Or bogus data in section header? For that matter, how does decodeULEB128() fail?

81

use llvm_unreachable("message, e.g. not yet implemented") instead of assert(0)

263

I don't know if this string has to match an arch name (e.g. "wasm32" or "wasm64") but it may well end up being the case for wasm that we don't have different file formats for wasm32 vs wasm64. So if this is just arbitrary, for now it could just be "wasm".

268

This can be Triple::wasm32 for now.

[dschuff]

(in general i do think it's going in the right direction :)

[sbc100]

Add objdump support

[sbc100]

Remove some debugging

[sunfish]

Cool! This looks like a great start!

include/llvm/Object/Wasm.h

30

The latest spec changes call this "user defined".

[sunfish]

include/llvm/Object/Wasm.h

42

It might be a little more consistent with the code for other container formats to move these enums and magic numbers toinclude/llvm/Support/Wasm.h.

[sunfish]

include/llvm/Object/Wasm.h

27

Let's update this to 0xd too.

[sbc100]

Parse all non-code sections.

[sbc100]

include/llvm/Object/Wasm.h

27

I will probably wait until 0xd branched get merged then update this patch. Since this patch has now grown significantly do you think I should split it into smaller chunks? Perhaps I should land just the YAML<->wasm stuff with tests.. and leave the readobj stuff for a second patch?

include/llvm/Support/FileSystem.h

265

This is just an enumeration of different magic number types. I don't think we know at this point if we want more than one magic number.

lib/Object/WasmObjectFile.cpp

23

I guess so. Cargo culted. I gave it a more meaningful name.

47

Yes, it would be nice to not read past EOF in the cast of malformed file. I'm not sure how to do this since we don't konw how many bytes will be consumbed by decodeULEB128 but I'll figure it out. Added a TODO for now.

[sbc100]

Add data section handling
Remove un-needed opcodes

[sbc100]

• Update to 0xd

[sbc100]

• Add objdump support

[sbc100]

• Add support for global section

[sbc100]

• Add support for START and GLOBAL sections and add tests

All spec tests can now be round-tripped to YAML

[dschuff]

lib/Object/WasmObjectFile.cpp

441

#undef ECase?

test/tools/llvm-readobj/file-headers.test

374

Could be WASM-NEXT:

test/tools/llvm-readobj/sections.test

497

also WASM-NEXT

tools/llvm-readobj/WasmDumper.cpp

63

llvm_unreachable()

tools/obj2yaml/wasm2yaml.cpp

41

these new foo lines could be use auto*

tools/yaml2obj/yaml2wasm.cpp

44

could writeUint{32,64} be a template?

46

could you just use endian::byte_swap<uint64_t, little>(Value)?

[Bigcheese]

This patch is a bit too big. I'd prefer if you picked one of the tools and did that first. llvm-objdump is a good place to start.

lib/Object/WasmObjectFile.cpp

38–45

We already have these in Support/Endian.h

tools/llvm-readobj/MachODumper.cpp

1 ↗

(On Diff #76164)

This is an unrelated change.

tools/obj2yaml/coff2yaml.cpp

1 ↗

(On Diff #76164)

Unrelated change.

tools/obj2yaml/wasm2yaml.cpp

41

This, and the others, would be better as:

auto TypeSec = std::make_unique<WasmYAML::TypeSection>();
// Fill them up
S = std::move(TypeSec);

tools/yaml2obj/yaml2wasm.cpp

44

Support/Endian.h has write64le.

[sbc100]

• Fixes based on code review

[sbc100]

tools/yaml2obj/yaml2wasm.cpp

44

Switched to write64le / write32le

[sunfish]

lib/Object/WasmObjectFile.cpp

199

It'd be good to handle WASM_SEC_USER here too. If I understand the code here, we don't need to actually parse it, for now, similar to WASM_SEC_CODE above.

[sunfish]

lib/Object/WasmObjectFile.cpp

92

Here and at similar places elsewhere in this patch, object_error::parse_error would be more descriptive than object::invalid_file_type.

[sunfish]

Oops, that's parse_failed, rather than parse_error.

[sbc100]

Closing in favor of https://reviews.llvm.org/D26172

lib/Object/WasmObjectFile.cpp

92

Fixed in the smaller PR: https://reviews.llvm.org/D26172

199

Fixed in smaller the PR: https://reviews.llvm.org/D26172

include/llvm/Object/Binary.h

enum {
     ID_ELF64L, // ELF 64-bit, little endian
     ID_ELF64B, // ELF 64-bit, big endian
 
     ID_MachO32L, // MachO 32-bit, little endian
     ID_MachO32B, // MachO 32-bit, big endian
     ID_MachO64L, // MachO 64-bit, little endian
     ID_MachO64B, // MachO 64-bit, big endian
 
+    ID_Wasm,
+
     ID_EndObjects
   };
 
   static inline unsigned int getELFType(bool isLE, bool is64Bits) {
     if (isLE)
       return is64Bits ? ID_ELF64L : ID_ELF32L;
     else
       return is64Bits ? ID_ELF64B : ID_ELF32B;
public:
   bool isMachO() const {
     return TypeID >= ID_MachO32L && TypeID <= ID_MachO64B;
   }
 
   bool isCOFF() const {
     return TypeID == ID_COFF;
   }
 
+  bool isWasm() const {
+    return TypeID == ID_Wasm;
+  }
+
   bool isCOFFImportFile() const {
     return TypeID == ID_COFFImportFile;
   }
 
   bool isIR() const {
     return TypeID == ID_IR;
   }
 

include/llvm/Object/ObjectFile.h

 #include <cstring>
 
 namespace llvm {
 namespace object {
 
 class ObjectFile;
 class COFFObjectFile;
 class MachOObjectFile;
+class WasmObjectFile;
 
 class SymbolRef;
 class symbol_iterator;
 class SectionRef;
 typedef content_iterator<SectionRef> section_iterator;
 
 /// This is a value type class that represents a single relocation in the list
 /// of relocations in the object file.
public:
   static ErrorOr<std::unique_ptr<ObjectFile>>
   createELFObjectFile(MemoryBufferRef Object);
 
   static Expected<std::unique_ptr<MachOObjectFile>>
   createMachOObjectFile(MemoryBufferRef Object,
                         uint32_t UniversalCputype = 0,
                         uint32_t UniversalIndex = 0);
 
+  static Expected<std::unique_ptr<WasmObjectFile>>
+  createWasmObjectFile(MemoryBufferRef Object);
 };
 
 // Inline function definitions.
 inline SymbolRef::SymbolRef(DataRefImpl SymbolP, const ObjectFile *Owner)
     : BasicSymbolRef(SymbolP, Owner) {}
 
 inline Expected<StringRef> SymbolRef::getName() const {
   return getObject()->getSymbolName(getRawDataRefImpl());

include/llvm/Object/Wasm.h

+//===- WasmObjectFile.h - Wasm object file implementation -------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file declares the WasmObjectFile class, which implements the ObjectFile
+// interface for Wasm files.
+//
+// See: https://github.com/WebAssembly/design/blob/master/BinaryEncoding.md
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_OBJECT_WASM_H
+#define LLVM_OBJECT_WASM_H
+
+#include "llvm/Object/ObjectFile.h"
+#include "llvm/Support/Wasm.h"
+
+namespace llvm {
+namespace object {
+
+class WasmObjectFile : public ObjectFile {
+public:
+  WasmObjectFile(MemoryBufferRef Object, Error &Err);
+  const wasm::WasmObjectHeader &getHeader() const;
+  const wasm::WasmSection *getWasmSection(const SectionRef &Section) const;
+  static inline bool classof(const Binary *v) { return v->isWasm(); }
+
+  const std::vector<wasm::WasmSignature> types() const { return Signatures; }
+  const std::vector<uint32_t> functions() const { return Functions; }
+  const std::vector<wasm::WasmImport> imports() const { return Imports; }
+  const std::vector<wasm::WasmTable> tables() const { return Tables; }
+  const std::vector<wasm::WasmLimits> memories() const { return Memories; }
+  const std::vector<wasm::WasmGlobal> globals() const { return Globals; }
+  const std::vector<wasm::WasmExport> exports() const { return Exports; }
+  const std::vector<wasm::WasmElemSegment> elements() const { return ElemSegments; }
+  const std::vector<wasm::WasmDataSegment> dataSegments() const { return DataSegments; }
+  uint32_t startFunction() const { return StartFunction; }
+
+protected:
+  // Overrides from ObjectFile.
+  void moveSymbolNext(DataRefImpl &Symb) const override;
+
+  std::error_code printSymbolName(raw_ostream &OS,
+                                  DataRefImpl Symb) const override;
+
+  uint32_t getSymbolFlags(DataRefImpl Symb) const override;
+
+  basic_symbol_iterator symbol_begin_impl() const override;
+
+  basic_symbol_iterator symbol_end_impl() const override;
+  Expected<StringRef> getSymbolName(DataRefImpl Symb) const override;
+
+  Expected<uint64_t> getSymbolAddress(DataRefImpl Symb) const override;
+  uint64_t getSymbolValueImpl(DataRefImpl Symb) const override;
+  uint32_t getSymbolAlignment(DataRefImpl Symb) const override;
+  uint64_t getCommonSymbolSizeImpl(DataRefImpl Symb) const override;
+  Expected<SymbolRef::Type> getSymbolType(DataRefImpl Symb) const override;
+  Expected<section_iterator>
+  getSymbolSection(DataRefImpl Symb) const override;
+
+  // Overrides from SectionRef.
+  friend class SectionRef;
+  void moveSectionNext(DataRefImpl &Sec) const override;
+  std::error_code getSectionName(DataRefImpl Sec,
+                                         StringRef &Res) const override;
+  uint64_t getSectionAddress(DataRefImpl Sec) const override;
+  uint64_t getSectionSize(DataRefImpl Sec) const override;
+  std::error_code getSectionContents(DataRefImpl Sec,
+                                     StringRef &Res) const override;
+  uint64_t getSectionAlignment(DataRefImpl Sec) const override;
+  bool isSectionCompressed(DataRefImpl Sec) const override;
+  bool isSectionText(DataRefImpl Sec) const override;
+  bool isSectionData(DataRefImpl Sec) const override;
+  bool isSectionBSS(DataRefImpl Sec) const override;
+  bool isSectionVirtual(DataRefImpl Sec) const override;
+  bool isSectionBitcode(DataRefImpl Sec) const override;
+  relocation_iterator section_rel_begin(DataRefImpl Sec) const override;
+  relocation_iterator section_rel_end(DataRefImpl Sec) const override;
+  section_iterator getRelocatedSection(DataRefImpl Sec) const override;
+
+  // Overrides from RelocationRef.
+  friend class RelocationRef;
+  void moveRelocationNext(DataRefImpl &Rel) const override;
+  uint64_t getRelocationOffset(DataRefImpl Rel) const override;
+  symbol_iterator getRelocationSymbol(DataRefImpl Rel) const override;
+  uint64_t getRelocationType(DataRefImpl Rel) const override;
+  void getRelocationTypeName(DataRefImpl Rel,
+                             SmallVectorImpl<char> &Result) const override;
+
+  section_iterator section_begin() const override;
+  section_iterator section_end() const override;
+  uint8_t getBytesInAddress() const override;
+  StringRef getFileFormatName() const override;
+  unsigned getArch() const override;
+  SubtargetFeatures getFeatures() const override { return SubtargetFeatures(); }
+  bool isRelocatableObject() const override;
+
+private:
+  const uint8_t *getPtr(size_t Offset) const;
+  Error parseTypeSection(const uint8_t *Ptr, size_t Length);
+  Error parseImportSection(const uint8_t *Ptr, size_t Length);
+  Error parseFunctionSection(const uint8_t *Ptr, size_t Length);
+  Error parseTableSection(const uint8_t *Ptr, size_t Length);
+  Error parseMemorySection(const uint8_t *Ptr, size_t Length);
+  Error parseGlobalSection(const uint8_t *Ptr, size_t Length);
+  Error parseExportSection(const uint8_t *Ptr, size_t Length);
+  Error parseStartSection(const uint8_t *Ptr, size_t Length);
+  Error parseElemSection(const uint8_t *Ptr, size_t Length);
+  Error parseDataSection(const uint8_t *Ptr, size_t Length);
+
+  wasm::WasmObjectHeader Header;
+  std::vector<wasm::WasmSection> Sections;
+  std::vector<wasm::WasmSignature> Signatures;
+  std::vector<uint32_t> Functions;
+  std::vector<wasm::WasmTable> Tables;
+  std::vector<wasm::WasmLimits> Memories;
+  std::vector<wasm::WasmGlobal> Globals;
+  std::vector<wasm::WasmImport> Imports;
+  std::vector<wasm::WasmExport> Exports;
+  std::vector<wasm::WasmElemSegment> ElemSegments;
+  std::vector<wasm::WasmDataSegment> DataSegments;
+  uint32_t StartFunction;
+};
+
+}
+}
+
+#endif

include/llvm/ObjectYAML/ObjectYAML.h

 //===- ObjectYAML.h ---------------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_OBJECTYAML_OBJECTYAML_H
 #define LLVM_OBJECTYAML_OBJECTYAML_H
 
 #include "llvm/Support/YAMLTraits.h"
 #include "llvm/ObjectYAML/ELFYAML.h"
 #include "llvm/ObjectYAML/COFFYAML.h"
 #include "llvm/ObjectYAML/MachOYAML.h"
+#include "llvm/ObjectYAML/WasmYAML.h"
 
 namespace llvm {
 namespace yaml {
 
 struct YamlObjectFile {
   std::unique_ptr<ELFYAML::Object> Elf;
   std::unique_ptr<COFFYAML::Object> Coff;
   std::unique_ptr<MachOYAML::Object> MachO;
   std::unique_ptr<MachOYAML::UniversalBinary> FatMachO;
+  std::unique_ptr<WasmYAML::Object> Wasm;
 };
 
 template <> struct MappingTraits<YamlObjectFile> {
   static void mapping(IO &IO, YamlObjectFile &ObjectFile);
 };
 
 } // namespace yaml
 } // namespace llvm
 
 #endif

include/llvm/ObjectYAML/WasmYAML.h

+//===- WasmYAML.h - Wasm YAMLIO implementation ------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+///
+/// \file
+/// \brief This file declares classes for handling the YAML representation
+/// of wasm binaries.
+///
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_OBJECTYAML_WASMYAML_H
+#define LLVM_OBJECTYAML_WASMYAML_H
+
+#include "llvm/Support/Wasm.h"
+#include "llvm/ObjectYAML/YAML.h"
+
+namespace llvm {
+namespace WasmYAML {
+
+LLVM_YAML_STRONG_TYPEDEF(uint32_t, SectionType)
+LLVM_YAML_STRONG_TYPEDEF(int32_t, ValueType)
+LLVM_YAML_STRONG_TYPEDEF(int32_t, TableType)
+LLVM_YAML_STRONG_TYPEDEF(int32_t, SignatureForm)
+LLVM_YAML_STRONG_TYPEDEF(uint32_t, ExportKind)
+LLVM_YAML_STRONG_TYPEDEF(uint32_t, Opcode)
+
+struct FileHeader {
+  yaml::Hex32 Version;
+};
+
+struct Import {
+  StringRef Module;
+  StringRef Field;
+  ExportKind Kind;
+  yaml::Hex32 SigIndex;
+};
+
+struct Limits {
+  yaml::Hex32 Flags;
+  yaml::Hex32 Initial;
+  yaml::Hex32 Maximum;
+};
+
+struct Table {
+  TableType ElemType;
+  Limits TableLimits;
+};
+
+struct Export {
+  StringRef Name;
+  ExportKind Kind;
+  yaml::Hex32 Index;
+};
+
+struct ElemSegment {
+  uint32_t TableIndex;
+  wasm::WasmInitExpr Offset;
+  std::vector<uint32_t> Functions;
+};
+
+struct Global {
+  ValueType Type;
+  bool Mutable;
+  wasm::WasmInitExpr InitExpr;
+};
+
+struct DataSegment {
+  yaml::Hex32 Index;
+  wasm::WasmInitExpr Offset;
+  yaml::BinaryRef Content;
+};
+
+struct Signature {
+  Signature() : Form(wasm::WASM_TYPE_FUNC) {}
+
+  SignatureForm Form;
+  std::vector<ValueType> ParamTypes;
+  ValueType ReturnType;
+};
+
+struct Section {
+  Section(SectionType SecType) : Type(SecType) {}
+
+  SectionType Type;
+};
+
+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;
+};
+
+struct ImportSection : Section {
+  ImportSection() : Section(wasm::WASM_SEC_IMPORT) {}
+  static bool classof(const Section *S) {
+    return S->Type == wasm::WASM_SEC_IMPORT;
+  }
+
+  std::vector<Import> Imports;
+};
+
+struct FunctionSection : Section {
+  FunctionSection() : Section(wasm::WASM_SEC_FUNCTION) {}
+  static bool classof(const Section *S) {
+    return S->Type == wasm::WASM_SEC_FUNCTION;
+  }
+
+  std::vector<uint32_t> FunctionTypes;
+};
+
+struct TableSection : Section {
+  TableSection() : Section(wasm::WASM_SEC_TABLE) {}
+  static bool classof(const Section *S) {
+    return S->Type == wasm::WASM_SEC_TABLE;
+  }
+
+  std::vector<Table> Tables;
+};
+
+struct MemorySection : Section {
+  MemorySection() : Section(wasm::WASM_SEC_MEMORY) {}
+  static bool classof(const Section *S) {
+    return S->Type == wasm::WASM_SEC_MEMORY;
+  }
+
+  std::vector<Limits> Memories;
+};
+
+struct GlobalSection : Section {
+  GlobalSection() : Section(wasm::WASM_SEC_GLOBAL) {}
+  static bool classof(const Section *S) {
+    return S->Type == wasm::WASM_SEC_GLOBAL;
+  }
+
+  std::vector<Global> Globals;
+};
+
+struct ExportSection : Section {
+  ExportSection() : Section(wasm::WASM_SEC_EXPORT) {}
+  static bool classof(const Section *S) {
+    return S->Type == wasm::WASM_SEC_EXPORT;
+  }
+
+  std::vector<Export> Exports;
+};
+
+struct StartSection : Section {
+  StartSection() : Section(wasm::WASM_SEC_START) {}
+  static bool classof(const Section *S) {
+    return S->Type == wasm::WASM_SEC_START;
+  }
+
+  uint32_t StartFunction;
+};
+
+struct ElemSection : Section {
+  ElemSection() : Section(wasm::WASM_SEC_ELEM) {}
+  static bool classof(const Section *S) {
+    return S->Type == wasm::WASM_SEC_ELEM;
+  }
+
+  std::vector<ElemSegment> Segments;
+};
+
+struct CodeSection : Section {
+  CodeSection() : Section(wasm::WASM_SEC_CODE) {}
+  static bool classof(const Section *S) {
+    return S->Type == wasm::WASM_SEC_CODE;
+  }
+
+  yaml::BinaryRef Content;
+};
+
+struct DataSection : Section {
+  DataSection() : Section(wasm::WASM_SEC_DATA) {}
+  static bool classof(const Section *S) {
+    return S->Type == wasm::WASM_SEC_DATA;
+  }
+
+  std::vector<DataSegment> Segments;
+};
+
+struct Object {
+  FileHeader Header;
+  std::vector<std::unique_ptr<Section>> Sections;
+};
+
+} // end namespace WasmYAML
+} // end namespace llvm
+
+LLVM_YAML_IS_SEQUENCE_VECTOR(std::unique_ptr<llvm::WasmYAML::Section>)
+LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::WasmYAML::Signature)
+LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::WasmYAML::ValueType)
+LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::WasmYAML::Table)
+LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::WasmYAML::Import)
+LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::WasmYAML::Export)
+LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::WasmYAML::ElemSegment)
+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(uint32_t)
+
+namespace llvm {
+namespace yaml {
+
+template <>
+struct MappingTraits<WasmYAML::FileHeader> {
+  static void mapping(IO &IO, WasmYAML::FileHeader &FileHdr);
+};
+
+template <>
+struct MappingTraits<std::unique_ptr<WasmYAML::Section>> {
+  static void mapping(IO &IO, std::unique_ptr<WasmYAML::Section> &Section);
+};
+
+template <>
+struct MappingTraits<WasmYAML::Object> {
+  static void mapping(IO &IO, WasmYAML::Object &Object);
+};
+
+template <>
+struct MappingTraits<WasmYAML::Import> {
+  static void mapping(IO &IO, WasmYAML::Import &Import);
+};
+
+template <>
+struct MappingTraits<WasmYAML::Export> {
+  static void mapping(IO &IO, WasmYAML::Export &Export);
+};
+
+template <>
+struct MappingTraits<WasmYAML::Global> {
+  static void mapping(IO &IO, WasmYAML::Global &Global);
+};
+
+template <>
+struct ScalarEnumerationTraits<WasmYAML::SectionType> {
+  static void enumeration(IO &IO, WasmYAML::SectionType &Type);
+};
+
+template <>
+struct MappingTraits<WasmYAML::Signature> {
+  static void mapping(IO &IO, WasmYAML::Signature &Signature);
+};
+
+template <>
+struct MappingTraits<WasmYAML::Table> {
+  static void mapping(IO &IO, WasmYAML::Table &Table);
+};
+
+template <>
+struct MappingTraits<WasmYAML::Limits> {
+  static void mapping(IO &IO, WasmYAML::Limits &Limits);
+};
+
+template <>
+struct MappingTraits<wasm::WasmInitExpr> {
+  static void mapping(IO &IO, wasm::WasmInitExpr &Expr);
+};
+
+template <>
+struct MappingTraits<WasmYAML::DataSegment> {
+  static void mapping(IO &IO, WasmYAML::DataSegment &Segment);
+};
+
+template <>
+struct MappingTraits<WasmYAML::ElemSegment> {
+  static void mapping(IO &IO, WasmYAML::ElemSegment &Segment);
+};
+
+template <>
+struct ScalarEnumerationTraits<WasmYAML::ValueType> {
+  static void enumeration(IO &IO, WasmYAML::ValueType &Type);
+};
+
+template <>
+struct ScalarEnumerationTraits<WasmYAML::ExportKind> {
+  static void enumeration(IO &IO, WasmYAML::ExportKind &Kind);
+};
+
+template <>
+struct ScalarEnumerationTraits<WasmYAML::TableType> {
+  static void enumeration(IO &IO, WasmYAML::TableType &Type);
+};
+
+template <>
+struct ScalarEnumerationTraits<WasmYAML::Opcode> {
+  static void enumeration(IO &IO, WasmYAML::Opcode &Opcode);
+};
+
+} // end namespace yaml
+} // end namespace llvm
+
+#endif

include/llvm/Support/FileSystem.h

enum Impl {
     macho_bundle,             ///< Mach-O Bundle file
     macho_dynamically_linked_shared_lib_stub, ///< Mach-O Shared lib stub
     macho_dsym_companion,     ///< Mach-O dSYM companion file
     macho_kext_bundle,        ///< Mach-O kext bundle file
     macho_universal_binary,   ///< Mach-O universal binary
     coff_object,              ///< COFF object file
     coff_import_library,      ///< COFF import library
     pecoff_executable,        ///< PECOFF executable file
-    windows_resource          ///< Windows compiled resource file (.rc)
+    windows_resource,         ///< Windows compiled resource file (.rc)
+    wasm_object               ///< WebAssembly Object file
   };
 
   bool is_object() const {
     return V != unknown;
   }
 
   file_magic() : V(unknown) {}
   file_magic(Impl V) : V(V) {}

include/llvm/Support/Wasm.h

+//===- Wasm.h - Wasm object file format -------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file defines manifest constants for the wasm object file format.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_SUPPORT_WASM_H
+#define LLVM_SUPPORT_WASM_H
+
+#include "llvm/ADT/ArrayRef.h"
+
+namespace llvm {
+namespace wasm {
+
+const char WasmMagic[] = { '\0', 'a', 's', 'm' };
+const uint32_t WasmVersion = 0xd;
+
+struct WasmObjectHeader {
+  StringRef Magic;
+  uint32_t Version;
+};
+
+struct WasmSection {
+  uint32_t Type;
+  uint32_t Offset;
+  ArrayRef<uint8_t> Content;
+};
+
+struct WasmSignature {
+  std::vector<int32_t> ParamTypes;
+  int32_t ReturnType;
+};
+
+struct WasmImport {
+  StringRef Module;
+  StringRef Field;
+  uint32_t Kind;
+  uint32_t SigIndex;
+};
+
+struct WasmExport {
+  StringRef Name;
+  uint32_t Kind;
+  uint32_t Index;
+};
+
+struct WasmLimits {
+  uint32_t Flags;
+  uint32_t Initial;
+  uint32_t Maximum;
+};
+
+struct WasmTable {
+  int32_t ElemType;
+  WasmLimits Limits;
+};
+
+struct WasmInitExpr {
+  uint8_t Opcode;
+  union {
+    int32_t Int32;
+    int64_t Int64;
+    int32_t Float32;
+    int64_t Float64;
+    uint32_t Global;
+  } Value;
+};
+
+struct WasmGlobal {
+  int32_t Type;
+  bool Mutable;
+  WasmInitExpr InitExpr;
+};
+
+struct WasmDataSegment {
+  uint32_t Index;
+  WasmInitExpr Offset;
+  ArrayRef<uint8_t> Content;
+};
+
+struct WasmElemSegment {
+  uint32_t TableIndex;
+  WasmInitExpr Offset;
+  std::vector<uint32_t> Functions;
+};
+
+enum : unsigned {
+  WASM_SEC_USER = 0,
+  WASM_SEC_TYPE = 1,
+  WASM_SEC_IMPORT = 2,
+  WASM_SEC_FUNCTION = 3,
+  WASM_SEC_TABLE = 4,
+  WASM_SEC_MEMORY = 5,
+  WASM_SEC_GLOBAL = 6,
+  WASM_SEC_EXPORT = 7,
+  WASM_SEC_START = 8,
+  WASM_SEC_ELEM = 9,
+  WASM_SEC_CODE = 10,
+  WASM_SEC_DATA = 11
+};
+
+enum : signed {
+  WASM_TYPE_I32 = -0x01,
+  WASM_TYPE_I64 = -0x02,
+  WASM_TYPE_F32 = -0x03,
+  WASM_TYPE_F64 = -0x04,
+  WASM_TYPE_ANYFUNC = -0x10,
+  WASM_TYPE_FUNC = -0x20,
+  WASM_TYPE_VOID = -0x40,
+};
+
+enum : unsigned {
+  WASM_OP_END = 0x0b,
+  WASM_OP_I32_CONST = 0x41,
+  WASM_OP_I64_CONST = 0x42,
+  WASM_OP_F32_CONST = 0x43,
+  WASM_OP_F64_CONST = 0x44,
+  WASM_OP_GET_GLOBAL = 0x23,
+};
+
+enum : unsigned {
+  WASM_LIMITS_FLAG_HAS_MAX = 0x1,
+};
+
+enum : unsigned {
+  WASM_EXTERNAL_FUNC = 0,
+  WASM_EXTERNAL_TABLE = 1,
+  WASM_EXTERNAL_MEMORY = 2,
+  WASM_EXTERNAL_GLOBAL = 3,
+};
+
+}  // end namespace wasm
+}  // end namespace llvm
+
+#endif

lib/Object/Binary.cpp

switch (Type) {
     case sys::fs::file_magic::macho_bundle:
     case sys::fs::file_magic::macho_dynamically_linked_shared_lib_stub:
     case sys::fs::file_magic::macho_dsym_companion:
     case sys::fs::file_magic::macho_kext_bundle:
     case sys::fs::file_magic::coff_object:
     case sys::fs::file_magic::coff_import_library:
     case sys::fs::file_magic::pecoff_executable:
     case sys::fs::file_magic::bitcode:
+    case sys::fs::file_magic::wasm_object:
       return ObjectFile::createSymbolicFile(Buffer, Type, Context);
     case sys::fs::file_magic::macho_universal_binary:
       return MachOUniversalBinary::create(Buffer);
     case sys::fs::file_magic::unknown:
     case sys::fs::file_magic::windows_resource:
       // Unrecognized object file format.
       return errorCodeToError(object_error::invalid_file_type);
   }

lib/Object/CMakeLists.txt

add_llvm_library(LLVMObject
   MachOObjectFile.cpp
   MachOUniversal.cpp
   ModuleSummaryIndexObjectFile.cpp
   Object.cpp
   ObjectFile.cpp
   RecordStreamer.cpp
   SymbolicFile.cpp
   SymbolSize.cpp
+  WasmObjectFile.cpp
 
   ADDITIONAL_HEADER_DIRS
   ${LLVM_MAIN_INCLUDE_DIR}/llvm/Object
 
   DEPENDS
   intrinsics_gen
   )

lib/Object/ObjectFile.cpp

 //===- ObjectFile.cpp - File format independent object file -----*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file defines a file format independent ObjectFile class.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/Object/COFF.h"
 #include "llvm/Object/MachO.h"
+#include "llvm/Object/Wasm.h"
 #include "llvm/Object/ObjectFile.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/raw_ostream.h"
 #include <system_error>
 
 using namespace llvm;
ObjectFile::createObjectFile(MemoryBufferRef Object, sys::fs::file_magic Type) {
   case sys::fs::file_magic::macho_dynamically_linked_shared_lib_stub:
   case sys::fs::file_magic::macho_dsym_companion:
   case sys::fs::file_magic::macho_kext_bundle:
     return createMachOObjectFile(Object);
   case sys::fs::file_magic::coff_object:
   case sys::fs::file_magic::coff_import_library:
   case sys::fs::file_magic::pecoff_executable:
     return errorOrToExpected(createCOFFObjectFile(Object));
+  case sys::fs::file_magic::wasm_object:
+    return createWasmObjectFile(Object);
   }
   llvm_unreachable("Unexpected Object File Type");
 }
 
 Expected<OwningBinary<ObjectFile>>
 ObjectFile::createObjectFile(StringRef ObjectPath) {
   ErrorOr<std::unique_ptr<MemoryBuffer>> FileOrErr =
       MemoryBuffer::getFile(ObjectPath);

lib/Object/SymbolicFile.cpp

Expected<std::unique_ptr<SymbolicFile>> SymbolicFile::createSymbolicFile(
   case sys::fs::file_magic::macho_preload_executable:
   case sys::fs::file_magic::macho_dynamically_linked_shared_lib:
   case sys::fs::file_magic::macho_dynamic_linker:
   case sys::fs::file_magic::macho_bundle:
   case sys::fs::file_magic::macho_dynamically_linked_shared_lib_stub:
   case sys::fs::file_magic::macho_dsym_companion:
   case sys::fs::file_magic::macho_kext_bundle:
   case sys::fs::file_magic::pecoff_executable:
+  case sys::fs::file_magic::wasm_object:
     return ObjectFile::createObjectFile(Object, Type);
   case sys::fs::file_magic::coff_import_library:
     return std::unique_ptr<SymbolicFile>(new COFFImportFile(Object));
   case sys::fs::file_magic::elf_relocatable:
   case sys::fs::file_magic::macho_object:
   case sys::fs::file_magic::coff_object: {
     Expected<std::unique_ptr<ObjectFile>> Obj =
         ObjectFile::createObjectFile(Object, Type);

lib/Object/WasmObjectFile.cpp

+//===- WasmObjectFile.cpp - Wasm object file implementation -----*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "llvm/Object/Wasm.h"
+#include "llvm/Support/Endian.h"
+#include "llvm/Support/LEB128.h"
+
+#include <iostream>
+
+namespace llvm {
+namespace object {
+
+Expected<std::unique_ptr<WasmObjectFile>>
+ObjectFile::createWasmObjectFile(MemoryBufferRef Buffer) {
+  Error Err;
+  std::unique_ptr<WasmObjectFile> ObjectFile;
+
+  ObjectFile.reset(new WasmObjectFile(Buffer, Err));
+  if (Err)
+     return std::move(Err);
+
+  return std::move(ObjectFile);
+}
+
+namespace {
+
+uint8_t readUint8(const uint8_t *&Ptr) {
+  return *Ptr++;
+}
+
+uint32_t readUint32(const uint8_t *&Ptr) {
+  uint32_t Result = support::endian::read32le(Ptr);
+  Ptr += sizeof(Result);
+  return Result;
+}
+
+int32_t readFloat32(const uint8_t *&Ptr) {
+  int32_t Result = 0;
+  memcpy(&Result, Ptr, sizeof(Result));
+  Ptr += sizeof(Result);
+  return Result;
+}
+
+int64_t readFloat64(const uint8_t *&Ptr) {
+  int64_t Result = 0;
+  memcpy(&Result, Ptr, sizeof(Result));
+  Ptr += sizeof(Result);
+  return Result;
+}
+
+uint64_t readULEB128(const uint8_t *&Ptr) {
+  unsigned Count;
+  uint64_t Result = decodeULEB128(Ptr, &Count);
+  Ptr += Count;
+  return Result;
+}
+
+int64_t readLEB128(const uint8_t *&Ptr) {
+  unsigned Count;
+  uint64_t Result = decodeSLEB128(Ptr, &Count);
+  Ptr += Count;
+  return Result;
+}
+
+Error readInitExpr(wasm::WasmInitExpr &Expr, const uint8_t *&Ptr) {
+  Expr.Opcode = readUint8(Ptr);
+
+  switch (Expr.Opcode) {
+    case wasm::WASM_OP_I32_CONST:
+      Expr.Value.Int32 = readLEB128(Ptr);
+      break;
+    case wasm::WASM_OP_I64_CONST:
+      Expr.Value.Int64 = readLEB128(Ptr);
+      break;
+    case wasm::WASM_OP_F32_CONST:
+      Expr.Value.Float32 = readFloat32(Ptr);
+      break;
+    case wasm::WASM_OP_F64_CONST:
+      Expr.Value.Float64 = readFloat64(Ptr);
+      break;
+    case wasm::WASM_OP_GET_GLOBAL:
+      Expr.Value.Global = readULEB128(Ptr);
+      break;
+    default:
+      return make_error<GenericBinaryError>("Invalid opcode in init_expr",
+          object_error::invalid_file_type);
+  }
+
+  uint8_t EndOpcode = readUint8(Ptr);
+  if (EndOpcode != wasm::WASM_OP_END) {
+    return make_error<GenericBinaryError>("Invalid init_expr",
+                     object_error::invalid_file_type);
+  }
+  return Error::success();
+}
+
+static wasm::WasmLimits readLimits(const uint8_t *&Ptr) {
+  wasm::WasmLimits Result;
+  Result.Flags = readULEB128(Ptr);
+  Result.Initial = readULEB128(Ptr);
+  if (Result.Flags & wasm::WASM_LIMITS_FLAG_HAS_MAX)
+    Result.Maximum = readULEB128(Ptr);
+  return Result;
+}
+
+StringRef readString(const uint8_t *&Ptr) {
+  uint32_t StringLen = readULEB128(Ptr);
+  StringRef Return = StringRef(reinterpret_cast<const char*>(Ptr), StringLen);
+  Ptr += StringLen;
+  return Return;
+}
+
+Error readSection(wasm::WasmSection &Section, const uint8_t *&Ptr,
+                  const uint8_t *Start) {
+  // TODO(sbc): Avoid reading past EOF in the case of malformed files.
+  Section.Offset = Ptr - Start;
+  Section.Type = readULEB128(Ptr);
+  uint32_t Size = readULEB128(Ptr);
+  Section.Content = ArrayRef<uint8_t>(Ptr, Size);
+  Ptr += Size;
+  return Error::success();
+}
+
+}
+
+WasmObjectFile::WasmObjectFile(MemoryBufferRef Buffer, Error &Err)
+    : ObjectFile(Binary::ID_Wasm, Buffer), StartFunction(-1) {
+  ErrorAsOutParameter ErrAsOutParam(&Err);
+  Header.Magic = getData().substr(0, 4);
+  if (Header.Magic != StringRef("\0asm", 4)) {
+    Err = make_error<GenericBinaryError>("Bad magic number",
+                     object_error::invalid_file_type);
+    return;
+  }
+  const uint8_t* Ptr = getPtr(4);
+  Header.Version = readUint32(Ptr);
+  if (Header.Version != wasm::WasmVersion) {
+    Err = make_error<GenericBinaryError>("Bad version number",
+                     object_error::invalid_file_type);
+    return;
+  }
+
+  const uint8_t* Eof = getPtr(getData().size());
+  wasm::WasmSection Sec;
+  while (Ptr < Eof) {
+    if ((Err = readSection(Sec, Ptr, getPtr(0))))
+      return;
+    Sections.push_back(Sec);
+    switch (Sec.Type) {
+      case wasm::WASM_SEC_TYPE:
+        if ((Err = parseTypeSection(Sec.Content.data(), Sec.Content.size())))
+          return;
+        break;
+      case wasm::WASM_SEC_IMPORT:
+        if ((Err = parseImportSection(Sec.Content.data(), Sec.Content.size())))
+          return;
+        break;
+      case wasm::WASM_SEC_FUNCTION:
+        if ((Err = parseFunctionSection(Sec.Content.data(), Sec.Content.size())))
+          return;
+        break;
+      case wasm::WASM_SEC_TABLE:
+        if ((Err = parseTableSection(Sec.Content.data(), Sec.Content.size())))
+          return;
+        break;
+      case wasm::WASM_SEC_MEMORY:
+        if ((Err = parseMemorySection(Sec.Content.data(), Sec.Content.size())))
+          return;
+        break;
+      case wasm::WASM_SEC_GLOBAL:
+        if ((Err = parseGlobalSection(Sec.Content.data(), Sec.Content.size())))
+          return;
+        break;
+      case wasm::WASM_SEC_EXPORT:
+        if ((Err = parseExportSection(Sec.Content.data(), Sec.Content.size())))
+          return;
+        break;
+      case wasm::WASM_SEC_START:
+        if ((Err = parseStartSection(Sec.Content.data(), Sec.Content.size())))
+          return;
+        break;
+      case wasm::WASM_SEC_ELEM:
+        if ((Err = parseElemSection(Sec.Content.data(), Sec.Content.size())))
+          return;
+        break;
+      case wasm::WASM_SEC_CODE:
+        // Nothing to parse, we just store the raw binary content
+        break;
+      case wasm::WASM_SEC_DATA:
+        if ((Err = parseDataSection(Sec.Content.data(), Sec.Content.size())))
+          return;
+        break;
+      default:
+        Err = make_error<GenericBinaryError>("Bad section type",
+                         object_error::invalid_file_type);
+        return;
+    }
+  }
+}
+
+Error WasmObjectFile::parseTypeSection(const uint8_t *Ptr, size_t Length) {
+  uint32_t Count = readULEB128(Ptr);
+  while (Count--) {
+    wasm::WasmSignature Sig;
+    Sig.ReturnType = wasm::WASM_TYPE_VOID;
+    int32_t Form = readLEB128(Ptr);
+    if (Form != wasm::WASM_TYPE_FUNC) {
+      return make_error<GenericBinaryError>("Invalid signature type",
+                        object_error::invalid_file_type);
+    }
+    uint32_t ParamCount = readULEB128(Ptr);
+    while (ParamCount--) {
+      uint32_t ParamType = readLEB128(Ptr);
+      Sig.ParamTypes.push_back(ParamType);
+    }
+    uint32_t ReturnCount = readULEB128(Ptr);
+    if (ReturnCount) {
+      if (ReturnCount != 1) {
+        return make_error<GenericBinaryError>(
+            "Multiple return types not supported",
+            object_error::invalid_file_type);
+      }
+      Sig.ReturnType = readLEB128(Ptr);
+    }
+    Signatures.push_back(Sig);
+  }
+  return Error::success();
+}
+
+Error WasmObjectFile::parseImportSection(const uint8_t *Ptr, size_t Length) {
+  uint32_t Count = readULEB128(Ptr);
+  while (Count--) {
+    wasm::WasmImport Im;
+    Im.Module = readString(Ptr);
+    Im.Field = readString(Ptr);
+    Im.Kind = readULEB128(Ptr);
+    Im.SigIndex = readULEB128(Ptr);
+    Imports.push_back(Im);
+  }
+  return Error::success();
+}
+
+Error WasmObjectFile::parseFunctionSection(const uint8_t *Ptr, size_t Length) {
+  uint32_t Count = readULEB128(Ptr);
+  while (Count--) {
+    Functions.push_back(readULEB128(Ptr));
+  }
+  return Error::success();
+}
+
+Error WasmObjectFile::parseTableSection(const uint8_t *Ptr, size_t Length) {
+  uint32_t Count = readULEB128(Ptr);
+  while (Count--) {
+    wasm::WasmTable Table;
+    Table.ElemType = readLEB128(Ptr);
+    if (Table.ElemType != wasm::WASM_TYPE_ANYFUNC) {
+        return make_error<GenericBinaryError>("Invalid table element type",
+            object_error::invalid_file_type);
+    }
+    Table.Limits = readLimits(Ptr);
+    Tables.push_back(Table);
+  }
+  return Error::success();
+}
+
+Error WasmObjectFile::parseMemorySection(const uint8_t *Ptr, size_t Length) {
+  uint32_t Count = readULEB128(Ptr);
+  while (Count--) {
+    Memories.push_back(readLimits(Ptr));
+  }
+  return Error::success();
+}
+
+Error WasmObjectFile::parseGlobalSection(const uint8_t *Ptr, size_t Length) {
+  uint32_t Count = readULEB128(Ptr);
+  while (Count--) {
+    wasm::WasmGlobal Global;
+    Global.Type = readLEB128(Ptr);
+    Global.Mutable = readUint8(Ptr);
+    size_t offset = Ptr - getPtr(0);
+    if (Error Err = readInitExpr(Global.InitExpr, Ptr)) {
+      offset = Ptr - getPtr(0);
+      return Err;
+    }
+    Globals.push_back(Global);
+  }
+  return Error::success();
+}
+
+Error WasmObjectFile::parseExportSection(const uint8_t *Ptr, size_t Length) {
+  uint32_t Count = readULEB128(Ptr);
+  while (Count--) {
+    wasm::WasmExport Ex;
+    Ex.Name = readString(Ptr);
+    Ex.Kind = readULEB128(Ptr);
+    Ex.Index = readULEB128(Ptr);
+    Exports.push_back(Ex);
+  }
+  return Error::success();
+}
+
+Error WasmObjectFile::parseStartSection(const uint8_t *Ptr, size_t Length) {
+  StartFunction = readULEB128(Ptr);
+  return Error::success();
+}
+
+Error WasmObjectFile::parseElemSection(const uint8_t *Ptr, size_t Length) {
+  uint32_t SegCount = readULEB128(Ptr);
+  while (SegCount--) {
+    wasm::WasmElemSegment Segment;
+    Segment.TableIndex = readULEB128(Ptr);
+    if (Segment.TableIndex != 0) {
+       return make_error<GenericBinaryError>("Invalid TableIndex",
+            object_error::invalid_file_type);
+    }
+    if (Error Err = readInitExpr(Segment.Offset, Ptr))
+      return Err;
+    int NumElems = readULEB128(Ptr);
+    while (NumElems--) {
+      Segment.Functions.push_back(readULEB128(Ptr));
+    }
+    ElemSegments.push_back(Segment);
+  }
+  return Error::success();
+}
+
+Error WasmObjectFile::parseDataSection(const uint8_t *Ptr, size_t Length) {
+  uint32_t SegCount = readULEB128(Ptr);
+  while (SegCount--) {
+    wasm::WasmDataSegment Segment;
+    Segment.Index = readULEB128(Ptr);
+    if (Error Err = readInitExpr(Segment.Offset, Ptr))
+        return Err;
+    uint32_t Size = readULEB128(Ptr);
+    Segment.Content = ArrayRef<uint8_t>(Ptr, Size);
+    Ptr += Size;
+    DataSegments.push_back(Segment);
+  }
+  return Error::success();
+}
+
+const uint8_t *WasmObjectFile::getPtr(size_t Offset) const {
+  return reinterpret_cast<const uint8_t *>(getData().substr(Offset, 1).data());
+}
+
+const wasm::WasmObjectHeader& WasmObjectFile::getHeader() const {
+  return Header;
+}
+
+void WasmObjectFile::moveSymbolNext(DataRefImpl &Symb) const {
+  llvm_unreachable("not yet implemented");
+}
+
+std::error_code WasmObjectFile::printSymbolName(raw_ostream &OS,
+                                          DataRefImpl Symb) const {
+  llvm_unreachable("not yet implemented");
+  return object_error::invalid_file_type;
+}
+
+uint32_t WasmObjectFile::getSymbolFlags(DataRefImpl Symb) const {
+  llvm_unreachable("not yet implemented");
+  return 0;
+}
+
+basic_symbol_iterator WasmObjectFile::symbol_begin_impl() const {
+  return BasicSymbolRef(DataRefImpl(), this);
+}
+
+basic_symbol_iterator WasmObjectFile::symbol_end_impl() const {
+  return BasicSymbolRef(DataRefImpl(), this);
+}
+
+Expected<StringRef> WasmObjectFile::getSymbolName(DataRefImpl Symb) const {
+  llvm_unreachable("not yet implemented");
+  return errorCodeToError(object_error::invalid_file_type);
+}
+
+Expected<uint64_t> WasmObjectFile::getSymbolAddress(DataRefImpl Symb) const {
+  llvm_unreachable("not yet implemented");
+  return errorCodeToError(object_error::invalid_file_type);
+}
+
+uint64_t WasmObjectFile::getSymbolValueImpl(DataRefImpl Symb) const {
+  llvm_unreachable("not yet implemented");
+  return 0;
+}
+
+uint32_t WasmObjectFile::getSymbolAlignment(DataRefImpl Symb) const {
+  llvm_unreachable("not yet implemented");
+  return 0;
+}
+
+uint64_t WasmObjectFile::getCommonSymbolSizeImpl(DataRefImpl Symb) const {
+  llvm_unreachable("not yet implemented");
+  return 0;
+}
+
+Expected<SymbolRef::Type>
+WasmObjectFile::getSymbolType(DataRefImpl Symb) const {
+  llvm_unreachable("not yet implemented");
+  return errorCodeToError(object_error::invalid_file_type);
+}
+
+Expected<section_iterator>
+WasmObjectFile::getSymbolSection(DataRefImpl Symb) const {
+  llvm_unreachable("not yet implemented");
+  return errorCodeToError(object_error::invalid_file_type);
+}
+
+void WasmObjectFile::moveSectionNext(DataRefImpl &Sec) const {
+  Sec.d.a++;
+}
+
+std::error_code WasmObjectFile::getSectionName(DataRefImpl Sec,
+                                               StringRef &Res) const {
+  const wasm::WasmSection& S = Sections[Sec.d.a];
+#define ECase(X) case wasm::WASM_SEC_##X: Res = #X; break
+  switch (S.Type) {
+    ECase(USER);
+    ECase(TYPE);
+    ECase(IMPORT);
+    ECase(FUNCTION);
+    ECase(TABLE);
+    ECase(MEMORY);
+    ECase(GLOBAL);
+    ECase(EXPORT);
+    ECase(START);
+    ECase(ELEM);
+    ECase(CODE);
+    ECase(DATA);
+    default:
+      return object_error::invalid_file_type;
+  }
+#undef ECase
+  return std::error_code();
+}
+
+uint64_t WasmObjectFile::getSectionAddress(DataRefImpl Sec) const {
+  return 0;
+}
+
+uint64_t WasmObjectFile::getSectionSize(DataRefImpl Sec) const {
+  const wasm::WasmSection& S = Sections[Sec.d.a];
+  return S.Content.size();
+}
+
+std::error_code WasmObjectFile::getSectionContents(DataRefImpl Sec,
+                                                   StringRef &Res) const {
+  const wasm::WasmSection& S = Sections[Sec.d.a];
+  Res = StringRef(reinterpret_cast<const char*>(S.Content.data()),
+      S.Content.size());
+  return std::error_code();
+}
+
+uint64_t WasmObjectFile::getSectionAlignment(DataRefImpl Sec) const {
+  return 1;
+}
+
+bool WasmObjectFile::isSectionCompressed(DataRefImpl Sec) const {
+  return false;
+}
+
+bool WasmObjectFile::isSectionText(DataRefImpl Sec) const {
+  const wasm::WasmSection& S = Sections[Sec.d.a];
+  return S.Type == wasm::WASM_SEC_CODE;
+}
+
+bool WasmObjectFile::isSectionData(DataRefImpl Sec) const {
+  const wasm::WasmSection& S = Sections[Sec.d.a];
+  return S.Type == wasm::WASM_SEC_DATA;
+}
+
+bool WasmObjectFile::isSectionBSS(DataRefImpl Sec) const {
+  return false;
+}
+
+bool WasmObjectFile::isSectionVirtual(DataRefImpl Sec) const {
+  return false;
+}
+
+bool WasmObjectFile::isSectionBitcode(DataRefImpl Sec) const {
+  return false;
+}
+
+relocation_iterator WasmObjectFile::section_rel_begin(DataRefImpl Sec) const {
+  llvm_unreachable("not yet implemented");
+  RelocationRef Rel;
+  return relocation_iterator(Rel);
+}
+
+relocation_iterator WasmObjectFile::section_rel_end(DataRefImpl Sec) const {
+  llvm_unreachable("not yet implemented");
+  RelocationRef Rel;
+  return relocation_iterator(Rel);
+}
+
+section_iterator WasmObjectFile::getRelocatedSection(DataRefImpl Sec) const {
+  llvm_unreachable("not yet implemented");
+  SectionRef Ref;
+  return section_iterator(Ref);
+}
+
+void WasmObjectFile::moveRelocationNext(DataRefImpl &Rel) const {
+  llvm_unreachable("not yet implemented");
+}
+
+uint64_t WasmObjectFile::getRelocationOffset(DataRefImpl Rel) const {
+  llvm_unreachable("not yet implemented");
+  return 0;
+}
+
+symbol_iterator WasmObjectFile::getRelocationSymbol(DataRefImpl Rel) const {
+  llvm_unreachable("not yet implemented");
+  SymbolRef Ref;
+  return symbol_iterator(Ref);
+}
+
+uint64_t WasmObjectFile::getRelocationType(DataRefImpl Rel) const {
+  llvm_unreachable("not yet implemented");
+  return 0;
+}
+
+void WasmObjectFile::getRelocationTypeName(DataRefImpl Rel,
+                                           SmallVectorImpl<char> &Result) const {
+  llvm_unreachable("not yet implemented");
+}
+
+section_iterator WasmObjectFile::section_begin() const {
+  DataRefImpl Ref;
+  Ref.d.a = 0;
+  return section_iterator(SectionRef(Ref, this));
+}
+
+section_iterator WasmObjectFile::section_end() const {
+  DataRefImpl Ref;
+  Ref.d.a = Sections.size();
+  return section_iterator(SectionRef(Ref, this));
+}
+
+uint8_t WasmObjectFile::getBytesInAddress() const {
+  return 4;
+}
+
+StringRef WasmObjectFile::getFileFormatName() const {
+  return "WASM";
+}
+
+unsigned WasmObjectFile::getArch() const {
+  return Triple::wasm32;
+}
+
+bool WasmObjectFile::isRelocatableObject() const {
+  return false;
+}
+
+const wasm::WasmSection *
+WasmObjectFile::getWasmSection(const SectionRef &Section) const {
+  return &Sections[Section.getRawDataRefImpl().d.a];
+}
+
+} // end namespace object
+} // end namespace llvm

lib/ObjectYAML/CMakeLists.txt

 add_llvm_library(LLVMObjectYAML
   YAML.cpp
   COFFYAML.cpp
   ELFYAML.cpp
   MachOYAML.cpp
   ObjectYAML.cpp
+  WasmYAML.cpp
   )

lib/ObjectYAML/ObjectYAML.cpp

if (IO.mapTag("!ELF")) {
       MappingTraits<COFFYAML::Object>::mapping(IO, *ObjectFile.Coff);
     } else if (IO.mapTag("!mach-o")) {
       ObjectFile.MachO.reset(new MachOYAML::Object());
       MappingTraits<MachOYAML::Object>::mapping(IO, *ObjectFile.MachO);
     } else if (IO.mapTag("!fat-mach-o")) {
       ObjectFile.FatMachO.reset(new MachOYAML::UniversalBinary());
       MappingTraits<MachOYAML::UniversalBinary>::mapping(IO,
                                                          *ObjectFile.FatMachO);
+    } else if (IO.mapTag("!WASM")) {
+      ObjectFile.Wasm.reset(new WasmYAML::Object());
+      MappingTraits<WasmYAML::Object>::mapping(IO, *ObjectFile.Wasm);
     } else {
       Input &In = (Input &)IO;
       std::string Tag = In.getCurrentNode()->getRawTag();
       if (Tag.empty())
         IO.setError("YAML Object File missing document type tag!");
       else
         IO.setError(
             llvm::Twine("YAML Object File unsupported document type tag '") +
             llvm::Twine(Tag.c_str()) + llvm::Twine("'!"));
     }
   }
 }

lib/ObjectYAML/WasmYAML.cpp

+//===- WasmYAML.cpp - Wasm YAMLIO implementation --------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file defines classes for handling the YAML representation of wasm.
+//
+//===----------------------------------------------------------------------===//
+
+#include "llvm/Object/Wasm.h"
+#include "llvm/ObjectYAML/WasmYAML.h"
+#include "llvm/Support/Casting.h"
+#include "llvm/Support/MipsABIFlags.h"
+
+namespace llvm {
+namespace yaml {
+
+void MappingTraits<WasmYAML::FileHeader>::mapping(IO &IO,
+    WasmYAML::FileHeader &FileHdr) {
+  IO.mapRequired("Version", FileHdr.Version);
+}
+
+void MappingTraits<WasmYAML::Object>::mapping(IO &IO,
+                                              WasmYAML::Object &Object) {
+  IO.setContext(&Object);
+  IO.mapTag("!WASM", true);
+  IO.mapRequired("FileHeader", Object.Header);
+  IO.mapOptional("Sections", Object.Sections);
+  IO.setContext(nullptr);
+}
+
+static void commonSectionMapping(IO &IO, WasmYAML::Section &Section) {
+  IO.mapRequired("Type", Section.Type);
+}
+
+static void sectionMapping(IO &IO, WasmYAML::TypeSection &Section) {
+  commonSectionMapping(IO, Section);
+  IO.mapOptional("Signatures", Section.Signatures);
+}
+
+static void sectionMapping(IO &IO, WasmYAML::ImportSection &Section) {
+  commonSectionMapping(IO, Section);
+  IO.mapOptional("Imports", Section.Imports);
+}
+
+static void sectionMapping(IO &IO, WasmYAML::FunctionSection &Section) {
+  commonSectionMapping(IO, Section);
+  IO.mapOptional("FunctionTypes", Section.FunctionTypes);
+}
+
+static void sectionMapping(IO &IO, WasmYAML::TableSection &Section) {
+  commonSectionMapping(IO, Section);
+  IO.mapOptional("Tables", Section.Tables);
+}
+
+static void sectionMapping(IO &IO, WasmYAML::MemorySection &Section) {
+  commonSectionMapping(IO, Section);
+  IO.mapOptional("Memories", Section.Memories);
+}
+
+static void sectionMapping(IO &IO, WasmYAML::GlobalSection &Section) {
+  commonSectionMapping(IO, Section);
+  IO.mapOptional("Globals", Section.Globals);
+}
+
+static void sectionMapping(IO &IO, WasmYAML::ExportSection &Section) {
+  commonSectionMapping(IO, Section);
+  IO.mapOptional("Exports", Section.Exports);
+}
+
+static void sectionMapping(IO &IO, WasmYAML::StartSection &Section) {
+  commonSectionMapping(IO, Section);
+  IO.mapOptional("StartFunction", Section.StartFunction);
+}
+
+static void sectionMapping(IO &IO, WasmYAML::ElemSection &Section) {
+  commonSectionMapping(IO, Section);
+  IO.mapOptional("Segments", Section.Segments);
+}
+
+static void sectionMapping(IO &IO, WasmYAML::CodeSection &Section) {
+  commonSectionMapping(IO, Section);
+  IO.mapRequired("Content", Section.Content);
+}
+
+static void sectionMapping(IO &IO, WasmYAML::DataSection &Section) {
+  commonSectionMapping(IO, Section);
+  IO.mapRequired("Segments", Section.Segments);
+}
+
+void MappingTraits<std::unique_ptr<WasmYAML::Section>>::mapping(
+    IO &IO, std::unique_ptr<WasmYAML::Section> &Section) {
+  WasmYAML::SectionType SectionType;
+  if (IO.outputting())
+    SectionType = Section->Type;
+  else
+    IO.mapRequired("Type", SectionType);
+
+  switch (SectionType) {
+    case wasm::WASM_SEC_TYPE:
+      if (!IO.outputting())
+        Section.reset(new WasmYAML::TypeSection());
+      sectionMapping(IO, *cast<WasmYAML::TypeSection>(Section.get()));
+      break;
+    case wasm::WASM_SEC_IMPORT:
+      if (!IO.outputting())
+        Section.reset(new WasmYAML::ImportSection());
+      sectionMapping(IO, *cast<WasmYAML::ImportSection>(Section.get()));
+      break;
+    case wasm::WASM_SEC_FUNCTION:
+      if (!IO.outputting())
+        Section.reset(new WasmYAML::FunctionSection());
+      sectionMapping(IO, *cast<WasmYAML::FunctionSection>(Section.get()));
+      break;
+    case wasm::WASM_SEC_TABLE:
+      if (!IO.outputting())
+        Section.reset(new WasmYAML::TableSection());
+      sectionMapping(IO, *cast<WasmYAML::TableSection>(Section.get()));
+      break;
+    case wasm::WASM_SEC_MEMORY:
+      if (!IO.outputting())
+        Section.reset(new WasmYAML::MemorySection());
+      sectionMapping(IO, *cast<WasmYAML::MemorySection>(Section.get()));
+      break;
+    case wasm::WASM_SEC_GLOBAL:
+      if (!IO.outputting())
+        Section.reset(new WasmYAML::GlobalSection());
+      sectionMapping(IO, *cast<WasmYAML::GlobalSection>(Section.get()));
+      break;
+    case wasm::WASM_SEC_EXPORT:
+      if (!IO.outputting())
+        Section.reset(new WasmYAML::ExportSection());
+      sectionMapping(IO, *cast<WasmYAML::ExportSection>(Section.get()));
+      break;
+    case wasm::WASM_SEC_START:
+      if (!IO.outputting())
+        Section.reset(new WasmYAML::StartSection());
+      sectionMapping(IO, *cast<WasmYAML::StartSection>(Section.get()));
+      break;
+    case wasm::WASM_SEC_ELEM:
+      if (!IO.outputting())
+        Section.reset(new WasmYAML::ElemSection());
+      sectionMapping(IO, *cast<WasmYAML::ElemSection>(Section.get()));
+      break;
+    case wasm::WASM_SEC_CODE:
+      if (!IO.outputting())
+        Section.reset(new WasmYAML::CodeSection());
+      sectionMapping(IO, *cast<WasmYAML::CodeSection>(Section.get()));
+      break;
+    case wasm::WASM_SEC_DATA:
+      if (!IO.outputting())
+        Section.reset(new WasmYAML::DataSection());
+      sectionMapping(IO, *cast<WasmYAML::DataSection>(Section.get()));
+      break;
+  }
+}
+
+void ScalarEnumerationTraits<WasmYAML::SectionType>::enumeration(
+    IO &IO, WasmYAML::SectionType &Type) {
+#define ECase(X) IO.enumCase(Type, #X, wasm::WASM_SEC_##X);
+  ECase(USER);
+  ECase(TYPE);
+  ECase(IMPORT);
+  ECase(FUNCTION);
+  ECase(TABLE);
+  ECase(MEMORY);
+  ECase(GLOBAL);
+  ECase(EXPORT);
+  ECase(START);
+  ECase(ELEM);
+  ECase(CODE);
+  ECase(DATA);
+#undef ECase
+}
+
+void MappingTraits<WasmYAML::Signature>::mapping(
+    IO &IO, WasmYAML::Signature &Signature) {
+  IO.mapRequired("ReturnType", Signature.ReturnType);
+  IO.mapRequired("ParamTypes", Signature.ParamTypes);
+}
+
+void MappingTraits<WasmYAML::Table>::mapping(
+    IO &IO, WasmYAML::Table &Table) {
+  IO.mapRequired("ElemType", Table.ElemType);
+  IO.mapRequired("Limits", Table.TableLimits);
+}
+
+void MappingTraits<WasmYAML::Limits>::mapping(
+    IO &IO, WasmYAML::Limits &Limits) {
+  if (!IO.outputting() || Limits.Flags)
+    IO.mapOptional("Flags", Limits.Flags);
+  IO.mapRequired("Initial", Limits.Initial);
+  if (!IO.outputting() || Limits.Flags & wasm::WASM_LIMITS_FLAG_HAS_MAX)
+    IO.mapOptional("Maximum", Limits.Maximum);
+}
+
+void MappingTraits<WasmYAML::ElemSegment>::mapping(
+    IO &IO, WasmYAML::ElemSegment &Segment) {
+  IO.mapRequired("Offset", Segment.Offset);
+  IO.mapRequired("Functions", Segment.Functions);
+}
+
+void MappingTraits<WasmYAML::Import>::mapping(
+    IO &IO, WasmYAML::Import &Import) {
+  IO.mapRequired("Module", Import.Module);
+  IO.mapRequired("Field", Import.Field);
+  IO.mapRequired("Kind", Import.Kind);
+  IO.mapRequired("SigIndex", Import.SigIndex);
+}
+
+void MappingTraits<WasmYAML::Export>::mapping(
+    IO &IO, WasmYAML::Export &Export) {
+  IO.mapRequired("Name", Export.Name);
+  IO.mapRequired("Kind", Export.Kind);
+  IO.mapRequired("Index", Export.Index);
+}
+
+void MappingTraits<WasmYAML::Global>::mapping(
+    IO &IO, WasmYAML::Global &Global) {
+  IO.mapRequired("Type", Global.Type);
+  IO.mapRequired("Mutable", Global.Mutable);
+  IO.mapRequired("InitExpr", Global.InitExpr);
+}
+
+void MappingTraits<wasm::WasmInitExpr>::mapping(
+    IO &IO, wasm::WasmInitExpr &Expr) {
+  WasmYAML::Opcode Op = Expr.Opcode;
+  IO.mapRequired("Opcode", Op);
+  Expr.Opcode = Op;
+  switch (Expr.Opcode) {
+    case wasm::WASM_OP_I32_CONST:
+      IO.mapRequired("Value", Expr.Value.Int32);
+      break;
+    case wasm::WASM_OP_I64_CONST:
+      IO.mapRequired("Value", Expr.Value.Int64);
+      break;
+    case wasm::WASM_OP_F32_CONST:
+      IO.mapRequired("Value", Expr.Value.Float32);
+      break;
+    case wasm::WASM_OP_F64_CONST:
+      IO.mapRequired("Value", Expr.Value.Float64);
+      break;
+  }
+}
+
+void MappingTraits<WasmYAML::DataSegment>::mapping(
+    IO &IO, WasmYAML::DataSegment &Segment) {
+  IO.mapRequired("Index", Segment.Index);
+  IO.mapRequired("Offset", Segment.Offset);
+  IO.mapRequired("Content", Segment.Content);
+}
+
+void ScalarEnumerationTraits<WasmYAML::ValueType>::enumeration(
+    IO &IO, WasmYAML::ValueType &Type) {
+#define ECase(X) IO.enumCase(Type, #X, wasm::WASM_TYPE_##X);
+  ECase(I32);
+  ECase(I64);
+  ECase(F32);
+  ECase(F64);
+  ECase(FUNC);
+  ECase(ANYFUNC);
+  ECase(VOID);
+#undef ECase
+}
+
+void ScalarEnumerationTraits<WasmYAML::ExportKind>::enumeration(
+    IO &IO, WasmYAML::ExportKind &Kind) {
+#define ECase(X) IO.enumCase(Kind, #X, wasm::WASM_EXTERNAL_##X);
+  ECase(FUNC);
+  ECase(TABLE);
+  ECase(MEMORY);
+  ECase(GLOBAL);
+#undef ECase
+}
+
+void ScalarEnumerationTraits<WasmYAML::Opcode>::enumeration(
+    IO &IO, WasmYAML::Opcode &Code) {
+#define ECase(X) IO.enumCase(Code, #X, wasm::WASM_OP_##X);
+  ECase(END);
+  ECase(I32_CONST);
+  ECase(I64_CONST);
+  ECase(F64_CONST);
+  ECase(F32_CONST);
+  ECase(GET_GLOBAL);
+#undef ECase
+}
+
+void ScalarEnumerationTraits<WasmYAML::TableType>::enumeration(
+    IO &IO, WasmYAML::TableType &Type) {
+#define ECase(X) IO.enumCase(Type, #X, wasm::WASM_TYPE_##X);
+  ECase(ANYFUNC);
+#undef ECase
+}
+
+} // end namespace yaml
+} // end namespace llvm

lib/Support/Path.cpp

case 0x00: {
       // Windows resource file
       const char Expected[] = { 0, 0, 0, 0, '\x20', 0, 0, 0, '\xff' };
       if (Magic.size() >= sizeof(Expected) &&
           memcmp(Magic.data(), Expected, sizeof(Expected)) == 0)
         return file_magic::windows_resource;
       // 0x0000 = COFF unknown machine type
       if (Magic[1] == 0)
         return file_magic::coff_object;
+      if (Magic[1] == 'a' && Magic[2] == 's' && Magic[3] == 'm')
+        return file_magic::wasm_object;
       break;
     }
     case 0xDE:  // 0x0B17C0DE = BC wraper
       if (Magic[1] == (char)0xC0 && Magic[2] == (char)0x17 &&
           Magic[3] == (char)0x0B)
         return file_magic::bitcode;
       break;
     case 'B':

test/ObjectYAML/Wasm/data_section.yaml

+# RUN: yaml2obj %s | obj2yaml | FileCheck %s
+--- !WASM
+FileHeader:
+  Version:         0x0000000D
+Sections:
+  - Type:            MEMORY
+    Memories:
+      - Initial:         0x00000003
+  - Type:            DATA
+    Segments:
+      - Index:           0x00000000
+        Offset:
+          Opcode:          I32_CONST
+          Value:           4
+        Content:         '10001000'
+...
+# CHECK: --- !WASM
+# CHECK: FileHeader:
+# CHECK:   Version:           0x0000000D
+# CHECK: Sections:
+# CHECK:   - Type:            DATA
+# CHECK:     Segments:
+# CHECK:       - Index:           0x00000000
+# CHECK:         Offset:
+# CHECK:           Opcode:          I32_CONST
+# CHECK:           Value:           4
+# CHECK:         Content:         '10001000'
+# CHECK: ...

test/ObjectYAML/Wasm/elem_section.yaml

+# RUN: yaml2obj %s | obj2yaml | FileCheck %s
+--- !WASM
+FileHeader:
+  Version:         0x0000000D
+Sections:
+  - Type:            TABLE
+    Tables:         
+      - ElemType:          ANYFUNC
+        Limits:
+          Flags:           0x00000001
+          Initial:         0x00000010
+          Maximum:         0x00000011
+  - Type:            ELEM
+    Segments:
+      - Offset:
+          Opcode:        I32_CONST
+          Value:         3
+        Functions:
+          - 1
+      - Offset:
+          Opcode:        I32_CONST
+          Value:         5
+        Functions:
+          - 4
+...
+# CHECK: --- !WASM
+# CHECK: FileHeader:
+# CHECK:   Version:           0x0000000D
+# CHECK: Sections:
+# CHECK:   - Type:            ELEM
+# CHECK:     Segments:
+# CHECK:       - Offset:
+# CHECK:           Opcode:           I32_CONST
+# CHECK:           Value:            3
+# CHECK:         Functions:
+# CHECK:           - 1
+# CHECK:       - Offset:
+# CHECK:           Opcode:           I32_CONST
+# CHECK:           Value:            5
+# CHECK:         Functions:
+# CHECK:           - 4
+# CHECK: ...

test/ObjectYAML/Wasm/export_section.yaml

+# RUN: yaml2obj %s | obj2yaml | FileCheck %s
+--- !WASM
+FileHeader:
+  Version:         0x0000000D
+Sections:
+  - Type:            EXPORT
+    Exports:         
+      - Name:            foo
+        Kind:            FUNC
+        Index:           0x00000000
+      - Name:            bar
+        Kind:            FUNC
+        Index:           0x00000001
+...
+# CHECK: --- !WASM
+# CHECK: FileHeader:
+# CHECK:   Version:           0x0000000D
+# CHECK: Sections:
+# CHECK:   - Type:            EXPORT
+# CHECK:     Exports:         
+# CHECK:       - Name:            foo
+# CHECK:         Kind:            FUNC
+# CHECK:         Index:           0x00000000
+# CHECK:       - Name:            bar
+# CHECK:         Kind:            FUNC
+# CHECK:         Index:           0x00000001
+# CHECK: ...

test/ObjectYAML/Wasm/function_section.yaml

+# RUN: yaml2obj %s | obj2yaml | FileCheck %s
+--- !WASM
+FileHeader:
+  Version:         0x0000000D
+Sections:
+  - Type:            FUNCTION
+    FunctionTypes:   
+      - 1
+      - 0
+...
+# CHECK: --- !WASM
+# CHECK: FileHeader:
+# CHECK:   Version:           0x0000000D
+# CHECK: Sections:
+# CHECK:   - Type:            FUNCTION
+# CHECK:     FunctionTypes:   
+# CHECK:       - 1
+# CHECK:       - 0
+# CHECK: ...

test/ObjectYAML/Wasm/global_section.yaml

+# RUN: yaml2obj %s | obj2yaml | FileCheck %s
+--- !WASM
+FileHeader:
+  Version:         0x0000000D
+Sections:
+  - Type:            GLOBAL
+    Globals:         
+      - Type:        I32
+        Mutable:     false
+        InitExpr:
+          Opcode:          I64_CONST
+          Value:           -5
+...
+# CHECK: --- !WASM
+# CHECK: FileHeader:
+# CHECK:   Version:           0x0000000D
+# CHECK: Sections:
+# CHECK:  - Type:            GLOBAL
+# CHECK:    Globals:         
+# CHECK:      - Type:        I32
+# CHECK:        Mutable:     false
+# CHECK:        InitExpr:
+# CHECK:          Opcode:          I64_CONST
+# CHECK:          Value:           -5
+# CHECK: ...

test/ObjectYAML/Wasm/header.yaml

+# RUN: yaml2obj %s | obj2yaml | FileCheck %s
+--- !WASM
+FileHeader:
+  Version:         0x0000000D
+...
+# CHECK: --- !WASM
+# CHECK: FileHeader:
+# CHECK:   Version:           0x0000000D
+# CHECK: ...

test/ObjectYAML/Wasm/header_invalid_version.yaml

+# RUN: yaml2obj %s | not obj2yaml 2>&1 | FileCheck %s
+
+--- !WASM
+FileHeader:
+  Version:         0x0000000B
+...
+
+# CHECK: Error: 'The file was not recognized as a valid object file'

test/ObjectYAML/Wasm/import_section.yaml

+# RUN: yaml2obj %s | obj2yaml | FileCheck %s
+--- !WASM
+FileHeader:
+  Version:         0x0000000D
+Sections:
+  - Type:            IMPORT
+    Imports:         
+      - Module:          foo
+        Field:           bar
+        Kind:            FUNC
+        SigIndex:        0x00000000
+      - Module:          fiz
+        Field:           baz
+        Kind:            FUNC
+        SigIndex:        0x00000007
+...
+# CHECK: --- !WASM
+# CHECK: FileHeader:
+# CHECK:   Version:           0x0000000D
+# CHECK: Sections:
+# CHECK:   - Type:            IMPORT
+# CHECK:     Imports:         
+# CHECK:       - Module:          foo
+# CHECK:         Field:           bar
+# CHECK:         Kind:            FUNC
+# CHECK:         SigIndex:        0x00000000
+# CHECK:       - Module:          fiz
+# CHECK:         Field:           baz
+# CHECK:         Kind:            FUNC
+# CHECK:         SigIndex:        0x00000007
+# CHECK: ...

test/ObjectYAML/Wasm/memory_section.yaml

+# RUN: yaml2obj %s | obj2yaml | FileCheck %s
+--- !WASM
+FileHeader:
+  Version:         0x0000000D
+Sections:
+  - Type:            MEMORY
+    Memories:         
+      - Flags:           0x00000001
+        Initial:         0x00000002
+        Maximum:         0x000000FF
+      - Initial:         0x00000003
+...
+# CHECK: --- !WASM
+# CHECK: FileHeader:
+# CHECK:   Version:           0x0000000D
+# CHECK: Sections:
+# CHECK:   - Type:            MEMORY
+# CHECK:     Memories:         
+# CHECK:       - Flags:            0x00000001
+# CHECK:         Initial:          0x00000002
+# CHECK:         Maximum:          0x000000FF
+# CHECK:       - Initial:          0x00000003
+# CHECK: ...

test/ObjectYAML/Wasm/start_section.yaml

+# RUN: yaml2obj %s | obj2yaml | FileCheck %s
+--- !WASM
+FileHeader:
+  Version:         0x0000000D
+Sections:
+  - Type:            START
+    StartFunction:   1
+...
+# CHECK: --- !WASM
+# CHECK: FileHeader:
+# CHECK:   Version:           0x0000000D
+# CHECK: Sections:
+# CHECK:  - Type:            START
+# CHECK:    StartFunction:   1
+# CHECK: ...

test/ObjectYAML/Wasm/table_section.yaml

+# RUN: yaml2obj %s | obj2yaml | FileCheck %s
+--- !WASM
+FileHeader:
+  Version:         0x0000000D
+Sections:
+  - Type:            TABLE
+    Tables:         
+      - ElemType:        ANYFUNC
+        Limits:
+          Flags:           0x00000001
+          Initial:         0x00000010
+          Maximum:         0x00000011
+...
+# CHECK: --- !WASM
+# CHECK: FileHeader:
+# CHECK:   Version:           0x0000000D
+# CHECK: Sections:
+# CHECK:  - Type:            TABLE
+# CHECK:    Tables:         
+# CHECK:      - ElemType:        ANYFUNC
+# CHECK:        Limits:
+# CHECK:          Flags:           0x00000001
+# CHECK:          Initial:         0x00000010
+# CHECK:          Maximum:         0x00000011
+# CHECK: ...

test/ObjectYAML/Wasm/type_section.yaml

+# RUN: yaml2obj %s | obj2yaml | FileCheck %s
+--- !WASM
+FileHeader:
+  Version:         0x0000000D
+Sections:
+  - Type:            TYPE
+    Signatures:
+      - ReturnType:      I32
+        ParamTypes:
+          - F32
+          - F32
+      - ReturnType:      I64
+        ParamTypes:
+          - F64
+          - F64
+...
+# CHECK: --- !WASM
+# CHECK: FileHeader:
+# CHECK:   Version:           0x0000000D
+# CHECK: Sections:
+# CHECK:  - Type:            TYPE
+# CHECK:    Signatures:
+# CHECK:      - ReturnType:      I32
+# CHECK:        ParamTypes:
+# CHECK:          - F32
+# CHECK:          - F32
+# CHECK:      - ReturnType:      I64
+# CHECK:        ParamTypes:
+# CHECK:          - F64
+# CHECK:          - F64
+# CHECK: ...

test/tools/llvm-objdump/wasm.txt

+# RUN: llvm-objdump -p %p/Inputs/test.wasm | FileCheck %s
+
+# CHECK: Version: 0xd
+# CHECK: Sections:
+# CHECK:      TYPE size 0x00000015 off  0x00000008
+# CHECK:    IMPORT size 0x00000011 off  0x00000025
+# CHECK:  FUNCTION size 0x00000003 off  0x00000038
+# CHECK:     TABLE size 0x00000005 off  0x00000043
+# CHECK:    EXPORT size 0x00000014 off  0x00000050
+# CHECK:      ELEM size 0x00000007 off  0x00000066
+# CHECK:  FUNCTION size 0x00000042 off  0x00000075

test/tools/llvm-readobj/file-headers.test

 RUN: llvm-readobj -h %p/Inputs/trivial.obj.macho-arm \
 RUN:   | FileCheck %s -check-prefix MACHO-ARM
 RUN: llvm-readobj -h %p/Inputs/magic.coff-unknown \
 RUN:   | FileCheck %s -check-prefix COFF-UNKNOWN
 RUN: llvm-readobj -h %p/Inputs/magic.coff-importlib \
 RUN:   | FileCheck %s -check-prefix COFF-IMPORTLIB
 RUN: llvm-readobj -h %p/Inputs/trivial.obj.elf-lanai \
 RUN:   | FileCheck %s -check-prefix ELF-LANAI
+RUN: llvm-readobj -h %p/Inputs/trivial.obj.wasm \
+RUN:   | FileCheck %s -check-prefix WASM
 
 COFF-ARM:      File: {{(.*[/\\])?}}trivial.obj.coff-arm
 COFF-ARM-NEXT: Format: COFF-ARM
 COFF-ARM-NEXT: Arch: thumb
 COFF-ARM-NEXT: AddressSize: 32bit
 COFF-ARM-NEXT: ImageFileHeader {
 COFF-ARM-NEXT:   Machine: IMAGE_FILE_MACHINE_ARMNT (0x1C4)
 COFF-ARM-NEXT:   SectionCount: 2

 ELF-LANAI-NEXT:   ]
 ELF-LANAI-NEXT:   HeaderSize: 52
 ELF-LANAI-NEXT:   ProgramHeaderEntrySize: 0
 ELF-LANAI-NEXT:   ProgramHeaderCount: 0
 ELF-LANAI-NEXT:   SectionHeaderEntrySize: 40
 ELF-LANAI-NEXT:   SectionHeaderCount: 8
 ELF-LANAI-NEXT:   StringTableSectionIndex: 1
 ELF-LANAI-NEXT: }
+
+WASM: Format: WASM
+WASM-NEXT: Arch: wasm32
+WASM-NEXT: AddressSize: 32bit
+WASM-NEXT: Version: 0xD

test/tools/llvm-readobj/sections.test

 RUN: llvm-readobj -s %p/Inputs/trivial.obj.coff-i386 \
 RUN:   | FileCheck %s -check-prefix COFF
 RUN: llvm-readobj -s %p/Inputs/trivial.obj.elf-i386 \
 RUN:   | FileCheck %s -check-prefix ELF
 RUN: llvm-readobj -s %p/Inputs/trivial.obj.elf-mipsel \
 RUN:   | FileCheck %s -check-prefix ELF-MIPSEL
 RUN: llvm-readobj -s %p/Inputs/trivial.obj.macho-i386 \
 RUN:   | FileCheck %s -check-prefix MACHO-I386
 RUN: llvm-readobj -s %p/Inputs/trivial.obj.macho-x86-64 \
 RUN:   | FileCheck %s -check-prefix MACHO-X86-64
 RUN: llvm-readobj -s %p/Inputs/trivial.obj.macho-ppc \
 RUN:   | FileCheck %s -check-prefix MACHO-PPC
 RUN: llvm-readobj -s %p/Inputs/trivial.obj.macho-ppc64 \
 RUN:   | FileCheck %s -check-prefix MACHO-PPC64
 RUN: llvm-readobj -s %p/Inputs/trivial.obj.macho-arm \
 RUN:   | FileCheck %s -check-prefix MACHO-ARM
+RUN: llvm-readobj -s %p/Inputs/trivial.obj.wasm \
+RUN:   | FileCheck %s -check-prefix WASM
 
 COFF:      Sections [
 COFF-NEXT:   Section {
 COFF-NEXT:     Number: 1
 COFF-NEXT:     Name: .text (2E 74 65 78 74 00 00 00)
 COFF-NEXT:     VirtualSize: 0x0
 COFF-NEXT:     VirtualAddress: 0x0
 COFF-NEXT:     RawDataSize: 22

 MACHO-ARM-NEXT:    RelocationCount: 0
 MACHO-ARM-NEXT:    Type: 0x6
 MACHO-ARM-NEXT:    Attributes [ (0x0)
 MACHO-ARM-NEXT:    ]
 MACHO-ARM-NEXT:    Reserved1: 0x0
 MACHO-ARM-NEXT:    Reserved2: 0x0
 MACHO-ARM-NEXT:  }
 MACHO-ARM-NEXT:]
+
+WASM: Sections [
+WASM-NEXT:   Section {
+WASM-NEXT:     Type: TYPE (0x1)
+WASM-NEXT:     Size: 15
+WASM-NEXT:     Offset: 8
+WASM-NEXT:   }
+WASM-NEXT:   Section {
+WASM-NEXT:     Type: IMPORT (0x2)
+WASM-NEXT:     Size: 11
+WASM-NEXT:     Offset: 25
+WASM-NEXT:   }
+WASM-NEXT:   Section {
+WASM-NEXT:     Type: FUNCTION (0x3)
+WASM-NEXT:     Size: 3
+WASM-NEXT:     Offset: 38
+WASM-NEXT:   }
+WASM-NEXT:   Section {
+WASM-NEXT:     Type: TABLE (0x4)
+WASM-NEXT:     Size: 5
+WASM-NEXT:     Offset: 43
+WASM-NEXT:   }
+WASM-NEXT:   Section {
+WASM-NEXT:     Type: EXPORT (0x7)
+WASM-NEXT:     Size: 14
+WASM-NEXT:     Offset: 50
+WASM-NEXT:   }
+WASM-NEXT:   Section {
+WASM-NEXT:     Type: ELEM (0x9)
+WASM-NEXT:     Size: 7
+WASM-NEXT:     Offset: 66
+WASM-NEXT:   }
+WASM-NEXT:   Section {
+WASM-NEXT:     Type: CODE (0xA)
+WASM-NEXT:     Size: 42
+WASM-NEXT:     Offset: 75
+WASM-NEXT:   }
+WASM-NEXT: ]

tools/llvm-nm/llvm-nm.cpp

 #include "llvm/IR/Module.h"
 #include "llvm/Object/Archive.h"
 #include "llvm/Object/COFF.h"
 #include "llvm/Object/ELFObjectFile.h"
 #include "llvm/Object/IRObjectFile.h"
 #include "llvm/Object/MachO.h"
 #include "llvm/Object/MachOUniversal.h"
 #include "llvm/Object/ObjectFile.h"
+#include "llvm/Object/Wasm.h"
 #include "llvm/Support/COFF.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/Format.h"
 #include "llvm/Support/ManagedStatic.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/PrettyStackTrace.h"
 #include "llvm/Support/Program.h"
if (isa<IRObjectFile>(Obj)) {
     Module &M = IRobj->getModule();
     if (M.getTargetTriple().empty())
       return false;
     Triple T(M.getTargetTriple());
     return T.isArch64Bit();
   }
   if (isa<COFFObjectFile>(Obj))
     return false;
+  if (isa<WasmObjectFile>(Obj))
+    return false;
   if (MachOObjectFile *MachO = dyn_cast<MachOObjectFile>(&Obj))
     return MachO->is64Bit();
   return cast<ELFObjectFileBase>(Obj).getBytesInAddress() == 8;
 }
 
 static StringRef CurrentFilename;
 typedef std::vector<NMSymbol> SymbolListT;
 static SymbolListT SymbolList;

tools/llvm-objdump/CMakeLists.txt

set(LLVM_LINK_COMPONENTS
   Symbolize
   )
 
 add_llvm_tool(llvm-objdump
   llvm-objdump.cpp
   COFFDump.cpp
   ELFDump.cpp
   MachODump.cpp
+  WasmDump.cpp
   )
 
 if(HAVE_LIBXAR)
   target_link_libraries(llvm-objdump ${XAR_LIB})
 endif()

tools/llvm-objdump/WasmDump.cpp

+//===-- WasmDump.cpp - wasm-specific dumper ---------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+///
+/// \file
+/// \brief This file implements the wasm-specific dumper for llvm-objdump.
+///
+//===----------------------------------------------------------------------===//
+
+#include "llvm-objdump.h"
+#include "llvm/Object/Wasm.h"
+
+using namespace llvm;
+using namespace object;
+
+void llvm::printWasmFileHeader(const object::ObjectFile *Obj) {
+  const WasmObjectFile *File = dyn_cast<const WasmObjectFile>(Obj);
+
+  outs() << "Version: 0x";
+  outs().write_hex(File->getHeader().Version);
+  outs() << "\n";
+  outs() << "\n";
+  outs() << "Sections:\n";
+
+  for (auto &Section : File->sections()) {
+    const wasm::WasmSection* WasmSec = File->getWasmSection(Section);
+    switch (WasmSec->Type) {
+      case wasm::WASM_SEC_USER:
+        outs() << "     USER";
+        break;
+      case wasm::WASM_SEC_TYPE:
+        outs() << "     TYPE";
+        break;
+      case wasm::WASM_SEC_IMPORT:
+        outs() << "   IMPORT";
+        break;
+      case wasm::WASM_SEC_FUNCTION:
+        outs() << " FUNCTION";
+        break;
+      case wasm::WASM_SEC_TABLE:
+        outs() << "    TABLE";
+        break;
+      case wasm::WASM_SEC_MEMORY:
+        outs() << "   MEMORY";
+        break;
+      case wasm::WASM_SEC_GLOBAL:
+        outs() << "   GLOBAL";
+        break;
+      case wasm::WASM_SEC_EXPORT:
+        outs() << "   EXPORT";
+        break;
+      case wasm::WASM_SEC_START:
+        outs() << "    START";
+        break;
+      case wasm::WASM_SEC_ELEM:
+        outs() << "     ELEM";
+        break;
+      case wasm::WASM_SEC_CODE:
+        outs() << " FUNCTION";
+        break;
+      case wasm::WASM_SEC_DATA:
+        outs() << " FUNCTION";
+        break;
+      default:
+        outs() << " UNKNOWN";
+        break;
+    }
+    outs() << " size " << format("0x%08d", WasmSec->Content.size());
+    outs() << " off  " << format("0x%08d", WasmSec->Offset);
+    outs() << "\n";
+  }
+}

tools/llvm-objdump/llvm-objdump.h

 void printMachOLazyBindTable(const object::MachOObjectFile* o);
 void printMachOWeakBindTable(const object::MachOObjectFile* o);
 void printELFFileHeader(const object::ObjectFile *o);
 void printCOFFFileHeader(const object::ObjectFile *o);
 void printCOFFSymbolTable(const object::COFFImportFile *i);
 void printCOFFSymbolTable(const object::COFFObjectFile *o);
 void printMachOFileHeader(const object::ObjectFile *o);
 void printMachOLoadCommands(const object::ObjectFile *o);
+void printWasmFileHeader(const object::ObjectFile *o);
 void printExportsTrie(const object::ObjectFile *o);
 void printRebaseTable(const object::ObjectFile *o);
 void printBindTable(const object::ObjectFile *o);
 void printLazyBindTable(const object::ObjectFile *o);
 void printWeakBindTable(const object::ObjectFile *o);
 void printRawClangAST(const object::ObjectFile *o);
 void PrintRelocations(const object::ObjectFile *o);
 void PrintSectionHeaders(const object::ObjectFile *o);

tools/llvm-objdump/llvm-objdump.cpp

static void printFaultMaps(const ObjectFile *Obj) {
   outs() << FMP;
 }
 
 static void printPrivateFileHeaders(const ObjectFile *o, bool onlyFirst) {
   if (o->isELF())
     return printELFFileHeader(o);
   if (o->isCOFF())
     return printCOFFFileHeader(o);
+  if (o->isWasm())
+    return printWasmFileHeader(o);
   if (o->isMachO()) {
     printMachOFileHeader(o);
     if (!onlyFirst)
       printMachOLoadCommands(o);
     return;
   }
   report_fatal_error("Invalid/Unsupported object file format");
 }

tools/llvm-readobj/CMakeLists.txt

add_llvm_tool(llvm-readobj
   ARMWinEHPrinter.cpp
   COFFDumper.cpp
   COFFImportDumper.cpp
   ELFDumper.cpp
   Error.cpp
   llvm-readobj.cpp
   MachODumper.cpp
   ObjDumper.cpp
+  WasmDumper.cpp
   Win64EHDumper.cpp
   )

tools/llvm-readobj/ObjDumper.h

 std::error_code createELFDumper(const object::ObjectFile *Obj,
                                 ScopedPrinter &Writer,
                                 std::unique_ptr<ObjDumper> &Result);
 
 std::error_code createMachODumper(const object::ObjectFile *Obj,
                                   ScopedPrinter &Writer,
                                   std::unique_ptr<ObjDumper> &Result);
 
+std::error_code createWasmDumper(const object::ObjectFile *Obj,
+                                  ScopedPrinter &Writer,
+                                  std::unique_ptr<ObjDumper> &Result);
+
 void dumpCOFFImportFile(const object::COFFImportFile *File);
 
 void dumpCodeViewMergedTypes(ScopedPrinter &Writer,
                              llvm::codeview::MemoryTypeTableBuilder &CVTypes);
 
 } // namespace llvm
 
 #endif

tools/llvm-readobj/WasmDumper.cpp

+//===-- WasmDumper.cpp - Object file dumping utility for llvm --------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file implements the Wasm-specific dumper for llvm-readobj.
+//
+//===----------------------------------------------------------------------===//
+
+#include "Error.h"
+#include "ObjDumper.h"
+#include "llvm/Object/Wasm.h"
+#include "llvm/Support/ScopedPrinter.h"
+
+using namespace llvm;
+using namespace object;
+
+namespace {
+
+const char* wasmSectionTypeToString(uint32_t Type) {
+  switch (Type) {
+    case wasm::WASM_SEC_USER: return "USER";
+    case wasm::WASM_SEC_TYPE: return "TYPE";
+    case wasm::WASM_SEC_IMPORT: return "IMPORT";
+    case wasm::WASM_SEC_FUNCTION: return "FUNCTION";
+    case wasm::WASM_SEC_TABLE: return "TABLE";
+    case wasm::WASM_SEC_MEMORY: return "MEMORY";
+    case wasm::WASM_SEC_GLOBAL: return "GLOBAL";
+    case wasm::WASM_SEC_EXPORT: return "EXPORT";
+    case wasm::WASM_SEC_START: return "START";
+    case wasm::WASM_SEC_ELEM: return "ELEM";
+    case wasm::WASM_SEC_CODE: return "CODE";
+    case wasm::WASM_SEC_DATA: return "DATA";
+  }
+  return "";
+}
+
+class WasmDumper : public ObjDumper {
+public:
+  WasmDumper(const WasmObjectFile *Obj, ScopedPrinter &Writer)
+      : ObjDumper(Writer), Obj(Obj) {}
+
+  void printFileHeaders() override {
+    W.printHex("Version", Obj->getHeader().Version);
+  }
+
+  void printSections() override {
+    ListScope Group(W, "Sections");
+    for (const SectionRef &Section : Obj->sections()) {
+      const wasm::WasmSection* WasmSec = Obj->getWasmSection(Section);
+      DictScope SectionD(W, "Section");
+      const char* Type = wasmSectionTypeToString(WasmSec->Type);
+      W.printHex("Type", Type, WasmSec->Type);
+      W.printNumber("Size", WasmSec->Content.size());
+      W.printNumber("Offset", WasmSec->Offset);
+    }
+  }
+  void printRelocations() override { llvm_unreachable("unimplemented"); }
+  void printSymbols() override { llvm_unreachable("unimplemented"); }
+  void printDynamicSymbols() override { llvm_unreachable("unimplemented"); }
+  void printUnwindInfo() override { llvm_unreachable("unimplemented"); }
+  void printStackMap() const override { llvm_unreachable("unimplemented"); }
+
+private:
+  const WasmObjectFile *Obj;
+};
+
+}
+
+namespace llvm {
+
+std::error_code createWasmDumper(const object::ObjectFile *Obj,
+                                 ScopedPrinter &Writer,
+                                 std::unique_ptr<ObjDumper> &Result) {
+  const WasmObjectFile *WasmObj = dyn_cast<WasmObjectFile>(Obj);
+  if (!WasmObj)
+    return readobj_error::unsupported_obj_file_format;
+
+  Result.reset(new WasmDumper(WasmObj, Writer));
+  return readobj_error::success;
+}
+
+} // namespace llvm

tools/llvm-readobj/llvm-readobj.cpp

if (!Obj)
     return readobj_error::unsupported_file_format;
 
   if (Obj->isCOFF())
     return createCOFFDumper(Obj, Writer, Result);
   if (Obj->isELF())
     return createELFDumper(Obj, Writer, Result);
   if (Obj->isMachO())
     return createMachODumper(Obj, Writer, Result);
+  if (Obj->isWasm())
+    return createWasmDumper(Obj, Writer, Result);
 
   return readobj_error::unsupported_obj_file_format;
 }
 
 /// @brief Dumps the specified object file.
 static void dumpObject(const ObjectFile *Obj) {
   ScopedPrinter Writer(outs());
   std::unique_ptr<ObjDumper> Dumper;

tools/obj2yaml/CMakeLists.txt

 set(LLVM_LINK_COMPONENTS
   Object
   ObjectYAML
   Support
   )
 
 add_llvm_tool(obj2yaml
   obj2yaml.cpp
   coff2yaml.cpp
   elf2yaml.cpp
   macho2yaml.cpp
+  wasm2yaml.cpp
   Error.cpp
   )

tools/obj2yaml/obj2yaml.h

 //===------ utils/obj2yaml.hpp - obj2yaml conversion tool -------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 // This file declares some helper routines, and also the format-specific
 // writers. To add a new format, add the declaration here, and, in a separate
 // source file, implement it.
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_TOOLS_OBJ2YAML_OBJ2YAML_H
 #define LLVM_TOOLS_OBJ2YAML_OBJ2YAML_H
 
 #include "llvm/Object/COFF.h"
+#include "llvm/Object/Wasm.h"
 #include "llvm/Support/raw_ostream.h"
 #include <system_error>
 
 std::error_code coff2yaml(llvm::raw_ostream &Out,
                           const llvm::object::COFFObjectFile &Obj);
 std::error_code elf2yaml(llvm::raw_ostream &Out,
                          const llvm::object::ObjectFile &Obj);
 std::error_code macho2yaml(llvm::raw_ostream &Out,
                            const llvm::object::Binary &Obj);
+std::error_code wasm2yaml(llvm::raw_ostream &Out,
+                          const llvm::object::WasmObjectFile &Obj);
 
 #endif

tools/obj2yaml/obj2yaml.cpp

 using namespace llvm;
 using namespace llvm::object;
 
 static std::error_code dumpObject(const ObjectFile &Obj) {
   if (Obj.isCOFF())
     return coff2yaml(outs(), cast<COFFObjectFile>(Obj));
   if (Obj.isELF())
     return elf2yaml(outs(), Obj);
+  if (Obj.isWasm())
+    return wasm2yaml(outs(), cast<WasmObjectFile>(Obj));
 
   return obj2yaml_error::unsupported_obj_file_format;
 }
 
 static std::error_code dumpInput(StringRef File) {
   Expected<OwningBinary<Binary>> BinaryOrErr = createBinary(File);
   if (!BinaryOrErr)
     return errorToErrorCode(BinaryOrErr.takeError());

tools/obj2yaml/wasm2yaml.cpp

+//===------ utils/wasm2yaml.cpp - obj2yaml conversion tool ------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "obj2yaml.h"
+#include "llvm/Object/COFF.h"
+#include "llvm/ObjectYAML/WasmYAML.h"
+#include "llvm/Support/ErrorHandling.h"
+#include "llvm/Support/YAMLTraits.h"
+
+using namespace llvm;
+
+namespace {
+
+class WasmDumper {
+  const object::WasmObjectFile &Obj;
+
+public:
+  WasmDumper(const object::WasmObjectFile &O) : Obj(O) {}
+  ErrorOr<WasmYAML::Object *> dump();
+};
+
+ErrorOr<WasmYAML::Object *> WasmDumper::dump() {
+  auto Y = make_unique<WasmYAML::Object>();
+
+  // Dump header
+  Y->Header.Version = Obj.getHeader().Version;
+
+  // Dump sections
+  for (const auto &Sec : Obj.sections()) {
+    const wasm::WasmSection* WasmSec = Obj.getWasmSection(Sec);
+    std::unique_ptr<WasmYAML::Section> S;
+    switch (WasmSec->Type) {
+      case wasm::WASM_SEC_TYPE: {
+        auto TypeSec = make_unique<WasmYAML::TypeSection>();
+        for (const auto &FunctionSig : Obj.types()) {
+          WasmYAML::Signature Sig;
+          Sig.ReturnType = FunctionSig.ReturnType;
+          for (const auto &ParamType : FunctionSig.ParamTypes)
+            Sig.ParamTypes.push_back(ParamType);
+          TypeSec->Signatures.push_back(Sig);
+        }
+        S = std::move(TypeSec);
+        break;
+      }
+      case wasm::WASM_SEC_IMPORT: {
+        auto ImportSec = make_unique<WasmYAML::ImportSection>();
+        for (auto &Import : Obj.imports()) {
+          WasmYAML::Import Ex;
+          Ex.Module = Import.Module;
+          Ex.Field = Import.Field;
+          Ex.Kind = Import.Kind;
+          Ex.SigIndex = Import.SigIndex;
+          ImportSec->Imports.push_back(Ex);
+        }
+        S = std::move(ImportSec);
+        break;
+      }
+      case wasm::WASM_SEC_FUNCTION: {
+        auto FuncSec = make_unique<WasmYAML::FunctionSection>();
+        for (const auto &Func : Obj.functions()) {
+          FuncSec->FunctionTypes.push_back(Func);
+        }
+        S = std::move(FuncSec);
+        break;
+      }
+      case wasm::WASM_SEC_TABLE: {
+        auto TableSec = make_unique<WasmYAML::TableSection>();
+        for (auto &Table : Obj.tables()) {
+          WasmYAML::Table T;
+          T.ElemType = Table.ElemType;
+          T.TableLimits.Flags = Table.Limits.Flags;
+          T.TableLimits.Initial = Table.Limits.Initial;
+          T.TableLimits.Maximum = Table.Limits.Maximum;
+          TableSec->Tables.push_back(T);
+        }
+        S = std::move(TableSec);
+        break;
+      }
+      case wasm::WASM_SEC_MEMORY: {
+        auto MemorySec = make_unique<WasmYAML::MemorySection>();
+        for (auto &Memory : Obj.memories()) {
+          WasmYAML::Limits L;
+          L.Flags = Memory.Flags;
+          L.Initial = Memory.Initial;
+          L.Maximum = Memory.Maximum;
+          MemorySec->Memories.push_back(L);
+        }
+        S = std::move(MemorySec);
+        break;
+      }
+      case wasm::WASM_SEC_GLOBAL: {
+        auto GlobalSec = make_unique<WasmYAML::GlobalSection>();
+        for (auto &Global : Obj.globals()) {
+          WasmYAML::Global G;
+          G.Type = Global.Type;
+          G.Mutable = Global.Mutable;
+          G.InitExpr = Global.InitExpr;
+          GlobalSec->Globals.push_back(G);
+        }
+        S = std::move(GlobalSec);
+        break;
+      }
+      case wasm::WASM_SEC_START: {
+        auto StartSec = make_unique<WasmYAML::StartSection>();
+        StartSec->StartFunction = Obj.startFunction();
+        S = std::move(StartSec);
+        break;
+      }
+      case wasm::WASM_SEC_EXPORT: {
+        auto ExportSec = make_unique<WasmYAML::ExportSection>();
+        for (auto &Export : Obj.exports()) {
+          WasmYAML::Export Ex;
+          Ex.Name = Export.Name;
+          Ex.Kind = Export.Kind;
+          Ex.Index = Export.Index;
+          ExportSec->Exports.push_back(Ex);
+        }
+        S = std::move(ExportSec);
+        break;
+      }
+      case wasm::WASM_SEC_ELEM: {
+        auto ElemSec = make_unique<WasmYAML::ElemSection>();
+        for (auto &Segment : Obj.elements()) {
+          WasmYAML::ElemSegment Seg;
+          Seg.TableIndex = Segment.TableIndex;
+          Seg.Offset = Segment.Offset;
+          for (auto &Func : Segment.Functions) {
+            Seg.Functions.push_back(Func);
+          }
+          ElemSec->Segments.push_back(Seg);
+        }
+        S = std::move(ElemSec);
+        break;
+      }
+      case wasm::WASM_SEC_CODE: {
+        auto CodeSec = make_unique<WasmYAML::CodeSection>();
+        CodeSec->Content = yaml::BinaryRef(WasmSec->Content);
+        S = std::move(CodeSec);
+        break;
+      }
+      case wasm::WASM_SEC_DATA: {
+        auto DataSec = make_unique<WasmYAML::DataSection>();
+        for (auto &Segment : Obj.dataSegments()) {
+          WasmYAML::DataSegment Seg;
+          Seg.Index = Segment.Index;
+          Seg.Offset = Segment.Offset;
+          Seg.Content = yaml::BinaryRef(Segment.Content);
+          DataSec->Segments.push_back(Seg);
+        }
+        S = std::move(DataSec);
+        break;
+      }
+      default:
+        llvm_unreachable("Unknown section type");
+    }
+    Y->Sections.push_back(std::move(S));
+  }
+
+  return Y.release();
+}
+
+}
+
+std::error_code wasm2yaml(raw_ostream &Out, const object::WasmObjectFile &Obj) {
+  WasmDumper Dumper(Obj);
+  ErrorOr<WasmYAML::Object *> YAMLOrErr = Dumper.dump();
+  if (std::error_code EC = YAMLOrErr.getError())
+    return EC;
+
+  std::unique_ptr<WasmYAML::Object> YAML(YAMLOrErr.get());
+  yaml::Output Yout(Out);
+  Yout << *YAML;
+
+  return std::error_code();
+}

tools/yaml2obj/CMakeLists.txt

 set(LLVM_LINK_COMPONENTS
   MC
   Object
   ObjectYAML
   Support
   )
 
 add_llvm_tool(yaml2obj
   yaml2obj.cpp
   yaml2coff.cpp
   yaml2elf.cpp
   yaml2macho.cpp
+  yaml2wasm.cpp
   )

tools/yaml2obj/yaml2obj.h

 namespace COFFYAML {
 struct Object;
 }
 
 namespace ELFYAML {
 struct Object;
 }
 
+namespace WasmYAML {
+struct Object;
+}
+
 namespace yaml {
 class Input;
 struct YamlObjectFile;
 }
 }
 
 int yaml2coff(llvm::COFFYAML::Object &Doc, llvm::raw_ostream &Out);
 int yaml2elf(llvm::ELFYAML::Object &Doc, llvm::raw_ostream &Out);
 int yaml2macho(llvm::yaml::YamlObjectFile &Doc, llvm::raw_ostream &Out);
+int yaml2wasm(llvm::WasmYAML::Object &Doc, llvm::raw_ostream &Out);
 
 #endif

tools/yaml2obj/yaml2obj.cpp

if (++CurDocNum == DocNum) {
       }
 
       if (Doc.Elf)
         return yaml2elf(*Doc.Elf, Out);
       if (Doc.Coff)
         return yaml2coff(*Doc.Coff, Out);
       if (Doc.MachO || Doc.FatMachO)
         return yaml2macho(Doc, Out);
+      if (Doc.Wasm)
+        return yaml2wasm(*Doc.Wasm, Out);
       errs() << "yaml2obj: Unknown document type!\n";
       return 1;
     }
   } while (YIn.nextDocument());
 
   errs() << "yaml2obj: Cannot find the " << DocNum
          << llvm::getOrdinalSuffix(DocNum) << " document\n";
   return 1;
 }
 
 int main(int argc, char **argv) {
   cl::ParseCommandLineOptions(argc, argv);
   sys::PrintStackTraceOnErrorSignal(argv[0]);
   PrettyStackTraceProgram X(argc, argv);
   llvm_shutdown_obj Y;  // Call llvm_shutdown() on exit.
 
   if (OutputFilename.empty())
     OutputFilename = "-";
 
   std::error_code EC;
   std::unique_ptr<tool_output_file> Out(
       new tool_output_file(OutputFilename, EC, sys::fs::F_None));
   if (EC) {
-    errs() << EC.message() << '\n';
+    errs() << "Error: '" << EC.message() << "'\n";
     return 1;
   }
 
   ErrorOr<std::unique_ptr<MemoryBuffer>> Buf =
       MemoryBuffer::getFileOrSTDIN(Input);
   if (!Buf)
     return 1;
 
   yaml::Input YIn(Buf.get()->getBuffer());
 
   int Res = convertYAML(YIn, Out->os());
   if (Res == 0)
     Out->keep();
 
   return Res;
 }

tools/yaml2obj/yaml2wasm.cpp

+//===- yaml2wasm - Convert YAML to a Wasm object file --------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+///
+/// \file
+/// \brief The Wasm component of yaml2obj.
+///
+//===----------------------------------------------------------------------===//
+//
+#include "yaml2obj.h"
+#include "llvm/ObjectYAML/ObjectYAML.h"
+#include "llvm/Object/Wasm.h"
+#include "llvm/Support/Endian.h"
+#include "llvm/Support/LEB128.h"
+
+using namespace llvm;
+
+/// This parses a yaml stream that represents a Wasm object file.
+/// See docs/yaml2obj for the yaml scheema.
+class WasmWriter {
+public:
+  WasmWriter(WasmYAML::Object &Obj) : Obj(Obj) {}
+  int writeWasm(raw_ostream &OS);
+  int writeSectionContent(raw_ostream &OS, WasmYAML::TypeSection &Section);
+  int writeSectionContent(raw_ostream &OS, WasmYAML::ImportSection &Section);
+  int writeSectionContent(raw_ostream &OS, WasmYAML::FunctionSection &Section);
+  int writeSectionContent(raw_ostream &OS, WasmYAML::TableSection &Section);
+  int writeSectionContent(raw_ostream &OS, WasmYAML::MemorySection &Section);
+  int writeSectionContent(raw_ostream &OS, WasmYAML::GlobalSection &Section);
+  int writeSectionContent(raw_ostream &OS, WasmYAML::ExportSection &Section);
+  int writeSectionContent(raw_ostream &OS, WasmYAML::StartSection &Section);
+  int writeSectionContent(raw_ostream &OS, WasmYAML::ElemSection &Section);
+  int writeSectionContent(raw_ostream &OS, WasmYAML::CodeSection &Section);
+  int writeSectionContent(raw_ostream &OS, WasmYAML::DataSection &Section);
+private:
+  WasmYAML::Object &Obj;
+};
+
+static int writeUint64(raw_ostream &OS, uint64_t Value) {
+  char Data[sizeof(Value)];
+  support::endian::write64le(Data, Value);
+  OS.write(Data, sizeof(Data));
+  return 0;
+}
+
+static int writeUint32(raw_ostream &OS, uint32_t Value) {
+  char Data[sizeof(Value)];
+  support::endian::write32le(Data, Value);
+  OS.write(Data, sizeof(Data));
+  return 0;
+}
+
+static int writeUint8(raw_ostream &OS, uint8_t Value) {
+  char Data[sizeof(Value)];
+  memcpy(Data, &Value, sizeof(Data));
+  OS.write(Data, sizeof(Data));
+  return 0;
+}
+
+static int writeStringRef(StringRef &Str, raw_ostream &OS) {
+  encodeULEB128(Str.size(), OS);
+  OS << Str;
+  return 0;
+}
+
+static int writeLimits(WasmYAML::Limits Lim, raw_ostream &OS) {
+  encodeULEB128(Lim.Flags, OS);
+  encodeULEB128(Lim.Initial, OS);
+  if (Lim.Flags & wasm::WASM_LIMITS_FLAG_HAS_MAX)
+    encodeULEB128(Lim.Maximum, OS);
+  return 0;
+}
+
+static int writeInitExpr(wasm::WasmInitExpr InitExpr, raw_ostream &OS) {
+  writeUint8(OS, InitExpr.Opcode);
+  switch (InitExpr.Opcode) {
+    case wasm::WASM_OP_I32_CONST:
+      encodeSLEB128(InitExpr.Value.Int32, OS);
+      break;
+    case wasm::WASM_OP_I64_CONST:
+      encodeSLEB128(InitExpr.Value.Int64, OS);
+      break;
+    case wasm::WASM_OP_F32_CONST:
+      writeUint32(OS, InitExpr.Value.Float32);
+      break;
+    case wasm::WASM_OP_F64_CONST:
+      writeUint64(OS, InitExpr.Value.Float64);
+      break;
+    case wasm::WASM_OP_GET_GLOBAL:
+      encodeULEB128(InitExpr.Value.Global, OS);
+      break;
+    default:
+      errs() << "Unknown opcode in init_expr: " << InitExpr.Opcode;
+      return 1;
+  }
+  writeUint8(OS, wasm::WASM_OP_END);
+  return 0;
+}
+
+int WasmWriter::writeSectionContent(raw_ostream &OS,
+                                    WasmYAML::TypeSection &Section) {
+  encodeULEB128(Section.Signatures.size(), OS);
+  for (auto &Sig : Section.Signatures) {
+    encodeSLEB128(Sig.Form, OS);
+    encodeULEB128(Sig.ParamTypes.size(), OS);
+    for (auto ParamType : Sig.ParamTypes)
+      encodeSLEB128(ParamType, OS);
+    if (Sig.ReturnType == wasm::WASM_TYPE_VOID) {
+      encodeULEB128(0, OS);
+    } else {
+      encodeULEB128(1, OS);
+      encodeSLEB128(Sig.ReturnType, OS);
+    }
+  }
+  return 0;
+}
+
+int WasmWriter::writeSectionContent(raw_ostream &OS,
+                                    WasmYAML::ImportSection &Section) {
+  encodeULEB128(Section.Imports.size(), OS);
+  for (auto &Import : Section.Imports) {
+    writeStringRef(Import.Module, OS);
+    writeStringRef(Import.Field, OS);
+    encodeULEB128(Import.Kind, OS);
+    switch (Import.Kind) {
+      case wasm::WASM_EXTERNAL_FUNC:
+        encodeULEB128(Import.SigIndex, OS);
+        break;
+      default:
+        errs() << "Unknown import type: " << Import.Kind;
+        return 1;
+    }
+  }
+  return 0;
+}
+
+int WasmWriter::writeSectionContent(raw_ostream &OS,
+                                    WasmYAML::FunctionSection &Section) {
+  encodeULEB128(Section.FunctionTypes.size(), OS);
+  for (uint32_t FuncType : Section.FunctionTypes) {
+    encodeULEB128(FuncType, OS);
+  }
+  return 0;
+}
+
+int WasmWriter::writeSectionContent(raw_ostream &OS,
+                                    WasmYAML::ExportSection &Section) {
+  encodeULEB128(Section.Exports.size(), OS);
+  for (auto &Export : Section.Exports) {
+    writeStringRef(Export.Name, OS);
+    encodeULEB128(Export.Kind, OS);
+    encodeULEB128(Export.Index, OS);
+  }
+  return 0;
+}
+
+int WasmWriter::writeSectionContent(raw_ostream &OS,
+                                    WasmYAML::StartSection &Section) {
+  encodeULEB128(Section.StartFunction, OS);
+  return 0;
+}
+
+int WasmWriter::writeSectionContent(raw_ostream &OS,
+                                    WasmYAML::TableSection &Section) {
+  encodeULEB128(Section.Tables.size(), OS);
+  for (auto &Table : Section.Tables) {
+    encodeSLEB128(Table.ElemType, OS);
+    writeLimits(Table.TableLimits, OS);
+  }
+  return 0;
+}
+
+int WasmWriter::writeSectionContent(raw_ostream &OS,
+                                    WasmYAML::MemorySection &Section) {
+  encodeULEB128(Section.Memories.size(), OS);
+  for (auto &Mem : Section.Memories) {
+    writeLimits(Mem, OS);
+  }
+  return 0;
+}
+
+int WasmWriter::writeSectionContent(raw_ostream &OS,
+                                    WasmYAML::GlobalSection &Section) {
+  encodeULEB128(Section.Globals.size(), OS);
+  for (auto &Global : Section.Globals) {
+    encodeSLEB128(Global.Type, OS);
+    writeUint8(OS, Global.Mutable);
+    writeInitExpr(Global.InitExpr, OS);
+  }
+  return 0;
+}
+
+int WasmWriter::writeSectionContent(raw_ostream &OS,
+                                    WasmYAML::ElemSection &Section) {
+  encodeULEB128(Section.Segments.size(), OS);
+  for (auto &Segment : Section.Segments) {
+    encodeULEB128(Segment.TableIndex, OS);
+    writeInitExpr(Segment.Offset, OS);
+
+    encodeULEB128(Segment.Functions.size(), OS);
+    for (auto &Function : Segment.Functions) {
+      encodeULEB128(Function, OS);
+    }
+  }
+  return 0;
+}
+
+int WasmWriter::writeSectionContent(raw_ostream &OS,
+                                    WasmYAML::CodeSection &Section) {
+  Section.Content.writeAsBinary(OS);
+  return 0;
+}
+
+int WasmWriter::writeSectionContent(raw_ostream &OS,
+                                    WasmYAML::DataSection &Section) {
+  encodeULEB128(Section.Segments.size(), OS);
+  for (auto &Segment : Section.Segments) {
+    encodeULEB128(Segment.Index, OS);
+    writeInitExpr(Segment.Offset, OS);
+    encodeULEB128(Segment.Content.binary_size(), OS);
+    Segment.Content.writeAsBinary(OS);
+  }
+  return 0;
+}
+
+int WasmWriter::writeWasm(raw_ostream &OS) {
+  // Write headers
+  OS.write(wasm::WasmMagic, sizeof(wasm::WasmMagic));
+  writeUint32(OS, Obj.Header.Version);
+
+  // Write each section
+  for (const std::unique_ptr<WasmYAML::Section> &Sec : Obj.Sections) {
+    encodeULEB128(Sec->Type, OS);
+
+    std::string OutString;
+    raw_string_ostream StringStream(OutString);
+    if (auto S = dyn_cast<WasmYAML::TypeSection>(Sec.get())) {
+      if (auto Err = writeSectionContent(StringStream, *S))
+        return Err;
+    } else if (auto S = dyn_cast<WasmYAML::ImportSection>(Sec.get())) {
+      if (auto Err = writeSectionContent(StringStream, *S))
+        return Err;
+    } else if (auto S = dyn_cast<WasmYAML::FunctionSection>(Sec.get())) {
+      if (auto Err = writeSectionContent(StringStream, *S))
+        return Err;
+    } else if (auto S = dyn_cast<WasmYAML::TableSection>(Sec.get())) {
+      if (auto Err = writeSectionContent(StringStream, *S))
+        return Err;
+    } else if (auto S = dyn_cast<WasmYAML::MemorySection>(Sec.get())) {
+      if (auto Err = writeSectionContent(StringStream, *S))
+        return Err;
+    } else if (auto S = dyn_cast<WasmYAML::GlobalSection>(Sec.get())) {
+      if (auto Err = writeSectionContent(StringStream, *S))
+        return Err;
+    } else if (auto S = dyn_cast<WasmYAML::ExportSection>(Sec.get())) {
+      if (auto Err = writeSectionContent(StringStream, *S))
+        return Err;
+    } else if (auto S = dyn_cast<WasmYAML::StartSection>(Sec.get())) {
+      if (auto Err = writeSectionContent(StringStream, *S))
+        return Err;
+    } else if (auto S = dyn_cast<WasmYAML::ElemSection>(Sec.get())) {
+      if (auto Err = writeSectionContent(StringStream, *S))
+        return Err;
+    } else if (auto S = dyn_cast<WasmYAML::CodeSection>(Sec.get())) {
+      if (auto Err = writeSectionContent(StringStream, *S))
+        return Err;
+    } else if (auto S = dyn_cast<WasmYAML::DataSection>(Sec.get())) {
+      if (auto Err = writeSectionContent(StringStream, *S))
+        return Err;
+    } else {
+      errs() << "Unknown section type: " << Sec->Type << "\n";
+      return 1;
+    }
+    StringStream.flush();
+
+    // Write the section size followed by the content
+    encodeULEB128(OutString.size(), OS);
+    OS << OutString;
+  }
+
+  return 0;
+}
+
+int yaml2wasm(llvm::WasmYAML::Object &Doc, raw_ostream &Out) {
+  WasmWriter Writer(Doc);
+
+  return Writer.writeWasm(Out);
+}