[WebAssembly] Add WebAssemblyMCExpr::Specifier

Move wasm-specific members outside of MCSymbolRefExpr::VariantKind (a
legacy interface I am eliminating). Most changes are mechanic and
similar to what I've done for many ELF targets (e.g. X86 llvm#132149)

Notes:

* `fixSymbolsInTLSFixups` is replaced with `setTLS` in
  `WebAssemblyWasmObjectWriter::getRelocType`, similar to what I've done
  for many ELF targets.
* `SymA->setUsedInGOT()` in `recordRelocation` is moved to
  `getRelocType`.

In the future, we should encode expressions with a relocation specifier
as WebAssemblyMCExpr and use `MCValue::RefKind` to hold the specifier of
the relocatable expression (e.g. AArch64, RISCV).
https://maskray.me/blog/2025-03-16-relocation-generation-in-assemblers

While here, rename "Modifier' to "Specifier":

> "Relocation modifier", though concise, suggests adjustments happen during the linker's relocation step rather than the assembler's expression evaluation. I landed on "relocation specifier" as the winner. It's clear, aligns with Arm and IBM’s usage, and fits the assembler's role seamlessly.

Pull Request: llvm#133116

Author: MaskRay

llvm/include/llvm/MC/MCExpr.h

@@ -208,12 +208,6 @@ class MCSymbolRefExpr : public MCExpr {
 
     VK_COFF_IMGREL32, // symbol@imgrel (image-relative)
 
-    VK_WASM_TYPEINDEX, // Reference to a symbol's type (signature)
-    VK_WASM_TLSREL,    // Memory address relative to __tls_base
-    VK_WASM_MBREL,     // Memory address relative to __memory_base
-    VK_WASM_TBREL,     // Table index relative to __table_base
-    VK_WASM_GOT_TLS,   // Wasm global index of TLS symbol.
-    VK_WASM_FUNCINDEX, // Wasm function index.
 
     FirstTargetSpecifier,
   };

llvm/include/llvm/MC/MCWasmStreamer.h

@@ -67,11 +67,8 @@ class MCWasmStreamer : public MCObjectStreamer {
   void finishImpl() override;
 
 private:
-  void emitInstToFragment(const MCInst &Inst, const MCSubtargetInfo &) override;
   void emitInstToData(const MCInst &Inst, const MCSubtargetInfo &) override;
 
-  void fixSymbolsInTLSFixups(const MCExpr *expr);
-
   bool SeenIdent;
 };
 

llvm/lib/MC/MCWasmStreamer.cpp

@@ -167,25 +167,13 @@ void MCWasmStreamer::emitIdent(StringRef IdentString) {
   // sections in the object format
 }
 
