[WebAssembly] Add symbol table to LLVM, 2/2

[ncw]

Summary

This patch gets rid of the Globals! Now we have "true" Data symbols, as requested by Sam.

And, there's an explicit symbol table.

All tests pass (after some updates). Function bodies and relocations etc have not changed, which adds confidence that it's working.

First half of symbol table support: D41954

Must be committed along with the corresponding LLD change: D42585

Implements: https://github.com/WebAssembly/tool-conventions/pull/39

[ncw]

I had a few hours this afternoon after my "real" work, and finished off the first implementation: all tests now passing!

(NB corresponding LLD changes not yet done.)

[ncw]

Updated:

• Added some more bits and pieces to truly make Wasm globals first-class objects
• Removed some unused code for emitting globals from a .global_variables section, seems to be completely unused

This changeset is getting a little bit big, but it is actually rather hard to split up. There's not much that could be done independently in its own commit - not without making the intermediate bits non-functioning. Hmm. Removing the .global_variables section could be split out.

In any case, there six other reviews that need to go in before this one, so we'll maybe get onto the review of all this code next week.

[sbc100]

include/llvm/BinaryFormat/Wasm.h

75

This separation of GlobalType looks good, but can perhaps be standalone change unrelated to symbols?

160

How about WasmDataReference or something like that? Since this isn't really symbol but a location a symbol can point to right?

161

Segment?

238

Can this be split out and added separately? (Or is it only relevant in this context?)

include/llvm/Object/Wasm.h

39

If these mirror the existing types then maybe just drop this enum completely?

45–46

I think we can drop SymbolIndex completely now can't we? The yaml can still include it just like it does for the other Index's but I don't think needs to be part of this data structure does it?

test/Object/obj2yaml.test

658

Can you just call this "Index" and have it come first, just like we do for the other indexes (i.e. Type index). It should always be contiguous and always start at zero but can still be useful in the yaml output I think.

[sbc100]

Some initial comments. Looks good in general!

Although I like small changes, I'm not sure I want to land that part 1 of this separately. Lets see how this evolves and how they look when combined too.

lib/MC/WasmObjectWriter.cpp

575

Nice!

1210

If this only __stack_pointer right now, can we wait on adding support for defined globals? Can this, and WASM_COMDAT_GLOBAL itself be a separate change?

[ncw]

In D42495#991420, @sbc100 wrote:

Some initial comments. Looks good in general!

Although I like small changes, I'm not sure I want to land that part 1 of this separately. Lets see how this evolves and how they look when combined too.

Parts 1 & 2 should certainly be in different svn commits (I feel), because otherwise you'd have a single commit where basically every line of test code changes. In the current split, roughly half the test output changes in each commit, which is rather more reassuring. Are you suggesting actually squashing them into a single mega-review?

I can see your point though that Parts 1 & 2 might want to be merged in immediate succession. Is your reasoning simply that you don't want to break the binary format too often?

In practice by the time a couple of other chunks are split off it'll be harder to merge the patch queue in one blast, rather than incrementally. Part 1 is sensible on its own - all functionality works and tests pass.

There are a few smaller changes that we could clean up now while pondering the big ones: D42095, D42539, D42540.

include/llvm/BinaryFormat/Wasm.h

75

Good point, candidate for splitting.

238

If it were split out, it would have to come after the big symbol change refactor, since before that point globals are all fake. I guess that would be possible to do that, but it would be a fairly small post-commit. I can remove it, for now.

include/llvm/Object/Wasm.h

39

Possibly, yes, but it does mirror existing usage. The enums in BinaryFormat are enum : unsigned and are used for assigning values read out of a binary, and the enums in Object are enum class and are used for logical operations like switch statements where you want the strongest compiler warnings.

45–46

I could check - the concept of SymbolIndex is still very much used, but maybe the variable isn't? I'd be surprised, but if it is now obsolete I'll remove it.

lib/MC/WasmObjectWriter.cpp

991–992

Now this I will split out into another commit.

Do you know how this code got here? It's completely unused, and appears like it wouldn't even work. That's because we're emitting globals here that aren't related to any MCSymbols, so they don't generate relocations even in the existing code - and without a R_GLOBAL relocation how could this have ever worked after linking?

1210

Yes, this little bit of stub code for defined globals isn't necessary and could be pulled out into a later commit. Would make sense.

Note - although this looks like an un-split mega-diff, I do actually have several followup chunks already split out, but I just haven't made the reviews for them to avoid premature spam.

test/Object/obj2yaml.test

658

:( Drat, regenerate every test again.... OK, fair enough, it's worth getting it right while we're at it.

[ncw]

Updated:

• Rebased on top of latest work
• Pulled out some chunks in separate reviews: D42750, and one to follow afterwards

[sbc100]

test/MC/WebAssembly/array-fill.ll

18–21

Shouldn't this be SymbolTable now?

21

Lets put "Kind" before "Name". i.e. common fields coming first makes sense to me.

25

Just Offset and Size make sense to me. If you want to be specific then maybe SegmentOffset

test/MC/WebAssembly/unnamed-data.ll

66

How about calling this just "Segment". We could even list the name here if it has one, rather than the index?

Since we use -fdata-sections by default the Offset will almost alwasys be zero, so perhaps we can elide it when it is zero (save for Size).. to make the output less verbose?

test/ObjectYAML/wasm/linking_section.yaml

57

Strange, some tests seem to use use "Index" and others use "SymbolIndex" are some not up-to-date?

tools/yaml2obj/yaml2wasm.cpp

149

Wrapping in ifndef _NDEBUG is more explicit I think.

[ncw]

Updated: addressed comments

[ncw]

test/MC/WebAssembly/unnamed-data.ll

66

As discussed, printing the segment name is more fiddly than it's worth given yaml2obj has to go the other way.

I've renamed DataSize -> Size, DataOffset -> Offset, and made Offset default to 0 (optional)

test/ObjectYAML/wasm/linking_section.yaml

57

Oops, just hadn't updated a couple

tools/yaml2obj/yaml2wasm.cpp

149

Hm, sorry, I forgot to do that. I just try and avoid ifdefs since they're ugly.

[ncw]

Updated:

• Fixed compile error after rebase
• Added "Defined" flag to WasmObject, use it to simplify a few lines of code

[sbc100]

Looks like this needs a rebase. Part 1 seems to apply fine, but this part isn't applying on top of that currently.

include/llvm/BinaryFormat/Wasm.h

246

I think maybe we should expose the symtab struct type here, and have WasmObjectFile have a symtab() method for iterating them directly.

My preference is for all the the structures that map directly from the binary should be declared here in BinaryFormat/Wasm.h.

Then perhaps we can even from the existing WasmSymbol from the other Wasm.h? Or at least have it be a wrapper around the one declared here?

include/llvm/Object/Wasm.h

39

I don't think we need to duplicate this just for that reason. I think we should just remove this completely.

[sbc100]

include/llvm/BinaryFormat/Wasm.h

244

[Not really part of this change but...] Should we add a separate type of BSS here? Or can BSS symbols be expresses as DATA with no segment?

Should these be WASM_SYMTYPE_XXX or WASM_SYMBOL_XXX or maybe just WASM_SYM_XXX ?

[ncw]

Updated with rebase and comments addressed

include/llvm/BinaryFormat/Wasm.h

244

Renamed to WASM_SYMBOL_TYPE_XXX - a bit verbose but matches conventions for the other enums.

Regarding BSS: I've been thinking/planning how to handle that; I can work on it after these patches if you want. What I had in mind was that the segment-metadata would gain the ability to describe BSS segments via a flag (currently no segment flags are defined), and for BSS segments there would be no corresponding Wasm segment. Currently we have Wasm segments mapping 1-to-1 to segment metadata; in the new scheme we'd have possibly more segment metadata than Wasm segments, and BSS segment metadata wouldn't have a corresponding Wasm segment.

246

Good idea, makes sense. I've added it to the LinkingMetadata struct rather than have a new symtab() method on the WasmObjectFile.

In fact, I've got a future commit where I'll add the Comdats to the LinkingMetadata (rather than their location as a freestanding method on WasmObjectFile).

I've stripped the guts out of llvm::object::WasmSymbol, but I've kept it around for the time being. It currently contains some extra information that isn't stored directly in the binary format, so it makes sense to keep it - in the same way that llvm::object::WasmSegment and WasmSection wrap the underlying BinaryFormat structs.

include/llvm/Object/Wasm.h

39

Ok, removed.

[ncw]

Updated: just a rebase to fix conflicts after variable renaming in patch 1/2

[sbc100]

lib/MC/WasmObjectWriter.cpp

151

Isn't this now the same as WasmSymbolInfo? (i.e. can we remove this?

1017

The return value of getType() here needs to be WASM_SYMBOL_TYPE_*.. but its currently a MCSymboLWasm::SymbolType. Rather than casting here, can we just remove MCSymboLWasm::SymbolType completely?

[ncw]

Updated: Removed redundant WasmObjectWriter::WasmSymbolEntry and MCSymbolWasm::SymbolType, now that there is an appropriate named struct/enum for these in BinaryFormat/Wasm.h

[ncw]

include/llvm/BinaryFormat/Wasm.h

244

I've had a better plan for BSS: we should keep the one-to-one correspondence Wasm segments and linking segments. Instead, we should tweak the "segment metadata" to include a Size, and there should be a WASM_SEGMENT_BSS flag. For BSS segments, the Wasm elem will just be empty (rather than contain the zeros explicitly), and the segment's size in LLD shall be taken from the metadata Size; for non-BSS segments the metadata's Size much match the size of the Wasm elem. Thus we can skip long runs of zeros - but without needing yet another concept of "index".

[sbc100]

include/llvm/BinaryFormat/Wasm.h

244

Sounds good to me

[sbc100]

lib/Object/WasmObjectFile.cpp

460

I think we should use readUint8 here.

I'm also not sure about the use of Optional in WasmSymbolInfo. I'd rather just explicit this byte directly, like we do with the HAS_MAX flag in WasmLimits.

[ncw]

Updated: removed use of Optional in symbol struct, used union instead for consistency with other structs. Using existing "DEFINED" flag to indicate whether a segment is present.

[ncw]

lib/Object/WasmObjectFile.cpp

460

Done. I was able to re-use the existing DEFINED flag to keep the struct compact

include/llvm/BinaryFormat/Wasm.h

 
 struct WasmGlobalType {
   int32_t Type;
   bool Mutable;
 };
 
 struct WasmGlobal {
   uint32_t Index;
   WasmGlobalType Type;
   WasmInitExpr InitExpr;
 };
 
 struct WasmImport {
   StringRef Module;
   StringRef Field;
   uint32_t Kind;
   union {

 };
 
 struct WasmElemSegment {
   uint32_t TableIndex;
   WasmInitExpr Offset;
   std::vector<uint32_t> Functions;
 };
 
+// Represents the location of a Wasm data symbol within a WasmDataSegment, as
+// the index of the segment, and the offset and size within the segment.
+struct WasmDataReference {
+  uint32_t Segment;
+  uint32_t Offset;
+  uint32_t Size;
+};
+
 struct WasmRelocation {
   uint32_t Type;   // The type of the relocation.
   uint32_t Index;  // Index into function or global index space.
   uint64_t Offset; // Offset from the start of the section.
   int64_t Addend;  // A value to add to the symbol.
 };
 
 struct WasmInitFunc {
   uint32_t Priority;
   uint32_t Symbol;
 };
 
+struct WasmSymbolInfo {
+  StringRef Name;
+  uint32_t Kind;
+  uint32_t Flags;
+  // For a function or global symbol, the index into the the Wasm index space.
+  uint32_t ElementIndex;
+  // For a data symbol, the segment (or empty if the data symbol is undefined).
+  Optional<wasm::WasmDataReference> Segment;
+};
+
 struct WasmFunctionName {
   uint32_t Index;
   StringRef Name;
 };
 
 struct WasmLinkingData {
   uint32_t DataSize;
   std::vector<WasmInitFunc> InitFunctions;
+  std::vector<WasmSymbolInfo> SymbolTable;
 };
 
 enum : unsigned {
   WASM_SEC_CUSTOM = 0,   // Custom / User-defined section
   WASM_SEC_TYPE = 1,     // Function signature declarations
   WASM_SEC_IMPORT = 2,   // Import declarations
   WASM_SEC_FUNCTION = 3, // Function declarations
   WASM_SEC_TABLE = 4,    // Indirect function table and other tables
   WASM_SEC_MEMORY = 5,   // Memory attributes

 // Kind codes used in the custom "name" section
 enum : unsigned {
   WASM_NAMES_FUNCTION = 0x1,
   WASM_NAMES_LOCAL    = 0x2,
 };
 
 // Kind codes used in the custom "linking" section
 enum : unsigned {
-  WASM_SYMBOL_INFO    = 0x2,
   WASM_DATA_SIZE      = 0x3,
   WASM_SEGMENT_INFO   = 0x5,
   WASM_INIT_FUNCS     = 0x6,
   WASM_COMDAT_INFO    = 0x7,
+  WASM_SYMBOL_TABLE   = 0x8,
 };
 
 // Kind codes used in the custom "linking" section in the WASM_COMDAT_INFO
 enum : unsigned {
   WASM_COMDAT_DATA        = 0x0,
   WASM_COMDAT_FUNCTION    = 0x1,
 };
 
+// Kind codes used in the custom "linking" section in the WASM_SYMBOL_TABLE
+enum WasmSymbolType : unsigned {
+  WASM_SYMBOL_TYPE_FUNCTION = 0x0,
+  WASM_SYMBOL_TYPE_DATA     = 0x1,
+  WASM_SYMBOL_TYPE_GLOBAL   = 0x2,
+};
+
 const unsigned WASM_SYMBOL_BINDING_MASK       = 0x3;
 const unsigned WASM_SYMBOL_VISIBILITY_MASK    = 0x4;
 
 const unsigned WASM_SYMBOL_BINDING_GLOBAL     = 0x0;
 const unsigned WASM_SYMBOL_BINDING_WEAK       = 0x1;
 const unsigned WASM_SYMBOL_BINDING_LOCAL      = 0x2;
 const unsigned WASM_SYMBOL_VISIBILITY_DEFAULT = 0x0;
 const unsigned WASM_SYMBOL_VISIBILITY_HIDDEN  = 0x4;
 
+// Flags used internally in WasmObject but not written to the binary
+const unsigned WASM_SYMBOL_OBJECT_MASK        = 0x100;
+const unsigned WASM_SYMBOL_OBJECT_DEFINED     = 0x100;
+
 #define WASM_RELOC(name, value) name = value,
 
 enum : unsigned {
 #include "WasmRelocs.def"
 };
 
 #undef WASM_RELOC
 
-struct Global {
-  ValType Type;
-  bool Mutable;
-
-  // The initial value for this global is either the value of an imported
-  // global, in which case InitialModule and InitialName specify the global
-  // import, or a value, in which case InitialModule is empty and InitialValue
-  // holds the value.
-  StringRef InitialModule;
-  StringRef InitialName;
-  uint64_t InitialValue;
-};
-
 } // end namespace wasm
 } // end namespace llvm
 
 #endif

include/llvm/MC/MCSectionWasm.h

private:
 
   // The offset of the MC function/data section in the wasm code/data section.
   // For data relocations the offset is relative to start of the data payload
   // itself and does not include the size of the section header.
   uint64_t SectionOffset;
 
   // For data sections, this is the offset of the corresponding wasm data
   // segment
-  uint64_t MemoryOffset;
+  uint32_t SegmentIndex;
 
   friend class MCContext;
   MCSectionWasm(StringRef Section, SectionKind K, const MCSymbolWasm *group,
                 unsigned UniqueID, MCSymbol *Begin)
       : MCSection(SV_Wasm, K, Begin), SectionName(Section), UniqueID(UniqueID),
-        Group(group), SectionOffset(0) {}
+        Group(group), SectionOffset(0), SegmentIndex((uint32_t)-1) {}
 
   void setSectionName(StringRef Name) { SectionName = Name; }
 
 public:
   ~MCSectionWasm();
 
   /// Decides whether a '.section' directive should be printed before the
   /// section name
public:
   }
 
   bool isUnique() const { return UniqueID != ~0U; }
   unsigned getUniqueID() const { return UniqueID; }
 
   uint64_t getSectionOffset() const { return SectionOffset; }
   void setSectionOffset(uint64_t Offset) { SectionOffset = Offset; }
 
-  uint32_t getMemoryOffset() const { return MemoryOffset; }
-  void setMemoryOffset(uint32_t Offset) { MemoryOffset = Offset; }
+  uint32_t getSegmentIndex() const { return SegmentIndex; }
+  void setSegmentIndex(uint32_t Index) { SegmentIndex = Index; }
 
   static bool classof(const MCSection *S) { return S->getVariant() == SV_Wasm; }
 };
 
 } // end namespace llvm
 
 #endif

include/llvm/MC/MCSymbolWasm.h

 #define LLVM_MC_MCSYMBOLWASM_H
 
 #include "llvm/BinaryFormat/Wasm.h"
 #include "llvm/MC/MCSymbol.h"
 
 namespace llvm {
 
 class MCSymbolWasm : public MCSymbol {
+public:
+  enum class SymbolType {
+    FUNCTION,
+    DATA,
+    GLOBAL
+  };
+
 private:
-  bool IsFunction = false;
+  SymbolType Type = SymbolType::DATA;
   bool IsWeak = false;
   bool IsHidden = false;
   bool IsComdat = false;
   std::string ModuleName;
   SmallVector<wasm::ValType, 1> Returns;
   SmallVector<wasm::ValType, 4> Params;
+  wasm::WasmGlobalType GlobalType;
   bool ParamsSet = false;
   bool ReturnsSet = false;
+  bool GlobalTypeSet = false;
 
   /// An expression describing how to calculate the size of a symbol. If a
   /// symbol has no size this field will be NULL.
   const MCExpr *SymbolSize = nullptr;
 
 public:
   // Use a module name of "env" for now, for compatibility with existing tools.
   // This is temporary, and may change, as the ABI is not yet stable.
   MCSymbolWasm(const StringMapEntry<bool> *Name, bool isTemporary)
       : MCSymbol(SymbolKindWasm, Name, isTemporary),
         ModuleName("env") {}
   static bool classof(const MCSymbol *S) { return S->isWasm(); }
 
   const MCExpr *getSize() const { return SymbolSize; }
   void setSize(const MCExpr *SS) { SymbolSize = SS; }
 
-  bool isFunction() const { return IsFunction; }
-  void setIsFunction(bool isFunc) { IsFunction = isFunc; }
+  bool isFunction() const { return Type == SymbolType::FUNCTION; }
+  bool isData() const { return Type == SymbolType::DATA; }
+  SymbolType getType() const { return Type; }
+  void setType(SymbolType type) { Type = type; }
 
   bool isWeak() const { return IsWeak; }
   void setWeak(bool isWeak) { IsWeak = isWeak; }
 
   bool isHidden() const { return IsHidden; }
   void setHidden(bool isHidden) { IsHidden = isHidden; }
 
   bool isComdat() const { return IsComdat; }
const SmallVector<wasm::ValType, 4> &getParams() const {
     assert(ParamsSet);
     return Params;
   }
 
   void setParams(SmallVectorImpl<wasm::ValType> &&Pars) {
     ParamsSet = true;
     Params = std::move(Pars);
   }
+
+  const wasm::WasmGlobalType &getGlobalType() const {
+    assert(GlobalTypeSet);
+    return GlobalType;
+  }
+
+  void setGlobalType(wasm::WasmGlobalType GT) {
+    GlobalTypeSet = true;
+    GlobalType = GT;
+  }
 };
 
 }  // end namespace llvm
 
 #endif // LLVM_MC_MCSYMBOLWASM_H

include/llvm/Object/Wasm.h

 // See: https://github.com/WebAssembly/design/blob/master/BinaryEncoding.md
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_OBJECT_WASM_H
 #define LLVM_OBJECT_WASM_H
 
 #include "llvm/ADT/ArrayRef.h"
