Line data    Source code

       1             : //===--- AMDGPUMachineModuleInfo.h ------------------------------*- C++ -*-===//
       2             : //
       3             : //                     The LLVM Compiler Infrastructure
       4             : //
       5             : // This file is distributed under the University of Illinois Open Source
       6             : // License. See LICENSE.TXT for details.
       7             : //
       8             : //===----------------------------------------------------------------------===//
       9             : //
      10             : /// \file
      11             : /// AMDGPU Machine Module Info.
      12             : ///
      13             : //
      14             : //===----------------------------------------------------------------------===//
      15             : 
      16             : #ifndef LLVM_LIB_TARGET_AMDGPU_AMDGPUMACHINEMODULEINFO_H
      17             : #define LLVM_LIB_TARGET_AMDGPU_AMDGPUMACHINEMODULEINFO_H
      18             : 
      19             : #include "llvm/ADT/None.h"
      20             : #include "llvm/ADT/Optional.h"
      21             : #include "llvm/CodeGen/MachineModuleInfo.h"
      22             : #include "llvm/CodeGen/MachineModuleInfoImpls.h"
      23             : #include "llvm/IR/LLVMContext.h"
      24             : 
      25             : namespace llvm {
      26             : 
      27             : class AMDGPUMachineModuleInfo final : public MachineModuleInfoELF {
      28             : private:
      29             : 
      30             :   // All supported memory/synchronization scopes can be found here:
      31             :   //   http://llvm.org/docs/AMDGPUUsage.html#memory-scopes
      32             : 
      33             :   /// Agent synchronization scope ID.
      34             :   SyncScope::ID AgentSSID;
      35             :   /// Workgroup synchronization scope ID.
      36             :   SyncScope::ID WorkgroupSSID;
      37             :   /// Wavefront synchronization scope ID.
      38             :   SyncScope::ID WavefrontSSID;
      39             : 
      40             :   /// In AMDGPU target synchronization scopes are inclusive, meaning a
      41             :   /// larger synchronization scope is inclusive of a smaller synchronization
      42             :   /// scope.
      43             :   ///
      44             :   /// \returns \p SSID's inclusion ordering, or "None" if \p SSID is not
      45             :   /// supported by the AMDGPU target.
      46             :   Optional<uint8_t> getSyncScopeInclusionOrdering(SyncScope::ID SSID) const {
      47        1445 :     if (SSID == SyncScope::SingleThread)
      48             :       return 0;
      49        1384 :     else if (SSID == getWavefrontSSID())
      50             :       return 1;
      51        1320 :     else if (SSID == getWorkgroupSSID())
      52             :       return 2;
      53        1255 :     else if (SSID == getAgentSSID())
      54             :       return 3;
      55        1189 :     else if (SSID == SyncScope::System)
      56             :       return 4;
      57             : 
      58             :     return None;
      59             :   }
      60             : 
      61             : public:
      62             :   AMDGPUMachineModuleInfo(const MachineModuleInfo &MMI);
      63             : 
      64             :   /// \returns Agent synchronization scope ID.
      65           0 :   SyncScope::ID getAgentSSID() const {
      66           0 :     return AgentSSID;
      67             :   }
      68             :   /// \returns Workgroup synchronization scope ID.
      69           0 :   SyncScope::ID getWorkgroupSSID() const {
      70           0 :     return WorkgroupSSID;
      71             :   }
      72             :   /// \returns Wavefront synchronization scope ID.
      73           0 :   SyncScope::ID getWavefrontSSID() const {
      74           0 :     return WavefrontSSID;
      75             :   }
      76             : 
      77             :   /// In AMDGPU target synchronization scopes are inclusive, meaning a
      78             :   /// larger synchronization scope is inclusive of a smaller synchronization
      79             :   /// scope.
      80             :   ///
      81             :   /// \returns True if synchronization scope \p A is larger than or equal to
      82             :   /// synchronization scope \p B, false if synchronization scope \p A is smaller
      83             :   /// than synchronization scope \p B, or "None" if either synchronization scope
      84             :   /// \p A or \p B is not supported by the AMDGPU target.
      85        1445 :   Optional<bool> isSyncScopeInclusion(SyncScope::ID A, SyncScope::ID B) const {
      86             :     const auto &AIO = getSyncScopeInclusionOrdering(A);
      87             :     const auto &BIO = getSyncScopeInclusionOrdering(B);
      88        1445 :     if (!AIO || !BIO)
      89             :       return None;
      90             : 
      91        1437 :     return AIO.getValue() > BIO.getValue();
      92             :   }
      93             : };
      94             : 
      95             : } // end namespace llvm
      96             : 
      97             : #endif // LLVM_LIB_TARGET_AMDGPU_AMDGPUMACHINEMODULEINFO_H