DXILResource.cpp

Go to the documentation of this file.

//===- DXILResource.cpp - Representations of DXIL resources ---------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
 
#include "llvm/Analysis/DXILResource.h"
#include "llvm/ADT/APInt.h"
#include "llvm/IR/DerivedTypes.h"
#include "llvm/IR/Metadata.h"
 
using namespace llvm;
using namespace dxil;
 
bool ResourceInfo::isUAV() const { return RC == ResourceClass::UAV; }
 
bool ResourceInfo::isCBuffer() const { return RC == ResourceClass::CBuffer; }
 
bool ResourceInfo::isSampler() const { return RC == ResourceClass::Sampler; }
 
bool ResourceInfo::isStruct() const {
  return Kind == ResourceKind::StructuredBuffer;
}
 
bool ResourceInfo::isTyped() const {
  switch (Kind) {
  case ResourceKind::Texture1D:
  case ResourceKind::Texture2D:
  case ResourceKind::Texture2DMS:
  case ResourceKind::Texture3D:
  case ResourceKind::TextureCube:
  case ResourceKind::Texture1DArray:
  case ResourceKind::Texture2DArray:
  case ResourceKind::Texture2DMSArray:
  case ResourceKind::TextureCubeArray:
  case ResourceKind::TypedBuffer:
    return true;
  case ResourceKind::RawBuffer:
  case ResourceKind::StructuredBuffer:
  case ResourceKind::FeedbackTexture2D:
  case ResourceKind::FeedbackTexture2DArray:
  case ResourceKind::CBuffer:
  case ResourceKind::Sampler:
  case ResourceKind::TBuffer:
  case ResourceKind::RTAccelerationStructure:
    return false;
  case ResourceKind::Invalid:
  case ResourceKind::NumEntries:
    llvm_unreachable("Invalid resource kind");
  }
  llvm_unreachable("Unhandled ResourceKind enum");
}
 
bool ResourceInfo::isFeedback() const {
  return Kind == ResourceKind::FeedbackTexture2D ||
         Kind == ResourceKind::FeedbackTexture2DArray;
}
 
bool ResourceInfo::isMultiSample() const {
  return Kind == ResourceKind::Texture2DMS ||
         Kind == ResourceKind::Texture2DMSArray;
}
 
ResourceInfo ResourceInfo::SRV(Value *Symbol, StringRef Name,
                               ElementType ElementTy, uint32_t ElementCount,
                               ResourceKind Kind) {
  ResourceInfo RI(ResourceClass::SRV, Kind, Symbol, Name);
  assert(RI.isTyped() && !(RI.isStruct() || RI.isMultiSample()) &&
         "Invalid ResourceKind for SRV constructor.");
  RI.Typed.ElementTy = ElementTy;
  RI.Typed.ElementCount = ElementCount;
  return RI;
}
 
ResourceInfo ResourceInfo::RawBuffer(Value *Symbol, StringRef Name) {
  ResourceInfo RI(ResourceClass::SRV, ResourceKind::RawBuffer, Symbol, Name);
  return RI;
}
 
ResourceInfo ResourceInfo::StructuredBuffer(Value *Symbol, StringRef Name,
                                            uint32_t Stride, Align Alignment) {
  ResourceInfo RI(ResourceClass::SRV, ResourceKind::StructuredBuffer, Symbol,
                  Name);
  RI.Struct.Stride = Stride;
  RI.Struct.Alignment = Alignment;
  return RI;
}
 
ResourceInfo ResourceInfo::Texture2DMS(Value *Symbol, StringRef Name,
                                       ElementType ElementTy,
                                       uint32_t ElementCount,
                                       uint32_t SampleCount) {
  ResourceInfo RI(ResourceClass::SRV, ResourceKind::Texture2DMS, Symbol, Name);
  RI.Typed.ElementTy = ElementTy;
  RI.Typed.ElementCount = ElementCount;
  RI.MultiSample.Count = SampleCount;
  return RI;
}
 
