LCOV - code coverage report
Current view: top level - lib/Target/AMDGPU - AMDGPUSubtarget.h (source / functions) Hit Total Coverage
Test: llvm-toolchain.info Lines: 99 99 100.0 %
Date: 2018-06-17 00:07:59 Functions: 22 25 88.0 %
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             : /// 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 "Utils/AMDGPUBaseInfo.h"
      27             : #include "llvm/ADT/Triple.h"
      28             : #include "llvm/CodeGen/GlobalISel/InstructionSelector.h"
      29             : #include "llvm/CodeGen/GlobalISel/LegalizerInfo.h"
      30             : #include "llvm/CodeGen/GlobalISel/RegisterBankInfo.h"
      31             : #include "llvm/CodeGen/MachineFunction.h"
      32             : #include "llvm/CodeGen/SelectionDAGTargetInfo.h"
      33             : #include "llvm/MC/MCInstrItineraries.h"
      34             : #include "llvm/Support/MathExtras.h"
      35             : #include <cassert>
      36             : #include <cstdint>
      37             : #include <memory>
      38             : #include <utility>
      39             : 
      40             : #define GET_SUBTARGETINFO_HEADER
      41             : #include "AMDGPUGenSubtargetInfo.inc"
      42             : 
      43             : namespace llvm {
      44             : 
      45             : class StringRef;
      46             : 
      47        5036 : class AMDGPUSubtarget : public AMDGPUGenSubtargetInfo {
      48             : public:
      49             :   enum Generation {
      50             :     R600 = 0,
      51             :     R700,
      52             :     EVERGREEN,
      53             :     NORTHERN_ISLANDS,
      54             :     SOUTHERN_ISLANDS,
      55             :     SEA_ISLANDS,
      56             :     VOLCANIC_ISLANDS,
      57             :     GFX9,
      58             :   };
      59             : 
      60             :   enum {
      61             :     ISAVersion0_0_0,
      62             :     ISAVersion6_0_0,
      63             :     ISAVersion6_0_1,
      64             :     ISAVersion7_0_0,
      65             :     ISAVersion7_0_1,
      66             :     ISAVersion7_0_2,
      67             :     ISAVersion7_0_3,
      68             :     ISAVersion7_0_4,
      69             :     ISAVersion8_0_1,
      70             :     ISAVersion8_0_2,
      71             :     ISAVersion8_0_3,
      72             :     ISAVersion8_1_0,
      73             :     ISAVersion9_0_0,
      74             :     ISAVersion9_0_2,
      75             :     ISAVersion9_0_4,
      76             :     ISAVersion9_0_6,
      77             :   };
      78             : 
      79             :   enum TrapHandlerAbi {
      80             :     TrapHandlerAbiNone = 0,
      81             :     TrapHandlerAbiHsa = 1
      82             :   };
      83             : 
      84             :   enum TrapID {
      85             :     TrapIDHardwareReserved = 0,
      86             :     TrapIDHSADebugTrap = 1,
      87             :     TrapIDLLVMTrap = 2,
      88             :     TrapIDLLVMDebugTrap = 3,
      89             :     TrapIDDebugBreakpoint = 7,
      90             :     TrapIDDebugReserved8 = 8,
      91             :     TrapIDDebugReservedFE = 0xfe,
      92             :     TrapIDDebugReservedFF = 0xff
      93             :   };
      94             : 
      95             :   enum TrapRegValues {
      96             :     LLVMTrapHandlerRegValue = 1
      97             :   };
      98             : 
      99             : protected:
     100             :   // Basic subtarget description.
     101             :   Triple TargetTriple;
     102             :   Generation Gen;
     103             :   unsigned IsaVersion;
     104             :   unsigned WavefrontSize;
     105             :   int LocalMemorySize;
     106             :   int LDSBankCount;
     107             :   unsigned MaxPrivateElementSize;
     108             : 
     109             :   // Possibly statically set by tablegen, but may want to be overridden.
     110             :   bool FastFMAF32;
     111             :   bool HalfRate64Ops;
     112             : 
     113             :   // Dynamially set bits that enable features.
     114             :   bool FP32Denormals;
     115             :   bool FP64FP16Denormals;
     116             :   bool FPExceptions;
     117             :   bool DX10Clamp;
     118             :   bool FlatForGlobal;
     119             :   bool AutoWaitcntBeforeBarrier;
     120             :   bool CodeObjectV3;
     121             :   bool UnalignedScratchAccess;
     122             :   bool UnalignedBufferAccess;
     123             :   bool HasApertureRegs;
     124             :   bool EnableXNACK;
     125             :   bool TrapHandler;
     126             :   bool DebuggerInsertNops;
     127             :   bool DebuggerReserveRegs;
     128             :   bool DebuggerEmitPrologue;
     129             : 
     130             :   // Used as options.
     131             :   bool EnableHugePrivateBuffer;
     132             :   bool EnableVGPRSpilling;
     133             :   bool EnablePromoteAlloca;
     134             :   bool EnableLoadStoreOpt;
     135             :   bool EnableUnsafeDSOffsetFolding;
     136             :   bool EnableSIScheduler;
     137             :   bool EnableDS128;
     138             :   bool DumpCode;
     139             : 
     140             :   // Subtarget statically properties set by tablegen
     141             :   bool FP64;
     142             :   bool FMA;
     143             :   bool MIMG_R128;
     144             :   bool IsGCN;
     145             :   bool GCN3Encoding;
     146             :   bool CIInsts;
     147             :   bool GFX9Insts;
     148             :   bool SGPRInitBug;
     149             :   bool HasSMemRealTime;
     150             :   bool Has16BitInsts;
     151             :   bool HasIntClamp;
     152             :   bool HasVOP3PInsts;
     153             :   bool HasMadMixInsts;
     154             :   bool HasFmaMixInsts;
     155             :   bool HasMovrel;
     156             :   bool HasVGPRIndexMode;
     157             :   bool HasScalarStores;
     158             :   bool HasScalarAtomics;
     159             :   bool HasInv2PiInlineImm;
     160             :   bool HasSDWA;
     161             :   bool HasSDWAOmod;
     162             :   bool HasSDWAScalar;
     163             :   bool HasSDWASdst;
     164             :   bool HasSDWAMac;
     165             :   bool HasSDWAOutModsVOPC;
     166             :   bool HasDPP;
     167             :   bool HasDLInsts;
     168             :   bool D16PreservesUnusedBits;
     169             :   bool FlatAddressSpace;
     170             :   bool FlatInstOffsets;
     171             :   bool FlatGlobalInsts;
     172             :   bool FlatScratchInsts;
     173             :   bool AddNoCarryInsts;
     174             :   bool HasUnpackedD16VMem;
     175             :   bool R600ALUInst;
     176             :   bool CaymanISA;
     177             :   bool CFALUBug;
     178             :   bool HasVertexCache;
     179             :   short TexVTXClauseSize;
     180             :   bool ScalarizeGlobal;
     181             : 
     182             :   // Dummy feature to use for assembler in tablegen.
     183             :   bool FeatureDisable;
     184             : 
     185             :   InstrItineraryData InstrItins;
     186             :   SelectionDAGTargetInfo TSInfo;
     187             :   AMDGPUAS AS;
     188             : 
     189             : public:
     190             :   AMDGPUSubtarget(const Triple &TT, StringRef GPU, StringRef FS,
     191             :                   const TargetMachine &TM);
     192             :   ~AMDGPUSubtarget() override;
     193             : 
     194             :   AMDGPUSubtarget &initializeSubtargetDependencies(const Triple &TT,
     195             :                                                    StringRef GPU, StringRef FS);
     196             : 
     197             :   const AMDGPUInstrInfo *getInstrInfo() const override = 0;
     198             :   const AMDGPUFrameLowering *getFrameLowering() const override = 0;
     199             :   const AMDGPUTargetLowering *getTargetLowering() const override = 0;
     200             :   const AMDGPURegisterInfo *getRegisterInfo() const override = 0;
     201             : 
     202       58857 :   const InstrItineraryData *getInstrItineraryData() const override {
     203       58857 :     return &InstrItins;
     204             :   }
     205             : 
     206             :   // Nothing implemented, just prevent crashes on use.
     207       26727 :   const SelectionDAGTargetInfo *getSelectionDAGInfo() const override {
     208       26727 :     return &TSInfo;
     209             :   }
     210             : 
     211             :   void ParseSubtargetFeatures(StringRef CPU, StringRef FS);
     212             : 
     213             :   bool isAmdHsaOS() const {
     214      210661 :     return TargetTriple.getOS() == Triple::AMDHSA;
     215             :   }
     216             : 
     217             :   bool isMesa3DOS() const {
     218       20192 :     return TargetTriple.getOS() == Triple::Mesa3D;
     219             :   }
     220             : 
     221             :   bool isAmdPalOS() const {
     222       19516 :     return TargetTriple.getOS() == Triple::AMDPAL;
     223             :   }
     224             : 
     225             :   Generation getGeneration() const {
     226             :     return Gen;
     227             :   }
     228             : 
     229             :   unsigned getWavefrontSize() const {
     230             :     return WavefrontSize;
     231             :   }
     232             : 
     233             :   unsigned getWavefrontSizeLog2() const {
     234             :     return Log2_32(WavefrontSize);
     235             :   }
     236             : 
     237             :   int getLocalMemorySize() const {
     238             :     return LocalMemorySize;
     239             :   }
     240             : 
     241             :   int getLDSBankCount() const {
     242             :     return LDSBankCount;
     243             :   }
     244             : 
     245             :   unsigned getMaxPrivateElementSize() const {
     246             :     return MaxPrivateElementSize;
     247             :   }
     248             : 
     249             :   AMDGPUAS getAMDGPUAS() const {
     250      461917 :     return AS;
     251             :   }
     252             : 
     253             :   bool has16BitInsts() const {
     254             :     return Has16BitInsts;
     255             :   }
     256             : 
     257             :   bool hasIntClamp() const {
     258             :     return HasIntClamp;
     259             :   }
     260             : 
     261             :   bool hasVOP3PInsts() const {
     262             :     return HasVOP3PInsts;
     263             :   }
     264             : 
     265             :   bool hasFP64() const {
     266             :     return FP64;
     267             :   }
     268             : 
     269             :   bool hasMIMG_R128() const {
     270             :     return MIMG_R128;
     271             :   }
     272             : 
     273             :   bool hasFastFMAF32() const {
     274             :     return FastFMAF32;
     275             :   }
     276             : 
     277             :   bool hasHalfRate64Ops() const {
     278             :     return HalfRate64Ops;
     279             :   }
     280             : 
     281             :   bool hasAddr64() const {
     282       69229 :     return (getGeneration() < VOLCANIC_ISLANDS);
     283             :   }
     284             : 
     285             :   bool hasBFE() const {
     286        3385 :     return (getGeneration() >= EVERGREEN);
     287             :   }
     288             : 
     289             :   bool hasBFI() const {
     290        2527 :     return (getGeneration() >= EVERGREEN);
     291             :   }
     292             : 
     293             :   bool hasBFM() const {
     294             :     return hasBFE();
     295             :   }
     296             : 
     297             :   bool hasBCNT(unsigned Size) const {
     298             :     if (Size == 32)
     299        2527 :       return (getGeneration() >= EVERGREEN);
     300             : 
     301             :     if (Size == 64)
     302        2527 :       return (getGeneration() >= SOUTHERN_ISLANDS);
     303             : 
     304             :     return false;
     305             :   }
     306             : 
     307             :   bool hasMulU24() const {
     308        8219 :     return (getGeneration() >= EVERGREEN);
     309             :   }
     310             : 
     311             :   bool hasMulI24() const {
     312        5009 :     return (getGeneration() >= SOUTHERN_ISLANDS ||
     313         415 :             hasCaymanISA());
     314             :   }
     315             : 
     316             :   bool hasFFBL() const {
     317        2527 :     return (getGeneration() >= EVERGREEN);
     318             :   }
     319             : 
     320             :   bool hasFFBH() const {
     321        2527 :     return (getGeneration() >= EVERGREEN);
     322             :   }
     323             : 
     324             :   bool hasMed3_16() const {
     325           9 :     return getGeneration() >= GFX9;
     326             :   }
     327             : 
     328             :   bool hasMin3Max3_16() const {
     329         355 :     return getGeneration() >= GFX9;
     330             :   }
     331             : 
     332             :   bool hasMadMixInsts() const {
     333             :     return HasMadMixInsts;
     334             :   }
     335             : 
     336             :   bool hasFmaMixInsts() const {
     337             :     return HasFmaMixInsts;
     338             :   }
     339             : 
     340             :   bool hasCARRY() const {
     341         286 :     return (getGeneration() >= EVERGREEN);
     342             :   }
     343             : 
     344             :   bool hasBORROW() const {
     345         286 :     return (getGeneration() >= EVERGREEN);
     346             :   }
     347             : 
     348             :   bool hasCaymanISA() const {
     349             :     return CaymanISA;
     350             :   }
     351             : 
     352             :   bool hasFMA() const {
     353             :     return FMA;
     354             :   }
     355             : 
     356             :   TrapHandlerAbi getTrapHandlerAbi() const {
     357          36 :     return isAmdHsaOS() ? TrapHandlerAbiHsa : TrapHandlerAbiNone;
     358             :   }
     359             : 
     360             :   bool enableHugePrivateBuffer() const {
     361             :     return EnableHugePrivateBuffer;
     362             :   }
     363             : 
     364             :   bool isPromoteAllocaEnabled() const {
     365             :     return EnablePromoteAlloca;
     366             :   }
     367             : 
     368             :   bool unsafeDSOffsetFoldingEnabled() const {
     369             :     return EnableUnsafeDSOffsetFolding;
     370             :   }
     371             : 
     372             :   bool dumpCode() const {
     373             :     return DumpCode;
     374             :   }
     375             : 
     376             :   /// Return the amount of LDS that can be used that will not restrict the
     377             :   /// occupancy lower than WaveCount.
     378             :   unsigned getMaxLocalMemSizeWithWaveCount(unsigned WaveCount,
     379             :                                            const Function &) const;
     380             : 
     381             :   /// Inverse of getMaxLocalMemWithWaveCount. Return the maximum wavecount if
     382             :   /// the given LDS memory size is the only constraint.
     383             :   unsigned getOccupancyWithLocalMemSize(uint32_t Bytes, const Function &) const;
     384             : 
     385             :   unsigned getOccupancyWithLocalMemSize(const MachineFunction &MF) const;
     386             : 
     387             :   bool hasFP16Denormals() const {
     388             :     return FP64FP16Denormals;
     389             :   }
     390             : 
     391             :   bool hasFP32Denormals() const {
     392             :     return FP32Denormals;
     393             :   }
     394             : 
     395             :   bool hasFP64Denormals() const {
     396             :     return FP64FP16Denormals;
     397             :   }
     398             : 
     399             :   bool supportsMinMaxDenormModes() const {
     400          44 :     return getGeneration() >= AMDGPUSubtarget::GFX9;
     401             :   }
     402             : 
     403             :   bool hasFPExceptions() const {
     404             :     return FPExceptions;
     405             :   }
     406             : 
     407             :   bool enableDX10Clamp() const {
     408             :     return DX10Clamp;
     409             :   }
     410             : 
     411             :   bool enableIEEEBit(const MachineFunction &MF) const {
     412      104048 :     return AMDGPU::isCompute(MF.getFunction().getCallingConv());
     413             :   }
     414             : 
     415             :   bool useFlatForGlobal() const {
     416             :     return FlatForGlobal;
     417             :   }
     418             : 
     419             :   /// \returns If target supports ds_read/write_b128 and user enables generation
     420             :   /// of ds_read/write_b128.
     421             :   bool useDS128() const {
     422       49358 :     return CIInsts && EnableDS128;
     423             :   }
     424             : 
     425             :   /// \returns If MUBUF instructions always perform range checking, even for
     426             :   /// buffer resources used for private memory access.
     427             :   bool privateMemoryResourceIsRangeChecked() const {
     428        5091 :     return getGeneration() < AMDGPUSubtarget::GFX9;
     429             :   }
     430             : 
     431             :   bool hasAutoWaitcntBeforeBarrier() const {
     432             :     return AutoWaitcntBeforeBarrier;
     433             :   }
     434             : 
     435             :   bool hasCodeObjectV3() const {
     436             :     return CodeObjectV3;
     437             :   }
     438             : 
     439             :   bool hasUnalignedBufferAccess() const {
     440             :     return UnalignedBufferAccess;
     441             :   }
     442             : 
     443             :   bool hasUnalignedScratchAccess() const {
     444             :     return UnalignedScratchAccess;
     445             :   }
     446             : 
     447             :   bool hasApertureRegs() const {
     448             :    return HasApertureRegs;
     449             :   }
     450             : 
     451             :   bool isTrapHandlerEnabled() const {
     452             :     return TrapHandler;
     453             :   }
     454             : 
     455             :   bool isXNACKEnabled() const {
     456             :     return EnableXNACK;
     457             :   }
     458             : 
     459             :   bool hasFlatAddressSpace() const {
     460             :     return FlatAddressSpace;
     461             :   }
     462             : 
     463             :   bool hasFlatInstOffsets() const {
     464             :     return FlatInstOffsets;
     465             :   }
     466             : 
     467             :   bool hasFlatGlobalInsts() const {
     468             :     return FlatGlobalInsts;
     469             :   }
     470             : 
     471             :   bool hasFlatScratchInsts() const {
     472             :     return FlatScratchInsts;
     473             :   }
     474             : 
     475             :   bool hasFlatLgkmVMemCountInOrder() const {
     476        1252 :     return getGeneration() > GFX9;
     477             :   }
     478             : 
     479             :   bool hasD16LoadStore() const {
     480             :     return getGeneration() >= GFX9;
     481             :   }
     482             : 
     483             :   /// Return if most LDS instructions have an m0 use that require m0 to be
     484             :   /// iniitalized.
     485             :   bool ldsRequiresM0Init() const {
     486       35270 :     return getGeneration() < GFX9;
     487             :   }
     488             : 
     489             :   bool hasAddNoCarry() const {
     490             :     return AddNoCarryInsts;
     491             :   }
     492             : 
     493             :   bool hasUnpackedD16VMem() const {
     494             :     return HasUnpackedD16VMem;
     495             :   }
     496             : 
     497             :   bool isMesaKernel(const Function &F) const {
     498       86148 :     return isMesa3DOS() && !AMDGPU::isShader(F.getCallingConv());
     499             :   }
     500             : 
     501             :   // Covers VS/PS/CS graphics shaders
     502             :   bool isMesaGfxShader(const Function &F) const {
     503       17037 :     return isMesa3DOS() && AMDGPU::isShader(F.getCallingConv());
     504             :   }
     505             : 
     506       92719 :   bool isAmdCodeObjectV2(const Function &F) const {
     507      185438 :     return isAmdHsaOS() || isMesaKernel(F);
     508             :   }
     509             : 
     510             :   bool hasMad64_32() const {
     511         670 :     return getGeneration() >= SEA_ISLANDS;
     512             :   }
     513             : 
     514             :   bool hasFminFmaxLegacy() const {
     515         659 :     return getGeneration() < AMDGPUSubtarget::VOLCANIC_ISLANDS;
     516             :   }
     517             : 
     518             :   bool hasSDWA() const {
     519             :     return HasSDWA;
     520             :   }
     521             : 
     522             :   bool hasSDWAOmod() const {
     523             :     return HasSDWAOmod;
     524             :   }
     525             : 
     526             :   bool hasSDWAScalar() const {
     527             :     return HasSDWAScalar;
     528             :   }
     529             : 
     530             :   bool hasSDWASdst() const {
     531             :     return HasSDWASdst;
     532             :   }
     533             : 
     534             :   bool hasSDWAMac() const {
     535             :     return HasSDWAMac;
     536             :   }
     537             : 
     538             :   bool hasSDWAOutModsVOPC() const {
     539             :     return HasSDWAOutModsVOPC;
     540             :   }
     541             : 
     542             :   bool vmemWriteNeedsExpWaitcnt() const {
     543       37399 :     return getGeneration() < SEA_ISLANDS;
     544             :   }
     545             : 
     546             :   bool hasDLInsts() const {
     547             :     return HasDLInsts;
     548             :   }
     549             : 
     550             :   bool d16PreservesUnusedBits() const {
     551             :     return D16PreservesUnusedBits;
     552             :   }
     553             : 
     554             :   /// Returns the offset in bytes from the start of the input buffer
     555             :   ///        of the first explicit kernel argument.
     556             :   unsigned getExplicitKernelArgOffset(const Function &F) const {
     557       23448 :     return isAmdCodeObjectV2(F) ? 0 : 36;
     558             :   }
     559             : 
     560             :   unsigned getAlignmentForImplicitArgPtr() const {
     561         187 :     return isAmdHsaOS() ? 8 : 4;
     562             :   }
     563             : 
     564             :   /// \returns Number of bytes of arguments that are passed to a shader or
     565             :   /// kernel in addition to the explicit ones declared for the function.
     566        4009 :   unsigned getImplicitArgNumBytes(const Function &F) const {
     567             :     if (isMesaKernel(F))
     568             :       return 16;
     569        3918 :     return AMDGPU::getIntegerAttribute(F, "amdgpu-implicitarg-num-bytes", 0);
     570             :   }
     571             : 
     572             :   // Scratch is allocated in 256 dword per wave blocks for the entire
     573             :   // wavefront. When viewed from the perspecive of an arbitrary workitem, this
     574             :   // is 4-byte aligned.
     575             :   //
     576             :   // Only 4-byte alignment is really needed to access anything. Transformations
     577             :   // on the pointer value itself may rely on the alignment / known low bits of
     578             :   // the pointer. Set this to something above the minimum to avoid needing
     579             :   // dynamic realignment in common cases.
     580             :   unsigned getStackAlignment() const {
     581             :     return 16;
     582             :   }
     583             : 
     584       61840 :   bool enableMachineScheduler() const override {
     585       61840 :     return true;
     586             :   }
     587             : 
     588       20846 :   bool enableSubRegLiveness() const override {
     589       20846 :     return true;
     590             :   }
     591             : 
     592      927348 :   void setScalarizeGlobalBehavior(bool b) { ScalarizeGlobal = b;}
     593             :   bool getScalarizeGlobalBehavior() const { return ScalarizeGlobal;}
     594             : 
     595             :   /// \returns Number of execution units per compute unit supported by the
     596             :   /// subtarget.
     597             :   unsigned getEUsPerCU() const {
     598             :     return AMDGPU::IsaInfo::getEUsPerCU(getFeatureBits());
     599             :   }
     600             : 
     601             :   /// \returns Maximum number of work groups per compute unit supported by the
     602             :   /// subtarget and limited by given \p FlatWorkGroupSize.
     603             :   unsigned getMaxWorkGroupsPerCU(unsigned FlatWorkGroupSize) const {
     604             :     return AMDGPU::IsaInfo::getMaxWorkGroupsPerCU(getFeatureBits(),
     605      183182 :                                                   FlatWorkGroupSize);
     606             :   }
     607             : 
     608             :   /// \returns Maximum number of waves per compute unit supported by the
     609             :   /// subtarget without any kind of limitation.
     610             :   unsigned getMaxWavesPerCU() const {
     611             :     return AMDGPU::IsaInfo::getMaxWavesPerCU(getFeatureBits());
     612             :   }
     613             : 
     614             :   /// \returns Maximum number of waves per compute unit supported by the
     615             :   /// subtarget and limited by given \p FlatWorkGroupSize.
     616             :   unsigned getMaxWavesPerCU(unsigned FlatWorkGroupSize) const {
     617             :     return AMDGPU::IsaInfo::getMaxWavesPerCU(getFeatureBits(),
     618             :                                              FlatWorkGroupSize);
     619             :   }
     620             : 
     621             :   /// \returns Minimum number of waves per execution unit supported by the
     622             :   /// subtarget.
     623             :   unsigned getMinWavesPerEU() const {
     624       35877 :     return AMDGPU::IsaInfo::getMinWavesPerEU(getFeatureBits());
     625             :   }
     626             : 
     627             :   /// \returns Maximum number of waves per execution unit supported by the
     628             :   /// subtarget without any kind of limitation.
     629             :   unsigned getMaxWavesPerEU() const {
     630      308078 :     return AMDGPU::IsaInfo::getMaxWavesPerEU(getFeatureBits());
     631             :   }
     632             : 
     633             :   /// \returns Maximum number of waves per execution unit supported by the
     634             :   /// subtarget and limited by given \p FlatWorkGroupSize.
     635             :   unsigned getMaxWavesPerEU(unsigned FlatWorkGroupSize) const {
     636             :     return AMDGPU::IsaInfo::getMaxWavesPerEU(getFeatureBits(),
     637       35877 :                                              FlatWorkGroupSize);
     638             :   }
     639             : 
     640             :   /// \returns Minimum flat work group size supported by the subtarget.
     641             :   unsigned getMinFlatWorkGroupSize() const {
     642      242102 :     return AMDGPU::IsaInfo::getMinFlatWorkGroupSize(getFeatureBits());
     643             :   }
     644             : 
     645             :   /// \returns Maximum flat work group size supported by the subtarget.
     646             :   unsigned getMaxFlatWorkGroupSize() const {
     647      242086 :     return AMDGPU::IsaInfo::getMaxFlatWorkGroupSize(getFeatureBits());
     648             :   }
     649             : 
     650             :   /// \returns Number of waves per work group supported by the subtarget and
     651             :   /// limited by given \p FlatWorkGroupSize.
     652             :   unsigned getWavesPerWorkGroup(unsigned FlatWorkGroupSize) const {
     653             :     return AMDGPU::IsaInfo::getWavesPerWorkGroup(getFeatureBits(),
     654             :                                                  FlatWorkGroupSize);
     655             :   }
     656             : 
     657             :   /// \returns Default range flat work group size for a calling convention.
     658             :   std::pair<unsigned, unsigned> getDefaultFlatWorkGroupSize(CallingConv::ID CC) const;
     659             : 
     660             :   /// \returns Subtarget's default pair of minimum/maximum flat work group sizes
     661             :   /// for function \p F, or minimum/maximum flat work group sizes explicitly
     662             :   /// requested using "amdgpu-flat-work-group-size" attribute attached to
     663             :   /// function \p F.
     664             :   ///
     665             :   /// \returns Subtarget's default values if explicitly requested values cannot
     666             :   /// be converted to integer, or violate subtarget's specifications.
     667             :   std::pair<unsigned, unsigned> getFlatWorkGroupSizes(const Function &F) const;
     668             : 
     669             :   /// \returns Subtarget's default pair of minimum/maximum number of waves per
     670             :   /// execution unit for function \p F, or minimum/maximum number of waves per
     671             :   /// execution unit explicitly requested using "amdgpu-waves-per-eu" attribute
     672             :   /// attached to function \p F.
     673             :   ///
     674             :   /// \returns Subtarget's default values if explicitly requested values cannot
     675             :   /// be converted to integer, violate subtarget's specifications, or are not
     676             :   /// compatible with minimum/maximum number of waves limited by flat work group
     677             :   /// size, register usage, and/or lds usage.
     678             :   std::pair<unsigned, unsigned> getWavesPerEU(const Function &F) const;
     679             : 
     680             :   /// Creates value range metadata on an workitemid.* inrinsic call or load.
     681             :   bool makeLIDRangeMetadata(Instruction *I) const;
     682             : };
     683             : 
     684        1140 : class R600Subtarget final : public AMDGPUSubtarget {
     685             : private:
     686             :   R600InstrInfo InstrInfo;
     687             :   R600FrameLowering FrameLowering;
     688             :   R600TargetLowering TLInfo;
     689             : 
     690             : public:
     691             :   R600Subtarget(const Triple &TT, StringRef CPU, StringRef FS,
     692             :                 const TargetMachine &TM);
     693             : 
     694      389842 :   const R600InstrInfo *getInstrInfo() const override {
     695      821556 :     return &InstrInfo;
     696             :   }
     697             : 
     698       27187 :   const R600FrameLowering *getFrameLowering() const override {
     699       29603 :     return &FrameLowering;
     700             :   }
     701             : 
     702      164779 :   const R600TargetLowering *getTargetLowering() const override {
     703      164779 :     return &TLInfo;
     704             :   }
     705             : 
     706     1569227 :   const R600RegisterInfo *getRegisterInfo() const override {
     707     1569227 :     return &InstrInfo.getRegisterInfo();
     708             :   }
     709             : 
     710             :   bool hasCFAluBug() const {
     711             :     return CFALUBug;
     712             :   }
     713             : 
     714             :   bool hasVertexCache() const {
     715             :     return HasVertexCache;
     716             :   }
     717             : 
     718             :   short getTexVTXClauseSize() const {
     719             :     return TexVTXClauseSize;
     720             :   }
     721             : };
     722             : 
     723        6699 : class SISubtarget final : public AMDGPUSubtarget {
     724             : private:
     725             :   SIInstrInfo InstrInfo;
     726             :   SIFrameLowering FrameLowering;
     727             :   SITargetLowering TLInfo;
     728             : 
     729             :   /// GlobalISel related APIs.
     730             :   std::unique_ptr<AMDGPUCallLowering> CallLoweringInfo;
     731             :   std::unique_ptr<InstructionSelector> InstSelector;
     732             :   std::unique_ptr<LegalizerInfo> Legalizer;
     733             :   std::unique_ptr<RegisterBankInfo> RegBankInfo;
     734             : 
     735             : public:
     736             :   SISubtarget(const Triple &TT, StringRef CPU, StringRef FS,
     737             :               const GCNTargetMachine &TM);
     738             : 
     739     3896356 :   const SIInstrInfo *getInstrInfo() const override {
     740     4341326 :     return &InstrInfo;
     741             :   }
     742             : 
     743      237284 :   const SIFrameLowering *getFrameLowering() const override {
     744      237284 :     return &FrameLowering;
     745             :   }
     746             : 
     747     1559215 :   const SITargetLowering *getTargetLowering() const override {
     748     1559215 :     return &TLInfo;
     749             :   }
     750             : 
     751          22 :   const CallLowering *getCallLowering() const override {
     752          22 :     return CallLoweringInfo.get();
     753             :   }
     754             : 
     755          27 :   const InstructionSelector *getInstructionSelector() const override {
     756          27 :     return InstSelector.get();
     757             :   }
     758             : 
     759          80 :   const LegalizerInfo *getLegalizerInfo() const override {
     760          80 :     return Legalizer.get();
     761             :   }
     762             : 
     763         375 :   const RegisterBankInfo *getRegBankInfo() const override {
     764         375 :     return RegBankInfo.get();
     765             :   }
     766             : 
     767    28112360 :   const SIRegisterInfo *getRegisterInfo() const override {
     768    28112360 :     return &InstrInfo.getRegisterInfo();
     769             :   }
     770             : 
     771             :   // XXX - Why is this here if it isn't in the default pass set?
     772          22 :   bool enableEarlyIfConversion() const override {
     773          22 :     return true;
     774             :   }
     775             : 
     776             :   void overrideSchedPolicy(MachineSchedPolicy &Policy,
     777             :                            unsigned NumRegionInstrs) const override;
     778             : 
     779             :   bool isVGPRSpillingEnabled(const Function& F) const;
     780             : 
     781             :   unsigned getMaxNumUserSGPRs() const {
     782             :     return 16;
     783             :   }
     784             : 
     785             :   bool hasSMemRealTime() const {
     786             :     return HasSMemRealTime;
     787             :   }
     788             : 
     789             :   bool hasMovrel() const {
     790             :     return HasMovrel;
     791             :   }
     792             : 
     793             :   bool hasVGPRIndexMode() const {
     794             :     return HasVGPRIndexMode;
     795             :   }
     796             : 
     797             :   bool useVGPRIndexMode(bool UserEnable) const {
     798         161 :     return !hasMovrel() || (UserEnable && hasVGPRIndexMode());
     799             :   }
     800             : 
     801             :   bool hasScalarCompareEq64() const {
     802          27 :     return getGeneration() >= VOLCANIC_ISLANDS;
     803             :   }
     804             : 
     805             :   bool hasScalarStores() const {
     806             :     return HasScalarStores;
     807             :   }
     808             : 
     809             :   bool hasScalarAtomics() const {
     810             :     return HasScalarAtomics;
     811             :   }
     812             : 
     813             :   bool hasInv2PiInlineImm() const {
     814             :     return HasInv2PiInlineImm;
     815             :   }
     816             : 
     817             :   bool hasDPP() const {
     818             :     return HasDPP;
     819             :   }
     820             : 
     821             :   bool enableSIScheduler() const {
     822             :     return EnableSIScheduler;
     823             :   }
     824             : 
     825             :   bool debuggerSupported() const {
     826        4015 :     return debuggerInsertNops() && debuggerReserveRegs() &&
     827           6 :       debuggerEmitPrologue();
     828             :   }
     829             : 
     830             :   bool debuggerInsertNops() const {
     831             :     return DebuggerInsertNops;
     832             :   }
     833             : 
     834             :   bool debuggerReserveRegs() const {
     835             :     return DebuggerReserveRegs;
     836             :   }
     837             : 
     838             :   bool debuggerEmitPrologue() const {
     839             :     return DebuggerEmitPrologue;
     840             :   }
     841             : 
     842             :   bool loadStoreOptEnabled() const {
     843             :     return EnableLoadStoreOpt;
     844             :   }
     845             : 
     846             :   bool hasSGPRInitBug() const {
     847             :     return SGPRInitBug;
     848             :   }
     849             : 
     850             :   bool has12DWordStoreHazard() const {
     851      313697 :     return getGeneration() != AMDGPUSubtarget::SOUTHERN_ISLANDS;
     852             :   }
     853             : 
     854             :   bool hasSMovFedHazard() const {
     855      693312 :     return getGeneration() >= AMDGPUSubtarget::GFX9;
     856             :   }
     857             : 
     858             :   bool hasReadM0MovRelInterpHazard() const {
     859      631351 :     return getGeneration() >= AMDGPUSubtarget::GFX9;
     860             :   }
     861             : 
     862             :   bool hasReadM0SendMsgHazard() const {
     863      198963 :     return getGeneration() >= AMDGPUSubtarget::VOLCANIC_ISLANDS;
     864             :   }
     865             : 
     866             :   unsigned getKernArgSegmentSize(const Function &F,
     867             :                                  unsigned ExplictArgBytes) const;
     868             : 
     869             :   /// Return the maximum number of waves per SIMD for kernels using \p SGPRs SGPRs
     870             :   unsigned getOccupancyWithNumSGPRs(unsigned SGPRs) const;
     871             : 
     872             :   /// Return the maximum number of waves per SIMD for kernels using \p VGPRs VGPRs
     873             :   unsigned getOccupancyWithNumVGPRs(unsigned VGPRs) const;
     874             : 
     875             :   /// \returns true if the flat_scratch register should be initialized with the
     876             :   /// pointer to the wave's scratch memory rather than a size and offset.
     877             :   bool flatScratchIsPointer() const {
     878         359 :     return getGeneration() >= GFX9;
     879             :   }
     880             : 
     881             :   /// \returns true if the machine has merged shaders in which s0-s7 are
     882             :   /// reserved by the hardware and user SGPRs start at s8
     883             :   bool hasMergedShaders() const {
     884           4 :     return getGeneration() >= GFX9;
     885             :   }
     886             : 
     887             :   /// \returns SGPR allocation granularity supported by the subtarget.
     888             :   unsigned getSGPRAllocGranule() const {
     889             :     return AMDGPU::IsaInfo::getSGPRAllocGranule(getFeatureBits());
     890             :   }
     891             : 
     892             :   /// \returns SGPR encoding granularity supported by the subtarget.
     893             :   unsigned getSGPREncodingGranule() const {
     894       32896 :     return AMDGPU::IsaInfo::getSGPREncodingGranule(getFeatureBits());
     895             :   }
     896             : 
     897             :   /// \returns Total number of SGPRs supported by the subtarget.
     898             :   unsigned getTotalNumSGPRs() const {
     899             :     return AMDGPU::IsaInfo::getTotalNumSGPRs(getFeatureBits());
     900             :   }
     901             : 
     902             :   /// \returns Addressable number of SGPRs supported by the subtarget.
     903             :   unsigned getAddressableNumSGPRs() const {
     904       34327 :     return AMDGPU::IsaInfo::getAddressableNumSGPRs(getFeatureBits());
     905             :   }
     906             : 
     907             :   /// \returns Minimum number of SGPRs that meets the given number of waves per
     908             :   /// execution unit requirement supported by the subtarget.
     909             :   unsigned getMinNumSGPRs(unsigned WavesPerEU) const {
     910       16508 :     return AMDGPU::IsaInfo::getMinNumSGPRs(getFeatureBits(), WavesPerEU);
     911             :   }
     912             : 
     913             :   /// \returns Maximum number of SGPRs that meets the given number of waves per
     914             :   /// execution unit requirement supported by the subtarget.
     915             :   unsigned getMaxNumSGPRs(unsigned WavesPerEU, bool Addressable) const {
     916             :     return AMDGPU::IsaInfo::getMaxNumSGPRs(getFeatureBits(), WavesPerEU,
     917      183921 :                                            Addressable);
     918             :   }
     919             : 
     920             :   /// \returns Reserved number of SGPRs for given function \p MF.
     921             :   unsigned getReservedNumSGPRs(const MachineFunction &MF) const;
     922             : 
     923             :   /// \returns Maximum number of SGPRs that meets number of waves per execution
     924             :   /// unit requirement for function \p MF, or number of SGPRs explicitly
     925             :   /// requested using "amdgpu-num-sgpr" attribute attached to function \p MF.
     926             :   ///
     927             :   /// \returns Value that meets number of waves per execution unit requirement
     928             :   /// if explicitly requested value cannot be converted to integer, violates
     929             :   /// subtarget's specifications, or does not meet number of waves per execution
     930             :   /// unit requirement.
     931             :   unsigned getMaxNumSGPRs(const MachineFunction &MF) const;
     932             : 
     933             :   /// \returns VGPR allocation granularity supported by the subtarget.
     934             :   unsigned getVGPRAllocGranule() const {
     935             :     return AMDGPU::IsaInfo::getVGPRAllocGranule(getFeatureBits());
     936             :   }
     937             : 
     938             :   /// \returns VGPR encoding granularity supported by the subtarget.
     939             :   unsigned getVGPREncodingGranule() const {
     940       32896 :     return AMDGPU::IsaInfo::getVGPREncodingGranule(getFeatureBits());
     941             :   }
     942             : 
     943             :   /// \returns Total number of VGPRs supported by the subtarget.
     944             :   unsigned getTotalNumVGPRs() const {
     945             :     return AMDGPU::IsaInfo::getTotalNumVGPRs(getFeatureBits());
     946             :   }
     947             : 
     948             :   /// \returns Addressable number of VGPRs supported by the subtarget.
     949             :   unsigned getAddressableNumVGPRs() const {
     950       17879 :     return AMDGPU::IsaInfo::getAddressableNumVGPRs(getFeatureBits());
     951             :   }
     952             : 
     953             :   /// \returns Minimum number of VGPRs that meets given number of waves per
     954             :   /// execution unit requirement supported by the subtarget.
     955             :   unsigned getMinNumVGPRs(unsigned WavesPerEU) const {
     956       16466 :     return AMDGPU::IsaInfo::getMinNumVGPRs(getFeatureBits(), WavesPerEU);
     957             :   }
     958             : 
     959             :   /// \returns Maximum number of VGPRs that meets given number of waves per
     960             :   /// execution unit requirement supported by the subtarget.
     961             :   unsigned getMaxNumVGPRs(unsigned WavesPerEU) const {
     962      149338 :     return AMDGPU::IsaInfo::getMaxNumVGPRs(getFeatureBits(), WavesPerEU);
     963             :   }
     964             : 
     965             :   /// \returns Reserved number of VGPRs for given function \p MF.
     966             :   unsigned getReservedNumVGPRs(const MachineFunction &MF) const {
     967      125815 :     return debuggerReserveRegs() ? 4 : 0;
     968             :   }
     969             : 
     970             :   /// \returns Maximum number of VGPRs that meets number of waves per execution
     971             :   /// unit requirement for function \p MF, or number of VGPRs explicitly
     972             :   /// requested using "amdgpu-num-vgpr" attribute attached to function \p MF.
     973             :   ///
     974             :   /// \returns Value that meets number of waves per execution unit requirement
     975             :   /// if explicitly requested value cannot be converted to integer, violates
     976             :   /// subtarget's specifications, or does not meet number of waves per execution
     977             :   /// unit requirement.
     978             :   unsigned getMaxNumVGPRs(const MachineFunction &MF) const;
     979             : 
     980             :   void getPostRAMutations(
     981             :       std::vector<std::unique_ptr<ScheduleDAGMutation>> &Mutations)
     982             :       const override;
     983             : };
     984             : 
     985             : } // end namespace llvm
     986             : 
     987             : #endif // LLVM_LIB_TARGET_AMDGPU_AMDGPUSUBTARGET_H

Generated by: LCOV version 1.13