Index: include/llvm/Object/Binary.h
===================================================================
--- include/llvm/Object/Binary.h
+++ include/llvm/Object/Binary.h
@@ -59,6 +59,8 @@
     ID_MachO64L, // MachO 64-bit, little endian
     ID_MachO64B, // MachO 64-bit, big endian
 
+    ID_Wasm,
+
     ID_EndObjects
   };
 
@@ -115,6 +117,10 @@
     return TypeID == ID_COFF;
   }
 
+  bool isWasm() const {
+    return TypeID == ID_Wasm;
+  }
+
   bool isCOFFImportFile() const {
     return TypeID == ID_COFFImportFile;
   }
Index: include/llvm/Object/ObjectFile.h
===================================================================
--- include/llvm/Object/ObjectFile.h
+++ include/llvm/Object/ObjectFile.h
@@ -29,6 +29,7 @@
 class ObjectFile;
 class COFFObjectFile;
 class MachOObjectFile;
+class WasmObjectFile;
 
 class SymbolRef;
 class symbol_iterator;
@@ -302,6 +303,8 @@
   static Expected<std::unique_ptr<MachOObjectFile>>
   createMachOObjectFile(MemoryBufferRef Object);
 
+  static Expected<std::unique_ptr<WasmObjectFile>>
+  createWasmObjectFile(MemoryBufferRef Object);
 };
 
 // Inline function definitions.
Index: include/llvm/Object/Wasm.h
===================================================================
--- /dev/null
+++ include/llvm/Object/Wasm.h
@@ -0,0 +1,131 @@
+//===- 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 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"
+
+namespace llvm {
+namespace object {
+
+static const char WasmMagic[] = { '\0', 'a', 's', 'm' };
+static uint32_t WasmVersion = 0xc;
+
+enum : unsigned {
+  WASM_SEC_UNKNOWN = 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
+};
+
+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;
+  static inline bool classof(const Binary *v) { return v->isWasm(); }
+
+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;
+
+  WasmObjectHeader Header;
+  std::vector<WasmSection> Sections;
+};
+
+}
+}
+
+#endif
Index: include/llvm/ObjectYAML/ObjectYAML.h
===================================================================
--- include/llvm/ObjectYAML/ObjectYAML.h
+++ include/llvm/ObjectYAML/ObjectYAML.h
@@ -14,6 +14,7 @@
 #include "llvm/ObjectYAML/ELFYAML.h"
 #include "llvm/ObjectYAML/COFFYAML.h"
 #include "llvm/ObjectYAML/MachOYAML.h"
+#include "llvm/ObjectYAML/WasmYAML.h"
 
 namespace llvm {
 namespace yaml {
@@ -23,6 +24,7 @@
   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> {
Index: include/llvm/ObjectYAML/WasmYAML.h
===================================================================
--- /dev/null
+++ include/llvm/ObjectYAML/WasmYAML.h
@@ -0,0 +1,66 @@
+//===- 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 {
+  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<Section> Sections;
+};
+
+} // end namespace WasmYAML
+} // end namespace llvm
+
+LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::WasmYAML::Section)
+
+namespace llvm {
+namespace yaml {
+
+template <>
+struct MappingTraits<WasmYAML::FileHeader> {
+  static void mapping(IO &IO, WasmYAML::FileHeader &FileHdr);
+};
+
+template <>
+struct MappingTraits<WasmYAML::Section> {
+  static void mapping(IO &IO, WasmYAML::Section &Section);
+};
+
+template <>
+struct MappingTraits<WasmYAML::Object> {
+  static void mapping(IO &IO, WasmYAML::Object &Object);
+};
+
+} // end namespace yaml
+} // end namespace llvm
+
+#endif
Index: include/llvm/Support/FileSystem.h
===================================================================
--- include/llvm/Support/FileSystem.h
+++ include/llvm/Support/FileSystem.h
@@ -261,7 +261,8 @@
     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 {
Index: lib/Object/Binary.cpp
===================================================================
--- lib/Object/Binary.cpp
+++ lib/Object/Binary.cpp
@@ -63,6 +63,7 @@
     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);
