[WebAssembly] Wrap definitions in namespace lld { namespace wasm {. NFC

[MaskRay]

Summary

Similar to D68323, but for wasm.

[ruiu]

LGTM

wasm/Driver.cpp

 
 #define DEBUG_TYPE "lld"
 
 using namespace llvm;
 using namespace llvm::object;
 using namespace llvm::sys;
 using namespace llvm::wasm;
 
-using namespace lld;
-using namespace lld::wasm;
-
-Configuration *lld::wasm::config;
+namespace lld {
+namespace wasm {
+Configuration *config;
 
 namespace {
 
 // Create enum with OPT_xxx values for each option in Options.td
 enum {
   OPT_INVALID = 0,
 #define OPTION(_1, _2, ID, _4, _5, _6, _7, _8, _9, _10, _11, _12) OPT_##ID,
 #include "Options.inc"
private:
 
   // True if we are in --whole-archive and --no-whole-archive.
   bool inWholeArchive = false;
 
   std::vector<InputFile *> files;
 };
 } // anonymous namespace
 
-bool lld::wasm::link(ArrayRef<const char *> args, bool canExitEarly,
-                     raw_ostream &error) {
+bool link(ArrayRef<const char *> args, bool canExitEarly, raw_ostream &error) {
   errorHandler().logName = args::getFilenameWithoutExe(args[0]);
   errorHandler().errorOS = &error;
   errorHandler().errorLimitExceededMsg =
       "too many errors emitted, stopping now (use "
       "-error-limit=0 to see all errors)";
   enableColors(error.has_colors());
 
   config = make<Configuration>();
if (errorCount())
     return;
 
   // Do size optimizations: garbage collection
   markLive();
 
   // Write the result to the file.
   writeResult();
 }
+
+} // namespace wasm
+} // namespace lld

wasm/InputChunks.cpp

 #include "lld/Common/LLVM.h"
 #include "llvm/Support/LEB128.h"
 
 #define DEBUG_TYPE "lld"
 
 using namespace llvm;
 using namespace llvm::wasm;
 using namespace llvm::support::endian;
-using namespace lld;
-using namespace lld::wasm;
 
-StringRef lld::relocTypeToString(uint8_t relocType) {
+namespace lld {
+StringRef relocTypeToString(uint8_t relocType) {
   switch (relocType) {
 #define WASM_RELOC(NAME, REL)                                                  \
   case REL:                                                                    \
     return #NAME;
 #include "llvm/BinaryFormat/WasmRelocs.def"
 #undef WASM_RELOC
   }
   llvm_unreachable("unknown reloc type");
 }
 
-std::string lld::toString(const InputChunk *c) {
+std::string toString(const wasm::InputChunk *c) {
   return (toString(c->file) + ":(" + c->getName() + ")").str();
 }
 
+namespace wasm {
 StringRef InputChunk::getComdatName() const {
   uint32_t index = getComdat();
   if (index == UINT32_MAX)
     return StringRef();
   return file->getWasmObj()->linkingData().Comdats[index];
 }
 
 void InputChunk::verifyRelocTargets() const {
for (const WasmRelocation &rel : relocations) {
     }
 
     // Store that value at the virtual address
     writeU8(os, WASM_OPCODE_I32_STORE, "I32_STORE");
     writeUleb128(os, 2, "align");
     writeUleb128(os, 0, "offset");
   }
 }
+
+} // namespace wasm
+} // namespace lld

wasm/InputFiles.cpp

 #include "lld/Common/Reproduce.h"
 #include "llvm/Object/Binary.h"
 #include "llvm/Object/Wasm.h"
 #include "llvm/Support/TarWriter.h"
 #include "llvm/Support/raw_ostream.h"
 
 #define DEBUG_TYPE "lld"
 
-using namespace lld;
-using namespace lld::wasm;
-
 using namespace llvm;
 using namespace llvm::object;
 using namespace llvm::wasm;
 
-std::unique_ptr<llvm::TarWriter> lld::wasm::tar;
+namespace lld {
+
+// Returns a string in the format of "foo.o" or "foo.a(bar.o)".
+std::string toString(const wasm::InputFile *file) {
+  if (!file)
+    return "<internal>";
+
+  if (file->archiveName.empty())
+    return file->getName();
+
+  return (file->archiveName + "(" + file->getName() + ")").str();
+}
 
-Optional<MemoryBufferRef> lld::wasm::readFile(StringRef path) {
+namespace wasm {
+std::unique_ptr<llvm::TarWriter> tar;
+
+Optional<MemoryBufferRef> readFile(StringRef path) {
   log("Loading: " + path);
 
   auto mbOrErr = MemoryBuffer::getFile(path);
   if (auto ec = mbOrErr.getError()) {
     error("cannot open " + path + ": " + ec.message());
     return None;
   }
   std::unique_ptr<MemoryBuffer> &mb = *mbOrErr;
   MemoryBufferRef mbref = mb->getMemBufferRef();
   make<std::unique_ptr<MemoryBuffer>>(std::move(mb)); // take MB ownership
 
   if (tar)
     tar->append(relativeToRoot(path), mbref.getBuffer());
   return mbref;
 }
 
-InputFile *lld::wasm::createObjectFile(MemoryBufferRef mb,
+InputFile *createObjectFile(MemoryBufferRef mb,
                                        StringRef archiveName) {
   file_magic magic = identify_magic(mb.getBuffer());
   if (magic == file_magic::wasm_object) {
     std::unique_ptr<Binary> bin =
         CHECK(createBinary(mb), mb.getBufferIdentifier());
     auto *obj = cast<WasmObjectFile>(bin.get());
     if (obj->isSharedObject())
       return make<SharedFile>(mb);
void BitcodeFile::parse() {
   std::vector<bool> keptComdats;
   for (StringRef s : obj->getComdatTable())
     keptComdats.push_back(symtab->addComdat(s));
 
   for (const lto::InputFile::Symbol &objSym : obj->symbols())
     symbols.push_back(createBitcodeSymbol(keptComdats, objSym, *this));
 }
 
-// Returns a string in the format of "foo.o" or "foo.a(bar.o)".
-std::string lld::toString(const wasm::InputFile *file) {
-  if (!file)
-    return "<internal>";
-
-  if (file->archiveName.empty())
-    return file->getName();
-
-  return (file->archiveName + "(" + file->getName() + ")").str();
-}
+} // namespace wasm
+} // namespace lld

wasm/LTO.cpp

 #include <algorithm>
 #include <cstddef>
 #include <memory>
 #include <string>
 #include <system_error>
 #include <vector>
 
 using namespace llvm;
-using namespace lld;
-using namespace lld::wasm;
 
+namespace lld {
+namespace wasm {
 static std::unique_ptr<lto::LTO> createLTO() {
   lto::Config c;
   c.Options = initTargetOptionsFromCodeGenFlags();
 
   // Always emit a section per function/data with LTO.
   c.Options.FunctionSections = true;
   c.Options.DataSections = true;
 
std::vector<StringRef> BitcodeCompiler::compile() {
   }
 
   for (std::unique_ptr<MemoryBuffer> &file : files)
     if (file)
       ret.push_back(file->getBuffer());
 
   return ret;
 }
+
+} // namespace wasm
+} // namespace lld

wasm/OutputSections.cpp

 #include "lld/Common/Threads.h"
 #include "llvm/ADT/Twine.h"
 #include "llvm/Support/LEB128.h"
 
 #define DEBUG_TYPE "lld"
 
 using namespace llvm;
 using namespace llvm::wasm;
-using namespace lld;
-using namespace lld::wasm;
 
+namespace lld {
+
+// Returns a string, e.g. "FUNCTION(.text)".
+std::string toString(const wasm::OutputSection &sec) {
+  if (!sec.name.empty())
+    return (sec.getSectionName() + "(" + sec.name + ")").str();
+  return sec.getSectionName();
+}
+
+namespace wasm {
 static StringRef sectionTypeToString(uint32_t sectionType) {
   switch (sectionType) {
   case WASM_SEC_CUSTOM:
     return "CUSTOM";
   case WASM_SEC_TYPE:
     return "TYPE";
   case WASM_SEC_IMPORT:
     return "IMPORT";
case WASM_SEC_DATA:
     return "DATA";
   case WASM_SEC_DATACOUNT:
     return "DATACOUNT";
   default:
     fatal("invalid section type");
   }
 }
 
-// Returns a string, e.g. "FUNCTION(.text)".
-std::string lld::toString(const OutputSection &sec) {
-  if (!sec.name.empty())
-    return (sec.getSectionName() + "(" + sec.name + ")").str();
-  return sec.getSectionName();
-}
-
 StringRef OutputSection::getSectionName() const {
   return sectionTypeToString(type);
 }
 
 void OutputSection::createHeader(size_t bodySize) {
   raw_string_ostream os(header);
   debugWrite(os.tell(), "section type [" + getSectionName() + "]");
   encodeULEB128(type, os);
for (const InputSection *inputSect : inputSections)
     count += inputSect->getNumRelocations();
   return count;
 }
 
 void CustomSection::writeRelocations(raw_ostream &os) const {
   for (const InputSection *s : inputSections)
     s->writeRelocations(os);
 }
+
+} // namespace wasm
+} // namespace lld

wasm/Relocations.cpp

 //===- Relocations.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 "Relocations.h"
 
 #include "InputChunks.h"
 #include "SyntheticSections.h"
 
 using namespace llvm;
 using namespace llvm::wasm;
 
-using namespace lld;
-using namespace lld::wasm;
-
+namespace lld {
+namespace wasm {
 static bool requiresGOTAccess(const Symbol *sym) {
   return config->isPic && !sym->isHidden() && !sym->isLocal();
 }
 
 static bool allowUndefined(const Symbol* sym) {
   // Historically --allow-undefined doesn't work for data symbols since we don't
   // have any way to represent these as imports in the final binary.  The idea
   // behind allowing undefined symbols is to allow importing these symbols from
static void addGOTEntry(Symbol *sym) {
   // potentially be optimized away at runtime or with a post-link tool.
   // TODO(sbc): Linker relaxation might also be able to optimize this away.
   if (config->isPic)
     out.importSec->addGOTEntry(sym);
   else
     out.globalSec->addStaticGOTEntry(sym);
 }
 
-void lld::wasm::scanRelocations(InputChunk *chunk) {
+void scanRelocations(InputChunk *chunk) {
   if (!chunk->live)
     return;
   ObjFile *file = chunk->file;
   ArrayRef<WasmSignature> types = file->getWasmObj()->types();
   for (const WasmRelocation &reloc : chunk->getRelocations()) {
     if (reloc.Type == R_WASM_TYPE_INDEX_LEB) {
       // Mark target type as live
       file->typeMap[reloc.Index] =
for (const WasmRelocation &reloc : chunk->getRelocations()) {
     } else {
       // Report undefined symbols
       if (sym->isUndefined() && !config->relocatable && !sym->isWeak())
         reportUndefined(sym);
     }
 
   }
 }
+
+} // namespace wasm
+} // namespace lld

wasm/SymbolTable.cpp

 #include "lld/Common/Memory.h"
 #include "llvm/ADT/SetVector.h"
 
 #define DEBUG_TYPE "lld"
 
 using namespace llvm;
 using namespace llvm::wasm;
 using namespace llvm::object;
-using namespace lld;
-using namespace lld::wasm;
 
-SymbolTable *lld::wasm::symtab;
+namespace lld {
+namespace wasm {
+SymbolTable *symtab;
 
 void SymbolTable::addFile(InputFile *file) {
   log("Processing: " + toString(file));
 
   // .a file
   if (auto *f = dyn_cast<ArchiveFile>(file)) {
     f->parse();
     return;
for (auto *symbol : variants) {
         auto *f = cast<FunctionSymbol>(symbol);
         reportFunctionSignatureMismatch(symName, f, defined, false);
         StringRef debugName = saver.save("unreachable:" + toString(*f));
         replaceWithUnreachable(f, *f->signature, debugName);
       }
     }
   }
 }
+
+} // namespace wasm
+} // namespace lld

wasm/Symbols.cpp

 #include "OutputSegment.h"
 #include "lld/Common/ErrorHandler.h"
 #include "lld/Common/Strings.h"
 
 #define DEBUG_TYPE "lld"
 
 using namespace llvm;
 using namespace llvm::wasm;
-using namespace lld;
-using namespace lld::wasm;
 
+namespace lld {
+std::string toString(const wasm::Symbol &sym) {
+  return maybeDemangleSymbol(sym.getName());
+}
+
+std::string maybeDemangleSymbol(StringRef name) {
+  if (wasm::config->demangle)
+    return demangleItanium(name);
+  return name;
+}
+
+std::string toString(wasm::Symbol::Kind kind) {
+  switch (kind) {
+  case wasm::Symbol::DefinedFunctionKind:
+    return "DefinedFunction";
+  case wasm::Symbol::DefinedDataKind:
+    return "DefinedData";
+  case wasm::Symbol::DefinedGlobalKind:
+    return "DefinedGlobal";
+  case wasm::Symbol::DefinedEventKind:
+    return "DefinedEvent";
+  case wasm::Symbol::UndefinedFunctionKind:
+    return "UndefinedFunction";
+  case wasm::Symbol::UndefinedDataKind:
+    return "UndefinedData";
+  case wasm::Symbol::UndefinedGlobalKind:
+    return "UndefinedGlobal";
+  case wasm::Symbol::LazyKind:
+    return "LazyKind";
+  case wasm::Symbol::SectionKind:
+    return "SectionKind";
+  case wasm::Symbol::OutputSectionKind:
+    return "OutputSectionKind";
+  }
+  llvm_unreachable("invalid symbol kind");
+}
+
+namespace wasm {
 DefinedFunction *WasmSym::callCtors;
 DefinedFunction *WasmSym::initMemory;
 DefinedFunction *WasmSym::applyRelocs;
 DefinedFunction *WasmSym::initTLS;
 DefinedData *WasmSym::dsoHandle;
 DefinedData *WasmSym::dataEnd;
 DefinedData *WasmSym::globalBase;
 DefinedData *WasmSym::heapBase;

 
 const OutputSectionSymbol *SectionSymbol::getOutputSectionSymbol() const {
   assert(section->outputSec && section->outputSec->sectionSym);
   return section->outputSec->sectionSym;
 }
 
 void LazySymbol::fetch() { cast<ArchiveFile>(file)->addMember(&archiveSymbol); }
 
-std::string lld::toString(const wasm::Symbol &sym) {
-  return lld::maybeDemangleSymbol(sym.getName());
-}
-
-std::string lld::maybeDemangleSymbol(StringRef name) {
-  if (config->demangle)
-    return demangleItanium(name);
-  return name;
-}
-
-std::string lld::toString(wasm::Symbol::Kind kind) {
-  switch (kind) {
-  case wasm::Symbol::DefinedFunctionKind:
-    return "DefinedFunction";
-  case wasm::Symbol::DefinedDataKind:
-    return "DefinedData";
-  case wasm::Symbol::DefinedGlobalKind:
-    return "DefinedGlobal";
-  case wasm::Symbol::DefinedEventKind:
-    return "DefinedEvent";
-  case wasm::Symbol::UndefinedFunctionKind:
-    return "UndefinedFunction";
-  case wasm::Symbol::UndefinedDataKind:
-    return "UndefinedData";
-  case wasm::Symbol::UndefinedGlobalKind:
-    return "UndefinedGlobal";
-  case wasm::Symbol::LazyKind:
-    return "LazyKind";
-  case wasm::Symbol::SectionKind:
-    return "SectionKind";
-  case wasm::Symbol::OutputSectionKind:
-    return "OutputSectionKind";
-  }
-  llvm_unreachable("invalid symbol kind");
-}
-
-
-void lld::wasm::printTraceSymbolUndefined(StringRef name, const InputFile* file) {
+void printTraceSymbolUndefined(StringRef name, const InputFile* file) {
   message(toString(file) + ": reference to " + name);
 }
 
 // Print out a log message for --trace-symbol.
-void lld::wasm::printTraceSymbol(Symbol *sym) {
+void printTraceSymbol(Symbol *sym) {
   // Undefined symbols are traced via printTraceSymbolUndefined
   if (sym->isUndefined())
     return;
 
   std::string s;
   if (sym->isLazy())
     s = ": lazy definition of ";
   else
     s = ": definition of ";
 
   message(toString(sym->getFile()) + s + sym->getName());
 }
 
-const char *lld::wasm::defaultModule = "env";
-const char *lld::wasm::functionTableName = "__indirect_function_table";
+const char *defaultModule = "env";
+const char *functionTableName = "__indirect_function_table";
+
+} // namespace wasm
+} // namespace lld

wasm/SyntheticSections.cpp

 #include "InputGlobal.h"
 #include "OutputSegment.h"
 #include "SymbolTable.h"
 #include "llvm/Support/Path.h"
 
 using namespace llvm;
 using namespace llvm::wasm;
 
-using namespace lld;
-using namespace lld::wasm;
+namespace lld {
+namespace wasm {
 
-OutStruct lld::wasm::out;
+OutStruct out;
 
 namespace {
 
 // Some synthetic sections (e.g. "name" and "linking") have subsections.
 // Just like the synthetic sections themselves these need to be created before
 // they can be written out (since they are preceded by their length). This
 // class is used to create subsections and then write them into the stream
 // of the parent section.

 
 void RelocSection::writeBody() {
   uint32_t count = sec->getNumRelocations();
   assert(sec->sectionIndex != UINT32_MAX);
   writeUleb128(bodyOutputStream, sec->sectionIndex, "reloc section");
   writeUleb128(bodyOutputStream, count, "reloc count");
   sec->writeRelocations(bodyOutputStream);
 }
+
+} // namespace wasm
+} // namespace lld

wasm/Writer.cpp

 
 #include <cstdarg>
 #include <map>
 
 #define DEBUG_TYPE "lld"
 
 using namespace llvm;
 using namespace llvm::wasm;
-using namespace lld;
-using namespace lld::wasm;
 
+namespace lld {
+namespace wasm {
 static constexpr int stackAlignment = 16;
 
 namespace {
 
 // The writer writes a SymbolTable result to a file.
 class Writer {
 public:
   void run();

 void Writer::createHeader() {
   raw_string_ostream os(header);
   writeBytes(os, WasmMagic, sizeof(WasmMagic), "wasm magic");
   writeU32(os, WasmVersion, "wasm version");
   os.flush();
   fileSize += header.size();
 }
 
-void lld::wasm::writeResult() { Writer().run(); }
+void writeResult() { Writer().run(); }
+
+} // namespace wasm
+} // namespace lld

wasm/WriterUtils.cpp

 #include "llvm/Support/LEB128.h"
 
 #define DEBUG_TYPE "lld"
 
 using namespace llvm;
 using namespace llvm::wasm;
 
 namespace lld {
+std::string toString(ValType type) {
+  switch (type) {
+  case ValType::I32:
+    return "i32";
+  case ValType::I64:
+    return "i64";
+  case ValType::F32:
+    return "f32";
+  case ValType::F64:
+    return "f64";
+  case ValType::V128:
+    return "v128";
+  case ValType::EXNREF:
+    return "exnref";
+  }
+  llvm_unreachable("Invalid wasm::ValType");
+}
+
+std::string toString(const WasmSignature &sig) {
+  SmallString<128> s("(");
+  for (ValType type : sig.Params) {
+    if (s.size() != 1)
+      s += ", ";
+    s += toString(type);
+  }
+  s += ") -> ";
+  if (sig.Returns.empty())
+    s += "void";
+  else
+    s += toString(sig.Returns[0]);
+  return s.str();
+}
 
-void wasm::debugWrite(uint64_t offset, const Twine &msg) {
+std::string toString(const WasmGlobalType &type) {
+  return (type.Mutable ? "var " : "const ") +
+         toString(static_cast<ValType>(type.Type));
+}
+
+std::string toString(const WasmEventType &type) {
+  if (type.Attribute == WASM_EVENT_ATTRIBUTE_EXCEPTION)
+    return "exception";
+  return "unknown";
+}
+
+namespace wasm {
+void debugWrite(uint64_t offset, const Twine &msg) {
   LLVM_DEBUG(dbgs() << format("  | %08lld: ", offset) << msg << "\n");
 }
 
-void wasm::writeUleb128(raw_ostream &os, uint32_t number, const Twine &msg) {
+void writeUleb128(raw_ostream &os, uint32_t number, const Twine &msg) {
   debugWrite(os.tell(), msg + "[" + utohexstr(number) + "]");
   encodeULEB128(number, os);
 }
 
-void wasm::writeSleb128(raw_ostream &os, int32_t number, const Twine &msg) {
+void writeSleb128(raw_ostream &os, int32_t number, const Twine &msg) {
   debugWrite(os.tell(), msg + "[" + utohexstr(number) + "]");
   encodeSLEB128(number, os);
 }
 
-void wasm::writeBytes(raw_ostream &os, const char *bytes, size_t count,
+void writeBytes(raw_ostream &os, const char *bytes, size_t count,
                       const Twine &msg) {
   debugWrite(os.tell(), msg + " [data[" + Twine(count) + "]]");
   os.write(bytes, count);
 }
 
-void wasm::writeStr(raw_ostream &os, StringRef string, const Twine &msg) {
+void writeStr(raw_ostream &os, StringRef string, const Twine &msg) {
   debugWrite(os.tell(),
              msg + " [str[" + Twine(string.size()) + "]: " + string + "]");
   encodeULEB128(string.size(), os);
   os.write(string.data(), string.size());
 }
 
-void wasm::writeU8(raw_ostream &os, uint8_t byte, const Twine &msg) {
+void writeU8(raw_ostream &os, uint8_t byte, const Twine &msg) {
   debugWrite(os.tell(), msg + " [0x" + utohexstr(byte) + "]");
   os << byte;
 }
 
-void wasm::writeU32(raw_ostream &os, uint32_t number, const Twine &msg) {
+void writeU32(raw_ostream &os, uint32_t number, const Twine &msg) {
   debugWrite(os.tell(), msg + "[0x" + utohexstr(number) + "]");
   support::endian::write(os, number, support::little);
 }
 
-void wasm::writeValueType(raw_ostream &os, ValType type, const Twine &msg) {
+void writeValueType(raw_ostream &os, ValType type, const Twine &msg) {
   writeU8(os, static_cast<uint8_t>(type),
           msg + "[type: " + toString(type) + "]");
 }
 
-void wasm::writeSig(raw_ostream &os, const WasmSignature &sig) {
+void writeSig(raw_ostream &os, const WasmSignature &sig) {
   writeU8(os, WASM_TYPE_FUNC, "signature type");
   writeUleb128(os, sig.Params.size(), "param Count");
   for (ValType paramType : sig.Params) {
     writeValueType(os, paramType, "param type");
   }
   writeUleb128(os, sig.Returns.size(), "result Count");
   if (sig.Returns.size()) {
     writeValueType(os, sig.Returns[0], "result type");
   }
 }
 
-void wasm::writeI32Const(raw_ostream &os, int32_t number, const Twine &msg) {
+void writeI32Const(raw_ostream &os, int32_t number, const Twine &msg) {
   writeU8(os, WASM_OPCODE_I32_CONST, "i32.const");
   writeSleb128(os, number, msg);
 }
 
-void wasm::writeI64Const(raw_ostream &os, int32_t number, const Twine &msg) {
+void writeI64Const(raw_ostream &os, int32_t number, const Twine &msg) {
   writeU8(os, WASM_OPCODE_I64_CONST, "i64.const");
   writeSleb128(os, number, msg);
 }
 
-void wasm::writeMemArg(raw_ostream &os, uint32_t alignment, uint32_t offset) {
+void writeMemArg(raw_ostream &os, uint32_t alignment, uint32_t offset) {
   writeUleb128(os, alignment, "alignment");
   writeUleb128(os, offset, "offset");
 }
 
-void wasm::writeInitExpr(raw_ostream &os, const WasmInitExpr &initExpr) {
+void writeInitExpr(raw_ostream &os, const WasmInitExpr &initExpr) {
   writeU8(os, initExpr.Opcode, "opcode");
   switch (initExpr.Opcode) {
   case WASM_OPCODE_I32_CONST:
     writeSleb128(os, initExpr.Value.Int32, "literal (i32)");
     break;
   case WASM_OPCODE_I64_CONST:
     writeSleb128(os, initExpr.Value.Int64, "literal (i64)");
     break;
   case WASM_OPCODE_GLOBAL_GET:
     writeUleb128(os, initExpr.Value.Global, "literal (global index)");
     break;
   default:
     fatal("unknown opcode in init expr: " + Twine(initExpr.Opcode));
   }
   writeU8(os, WASM_OPCODE_END, "opcode:end");
 }
 
-void wasm::writeLimits(raw_ostream &os, const WasmLimits &limits) {
+void writeLimits(raw_ostream &os, const WasmLimits &limits) {
   writeU8(os, limits.Flags, "limits flags");
   writeUleb128(os, limits.Initial, "limits initial");
   if (limits.Flags & WASM_LIMITS_FLAG_HAS_MAX)
     writeUleb128(os, limits.Maximum, "limits max");
 }
 
-void wasm::writeGlobalType(raw_ostream &os, const WasmGlobalType &type) {
+void writeGlobalType(raw_ostream &os, const WasmGlobalType &type) {
   // TODO: Update WasmGlobalType to use ValType and remove this cast.
   writeValueType(os, ValType(type.Type), "global type");
   writeU8(os, type.Mutable, "global mutable");
 }
 
-void wasm::writeGlobal(raw_ostream &os, const WasmGlobal &global) {
+void writeGlobal(raw_ostream &os, const WasmGlobal &global) {
   writeGlobalType(os, global.Type);
   writeInitExpr(os, global.InitExpr);
 }
 
-void wasm::writeEventType(raw_ostream &os, const WasmEventType &type) {
+void writeEventType(raw_ostream &os, const WasmEventType &type) {
   writeUleb128(os, type.Attribute, "event attribute");
   writeUleb128(os, type.SigIndex, "sig index");
 }
 
-void wasm::writeEvent(raw_ostream &os, const WasmEvent &event) {
+void writeEvent(raw_ostream &os, const WasmEvent &event) {
   writeEventType(os, event.Type);
 }
 
-void wasm::writeTableType(raw_ostream &os, const llvm::wasm::WasmTable &type) {
+void writeTableType(raw_ostream &os, const llvm::wasm::WasmTable &type) {
   writeU8(os, WASM_TYPE_FUNCREF, "table type");
   writeLimits(os, type.Limits);
 }
 
-void wasm::writeImport(raw_ostream &os, const WasmImport &import) {
+void writeImport(raw_ostream &os, const WasmImport &import) {
   writeStr(os, import.Module, "import module name");
   writeStr(os, import.Field, "import field name");
   writeU8(os, import.Kind, "import kind");
   switch (import.Kind) {
   case WASM_EXTERNAL_FUNCTION:
     writeUleb128(os, import.SigIndex, "import sig index");
     break;
   case WASM_EXTERNAL_GLOBAL:
     writeGlobalType(os, import.Global);
     break;
   case WASM_EXTERNAL_EVENT:
     writeEventType(os, import.Event);
     break;
   case WASM_EXTERNAL_MEMORY:
     writeLimits(os, import.Memory);
     break;
   case WASM_EXTERNAL_TABLE:
     writeTableType(os, import.Table);
     break;
   default:
     fatal("unsupported import type: " + Twine(import.Kind));
   }
 }
 
-void wasm::writeExport(raw_ostream &os, const WasmExport &export_) {
+void writeExport(raw_ostream &os, const WasmExport &export_) {
   writeStr(os, export_.Name, "export name");
   writeU8(os, export_.Kind, "export kind");
   switch (export_.Kind) {
   case WASM_EXTERNAL_FUNCTION:
     writeUleb128(os, export_.Index, "function index");
     break;
   case WASM_EXTERNAL_GLOBAL:
     writeUleb128(os, export_.Index, "global index");
     break;
   case WASM_EXTERNAL_MEMORY:
     writeUleb128(os, export_.Index, "memory index");
     break;
   case WASM_EXTERNAL_TABLE:
     writeUleb128(os, export_.Index, "table index");
     break;
   default:
     fatal("unsupported export type: " + Twine(export_.Kind));
   }
 }
-} // namespace lld
-
-std::string lld::toString(ValType type) {
-  switch (type) {
-  case ValType::I32:
-    return "i32";
-  case ValType::I64:
-    return "i64";
-  case ValType::F32:
-    return "f32";
-  case ValType::F64:
-    return "f64";
-  case ValType::V128:
-    return "v128";
-  case ValType::EXNREF:
-    return "exnref";
-  }
-  llvm_unreachable("Invalid wasm::ValType");
-}
-
-std::string lld::toString(const WasmSignature &sig) {
-  SmallString<128> s("(");
-  for (ValType type : sig.Params) {
-    if (s.size() != 1)
-      s += ", ";
-    s += toString(type);
-  }
-  s += ") -> ";
-  if (sig.Returns.empty())
-    s += "void";
-  else
-    s += toString(sig.Returns[0]);
-  return s.str();
-}
-
-std::string lld::toString(const WasmGlobalType &type) {
-  return (type.Mutable ? "var " : "const ") +
-         toString(static_cast<ValType>(type.Type));
-}
 
-std::string lld::toString(const WasmEventType &type) {
-  if (type.Attribute == WASM_EVENT_ATTRIBUTE_EXCEPTION)
-    return "exception";
-  return "unknown";
-}
+} // namespace wasm
+} // namespace lld