635 lines
20 KiB
C++
635 lines
20 KiB
C++
//===- DXContainerYAML.h - DXContainer YAMLIO implementation ----*- C++ -*-===//
|
|
//
|
|
// 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
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
///
|
|
/// \file
|
|
/// This file declares classes for handling the YAML representation
|
|
/// of DXContainer.
|
|
///
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#ifndef LLVM_OBJECTYAML_DXCONTAINERYAML_H
|
|
#define LLVM_OBJECTYAML_DXCONTAINERYAML_H
|
|
|
|
#include "llvm/ADT/StringRef.h"
|
|
#include "llvm/BinaryFormat/DXContainer.h"
|
|
#include "llvm/Object/DXContainer.h"
|
|
#include "llvm/ObjectYAML/YAML.h"
|
|
#include "llvm/Support/Compiler.h"
|
|
#include "llvm/Support/YAMLTraits.h"
|
|
#include <array>
|
|
#include <optional>
|
|
#include <string>
|
|
#include <vector>
|
|
|
|
namespace llvm {
|
|
namespace DXContainerYAML {
|
|
|
|
struct VersionTuple {
|
|
uint16_t Major;
|
|
uint16_t Minor;
|
|
};
|
|
|
|
// The optional header fields are required in the binary and will be populated
|
|
// when reading from binary, but can be omitted in the YAML text because the
|
|
// emitter can calculate them.
|
|
struct FileHeader {
|
|
std::vector<llvm::yaml::Hex8> Hash;
|
|
VersionTuple Version;
|
|
std::optional<uint32_t> FileSize;
|
|
uint32_t PartCount;
|
|
std::optional<std::vector<uint32_t>> PartOffsets;
|
|
};
|
|
|
|
struct DXILProgram {
|
|
uint8_t MajorVersion;
|
|
uint8_t MinorVersion;
|
|
uint16_t ShaderKind;
|
|
std::optional<uint32_t> Size;
|
|
uint16_t DXILMajorVersion;
|
|
uint16_t DXILMinorVersion;
|
|
std::optional<uint32_t> DXILOffset;
|
|
std::optional<uint32_t> DXILSize;
|
|
std::optional<std::vector<llvm::yaml::Hex8>> DXIL;
|
|
};
|
|
|
|
#define SHADER_FEATURE_FLAG(Num, DxilModuleNum, Val, Str) bool Val = false;
|
|
struct ShaderFeatureFlags {
|
|
ShaderFeatureFlags() = default;
|
|
LLVM_ABI ShaderFeatureFlags(uint64_t FlagData);
|
|
LLVM_ABI uint64_t getEncodedFlags();
|
|
#include "llvm/BinaryFormat/DXContainerConstants.def"
|
|
};
|
|
|
|
struct ShaderHash {
|
|
ShaderHash() = default;
|
|
LLVM_ABI ShaderHash(const dxbc::ShaderHash &Data);
|
|
|
|
bool IncludesSource;
|
|
std::vector<llvm::yaml::Hex8> Digest;
|
|
};
|
|
|
|
struct RootConstantsYaml {
|
|
uint32_t ShaderRegister;
|
|
uint32_t RegisterSpace;
|
|
uint32_t Num32BitValues;
|
|
};
|
|
|
|
struct RootDescriptorYaml {
|
|
RootDescriptorYaml() = default;
|
|
|
|
uint32_t ShaderRegister;
|
|
uint32_t RegisterSpace;
|
|
|
|
LLVM_ABI uint32_t getEncodedFlags() const;
|
|
|
|
#define ROOT_DESCRIPTOR_FLAG(Num, Enum, Flag) bool Enum = false;
|
|
#include "llvm/BinaryFormat/DXContainerConstants.def"
|
|
};
|
|
|
|
struct DescriptorRangeYaml {
|
|
dxil::ResourceClass RangeType;
|
|
uint32_t NumDescriptors;
|
|
uint32_t BaseShaderRegister;
|
|
uint32_t RegisterSpace;
|
|
uint32_t OffsetInDescriptorsFromTableStart;
|
|
|
|
LLVM_ABI uint32_t getEncodedFlags() const;
|
|
|
|
#define DESCRIPTOR_RANGE_FLAG(Num, Enum, Flag) bool Enum = false;
|
|
#include "llvm/BinaryFormat/DXContainerConstants.def"
|
|
};
|
|
|
|
struct DescriptorTableYaml {
|
|
uint32_t NumRanges;
|
|
uint32_t RangesOffset;
|
|
SmallVector<DescriptorRangeYaml> Ranges;
|
|
};
|
|
|
|
struct RootParameterHeaderYaml {
|
|
dxbc::RootParameterType Type;
|
|
dxbc::ShaderVisibility Visibility;
|
|
uint32_t Offset;
|
|
|
|
RootParameterHeaderYaml() = default;
|
|
RootParameterHeaderYaml(dxbc::RootParameterType T) : Type(T) {}
|
|
};
|
|
|
|
struct RootParameterLocationYaml {
|
|
RootParameterHeaderYaml Header;
|
|
std::optional<size_t> IndexInSignature;
|
|
|
|
RootParameterLocationYaml() = default;
|
|
explicit RootParameterLocationYaml(RootParameterHeaderYaml Header)
|
|
: Header(Header) {}
|
|
};
|
|
|
|
struct RootParameterYamlDesc {
|
|
SmallVector<RootParameterLocationYaml> Locations;
|
|
|
|
SmallVector<RootConstantsYaml> Constants;
|
|
SmallVector<RootDescriptorYaml> Descriptors;
|
|
SmallVector<DescriptorTableYaml> Tables;
|
|
|
|
template <typename T>
|
|
T &getOrInsertImpl(RootParameterLocationYaml &ParamDesc,
|
|
SmallVectorImpl<T> &Container) {
|
|
if (!ParamDesc.IndexInSignature) {
|
|
ParamDesc.IndexInSignature = Container.size();
|
|
Container.emplace_back();
|
|
}
|
|
return Container[*ParamDesc.IndexInSignature];
|
|
}
|
|
|
|
RootConstantsYaml &
|
|
getOrInsertConstants(RootParameterLocationYaml &ParamDesc) {
|
|
return getOrInsertImpl(ParamDesc, Constants);
|
|
}
|
|
|
|
RootDescriptorYaml &
|
|
getOrInsertDescriptor(RootParameterLocationYaml &ParamDesc) {
|
|
return getOrInsertImpl(ParamDesc, Descriptors);
|
|
}
|
|
|
|
DescriptorTableYaml &getOrInsertTable(RootParameterLocationYaml &ParamDesc) {
|
|
return getOrInsertImpl(ParamDesc, Tables);
|
|
}
|
|
|
|
void insertLocation(RootParameterLocationYaml &Location) {
|
|
Locations.push_back(Location);
|
|
}
|
|
};
|
|
|
|
struct StaticSamplerYamlDesc {
|
|
dxbc::SamplerFilter Filter = dxbc::SamplerFilter::Anisotropic;
|
|
dxbc::TextureAddressMode AddressU = dxbc::TextureAddressMode::Wrap;
|
|
dxbc::TextureAddressMode AddressV = dxbc::TextureAddressMode::Wrap;
|
|
dxbc::TextureAddressMode AddressW = dxbc::TextureAddressMode::Wrap;
|
|
float MipLODBias = 0.f;
|
|
uint32_t MaxAnisotropy = 16u;
|
|
dxbc::ComparisonFunc ComparisonFunc = dxbc::ComparisonFunc::LessEqual;
|
|
dxbc::StaticBorderColor BorderColor = dxbc::StaticBorderColor::OpaqueWhite;
|
|
float MinLOD = 0.f;
|
|
float MaxLOD = std::numeric_limits<float>::max();
|
|
uint32_t ShaderRegister;
|
|
uint32_t RegisterSpace;
|
|
dxbc::ShaderVisibility ShaderVisibility;
|
|
|
|
LLVM_ABI uint32_t getEncodedFlags() const;
|
|
|
|
#define STATIC_SAMPLER_FLAG(Num, Enum, Flag) bool Enum = false;
|
|
#include "llvm/BinaryFormat/DXContainerConstants.def"
|
|
};
|
|
|
|
struct RootSignatureYamlDesc {
|
|
RootSignatureYamlDesc() = default;
|
|
|
|
uint32_t Version;
|
|
uint32_t NumRootParameters;
|
|
std::optional<uint32_t> RootParametersOffset;
|
|
uint32_t NumStaticSamplers;
|
|
std::optional<uint32_t> StaticSamplersOffset;
|
|
|
|
RootParameterYamlDesc Parameters;
|
|
SmallVector<StaticSamplerYamlDesc> StaticSamplers;
|
|
|
|
LLVM_ABI uint32_t getEncodedFlags();
|
|
|
|
iterator_range<StaticSamplerYamlDesc *> samplers() {
|
|
return make_range(StaticSamplers.begin(), StaticSamplers.end());
|
|
}
|
|
|
|
LLVM_ABI static llvm::Expected<DXContainerYAML::RootSignatureYamlDesc>
|
|
create(const object::DirectX::RootSignature &Data);
|
|
|
|
#define ROOT_SIGNATURE_FLAG(Num, Val) bool Val = false;
|
|
#include "llvm/BinaryFormat/DXContainerConstants.def"
|
|
};
|
|
|
|
using ResourceFlags = dxbc::PSV::ResourceFlags;
|
|
using ResourceBindInfo = dxbc::PSV::v2::ResourceBindInfo;
|
|
|
|
struct SignatureElement {
|
|
SignatureElement() = default;
|
|
|
|
SignatureElement(dxbc::PSV::v0::SignatureElement El, StringRef StringTable,
|
|
ArrayRef<uint32_t> IdxTable)
|
|
: Name(StringTable.substr(El.NameOffset,
|
|
StringTable.find('\0', El.NameOffset) -
|
|
El.NameOffset)),
|
|
Indices(IdxTable.slice(El.IndicesOffset, El.Rows)),
|
|
StartRow(El.StartRow), Cols(El.Cols), StartCol(El.StartCol),
|
|
Allocated(El.Allocated != 0), Kind(El.Kind), Type(El.Type),
|
|
Mode(El.Mode), DynamicMask(El.DynamicMask), Stream(El.Stream) {}
|
|
StringRef Name;
|
|
SmallVector<uint32_t> Indices;
|
|
|
|
uint8_t StartRow;
|
|
uint8_t Cols;
|
|
uint8_t StartCol;
|
|
bool Allocated;
|
|
dxbc::PSV::SemanticKind Kind;
|
|
|
|
dxbc::PSV::ComponentType Type;
|
|
dxbc::PSV::InterpolationMode Mode;
|
|
llvm::yaml::Hex8 DynamicMask;
|
|
uint8_t Stream;
|
|
};
|
|
|
|
struct StringTableEntry {
|
|
StringRef String;
|
|
uint32_t Offset;
|
|
};
|
|
|
|
struct PSVInfo {
|
|
// The version field isn't actually encoded in the file, but it is inferred by
|
|
// the size of data regions. We include it in the yaml because it simplifies
|
|
// the format.
|
|
uint32_t Version;
|
|
|
|
dxbc::PSV::v3::RuntimeInfo Info;
|
|
uint32_t ResourceStride;
|
|
SmallVector<ResourceBindInfo> Resources;
|
|
SmallVector<SignatureElement> SigInputElements;
|
|
SmallVector<SignatureElement> SigOutputElements;
|
|
SmallVector<SignatureElement> SigPatchOrPrimElements;
|
|
|
|
using MaskVector = SmallVector<llvm::yaml::Hex32>;
|
|
std::array<MaskVector, 4> OutputVectorMasks;
|
|
MaskVector PatchOrPrimMasks;
|
|
std::array<MaskVector, 4> InputOutputMap;
|
|
MaskVector InputPatchMap;
|
|
MaskVector PatchOutputMap;
|
|
|
|
StringRef EntryName;
|
|
|
|
// Output-only fields populated by obj2yaml for inspection.
|
|
SmallVector<StringTableEntry> StringTable;
|
|
uint32_t RuntimeInfoSize = 0;
|
|
|
|
LLVM_ABI void mapInfoForVersion(yaml::IO &IO);
|
|
|
|
LLVM_ABI PSVInfo();
|
|
LLVM_ABI PSVInfo(const dxbc::PSV::v0::RuntimeInfo *P, uint16_t Stage);
|
|
LLVM_ABI PSVInfo(const dxbc::PSV::v1::RuntimeInfo *P);
|
|
LLVM_ABI PSVInfo(const dxbc::PSV::v2::RuntimeInfo *P);
|
|
LLVM_ABI PSVInfo(const dxbc::PSV::v3::RuntimeInfo *P, StringRef StringTable);
|
|
};
|
|
|
|
struct SignatureParameter {
|
|
uint32_t Stream;
|
|
std::string Name;
|
|
uint32_t Index;
|
|
dxbc::D3DSystemValue SystemValue;
|
|
dxbc::SigComponentType CompType;
|
|
uint32_t Register;
|
|
uint8_t Mask;
|
|
uint8_t ExclusiveMask;
|
|
dxbc::SigMinPrecision MinPrecision;
|
|
};
|
|
|
|
struct Signature {
|
|
llvm::SmallVector<SignatureParameter> Parameters;
|
|
};
|
|
|
|
struct DebugName {
|
|
std::optional<uint16_t> Flags;
|
|
std::optional<uint16_t> NameLength;
|
|
std::string Filename;
|
|
};
|
|
|
|
struct CompilerVersion {
|
|
std::optional<uint16_t> Major;
|
|
std::optional<uint16_t> Minor;
|
|
std::optional<bool> IsDebugBuild;
|
|
std::optional<bool> IsValidated;
|
|
std::optional<uint32_t> CommitCount;
|
|
std::optional<uint32_t> ContentSizeInBytes;
|
|
std::optional<std::string> CommitSha;
|
|
std::optional<std::string> CustomVersionString;
|
|
};
|
|
|
|
struct SourceInfo {
|
|
struct Header {
|
|
std::optional<uint32_t> AlignedSizeInBytes;
|
|
std::optional<uint16_t> Flags;
|
|
std::optional<uint16_t> SectionCount;
|
|
};
|
|
|
|
struct SectionHeader {
|
|
std::optional<uint32_t> AlignedSizeInBytes;
|
|
std::optional<uint16_t> Flags;
|
|
std::optional<dxbc::SourceInfo::SectionType> Type;
|
|
};
|
|
|
|
struct Section {
|
|
SectionHeader GenericHeader;
|
|
};
|
|
|
|
struct SourceContents : public Section {
|
|
struct Header {
|
|
std::optional<uint32_t> AlignedSizeInBytes;
|
|
std::optional<uint16_t> Flags;
|
|
dxbc::SourceInfo::Contents::CompressionType Type;
|
|
std::optional<uint32_t> EntriesSizeInBytes;
|
|
std::optional<uint32_t> UncompressedEntriesSizeInBytes;
|
|
std::optional<uint32_t> Count;
|
|
};
|
|
|
|
struct Entry {
|
|
std::optional<uint32_t> AlignedSizeInBytes;
|
|
std::optional<uint32_t> Flags;
|
|
std::optional<uint32_t> ContentSizeInBytes;
|
|
std::string FileContent;
|
|
};
|
|
|
|
Header Parameters;
|
|
SmallVector<Entry> Entries;
|
|
};
|
|
|
|
struct SourceNames : public Section {
|
|
struct Header {
|
|
std::optional<uint32_t> Flags;
|
|
std::optional<uint32_t> Count;
|
|
std::optional<uint16_t> EntriesSizeInBytes;
|
|
};
|
|
|
|
struct Entry {
|
|
std::optional<uint32_t> AlignedSizeInBytes;
|
|
std::optional<uint32_t> Flags;
|
|
std::optional<uint32_t> NameSizeInBytes;
|
|
std::optional<uint32_t> ContentSizeInBytes;
|
|
StringRef FileName;
|
|
};
|
|
|
|
Header Parameters;
|
|
SmallVector<Entry> Entries;
|
|
};
|
|
|
|
struct ProgramArgs : public Section {
|
|
struct Header {
|
|
std::optional<uint32_t> Flags;
|
|
std::optional<uint32_t> SizeInBytes;
|
|
std::optional<uint32_t> Count;
|
|
};
|
|
|
|
Header Parameters;
|
|
SmallVector<mcdxbc::SourceInfo::ProgramArgs::Entry> Args;
|
|
};
|
|
|
|
Header Parameters;
|
|
SourceNames Names;
|
|
SourceContents Contents;
|
|
ProgramArgs Args;
|
|
};
|
|
|
|
struct Part {
|
|
Part() = default;
|
|
Part(std::string N, uint32_t S) : Name(N), Size(S) {}
|
|
std::string Name;
|
|
uint32_t Size;
|
|
std::optional<DXILProgram> Program;
|
|
std::optional<ShaderFeatureFlags> Flags;
|
|
std::optional<ShaderHash> Hash;
|
|
std::optional<PSVInfo> Info;
|
|
std::optional<DXContainerYAML::Signature> Signature;
|
|
std::optional<DXContainerYAML::RootSignatureYamlDesc> RootSignature;
|
|
std::optional<DXContainerYAML::DebugName> DebugName;
|
|
std::optional<DXContainerYAML::CompilerVersion> CompilerVersion;
|
|
std::optional<DXContainerYAML::SourceInfo> SourceInfo;
|
|
};
|
|
|
|
struct Object {
|
|
FileHeader Header;
|
|
std::vector<Part> Parts;
|
|
};
|
|
|
|
LLVM_ABI Expected<std::unique_ptr<DXContainerYAML::Object>>
|
|
fromDXContainer(object::DXContainer &DXC);
|
|
|
|
} // namespace DXContainerYAML
|
|
} // namespace llvm
|
|
|
|
LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::DXContainerYAML::Part)
|
|
LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::DXContainerYAML::ResourceBindInfo)
|
|
LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::DXContainerYAML::SignatureElement)
|
|
LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::DXContainerYAML::PSVInfo::MaskVector)
|
|
LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::DXContainerYAML::SignatureParameter)
|
|
LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::DXContainerYAML::RootParameterLocationYaml)
|
|
LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::DXContainerYAML::DescriptorRangeYaml)
|
|
LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::DXContainerYAML::StaticSamplerYamlDesc)
|
|
LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::DXContainerYAML::StringTableEntry)
|
|
LLVM_YAML_IS_SEQUENCE_VECTOR(
|
|
llvm::DXContainerYAML::SourceInfo::SourceNames::Entry)
|
|
LLVM_YAML_IS_SEQUENCE_VECTOR(
|
|
llvm::DXContainerYAML::SourceInfo::SourceContents::Entry)
|
|
LLVM_YAML_IS_SEQUENCE_VECTOR(mcdxbc::SourceInfo::ProgramArgs::Entry)
|
|
LLVM_YAML_DECLARE_ENUM_TRAITS(llvm::dxbc::PSV::SemanticKind)
|
|
LLVM_YAML_DECLARE_ENUM_TRAITS(llvm::dxbc::PSV::ComponentType)
|
|
LLVM_YAML_DECLARE_ENUM_TRAITS(llvm::dxbc::PSV::InterpolationMode)
|
|
LLVM_YAML_DECLARE_ENUM_TRAITS(llvm::dxbc::PSV::ResourceType)
|
|
LLVM_YAML_DECLARE_ENUM_TRAITS(llvm::dxbc::PSV::ResourceKind)
|
|
LLVM_YAML_DECLARE_ENUM_TRAITS(llvm::dxbc::D3DSystemValue)
|
|
LLVM_YAML_DECLARE_ENUM_TRAITS(llvm::dxbc::SigComponentType)
|
|
LLVM_YAML_DECLARE_ENUM_TRAITS(llvm::dxbc::SigMinPrecision)
|
|
LLVM_YAML_DECLARE_ENUM_TRAITS(llvm::dxbc::RootParameterType)
|
|
LLVM_YAML_DECLARE_ENUM_TRAITS(dxil::ResourceClass)
|
|
LLVM_YAML_DECLARE_ENUM_TRAITS(llvm::dxbc::SamplerFilter)
|
|
LLVM_YAML_DECLARE_ENUM_TRAITS(llvm::dxbc::StaticBorderColor)
|
|
LLVM_YAML_DECLARE_ENUM_TRAITS(llvm::dxbc::TextureAddressMode)
|
|
LLVM_YAML_DECLARE_ENUM_TRAITS(llvm::dxbc::ShaderVisibility)
|
|
LLVM_YAML_DECLARE_ENUM_TRAITS(llvm::dxbc::ComparisonFunc)
|
|
LLVM_YAML_DECLARE_ENUM_TRAITS(llvm::dxbc::SourceInfo::SectionType)
|
|
LLVM_YAML_DECLARE_ENUM_TRAITS(llvm::dxbc::SourceInfo::Contents::CompressionType)
|
|
|
|
namespace llvm {
|
|
|
|
class raw_ostream;
|
|
|
|
namespace yaml {
|
|
|
|
template <> struct MappingTraits<DXContainerYAML::VersionTuple> {
|
|
LLVM_ABI static void mapping(IO &IO, DXContainerYAML::VersionTuple &Version);
|
|
};
|
|
|
|
template <> struct MappingTraits<DXContainerYAML::FileHeader> {
|
|
LLVM_ABI static void mapping(IO &IO, DXContainerYAML::FileHeader &Header);
|
|
};
|
|
|
|
template <> struct MappingTraits<DXContainerYAML::DXILProgram> {
|
|
LLVM_ABI static void mapping(IO &IO, DXContainerYAML::DXILProgram &Program);
|
|
};
|
|
|
|
template <> struct MappingTraits<DXContainerYAML::ShaderFeatureFlags> {
|
|
LLVM_ABI static void mapping(IO &IO,
|
|
DXContainerYAML::ShaderFeatureFlags &Flags);
|
|
};
|
|
|
|
template <> struct MappingTraits<DXContainerYAML::ShaderHash> {
|
|
LLVM_ABI static void mapping(IO &IO, DXContainerYAML::ShaderHash &Hash);
|
|
};
|
|
|
|
template <> struct MappingTraits<DXContainerYAML::PSVInfo> {
|
|
LLVM_ABI static void mapping(IO &IO, DXContainerYAML::PSVInfo &PSV);
|
|
};
|
|
|
|
template <> struct MappingTraits<DXContainerYAML::DebugName> {
|
|
LLVM_ABI static void mapping(IO &IO, DXContainerYAML::DebugName &DebugName);
|
|
};
|
|
|
|
template <> struct MappingTraits<DXContainerYAML::CompilerVersion> {
|
|
LLVM_ABI static void
|
|
mapping(IO &IO, DXContainerYAML::CompilerVersion &CompilerVersion);
|
|
};
|
|
|
|
template <> struct MappingTraits<DXContainerYAML::Part> {
|
|
LLVM_ABI static void mapping(IO &IO, DXContainerYAML::Part &Version);
|
|
};
|
|
|
|
template <> struct MappingTraits<DXContainerYAML::Object> {
|
|
LLVM_ABI static void mapping(IO &IO, DXContainerYAML::Object &Obj);
|
|
};
|
|
|
|
template <> struct MappingTraits<DXContainerYAML::ResourceFlags> {
|
|
LLVM_ABI static void mapping(IO &IO, DXContainerYAML::ResourceFlags &Flags);
|
|
};
|
|
|
|
template <> struct MappingTraits<DXContainerYAML::ResourceBindInfo> {
|
|
LLVM_ABI static void mapping(IO &IO, DXContainerYAML::ResourceBindInfo &Res);
|
|
};
|
|
|
|
template <> struct MappingTraits<DXContainerYAML::SignatureElement> {
|
|
LLVM_ABI static void mapping(IO &IO,
|
|
llvm::DXContainerYAML::SignatureElement &El);
|
|
};
|
|
|
|
template <> struct MappingTraits<DXContainerYAML::StringTableEntry> {
|
|
LLVM_ABI static void mapping(IO &IO, DXContainerYAML::StringTableEntry &E);
|
|
};
|
|
|
|
template <> struct MappingTraits<DXContainerYAML::SignatureParameter> {
|
|
LLVM_ABI static void mapping(IO &IO,
|
|
llvm::DXContainerYAML::SignatureParameter &El);
|
|
};
|
|
|
|
template <> struct MappingTraits<DXContainerYAML::Signature> {
|
|
LLVM_ABI static void mapping(IO &IO, llvm::DXContainerYAML::Signature &El);
|
|
};
|
|
|
|
template <> struct MappingTraits<DXContainerYAML::RootSignatureYamlDesc> {
|
|
LLVM_ABI static void
|
|
mapping(IO &IO, DXContainerYAML::RootSignatureYamlDesc &RootSignature);
|
|
};
|
|
|
|
template <>
|
|
struct MappingContextTraits<DXContainerYAML::RootParameterLocationYaml,
|
|
DXContainerYAML::RootSignatureYamlDesc> {
|
|
LLVM_ABI static void
|
|
mapping(IO &IO, llvm::DXContainerYAML::RootParameterLocationYaml &L,
|
|
DXContainerYAML::RootSignatureYamlDesc &S);
|
|
};
|
|
|
|
template <> struct MappingTraits<llvm::DXContainerYAML::RootConstantsYaml> {
|
|
LLVM_ABI static void mapping(IO &IO,
|
|
llvm::DXContainerYAML::RootConstantsYaml &C);
|
|
};
|
|
|
|
template <> struct MappingTraits<llvm::DXContainerYAML::RootDescriptorYaml> {
|
|
LLVM_ABI static void mapping(IO &IO,
|
|
llvm::DXContainerYAML::RootDescriptorYaml &D);
|
|
};
|
|
|
|
template <> struct MappingTraits<llvm::DXContainerYAML::DescriptorTableYaml> {
|
|
LLVM_ABI static void mapping(IO &IO,
|
|
llvm::DXContainerYAML::DescriptorTableYaml &D);
|
|
};
|
|
|
|
template <> struct MappingTraits<llvm::DXContainerYAML::DescriptorRangeYaml> {
|
|
LLVM_ABI static void mapping(IO &IO,
|
|
llvm::DXContainerYAML::DescriptorRangeYaml &D);
|
|
};
|
|
|
|
template <> struct MappingTraits<llvm::DXContainerYAML::StaticSamplerYamlDesc> {
|
|
LLVM_ABI static void mapping(IO &IO,
|
|
llvm::DXContainerYAML::StaticSamplerYamlDesc &S);
|
|
};
|
|
|
|
template <> struct MappingTraits<llvm::DXContainerYAML::SourceInfo::Header> {
|
|
LLVM_ABI static void mapping(IO &IO,
|
|
llvm::DXContainerYAML::SourceInfo::Header &H);
|
|
};
|
|
|
|
template <>
|
|
struct MappingTraits<llvm::DXContainerYAML::SourceInfo::SectionHeader> {
|
|
LLVM_ABI static void
|
|
mapping(IO &IO, llvm::DXContainerYAML::SourceInfo::SectionHeader &H);
|
|
};
|
|
|
|
template <>
|
|
struct MappingTraits<llvm::DXContainerYAML::SourceInfo::SourceNames::Header> {
|
|
LLVM_ABI static void
|
|
mapping(IO &IO, llvm::DXContainerYAML::SourceInfo::SourceNames::Header &H);
|
|
};
|
|
|
|
template <>
|
|
struct MappingTraits<llvm::DXContainerYAML::SourceInfo::SourceNames::Entry> {
|
|
LLVM_ABI static void
|
|
mapping(IO &IO, llvm::DXContainerYAML::SourceInfo::SourceNames::Entry &E);
|
|
};
|
|
|
|
template <>
|
|
struct MappingTraits<llvm::DXContainerYAML::SourceInfo::SourceNames> {
|
|
LLVM_ABI static void
|
|
mapping(IO &IO, llvm::DXContainerYAML::SourceInfo::SourceNames &S);
|
|
};
|
|
|
|
template <>
|
|
struct MappingTraits<
|
|
llvm::DXContainerYAML::SourceInfo::SourceContents::Header> {
|
|
LLVM_ABI static void
|
|
mapping(IO &IO, llvm::DXContainerYAML::SourceInfo::SourceContents::Header &H);
|
|
};
|
|
|
|
template <>
|
|
struct MappingTraits<llvm::DXContainerYAML::SourceInfo::SourceContents::Entry> {
|
|
LLVM_ABI static void
|
|
mapping(IO &IO, llvm::DXContainerYAML::SourceInfo::SourceContents::Entry &E);
|
|
};
|
|
|
|
template <>
|
|
struct MappingTraits<llvm::DXContainerYAML::SourceInfo::SourceContents> {
|
|
LLVM_ABI static void
|
|
mapping(IO &IO, llvm::DXContainerYAML::SourceInfo::SourceContents &S);
|
|
};
|
|
|
|
template <>
|
|
struct MappingTraits<llvm::DXContainerYAML::SourceInfo::ProgramArgs::Header> {
|
|
LLVM_ABI static void
|
|
mapping(IO &IO, llvm::DXContainerYAML::SourceInfo::ProgramArgs::Header &H);
|
|
};
|
|
|
|
template <> struct MappingTraits<mcdxbc::SourceInfo::ProgramArgs::Entry> {
|
|
LLVM_ABI static void mapping(IO &IO,
|
|
mcdxbc::SourceInfo::ProgramArgs::Entry &E);
|
|
};
|
|
|
|
template <>
|
|
struct MappingTraits<llvm::DXContainerYAML::SourceInfo::ProgramArgs> {
|
|
LLVM_ABI static void
|
|
mapping(IO &IO, llvm::DXContainerYAML::SourceInfo::ProgramArgs &S);
|
|
};
|
|
|
|
template <> struct MappingTraits<llvm::DXContainerYAML::SourceInfo> {
|
|
LLVM_ABI static void mapping(IO &IO, llvm::DXContainerYAML::SourceInfo &S);
|
|
};
|
|
|
|
} // namespace yaml
|
|
|
|
} // namespace llvm
|
|
|
|
#endif // LLVM_OBJECTYAML_DXCONTAINERYAML_H
|