[WebAssembly] Always start table index at 1, even for relocatable output

[ncw]

Summary

Previously llvm was using 0 as the first table index for wasm object files
but now that has switched to 1 we can have the output of lld do the same
and simplify the code.

---

No need to commit simultaneously with the matching LLVM change (D42095), they are completely independent. Third chunk split out of D41955.

No functional changes, since the table is ignored of object files.

[ncw]

test/wasm/relocatable.ll

148

Test expectations updated: as for D42095, relocatable Wasm files now match non-relocatable ones (avoiding random/unnecessary differences between them is good). The ELEM section has offset one, causing the indexes below to be incremented by one as well.

[sbc100]

wasm/Writer.cpp

118–119

Just use a global static "static const int kInitialTableOffset"?

[ncw]

Updated:

• Renamed constant

[ncw]

Updated:

• Simple rebase

[ncw]

Updated:

• Another rebase after #4c and #4d landed

[ncw]

Updated:

• Rebased to avoid conflict after previous change was landed with some reformating

[sbc100]

Can you update the description and title, now that this change is so specific.

[ncw]

Updated:

• After weak-alias.ll test was extended (to test relocatable output as well) this patch had to be updated...

Could it be merged soon to avoid further rebasing?

[sbc100]

I was imagining a more simple CL description. Something like:

[WebAssembly] Always start table index at 1, even for relocatable output

Previously llvm was using 0 as the first table index for wasm object files
but now that has switched to 1 we can have the output of lld to the same
and simply the code.

Happy to land make this change myself as I land it but i think its nice to have
the review match the commit.

test/wasm/locals-duplicate.test

 ; RELOC-NEXT:   - Type:            FUNCTION
 ; RELOC-NEXT:     FunctionTypes:   [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
 ; RELOC-NEXT:                        0, 0 ]
 ; RELOC-NEXT:   - Type:            TABLE
 ; RELOC-NEXT:     Tables:          
 ; RELOC-NEXT:       - ElemType:        ANYFUNC
 ; RELOC-NEXT:         Limits:          
 ; RELOC-NEXT:           Flags:           [ HAS_MAX ]
-; RELOC-NEXT:           Initial:         0x00000006
-; RELOC-NEXT:           Maximum:         0x00000006
+; RELOC-NEXT:           Initial:         0x00000007
+; RELOC-NEXT:           Maximum:         0x00000007
 ; RELOC-NEXT:   - Type:            MEMORY
 ; RELOC-NEXT:     Memories:        
 ; RELOC-NEXT:       - Initial:         0x00000001
 ; RELOC-NEXT:   - Type:            GLOBAL
 ; RELOC-NEXT:     Globals:         
 ; RELOC-NEXT:       - Index:           0
 ; RELOC-NEXT:         Type:            I32
 ; RELOC-NEXT:         Mutable:         false

 ; RELOC-NEXT:         Index:           4
 ; RELOC-NEXT:       - Name:            colliding_global3.1
 ; RELOC-NEXT:         Kind:            GLOBAL
 ; RELOC-NEXT:         Index:           5
 ; RELOC-NEXT:   - Type:            ELEM
 ; RELOC-NEXT:     Segments:        
 ; RELOC-NEXT:       - Offset:          
 ; RELOC-NEXT:           Opcode:          I32_CONST
-; RELOC-NEXT:           Value:           0
+; RELOC-NEXT:           Value:           1
 ; RELOC-NEXT:         Functions:       [ 0, 1, 2, 9, 10, 11 ]
 ; RELOC-NEXT:   - Type:            CODE
 ; RELOC-NEXT:     Relocations:     
 ; RELOC-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_SLEB
 ; RELOC-NEXT:         Index:           0
 ; RELOC-NEXT:         Offset:          0x00000013
 ; RELOC-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_SLEB
 ; RELOC-NEXT:         Index:           1

 ; RELOC-NEXT:       - Index:           4
 ; RELOC-NEXT:         Locals:          
 ; RELOC-NEXT:         Body:            4188808080000B
 ; RELOC-NEXT:       - Index:           5
 ; RELOC-NEXT:         Locals:          
 ; RELOC-NEXT:         Body:            4190808080000B
 ; RELOC-NEXT:       - Index:           6
 ; RELOC-NEXT:         Locals:          
