DXContainerYAML.cpp Source File (original) (raw)

20#include

21#include <system_error>

23namespace llvm {

27static_assert((uint64_t)dxbc::FeatureFlags::NextUnusedBit <= 1ull << 63,

28 "Shader flag bits exceed enum size.");

31#define SHADER_FEATURE_FLAG(Num, DxilModuleNum, Val, Str) \

32 Val = (FlagData & (uint64_t)dxbc::FeatureFlags::Val) > 0;

33#include "llvm/BinaryFormat/DXContainerConstants.def"

34}

36template

45 return E;

46 auto Table = *TableOrErr;

53 TableYaml.NumRanges = Table.NumRanges;

56 for (const auto &R : Table.Ranges) {

59 R.OffsetInDescriptorsFromTableStart;

65 "Invalid value for descriptor range type");

67 if constexpr (std::is_same_v<T, dxbc::RTS0::v2::DescriptorRange>) {

69#define DESCRIPTOR_RANGE_FLAG(Num, Enum, Flag) \

70 NewR.Enum = \

71 (R.Flags & llvm::to_underlying(dxbc::DescriptorRangeFlags::Enum)) != 0;

72#include "llvm/BinaryFormat/DXContainerConstants.def"

73 }

74 TableYaml.Ranges.push_back(NewR);

75 }

78}

98 "Invalid value for parameter type");

101 Header.Offset = PH.ParameterOffset;

102

105 "Invalid value for shader visibility");

106

108

110 Data.getParameter(PH);

112 return std::move(E);

114

117 RCV->read();

119 return std::move(E);

120

121 auto Constants = *ConstantsOrErr;

126 ConstantYaml.Num32BitValues = Constants.Num32BitValues;

127 ConstantYaml.ShaderRegister = Constants.ShaderRegister;

128 ConstantYaml.RegisterSpace = Constants.RegisterSpace;

129

130 } else if (auto *RDV =

135 return std::move(E);

136 auto Descriptor = *DescriptorOrErr;

141

142 YamlDescriptor.ShaderRegister = Descriptor.ShaderRegister;

143 YamlDescriptor.RegisterSpace = Descriptor.RegisterSpace;

145#define ROOT_DESCRIPTOR_FLAG(Num, Enum, Flag) \

146 YamlDescriptor.Enum = \

147 (Descriptor.Flags & \

148 llvm::to_underlying(dxbc::RootDescriptorFlags::Enum)) > 0;

149#include "llvm/BinaryFormat/DXContainerConstants.def"

150 }

151 } else if (auto *DTV =

155 Header, RootSigDesc, DTV))

156 return std::move(E);

159 Header, RootSigDesc, DTV))

160 return std::move(E);

161 } else

163 }

164 }

165

166 for (const auto &S : Data.samplers()) {

169 "Invalid value for static sampler filter");

170

173 "Invalid value for static sampler AddressU");

174

177 "Invalid value for static sampler AddressV");

178

181 "Invalid value for static sampler AddressW");

182

185 std::errc::invalid_argument,

186 "Invalid value for static sampler ComparisonFunc");

187

190 "Invalid value for static sampler BorderColor");

191

194 std::errc::invalid_argument,

195 "Invalid value for static sampler ShaderVisibility");

196

206 NewS.MinLOD = S.MinLOD;

207 NewS.MaxLOD = S.MaxLOD;

211

213#define STATIC_SAMPLER_FLAG(Num, Enum, Flag) \

214 NewS.Enum = (S.Flags & llvm::to_underlying(dxbc::StaticSamplerFlags::Enum));

215#include "llvm/BinaryFormat/DXContainerConstants.def"

216 }

218 }

219

220#define ROOT_SIGNATURE_FLAG(Num, Val) \

221 RootSigDesc.Val = (Flags & llvm::to_underlying(dxbc::RootFlags::Val)) > 0;

222#include "llvm/BinaryFormat/DXContainerConstants.def"

223 return RootSigDesc;

224}

225

228#define ROOT_DESCRIPTOR_FLAG(Num, Enum, Flag) \

229 if (Enum) \

230 Flags |= (uint32_t)dxbc::RootDescriptorFlags::Enum;

231#include "llvm/BinaryFormat/DXContainerConstants.def"

232 return Flags;

233}

234

237#define ROOT_SIGNATURE_FLAG(Num, Val) \

238 if (Val) \

