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

10

implement->implements

11

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)

35

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

41

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?

59

commented-out code.

69

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

include/llvm/ObjectYAML/WasmYAML.h

41

WasmYAML

57

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

11

alphabetize includes.

22

What does R stand for? return value?

26

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

31

Can any of these be static or anonymous namespace?

46

Does this function have any way to fail?

57

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?

80

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

262

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".

267

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

22

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

46

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 ↗

(On Diff #76164)

Could be WASM-NEXT:

test/tools/llvm-readobj/sections.test

497 ↗

(On Diff #76164)

also WASM-NEXT

tools/llvm-readobj/WasmDumper.cpp

62 ↗

(On Diff #76164)

llvm_unreachable()

tools/obj2yaml/wasm2yaml.cpp

41

these new foo lines could be use auto*

tools/yaml2obj/yaml2wasm.cpp

43 ↗

(On Diff #76164)

could writeUint{32,64} be a template?

45 ↗

(On Diff #76164)

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

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

43 ↗

(On Diff #76164)

Support/Endian.h has write64le.

[sbc100]

• Fixes based on code review

[sbc100]

tools/yaml2obj/yaml2wasm.cpp

43 ↗

(On Diff #76164)

Switched to write64le / write32le

[sunfish]

lib/Object/WasmObjectFile.cpp

200

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

93

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

93

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

200

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:
   createCOFFObjectFile(MemoryBufferRef Object);
 
   static ErrorOr<std::unique_ptr<ObjectFile>>
   createELFObjectFile(MemoryBufferRef Object);
 
   static Expected<std::unique_ptr<MachOObjectFile>>
   createMachOObjectFile(MemoryBufferRef Object);
 
+  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

+//===- Wasm.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 implement the ObjectFile
+// interface for Wasm files.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_OBJECT_WASM_H
+#define LLVM_OBJECT_WASM_H
+
+#include "llvm/Object/ObjectFile.h"
+
+namespace llvm {
+namespace object {
+
+struct WasmObjectHeader {
+  StringRef Magic;
+  uint32_t Version;
+};
+
+struct WasmSection {
+  uint32_t Offset;
+  uint32_t Kind;
+  uint32_t Size;
+  const uint8_t* Start;
+};
+
+class WasmObjectFile : public ObjectFile {
+public:
+  WasmObjectFile(MemoryBufferRef Object, Error &Err);
+  const WasmObjectHeader &getHeader() const;
+  const WasmSection *getWasmSection(const SectionRef &Section) const;
+
+protected:
+  WasmObjectHeader Header;
+  std::vector<WasmSection> Sections;
+
+  const uint8_t *getPtr(size_t Offset) const;
+
+  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;
+
+  //std::error_code printSymbolName(raw_ostream &OS,
+                                  //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;
+
+  // Same as above for 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;
+
+  // Same as above for 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;
+};
+
+}
+}
+
+#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/ObjectYAML/YAML.h"
+
+namespace llvm {
+namespace WasmYAML {
+
+struct FileHeader {
+  StringRef Magic;
+  llvm::yaml::Hex32 Version;
+};
+
+struct Section {
+  uint32_t Kind;
+  llvm::yaml::Hex32 Offset;
+  llvm::yaml::Hex32 Size;
+  yaml::BinaryRef Content;
+};
+
+struct Object {
+  FileHeader Header;
+  std::vector<std::unique_ptr<Section>> Sections;
+};
+
+} // namespace llvm::MachOYAML
+} // namespace llvm
+
+LLVM_YAML_IS_SEQUENCE_VECTOR(std::unique_ptr<llvm::WasmYAML::Section>)
+
+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);
+  //static StringRef validate(IO &io, std::unique_ptr<WasmYAML::Section> &Section);
+};
+
+template <>
+struct MappingTraits<WasmYAML::Object> {
+  static void mapping(IO &IO, WasmYAML::Object &Object);
+};
+
+} // 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) {}

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/LEB128.h"
+#include "llvm/Support/Host.h"
+
+#include <iostream>
+
+namespace llvm {
+namespace object {
+
+Expected<std::unique_ptr<WasmObjectFile>>
+ObjectFile::createWasmObjectFile(MemoryBufferRef Buffer) {
+  Error Err;
+  std::unique_ptr<WasmObjectFile> R;
+
+  R.reset(new WasmObjectFile(Buffer, Err));
+  if (Err)
+     std::move(Err);
+
+  return std::move(R);
+}
+
+uint32_t readUint32(const uint8_t *Ptr) {
+  uint32_t Result = 0;
+  memcpy(&Result, Ptr, sizeof(Result));
+  if (!sys::IsLittleEndianHost)
+    sys::swapByteOrder(Result);
+  return Result;
+}
+
+uint64_t readULEB128(const uint8_t *&Ptr) {
+  unsigned Count;
+  uint64_t Result = decodeULEB128(Ptr, &Count);
+  Ptr += Count;
+  return Result;
+}
+
+void readSection(WasmSection &Section, const uint8_t *&Ptr, const uint8_t *Start) {
+  Section.Offset = Ptr - Start;
+  Section.Kind = readULEB128(Ptr);
+  Section.Size = readULEB128(Ptr);
+  Section.Start = Ptr;
+  Ptr += Section.Size;
+}
+
+WasmObjectFile::WasmObjectFile(MemoryBufferRef Buffer, Error &Err)
+    : ObjectFile(Binary::ID_WASM, Buffer) {
+  Header.Magic = getData().substr(0, 4);
+  Header.Version = readUint32(getPtr(4));
+  if (Header.Magic != StringRef("\0asm", 4)) {
+    Err = make_error<GenericBinaryError>("Bad magic number",
+                     object_error::invalid_file_type);
+  }
+  const uint8_t* Ptr = getPtr(8);
+  const uint8_t* Eof = getPtr(getData().size());
+  WasmSection Sec;
+  while (Ptr < Eof) {
+    readSection(Sec, Ptr, getPtr(0));
+    Sections.push_back(Sec);
+  }
+}
+
+const uint8_t *WasmObjectFile::getPtr(size_t Offset) const {
+  return (const uint8_t*)getData().substr(Offset, 1).data();
+}
+
+const WasmObjectHeader& WasmObjectFile::getHeader() const {
+  return Header;
+}
+
+void WasmObjectFile::moveSymbolNext(DataRefImpl &Symb) const {
+  assert(0);
+}
+
+std::error_code WasmObjectFile::printSymbolName(raw_ostream &OS,
+                                          DataRefImpl Symb) const {
+  assert(0);
+  return object_error::invalid_file_type;
+}
+
+uint32_t WasmObjectFile::getSymbolFlags(DataRefImpl Symb) const {
+  assert(0);
+  return 0;
+}
+
+basic_symbol_iterator WasmObjectFile::symbol_begin_impl() const {
+  assert(0);
+  return BasicSymbolRef(DataRefImpl(), this);
+}
+
+basic_symbol_iterator WasmObjectFile::symbol_end_impl() const {
+  assert(0);
+  return BasicSymbolRef(DataRefImpl(), this);
+}
+
+Expected<StringRef> WasmObjectFile::getSymbolName(DataRefImpl Symb) const {
+  assert(0);
+  return errorCodeToError(object_error::invalid_file_type);
+}
+
+Expected<uint64_t> WasmObjectFile::getSymbolAddress(DataRefImpl Symb) const {
+  assert(0);
+  return errorCodeToError(object_error::invalid_file_type);
+}
+
+uint64_t WasmObjectFile::getSymbolValueImpl(DataRefImpl Symb) const {
+  assert(0);
+  return 0;
+}
+
+uint32_t WasmObjectFile::getSymbolAlignment(DataRefImpl Symb) const {
+  assert(0);
+  return 0;
+}
+
+uint64_t WasmObjectFile::getCommonSymbolSizeImpl(DataRefImpl Symb) const {
+  assert(0);
+  return 0;
+}
+
+Expected<SymbolRef::Type> WasmObjectFile::getSymbolType(DataRefImpl Symb) const {
+  assert(0);
+  return errorCodeToError(object_error::invalid_file_type);
+}
+
+Expected<section_iterator> WasmObjectFile::getSymbolSection(DataRefImpl Symb) const {
+  assert(0);
+  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 {
+  assert(0);
+  return object_error::invalid_file_type;
+}
+
+uint64_t WasmObjectFile::getSectionAddress(DataRefImpl Sec) const {
+  assert(0);
+  return 0;
+}
+
+uint64_t WasmObjectFile::getSectionSize(DataRefImpl Sec) const {
+  assert(0);
+  return 0;
+}
+
+std::error_code WasmObjectFile::getSectionContents(DataRefImpl Sec,
+                                                   StringRef &Res) const {
+  assert(0);
+  return object_error::invalid_file_type;
+}
+
+uint64_t WasmObjectFile::getSectionAlignment(DataRefImpl Sec) const {
+  assert(0);
+  return 1;
+}
+
+bool WasmObjectFile::isSectionCompressed(DataRefImpl Sec) const {
+  assert(0);
+  return false;
+}
+
+bool WasmObjectFile::isSectionText(DataRefImpl Sec) const {
+  assert(0);
+  return false;
+}
+
+bool WasmObjectFile::isSectionData(DataRefImpl Sec) const {
+  assert(0);
+  return false;
+}
+
+bool WasmObjectFile::isSectionBSS(DataRefImpl Sec) const {
+  assert(0);
+  return false;
+}
+
+bool WasmObjectFile::isSectionVirtual(DataRefImpl Sec) const {
+  assert(0);
+  return false;
+}
+
+bool WasmObjectFile::isSectionBitcode(DataRefImpl Sec) const {
+  assert(0);
+  return false;
+}
+
+relocation_iterator WasmObjectFile::section_rel_begin(DataRefImpl Sec) const {
+  assert(0);
+  RelocationRef Rel;
+  return relocation_iterator(Rel);
+}
+
+relocation_iterator WasmObjectFile::section_rel_end(DataRefImpl Sec) const {
+  assert(0);
+  RelocationRef Rel;
+  return relocation_iterator(Rel);
+}
+
+section_iterator WasmObjectFile::getRelocatedSection(DataRefImpl Sec) const {
+  assert(0);
+  SectionRef Ref;
+  return section_iterator(Ref);
+}
+
+void WasmObjectFile::moveRelocationNext(DataRefImpl &Rel) const {
+  assert(0);
+}
+
+uint64_t WasmObjectFile::getRelocationOffset(DataRefImpl Rel) const {
+  assert(0);
+  return 0;
+}
+
+symbol_iterator WasmObjectFile::getRelocationSymbol(DataRefImpl Rel) const {
+  assert(0);
+  SymbolRef Ref;
+  return symbol_iterator(Ref);
+}
+
+uint64_t WasmObjectFile::getRelocationType(DataRefImpl Rel) const {
+  assert(0);
+  return 0;
+}
+
+void WasmObjectFile::getRelocationTypeName(DataRefImpl Rel,
+                                           SmallVectorImpl<char> &Result) const {
+  assert(0);
+}
+
+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 {
+  assert(0);
+  return 0;
+}
+
+StringRef WasmObjectFile::getFileFormatName() const {
+  assert(0);
+  return "wasm32";
+}
+
+unsigned WasmObjectFile::getArch() const {
+  assert(0);
+  return Triple::UnknownArch;
+}
+
+bool WasmObjectFile::isRelocatableObject() const {
+  assert(0);
+  return false;
+}
+
+const 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/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/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("Magic", FileHdr.Magic);
+  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);
+}
+
+void MappingTraits<std::unique_ptr<WasmYAML::Section>>::mapping(
+    IO &IO,
+    std::unique_ptr<WasmYAML::Section> &Section) {
+  IO.mapRequired("Kind", Section->Kind);
+  IO.mapRequired("Offset", Section->Offset);
+  IO.mapRequired("Size", Section->Size);
+  IO.mapRequired("Content", Section->Content);
+}
+
+} // 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':

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/coff2yaml.cpp

-//===------ utils/obj2yaml.cpp - obj2yaml conversion tool -------*- C++ -*-===//
+//===------ utils/coff2yaml.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.
 //
 //===----------------------------------------------------------------------===//
 

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.Magic = Obj.getHeader().Magic;
+  Y->Header.Version = Obj.getHeader().Version;
+
+  // Dump sections
+  for (const auto &Sec : Obj.sections()) {
+    const object::WasmSection* WasmSec = Obj.getWasmSection(Sec);
+    WasmYAML::Section* S = new WasmYAML::Section;
+    S->Kind = WasmSec->Kind;
+    S->Offset = WasmSec->Offset;
+    S->Size = WasmSec->Size;
+    ArrayRef<uint8_t> Content(WasmSec->Start, WasmSec->Size);
+    S->Content = yaml::BinaryRef(Content);
+    Y->Sections.push_back(std::unique_ptr<WasmYAML::Section>(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();
+}