[WIP] Add WASM_TABLE_INDEX_{SLEB,I32} reloc types with addends

[dschuff]

llvm/lib/Object/WasmObjectFile.cpp

764

@sbc100 When I run the test (see symbol-offsets.s) I'm running into this error when I hit the R_WASM_TABLE_INDEX_I32_ADDEND reloc. Any idea why this might be happening?

[sbc100]

llvm/lib/Target/WebAssembly/WebAssemblyMCInstLower.cpp

153

Can you link the bug where we discuessed this. I'm having trouble remember why should even allow this give that it doesn't make any sense to do arithmetic on table indexes.

[dschuff]

llvm/lib/Target/WebAssembly/WebAssemblyMCInstLower.cpp

153

https://bugs.llvm.org/show_bug.cgi?id=43133

[sbc100]

llvm/include/llvm/BinaryFormat/WasmRelocs.def

19

Missing newline at EOF?

llvm/lib/Object/WasmObjectFile.cpp

774

Indentation looks off

[sbc100]

llvm/test/MC/WebAssembly/symbol-offsets.s

47

Missing newline at EOF?

[dschuff]

Abandoning in favor of D107940

lld/wasm/InputChunks.cpp

for (const WasmRelocation &rel : relocations) {
     case R_WASM_EVENT_INDEX_LEB:
     case R_WASM_MEMORY_ADDR_LEB:
       existingValue = decodeULEB128(loc, &bytesRead);
       break;
     case R_WASM_TABLE_INDEX_SLEB:
     case R_WASM_TABLE_INDEX_REL_SLEB:
     case R_WASM_MEMORY_ADDR_SLEB:
     case R_WASM_MEMORY_ADDR_REL_SLEB:
+    case R_WASM_TABLE_INDEX_SLEB_ADDEND:
       existingValue = static_cast<uint32_t>(decodeSLEB128(loc, &bytesRead));
       break;
     case R_WASM_TABLE_INDEX_I32:
     case R_WASM_MEMORY_ADDR_I32:
     case R_WASM_FUNCTION_OFFSET_I32:
     case R_WASM_SECTION_OFFSET_I32:
+    case R_WASM_TABLE_INDEX_I32_ADDEND:
       existingValue = static_cast<uint32_t>(read32le(loc));
       break;
     default:
       llvm_unreachable("unknown relocation type");
     }
 
     if (bytesRead && bytesRead != 5)
       warn("expected LEB at relocation site be 5-byte padded");
for (const WasmRelocation &rel : relocations) {
     case R_WASM_EVENT_INDEX_LEB:
     case R_WASM_MEMORY_ADDR_LEB:
       encodeULEB128(value, loc, 5);
       break;
     case R_WASM_TABLE_INDEX_SLEB:
     case R_WASM_TABLE_INDEX_REL_SLEB:
     case R_WASM_MEMORY_ADDR_SLEB:
     case R_WASM_MEMORY_ADDR_REL_SLEB:
+    case R_WASM_TABLE_INDEX_SLEB_ADDEND:
       encodeSLEB128(static_cast<int32_t>(value), loc, 5);
       break;
     case R_WASM_TABLE_INDEX_I32:
     case R_WASM_MEMORY_ADDR_I32:
     case R_WASM_FUNCTION_OFFSET_I32:
     case R_WASM_SECTION_OFFSET_I32:
+    case R_WASM_TABLE_INDEX_I32_ADDEND:
       write32le(loc, value);
       break;
     default:
       llvm_unreachable("unknown relocation type");
     }
   }
 }
 