239 Flag |= (uint32_t)dxbc::RootFlags::Val;

240#include "llvm/BinaryFormat/DXContainerConstants.def"

241 return Flag;

242}

243

246#define DESCRIPTOR_RANGE_FLAG(Num, Enum, Flag) \

247 if (Enum) \

248 Flags |= (uint32_t)dxbc::DescriptorRangeFlags::Enum;

249#include "llvm/BinaryFormat/DXContainerConstants.def"

250 return Flags;

251}

252

255#define STATIC_SAMPLER_FLAG(Num, Enum, Flag) \

256 if (Enum) \

257 Flags |= (uint32_t)dxbc::StaticSamplerFlags::Enum;

258#include "llvm/BinaryFormat/DXContainerConstants.def"

259 return Flags;

260}

261

264#define SHADER_FEATURE_FLAG(Num, DxilModuleNum, Val, Str) \

265 if (Val) \

266 Flag |= (uint64_t)dxbc::FeatureFlags::Val;

267#include "llvm/BinaryFormat/DXContainerConstants.def"

268 return Flag;

269}

270

275 memcpy(Digest.data(), &Data.Digest[0], 16);

276}

277

279 memset(&Info, 0, sizeof(Info));

280}

281

285 memset(&Info, 0, sizeof(Info));

287

288 assert(Stage < std::numeric_limits<uint8_t>::max() &&

289 "Stage should be a very small number");

290

291

292 Info.ShaderStage = static_cast<uint8_t>(Stage);

293}

294

297 memset(&Info, 0, sizeof(Info));

299}

300

303 memset(&Info, 0, sizeof(Info));

305}

306

312 P->EntryNameOffset)) {

313 memset(&Info, 0, sizeof(Info));

315}

316

317namespace yaml {

318

324

333

345

348#define SHADER_FEATURE_FLAG(Num, DxilModuleNum, Val, Str) \

349 IO.mapRequired(#Val, Flags.Val);

350#include "llvm/BinaryFormat/DXContainerConstants.def"

351}

352

358

362

363

367

368

370

371

372

375

379 return;

383

388 IO.mapRequired("OutputVectorMasks", MutableOutMasks);

391 }

395

398

401}

402

415

420

430#define ROOT_SIGNATURE_FLAG(Num, Val) IO.mapOptional(#Val, S.Val, false);

431#include "llvm/BinaryFormat/DXContainerConstants.def"

432}

433

437

439 if (R.NumDescriptors == UINT_MAX) {

440 int32_t NegOne = -1;

442 } else

443 IO.mapRequired("NumDescriptors", R.NumDescriptors);

444 } else {

445 int32_t TmpNumDesc = 0;

447 R.NumDescriptors = static_cast<uint32_t>(TmpNumDesc);

448 }

449

450 IO.mapRequired("BaseShaderRegister", R.BaseShaderRegister);

451 IO.mapRequired("RegisterSpace", R.RegisterSpace);

452 IO.mapRequired("OffsetInDescriptorsFromTableStart",

453 R.OffsetInDescriptorsFromTableStart);

454#define DESCRIPTOR_RANGE_FLAG(Num, Enum, Flag) \

455 IO.mapOptional(#Flag, R.Enum, false);

456#include "llvm/BinaryFormat/DXContainerConstants.def"

457}

458

465

471 IO.mapRequired("ShaderVisibility", L.Header.Visibility);

472

473 switch (L.Header.Type) {

474 case dxbc::RootParameterType::Constants32Bit: {

478 break;

479 }

480 case dxbc::RootParameterType::CBV:

481 case dxbc::RootParameterType::SRV:

482 case dxbc::RootParameterType::UAV: {

486 break;

487 }

488 case dxbc::RootParameterType::DescriptorTable: {

492 break;

493 }

494 }

495}

496

503

508#define ROOT_DESCRIPTOR_FLAG(Num, Enum, Flag) \

509 IO.mapOptional(#Flag, D.Enum, false);

510#include "llvm/BinaryFormat/DXContainerConstants.def"

511}

512

515

529#define STATIC_SAMPLER_FLAG(Num, Enum, Flag) \

530 IO.mapOptional(#Flag, S.Enum, false);

531#include "llvm/BinaryFormat/DXContainerConstants.def"

532}

533

545

548 IO.mapTag("!dxcontainer", true);

551}

552

