[WebAssembly] Remove `using` statements from header files. NFC.

[aheejin]

I think what @dschuff said in this comment was not removing all using from headers, but removing using namespace from headers.. no? We are not using using namespace in header files already.

[sbc100]

In D54758#1304845, @aheejin wrote:

I think what @dschuff said in this comment was not removing all using from headers, but removing using namespace from headers.. no? We are not using using namespace in header files already.

Hmm, good point. @ruiu, what is your take the policy for lld around this?

[kristina]

I think some redundant includes should definitely go (IWYU). Regarding more granular using declarations, honestly it's up to @ruiu, Clang and LLDB handle it by aliasing some of LLVM's common classes in their respective namespaces, maybe that could work for LLD too? In fact I'm guessing that's the purpose of lld/Common/LLVM.h, you could take a similar approach for Wasm specific stuff and limit the using statements to your namespace.

[ruiu]

In D54758#1307205, @kristina wrote:

I think some redundant includes should definitely go (IWYU). Regarding more granular using declarations, honestly it's up to @ruiu, Clang and LLDB handle it by aliasing some of LLVM's common classes in their respective namespaces, maybe that could work for LLD too? In fact I'm guessing that's the purpose of lld/Common/LLVM.h, you could take a similar approach for Wasm specific stuff and limit the using statements to your namespace.

Your guess is correct; lld/Common/LLVM.h is to using some identifiers so that they can be referred without namespace specifiers. In fact, I think it is fine to add Wasm* names to that file because it is obvious that they will never conflict with other names because of Wasm prefix. Some names are ambiguous, such as llvm::object::Archive, and it is better to refer them using a fully qualified name, as we have other classes with confusing names (e.g. lld::*::ArchiveFile).

[sbc100]

In D54758#1308253, @ruiu wrote:

In D54758#1307205, @kristina wrote:

I think some redundant includes should definitely go (IWYU). Regarding more granular using declarations, honestly it's up to @ruiu, Clang and LLDB handle it by aliasing some of LLVM's common classes in their respective namespaces, maybe that could work for LLD too? In fact I'm guessing that's the purpose of lld/Common/LLVM.h, you could take a similar approach for Wasm specific stuff and limit the using statements to your namespace.

Your guess is correct; lld/Common/LLVM.h is to using some identifiers so that they can be referred without namespace specifiers. In fact, I think it is fine to add Wasm* names to that file because it is obvious that they will never conflict with other names because of Wasm prefix. Some names are ambiguous, such as llvm::object::Archive, and it is better to refer them using a fully qualified name, as we have other classes with confusing names (e.g. lld::*::ArchiveFile).

That does mean that lld/Common/LLVM.h will need to include llvm/Object/Wasm.h. It seems strange that has not been necessary for ELF/ COFF so far but I'll upload a new version this change and you can see what you think of it.

[sbc100]

• feedback

[sbc100]

• sort

[ruiu]

LGTM. This is fine to me. We could create lld/wasm/LLVM.h to import Wasm* identifiers, but adding these identifiers directly to llvm/Common/LLVM.h makes more sense to me because the number of symbols we want to import is small.

That does mean that lld/Common/LLVM.h will need to include llvm/Object/Wasm.h. It seems strange that has not been necessary for ELF/ COFF so far but I'll upload a new version this change and you can see what you think of it.

As you noticed, you don't actually have to include llvm/Object/Wasm.h. You just need to declare class/struct names in lld/Common/LLVM.h.

include/lld/Common/LLVM.h

54 ↗