ResourceInfo ResourceInfo::Texture2DMSArray(Value *Symbol, StringRef Name,
                                            ElementType ElementTy,
                                            uint32_t ElementCount,
                                            uint32_t SampleCount) {
  ResourceInfo RI(ResourceClass::SRV, ResourceKind::Texture2DMSArray, Symbol,
                  Name);
  RI.Typed.ElementTy = ElementTy;
  RI.Typed.ElementCount = ElementCount;
  RI.MultiSample.Count = SampleCount;
  return RI;
}
 
ResourceInfo ResourceInfo::UAV(Value *Symbol, StringRef Name,
                               ElementType ElementTy, uint32_t ElementCount,
                               bool GloballyCoherent, bool IsROV,
                               ResourceKind Kind) {
  ResourceInfo RI(ResourceClass::UAV, Kind, Symbol, Name);
  assert(RI.isTyped() && !(RI.isStruct() || RI.isMultiSample()) &&
         "Invalid ResourceKind for UAV constructor.");
  RI.Typed.ElementTy = ElementTy;
  RI.Typed.ElementCount = ElementCount;
  RI.UAVFlags.GloballyCoherent = GloballyCoherent;
  RI.UAVFlags.IsROV = IsROV;
  RI.UAVFlags.HasCounter = false;
  return RI;
}
 
ResourceInfo ResourceInfo::RWRawBuffer(Value *Symbol, StringRef Name,
                                       bool GloballyCoherent, bool IsROV) {
  ResourceInfo RI(ResourceClass::UAV, ResourceKind::RawBuffer, Symbol, Name);
  RI.UAVFlags.GloballyCoherent = GloballyCoherent;
  RI.UAVFlags.IsROV = IsROV;
  RI.UAVFlags.HasCounter = false;
  return RI;
}
 
ResourceInfo ResourceInfo::RWStructuredBuffer(Value *Symbol, StringRef Name,
                                              uint32_t Stride, Align Alignment,
                                              bool GloballyCoherent, bool IsROV,
                                              bool HasCounter) {
  ResourceInfo RI(ResourceClass::UAV, ResourceKind::StructuredBuffer, Symbol,
                  Name);
  RI.Struct.Stride = Stride;
  RI.Struct.Alignment = Alignment;
  RI.UAVFlags.GloballyCoherent = GloballyCoherent;
  RI.UAVFlags.IsROV = IsROV;
  RI.UAVFlags.HasCounter = HasCounter;
  return RI;
}
 
ResourceInfo ResourceInfo::RWTexture2DMS(Value *Symbol, StringRef Name,
                                         ElementType ElementTy,
                                         uint32_t ElementCount,
                                         uint32_t SampleCount,
                                         bool GloballyCoherent) {
  ResourceInfo RI(ResourceClass::UAV, ResourceKind::Texture2DMS, Symbol, Name);
  RI.Typed.ElementTy = ElementTy;
  RI.Typed.ElementCount = ElementCount;
  RI.UAVFlags.GloballyCoherent = GloballyCoherent;
  RI.UAVFlags.IsROV = false;
  RI.UAVFlags.HasCounter = false;
  RI.MultiSample.Count = SampleCount;
  return RI;
}
 
ResourceInfo ResourceInfo::RWTexture2DMSArray(Value *Symbol, StringRef Name,
                                              ElementType ElementTy,
                                              uint32_t ElementCount,
                                              uint32_t SampleCount,
                                              bool GloballyCoherent) {
  ResourceInfo RI(ResourceClass::UAV, ResourceKind::Texture2DMSArray, Symbol,
                  Name);
  RI.Typed.ElementTy = ElementTy;
  RI.Typed.ElementCount = ElementCount;
  RI.UAVFlags.GloballyCoherent = GloballyCoherent;
  RI.UAVFlags.IsROV = false;
  RI.UAVFlags.HasCounter = false;
  RI.MultiSample.Count = SampleCount;
  return RI;
}
 