-; RELOC-NEXT:         Body:            4180808080000B
+; RELOC-NEXT:         Body:            4181808080000B
 ; RELOC-NEXT:       - Index:           7
 ; RELOC-NEXT:         Locals:          
-; RELOC-NEXT:         Body:            4181808080000B
+; RELOC-NEXT:         Body:            4182808080000B
 ; RELOC-NEXT:       - Index:           8
 ; RELOC-NEXT:         Locals:          
-; RELOC-NEXT:         Body:            4182808080000B
+; RELOC-NEXT:         Body:            4183808080000B
 ; RELOC-NEXT:       - Index:           9
 ; RELOC-NEXT:         Locals:          
 ; RELOC-NEXT:         Body:            41020B
 ; RELOC-NEXT:       - Index:           10
 ; RELOC-NEXT:         Locals:          
 ; RELOC-NEXT:         Body:            41020B
 ; RELOC-NEXT:       - Index:           11
 ; RELOC-NEXT:         Locals:          
 ; RELOC-NEXT:         Body:            41020B
 ; RELOC-NEXT:       - Index:           12
 ; RELOC-NEXT:         Locals:          
 ; RELOC-NEXT:         Body:            4184808080000B
 ; RELOC-NEXT:       - Index:           13
 ; RELOC-NEXT:         Locals:          
 ; RELOC-NEXT:         Body:            418C808080000B
 ; RELOC-NEXT:       - Index:           14
 ; RELOC-NEXT:         Locals:          
 ; RELOC-NEXT:         Body:            4194808080000B
 ; RELOC-NEXT:       - Index:           15
 ; RELOC-NEXT:         Locals:          
-; RELOC-NEXT:         Body:            4183808080000B
+; RELOC-NEXT:         Body:            4184808080000B
 ; RELOC-NEXT:       - Index:           16
 ; RELOC-NEXT:         Locals:          
-; RELOC-NEXT:         Body:            4184808080000B
+; RELOC-NEXT:         Body:            4185808080000B
 ; RELOC-NEXT:       - Index:           17
 ; RELOC-NEXT:         Locals:          
-; RELOC-NEXT:         Body:            4185808080000B
+; RELOC-NEXT:         Body:            4186808080000B
 ; RELOC-NEXT:   - Type:            DATA
 ; RELOC-NEXT:     Segments:        
 ; RELOC-NEXT:       - SectionOffset:   6
 ; RELOC-NEXT:         MemoryIndex:     0
 ; RELOC-NEXT:         Offset:          
 ; RELOC-NEXT:           Opcode:          I32_CONST
 ; RELOC-NEXT:           Value:           0
 ; RELOC-NEXT:         Content:         '0000000000000000'

test/wasm/relocatable.ll

 ; CHECK-NEXT:         GlobalMutable:   false
 ; CHECK-NEXT:   - Type:            FUNCTION
 ; CHECK-NEXT:     FunctionTypes:   [ 0, 2, 2 ]
 ; CHECK-NEXT:   - Type:            TABLE
 ; CHECK-NEXT:     Tables:
 ; CHECK-NEXT:       - ElemType:        ANYFUNC
 ; CHECK-NEXT:         Limits:
 ; CHECK-NEXT:           Flags:           [ HAS_MAX ]
-; CHECK-NEXT:           Initial:         0x00000003
-; CHECK-NEXT:           Maximum:         0x00000003
+; CHECK-NEXT:           Initial:         0x00000004
+; CHECK-NEXT:           Maximum:         0x00000004
 ; CHECK-NEXT:   - Type:            MEMORY
 ; CHECK-NEXT:     Memories:
 ; CHECK-NEXT:       - Initial:         0x00000001
 ; CHECK-NEXT:   - Type:            GLOBAL
 ; CHECK-NEXT:     Globals:
 ; CHECK-NEXT:       - Index:           1
 ; CHECK-NEXT:         Type:            I32
 ; CHECK-NEXT:         Mutable:         false

 ; CHECK-NEXT:         Index:           5
 ; CHECK-NEXT:       - Name:            data_addr1
 ; CHECK-NEXT:         Kind:            GLOBAL
 ; CHECK-NEXT:         Index:           6
 ; CHECK-NEXT:   - Type:            ELEM
 ; CHECK-NEXT:     Segments:
 ; CHECK-NEXT:       - Offset:
 ; CHECK-NEXT:           Opcode:          I32_CONST
