MC,SPARC: Replace SparcMCExpr with MCSpecifierExpr

Add a hook printSpecifierExpr so that targets can implement
relocation specifier printing without inheriting from MCSpecifierExpr.

Author: MaskRay

llvm/include/llvm/MC/MCAsmInfo.h

@@ -28,6 +28,7 @@ namespace llvm {
 class MCContext;
 class MCCFIInstruction;
 class MCExpr;
+class MCSpecifierExpr;
 class MCSection;
 class MCStreamer;
 class MCSubtargetInfo;
@@ -712,6 +713,7 @@ class LLVM_ABI MCAsmInfo {
   std::optional<uint32_t> getSpecifierForName(StringRef Name) const;
 
   void printExpr(raw_ostream &, const MCExpr &) const;
+  virtual void printSpecifierExpr(raw_ostream &, const MCSpecifierExpr &) const;
 };
 
 } // end namespace llvm

llvm/include/llvm/MC/MCExpr.h

@@ -82,6 +82,7 @@ class MCExpr {
   /// \name Utility Methods
   /// @{
 
+  // TODO: Make this private. Users should call MCAsmInfo::printExpr instead.
   LLVM_ABI void print(raw_ostream &OS, const MCAsmInfo *MAI,
                       int SurroundingPrec = 0) const;
   LLVM_ABI void dump() const;
@@ -509,7 +510,7 @@ class LLVM_ABI MCSpecifierExpr : public MCExpr {
   // Target-specific relocation specifier code
   const Spec specifier;
 
-protected:
+public:
   explicit MCSpecifierExpr(const MCExpr *Expr, Spec S)
       : MCExpr(Specifier, SMLoc()), Expr(Expr), specifier(S) {}
   virtual ~MCSpecifierExpr() = default;
@@ -518,7 +519,9 @@ class LLVM_ABI MCSpecifierExpr : public MCExpr {
   Spec getSpecifier() const { return specifier; }
   const MCExpr *getSubExpr() const { return Expr; }
 
-  virtual void printImpl(raw_ostream &OS, const MCAsmInfo *MAI) const = 0;
+  virtual void printImpl(raw_ostream &OS, const MCAsmInfo *MAI) const {
+    llvm_unreachable("Replace MCExpr::print calls with MCAsmInfo::printExpr");
+  }
   virtual bool evaluateAsRelocatableImpl(MCValue &Res,
                                          const MCAssembler *Asm) const;
 

llvm/lib/MC/MCAsmInfo.cpp

@@ -151,5 +151,15 @@ std::optional<uint32_t> MCAsmInfo::getSpecifierForName(StringRef Name) const {
 }
 
 void MCAsmInfo::printExpr(raw_ostream &OS, const MCExpr &Expr) const {
-  Expr.print(OS, this);
+  if (auto *SE = dyn_cast<MCSpecifierExpr>(&Expr))
+    printSpecifierExpr(OS, *SE);
+  else
+    Expr.print(OS, this);
+}
+
+void MCAsmInfo::printSpecifierExpr(raw_ostream &OS,
+                                   const MCSpecifierExpr &Expr) const {
+  // TODO: Switch to unreachable after all targets that use MCSpecifierExpr
+  // migrate to MCAsmInfo::printSpecifierExpr.
+  Expr.printImpl(OS, this);
 }

llvm/lib/MC/MCExpr.cpp

@@ -174,6 +174,8 @@ void MCExpr::print(raw_ostream &OS, const MCAsmInfo *MAI,
   }
 
   case MCExpr::Specifier:
+    // TODO: Remove after all targets that use MCSpecifierExpr migrate to
+    // MCAsmInfo::printSpecifierExpr.
     return cast<MCSpecifierExpr>(this)->printImpl(OS, MAI);
   }
 

llvm/lib/Target/Sparc/MCTargetDesc/SparcInstPrinter.cpp

@@ -12,6 +12,7 @@
 
 #include "SparcInstPrinter.h"
 #include "Sparc.h"
+#include "llvm/MC/MCAsmInfo.h"
 #include "llvm/MC/MCExpr.h"
 #include "llvm/MC/MCInst.h"
 #include "llvm/MC/MCSubtargetInfo.h"
@@ -142,7 +143,7 @@ void SparcInstPrinter::printOperand(const MCInst *MI, int opNum,
   }
 
   assert(MO.isExpr() && "Unknown operand kind in printOperand");
-  MO.getExpr()->print(O, &MAI);
+  MAI.printExpr(O, *MO.getExpr());
 }
 
 void SparcInstPrinter::printMemOperand(const MCInst *MI, int opNum,
@@ -288,5 +289,5 @@ void SparcInstPrinter::printCTILabel(const MCInst *MI, uint64_t Address,
   }
 
   // Otherwise, just print the expression.
-  Op.getExpr()->print(O, &MAI);
+  MAI.printExpr(O, *Op.getExpr());
 }

llvm/lib/Target/Sparc/MCTargetDesc/SparcMCAsmInfo.cpp

@@ -66,3 +66,13 @@ SparcELFMCAsmInfo::getExprForFDESymbol(const MCSymbol *Sym,
   }
   return MCAsmInfo::getExprForFDESymbol(Sym, Encoding, Streamer);
 }