ResourceInfo ResourceInfo::FeedbackTexture2D(Value *Symbol, StringRef Name,
                                             SamplerFeedbackType FeedbackTy) {
  ResourceInfo RI(ResourceClass::UAV, ResourceKind::FeedbackTexture2D, Symbol,
                  Name);
  RI.UAVFlags.GloballyCoherent = false;
  RI.UAVFlags.IsROV = false;
  RI.UAVFlags.HasCounter = false;
  RI.Feedback.Type = FeedbackTy;
  return RI;
}
 
ResourceInfo
ResourceInfo::FeedbackTexture2DArray(Value *Symbol, StringRef Name,
                                     SamplerFeedbackType FeedbackTy) {
  ResourceInfo RI(ResourceClass::UAV, ResourceKind::FeedbackTexture2DArray,
                  Symbol, Name);
  RI.UAVFlags.GloballyCoherent = false;
  RI.UAVFlags.IsROV = false;
  RI.UAVFlags.HasCounter = false;
  RI.Feedback.Type = FeedbackTy;
  return RI;
}
 
ResourceInfo ResourceInfo::CBuffer(Value *Symbol, StringRef Name,
                                   uint32_t Size) {
  ResourceInfo RI(ResourceClass::CBuffer, ResourceKind::CBuffer, Symbol, Name);
  RI.CBufferSize = Size;
  return RI;
}
 
ResourceInfo ResourceInfo::Sampler(Value *Symbol, StringRef Name,
                                   SamplerType SamplerTy) {
  ResourceInfo RI(ResourceClass::Sampler, ResourceKind::Sampler, Symbol, Name);
  RI.SamplerTy = SamplerTy;
  return RI;
}
 
bool ResourceInfo::operator==(const ResourceInfo &RHS) const {
  if (std::tie(Symbol, Name, Binding, RC, Kind) !=
      std::tie(RHS.Symbol, RHS.Name, RHS.Binding, RHS.RC, RHS.Kind))
    return false;
  if (isCBuffer())
    return CBufferSize == RHS.CBufferSize;
  if (isSampler())
    return SamplerTy == RHS.SamplerTy;
  if (isUAV() && UAVFlags != RHS.UAVFlags)
    return false;
 
  if (isStruct())
    return Struct == RHS.Struct;
  if (isFeedback())
    return Feedback == RHS.Feedback;
  if (isTyped() && Typed != RHS.Typed)
    return false;
 
  if (isMultiSample())
    return MultiSample == RHS.MultiSample;
 
  assert((Kind == ResourceKind::RawBuffer) && "Unhandled resource kind");
  return true;
}
 