+#include "llvm/ADT/Optional.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/StringMap.h"
 #include "llvm/BinaryFormat/Wasm.h"
 #include "llvm/Object/Binary.h"
 #include "llvm/Object/ObjectFile.h"
 #include "llvm/Support/Error.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include <cstddef>
 #include <cstdint>
 #include <vector>
 
 namespace llvm {
 namespace object {
 
 class WasmSymbol {
 public:
-  enum class SymbolType {
-    FUNCTION_IMPORT,
-    FUNCTION_EXPORT,
-    GLOBAL_IMPORT,
-    GLOBAL_EXPORT,
-  };
-
-  WasmSymbol(StringRef Name, SymbolType Type, uint32_t Section,
-             uint32_t SymbolIndex, uint32_t ElementIndex,
-             uint32_t FunctionType = 0)
-      : Name(Name), Type(Type), Section(Section), SymbolIndex(SymbolIndex),
-        ElementIndex(ElementIndex), FunctionType(FunctionType) {}
+  WasmSymbol(uint32_t Section, const wasm::WasmSignature *FunctionType,
+             const wasm::WasmGlobalType *GlobalType,
+             const wasm::WasmSymbolInfo &Info)
+      : Section(Section), FunctionType(FunctionType), GlobalType(GlobalType),
+        Info(Info) {}
 
-  StringRef Name;
-  SymbolType Type;
   uint32_t Section;
-  uint32_t Flags = 0;
 
-  // Index into the Symbol index space, which consists of all Symbols
-  // together, in order of declaration.
-  uint32_t SymbolIndex;
-  // For a function or global symbol, the index into the the Wasm index space.
-  // This is the index space used by the Wasm format for referring to a function
-  // or global, and consists of the imports then definitions.
-  uint32_t ElementIndex;
+  const wasm::WasmSignature *FunctionType;
+  const wasm::WasmGlobalType *GlobalType;
 
-  // For a function symbol, the type index.
-  uint32_t FunctionType;
+  const wasm::WasmSymbolInfo &Info;
 
 
   bool isTypeFunction() const {
-    return Type == WasmSymbol::SymbolType::FUNCTION_IMPORT ||
-           Type == WasmSymbol::SymbolType::FUNCTION_EXPORT;
+    return Info.Kind == wasm::WASM_SYMBOL_TYPE_FUNCTION;
+  }
+
+  bool isTypeData() const {
+    return Info.Kind == wasm::WASM_SYMBOL_TYPE_DATA;
   }
 
   bool isTypeGlobal() const {
-    return Type == SymbolType::GLOBAL_IMPORT ||
-           Type == SymbolType::GLOBAL_EXPORT;
+    return Info.Kind == wasm::WASM_SYMBOL_TYPE_GLOBAL;
+  }
+
+
+  bool isDefined() const {
+    return (Info.Flags & wasm::WASM_SYMBOL_OBJECT_DEFINED) != 0;
+  }
+
+  bool isUndefined() const {
+    return !isDefined();
   }
 
 
   bool isBindingWeak() const {
     return getBinding() == wasm::WASM_SYMBOL_BINDING_WEAK;
   }
 
   bool isBindingGlobal() const {
     return getBinding() == wasm::WASM_SYMBOL_BINDING_GLOBAL;
   }
 
   bool isBindingLocal() const {
     return getBinding() == wasm::WASM_SYMBOL_BINDING_LOCAL;
   }
 
   unsigned getBinding() const {
-    return Flags & wasm::WASM_SYMBOL_BINDING_MASK;
+    return Info.Flags & wasm::WASM_SYMBOL_BINDING_MASK;
   }
 
   bool isHidden() const {
     return getVisibility() == wasm::WASM_SYMBOL_VISIBILITY_HIDDEN;
   }
 
   unsigned getVisibility() const {
-    return Flags & wasm::WASM_SYMBOL_VISIBILITY_MASK;
+    return Info.Flags & wasm::WASM_SYMBOL_VISIBILITY_MASK;
   }
 
   void print(raw_ostream &Out) const {
-    Out << "Name=" << Name << ", Type=" << static_cast<int>(Type)
-        << ", Flags=" << Flags << " ElemIndex=" << ElementIndex;
+    Out << "Name=" << Info.Name << ", Kind=" << static_cast<int>(Info.Kind)
+        << ", Flags=" << Info.Flags;
+    if (!isTypeData())
+      Out << ", ElemIndex=" << Info.ElementIndex;
+    else if (Info.Segment.hasValue())
+      Out << ", SegmentIndex=" << Info.Segment.getValue().Segment;
   }
 
 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
   LLVM_DUMP_METHOD void dump() const { print(dbgs()); }
 #endif
 };
 
 struct WasmSection {
public:
   bool isRelocatableObject() const override;
 
 private:
   bool isValidFunctionIndex(uint32_t Index) const;
   bool isDefinedFunctionIndex(uint32_t Index) const;
   bool isValidGlobalIndex(uint32_t Index) const;
   bool isDefinedGlobalIndex(uint32_t Index) const;
   bool isValidFunctionSymbolIndex(uint32_t Index) const;
-  wasm::WasmFunction& getDefinedFunction(uint32_t Index);
+  wasm::WasmFunction &getDefinedFunction(uint32_t Index);
+  wasm::WasmGlobal &getDefinedGlobal(uint32_t Index);
 
   const WasmSection &getWasmSection(DataRefImpl Ref) const;
   const wasm::WasmRelocation &getWasmRelocation(DataRefImpl Ref) const;
 
   WasmSection* findCustomSectionByName(StringRef Name);
   WasmSection* findSectionByType(uint32_t Type);
 
   const uint8_t *getPtr(size_t Offset) const;
private:
   Error parseStartSection(const uint8_t *Ptr, const uint8_t *End);
   Error parseElemSection(const uint8_t *Ptr, const uint8_t *End);
   Error parseCodeSection(const uint8_t *Ptr, const uint8_t *End);
   Error parseDataSection(const uint8_t *Ptr, const uint8_t *End);
 
   // Custom section types
   Error parseNameSection(const uint8_t *Ptr, const uint8_t *End);
   Error parseLinkingSection(const uint8_t *Ptr, const uint8_t *End);
+  Error parseLinkingSectionSymtab(const uint8_t *&Ptr, const uint8_t *End);
   Error parseLinkingSectionComdat(const uint8_t *&Ptr, const uint8_t *End);
   Error parseRelocSection(StringRef Name, const uint8_t *Ptr,
                           const uint8_t *End);
 
-  Error populateSymbolTable();
-
   wasm::WasmObjectHeader Header;
   std::vector<WasmSection> Sections;
   std::vector<wasm::WasmSignature> Signatures;
   std::vector<uint32_t> FunctionTypes;
   std::vector<wasm::WasmTable> Tables;
   std::vector<wasm::WasmLimits> Memories;
   std::vector<wasm::WasmGlobal> Globals;
   std::vector<wasm::WasmImport> Imports;
   std::vector<wasm::WasmExport> Exports;
   std::vector<wasm::WasmElemSegment> ElemSegments;
   std::vector<WasmSegment> DataSegments;
   std::vector<wasm::WasmFunction> Functions;
   std::vector<WasmSymbol> Symbols;
   std::vector<StringRef> Comdats;
   std::vector<wasm::WasmFunctionName> DebugNames;
   uint32_t StartFunction = -1;
   bool HasLinkingSection = false;
   wasm::WasmLinkingData LinkingData;
   uint32_t NumImportedGlobals = 0;
   uint32_t NumImportedFunctions = 0;
   uint32_t ImportSection = 0;
-  uint32_t ExportSection = 0;
-
-  // TODO: will get rid of this map in next commit, once we get replace the
-  // WASM_SYMBOL_INFO section with WASM_SYMBOL_TABLE
-  StringMap<uint32_t> SymbolMap;
+  uint32_t GlobalSection = 0;
+  uint32_t CodeSection = 0;
+  uint32_t DataSection = 0;
 };
 
 } // end namespace object
 
 inline raw_ostream &operator<<(raw_ostream &OS,
                                const object::WasmSymbol &Sym) {
   Sym.print(OS);
   return OS;
 }
 
 } // end namespace llvm
 
 #endif // LLVM_OBJECT_WASM_H

include/llvm/ObjectYAML/WasmYAML.h

 LLVM_YAML_STRONG_TYPEDEF(uint32_t, SectionType)
 LLVM_YAML_STRONG_TYPEDEF(int32_t, ValueType)
 LLVM_YAML_STRONG_TYPEDEF(int32_t, TableType)
 LLVM_YAML_STRONG_TYPEDEF(int32_t, SignatureForm)
 LLVM_YAML_STRONG_TYPEDEF(uint32_t, ExportKind)
 LLVM_YAML_STRONG_TYPEDEF(uint32_t, Opcode)
 LLVM_YAML_STRONG_TYPEDEF(uint32_t, RelocType)
 LLVM_YAML_STRONG_TYPEDEF(uint32_t, SymbolFlags)
+LLVM_YAML_STRONG_TYPEDEF(uint32_t, SymbolKind)
 LLVM_YAML_STRONG_TYPEDEF(uint32_t, SegmentFlags)
 LLVM_YAML_STRONG_TYPEDEF(uint32_t, LimitFlags)
 LLVM_YAML_STRONG_TYPEDEF(uint32_t, ComdatKind)
 
 struct FileHeader {
   yaml::Hex32 Version;
 };
 

 
 struct Signature {
   uint32_t Index;
   SignatureForm Form = wasm::WASM_TYPE_FUNC;
   std::vector<ValueType> ParamTypes;
   ValueType ReturnType;
 };
 