+
+void SparcELFMCAsmInfo::printSpecifierExpr(raw_ostream &OS,
+                                           const MCSpecifierExpr &Expr) const {
+  StringRef S = Sparc::getSpecifierName(Expr.getSpecifier());
+  if (!S.empty())
+    OS << '%' << S << '(';
+  printExpr(OS, *Expr.getSubExpr());
+  if (!S.empty())
+    OS << ')';
+}

llvm/lib/Target/Sparc/MCTargetDesc/SparcMCAsmInfo.h

@@ -32,6 +32,8 @@ class SparcELFMCAsmInfo : public MCAsmInfoELF {
                                     unsigned Encoding,
                                     MCStreamer &Streamer) const override;
 
+  void printSpecifierExpr(raw_ostream &OS,
+                          const MCSpecifierExpr &Expr) const override;
 };
 
 } // end namespace llvm

llvm/lib/Target/Sparc/MCTargetDesc/SparcMCExpr.cpp

@@ -24,21 +24,12 @@ using namespace llvm;
 
 const SparcMCExpr *Sparc::createSpecifierExpr(MCContext &Ctx,
                                               const MCExpr *Expr, uint16_t S) {
-  return new (Ctx) SparcMCExpr(Expr, S);
+  return new (Ctx) MCSpecifierExpr(Expr, S);
 }
 
 const SparcMCExpr *Sparc::createSpecifierExpr(MCContext &Ctx,
                                               const MCSymbol *Sym, uint16_t S) {
-  return new (Ctx) SparcMCExpr(MCSymbolRefExpr::create(Sym, Ctx), S);
-}
-
-void SparcMCExpr::printImpl(raw_ostream &OS, const MCAsmInfo *MAI) const {
-  StringRef S = Sparc::getSpecifierName(specifier);
-  if (!S.empty())
-    OS << '%' << S << '(';
-  getSubExpr()->print(OS, MAI);
-  if (!S.empty())
-    OS << ')';
+  return new (Ctx) MCSpecifierExpr(MCSymbolRefExpr::create(Sym, Ctx), S);
 }
 
 StringRef Sparc::getSpecifierName(uint16_t S) {

llvm/lib/Target/Sparc/MCTargetDesc/SparcMCExpr.h

@@ -20,12 +20,7 @@
 namespace llvm {
 
 class StringRef;
-class SparcMCExpr : public MCSpecifierExpr {
-public:
-  explicit SparcMCExpr(const MCExpr *Expr, uint16_t S)
-      : MCSpecifierExpr(Expr, S) {}
-  void printImpl(raw_ostream &OS, const MCAsmInfo *MAI) const override;
-};
+using SparcMCExpr = MCSpecifierExpr;
 
 namespace Sparc {
 const SparcMCExpr *createSpecifierExpr(MCContext &Ctx, const MCExpr *Expr,