-void MCWasmStreamer::emitInstToFragment(const MCInst &Inst,
-                                        const MCSubtargetInfo &STI) {
-  this->MCObjectStreamer::emitInstToFragment(Inst, STI);
-  MCRelaxableFragment &F = *cast<MCRelaxableFragment>(getCurrentFragment());
-
-  for (auto &Fixup : F.getFixups())
-    fixSymbolsInTLSFixups(Fixup.getValue());
-}
-
 void MCWasmStreamer::emitInstToData(const MCInst &Inst,
                                     const MCSubtargetInfo &STI) {
   MCAssembler &Assembler = getAssembler();
   SmallVector<MCFixup, 4> Fixups;
   SmallString<256> Code;
   Assembler.getEmitter().encodeInstruction(Inst, Code, Fixups, STI);
 
-  for (auto &Fixup : Fixups)
-    fixSymbolsInTLSFixups(Fixup.getValue());
-
   // Append the encoded instruction to the current data fragment (or create a
   // new such fragment if the current fragment is not a data fragment).
   MCDataFragment *DF = getOrCreateDataFragment();
@@ -205,39 +193,6 @@ void MCWasmStreamer::finishImpl() {
   this->MCObjectStreamer::finishImpl();
 }
 
-void MCWasmStreamer::fixSymbolsInTLSFixups(const MCExpr *expr) {
-  switch (expr->getKind()) {
-  case MCExpr::Target:
-  case MCExpr::Constant:
-    break;
-
-  case MCExpr::Binary: {
-    const MCBinaryExpr *be = cast<MCBinaryExpr>(expr);
-    fixSymbolsInTLSFixups(be->getLHS());
-    fixSymbolsInTLSFixups(be->getRHS());
-    break;
-  }
-
-  case MCExpr::SymbolRef: {
-    const MCSymbolRefExpr &symRef = *cast<MCSymbolRefExpr>(expr);
-    switch (symRef.getKind()) {
-    case MCSymbolRefExpr::VK_WASM_TLSREL:
-    case MCSymbolRefExpr::VK_WASM_GOT_TLS:
-      getAssembler().registerSymbol(symRef.getSymbol());
-      cast<MCSymbolWasm>(symRef.getSymbol()).setTLS();
-      break;
-    default:
-      break;
-    }
-    break;
-  }
-
-  case MCExpr::Unary:
-    fixSymbolsInTLSFixups(cast<MCUnaryExpr>(expr)->getSubExpr());
-    break;
-  }
-}
-
 void MCWasmStreamer::emitSymbolDesc(MCSymbol *Symbol, unsigned DescValue) {
   llvm_unreachable("Wasm doesn't support this directive");
 }

llvm/lib/MC/WasmObjectWriter.cpp

@@ -606,15 +606,6 @@ void WasmObjectWriter::recordRelocation(MCAssembler &Asm,
     SymA->setUsedInReloc();
   }
 
-  switch (Target.getSymSpecifier()) {
-  case MCSymbolRefExpr::VK_GOT:
-  case MCSymbolRefExpr::VK_WASM_GOT_TLS:
-    SymA->setUsedInGOT();
-    break;
-  default:
-    break;
-  }
-
   WasmRelocationEntry Rec(FixupOffset, SymA, C, Type, &FixupSection);
   LLVM_DEBUG(dbgs() << "WasmReloc: " << Rec << "\n");
 

llvm/lib/Target/WebAssembly/AsmParser/WebAssemblyAsmParser.cpp

@@ -14,6 +14,7 @@
 //===----------------------------------------------------------------------===//
 
 #include "AsmParser/WebAssemblyAsmTypeCheck.h"
+#include "MCTargetDesc/WebAssemblyMCExpr.h"
 #include "MCTargetDesc/WebAssemblyMCTargetDesc.h"
 #include "MCTargetDesc/WebAssemblyMCTypeUtilities.h"
 #include "MCTargetDesc/WebAssemblyTargetStreamer.h"
@@ -701,7 +702,7 @@ class WebAssemblyAsmParser final : public MCTargetAsmParser {
       WasmSym->setSignature(Signature);
       WasmSym->setType(wasm::WASM_SYMBOL_TYPE_FUNCTION);
       const MCExpr *Expr = MCSymbolRefExpr::create(
-          WasmSym, MCSymbolRefExpr::VK_WASM_TYPEINDEX, Ctx);
+          WasmSym, WebAssemblyMCExpr::VK_TYPEINDEX, Ctx);
       Operands.push_back(std::make_unique<WebAssemblyOperand>(
           Loc.getLoc(), Loc.getEndLoc(), WebAssemblyOperand::SymOp{Expr}));
     }

llvm/lib/Target/WebAssembly/AsmParser/WebAssemblyAsmTypeCheck.cpp

@@ -14,6 +14,7 @@
 //===----------------------------------------------------------------------===//
 
 #include "AsmParser/WebAssemblyAsmTypeCheck.h"
+#include "MCTargetDesc/WebAssemblyMCExpr.h"
 #include "MCTargetDesc/WebAssemblyMCTargetDesc.h"
 #include "MCTargetDesc/WebAssemblyMCTypeUtilities.h"
 #include "MCTargetDesc/WebAssemblyTargetStreamer.h"
