LCOV - code coverage report
Current view: top level - lib/Target/AMDGPU - AMDGPUSubtarget.h (source / functions) Hit Total Coverage
Test: llvm-toolchain.info Lines: 100 100 100.0 %
Date: 2017-09-14 15:23:50 Functions: 24 27 88.9 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : //=====-- AMDGPUSubtarget.h - Define Subtarget for AMDGPU ------*- 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             : /// \brief AMDGPU specific subclass of TargetSubtarget.
      12             : //
      13             : //===----------------------------------------------------------------------===//
      14             : 
      15             : #ifndef LLVM_LIB_TARGET_AMDGPU_AMDGPUSUBTARGET_H
      16             : #define LLVM_LIB_TARGET_AMDGPU_AMDGPUSUBTARGET_H
      17             : 
      18             : #include "AMDGPU.h"
      19             : #include "AMDGPUCallLowering.h"
      20             : #include "R600FrameLowering.h"
      21             : #include "R600ISelLowering.h"
      22             : #include "R600InstrInfo.h"
      23             : #include "SIFrameLowering.h"
      24             : #include "SIISelLowering.h"
      25             : #include "SIInstrInfo.h"
      26             : #include "SIMachineFunctionInfo.h"
      27             : #include "Utils/AMDGPUBaseInfo.h"
      28             : #include "llvm/ADT/Triple.h"
      29             : #include "llvm/CodeGen/GlobalISel/InstructionSelector.h"
      30             : #include "llvm/CodeGen/GlobalISel/LegalizerInfo.h"
      31             : #include "llvm/CodeGen/GlobalISel/RegisterBankInfo.h"
      32             : #include "llvm/CodeGen/MachineFunction.h"
      33             : #include "llvm/CodeGen/SelectionDAGTargetInfo.h"
      34             : #include "llvm/MC/MCInstrItineraries.h"
      35             : #include "llvm/Support/MathExtras.h"
      36             : #include <cassert>
      37             : #include <cstdint>
      38             : #include <memory>
      39             : #include <utility>
      40             : 
      41             : #define GET_SUBTARGETINFO_HEADER
      42             : #include "AMDGPUGenSubtargetInfo.inc"
      43             : 
      44             : namespace llvm {
      45             : 
      46             : class StringRef;
      47             : 
      48        6120 : class AMDGPUSubtarget : public AMDGPUGenSubtargetInfo {
      49             : public:
      50             :   enum Generation {
      51             :     R600 = 0,
      52             :     R700,
      53             :     EVERGREEN,
      54             :     NORTHERN_ISLANDS,
      55             :     SOUTHERN_ISLANDS,
      56             :     SEA_ISLANDS,
      57             :     VOLCANIC_ISLANDS,
      58             :     GFX9,
      59             :   };
      60             : 
      61             :   enum {
      62             :     ISAVersion0_0_0,
      63             :     ISAVersion6_0_0,
      64             :     ISAVersion6_0_1,
      65             :     ISAVersion7_0_0,
      66             :     ISAVersion7_0_1,
      67             :     ISAVersion7_0_2,
      68             :     ISAVersion7_0_3,
      69             :     ISAVersion8_0_0,
      70             :     ISAVersion8_0_1,
      71             :     ISAVersion8_0_2,
      72             :     ISAVersion8_0_3,
      73             :     ISAVersion8_0_4,
      74             :     ISAVersion8_1_0,
      75             :     ISAVersion9_0_0,
      76             :     ISAVersion9_0_1,
      77             :     ISAVersion9_0_2,
      78             :     ISAVersion9_0_3
      79             :   };
      80             : 
      81             :   enum TrapHandlerAbi {
      82             :     TrapHandlerAbiNone = 0,
      83             :     TrapHandlerAbiHsa = 1
      84             :   };
      85             : 
      86             :   enum TrapID {
      87             :     TrapIDHardwareReserved = 0,
      88             :     TrapIDHSADebugTrap = 1,
      89             :     TrapIDLLVMTrap = 2,
      90             :     TrapIDLLVMDebugTrap = 3,
      91             :     TrapIDDebugBreakpoint = 7,
      92             :     TrapIDDebugReserved8 = 8,
      93             :     TrapIDDebugReservedFE = 0xfe,
      94             :     TrapIDDebugReservedFF = 0xff
      95             :   };
      96             : 
      97             :   enum TrapRegValues {
      98             :     LLVMTrapHandlerRegValue = 1
      99             :   };
     100             : 
     101             : protected:
     102             :   // Basic subtarget description.
     103             :   Triple TargetTriple;
     104             :   Generation Gen;
     105             :   unsigned IsaVersion;
     106             :   unsigned WavefrontSize;
     107             :   int LocalMemorySize;
     108             :   int LDSBankCount;
     109             :   unsigned MaxPrivateElementSize;
     110             : 
     111             :   // Possibly statically set by tablegen, but may want to be overridden.
     112             :   bool FastFMAF32;
     113             :   bool HalfRate64Ops;
     114             : 
     115             :   // Dynamially set bits that enable features.
     116             :   bool FP32Denormals;
     117             :   bool FP64FP16Denormals;
     118             :   bool FPExceptions;
     119             :   bool DX10Clamp;
     120             :   bool FlatForGlobal;
     121             :   bool AutoWaitcntBeforeBarrier;
     122             :   bool UnalignedScratchAccess;
     123             :   bool UnalignedBufferAccess;
     124             :   bool HasApertureRegs;
     125             :   bool EnableXNACK;
     126             :   bool TrapHandler;
     127             :   bool DebuggerInsertNops;
     128             :   bool DebuggerReserveRegs;
     129             :   bool DebuggerEmitPrologue;
     130             : 
     131             :   // Used as options.
     132             :   bool EnableVGPRSpilling;
     133             :   bool EnablePromoteAlloca;
     134             :   bool EnableLoadStoreOpt;
     135             :   bool EnableUnsafeDSOffsetFolding;
     136             :   bool EnableSIScheduler;
     137             :   bool DumpCode;
     138             : 
     139             :   // Subtarget statically properties set by tablegen
     140             :   bool FP64;
     141             :   bool IsGCN;
     142             :   bool GCN3Encoding;
     143             :   bool CIInsts;
     144             :   bool GFX9Insts;
     145             :   bool SGPRInitBug;
     146             :   bool HasSMemRealTime;
     147             :   bool Has16BitInsts;
     148             :   bool HasIntClamp;
     149             :   bool HasVOP3PInsts;
     150             :   bool HasMovrel;
     151             :   bool HasVGPRIndexMode;
     152             :   bool HasScalarStores;
     153             :   bool HasInv2PiInlineImm;
     154             :   bool HasSDWA;
     155             :   bool HasSDWAOmod;
     156             :   bool HasSDWAScalar;
     157             :   bool HasSDWASdst;
     158             :   bool HasSDWAMac;
     159             :   bool HasSDWAOutModsVOPC;
     160             :   bool HasDPP;
     161             :   bool FlatAddressSpace;
     162             :   bool FlatInstOffsets;
     163             :   bool FlatGlobalInsts;
     164             :   bool FlatScratchInsts;
     165             :   bool AddNoCarryInsts;
     166             :   bool R600ALUInst;
     167             :   bool CaymanISA;
     168             :   bool CFALUBug;
     169             :   bool HasVertexCache;
     170             :   short TexVTXClauseSize;
     171             :   bool ScalarizeGlobal;
     172             : 
     173             :   // Dummy feature to use for assembler in tablegen.
     174             :   bool FeatureDisable;
     175             : 
     176             :   InstrItineraryData InstrItins;
     177             :   SelectionDAGTargetInfo TSInfo;
     178             :   AMDGPUAS AS;
     179             : 
     180             : public:
     181             :   AMDGPUSubtarget(const Triple &TT, StringRef GPU, StringRef FS,
     182             :                   const TargetMachine &TM);
     183             :   ~AMDGPUSubtarget() override;
     184             : 
     185             :   AMDGPUSubtarget &initializeSubtargetDependencies(const Triple &TT,
     186             :                                                    StringRef GPU, StringRef FS);
     187             : 
     188             :   const AMDGPUInstrInfo *getInstrInfo() const override = 0;
     189             :   const AMDGPUFrameLowering *getFrameLowering() const override = 0;
     190             :   const AMDGPUTargetLowering *getTargetLowering() const override = 0;
     191             :   const AMDGPURegisterInfo *getRegisterInfo() const override = 0;
     192             : 
     193       49240 :   const InstrItineraryData *getInstrItineraryData() const override {
     194       49240 :     return &InstrItins;
     195             :   }
     196             : 
     197             :   // Nothing implemented, just prevent crashes on use.
     198       22170 :   const SelectionDAGTargetInfo *getSelectionDAGInfo() const override {
     199       22170 :     return &TSInfo;
     200             :   }
     201             : 
     202             :   void ParseSubtargetFeatures(StringRef CPU, StringRef FS);
     203             : 
     204             :   bool isAmdHsaOS() const {
     205      224642 :     return TargetTriple.getOS() == Triple::AMDHSA;
     206             :   }
     207             : 
     208             :   bool isMesa3DOS() const {
     209      104854 :     return TargetTriple.getOS() == Triple::Mesa3D;
     210             :   }
     211             : 
     212        1664 :   bool isOpenCLEnv() const {
     213        1664 :     return TargetTriple.getEnvironment() == Triple::OpenCL ||
     214        3319 :            TargetTriple.getEnvironmentName() == "amdgizcl";
     215             :   }
     216             : 
     217             :   Generation getGeneration() const {
     218             :     return Gen;
     219             :   }
     220             : 
     221             :   unsigned getWavefrontSize() const {
     222             :     return WavefrontSize;
     223             :   }
     224             : 
     225             :   int getLocalMemorySize() const {
     226             :     return LocalMemorySize;
     227             :   }
     228             : 
     229             :   int getLDSBankCount() const {
     230             :     return LDSBankCount;
     231             :   }
     232             : 
     233             :   unsigned getMaxPrivateElementSize() const {
     234             :     return MaxPrivateElementSize;
     235             :   }
     236             : 
     237             :   AMDGPUAS getAMDGPUAS() const {
     238      113324 :     return AS;
     239             :   }
     240             : 
     241             :   bool has16BitInsts() const {
     242             :     return Has16BitInsts;
     243             :   }
     244             : 
     245             :   bool hasIntClamp() const {
     246             :     return HasIntClamp;
     247             :   }
     248             : 
     249             :   bool hasVOP3PInsts() const {
     250             :     return HasVOP3PInsts;
     251             :   }
     252             : 
     253             :   bool hasHWFP64() const {
     254             :     return FP64;
     255             :   }
     256             : 
     257             :   bool hasFastFMAF32() const {
     258             :     return FastFMAF32;
     259             :   }
     260             : 
     261             :   bool hasHalfRate64Ops() const {
     262             :     return HalfRate64Ops;
     263             :   }
     264             : 
     265             :   bool hasAddr64() const {
     266       56532 :     return (getGeneration() < VOLCANIC_ISLANDS);
     267             :   }
     268             : 
     269             :   bool hasBFE() const {
     270        2808 :     return (getGeneration() >= EVERGREEN);
     271             :   }
     272             : 
     273             :   bool hasBFI() const {
     274        2049 :     return (getGeneration() >= EVERGREEN);
     275             :   }
     276             : 
     277             :   bool hasBFM() const {
     278             :     return hasBFE();
     279             :   }
     280             : 
     281             :   bool hasBCNT(unsigned Size) const {
     282             :     if (Size == 32)
     283        2049 :       return (getGeneration() >= EVERGREEN);
     284             : 
     285             :     if (Size == 64)
     286        2049 :       return (getGeneration() >= SOUTHERN_ISLANDS);
     287             : 
     288             :     return false;
     289             :   }
     290             : 
     291             :   bool hasMulU24() const {
     292        2805 :     return (getGeneration() >= EVERGREEN);
     293             :   }
     294             : 
     295             :   bool hasMulI24() const {
     296        1917 :     return (getGeneration() >= SOUTHERN_ISLANDS ||
     297         412 :             hasCaymanISA());
     298             :   }
     299             : 
     300             :   bool hasFFBL() const {
     301        2049 :     return (getGeneration() >= EVERGREEN);
     302             :   }
     303             : 
     304             :   bool hasFFBH() const {
     305        2049 :     return (getGeneration() >= EVERGREEN);
     306             :   }
     307             : 
     308             :   bool hasMed3_16() const {
     309           9 :     return getGeneration() >= GFX9;
     310             :   }
     311             : 
     312             :   bool hasMin3Max3_16() const {
     313         199 :     return getGeneration() >= GFX9;
     314             :   }
     315             : 
     316             :   bool hasMadMixInsts() const {
     317        1139 :     return getGeneration() >= GFX9;
     318             :   }
     319             : 
     320             :   bool hasCARRY() const {
     321         253 :     return (getGeneration() >= EVERGREEN);
     322             :   }
     323             : 
     324             :   bool hasBORROW() const {
     325         253 :     return (getGeneration() >= EVERGREEN);
     326             :   }
     327             : 
     328             :   bool hasCaymanISA() const {
     329             :     return CaymanISA;
     330             :   }
     331             : 
     332             :   TrapHandlerAbi getTrapHandlerAbi() const {
     333          36 :     return isAmdHsaOS() ? TrapHandlerAbiHsa : TrapHandlerAbiNone;
     334             :   }
     335             : 
     336             :   bool isPromoteAllocaEnabled() const {
     337             :     return EnablePromoteAlloca;
     338             :   }
     339             : 
     340             :   bool unsafeDSOffsetFoldingEnabled() const {
     341             :     return EnableUnsafeDSOffsetFolding;
     342             :   }
     343             : 
     344             :   bool dumpCode() const {
     345             :     return DumpCode;
     346             :   }
     347             : 
     348             :   /// Return the amount of LDS that can be used that will not restrict the
     349             :   /// occupancy lower than WaveCount.
     350             :   unsigned getMaxLocalMemSizeWithWaveCount(unsigned WaveCount,
     351             :                                            const Function &) const;
     352             : 
     353             :   /// Inverse of getMaxLocalMemWithWaveCount. Return the maximum wavecount if
     354             :   /// the given LDS memory size is the only constraint.
     355             :   unsigned getOccupancyWithLocalMemSize(uint32_t Bytes, const Function &) const;
     356             : 
     357           6 :   unsigned getOccupancyWithLocalMemSize(const MachineFunction &MF) const {
     358           6 :     const auto *MFI = MF.getInfo<SIMachineFunctionInfo>();
     359           6 :     return getOccupancyWithLocalMemSize(MFI->getLDSSize(), *MF.getFunction());
     360             :   }
     361             : 
     362             :   bool hasFP16Denormals() const {
     363             :     return FP64FP16Denormals;
     364             :   }
     365             : 
     366             :   bool hasFP32Denormals() const {
     367             :     return FP32Denormals;
     368             :   }
     369             : 
     370             :   bool hasFP64Denormals() const {
     371             :     return FP64FP16Denormals;
     372             :   }
     373             : 
     374             :   bool supportsMinMaxDenormModes() const {
     375          44 :     return getGeneration() >= AMDGPUSubtarget::GFX9;
     376             :   }
     377             : 
     378             :   bool hasFPExceptions() const {
     379             :     return FPExceptions;
     380             :   }
     381             : 
     382             :   bool enableDX10Clamp() const {
     383             :     return DX10Clamp;
     384             :   }
     385             : 
     386             :   bool enableIEEEBit(const MachineFunction &MF) const {
     387       87408 :     return AMDGPU::isCompute(MF.getFunction()->getCallingConv());
     388             :   }
     389             : 
     390             :   bool useFlatForGlobal() const {
     391             :     return FlatForGlobal;
     392             :   }
     393             : 
     394             :   bool hasAutoWaitcntBeforeBarrier() const {
     395             :     return AutoWaitcntBeforeBarrier;
     396             :   }
     397             : 
     398             :   bool hasUnalignedBufferAccess() const {
     399             :     return UnalignedBufferAccess;
     400             :   }
     401             : 
     402             :   bool hasUnalignedScratchAccess() const {
     403             :     return UnalignedScratchAccess;
     404             :   }
     405             : 
     406             :   bool hasApertureRegs() const {
     407             :    return HasApertureRegs;
     408             :   }
     409             : 
     410             :   bool isTrapHandlerEnabled() const {
     411             :     return TrapHandler;
     412             :   }
     413             : 
     414             :   bool isXNACKEnabled() const {
     415             :     return EnableXNACK;
     416             :   }
     417             : 
     418             :   bool hasFlatAddressSpace() const {
     419             :     return FlatAddressSpace;
     420             :   }
     421             : 
     422             :   bool hasFlatInstOffsets() const {
     423             :     return FlatInstOffsets;
     424             :   }
     425             : 
     426             :   bool hasFlatGlobalInsts() const {
     427             :     return FlatGlobalInsts;
     428             :   }
     429             : 
     430             :   bool hasFlatScratchInsts() const {
     431             :     return FlatScratchInsts;
     432             :   }
     433             : 
     434             :   bool hasD16LoadStore() const {
     435             :     return getGeneration() >= GFX9;
     436             :   }
     437             : 
     438             :   bool hasAddNoCarry() const {
     439             :     return AddNoCarryInsts;
     440             :   }
     441             : 
     442             :   bool isMesaKernel(const MachineFunction &MF) const {
     443       91791 :     return isMesa3DOS() && !AMDGPU::isShader(MF.getFunction()->getCallingConv());
     444             :   }
     445             : 
     446             :   // Covers VS/PS/CS graphics shaders
     447             :   bool isMesaGfxShader(const MachineFunction &MF) const {
     448       13947 :     return isMesa3DOS() && AMDGPU::isShader(MF.getFunction()->getCallingConv());
     449             :   }
     450             : 
     451      100249 :   bool isAmdCodeObjectV2(const MachineFunction &MF) const {
     452      200498 :     return isAmdHsaOS() || isMesaKernel(MF);
     453             :   }
     454             : 
     455             :   bool hasFminFmaxLegacy() const {
     456         572 :     return getGeneration() < AMDGPUSubtarget::VOLCANIC_ISLANDS;
     457             :   }
     458             : 
     459             :   bool hasSDWA() const {
     460             :     return HasSDWA;
     461             :   }
     462             : 
     463             :   bool hasSDWAOmod() const {
     464             :     return HasSDWAOmod;
     465             :   }
     466             : 
     467             :   bool hasSDWAScalar() const {
     468             :     return HasSDWAScalar;
     469             :   }
     470             : 
     471             :   bool hasSDWASdst() const {
     472             :     return HasSDWASdst;
     473             :   }
     474             : 
     475             :   bool hasSDWAMac() const {
     476             :     return HasSDWAMac;
     477             :   }
     478             : 
     479             :   bool hasSDWAOutModsVOPC() const {
     480             :     return HasSDWAOutModsVOPC;
     481             :   }
     482             : 
     483             :   /// \brief Returns the offset in bytes from the start of the input buffer
     484             :   ///        of the first explicit kernel argument.
     485             :   unsigned getExplicitKernelArgOffset(const MachineFunction &MF) const {
     486       37256 :     return isAmdCodeObjectV2(MF) ? 0 : 36;
     487             :   }
     488             : 
     489             :   unsigned getAlignmentForImplicitArgPtr() const {
     490         125 :     return isAmdHsaOS() ? 8 : 4;
     491             :   }
     492             : 
     493        1745 :   unsigned getImplicitArgNumBytes(const MachineFunction &MF) const {
     494             :     if (isMesaKernel(MF))
     495             :       return 16;
     496        1664 :     if (isAmdHsaOS() && isOpenCLEnv())
     497             :       return 32;
     498             :     return 0;
     499             :   }
     500             : 
     501             :   // Scratch is allocated in 256 dword per wave blocks for the entire
     502             :   // wavefront. When viewed from the perspecive of an arbitrary workitem, this
     503             :   // is 4-byte aligned.
     504             :   unsigned getStackAlignment() const {
     505             :     return 4;
     506             :   }
     507             : 
     508       52074 :   bool enableMachineScheduler() const override {
     509       52074 :     return true;
     510             :   }
     511             : 
     512       17168 :   bool enableSubRegLiveness() const override {
     513       17168 :     return true;
     514             :   }
     515             : 
     516      363267 :   void setScalarizeGlobalBehavior(bool b) { ScalarizeGlobal = b;}
     517             :   bool getScalarizeGlobalBehavior() const { return ScalarizeGlobal;}
     518             : 
     519             :   /// \returns Number of execution units per compute unit supported by the
     520             :   /// subtarget.
     521             :   unsigned getEUsPerCU() const {
     522             :     return AMDGPU::IsaInfo::getEUsPerCU(getFeatureBits());
     523             :   }
     524             : 
     525             :   /// \returns Maximum number of work groups per compute unit supported by the
     526             :   /// subtarget and limited by given \p FlatWorkGroupSize.
     527             :   unsigned getMaxWorkGroupsPerCU(unsigned FlatWorkGroupSize) const {
     528      276906 :     return AMDGPU::IsaInfo::getMaxWorkGroupsPerCU(getFeatureBits(),
     529      138453 :                                                   FlatWorkGroupSize);
     530             :   }
     531             : 
     532             :   /// \returns Maximum number of waves per compute unit supported by the
     533             :   /// subtarget without any kind of limitation.
     534             :   unsigned getMaxWavesPerCU() const {
     535             :     return AMDGPU::IsaInfo::getMaxWavesPerCU(getFeatureBits());
     536             :   }
     537             : 
     538             :   /// \returns Maximum number of waves per compute unit supported by the
     539             :   /// subtarget and limited by given \p FlatWorkGroupSize.
     540             :   unsigned getMaxWavesPerCU(unsigned FlatWorkGroupSize) const {
     541             :     return AMDGPU::IsaInfo::getMaxWavesPerCU(getFeatureBits(),
     542             :                                              FlatWorkGroupSize);
     543             :   }
     544             : 
     545             :   /// \returns Minimum number of waves per execution unit supported by the
     546             :   /// subtarget.
     547             :   unsigned getMinWavesPerEU() const {
     548       30179 :     return AMDGPU::IsaInfo::getMinWavesPerEU(getFeatureBits());
     549             :   }
     550             : 
     551             :   /// \returns Maximum number of waves per execution unit supported by the
     552             :   /// subtarget without any kind of limitation.
     553             :   unsigned getMaxWavesPerEU() const {
     554      289311 :     return AMDGPU::IsaInfo::getMaxWavesPerEU(getFeatureBits());
     555             :   }
     556             : 
     557             :   /// \returns Maximum number of waves per execution unit supported by the
     558             :   /// subtarget and limited by given \p FlatWorkGroupSize.
     559             :   unsigned getMaxWavesPerEU(unsigned FlatWorkGroupSize) const {
     560       30179 :     return AMDGPU::IsaInfo::getMaxWavesPerEU(getFeatureBits(),
     561       30179 :                                              FlatWorkGroupSize);
     562             :   }
     563             : 
     564             :   /// \returns Minimum flat work group size supported by the subtarget.
     565             :   unsigned getMinFlatWorkGroupSize() const {
     566      374782 :     return AMDGPU::IsaInfo::getMinFlatWorkGroupSize(getFeatureBits());
     567             :   }
     568             : 
     569             :   /// \returns Maximum flat work group size supported by the subtarget.
     570             :   unsigned getMaxFlatWorkGroupSize() const {
     571      187391 :     return AMDGPU::IsaInfo::getMaxFlatWorkGroupSize(getFeatureBits());
     572             :   }
     573             : 
     574             :   /// \returns Number of waves per work group supported by the subtarget and
     575             :   /// limited by given \p FlatWorkGroupSize.
     576             :   unsigned getWavesPerWorkGroup(unsigned FlatWorkGroupSize) const {
     577             :     return AMDGPU::IsaInfo::getWavesPerWorkGroup(getFeatureBits(),
     578             :                                                  FlatWorkGroupSize);
     579             :   }
     580             : 
     581             :   /// \returns Subtarget's default pair of minimum/maximum flat work group sizes
     582             :   /// for function \p F, or minimum/maximum flat work group sizes explicitly
     583             :   /// requested using "amdgpu-flat-work-group-size" attribute attached to
     584             :   /// function \p F.
     585             :   ///
     586             :   /// \returns Subtarget's default values if explicitly requested values cannot
     587             :   /// be converted to integer, or violate subtarget's specifications.
     588             :   std::pair<unsigned, unsigned> getFlatWorkGroupSizes(const Function &F) const;
     589             : 
     590             :   /// \returns Subtarget's default pair of minimum/maximum number of waves per
     591             :   /// execution unit for function \p F, or minimum/maximum number of waves per
     592             :   /// execution unit explicitly requested using "amdgpu-waves-per-eu" attribute
     593             :   /// attached to function \p F.
     594             :   ///
     595             :   /// \returns Subtarget's default values if explicitly requested values cannot
     596             :   /// be converted to integer, violate subtarget's specifications, or are not
     597             :   /// compatible with minimum/maximum number of waves limited by flat work group
     598             :   /// size, register usage, and/or lds usage.
     599             :   std::pair<unsigned, unsigned> getWavesPerEU(const Function &F) const;
     600             : 
     601             :   /// Creates value range metadata on an workitemid.* inrinsic call or load.
     602             :   bool makeLIDRangeMetadata(Instruction *I) const;
     603             : };
     604             : 
     605        1008 : class R600Subtarget final : public AMDGPUSubtarget {
     606             : private:
     607             :   R600InstrInfo InstrInfo;
     608             :   R600FrameLowering FrameLowering;
     609             :   R600TargetLowering TLInfo;
     610             : 
     611             : public:
     612             :   R600Subtarget(const Triple &TT, StringRef CPU, StringRef FS,
     613             :                 const TargetMachine &TM);
     614             : 
     615      512596 :   const R600InstrInfo *getInstrInfo() const override {
     616      932638 :     return &InstrInfo;
     617             :   }
     618             : 
     619       25080 :   const R600FrameLowering *getFrameLowering() const override {
     620       27422 :     return &FrameLowering;
     621             :   }
     622             : 
     623      105799 :   const R600TargetLowering *getTargetLowering() const override {
     624      105799 :     return &TLInfo;
     625             :   }
     626             : 
     627     1508294 :   const R600RegisterInfo *getRegisterInfo() const override {
     628     3030006 :     return &InstrInfo.getRegisterInfo();
     629             :   }
     630             : 
     631             :   bool hasCFAluBug() const {
     632             :     return CFALUBug;
     633             :   }
     634             : 
     635             :   bool hasVertexCache() const {
     636             :     return HasVertexCache;
     637             :   }
     638             : 
     639             :   short getTexVTXClauseSize() const {
     640             :     return TexVTXClauseSize;
     641             :   }
     642             : };
     643             : 
     644       16092 : class SISubtarget final : public AMDGPUSubtarget {
     645             : private:
     646             :   SIInstrInfo InstrInfo;
     647             :   SIFrameLowering FrameLowering;
     648             :   SITargetLowering TLInfo;
     649             : 
     650             :   /// GlobalISel related APIs.
     651             :   std::unique_ptr<AMDGPUCallLowering> CallLoweringInfo;
     652             :   std::unique_ptr<InstructionSelector> InstSelector;
     653             :   std::unique_ptr<LegalizerInfo> Legalizer;
     654             :   std::unique_ptr<RegisterBankInfo> RegBankInfo;
     655             : 
     656             : public:
     657             :   SISubtarget(const Triple &TT, StringRef CPU, StringRef FS,
     658             :               const TargetMachine &TM);
     659             : 
     660     3268185 :   const SIInstrInfo *getInstrInfo() const override {
     661     4017437 :     return &InstrInfo;
     662             :   }
     663             : 
     664      180529 :   const SIFrameLowering *getFrameLowering() const override {
     665      180529 :     return &FrameLowering;
     666             :   }
     667             : 
     668      916000 :   const SITargetLowering *getTargetLowering() const override {
     669      916000 :     return &TLInfo;
     670             :   }
     671             : 
     672          20 :   const CallLowering *getCallLowering() const override {
     673          40 :     return CallLoweringInfo.get();
     674             :   }
     675             : 
     676          20 :   const InstructionSelector *getInstructionSelector() const override {
     677          40 :     return InstSelector.get();
     678             :   }
     679             : 
     680          23 :   const LegalizerInfo *getLegalizerInfo() const override {
     681          46 :     return Legalizer.get();
     682             :   }
     683             : 
     684         123 :   const RegisterBankInfo *getRegBankInfo() const override {
     685         246 :     return RegBankInfo.get();
     686             :   }
     687             : 
     688    23949432 :   const SIRegisterInfo *getRegisterInfo() const override {
     689    50072724 :     return &InstrInfo.getRegisterInfo();
     690             :   }
     691             : 
     692             :   // XXX - Why is this here if it isn't in the default pass set?
     693          22 :   bool enableEarlyIfConversion() const override {
     694          22 :     return true;
     695             :   }
     696             : 
     697             :   void overrideSchedPolicy(MachineSchedPolicy &Policy,
     698             :                            unsigned NumRegionInstrs) const override;
     699             : 
     700             :   bool isVGPRSpillingEnabled(const Function& F) const;
     701             : 
     702             :   unsigned getMaxNumUserSGPRs() const {
     703             :     return 16;
     704             :   }
     705             : 
     706             :   bool hasSMemRealTime() const {
     707             :     return HasSMemRealTime;
     708             :   }
     709             : 
     710             :   bool hasMovrel() const {
     711             :     return HasMovrel;
     712             :   }
     713             : 
     714             :   bool hasVGPRIndexMode() const {
     715             :     return HasVGPRIndexMode;
     716             :   }
     717             : 
     718             :   bool useVGPRIndexMode(bool UserEnable) const {
     719         172 :     return !hasMovrel() || (UserEnable && hasVGPRIndexMode());
     720             :   }
     721             : 
     722             :   bool hasScalarCompareEq64() const {
     723          37 :     return getGeneration() >= VOLCANIC_ISLANDS;
     724             :   }
     725             : 
     726             :   bool hasScalarStores() const {
     727             :     return HasScalarStores;
     728             :   }
     729             : 
     730             :   bool hasInv2PiInlineImm() const {
     731             :     return HasInv2PiInlineImm;
     732             :   }
     733             : 
     734             :   bool hasDPP() const {
     735             :     return HasDPP;
     736             :   }
     737             : 
     738             :   bool enableSIScheduler() const {
     739             :     return EnableSIScheduler;
     740             :   }
     741             : 
     742             :   bool debuggerSupported() const {
     743        1748 :     return debuggerInsertNops() && debuggerReserveRegs() &&
     744           3 :       debuggerEmitPrologue();
     745             :   }
     746             : 
     747             :   bool debuggerInsertNops() const {
     748             :     return DebuggerInsertNops;
     749             :   }
     750             : 
     751             :   bool debuggerReserveRegs() const {
     752             :     return DebuggerReserveRegs;
     753             :   }
     754             : 
     755             :   bool debuggerEmitPrologue() const {
     756             :     return DebuggerEmitPrologue;
     757             :   }
     758             : 
     759             :   bool loadStoreOptEnabled() const {
     760             :     return EnableLoadStoreOpt;
     761             :   }
     762             : 
     763             :   bool hasSGPRInitBug() const {
     764             :     return SGPRInitBug;
     765             :   }
     766             : 
     767             :   bool has12DWordStoreHazard() const {
     768      276005 :     return getGeneration() != AMDGPUSubtarget::SOUTHERN_ISLANDS;
     769             :   }
     770             : 
     771             :   bool hasSMovFedHazard() const {
     772      616943 :     return getGeneration() >= AMDGPUSubtarget::GFX9;
     773             :   }
     774             : 
     775             :   bool hasReadM0Hazard() const {
     776        1171 :     return getGeneration() >= AMDGPUSubtarget::GFX9;
     777             :   }
     778             : 
     779             :   unsigned getKernArgSegmentSize(const MachineFunction &MF,
     780             :                                  unsigned ExplictArgBytes) const;
     781             : 
     782             :   /// Return the maximum number of waves per SIMD for kernels using \p SGPRs SGPRs
     783             :   unsigned getOccupancyWithNumSGPRs(unsigned SGPRs) const;
     784             : 
     785             :   /// Return the maximum number of waves per SIMD for kernels using \p VGPRs VGPRs
     786             :   unsigned getOccupancyWithNumVGPRs(unsigned VGPRs) const;
     787             : 
     788             :   /// \returns true if the flat_scratch register should be initialized with the
     789             :   /// pointer to the wave's scratch memory rather than a size and offset.
     790             :   bool flatScratchIsPointer() const {
     791         332 :     return getGeneration() >= GFX9;
     792             :   }
     793             : 
     794             :   /// \returns SGPR allocation granularity supported by the subtarget.
     795             :   unsigned getSGPRAllocGranule() const {
     796             :     return AMDGPU::IsaInfo::getSGPRAllocGranule(getFeatureBits());
     797             :   }
     798             : 
     799             :   /// \returns SGPR encoding granularity supported by the subtarget.
     800             :   unsigned getSGPREncodingGranule() const {
     801       28336 :     return AMDGPU::IsaInfo::getSGPREncodingGranule(getFeatureBits());
     802             :   }
     803             : 
     804             :   /// \returns Total number of SGPRs supported by the subtarget.
     805             :   unsigned getTotalNumSGPRs() const {
     806             :     return AMDGPU::IsaInfo::getTotalNumSGPRs(getFeatureBits());
     807             :   }
     808             : 
     809             :   /// \returns Addressable number of SGPRs supported by the subtarget.
     810             :   unsigned getAddressableNumSGPRs() const {
     811       46710 :     return AMDGPU::IsaInfo::getAddressableNumSGPRs(getFeatureBits());
     812             :   }
     813             : 
     814             :   /// \returns Minimum number of SGPRs that meets the given number of waves per
     815             :   /// execution unit requirement supported by the subtarget.
     816             :   unsigned getMinNumSGPRs(unsigned WavesPerEU) const {
     817       28376 :     return AMDGPU::IsaInfo::getMinNumSGPRs(getFeatureBits(), WavesPerEU);
     818             :   }
     819             : 
     820             :   /// \returns Maximum number of SGPRs that meets the given number of waves per
     821             :   /// execution unit requirement supported by the subtarget.
     822             :   unsigned getMaxNumSGPRs(unsigned WavesPerEU, bool Addressable) const {
     823      412073 :     return AMDGPU::IsaInfo::getMaxNumSGPRs(getFeatureBits(), WavesPerEU,
     824      259187 :                                            Addressable);
     825             :   }
     826             : 
     827             :   /// \returns Reserved number of SGPRs for given function \p MF.
     828             :   unsigned getReservedNumSGPRs(const MachineFunction &MF) const;
     829             : 
     830             :   /// \returns Maximum number of SGPRs that meets number of waves per execution
     831             :   /// unit requirement for function \p MF, or number of SGPRs explicitly
     832             :   /// requested using "amdgpu-num-sgpr" attribute attached to function \p MF.
     833             :   ///
     834             :   /// \returns Value that meets number of waves per execution unit requirement
     835             :   /// if explicitly requested value cannot be converted to integer, violates
     836             :   /// subtarget's specifications, or does not meet number of waves per execution
     837             :   /// unit requirement.
     838             :   unsigned getMaxNumSGPRs(const MachineFunction &MF) const;
     839             : 
     840             :   /// \returns VGPR allocation granularity supported by the subtarget.
     841             :   unsigned getVGPRAllocGranule() const {
     842             :     return AMDGPU::IsaInfo::getVGPRAllocGranule(getFeatureBits());
     843             :   }
     844             : 
     845             :   /// \returns VGPR encoding granularity supported by the subtarget.
     846             :   unsigned getVGPREncodingGranule() const {
     847       28336 :     return AMDGPU::IsaInfo::getVGPREncodingGranule(getFeatureBits());
     848             :   }
     849             : 
     850             :   /// \returns Total number of VGPRs supported by the subtarget.
     851             :   unsigned getTotalNumVGPRs() const {
     852             :     return AMDGPU::IsaInfo::getTotalNumVGPRs(getFeatureBits());
     853             :   }
     854             : 
     855             :   /// \returns Addressable number of VGPRs supported by the subtarget.
     856             :   unsigned getAddressableNumVGPRs() const {
     857       29664 :     return AMDGPU::IsaInfo::getAddressableNumVGPRs(getFeatureBits());
     858             :   }
     859             : 
     860             :   /// \returns Minimum number of VGPRs that meets given number of waves per
     861             :   /// execution unit requirement supported by the subtarget.
     862             :   unsigned getMinNumVGPRs(unsigned WavesPerEU) const {
     863       14174 :     return AMDGPU::IsaInfo::getMinNumVGPRs(getFeatureBits(), WavesPerEU);
     864             :   }
     865             : 
     866             :   /// \returns Maximum number of VGPRs that meets given number of waves per
     867             :   /// execution unit requirement supported by the subtarget.
     868             :   unsigned getMaxNumVGPRs(unsigned WavesPerEU) const {
     869      245657 :     return AMDGPU::IsaInfo::getMaxNumVGPRs(getFeatureBits(), WavesPerEU);
     870             :   }
     871             : 
     872             :   /// \returns Reserved number of VGPRs for given function \p MF.
     873             :   unsigned getReservedNumVGPRs(const MachineFunction &MF) const {
     874      104674 :     return debuggerReserveRegs() ? 4 : 0;
     875             :   }
     876             : 
     877             :   /// \returns Maximum number of VGPRs that meets number of waves per execution
     878             :   /// unit requirement for function \p MF, or number of VGPRs explicitly
     879             :   /// requested using "amdgpu-num-vgpr" attribute attached to function \p MF.
     880             :   ///
     881             :   /// \returns Value that meets number of waves per execution unit requirement
     882             :   /// if explicitly requested value cannot be converted to integer, violates
     883             :   /// subtarget's specifications, or does not meet number of waves per execution
     884             :   /// unit requirement.
     885             :   unsigned getMaxNumVGPRs(const MachineFunction &MF) const;
     886             : };
     887             : 
     888             : } // end namespace llvm
     889             : 
     890             : #endif // LLVM_LIB_TARGET_AMDGPU_AMDGPUSUBTARGET_H

Generated by: LCOV version 1.13