555#define RESOURCE_FLAG(FlagIndex, Enum) IO.mapRequired(#Enum, Flags.Bits.Enum);

556#include "llvm/BinaryFormat/DXContainerConstants.def"

557}

558

565

567 if (*PSVVersion < 2)

568 return;

569

572}

573

588

593}

594

595void ScalarEnumerationTraitsdxbc::PSV::ComponentType::enumeration(

598 IO.enumCase(Value, E.Name, E.Value);

599}

600

601void ScalarEnumerationTraitsdxbc::PSV::InterpolationMode::enumeration(

602 IO &IO, dxbc::PSV::InterpolationMode &Value) {

603 for (const auto &E : dxbc::PSV::getInterpolationModes())

604 IO.enumCase(Value, E.Name, E.Value);

605}

606

607void ScalarEnumerationTraitsdxbc::PSV::ResourceType::enumeration(

608 IO &IO, dxbc::PSV::ResourceType &Value) {

609 for (const auto &E : dxbc::PSV::getResourceTypes())

610 IO.enumCase(Value, E.Name, E.Value);

611}

612

613void ScalarEnumerationTraitsdxbc::PSV::ResourceKind::enumeration(

614 IO &IO, dxbc::PSV::ResourceKind &Value) {

615 for (const auto &E : dxbc::PSV::getResourceKinds())

616 IO.enumCase(Value, E.Name, E.Value);

617}

618

619void ScalarEnumerationTraitsdxbc::D3DSystemValue::enumeration(

620 IO &IO, dxbc::D3DSystemValue &Value) {

621 for (const auto &E : dxbc::getD3DSystemValues())

622 IO.enumCase(Value, E.Name, E.Value);

623}

624

625void ScalarEnumerationTraitsdxbc::SigMinPrecision::enumeration(

626 IO &IO, dxbc::SigMinPrecision &Value) {

627 for (const auto &E : dxbc::getSigMinPrecisions())

628 IO.enumCase(Value, E.Name, E.Value);

629}

630

631void ScalarEnumerationTraitsdxbc::SigComponentType::enumeration(

632 IO &IO, dxbc::SigComponentType &Value) {

633 for (const auto &E : dxbc::getSigComponentTypes())

634 IO.enumCase(Value, E.Name, E.Value);

635}

636

637void ScalarEnumerationTraitsdxbc::RootParameterType::enumeration(

638 IO &IO, dxbc::RootParameterType &Value) {

639 for (const auto &E : dxbc::getRootParameterTypes())

640 IO.enumCase(Value, E.Name, E.Value);

641}

642

643void ScalarEnumerationTraitsdxil::ResourceClass::enumeration(

644 IO &IO, dxil::ResourceClass &Value) {

645 const EnumEntrydxil::ResourceClass ResourceClasses[] = {

646 {"CBuffer", dxil::ResourceClass::CBuffer},

647 {"SRV", dxil::ResourceClass::SRV},

648 {"UAV", dxil::ResourceClass::UAV},

649 {"Sampler", dxil::ResourceClass::Sampler},

650 };

651

652 for (const auto &E : ResourceClasses)

653 IO.enumCase(Value, E.Name, E.Value);

654}

655

656void ScalarEnumerationTraitsdxbc::SamplerFilter::enumeration(

657 IO &IO, dxbc::SamplerFilter &Value) {

658 for (const auto &E : dxbc::getSamplerFilters())

659 IO.enumCase(Value, E.Name, E.Value);

660}

661

662void ScalarEnumerationTraitsdxbc::StaticBorderColor::enumeration(

663 IO &IO, dxbc::StaticBorderColor &Value) {

664 for (const auto &E : dxbc::getStaticBorderColors())

665 IO.enumCase(Value, E.Name, E.Value);

666}

667

668void ScalarEnumerationTraitsdxbc::TextureAddressMode::enumeration(

669 IO &IO, dxbc::TextureAddressMode &Value) {

670 for (const auto &E : dxbc::getTextureAddressModes())

671 IO.enumCase(Value, E.Name, E.Value);

672}

673

674void ScalarEnumerationTraitsdxbc::ShaderVisibility::enumeration(

675 IO &IO, dxbc::ShaderVisibility &Value) {

676 for (const auto &E : dxbc::getShaderVisibility())

677 IO.enumCase(Value, E.Name, E.Value);

678}

679

