1 //===- DXContainerYAML.cpp - DXContainer YAMLIO implementation ------------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 //
9 // This file defines classes for handling the YAML representation of
10 // DXContainerYAML.
11 //
12 //===----------------------------------------------------------------------===//
13
14 #include "llvm/ObjectYAML/DXContainerYAML.h"
15 #include "llvm/ADT/ScopeExit.h"
16 #include "llvm/BinaryFormat/DXContainer.h"
17 #include "llvm/Support/ScopedPrinter.h"
18
19 namespace llvm {
20
21 // This assert is duplicated here to leave a breadcrumb of the places that need
22 // to be updated if flags grow past 64-bits.
23 static_assert((uint64_t)dxbc::FeatureFlags::NextUnusedBit <= 1ull << 63,
24 "Shader flag bits exceed enum size.");
25
ShaderFeatureFlags(uint64_t FlagData)26 DXContainerYAML::ShaderFeatureFlags::ShaderFeatureFlags(uint64_t FlagData) {
27 #define SHADER_FEATURE_FLAG(Num, DxilModuleNum, Val, Str) \
28 Val = (FlagData & (uint64_t)dxbc::FeatureFlags::Val) > 0;
29 #include "llvm/BinaryFormat/DXContainerConstants.def"
30 }
31
getEncodedFlags()32 uint64_t DXContainerYAML::ShaderFeatureFlags::getEncodedFlags() {
33 uint64_t Flag = 0;
34 #define SHADER_FEATURE_FLAG(Num, DxilModuleNum, Val, Str) \
35 if (Val) \
36 Flag |= (uint64_t)dxbc::FeatureFlags::Val;
37 #include "llvm/BinaryFormat/DXContainerConstants.def"
38 return Flag;
39 }
40
ShaderHash(const dxbc::ShaderHash & Data)41 DXContainerYAML::ShaderHash::ShaderHash(const dxbc::ShaderHash &Data)
42 : IncludesSource((Data.Flags & static_cast<uint32_t>(
43 dxbc::HashFlags::IncludesSource)) != 0),
44 Digest(16, 0) {
45 memcpy(Digest.data(), &Data.Digest[0], 16);
46 }
47
PSVInfo()48 DXContainerYAML::PSVInfo::PSVInfo() : Version(0) {
49 memset(&Info, 0, sizeof(Info));
50 }
51
PSVInfo(const dxbc::PSV::v0::RuntimeInfo * P,uint16_t Stage)52 DXContainerYAML::PSVInfo::PSVInfo(const dxbc::PSV::v0::RuntimeInfo *P,
53 uint16_t Stage)
54 : Version(0) {
55 memset(&Info, 0, sizeof(Info));
56 memcpy(&Info, P, sizeof(dxbc::PSV::v0::RuntimeInfo));
57
58 assert(Stage < std::numeric_limits<uint8_t>::max() &&
59 "Stage should be a very small number");
60 // We need to bring the stage in separately since it isn't part of the v1 data
61 // structure.
62 Info.ShaderStage = static_cast<uint8_t>(Stage);
63 }
64
PSVInfo(const dxbc::PSV::v1::RuntimeInfo * P)65 DXContainerYAML::PSVInfo::PSVInfo(const dxbc::PSV::v1::RuntimeInfo *P)
66 : Version(1) {
67 memset(&Info, 0, sizeof(Info));
68 memcpy(&Info, P, sizeof(dxbc::PSV::v1::RuntimeInfo));
69 }
70
PSVInfo(const dxbc::PSV::v2::RuntimeInfo * P)71 DXContainerYAML::PSVInfo::PSVInfo(const dxbc::PSV::v2::RuntimeInfo *P)
72 : Version(2) {
73 memset(&Info, 0, sizeof(Info));
74 memcpy(&Info, P, sizeof(dxbc::PSV::v2::RuntimeInfo));
75 }
76
PSVInfo(const dxbc::PSV::v3::RuntimeInfo * P,StringRef StringTable)77 DXContainerYAML::PSVInfo::PSVInfo(const dxbc::PSV::v3::RuntimeInfo *P,
78 StringRef StringTable)
79 : Version(3),
80 EntryName(StringTable.substr(P->EntryNameOffset,
81 StringTable.find('\0', P->EntryNameOffset) -
82 P->EntryNameOffset)) {
83 memset(&Info, 0, sizeof(Info));
84 memcpy(&Info, P, sizeof(dxbc::PSV::v3::RuntimeInfo));
85 }
86
87 namespace yaml {
88
mapping(IO & IO,DXContainerYAML::VersionTuple & Version)89 void MappingTraits<DXContainerYAML::VersionTuple>::mapping(
90 IO &IO, DXContainerYAML::VersionTuple &Version) {
91 IO.mapRequired("Major", Version.Major);
92 IO.mapRequired("Minor", Version.Minor);
93 }
94
mapping(IO & IO,DXContainerYAML::FileHeader & Header)95 void MappingTraits<DXContainerYAML::FileHeader>::mapping(
96 IO &IO, DXContainerYAML::FileHeader &Header) {
97 IO.mapRequired("Hash", Header.Hash);
98 IO.mapRequired("Version", Header.Version);
99 IO.mapOptional("FileSize", Header.FileSize);
100 IO.mapRequired("PartCount", Header.PartCount);
101 IO.mapOptional("PartOffsets", Header.PartOffsets);
102 }
103
mapping(IO & IO,DXContainerYAML::DXILProgram & Program)104 void MappingTraits<DXContainerYAML::DXILProgram>::mapping(
105 IO &IO, DXContainerYAML::DXILProgram &Program) {
106 IO.mapRequired("MajorVersion", Program.MajorVersion);
107 IO.mapRequired("MinorVersion", Program.MinorVersion);
108 IO.mapRequired("ShaderKind", Program.ShaderKind);
109 IO.mapOptional("Size", Program.Size);
110 IO.mapRequired("DXILMajorVersion", Program.DXILMajorVersion);
111 IO.mapRequired("DXILMinorVersion", Program.DXILMinorVersion);
112 IO.mapOptional("DXILSize", Program.DXILSize);
113 IO.mapOptional("DXIL", Program.DXIL);
114 }
115
mapping(IO & IO,DXContainerYAML::ShaderFeatureFlags & Flags)116 void MappingTraits<DXContainerYAML::ShaderFeatureFlags>::mapping(
117 IO &IO, DXContainerYAML::ShaderFeatureFlags &Flags) {
118 #define SHADER_FEATURE_FLAG(Num, DxilModuleNum, Val, Str) \
119 IO.mapRequired(#Val, Flags.Val);
120 #include "llvm/BinaryFormat/DXContainerConstants.def"
121 }
122
mapping(IO & IO,DXContainerYAML::ShaderHash & Hash)123 void MappingTraits<DXContainerYAML::ShaderHash>::mapping(
124 IO &IO, DXContainerYAML::ShaderHash &Hash) {
125 IO.mapRequired("IncludesSource", Hash.IncludesSource);
126 IO.mapRequired("Digest", Hash.Digest);
127 }
128
mapping(IO & IO,DXContainerYAML::PSVInfo & PSV)129 void MappingTraits<DXContainerYAML::PSVInfo>::mapping(
130 IO &IO, DXContainerYAML::PSVInfo &PSV) {
131 IO.mapRequired("Version", PSV.Version);
132
133 // Store the PSV version in the YAML context.
134 void *OldContext = IO.getContext();
135 uint32_t Version = PSV.Version;
136 IO.setContext(&Version);
137
138 // Restore the YAML context on function exit.
139 auto RestoreContext = make_scope_exit([&]() { IO.setContext(OldContext); });
140
141 // Shader stage is only included in binaries for v1 and later, but we always
142 // include it since it simplifies parsing and file construction.
143 IO.mapRequired("ShaderStage", PSV.Info.ShaderStage);
144 PSV.mapInfoForVersion(IO);
145
146 IO.mapRequired("ResourceStride", PSV.ResourceStride);
147 IO.mapRequired("Resources", PSV.Resources);
148 if (PSV.Version == 0)
149 return;
150 IO.mapRequired("SigInputElements", PSV.SigInputElements);
151 IO.mapRequired("SigOutputElements", PSV.SigOutputElements);
152 IO.mapRequired("SigPatchOrPrimElements", PSV.SigPatchOrPrimElements);
153
154 Triple::EnvironmentType Stage = dxbc::getShaderStage(PSV.Info.ShaderStage);
155 if (PSV.Info.UsesViewID) {
156 MutableArrayRef<SmallVector<llvm::yaml::Hex32>> MutableOutMasks(
157 PSV.OutputVectorMasks);
158 IO.mapRequired("OutputVectorMasks", MutableOutMasks);
159 if (Stage == Triple::EnvironmentType::Hull)
160 IO.mapRequired("PatchOrPrimMasks", PSV.PatchOrPrimMasks);
161 }
162 MutableArrayRef<SmallVector<llvm::yaml::Hex32>> MutableIOMap(
163 PSV.InputOutputMap);
164 IO.mapRequired("InputOutputMap", MutableIOMap);
165
166 if (Stage == Triple::EnvironmentType::Hull)
167 IO.mapRequired("InputPatchMap", PSV.InputPatchMap);
168
169 if (Stage == Triple::EnvironmentType::Domain)
170 IO.mapRequired("PatchOutputMap", PSV.PatchOutputMap);
171 }
172
mapping(IO & IO,DXContainerYAML::SignatureParameter & S)173 void MappingTraits<DXContainerYAML::SignatureParameter>::mapping(
174 IO &IO, DXContainerYAML::SignatureParameter &S) {
175 IO.mapRequired("Stream", S.Stream);
176 IO.mapRequired("Name", S.Name);
177 IO.mapRequired("Index", S.Index);
178 IO.mapRequired("SystemValue", S.SystemValue);
179 IO.mapRequired("CompType", S.CompType);
180 IO.mapRequired("Register", S.Register);
181 IO.mapRequired("Mask", S.Mask);
182 IO.mapRequired("ExclusiveMask", S.ExclusiveMask);
183 IO.mapRequired("MinPrecision", S.MinPrecision);
184 }
185
mapping(IO & IO,DXContainerYAML::Signature & S)186 void MappingTraits<DXContainerYAML::Signature>::mapping(
187 IO &IO, DXContainerYAML::Signature &S) {
188 IO.mapRequired("Parameters", S.Parameters);
189 }
190
mapping(IO & IO,DXContainerYAML::Part & P)191 void MappingTraits<DXContainerYAML::Part>::mapping(IO &IO,
192 DXContainerYAML::Part &P) {
193 IO.mapRequired("Name", P.Name);
194 IO.mapRequired("Size", P.Size);
195 IO.mapOptional("Program", P.Program);
196 IO.mapOptional("Flags", P.Flags);
197 IO.mapOptional("Hash", P.Hash);
198 IO.mapOptional("PSVInfo", P.Info);
199 IO.mapOptional("Signature", P.Signature);
200 }
201
mapping(IO & IO,DXContainerYAML::Object & Obj)202 void MappingTraits<DXContainerYAML::Object>::mapping(
203 IO &IO, DXContainerYAML::Object &Obj) {
204 IO.mapTag("!dxcontainer", true);
205 IO.mapRequired("Header", Obj.Header);
206 IO.mapRequired("Parts", Obj.Parts);
207 }
208
mapping(IO & IO,DXContainerYAML::ResourceBindInfo & Res)209 void MappingTraits<DXContainerYAML::ResourceBindInfo>::mapping(
210 IO &IO, DXContainerYAML::ResourceBindInfo &Res) {
211 IO.mapRequired("Type", Res.Type);
212 IO.mapRequired("Space", Res.Space);
213 IO.mapRequired("LowerBound", Res.LowerBound);
214 IO.mapRequired("UpperBound", Res.UpperBound);
215
216 const uint32_t *PSVVersion = static_cast<uint32_t *>(IO.getContext());
217 if (*PSVVersion < 2)
218 return;
219
220 IO.mapRequired("Kind", Res.Kind);
221 IO.mapRequired("Flags", Res.Flags);
222 }
223
mapping(IO & IO,DXContainerYAML::SignatureElement & El)224 void MappingTraits<DXContainerYAML::SignatureElement>::mapping(
225 IO &IO, DXContainerYAML::SignatureElement &El) {
226 IO.mapRequired("Name", El.Name);
227 IO.mapRequired("Indices", El.Indices);
228 IO.mapRequired("StartRow", El.StartRow);
229 IO.mapRequired("Cols", El.Cols);
230 IO.mapRequired("StartCol", El.StartCol);
231 IO.mapRequired("Allocated", El.Allocated);
232 IO.mapRequired("Kind", El.Kind);
233 IO.mapRequired("ComponentType", El.Type);
234 IO.mapRequired("Interpolation", El.Mode);
235 IO.mapRequired("DynamicMask", El.DynamicMask);
236 IO.mapRequired("Stream", El.Stream);
237 }
238
enumeration(IO & IO,dxbc::PSV::SemanticKind & Value)239 void ScalarEnumerationTraits<dxbc::PSV::SemanticKind>::enumeration(
240 IO &IO, dxbc::PSV::SemanticKind &Value) {
241 for (const auto &E : dxbc::PSV::getSemanticKinds())
242 IO.enumCase(Value, E.Name.str().c_str(), E.Value);
243 }
244
enumeration(IO & IO,dxbc::PSV::ComponentType & Value)245 void ScalarEnumerationTraits<dxbc::PSV::ComponentType>::enumeration(
246 IO &IO, dxbc::PSV::ComponentType &Value) {
247 for (const auto &E : dxbc::PSV::getComponentTypes())
248 IO.enumCase(Value, E.Name.str().c_str(), E.Value);
249 }
250
enumeration(IO & IO,dxbc::PSV::InterpolationMode & Value)251 void ScalarEnumerationTraits<dxbc::PSV::InterpolationMode>::enumeration(
252 IO &IO, dxbc::PSV::InterpolationMode &Value) {
253 for (const auto &E : dxbc::PSV::getInterpolationModes())
254 IO.enumCase(Value, E.Name.str().c_str(), E.Value);
255 }
256
enumeration(IO & IO,dxbc::D3DSystemValue & Value)257 void ScalarEnumerationTraits<dxbc::D3DSystemValue>::enumeration(
258 IO &IO, dxbc::D3DSystemValue &Value) {
259 for (const auto &E : dxbc::getD3DSystemValues())
260 IO.enumCase(Value, E.Name.str().c_str(), E.Value);
261 }
262
enumeration(IO & IO,dxbc::SigMinPrecision & Value)263 void ScalarEnumerationTraits<dxbc::SigMinPrecision>::enumeration(
264 IO &IO, dxbc::SigMinPrecision &Value) {
265 for (const auto &E : dxbc::getSigMinPrecisions())
266 IO.enumCase(Value, E.Name.str().c_str(), E.Value);
267 }
268
enumeration(IO & IO,dxbc::SigComponentType & Value)269 void ScalarEnumerationTraits<dxbc::SigComponentType>::enumeration(
270 IO &IO, dxbc::SigComponentType &Value) {
271 for (const auto &E : dxbc::getSigComponentTypes())
272 IO.enumCase(Value, E.Name.str().c_str(), E.Value);
273 }
274
275 } // namespace yaml
276
mapInfoForVersion(yaml::IO & IO)277 void DXContainerYAML::PSVInfo::mapInfoForVersion(yaml::IO &IO) {
278 dxbc::PipelinePSVInfo &StageInfo = Info.StageInfo;
279 Triple::EnvironmentType Stage = dxbc::getShaderStage(Info.ShaderStage);
280
281 switch (Stage) {
282 case Triple::EnvironmentType::Pixel:
283 IO.mapRequired("DepthOutput", StageInfo.PS.DepthOutput);
284 IO.mapRequired("SampleFrequency", StageInfo.PS.SampleFrequency);
285 break;
286 case Triple::EnvironmentType::Vertex:
287 IO.mapRequired("OutputPositionPresent", StageInfo.VS.OutputPositionPresent);
288 break;
289 case Triple::EnvironmentType::Geometry:
290 IO.mapRequired("InputPrimitive", StageInfo.GS.InputPrimitive);
291 IO.mapRequired("OutputTopology", StageInfo.GS.OutputTopology);
292 IO.mapRequired("OutputStreamMask", StageInfo.GS.OutputStreamMask);
293 IO.mapRequired("OutputPositionPresent", StageInfo.GS.OutputPositionPresent);
294 break;
295 case Triple::EnvironmentType::Hull:
296 IO.mapRequired("InputControlPointCount",
297 StageInfo.HS.InputControlPointCount);
298 IO.mapRequired("OutputControlPointCount",
299 StageInfo.HS.OutputControlPointCount);
300 IO.mapRequired("TessellatorDomain", StageInfo.HS.TessellatorDomain);
301 IO.mapRequired("TessellatorOutputPrimitive",
302 StageInfo.HS.TessellatorOutputPrimitive);
303 break;
304 case Triple::EnvironmentType::Domain:
305 IO.mapRequired("InputControlPointCount",
306 StageInfo.DS.InputControlPointCount);
307 IO.mapRequired("OutputPositionPresent", StageInfo.DS.OutputPositionPresent);
308 IO.mapRequired("TessellatorDomain", StageInfo.DS.TessellatorDomain);
309 break;
310 case Triple::EnvironmentType::Mesh:
311 IO.mapRequired("GroupSharedBytesUsed", StageInfo.MS.GroupSharedBytesUsed);
312 IO.mapRequired("GroupSharedBytesDependentOnViewID",
313 StageInfo.MS.GroupSharedBytesDependentOnViewID);
314 IO.mapRequired("PayloadSizeInBytes", StageInfo.MS.PayloadSizeInBytes);
315 IO.mapRequired("MaxOutputVertices", StageInfo.MS.MaxOutputVertices);
316 IO.mapRequired("MaxOutputPrimitives", StageInfo.MS.MaxOutputPrimitives);
317 break;
318 case Triple::EnvironmentType::Amplification:
319 IO.mapRequired("PayloadSizeInBytes", StageInfo.AS.PayloadSizeInBytes);
320 break;
321 default:
322 break;
323 }
324
325 IO.mapRequired("MinimumWaveLaneCount", Info.MinimumWaveLaneCount);
326 IO.mapRequired("MaximumWaveLaneCount", Info.MaximumWaveLaneCount);
327
328 if (Version == 0)
329 return;
330
331 IO.mapRequired("UsesViewID", Info.UsesViewID);
332
333 switch (Stage) {
334 case Triple::EnvironmentType::Geometry:
335 IO.mapRequired("MaxVertexCount", Info.GeomData.MaxVertexCount);
336 break;
337 case Triple::EnvironmentType::Hull:
338 case Triple::EnvironmentType::Domain:
339 IO.mapRequired("SigPatchConstOrPrimVectors",
340 Info.GeomData.SigPatchConstOrPrimVectors);
341 break;
342 case Triple::EnvironmentType::Mesh:
343 IO.mapRequired("SigPrimVectors", Info.GeomData.MeshInfo.SigPrimVectors);
344 IO.mapRequired("MeshOutputTopology",
345 Info.GeomData.MeshInfo.MeshOutputTopology);
346 break;
347 default:
348 break;
349 }
350
351 IO.mapRequired("SigInputVectors", Info.SigInputVectors);
352 MutableArrayRef<uint8_t> Vec(Info.SigOutputVectors);
353 IO.mapRequired("SigOutputVectors", Vec);
354
355 if (Version == 1)
356 return;
357
358 IO.mapRequired("NumThreadsX", Info.NumThreadsX);
359 IO.mapRequired("NumThreadsY", Info.NumThreadsY);
360 IO.mapRequired("NumThreadsZ", Info.NumThreadsZ);
361
362 if (Version == 2)
363 return;
364
365 IO.mapRequired("EntryName", EntryName);
366 }
367
368 } // namespace llvm
369