LCOV - code coverage report
Current view: top level - lib/Target/AMDGPU - AMDGPUArgumentUsageInfo.h (source / functions) Hit Total Coverage
Test: llvm-toolchain.info Lines: 11 16 68.8 %
Date: 2018-10-14 09:39:32 Functions: 2 4 50.0 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : //==- AMDGPUArgumentrUsageInfo.h - Function Arg Usage Info -------*- 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             : #ifndef LLVM_LIB_TARGET_AMDGPU_AMDGPUARGUMENTUSAGEINFO_H
      11             : #define LLVM_LIB_TARGET_AMDGPU_AMDGPUARGUMENTUSAGEINFO_H
      12             : 
      13             : #include "llvm/ADT/DenseMap.h"
      14             : #include "llvm/IR/Function.h"
      15             : #include "llvm/Pass.h"
      16             : 
      17             : namespace llvm {
      18             : 
      19             : class Function;
      20             : class raw_ostream;
      21             : class GCNSubtarget;
      22             : class TargetMachine;
      23             : class TargetRegisterClass;
      24             : class TargetRegisterInfo;
      25             : 
      26             : struct ArgDescriptor {
      27             : private:
      28             :   friend struct AMDGPUFunctionArgInfo;
      29             :   friend class AMDGPUArgumentUsageInfo;
      30             : 
      31             :   union {
      32             :     unsigned Register;
      33             :     unsigned StackOffset;
      34             :   };
      35             : 
      36             :   bool IsStack : 1;
      37             :   bool IsSet : 1;
      38             : 
      39             :   ArgDescriptor(unsigned Val = 0, bool IsStack = false, bool IsSet = false)
      40             :     : Register(Val), IsStack(IsStack), IsSet(IsSet) {}
      41             : public:
      42             :   static ArgDescriptor createRegister(unsigned Reg) {
      43             :     return ArgDescriptor(Reg, false, true);
      44             :   }
      45             : 
      46             :   static ArgDescriptor createStack(unsigned Reg) {
      47             :     return ArgDescriptor(Reg, true, true);
      48             :   }
      49             : 
      50             :   bool isSet() const {
      51       64230 :     return IsSet;
      52             :   }
      53             : 
      54             :   explicit operator bool() const {
      55             :     return isSet();
      56             :   }
      57             : 
      58             :   bool isRegister() const {
      59        3711 :     return !IsStack;
      60             :   }
      61             : 
      62           0 :   unsigned getRegister() const {
      63             :     assert(!IsStack);
      64           0 :     return Register;
      65             :   }
      66             : 
      67           0 :   unsigned getStackOffset() const {
      68             :     assert(IsStack);
      69           0 :     return StackOffset;
      70             :   }
      71             : 
      72             :   void print(raw_ostream &OS, const TargetRegisterInfo *TRI = nullptr) const;
      73             : };
      74             : 
      75             : inline raw_ostream &operator<<(raw_ostream &OS, const ArgDescriptor &Arg) {
      76           0 :   Arg.print(OS);
      77             :   return OS;
      78             : }
      79             : 
      80             : struct AMDGPUFunctionArgInfo {
      81             :   enum PreloadedValue {
      82             :     // SGPRS:
      83             :     PRIVATE_SEGMENT_BUFFER = 0,
      84             :     DISPATCH_PTR        =  1,
      85             :     QUEUE_PTR           =  2,
      86             :     KERNARG_SEGMENT_PTR =  3,
      87             :     DISPATCH_ID         =  4,
      88             :     FLAT_SCRATCH_INIT   =  5,
      89             :     WORKGROUP_ID_X      = 10,
      90             :     WORKGROUP_ID_Y      = 11,
      91             :     WORKGROUP_ID_Z      = 12,
      92             :     PRIVATE_SEGMENT_WAVE_BYTE_OFFSET = 14,
      93             :     IMPLICIT_BUFFER_PTR = 15,
      94             :     IMPLICIT_ARG_PTR = 16,
      95             : 
      96             :     // VGPRS:
      97             :     WORKITEM_ID_X       = 17,
      98             :     WORKITEM_ID_Y       = 18,
      99             :     WORKITEM_ID_Z       = 19,
     100             :     FIRST_VGPR_VALUE    = WORKITEM_ID_X
     101             :   };
     102             : 
     103             :   // Kernel input registers setup for the HSA ABI in allocation order.
     104             : 
     105             :   // User SGPRs in kernels
     106             :   // XXX - Can these require argument spills?
     107             :   ArgDescriptor PrivateSegmentBuffer;
     108             :   ArgDescriptor DispatchPtr;
     109             :   ArgDescriptor QueuePtr;
     110             :   ArgDescriptor KernargSegmentPtr;
     111             :   ArgDescriptor DispatchID;
     112             :   ArgDescriptor FlatScratchInit;
     113             :   ArgDescriptor PrivateSegmentSize;
     114             : 
     115             :   // System SGPRs in kernels.
     116             :   ArgDescriptor WorkGroupIDX;
     117             :   ArgDescriptor WorkGroupIDY;
     118             :   ArgDescriptor WorkGroupIDZ;
     119             :   ArgDescriptor WorkGroupInfo;
     120             :   ArgDescriptor PrivateSegmentWaveByteOffset;
     121             : 
     122             :   // Pointer with offset from kernargsegmentptr to where special ABI arguments
     123             :   // are passed to callable functions.
     124             :   ArgDescriptor ImplicitArgPtr;
     125             : 
     126             :   // Input registers for non-HSA ABI
     127             :   ArgDescriptor ImplicitBufferPtr = 0;
     128             : 
     129             :   // VGPRs inputs. These are always v0, v1 and v2 for entry functions.
     130             :   ArgDescriptor WorkItemIDX;
     131             :   ArgDescriptor WorkItemIDY;
     132             :   ArgDescriptor WorkItemIDZ;
     133             : 
     134             :   std::pair<const ArgDescriptor *, const TargetRegisterClass *>
     135             :   getPreloadedValue(PreloadedValue Value) const;
     136             : };
     137             : 
     138             : class AMDGPUArgumentUsageInfo : public ImmutablePass {
     139             : private:
     140             :   static const AMDGPUFunctionArgInfo ExternFunctionInfo;
     141             :   DenseMap<const Function *, AMDGPUFunctionArgInfo> ArgInfoMap;
     142             : 
     143             : public:
     144             :   static char ID;
     145             : 
     146        4386 :   AMDGPUArgumentUsageInfo() : ImmutablePass(ID) { }
     147             : 
     148        2193 :   void getAnalysisUsage(AnalysisUsage &AU) const override {
     149             :     AU.setPreservesAll();
     150        2193 :   }
     151             : 
     152             :   bool doInitialization(Module &M) override;
     153             :   bool doFinalization(Module &M) override;
     154             : 
     155             :   void print(raw_ostream &OS, const Module *M = nullptr) const override;
     156             : 
     157       19639 :   void setFuncArgInfo(const Function &F, const AMDGPUFunctionArgInfo &ArgInfo) {
     158       19639 :     ArgInfoMap[&F] = ArgInfo;
     159       19639 :   }
     160             : 
     161             :   const AMDGPUFunctionArgInfo &lookupFuncArgInfo(const Function &F) const {
     162         575 :     auto I = ArgInfoMap.find(&F);
     163         575 :     if (I == ArgInfoMap.end()) {
     164             :       assert(F.isDeclaration());
     165             :       return ExternFunctionInfo;
     166             :     }
     167             : 
     168         207 :     return I->second;
     169             :   }
     170             : };
     171             : 
     172             : } // end namespace llvm
     173             : 
     174             : #endif

Generated by: LCOV version 1.13