680void ScalarEnumerationTraitsdxbc::ComparisonFunc::enumeration(

681 IO &IO, dxbc::ComparisonFunc &Value) {

682 for (const auto &E : dxbc::getComparisonFuncs())

683 IO.enumCase(Value, E.Name, E.Value);

684}

685

686}

687

691

692 switch (Stage) {

696 break;

699 break;

705 break;

709 IO.mapRequired("OutputControlPointCount",

712 IO.mapRequired("TessellatorOutputPrimitive",

714 break;

720 break;

723 IO.mapRequired("GroupSharedBytesDependentOnViewID",

728 break;

731 break;

732 default:

733 break;

734 }

735

736 IO.mapRequired("MinimumWaveLaneCount", Info.MinimumWaveLaneCount);

737 IO.mapRequired("MaximumWaveLaneCount", Info.MaximumWaveLaneCount);

738

740 return;

741

743

744 switch (Stage) {

746 IO.mapRequired("MaxVertexCount", Info.GeomData.MaxVertexCount);

747 break;

750 IO.mapRequired("SigPatchConstOrPrimVectors",

751 Info.GeomData.SigPatchConstOrPrimVectors);

752 break;

754 IO.mapRequired("SigPrimVectors", Info.GeomData.MeshInfo.SigPrimVectors);

756 Info.GeomData.MeshInfo.MeshOutputTopology);

757 break;

758 default:

759 break;

760 }

761

765

767 return;

768

772

774 return;

775

777}

778

779}

assert(UImm &&(UImm !=~static_cast< T >(0)) &&"Invalid immediate!")

static GCRegistry::Add< StatepointGC > D("statepoint-example", "an example strategy for statepoint")

static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")

This file declares classes for handling the YAML representation of DXContainer.

This file contains library features backported from future STL versions.

This file defines the make_scope_exit function, which executes user-defined cleanup logic at scope ex...

static StringRef substr(StringRef Str, uint64_t Len)

Lightweight error class with error context and mandatory checking.

static ErrorSuccess success()

Create a success value.

Tagged union holding either a T or a Error.

Error takeError()

Take ownership of the stored error.

reference get()

Returns a reference to the stored T value.