Index: lib/Object/CMakeLists.txt
===================================================================
--- lib/Object/CMakeLists.txt
+++ lib/Object/CMakeLists.txt
@@ -15,6 +15,7 @@
   RecordStreamer.cpp
   SymbolicFile.cpp
   SymbolSize.cpp
+  WasmObjectFile.cpp
 
   ADDITIONAL_HEADER_DIRS
   ${LLVM_MAIN_INCLUDE_DIR}/llvm/Object
Index: lib/Object/ObjectFile.cpp
===================================================================
--- lib/Object/ObjectFile.cpp
+++ lib/Object/ObjectFile.cpp
@@ -13,6 +13,7 @@
 
 #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"
@@ -104,6 +105,8 @@
   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");
 }
Index: lib/Object/SymbolicFile.cpp
===================================================================
--- lib/Object/SymbolicFile.cpp
+++ lib/Object/SymbolicFile.cpp
@@ -57,6 +57,7 @@
   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));
Index: lib/Object/WasmObjectFile.cpp
===================================================================
--- /dev/null
+++ lib/Object/WasmObjectFile.cpp
@@ -0,0 +1,286 @@
+//===- 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/Host.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 {
+
+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) {
+  // TODO(sbc): Avoid reading past EOF in the case of malformed files.
+  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 {
+  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 {
+  llvm_unreachable("not yet implemented");
+  return BasicSymbolRef(DataRefImpl(), this);
+}
+
+basic_symbol_iterator WasmObjectFile::symbol_end_impl() const {
+  llvm_unreachable("not yet implemented");
+  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 {
+  llvm_unreachable("not yet implemented");
+  return object_error::invalid_file_type;
+}
+
+uint64_t WasmObjectFile::getSectionAddress(DataRefImpl Sec) const {
+  llvm_unreachable("not yet implemented");
+  return 0;
+}
+
+uint64_t WasmObjectFile::getSectionSize(DataRefImpl Sec) const {
+  llvm_unreachable("not yet implemented");
+  return 0;
+}
+
+std::error_code WasmObjectFile::getSectionContents(DataRefImpl Sec,
+                                                   StringRef &Res) const {
+  llvm_unreachable("not yet implemented");
+  return object_error::invalid_file_type;
+}
+
+uint64_t WasmObjectFile::getSectionAlignment(DataRefImpl Sec) const {
+  llvm_unreachable("not yet implemented");
+  return 1;
+}
+
+bool WasmObjectFile::isSectionCompressed(DataRefImpl Sec) const {
+  llvm_unreachable("not yet implemented");
+  return false;
+}
+
+bool WasmObjectFile::isSectionText(DataRefImpl Sec) const {
+  llvm_unreachable("not yet implemented");
+  return false;
+}
+
+bool WasmObjectFile::isSectionData(DataRefImpl Sec) const {
+  llvm_unreachable("not yet implemented");
+  return false;
+}
+
+bool WasmObjectFile::isSectionBSS(DataRefImpl Sec) const {
+  llvm_unreachable("not yet implemented");
+  return false;
+}
+
+bool WasmObjectFile::isSectionVirtual(DataRefImpl Sec) const {
+  llvm_unreachable("not yet implemented");
+  return false;
+}
+
+bool WasmObjectFile::isSectionBitcode(DataRefImpl Sec) const {
+  llvm_unreachable("not yet implemented");
+  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 {
+  llvm_unreachable("not yet implemented");
+  return false;
+}
+
+const WasmSection *
+WasmObjectFile::getWasmSection(const SectionRef &Section) const {
+  return &Sections[Section.getRawDataRefImpl().d.a];
+}
+
+} // end namespace object
+} // end namespace llvm
Index: lib/ObjectYAML/CMakeLists.txt
===================================================================
--- lib/ObjectYAML/CMakeLists.txt
+++ lib/ObjectYAML/CMakeLists.txt
@@ -4,4 +4,5 @@
   ELFYAML.cpp
   MachOYAML.cpp
   ObjectYAML.cpp
+  WasmYAML.cpp
   )
Index: lib/ObjectYAML/ObjectYAML.cpp
===================================================================
--- lib/ObjectYAML/ObjectYAML.cpp
+++ lib/ObjectYAML/ObjectYAML.cpp
@@ -43,6 +43,9 @@
       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();
Index: lib/ObjectYAML/WasmYAML.cpp
===================================================================
--- /dev/null
+++ lib/ObjectYAML/WasmYAML.cpp
@@ -0,0 +1,45 @@
+//===- 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("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<WasmYAML::Section>::mapping(
+    IO &IO,
+    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
Index: lib/Support/Path.cpp
===================================================================
--- lib/Support/Path.cpp
+++ lib/Support/Path.cpp
@@ -1008,6 +1008,8 @@
       // 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
Index: tools/llvm-readobj/CMakeLists.txt
===================================================================
--- tools/llvm-readobj/CMakeLists.txt
+++ tools/llvm-readobj/CMakeLists.txt
@@ -16,5 +16,6 @@
   llvm-readobj.cpp
   MachODumper.cpp
   ObjDumper.cpp
+  WasmDumper.cpp
   Win64EHDumper.cpp
   )