+struct SymbolInfoSegment {
+  int32_t Segment;
+  uint32_t Offset;
+  uint32_t Size;
+};
+
 struct SymbolInfo {
+  uint32_t Index;
   StringRef Name;
+  SymbolKind Kind;
   SymbolFlags Flags;
+  union {
+    uint32_t FunctionIndex;
+    uint32_t GlobalIndex;
+    SymbolInfoSegment Segment;
+  };
 };
 
 struct InitFunction {
   uint32_t Priority;
   uint32_t Symbol;
 };
 
 struct ComdatEntry {
struct LinkingSection : CustomSection {
   LinkingSection() : CustomSection("linking") {}
 
   static bool classof(const Section *S) {
     auto C = dyn_cast<CustomSection>(S);
     return C && C->Name == "linking";
   }
 
   uint32_t DataSize;
-  std::vector<SymbolInfo> SymbolInfos;
+  std::vector<SymbolInfo> SymbolTable;
   std::vector<SegmentInfo> SegmentInfos;
   std::vector<InitFunction> InitFunctions;
   std::vector<Comdat> Comdats;
 };
 
 struct TypeSection : Section {
   TypeSection() : Section(wasm::WASM_SEC_TYPE) {}
 

 template <> struct ScalarBitSetTraits<WasmYAML::LimitFlags> {
   static void bitset(IO &IO, WasmYAML::LimitFlags &Value);
 };
 
 template <> struct ScalarBitSetTraits<WasmYAML::SymbolFlags> {
   static void bitset(IO &IO, WasmYAML::SymbolFlags &Value);
 };
 
+template <> struct ScalarEnumerationTraits<WasmYAML::SymbolKind> {
+  static void enumeration(IO &IO, WasmYAML::SymbolKind &Kind);
+};
+
 template <> struct ScalarBitSetTraits<WasmYAML::SegmentFlags> {
   static void bitset(IO &IO, WasmYAML::SegmentFlags &Value);
 };
 
 template <> struct ScalarEnumerationTraits<WasmYAML::SectionType> {
   static void enumeration(IO &IO, WasmYAML::SectionType &Type);
 };
 

lib/MC/MCWasmStreamer.cpp

case MCSA_WeakReference:
     Symbol->setExternal(true);
     break;
 
   case MCSA_Global:
     Symbol->setExternal(true);
     break;
 
   case MCSA_ELF_TypeFunction:
-    Symbol->setIsFunction(true);
+    Symbol->setType(MCSymbolWasm::SymbolType::FUNCTION);
     break;
 
   case MCSA_ELF_TypeObject:
-    Symbol->setIsFunction(false);
+    Symbol->setType(MCSymbolWasm::SymbolType::DATA);
     break;
 
   default:
     // unrecognized directive
     llvm_unreachable("unexpected MCSymbolAttr");
     return false;
   }
 

lib/MC/WasmObjectWriter.cpp

 // Information about a single item which is part of a COMDAT.  For each data
 // segment or function which is in the COMDAT, there is a corresponding
 // WasmComdatEntry.
 struct WasmComdatEntry {
   unsigned Kind;
   uint32_t Index;
 };
 
+// Information about a single entry to be written to the symbol table
+struct WasmSymbolEntry {
+  StringRef Name;
+  unsigned Kind;
+  uint32_t Flags;
+  uint32_t WasmIndex;
+  Optional<wasm::WasmDataReference> Segment;
+};
+
 // Information about a single relocation.
 struct WasmRelocationEntry {
   uint64_t Offset;                  // Where is the relocation.
   const MCSymbolWasm *Symbol;       // The symbol to relocate with.
   int64_t Addend;                   // A value to add to the symbol.
   unsigned Type;                    // The type of the relocation.
   const MCSectionWasm *FixupSection;// The section the relocation is targeting.
 
class WasmObjectWriter : public MCObjectWriter {
   DenseMap<const MCSymbolWasm *, uint32_t> TypeIndices;
   // Maps function symbols to the table element index space. Used
   // for TABLE_INDEX relocation types (i.e. address taken functions).
   DenseMap<const MCSymbolWasm *, uint32_t> TableIndices;
   // Maps function/global symbols to the (shared) Symbol index space.
   DenseMap<const MCSymbolWasm *, uint32_t> SymbolIndices;
   // Maps function/global symbols to the function/global Wasm index space.
   DenseMap<const MCSymbolWasm *, uint32_t> WasmIndices;
+  // Maps data symbols to the Wasm segment and offset/size with the segment.
+  DenseMap<const MCSymbolWasm *, Optional<wasm::WasmDataReference>>
+      SegmentIndices;
 
   DenseMap<WasmFunctionType, int32_t, WasmFunctionTypeDenseMapInfo>
       FunctionTypeIndices;
   SmallVector<WasmFunctionType, 4> FunctionTypes;
   SmallVector<WasmGlobal, 4> Globals;
+  SmallVector<WasmDataSegment, 4> DataSegments;
   unsigned NumFunctionImports = 0;
   unsigned NumGlobalImports = 0;
 
   // TargetObjectWriter wrappers.
   bool is64Bit() const { return TargetObjectWriter->is64Bit(); }
   unsigned getRelocType(const MCValue &Target, const MCFixup &Fixup) const {
     return TargetObjectWriter->getRelocType(Target, Fixup);
   }

 private:
   void reset() override {
     CodeRelocations.clear();
     DataRelocations.clear();
     TypeIndices.clear();
     SymbolIndices.clear();
     WasmIndices.clear();
     TableIndices.clear();
+    SegmentIndices.clear();
     FunctionTypeIndices.clear();
     FunctionTypes.clear();
     Globals.clear();
+    DataSegments.clear();
     MCObjectWriter::reset();
     NumFunctionImports = 0;
     NumGlobalImports = 0;
   }
 
   void writeHeader(const MCAssembler &Asm);
 
   void recordRelocation(MCAssembler &Asm, const MCAsmLayout &Layout,
private:
   void writeImportSection(ArrayRef<WasmImport> Imports, uint32_t DataSize,
                           uint32_t NumElements);
   void writeFunctionSection(ArrayRef<WasmFunction> Functions);
   void writeGlobalSection();
   void writeExportSection(ArrayRef<WasmExport> Exports);
   void writeElemSection(ArrayRef<uint32_t> TableElems);
   void writeCodeSection(const MCAssembler &Asm, const MCAsmLayout &Layout,
                         ArrayRef<WasmFunction> Functions);
-  void writeDataSection(ArrayRef<WasmDataSegment> Segments);
+  void writeDataSection();
   void writeCodeRelocSection();
   void writeDataRelocSection();
   void writeLinkingMetaDataSection(
-      ArrayRef<WasmDataSegment> Segments, uint32_t DataSize,
-      ArrayRef<std::pair<StringRef, uint32_t>> SymbolFlags,
+      uint32_t DataSize, ArrayRef<WasmSymbolEntry> SymbolInfos,
       ArrayRef<std::pair<uint16_t, uint32_t>> InitFuncs,
       const std::map<StringRef, std::vector<WasmComdatEntry>>& Comdats);
 
   uint32_t getProvisionalValue(const WasmRelocationEntry &RelEntry);
   void applyRelocations(ArrayRef<WasmRelocationEntry> Relocations,
                         uint64_t ContentsOffset);
 
   void writeRelocations(ArrayRef<WasmRelocationEntry> Relocations);
WasmObjectWriter::getProvisionalValue(const WasmRelocationEntry &RelEntry) {
   case wasm::R_WEBASSEMBLY_MEMORY_ADDR_LEB:
   case wasm::R_WEBASSEMBLY_MEMORY_ADDR_I32:
   case wasm::R_WEBASSEMBLY_MEMORY_ADDR_SLEB: {
     // Provisional value is address of the global
     const MCSymbolWasm *Sym = ResolveSymbol(*RelEntry.Symbol);
     // For undefined symbols, use zero
     if (!Sym->isDefined())
       return 0;
-
-    uint32_t GlobalIndex = WasmIndices[Sym];
-    const WasmGlobal& Global = Globals[GlobalIndex - NumGlobalImports];
-    uint64_t Address = Global.InitialValue + RelEntry.Addend;
-
+    auto &SI = SegmentIndices[Sym];
+    const WasmDataSegment &Segment = DataSegments[SI.getValue().Segment];
     // Ignore overflow. LLVM allows address arithmetic to silently wrap.
-    return Address;
+    return Segment.Offset + SI.getValue().Offset + RelEntry.Addend;
   }
   default:
     llvm_unreachable("invalid relocation type");
   }
 }
 
 static void addData(SmallVectorImpl<char> &DataBytes,
                     MCSectionWasm &DataSection) {
   DEBUG(errs() << "addData: " << DataSection.getSectionName() << "\n");
 
   DataBytes.resize(alignTo(DataBytes.size(), DataSection.getAlignment()));
 
-  size_t LastFragmentSize = 0;
   for (const MCFragment &Frag : DataSection) {
     if (Frag.hasInstructions())
       report_fatal_error("only data supported in data sections");
 
     if (auto *Align = dyn_cast<MCAlignFragment>(&Frag)) {
       if (Align->getValueSize() != 1)
         report_fatal_error("only byte values supported for alignment");
       // If nops are requested, use zeros, as this is the data section.
       uint8_t Value = Align->hasEmitNops() ? 0 : Align->getValue();
       uint64_t Size = std::min<uint64_t>(alignTo(DataBytes.size(),
                                                  Align->getAlignment()),
                                          DataBytes.size() +
                                              Align->getMaxBytesToEmit());
       DataBytes.resize(Size, Value);
     } else if (auto *Fill = dyn_cast<MCFillFragment>(&Frag)) {
       int64_t Size;
       if (!Fill->getSize().evaluateAsAbsolute(Size))
         llvm_unreachable("The fill should be an assembler constant");
       DataBytes.insert(DataBytes.end(), Size, Fill->getValue());
     } else {
       const auto &DataFrag = cast<MCDataFragment>(Frag);
       const SmallVectorImpl<char> &Contents = DataFrag.getContents();
 
       DataBytes.insert(DataBytes.end(), Contents.begin(), Contents.end());
-      LastFragmentSize = Contents.size();
     }
   }
 
-  // Don't allow empty segments, or segments that end with zero-sized
-  // fragment, otherwise the linker cannot map symbols to a unique
-  // data segment.  This can be triggered by zero-sized structs
-  // See: test/MC/WebAssembly/bss.ll
-  if (LastFragmentSize == 0)
-    DataBytes.resize(DataBytes.size() + 1);
   DEBUG(dbgs() << "addData -> " << DataBytes.size() << "\n");
 }
 
 uint32_t
 WasmObjectWriter::getRelocationIndexValue(const WasmRelocationEntry &RelEntry) {
   if (RelEntry.Type == wasm::R_WEBASSEMBLY_TYPE_INDEX_LEB) {
     if (!TypeIndices.count(RelEntry.Symbol))
       report_fatal_error("symbol not found in type index space: " +
void WasmObjectWriter::writeCodeSection(const MCAssembler &Asm,
   }
 
   // Apply fixups.
   applyRelocations(CodeRelocations, Section.ContentsOffset);
 
   endSection(Section);
 }
 
-void WasmObjectWriter::writeDataSection(ArrayRef<WasmDataSegment> Segments) {
-  if (Segments.empty())
+void WasmObjectWriter::writeDataSection() {
+  if (DataSegments.empty())
     return;
 
   SectionBookkeeping Section;
   startSection(Section, wasm::WASM_SEC_DATA);
 
-  encodeULEB128(Segments.size(), getStream()); // count
+  encodeULEB128(DataSegments.size(), getStream()); // count
 
-  for (const WasmDataSegment & Segment : Segments) {
+  for (const WasmDataSegment & Segment : DataSegments) {
     encodeULEB128(0, getStream()); // memory index
     write8(wasm::WASM_OPCODE_I32_CONST);
     encodeSLEB128(Segment.Offset, getStream()); // offset
     write8(wasm::WASM_OPCODE_END);
     encodeULEB128(Segment.Data.size(), getStream()); // size
     Segment.Section->setSectionOffset(getStream().tell() - Section.ContentsOffset);
     writeBytes(Segment.Data); // data
   }
void WasmObjectWriter::writeDataRelocSection() {
   encodeULEB128(DataRelocations.size(), getStream());
 
   writeRelocations(DataRelocations);
 
   endSection(Section);
 }
 
 void WasmObjectWriter::writeLinkingMetaDataSection(
-    ArrayRef<WasmDataSegment> Segments, uint32_t DataSize,
-    ArrayRef<std::pair<StringRef, uint32_t>> SymbolFlags,
+    uint32_t DataSize, ArrayRef<WasmSymbolEntry> SymbolInfos,
     ArrayRef<std::pair<uint16_t, uint32_t>> InitFuncs,
     const std::map<StringRef, std::vector<WasmComdatEntry>>& Comdats) {
   SectionBookkeeping Section;
   startSection(Section, wasm::WASM_SEC_CUSTOM, "linking");
   SectionBookkeeping SubSection;
 
-  if (SymbolFlags.size() != 0) {
-    startSection(SubSection, wasm::WASM_SYMBOL_INFO);
-    encodeULEB128(SymbolFlags.size(), getStream());
-    for (auto Pair: SymbolFlags) {
-      writeString(Pair.first);
-      encodeULEB128(Pair.second, getStream());
+  if (SymbolInfos.size() != 0) {
+    startSection(SubSection, wasm::WASM_SYMBOL_TABLE);
+    encodeULEB128(SymbolInfos.size(), getStream());
+    for (auto &Sym : SymbolInfos) {
+      encodeULEB128(Sym.Kind, getStream());
+      encodeULEB128(Sym.Flags, getStream());
+      switch (Sym.Kind) {
+      case wasm::WASM_SYMBOL_TYPE_FUNCTION:
+        encodeULEB128(Sym.WasmIndex, getStream());
+        if (Sym.WasmIndex >= NumFunctionImports)
+          writeString(Sym.Name);
+        break;
+      case wasm::WASM_SYMBOL_TYPE_GLOBAL:
+        encodeULEB128(Sym.WasmIndex, getStream());
+        if (Sym.WasmIndex >= NumGlobalImports)
+          writeString(Sym.Name);
+        break;
+      case wasm::WASM_SYMBOL_TYPE_DATA:
+        writeString(Sym.Name);
+        getStream() << static_cast<uint8_t>(Sym.Segment.hasValue());
+        if (Sym.Segment.hasValue()) {
+          encodeULEB128(Sym.Segment.getValue().Segment, getStream());
+          encodeULEB128(Sym.Segment.getValue().Offset, getStream());
+          encodeULEB128(Sym.Segment.getValue().Size, getStream());
+        }
+        break;
+      default:
+        llvm_unreachable("unexpected kind");
+      }
     }
     endSection(SubSection);
   }
 
   if (DataSize > 0) {
     startSection(SubSection, wasm::WASM_DATA_SIZE);
     encodeULEB128(DataSize, getStream());
     endSection(SubSection);
   }
 
-  if (Segments.size()) {
+  if (DataSegments.size()) {
     startSection(SubSection, wasm::WASM_SEGMENT_INFO);
-    encodeULEB128(Segments.size(), getStream());
-    for (const WasmDataSegment &Segment : Segments) {
+    encodeULEB128(DataSegments.size(), getStream());
+    for (const WasmDataSegment &Segment : DataSegments) {
       writeString(Segment.Name);
       encodeULEB128(Segment.Alignment, getStream());
       encodeULEB128(Segment.Flags, getStream());
     }
     endSection(SubSection);
   }
 
   if (!InitFuncs.empty()) {
void WasmObjectWriter::writeObject(MCAssembler &Asm,
   MCContext &Ctx = Asm.getContext();
   int32_t PtrType = is64Bit() ? wasm::WASM_TYPE_I64 : wasm::WASM_TYPE_I32;
 
   // Collect information from the available symbols.
   SmallVector<WasmFunction, 4> Functions;
   SmallVector<uint32_t, 4> TableElems;
   SmallVector<WasmImport, 4> Imports;
   SmallVector<WasmExport, 4> Exports;
-  SmallVector<std::pair<StringRef, uint32_t>, 4> SymbolFlags;
+  SmallVector<WasmSymbolEntry, 4> SymbolInfos;
   SmallVector<std::pair<uint16_t, uint32_t>, 2> InitFuncs;
   std::map<StringRef, std::vector<WasmComdatEntry>> Comdats;
   unsigned NumSymbols = 0;
-  SmallVector<WasmDataSegment, 4> DataSegments;
   uint32_t DataSize = 0;
 
   auto AddSymbol = [&](const MCSymbolWasm &WS) {
     uint32_t Flags = (WS.isWeak() ? wasm::WASM_SYMBOL_BINDING_WEAK : 0) |
         (WS.isHidden() ? wasm::WASM_SYMBOL_VISIBILITY_HIDDEN : 0) |
         (!WS.isExternal() && WS.isDefined() ? wasm::WASM_SYMBOL_BINDING_LOCAL : 0);
-    if (Flags != 0) {
-      SymbolFlags.emplace_back(WS.getName(), Flags);
+    if (WS.isData()) {
+      SymbolInfos.emplace_back(
+          WasmSymbolEntry{WS.getName(), wasm::WASM_SYMBOL_TYPE_DATA, Flags, 0,
+                          SegmentIndices[&WS]});
+    } else {
+      SymbolInfos.emplace_back(
+          WasmSymbolEntry{WS.getName(), static_cast<unsigned>(WS.getType()),
+                          Flags, WasmIndices[&WS], None});
     }
   };
 
   // For now, always emit the memory import, since loads and stores are not
   // valid without it. In the future, we could perhaps be more clever and omit
   // it if there are no loads or stores.
   MCSymbolWasm *MemorySym =
       cast<MCSymbolWasm>(Ctx.getOrCreateSymbol("__linear_memory"));
   WasmImport MemImport;
   MemImport.ModuleName = MemorySym->getModuleName();
   MemImport.FieldName = MemorySym->getName();
   MemImport.Kind = wasm::WASM_EXTERNAL_MEMORY;
for (const MCSymbol &S : Asm.symbols()) {
     if (WS.isFunction())
       registerFunctionType(WS);
 
     if (WS.isTemporary())
       continue;
 
     // If the symbol is not defined in this translation unit, import it.
     if (!WS.isDefined() && !WS.isComdat()) {
+
+      if (WS.isFunction()) {
         WasmImport Import;
         Import.ModuleName = WS.getModuleName();
         Import.FieldName = WS.getName();
-
-      if (WS.isFunction()) {
         Import.Kind = wasm::WASM_EXTERNAL_FUNCTION;
         Import.Type = getFunctionType(WS);
+        Imports.push_back(Import);
         WasmIndices[&WS] = NumFunctionImports++;
+      } else if (WS.isData()) {
+        SegmentIndices[&WS] = None;
       } else {
+        WasmImport Import;
+        Import.ModuleName = WS.getModuleName();
+        Import.FieldName = WS.getName();
         Import.Kind = wasm::WASM_EXTERNAL_GLOBAL;
         Import.Type = PtrType;
         Import.IsMutable = false;
-        WasmIndices[&WS] = NumGlobalImports++;
         // If this global is the stack pointer, make it mutable.
         if (WS.getName() == "__stack_pointer")
           Import.IsMutable = true;
-      }
         Imports.push_back(Import);
+        WasmIndices[&WS] = NumGlobalImports++;
+      }
 
+      // TODO(ncw) We shouldn't be adding the symbol to the symbol table here!
+      // Instead it should be done by removing the "if (WS.isDefined())" block
+      // in the big loop below (line ~1284).  However - that would reorder all
+      // the symbols and thus require all the tests to be updated.  I think it's
+      // better to make that change therefore in a future commit, to isolate
+      // each test update from the change that caused it.
       SymbolIndices[&WS] = NumSymbols++;
       AddSymbol(WS);
     }
   }
 
   for (MCSection &Sec : Asm) {
     auto &Section = static_cast<MCSectionWasm &>(Sec);
     if (!Section.isWasmData())
for (MCSection &Sec : Asm) {
     WasmDataSegment &Segment = DataSegments.back();
     Segment.Name = Section.getSectionName();
     Segment.Offset = DataSize;
     Segment.Section = &Section;
     addData(Segment.Data, Section);
     Segment.Alignment = Section.getAlignment();
     Segment.Flags = 0;
     DataSize += Segment.Data.size();
-    Section.setMemoryOffset(Segment.Offset);
+    Section.setSegmentIndex(SegmentIndex);
 
     if (const MCSymbolWasm *C = Section.getGroup()) {
       Comdats[C->getName()].emplace_back(
           WasmComdatEntry{wasm::WASM_COMDAT_DATA, SegmentIndex});
     }
   }
 
   // Handle regular defined and undefined symbols.
DEBUG(dbgs() << "MCSymbol: '" << S << "'"
                  << " isHidden=" << WS.isHidden()
                  << " isVariable=" << WS.isVariable() << "\n");
 
     if (WS.isVariable())
       continue;
     if (WS.isComdat() && !WS.isDefined())
       continue;
 
-    unsigned WasmIndex;
-
     if (WS.isFunction()) {
+      unsigned WasmIndex;
       if (WS.isDefined()) {
         if (WS.getOffset() != 0)
           report_fatal_error(
               "function sections must contain one function each");
 
         if (WS.getSize() == 0)
           report_fatal_error(
               "function symbols must have a size set with .size");
 
-        // A definition. Export the function body.
+        // A definition. Write out the function body.
         WasmIndex = NumFunctionImports + Functions.size();
         WasmFunction Func;
         Func.Type = getFunctionType(WS);
         Func.Sym = &WS;
         WasmIndices[&WS] = WasmIndex;
         Functions.push_back(Func);
 
         auto &Section = static_cast<MCSectionWasm &>(WS.getSection());
         if (const MCSymbolWasm *C = Section.getGroup()) {
           Comdats[C->getName()].emplace_back(
               WasmComdatEntry{wasm::WASM_COMDAT_FUNCTION, WasmIndex});
         }
       } else {
         // An import; the index was assigned above.
         WasmIndex = WasmIndices.find(&WS)->second;
       }
 
       DEBUG(dbgs() << "  -> function index: " << WasmIndex << "\n");
-    } else {
+    } else if (WS.isData()) {
       if (WS.isTemporary() && !WS.getSize())
         continue;
 
+      Optional<wasm::WasmDataReference> SegInfo;
       if (WS.isDefined()) {
         if (!WS.getSize())
           report_fatal_error("data symbols must have a size set with .size: " +
                              WS.getName());
 
         int64_t Size = 0;
         if (!WS.getSize()->evaluateAsAbsolute(Size, Layout))
           report_fatal_error(".size expression must be evaluatable");
 
         auto& DataSection = static_cast<MCSectionWasm&>(WS.getSection());
         assert(DataSection.isWasmData());
 
-        // For each global, prepare a corresponding wasm global holding its
-        // address.  For externals these will also be named exports.
-        WasmIndex = NumGlobalImports + Globals.size();
-        WasmGlobal Global;
-        Global.Type.Type = PtrType;
-        Global.Type.Mutable = false;
-        Global.InitialValue =
-            DataSection.getMemoryOffset() + Layout.getSymbolOffset(WS);
-        WasmIndices[&WS] = WasmIndex;
-        Globals.push_back(Global);
+        // For each data symbol, export it in the symtab as a reference to the
+        // corresponding Wasm data segment.
+        SegInfo = wasm::WasmDataReference{
+            DataSection.getSegmentIndex(),
+            static_cast<uint32_t>(Layout.getSymbolOffset(WS)),
+            static_cast<uint32_t>(Size)};
+        SegmentIndices[&WS] = SegInfo;
       } else {
         // An import; the index was assigned above.
+        SegInfo = SegmentIndices.find(&WS)->second;
+      }
+      DEBUG(dbgs() << "  -> segment index: "
+                   << (SegInfo.hasValue() ? (int)SegInfo.getValue().Segment : -1)
+                   << "\n");
+    } else {
+      // A "true" Wasm global (currently just __stack_pointer)
+      unsigned WasmIndex;
+      if (WS.isDefined()) {
+        report_fatal_error("don't yet support defined globals");
+      } else {
+        // An import; the index was assigned above
         WasmIndex = WasmIndices.find(&WS)->second;
       }
+
       DEBUG(dbgs() << "  -> global index: " << WasmIndex << "\n");
     }
 
-    // If the symbol is visible outside this translation unit, export it.
     if (WS.isDefined()) {
-      WasmExport Export;
-      Export.FieldName = WS.getName();
-      Export.Index = WasmIndex;
-      if (WS.isFunction())
-        Export.Kind = wasm::WASM_EXTERNAL_FUNCTION;
-      else
-        Export.Kind = wasm::WASM_EXTERNAL_GLOBAL;
-      DEBUG(dbgs() << "  -> export " << Exports.size() << "\n");
-      Exports.push_back(Export);
-
       SymbolIndices[&WS] = NumSymbols++;
       AddSymbol(WS);
     }
   }
 
   // Handle weak aliases. We need to process these in a separate pass because
   // we need to have processed the target of the alias before the alias itself
   // and the symbols are not necessarily ordered in this way.
   for (const MCSymbol &S : Asm.symbols()) {
     if (!S.isVariable())
       continue;
 
     assert(S.isDefined());
 
     // Find the target symbol of this weak alias and export that index
     const auto &WS = static_cast<const MCSymbolWasm &>(S);
     const MCSymbolWasm *ResolvedSym = ResolveSymbol(WS);
     DEBUG(dbgs() << WS.getName() << ": weak alias of '" << *ResolvedSym << "'\n");
 
+    if (WS.isFunction()) {
       assert(WasmIndices.count(ResolvedSym) > 0);
       uint32_t WasmIndex = WasmIndices.find(ResolvedSym)->second;
       WasmIndices[&WS] = WasmIndex;
       DEBUG(dbgs() << "  -> index:" << WasmIndex << "\n");
-
-    WasmExport Export;
-    Export.FieldName = WS.getName();
-    Export.Index = WasmIndex;
-    if (WS.isFunction())
-      Export.Kind = wasm::WASM_EXTERNAL_FUNCTION;
-    else
-      Export.Kind = wasm::WASM_EXTERNAL_GLOBAL;
-    DEBUG(dbgs() << "  -> export " << Exports.size() << "\n");
-    Exports.push_back(Export);
+    } else if (WS.isData()) {
+      assert(SegmentIndices.count(ResolvedSym) > 0);
+      auto &SI = SegmentIndices.find(ResolvedSym)->second;
+      SegmentIndices[&WS] = SI;
+      DEBUG(dbgs() << "  -> index:" << SI.getValue().Segment << "\n");
+    } else {
+      report_fatal_error("don't yet support global aliases");
+    }
 
     SymbolIndices[&WS] = NumSymbols++;
     AddSymbol(WS);
   }
 
   {
     auto HandleReloc = [&](const WasmRelocationEntry &Rel) {
       // Functions referenced by a relocation need to put in the table.  This is
void WasmObjectWriter::writeObject(MCAssembler &Asm,
   writeImportSection(Imports, DataSize, TableElems.size());
   writeFunctionSection(Functions);
   // Skip the "table" section; we import the table instead.
   // Skip the "memory" section; we import the memory instead.
   writeGlobalSection();
   writeExportSection(Exports);
   writeElemSection(TableElems);
   writeCodeSection(Asm, Layout, Functions);
-  writeDataSection(DataSegments);
+  writeDataSection();
   writeCodeRelocSection();
   writeDataRelocSection();
-  writeLinkingMetaDataSection(DataSegments, DataSize, SymbolFlags,
-                              InitFuncs, Comdats);
+  writeLinkingMetaDataSection(DataSize, SymbolInfos, InitFuncs, Comdats);
 
   // TODO: Translate the .comment section to the output.
   // TODO: Translate debug sections to the output.
 }
 
 std::unique_ptr<MCObjectWriter>
 llvm::createWasmObjectWriter(std::unique_ptr<MCWasmObjectTargetWriter> MOTW,
                              raw_pwrite_stream &OS) {
   return llvm::make_unique<WasmObjectWriter>(std::move(MOTW), OS);
 }

lib/Object/WasmObjectFile.cpp

Error WasmObjectFile::parseNameSection(const uint8_t *Ptr, const uint8_t *End) {
   }
 
   if (Ptr != End)
     return make_error<GenericBinaryError>("Name section ended prematurely",
                                           object_error::parse_failed);
   return Error::success();
 }
 
-Error WasmObjectFile::populateSymbolTable() {
-  Symbols.reserve(NumImportedFunctions + NumImportedGlobals + Exports.size());
-
-  // Add imports to symbol table
-  for (const wasm::WasmImport& Import : Imports) {
-    WasmSymbol::SymbolType ImportType;
-    unsigned FunctionType = 0;
-    switch (Import.Kind) {
-    case wasm::WASM_EXTERNAL_GLOBAL:
-      assert(Import.Global.Type == wasm::WASM_TYPE_I32);
-      ImportType = WasmSymbol::SymbolType::GLOBAL_IMPORT;
-      break;
-    case wasm::WASM_EXTERNAL_FUNCTION:
-      ImportType = WasmSymbol::SymbolType::FUNCTION_IMPORT;
-      FunctionType = Import.SigIndex;
-      break;
-    default:
-      continue;
-    }
-    unsigned SymbolIndex = Symbols.size();
-    if (!SymbolMap.try_emplace(Import.Field, SymbolIndex).second)
-      return make_error<GenericBinaryError>(
-          "Duplicate symbol name " + Import.Field,
-          object_error::parse_failed);
-    unsigned WasmIndex = SymbolIndex;
-    Symbols.emplace_back(Import.Field, ImportType, ImportSection, SymbolIndex,
-                         WasmIndex, FunctionType);
-    DEBUG(dbgs() << "Adding import: " << Symbols.back()
-                 << " sym index:" << SymbolIndex << "\n");
-  }
-
-  // Add exports to symbol table
-  for (const wasm::WasmExport& Export : Exports) {
-    WasmSymbol::SymbolType ExportType;
-    unsigned FunctionType = 0;
-    switch (Export.Kind) {
-    case wasm::WASM_EXTERNAL_GLOBAL:
-      assert(isValidGlobalIndex(Export.Index));
-      if (!isDefinedGlobalIndex(Export.Index))
-        return make_error<GenericBinaryError>("symbol cannot export an import",
-                                              object_error::parse_failed);
-      ExportType = WasmSymbol::SymbolType::GLOBAL_EXPORT;
-      break;
-    case wasm::WASM_EXTERNAL_FUNCTION: {
-      assert(isValidFunctionIndex(Export.Index));
-      if (!isDefinedFunctionIndex(Export.Index))
-        return make_error<GenericBinaryError>("symbol cannot export an import",
-                                              object_error::parse_failed);
-      ExportType = WasmSymbol::SymbolType::FUNCTION_EXPORT;
-      FunctionType = FunctionTypes[Export.Index - NumImportedFunctions];
-      auto &Function = getDefinedFunction(Export.Index);
-      if (Function.Name.empty()) {
-        // Use the export's name to set a name for the Function, but only if one
-        // hasn't already been set.
-        Function.Name = Export.Name;
-      }
-      break;
-    }
-    default:
-      continue;
-    }
-    unsigned SymbolIndex = Symbols.size();
-    if (!SymbolMap.try_emplace(Export.Name, SymbolIndex).second)
-      return make_error<GenericBinaryError>(
-          "Duplicate symbol name " + Export.Name,
-          object_error::parse_failed);
-    unsigned WasmIndex = Export.Index;
-    Symbols.emplace_back(Export.Name, ExportType, ExportSection, SymbolIndex,
-                         WasmIndex, FunctionType);
-    DEBUG(dbgs() << "Adding export: " << Symbols.back()
-                 << " sym index:" << SymbolIndex << "\n");
-  }
-
-  return Error::success();
-}
-
 Error WasmObjectFile::parseLinkingSection(const uint8_t *Ptr,
                                           const uint8_t *End) {
   HasLinkingSection = true;
   if (Functions.size() != FunctionTypes.size()) {
     return make_error<GenericBinaryError>(
         "Linking data must come after code section", object_error::parse_failed);
   }
 
-  // Only populate the symbol table with imports and exports if the object
-  // has a linking section (i.e. its a relocatable object file). Otherwise
-  // the global might not represent symbols at all.
-  if (Error Err = populateSymbolTable())
-    return Err;
-
   while (Ptr < End) {
     uint8_t Type = readVarint7(Ptr);
     uint32_t Size = readVaruint32(Ptr);
     const uint8_t *SubSectionEnd = Ptr + Size;
     switch (Type) {
-    case wasm::WASM_SYMBOL_INFO: {
-      uint32_t Count = readVaruint32(Ptr);
-      while (Count--) {
-        StringRef Symbol = readString(Ptr);
-        uint32_t Flags = readVaruint32(Ptr);
-        auto iter = SymbolMap.find(Symbol);
-        if (iter == SymbolMap.end()) {
-          return make_error<GenericBinaryError>(
-              "Invalid symbol name in linking section: " + Symbol,
-              object_error::parse_failed);
-        }
-        uint32_t SymIndex = iter->second;
-        assert(SymIndex < Symbols.size());
-        Symbols[SymIndex].Flags = Flags;
-        DEBUG(dbgs() << "Set symbol flags index:"
-                     << SymIndex << " name:"
-                     << Symbols[SymIndex].Name << " expected:"
-                     << Symbol << " flags: " << Flags << "\n");
-      }
+    case wasm::WASM_SYMBOL_TABLE:
+      if (Error Err = parseLinkingSectionSymtab(Ptr, SubSectionEnd))
+        return Err;
       break;
-    }
     case wasm::WASM_DATA_SIZE:
       LinkingData.DataSize = readVaruint32(Ptr);
       break;
     case wasm::WASM_SEGMENT_INFO: {
       uint32_t Count = readVaruint32(Ptr);
       if (Count > DataSegments.size())
         return make_error<GenericBinaryError>("Too many segment names",
                                               object_error::parse_failed);
if (Ptr != SubSectionEnd)
           "Linking sub-section ended prematurely", object_error::parse_failed);
   }
   if (Ptr != End)
     return make_error<GenericBinaryError>("Linking section ended prematurely",
                                           object_error::parse_failed);
   return Error::success();
 }
 
+Error WasmObjectFile::parseLinkingSectionSymtab(const uint8_t *&Ptr,
+                                                const uint8_t *End) {
+  uint32_t LinkingSection = Sections.size();
+  uint32_t Count = readVaruint32(Ptr);
+  LinkingData.SymbolTable.reserve(Count);
+  Symbols.reserve(Count);
+  StringSet<> SymbolNames;
+
+  std::vector<wasm::WasmImport*> ImportedGlobals;
+  std::vector<wasm::WasmImport*> ImportedFunctions;
+  ImportedGlobals.reserve(Imports.size());
+  ImportedFunctions.reserve(Imports.size());
+  for (auto &I : Imports) {
+    if (I.Kind == wasm::WASM_EXTERNAL_FUNCTION)
+      ImportedFunctions.emplace_back(&I);
+    else if (I.Kind == wasm::WASM_EXTERNAL_GLOBAL)
+      ImportedGlobals.emplace_back(&I);
+  }
+
+  while (Count--) {
+    wasm::WasmSymbolInfo Info;
+    uint32_t Section;
+    const wasm::WasmSignature *FunctionType = nullptr;
+    const wasm::WasmGlobalType *GlobalType = nullptr;
+
+    Info.Kind = readVaruint32(Ptr);
+    Info.Flags = readVaruint32(Ptr);
+
+    switch (Info.Kind) {
+    case wasm::WASM_SYMBOL_TYPE_FUNCTION:
+      Info.ElementIndex = readVaruint32(Ptr);
+      if (!isValidFunctionIndex(Info.ElementIndex))
+        return make_error<GenericBinaryError>("invalid function symbol index",
+                                              object_error::parse_failed);
+      if (isDefinedFunctionIndex(Info.ElementIndex)) {
+        Section = CodeSection;
+        Info.Name = readString(Ptr);
+        unsigned FuncIndex = Info.ElementIndex - NumImportedFunctions;
+        FunctionType = &Signatures[FunctionTypes[FuncIndex]];
+        Info.Flags |= wasm::WASM_SYMBOL_OBJECT_DEFINED;
+        auto &Function = Functions[FuncIndex];
+        if (Function.Name.empty()) {
+          // Use the symbol's name to set a name for the Function, but only if
+          // one hasn't already been set.
+          Function.Name = Info.Name;
+        }
+      } else {
+        Section = ImportSection;
+        wasm::WasmImport &Import = *ImportedFunctions[Info.ElementIndex];
+        FunctionType = &Signatures[Import.SigIndex];
+        Info.Name = Import.Field;
+      }
+      break;
+
+    case wasm::WASM_SYMBOL_TYPE_GLOBAL:
+      Info.ElementIndex = readVaruint32(Ptr);
+      if (!isValidGlobalIndex(Info.ElementIndex))
+        return make_error<GenericBinaryError>("invalid global symbol index",
+                                              object_error::parse_failed);
+      if (isDefinedGlobalIndex(Info.ElementIndex)) {
+        Section = GlobalSection;
+        Info.Name = readString(Ptr);
+        unsigned GlobalIndex = Info.ElementIndex - NumImportedGlobals;
+        GlobalType = &Globals[GlobalIndex].Type;
+        Info.Flags |= wasm::WASM_SYMBOL_OBJECT_DEFINED;
+      } else {
+        Section = ImportSection;
+        wasm::WasmImport &Import = *ImportedGlobals[Info.ElementIndex];
+        Info.Name = Import.Field;
+        GlobalType = &Import.Global;
+      }
+      break;
+
+    case wasm::WASM_SYMBOL_TYPE_DATA:
+      Info.Name = readString(Ptr);
+      if (*Ptr++) {
+        Section = DataSection;
+        uint32_t Index = readVaruint32(Ptr);
+        if (Index >= DataSegments.size())
+          return make_error<GenericBinaryError>("invalid data symbol index",
+                                                object_error::parse_failed);
+        uint32_t Offset = readVaruint32(Ptr);
+        uint32_t Size = readVaruint32(Ptr);
+        if (Offset + Size > DataSegments[Index].Data.Content.size())
+          return make_error<GenericBinaryError>("invalid data symbol index",
+                                                object_error::parse_failed);
+        Info.Segment = wasm::WasmDataReference{Index, Offset, Size};
+        Info.Flags |= wasm::WASM_SYMBOL_OBJECT_DEFINED;
+      } else {
+        Section = LinkingSection;
+      }
+      break;
+
+    default:
+      return make_error<GenericBinaryError>("Invalid symbol kind",
+                                            object_error::parse_failed);
+    }
+
+    if ((Info.Flags & wasm::WASM_SYMBOL_BINDING_MASK) !=
+            wasm::WASM_SYMBOL_BINDING_LOCAL &&
+        !SymbolNames.insert(Info.Name).second)
+      return make_error<GenericBinaryError>("Duplicate symbol name " +
+                                                Twine(Info.Name),
+                                            object_error::parse_failed);
+    LinkingData.SymbolTable.emplace_back(Info);
+    Symbols.emplace_back(Section, FunctionType, GlobalType,
+                         LinkingData.SymbolTable.back());
+    DEBUG(dbgs() << "Adding symbol: " << Symbols.back() << "\n");
+  }
+
+  return Error::success();
+}
+
 Error WasmObjectFile::parseLinkingSectionComdat(const uint8_t *&Ptr,
                                                 const uint8_t *End)
 {
   uint32_t ComdatCount = readVaruint32(Ptr);
   StringSet<> ComdatSet;
   while (ComdatCount--) {
     StringRef Name = readString(Ptr);
     if (Name.empty() || !ComdatSet.insert(Name).second)
Error WasmObjectFile::parseMemorySection(const uint8_t *Ptr, const uint8_t *End) {
   }
   if (Ptr != End)
     return make_error<GenericBinaryError>("Memory section ended prematurely",
                                           object_error::parse_failed);
   return Error::success();
 }
 
 Error WasmObjectFile::parseGlobalSection(const uint8_t *Ptr, const uint8_t *End) {
+  GlobalSection = Sections.size();
   uint32_t Count = readVaruint32(Ptr);
   Globals.reserve(Count);
   while (Count--) {
     wasm::WasmGlobal Global;
     Global.Index = NumImportedGlobals + Globals.size();
     Global.Type.Type = readVarint7(Ptr);
     Global.Type.Mutable = readVaruint1(Ptr);
     if (Error Err = readInitExpr(Global.InitExpr, Ptr))
       return Err;
     Globals.push_back(Global);
   }
   if (Ptr != End)
     return make_error<GenericBinaryError>("Global section ended prematurely",
                                           object_error::parse_failed);
   return Error::success();
 }
 
 Error WasmObjectFile::parseExportSection(const uint8_t *Ptr, const uint8_t *End) {
-  ExportSection = Sections.size();
   uint32_t Count = readVaruint32(Ptr);
   Exports.reserve(Count);
   for (uint32_t i = 0; i < Count; i++) {
     wasm::WasmExport Ex;
     Ex.Name = readString(Ptr);
     Ex.Kind = readUint8(Ptr);
     Ex.Index = readVaruint32(Ptr);
     switch (Ex.Kind) {

 bool WasmObjectFile::isDefinedGlobalIndex(uint32_t Index) const {
   return Index >= NumImportedGlobals && isValidGlobalIndex(Index);
 }
 
 bool WasmObjectFile::isValidFunctionSymbolIndex(uint32_t Index) const {
   return Index < Symbols.size() && Symbols[Index].isTypeFunction();
 }
 
-wasm::WasmFunction& WasmObjectFile::getDefinedFunction(uint32_t Index) {
+wasm::WasmFunction &WasmObjectFile::getDefinedFunction(uint32_t Index) {
   assert(isDefinedFunctionIndex(Index));
   return Functions[Index - NumImportedFunctions];
 }
 
+wasm::WasmGlobal &WasmObjectFile::getDefinedGlobal(uint32_t Index) {
+  assert(isDefinedGlobalIndex(Index));
+  return Globals[Index - NumImportedGlobals];
+}
+
 Error WasmObjectFile::parseStartSection(const uint8_t *Ptr, const uint8_t *End) {
   StartFunction = readVaruint32(Ptr);
   if (!isValidFunctionIndex(StartFunction))
     return make_error<GenericBinaryError>("Invalid start function",
                                           object_error::parse_failed);
   return Error::success();
 }
 
 Error WasmObjectFile::parseCodeSection(const uint8_t *Ptr, const uint8_t *End) {
+  CodeSection = Sections.size();
   const uint8_t *CodeSectionStart = Ptr;
   uint32_t FunctionCount = readVaruint32(Ptr);
   if (FunctionCount != FunctionTypes.size()) {
     return make_error<GenericBinaryError>("Invalid function count",
                                           object_error::parse_failed);
   }
 
   while (FunctionCount--) {
Error WasmObjectFile::parseElemSection(const uint8_t *Ptr, const uint8_t *End) {
   }
   if (Ptr != End)
     return make_error<GenericBinaryError>("Elem section ended prematurely",
                                           object_error::parse_failed);
   return Error::success();
 }
 
 Error WasmObjectFile::parseDataSection(const uint8_t *Ptr, const uint8_t *End) {
+  DataSection = Sections.size();
   const uint8_t *Start = Ptr;
   uint32_t Count = readVaruint32(Ptr);
   DataSegments.reserve(Count);
   while (Count--) {
     WasmSegment Segment;
     Segment.Data.MemoryIndex = readVaruint32(Ptr);
     if (Error Err = readInitExpr(Segment.Data.Offset, Ptr))
       return Err;
uint32_t WasmObjectFile::getSymbolFlags(DataRefImpl Symb) const {
 
   DEBUG(dbgs() << "getSymbolFlags: ptr=" << &Sym << " " << Sym << "\n");
   if (Sym.isBindingWeak())
     Result |= SymbolRef::SF_Weak;
   if (!Sym.isBindingLocal())
     Result |= SymbolRef::SF_Global;
   if (Sym.isHidden())
     Result |= SymbolRef::SF_Hidden;
-
-  switch (Sym.Type) {
-  case WasmSymbol::SymbolType::FUNCTION_IMPORT:
-    Result |= SymbolRef::SF_Undefined | SymbolRef::SF_Executable;
-    break;
-  case WasmSymbol::SymbolType::FUNCTION_EXPORT:
-    Result |= SymbolRef::SF_Executable;
-    break;
-  case WasmSymbol::SymbolType::GLOBAL_IMPORT:
+  if (Sym.isUndefined())
     Result |= SymbolRef::SF_Undefined;
-    break;
-  case WasmSymbol::SymbolType::GLOBAL_EXPORT:
-    break;
-  }
-
+  if (Sym.isTypeFunction())
+    Result |= SymbolRef::SF_Executable;
   return Result;
 }
 
 basic_symbol_iterator WasmObjectFile::symbol_begin() const {
   DataRefImpl Ref;
   Ref.d.a = 0;
   return BasicSymbolRef(Ref, this);
 }
 
 basic_symbol_iterator WasmObjectFile::symbol_end() const {
   DataRefImpl Ref;
   Ref.d.a = Symbols.size();
   return BasicSymbolRef(Ref, this);
 }
 
 const WasmSymbol &WasmObjectFile::getWasmSymbol(const DataRefImpl &Symb) const {
   return Symbols[Symb.d.a];
 }
 
 const WasmSymbol &WasmObjectFile::getWasmSymbol(const SymbolRef &Symb) const {
   return getWasmSymbol(Symb.getRawDataRefImpl());
 }
 
 Expected<StringRef> WasmObjectFile::getSymbolName(DataRefImpl Symb) const {
-  return getWasmSymbol(Symb).Name;
+  return getWasmSymbol(Symb).Info.Name;
 }
 
 Expected<uint64_t> WasmObjectFile::getSymbolAddress(DataRefImpl Symb) const {
   return getSymbolValue(Symb);
 }
 
 uint64_t WasmObjectFile::getWasmSymbolValue(const WasmSymbol& Sym) const {
-  switch (Sym.Type) {
-  case WasmSymbol::SymbolType::FUNCTION_IMPORT:
-  case WasmSymbol::SymbolType::GLOBAL_IMPORT:
-  case WasmSymbol::SymbolType::FUNCTION_EXPORT:
-    return Sym.ElementIndex;
-  case WasmSymbol::SymbolType::GLOBAL_EXPORT: {
-    uint32_t GlobalIndex = Sym.ElementIndex - NumImportedGlobals;
-    assert(GlobalIndex < Globals.size());
-    const wasm::WasmGlobal &Global = Globals[GlobalIndex];
-    // WasmSymbols correspond only to I32_CONST globals
-    assert(Global.InitExpr.Opcode == wasm::WASM_OPCODE_I32_CONST);
-    return Global.InitExpr.Value.Int32;
+  switch (Sym.Info.Kind) {
+  case wasm::WASM_SYMBOL_TYPE_FUNCTION:
+  case wasm::WASM_SYMBOL_TYPE_GLOBAL:
+    return Sym.Info.ElementIndex;
+  case wasm::WASM_SYMBOL_TYPE_DATA: {
+    auto &SegmentSym = Sym.Info.Segment.getValue();
+    auto &Segment = DataSegments[SegmentSym.Segment].Data;
+    assert(Segment.Offset.Opcode == wasm::WASM_OPCODE_I32_CONST);
+    return Segment.Offset.Value.Int32 + SegmentSym.Offset;
   }
+  default:
+    llvm_unreachable("invalid symbol kind");
+    break;
   }
-  llvm_unreachable("invalid symbol type");
 }
 
 uint64_t WasmObjectFile::getSymbolValueImpl(DataRefImpl Symb) const {
   return getWasmSymbolValue(getWasmSymbol(Symb));
 }
 
 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 {
   const WasmSymbol &Sym = getWasmSymbol(Symb);
 
-  switch (Sym.Type) {
-  case WasmSymbol::SymbolType::FUNCTION_IMPORT:
-  case WasmSymbol::SymbolType::FUNCTION_EXPORT:
+  switch (Sym.Info.Kind) {
+  case wasm::WASM_SYMBOL_TYPE_FUNCTION:
     return SymbolRef::ST_Function;
-  case WasmSymbol::SymbolType::GLOBAL_IMPORT:
-  case WasmSymbol::SymbolType::GLOBAL_EXPORT:
+  case wasm::WASM_SYMBOL_TYPE_GLOBAL:
+    return SymbolRef::ST_Other;
+  case wasm::WASM_SYMBOL_TYPE_DATA:
     return SymbolRef::ST_Data;
-  }
-
+  default:
     llvm_unreachable("Unknown WasmSymbol::SymbolType");
     return SymbolRef::ST_Other;
   }
+}
 
 Expected<section_iterator>
 WasmObjectFile::getSymbolSection(DataRefImpl Symb) const {
   DataRefImpl Ref;
   Ref.d.a = getWasmSymbol(Symb).Section;
   return section_iterator(SectionRef(Ref, this));
 }
 

lib/ObjectYAML/WasmYAML.cpp

static void sectionMapping(IO &IO, WasmYAML::NameSection &Section) {
   IO.mapRequired("Name", Section.Name);
   IO.mapOptional("FunctionNames", Section.FunctionNames);
 }
 
 static void sectionMapping(IO &IO, WasmYAML::LinkingSection &Section) {
   commonSectionMapping(IO, Section);
   IO.mapRequired("Name", Section.Name);
   IO.mapRequired("DataSize", Section.DataSize);
-  IO.mapOptional("SymbolInfo", Section.SymbolInfos);
+  IO.mapOptional("SymbolTable", Section.SymbolTable);
   IO.mapOptional("SegmentInfo", Section.SegmentInfos);
   IO.mapOptional("InitFunctions", Section.InitFunctions);
   IO.mapOptional("Comdats", Section.Comdats);
 }
 
 static void sectionMapping(IO &IO, WasmYAML::CustomSection &Section) {
   commonSectionMapping(IO, Section);
   IO.mapRequired("Name", Section.Name);

 void MappingTraits<WasmYAML::Comdat>::mapping(
     IO &IO, WasmYAML::Comdat &Comdat) {
   IO.mapRequired("Name", Comdat.Name);
   IO.mapRequired("Entries", Comdat.Entries);
 }
 
 void MappingTraits<WasmYAML::SymbolInfo>::mapping(IO &IO,
                                                   WasmYAML::SymbolInfo &Info) {
+  IO.mapRequired("Index", Info.Index);
+  IO.mapRequired("Kind", Info.Kind);
   IO.mapRequired("Name", Info.Name);
   IO.mapRequired("Flags", Info.Flags);
+  if (Info.Kind == wasm::WASM_SYMBOL_TYPE_FUNCTION) {
+    IO.mapRequired("FunctionIndex", Info.FunctionIndex);
+  } else if (Info.Kind == wasm::WASM_SYMBOL_TYPE_GLOBAL) {
+    IO.mapRequired("GlobalIndex", Info.GlobalIndex);
+  } else if (Info.Kind == wasm::WASM_SYMBOL_TYPE_DATA) {
+    IO.mapOptional("SegmentIndex", Info.Segment.Segment, -1);
+    if (Info.Segment.Segment >= 0) {
+      IO.mapOptional("Offset", Info.Segment.Offset, 0u);
+      IO.mapRequired("Size", Info.Segment.Size);
+    }
+  } else {
+    llvm_unreachable("unsupported symbol kind");
+  }
 }
 
 void ScalarBitSetTraits<WasmYAML::LimitFlags>::bitset(
     IO &IO, WasmYAML::LimitFlags &Value) {
 #define BCase(X) IO.bitSetCase(Value, #X, wasm::WASM_LIMITS_FLAG_##X)
   BCase(HAS_MAX);
 #undef BCase
 }
 
 void ScalarBitSetTraits<WasmYAML::SegmentFlags>::bitset(
     IO &IO, WasmYAML::SegmentFlags &Value) {
 }
 
 void ScalarBitSetTraits<WasmYAML::SymbolFlags>::bitset(
     IO &IO, WasmYAML::SymbolFlags &Value) {
 #define BCaseMask(M, X) IO.maskedBitSetCase(Value, #X, wasm::WASM_SYMBOL_##X, wasm::WASM_SYMBOL_##M)
   //BCaseMask(BINDING_MASK, BINDING_GLOBAL);
   BCaseMask(BINDING_MASK, BINDING_WEAK);
   BCaseMask(BINDING_MASK, BINDING_LOCAL);
   //BCaseMask(VISIBILITY_MASK, VISIBILITY_DEFAULT);
   BCaseMask(VISIBILITY_MASK, VISIBILITY_HIDDEN);
+  //BCaseMask(OBJECT_MASK, OBJECT_DEFINED)
 #undef BCaseMask
 }
 
+void ScalarEnumerationTraits<WasmYAML::SymbolKind>::enumeration(
+    IO &IO, WasmYAML::SymbolKind &Kind) {
+#define ECase(X) IO.enumCase(Kind, #X, wasm::WASM_SYMBOL_TYPE_##X);
+  ECase(FUNCTION);
+  ECase(DATA);
+  ECase(GLOBAL);
+#undef ECase
+}
+
 void ScalarEnumerationTraits<WasmYAML::ValueType>::enumeration(
     IO &IO, WasmYAML::ValueType &Type) {
 #define ECase(X) IO.enumCase(Type, #X, wasm::WASM_TYPE_##X);
   ECase(I32);
   ECase(I64);
   ECase(F32);
   ECase(F64);
   ECase(ANYFUNC);

lib/Target/WebAssembly/MCTargetDesc/WebAssemblyTargetStreamer.cpp

for (MVT Ty : Params)
     ValParams.push_back(WebAssembly::toValType(Ty));
 
   SmallVector<wasm::ValType, 1> ValResults;
   for (MVT Ty : Results)
     ValResults.push_back(WebAssembly::toValType(Ty));
 
   WasmSym->setParams(std::move(ValParams));
   WasmSym->setReturns(std::move(ValResults));
-  WasmSym->setIsFunction(true);
+  WasmSym->setType(MCSymbolWasm::SymbolType::FUNCTION);
 }
 
 void WebAssemblyTargetWasmStreamer::emitGlobalImport(StringRef name) {
   llvm_unreachable(".global_import is not needed for direct wasm output");
 }

lib/Target/WebAssembly/WebAssemblyMCInstLower.cpp

for (Type *Ty : FuncTy->params()) {
         Params.push_back(WebAssembly::toValType(ParamMVT));
     }
 
     if (FuncTy->isVarArg())
       Params.push_back(iPTR);
 
     WasmSym->setReturns(std::move(Returns));
     WasmSym->setParams(std::move(Params));
-    WasmSym->setIsFunction(true);
+    WasmSym->setType(MCSymbolWasm::SymbolType::FUNCTION);
   }
 
   return WasmSym;
 }
 
 MCSymbol *WebAssemblyMCInstLower::GetExternalSymbolSymbol(
     const MachineOperand &MO) const {
   const char *Name = MO.getSymbolName();
   MCSymbol *Sym = Printer.GetExternalSymbolSymbol(Name);
   if (isa<MCSymbolELF>(Sym))
     return Sym;
 
   MCSymbolWasm *WasmSym = cast<MCSymbolWasm>(Sym);
   const WebAssemblySubtarget &Subtarget = Printer.getSubtarget();
 
   // __stack_pointer is a global variable; all other external symbols used by
-  // CodeGen are functions.
-  if (strcmp(Name, "__stack_pointer") == 0)
+  // CodeGen are functions.  It's OK to hardcode knowledge of specific symbols
+  // here; this method is precisely there for fetching the signatures of known
+  // Clang-provided symbols.
+  if (strcmp(Name, "__stack_pointer") == 0) {
+    wasm::ValType iPTR =
+        Subtarget.hasAddr64() ? wasm::ValType::I64 : wasm::ValType::I32;
+    WasmSym->setType(MCSymbolWasm::SymbolType::GLOBAL);
+    WasmSym->setGlobalType(wasm::WasmGlobalType{int32_t(iPTR), true});
     return WasmSym;
+  }
 
   SmallVector<wasm::ValType, 4> Returns;
   SmallVector<wasm::ValType, 4> Params;
   GetSignature(Subtarget, Name, Returns, Params);
 
   WasmSym->setReturns(std::move(Returns));
   WasmSym->setParams(std::move(Params));
-  WasmSym->setIsFunction(true);
+  WasmSym->setType(MCSymbolWasm::SymbolType::FUNCTION);
 
   return WasmSym;
 }
 
 MCOperand WebAssemblyMCInstLower::LowerSymbolOperand(MCSymbol *Sym,
                                                      int64_t Offset,
                                                      bool IsFunc) const {
   MCSymbolRefExpr::VariantKind VK =
case MachineOperand::MO_Immediate:
             // call_indirect instructions have a callee operand at the end which
             // doesn't count as a param.
             if (WebAssembly::isCallIndirect(*MI))
               Params.pop_back();
 
             MCSymbolWasm *WasmSym = cast<MCSymbolWasm>(Sym);
             WasmSym->setReturns(std::move(Returns));
             WasmSym->setParams(std::move(Params));
-            WasmSym->setIsFunction(true);
+            WasmSym->setType(MCSymbolWasm::SymbolType::FUNCTION);
 
             const MCExpr *Expr =
                 MCSymbolRefExpr::create(WasmSym,
                                         MCSymbolRefExpr::VK_WebAssembly_TYPEINDEX,
                                         Ctx);
             MCOp = MCOperand::createExpr(Expr);
             break;
           }

test/MC/WebAssembly/array-fill.ll

 @gBd = hidden global [2 x %struct.bd] [%struct.bd { i8 1 }, %struct.bd { i8 2 }], align 1
 
 ; CHECK:        - Type:            DATA
 ; CHECK:              Content:         '0102'
 
 ; CHECK:        - Type:            CUSTOM
 ; CHECK-NEXT:     Name:            linking
 ; CHECK-NEXT:     DataSize:        2
-; CHECK-NEXT:     SymbolInfo:      
-; CHECK-NEXT:       - Name:            gBd
+; CHECK-NEXT:     SymbolTable:
+; CHECK-NEXT:       - Index:           0
+; CHECK-NEXT:         Kind:            DATA
+; CHECK-NEXT:         Name:            gBd
 ; CHECK-NEXT:         Flags:           [ VISIBILITY_HIDDEN ]
+; CHECK-NEXT:         SegmentIndex:    0
+; CHECK-NEXT:         Size:            2
 ; CHECK-NEXT:     SegmentInfo:    
 ; CHECK-NEXT:       - Index:           0
 ; CHECK-NEXT:         Name:            .data
 ; CHECK-NEXT:         Alignment:       1
 ; CHECK-NEXT:         Flags:           [ ]
 ; CHECK-NEXT: ...

test/MC/WebAssembly/bss.ll

 ; RUN: llc -filetype=obj %s -o - | obj2yaml | FileCheck %s
 
 target triple = "wasm32-unknown-unknown-wasm"
 
 @g0 = global i8* null, align 4
 @g1 = global i32 0, align 4
 
 %union.u1 = type {}
 @foo = global %union.u1 zeroinitializer, align 1
 @bar = global %union.u1 zeroinitializer, align 1
 
-; CHECK:        - Type:            GLOBAL
-; CHECK-NEXT:     Globals:         
-; CHECK-NEXT:       - Index:           0
-; CHECK-NEXT:         Type:            I32
-; CHECK-NEXT:         Mutable:         false
-; CHECK-NEXT:         InitExpr:        
-; CHECK-NEXT:           Opcode:          I32_CONST
-; CHECK-NEXT:           Value:           0
-; CHECK-NEXT:       - Index:           1
-; CHECK-NEXT:         Type:            I32
-; CHECK-NEXT:         Mutable:         false
-; CHECK-NEXT:         InitExpr:        
-; CHECK-NEXT:           Opcode:          I32_CONST
-; CHECK-NEXT:           Value:           4
-; CHECK-NEXT:       - Index:           2
-; CHECK-NEXT:         Type:            I32
-; CHECK-NEXT:         Mutable:         false
-; CHECK-NEXT:         InitExpr:        
-; CHECK-NEXT:           Opcode:          I32_CONST
-; CHECK-NEXT:           Value:           8
-; CHECK-NEXT:       - Index:           3
-; CHECK-NEXT:         Type:            I32
-; CHECK-NEXT:         Mutable:         false
-; CHECK-NEXT:         InitExpr:        
-; CHECK-NEXT:           Opcode:          I32_CONST
-; CHECK-NEXT:           Value:           9
-; CHECK-NEXT:   - Type:            EXPORT
-; CHECK-NEXT:     Exports:         
-; CHECK-NEXT:       - Name:            g0
-; CHECK-NEXT:         Kind:            GLOBAL
-; CHECK-NEXT:         Index:           0
-; CHECK-NEXT:       - Name:            g1
-; CHECK-NEXT:         Kind:            GLOBAL
-; CHECK-NEXT:         Index:           1
-; CHECK-NEXT:       - Name:            foo
-; CHECK-NEXT:         Kind:            GLOBAL
-; CHECK-NEXT:         Index:           2
-; CHECK-NEXT:       - Name:            bar
-; CHECK-NEXT:         Kind:            GLOBAL
-; CHECK-NEXT:         Index:           3
-; CHECK-NEXT:   - Type:            DATA
-; CHECK-NEXT:     Segments:        
+; CHECK:        - Type:            DATA
+; CHECK-NEXT:     Segments:
 ; CHECK-NEXT:       - SectionOffset:   6
 ; CHECK-NEXT:         MemoryIndex:     0
-; CHECK-NEXT:         Offset:          
+; CHECK-NEXT:         Offset:
 ; CHECK-NEXT:           Opcode:          I32_CONST
 ; CHECK-NEXT:           Value:           0
 ; CHECK-NEXT:         Content:         '00000000'
 ; CHECK-NEXT:       - SectionOffset:   15
 ; CHECK-NEXT:         MemoryIndex:     0
-; CHECK-NEXT:         Offset:          
+; CHECK-NEXT:         Offset:
 ; CHECK-NEXT:           Opcode:          I32_CONST
 ; CHECK-NEXT:           Value:           4
 ; CHECK-NEXT:         Content:         '00000000'
 ; CHECK-NEXT:       - SectionOffset:   24
 ; CHECK-NEXT:         MemoryIndex:     0
-; CHECK-NEXT:         Offset:          
+; CHECK-NEXT:         Offset:
 ; CHECK-NEXT:           Opcode:          I32_CONST
 ; CHECK-NEXT:           Value:           8
-; CHECK-NEXT:         Content:         '00'
-; CHECK-NEXT:       - SectionOffset:  30 
+; CHECK-NEXT:         Content:         ''
+; CHECK-NEXT:       - SectionOffset:   29
 ; CHECK-NEXT:         MemoryIndex:     0
-; CHECK-NEXT:         Offset:          
+; CHECK-NEXT:         Offset:
 ; CHECK-NEXT:           Opcode:          I32_CONST
-; CHECK-NEXT:           Value:           9
-; CHECK-NEXT:         Content:         '00'
+; CHECK-NEXT:           Value:           8
+; CHECK-NEXT:         Content:         ''
 ; CHECK-NEXT:   - Type:            CUSTOM
 ; CHECK-NEXT:     Name:            linking
-; CHECK-NEXT:     DataSize:        10
+; CHECK-NEXT:     DataSize:        8
+; CHECK-NEXT:     SymbolTable:
+; CHECK-NEXT:       - Index:           0
+; CHECK-NEXT:         Kind:            DATA
+; CHECK-NEXT:         Name:            g0
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         SegmentIndex:    0
+; CHECK-NEXT:         Size:            4
+; CHECK-NEXT:       - Index:           1
+; CHECK-NEXT:         Kind:            DATA
+; CHECK-NEXT:         Name:            g1
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         SegmentIndex:    1
+; CHECK-NEXT:         Size:            4
+; CHECK-NEXT:       - Index:           2
+; CHECK-NEXT:         Kind:            DATA
+; CHECK-NEXT:         Name:            foo
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         SegmentIndex:    2
+; CHECK-NEXT:         Size:            0
+; CHECK-NEXT:       - Index:           3
+; CHECK-NEXT:         Kind:            DATA
+; CHECK-NEXT:         Name:            bar
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         SegmentIndex:    3
+; CHECK-NEXT:         Size:            0
 ; CHECK-NEXT:     SegmentInfo:    
 ; CHECK-NEXT:       - Index:           0
 ; CHECK-NEXT:         Name:            .bss.g0
 ; CHECK-NEXT:         Alignment:       4
 ; CHECK-NEXT:         Flags:           [ ]
 ; CHECK-NEXT:       - Index:           1
 ; CHECK-NEXT:         Name:            .bss.g1
 ; CHECK-NEXT:         Alignment:       4

test/MC/WebAssembly/comdat.ll

 ; CHECK-NEXT:           Limits:          
 ; CHECK-NEXT:             Initial:         0x00000000
 ; CHECK-NEXT:       - Module:          env
 ; CHECK-NEXT:         Field:           funcImport
 ; CHECK-NEXT:         Kind:            FUNCTION
 ; CHECK-NEXT:         SigIndex:        0
 ; CHECK-NEXT:   - Type:            FUNCTION
 ; CHECK-NEXT:     FunctionTypes:   [ 0, 0, 0 ]
-; CHECK-NEXT:   - Type:            GLOBAL
-; CHECK-NEXT:     Globals:         
-; CHECK-NEXT:       - Index:           0
-; CHECK-NEXT:         Type:            I32
-; CHECK-NEXT:         Mutable:         false
-; CHECK-NEXT:         InitExpr:        
-; CHECK-NEXT:           Opcode:          I32_CONST
-; CHECK-NEXT:           Value:           0
-; CHECK-NEXT:  - Type:            EXPORT
-; CHECK-NEXT:    Exports:
-; CHECK-NEXT:      - Name:            callImport
-; CHECK-NEXT:        Kind:            FUNCTION
-; CHECK-NEXT:        Index:           1
-; CHECK-NEXT:      - Name:            basicInlineFn
-; CHECK-NEXT:        Kind:            FUNCTION
-; CHECK-NEXT:        Index:           2
-; CHECK-NEXT:      - Name:            sharedFn
-; CHECK-NEXT:        Kind:            FUNCTION
-; CHECK-NEXT:        Index:           3
-; CHECK-NEXT:      - Name:            constantData
-; CHECK-NEXT:        Kind:            GLOBAL
-; CHECK-NEXT:        Index:           0
 ; CHECK-NEXT:  - Type:            CODE
 ; CHECK-NEXT:    Relocations:
 ; CHECK-NEXT:      - Type:            R_WEBASSEMBLY_FUNCTION_INDEX_LEB
 ; CHECK-NEXT:        Index:           0
 ; CHECK-NEXT:        Offset:          0x00000004
 ; CHECK-NEXT:    Functions:
 ; CHECK-NEXT:      - Index:           1
 ; CHECK-NEXT:        Locals:

 ; CHECK-NEXT:        MemoryIndex:     0
 ; CHECK-NEXT:        Offset:
 ; CHECK-NEXT:          Opcode:          I32_CONST
 ; CHECK-NEXT:          Value:           0
 ; CHECK-NEXT:        Content:         '616263'
 ; CHECK-NEXT:  - Type:            CUSTOM
 ; CHECK-NEXT:    Name:            linking
 ; CHECK-NEXT:    DataSize:        3
-; CHECK-NEXT:    SymbolInfo:
-; CHECK-NEXT:      - Name:            basicInlineFn
-; CHECK-NEXT:        Flags:           [ BINDING_WEAK ]
-; CHECK-NEXT:      - Name:            sharedFn
-; CHECK-NEXT:        Flags:           [ BINDING_WEAK ]
-; CHECK-NEXT:      - Name:            constantData
-; CHECK-NEXT:        Flags:           [ BINDING_WEAK ]
+; CHECK-NEXT:    SymbolTable:
+; CHECK-NEXT:       - Index:           0
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            funcImport
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   0
+; CHECK-NEXT:       - Index:           1
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            callImport
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   1
+; CHECK-NEXT:       - Index:           2
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            basicInlineFn
+; CHECK-NEXT:         Flags:           [ BINDING_WEAK ]
+; CHECK-NEXT:         FunctionIndex:   2
+; CHECK-NEXT:       - Index:           3
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            sharedFn
+; CHECK-NEXT:         Flags:           [ BINDING_WEAK ]
+; CHECK-NEXT:         FunctionIndex:   3
+; CHECK-NEXT:       - Index:           4
+; CHECK-NEXT:         Kind:            DATA
+; CHECK-NEXT:         Name:            constantData
+; CHECK-NEXT:         Flags:           [ BINDING_WEAK ]
+; CHECK-NEXT:         SegmentIndex:    0
+; CHECK-NEXT:         Size:            3
 ; CHECK-NEXT:    SegmentInfo:
 ; CHECK-NEXT:      - Index:           0
 ; CHECK-NEXT:        Name:            .rodata.constantData
 ; CHECK-NEXT:        Alignment:       1
 ; CHECK-NEXT:        Flags:           [  ]
 ; CHECK-NEXT:    Comdats:
-; CHECK-NEXT:      - Name:            basicInlineFn
+; CHECK-NEXT:        Name:            basicInlineFn
 ; CHECK-NEXT:        Entries:
 ; CHECK-NEXT:          - Kind:            FUNCTION
 ; CHECK-NEXT:            Index:           2
-; CHECK-NEXT:      - Name:            sharedComdat
+; CHECK-NEXT:        Name:            sharedComdat
 ; CHECK-NEXT:        Entries:
 ; CHECK-NEXT:          - Kind:            FUNCTION
 ; CHECK-NEXT:            Index:           3
 ; CHECK-NEXT:          - Kind:            DATA
 ; CHECK-NEXT:            Index:           0
 ; CHECK-NEXT: ...

test/MC/WebAssembly/explicit-sections.ll

 ; RUN: llc -filetype=obj %s -o - | obj2yaml | FileCheck %s
 
 target triple = "wasm32-unknown-unknown-wasm"
 
 %struct.bd = type { i32, i8 }
 
 @global0 = global i32 8, align 8
 @global1 = global %struct.bd  { i32 1, i8 3 }, align 8, section ".sec1"
 @global2 = global i64 7, align 8, section ".sec1"
 @global3 = global i32 8, align 8, section ".sec2"
 
-; CHECK:        - Type:            GLOBAL
-; CHECK-NEXT:     Globals:         
-; CHECK-NEXT:       - Index:           0
-; CHECK-NEXT:         Type:            I32
-; CHECK-NEXT:         Mutable:         false
-; CHECK-NEXT:         InitExpr:        
-; CHECK-NEXT:           Opcode:          I32_CONST
-; CHECK-NEXT:           Value:           0
-; CHECK-NEXT:       - Index:           1
-; CHECK-NEXT:         Type:            I32
-; CHECK-NEXT:         Mutable:         false
-; CHECK-NEXT:         InitExpr:        
-; CHECK-NEXT:           Opcode:          I32_CONST
-; CHECK-NEXT:           Value:           8
-; CHECK-NEXT:       - Index:           2
-; CHECK-NEXT:         Type:            I32
-; CHECK-NEXT:         Mutable:         false
-; CHECK-NEXT:         InitExpr:        
-; CHECK-NEXT:           Opcode:          I32_CONST
-; CHECK-NEXT:           Value:           16
-; CHECK-NEXT:       - Index:           3
-; CHECK-NEXT:         Type:            I32
-; CHECK-NEXT:         Mutable:         false
-; CHECK-NEXT:         InitExpr:        
-; CHECK-NEXT:           Opcode:          I32_CONST
-; CHECK-NEXT:           Value:           24
-; CHECK-NEXT:   - Type:            EXPORT
-; CHECK-NEXT:     Exports:         
-; CHECK-NEXT:       - Name:            global0
-; CHECK-NEXT:         Kind:            GLOBAL
-; CHECK-NEXT:         Index:           0
-; CHECK-NEXT:       - Name:            global1
-; CHECK-NEXT:         Kind:            GLOBAL
-; CHECK-NEXT:         Index:           1
-; CHECK-NEXT:       - Name:            global2
-; CHECK-NEXT:         Kind:            GLOBAL
-; CHECK-NEXT:         Index:           2
-; CHECK-NEXT:       - Name:            global3
-; CHECK-NEXT:         Kind:            GLOBAL
-; CHECK-NEXT:         Index:           3
-; CHECK-NEXT:   - Type:            DATA
+
+; CHECK:        - Type:            DATA
 ; CHECK-NEXT:     Segments:        
 ; CHECK-NEXT:       - SectionOffset:   6
 ; CHECK-NEXT:         MemoryIndex:     0
 ; CHECK-NEXT:         Offset:          
 ; CHECK-NEXT:           Opcode:          I32_CONST
 ; CHECK-NEXT:           Value:           0
 ; CHECK-NEXT:         Content:         '08000000'
 ; CHECK-NEXT:       - SectionOffset:   15
 ; CHECK-NEXT:         MemoryIndex:     0
 ; CHECK-NEXT:         Offset:          
 ; CHECK-NEXT:           Opcode:          I32_CONST
 ; CHECK-NEXT:           Value:           8
 ; CHECK-NEXT:         Content:         '01000000030000000700000000000000'
 ; CHECK-NEXT:       - SectionOffset:   36
 ; CHECK-NEXT:         MemoryIndex:     0
 ; CHECK-NEXT:         Offset:          
 ; CHECK-NEXT:           Opcode:          I32_CONST
 ; CHECK-NEXT:           Value:           24
 ; CHECK-NEXT:         Content:         '08000000'
-
-; CHECK:        - Type:            CUSTOM
+; CHECK-NEXT:   - Type:            CUSTOM
 ; CHECK-NEXT:     Name:            linking
 ; CHECK-NEXT:     DataSize:        28
+; CHECK-NEXT:     SymbolTable:
+; CHECK-NEXT:       - Index:           0
+; CHECK-NEXT:         Kind:            DATA
+; CHECK-NEXT:         Name:            global0
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         SegmentIndex:    0
+; CHECK-NEXT:         Size:            4
+; CHECK-NEXT:       - Index:           1
+; CHECK-NEXT:         Kind:            DATA
+; CHECK-NEXT:         Name:            global1
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         SegmentIndex:    1
+; CHECK-NEXT:         Size:            8
+; CHECK-NEXT:       - Index:           2
+; CHECK-NEXT:         Kind:            DATA
+; CHECK-NEXT:         Name:            global2
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         SegmentIndex:    1
+; CHECK-NEXT:         Offset:          8
+; CHECK-NEXT:         Size:            8
+; CHECK-NEXT:       - Index:           3
+; CHECK-NEXT:         Kind:            DATA
+; CHECK-NEXT:         Name:            global3
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         SegmentIndex:    2
+; CHECK-NEXT:         Size:            4
 ; CHECK-NEXT:     SegmentInfo:    
 ; CHECK-NEXT:       - Index:           0
 ; CHECK-NEXT:         Name:            .data.global0
 ; CHECK-NEXT:         Alignment:       8
 ; CHECK-NEXT:         Flags:           [ ]
 ; CHECK-NEXT:       - Index:           1
 ; CHECK-NEXT:         Name:            .sec1
 ; CHECK-NEXT:         Alignment:       8
 ; CHECK-NEXT:         Flags:           [ ]
 ; CHECK-NEXT:       - Index:           2
 ; CHECK-NEXT:         Name:            .sec2
 ; CHECK-NEXT:         Alignment:       8
 ; CHECK-NEXT:         Flags:           [ ]
 ; CHECK-NEXT: ...

test/MC/WebAssembly/func-address.ll

 }
 
 ; CHECK:   Section {
 ; CHECK:     Type: ELEM (0x9)
 ; CHECK:     Size: 7
 ; CHECK:   }
 
 ; CHECK: Relocations [
-; CHECK:   Section (6) CODE {
+; CHECK:   Section (5) CODE {
 ; CHECK:     Relocation {
 ; CHECK:       Type: R_WEBASSEMBLY_FUNCTION_INDEX_LEB (0)
 ; CHECK:       Offset: 0x4
 ; CHECK:       Index: 0x0
 ; CHECK:     }
 ; CHECK:     Relocation {
 ; CHECK:       Type: R_WEBASSEMBLY_FUNCTION_INDEX_LEB (0)
 ; CHECK:       Offset: 0xB
 ; CHECK:       Index: 0x1
 ; CHECK:     }
 ; CHECK:     Relocation {
 ; CHECK:       Type: R_WEBASSEMBLY_TABLE_INDEX_SLEB (1)
 ; CHECK:       Offset: 0x1E
 ; CHECK:       Index: 0x3
 ; CHECK:     }
 ; CHECK:   }

test/MC/WebAssembly/global-ctor-dtor.ll

 ; CHECK-NEXT:           ElemType:        ANYFUNC
 ; CHECK-NEXT:           Limits:          
 ; CHECK-NEXT:             Initial:         0x00000002
 ; CHECK-NEXT:       - Module:          env
 ; CHECK-NEXT:         Field:           func3
 ; CHECK-NEXT:         Kind:            FUNCTION
 ; CHECK-NEXT:         SigIndex:        1
 ; CHECK-NEXT:       - Module:          env
-; CHECK-NEXT:         Field:           __dso_handle
-; CHECK-NEXT:         Kind:            GLOBAL
-; CHECK-NEXT:         GlobalType:      I32
-; CHECK-NEXT:         GlobalMutable:   false
-; CHECK-NEXT:       - Module:          env
 ; CHECK-NEXT:         Field:           __cxa_atexit
 ; CHECK-NEXT:         Kind:            FUNCTION
 ; CHECK-NEXT:         SigIndex:        2
 ; CHECK-NEXT:       - Module:          env
 ; CHECK-NEXT:         Field:           func2
 ; CHECK-NEXT:         Kind:            FUNCTION
 ; CHECK-NEXT:         SigIndex:        1
 ; CHECK-NEXT:       - Module:          env
 ; CHECK-NEXT:         Field:           func1
 ; CHECK-NEXT:         Kind:            FUNCTION
 ; CHECK-NEXT:         SigIndex:        1
 ; CHECK-NEXT:       - Module:          env
 ; CHECK-NEXT:         Field:           func0
 ; CHECK-NEXT:         Kind:            FUNCTION
 ; CHECK-NEXT:         SigIndex:        1
 ; CHECK-NEXT:   - Type:            FUNCTION
 ; CHECK-NEXT:     FunctionTypes:   [ 0, 1, 0, 1 ]
-; CHECK-NEXT:   - Type:            GLOBAL
-; CHECK-NEXT:     Globals:         
-; CHECK-NEXT:       - Index:           1
-; CHECK-NEXT:         Type:            I32
-; CHECK-NEXT:         Mutable:         false
-; CHECK-NEXT:         InitExpr:        
-; CHECK-NEXT:           Opcode:          I32_CONST
-; CHECK-NEXT:           Value:           0
-; CHECK-NEXT:   - Type:            EXPORT
-; CHECK-NEXT:     Exports:         
-; CHECK-NEXT:       - Name:            .Lcall_dtors.42
-; CHECK-NEXT:         Kind:            FUNCTION
-; CHECK-NEXT:         Index:           5
-; CHECK-NEXT:       - Name:            .Lregister_call_dtors.42
-; CHECK-NEXT:         Kind:            FUNCTION
-; CHECK-NEXT:         Index:           6
-; CHECK-NEXT:       - Name:            .Lcall_dtors
-; CHECK-NEXT:         Kind:            FUNCTION
-; CHECK-NEXT:         Index:           7
-; CHECK-NEXT:       - Name:            .Lregister_call_dtors
-; CHECK-NEXT:         Kind:            FUNCTION
-; CHECK-NEXT:         Index:           8
-; CHECK-NEXT:       - Name:            global1
-; CHECK-NEXT:         Kind:            GLOBAL
-; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:   - Type:            ELEM
 ; CHECK-NEXT:     Segments:        
 ; CHECK-NEXT:       - Offset:          
 ; CHECK-NEXT:           Opcode:          I32_CONST
 ; CHECK-NEXT:           Value:           1
 ; CHECK-NEXT:         Functions:       [ 5, 7 ]
 ; CHECK-NEXT:   - Type:            CODE
 ; CHECK-NEXT:     Relocations:     

 ; CHECK-NEXT:         MemoryIndex:     0
 ; CHECK-NEXT:         Offset:          
 ; CHECK-NEXT:           Opcode:          I32_CONST
 ; CHECK-NEXT:           Value:           0
 ; CHECK-NEXT:         Content:         '01040000'
 ; CHECK-NEXT:   - Type:            CUSTOM
 ; CHECK-NEXT:     Name:            linking
 ; CHECK-NEXT:     DataSize:        4
-; CHECK-NEXT:     SymbolInfo:      
-; CHECK-NEXT:       - Name:            __dso_handle
+; CHECK-NEXT:     SymbolTable:
+; CHECK-NEXT:       - Index:           0
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            func3
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   0
+; CHECK-NEXT:       - Index:           1
+; CHECK-NEXT:         Kind:            DATA
+; CHECK-NEXT:         Name:            __dso_handle
 ; CHECK-NEXT:         Flags:           [ BINDING_WEAK, VISIBILITY_HIDDEN ]
-; CHECK-NEXT:       - Name:            .Lcall_dtors.42
+; CHECK-NEXT:       - Index:           2
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            __cxa_atexit
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   1
+; CHECK-NEXT:       - Index:           3
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            func2
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   2
+; CHECK-NEXT:       - Index:           4
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            func1
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   3
+; CHECK-NEXT:       - Index:           5
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            func0
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   4
+; CHECK-NEXT:       - Index:           6
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            .Lcall_dtors.42
 ; CHECK-NEXT:         Flags:           [ BINDING_LOCAL ]
-; CHECK-NEXT:       - Name:            .Lregister_call_dtors.42
+; CHECK-NEXT:         FunctionIndex:   5
+; CHECK-NEXT:       - Index:           7
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            .Lregister_call_dtors.42
 ; CHECK-NEXT:         Flags:           [ BINDING_LOCAL ]
-; CHECK-NEXT:       - Name:            .Lcall_dtors
+; CHECK-NEXT:         FunctionIndex:   6
+; CHECK-NEXT:       - Index:           8
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            .Lcall_dtors
 ; CHECK-NEXT:         Flags:           [ BINDING_LOCAL ]
-; CHECK-NEXT:       - Name:            .Lregister_call_dtors
+; CHECK-NEXT:         FunctionIndex:   7
+; CHECK-NEXT:       - Index:           9
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            .Lregister_call_dtors
 ; CHECK-NEXT:         Flags:           [ BINDING_LOCAL ]
+; CHECK-NEXT:         FunctionIndex:   8
+; CHECK-NEXT:       - Index:           10
+; CHECK-NEXT:         Kind:            DATA
+; CHECK-NEXT:         Name:            global1
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         SegmentIndex:    0
+; CHECK-NEXT:         Size:            4
 ; CHECK-NEXT:     SegmentInfo:     
 ; CHECK-NEXT:       - Index:           0
 ; CHECK-NEXT:         Name:            .data.global1
 ; CHECK-NEXT:         Alignment:       8
 ; CHECK-NEXT:         Flags:           [ ]
 ; CHECK-NEXT:     InitFunctions:     
 ; CHECK-NEXT:       - Priority: 42
 ; CHECK-NEXT:         Symbol: 4
 ; CHECK-NEXT:       - Priority: 42
 ; CHECK-NEXT:         Symbol: 7
 ; CHECK-NEXT:       - Priority: 65535
 ; CHECK-NEXT:         Symbol: 5
 ; CHECK-NEXT:       - Priority: 65535
 ; CHECK-NEXT:         Symbol: 9
 ; CHECK-NEXT: ...

test/MC/WebAssembly/reloc-code.ll

entry:
     %tmp3 = call i32 @c()
     %tmp4 = call i32 @d()
     ret i32 %tmp2
 }
 
 
 ; CHECK: Format: WASM
 ; CHECK: Relocations [
-; CHECK-NEXT:   Section (6) CODE {
+; CHECK-NEXT:   Section (4) CODE {
 ; CHECK-NEXT:     Relocation {
 ; CHECK-NEXT:       Type: R_WEBASSEMBLY_MEMORY_ADDR_LEB (3)
 ; CHECK-NEXT:       Offset: 0x9
 ; CHECK-NEXT:       Index: 0x3
 ; CHECK-NEXT:       Addend: 0
 ; CHECK-NEXT:     }
 ; CHECK-NEXT:     Relocation {
 ; CHECK-NEXT:       Type: R_WEBASSEMBLY_MEMORY_ADDR_LEB (3)

test/MC/WebAssembly/reloc-data.ll

 ; RUN: llc -O0 -filetype=obj %s -o - | llvm-readobj -r -expand-relocs | FileCheck %s
 
 target triple = "wasm32-unknown-unknown-wasm"
 
 ; foo and bar are external and internal symbols.  a and b are pointers
 ; initialized to these locations offset by 2 and -2 elements respecitively.
 
 @foo = external global i32, align 4
 @bar = global i64 7, align 4
 @a = global i32* getelementptr (i32, i32* @foo, i32 2), align 8
 @b = global i64* getelementptr (i64, i64* @bar, i64 -2), align 8
 @c = global [3 x i32*] [i32* @foo, i32* @foo, i32* @foo], align 16
 
 ; CHECK:      Format: WASM
 ; CHECK:      Relocations [
-; CHECK-NEXT:   Section (4) DATA {
+; CHECK-NEXT:   Section (2) DATA {
 ; CHECK-NEXT:     Relocation {
 ; CHECK-NEXT:       Type: R_WEBASSEMBLY_MEMORY_ADDR_I32 (5)
 ; CHECK-NEXT:       Offset: 0x13
 ; CHECK-NEXT:       Index: 0x0
 ; CHECK-NEXT:       Addend: 8
 ; CHECK-NEXT:     }
 ; CHECK-NEXT:     Relocation {
 ; CHECK-NEXT:       Type: R_WEBASSEMBLY_MEMORY_ADDR_I32 (5)

test/MC/WebAssembly/sections.ll

 ; CHECK:   }
 ; CHECK:  Section {
 ; CHECK:    Type: IMPORT (0x2)
 ; CHECK:  }
 ; CHECK:  Section {
 ; CHECK:    Type: FUNCTION (0x3)
 ; CHECK:  }
 ; CHECK:  Section {
-; CHECK:    Type: GLOBAL (0x6)
-; CHECK:  }
-; CHECK:  Section {
-; CHECK:    Type: EXPORT (0x7)
-; CHECK:  }
-; CHECK:  Section {
 ; CHECK:    Type: CODE (0xA)
 ; CHECK:  }
 ; CHECK:  Section {
 ; CHECK:    Type: DATA (0xB)
 ; CHECK:  }
 ; CHECK:  Section {
 ; CHECK:    Type: CUSTOM (0x0)
 ; CHECK:    Name: reloc.CODE
 ; CHECK:  }
 ; CHECK:]
 

test/MC/WebAssembly/unnamed-data.ll

 ; RUN: llc -filetype=obj %s -o - | obj2yaml | FileCheck %s
 
 target triple = "wasm32-unknown-unknown-wasm"
 
 @.str1 = private unnamed_addr constant [6 x i8] c"hello\00", align 1
 @.str2 = private unnamed_addr constant [6 x i8] c"world\00", align 1
 
 @a = global i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str1, i32 0, i32 0), align 8
 @b = global i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str2, i32 0, i32 0), align 8
 
 
-; CHECK:        - Type:            GLOBAL
-; CHECK-NEXT:     Globals:         
-; CHECK-NEXT:       - Index:           0
-; CHECK-NEXT:         Type:            I32
-; CHECK-NEXT:         Mutable:         false
-; CHECK-NEXT:         InitExpr:        
-; CHECK-NEXT:           Opcode:          I32_CONST
-; CHECK-NEXT:           Value:           0
-; CHECK-NEXT:       - Index:           1
-; CHECK-NEXT:         Type:            I32
-; CHECK-NEXT:         Mutable:         false
-; CHECK-NEXT:         InitExpr:        
-; CHECK-NEXT:           Opcode:          I32_CONST
-; CHECK-NEXT:           Value:           6
-; CHECK-NEXT:       - Index:           2
-; CHECK-NEXT:         Type:            I32
-; CHECK-NEXT:         Mutable:         false
-; CHECK-NEXT:         InitExpr:        
-; CHECK-NEXT:           Opcode:          I32_CONST
-; CHECK-NEXT:           Value:           16
-; CHECK-NEXT:       - Index:           3
-; CHECK-NEXT:         Type:            I32
-; CHECK-NEXT:         Mutable:         false
-; CHECK-NEXT:         InitExpr:
-; CHECK-NEXT:           Opcode:          I32_CONST
-; CHECK-NEXT:           Value:           24
-; CHECK-NEXT:   - Type:            EXPORT
-; CHECK-NEXT:     Exports:
-; CHECK-NEXT:       - Name:            .L.str1
-; CHECK-NEXT:         Kind:            GLOBAL
-; CHECK-NEXT:         Index:           0
-; CHECK-NEXT:       - Name:            .L.str2
-; CHECK-NEXT:         Kind:            GLOBAL
-; CHECK-NEXT:         Index:           1
-; CHECK-NEXT:       - Name:            a
-; CHECK-NEXT:         Kind:            GLOBAL
-; CHECK-NEXT:         Index:           2
-; CHECK-NEXT:       - Name:            b
-; CHECK-NEXT:         Kind:            GLOBAL
-; CHECK-NEXT:         Index:           3
-; CHECK-NEXT:   - Type:            DATA
+; CHECK:        - Type:            DATA
 ; CHECK-NEXT:     Relocations:     
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_I32
 ; CHECK-NEXT:         Index:           0
 ; CHECK-NEXT:         Offset:          0x0000001C
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_I32
 ; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x00000025
 ; CHECK-NEXT:     Segments:        

 ; CHECK-NEXT:         MemoryIndex:     0
 ; CHECK-NEXT:         Offset:          
 ; CHECK-NEXT:           Opcode:          I32_CONST
 ; CHECK-NEXT:           Value:           24
 ; CHECK-NEXT:         Content:         '06000000'
 ; CHECK-NEXT:   - Type:            CUSTOM
 ; CHECK-NEXT:     Name:            linking
 ; CHECK-NEXT:     DataSize:        28
-; CHECK-NEXT:     SymbolInfo:      
-; CHECK-NEXT:       - Name:            .L.str1
+; CHECK-NEXT:     SymbolTable:      
+; CHECK-NEXT:       - Index:           0
+; CHECK-NEXT:         Kind:            DATA
+; CHECK-NEXT:         Name:            .L.str1
 ; CHECK-NEXT:         Flags:           [ BINDING_LOCAL ]
-; CHECK-NEXT:       - Name:            .L.str2
+; CHECK-NEXT:         SegmentIndex:    0
+; CHECK-NEXT:         Size:            6
+; CHECK-NEXT:       - Index:           1
+; CHECK-NEXT:         Kind:            DATA
+; CHECK-NEXT:         Name:            .L.str2
 ; CHECK-NEXT:         Flags:           [ BINDING_LOCAL ]
+; CHECK-NEXT:         SegmentIndex:    1
+; CHECK-NEXT:         Size:            6
+; CHECK-NEXT:       - Index:           2
+; CHECK-NEXT:         Kind:            DATA
+; CHECK-NEXT:         Name:            a
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         SegmentIndex:    2
+; CHECK-NEXT:         Size:            4
+; CHECK-NEXT:       - Index:           3
+; CHECK-NEXT:         Kind:            DATA
+; CHECK-NEXT:         Name:            b
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         SegmentIndex:    3
+; CHECK-NEXT:         Size:            4
 ; CHECK-NEXT:     SegmentInfo:    
 ; CHECK-NEXT:       - Index:       0
 ; CHECK-NEXT:         Name:        .rodata..L.str1
 ; CHECK-NEXT:         Alignment:   1
 ; CHECK-NEXT:         Flags:       [ ]
 ; CHECK-NEXT:       - Index:       1
 ; CHECK-NEXT:         Name:        .rodata..L.str2
 ; CHECK-NEXT:         Alignment:   1

test/MC/WebAssembly/visibility.ll

 define hidden void @hiddenVis() #0 {
 entry:
   ret void
 }
 
 ; CHECK:        - Type:            CUSTOM
 ; CHECK-NEXT:     Name:            linking
 ; CHECK-NEXT:     DataSize:        0
-; CHECK-NEXT:     SymbolInfo:
-; CHECK-NEXT:       - Name:            hiddenVis
+; CHECK-NEXT:     SymbolTable:
+; CHECK-NEXT:       - Index:           0
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            defaultVis
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   0
+; CHECK-NEXT:       - Index:           1
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            hiddenVis
 ; CHECK-NEXT:         Flags:           [ VISIBILITY_HIDDEN ]
+; CHECK-NEXT:         FunctionIndex:   1
 ; CHECK-NEXT: ...

test/MC/WebAssembly/weak-alias.ll

 ; CHECK-NEXT:         Field:           __indirect_function_table
 ; CHECK-NEXT:         Kind:            TABLE
 ; CHECK-NEXT:         Table:
 ; CHECK-NEXT:           ElemType:        ANYFUNC
 ; CHECK-NEXT:           Limits:
 ; CHECK-NEXT:             Initial:         0x00000001
 ; CHECK-NEXT:   - Type:            FUNCTION
 ; CHECK-NEXT:     FunctionTypes:   [ 0, 0, 0, 0, 0 ]
-; CHECK-NEXT:   - Type:            GLOBAL
-; CHECK-NEXT:     Globals:         
-; CHECK-NEXT:       - Index:           0
-; CHECK-NEXT:         Type:            I32
-; CHECK-NEXT:         Mutable:         false
-; CHECK-NEXT:         InitExpr:        
-; CHECK-NEXT:           Opcode:          I32_CONST
-; CHECK-NEXT:           Value:           8
-; CHECK-NEXT:       - Index:           1
-; CHECK-NEXT:         Type:            I32
-; CHECK-NEXT:         Mutable:         false
-; CHECK-NEXT:         InitExpr:        
-; CHECK-NEXT:           Opcode:          I32_CONST
-; CHECK-NEXT:           Value:           16
-; CHECK-NEXT:       - Index:           2
-; CHECK-NEXT:         Type:            I32
-; CHECK-NEXT:         Mutable:         false
-; CHECK-NEXT:         InitExpr:        
-; CHECK-NEXT:           Opcode:          I32_CONST
-; CHECK-NEXT:           Value:           0
-; CHECK-NEXT:   - Type:            EXPORT
-; CHECK-NEXT:     Exports:         
-; CHECK-NEXT:       - Name:            foo
-; CHECK-NEXT:         Kind:            FUNCTION
-; CHECK-NEXT:         Index:           0
-; CHECK-NEXT:       - Name:            call_direct
-; CHECK-NEXT:         Kind:            FUNCTION
-; CHECK-NEXT:         Index:           1
-; CHECK-NEXT:       - Name:            call_alias
-; CHECK-NEXT:         Kind:            FUNCTION
-; CHECK-NEXT:         Index:           2
-; CHECK-NEXT:       - Name:            call_direct_ptr
-; CHECK-NEXT:         Kind:            FUNCTION
-; CHECK-NEXT:         Index:           3
-; CHECK-NEXT:       - Name:            direct_address
-; CHECK-NEXT:         Kind:            GLOBAL
-; CHECK-NEXT:         Index:           0
-; CHECK-NEXT:       - Name:            call_alias_ptr
-; CHECK-NEXT:         Kind:            FUNCTION
-; CHECK-NEXT:         Index:           4
-; CHECK-NEXT:       - Name:            alias_address
-; CHECK-NEXT:         Kind:            GLOBAL
-; CHECK-NEXT:         Index:           1
-; CHECK-NEXT:       - Name:            bar
-; CHECK-NEXT:         Kind:            GLOBAL
-; CHECK-NEXT:         Index:           2
-; CHECK-NEXT:       - Name:            foo_alias
-; CHECK-NEXT:         Kind:            FUNCTION
-; CHECK-NEXT:         Index:           0
-; CHECK-NEXT:       - Name:            bar_alias
-; CHECK-NEXT:         Kind:            GLOBAL
-; CHECK-NEXT:         Index:           2
 ; CHECK-NEXT:   - Type:            ELEM
 ; CHECK-NEXT:     Segments:        
 ; CHECK-NEXT:       - Offset:          
 ; CHECK-NEXT:           Opcode:          I32_CONST
 ; CHECK-NEXT:           Value:           1
 ; CHECK-NEXT:         Functions:       [ 0 ]
 ; CHECK-NEXT:   - Type:            CODE
 ; CHECK-NEXT:     Relocations:     

 ; CHECK-NEXT:         MemoryIndex:     0
 ; CHECK-NEXT:         Offset:
 ; CHECK-NEXT:           Opcode:          I32_CONST
 ; CHECK-NEXT:           Value:           16
 ; CHECK-NEXT:         Content:         '01000000'
 ; CHECK-NEXT:   - Type:            CUSTOM
 ; CHECK-NEXT:     Name:            linking
 ; CHECK-NEXT:     DataSize:        20
-; CHECK-NEXT:     SymbolInfo:      
-; CHECK-NEXT:       - Name:            foo
+; CHECK-NEXT:     SymbolTable:      
+; CHECK-NEXT:       - Index:           0
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            foo
 ; CHECK-NEXT:         Flags:           [ VISIBILITY_HIDDEN ]
-; CHECK-NEXT:       - Name:            call_direct
+; CHECK-NEXT:         FunctionIndex:   0
+; CHECK-NEXT:       - Index:           1
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            call_direct
 ; CHECK-NEXT:         Flags:           [ VISIBILITY_HIDDEN ]
-; CHECK-NEXT:       - Name:            call_alias
+; CHECK-NEXT:         FunctionIndex:   1
+; CHECK-NEXT:       - Index:           2
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            call_alias
 ; CHECK-NEXT:         Flags:           [ VISIBILITY_HIDDEN ]
-; CHECK-NEXT:       - Name:            call_direct_ptr
+; CHECK-NEXT:         FunctionIndex:   2
+; CHECK-NEXT:       - Index:           3
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            call_direct_ptr
 ; CHECK-NEXT:         Flags:           [ VISIBILITY_HIDDEN ]
-; CHECK-NEXT:       - Name:            call_alias_ptr
+; CHECK-NEXT:         FunctionIndex:   3
+; CHECK-NEXT:       - Index:           4
+; CHECK-NEXT:         Kind:            DATA
+; CHECK-NEXT:         Name:            direct_address
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         SegmentIndex:    1
+; CHECK-NEXT:         Size:            4
+; CHECK-NEXT:       - Index:           5
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            call_alias_ptr
 ; CHECK-NEXT:         Flags:           [ VISIBILITY_HIDDEN ]
-; CHECK-NEXT:       - Name:            foo_alias
+; CHECK-NEXT:         FunctionIndex:   4
+; CHECK-NEXT:       - Index:           6
+; CHECK-NEXT:         Kind:            DATA
+; CHECK-NEXT:         Name:            alias_address
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         SegmentIndex:    2
+; CHECK-NEXT:         Size:            4
+; CHECK-NEXT:       - Index:           7
+; CHECK-NEXT:         Kind:            DATA
+; CHECK-NEXT:         Name:            bar
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         SegmentIndex:    0
+; CHECK-NEXT:         Size:            4
+; CHECK-NEXT:       - Index:           8
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            foo_alias
 ; CHECK-NEXT:         Flags:           [ BINDING_WEAK, VISIBILITY_HIDDEN ]
-; CHECK-NEXT:       - Name:            bar_alias
+; CHECK-NEXT:         FunctionIndex:   0
+; CHECK-NEXT:       - Index:           9
+; CHECK-NEXT:         Kind:            DATA
+; CHECK-NEXT:         Name:            bar_alias
 ; CHECK-NEXT:         Flags:           [ BINDING_WEAK, VISIBILITY_HIDDEN ]
+; CHECK-NEXT:         SegmentIndex:    0
+; CHECK-NEXT:         Size:            4
 ; CHECK-NEXT:     SegmentInfo:    
 ; CHECK-NEXT:       - Index:           0
 ; CHECK-NEXT:         Name:            .data.bar
 ; CHECK-NEXT:         Alignment:       8
 ; CHECK-NEXT:         Flags:           [ ]
 ; CHECK-NEXT:       - Index:           1
 ; CHECK-NEXT:         Name:            .data.direct_address
 ; CHECK-NEXT:         Alignment:       8
 ; CHECK-NEXT:         Flags:           [ ]
 ; CHECK-NEXT:       - Index:           2
 ; CHECK-NEXT:         Name:            .data.alias_address
 ; CHECK-NEXT:         Alignment:       8
 ; CHECK-NEXT:         Flags:           [ ]
 ; CHECK-NEXT: ...
 
 ; CHECK-SYMS: SYMBOL TABLE:
-; CHECK-SYMS-NEXT: 00000000 g     F EXPORT     .hidden foo
-; CHECK-SYMS-NEXT: 00000001 g     F EXPORT     .hidden call_direct
-; CHECK-SYMS-NEXT: 00000002 g     F EXPORT     .hidden call_alias
-; CHECK-SYMS-NEXT: 00000003 g     F EXPORT     .hidden call_direct_ptr
-; CHECK-SYMS-NEXT: 00000008 g       EXPORT     direct_address
-; CHECK-SYMS-NEXT: 00000004 g     F EXPORT     .hidden call_alias_ptr
-; CHECK-SYMS-NEXT: 00000010 g       EXPORT     alias_address
-; CHECK-SYMS-NEXT: 00000000 g       EXPORT     bar
-; CHECK-SYMS-NEXT: 00000000 gw    F EXPORT     .hidden foo_alias
-; CHECK-SYMS-NEXT: 00000000 gw      EXPORT     .hidden bar_alias
+; CHECK-SYMS-NEXT: 00000000 g     F CODE     .hidden foo
+; CHECK-SYMS-NEXT: 00000001 g     F CODE     .hidden call_direct
+; CHECK-SYMS-NEXT: 00000002 g     F CODE     .hidden call_alias
+; CHECK-SYMS-NEXT: 00000003 g     F CODE     .hidden call_direct_ptr
+; CHECK-SYMS-NEXT: 00000008 g       DATA     direct_address
+; CHECK-SYMS-NEXT: 00000004 g     F CODE     .hidden call_alias_ptr
+; CHECK-SYMS-NEXT: 00000010 g       DATA     alias_address
+; CHECK-SYMS-NEXT: 00000000 g       DATA     bar
+; CHECK-SYMS-NEXT: 00000000 gw    F CODE     .hidden foo_alias
+; CHECK-SYMS-NEXT: 00000000 gw      DATA     .hidden bar_alias

test/MC/WebAssembly/weak.ll

 }
 
 ; CHECK:        - Type:            IMPORT
 ; CHECK-NEXT:     Imports:         
 ; CHECK:            - Module:          env
 ; CHECK-NEXT:         Field:           __linear_memory
 ; CHECK:            - Module:          env
 ; CHECK-NEXT:         Field:           __indirect_function_table
-; CHECK:            - Module:          env
-; CHECK-NEXT:         Field:           weak_external_data
-; CHECK-NEXT:         Kind:            GLOBAL
-; CHECK-NEXT:         GlobalType:      I32
-; CHECK-NEXT:         GlobalMutable:   false
 
 
 ; CHECK:        - Type:            CUSTOM
 ; CHECK-NEXT:     Name:            linking
 ; CHECK-NEXT:     DataSize:        0
-; CHECK-NEXT:     SymbolInfo:      
-; CHECK-NEXT:       - Name:            weak_external_data
+; CHECK-NEXT:     SymbolTable:      
+; CHECK-NEXT:       - Index:           0
+; CHECK-NEXT:         Kind:            DATA
+; CHECK-NEXT:         Name:            weak_external_data
 ; CHECK-NEXT:         Flags:           [ BINDING_WEAK ]
-; CHECK-NEXT:       - Name:            weak_function
+; CHECK-NEXT:       - Index:           1
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            weak_function
 ; CHECK-NEXT:         Flags:           [ BINDING_WEAK, VISIBILITY_HIDDEN ]
+; CHECK-NEXT:         FunctionIndex:   0
 ; CHECK-NEXT: ...

test/Object/nm-trivial-object.test

 
 COFF32: 00000000 d .data
 COFF32-NEXT: 00000000 t .text
 COFF32-NEXT: 00000000 d L_.str
 COFF32-NEXT:          U _SomeOtherFunction
 COFF32-NEXT: 00000000 T _main
 COFF32-NEXT:          U _puts
 
-WASM:               U SomeOtherFunction
+
+WASM:      00000000 d .L.str
+WASM-NEXT:          U SomeOtherFunction
 WASM-NEXT: 00000002 T main
 WASM-NEXT:          U puts
 WASM-NEXT: 00000010 D var
 
+
 COFF64: 00000000 d .data
 COFF64-NEXT: 00000000 t .text
 COFF64-NEXT: 00000000 r ??__Ex@@YAXXZ
 COFF64-NEXT: 00000000 d L.str
 COFF64-NEXT:          U SomeOtherFunction
 COFF64-NEXT: 00000000 T main
 COFF64-NEXT:          U puts
 

test/Object/obj2yaml.test

 ELF-AVR-NEXT:       Section:         .text
 ELF-AVR-NEXT:     - Name:            _edata
 ELF-AVR-NEXT:       Section:         .data
 ELF-AVR-NEXT:       Value:           0x0000000000800060
 ELF-AVR-NEXT:     - Name:            _end
 ELF-AVR-NEXT:       Section:         .data
 ELF-AVR-NEXT:       Value:           0x0000000000800060
 
+
 WASM:      --- !WASM
 WASM-NEXT: FileHeader:
 WASM-NEXT:   Version:         0x00000001
-WASM:      - Type:            EXPORT
-WASM-NEXT:   Exports:         
-WASM-NEXT:     - Name:            main
-WASM-NEXT:       Kind:            FUNCTION
-WASM-NEXT:       Index:           2
-WASM-NEXT:     - Name:            var
-WASM-NEXT:       Kind:            GLOBAL
-WASM-NEXT:       Index:           1
+WASM:        - Type:            CUSTOM
+WASM-NEXT:     Name:            linking
+WASM-NEXT:     DataSize:        20
+WASM-NEXT:     SymbolTable:
+WASM-NEXT:       - Index:           0
+WASM-NEXT:         Kind:            FUNCTION
+WASM-NEXT:         Name:            puts
+WASM-NEXT:         Flags:           [  ]
+WASM-NEXT:         FunctionIndex:   0
+WASM-NEXT:       - Index:           1
+WASM:              Name:            SomeOtherFunction
+WASM:            - Index:           2
+WASM:              Name:            main
+WASM:            - Index:           3
+WASM-NEXT:         Kind:            DATA
+WASM-NEXT:         Name:            .L.str
+WASM-NEXT:         Flags:           [ BINDING_LOCAL ]
+WASM-NEXT:         SegmentIndex:    0
+WASM-NEXT:         Size:        13
+WASM-NEXT:       - Index:           4
+WASM:              Name:            var
+WASM:          SegmentInfo:
+WASM-NEXT:       - Index:           0
+WASM-NEXT:         Name:            .rodata..L.str
+WASM-NEXT:         Alignment:       1
+WASM-NEXT:         Flags:           [  ]
+WASM-NEXT:       - Index:           1
+WASM:      ...
+
 
 ELF-X86-64-UNWIND:      - Name:            .eh_frame
 ELF-X86-64-UNWIND-NEXT:   Type:            SHT_X86_64_UNWIND
 ELF-X86-64-UNWIND-NEXT:   Flags:           [ SHF_ALLOC ]
 ELF-X86-64-UNWIND-NEXT:   AddressAlign:    0x0000000000000001
 ELF-X86-64-UNWIND-NEXT:   Content:         ''
 
 RUN: not obj2yaml %t.blah 2>&1 | FileCheck --check-prefix=ENOENT %s
 ENOENT: Error reading file: {{.*}}.blah: {{[Nn]}}o such file or directory

test/Object/objdump-relocations.test

 ELF-MIPSEL: R_MIPS_HI16 _gp_disp
 ELF-MIPSEL: R_MIPS_LO16 _gp_disp
 ELF-MIPSEL: R_MIPS_GOT16 $.str
 ELF-MIPSEL: R_MIPS_LO16 $.str
 ELF-MIPSEL: R_MIPS_CALL16 puts
 ELF-MIPSEL: R_MIPS_CALL16 SomeOtherFunction
 
 WASM:      CODE
-WASM-NEXT: R_WEBASSEMBLY_MEMORY_ADDR_SLEB 0+0
+WASM-NEXT: R_WEBASSEMBLY_MEMORY_ADDR_SLEB 3+0
 WASM-NEXT: R_WEBASSEMBLY_FUNCTION_INDEX_LEB 0+0
 WASM-NEXT: R_WEBASSEMBLY_FUNCTION_INDEX_LEB 1+0
 
 ELF-complex-x86-64: .text
 ELF-complex-x86-64-NEXT: R_X86_64_8 .data-4
 ELF-complex-x86-64-NEXT: R_X86_64_16 .data-4
 ELF-complex-x86-64-NEXT: R_X86_64_32 .data-4
 ELF-complex-x86-64-NEXT: R_X86_64_32S .data-4
 ELF-complex-x86-64-NEXT: R_X86_64_64 .data-4
 ELF-complex-x86-64-NEXT: R_X86_64_PC32 .data-4-P
 ELF-complex-x86-64-NEXT: R_X86_64_32 .data+0
 ELF-complex-x86-64-NEXT: R_X86_64_32 .data+4

test/ObjectYAML/wasm/linking_section.yaml

Segments:
       - MemoryIndex:      0
         Offset:
           Opcode:          I32_CONST
           Value:           8
         Content:         '11110000'
   - Type:            CUSTOM
     Name:            linking
     DataSize:        999
-    SymbolInfo:
-      - Name:            bar
+    SymbolTable:
+      - Index:           0
+        Kind:            FUNCTION
+        Name:            bar
         Flags:           [ BINDING_WEAK ]
+        FunctionIndex:   0
     SegmentInfo:
       - Index:       0
         Alignment:   4
         Flags:       [ ]
         Name:        mydata
       - Index:       1
         Alignment:   2
         Flags:       [ ]
         Name:        moredata
     InitFunctions:
       - Priority:      1
         Symbol:        0
 ...
 # CHECK:       - Type:            CUSTOM
 # CHECK-NEXT:    Name:            linking
 # CHECK-NEXT:    DataSize:        999
-# CHECK-NEXT:    SymbolInfo:
-# CHECK-NEXT:      - Name:            bar
+# CHECK-NEXT:    SymbolTable:
+# CHECK-NEXT:      - Index:           0
+# CHECK-NEXT:        Kind:            FUNCTION
+# CHECK-NEXT:        Name:            bar
 # CHECK-NEXT:        Flags:           [ BINDING_WEAK ]
+# CHECK-NEXT:        FunctionIndex:   0
 # CHECK-NEXT:    SegmentInfo:
 # CHECK-NEXT:      - Index:           0
 # CHECK-NEXT:        Name:            mydata
 # CHECK-NEXT:        Alignment:       4
 # CHECK-NEXT:        Flags:           [ ]
 # CHECK-NEXT:      - Index:           1
 # CHECK-NEXT:        Name:            moredata
 # CHECK-NEXT:        Alignment:       2
 # CHECK-NEXT:        Flags:           [ ]
 # CHECK-NEXT:    InitFunctions:
 # CHECK-NEXT:       - Priority:       1
 # CHECK-NEXT:         Symbol:         0
 # CHECK-NEXT: ...

test/ObjectYAML/wasm/weak_symbols.yaml

Functions:
         Locals:
         Body:            00
       - Index:           1
         Locals:
         Body:            00
   - Type:            CUSTOM
     Name:            linking
     DataSize:        10
-    SymbolInfo:
-      - Name:            function_export
+    SymbolTable:
+      - Index:           0
+        Kind:            FUNCTION
+        Name:            function_export
         Flags:           [ BINDING_WEAK ]
-      - Name:            global_export
+        FunctionIndex:   0
+      - Index:           1
+        Kind:            GLOBAL
+        Name:            global_export
         Flags:           [ BINDING_WEAK ]
+        GlobalIndex:     0
 ...
 # CHECK: --- !WASM
 # CHECK: FileHeader:
 # CHECK:   Version:           0x00000001
 # CHECK: Sections:
 # CHECK:   - Type:            EXPORT
 # CHECK:     Exports:         
 # CHECK:       - Name:            function_export
 # CHECK:         Kind:            FUNCTION
 # CHECK:         Index:           1
 # CHECK:       - Name:            global_export
 # CHECK:         Kind:            GLOBAL
 # CHECK:         Index:           0
 # CHECK:   - Type:            CUSTOM
 # CHECK:     Name:            linking
 # CHECK:     DataSize:        10
-# CHECK:     SymbolInfo:
-# CHECK:       - Name:            function_export
-# CHECK:         Flags:           [ BINDING_WEAK ]
-# CHECK:       - Name:            global_export
-# CHECK:         Flags:           [ BINDING_WEAK ]
+# CHECK:     SymbolTable:
+# CHECK:      - Index:           0
+# CHECK:        Kind:            FUNCTION
+# CHECK:        Name:            function_export
+# CHECK:        Flags:           [ BINDING_WEAK ]
+# CHECK:        FunctionIndex:   0
+# CHECK:      - Index:           1
+# CHECK:        Kind:            GLOBAL
+# CHECK:        Name:            global_export
+# CHECK:        Flags:           [ BINDING_WEAK ]
+# CHECK:        GlobalIndex:     0

test/tools/llvm-nm/wasm/exports.yaml

 # RUN: yaml2obj < %s | llvm-nm - | FileCheck -strict-whitespace %s
 
-# That wasm exports of functions and globals are displayed as global data and
-# code symbols.
+# Check that wasm exports of functions/globals/data are displayed correctly
 
 --- !WASM
 FileHeader:
   Version:         0x00000001
 Sections:
   - Type:            TYPE
     Signatures:
       - Index:           0
         ReturnType:      I32
         ParamTypes:
           - I32
-  - Type:            IMPORT
-    Imports:
-      - Module:          env
-        Field:           fimport
-        Kind:            FUNCTION
-        SigIndex:        0
-      - Module:          env
-        Field:           gimport
-        Kind:            GLOBAL
-        GlobalType:      I32
-        GlobalMutable:   false
   - Type:            FUNCTION
-    FunctionTypes: [ 0, 0, 0, 0, 0 ]
+    FunctionTypes: [ 0 ]
   - Type:            GLOBAL
     Globals:
-      - Index:       1
+      - Index:       0
         Type:        I32
         Mutable:     false
         InitExpr:
           Opcode:          I64_CONST
           Value:           32
-      - Index:       2
-        Type:        I32
-        Mutable:     false
-        InitExpr:
-          Opcode:          I32_CONST
-          Value:           64
-      - Index:       3
-        Type:        I32
-        Mutable:     false
-        InitExpr:
-          Opcode:          I32_CONST
-          Value:           1024
-  - Type:            EXPORT
-    Exports:
-      - Name:            foo
-        Kind:            FUNCTION
-        Index:           0x00000004
-      - Name:            bar
-        Kind:            GLOBAL
-        Index:           0x00000003
   - Type:            CODE
     Functions:
-      - Index:           1
-        Locals:
-        Body:            00
-      - Index:           2
-        Locals:
-        Body:            00
-      - Index:           3
-        Locals:
-        Body:            00
-      - Index:           4
-        Locals:
-        Body:            00
-      - Index:           5
+      - Index:           0
         Locals:
         Body:            00
+  - Type:            DATA
+    Segments:
+      - SectionOffset:   6
+        MemoryIndex:     0
+        Offset:
+          Opcode:          I32_CONST
+          Value:           0
+        Content:         '616263'
   - Type:            CUSTOM
-    Name:            "linking"
-    DataSize:        0
+    Name:            linking
+    DataSize:        3
+    SymbolTable:
+       - Index:           0
+         Kind:            FUNCTION
+         Name:            fexport
+         Flags:           [  ]
+         FunctionIndex:   0
+       - Index:           1
+         Kind:            GLOBAL
+         Name:            gexport
+         Flags:           [  ]
+         GlobalIndex:     0
+       - Index:           2
+         Kind:            DATA
+         Name:            dexport
+         Flags:           [  ]
+         SegmentIndex:    0
+         Size:        3
+    SegmentInfo:
+      - Index:           0
+        Name:            .rodata.constantData
+        Alignment:       1
+        Flags:           [  ]
 
-# CHECK:      00000400 D bar
-# CHECK-NEXT:          U fimport
-# CHECK-NEXT: 00000004 T foo
-# CHECK-NEXT:          U gimport
+# CHECK:      00000000 D dexport
+# CHECK-NEXT: 00000000 T fexport
+# CHECK-NEXT: 00000000 D gexport

test/tools/llvm-nm/wasm/imports.yaml

 # RUN: yaml2obj < %s | llvm-nm - | FileCheck -strict-whitespace %s
 
+# Check that wasm import of functions/globals/data are displayed correctly
+
 --- !WASM
 FileHeader:
   Version:         0x00000001
 Sections:
   - Type:            TYPE
     Signatures:
       - Index:           0
         ReturnType:      I32
         ParamTypes:
           - I32
   - Type:            IMPORT
     Imports:
       - Module:          env
-        Field:           foo
+        Field:           fimport
         Kind:            FUNCTION
         SigIndex:        0
       - Module:          env
-        Field:           bar
+        Field:           gimport
         Kind:            GLOBAL
         GlobalType:      I32
         GlobalMutable:   false
   - Type:            CUSTOM
-    Name:            "linking"
-    DataSize:        0
+    Name:            linking
+    DataSize:        3
+    SymbolTable:
+       - Index:           0
+         Kind:            FUNCTION
+         Name:            fimport
+         Flags:           [  ]
+         FunctionIndex:   0
+       - Index:           1
+         Kind:            GLOBAL
+         Name:            gimport
+         Flags:           [  ]
+         GlobalIndex:     0
+       - Index:           2
+         Kind:            DATA
+         Name:            dimport
+         Flags:           [  ]
 
-# CHECK:    U bar
-# CHECK:    U foo
+# CHECK:      U dimport
+# CHECK-NEXT: U fimport
+# CHECK-NEXT: U gimport

test/tools/llvm-nm/wasm/weak-symbols.yaml

 # RUN: yaml2obj < %s | llvm-nm - | FileCheck -strict-whitespace %s
 
-# That wasm exports of functions and globals are displayed as global data and
-# code symbols.
+# Check that wasm weak function/global/data symbols are displayed correctly
 
 --- !WASM
 FileHeader:
   Version:         0x00000001
 Sections:
   - Type:            TYPE
     Signatures:
       - Index:           0
         ReturnType:      I32
         ParamTypes:
           - I32
   - Type:            IMPORT
     Imports:
       - Module:          env
         Field:           weak_import_func
         Kind:            FUNCTION
         SigIndex:        0
       - Module:          env
-        Field:           weak_import_data
+        Field:           weak_import_global
         Kind:            GLOBAL
         GlobalType:      I32
         GlobalMutable:   false
   - Type:            FUNCTION
-    FunctionTypes: [ 0, 0, 0, 0 ]
+    FunctionTypes: [ 0 ]
   - Type:            GLOBAL
     Globals:
       - Index:       1
         Type:        I32
         Mutable:     false
         InitExpr:
           Opcode:          I64_CONST
           Value:           32
-      - Index:       2
-        Type:        I32
-        Mutable:     false
-        InitExpr:
-          Opcode:          I32_CONST
-          Value:           64
-      - Index:       3
-        Type:        I32
-        Mutable:     false
-        InitExpr:
-          Opcode:          I32_CONST
-          Value:           1024
-  - Type:            EXPORT
-    Exports:
-      - Name:            weak_global_func
-        Kind:            FUNCTION
-        Index:           0x00000004
-      - Name:            weak_global_data
-        Kind:            GLOBAL
-        Index:           0x00000003
   - Type:            CODE
     Functions:
       - Index:           1
         Locals:
         Body:            00
-      - Index:           2
-        Locals:
-        Body:            00
-      - Index:           3
-        Locals:
-        Body:            00
-      - Index:           4
-        Locals:
-        Body:            00
+  - Type:            DATA
+    Segments:
+      - SectionOffset:   6
+        MemoryIndex:     0
+        Offset:
+          Opcode:          I32_CONST
+          Value:           0
+        Content:         '616263'
   - Type:            CUSTOM
     Name:            linking
-    DataSize:        0
-    SymbolInfo:
-      - Name:            weak_global_func
+    DataSize:        3
+    SymbolTable:
+       - Index:           0
+         Kind:            DATA
+         Name:            weak_defined_data
          Flags:           [ BINDING_WEAK ]
-      - Name:            weak_global_data
+         SegmentIndex:    0
+         Size:            3
+       - Index:           1
+         Kind:            FUNCTION
+         Name:            weak_defined_func
          Flags:           [ BINDING_WEAK ]
-      - Name:            weak_import_func
+         FunctionIndex:   1
+       - Index:           2
+         Kind:            GLOBAL
+         Name:            weak_defined_global
          Flags:           [ BINDING_WEAK ]
-      - Name:            weak_import_data
+         GlobalIndex:     1
+       - Index:           3
+         Kind:            DATA
+         Name:            weak_import_data
+         Flags:           [ BINDING_WEAK ]
+       - Index:           4
+         Kind:            FUNCTION
+         Name:            weak_import_func
          Flags:           [ BINDING_WEAK ]
+         FunctionIndex:   0
+       - Index:           5
+         Kind:            GLOBAL
+         Name:            weak_import_global
+         Flags:           [ BINDING_WEAK ]
+         GlobalIndex:     0
+    SegmentInfo:
+      - Index:           0
+        Name:            .rodata.constantData
+        Alignment:       1
+        Flags:           [  ]
+
 
-# CHECK: 00000400 W weak_global_data
-# CHECK: 00000004 W weak_global_func
-# CHECK:          w weak_import_data
-# CHECK:          w weak_import_func
+# CHECK:      00000000 W weak_defined_data
+# CHECK-NEXT: 00000001 W weak_defined_func
+# CHECK-NEXT: 00000001 W weak_defined_global
+# CHECK-NEXT:          w weak_import_data
+# CHECK-NEXT:          w weak_import_func
+# CHECK-NEXT:          w weak_import_global

test/tools/llvm-objdump/WebAssembly/symbol-table.test

 RUN: llvm-objdump -t %p/../Inputs/trivial.obj.wasm | FileCheck %s
 
 CHECK:      SYMBOL TABLE:
 CHECK-NEXT: 00000000 g     F IMPORT puts
 CHECK-NEXT: 00000000 g     F IMPORT SomeOtherFunction
-CHECK-NEXT: 00000002 g     F EXPORT main
-CHECK-NEXT: 00000010 g       EXPORT var
-
+CHECK-NEXT: 00000002 g     F CODE main
+CHECK-NEXT: 00000000 l       DATA   .L.str
+CHECK-NEXT: 00000010 g       DATA   var

test/tools/llvm-objdump/wasm.txt

 # RUN: llvm-objdump -h %p/Inputs/trivial.obj.wasm | FileCheck %s
 
 # CHECK:      Sections:
 # CHECK-NEXT: Idx Name          Size      Address          Type
-# CHECK-NEXT:  0 TYPE          0000000e 0000000000000000 
-# CHECK-NEXT:  1 IMPORT        00000024 0000000000000000 
-# CHECK-NEXT:  2 FUNCTION      00000002 0000000000000000 
-# CHECK-NEXT:  3 TABLE         00000004 0000000000000000 
-# CHECK-NEXT:  4 MEMORY        00000003 0000000000000000 
-# CHECK-NEXT:  5 GLOBAL        0000000b 0000000000000000 
-# CHECK-NEXT:  6 EXPORT        0000000e 0000000000000000 
-# CHECK-NEXT:  7 CODE          00000019 0000000000000000 TEXT 
-# CHECK-NEXT:  8 DATA          0000001a 0000000000000000 DATA 
-# CHECK-NEXT:  9 name          0000002b 0000000000000000 
-# CHECK-NEXT: 10 reloc.CODE    00000017 0000000000000000 
-# CHECK-NEXT: 11 linking       00000016 0000000000000000 
+# CHECK-NEXT:  0 TYPE          0000000e 0000000000000000
+# CHECK-NEXT:  1 IMPORT        0000005d 0000000000000000
+# CHECK-NEXT:  2 FUNCTION      00000002 0000000000000000
+# CHECK-NEXT:  3 CODE          00000019 0000000000000000 TEXT
+# CHECK-NEXT:  4 DATA          0000001c 0000000000000000 DATA
+# CHECK-NEXT:  5 reloc.CODE    00000017 0000000000000000
+# CHECK-NEXT:  6 linking       0000005e 0000000000000000
 
 # RUN: llvm-objdump -p %p/Inputs/trivial.obj.wasm | FileCheck %s -check-prefix CHECK-HEADER
 
 # CHECK-HEADER: Program Header:
 # CHECK-HEADER: Version: 0x1
 
 # RUN: llvm-objdump -s --section=CODE %p/Inputs/trivial.obj.wasm | FileCheck %s -check-prefix CHECK-SECTIONS
 
 # CHECK-SECTIONS: Contents of section CODE:
 # CHECK-SECTIONS: 0000 01170041 80808080 00108080 8080001a  ...A............
 # CHECK-SECTIONS: 0010 10818080 80004100 0b                 ......A..

test/tools/llvm-readobj/relocations.test

 MACHO-ARM-NEXT:        Length: 2
 MACHO-ARM-NEXT:        Type: ARM_RELOC_PAIR (1)
 MACHO-ARM-NEXT:        Value: 0x4
 MACHO-ARM-NEXT:      }
 MACHO-ARM-NEXT:    }
 MACHO-ARM-NEXT:  ]
 
 WASM:      Relocations [
-WASM-NEXT:   Section (8) CODE {
+WASM-NEXT:   Section (4) CODE {
 WASM-NEXT:     Relocation {
 WASM-NEXT:       Type: R_WEBASSEMBLY_MEMORY_ADDR_SLEB (4)
 WASM-NEXT:       Offset: 0x4
-WASM-NEXT:       Index: 0x0
+WASM-NEXT:       Index: 0x3
 WASM-NEXT:       Addend: 0
 WASM-NEXT:     }
 WASM-NEXT:     Relocation {
 WASM-NEXT:       Type: R_WEBASSEMBLY_FUNCTION_INDEX_LEB (0)
 WASM-NEXT:       Offset: 0xA
 WASM-NEXT:       Index: 0x0
 WASM-NEXT:     }
 WASM-NEXT:     Relocation {
 WASM-NEXT:       Type: R_WEBASSEMBLY_FUNCTION_INDEX_LEB (0)
 WASM-NEXT:       Offset: 0x11
 WASM-NEXT:       Index: 0x1
 WASM-NEXT:     }
 WASM-NEXT:   }
 WASM-NEXT: ]

test/tools/llvm-readobj/sections.test

 WASM:      Sections [
 WASM-NEXT:   Section {
 WASM-NEXT:     Type: TYPE (0x1)
 WASM-NEXT:     Size: 14
 WASM-NEXT:     Offset: 8
 WASM-NEXT:   }
 WASM-NEXT:   Section {
 WASM-NEXT:     Type: IMPORT (0x2)
-WASM-NEXT:     Size: 36
+WASM-NEXT:     Size: 93
 WASM-NEXT:     Offset: 28
 WASM-NEXT:   }
 WASM-NEXT:   Section {
 WASM-NEXT:     Type: FUNCTION (0x3)
 WASM-NEXT:     Size: 2
-WASM-NEXT:     Offset: 70
-WASM-NEXT:   }
-WASM-NEXT:   Section {
-WASM-NEXT:     Type: TABLE (0x4)
-WASM-NEXT:     Size: 4
-WASM-NEXT:     Offset: 78
-WASM-NEXT:   }
-WASM-NEXT:   Section {
-WASM-NEXT:     Type: MEMORY (0x5)
-WASM-NEXT:     Size: 3
-WASM-NEXT:     Offset: 88
-WASM-NEXT:     Memories [
-WASM-NEXT:       Memory {
-WASM-NEXT:         InitialPages: 1
-WASM-NEXT:       }
-WASM-NEXT:     ]
-WASM-NEXT:   }
-WASM-NEXT:   Section {
-WASM-NEXT:     Type: GLOBAL (0x6)
-WASM-NEXT:     Size: 6
-WASM-NEXT:     Offset: 97
-WASM-NEXT:   }
-WASM-NEXT:   Section {
-WASM-NEXT:     Type: EXPORT (0x7)
-WASM-NEXT:     Size: 8
-WASM-NEXT:     Offset: 109
+WASM-NEXT:     Offset: 127
 WASM-NEXT:   }
 WASM-NEXT:   Section {
 WASM-NEXT:     Type: CODE (0xA)
 WASM-NEXT:     Size: 25
-WASM-NEXT:     Offset: 123
+WASM-NEXT:     Offset: 135
 WASM-NEXT:   }
 WASM-NEXT:   Section {
 WASM-NEXT:     Type: DATA (0xB)
 WASM-NEXT:     Size: 19
-WASM-NEXT:     Offset: 154
+WASM-NEXT:     Offset: 166
 WASM-NEXT:     Segments [
 WASM-NEXT:       Segment {
+WASM-NEXT:         Name: .rodata..L.str
 WASM-NEXT:         Size: 13
 WASM-NEXT:         Offset: 0
 WASM-NEXT:       }
 WASM-NEXT:     ]
 WASM-NEXT:   }
 WASM-NEXT:   Section {
 WASM-NEXT:     Type: CUSTOM (0x0)
-WASM-NEXT:     Size: 43
-WASM-NEXT:     Offset: 179
-WASM-NEXT:     Name: name
-WASM-NEXT:   }
-WASM-NEXT:   Section {
-WASM-NEXT:     Type: CUSTOM (0x0)
 WASM-NEXT:     Size: 23
-WASM-NEXT:     Offset: 228
+WASM-NEXT:     Offset: 191
 WASM-NEXT:     Name: reloc.CODE
 WASM-NEXT:   }
 WASM-NEXT:   Section {
 WASM-NEXT:     Type: CUSTOM (0x0)
-WASM-NEXT:     Size: 22
-WASM-NEXT:     Offset: 257
+WASM-NEXT:     Size: 73
+WASM-NEXT:     Offset: 220
 WASM-NEXT:     Name: linking
 WASM-NEXT:     DataSize: 13
 WASM-NEXT:   }
 WASM-NEXT: ]

test/tools/llvm-readobj/symbols.test

 ELF-NEXT:     Type: Object (0x1)
 ELF-NEXT:     Other: 0
 ELF-NEXT:     Section: .rodata.str1.1 (0x5)
 ELF-NEXT:   }
 
 WASM:      Symbols [
 WASM-NEXT:   Symbol {
 WASM-NEXT:     Name: puts
-WASM-NEXT:     Type: FUNCTION_IMPORT (0x0)
+WASM-NEXT:     Type: FUNCTION (0x0)
 WASM-NEXT:     Flags: 0x0
 WASM-NEXT:   }
 WASM-NEXT:   Symbol {
 WASM-NEXT:     Name: SomeOtherFunction
-WASM-NEXT:     Type: FUNCTION_IMPORT (0x0)
+WASM-NEXT:     Type: FUNCTION (0x0)
 WASM-NEXT:     Flags: 0x0
 WASM-NEXT:   }
 WASM-NEXT:   Symbol {
 WASM-NEXT:     Name: main
-WASM-NEXT:     Type: FUNCTION_EXPORT (0x1)
-WASM-NEXT:     Flags: 0x0
+WASM-NEXT:     Type: FUNCTION (0x0)
+WASM-NEXT:     Flags: 0x100
+WASM-NEXT:   }
+WASM-NEXT:   Symbol {
+WASM-NEXT:     Name: .L.str
+WASM-NEXT:     Type: DATA (0x1)
+WASM-NEXT:     Flags: 0x102
 WASM-NEXT:   }
 WASM-NEXT: ]

tools/llvm-readobj/WasmDumper.cpp

 #include "llvm/Support/ScopedPrinter.h"
 
 using namespace llvm;
 using namespace object;
 
 namespace {
 
 static const EnumEntry<unsigned> WasmSymbolTypes[] = {
-#define ENUM_ENTRY(X) { #X, static_cast<unsigned>(WasmSymbol::SymbolType::X) }
-  ENUM_ENTRY(FUNCTION_IMPORT),
-  ENUM_ENTRY(FUNCTION_EXPORT),
-  ENUM_ENTRY(GLOBAL_IMPORT),
-  ENUM_ENTRY(GLOBAL_EXPORT),
+#define ENUM_ENTRY(X) { #X, wasm::WASM_SYMBOL_TYPE_##X }
+  ENUM_ENTRY(FUNCTION),
+  ENUM_ENTRY(DATA),
+  ENUM_ENTRY(GLOBAL),
 #undef ENUM_ENTRY
 };
 
 static const EnumEntry<uint32_t> WasmSectionTypes[] = {
 #define ENUM_ENTRY(X) { #X, wasm::WASM_SEC_##X }
   ENUM_ENTRY(CUSTOM),
   ENUM_ENTRY(TYPE),
   ENUM_ENTRY(IMPORT),
if (opts::SectionData) {
       W.printBinaryBlock("SectionData", WasmSec.Content);
     }
   }
 }
 
 void WasmDumper::printSymbol(const SymbolRef &Sym) {
   DictScope D(W, "Symbol");
   WasmSymbol Symbol = Obj->getWasmSymbol(Sym.getRawDataRefImpl());
-  W.printString("Name", Symbol.Name);
-  W.printEnum("Type", static_cast<unsigned>(Symbol.Type), makeArrayRef(WasmSymbolTypes));
-  W.printHex("Flags", Symbol.Flags);
+  W.printString("Name", Symbol.Info.Name);
+  W.printEnum("Type", Symbol.Info.Kind, makeArrayRef(WasmSymbolTypes));
+  W.printHex("Flags", Symbol.Info.Flags);
 }
 
 }
 
 namespace llvm {
 
 std::error_code createWasmDumper(const object::ObjectFile *Obj,
                                  ScopedPrinter &Writer,

tools/obj2yaml/wasm2yaml.cpp

for (const object::WasmSegment &Segment : Obj.dataSegments()) {
       }
       if (!Segment.Data.Comdat.empty()) {
         auto &Comdat = LinkingSec->Comdats[ComdatIndexes[Segment.Data.Comdat]];
         Comdat.Entries.emplace_back(
             WasmYAML::ComdatEntry{wasm::WASM_COMDAT_DATA, SegmentIndex});
       }
       SegmentIndex++;
     }
-    for (const object::SymbolRef& Sym: Obj.symbols()) {
-      const object::WasmSymbol Symbol = Obj.getWasmSymbol(Sym);
-      if (Symbol.Flags != 0) {
-        WasmYAML::SymbolInfo Info{Symbol.Name, Symbol.Flags};
-        LinkingSec->SymbolInfos.emplace_back(Info);
+    uint32_t SymbolIndex = 0;
+    for (const wasm::WasmSymbolInfo &Symbol: Obj.linkingData().SymbolTable) {
+      WasmYAML::SymbolInfo Info;
+      Info.Index = SymbolIndex++;
+      Info.Kind = static_cast<uint32_t>(Symbol.Kind);
+      Info.Name = Symbol.Name;
+      Info.Flags = Symbol.Flags;
+      switch (Symbol.Kind) {
+      case wasm::WASM_SYMBOL_TYPE_DATA:
+        if (Symbol.Segment.hasValue()) {
+          Info.Segment.Segment =
+              static_cast<int32_t>(Symbol.Segment.getValue().Segment);
+          Info.Segment.Offset = Symbol.Segment.getValue().Offset;
+          Info.Segment.Size = Symbol.Segment.getValue().Size;
+        } else {
+          Info.Segment.Segment = -1;
+          Info.Segment.Offset = 0;
+          Info.Segment.Size = 0;
+        }
+        break;
+      case wasm::WASM_SYMBOL_TYPE_FUNCTION:
+        Info.FunctionIndex = Symbol.ElementIndex;
+        break;
+      case wasm::WASM_SYMBOL_TYPE_GLOBAL:
+        Info.GlobalIndex = Symbol.ElementIndex;
+        break;
       }
+      LinkingSec->SymbolTable.emplace_back(Info);
     }
     LinkingSec->DataSize = Obj.linkingData().DataSize;
     for (const wasm::WasmInitFunc &Func : Obj.linkingData().InitFunctions) {
       WasmYAML::InitFunction F{Func.Priority, Func.Symbol};
       LinkingSec->InitFunctions.emplace_back(F);
     }
     CustomSec = std::move(LinkingSec);
   } else {

tools/yaml2obj/yaml2wasm.cpp

 //===- 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 "llvm/ObjectYAML/ObjectYAML.h"
 #include "llvm/Support/Endian.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.
int WasmWriter::writeSectionContent(raw_ostream &OS, WasmYAML::LinkingSection &Section) {
 
   SubSectionWriter SubSection(OS);
 
   // DATA_SIZE subsection
   encodeULEB128(wasm::WASM_DATA_SIZE, OS);
   encodeULEB128(Section.DataSize, SubSection.GetStream());
   SubSection.Done();
 
-  // SYMBOL_INFO subsection
-  if (Section.SymbolInfos.size()) {
-    encodeULEB128(wasm::WASM_SYMBOL_INFO, OS);
-
-    encodeULEB128(Section.SymbolInfos.size(), SubSection.GetStream());
-    for (const WasmYAML::SymbolInfo &Info : Section.SymbolInfos) {
+  // SYMBOL_TABLE subsection
+  if (Section.SymbolTable.size()) {
+    encodeULEB128(wasm::WASM_SYMBOL_TABLE, OS);
+
+    encodeULEB128(Section.SymbolTable.size(), SubSection.GetStream());
+    uint32_t SymbolIndex = 0;
+    (void)SymbolIndex;
+    for (const WasmYAML::SymbolInfo &Info : Section.SymbolTable) {
+      assert(Info.Index == SymbolIndex++);
+      encodeULEB128(Info.Kind, SubSection.GetStream());
+      encodeULEB128(Info.Flags & ~wasm::WASM_SYMBOL_OBJECT_MASK,
+                    SubSection.GetStream());
+      switch (Info.Kind) {
+      case wasm::WASM_SYMBOL_TYPE_FUNCTION:
+        encodeULEB128(Info.FunctionIndex, SubSection.GetStream());
+        if (Info.FunctionIndex >= NumImportedFunctions)
+          writeStringRef(Info.Name, SubSection.GetStream());
+        break;
+      case wasm::WASM_SYMBOL_TYPE_GLOBAL:
+        encodeULEB128(Info.GlobalIndex, SubSection.GetStream());
+        if (Info.GlobalIndex >= NumImportedGlobals)
+          writeStringRef(Info.Name, SubSection.GetStream());
+        break;
+      case wasm::WASM_SYMBOL_TYPE_DATA:
         writeStringRef(Info.Name, SubSection.GetStream());
-      encodeULEB128(Info.Flags, SubSection.GetStream());
+        SubSection.GetStream() <<
+            static_cast<uint8_t>(Info.Segment.Segment >= 0);
+        if (Info.Segment.Segment >= 0) {
+          encodeULEB128(static_cast<uint32_t>(Info.Segment.Segment),
+                        SubSection.GetStream());
+          encodeULEB128(Info.Segment.Offset, SubSection.GetStream());
+          encodeULEB128(Info.Segment.Size, SubSection.GetStream());
+        }
+        break;
+      default:
+        llvm_unreachable("unexpected kind");
+      }
     }
 
     SubSection.Done();
   }
 
   // SEGMENT_NAMES subsection
   if (Section.SegmentInfos.size()) {
     encodeULEB128(wasm::WASM_SEGMENT_INFO, OS);