lib/DXIL/DxilResourceBase.cpp

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// DxilResourceBase.cpp                                                      //
// Copyright (C) Microsoft Corporation. All rights reserved.                 //
// This file is distributed under the University of Illinois Open Source     //
// License. See LICENSE.TXT for details.                                     //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

#include "dxc/DXIL/DxilResourceBase.h"
#include "dxc/Support/Global.h"
#include "llvm/IR/Constant.h"

namespace hlsl {

//------------------------------------------------------------------------------
//
// ResourceBase methods.
//
DxilResourceBase::DxilResourceBase(Class C)
    : m_Class(C), m_Kind(Kind::Invalid), m_ID(UINT_MAX), m_SpaceID(0),
      m_LowerBound(0), m_RangeSize(0), m_pSymbol(nullptr), m_pHandle(nullptr),
      m_pHLSLTy(nullptr) {}

DxilResourceBase::Class DxilResourceBase::GetClass() const { return m_Class; }
DxilResourceBase::Kind DxilResourceBase::GetKind() const { return m_Kind; }
void DxilResourceBase::SetKind(DxilResourceBase::Kind ResourceKind) {
  DXASSERT(ResourceKind > Kind::Invalid && ResourceKind < Kind::NumEntries,
           "otherwise the caller passed wrong resource type");
  m_Kind = ResourceKind;
}

unsigned DxilResourceBase::GetID() const { return m_ID; }
unsigned DxilResourceBase::GetSpaceID() const { return m_SpaceID; }
unsigned DxilResourceBase::GetLowerBound() const { return m_LowerBound; }
unsigned DxilResourceBase::GetUpperBound() const {
  return m_RangeSize != UINT_MAX ? m_LowerBound + m_RangeSize - 1 : UINT_MAX;
}
unsigned DxilResourceBase::GetRangeSize() const { return m_RangeSize; }
llvm::Constant *DxilResourceBase::GetGlobalSymbol() const { return m_pSymbol; }
const std::string &DxilResourceBase::GetGlobalName() const { return m_Name; }
llvm::Value *DxilResourceBase::GetHandle() const { return m_pHandle; }
// If m_pHLSLTy is nullptr, HLSL type is the type of m_pSymbol.
// In sm6.6, type of m_pSymbol will be mutated to handleTy, m_pHLSLTy will save
// the original HLSL type.
llvm::Type *DxilResourceBase::GetHLSLType() const {
  return m_pHLSLTy == nullptr ? m_pSymbol->getType() : m_pHLSLTy;
}
bool DxilResourceBase::IsAllocated() const { return m_LowerBound != UINT_MAX; }
bool DxilResourceBase::IsUnbounded() const { return m_RangeSize == UINT_MAX; }

void DxilResourceBase::SetClass(Class C) { m_Class = C; }
void DxilResourceBase::SetID(unsigned ID) { m_ID = ID; }
void DxilResourceBase::SetSpaceID(unsigned SpaceID) { m_SpaceID = SpaceID; }
void DxilResourceBase::SetLowerBound(unsigned LB) { m_LowerBound = LB; }
void DxilResourceBase::SetRangeSize(unsigned RangeSize) {
  m_RangeSize = RangeSize;
}
void DxilResourceBase::SetGlobalSymbol(llvm::Constant *pGV) { m_pSymbol = pGV; }
void DxilResourceBase::SetGlobalName(const std::string &Name) { m_Name = Name; }
void DxilResourceBase::SetHandle(llvm::Value *pHandle) { m_pHandle = pHandle; }
void DxilResourceBase::SetHLSLType(llvm::Type *pTy) { m_pHLSLTy = pTy; }

static const char *s_ResourceClassNames[] = {"texture", "UAV", "cbuffer",
                                             "sampler"};
static_assert(_countof(s_ResourceClassNames) ==
                  (unsigned)DxilResourceBase::Class::Invalid,
              "Resource class names array must be updated when new resource "
              "class enums are added.");

const char *DxilResourceBase::GetResClassName() const {
  return s_ResourceClassNames[(unsigned)m_Class];
}

static const char *s_ResourceIDPrefixes[] = {"T", "U", "CB", "S"};
static_assert(_countof(s_ResourceIDPrefixes) ==
                  (unsigned)DxilResourceBase::Class::Invalid,
              "Resource id prefixes array must be updated when new resource "
              "class enums are added.");

const char *DxilResourceBase::GetResIDPrefix() const {
  return s_ResourceIDPrefixes[(unsigned)m_Class];
}

static const char *s_ResourceBindPrefixes[] = {"t", "u", "cb", "s"};
static_assert(_countof(s_ResourceBindPrefixes) ==
                  (unsigned)DxilResourceBase::Class::Invalid,
              "Resource bind prefixes array must be updated when new resource "
              "class enums are added.");

const char *DxilResourceBase::GetResBindPrefix() const {
  return s_ResourceBindPrefixes[(unsigned)m_Class];
}

static const char *s_ResourceDimNames[] = {
    "invalid", "1d",      "2d",        "2dMS",         "3d",
    "cube",    "1darray", "2darray",   "2darrayMS",    "cubearray",
    "buf",     "rawbuf",  "structbuf", "cbuffer",      "sampler",
    "tbuffer", "ras",     "fbtex2d",   "fbtex2darray",
};
static_assert(_countof(s_ResourceDimNames) ==
                  (unsigned)DxilResourceBase::Kind::NumEntries,
              "Resource dim names array must be updated when new resource kind "
              "enums are added.");

const char *DxilResourceBase::GetResDimName() const {
  return s_ResourceDimNames[(unsigned)m_Kind];
}

static const char *s_ResourceKindNames[] = {
    "invalid",
    "Texture1D",
    "Texture2D",
    "Texture2DMS",
    "Texture3D",
    "TextureCube",
    "Texture1DArray",
    "Texture2DArray",
    "Texture2DMSArray",
    "TextureCubeArray",
    "TypedBuffer",
    "RawBuffer",
    "StructuredBuffer",
    "CBuffer",
    "Sampler",
    "TBuffer",
    "RTAccelerationStructure",
    "FeedbackTexture2D",
    "FeedbackTexture2DArray",
};
static_assert(_countof(s_ResourceKindNames) ==
                  (unsigned)DxilResourceBase::Kind::NumEntries,
              "Resource kind names array must be updated when new resource "
              "kind enums are added.");

const char *DxilResourceBase::GetResKindName() const {
  return GetResourceKindName(m_Kind);
}

const char *GetResourceKindName(DXIL::ResourceKind K) {
  return s_ResourceKindNames[(unsigned)K];
}

} // namespace hlsl