[RISCV][MC] Backport support for parsing modifiers in data directives

This backports the core of fe6fb91 to
support parsing `.foo %bar(expr)` in RISC-V assembly, which will be used
as the syntax for code capabilities. Note that upstream has since
switched to "specifier" rather than "modifier" for the terminology here,
but I have kept RISC-V consistent with our older version in using
"modifier". The MC header's comment does however use "specifier" as it's
target-independent.

Upstream commit message:

    [RISCV] Replace @plt/@gotpcrel in data directives with %pltpcrel %gotpcrel

    clang -fexperimental-relative-c++-abi-vtables might generate `@plt` and
    `@gotpcrel` specifiers in data directives. The syntax is not used in
    humand-written assembly code, and is not supported by GNU assembler.
    Note: the `@plt` in `.word foo@plt` is different from
    the legacy `call func@plt` (where `@plt` is simply ignored).

    The `@plt` syntax was selected was simply due to a quirk of AsmParser:
    the syntax was supported by all targets until I updated it
    to be an opt-in feature in a067175

    RISC-V favors the `%specifier(expr)` syntax following MIPS and Sparc,
    and we should follow this convention.

    This PR adds support for `.word %pltpcrel(foo+offset)` and
    `.word %gotpcrel(foo)`, and drops `@plt` and `@gotpcrel`.

    * MCValue::SymA can no longer have a SymbolVariant. Add an assert
      similar to that of AArch64ELFObjectWriter.cpp before
      https://reviews.llvm.org/D81446 (see my analysis at
      https://maskray.me/blog/2025-03-16-relocation-generation-in-assemblers
      if intrigued)
    * `jump foo@plt, x31` now has a different diagnostic.

    Pull Request: llvm/llvm-project#132569

Author: jrtc27

llvm/include/llvm/MC/MCParser/MCTargetAsmParser.h

@@ -412,6 +412,12 @@ class MCTargetAsmParser : public MCAsmParserExtension {
   virtual bool parsePrimaryExpr(const MCExpr *&Res, SMLoc &EndLoc) {
     return getParser().parsePrimaryExpr(Res, EndLoc, nullptr);
   }
+  // Parse an expression in a data directive, possibly with a relocation
+  // specifier.
+  virtual bool parseDataExpr(const MCExpr *&Res) {
+    SMLoc EndLoc;
+    return getParser().parseExpression(Res, EndLoc);
+  }
 
   virtual bool parseRegister(MCRegister &Reg, SMLoc &StartLoc,
                              SMLoc &EndLoc) = 0;

llvm/lib/MC/MCParser/AsmParser.cpp

@@ -3203,7 +3203,7 @@ bool AsmParser::parseDirectiveValue(StringRef IDVal, unsigned Size) {
   auto parseOp = [&]() -> bool {
     const MCExpr *Value;
     SMLoc ExprLoc = getLexer().getLoc();
-    if (checkForValidSection() || parseExpression(Value))
+    if (checkForValidSection() || getTargetParser().parseDataExpr(Value))
       return true;
     // Special case constant expressions to match code generator.
     if (const MCConstantExpr *MCE = dyn_cast<MCConstantExpr>(Value)) {
@@ -5881,7 +5881,7 @@ bool AsmParser::parseDirectiveCheriCap(SMLoc DirectiveLoc) {
   if (!getTargetParser().isCheri())
     return Error(DirectiveLoc, "'.chericap' requires CHERI");
 
-  if (parseExpression(Expr))
+  if (getTargetParser().parseDataExpr(Expr))
     return true;
 
   int64_t Value;

llvm/lib/Target/RISCV/AsmParser/RISCVAsmParser.cpp

@@ -248,6 +248,8 @@ class RISCVAsmParser : public MCTargetAsmParser {
   ParseStatus parseZcmpSpimm(OperandVector &Operands);
 
   bool parseOperand(OperandVector &Operands, StringRef Mnemonic);
+  bool parseExprWithModifier(const MCExpr *&Res, SMLoc &E);
+  bool parseDataExpr(const MCExpr *&Res) override;
 
   bool parseDirectiveOption();
   bool parseDirectiveAttribute();
@@ -2236,7 +2238,14 @@ ParseStatus RISCVAsmParser::parseOperandWithModifier(OperandVector &Operands) {
 
   if (parseToken(AsmToken::Percent, "expected '%' for operand modifier"))
     return ParseStatus::Failure;
+  const MCExpr *Expr = nullptr;
+  bool Failed = parseExprWithModifier(Expr, E);
+  if (!Failed)
+    Operands.push_back(RISCVOperand::createImm(Expr, S, E, isRV64()));
+  return Failed;
+}
 
+bool RISCVAsmParser::parseExprWithModifier(const MCExpr *&Res, SMLoc &E) {
   if (getLexer().getKind() != AsmToken::Identifier)
     return Error(getLoc(), "expected valid identifier for operand modifier");
   StringRef Identifier = getParser().getTok().getIdentifier();
@@ -2246,15 +2255,21 @@ ParseStatus RISCVAsmParser::parseOperandWithModifier(OperandVector &Operands) {
 
   getParser().Lex(); // Eat the identifier
   if (parseToken(AsmToken::LParen, "expected '('"))
-    return ParseStatus::Failure;
+    return true;
 
   const MCExpr *SubExpr;
   if (getParser().parseParenExpression(SubExpr, E))
-    return ParseStatus::Failure;
+    return true;
 
-  const MCExpr *ModExpr = RISCVMCExpr::create(SubExpr, VK, getContext());
-  Operands.push_back(RISCVOperand::createImm(ModExpr, S, E, isRV64()));
-  return ParseStatus::Success;
+  Res = RISCVMCExpr::create(SubExpr, VK, getContext());
+  return false;
+}
+
+bool RISCVAsmParser::parseDataExpr(const MCExpr *&Res) {
+  SMLoc E;
+  if (parseOptionalToken(AsmToken::Percent))
+    return parseExprWithModifier(Res, E);
+  return getParser().parseExpression(Res);
 }
 
 ParseStatus RISCVAsmParser::parseBareSymbol(OperandVector &Operands) {