[WebAssembly] Explicitly specify function/global index space in YAML

[sbc100]

Summary

These indexes are useful because they are not always zero based and functions and
globals are referenced elsewhere by their index.

This matches what we already do for the type index space.

[sbc100]

lld-side change: https://reviews.llvm.org/D41878

include/llvm/BinaryFormat/Wasm.h

union {
     int64_t Int64;
     int32_t Float32;
     int64_t Float64;
     uint32_t Global;
   } Value;
 };
 
 struct WasmGlobal {
+  uint32_t Index;
   int32_t Type;
   bool Mutable;
   WasmInitExpr InitExpr;
 };
 
 struct WasmImport {
   StringRef Module;
   StringRef Field;
   uint32_t Kind;
   union {
     uint32_t SigIndex;
     WasmGlobal Global;
     WasmTable Table;
     WasmLimits Memory;
   };
 };
 
 struct WasmLocalDecl {
   int32_t Type;
   uint32_t Count;
 };
 
 struct WasmFunction {
+  uint32_t Index;
   std::vector<WasmLocalDecl> Locals;
   ArrayRef<uint8_t> Body;
   uint32_t CodeSectionOffset;
   uint32_t Size;
 };
 
 struct WasmDataSegment {
   uint32_t MemoryIndex;

include/llvm/ObjectYAML/WasmYAML.h

 
 struct ElemSegment {
   uint32_t TableIndex;
   wasm::WasmInitExpr Offset;
   std::vector<uint32_t> Functions;
 };
 
 struct Global {
+  uint32_t Index;
   ValueType Type;
   bool Mutable;
   wasm::WasmInitExpr InitExpr;
 };
 
 struct Import {
   StringRef Module;
   StringRef Field;
   ExportKind Kind;
   union {
     uint32_t SigIndex;
     Global GlobalImport;
     Table TableImport;
     Limits Memory;
   };
 };
 
 struct LocalDecl {
   ValueType Type;
   uint32_t Count;
 };
 
 struct Function {
+  uint32_t Index;
   std::vector<LocalDecl> Locals;
   yaml::BinaryRef Body;
 };
 
 struct Relocation {
   RelocType Type;
   uint32_t Index;
   yaml::Hex32 Offset;

lib/Object/WasmObjectFile.cpp

Error WasmObjectFile::parseMemorySection(const uint8_t *Ptr, const uint8_t *End) {
   return Error::success();
 }
 
 Error WasmObjectFile::parseGlobalSection(const uint8_t *Ptr, const uint8_t *End) {
   uint32_t Count = readVaruint32(Ptr);
   Globals.reserve(Count);
   while (Count--) {
     wasm::WasmGlobal Global;
+    Global.Index = NumImportedGlobals + Globals.size();
     Global.Type = readVarint7(Ptr);
     Global.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",
Error WasmObjectFile::parseCodeSection(const uint8_t *Ptr, const uint8_t *End) {
   }
 
   while (FunctionCount--) {
     wasm::WasmFunction Function;
     const uint8_t *FunctionStart = Ptr;
     uint32_t Size = readVaruint32(Ptr);
     const uint8_t *FunctionEnd = Ptr + Size;
 
+    Function.Index = NumImportedFunctions + Functions.size();
     Function.CodeSectionOffset = FunctionStart - CodeSectionStart;
     Function.Size = FunctionEnd - FunctionStart;
 
     uint32_t NumLocalDecls = readVaruint32(Ptr);
     Function.Locals.reserve(NumLocalDecls);
     while (NumLocalDecls--) {
       wasm::WasmLocalDecl Decl;
       Decl.Count = readVaruint32(Ptr);
uint64_t WasmObjectFile::getWasmSymbolValue(const WasmSymbol& Sym) const {
   case WasmSymbol::SymbolType::FUNCTION_IMPORT:
   case WasmSymbol::SymbolType::GLOBAL_IMPORT:
   case WasmSymbol::SymbolType::FUNCTION_EXPORT:
   case WasmSymbol::SymbolType::DEBUG_FUNCTION_NAME:
     return Sym.ElementIndex;
   case WasmSymbol::SymbolType::GLOBAL_EXPORT: {
     uint32_t GlobalIndex = Sym.ElementIndex - NumImportedGlobals;
     assert(GlobalIndex < Globals.size());
-    const wasm::WasmGlobal& Global = Globals[GlobalIndex];
+    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;
   }
   }
   llvm_unreachable("invalid symbol type");
 }
 

lib/ObjectYAML/WasmYAML.cpp

#define ECase(X) IO.enumCase(Type, #X, wasm::WASM_SEC_##X);
   ECase(ELEM);
   ECase(CODE);
   ECase(DATA);
 #undef ECase
 }
 
 void MappingTraits<WasmYAML::Signature>::mapping(
     IO &IO, WasmYAML::Signature &Signature) {
-  IO.mapOptional("Index", Signature.Index);
+  IO.mapRequired("Index", Signature.Index);
   IO.mapRequired("ReturnType", Signature.ReturnType);
   IO.mapRequired("ParamTypes", Signature.ParamTypes);
 }
 
 void MappingTraits<WasmYAML::Table>::mapping(IO &IO, WasmYAML::Table &Table) {
   IO.mapRequired("ElemType", Table.ElemType);
   IO.mapRequired("Limits", Table.TableLimits);
 }
 
 void MappingTraits<WasmYAML::Function>::mapping(IO &IO,
                                                 WasmYAML::Function &Function) {
+  IO.mapRequired("Index", Function.Index);
   IO.mapRequired("Locals", Function.Locals);
   IO.mapRequired("Body", Function.Body);
 }
 
 void MappingTraits<WasmYAML::Relocation>::mapping(
     IO &IO, WasmYAML::Relocation &Relocation) {
   IO.mapRequired("Type", Relocation.Type);
   IO.mapRequired("Index", Relocation.Index);
void MappingTraits<WasmYAML::Export>::mapping(IO &IO,
                                               WasmYAML::Export &Export) {
   IO.mapRequired("Name", Export.Name);
   IO.mapRequired("Kind", Export.Kind);
   IO.mapRequired("Index", Export.Index);
 }
 
 void MappingTraits<WasmYAML::Global>::mapping(IO &IO,
                                               WasmYAML::Global &Global) {
+  IO.mapRequired("Index", Global.Index);
   IO.mapRequired("Type", Global.Type);
   IO.mapRequired("Mutable", Global.Mutable);
   IO.mapRequired("InitExpr", Global.InitExpr);
 }
 
 void MappingTraits<wasm::WasmInitExpr>::mapping(IO &IO,
                                                 wasm::WasmInitExpr &Expr) {
   WasmYAML::Opcode Op = Expr.Opcode;

test/MC/WebAssembly/bss.ll

 ; RUN: llc -mtriple wasm32-unknown-unknown-wasm -filetype=obj %s -o - | obj2yaml | FileCheck %s
 
 @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:       - Type:            I32
+; 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:            I32
+; 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:       - Type:            I32
+; 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:       - Type:            I32
+; 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

test/MC/WebAssembly/explicit-sections.ll

 ; RUN: llc -mtriple wasm32-unknown-unknown-wasm -filetype=obj %s -o - | obj2yaml | FileCheck %s
 
 %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:       - Type:            I32
+; 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:            I32
+; 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:       - Type:            I32
+; 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:       - Type:            I32
+; 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

test/MC/WebAssembly/init-fini-array.ll

 ; 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:       - Type:            I32
+; 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:         Offset:          0x00000037
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_SLEB
 ; CHECK-NEXT:         Index:           0
 ; CHECK-NEXT:         Offset:          0x0000003F
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_FUNCTION_INDEX_LEB
 ; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x00000045
 ; CHECK-NEXT:     Functions:       
-; CHECK-NEXT:       - Locals:          
+; CHECK-NEXT:       - Index:           5
+; CHECK-NEXT:         Locals:          
 ; CHECK-NEXT:         Body:            1080808080000B
-; CHECK-NEXT:       - Locals:          
+; CHECK-NEXT:       - Index:           6
+; CHECK-NEXT:         Locals:          
 ; CHECK-NEXT:         Body:            0240418080808000410041FFFFFFFF7F1081808080000D000F0B00000B
-; CHECK-NEXT:       - Locals:          
+; CHECK-NEXT:       - Index:           7
+; CHECK-NEXT:         Locals:          
 ; CHECK-NEXT:         Body:            1082808080000B
-; CHECK-NEXT:       - Locals:          
+; CHECK-NEXT:       - Index:           8
+; CHECK-NEXT:         Locals:          
 ; CHECK-NEXT:         Body:            0240418180808000410041FFFFFFFF7F1081808080000D000F0B00000B
 ; CHECK-NEXT:   - 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

test/MC/WebAssembly/unnamed-data.ll

 ; RUN: llc -mtriple wasm32-unknown-unknown-wasm -filetype=obj %s -o - | obj2yaml | FileCheck %s
 
 @.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:       - Type:            I32
+; 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:            I32
+; 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:       - Type:            I32
+; 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:       - Type:            I32
+; 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

test/MC/WebAssembly/weak-alias.ll

 ; CHECK-NEXT:         Field:           bar_alias
 ; CHECK-NEXT:         Kind:            GLOBAL
 ; CHECK-NEXT:         GlobalType:      I32
 ; CHECK-NEXT:         GlobalMutable:   false
 ; CHECK-NEXT:   - Type:            FUNCTION
 ; CHECK-NEXT:     FunctionTypes:   [ 0, 0, 0, 0, 0 ]
 ; CHECK-NEXT:   - Type:            GLOBAL
 ; CHECK-NEXT:     Globals:         
-; CHECK-NEXT:       - Type:            I32
+; 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:       - Type:            I32
+; 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:       - Type:            I32
+; CHECK-NEXT:       - Index:           3
+; 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:         Offset:          0x00000024
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
 ; CHECK-NEXT:         Index:           2
 ; CHECK-NEXT:         Offset:          0x00000031
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_TYPE_INDEX_LEB
 ; CHECK-NEXT:         Index:           0
 ; CHECK-NEXT:         Offset:          0x00000037
 ; CHECK-NEXT:     Functions:       
-; CHECK-NEXT:       - Locals:          
+; CHECK-NEXT:       - Index:           1
+; CHECK-NEXT:         Locals:          
 ; CHECK-NEXT:         Body:            41000B
-; CHECK-NEXT:       - Locals:          
+; CHECK-NEXT:       - Index:           2
+; CHECK-NEXT:         Locals:          
 ; CHECK-NEXT:         Body:            1081808080000B
-; CHECK-NEXT:       - Locals:          
+; CHECK-NEXT:       - Index:           3
+; CHECK-NEXT:         Locals:          
 ; CHECK-NEXT:         Body:            1080808080000B
-; CHECK-NEXT:       - Locals:          
+; CHECK-NEXT:       - Index:           4
+; CHECK-NEXT:         Locals:          
 ; CHECK-NEXT:         Body:            410028028880808000118080808000000B
-; CHECK-NEXT:       - Locals:          
+; CHECK-NEXT:       - Index:           5
+; CHECK-NEXT:         Locals:          
 ; CHECK-NEXT:         Body:            410028029080808000118080808000000B
 ; CHECK-NEXT:   - Type:            DATA
 ; CHECK-NEXT:     Relocations:     
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_TABLE_INDEX_I32
 ; CHECK-NEXT:         Index:           0
 ; CHECK-NEXT:         Offset:          0x0000000F
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_TABLE_INDEX_I32
 ; CHECK-NEXT:         Index:           1

test/ObjectYAML/wasm/code_section.yaml

 # RUN: yaml2obj %s | obj2yaml | FileCheck %s
 --- !WASM
 FileHeader:
   Version:         0x00000001
 Sections:
   - Type:            TYPE
     Signatures:
-      - ReturnType:      F32
+      - Index:           0
+        ReturnType:      F32
         ParamTypes:
           - I32
-      - ReturnType:      NORESULT
+      - Index:           1
+        ReturnType:      NORESULT
         ParamTypes:
           - I32
           - I64
   - Type:            FUNCTION
     FunctionTypes:
       - 0
       - 1
   - Type:            CODE
     Relocations:
       - Type:            R_WEBASSEMBLY_TABLE_INDEX_SLEB
         Index:           0
         Offset:          0x00000006
       - Type:            R_WEBASSEMBLY_FUNCTION_INDEX_LEB
         Index:           1
         Offset:          0x00000025
     Functions:
-      - Locals:
+      - Index:              0
+        Locals:
          - Type:            I32
            Count:           3
         Body:            418080808000210020002101200111808080800000210220020F0B
-      - Locals:
+      - Index:              1
+        Locals:
          - Type:            I32
            Count:           1
         Body:            108180808000210020000F0B
 ...
 # CHECK: --- !WASM
 # CHECK: FileHeader:
 # CHECK:   Version:           0x00000001
 # CHECK: Sections:

 # CHECK:    Relocations:
 # CHECK:      - Type:            R_WEBASSEMBLY_TABLE_INDEX_SLEB
 # CHECK:        Index:           0
 # CHECK:        Offset:          0x00000006
 # CHECK:      - Type:            R_WEBASSEMBLY_FUNCTION_INDEX_LEB
 # CHECK:        Index:           1
 # CHECK:        Offset:          0x00000025
 # CHECK:    Functions:
-# CHECK:      - Locals:
+# CHECK:      - Index:              0
+# CHECK:        Locals:
 # CHECK:         - Type:            I32
 # CHECK:           Count:           3
 # CHECK:        Body:            418080808000210020002101200111808080800000210220020F0B
-# CHECK:      - Locals:
+# CHECK:      - Index:              1
+# CHECK:        Locals:
 # CHECK:         - Type:            I32
 # CHECK:           Count:           1
 # CHECK:        Body:            108180808000210020000F0B

test/ObjectYAML/wasm/export_section.yaml

 # RUN: yaml2obj %s | obj2yaml | FileCheck %s
 --- !WASM
 FileHeader:
   Version:         0x00000001
 Sections:
   - Type:            FUNCTION
     FunctionTypes: [ 0, 0 ]
   - Type:            GLOBAL
     Globals:
-      - Type:        I32
+      - Index:       0
+        Type:        I32
         Mutable:     false
         InitExpr:
           Opcode:          I64_CONST
           Value:           32
-      - Type:        I32
+      - Index:       1
+        Type:        I32
         Mutable:     false
         InitExpr:
           Opcode:          I64_CONST
           Value:           64
   - Type:            EXPORT
     Exports:         
       - Name:            function_export
         Kind:            FUNCTION

test/ObjectYAML/wasm/global_section.yaml

 # RUN: yaml2obj %s | obj2yaml | FileCheck %s
 --- !WASM
 FileHeader:
   Version:         0x00000001
 Sections:
   - Type:            GLOBAL
     Globals:         
-      - Type:        I32
+      - Index:       0
+        Type:        I32
         Mutable:     false
         InitExpr:
           Opcode:          I64_CONST
           Value:           -5
 ...
 # CHECK: --- !WASM
 # CHECK: FileHeader:
 # CHECK:   Version:           0x00000001
 # CHECK: Sections:
 # CHECK:  - Type:            GLOBAL
 # CHECK:    Globals:         
-# CHECK:      - Type:        I32
+# CHECK:      - Index:       0
+# CHECK:        Type:        I32
 # CHECK:        Mutable:     false
 # CHECK:        InitExpr:
 # CHECK:          Opcode:          I64_CONST
 # CHECK:          Value:           -5
 # CHECK: ...

test/ObjectYAML/wasm/import_section.yaml

 # RUN: yaml2obj %s | obj2yaml | FileCheck %s
 --- !WASM
 FileHeader:
   Version:         0x00000001
 Sections:
   - Type:            TYPE
     Signatures:
-      - ReturnType:      I32
+      - Index:           0
+        ReturnType:      I32
         ParamTypes:
           - I32
   - Type:            IMPORT
     Imports:
       - Module:          foo
         Field:           imported_function
         Kind:            FUNCTION
         SigIndex:        0

test/ObjectYAML/wasm/linking_section.yaml

 # RUN: yaml2obj %s | obj2yaml | FileCheck %s
 --- !WASM
 FileHeader:
   Version:         0x00000001
 Sections:
   - Type:            TYPE
     Signatures:
-      - ReturnType:      I32
+      - Index:           0
+        ReturnType:      I32
         ParamTypes:
           - I32
   - Type:            IMPORT
     Imports:
       - Module:          foo
         Field:           bar
         Kind:            FUNCTION
         SigIndex:        0

test/ObjectYAML/wasm/name_section.yaml

 # RUN: yaml2obj %s | obj2yaml | FileCheck %s
 --- !WASM
 FileHeader:
   Version:         0x00000001
 Sections:
   - Type:            TYPE
     Signatures:
-      - ReturnType:      I32
+      - Index:           0
+        ReturnType:      I32
         ParamTypes:
           - I32
   - Type:            IMPORT
     Imports:
       - Module:          foo
         Field:           a
         Kind:            FUNCTION
         SigIndex:        0

test/ObjectYAML/wasm/start_section.yaml

 # RUN: yaml2obj %s | obj2yaml | FileCheck %s
 
 --- !WASM
 FileHeader:
   Version:         0x00000001
 Sections:
   - Type:            TYPE
     Signatures:
-      - ReturnType:      I32
+      - Index:           0
+        ReturnType:      I32
         ParamTypes:
           - F32
           - F32
   - Type:            FUNCTION
     FunctionTypes: [ 0, 0, 0 ]
   - Type:            START
     StartFunction:   1
 ...
 # CHECK: --- !WASM
 # CHECK: FileHeader:
 # CHECK:   Version:           0x00000001
 # CHECK: Sections:
 # CHECK:  - Type:            START
 # CHECK:    StartFunction:   1
 # CHECK: ...

test/ObjectYAML/wasm/type_section.yaml

 # RUN: yaml2obj %s | obj2yaml | FileCheck %s
 --- !WASM
 FileHeader:
   Version:         0x00000001
 Sections:
   - Type:            TYPE
     Signatures:
-      - ReturnType:      I32
+      - Index:           0
+        ReturnType:      I32
         ParamTypes:
           - F32
           - F32
-      - ReturnType:      I64
+      - Index:           1
+        ReturnType:      I64
         ParamTypes:
           - F64
           - F64
 ...
 # CHECK: --- !WASM
 # CHECK: FileHeader:
 # CHECK:   Version:           0x00000001
 # CHECK: Sections:

test/ObjectYAML/wasm/weak_symbols.yaml

 # RUN: yaml2obj %s | obj2yaml | FileCheck %s
 --- !WASM
 FileHeader:
   Version:         0x00000001
 Sections:
   - Type:            TYPE
     Signatures:
-      - ReturnType:      I32
+      - Index:           0
+        ReturnType:      I32
         ParamTypes:
   - Type:            FUNCTION
     FunctionTypes:   [ 0, 0 ]
   - Type:            GLOBAL
     Globals:         
-      - Type:        I32
+      - Index:       0
+        Type:        I32
         Mutable:     false
         InitExpr:
           Opcode:          I32_CONST
           Value:           1
   - Type:            EXPORT
     Exports:         
       - Name:            function_export
         Kind:            FUNCTION

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.
 
 --- !WASM
 FileHeader:
   Version:         0x00000001
 Sections:
   - Type:            TYPE
     Signatures:
-      - ReturnType:      I32
+      - 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 ]
   - Type:            GLOBAL
     Globals:
-      - Type:        I32
+      - Index:       1
+        Type:        I32
         Mutable:     false
         InitExpr:
           Opcode:          I64_CONST
           Value:           32
-      - Type:        I32
+      - Index:       2
+        Type:        I32
         Mutable:     false
         InitExpr:
           Opcode:          I32_CONST
           Value:           64
-      - Type:        I32
+      - Index:       3
+        Type:        I32
         Mutable:     false
         InitExpr:
           Opcode:          I32_CONST
           Value:           1024
-  - Type:            IMPORT
-    Imports:
-      - Module:          env
-        Field:           fimport
-        Kind:            FUNCTION
-        SigIndex:        0
-      - Module:          env
-        Field:           gimport
-        Kind:            GLOBAL
-        GlobalType:      I32
-        GlobalMutable:   false
   - Type:            EXPORT
     Exports:
       - Name:            foo
         Kind:            FUNCTION
         Index:           0x00000004
       - Name:            bar
         Kind:            GLOBAL
         Index:           0x00000003
   - Type:            CUSTOM
     Name:            "linking"
     DataSize:        0
 
 # CHECK:      00000400 D bar
 # CHECK-NEXT:          U fimport
 # CHECK-NEXT: 00000004 T foo
 # CHECK-NEXT:          U gimport

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

 # RUN: yaml2obj < %s | llvm-nm - | FileCheck -strict-whitespace %s
 
 --- !WASM
 FileHeader:
   Version:         0x00000001
 Sections:
   - Type:            TYPE
     Signatures:
-      - ReturnType:      I32
+      - Index:           0
+        ReturnType:      I32
         ParamTypes:
           - I32
   - Type:            IMPORT
     Imports:
       - Module:          env
         Field:           foo
         Kind:            FUNCTION
         SigIndex:        0

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.
 
 --- !WASM
 FileHeader:
   Version:         0x00000001
 Sections:
   - Type:            TYPE
     Signatures:
-      - ReturnType:      I32
+      - Index:           0
+        ReturnType:      I32
         ParamTypes:
           - I32
-  - Type:            FUNCTION
-    FunctionTypes: [ 0, 0, 0, 0 ]
   - Type:            IMPORT
     Imports:
       - Module:          env
         Field:           weak_import_func
         Kind:            FUNCTION
         SigIndex:        0
       - Module:          env
         Field:           weak_import_data
         Kind:            GLOBAL
         GlobalType:      I32
         GlobalMutable:   false
+  - Type:            FUNCTION
+    FunctionTypes: [ 0, 0, 0, 0 ]
   - Type:            GLOBAL
     Globals:
-      - Type:        I32
+      - Index:       1
+        Type:        I32
         Mutable:     false
         InitExpr:
           Opcode:          I64_CONST
           Value:           32
-      - Type:        I32
+      - Index:       2
+        Type:        I32
         Mutable:     false
         InitExpr:
           Opcode:          I32_CONST
           Value:           64
-      - Type:        I32
+      - Index:       3
+        Type:        I32
         Mutable:     false
         InitExpr:
           Opcode:          I32_CONST
           Value:           1024
   - Type:            EXPORT
     Exports:
       - Name:            weak_global_func
         Kind:            FUNCTION

tools/obj2yaml/wasm2yaml.cpp

case wasm::WASM_SEC_MEMORY: {
       }
       S = std::move(MemorySec);
       break;
     }
     case wasm::WASM_SEC_GLOBAL: {
       auto GlobalSec = make_unique<WasmYAML::GlobalSection>();
       for (auto &Global : Obj.globals()) {
         WasmYAML::Global G;
+        G.Index = Global.Index;
         G.Type = Global.Type;
         G.Mutable = Global.Mutable;
         G.InitExpr = Global.InitExpr;
         GlobalSec->Globals.push_back(G);
       }
       S = std::move(GlobalSec);
       break;
     }
case wasm::WASM_SEC_ELEM: {
       }
       S = std::move(ElemSec);
       break;
     }
     case wasm::WASM_SEC_CODE: {
       auto CodeSec = make_unique<WasmYAML::CodeSection>();
       for (auto &Func : Obj.functions()) {
         WasmYAML::Function Function;
+        Function.Index = Func.Index;
         for (auto &Local : Func.Locals) {
           WasmYAML::LocalDecl LocalDecl;
           LocalDecl.Type = Local.Type;
           LocalDecl.Count = Local.Count;
           Function.Locals.push_back(LocalDecl);
         }
         Function.Body = yaml::BinaryRef(Func.Body);
         CodeSec->Functions.push_back(Function);

tools/yaml2obj/yaml2wasm.cpp

private:
   int writeSectionContent(raw_ostream &OS, WasmYAML::ElemSection &Section);
   int writeSectionContent(raw_ostream &OS, WasmYAML::CodeSection &Section);
   int writeSectionContent(raw_ostream &OS, WasmYAML::DataSection &Section);
 
   // Custom section types
   int writeSectionContent(raw_ostream &OS, WasmYAML::NameSection &Section);
   int writeSectionContent(raw_ostream &OS, WasmYAML::LinkingSection &Section);
   WasmYAML::Object &Obj;
+  uint32_t NumImportedFunctions = 0;
+  uint32_t NumImportedGlobals = 0;
 };
 
 static int writeUint64(raw_ostream &OS, uint64_t Value) {
   char Data[sizeof(Value)];
   support::endian::write64le(Data, Value);
   OS.write(Data, sizeof(Data));
   return 0;
 }
case wasm::WASM_OPCODE_F32_CONST:
     break;
   case wasm::WASM_OPCODE_F64_CONST:
     writeUint64(OS, InitExpr.Value.Float64);
     break;
   case wasm::WASM_OPCODE_GET_GLOBAL:
     encodeULEB128(InitExpr.Value.Global, OS);
     break;
   default:
-    errs() << "Unknown opcode in init_expr: " << InitExpr.Opcode;
+    errs() << "Unknown opcode in init_expr: " << InitExpr.Opcode << "\n";
     return 1;
   }
   writeUint8(OS, wasm::WASM_OPCODE_END);
   return 0;
 }
 
 class SubSectionWriter {
   raw_ostream &OS;
if (auto S = dyn_cast<WasmYAML::NameSection>(&Section)) {
     Section.Payload.writeAsBinary(OS);
   }
   return 0;
 }
 
 int WasmWriter::writeSectionContent(raw_ostream &OS,
                                     WasmYAML::TypeSection &Section) {
   encodeULEB128(Section.Signatures.size(), OS);
+  uint32_t ExpectedIndex = 0;
   for (const WasmYAML::Signature &Sig : Section.Signatures) {
+    if (Sig.Index != ExpectedIndex) {
+      errs() << "Unexpected type index: " << Sig.Index << "\n";
+      return 1;
+    }
+    ++ExpectedIndex;
     encodeSLEB128(Sig.Form, OS);
     encodeULEB128(Sig.ParamTypes.size(), OS);
     for (auto ParamType : Sig.ParamTypes)
       encodeSLEB128(ParamType, OS);
     if (Sig.ReturnType == wasm::WASM_TYPE_NORESULT) {
       encodeSLEB128(0, OS);
     } else {
       encodeULEB128(1, OS);
       encodeSLEB128(Sig.ReturnType, OS);
     }
   }
   return 0;
 }
 
 int WasmWriter::writeSectionContent(raw_ostream &OS,
                                     WasmYAML::ImportSection &Section) {
   encodeULEB128(Section.Imports.size(), OS);
   for (const WasmYAML::Import &Import : Section.Imports) {
     writeStringRef(Import.Module, OS);
     writeStringRef(Import.Field, OS);
     encodeULEB128(Import.Kind, OS);
     switch (Import.Kind) {
     case wasm::WASM_EXTERNAL_FUNCTION:
       encodeULEB128(Import.SigIndex, OS);
+      NumImportedFunctions++;
       break;
     case wasm::WASM_EXTERNAL_GLOBAL:
       encodeSLEB128(Import.GlobalImport.Type, OS);
       writeUint8(OS, Import.GlobalImport.Mutable);
+      NumImportedGlobals++;
       break;
     case wasm::WASM_EXTERNAL_MEMORY:
       writeLimits(Import.Memory, OS);
       break;
     case wasm::WASM_EXTERNAL_TABLE:
       encodeSLEB128(Import.TableImport.ElemType, OS);
       writeLimits(Import.TableImport.TableLimits, OS);
       break;
     default:
-      errs() << "Unknown import type: " << Import.Kind;
+      errs() << "Unknown import type: " << Import.Kind << "\n";
       return 1;
     }
   }
   return 0;
 }
 
 int WasmWriter::writeSectionContent(raw_ostream &OS,
                                     WasmYAML::FunctionSection &Section) {
for (const WasmYAML::Limits &Mem : Section.Memories) {
     writeLimits(Mem, OS);
   }
   return 0;
 }
 
 int WasmWriter::writeSectionContent(raw_ostream &OS,
                                     WasmYAML::GlobalSection &Section) {
   encodeULEB128(Section.Globals.size(), OS);
+  uint32_t ExpectedIndex = NumImportedGlobals;
   for (auto &Global : Section.Globals) {
+    if (Global.Index != ExpectedIndex) {
+      errs() << "Unexpected global index: " << Global.Index << "\n";
+      return 1;
+    }
+    ++ExpectedIndex;
     encodeSLEB128(Global.Type, OS);
     writeUint8(OS, Global.Mutable);
     writeInitExpr(Global.InitExpr, OS);
   }
   return 0;
 }
 
 int WasmWriter::writeSectionContent(raw_ostream &OS,
for (auto &Segment : Section.Segments) {
     }
   }
   return 0;
 }
 
 int WasmWriter::writeSectionContent(raw_ostream &OS,
                                     WasmYAML::CodeSection &Section) {
   encodeULEB128(Section.Functions.size(), OS);
+  uint32_t ExpectedIndex = NumImportedFunctions;
   for (auto &Func : Section.Functions) {
     std::string OutString;
     raw_string_ostream StringStream(OutString);
+    if (Func.Index != ExpectedIndex) {
+      errs() << "Unexpected function index: " << Func.Index << "\n";
+      return 1;
+    }
+    ++ExpectedIndex;
 
     encodeULEB128(Func.Locals.size(), StringStream);
     for (auto &LocalDecl : Func.Locals) {
       encodeULEB128(LocalDecl.Count, StringStream);
       encodeSLEB128(LocalDecl.Type, StringStream);
     }
 
     Func.Body.writeAsBinary(StringStream);

 
 
 int WasmWriter::writeWasm(raw_ostream &OS) {
   // Write headers
   OS.write(wasm::WasmMagic, sizeof(wasm::WasmMagic));
   writeUint32(OS, Obj.Header.Version);
 
   // Write each section
+  uint32_t LastType = 0;
   for (const std::unique_ptr<WasmYAML::Section> &Sec : Obj.Sections) {
-    encodeULEB128(Sec->Type, OS);
+    uint32_t Type = Sec->Type;
+    if (Type != wasm::WASM_SEC_CUSTOM) {
+      if (Type < LastType) {
+        errs() << "Out of order section type: " << Type << "\n";
+        return 1;
+      }
+      LastType = Type;
+    }
 
+    encodeULEB128(Sec->Type, OS);
     std::string OutString;
     raw_string_ostream StringStream(OutString);
     if (auto S = dyn_cast<WasmYAML::CustomSection>(Sec.get())) {
       if (auto Err = writeSectionContent(StringStream, *S))
         return Err;
     } else if (auto S = dyn_cast<WasmYAML::TypeSection>(Sec.get())) {
       if (auto Err = writeSectionContent(StringStream, *S))
         return Err;