Index: tools/llvm-readobj/MachODumper.cpp
===================================================================
--- tools/llvm-readobj/MachODumper.cpp
+++ tools/llvm-readobj/MachODumper.cpp
@@ -1,4 +1,4 @@
-//===-- MachODump.cpp - Object file dumping utility for llvm --------------===//
+//===-- MachODumper.cpp - Object file dumping utility for llvm ------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
Index: tools/llvm-readobj/ObjDumper.h
===================================================================
--- tools/llvm-readobj/ObjDumper.h
+++ tools/llvm-readobj/ObjDumper.h
@@ -94,6 +94,10 @@
                                   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,
Index: tools/llvm-readobj/WasmDumper.cpp
===================================================================
--- /dev/null
+++ tools/llvm-readobj/WasmDumper.cpp
@@ -0,0 +1,88 @@
+//===-- 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* wasmSectionKindToString(uint32_t Kind) {
+  switch (Kind) {
+    case WASM_SEC_UNKNOWN: return "UNKOWNN";
+    case WASM_SEC_TYPE: return "TYPE";
+    case WASM_SEC_IMPORT: return "IMPORT";
+    case WASM_SEC_FUNCTION: return "FUNCTION";
+    case WASM_SEC_TABLE: return "TABLE";
+    case WASM_SEC_MEMORY: return "MEMORY";
+    case WASM_SEC_GLOBAL: return "GLOBAL";
+    case WASM_SEC_EXPORT: return "EXPORT";
+    case WASM_SEC_START: return "START";
+    case WASM_SEC_ELEM: return "ELEM";
+    case WASM_SEC_CODE: return "CODE";
+    case 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 object::WasmSection* WasmSec = Obj->getWasmSection(Section);
+      DictScope SectionD(W, "Section");
+      const char* Kind = wasmSectionKindToString(WasmSec->Kind);
+      W.printHex("Kind", Kind, WasmSec->Kind);
+      W.printNumber("Size", WasmSec->Size);
+      W.printNumber("Offset", WasmSec->Offset);
+    }
+  }
+  void printRelocations() override { assert(0); }
+  void printSymbols() override { assert(0); }
+  void printDynamicSymbols() override { assert(0); }
+  void printUnwindInfo() override { assert(0); }
+  void printStackMap() const override { assert(0); }
+
+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
Index: tools/llvm-readobj/llvm-readobj.cpp
===================================================================
--- tools/llvm-readobj/llvm-readobj.cpp
+++ tools/llvm-readobj/llvm-readobj.cpp
@@ -354,6 +354,8 @@
     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;
 }
Index: tools/obj2yaml/CMakeLists.txt
===================================================================
--- tools/obj2yaml/CMakeLists.txt
+++ tools/obj2yaml/CMakeLists.txt
@@ -9,5 +9,6 @@
   coff2yaml.cpp
   elf2yaml.cpp
   macho2yaml.cpp