MDTuple *ResourceInfo::getAsMetadata(LLVMContext &Ctx) const {
  SmallVector<Metadata *, 11> MDVals;
 
  Type *I32Ty = Type::getInt32Ty(Ctx);
  Type *I1Ty = Type::getInt1Ty(Ctx);
  auto getIntMD = [&I32Ty](uint32_t V) {
    return ConstantAsMetadata::get(
        Constant::getIntegerValue(I32Ty, APInt(32, V)));
  };
  auto getBoolMD = [&I1Ty](uint32_t V) {
    return ConstantAsMetadata::get(
        Constant::getIntegerValue(I1Ty, APInt(1, V)));
  };
 
  MDVals.push_back(getIntMD(Binding.UniqueID));
  MDVals.push_back(ValueAsMetadata::get(Symbol));
  MDVals.push_back(MDString::get(Ctx, Name));
  MDVals.push_back(getIntMD(Binding.Space));
  MDVals.push_back(getIntMD(Binding.LowerBound));
  MDVals.push_back(getIntMD(Binding.Size));
 
  if (isCBuffer()) {
    MDVals.push_back(getIntMD(CBufferSize));
    MDVals.push_back(nullptr);
  } else if (isSampler()) {
    MDVals.push_back(getIntMD(llvm::to_underlying(SamplerTy)));
    MDVals.push_back(nullptr);
  } else {
    MDVals.push_back(getIntMD(llvm::to_underlying(Kind)));
 
    if (isUAV()) {
      MDVals.push_back(getBoolMD(UAVFlags.GloballyCoherent));
      MDVals.push_back(getBoolMD(UAVFlags.HasCounter));
      MDVals.push_back(getBoolMD(UAVFlags.IsROV));
    } else {
      // All SRVs include sample count in the metadata, but it's only meaningful
      // for multi-sampled textured. Also, UAVs can be multisampled in SM6.7+,
      // but this just isn't reflected in the metadata at all.
      uint32_t SampleCount = isMultiSample() ? MultiSample.Count : 0;
      MDVals.push_back(getIntMD(SampleCount));
    }
 
    // Further properties are attached to a metadata list of tag-value pairs.
    SmallVector<Metadata *> Tags;
    if (isStruct()) {
      Tags.push_back(
          getIntMD(llvm::to_underlying(ExtPropTags::StructuredBufferStride)));
      Tags.push_back(getIntMD(Struct.Stride));
    } else if (isTyped()) {
      Tags.push_back(getIntMD(llvm::to_underlying(ExtPropTags::ElementType)));
      Tags.push_back(getIntMD(llvm::to_underlying(Typed.ElementTy)));
    } else if (isFeedback()) {
      Tags.push_back(
          getIntMD(llvm::to_underlying(ExtPropTags::SamplerFeedbackKind)));
      Tags.push_back(getIntMD(llvm::to_underlying(Feedback.Type)));
    }
    MDVals.push_back(Tags.empty() ? nullptr : MDNode::get(Ctx, Tags));
  }
 
  return MDNode::get(Ctx, MDVals);
}
 
std::pair<uint32_t, uint32_t> ResourceInfo::getAnnotateProps() const {
  uint32_t ResourceKind = llvm::to_underlying(Kind);
  uint32_t AlignLog2 = isStruct() ? Log2(Struct.Alignment) : 0;
  bool IsUAV = isUAV();
  bool IsROV = IsUAV && UAVFlags.IsROV;
  bool IsGloballyCoherent = IsUAV && UAVFlags.GloballyCoherent;
  uint8_t SamplerCmpOrHasCounter = 0;
  if (IsUAV)
    SamplerCmpOrHasCounter = UAVFlags.HasCounter;
  else if (isSampler())
    SamplerCmpOrHasCounter = SamplerTy == SamplerType::Comparison;
 
  // TODO: Document this format. Currently the only reference is the
  // implementation of dxc's DxilResourceProperties struct.
  uint32_t Word0 = 0;
  Word0 |= ResourceKind & 0xFF;
  Word0 |= (AlignLog2 & 0xF) << 8;
  Word0 |= (IsUAV & 1) << 12;
  Word0 |= (IsROV & 1) << 13;
  Word0 |= (IsGloballyCoherent & 1) << 14;
  Word0 |= (SamplerCmpOrHasCounter & 1) << 15;
 
  uint32_t Word1 = 0;
  if (isStruct())
    Word1 = Struct.Stride;
  else if (isCBuffer())
    Word1 = CBufferSize;
  else if (isFeedback())
    Word1 = llvm::to_underlying(Feedback.Type);
  else if (isTyped()) {
    uint32_t CompType = llvm::to_underlying(Typed.ElementTy);
    uint32_t CompCount = Typed.ElementCount;
    uint32_t SampleCount = isMultiSample() ? MultiSample.Count : 0;
 
    Word1 |= (CompType & 0xFF) << 0;
    Word1 |= (CompCount & 0xFF) << 8;
    Word1 |= (SampleCount & 0xFF) << 16;
  }
 
  return {Word0, Word1};
}
 
#define DEBUG_TYPE "dxil-resource"