LCOV - code coverage report
Current view: top level - lib/Target/AMDGPU - AMDGPULibFunc.h (source / functions) Hit Total Coverage
Test: llvm-toolchain.info Lines: 23 33 69.7 %
Date: 2018-10-20 13:21:21 Functions: 4 12 33.3 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : //===-- AMDGPULibFunc.h ----------------------------------------*- C++ -*--===//
       2             : //
       3             : //                     The LLVM Compiler Infrastructure
       4             : //
       5             : // This file is distributed under the University of Illinois Open Source
       6             : // License. See LICENSE.TXT for details.
       7             : //
       8             : //===----------------------------------------------------------------------===//
       9             : 
      10             : #ifndef _AMDGPU_LIBFUNC_H_
      11             : #define _AMDGPU_LIBFUNC_H_
      12             : 
      13             : #include "llvm/ADT/StringRef.h"
      14             : 
      15             : namespace llvm {
      16             : 
      17             : class FunctionType;
      18             : class Function;
      19             : class Module;
      20             : 
      21             : class AMDGPULibFuncBase {
      22             : public:
      23             :   enum EFuncId {
      24             :     EI_NONE,
      25             : 
      26             :     // IMPORTANT: enums below should go in ascending by 1 value order
      27             :     // because they are used as indexes in the mangling rules table.
      28             :     // don't use explicit value assignment.
      29             :     //
      30             :     // There are two types of library functions: those with mangled
      31             :     // name and those with unmangled name. The enums for the library
      32             :     // functions with mangled name are defined before enums for the
      33             :     // library functions with unmangled name. The enum for the last
      34             :     // library function with mangled name is EI_LAST_MANGLED.
      35             :     //
      36             :     // Library functions with mangled name.
      37             :     EI_ABS,
      38             :     EI_ABS_DIFF,
      39             :     EI_ACOS,
      40             :     EI_ACOSH,
      41             :     EI_ACOSPI,
      42             :     EI_ADD_SAT,
      43             :     EI_ALL,
      44             :     EI_ANY,
      45             :     EI_ASIN,
      46             :     EI_ASINH,
      47             :     EI_ASINPI,
      48             :     EI_ASYNC_WORK_GROUP_COPY,
      49             :     EI_ASYNC_WORK_GROUP_STRIDED_COPY,
      50             :     EI_ATAN,
      51             :     EI_ATAN2,
      52             :     EI_ATAN2PI,
      53             :     EI_ATANH,
      54             :     EI_ATANPI,
      55             :     EI_ATOMIC_ADD,
      56             :     EI_ATOMIC_AND,
      57             :     EI_ATOMIC_CMPXCHG,
      58             :     EI_ATOMIC_DEC,
      59             :     EI_ATOMIC_INC,
      60             :     EI_ATOMIC_MAX,
      61             :     EI_ATOMIC_MIN,
      62             :     EI_ATOMIC_OR,
      63             :     EI_ATOMIC_SUB,
      64             :     EI_ATOMIC_XCHG,
      65             :     EI_ATOMIC_XOR,
      66             :     EI_BITSELECT,
      67             :     EI_CBRT,
      68             :     EI_CEIL,
      69             :     EI_CLAMP,
      70             :     EI_CLZ,
      71             :     EI_COMMIT_READ_PIPE,
      72             :     EI_COMMIT_WRITE_PIPE,
      73             :     EI_COPYSIGN,
      74             :     EI_COS,
      75             :     EI_COSH,
      76             :     EI_COSPI,
      77             :     EI_CROSS,
      78             :     EI_CTZ,
      79             :     EI_DEGREES,
      80             :     EI_DISTANCE,
      81             :     EI_DIVIDE,
      82             :     EI_DOT,
      83             :     EI_ERF,
      84             :     EI_ERFC,
      85             :     EI_EXP,
      86             :     EI_EXP10,
      87             :     EI_EXP2,
      88             :     EI_EXPM1,
      89             :     EI_FABS,
      90             :     EI_FAST_DISTANCE,
      91             :     EI_FAST_LENGTH,
      92             :     EI_FAST_NORMALIZE,
      93             :     EI_FDIM,
      94             :     EI_FLOOR,
      95             :     EI_FMA,
      96             :     EI_FMAX,
      97             :     EI_FMIN,
      98             :     EI_FMOD,
      99             :     EI_FRACT,
     100             :     EI_FREXP,
     101             :     EI_GET_IMAGE_ARRAY_SIZE,
     102             :     EI_GET_IMAGE_CHANNEL_DATA_TYPE,
     103             :     EI_GET_IMAGE_CHANNEL_ORDER,
     104             :     EI_GET_IMAGE_DIM,
     105             :     EI_GET_IMAGE_HEIGHT,
     106             :     EI_GET_IMAGE_WIDTH,
     107             :     EI_GET_PIPE_MAX_PACKETS,
     108             :     EI_GET_PIPE_NUM_PACKETS,
     109             :     EI_HADD,
     110             :     EI_HYPOT,
     111             :     EI_ILOGB,
     112             :     EI_ISEQUAL,
     113             :     EI_ISFINITE,
     114             :     EI_ISGREATER,
     115             :     EI_ISGREATEREQUAL,
     116             :     EI_ISINF,
     117             :     EI_ISLESS,
     118             :     EI_ISLESSEQUAL,
     119             :     EI_ISLESSGREATER,
     120             :     EI_ISNAN,
     121             :     EI_ISNORMAL,
     122             :     EI_ISNOTEQUAL,
     123             :     EI_ISORDERED,
     124             :     EI_ISUNORDERED,
     125             :     EI_LDEXP,
     126             :     EI_LENGTH,
     127             :     EI_LGAMMA,
     128             :     EI_LGAMMA_R,
     129             :     EI_LOG,
     130             :     EI_LOG10,
     131             :     EI_LOG1P,
     132             :     EI_LOG2,
     133             :     EI_LOGB,
     134             :     EI_MAD,
     135             :     EI_MAD24,
     136             :     EI_MAD_HI,
     137             :     EI_MAD_SAT,
     138             :     EI_MAX,
     139             :     EI_MAXMAG,
     140             :     EI_MIN,
     141             :     EI_MINMAG,
     142             :     EI_MIX,
     143             :     EI_MODF,
     144             :     EI_MUL24,
     145             :     EI_MUL_HI,
     146             :     EI_NAN,
     147             :     EI_NEXTAFTER,
     148             :     EI_NORMALIZE,
     149             :     EI_POPCOUNT,
     150             :     EI_POW,
     151             :     EI_POWN,
     152             :     EI_POWR,
     153             :     EI_PREFETCH,
     154             :     EI_RADIANS,
     155             :     EI_RECIP,
     156             :     EI_REMAINDER,
     157             :     EI_REMQUO,
     158             :     EI_RESERVE_READ_PIPE,
     159             :     EI_RESERVE_WRITE_PIPE,
     160             :     EI_RHADD,
     161             :     EI_RINT,
     162             :     EI_ROOTN,
     163             :     EI_ROTATE,
     164             :     EI_ROUND,
     165             :     EI_RSQRT,
     166             :     EI_SELECT,
     167             :     EI_SHUFFLE,
     168             :     EI_SHUFFLE2,
     169             :     EI_SIGN,
     170             :     EI_SIGNBIT,
     171             :     EI_SIN,
     172             :     EI_SINCOS,
     173             :     EI_SINH,
     174             :     EI_SINPI,
     175             :     EI_SMOOTHSTEP,
     176             :     EI_SQRT,
     177             :     EI_STEP,
     178             :     EI_SUB_GROUP_BROADCAST,
     179             :     EI_SUB_GROUP_COMMIT_READ_PIPE,
     180             :     EI_SUB_GROUP_COMMIT_WRITE_PIPE,
     181             :     EI_SUB_GROUP_REDUCE_ADD,
     182             :     EI_SUB_GROUP_REDUCE_MAX,
     183             :     EI_SUB_GROUP_REDUCE_MIN,
     184             :     EI_SUB_GROUP_RESERVE_READ_PIPE,
     185             :     EI_SUB_GROUP_RESERVE_WRITE_PIPE,
     186             :     EI_SUB_GROUP_SCAN_EXCLUSIVE_ADD,
     187             :     EI_SUB_GROUP_SCAN_EXCLUSIVE_MAX,
     188             :     EI_SUB_GROUP_SCAN_EXCLUSIVE_MIN,
     189             :     EI_SUB_GROUP_SCAN_INCLUSIVE_ADD,
     190             :     EI_SUB_GROUP_SCAN_INCLUSIVE_MAX,
     191             :     EI_SUB_GROUP_SCAN_INCLUSIVE_MIN,
     192             :     EI_SUB_SAT,
     193             :     EI_TAN,
     194             :     EI_TANH,
     195             :     EI_TANPI,
     196             :     EI_TGAMMA,
     197             :     EI_TRUNC,
     198             :     EI_UPSAMPLE,
     199             :     EI_VEC_STEP,
     200             :     EI_VSTORE,
     201             :     EI_VSTORE16,
     202             :     EI_VSTORE2,
     203             :     EI_VSTORE3,
     204             :     EI_VSTORE4,
     205             :     EI_VSTORE8,
     206             :     EI_WORK_GROUP_COMMIT_READ_PIPE,
     207             :     EI_WORK_GROUP_COMMIT_WRITE_PIPE,
     208             :     EI_WORK_GROUP_REDUCE_ADD,
     209             :     EI_WORK_GROUP_REDUCE_MAX,
     210             :     EI_WORK_GROUP_REDUCE_MIN,
     211             :     EI_WORK_GROUP_RESERVE_READ_PIPE,
     212             :     EI_WORK_GROUP_RESERVE_WRITE_PIPE,
     213             :     EI_WORK_GROUP_SCAN_EXCLUSIVE_ADD,
     214             :     EI_WORK_GROUP_SCAN_EXCLUSIVE_MAX,
     215             :     EI_WORK_GROUP_SCAN_EXCLUSIVE_MIN,
     216             :     EI_WORK_GROUP_SCAN_INCLUSIVE_ADD,
     217             :     EI_WORK_GROUP_SCAN_INCLUSIVE_MAX,
     218             :     EI_WORK_GROUP_SCAN_INCLUSIVE_MIN,
     219             :     EI_WRITE_IMAGEF,
     220             :     EI_WRITE_IMAGEI,
     221             :     EI_WRITE_IMAGEUI,
     222             :     EI_NCOS,
     223             :     EI_NEXP2,
     224             :     EI_NFMA,
     225             :     EI_NLOG2,
     226             :     EI_NRCP,
     227             :     EI_NRSQRT,
     228             :     EI_NSIN,
     229             :     EI_NSQRT,
     230             :     EI_FTZ,
     231             :     EI_FLDEXP,
     232             :     EI_CLASS,
     233             :     EI_RCBRT,
     234             :     EI_LAST_MANGLED =
     235             :         EI_RCBRT, /* The last library function with mangled name */
     236             : 
     237             :     // Library functions with unmangled name.
     238             :     EI_READ_PIPE_2,
     239             :     EI_READ_PIPE_4,
     240             :     EI_WRITE_PIPE_2,
     241             :     EI_WRITE_PIPE_4,
     242             : 
     243             :     EX_INTRINSICS_COUNT
     244             :   };
     245             : 
     246             :   enum ENamePrefix {
     247             :     NOPFX,
     248             :     NATIVE,
     249             :     HALF
     250             :   };
     251             : 
     252             :   enum EType {
     253             :     B8  = 1,
     254             :     B16 = 2,
     255             :     B32 = 3,
     256             :     B64 = 4,
     257             :     SIZE_MASK = 7,
     258             :     FLOAT = 0x10,
     259             :     INT   = 0x20,
     260             :     UINT  = 0x30,
     261             :     BASE_TYPE_MASK = 0x30,
     262             :     U8  =  UINT | B8,
     263             :     U16 =  UINT | B16,
     264             :     U32 =  UINT | B32,
     265             :     U64 =  UINT | B64,
     266             :     I8  =   INT | B8,
     267             :     I16 =   INT | B16,
     268             :     I32 =   INT | B32,
     269             :     I64 =   INT | B64,
     270             :     F16 = FLOAT | B16,
     271             :     F32 = FLOAT | B32,
     272             :     F64 = FLOAT | B64,
     273             :     IMG1DA = 0x80,
     274             :     IMG1DB,
     275             :     IMG2DA,
     276             :     IMG1D,
     277             :     IMG2D,
     278             :     IMG3D,
     279             :     SAMPLER,
     280             :     EVENT,
     281             :     DUMMY
     282             :   };
     283             : 
     284             :   enum EPtrKind {
     285             :     BYVALUE = 0,
     286             :     ADDR_SPACE = 0xF, // Address space takes value 0x1 ~ 0xF.
     287             :     CONST      = 0x10,
     288             :     VOLATILE   = 0x20
     289             :   };
     290             : 
     291             :   struct Param {
     292             :     unsigned char ArgType;
     293             :     unsigned char VectorSize;
     294             :     unsigned char PtrKind;
     295             : 
     296             :     unsigned char Reserved;
     297             : 
     298             :     void reset() {
     299        1996 :       ArgType = 0;
     300        1996 :       VectorSize = 1;
     301           0 :       PtrKind = 0;
     302             :     }
     303        1507 :     Param() { reset(); }
     304             : 
     305             :     template <typename Stream>
     306             :     void mangleItanium(Stream& os);
     307             :   };
     308             :   static bool isMangled(EFuncId Id) {
     309           0 :     return static_cast<unsigned>(Id) <= static_cast<unsigned>(EI_LAST_MANGLED);
     310             :   }
     311             : 
     312             :   static unsigned getEPtrKindFromAddrSpace(unsigned AS) {
     313             :     assert(((AS + 1) & ~ADDR_SPACE) == 0);
     314           0 :     return AS + 1;
     315             :   }
     316             : 
     317             :   static unsigned getAddrSpaceFromEPtrKind(unsigned Kind) {
     318          12 :     Kind = Kind & ADDR_SPACE;
     319             :     assert(Kind >= 1);
     320          12 :     return Kind - 1;
     321             :   }
     322             : };
     323             : 
     324             : class AMDGPULibFuncImpl : public AMDGPULibFuncBase {
     325             : public:
     326         353 :   AMDGPULibFuncImpl() {}
     327           0 :   virtual ~AMDGPULibFuncImpl() {}
     328             : 
     329             :   /// Get unmangled name for mangled library function and name for unmangled
     330             :   /// library function.
     331             :   virtual std::string getName() const = 0;
     332             :   virtual unsigned getNumArgs() const = 0;
     333           0 :   EFuncId getId() const { return FuncId; }
     334           0 :   ENamePrefix getPrefix() const { return FKind; }
     335             : 
     336           0 :   bool isMangled() const { return AMDGPULibFuncBase::isMangled(FuncId); }
     337             : 
     338          28 :   void setId(EFuncId id) { FuncId = id; }
     339             :   virtual bool parseFuncName(StringRef &mangledName) = 0;
     340             : 
     341             :   /// \return The mangled function name for mangled library functions
     342             :   /// and unmangled function name for unmangled library functions.
     343             :   virtual std::string mangle() const = 0;
     344             : 
     345         104 :   void setName(StringRef N) { Name = N; }
     346          27 :   void setPrefix(ENamePrefix pfx) { FKind = pfx; }
     347             : 
     348             :   virtual FunctionType *getFunctionType(Module &M) const = 0;
     349             : 
     350             : protected:
     351             :   EFuncId FuncId;
     352             :   std::string Name;
     353             :   ENamePrefix FKind;
     354             : };
     355             : 
     356             : /// Wrapper class for AMDGPULIbFuncImpl
     357          48 : class AMDGPULibFunc : public AMDGPULibFuncBase {
     358             : public:
     359             :   explicit AMDGPULibFunc() : Impl(std::unique_ptr<AMDGPULibFuncImpl>()) {}
     360             :   AMDGPULibFunc(const AMDGPULibFunc &F);
     361             :   /// Clone a mangled library func with the Id \p Id and argument info from \p
     362             :   /// CopyFrom.
     363             :   explicit AMDGPULibFunc(EFuncId Id, const AMDGPULibFunc &CopyFrom);
     364             :   /// Construct an unmangled library function on the fly.
     365             :   explicit AMDGPULibFunc(StringRef FName, FunctionType *FT);
     366             : 
     367             :   AMDGPULibFunc &operator=(const AMDGPULibFunc &F);
     368             : 
     369             :   /// Get unmangled name for mangled library function and name for unmangled
     370             :   /// library function.
     371           0 :   std::string getName() const { return Impl->getName(); }
     372         210 :   unsigned getNumArgs() const { return Impl->getNumArgs(); }
     373         559 :   EFuncId getId() const { return Impl->getId(); }
     374          99 :   ENamePrefix getPrefix() const { return Impl->getPrefix(); }
     375             :   /// Get leading parameters for mangled lib functions.
     376             :   Param *getLeads();
     377             :   const Param *getLeads() const;
     378             : 
     379          69 :   bool isMangled() const { return Impl->isMangled(); }
     380             :   void setId(EFuncId Id) { Impl->setId(Id); }
     381             :   bool parseFuncName(StringRef &MangledName) {
     382             :     return Impl->parseFuncName(MangledName);
     383             :   }
     384             : 
     385             :   /// \return The mangled function name for mangled library functions
     386             :   /// and unmangled function name for unmangled library functions.
     387         143 :   std::string mangle() const { return Impl->mangle(); }
     388             : 
     389             :   void setName(StringRef N) { Impl->setName(N); }
     390             :   void setPrefix(ENamePrefix PFX) { Impl->setPrefix(PFX); }
     391             : 
     392             :   FunctionType *getFunctionType(Module &M) const {
     393          99 :     return Impl->getFunctionType(M);
     394             :   }
     395             :   static Function *getFunction(llvm::Module *M, const AMDGPULibFunc &fInfo);
     396             : 
     397             :   static Function *getOrInsertFunction(llvm::Module *M,
     398             :                                        const AMDGPULibFunc &fInfo);
     399             :   static bool parse(StringRef MangledName, AMDGPULibFunc &Ptr);
     400             : 
     401             : private:
     402             :   /// Initialize as a mangled library function.
     403             :   void initMangled();
     404             :   std::unique_ptr<AMDGPULibFuncImpl> Impl;
     405             : };
     406             : 
     407             : class AMDGPUMangledLibFunc : public AMDGPULibFuncImpl {
     408             : public:
     409             :   Param Leads[2];
     410             : 
     411             :   explicit AMDGPUMangledLibFunc();
     412             :   explicit AMDGPUMangledLibFunc(EFuncId id,
     413             :                                 const AMDGPUMangledLibFunc &copyFrom);
     414             : 
     415             :   std::string getName() const override;
     416             :   unsigned getNumArgs() const override;
     417             :   FunctionType *getFunctionType(Module &M) const override;
     418             :   static StringRef getUnmangledName(StringRef MangledName);
     419             : 
     420             :   bool parseFuncName(StringRef &mangledName) override;
     421             : 
     422             :   // Methods for support type inquiry through isa, cast, and dyn_cast:
     423           2 :   static bool classof(const AMDGPULibFuncImpl *F) { return F->isMangled(); }
     424             : 
     425             :   std::string mangle() const override;
     426             : 
     427             : private:
     428             :   std::string mangleNameItanium() const;
     429             : 
     430             :   std::string mangleName(StringRef Name) const;
     431             :   bool parseUnmangledName(StringRef MangledName);
     432             : 
     433             :   template <typename Stream> void writeName(Stream &OS) const;
     434             : };
     435             : 
     436             : class AMDGPUUnmangledLibFunc : public AMDGPULibFuncImpl {
     437             :   FunctionType *FuncTy;
     438             : 
     439             : public:
     440             :   explicit AMDGPUUnmangledLibFunc();
     441          72 :   explicit AMDGPUUnmangledLibFunc(StringRef FName, FunctionType *FT) {
     442          36 :     Name = FName;
     443          36 :     FuncTy = FT;
     444          36 :   }
     445           0 :   std::string getName() const override { return Name; }
     446             :   unsigned getNumArgs() const override;
     447          36 :   FunctionType *getFunctionType(Module &M) const override { return FuncTy; }
     448             : 
     449             :   bool parseFuncName(StringRef &Name) override;
     450             : 
     451             :   // Methods for support type inquiry through isa, cast, and dyn_cast:
     452           0 :   static bool classof(const AMDGPULibFuncImpl *F) { return !F->isMangled(); }
     453             : 
     454          36 :   std::string mangle() const override { return Name; }
     455             : 
     456             :   void setFunctionType(FunctionType *FT) { FuncTy = FT; }
     457             : };
     458             : }
     459             : #endif // _AMDGPU_LIBFUNC_H_

Generated by: LCOV version 1.13