AMDGPU/NFC: Cleanup/refactor SIMemoryLegalizer [1]:

[kzhuravl]

Summary

• Rename MemOpInfo -> SIMemOpInfo
• Move SIMemOpInfo class out of SIMemoryLegalizer class

[t-tye]

LGTM

llvm/trunk/lib/Target/AMDGPU/SIMemoryLegalizer.cpp

 using namespace llvm;
 using namespace llvm::AMDGPU;
 
 #define DEBUG_TYPE "si-memory-legalizer"
 #define PASS_NAME "SI Memory Legalizer"
 
 namespace {
 
-class SIMemoryLegalizer final : public MachineFunctionPass {
-private:
-  struct MemOpInfo final {
-    SyncScope::ID SSID = SyncScope::System;
-    AtomicOrdering Ordering = AtomicOrdering::SequentiallyConsistent;
-    AtomicOrdering FailureOrdering = AtomicOrdering::SequentiallyConsistent;
+struct SIMemOpInfo final {
 
-    MemOpInfo() = default;
+  SIMemOpInfo() = default;
 
-    MemOpInfo(SyncScope::ID SSID,
+  SIMemOpInfo(SyncScope::ID SSID,
               AtomicOrdering Ordering,
               AtomicOrdering FailureOrdering)
-        : SSID(SSID),
-          Ordering(Ordering),
-          FailureOrdering(FailureOrdering) {}
 
-    MemOpInfo(const MachineMemOperand *MMO)
-        : SSID(MMO->getSyncScopeID()),
-          Ordering(MMO->getOrdering()),
-          FailureOrdering(MMO->getFailureOrdering()) {}
-  };
+  SIMemOpInfo(const MachineMemOperand *MMO)
 
+class SIMemoryLegalizer final : public MachineFunctionPass {
+private:
   /// \brief LLVM context.
   LLVMContext *CTX = nullptr;
 
   /// \brief Machine module info.
   const AMDGPUMachineModuleInfo *MMI = nullptr;
 
   /// \brief Instruction info.
   const SIInstrInfo *TII = nullptr;
private:
   /// function. Returns true if current function is modified, false otherwise.
   bool removeAtomicPseudoMIs();
 
   /// \brief Reports unknown synchronization scope used in \p MI to LLVM
   /// context.
   void reportUnknownSynchScope(const MachineBasicBlock::iterator &MI);
 
   /// \returns Load info if \p MI is a load operation, "None" otherwise.
-  Optional<MemOpInfo> getLoadInfo(const MachineBasicBlock::iterator &MI) const;
+  Optional<SIMemOpInfo> getLoadInfo(
+      const MachineBasicBlock::iterator &MI) const;
   /// \returns Store info if \p MI is a store operation, "None" otherwise.
-  Optional<MemOpInfo> getStoreInfo(const MachineBasicBlock::iterator &MI) const;
+  Optional<SIMemOpInfo> getStoreInfo(
+      const MachineBasicBlock::iterator &MI) const;
   /// \returns Atomic fence info if \p MI is an atomic fence operation,
   /// "None" otherwise.
-  Optional<MemOpInfo> getAtomicFenceInfo(
+  Optional<SIMemOpInfo> getAtomicFenceInfo(
       const MachineBasicBlock::iterator &MI) const;
   /// \returns Atomic cmpxchg info if \p MI is an atomic cmpxchg operation,
   /// "None" otherwise.
-  Optional<MemOpInfo> getAtomicCmpxchgInfo(
+  Optional<SIMemOpInfo> getAtomicCmpxchgInfo(
       const MachineBasicBlock::iterator &MI) const;
   /// \returns Atomic rmw info if \p MI is an atomic rmw operation,
   /// "None" otherwise.
-  Optional<MemOpInfo> getAtomicRmwInfo(
+  Optional<SIMemOpInfo> getAtomicRmwInfo(
       const MachineBasicBlock::iterator &MI) const;
 
   /// \brief Expands load operation \p MI. Returns true if instructions are
   /// added/deleted or \p MI is modified, false otherwise.
-  bool expandLoad(const MemOpInfo &MOI, MachineBasicBlock::iterator &MI);
+  bool expandLoad(const SIMemOpInfo &MOI,
+                  MachineBasicBlock::iterator &MI);
   /// \brief Expands store operation \p MI. Returns true if instructions are
   /// added/deleted or \p MI is modified, false otherwise.
-  bool expandStore(const MemOpInfo &MOI, MachineBasicBlock::iterator &MI);
+  bool expandStore(const SIMemOpInfo &MOI,
+                   MachineBasicBlock::iterator &MI);
   /// \brief Expands atomic fence operation \p MI. Returns true if
   /// instructions are added/deleted or \p MI is modified, false otherwise.
-  bool expandAtomicFence(const MemOpInfo &MOI,
+  bool expandAtomicFence(const SIMemOpInfo &MOI,
                          MachineBasicBlock::iterator &MI);
   /// \brief Expands atomic cmpxchg operation \p MI. Returns true if
   /// instructions are added/deleted or \p MI is modified, false otherwise.
-  bool expandAtomicCmpxchg(const MemOpInfo &MOI,
+  bool expandAtomicCmpxchg(const SIMemOpInfo &MOI,
                            MachineBasicBlock::iterator &MI);
   /// \brief Expands atomic rmw operation \p MI. Returns true if
   /// instructions are added/deleted or \p MI is modified, false otherwise.
-  bool expandAtomicRmw(const MemOpInfo &MOI,
+  bool expandAtomicRmw(const SIMemOpInfo &MOI,
                        MachineBasicBlock::iterator &MI);
 
 public:
   static char ID;
 
   SIMemoryLegalizer() : MachineFunctionPass(ID) {}
 
   void getAnalysisUsage(AnalysisUsage &AU) const override {

 
 void SIMemoryLegalizer::reportUnknownSynchScope(
     const MachineBasicBlock::iterator &MI) {
   DiagnosticInfoUnsupported Diag(*MI->getParent()->getParent()->getFunction(),
                                  "Unsupported synchronization scope");
   CTX->diagnose(Diag);
 }
 
-Optional<SIMemoryLegalizer::MemOpInfo> SIMemoryLegalizer::getLoadInfo(
+Optional<SIMemOpInfo> SIMemoryLegalizer::getLoadInfo(
     const MachineBasicBlock::iterator &MI) const {
   assert(MI->getDesc().TSFlags & SIInstrFlags::maybeAtomic);
 
   if (!(MI->mayLoad() && !MI->mayStore()))
     return None;
   if (!MI->hasOneMemOperand())
-    return MemOpInfo();
+    return SIMemOpInfo();
 
   const MachineMemOperand *MMO = *MI->memoperands_begin();
   if (!MMO->isAtomic())
     return None;
 
-  return MemOpInfo(MMO);
+  return SIMemOpInfo(MMO);
 }
 
-Optional<SIMemoryLegalizer::MemOpInfo> SIMemoryLegalizer::getStoreInfo(
+Optional<SIMemOpInfo> SIMemoryLegalizer::getStoreInfo(
     const MachineBasicBlock::iterator &MI) const {
   assert(MI->getDesc().TSFlags & SIInstrFlags::maybeAtomic);
 
   if (!(!MI->mayLoad() && MI->mayStore()))
     return None;
   if (!MI->hasOneMemOperand())
-    return MemOpInfo();
+    return SIMemOpInfo();
 
   const MachineMemOperand *MMO = *MI->memoperands_begin();
   if (!MMO->isAtomic())
     return None;
 
-  return MemOpInfo(MMO);
+  return SIMemOpInfo(MMO);
 }
 
-Optional<SIMemoryLegalizer::MemOpInfo> SIMemoryLegalizer::getAtomicFenceInfo(
+Optional<SIMemOpInfo> SIMemoryLegalizer::getAtomicFenceInfo(
     const MachineBasicBlock::iterator &MI) const {
   assert(MI->getDesc().TSFlags & SIInstrFlags::maybeAtomic);
 
   if (MI->getOpcode() != AMDGPU::ATOMIC_FENCE)
     return None;
 
   SyncScope::ID SSID =
       static_cast<SyncScope::ID>(MI->getOperand(1).getImm());
   AtomicOrdering Ordering =
       static_cast<AtomicOrdering>(MI->getOperand(0).getImm());
-  return MemOpInfo(SSID, Ordering, AtomicOrdering::NotAtomic);
+  return SIMemOpInfo(SSID, Ordering, AtomicOrdering::NotAtomic);
 }
 
-Optional<SIMemoryLegalizer::MemOpInfo> SIMemoryLegalizer::getAtomicCmpxchgInfo(
+Optional<SIMemOpInfo> SIMemoryLegalizer::getAtomicCmpxchgInfo(
     const MachineBasicBlock::iterator &MI) const {
   assert(MI->getDesc().TSFlags & SIInstrFlags::maybeAtomic);
 
   if (!(MI->mayLoad() && MI->mayStore()))
     return None;
   if (!MI->hasOneMemOperand())
-    return MemOpInfo();
+    return SIMemOpInfo();
 
   const MachineMemOperand *MMO = *MI->memoperands_begin();
   if (!MMO->isAtomic())
     return None;
   if (MMO->getFailureOrdering() == AtomicOrdering::NotAtomic)
     return None;
 
-  return MemOpInfo(MMO);
+  return SIMemOpInfo(MMO);
 }
 
-Optional<SIMemoryLegalizer::MemOpInfo> SIMemoryLegalizer::getAtomicRmwInfo(
+Optional<SIMemOpInfo> SIMemoryLegalizer::getAtomicRmwInfo(
     const MachineBasicBlock::iterator &MI) const {
   assert(MI->getDesc().TSFlags & SIInstrFlags::maybeAtomic);
 
   if (!(MI->mayLoad() && MI->mayStore()))
     return None;
   if (!MI->hasOneMemOperand())
-    return MemOpInfo();
+    return SIMemOpInfo();
 
   const MachineMemOperand *MMO = *MI->memoperands_begin();
   if (!MMO->isAtomic())
     return None;
   if (MMO->getFailureOrdering() != AtomicOrdering::NotAtomic)
     return None;
 
-  return MemOpInfo(MMO);
+  return SIMemOpInfo(MMO);
 }
 
-bool SIMemoryLegalizer::expandLoad(const MemOpInfo &MOI,
+bool SIMemoryLegalizer::expandLoad(const SIMemOpInfo &MOI,
                                    MachineBasicBlock::iterator &MI) {
   assert(MI->mayLoad() && !MI->mayStore());
 
   bool Changed = false;
   if (MOI.SSID == SyncScope::System ||
       MOI.SSID == MMI->getAgentSSID()) {
     if (MOI.Ordering == AtomicOrdering::Acquire ||
         MOI.Ordering == AtomicOrdering::SequentiallyConsistent)
return Changed;
              MOI.SSID == MMI->getWavefrontSSID()) {
     return Changed;
   } else {
     reportUnknownSynchScope(MI);
     return Changed;
   }
 }
 
-bool SIMemoryLegalizer::expandStore(const MemOpInfo &MOI,
+bool SIMemoryLegalizer::expandStore(const SIMemOpInfo &MOI,
                                     MachineBasicBlock::iterator &MI) {
   assert(!MI->mayLoad() && MI->mayStore());
 
   bool Changed = false;
   if (MOI.SSID == SyncScope::System ||
       MOI.SSID == MMI->getAgentSSID()) {
     if (MOI.Ordering == AtomicOrdering::Release ||
         MOI.Ordering == AtomicOrdering::SequentiallyConsistent)
       Changed |= insertWaitcntVmcnt0(MI);
 
     return Changed;
   } else if (MOI.SSID == SyncScope::SingleThread ||
              MOI.SSID == MMI->getWorkgroupSSID() ||
              MOI.SSID == MMI->getWavefrontSSID()) {
     return Changed;
   } else {
     reportUnknownSynchScope(MI);
     return Changed;
   }
 }
 
-bool SIMemoryLegalizer::expandAtomicFence(const MemOpInfo &MOI,
+bool SIMemoryLegalizer::expandAtomicFence(const SIMemOpInfo &MOI,
                                           MachineBasicBlock::iterator &MI) {
   assert(MI->getOpcode() == AMDGPU::ATOMIC_FENCE);
 
   bool Changed = false;
   if (MOI.SSID == SyncScope::System ||
       MOI.SSID == MMI->getAgentSSID()) {
     if (MOI.Ordering == AtomicOrdering::Acquire ||
         MOI.Ordering == AtomicOrdering::Release ||
if (MOI.SSID == SyncScope::System ||
     AtomicPseudoMIs.push_back(MI);
     return Changed;
   } else {
     reportUnknownSynchScope(MI);
     return Changed;
   }
 }
 
-bool SIMemoryLegalizer::expandAtomicCmpxchg(const MemOpInfo &MOI,
+bool SIMemoryLegalizer::expandAtomicCmpxchg(const SIMemOpInfo &MOI,
                                             MachineBasicBlock::iterator &MI) {
   assert(MI->mayLoad() && MI->mayStore());
 
   bool Changed = false;
   if (MOI.SSID == SyncScope::System ||
       MOI.SSID == MMI->getAgentSSID()) {
     if (MOI.Ordering == AtomicOrdering::Release ||
         MOI.Ordering == AtomicOrdering::AcquireRelease ||
if (MOI.SSID == SyncScope::System ||
     Changed |= setGLC(MI);
     return Changed;
   } else {
     reportUnknownSynchScope(MI);
     return Changed;
   }
 }
 
-bool SIMemoryLegalizer::expandAtomicRmw(const MemOpInfo &MOI,
+bool SIMemoryLegalizer::expandAtomicRmw(const SIMemOpInfo &MOI,
                                         MachineBasicBlock::iterator &MI) {
   assert(MI->mayLoad() && MI->mayStore());
 
   bool Changed = false;
   if (MOI.SSID == SyncScope::System ||
       MOI.SSID == MMI->getAgentSSID()) {
     if (MOI.Ordering == AtomicOrdering::Release ||
         MOI.Ordering == AtomicOrdering::AcquireRelease ||