+  wasm2yaml.cpp
   Error.cpp
   )
Index: tools/obj2yaml/coff2yaml.cpp
===================================================================
--- tools/obj2yaml/coff2yaml.cpp
+++ tools/obj2yaml/coff2yaml.cpp
@@ -1,4 +1,4 @@
-//===------ utils/obj2yaml.cpp - obj2yaml conversion tool -------*- C++ -*-===//
+//===------ utils/coff2yaml.cpp - obj2yaml conversion tool ------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
Index: tools/obj2yaml/obj2yaml.h
===================================================================
--- tools/obj2yaml/obj2yaml.h
+++ tools/obj2yaml/obj2yaml.h
@@ -14,6 +14,7 @@
 #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>
 
@@ -23,5 +24,7 @@
                          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
Index: tools/obj2yaml/obj2yaml.cpp
===================================================================
--- tools/obj2yaml/obj2yaml.cpp
+++ tools/obj2yaml/obj2yaml.cpp
@@ -24,6 +24,8 @@
     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;
 }
Index: tools/obj2yaml/wasm2yaml.cpp
===================================================================
--- /dev/null
+++ tools/obj2yaml/wasm2yaml.cpp
@@ -0,0 +1,62 @@
+//===------ 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 object::WasmSection* WasmSec = Obj.getWasmSection(Sec);
+    WasmYAML::Section S;
+    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(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();
+}
Index: tools/yaml2obj/CMakeLists.txt
===================================================================
--- tools/yaml2obj/CMakeLists.txt
+++ tools/yaml2obj/CMakeLists.txt
@@ -10,4 +10,5 @@
   yaml2coff.cpp
   yaml2elf.cpp
   yaml2macho.cpp
+  yaml2wasm.cpp
   )
Index: tools/yaml2obj/yaml2obj.h
===================================================================
--- tools/yaml2obj/yaml2obj.h
+++ tools/yaml2obj/yaml2obj.h
@@ -23,6 +23,10 @@
 struct Object;
 }
 
+namespace WasmYAML {
+struct Object;
+}
+
 namespace yaml {
 class Input;
 struct YamlObjectFile;
@@ -32,5 +36,6 @@
 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
Index: tools/yaml2obj/yaml2obj.cpp
===================================================================
--- tools/yaml2obj/yaml2obj.cpp
+++ tools/yaml2obj/yaml2obj.cpp
@@ -57,6 +57,8 @@
         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;
     }
Index: tools/yaml2obj/yaml2wasm.cpp
===================================================================
--- /dev/null
+++ tools/yaml2obj/yaml2wasm.cpp
@@ -0,0 +1,60 @@
+//===- 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/Error.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) {}
+  Error writeWasm(raw_ostream &OS);
+private:
+  WasmYAML::Object &Obj;
+};
+
+static void writeUint32(raw_ostream &OS, uint32_t Value) {
+  char Data[4];
+  if (!sys::IsLittleEndianHost)
+    sys::swapByteOrder(Value);
+  memcpy(Data, &Value, sizeof(Data));
+  OS.write(Data, sizeof(Data));
+}
+
+Error WasmWriter::writeWasm(raw_ostream &OS) {
+  OS.write(object::WasmMagic, sizeof(object::WasmMagic));
+  writeUint32(OS, object::WasmVersion);
+  for (const WasmYAML::Section &S : Obj.Sections) {
+    encodeULEB128(S.Kind, OS);
+    encodeULEB128(S.Size, OS);
+    S.Content.writeAsBinary(OS);
+  }
+  return Error::success();
+}
+
+int yaml2wasm(llvm::WasmYAML::Object &Doc, raw_ostream &Out) {
+  WasmWriter Writer(Doc);
+
+  if (auto Err = Writer.writeWasm(Out)) {
+    errs() << toString(std::move(Err));
+    return 1;
+  }
+  return 0;
+}