(On Diff #175360)

nit: add a blank line before a new namespace declaration.

wasm/Driver.cpp

 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/Process.h"
 #include "llvm/Support/TargetSelect.h"
 
 #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;
 

wasm/InputChunks.h

 //===----------------------------------------------------------------------===//
 
 #ifndef LLD_WASM_INPUT_CHUNKS_H
 #define LLD_WASM_INPUT_CHUNKS_H
 
 #include "Config.h"
 #include "InputFiles.h"
 #include "lld/Common/ErrorHandler.h"
+#include "lld/Common/LLVM.h"
 #include "llvm/Object/Wasm.h"
 
-using llvm::object::WasmSection;
-using llvm::object::WasmSegment;
-using llvm::wasm::WasmFunction;
-using llvm::wasm::WasmRelocation;
-using llvm::wasm::WasmSignature;
-
-namespace llvm {
-class raw_ostream;
-}
-
 namespace lld {
 namespace wasm {
 
 class ObjFile;
 class OutputSegment;
 
 class InputChunk {
 public:
   enum Kind { DataSegment, Function, SyntheticFunction, Section };
 
   Kind kind() const { return SectionKind; }
 
   virtual uint32_t getSize() const { return data().size(); }
   virtual uint32_t getInputSize() const { return getSize(); };
 
   virtual void writeTo(uint8_t *SectionStart) const;
 
-  ArrayRef<WasmRelocation> getRelocations() const { return Relocations; }
-  void setRelocations(ArrayRef<WasmRelocation> Rs) { Relocations = Rs; }
+  ArrayRef<llvm::wasm::WasmRelocation> getRelocations() const {
+    return Relocations;
+  }
+
+  void setRelocations(ArrayRef<llvm::wasm::WasmRelocation> Relocs) {
+    Relocations = Relocs;
+  }
 
   virtual StringRef getName() const = 0;
   virtual StringRef getDebugName() const = 0;
   virtual uint32_t getComdat() const = 0;
   StringRef getComdatName() const;
   virtual uint32_t getInputSectionOffset() const = 0;
 
   size_t NumRelocations() const { return Relocations.size(); }
InputChunk(ObjFile *F, Kind K)
       : File(F), Live(!Config->GcSections), SectionKind(K) {}
   virtual ~InputChunk() = default;
   virtual ArrayRef<uint8_t> data() const = 0;
 
   // Verifies the existing data at relocation targets matches our expectations.
   // This is performed only debug builds as an extra sanity check.
   void verifyRelocTargets() const;
 
-  ArrayRef<WasmRelocation> Relocations;
+  ArrayRef<llvm::wasm::WasmRelocation> Relocations;
   Kind SectionKind;
 };
 
 // Represents a WebAssembly data segment which can be included as part of
 // an output data segments.  Note that in WebAssembly, unlike ELF and other
 // formats, used the term "data segment" to refer to the continous regions of
 // memory that make on the data section. See:
 // https://webassembly.github.io/spec/syntax/modules.html#syntax-data
 //
 // For example, by default, clang will produce a separate data section for
 // each global variable.
 class InputSegment : public InputChunk {
 public:
-  InputSegment(const WasmSegment &Seg, ObjFile *F)
+  InputSegment(const llvm::object::WasmSegment &Seg, ObjFile *F)
       : InputChunk(F, InputChunk::DataSegment), Segment(Seg) {}
 
   static bool classof(const InputChunk *C) { return C->kind() == DataSegment; }
 
   uint32_t getAlignment() const { return Segment.Data.Alignment; }
   StringRef getName() const override { return Segment.Data.Name; }
   StringRef getDebugName() const override { return StringRef(); }
   uint32_t getComdat() const override { return Segment.Data.Comdat; }
   uint32_t getInputSectionOffset() const override {
     return Segment.SectionOffset;
   }
 
   const OutputSegment *OutputSeg = nullptr;
   int32_t OutputSegmentOffset = 0;
 
 protected:
   ArrayRef<uint8_t> data() const override { return Segment.Data.Content; }
 
-  const WasmSegment &Segment;
+  const llvm::object::WasmSegment &Segment;
 };
 
 // Represents a single wasm function within and input file.  These are
 // combined to create the final output CODE section.
 class InputFunction : public InputChunk {
 public:
-  InputFunction(const WasmSignature &S, const WasmFunction *Func, ObjFile *F)
+  InputFunction(const llvm::wasm::WasmSignature &S,
+                const llvm::wasm::WasmFunction *Func, ObjFile *F)
       : InputChunk(F, InputChunk::Function), Signature(S), Function(Func) {}
 
   static bool classof(const InputChunk *C) {
     return C->kind() == InputChunk::Function ||
            C->kind() == InputChunk::SyntheticFunction;
   }
 
   void writeTo(uint8_t *SectionStart) const override;
public:
   void setTableIndex(uint32_t Index);
 
   // The size of a given input function can depend on the values of the
   // LEB relocations within it.  This finalizeContents method is called after
   // all the symbol values have be calcualted but before getSize() is ever
   // called.
   void calculateSize();
 
-  const WasmSignature &Signature;
+  const llvm::wasm::WasmSignature &Signature;
 
 protected:
   ArrayRef<uint8_t> data() const override {
     assert(!Config->CompressRelocations);
     return File->CodeSection->Content.slice(getInputSectionOffset(),
                                             Function->Size);
   }
 
-  const WasmFunction *Function;
+  const llvm::wasm::WasmFunction *Function;
   llvm::Optional<uint32_t> FunctionIndex;
   llvm::Optional<uint32_t> TableIndex;
   uint32_t CompressedFuncSize = 0;
   uint32_t CompressedSize = 0;
 };
 
 class SyntheticFunction : public InputFunction {
 public:
-  SyntheticFunction(const WasmSignature &S, StringRef Name,
+  SyntheticFunction(const llvm::wasm::WasmSignature &S, StringRef Name,
                     StringRef DebugName = {})
       : InputFunction(S, nullptr, nullptr), Name(Name), DebugName(DebugName) {
     SectionKind = InputChunk::SyntheticFunction;
   }
 
   static bool classof(const InputChunk *C) {
     return C->kind() == InputChunk::SyntheticFunction;
   }
protected:
   StringRef Name;
   StringRef DebugName;
   ArrayRef<uint8_t> Body;
 };
 
 // Represents a single Wasm Section within an input file.
 class InputSection : public InputChunk {
 public:
-  InputSection(const WasmSection &S, ObjFile *F)
+  InputSection(const llvm::object::WasmSection &S, ObjFile *F)
       : InputChunk(F, InputChunk::Section), Section(S) {
     assert(Section.Type == llvm::wasm::WASM_SEC_CUSTOM);
   }
 
   StringRef getName() const override { return Section.Name; }
   StringRef getDebugName() const override { return StringRef(); }
   uint32_t getComdat() const override { return UINT32_MAX; }
 
 protected:
   ArrayRef<uint8_t> data() const override { return Section.Content; }
 
   // Offset within the input section.  This is only zero since this chunk
   // type represents an entire input section, not part of one.
   uint32_t getInputSectionOffset() const override { return 0; }
 
-  const WasmSection &Section;
+  const llvm::object::WasmSection &Section;
 };
 
 } // namespace wasm
 
 std::string toString(const wasm::InputChunk *);
 } // namespace lld
 
 #endif // LLD_WASM_INPUT_CHUNKS_H

wasm/InputFiles.h

 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/DenseSet.h"
 #include "llvm/LTO/LTO.h"
 #include "llvm/Object/Archive.h"
 #include "llvm/Object/Wasm.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include <vector>
 
-using llvm::object::Archive;
-using llvm::object::WasmObjectFile;
-using llvm::object::WasmSection;
-using llvm::object::WasmSymbol;
-using llvm::wasm::WasmGlobal;
-using llvm::wasm::WasmImport;
-using llvm::wasm::WasmRelocation;
-using llvm::wasm::WasmSignature;
-
-namespace llvm {
-namespace lto {
-class InputFile;
-}
-} // namespace llvm
-
 namespace lld {
 namespace wasm {
 
 class InputChunk;
 class InputFunction;
 class InputSegment;
 class InputGlobal;
 class InputSection;

 };
 
 // .a file (ar archive)
 class ArchiveFile : public InputFile {
 public:
   explicit ArchiveFile(MemoryBufferRef M) : InputFile(ArchiveKind, M) {}
   static bool classof(const InputFile *F) { return F->kind() == ArchiveKind; }
 
-  void addMember(const Archive::Symbol *Sym);
+  void addMember(const llvm::object::Archive::Symbol *Sym);
 
   void parse() override;
 
 private:
-  std::unique_ptr<Archive> File;
+  std::unique_ptr<llvm::object::Archive> File;
   llvm::DenseSet<uint64_t> Seen;
 };
 
 // .o file (wasm object file)
 class ObjFile : public InputFile {
 public:
   explicit ObjFile(MemoryBufferRef M) : InputFile(ObjectKind, M) {}
   static bool classof(const InputFile *F) { return F->kind() == ObjectKind; }
 
   void parse() override;
 
   // Returns the underlying wasm file.
-  const WasmObjectFile *getWasmObj() const { return WasmObj.get(); }
+  const llvm::object::WasmObjectFile *getWasmObj() const {
+    return WasmObj.get();
+  }
 
   void dumpInfo() const;
 
-  uint32_t calcNewIndex(const WasmRelocation &Reloc) const;
-  uint32_t calcNewValue(const WasmRelocation &Reloc) const;
-  uint32_t calcNewAddend(const WasmRelocation &Reloc) const;
-  uint32_t calcExpectedValue(const WasmRelocation &Reloc) const;
+  uint32_t calcNewIndex(const llvm::wasm::WasmRelocation &Reloc) const;
+  uint32_t calcNewValue(const llvm::wasm::WasmRelocation &Reloc) const;
+  uint32_t calcNewAddend(const llvm::wasm::WasmRelocation &Reloc) const;
+  uint32_t calcExpectedValue(const llvm::wasm::WasmRelocation &Reloc) const;
 
-  const WasmSection *CodeSection = nullptr;
-  const WasmSection *DataSection = nullptr;
+  const llvm::object::WasmSection *CodeSection = nullptr;
+  const llvm::object::WasmSection *DataSection = nullptr;
 
   // Maps input type indices to output type indices
   std::vector<uint32_t> TypeMap;
   std::vector<bool> TypeIsUsed;
   // Maps function indices to table indices
   std::vector<uint32_t> TableEntries;
   std::vector<bool> UsedComdats;
   std::vector<InputSegment *> Segments;
   std::vector<InputFunction *> Functions;
   std::vector<InputGlobal *> Globals;
   std::vector<InputSection *> CustomSections;
   llvm::DenseMap<uint32_t, InputSection *> CustomSectionsByIndex;
 
   Symbol *getSymbol(uint32_t Index) const { return Symbols[Index]; }
   FunctionSymbol *getFunctionSymbol(uint32_t Index) const;
   DataSymbol *getDataSymbol(uint32_t Index) const;
   GlobalSymbol *getGlobalSymbol(uint32_t Index) const;
   SectionSymbol *getSectionSymbol(uint32_t Index) const;
 
 private:
-  Symbol *createDefined(const WasmSymbol &Sym);
-  Symbol *createUndefined(const WasmSymbol &Sym);
+  Symbol *createDefined(const llvm::object::WasmSymbol &Sym);
+  Symbol *createUndefined(const llvm::object::WasmSymbol &Sym);
 
   bool isExcludedByComdat(InputChunk *Chunk) const;
 
-  std::unique_ptr<WasmObjectFile> WasmObj;
+  std::unique_ptr<llvm::object::WasmObjectFile> WasmObj;
 };
 
 class BitcodeFile : public InputFile {
 public:
   explicit BitcodeFile(MemoryBufferRef M) : InputFile(BitcodeKind, M) {}
   static bool classof(const InputFile *F) { return F->kind() == BitcodeKind; }
 
   void parse() override;

wasm/InputGlobal.h

 #define LLD_WASM_INPUT_GLOBAL_H
 
 #include "Config.h"
 #include "InputFiles.h"
 #include "WriterUtils.h"
 #include "lld/Common/ErrorHandler.h"
 #include "llvm/Object/Wasm.h"
 
-using llvm::wasm::WasmGlobal;
-using llvm::wasm::WasmInitExpr;
-
 namespace lld {
 namespace wasm {
 
 // Represents a single Wasm Global Variable within an input file. These are
 // combined to form the final GLOBALS section.
 class InputGlobal {
 public:
-  InputGlobal(const WasmGlobal &G, ObjFile *F)
+  InputGlobal(const llvm::wasm::WasmGlobal &G, ObjFile *F)
       : File(F), Global(G), Live(!Config->GcSections) {}
 
   StringRef getName() const { return Global.SymbolName; }
-  const WasmGlobalType &getType() const { return Global.Type; }
+  const llvm::wasm::WasmGlobalType &getType() const { return Global.Type; }
 
   uint32_t getGlobalIndex() const { return GlobalIndex.getValue(); }
   bool hasGlobalIndex() const { return GlobalIndex.hasValue(); }
   void setGlobalIndex(uint32_t Index) {
     assert(!hasGlobalIndex());
     GlobalIndex = Index;
   }
 
   ObjFile *File;
-  WasmGlobal Global;
+  llvm::wasm::WasmGlobal Global;
 
   bool Live = false;
 
 protected:
   llvm::Optional<uint32_t> GlobalIndex;
 };
 
 } // namespace wasm
 
 inline std::string toString(const wasm::InputGlobal *G) {
   return (toString(G->File) + ":(" + G->getName() + ")").str();
 }
 
 } // namespace lld
 
 #endif // LLD_WASM_INPUT_GLOBAL_H

wasm/OutputSections.h

 //===- OutputSections.h -----------------------------------------*- C++ -*-===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLD_WASM_OUTPUT_SECTIONS_H
 #define LLD_WASM_OUTPUT_SECTIONS_H
 
 #include "InputChunks.h"
 #include "WriterUtils.h"
 #include "lld/Common/ErrorHandler.h"
+#include "lld/Common/LLVM.h"
 #include "llvm/ADT/DenseMap.h"
 
-using llvm::raw_ostream;
-using llvm::raw_string_ostream;
-
 namespace lld {
 
 namespace wasm {
 class OutputSection;
 }
 std::string toString(const wasm::OutputSection &Section);
 
 namespace wasm {
void finalizeContents() override {
     createHeader(Body.size());
   }
 
   raw_ostream &getStream() { return BodyOutputStream; }
 
   std::string Body;
 
 protected:
-  raw_string_ostream BodyOutputStream;
+  llvm::raw_string_ostream BodyOutputStream;
 };
 
 class CodeSection : public OutputSection {
 public:
   explicit CodeSection(ArrayRef<InputFunction *> Functions);
   size_t getSize() const override { return Header.size() + BodySize; }
   void writeTo(uint8_t *Buf) override;
   uint32_t numRelocations() const override;

wasm/SymbolTable.h

 #ifndef LLD_WASM_SYMBOL_TABLE_H
 #define LLD_WASM_SYMBOL_TABLE_H
 
 #include "InputFiles.h"
 #include "LTO.h"
 #include "Symbols.h"
 #include "llvm/ADT/CachedHashString.h"
 #include "llvm/ADT/DenseSet.h"
-#include "llvm/Support/raw_ostream.h"
 
-using llvm::wasm::WasmGlobalType;
-using llvm::wasm::WasmSignature;
+namespace llvm {
+namespace wasm {
+struct WasmGlobalType;
+struct WasmSignature;
+}
+}
 
 namespace lld {
 namespace wasm {
 
 class InputSegment;
 
 // SymbolTable is a bucket of all known symbols, including defined,
 // undefined, or lazy symbols (the last one is symbols in archive
Symbol *addDefinedFunction(StringRef Name, uint32_t Flags, InputFile *File,
                              InputFunction *Function);
   Symbol *addDefinedData(StringRef Name, uint32_t Flags, InputFile *File,
                          InputSegment *Segment, uint32_t Address,
                          uint32_t Size);
   Symbol *addDefinedGlobal(StringRef Name, uint32_t Flags, InputFile *File,
                            InputGlobal *G);
 
   Symbol *addUndefinedFunction(StringRef Name, uint32_t Flags, InputFile *File,
-                               const WasmSignature *Signature);
+                               const llvm::wasm::WasmSignature *Signature);
   Symbol *addUndefinedData(StringRef Name, uint32_t Flags, InputFile *File);
   Symbol *addUndefinedGlobal(StringRef Name, uint32_t Flags, InputFile *File,
-                             const WasmGlobalType *Type);
+                             const llvm::wasm::WasmGlobalType *Type);
 
-  void addLazy(ArchiveFile *F, const Archive::Symbol *Sym);
+  void addLazy(ArchiveFile *F, const llvm::object::Archive::Symbol *Sym);
 
   bool addComdat(StringRef Name);
 
   DefinedData *addSyntheticDataSymbol(StringRef Name, uint32_t Flags);
   DefinedGlobal *addSyntheticGlobal(StringRef Name, uint32_t Flags,
                                     InputGlobal *Global);
   DefinedFunction *addSyntheticFunction(StringRef Name, uint32_t Flags,
                                         InputFunction *Function);

wasm/SymbolTable.cpp

 #include "lld/Common/ErrorHandler.h"
 #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;
 
 void SymbolTable::addFile(InputFile *File) {
   log("Processing: " + toString(File));
   File->parse();

wasm/Symbols.h

 #ifndef LLD_WASM_SYMBOLS_H
 #define LLD_WASM_SYMBOLS_H
 
 #include "Config.h"
 #include "lld/Common/LLVM.h"
 #include "llvm/Object/Archive.h"
 #include "llvm/Object/Wasm.h"
 
-using llvm::object::Archive;
-using llvm::object::WasmSymbol;
-using llvm::wasm::WasmGlobal;
-using llvm::wasm::WasmGlobalType;
-using llvm::wasm::WasmSignature;
-using llvm::wasm::WasmSymbolType;
-
 namespace lld {
 namespace wasm {
 
 class InputFile;
 class InputChunk;
 class InputSegment;
 class InputFunction;
 class InputGlobal;
public:
 
   void setHidden(bool IsHidden);
 
   // Get/set the index in the output symbol table.  This is only used for
   // relocatable output.
   uint32_t getOutputSymbolIndex() const;
   void setOutputSymbolIndex(uint32_t Index);
 
-  WasmSymbolType getWasmType() const;
+  llvm::wasm::WasmSymbolType getWasmType() const;
   bool isExported() const;
 
   // True if this symbol was referenced by a regular (non-bitcode) object.
   unsigned IsUsedInRegularObj : 1;
   unsigned ForceExport : 1;
 
 protected:
   Symbol(StringRef Name, Kind K, uint32_t Flags, InputFile *F)
public:
   uint32_t getTableIndex() const;
   bool hasTableIndex() const;
 
   // Get/set the function index
   uint32_t getFunctionIndex() const;
   void setFunctionIndex(uint32_t Index);
   bool hasFunctionIndex() const;
 
-  const WasmSignature *FunctionType;
+  const llvm::wasm::WasmSignature *FunctionType;
 
 protected:
   FunctionSymbol(StringRef Name, Kind K, uint32_t Flags, InputFile *F,
-                 const WasmSignature *Type)
+                 const llvm::wasm::WasmSignature *Type)
       : Symbol(Name, K, Flags, F), FunctionType(Type) {}
 
   uint32_t TableIndex = INVALID_INDEX;
   uint32_t FunctionIndex = INVALID_INDEX;
 };
 
 class DefinedFunction : public FunctionSymbol {
 public:
   DefinedFunction(StringRef Name, uint32_t Flags, InputFile *F,
                   InputFunction *Function);
 
   static bool classof(const Symbol *S) {
     return S->kind() == DefinedFunctionKind;
   }
 
   InputFunction *Function;
 };
 
 class UndefinedFunction : public FunctionSymbol {
 public:
   UndefinedFunction(StringRef Name, uint32_t Flags, InputFile *File = nullptr,
-                    const WasmSignature *Type = nullptr)
+                    const llvm::wasm::WasmSignature *Type = nullptr)
       : FunctionSymbol(Name, UndefinedFunctionKind, Flags, File, Type) {}
 
   static bool classof(const Symbol *S) {
     return S->kind() == UndefinedFunctionKind;
   }
 };
 
 class SectionSymbol : public Symbol {

 };
 
 class GlobalSymbol : public Symbol {
 public:
   static bool classof(const Symbol *S) {
     return S->kind() == DefinedGlobalKind || S->kind() == UndefinedGlobalKind;
   }
 
-  const WasmGlobalType *getGlobalType() const { return GlobalType; }
+  const llvm::wasm::WasmGlobalType *getGlobalType() const { return GlobalType; }
 
   // Get/set the global index
   uint32_t getGlobalIndex() const;
   void setGlobalIndex(uint32_t Index);
   bool hasGlobalIndex() const;
 
 protected:
   GlobalSymbol(StringRef Name, Kind K, uint32_t Flags, InputFile *F,
-               const WasmGlobalType *GlobalType)
+               const llvm::wasm::WasmGlobalType *GlobalType)
       : Symbol(Name, K, Flags, F), GlobalType(GlobalType) {}
 
   // Explicit function type, needed for undefined or synthetic functions only.
   // For regular defined globals this information comes from the InputChunk.
-  const WasmGlobalType *GlobalType;
+  const llvm::wasm::WasmGlobalType *GlobalType;
   uint32_t GlobalIndex = INVALID_INDEX;
 };
 
 class DefinedGlobal : public GlobalSymbol {
 public:
   DefinedGlobal(StringRef Name, uint32_t Flags, InputFile *File,
                 InputGlobal *Global);
 
   static bool classof(const Symbol *S) {
     return S->kind() == DefinedGlobalKind;
   }
 
   InputGlobal *Global;
 };
 
 class UndefinedGlobal : public GlobalSymbol {
 public:
   UndefinedGlobal(StringRef Name, uint32_t Flags, InputFile *File = nullptr,
-                  const WasmGlobalType *Type = nullptr)
+                  const llvm::wasm::WasmGlobalType *Type = nullptr)
       : GlobalSymbol(Name, UndefinedGlobalKind, Flags, File, Type) {}
 
   static bool classof(const Symbol *S) {
     return S->kind() == UndefinedGlobalKind;
   }
 };
 
 class LazySymbol : public Symbol {
 public:
-  LazySymbol(StringRef Name, InputFile *File, const Archive::Symbol &Sym)
+  LazySymbol(StringRef Name, InputFile *File,
+             const llvm::object::Archive::Symbol &Sym)
       : Symbol(Name, LazyKind, 0, File), ArchiveSymbol(Sym) {}
 
   static bool classof(const Symbol *S) { return S->kind() == LazyKind; }
   void fetch();
 
 private:
-  Archive::Symbol ArchiveSymbol;
+  llvm::object::Archive::Symbol ArchiveSymbol;
 };
 
 // linker-generated symbols
 struct WasmSym {
   // __stack_pointer
   // Global that holds the address of the top of the explicit value stack in
   // linear memory.
   static GlobalSymbol *StackPointer;

wasm/WriterUtils.h

 //===- WriterUtils.h --------------------------------------------*- C++ -*-===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLD_WASM_WRITERUTILS_H
 #define LLD_WASM_WRITERUTILS_H
 
 #include "lld/Common/LLVM.h"
 #include "llvm/ADT/Twine.h"
 #include "llvm/Object/Wasm.h"
-#include "llvm/Support/raw_ostream.h"
-
-using llvm::raw_ostream;
 
 namespace lld {
 namespace wasm {
 
 void debugWrite(uint64_t Offset, const Twine &Msg);
 
 void writeUleb128(raw_ostream &OS, uint32_t Number, const Twine &Msg);