Remove unused Modifier

Author: tclin914

llvm/lib/Target/RISCV/RISCVAsmPrinter.cpp

@@ -985,15 +985,6 @@ bool RISCVAsmPrinter::lowerToMCInst(const MachineInstr *MI, MCInst &OutMI) {
   return false;
 }
 
-static MCSymbolRefExpr::VariantKind
-getModifierVariantKind(RISCVCP::RISCVCPModifier Modifier) {
-  switch (Modifier) {
-  case RISCVCP::None:
-    return MCSymbolRefExpr::VK_None;
-  }
-  llvm_unreachable("Invalid RISCVCPModifier!");
-}
-
 void RISCVAsmPrinter::emitMachineConstantPoolValue(
     MachineConstantPoolValue *MCPV) {
   auto *RCPV = static_cast<RISCVConstantPoolValue *>(MCPV);
@@ -1012,7 +1003,7 @@ void RISCVAsmPrinter::emitMachineConstantPoolValue(
   }
 
   const MCExpr *Expr = MCSymbolRefExpr::create(
-      MCSym, getModifierVariantKind(RCPV->getModifier()), OutContext);
+      MCSym, MCSymbolRefExpr::VK_None, OutContext);
   uint64_t Size = getDataLayout().getTypeAllocSize(RCPV->getType());
   OutStreamer->emitValue(Expr, Size);
 }

llvm/lib/Target/RISCV/RISCVConstantPoolValue.cpp

@@ -22,37 +22,22 @@
 using namespace llvm;
 
 RISCVConstantPoolValue::RISCVConstantPoolValue(
-    LLVMContext &C, RISCVCP::RISCVCPKind Kind,
-    RISCVCP::RISCVCPModifier Modifier)
-    : MachineConstantPoolValue((Type *)Type::getInt64Ty(C)), Kind(Kind),
-      Modifier(Modifier) {}
+    LLVMContext &C, RISCVCP::RISCVCPKind Kind)
+    : MachineConstantPoolValue((Type *)Type::getInt64Ty(C)), Kind(Kind) {}
 
 RISCVConstantPoolValue::RISCVConstantPoolValue(
-    Type *Ty, RISCVCP::RISCVCPKind Kind, RISCVCP::RISCVCPModifier Modifier)
-    : MachineConstantPoolValue(Ty), Kind(Kind), Modifier(Modifier) {}
+    Type *Ty, RISCVCP::RISCVCPKind Kind)
+    : MachineConstantPoolValue(Ty), Kind(Kind) {}
 
 int RISCVConstantPoolValue::getExistingMachineCPValue(MachineConstantPool *CP,
                                                       Align Alignment) {
   llvm_unreachable("Shouldn't be calling this directly!");
 }
 
-StringRef RISCVConstantPoolValue::getModifierText() const {
-  switch (Modifier) {
-  case RISCVCP::None:
-    return "";
-  }
-  llvm_unreachable("Unknown modifier!");
-}
-
-void RISCVConstantPoolValue::print(raw_ostream &O) const {
-  if (hasModifier())
-    O << "@" << getModifierText();
-}
-
 RISCVConstantPoolConstant::RISCVConstantPoolConstant(Type *Ty,
                                                      const Constant *GV,
                                                      RISCVCP::RISCVCPKind Kind)
