[Xtensa] Rename VariantKind to Specifier

MaskRay · MaskRay · commit 39df4945e188 · 2025-03-23T11:26:56.000-07:00
Follow the X86, Mips, and RISCV renaming.

&gt; "Relocation modifier" suggests adjustments happen during the linker's relocation step rather than the assembler's expression evaluation.
&gt; "Relocation specifier" is clear, aligns with Arm and IBM AIX's documentation, and fits the assembler's role seamlessly.

In addition, rename *MCExpr::getKind, which confusingly shadows the base class getKind.

The parseSpecifier name follows Sparc.
diff --git a/llvm/lib/Target/Xtensa/AsmParser/XtensaAsmParser.cpp b/llvm/lib/Target/Xtensa/AsmParser/XtensaAsmParser.cpp
@@ -391,7 +391,7 @@ bool XtensaAsmParser::processInstruction(MCInst &Inst, SMLoc IDLoc,
   case Xtensa::L32R: {
     const MCSymbolRefExpr *OpExpr =
         static_cast<const MCSymbolRefExpr *>(Inst.getOperand(1).getExpr());
-    XtensaMCExpr::VariantKind Kind = XtensaMCExpr::VK_Xtensa_None;
+    XtensaMCExpr::Specifier Kind = XtensaMCExpr::VK_None;
     const MCExpr *NewOpExpr = XtensaMCExpr::create(OpExpr, Kind, getContext());
     Inst.getOperand(1).setExpr(NewOpExpr);
     break;
@@ -411,8 +411,8 @@ bool XtensaAsmParser::processInstruction(MCInst &Inst, SMLoc IDLoc,
         const MCExpr *Value = MCConstantExpr::create(ImmOp64, getContext());
         MCSymbol *Sym = getContext().createTempSymbol();
         const MCExpr *Expr = MCSymbolRefExpr::create(Sym, getContext());
-        const MCExpr *OpExpr = XtensaMCExpr::create(
-            Expr, XtensaMCExpr::VK_Xtensa_None, getContext());
+        const MCExpr *OpExpr =
+            XtensaMCExpr::create(Expr, XtensaMCExpr::VK_None, getContext());
         TmpInst.addOperand(Inst.getOperand(0));
         MCOperand Op1 = MCOperand::createExpr(OpExpr);
         TmpInst.addOperand(Op1);
@@ -426,8 +426,8 @@ bool XtensaAsmParser::processInstruction(MCInst &Inst, SMLoc IDLoc,
       const MCExpr *Value = Inst.getOperand(1).getExpr();
       MCSymbol *Sym = getContext().createTempSymbol();
       const MCExpr *Expr = MCSymbolRefExpr::create(Sym, getContext());
-      const MCExpr *OpExpr = XtensaMCExpr::create(
-          Expr, XtensaMCExpr::VK_Xtensa_None, getContext());
+      const MCExpr *OpExpr =
+          XtensaMCExpr::create(Expr, XtensaMCExpr::VK_None, getContext());
       TmpInst.addOperand(Inst.getOperand(0));
       MCOperand Op1 = MCOperand::createExpr(OpExpr);
       TmpInst.addOperand(Op1);
diff --git a/llvm/lib/Target/Xtensa/MCTargetDesc/XtensaInstPrinter.cpp b/llvm/lib/Target/Xtensa/MCTargetDesc/XtensaInstPrinter.cpp
@@ -13,6 +13,7 @@
 //===----------------------------------------------------------------------===//
 
 #include "XtensaInstPrinter.h"
+#include "MCTargetDesc/XtensaMCExpr.h"
 #include "llvm/CodeGen/MachineOperand.h"
 #include "llvm/MC/MCExpr.h"
 #include "llvm/MC/MCInstrInfo.h"
@@ -34,10 +35,9 @@ static void printExpr(const MCExpr *Expr, raw_ostream &OS) {
   if (!(SRE = cast<MCSymbolRefExpr>(Expr)))
     assert(false && "Unexpected MCExpr type.");
 
-  MCSymbolRefExpr::VariantKind Kind = SRE->getKind();
-
-  switch (Kind) {
-  case MCSymbolRefExpr::VK_None:
+  auto Spec = XtensaMCExpr::Specifier(SRE->getKind());
+  switch (Spec) {
+  case XtensaMCExpr::VK_None:
     break;
   // TODO
   default:
@@ -52,7 +52,7 @@ static void printExpr(const MCExpr *Expr, raw_ostream &OS) {
     OS << Offset;
   }
 
-  if (Kind != MCSymbolRefExpr::VK_None)
+  if (Spec != XtensaMCExpr::VK_None)
     OS << ')';
 }
 
diff --git a/llvm/lib/Target/Xtensa/MCTargetDesc/XtensaMCExpr.cpp b/llvm/lib/Target/Xtensa/MCTargetDesc/XtensaMCExpr.cpp
@@ -26,36 +26,40 @@ using namespace llvm;
 
 #define DEBUG_TYPE "xtensamcexpr"
 
-const XtensaMCExpr *XtensaMCExpr::create(const MCExpr *Expr, VariantKind Kind,
+const XtensaMCExpr *XtensaMCExpr::create(const MCExpr *Expr, Specifier S,
                                          MCContext &Ctx) {
-  return new (Ctx) XtensaMCExpr(Expr, Kind);
+  return new (Ctx) XtensaMCExpr(Expr, S);
 }
 
 void XtensaMCExpr::printImpl(raw_ostream &OS, const MCAsmInfo *MAI) const {
-  bool HasVariant = getKind() != VK_Xtensa_None;
-  if (HasVariant)
-    OS << '%' << getVariantKindName(getKind()) << '(';
+  bool HasSpecifier = getSpecifier() != VK_None;
+  if (HasSpecifier)
+    OS << '%' << getSpecifierName(getSpecifier()) << '(';
   Expr->print(OS, MAI);
-  if (HasVariant)
+  if (HasSpecifier)
     OS << ')';
 }
 
 bool XtensaMCExpr::evaluateAsRelocatableImpl(MCValue &Res,
                                              const MCAssembler *Asm) const {
-  return getSubExpr()->evaluateAsRelocatable(Res, Asm);
+  if (!getSubExpr()->evaluateAsRelocatable(Res, Asm))
+    return false;
+
+  Res =
+      MCValue::get(Res.getSymA(), Res.getSymB(), Res.getConstant(), specifier);
+  return !Res.getSymB();
 }
 
 void XtensaMCExpr::visitUsedExpr(MCStreamer &Streamer) const {
   Streamer.visitUsedExpr(*getSubExpr());
 }
 
-XtensaMCExpr::VariantKind XtensaMCExpr::getVariantKindForName(StringRef name) {
-  return StringSwitch<XtensaMCExpr::VariantKind>(name).Default(
-      VK_Xtensa_Invalid);
+XtensaMCExpr::Specifier XtensaMCExpr::parseSpecifier(StringRef name) {
+  return StringSwitch<XtensaMCExpr::Specifier>(name).Default(VK_None);
 }
 
-StringRef XtensaMCExpr::getVariantKindName(VariantKind Kind) {
-  switch (Kind) {
+StringRef XtensaMCExpr::getSpecifierName(Specifier S) {
+  switch (S) {
   default:
     llvm_unreachable("Invalid ELF symbol kind");
   }
diff --git a/llvm/lib/Target/Xtensa/MCTargetDesc/XtensaMCExpr.h b/llvm/lib/Target/Xtensa/MCTargetDesc/XtensaMCExpr.h
@@ -22,20 +22,20 @@ namespace llvm {
 class StringRef;
 class XtensaMCExpr : public MCTargetExpr {
 public:
-  enum VariantKind { VK_Xtensa_None, VK_Xtensa_Invalid };
+  enum Specifier { VK_None, VK_TPOFF };
 
 private:
   const MCExpr *Expr;
-  const VariantKind Kind;
+  const Specifier specifier;
 
-  explicit XtensaMCExpr(const MCExpr *Expr, VariantKind Kind)
-      : Expr(Expr), Kind(Kind) {}
+  explicit XtensaMCExpr(const MCExpr *Expr, Specifier S)
+      : Expr(Expr), specifier(S) {}
 
 public:
-  static const XtensaMCExpr *create(const MCExpr *Expr, VariantKind Kind,
+  static const XtensaMCExpr *create(const MCExpr *Expr, Specifier,
                                     MCContext &Ctx);
 
-  VariantKind getKind() const { return Kind; }
+  Specifier getSpecifier() const { return specifier; }
 
   const MCExpr *getSubExpr() const { return Expr; }
 
@@ -47,8 +47,8 @@ class XtensaMCExpr : public MCTargetExpr {
     return getSubExpr()->findAssociatedFragment();
   }
 
-  static VariantKind getVariantKindForName(StringRef name);
-  static StringRef getVariantKindName(VariantKind Kind);
+  static Specifier parseSpecifier(StringRef name);
+  static StringRef getSpecifierName(Specifier Kind);
 };
 
 } // end namespace llvm.
diff --git a/llvm/lib/Target/Xtensa/XtensaAsmPrinter.cpp b/llvm/lib/Target/Xtensa/XtensaAsmPrinter.cpp
@@ -32,13 +32,13 @@
 
 using namespace llvm;
 
-static MCSymbolRefExpr::VariantKind
-getModifierVariantKind(XtensaCP::XtensaCPModifier Modifier) {
+static XtensaMCExpr::Specifier
+getModifierSpecifier(XtensaCP::XtensaCPModifier Modifier) {
   switch (Modifier) {
   case XtensaCP::no_modifier:
-    return MCSymbolRefExpr::VK_None;
+    return XtensaMCExpr::VK_None;
   case XtensaCP::TPOFF:
-    return MCSymbolRefExpr::VK_TPOFF;
+    return XtensaMCExpr::VK_TPOFF;
   }
   report_fatal_error("Invalid XtensaCPModifier!");
 }
@@ -92,7 +92,7 @@ void XtensaAsmPrinter::emitMachineConstantPoolValue(
   MCSymbol *LblSym = GetCPISymbol(ACPV->getLabelId());
   auto *TS =
       static_cast<XtensaTargetStreamer *>(OutStreamer->getTargetStreamer());
-  MCSymbolRefExpr::VariantKind VK = getModifierVariantKind(ACPV->getModifier());
+  XtensaMCExpr::Specifier VK = getModifierSpecifier(ACPV->getModifier());
 
   if (ACPV->getModifier() != XtensaCP::no_modifier) {
     std::string SymName(MCSym->getName());
@@ -227,7 +227,7 @@ XtensaAsmPrinter::LowerSymbolOperand(const MachineOperand &MO,
                                      MachineOperand::MachineOperandType MOTy,
                                      unsigned Offset) const {
   const MCSymbol *Symbol;
-  XtensaMCExpr::VariantKind Kind = XtensaMCExpr::VK_Xtensa_None;
+  XtensaMCExpr::Specifier Kind = XtensaMCExpr::VK_None;
 
   switch (MOTy) {
   case MachineOperand::MO_GlobalAddress:
