[WebAssembly][lld] R_WASM_TABLE_NUMBER_LEB is variable-width

[wingo]

Summary

WebAssembly 1.0 only supports a table-number immediate operand of 0x00.
As we add support for multiple tables with a corresponding relocation,
continue to allow generation of one-byte table number references, so
that the "normal" case of just one table with the number 0 can be
written as 0x00. This allows the compiler to output relocations for
call_indirect while targetting WebAssembly 1.0, simplifying the
configuration space.

[wingo]

A bit of an RFC, this one -- perhaps it is a way out of the impasse of https://reviews.llvm.org/D95005.

[wingo]

I should add that I am not married to this idea and other solutions may be better

[wingo]

As discussed in https://reviews.llvm.org/D90948, this is not the way to go :)

lld/wasm/InputChunks.cpp

for (const WasmRelocation &rel : relocations) {
     case R_WASM_MEMORY_ADDR_I64:
     case R_WASM_FUNCTION_OFFSET_I64:
       existingValue = read64le(loc);
       break;
     default:
       llvm_unreachable("unknown relocation type");
     }
 
+    if (rel.Type == R_WASM_TABLE_NUMBER_LEB) {
+      if (bytesRead < 1 || bytesRead > 5)
+        warn("expected LEB at relocation site be 1-5 bytes long");
+    } else {
       if (bytesRead && bytesRead != paddedLEBWidth)
         warn("expected LEB at relocation site be 5/10-byte padded");
+    }
 
     if (rel.Type != R_WASM_GLOBAL_INDEX_LEB &&
         rel.Type != R_WASM_GLOBAL_INDEX_I32) {
       auto expectedValue = file->calcExpectedValue(rel);
       if (expectedValue != existingValue)
         warn(toString(this) + ": unexpected existing value for " +
              relocTypeToString(rel.Type) + ": existing=" +
              Twine(existingValue) + " expected=" + Twine(expectedValue));
LLVM_DEBUG(dbgs() << " addend=" << rel.Addend << " index=" << rel.Index
                       << "\n");
 
     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_NUMBER_LEB:
       encodeULEB128(value, loc, 5);
       break;
+    case R_WASM_TABLE_NUMBER_LEB: {
+      uint32_t bytesRead = 0;
+      decodeULEB128(loc, &bytesRead);
+      encodeULEB128(value, loc, bytesRead);
+      break;
+    }
     case R_WASM_MEMORY_ADDR_LEB64:
       encodeULEB128(value, loc, 10);
       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_MEMORY_ADDR_TLS_SLEB:

 
 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_NUMBER_LEB:
   case R_WASM_TABLE_INDEX_SLEB:
   case R_WASM_MEMORY_ADDR_SLEB:
     return 5;
   case R_WASM_TABLE_INDEX_SLEB64:
   case R_WASM_MEMORY_ADDR_LEB64:
   case R_WASM_MEMORY_ADDR_SLEB64:
     return 10;
   default:
     llvm_unreachable("unexpected relocation type");
   }
 }
 
 static unsigned getRelocWidth(const WasmRelocation &rel, uint64_t value) {
   uint8_t buf[10];
   return writeCompressedReloc(buf, rel, value);
 }
 
+static bool relocHasPaddedWidth(const WasmRelocation &rel) {
+  return rel.Type != R_WASM_TABLE_NUMBER_LEB;
+}
+
+static uint32_t getRelocInputWidth(const uint8_t *buf,
+                                   const WasmRelocation &rel) {
+  if (relocHasPaddedWidth(rel)) {
+    return getRelocWidthPadded(rel);
+  } else {
+    uint32_t relocSize = 0;
+    decodeULEB128(buf + rel.Offset, &relocSize);
+    return relocSize;
+  }
+}
+
 // Relocations of type LEB and SLEB in the code section are padded to 5 bytes
 // so that a fast linker can blindly overwrite them without needing to worry
 // about the number of bytes needed to encode the values.
 // However, for optimal output the code section can be compressed to remove
 // the padding then outputting non-relocatable files.
 // In this case we need to perform a size calculation based on the value at each
 // relocation.  At best we end up saving 4 bytes for each relocation entry.
 //
void InputFunction::calculateSize() {
 
   auto tombstone = getTombstone();
 
   uint32_t lastRelocEnd = start + functionSizeLength;
   for (const WasmRelocation &rel : relocations) {
     LLVM_DEBUG(dbgs() << "  region: " << (rel.Offset - lastRelocEnd) << "\n");
     compressedFuncSize += rel.Offset - lastRelocEnd;
     compressedFuncSize += getRelocWidth(rel, file->calcNewValue(rel, tombstone));
-    lastRelocEnd = rel.Offset + getRelocWidthPadded(rel);
+    lastRelocEnd = rel.Offset + getRelocInputWidth(secStart, rel);
   }
   LLVM_DEBUG(dbgs() << "  final region: " << (end - lastRelocEnd) << "\n");
   compressedFuncSize += end - lastRelocEnd;
 
   // Now we know how long the resulting function is we can add the encoding
   // of its length
   uint8_t buf[5];
   compressedSize = compressedFuncSize + encodeULEB128(compressedFuncSize, buf);
void InputFunction::writeTo(uint8_t *buf) const {
   buf += encodeULEB128(compressedFuncSize, buf);
   const uint8_t *lastRelocEnd = funcStart;
   for (const WasmRelocation &rel : relocations) {
     unsigned chunkSize = (secStart + rel.Offset) - lastRelocEnd;
     LLVM_DEBUG(dbgs() << "  write chunk: " << chunkSize << "\n");
     memcpy(buf, lastRelocEnd, chunkSize);
     buf += chunkSize;
     buf += writeCompressedReloc(buf, rel, file->calcNewValue(rel, tombstone));
-    lastRelocEnd = secStart + rel.Offset + getRelocWidthPadded(rel);
+    lastRelocEnd = secStart + rel.Offset + getRelocInputWidth(secStart, rel);
   }
 
   unsigned chunkSize = end - lastRelocEnd;
   LLVM_DEBUG(dbgs() << "  write final chunk: " << chunkSize << "\n");
   memcpy(buf, lastRelocEnd, chunkSize);
   LLVM_DEBUG(dbgs() << "  total: " << (buf + chunkSize - orig) << "\n");
 }