static unsigned writeCompressedReloc(uint8_t *buf, const WasmRelocation &rel,
   case R_WASM_TYPE_INDEX_LEB:
   case R_WASM_FUNCTION_INDEX_LEB:
   case R_WASM_GLOBAL_INDEX_LEB:
   case R_WASM_EVENT_INDEX_LEB:
   case R_WASM_MEMORY_ADDR_LEB:
     return encodeULEB128(value, buf);
   case R_WASM_TABLE_INDEX_SLEB:
   case R_WASM_MEMORY_ADDR_SLEB:
+  case R_WASM_TABLE_INDEX_SLEB_ADDEND:
     return encodeSLEB128(static_cast<int32_t>(value), buf);
   default:
     llvm_unreachable("unexpected relocation type");
   }
 }
 
 static unsigned getRelocWidthPadded(const WasmRelocation &rel) {
   switch (rel.Type) {
   case R_WASM_TYPE_INDEX_LEB:
   case R_WASM_FUNCTION_INDEX_LEB:
   case R_WASM_GLOBAL_INDEX_LEB:
   case R_WASM_EVENT_INDEX_LEB:
   case R_WASM_MEMORY_ADDR_LEB:
   case R_WASM_TABLE_INDEX_SLEB:
   case R_WASM_MEMORY_ADDR_SLEB:
+  case R_WASM_TABLE_INDEX_SLEB_ADDEND:
     return 5;
   default:
     llvm_unreachable("unexpected relocation type");
   }
 }
 
 static unsigned getRelocWidth(const WasmRelocation &rel, uint32_t value) {
   uint8_t buf[5];
if (sym->hasGOTIndex()) {
       writeUleb128(os, sym->getGOTIndex(), "global index");
       if (rel.Addend) {
         writeU8(os, WASM_OPCODE_I32_CONST, "CONST");
         writeSleb128(os, rel.Addend, "addend");
         writeU8(os, WASM_OPCODE_I32_ADD, "ADD");
       }
     } else {
       const GlobalSymbol* baseSymbol = WasmSym::memoryBase;
-      if (rel.Type == R_WASM_TABLE_INDEX_I32)
+      if (rel.Type == R_WASM_TABLE_INDEX_I32 ||
+          rel.Type == R_WASM_TABLE_INDEX_I32_ADDEND)
         baseSymbol = WasmSym::tableBase;
       writeU8(os, WASM_OPCODE_GLOBAL_GET, "GLOBAL_GET");
       writeUleb128(os, baseSymbol->getGlobalIndex(), "base");
       writeU8(os, WASM_OPCODE_I32_CONST, "CONST");
       writeSleb128(os, file->calcNewValue(rel), "offset");
       writeU8(os, WASM_OPCODE_I32_ADD, "ADD");
     }
 
     // Store that value at the virtual address
     writeU8(os, WASM_OPCODE_I32_STORE, "I32_STORE");
     writeUleb128(os, 2, "align");
     writeUleb128(os, 0, "offset");
   }
 }

