[llvm-branch-commits] [Sparc] Port ErrataWorkaround to NewPM (PR #237660)

via llvm-branch-commits llvm-branch-commits at lists.llvm.org
Sat Oct 31 17:18:39 PDT 2026


llvmorg-github-actions[bot] wrote:


<!--LLVM PR SUMMARY COMMENT-->

@llvm/pr-subscribers-backend-sparc

Author: Aiden Grossman (boomanaiden154)

<details>
<summary>Changes</summary>

Standard NewPM pass porting.


---
Full diff: https://github.com/llvm/llvm-project/pull/237660.diff


7 Files Affected:

- (modified) llvm/lib/Target/Sparc/LeonPasses.cpp (+59-35) 
- (modified) llvm/lib/Target/Sparc/LeonPasses.h (+8-20) 
- (modified) llvm/lib/Target/Sparc/Sparc.h (+8-1) 
- (modified) llvm/lib/Target/Sparc/SparcCodeGenPassBuilder.cpp (+1-1) 
- (modified) llvm/lib/Target/Sparc/SparcPassRegistry.def (+1) 
- (modified) llvm/lib/Target/Sparc/SparcTargetMachine.cpp (+2-2) 
- (modified) llvm/test/CodeGen/SPARC/newpm-pipeline.ll (+1) 


``````````diff
diff --git a/llvm/lib/Target/Sparc/LeonPasses.cpp b/llvm/lib/Target/Sparc/LeonPasses.cpp
index 67d4a7f2d29a5..15bc76a0b5812 100644
--- a/llvm/lib/Target/Sparc/LeonPasses.cpp
+++ b/llvm/lib/Target/Sparc/LeonPasses.cpp
@@ -18,24 +18,27 @@
 #include "llvm/CodeGen/MachineInstr.h"
 #include "llvm/CodeGen/MachineInstrBuilder.h"
 #include "llvm/CodeGen/MachinePassManager.h"
+#include "llvm/CodeGen/TargetInstrInfo.h"
+#include "llvm/CodeGen/TargetRegisterInfo.h"
 #include "llvm/IR/Analysis.h"
 #include "llvm/Support/raw_ostream.h"
 
 using namespace llvm;
 
-char ErrataWorkaround::ID = 0;
+char SparcErrataWorkaroundLegacy::ID = 0;
 
-ErrataWorkaround::ErrataWorkaround() : MachineFunctionPass(ID) {
-  initializeErrataWorkaroundPass(*PassRegistry::getPassRegistry());
+SparcErrataWorkaroundLegacy::SparcErrataWorkaroundLegacy()
+    : MachineFunctionPass(ID) {
+  initializeSparcErrataWorkaroundLegacyPass(*PassRegistry::getPassRegistry());
 }
 
-INITIALIZE_PASS(ErrataWorkaround, "errata-workaround", "Errata workaround pass",
-                false, false)
+INITIALIZE_PASS(SparcErrataWorkaroundLegacy, "errata-workaround",
+                "Errata workaround pass", false, false)
 
 // Move iterator to the next instruction in the function, ignoring
 // meta instructions and inline assembly. Returns false when reaching
 // the end of the function.
-bool ErrataWorkaround::moveNext(MachineBasicBlock::iterator &I) {
+static bool moveNext(MachineBasicBlock::iterator &I) {
 
   MachineBasicBlock *MBB = I->getParent();
 
@@ -53,11 +56,12 @@ bool ErrataWorkaround::moveNext(MachineBasicBlock::iterator &I) {
   return true;
 }
 
-void ErrataWorkaround::insertNop(MachineBasicBlock::iterator I) {
+static void insertNop(MachineBasicBlock::iterator I,
+                      const TargetInstrInfo *TII) {
   BuildMI(*I->getParent(), I, I->getDebugLoc(), TII->get(SP::NOP));
 }
 
-bool ErrataWorkaround::isFloat(MachineBasicBlock::iterator I) {
+static bool isFloat(MachineBasicBlock::iterator I) {
   if (I->getNumOperands() == 0)
     return false;
 
@@ -72,7 +76,7 @@ bool ErrataWorkaround::isFloat(MachineBasicBlock::iterator I) {
   return true;
 }
 
-bool ErrataWorkaround::isDivSqrt(MachineBasicBlock::iterator I) {
+static bool isDivSqrt(MachineBasicBlock::iterator I) {
   switch (I->getOpcode()) {
   case SP::FDIVS:
   case SP::FDIVD:
@@ -83,7 +87,7 @@ bool ErrataWorkaround::isDivSqrt(MachineBasicBlock::iterator I) {
   return false;
 }
 
-bool ErrataWorkaround::isAtomic(MachineBasicBlock::iterator I) {
+static bool isAtomic(MachineBasicBlock::iterator I) {
   switch (I->getOpcode()) {
   case SP::SWAPrr:
   case SP::SWAPri:
@@ -100,7 +104,8 @@ bool ErrataWorkaround::isAtomic(MachineBasicBlock::iterator I) {
 // (stb/sth/st/stf) -> (single non-store/load instruction) -> (any store)
 // If the sequence is detected a NOP instruction is inserted after
 // the first store instruction.
-bool ErrataWorkaround::checkSeqTN0009A(MachineBasicBlock::iterator I) {
+static bool checkSeqTN0009A(MachineBasicBlock::iterator I,
+                            const TargetInstrInfo *TII) {
   switch (I->getOpcode()) {
   case SP::STrr:
   case SP::STri:
@@ -130,7 +135,7 @@ bool ErrataWorkaround::checkSeqTN0009A(MachineBasicBlock::iterator I) {
   if (!MI->mayStore())
     return false;
 
-  insertNop(PatchHere);
+  insertNop(PatchHere, TII);
   return true;
 }
 
@@ -138,7 +143,8 @@ bool ErrataWorkaround::checkSeqTN0009A(MachineBasicBlock::iterator I) {
 // (std/stdf) -> (any store)
 // If the sequence is detected a NOP instruction is inserted after
 // the first store instruction.
-bool ErrataWorkaround::checkSeqTN0009B(MachineBasicBlock::iterator I) {
+static bool checkSeqTN0009B(MachineBasicBlock::iterator I,
+                            const TargetInstrInfo *TII) {
 
   switch (I->getOpcode()) {
   case SP::STDrr:
@@ -158,14 +164,15 @@ bool ErrataWorkaround::checkSeqTN0009B(MachineBasicBlock::iterator I) {
   if (!MI->mayStore())
     return false;
 
-  insertNop(MI);
+  insertNop(MI, TII);
   return true;
 }
 
 // Insert a NOP at branch target if load in delay slot and atomic
 // instruction at branch target. Also insert a NOP between load
 // instruction and atomic instruction (swap or casa).
-bool ErrataWorkaround::checkSeqTN0010(MachineBasicBlock::iterator I) {
+static bool checkSeqTN0010(MachineBasicBlock::iterator I,
+                           const TargetInstrInfo *TII) {
 
   // Check for load instruction or branch bundled with load instruction
   if (!I->mayLoad())
@@ -183,7 +190,7 @@ bool ErrataWorkaround::checkSeqTN0010(MachineBasicBlock::iterator I) {
       return false;
 
     if (isAtomic(MI))
-      insertNop(MI);
+      insertNop(MI, TII);
   }
 
   // Check for load followed by atomic instruction
@@ -193,12 +200,13 @@ bool ErrataWorkaround::checkSeqTN0010(MachineBasicBlock::iterator I) {
 
   if (!isAtomic(MI))
     return false;
-  insertNop(MI);
+  insertNop(MI, TII);
   return true;
 }
 
 // Do not allow functions to begin with an atomic instruction
-bool ErrataWorkaround::checkSeqTN0010First(MachineBasicBlock &MBB) {
+static bool checkSeqTN0010First(MachineBasicBlock &MBB,
+                                const TargetInstrInfo *TII) {
   MachineBasicBlock::iterator I = MBB.begin();
   while (I != MBB.end() && I->isMetaInstruction())
     I++;
@@ -206,13 +214,14 @@ bool ErrataWorkaround::checkSeqTN0010First(MachineBasicBlock &MBB) {
     return false;
   if (!isAtomic(I))
     return false;
-  insertNop(I);
+  insertNop(I, TII);
   return true;
 }
 
 // Inserts a NOP instruction at the target of an integer branch if the
 // target is a floating-point instruction or floating-point branch.
-bool ErrataWorkaround::checkSeqTN0012(MachineBasicBlock::iterator I) {
+static bool checkSeqTN0012(MachineBasicBlock::iterator I,
+                           const TargetInstrInfo *TII) {
 
   if (I->getOpcode() != SP::BCOND && I->getOpcode() != SP::BCONDA)
     return false;
@@ -229,7 +238,7 @@ bool ErrataWorkaround::checkSeqTN0012(MachineBasicBlock::iterator I) {
   if (!isFloat(MI) && MI->getOpcode() != SP::FBCOND)
     return false;
 
-  insertNop(MI);
+  insertNop(MI, TII);
   return true;
 }
 
@@ -242,7 +251,9 @@ bool ErrataWorkaround::checkSeqTN0012(MachineBasicBlock::iterator I) {
 //
 // The function also prevents the following code sequence from being generated,
 // (div/sqrt) -> (branch), by inserting a NOP instruction after the (div/sqrt).
-bool ErrataWorkaround::checkSeqTN0013(MachineBasicBlock::iterator I) {
+static bool checkSeqTN0013(MachineBasicBlock::iterator I,
+                           const TargetInstrInfo *TII,
+                           const TargetRegisterInfo *TRI) {
 
   if (!isDivSqrt(I))
     return false;
@@ -254,7 +265,7 @@ bool ErrataWorkaround::checkSeqTN0013(MachineBasicBlock::iterator I) {
     return false;
 
   if (MI->isBranch()) {
-    insertNop(MI);
+    insertNop(MI, TII);
     return true;
   }
 
@@ -278,9 +289,9 @@ bool ErrataWorkaround::checkSeqTN0013(MachineBasicBlock::iterator I) {
       if (fpFound < 2)
         return false;
 
-      insertNop(PatchHere);
+      insertNop(PatchHere, TII);
       if (i == 2)
-        insertNop(PatchHere);
+        insertNop(PatchHere, TII);
       return true;
     }
 
@@ -292,37 +303,50 @@ bool ErrataWorkaround::checkSeqTN0013(MachineBasicBlock::iterator I) {
   return false;
 }
 
-bool ErrataWorkaround::runOnMachineFunction(MachineFunction &MF) {
+static bool runErrataWorkaroundOnMachineFunction(MachineFunction &MF) {
   bool Changed = false;
-  ST = &MF.getSubtarget<SparcSubtarget>();
+  const SparcSubtarget *ST = &MF.getSubtarget<SparcSubtarget>();
 
   if (!(ST->fixTN0009() || ST->fixTN0010() || ST->fixTN0012() ||
         ST->fixTN0013()))
     return false;
 
-  TII = ST->getInstrInfo();
-  TRI = ST->getRegisterInfo();
+  const TargetInstrInfo *TII = ST->getInstrInfo();
+  const TargetRegisterInfo *TRI = ST->getRegisterInfo();
 
   if (ST->fixTN0010())
-    Changed |= checkSeqTN0010First(MF.front());
+    Changed |= checkSeqTN0010First(MF.front(), TII);
 
   for (auto &MBB : MF) {
     for (auto &I : MBB) {
       if (ST->fixTN0009()) {
-        Changed |= checkSeqTN0009A(I);
-        Changed |= checkSeqTN0009B(I);
+        Changed |= checkSeqTN0009A(I, TII);
+        Changed |= checkSeqTN0009B(I, TII);
       }
       if (ST->fixTN0010())
-        Changed |= checkSeqTN0010(I);
+        Changed |= checkSeqTN0010(I, TII);
       if (ST->fixTN0012())
-        Changed |= checkSeqTN0012(I);
+        Changed |= checkSeqTN0012(I, TII);
       if (ST->fixTN0013())
-        Changed |= checkSeqTN0013(I);
+        Changed |= checkSeqTN0013(I, TII, TRI);
     }
   }
   return Changed;
 }
 
+bool SparcErrataWorkaroundLegacy::runOnMachineFunction(MachineFunction &MF) {
+  return runErrataWorkaroundOnMachineFunction(MF);
+}
+
+PreservedAnalyses
+SparcErrataWorkaroundPass::run(MachineFunction &MF,
+                               MachineFunctionAnalysisManager &MFAM) {
+  return runErrataWorkaroundOnMachineFunction(MF)
+             ? getMachineFunctionPassPreservedAnalyses()
+                   .preserveSet<CFGAnalyses>()
+             : PreservedAnalyses::all();
+}
+
 //*****************************************************************************
 //**** InsertNOPLoad pass
 //*****************************************************************************
diff --git a/llvm/lib/Target/Sparc/LeonPasses.h b/llvm/lib/Target/Sparc/LeonPasses.h
index b8b08c35afd5a..e0ec9db1d9040 100644
--- a/llvm/lib/Target/Sparc/LeonPasses.h
+++ b/llvm/lib/Target/Sparc/LeonPasses.h
@@ -18,32 +18,20 @@
 namespace llvm {
 class SparcSubtarget;
 
-class LLVM_LIBRARY_VISIBILITY ErrataWorkaround : public MachineFunctionPass {
-protected:
-  const SparcSubtarget *ST;
-  const TargetInstrInfo *TII;
-  const TargetRegisterInfo *TRI;
-
-  bool checkSeqTN0009A(MachineBasicBlock::iterator I);
-  bool checkSeqTN0009B(MachineBasicBlock::iterator I);
-  bool checkSeqTN0010First(MachineBasicBlock &MBB);
-  bool checkSeqTN0010(MachineBasicBlock::iterator I);
-  bool checkSeqTN0012(MachineBasicBlock::iterator I);
-  bool checkSeqTN0013(MachineBasicBlock::iterator I);
-
-  bool moveNext(MachineBasicBlock::iterator &I);
-  bool isFloat(MachineBasicBlock::iterator I);
-  bool isDivSqrt(MachineBasicBlock::iterator I);
-  bool isAtomic(MachineBasicBlock::iterator I);
-  void insertNop(MachineBasicBlock::iterator I);
-
+class LLVM_LIBRARY_VISIBILITY SparcErrataWorkaroundLegacy
+    : public MachineFunctionPass {
 public:
   static char ID;
 
-  ErrataWorkaround();
+  SparcErrataWorkaroundLegacy();
   bool runOnMachineFunction(MachineFunction &MF) override;
 
   StringRef getPassName() const override { return "Errata workaround pass"; };
+
+  void getAnalysisUsage(AnalysisUsage &AU) const override {
+    AU.setPreservesCFG();
+    MachineFunctionPass::getAnalysisUsage(AU);
+  }
 };
 
 class LLVM_LIBRARY_VISIBILITY SparcInsertNOPLoadLegacy
diff --git a/llvm/lib/Target/Sparc/Sparc.h b/llvm/lib/Target/Sparc/Sparc.h
index ce88cd42bed94..335891dc40789 100644
--- a/llvm/lib/Target/Sparc/Sparc.h
+++ b/llvm/lib/Target/Sparc/Sparc.h
@@ -72,9 +72,16 @@ class SparcFixAllFDIVSQRTPass
                         MachineFunctionAnalysisManager &MFAM);
 };
 
+class SparcErrataWorkaroundPass
+    : public RequiredPassInfoMixin<SparcErrataWorkaroundPass> {
+public:
+  PreservedAnalyses run(MachineFunction &MF,
+                        MachineFunctionAnalysisManager &MFAM);
+};
+
 void initializeSparcAsmPrinterPass(PassRegistry &);
 void initializeSparcDAGToDAGISelLegacyPass(PassRegistry &);
-void initializeErrataWorkaroundPass(PassRegistry &);
+void initializeSparcErrataWorkaroundLegacyPass(PassRegistry &);
 } // namespace llvm
 
 namespace llvm {
diff --git a/llvm/lib/Target/Sparc/SparcCodeGenPassBuilder.cpp b/llvm/lib/Target/Sparc/SparcCodeGenPassBuilder.cpp
index 387cbc85c172c..5e7d4e1d7f546 100644
--- a/llvm/lib/Target/Sparc/SparcCodeGenPassBuilder.cpp
+++ b/llvm/lib/Target/Sparc/SparcCodeGenPassBuilder.cpp
@@ -59,7 +59,7 @@ void SparcCodeGenPassBuilder::addPreEmitPass(PassManagerWrapper &PMW) {
   addMachineFunctionPass(SparcInsertNOPLoadPass(), PMW);
   addMachineFunctionPass(SparcDetectRoundChangePass(), PMW);
   addMachineFunctionPass(SparcFixAllFDIVSQRTPass(), PMW);
-  // TODO(boomanaiden154): Add SparcErrataWorkaroundPass
+  addMachineFunctionPass(SparcErrataWorkaroundPass(), PMW);
 }
 
 void SparcCodeGenPassBuilder::addAsmPrinterBegin(PassManagerWrapper &PMW) {
diff --git a/llvm/lib/Target/Sparc/SparcPassRegistry.def b/llvm/lib/Target/Sparc/SparcPassRegistry.def
index b8519b01464aa..e41655864c6e5 100644
--- a/llvm/lib/Target/Sparc/SparcPassRegistry.def
+++ b/llvm/lib/Target/Sparc/SparcPassRegistry.def
@@ -18,6 +18,7 @@
 #endif
 MACHINE_FUNCTION_PASS("sparc-delay-slot-filler", SparcDelaySlotFillerPass())
 MACHINE_FUNCTION_PASS("sparc-detect-round-change", SparcDetectRoundChangePass())
+MACHINE_FUNCTION_PASS("sparc-errata-workaround", SparcErrataWorkaroundPass())
 MACHINE_FUNCTION_PASS("sparc-fix-all-fdivsqrt", SparcFixAllFDIVSQRTPass())
 MACHINE_FUNCTION_PASS("sparc-insert-nop-load", SparcInsertNOPLoadPass())
 MACHINE_FUNCTION_PASS("sparc-isel", SparcDAGToDAGISelPass(*this, getOptLevel()))
diff --git a/llvm/lib/Target/Sparc/SparcTargetMachine.cpp b/llvm/lib/Target/Sparc/SparcTargetMachine.cpp
index d710b585f6bcf..9f4c8e532bbd1 100644
--- a/llvm/lib/Target/Sparc/SparcTargetMachine.cpp
+++ b/llvm/lib/Target/Sparc/SparcTargetMachine.cpp
@@ -34,7 +34,7 @@ extern "C" LLVM_ABI LLVM_EXTERNAL_VISIBILITY void LLVMInitializeSparcTarget() {
   PassRegistry &PR = *PassRegistry::getPassRegistry();
   initializeSparcAsmPrinterPass(PR);
   initializeSparcDAGToDAGISelLegacyPass(PR);
-  initializeErrataWorkaroundPass(PR);
+  initializeSparcErrataWorkaroundLegacyPass(PR);
 }
 
 static Reloc::Model getEffectiveRelocModel(std::optional<Reloc::Model> RM) {
@@ -169,7 +169,7 @@ void SparcPassConfig::addPreEmitPass(){
   addPass(new SparcInsertNOPLoadLegacy());
   addPass(new SparcDetectRoundChangeLegacy());
   addPass(new SparcFixAllFDIVSQRTLegacy());
-  addPass(new ErrataWorkaround());
+  addPass(new SparcErrataWorkaroundLegacy());
 }
 
 void SparcV8TargetMachine::anchor() { }
diff --git a/llvm/test/CodeGen/SPARC/newpm-pipeline.ll b/llvm/test/CodeGen/SPARC/newpm-pipeline.ll
index 4a256a55aa59d..e8f316d066bdb 100644
--- a/llvm/test/CodeGen/SPARC/newpm-pipeline.ll
+++ b/llvm/test/CodeGen/SPARC/newpm-pipeline.ll
@@ -85,6 +85,7 @@
 ; SPARC-NEXT:     sparc-insert-nop-load
 ; SPARC-NEXT:     sparc-detect-round-change
 ; SPARC-NEXT:     sparc-fix-all-fdivsqrt
+; SPARC-NEXT:     sparc-errata-workaround
 ; SPARC-NEXT:     funclet-layout
 ; SPARC-NEXT:     remove-loads-into-fake-uses
 ; SPARC-NEXT:     StackMapLivenessPass

``````````

</details>


https://github.com/llvm/llvm-project/pull/237660


More information about the llvm-branch-commits mailing list