-; CHECK-NEXT:           Value:           0
+; CHECK-NEXT:           Value:           1
 ; CHECK-NEXT:         Functions:       [ 4, 1, 2 ]
 ; CHECK-NEXT:   - Type:            CODE
 ; CHECK-NEXT:     Relocations:
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_SLEB
 ; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x00000004
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_FUNCTION_INDEX_LEB
 ; CHECK-NEXT:         Index:           0

 ; CHECK-NEXT:           Opcode:          I32_CONST
 ; CHECK-NEXT:           Value:           0
 ; CHECK-NEXT:         Content:         68656C6C6F0A00
 ; CHECK-NEXT:       - SectionOffset:   18
 ; CHECK-NEXT:         MemoryIndex:     0
 ; CHECK-NEXT:         Offset:
 ; CHECK-NEXT:           Opcode:          I32_CONST
 ; CHECK-NEXT:           Value:           8
-; CHECK-NEXT:         Content:         '00000000'
+; CHECK-NEXT:         Content:         '01000000'
 ; CHECK-NEXT:       - SectionOffset:   27
 ; CHECK-NEXT:         MemoryIndex:     0
 ; CHECK-NEXT:         Offset:
 ; CHECK-NEXT:           Opcode:          I32_CONST
 ; CHECK-NEXT:           Value:           12
-; CHECK-NEXT:         Content:         '01000000'
+; CHECK-NEXT:         Content:         '02000000'
 ; CHECK-NEXT:       - SectionOffset:   36
 ; CHECK-NEXT:         MemoryIndex:     0
 ; CHECK-NEXT:         Offset:
 ; CHECK-NEXT:           Opcode:          I32_CONST
 ; CHECK-NEXT:           Value:           16
-; CHECK-NEXT:         Content:         '02000000'
+; CHECK-NEXT:         Content:         '03000000'
 ; CHECK-NEXT:       - SectionOffset:   45
 ; CHECK-NEXT:         MemoryIndex:     0
 ; CHECK-NEXT:         Offset:
 ; CHECK-NEXT:           Opcode:          I32_CONST
 ; CHECK-NEXT:           Value:           24
 ; CHECK-NEXT:         Content:         '00000000'
 ; CHECK-NEXT:       - SectionOffset:   54
 ; CHECK-NEXT:         MemoryIndex:     0

test/wasm/stack-pointer.ll

 ; CHECK-NEXT:         GlobalMutable:   false
 ; CHECK-NEXT:   - Type:            FUNCTION
 ; CHECK-NEXT:     FunctionTypes:   [ 0 ]
 ; CHECK-NEXT:   - Type:            TABLE
 ; CHECK-NEXT:     Tables:
 ; CHECK-NEXT:       - ElemType:        ANYFUNC
 ; CHECK-NEXT:         Limits:
 ; CHECK-NEXT:           Flags:           [ HAS_MAX ]
-; CHECK-NEXT:           Initial:         0x00000000
-; CHECK-NEXT:           Maximum:         0x00000000
+; CHECK-NEXT:           Initial:         0x00000001
+; CHECK-NEXT:           Maximum:         0x00000001
 ; CHECK-NEXT:   - Type:            MEMORY
 ; CHECK-NEXT:     Memories:
 ; CHECK-NEXT:       - Initial:         0x00000000
 ; CHECK-NEXT:   - Type:            EXPORT
 ; CHECK-NEXT:     Exports:         
 ; CHECK-NEXT:       - Name:            _start
 ; CHECK-NEXT:         Kind:            FUNCTION
 ; CHECK-NEXT:         Index:           0

wasm/Writer.cpp

 #define DEBUG_TYPE "lld"
 
 using namespace llvm;
 using namespace llvm::wasm;
 using namespace lld;
 using namespace lld::wasm;
 
 static constexpr int kStackAlignment = 16;