-    : RISCVConstantPoolValue(Ty, Kind, RISCVCP::None), CVal(GV) {}
+    : RISCVConstantPoolValue(Ty, Kind), CVal(GV) {}
 
 RISCVConstantPoolConstant *
 RISCVConstantPoolConstant::Create(const GlobalValue *GV,
@@ -78,7 +63,6 @@ void RISCVConstantPoolConstant::addSelectionDAGCSEId(FoldingSetNodeID &ID) {
 
 void RISCVConstantPoolConstant::print(raw_ostream &O) const {
   O << CVal->getName();
-  RISCVConstantPoolValue::print(O);
 }
 
 const GlobalValue *RISCVConstantPoolConstant::getGlobalValue() const {
@@ -90,13 +74,12 @@ const BlockAddress *RISCVConstantPoolConstant::getBlockAddress() const {
 }
 
 RISCVConstantPoolSymbol::RISCVConstantPoolSymbol(
-    LLVMContext &C, StringRef s, RISCVCP::RISCVCPModifier Modifier)
-    : RISCVConstantPoolValue(C, RISCVCP::ExtSymbol, Modifier), S(s) {}
+    LLVMContext &C, StringRef s)
+    : RISCVConstantPoolValue(C, RISCVCP::ExtSymbol), S(s) {}
 
 RISCVConstantPoolSymbol *
-RISCVConstantPoolSymbol::Create(LLVMContext &C, StringRef s,
-                                RISCVCP::RISCVCPModifier Modifier) {
-  return new RISCVConstantPoolSymbol(C, s, Modifier);
+RISCVConstantPoolSymbol::Create(LLVMContext &C, StringRef s) {
+  return new RISCVConstantPoolSymbol(C, s);
 }
 
 int RISCVConstantPoolSymbol::getExistingMachineCPValue(MachineConstantPool *CP,
@@ -110,5 +93,4 @@ void RISCVConstantPoolSymbol::addSelectionDAGCSEId(FoldingSetNodeID &ID) {
 
 void RISCVConstantPoolSymbol::print(raw_ostream &O) const {
   O << S;
-  RISCVConstantPoolValue::print(O);
 }

llvm/lib/Target/RISCV/RISCVConstantPoolValue.h

@@ -26,23 +26,16 @@ class LLVMContext;
 namespace RISCVCP {
 
 enum RISCVCPKind { ExtSymbol, GlobalValue, BlockAddress };
-
-enum RISCVCPModifier {
-  None,
-};
 } // end namespace RISCVCP
 
 /// A RISCV-specific constant pool value.
 class RISCVConstantPoolValue : public MachineConstantPoolValue {
   RISCVCP::RISCVCPKind Kind;
-  RISCVCP::RISCVCPModifier Modifier;
 
 protected:
-  RISCVConstantPoolValue(LLVMContext &C, RISCVCP::RISCVCPKind Kind,
-                         RISCVCP::RISCVCPModifier Modifier);
+  RISCVConstantPoolValue(LLVMContext &C, RISCVCP::RISCVCPKind Kind);
 
-  RISCVConstantPoolValue(Type *Ty, RISCVCP::RISCVCPKind Kind,
-                         RISCVCP::RISCVCPModifier Modifier);
+  RISCVConstantPoolValue(Type *Ty, RISCVCP::RISCVCPKind Kind);
 
   template <typename Derived>
   int getExistingMachineCPValueImpl(MachineConstantPool *CP, Align Alignment) {
@@ -64,10 +57,6 @@ class RISCVConstantPoolValue : public MachineConstantPoolValue {
 public:
   ~RISCVConstantPoolValue() = default;
 
-  RISCVCP::RISCVCPModifier getModifier() const { return Modifier; }
-  StringRef getModifierText() const;
-  bool hasModifier() const { return Modifier != RISCVCP::None; }
-
   bool isExtSymbol() const { return Kind == RISCVCP::ExtSymbol; }
   bool isGlobalValue() const { return Kind == RISCVCP::GlobalValue; }
   bool isBlockAddress() const { return Kind == RISCVCP::BlockAddress; }
@@ -76,12 +65,6 @@ class RISCVConstantPoolValue : public MachineConstantPoolValue {
                                 Align Alignment) override;
 
   void addSelectionDAGCSEId(FoldingSetNodeID &ID) override {}
-
-  bool equals(const RISCVConstantPoolValue *A) const {
-    return this->Modifier == A->Modifier;
-  }
-
-  void print(raw_ostream &O) const override;
 };
 
 class RISCVConstantPoolConstant : public RISCVConstantPoolValue {
@@ -107,7 +90,7 @@ class RISCVConstantPoolConstant : public RISCVConstantPoolValue {
   void print(raw_ostream &O) const override;
 
   bool equals(const RISCVConstantPoolConstant *A) const {
-    return CVal == A->CVal && RISCVConstantPoolValue::equals(A);
+    return CVal == A->CVal;
   }
 
   static bool classof(const RISCVConstantPoolValue *RCPV) {
@@ -118,12 +101,10 @@ class RISCVConstantPoolConstant : public RISCVConstantPoolValue {
 class RISCVConstantPoolSymbol : public RISCVConstantPoolValue {
   const std::string S;
 
-  RISCVConstantPoolSymbol(LLVMContext &C, StringRef s,
-                          RISCVCP::RISCVCPModifier Modifier);
+  RISCVConstantPoolSymbol(LLVMContext &C, StringRef s);
 
 public:
-  static RISCVConstantPoolSymbol *Create(LLVMContext &C, StringRef s,
-                                         RISCVCP ::RISCVCPModifier Modifier);
+  static RISCVConstantPoolSymbol *Create(LLVMContext &C, StringRef s);
 
   std::string getSymbol() const { return S; }
 
@@ -135,7 +116,7 @@ class RISCVConstantPoolSymbol : public RISCVConstantPoolValue {
   void print(raw_ostream &O) const override;
 
   bool equals(const RISCVConstantPoolSymbol *A) const {
-    return S == A->S && RISCVConstantPoolValue::equals(A);
+    return S == A->S;
   }
   static bool classof(const RISCVConstantPoolValue *RCPV) {
     return RCPV->isExtSymbol();

llvm/lib/Target/RISCV/RISCVISelLowering.cpp

@@ -6457,7 +6457,7 @@ static SDValue getLargeAddr(NodeTy *N, SDLoc DL, EVT Ty, SelectionDAG &DAG) {
         MachinePointerInfo::getConstantPool(DAG.getMachineFunction()));
   } else if (ExternalSymbolSDNode *S = dyn_cast<ExternalSymbolSDNode>(N)) {
     RISCVConstantPoolSymbol *CPV = RISCVConstantPoolSymbol::Create(
-        *DAG.getContext(), S->getSymbol(), RISCVCP::None);
+        *DAG.getContext(), S->getSymbol());
     SDValue CPAddr = DAG.getTargetConstantPool(CPV, Ty, Align(8));
     SDValue LC = DAG.getNode(RISCVISD::LLA, DL, Ty, CPAddr);
     return DAG.getLoad(