[llvm-strip] Add WebAssembly support

[paolosev]

Summary

The DWARF debug info for a WebAssembly module is currently embedded within the module in a sequence custom sections, whose name matches the DWARF section name as defined in the DWARF standard (e.g. .debug_info or .debug_line).
It should be possible to export the debug info into a separate, external file and in that case a custom section named "external_debug_info" should be added to the original module. The "external_debug_info" section should contain an UTF-8 encoded URL to the external debug info file (see https://yurydelendik.github.io/webassembly-dwarf/ for more details).

This patch modifies llvm-strip and llvm-objcopy to also work with Wasm modules.
Several existing options should work also for Wasm files:

• -g, --strip-debug, -S, --strip-all, --strip-all-gnu -x, --discard-all, --strip-unneeded (Remove all DWARF custom sections from a Wasm file).
• -R, --remove-section (Remove the sections listed).
• -j, --only-section (Remove all sections but the one listed).

Note that Wasm custom sections can be referred by their name, while the standard sections can be referred by their id (1:Type, 2: Import, ... 10: Code, and so on).

Two new options should be introduced, specific for Wasm modules:

--wasm-split-debug <wasm-sym-file> should behave like --split-dwo does for ELF files: extract the debug information into a separate file and strip the debug sections from the input file.
(Note: not sure if we could instead reuse the existing --split-dwo here, but we are not really dealing with DWO files, so that would be confusing).

--wasm-debug-info-url <dwarf-url> should be used to specify the URL of the DWARF debug info file created with --wasm-split-debug. This URL will be embedded in the "external_debug_info" custom section of the original file. If not specified, use the output file path of --wasm-split-debug as default value.

[sbc100]

Is this an in-flight collision with https://reviews.llvm.org/D70930?

[paolosev]

Doh! I didn't know there was this work ongoing.
I think we could maybe continue from there, once https://reviews.llvm.org/D70930 is merged; what I would like is to have something like --split-dwo that works with WASM files and only extracts DWARF sections.

[jhenderson]

It's worth also noting that if you want to contribute to the ongoing effort to add support for WASM in llvm-objcopy and llvm-strip, it's best to do it in small pieces (typically one option at a time), to make it easier to review, and don't forget to add testing!

llvm/tools/llvm-objcopy/CMakeLists.txt

add_llvm_tool(llvm-objcopy
   ELF/ELFConfig.cpp
   ELF/ELFObjcopy.cpp
   ELF/Object.cpp
   MachO/MachOObjcopy.cpp
   MachO/MachOReader.cpp
   MachO/MachOWriter.cpp
   MachO/MachOLayoutBuilder.cpp
   MachO/Object.cpp
+  Wasm/Object.cpp
+  Wasm/Reader.cpp
+  Wasm/Writer.cpp
+  Wasm/WasmObjcopy.cpp
   DEPENDS
   ObjcopyOptsTableGen
   InstallNameToolOptsTableGen
   StripOptsTableGen
   )
 
 add_llvm_tool_symlink(llvm-install-name-tool llvm-objcopy)
 add_llvm_tool_symlink(llvm-strip llvm-objcopy)
 
 if(LLVM_INSTALL_BINUTILS_SYMLINKS)
   add_llvm_tool_symlink(objcopy llvm-objcopy)
   add_llvm_tool_symlink(strip llvm-objcopy)
 endif()

llvm/tools/llvm-objcopy/CopyConfig.h

struct CopyConfig {
   Optional<StringRef> BuildIdLinkOutput;
   Optional<StringRef> ExtractPartition;
   StringRef SplitDWO;
   StringRef SymbolsPrefix;
   StringRef AllocSectionsPrefix;
   DiscardType DiscardMode = DiscardType::None;
   Optional<StringRef> NewSymbolVisibility;
 
+  // WebAssembly only
+  StringRef WasmSplitDebug;
+  StringRef WasmDebugInfoUrl;
+
   // Repeated options
   std::vector<StringRef> AddSection;
   std::vector<StringRef> DumpSection;
   std::vector<StringRef> SymbolsToAdd;
   std::vector<StringRef> RPathToAdd;
 
   // Section matchers
   NameMatcher KeepSection;

llvm/tools/llvm-objcopy/CopyConfig.cpp

parseObjcopyOptions(ArrayRef<const char *> ArgsArr,
   Config.BuildIdLinkDir = InputArgs.getLastArgValue(OBJCOPY_build_id_link_dir);
   if (InputArgs.hasArg(OBJCOPY_build_id_link_input))
     Config.BuildIdLinkInput =
         InputArgs.getLastArgValue(OBJCOPY_build_id_link_input);
   if (InputArgs.hasArg(OBJCOPY_build_id_link_output))
     Config.BuildIdLinkOutput =
         InputArgs.getLastArgValue(OBJCOPY_build_id_link_output);
   Config.SplitDWO = InputArgs.getLastArgValue(OBJCOPY_split_dwo);
+  Config.WasmSplitDebug = InputArgs.getLastArgValue(OBJCOPY_wasm_split_debug);
+  Config.WasmDebugInfoUrl =
+      InputArgs.getLastArgValue(OBJCOPY_wasm_debug_info_url);
   Config.SymbolsPrefix = InputArgs.getLastArgValue(OBJCOPY_prefix_symbols);
   Config.AllocSectionsPrefix =
       InputArgs.getLastArgValue(OBJCOPY_prefix_alloc_sections);
   if (auto Arg = InputArgs.getLastArg(OBJCOPY_extract_partition))
     Config.ExtractPartition = Arg->getValue();
 
   for (auto Arg : InputArgs.filtered(OBJCOPY_redefine_symbol)) {
     if (!StringRef(Arg->getValue()).contains('='))

llvm/tools/llvm-objcopy/ObjcopyOpts.td

 
 defm add_symbol
     : Eq<"add-symbol", "Add new symbol <name> to .symtab. Accepted flags: "
          "global, local, weak, default, hidden, protected, file, section, object, "
          "function, indirect-function. Accepted but ignored for "
          "compatibility: debug, constructor, warning, indirect, synthetic, "
          "unique-object, before.">,
       MetaVarName<"name=[section:]value[,flags]">;
+
+defm wasm_split_debug
+    : Eq<"wasm-split-debug", "For a Wasm module, extract all debug sections "
+                           "from the input file to <wasm-sym-file>, then "
+                             "strip-debug on the input file.">,
+      MetaVarName<"wasm-sym-file">;
+
+defm wasm_debug_info_url
+    : Eq<"wasm-debug-info-url", "For a Wasm module, specify the locatiuon of "
+                                "the debug info file created with "
+                "--wasm-split-debug.">,
+      MetaVarName<"dwarf-url">;

llvm/tools/llvm-objcopy/Wasm/Object.h

+//===- Object.h -------------------------------------------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_TOOLS_OBJCOPY_WASM_OBJECT_H
+#define LLVM_TOOLS_OBJCOPY_WASM_OBJECT_H
+
+#include "llvm/ADT/ArrayRef.h"
+#include "llvm/ADT/StringRef.h"
+#include "llvm/ADT/iterator_range.h"
+#include "llvm/BinaryFormat/Wasm.h"
+#include "llvm/Object/Wasm.h"
+#include "llvm/Support/LEB128.h"
+
+namespace llvm {
+namespace objcopy {
+namespace wasm {
+
+struct Section {
+  uint32_t Type;
+  StringRef Name; // (Custom sections only)
+
+  Section(uint32_t Type);
+  Section(StringRef Name);
+
+  ArrayRef<uint8_t> getContents() const {
+    if (!OwnedContents.empty())
+      return OwnedContents;
+    return ContentsRef;
+  }
+
+  void setContentsRef(ArrayRef<uint8_t> Data) {
+    OwnedContents.clear();
+    ContentsRef = Data;
+  }
+
+  void setOwnedContents(std::vector<uint8_t> &&Data) {
+    ContentsRef = ArrayRef<uint8_t>();
+    OwnedContents = std::move(Data);
+  }
+
+  size_t getPayloadLength() const {
+    size_t ContentSize = getContents().size();
+    size_t NameSize = Type != llvm::wasm::WASM_SEC_CUSTOM
+                          ? 0
+                          : llvm::getULEB128Size(Name.size()) + Name.size();
+    return ContentSize + NameSize;
+  }
+
+  size_t getSize() const {
+    size_t PayloadLen = getPayloadLength();
+    size_t SectionSize =
+        sizeof(uint8_t) + llvm::getULEB128Size(PayloadLen) + PayloadLen;
+    return SectionSize;
+  }
+
+private:
+  ArrayRef<uint8_t> ContentsRef;
+  std::vector<uint8_t> OwnedContents;
+};
+
+struct Object {
+  llvm::wasm::WasmObjectHeader WasmHeader;
+
+  Object();
+
+  ArrayRef<Section> getSections() const { return Sections; }
+  iterator_range<std::vector<Section>::iterator> getMutableSections() {
+    return make_range(Sections.begin(), Sections.end());
+  }
+
+  void addSections(ArrayRef<Section> NewSections);
+  void removeSections(function_ref<bool(const Section &)> ToRemove);
+
+  void setExternalDebugInfoSection(StringRef ExternalDebugInfoUrl);
+
+private:
+  std::vector<Section> Sections;
+};
+
+} // end namespace wasm
+} // end namespace objcopy
+} // end namespace llvm
+
+#endif // LLVM_TOOLS_OBJCOPY_WASM_OBJECT_H

llvm/tools/llvm-objcopy/Wasm/Object.cpp

+//===- Object.cpp ---------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "Object.h"
+#include "Buffer.h"
+#include <algorithm>
+
+namespace llvm {
+namespace objcopy {
+namespace wasm {
+
+using namespace object;
+
+static const std::string WasmSectionNames[14] = {
+    "",       "type",  "import",  "function", "table", "memory",    "global",
+    "export", "start", "element", "code",     "data",  "datacount", "event"};
+
+Section::Section(uint32_t SectionType) : Type(SectionType) {
+  assert(SectionType > llvm::wasm::WASM_SEC_CUSTOM &&
+         SectionType <= llvm::wasm::WASM_SEC_EVENT);
+  Name = StringRef(WasmSectionNames[SectionType]);
+}
+
+Section::Section(StringRef SectionName)
+    : Type(llvm::wasm::WASM_SEC_CUSTOM), Name(SectionName) {}
+
+Object::Object() {
+  WasmHeader.Magic = {llvm::wasm::WasmMagic, sizeof(llvm::wasm::WasmMagic)};
+  WasmHeader.Version = llvm::wasm::WasmVersion;
+}
+
+void Object::addSections(ArrayRef<Section> NewSections) {
+  for (Section S : NewSections) {
+    Sections.emplace_back(S);
+  }
+}
+
+void Object::removeSections(function_ref<bool(const Section &)> ToRemove) {
+  Sections.erase(
+      std::remove_if(std::begin(Sections), std::end(Sections),
+                     [ToRemove](const Section &Sec) { return ToRemove(Sec); }),
+      std::end(Sections));
+}
+
+void Object::setExternalDebugInfoSection(StringRef ExternalDebugInfoUrl) {
+  static const StringRef ExternalDebugInfoSectionName("external_debug_info");
+
+  removeSections([](const Section &Section) {
+    return Section.Name == ExternalDebugInfoSectionName;
+  });
+
+  uint32_t UrlLen = ExternalDebugInfoUrl.size();
+  uint32_t ContentSize = llvm::getULEB128Size(UrlLen) + UrlLen;
+
+  std::vector<uint8_t> Buf(ContentSize);
+  uint8_t *Ptr = &Buf[0];
+  Ptr += llvm::encodeULEB128(UrlLen, Ptr);
+  memcpy(Ptr, reinterpret_cast<const uint8_t *>(ExternalDebugInfoUrl.data()),
+         UrlLen);
+  Ptr += UrlLen;
+  assert(Ptr - &Buf[0] == ContentSize);
+
+  Section S(ExternalDebugInfoSectionName);
+  S.setOwnedContents(std::move(Buf));
+
+  addSections(ArrayRef<Section>{S});
+}
+
+} // end namespace wasm
+} // end namespace objcopy
+} // end namespace llvm

llvm/tools/llvm-objcopy/Wasm/Reader.h

+//===- Reader.h -------------------------------------------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_TOOLS_OBJCOPY_WASM_READER_H
+#define LLVM_TOOLS_OBJCOPY_WASM_READER_H
+
+#include "Buffer.h"
+#include "llvm/Object/Wasm.h"
+#include "llvm/Support/Error.h"
+
+namespace llvm {
+namespace objcopy {
+namespace wasm {
+
+struct Object;
+
+using object::WasmObjectFile;
+
+class WasmReader {
+public:
+  explicit WasmReader(const WasmObjectFile &O) : WasmObj(O) {}
+
+  Expected<std::unique_ptr<Object>> create() const;
+
+private:
+  Error readSections(Object &Obj) const;
+
+  const WasmObjectFile &WasmObj;
+};
+
+} // end namespace wasm
+} // end namespace objcopy
+} // end namespace llvm
+
+#endif // LLVM_TOOLS_OBJCOPY_WASM_READER_H

llvm/tools/llvm-objcopy/Wasm/Reader.cpp

+//===- Reader.cpp ---------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "Reader.h"
+#include "Object.h"
+
+namespace llvm {
+namespace objcopy {
+namespace wasm {
+
+using namespace object;
+
+Error WasmReader::readSections(Object &Obj) const {
+  std::vector<Section> Sections;
+  for (section_iterator SI = WasmObj.section_begin(),
+                        SE = WasmObj.section_end();
+       SI != SE; ++SI) {
+    const SectionRef &section_ref = *SI;
+    const WasmSection &section = WasmObj.getWasmSection(section_ref);
+
+    if (section.Type != llvm::wasm::WASM_SEC_CUSTOM) {
+      assert(section.Type <= llvm::wasm::WASM_SEC_EVENT);
+      Sections.push_back(Section(section.Type));
+    } else
+      Sections.push_back(Section(section.Name));
+
+    DataRefImpl data_ref = section_ref.getRawDataRefImpl();
+    Expected<ArrayRef<uint8_t>> ErrorOrContents =
+        WasmObj.getSectionContents(data_ref);
+    if (!ErrorOrContents)
+      return ErrorOrContents.takeError();
+
+    Section &S = Sections.back();
+    S.setContentsRef(ErrorOrContents.get());
+  }
+
+  Obj.addSections(Sections);
+  return Error::success();
+}
+
+Expected<std::unique_ptr<Object>> WasmReader::create() const {
+  auto Obj = std::make_unique<Object>();
+
+  if (Error E = readSections(*Obj))
+    return std::move(E);
+
+  return std::move(Obj);
+}
+
+} // end namespace wasm
+} // end namespace objcopy
+} // end namespace llvm

llvm/tools/llvm-objcopy/Wasm/WasmObjcopy.h

+//===- WasmObjcopy.h --------------------------------------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_TOOLS_OBJCOPY_WASMOBJCOPY_H
+#define LLVM_TOOLS_OBJCOPY_WASMOBJCOPY_H
+
+namespace llvm {
+class Error;
+
+namespace object {
+class WasmObjectFile;
+} // end namespace object
+
+namespace objcopy {
+struct CopyConfig;
+class Buffer;
+
+namespace wasm {
+Error executeObjcopyOnBinary(const CopyConfig &Config,
+                             object::WasmObjectFile &In, Buffer &Out);
+
+} // end namespace wasm
+} // end namespace objcopy
+} // end namespace llvm
+
+#endif // LLVM_TOOLS_OBJCOPY_WASMOBJCOPY_H

llvm/tools/llvm-objcopy/Wasm/WasmObjcopy.cpp

+//===- WasmObjcopy.cpp ----------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "WasmObjcopy.h"
+#include "CopyConfig.h"
+#include "Object.h"
+#include "Reader.h"
+#include "Writer.h"
+#include "llvm-objcopy.h"
+#include "llvm/Support/Errc.h"
+#include "llvm/Support/Error.h"
+
+namespace llvm {
+namespace objcopy {
+namespace wasm {
+
+static bool isDebugSection(const Section &Sec) {
+  return Sec.Name.startswith(".debug");
+}
+
+static Error splitDwarfToFile(const CopyConfig &Config,
+                              const WasmReader &Reader, StringRef File) {
+  Expected<std::unique_ptr<Object>> ObjOrErr = Reader.create();
+  if (!ObjOrErr)
+    return createFileError(File, ObjOrErr.takeError());
+
+  Object *Obj = ObjOrErr->get();
+  Obj->removeSections([](const Section &Sec) { return !isDebugSection(Sec); });
+
+  FileBuffer Out(File);
+  WasmWriter Writer(*Obj, Out);
+  if (Error E = Writer.write())
+    return createFileError(Config.OutputFilename, std::move(E));
+  return Error::success();
+}
+
+// This function handles the high level operations of GNU objcopy including
+// handling command line options. It's important to outline certain properties
+// we expect to hold of the command line operations. Any operation that "keeps"
+// should keep regardless of a remove. Additionally any removal should respect
+// any previous removals. Lastly whether or not something is removed shouldn't
+// depend a) on the order the options occur in or b) on some opaque priority
+// system. The only priority is that keeps/copies overrule removes.
+static Error handleArgs(const CopyConfig &Config, Object &Obj,
+                        const WasmReader &Reader) {
+  if (!Config.WasmSplitDebug.empty()) {
+    if (Error E = splitDwarfToFile(Config, Reader, Config.WasmSplitDebug))
+      return E;
+
+    // Add or replace "external_debug_info" custom section
+    Obj.setExternalDebugInfoSection(Config.WasmDebugInfoUrl.empty()
+                                        ? Config.WasmSplitDebug
+                                        : Config.WasmDebugInfoUrl);
+  }
+
+  // Perform the actual section removals.
+  Obj.removeSections([&Config](const Section &Sec) {
+    // --only-section fully removes sections that aren't mentioned.
+    if (!Config.OnlySection.empty() && !Config.OnlySection.matches(Sec.Name))
+      return true;
+
+    if (Config.StripDebug || Config.StripAll || Config.StripAllGNU ||
+        !Config.WasmSplitDebug.empty() || Config.StripUnneeded ||
+        Config.DiscardMode == DiscardType::All) {
+      if (isDebugSection(Sec))
+        return true;
+    }
+
+    if (Config.ToRemove.matches(Sec.Name))
+      return true;
+
+    return false;
+  });
+
+  if (!Config.AddGnuDebugLink.empty() || !Config.AddSection.empty() ||
+      !Config.AllocSectionsPrefix.empty() || Config.AllowBrokenLinks ||
+      !Config.BuildIdLinkDir.empty() || Config.BuildIdLinkInput ||
+      Config.BuildIdLinkOutput || Config.DecompressDebugSections ||
+      Config.DiscardMode == DiscardType::Locals ||
+      !Config.DumpSection.empty() || Config.EntryExpr || Config.ExtractDWO ||
+      Config.KeepFileSymbols || Config.LocalizeHidden ||
+      !Config.KeepSection.empty() || Config.NewSymbolVisibility ||
+      Config.OnlyKeepDebug || Config.PreserveDates ||
+      !Config.SectionsToRename.empty() || !Config.SetSectionAlignment.empty() ||
+      !Config.SetSectionFlags.empty() || !Config.SplitDWO.empty() ||
+      Config.StripDWO || Config.StripNonAlloc || Config.StripSections ||
+      !Config.SymbolsPrefix.empty() || !Config.SymbolsToAdd.empty() ||
+      !Config.SymbolsToGlobalize.empty() || !Config.SymbolsToKeep.empty() ||
+      !Config.SymbolsToKeepGlobal.empty() ||
+      !Config.SymbolsToLocalize.empty() || !Config.SymbolsToRemove.empty() ||
+      !Config.SymbolsToWeaken.empty() ||
+      !Config.UnneededSymbolsToRemove.empty() || Config.Weaken) {
+    return createStringError(llvm::errc::invalid_argument,
+                             "option not supported by llvm-objcopy for WASM");
+  }
+
+  return Error::success();
+}
+
+Error executeObjcopyOnBinary(const CopyConfig &Config,
+                             object::WasmObjectFile &In, Buffer &Out) {
+  WasmReader Reader(In);
+  Expected<std::unique_ptr<Object>> ObjOrErr = Reader.create();
+  if (!ObjOrErr)
+    return createFileError(Config.InputFilename, ObjOrErr.takeError());
+
+  Object *Obj = ObjOrErr->get();
+  assert(Obj && "Unable to deserialize Wasm object");
+
+  if (Error E = handleArgs(Config, *Obj, Reader))
+    return createFileError(Config.InputFilename, std::move(E));
+
+  WasmWriter Writer(*Obj, Out);
+  if (Error E = Writer.write())
+    return createFileError(Config.OutputFilename, std::move(E));
+
+  return Error::success();
+}
+
+} // end namespace wasm
+} // end namespace objcopy
+} // end namespace llvm

llvm/tools/llvm-objcopy/Wasm/Writer.h

+//===- Writer.h -------------------------------------------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_TOOLS_OBJCOPY_WASM_WRITER_H
+#define LLVM_TOOLS_OBJCOPY_WASM_WRITER_H
+
+#include "Buffer.h"
+#include "llvm/Support/Error.h"
+
+namespace llvm {
+namespace objcopy {
+namespace wasm {
+
+struct Object;
+
+class WasmWriter {
+public:
+  WasmWriter(const Object &Obj, Buffer &Buf) : Obj(Obj), Buf(Buf) {}
+
+  Error write();
+
+private:
+  size_t calculateFileSize() const;
+  size_t headerSize() const;
+  void writeHeader();
+  void writeSections();
+
+  const Object &Obj;
+  Buffer &Buf;
+};
+
+} // end namespace wasm
+} // end namespace objcopy
+} // end namespace llvm
+
+#endif // LLVM_TOOLS_OBJCOPY_WASM_WRITER_H

llvm/tools/llvm-objcopy/Wasm/Writer.cpp

+//===- Writer.cpp ---------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "Writer.h"
+#include "Object.h"
+#include "llvm/Object/Wasm.h"
+#include "llvm/Support/LEB128.h"
+
+namespace llvm {
+namespace objcopy {
+namespace wasm {
+
+size_t WasmWriter::headerSize() const {
+  return Obj.WasmHeader.Magic.size() + sizeof(Obj.WasmHeader.Version);
+}
+
+void WasmWriter::writeHeader() {
+  uint8_t *Ptr = Buf.getBufferStart();
+
+  memcpy(Ptr, Obj.WasmHeader.Magic.data(), Obj.WasmHeader.Magic.size());
+  Ptr += Obj.WasmHeader.Magic.size();
+
+  memcpy(Ptr, &Obj.WasmHeader.Version, sizeof(Obj.WasmHeader.Version));
+  Ptr += sizeof(Obj.WasmHeader.Version);
+}
+
+void WasmWriter::writeSections() {
+  uint8_t *Ptr = Buf.getBufferStart() + headerSize();
+  for (const auto &section : Obj.getSections()) {
+    *Ptr++ = section.Type;
+    Ptr += llvm::encodeULEB128(section.getPayloadLength(), Ptr);
+    if (section.Type == llvm::wasm::WASM_SEC_CUSTOM) {
+      Ptr += llvm::encodeULEB128(section.Name.size(), Ptr);
+      memcpy(Ptr, section.Name.data(), section.Name.size());
+      Ptr += section.Name.size();
+    }
+    memcpy(Ptr, section.getContents().data(), section.getContents().size());
+    Ptr += section.getContents().size();
+  }
+  assert(Ptr - Buf.getBufferStart() == calculateFileSize());
+}
+
+size_t WasmWriter::calculateFileSize() const {
+  size_t FileSize = headerSize();
+  for (const Section &section : Obj.getSections()) {
+    FileSize += section.getSize();
+  }
+  return FileSize;
+}
+
+Error WasmWriter::write() {
+  size_t FileSize = calculateFileSize();
+  if (Error E = Buf.allocate(FileSize))
+    return E;
+
+  writeHeader();
+  writeSections();
+
+  return Buf.commit();
+}
+
+} // end namespace wasm
+} // end namespace objcopy
+} // end namespace llvm

llvm/tools/llvm-objcopy/llvm-objcopy.cpp

 //===- llvm-objcopy.cpp ---------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm-objcopy.h"
 #include "Buffer.h"
+#include "COFF/COFFObjcopy.h"
 #include "CopyConfig.h"
 #include "ELF/ELFObjcopy.h"
-#include "COFF/COFFObjcopy.h"
 #include "MachO/MachOObjcopy.h"
+#include "Wasm/WasmObjcopy.h"
 
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/Twine.h"
 #include "llvm/Object/Archive.h"
 #include "llvm/Object/ArchiveWriter.h"
 #include "llvm/Object/Binary.h"
 #include "llvm/Object/COFF.h"
 #include "llvm/Object/ELFObjectFile.h"
 #include "llvm/Object/ELFTypes.h"
 #include "llvm/Object/Error.h"
 #include "llvm/Object/MachO.h"
+#include "llvm/Object/Wasm.h"
 #include "llvm/Option/Arg.h"
 #include "llvm/Option/ArgList.h"
 #include "llvm/Option/Option.h"
 #include "llvm/Support/Casting.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Error.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/ErrorOr.h"
static Error executeObjcopyOnBinary(CopyConfig &Config, object::Binary &In,
   if (auto *ELFBinary = dyn_cast<object::ELFObjectFileBase>(&In)) {
     if (Error E = Config.parseELFConfig())
       return E;
     return elf::executeObjcopyOnBinary(Config, *ELFBinary, Out);
   } else if (auto *COFFBinary = dyn_cast<object::COFFObjectFile>(&In))
     return coff::executeObjcopyOnBinary(Config, *COFFBinary, Out);
   else if (auto *MachOBinary = dyn_cast<object::MachOObjectFile>(&In))
     return macho::executeObjcopyOnBinary(Config, *MachOBinary, Out);
+  else if (auto *WasmBinary = dyn_cast<object::WasmObjectFile>(&In))
+    return objcopy::wasm::executeObjcopyOnBinary(Config, *WasmBinary, Out);
   else
     return createStringError(object_error::invalid_file_type,
                              "unsupported object file format");
 }
 
 static Error executeObjcopyOnArchive(CopyConfig &Config, const Archive &Ar) {
   std::vector<NewArchiveMember> NewArchiveMembers;
   Error Err = Error::success();