MutableArrayRef - Represent a mutable reference to an array (0 or more elements consecutively in memo...

StringRef - Represent a constant reference to a string, i.e.

A table of densely packed, null-terminated strings indexed by offset.

LLVM Value Representation.

virtual bool outputting() const =0

virtual bool mapTag(StringRef Tag, bool Default=false)=0

void enumCase(T &Val, StringRef Str, const T ConstVal)

void mapOptional(StringRef Key, T &Val)

void * getContext() const

void mapRequired(StringRef Key, T &Val)

#define llvm_unreachable(msg)

Marks that the current location is not supposed to be reachable.

@ C

The default llvm calling convention, compatible with C.

dxbc::PSV::ResourceFlags ResourceFlags

dxbc::PSV::v2::ResourceBindInfo ResourceBindInfo

LLVM_ABI ArrayRef< EnumEntry< ComponentType > > getComponentTypes()

LLVM_ABI ArrayRef< EnumEntry< SemanticKind > > getSemanticKinds()

bool isValidShaderVisibility(uint32_t V)

bool isValidSamplerFilter(uint32_t V)

Triple::EnvironmentType getShaderStage(uint32_t Kind)

bool isValidBorderColor(uint32_t V)

bool isValidComparisonFunc(uint32_t V)

LLVM_ABI_FOR_TEST bool isValidParameterType(uint32_t V)

bool isValidAddress(uint32_t V)

bool isValidRangeType(uint32_t V)

This is an optimization pass for GlobalISel generic memory operations.

auto find(R &&Range, const T &Val)

Provide wrappers to std::find which take ranges instead of having to pass begin/end explicitly.

detail::scope_exit< std::decay_t< Callable > > make_scope_exit(Callable &&F)

decltype(auto) dyn_cast(const From &Val)

dyn_cast - Return the argument parameter cast to the specified type.

Error createStringError(std::error_code EC, char const *Fmt, const Ts &... Vals)

Create formatted StringError object.

FunctionAddr VTableAddr uintptr_t uintptr_t Version

static llvm::Error readDescriptorRanges(DXContainerYAML::RootParameterHeaderYaml &Header, DXContainerYAML::RootSignatureYamlDesc &RootSigDesc, object::DirectX::DescriptorTableView *DTV)

Definition DXContainerYAML.cpp:38

FunctionAddr VTableAddr uintptr_t uintptr_t Data

uint16_t DXILMajorVersion

std::optional< uint32_t > Size

uint16_t DXILMinorVersion

std::optional< std::vector< llvm::yaml::Hex8 > > DXIL

std::optional< uint32_t > DXILSize

uint32_t OffsetInDescriptorsFromTableStart

uint32_t BaseShaderRegister

LLVM_ABI uint32_t getEncodedFlags() const

Definition DXContainerYAML.cpp:244

dxil::ResourceClass RangeType

SmallVector< DescriptorRangeYaml > Ranges

std::array< MaskVector, 4 > InputOutputMap

LLVM_ABI PSVInfo()

Definition DXContainerYAML.cpp:278

MaskVector PatchOutputMap

SmallVector< SignatureElement > SigOutputElements

MaskVector PatchOrPrimMasks

SmallVector< SignatureElement > SigPatchOrPrimElements

SmallVector< ResourceBindInfo > Resources

SmallVector< SignatureElement > SigInputElements

LLVM_ABI void mapInfoForVersion(yaml::IO &IO)

Definition DXContainerYAML.cpp:688

dxbc::PSV::v3::RuntimeInfo Info

std::array< MaskVector, 4 > OutputVectorMasks

LLVM_ABI uint32_t getEncodedFlags() const

Definition DXContainerYAML.cpp:226

RootDescriptorYaml & getOrInsertDescriptor(RootParameterLocationYaml &ParamDesc)

SmallVector< RootParameterLocationYaml > Locations

RootConstantsYaml & getOrInsertConstants(RootParameterLocationYaml &ParamDesc)

void insertLocation(RootParameterLocationYaml &Location)

DescriptorTableYaml & getOrInsertTable(RootParameterLocationYaml &ParamDesc)

uint32_t NumRootParameters

uint32_t NumStaticSamplers

SmallVector< StaticSamplerYamlDesc > StaticSamplers

std::optional< uint32_t > RootParametersOffset

RootSignatureYamlDesc()=default

LLVM_ABI uint32_t getEncodedFlags()

Definition DXContainerYAML.cpp:235

static LLVM_ABI llvm::Expected< DXContainerYAML::RootSignatureYamlDesc > create(const object::DirectX::RootSignature &Data)

Definition DXContainerYAML.cpp:81

RootParameterYamlDesc Parameters

std::optional< uint32_t > StaticSamplersOffset

ShaderFeatureFlags()=default

LLVM_ABI uint64_t getEncodedFlags()

Definition DXContainerYAML.cpp:262

std::vector< llvm::yaml::Hex8 > Digest

dxbc::PSV::ComponentType Type

dxbc::PSV::InterpolationMode Mode

llvm::yaml::Hex8 DynamicMask

dxbc::PSV::SemanticKind Kind

SmallVector< uint32_t > Indices

dxbc::SigComponentType CompType

dxbc::SigMinPrecision MinPrecision

dxbc::D3DSystemValue SystemValue

llvm::SmallVector< SignatureParameter > Parameters

dxbc::StaticBorderColor BorderColor

dxbc::ShaderVisibility ShaderVisibility

dxbc::TextureAddressMode AddressU

dxbc::SamplerFilter Filter

dxbc::ComparisonFunc ComparisonFunc

dxbc::TextureAddressMode AddressV

LLVM_ABI uint32_t getEncodedFlags() const

Definition DXContainerYAML.cpp:253

dxbc::TextureAddressMode AddressW

uint32_t PayloadSizeInBytes

uint32_t InputControlPointCount

uint32_t TessellatorDomain

uint8_t OutputPositionPresent

uint32_t OutputStreamMask

uint32_t TessellatorOutputPrimitive

uint32_t OutputControlPointCount

uint32_t InputControlPointCount

uint32_t TessellatorDomain

uint32_t PayloadSizeInBytes

uint16_t MaxOutputVertices

uint16_t MaxOutputPrimitives

uint32_t GroupSharedBytesDependentOnViewID

uint32_t GroupSharedBytesUsed

uint8_t OutputPositionPresent

llvm::Expected< DescriptorTable< T > > read()

This class is similar to MappingTraits but allows you to pass in additional context for each map o...

This class should be specialized by any type that needs to be converted to/from a YAML mapping.

This class should be specialized by any integral type that converts to/from a YAML scalar where there...