+static constexpr int kInitialTableOffset = 1;
 
 namespace {
 
 // Traits for using WasmSignature in a DenseMap.
 struct WasmSignatureDenseMapInfo {
   static WasmSignature getEmptyKey() {
     WasmSignature Sig;
     Sig.ReturnType = 1;
private:
   void createLinkingSection();
   void createNameSection();
 
   void writeHeader();
   void writeSections();
 
   uint64_t FileSize = 0;
   uint32_t DataSize = 0;
   uint32_t NumMemoryPages = 0;
-  uint32_t InitialTableOffset = 0;
 
   std::vector<const WasmSignature *> Types;
   DenseMap<WasmSignature, int32_t, WasmSignatureDenseMapInfo> TypeIndices;
   std::vector<const Symbol *> ImportedFunctions;
   std::vector<const Symbol *> ImportedGlobals;
   std::vector<WasmExportEntry> ExportedSymbols;
   std::vector<const Symbol *> DefinedGlobals;
   std::vector<InputFunction *> DefinedFunctions;
   std::vector<const Symbol *> IndirectFunctions;
void Writer::createTableSection() {
   // Always output a table section, even if there are no indirect calls.
   // There are two reasons for this:
   //  1. For executables it is useful to have an empty table slot at 0
   //     which can be filled with a null function call handler.
   //  2. If we don't do this, any program that contains a call_indirect but
   //     no address-taken function will fail at validation time since it is
   //     a validation error to include a call_indirect instruction if there
   //     is not table.
-  uint32_t TableSize = InitialTableOffset + IndirectFunctions.size();
+  uint32_t TableSize = kInitialTableOffset + IndirectFunctions.size();
 
   SyntheticSection *Section = createSyntheticSection(WASM_SEC_TABLE);
   raw_ostream &OS = Section->getStream();
 
   writeUleb128(OS, 1, "table count");
   writeSleb128(OS, WASM_TYPE_ANYFUNC, "table type");
   writeUleb128(OS, WASM_LIMITS_FLAG_HAS_MAX, "table flags");
   writeUleb128(OS, TableSize, "table initial size");
void Writer::createElemSection() {
 
   SyntheticSection *Section = createSyntheticSection(WASM_SEC_ELEM);
   raw_ostream &OS = Section->getStream();
 
   writeUleb128(OS, 1, "segment count");
   writeUleb128(OS, 0, "table index");
   WasmInitExpr InitExpr;
   InitExpr.Opcode = WASM_OPCODE_I32_CONST;
-  InitExpr.Value.Int32 = InitialTableOffset;
+  InitExpr.Value.Int32 = kInitialTableOffset;
   writeInitExpr(OS, InitExpr);
   writeUleb128(OS, IndirectFunctions.size(), "elem count");
 
-  uint32_t TableIndex = InitialTableOffset;
+  uint32_t TableIndex = kInitialTableOffset;
   for (const Symbol *Sym : IndirectFunctions) {
     assert(Sym->getTableIndex() == TableIndex);
     writeUleb128(OS, Sym->getOutputIndex(), "function index");
     ++TableIndex;
   }
 }
 
 void Writer::createCodeSection() {
void Writer::assignIndexes() {
   if (Config->HeapBaseSymbol) {
     DefinedGlobals.emplace_back(Config->HeapBaseSymbol);
     Config->HeapBaseSymbol->setOutputIndex(GlobalIndex++);
   }
 
   if (Config->Relocatable)
     DefinedGlobals.reserve(Symtab->getSymbols().size());
 
-  uint32_t TableIndex = InitialTableOffset;
+  uint32_t TableIndex = kInitialTableOffset;
 
   for (ObjFile *File : Symtab->ObjectFiles) {
     if (Config->Relocatable) {
       DEBUG(dbgs() << "Globals: " << File->getName() << "\n");
       for (Symbol *Sym : File->getSymbols()) {
         // Create wasm globals for data symbols defined in this file
         if (!Sym->isDefined() || File != Sym->getFile())
           continue;
void Writer::calculateInitFunctions() {
   // in the correct order.
   std::sort(InitFunctions.begin(), InitFunctions.end(),
             [](const WasmInitFunc &L, const WasmInitFunc &R) {
               return L.Priority < R.Priority;
             });
 }
 
 void Writer::run() {
-  if (!Config->Relocatable)
-    InitialTableOffset = 1;
-
   log("-- calculateTypes");
   calculateTypes();
   log("-- calculateImports");
   calculateImports();
   log("-- assignIndexes");
   assignIndexes();
   log("-- calculateExports");
   calculateExports();