lld/wasm/InputFiles.cpp

 
 // Calculate the value we expect to find at the relocation location.
 // This is used as a sanity check before applying a relocation to a given
 // location.  It is useful for catching bugs in the compiler and linker.
 uint32_t ObjFile::calcExpectedValue(const WasmRelocation &reloc) const {
   switch (reloc.Type) {
   case R_WASM_TABLE_INDEX_I32:
   case R_WASM_TABLE_INDEX_SLEB:
+  case R_WASM_TABLE_INDEX_I32_ADDEND:
+  case R_WASM_TABLE_INDEX_SLEB_ADDEND:
   case R_WASM_TABLE_INDEX_REL_SLEB: {
     const WasmSymbol &sym = wasmObj->syms()[reloc.Index];
     return tableEntries[sym.Info.ElementIndex];
   }
   case R_WASM_MEMORY_ADDR_SLEB:
   case R_WASM_MEMORY_ADDR_I32:
   case R_WASM_MEMORY_ADDR_LEB:
   case R_WASM_MEMORY_ADDR_REL_SLEB: {
if (reloc.Type != R_WASM_TYPE_INDEX_LEB) {
     sym = symbols[reloc.Index];
 
     // We can end up with relocations against non-live symbols.  For example
     // in debug sections.
     if ((isa<FunctionSymbol>(sym) || isa<DataSymbol>(sym)) && !sym->isLive())
       return 0;
   }
 
+  uint32_t Addend = 0;
   switch (reloc.Type) {
+  case R_WASM_TABLE_INDEX_I32_ADDEND:
+  case R_WASM_TABLE_INDEX_SLEB_ADDEND:
+    Addend = static_cast<uint32_t>(reloc.Addend);
+    LLVM_FALLTHROUGH;
   case R_WASM_TABLE_INDEX_I32:
   case R_WASM_TABLE_INDEX_SLEB:
   case R_WASM_TABLE_INDEX_REL_SLEB:
     if (!getFunctionSymbol(reloc.Index)->hasTableIndex())
-      return 0;
-    return getFunctionSymbol(reloc.Index)->getTableIndex();
+      return 0; // Should this be Addend?
+    return getFunctionSymbol(reloc.Index)->getTableIndex() + Addend;
   case R_WASM_MEMORY_ADDR_SLEB:
   case R_WASM_MEMORY_ADDR_I32:
   case R_WASM_MEMORY_ADDR_LEB:
   case R_WASM_MEMORY_ADDR_REL_SLEB:
     if (isa<UndefinedData>(sym))
       return 0;
     return cast<DefinedData>(sym)->getVirtualAddress() + reloc.Addend;
   case R_WASM_TYPE_INDEX_LEB:

llvm/include/llvm/BinaryFormat/WasmRelocs.def

 WASM_RELOC(R_WASM_MEMORY_ADDR_I32,       5)
 WASM_RELOC(R_WASM_TYPE_INDEX_LEB,        6)
 WASM_RELOC(R_WASM_GLOBAL_INDEX_LEB,      7)
 WASM_RELOC(R_WASM_FUNCTION_OFFSET_I32,   8)
 WASM_RELOC(R_WASM_SECTION_OFFSET_I32,    9)
 WASM_RELOC(R_WASM_EVENT_INDEX_LEB,      10)
 WASM_RELOC(R_WASM_MEMORY_ADDR_REL_SLEB, 11)
 WASM_RELOC(R_WASM_TABLE_INDEX_REL_SLEB, 12)
+WASM_RELOC(R_WASM_TABLE_INDEX_SLEB_ADDEND, 13)
+WASM_RELOC(R_WASM_TABLE_INDEX_I32_ADDEND, 14)
 No newline at end of file

llvm/lib/BinaryFormat/Wasm.cpp

 bool llvm::wasm::relocTypeHasAddend(uint32_t Type) {
   switch (Type) {
   case R_WASM_MEMORY_ADDR_LEB:
   case R_WASM_MEMORY_ADDR_SLEB:
   case R_WASM_MEMORY_ADDR_REL_SLEB:
   case R_WASM_MEMORY_ADDR_I32:
   case R_WASM_FUNCTION_OFFSET_I32:
   case R_WASM_SECTION_OFFSET_I32:
+  case R_WASM_TABLE_INDEX_SLEB_ADDEND:
+  case R_WASM_TABLE_INDEX_I32_ADDEND:
     return true;
   default:
     return false;
   }
 }

llvm/lib/MC/WasmObjectWriter.cpp

WasmObjectWriter::getProvisionalValue(const WasmRelocationEntry &RelEntry) {
   if (RelEntry.Type == wasm::R_WASM_GLOBAL_INDEX_LEB && !RelEntry.Symbol->isGlobal()) {
     assert(GOTIndices.count(RelEntry.Symbol) > 0 && "symbol not found in GOT index space");
     return GOTIndices[RelEntry.Symbol];
   }
 
   switch (RelEntry.Type) {
   case wasm::R_WASM_TABLE_INDEX_REL_SLEB:
   case wasm::R_WASM_TABLE_INDEX_SLEB:
-  case wasm::R_WASM_TABLE_INDEX_I32: {
+  case wasm::R_WASM_TABLE_INDEX_I32:
+  case wasm::R_WASM_TABLE_INDEX_SLEB_ADDEND:
+  case wasm::R_WASM_TABLE_INDEX_I32_ADDEND: {
     // Provisional value is table address of the resolved symbol itself
     const MCSymbolWasm *Sym = resolveSymbol(*RelEntry.Symbol);
     assert(Sym->isFunction());
     return TableIndices[Sym];
   }
   case wasm::R_WASM_TYPE_INDEX_LEB:
     // Provisional value is same as the index
     return getRelocationIndexValue(RelEntry);
for (const WasmRelocationEntry &RelEntry : Relocations) {
     case wasm::R_WASM_MEMORY_ADDR_LEB:
     case wasm::R_WASM_EVENT_INDEX_LEB:
       writePatchableLEB(Stream, Value, Offset);
       break;
     case wasm::R_WASM_TABLE_INDEX_I32:
     case wasm::R_WASM_MEMORY_ADDR_I32:
     case wasm::R_WASM_FUNCTION_OFFSET_I32:
     case wasm::R_WASM_SECTION_OFFSET_I32:
+    case wasm::R_WASM_TABLE_INDEX_I32_ADDEND:
       writeI32(Stream, Value, Offset);
       break;
     case wasm::R_WASM_TABLE_INDEX_SLEB:
     case wasm::R_WASM_TABLE_INDEX_REL_SLEB:
     case wasm::R_WASM_MEMORY_ADDR_SLEB:
     case wasm::R_WASM_MEMORY_ADDR_REL_SLEB:
+    case wasm::R_WASM_TABLE_INDEX_SLEB_ADDEND:
       writePatchableSLEB(Stream, Value, Offset);
       break;
     default:
       llvm_unreachable("invalid relocation type");
     }
   }
 }
 
for (const MCSymbol &S : Asm.symbols()) {
     SymbolInfos.emplace_back(Info);
   }
 
   {
     auto HandleReloc = [&](const WasmRelocationEntry &Rel) {
       // Functions referenced by a relocation need to put in the table.  This is
       // purely to make the object file's provisional values readable, and is
       // ignored by the linker, which re-calculates the relocations itself.
-      if (Rel.Type != wasm::R_WASM_TABLE_INDEX_I32 &&
-          Rel.Type != wasm::R_WASM_TABLE_INDEX_SLEB)
+      switch (Rel.Type) {
+      case wasm::R_WASM_TABLE_INDEX_I32:
+      case wasm::R_WASM_TABLE_INDEX_SLEB:
+      case wasm::R_WASM_TABLE_INDEX_SLEB_ADDEND:
+      case wasm::R_WASM_TABLE_INDEX_I32_ADDEND:
+        break;
+       default:
         return;
+      }
       assert(Rel.Symbol->isFunction());
       const MCSymbolWasm &WS = *resolveSymbol(*Rel.Symbol);
       uint32_t FunctionIndex = WasmIndices.find(&WS)->second;
       uint32_t TableIndex = TableElems.size() + InitialTableOffset;
       if (TableIndices.try_emplace(&WS, TableIndex).second) {
         LLVM_DEBUG(dbgs() << "  -> adding " << WS.getName()
                           << " to table: " << TableIndex << "\n");
         TableElems.push_back(FunctionIndex);

llvm/lib/Object/RelocationResolver.cpp

static bool supportsWasm32(uint64_t Type) {
   case wasm::R_WASM_MEMORY_ADDR_LEB:
   case wasm::R_WASM_MEMORY_ADDR_SLEB:
   case wasm::R_WASM_MEMORY_ADDR_I32:
   case wasm::R_WASM_TYPE_INDEX_LEB:
   case wasm::R_WASM_GLOBAL_INDEX_LEB:
   case wasm::R_WASM_FUNCTION_OFFSET_I32:
   case wasm::R_WASM_SECTION_OFFSET_I32:
   case wasm::R_WASM_EVENT_INDEX_LEB:
+  case wasm::R_WASM_TABLE_INDEX_SLEB_ADDEND:
+  case wasm::R_WASM_TABLE_INDEX_I32_ADDEND:
     return true;
   default:
     return false;
   }
 }
 
 static uint64_t resolveWasm32(RelocationRef R, uint64_t S, uint64_t A) {
   switch (R.getType()) {
   case wasm::R_WASM_FUNCTION_INDEX_LEB:
   case wasm::R_WASM_TABLE_INDEX_SLEB:
   case wasm::R_WASM_TABLE_INDEX_I32:
   case wasm::R_WASM_MEMORY_ADDR_LEB:
   case wasm::R_WASM_MEMORY_ADDR_SLEB:
   case wasm::R_WASM_MEMORY_ADDR_I32:
   case wasm::R_WASM_TYPE_INDEX_LEB:
   case wasm::R_WASM_GLOBAL_INDEX_LEB:
   case wasm::R_WASM_FUNCTION_OFFSET_I32:
   case wasm::R_WASM_SECTION_OFFSET_I32:
   case wasm::R_WASM_EVENT_INDEX_LEB:
+  case wasm::R_WASM_TABLE_INDEX_SLEB_ADDEND:
+  case wasm::R_WASM_TABLE_INDEX_I32_ADDEND:
     // For wasm section, its offset at 0 -- ignoring Value
     return A;
   default:
     llvm_unreachable("Invalid relocation type");
   }
 }
 
 std::pair<bool (*)(uint64_t), RelocationResolver>

llvm/lib/Object/WasmObjectFile.cpp

Error WasmObjectFile::parseRelocSection(StringRef Name, ReadContext &Ctx) {
   uint32_t RelocCount = readVaruint32(Ctx);
   uint32_t EndOffset = Section.Content.size();
   uint32_t PreviousOffset = 0;
   while (RelocCount--) {
     wasm::WasmRelocation Reloc = {};
     Reloc.Type = readVaruint32(Ctx);
     Reloc.Offset = readVaruint32(Ctx);
     if (Reloc.Offset < PreviousOffset)
       return make_error<GenericBinaryError>("Relocations not in offset order",
                                             object_error::parse_failed);
     PreviousOffset = Reloc.Offset;
     Reloc.Index = readVaruint32(Ctx);
     switch (Reloc.Type) {
     case wasm::R_WASM_FUNCTION_INDEX_LEB:
     case wasm::R_WASM_TABLE_INDEX_SLEB:
     case wasm::R_WASM_TABLE_INDEX_I32:
     case wasm::R_WASM_TABLE_INDEX_REL_SLEB:
+    case wasm::R_WASM_TABLE_INDEX_SLEB_ADDEND:
+     case wasm::R_WASM_TABLE_INDEX_I32_ADDEND:
       if (!isValidFunctionSymbol(Reloc.Index))
         return make_error<GenericBinaryError>("Bad relocation function index",
                                               object_error::parse_failed);
       break;
     case wasm::R_WASM_TYPE_INDEX_LEB:
       if (Reloc.Index >= Signatures.size())
         return make_error<GenericBinaryError>("Bad relocation type index",
                                               object_error::parse_failed);
while (RelocCount--) {
 
     // Relocations must fit inside the section, and must appear in order.  They
     // also shouldn't overlap a function/element boundary, but we don't bother
     // to check that.
     uint64_t Size = 5;
     if (Reloc.Type == wasm::R_WASM_TABLE_INDEX_I32 ||
         Reloc.Type == wasm::R_WASM_MEMORY_ADDR_I32 ||
         Reloc.Type == wasm::R_WASM_SECTION_OFFSET_I32 ||
-        Reloc.Type == wasm::R_WASM_FUNCTION_OFFSET_I32)
+        Reloc.Type == wasm::R_WASM_FUNCTION_OFFSET_I32 ||
+        Reloc.Type == wasm::R_WASM_TABLE_INDEX_I32_ADDEND)
       Size = 4;
     if (Reloc.Offset + Size > EndOffset)
       return make_error<GenericBinaryError>("Bad relocation offset",
                                             object_error::parse_failed);
 
     Section.Relocations.push_back(Reloc);
   }
   if (Ctx.Ptr != Ctx.End)

llvm/lib/Target/WebAssembly/MCTargetDesc/WebAssemblyWasmObjectWriter.cpp

case MCSymbolRefExpr::VK_WASM_TYPEINDEX:
       return wasm::R_WASM_TYPE_INDEX_LEB;
     default:
       break;
   }
 
   switch (unsigned(Fixup.getKind())) {
   case WebAssembly::fixup_sleb128_i32:
     if (SymA.isFunction())
-      return wasm::R_WASM_TABLE_INDEX_SLEB;
+      return Target.getConstant() == 0 ?
+          wasm::R_WASM_TABLE_INDEX_SLEB : wasm::R_WASM_TABLE_INDEX_SLEB_ADDEND;
     return wasm::R_WASM_MEMORY_ADDR_SLEB;
   case WebAssembly::fixup_sleb128_i64:
     llvm_unreachable("fixup_sleb128_i64 not implemented yet");
   case WebAssembly::fixup_uleb128_i32:
     if (SymA.isGlobal())
       return wasm::R_WASM_GLOBAL_INDEX_LEB;
     if (SymA.isFunction())
       return wasm::R_WASM_FUNCTION_INDEX_LEB;
     if (SymA.isEvent())
       return wasm::R_WASM_EVENT_INDEX_LEB;
     return wasm::R_WASM_MEMORY_ADDR_LEB;
   case FK_Data_4:
     if (SymA.isFunction())
-      return wasm::R_WASM_TABLE_INDEX_I32;
+      return Target.getConstant() == 0 ?
+          wasm::R_WASM_TABLE_INDEX_I32 : wasm::R_WASM_TABLE_INDEX_I32_ADDEND;
     if (auto Section = static_cast<const MCSectionWasm *>(
             getFixupSection(Fixup.getValue()))) {
       if (Section->getKind().isText())
         return wasm::R_WASM_FUNCTION_OFFSET_I32;
       else if (!Section->isWasmData())
         return wasm::R_WASM_SECTION_OFFSET_I32;
     }
     return wasm::R_WASM_MEMORY_ADDR_I32;

llvm/lib/Target/WebAssembly/WebAssemblyMCInstLower.cpp

MCOperand WebAssemblyMCInstLower::lowerSymbolOperand(const MachineOperand &MO,
   }
 
   const MCExpr *Expr = MCSymbolRefExpr::create(Sym, Kind, Ctx);
 
   if (MO.getOffset() != 0) {
     const auto *WasmSym = cast<MCSymbolWasm>(Sym);
     if (TargetFlags == WebAssemblyII::MO_GOT)
       report_fatal_error("GOT symbol references do not support offsets");
-    if (WasmSym->isFunction())
-      report_fatal_error("Function addresses with offsets not supported");
     if (WasmSym->isGlobal())
       report_fatal_error("Global indexes with offsets not supported");
     if (WasmSym->isEvent())
       report_fatal_error("Event indexes with offsets not supported");
 
     Expr = MCBinaryExpr::createAdd(
         Expr, MCConstantExpr::create(MO.getOffset(), Ctx), Ctx);
   }

llvm/test/MC/WebAssembly/symbol-offsets.s

+# RUN: llvm-mc -triple=wasm32-unknown-unknown -filetype=obj < %s | obj2yaml | FileCheck %s
+
+        .text
+funcaddr:          
+  .functype funcaddr () -> (i32)
+# Function symbol with offset (table index reloc with addend)
+  i32.const f1 + 3
+  call  f2
+# Data symbol with offset (addr reloc with addend)
+  i32.const d1 + 4
+  end_function
+
+  .functype f2 (i32) -> ()
+  .functype f1 () -> ()
+
+        .section .data,"",@
+d1:
+        .int32 1
+        .size d1, 4
+d2:
+        .int32 f1 + 8
+        .size d2, 4
+
+# CHECK:      --- !WASM
+# CHECK-NEXT: FileHeader:
+# CHECK-NEXT:   Version:         0x00000001
+
+# CHECK:  - Type:            CODE
+# CHECK-NEXT:    Relocations:
+# CHECK-NEXT:      - Type:            R_WASM_TABLE_INDEX_SLEB_ADDEND
+# CHECK-NEXT:        Index:           1
+# CHECK-NEXT:        Offset:          0x00000004
+# CHECK-NEXTT:        Addend:          8
+# CHECK-NEXT:      - Type:            R_WASM_FUNCTION_INDEX_LEB
+# CHECK-NEXT:        Index:           2
+# CHECK-NEXT:        Offset:          0x0000000A
+# CHECK-NEXT:      - Type:            R_WASM_MEMORY_ADDR_SLEB
+# CHECK-NEXT:        Index:           3
+# CHECK-NEXT:        Offset:          0x00000010
+# CHECK-NEXT:        Addend:          4
+
+# CHECK:   - Type:            DATA
+# CHECK-NEXT:    Relocations:
+# CHECK-NEXT:      - Type:            R_WASM_TABLE_INDEX_I32_ADDEND
+# CHECK-NEXT:        Index:           1
+# CHECK-NEXT:        Offset:          0x0000000A
+# CHECK-NEXT:        Addend:          8
 No newline at end of file