@@ -264,9 +265,9 @@ bool WebAssemblyAsmTypeCheck::getGlobal(SMLoc ErrorLoc,
     break;
   case wasm::WASM_SYMBOL_TYPE_FUNCTION:
   case wasm::WASM_SYMBOL_TYPE_DATA:
-    switch (SymRef->getKind()) {
-    case MCSymbolRefExpr::VK_GOT:
-    case MCSymbolRefExpr::VK_WASM_GOT_TLS:
+    switch (getSpecifier(SymRef)) {
+    case WebAssemblyMCExpr::VK_GOT:
+    case WebAssemblyMCExpr::VK_GOT_TLS:
       Type = Is64 ? wasm::ValType::I64 : wasm::ValType::I32;
       return false;
     default:

llvm/lib/Target/WebAssembly/Disassembler/WebAssemblyDisassembler.cpp

@@ -14,6 +14,7 @@
 ///
 //===----------------------------------------------------------------------===//
 
+#include "MCTargetDesc/WebAssemblyMCExpr.h"
 #include "MCTargetDesc/WebAssemblyMCTypeUtilities.h"
 #include "TargetInfo/WebAssemblyTargetInfo.h"
 #include "llvm/BinaryFormat/Wasm.h"
@@ -238,7 +239,7 @@ MCDisassembler::DecodeStatus WebAssemblyDisassembler::getInstruction(
         auto *WasmSym = cast<MCSymbolWasm>(Sym);
         WasmSym->setType(wasm::WASM_SYMBOL_TYPE_FUNCTION);
         const MCExpr *Expr = MCSymbolRefExpr::create(
-            WasmSym, MCSymbolRefExpr::VK_WASM_TYPEINDEX, getContext());
+            WasmSym, WebAssemblyMCExpr::VK_TYPEINDEX, getContext());
         MI.addOperand(MCOperand::createExpr(Expr));
       }
       break;

llvm/lib/Target/WebAssembly/MCTargetDesc/CMakeLists.txt

@@ -3,6 +3,7 @@ add_llvm_component_library(LLVMWebAssemblyDesc
   WebAssemblyInstPrinter.cpp
   WebAssemblyMCAsmInfo.cpp
   WebAssemblyMCCodeEmitter.cpp
+  WebAssemblyMCExpr.cpp
   WebAssemblyMCTargetDesc.cpp
   WebAssemblyMCTypeUtilities.cpp
   WebAssemblyTargetStreamer.cpp

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

@@ -12,6 +12,7 @@
 //===----------------------------------------------------------------------===//
 
 #include "MCTargetDesc/WebAssemblyInstPrinter.h"
+#include "MCTargetDesc/WebAssemblyMCExpr.h"
 #include "MCTargetDesc/WebAssemblyMCTargetDesc.h"
 #include "MCTargetDesc/WebAssemblyMCTypeUtilities.h"
 #include "llvm/ADT/APFloat.h"
@@ -339,7 +340,7 @@ void WebAssemblyInstPrinter::printOperand(const MCInst *MI, unsigned OpNo,
     // as a signature here, such that the assembler can recover this
     // information.
     auto SRE = static_cast<const MCSymbolRefExpr *>(Op.getExpr());
-    if (SRE->getKind() == MCSymbolRefExpr::VK_WASM_TYPEINDEX) {
+    if (getSpecifier(SRE) == WebAssemblyMCExpr::VK_TYPEINDEX) {
       auto &Sym = static_cast<const MCSymbolWasm &>(SRE->getSymbol());
       O << WebAssembly::signatureToString(Sym.getSignature());
     } else {

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

@@ -13,6 +13,7 @@
 //===----------------------------------------------------------------------===//
 
 #include "WebAssemblyMCAsmInfo.h"
+#include "WebAssemblyMCExpr.h"
 #include "WebAssemblyMCTargetDesc.h"
 #include "llvm/MC/MCExpr.h"
 #include "llvm/TargetParser/Triple.h"
@@ -22,13 +23,13 @@ using namespace llvm;
 #define DEBUG_TYPE "wasm-mc-asm-info"
 
 const MCAsmInfo::VariantKindDesc variantKindDescs[] = {
-    {MCSymbolRefExpr::VK_WASM_TYPEINDEX, "TYPEINDEX"},
-    {MCSymbolRefExpr::VK_WASM_TBREL, "TBREL"},
-    {MCSymbolRefExpr::VK_WASM_MBREL, "MBREL"},
-    {MCSymbolRefExpr::VK_WASM_TLSREL, "TLSREL"},
-    {MCSymbolRefExpr::VK_GOT, "GOT"},
-    {MCSymbolRefExpr::VK_WASM_GOT_TLS, "GOT@TLS"},
-    {MCSymbolRefExpr::VK_WASM_FUNCINDEX, "FUNCINDEX"},
+    {WebAssemblyMCExpr::VK_TYPEINDEX, "TYPEINDEX"},
+    {WebAssemblyMCExpr::VK_TBREL, "TBREL"},
+    {WebAssemblyMCExpr::VK_MBREL, "MBREL"},
+    {WebAssemblyMCExpr::VK_TLSREL, "TLSREL"},
+    {WebAssemblyMCExpr::VK_GOT, "GOT"},
+    {WebAssemblyMCExpr::VK_GOT_TLS, "GOT@TLS"},
+    {WebAssemblyMCExpr::VK_FUNCINDEX, "FUNCINDEX"},
 };
 
 WebAssemblyMCAsmInfo::~WebAssemblyMCAsmInfo() = default; // anchor.

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

@@ -0,0 +1,34 @@
+//===- WebAssembly specific MC expression classes ---------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "WebAssemblyMCExpr.h"
+#include "llvm/MC/MCContext.h"
+#include "llvm/MC/MCStreamer.h"
+#include "llvm/MC/MCValue.h"
+
+using namespace llvm;
+
+const WebAssemblyMCExpr *
+WebAssemblyMCExpr::create(const MCExpr *Expr, Specifier S, MCContext &Ctx) {
+  return new (Ctx) WebAssemblyMCExpr(Expr, S);
+}
+
+void WebAssemblyMCExpr::printImpl(raw_ostream &OS, const MCAsmInfo *MAI) const {
+}
+
+bool WebAssemblyMCExpr::evaluateAsRelocatableImpl(
+    MCValue &Res, const MCAssembler *Asm) const {
+  if (!getSubExpr()->evaluateAsRelocatable(Res, Asm))
+    return false;
+  Res.setSpecifier(specifier);
+  return !Res.getSubSym();
+}
+
+void WebAssemblyMCExpr::visitUsedExpr(MCStreamer &S) const {
+  S.visitUsedExpr(*Expr);
+}

llvm/lib/Target/WebAssembly/MCTargetDesc/WebAssemblyMCExpr.h

@@ -0,0 +1,64 @@
+//===- WebAssembly specific MC expression classes ---------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// The MCTargetExpr subclass describes a relocatable expression with a
+// WebAssembly-specific relocation specifier.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_LIB_TARGET_WEBASSEMBLY_MCTARGETDESC_WEBASSEMBLYMCEXPR_H
+#define LLVM_LIB_TARGET_WEBASSEMBLY_MCTARGETDESC_WEBASSEMBLYMCEXPR_H
+
+#include "llvm/MC/MCExpr.h"
+
+namespace llvm {
+
+class WebAssemblyMCExpr : public MCTargetExpr {
+public:
+  enum Specifier {
+    VK_None,
+    VK_TYPEINDEX,
+    VK_TBREL,
+    VK_MBREL,
+    VK_TLSREL,
+    VK_GOT,
+    VK_GOT_TLS,
+    VK_FUNCINDEX,
+  };
+
+private:
+  const MCExpr *Expr;
+  const Specifier specifier;
+
+protected:
+  explicit WebAssemblyMCExpr(const MCExpr *Expr, Specifier S)
+      : Expr(Expr), specifier(S) {}
+
+public:
+  static const WebAssemblyMCExpr *create(const MCExpr *, Specifier,
+                                         MCContext &);
+
+  Specifier getSpecifier() const { return specifier; }
+  const MCExpr *getSubExpr() const { return Expr; }
+
+  void printImpl(raw_ostream &OS, const MCAsmInfo *MAI) const override;
+  bool evaluateAsRelocatableImpl(MCValue &Res,
+                                 const MCAssembler *Asm) const override;
+  void visitUsedExpr(MCStreamer &Streamer) const override;
+  MCFragment *findAssociatedFragment() const override {
+    return getSubExpr()->findAssociatedFragment();
+  }
+};
+
+static inline WebAssemblyMCExpr::Specifier
+getSpecifier(const MCSymbolRefExpr *SRE) {
+  return WebAssemblyMCExpr::Specifier(SRE->getKind());
+}
+} // namespace llvm
+
+#endif

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

@@ -13,6 +13,7 @@
 //===----------------------------------------------------------------------===//
 
 #include "MCTargetDesc/WebAssemblyFixupKinds.h"
+#include "MCTargetDesc/WebAssemblyMCExpr.h"
 #include "MCTargetDesc/WebAssemblyMCTargetDesc.h"
 #include "llvm/BinaryFormat/Wasm.h"
 #include "llvm/MC/MCAsmBackend.h"
@@ -66,31 +67,33 @@ unsigned WebAssemblyWasmObjectWriter::getRelocType(
     const MCValue &Target, const MCFixup &Fixup,
     const MCSectionWasm &FixupSection, bool IsLocRel) const {
   auto &SymA = cast<MCSymbolWasm>(*Target.getAddSym());
-  auto Spec = Target.getSymSpecifier();
+  auto Spec = WebAssemblyMCExpr::Specifier(Target.getSpecifier());
   switch (Spec) {
-  case MCSymbolRefExpr::VK_GOT:
-  case MCSymbolRefExpr::VK_WASM_GOT_TLS:
+  case WebAssemblyMCExpr::VK_GOT:
+    SymA.setUsedInGOT();
     return wasm::R_WASM_GLOBAL_INDEX_LEB;
-  case MCSymbolRefExpr::VK_WASM_TBREL:
+  case WebAssemblyMCExpr::VK_GOT_TLS:
+    SymA.setUsedInGOT();
+    SymA.setTLS();
+    return wasm::R_WASM_GLOBAL_INDEX_LEB;
+  case WebAssemblyMCExpr::VK_TBREL:
     assert(SymA.isFunction());
     return is64Bit() ? wasm::R_WASM_TABLE_INDEX_REL_SLEB64
                      : wasm::R_WASM_TABLE_INDEX_REL_SLEB;
-  case MCSymbolRefExpr::VK_WASM_TLSREL:
+  case WebAssemblyMCExpr::VK_TLSREL:
+    SymA.setTLS();
     return is64Bit() ? wasm::R_WASM_MEMORY_ADDR_TLS_SLEB64
                      : wasm::R_WASM_MEMORY_ADDR_TLS_SLEB;
-  case MCSymbolRefExpr::VK_WASM_MBREL:
+  case WebAssemblyMCExpr::VK_MBREL:
     assert(SymA.isData());
     return is64Bit() ? wasm::R_WASM_MEMORY_ADDR_REL_SLEB64
                      : wasm::R_WASM_MEMORY_ADDR_REL_SLEB;
-  case MCSymbolRefExpr::VK_WASM_TYPEINDEX:
+  case WebAssemblyMCExpr::VK_TYPEINDEX:
     return wasm::R_WASM_TYPE_INDEX_LEB;
-  case MCSymbolRefExpr::VK_None:
+  case WebAssemblyMCExpr::VK_None:
     break;
-  case MCSymbolRefExpr::VK_WASM_FUNCINDEX:
+  case WebAssemblyMCExpr::VK_FUNCINDEX:
     return wasm::R_WASM_FUNCTION_INDEX_I32;
-  default:
-    report_fatal_error("unknown VariantKind");
-    break;
   }
 
   switch (unsigned(Fixup.getKind())) {

llvm/lib/Target/WebAssembly/WebAssemblyAsmPrinter.cpp

@@ -14,6 +14,7 @@
 //===----------------------------------------------------------------------===//
 
 #include "WebAssemblyAsmPrinter.h"
+#include "MCTargetDesc/WebAssemblyMCExpr.h"
 #include "MCTargetDesc/WebAssemblyMCTargetDesc.h"
 #include "MCTargetDesc/WebAssemblyTargetStreamer.h"
 #include "TargetInfo/WebAssemblyTargetInfo.h"
@@ -590,7 +591,7 @@ void WebAssemblyAsmPrinter::EmitFunctionAttributes(Module &M) {
 
     for (auto &Sym : Symbols) {
       OutStreamer->emitValue(
-          MCSymbolRefExpr::create(Sym, MCSymbolRefExpr::VK_WASM_FUNCINDEX,
+          MCSymbolRefExpr::create(Sym, WebAssemblyMCExpr::VK_FUNCINDEX,
                                   OutContext),
           4);
     }