LCOV - code coverage report
Current view: top level - include/llvm/Support - AMDGPUMetadata.h (source / functions) Hit Total Coverage
Test: llvm-toolchain.info Lines: 11 11 100.0 %
Date: 2018-05-20 00:06:23 Functions: 12 12 100.0 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : //===--- AMDGPUMetadata.h ---------------------------------------*- C++ -*-===//
       2             : //
       3             : //                     The LLVM Compiler Infrastructure
       4             : //
       5             : // This file is distributed under the University of Illinois Open Source
       6             : // License. See LICENSE.TXT for details.
       7             : //
       8             : //===----------------------------------------------------------------------===//
       9             : //
      10             : /// \file
      11             : /// AMDGPU metadata definitions and in-memory representations.
      12             : ///
      13             : //
      14             : //===----------------------------------------------------------------------===//
      15             : 
      16             : #ifndef LLVM_SUPPORT_AMDGPUMETADATA_H
      17             : #define LLVM_SUPPORT_AMDGPUMETADATA_H
      18             : 
      19             : #include <cstdint>
      20             : #include <string>
      21             : #include <system_error>
      22             : #include <vector>
      23             : 
      24             : namespace llvm {
      25             : namespace AMDGPU {
      26             : 
      27             : //===----------------------------------------------------------------------===//
      28             : // HSA metadata.
      29             : //===----------------------------------------------------------------------===//
      30             : namespace HSAMD {
      31             : 
      32             : /// HSA metadata major version.
      33             : constexpr uint32_t VersionMajor = 1;
      34             : /// HSA metadata minor version.
      35             : constexpr uint32_t VersionMinor = 0;
      36             : 
      37             : /// HSA metadata beginning assembler directive.
      38             : constexpr char AssemblerDirectiveBegin[] = ".amd_amdgpu_hsa_metadata";
      39             : /// HSA metadata ending assembler directive.
      40             : constexpr char AssemblerDirectiveEnd[] = ".end_amd_amdgpu_hsa_metadata";
      41             : 
      42             : /// Access qualifiers.
      43             : enum class AccessQualifier : uint8_t {
      44             :   Default   = 0,
      45             :   ReadOnly  = 1,
      46             :   WriteOnly = 2,
      47             :   ReadWrite = 3,
      48             :   Unknown   = 0xff
      49             : };
      50             : 
      51             : /// Address space qualifiers.
      52             : enum class AddressSpaceQualifier : uint8_t {
      53             :   Private  = 0,
      54             :   Global   = 1,
      55             :   Constant = 2,
      56             :   Local    = 3,
      57             :   Generic  = 4,
      58             :   Region   = 5,
      59             :   Unknown  = 0xff
      60             : };
      61             : 
      62             : /// Value kinds.
      63             : enum class ValueKind : uint8_t {
      64             :   ByValue                = 0,
      65             :   GlobalBuffer           = 1,
      66             :   DynamicSharedPointer   = 2,
      67             :   Sampler                = 3,
      68             :   Image                  = 4,
      69             :   Pipe                   = 5,
      70             :   Queue                  = 6,
      71             :   HiddenGlobalOffsetX    = 7,
      72             :   HiddenGlobalOffsetY    = 8,
      73             :   HiddenGlobalOffsetZ    = 9,
      74             :   HiddenNone             = 10,
      75             :   HiddenPrintfBuffer     = 11,
      76             :   HiddenDefaultQueue     = 12,
      77             :   HiddenCompletionAction = 13,
      78             :   Unknown                = 0xff
      79             : };
      80             : 
      81             : /// Value types.
      82             : enum class ValueType : uint8_t {
      83             :   Struct  = 0,
      84             :   I8      = 1,
      85             :   U8      = 2,
      86             :   I16     = 3,
      87             :   U16     = 4,
      88             :   F16     = 5,
      89             :   I32     = 6,
      90             :   U32     = 7,
      91             :   F32     = 8,
      92             :   I64     = 9,
      93             :   U64     = 10,
      94             :   F64     = 11,
      95             :   Unknown = 0xff
      96             : };
      97             : 
      98             : //===----------------------------------------------------------------------===//
      99             : // Kernel Metadata.
     100             : //===----------------------------------------------------------------------===//
     101             : namespace Kernel {
     102             : 
     103             : //===----------------------------------------------------------------------===//
     104             : // Kernel Attributes Metadata.
     105             : //===----------------------------------------------------------------------===//
     106             : namespace Attrs {
     107             : 
     108             : namespace Key {
     109             : /// Key for Kernel::Attr::Metadata::mReqdWorkGroupSize.
     110             : constexpr char ReqdWorkGroupSize[] = "ReqdWorkGroupSize";
     111             : /// Key for Kernel::Attr::Metadata::mWorkGroupSizeHint.
     112             : constexpr char WorkGroupSizeHint[] = "WorkGroupSizeHint";
     113             : /// Key for Kernel::Attr::Metadata::mVecTypeHint.
     114             : constexpr char VecTypeHint[] = "VecTypeHint";
     115             : /// Key for Kernel::Attr::Metadata::mRuntimeHandle.
     116             : constexpr char RuntimeHandle[] = "RuntimeHandle";
     117             : } // end namespace Key
     118             : 
     119             : /// In-memory representation of kernel attributes metadata.
     120       40185 : struct Metadata final {
     121             :   /// 'reqd_work_group_size' attribute. Optional.
     122             :   std::vector<uint32_t> mReqdWorkGroupSize = std::vector<uint32_t>();
     123             :   /// 'work_group_size_hint' attribute. Optional.
     124             :   std::vector<uint32_t> mWorkGroupSizeHint = std::vector<uint32_t>();
     125             :   /// 'vec_type_hint' attribute. Optional.
     126             :   std::string mVecTypeHint = std::string();
     127             :   /// External symbol created by runtime to store the kernel address
     128             :   /// for enqueued blocks.
     129             :   std::string mRuntimeHandle = std::string();
     130             : 
     131             :   /// Default constructor.
     132             :   Metadata() = default;
     133             : 
     134             :   /// \returns True if kernel attributes metadata is empty, false otherwise.
     135             :   bool empty() const {
     136             :     return !notEmpty();
     137             :   }
     138             : 
     139             :   /// \returns True if kernel attributes metadata is not empty, false otherwise.
     140             :   bool notEmpty() const {
     141        7677 :     return !mReqdWorkGroupSize.empty() || !mWorkGroupSizeHint.empty() ||
     142        7590 :            !mVecTypeHint.empty() || !mRuntimeHandle.empty();
     143             :   }
     144             : };
     145             : 
     146             : } // end namespace Attrs
     147             : 
     148             : //===----------------------------------------------------------------------===//
     149             : // Kernel Argument Metadata.
     150             : //===----------------------------------------------------------------------===//
     151             : namespace Arg {
     152             : 
     153             : namespace Key {
     154             : /// Key for Kernel::Arg::Metadata::mName.
     155             : constexpr char Name[] = "Name";
     156             : /// Key for Kernel::Arg::Metadata::mTypeName.
     157             : constexpr char TypeName[] = "TypeName";
     158             : /// Key for Kernel::Arg::Metadata::mSize.
     159             : constexpr char Size[] = "Size";
     160             : /// Key for Kernel::Arg::Metadata::mAlign.
     161             : constexpr char Align[] = "Align";
     162             : /// Key for Kernel::Arg::Metadata::mValueKind.
     163             : constexpr char ValueKind[] = "ValueKind";
     164             : /// Key for Kernel::Arg::Metadata::mValueType.
     165             : constexpr char ValueType[] = "ValueType";
     166             : /// Key for Kernel::Arg::Metadata::mPointeeAlign.
     167             : constexpr char PointeeAlign[] = "PointeeAlign";
     168             : /// Key for Kernel::Arg::Metadata::mAddrSpaceQual.
     169             : constexpr char AddrSpaceQual[] = "AddrSpaceQual";
     170             : /// Key for Kernel::Arg::Metadata::mAccQual.
     171             : constexpr char AccQual[] = "AccQual";
     172             : /// Key for Kernel::Arg::Metadata::mActualAccQual.
     173             : constexpr char ActualAccQual[] = "ActualAccQual";
     174             : /// Key for Kernel::Arg::Metadata::mIsConst.
     175             : constexpr char IsConst[] = "IsConst";
     176             : /// Key for Kernel::Arg::Metadata::mIsRestrict.
     177             : constexpr char IsRestrict[] = "IsRestrict";
     178             : /// Key for Kernel::Arg::Metadata::mIsVolatile.
     179             : constexpr char IsVolatile[] = "IsVolatile";
     180             : /// Key for Kernel::Arg::Metadata::mIsPipe.
     181             : constexpr char IsPipe[] = "IsPipe";
     182             : } // end namespace Key
     183             : 
     184             : /// In-memory representation of kernel argument metadata.
     185       90039 : struct Metadata final {
     186             :   /// Name. Optional.
     187             :   std::string mName = std::string();
     188             :   /// Type name. Optional.
     189             :   std::string mTypeName = std::string();
     190             :   /// Size in bytes. Required.
     191             :   uint32_t mSize = 0;
     192             :   /// Alignment in bytes. Required.
     193             :   uint32_t mAlign = 0;
     194             :   /// Value kind. Required.
     195             :   ValueKind mValueKind = ValueKind::Unknown;
     196             :   /// Value type. Required.
     197             :   ValueType mValueType = ValueType::Unknown;
     198             :   /// Pointee alignment in bytes. Optional.
     199             :   uint32_t mPointeeAlign = 0;
     200             :   /// Address space qualifier. Optional.
     201             :   AddressSpaceQualifier mAddrSpaceQual = AddressSpaceQualifier::Unknown;
     202             :   /// Access qualifier. Optional.
     203             :   AccessQualifier mAccQual = AccessQualifier::Unknown;
     204             :   /// Actual access qualifier. Optional.
     205             :   AccessQualifier mActualAccQual = AccessQualifier::Unknown;
     206             :   /// True if 'const' qualifier is specified. Optional.
     207             :   bool mIsConst = false;
     208             :   /// True if 'restrict' qualifier is specified. Optional.
     209             :   bool mIsRestrict = false;
     210             :   /// True if 'volatile' qualifier is specified. Optional.
     211             :   bool mIsVolatile = false;
     212             :   /// True if 'pipe' qualifier is specified. Optional.
     213             :   bool mIsPipe = false;
     214             : 
     215             :   /// Default constructor.
     216        5037 :   Metadata() = default;
     217             : };
     218             : 
     219             : } // end namespace Arg
     220             : 
     221             : //===----------------------------------------------------------------------===//
     222             : // Kernel Code Properties Metadata.
     223             : //===----------------------------------------------------------------------===//
     224             : namespace CodeProps {
     225             : 
     226             : namespace Key {
     227             : /// Key for Kernel::CodeProps::Metadata::mKernargSegmentSize.
     228             : constexpr char KernargSegmentSize[] = "KernargSegmentSize";
     229             : /// Key for Kernel::CodeProps::Metadata::mGroupSegmentFixedSize.
     230             : constexpr char GroupSegmentFixedSize[] = "GroupSegmentFixedSize";
     231             : /// Key for Kernel::CodeProps::Metadata::mPrivateSegmentFixedSize.
     232             : constexpr char PrivateSegmentFixedSize[] = "PrivateSegmentFixedSize";
     233             : /// Key for Kernel::CodeProps::Metadata::mKernargSegmentAlign.
     234             : constexpr char KernargSegmentAlign[] = "KernargSegmentAlign";
     235             : /// Key for Kernel::CodeProps::Metadata::mWavefrontSize.
     236             : constexpr char WavefrontSize[] = "WavefrontSize";
     237             : /// Key for Kernel::CodeProps::Metadata::mNumSGPRs.
     238             : constexpr char NumSGPRs[] = "NumSGPRs";
     239             : /// Key for Kernel::CodeProps::Metadata::mNumVGPRs.
     240             : constexpr char NumVGPRs[] = "NumVGPRs";
     241             : /// Key for Kernel::CodeProps::Metadata::mMaxFlatWorkGroupSize.
     242             : constexpr char MaxFlatWorkGroupSize[] = "MaxFlatWorkGroupSize";
     243             : /// Key for Kernel::CodeProps::Metadata::mIsDynamicCallStack.
     244             : constexpr char IsDynamicCallStack[] = "IsDynamicCallStack";
     245             : /// Key for Kernel::CodeProps::Metadata::mIsXNACKEnabled.
     246             : constexpr char IsXNACKEnabled[] = "IsXNACKEnabled";
     247             : /// Key for Kernel::CodeProps::Metadata::mNumSpilledSGPRs.
     248             : constexpr char NumSpilledSGPRs[] = "NumSpilledSGPRs";
     249             : /// Key for Kernel::CodeProps::Metadata::mNumSpilledVGPRs.
     250             : constexpr char NumSpilledVGPRs[] = "NumSpilledVGPRs";
     251             : } // end namespace Key
     252             : 
     253             : /// In-memory representation of kernel code properties metadata.
     254             : struct Metadata final {
     255             :   /// Size in bytes of the kernarg segment memory. Kernarg segment memory
     256             :   /// holds the values of the arguments to the kernel. Required.
     257             :   uint64_t mKernargSegmentSize = 0;
     258             :   /// Size in bytes of the group segment memory required by a workgroup.
     259             :   /// This value does not include any dynamically allocated group segment memory
     260             :   /// that may be added when the kernel is dispatched. Required.
     261             :   uint32_t mGroupSegmentFixedSize = 0;
     262             :   /// Size in bytes of the private segment memory required by a workitem.
     263             :   /// Private segment memory includes arg, spill and private segments. Required.
     264             :   uint32_t mPrivateSegmentFixedSize = 0;
     265             :   /// Maximum byte alignment of variables used by the kernel in the
     266             :   /// kernarg memory segment. Required.
     267             :   uint32_t mKernargSegmentAlign = 0;
     268             :   /// Wavefront size. Required.
     269             :   uint32_t mWavefrontSize = 0;
     270             :   /// Total number of SGPRs used by a wavefront. Optional.
     271             :   uint16_t mNumSGPRs = 0;
     272             :   /// Total number of VGPRs used by a workitem. Optional.
     273             :   uint16_t mNumVGPRs = 0;
     274             :   /// Maximum flat work-group size supported by the kernel. Optional.
     275             :   uint32_t mMaxFlatWorkGroupSize = 0;
     276             :   /// True if the generated machine code is using a dynamically sized
     277             :   /// call stack. Optional.
     278             :   bool mIsDynamicCallStack = false;
     279             :   /// True if the generated machine code is capable of supporting XNACK.
     280             :   /// Optional.
     281             :   bool mIsXNACKEnabled = false;
     282             :   /// Number of SGPRs spilled by a wavefront. Optional.
     283             :   uint16_t mNumSpilledSGPRs = 0;
     284             :   /// Number of VGPRs spilled by a workitem. Optional.
     285             :   uint16_t mNumSpilledVGPRs = 0;
     286             : 
     287             :   /// Default constructor.
     288        1935 :   Metadata() = default;
     289             : 
     290             :   /// \returns True if kernel code properties metadata is empty, false
     291             :   /// otherwise.
     292             :   bool empty() const {
     293             :     return !notEmpty();
     294             :   }
     295             : 
     296             :   /// \returns True if kernel code properties metadata is not empty, false
     297             :   /// otherwise.
     298             :   bool notEmpty() const {
     299             :     return true;
     300             :   }
     301             : };
     302             : 
     303             : } // end namespace CodeProps
     304             : 
     305             : //===----------------------------------------------------------------------===//
     306             : // Kernel Debug Properties Metadata.
     307             : //===----------------------------------------------------------------------===//
     308             : namespace DebugProps {
     309             : 
     310             : namespace Key {
     311             : /// Key for Kernel::DebugProps::Metadata::mDebuggerABIVersion.
     312             : constexpr char DebuggerABIVersion[] = "DebuggerABIVersion";
     313             : /// Key for Kernel::DebugProps::Metadata::mReservedNumVGPRs.
     314             : constexpr char ReservedNumVGPRs[] = "ReservedNumVGPRs";
     315             : /// Key for Kernel::DebugProps::Metadata::mReservedFirstVGPR.
     316             : constexpr char ReservedFirstVGPR[] = "ReservedFirstVGPR";
     317             : /// Key for Kernel::DebugProps::Metadata::mPrivateSegmentBufferSGPR.
     318             : constexpr char PrivateSegmentBufferSGPR[] = "PrivateSegmentBufferSGPR";
     319             : /// Key for
     320             : ///     Kernel::DebugProps::Metadata::mWavefrontPrivateSegmentOffsetSGPR.
     321             : constexpr char WavefrontPrivateSegmentOffsetSGPR[] =
     322             :     "WavefrontPrivateSegmentOffsetSGPR";
     323             : } // end namespace Key
     324             : 
     325             : /// In-memory representation of kernel debug properties metadata.
     326       24438 : struct Metadata final {
     327             :   /// Debugger ABI version. Optional.
     328             :   std::vector<uint32_t> mDebuggerABIVersion = std::vector<uint32_t>();
     329             :   /// Consecutive number of VGPRs reserved for debugger use. Must be 0 if
     330             :   /// mDebuggerABIVersion is not set. Optional.
     331             :   uint16_t mReservedNumVGPRs = 0;
     332             :   /// First fixed VGPR reserved. Must be uint16_t(-1) if
     333             :   /// mDebuggerABIVersion is not set or mReservedFirstVGPR is 0. Optional.
     334             :   uint16_t mReservedFirstVGPR = uint16_t(-1);
     335             :   /// Fixed SGPR of the first of 4 SGPRs used to hold the scratch V# used
     336             :   /// for the entire kernel execution. Must be uint16_t(-1) if
     337             :   /// mDebuggerABIVersion is not set or SGPR not used or not known. Optional.
     338             :   uint16_t mPrivateSegmentBufferSGPR = uint16_t(-1);
     339             :   /// Fixed SGPR used to hold the wave scratch offset for the entire
     340             :   /// kernel execution. Must be uint16_t(-1) if mDebuggerABIVersion is not set
     341             :   /// or SGPR is not used or not known. Optional.
     342             :   uint16_t mWavefrontPrivateSegmentOffsetSGPR = uint16_t(-1);
     343             : 
     344             :   /// Default constructor.
     345        3748 :   Metadata() = default;
     346             : 
     347             :   /// \returns True if kernel debug properties metadata is empty, false
     348             :   /// otherwise.
     349             :   bool empty() const {
     350             :     return !notEmpty();
     351             :   }
     352             : 
     353             :   /// \returns True if kernel debug properties metadata is not empty, false
     354             :   /// otherwise.
     355             :   bool notEmpty() const {
     356             :     return !mDebuggerABIVersion.empty();
     357             :   }
     358             : };
     359             : 
     360             : } // end namespace DebugProps
     361             : 
     362             : namespace Key {
     363             : /// Key for Kernel::Metadata::mName.
     364             : constexpr char Name[] = "Name";
     365             : /// Key for Kernel::Metadata::mSymbolName.
     366             : constexpr char SymbolName[] = "SymbolName";
     367             : /// Key for Kernel::Metadata::mLanguage.
     368             : constexpr char Language[] = "Language";
     369             : /// Key for Kernel::Metadata::mLanguageVersion.
     370             : constexpr char LanguageVersion[] = "LanguageVersion";
     371             : /// Key for Kernel::Metadata::mAttrs.
     372             : constexpr char Attrs[] = "Attrs";
     373             : /// Key for Kernel::Metadata::mArgs.
     374             : constexpr char Args[] = "Args";
     375             : /// Key for Kernel::Metadata::mCodeProps.
     376             : constexpr char CodeProps[] = "CodeProps";
     377             : /// Key for Kernel::Metadata::mDebugProps.
     378             : constexpr char DebugProps[] = "DebugProps";
     379             : } // end namespace Key
     380             : 
     381             : /// In-memory representation of kernel metadata.
     382       66552 : struct Metadata final {
     383             :   /// Kernel source name. Required.
     384             :   std::string mName = std::string();
     385             :   /// Kernel descriptor name. Required.
     386             :   std::string mSymbolName = std::string();
     387             :   /// Language. Optional.
     388             :   std::string mLanguage = std::string();
     389             :   /// Language version. Optional.
     390             :   std::vector<uint32_t> mLanguageVersion = std::vector<uint32_t>();
     391             :   /// Attributes metadata. Optional.
     392             :   Attrs::Metadata mAttrs = Attrs::Metadata();
     393             :   /// Arguments metadata. Optional.
     394             :   std::vector<Arg::Metadata> mArgs = std::vector<Arg::Metadata>();
     395             :   /// Code properties metadata. Optional.
     396             :   CodeProps::Metadata mCodeProps = CodeProps::Metadata();
     397             :   /// Debug properties metadata. Optional.
     398             :   DebugProps::Metadata mDebugProps = DebugProps::Metadata();
     399             : 
     400             :   /// Default constructor.
     401        9675 :   Metadata() = default;
     402             : };
     403             : 
     404             : } // end namespace Kernel
     405             : 
     406             : namespace Key {
     407             : /// Key for HSA::Metadata::mVersion.
     408             : constexpr char Version[] = "Version";
     409             : /// Key for HSA::Metadata::mPrintf.
     410             : constexpr char Printf[] = "Printf";
     411             : /// Key for HSA::Metadata::mKernels.
     412             : constexpr char Kernels[] = "Kernels";
     413             : } // end namespace Key
     414             : 
     415             : /// In-memory representation of HSA metadata.
     416        5790 : struct Metadata final {
     417             :   /// HSA metadata version. Required.
     418             :   std::vector<uint32_t> mVersion = std::vector<uint32_t>();
     419             :   /// Printf metadata. Optional.
     420             :   std::vector<std::string> mPrintf = std::vector<std::string>();
     421             :   /// Kernels metadata. Required.
     422             :   std::vector<Kernel::Metadata> mKernels = std::vector<Kernel::Metadata>();
     423             : 
     424             :   /// Default constructor.
     425             :   Metadata() = default;
     426             : };
     427             : 
     428             : /// Converts \p String to \p HSAMetadata.
     429             : std::error_code fromString(std::string String, Metadata &HSAMetadata);
     430             : 
     431             : /// Converts \p HSAMetadata to \p String.
     432             : std::error_code toString(Metadata HSAMetadata, std::string &String);
     433             : 
     434             : } // end namespace HSAMD
     435             : 
     436             : //===----------------------------------------------------------------------===//
     437             : // PAL metadata.
     438             : //===----------------------------------------------------------------------===//
     439             : namespace PALMD {
     440             : 
     441             : /// PAL metadata assembler directive.
     442             : constexpr char AssemblerDirective[] = ".amd_amdgpu_pal_metadata";
     443             : 
     444             : /// PAL metadata keys.
     445             : enum Key : uint32_t {
     446             :   LS_NUM_USED_VGPRS = 0x10000021,
     447             :   HS_NUM_USED_VGPRS = 0x10000022,
     448             :   ES_NUM_USED_VGPRS = 0x10000023,
     449             :   GS_NUM_USED_VGPRS = 0x10000024,
     450             :   VS_NUM_USED_VGPRS = 0x10000025,
     451             :   PS_NUM_USED_VGPRS = 0x10000026,
     452             :   CS_NUM_USED_VGPRS = 0x10000027,
     453             : 
     454             :   LS_NUM_USED_SGPRS = 0x10000028,
     455             :   HS_NUM_USED_SGPRS = 0x10000029,
     456             :   ES_NUM_USED_SGPRS = 0x1000002a,
     457             :   GS_NUM_USED_SGPRS = 0x1000002b,
     458             :   VS_NUM_USED_SGPRS = 0x1000002c,
     459             :   PS_NUM_USED_SGPRS = 0x1000002d,
     460             :   CS_NUM_USED_SGPRS = 0x1000002e,
     461             : 
     462             :   LS_SCRATCH_SIZE = 0x10000044,
     463             :   HS_SCRATCH_SIZE = 0x10000045,
     464             :   ES_SCRATCH_SIZE = 0x10000046,
     465             :   GS_SCRATCH_SIZE = 0x10000047,
     466             :   VS_SCRATCH_SIZE = 0x10000048,
     467             :   PS_SCRATCH_SIZE = 0x10000049,
     468             :   CS_SCRATCH_SIZE = 0x1000004a
     469             : };
     470             : 
     471             : /// PAL metadata represented as a vector.
     472             : typedef std::vector<uint32_t> Metadata;
     473             : 
     474             : /// Converts \p PALMetadata to \p String.
     475             : std::error_code toString(const Metadata &PALMetadata, std::string &String);
     476             : 
     477             : } // end namespace PALMD
     478             : } // end namespace AMDGPU
     479             : } // end namespace llvm
     480             : 
     481             : #endif // LLVM_SUPPORT_AMDGPUMETADATA_H

Generated by: LCOV version 1.13