LLVM 19.0.0git
DXContainer.cpp
Go to the documentation of this file.
1//===- DXContainer.cpp - DXContainer object file 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
11#include "llvm/Object/Error.h"
14
15using namespace llvm;
16using namespace llvm::object;
17
18static Error parseFailed(const Twine &Msg) {
19 return make_error<GenericBinaryError>(Msg.str(), object_error::parse_failed);
20}
21
22template <typename T>
23static Error readStruct(StringRef Buffer, const char *Src, T &Struct) {
24 // Don't read before the beginning or past the end of the file
25 if (Src < Buffer.begin() || Src + sizeof(T) > Buffer.end())
26 return parseFailed("Reading structure out of file bounds");
27
28 memcpy(&Struct, Src, sizeof(T));
29 // DXContainer is always little endian
31 Struct.swapBytes();
32 return Error::success();
33}
34
35template <typename T>
36static Error readInteger(StringRef Buffer, const char *Src, T &Val,
37 Twine Str = "structure") {
38 static_assert(std::is_integral_v<T>,
39 "Cannot call readInteger on non-integral type.");
40 // Don't read before the beginning or past the end of the file
41 if (Src < Buffer.begin() || Src + sizeof(T) > Buffer.end())
42 return parseFailed(Twine("Reading ") + Str + " out of file bounds");
43
44 // The DXContainer offset table is comprised of uint32_t values but not padded
45 // to a 64-bit boundary. So Parts may start unaligned if there is an odd
46 // number of parts and part data itself is not required to be padded.
47 if (reinterpret_cast<uintptr_t>(Src) % alignof(T) != 0)
48 memcpy(reinterpret_cast<char *>(&Val), Src, sizeof(T));
49 else
50 Val = *reinterpret_cast<const T *>(Src);
51 // DXContainer is always little endian
54 return Error::success();
55}
56
57DXContainer::DXContainer(MemoryBufferRef O) : Data(O) {}
58
59Error DXContainer::parseHeader() {
60 return readStruct(Data.getBuffer(), Data.getBuffer().data(), Header);
61}
62
63Error DXContainer::parseDXILHeader(StringRef Part) {
64 if (DXIL)
65 return parseFailed("More than one DXIL part is present in the file");
66 const char *Current = Part.begin();
68 if (Error Err = readStruct(Part, Current, Header))
69 return Err;
70 Current += offsetof(dxbc::ProgramHeader, Bitcode) + Header.Bitcode.Offset;
71 DXIL.emplace(std::make_pair(Header, Current));
72 return Error::success();
73}
74
75Error DXContainer::parseShaderFeatureFlags(StringRef Part) {
76 if (ShaderFeatureFlags)
77 return parseFailed("More than one SFI0 part is present in the file");
78 uint64_t FlagValue = 0;
79 if (Error Err = readInteger(Part, Part.begin(), FlagValue))
80 return Err;
81 ShaderFeatureFlags = FlagValue;
82 return Error::success();
83}
84
85Error DXContainer::parseHash(StringRef Part) {
86 if (Hash)
87 return parseFailed("More than one HASH part is present in the file");
88 dxbc::ShaderHash ReadHash;
89 if (Error Err = readStruct(Part, Part.begin(), ReadHash))
90 return Err;
91 Hash = ReadHash;
92 return Error::success();
93}
94
95Error DXContainer::parsePSVInfo(StringRef Part) {
96 if (PSVInfo)
97 return parseFailed("More than one PSV0 part is present in the file");
98 PSVInfo = DirectX::PSVRuntimeInfo(Part);
99 // Parsing the PSVRuntime info occurs late because we need to read data from
100 // other parts first.
101 return Error::success();
102}
103
106 if (Error Err = readStruct(Part, Part.begin(), SigHeader))
107 return Err;
108 size_t Size = sizeof(dxbc::ProgramSignatureElement) * SigHeader.ParamCount;
109
110 if (Part.size() < Size + SigHeader.FirstParamOffset)
111 return parseFailed("Signature parameters extend beyond the part boundary");
112
113 Parameters.Data = Part.substr(SigHeader.FirstParamOffset, Size);
114
115 StringTableOffset = SigHeader.FirstParamOffset + static_cast<uint32_t>(Size);
116 StringTable = Part.substr(SigHeader.FirstParamOffset + Size);
117
118 for (const auto &Param : Parameters) {
119 if (Param.NameOffset < StringTableOffset)
120 return parseFailed("Invalid parameter name offset: name starts before "
121 "the first name offset");
122 if (Param.NameOffset - StringTableOffset > StringTable.size())
123 return parseFailed("Invalid parameter name offset: name starts after the "
124 "end of the part data");
125 }
126 return Error::success();
127}
128
129Error DXContainer::parsePartOffsets() {
130 uint32_t LastOffset =
131 sizeof(dxbc::Header) + (Header.PartCount * sizeof(uint32_t));
132 const char *Current = Data.getBuffer().data() + sizeof(dxbc::Header);
133 for (uint32_t Part = 0; Part < Header.PartCount; ++Part) {
134 uint32_t PartOffset;
135 if (Error Err = readInteger(Data.getBuffer(), Current, PartOffset))
136 return Err;
137 if (PartOffset < LastOffset)
138 return parseFailed(
139 formatv(
140 "Part offset for part {0} begins before the previous part ends",
141 Part)
142 .str());
143 Current += sizeof(uint32_t);
144 if (PartOffset >= Data.getBufferSize())
145 return parseFailed("Part offset points beyond boundary of the file");
146 // To prevent overflow when reading the part name, we subtract the part name
147 // size from the buffer size, rather than adding to the offset. Since the
148 // file header is larger than the part header we can't reach this code
149 // unless the buffer is at least as large as a part header, so this
150 // subtraction can't underflow.
151 if (PartOffset >= Data.getBufferSize() - sizeof(dxbc::PartHeader::Name))
152 return parseFailed("File not large enough to read part name");
153 PartOffsets.push_back(PartOffset);
154
155 dxbc::PartType PT =
156 dxbc::parsePartType(Data.getBuffer().substr(PartOffset, 4));
157 uint32_t PartDataStart = PartOffset + sizeof(dxbc::PartHeader);
158 uint32_t PartSize;
159 if (Error Err = readInteger(Data.getBuffer(),
160 Data.getBufferStart() + PartOffset + 4,
161 PartSize, "part size"))
162 return Err;
163 StringRef PartData = Data.getBuffer().substr(PartDataStart, PartSize);
164 LastOffset = PartOffset + PartSize;
165 switch (PT) {
166 case dxbc::PartType::DXIL:
167 if (Error Err = parseDXILHeader(PartData))
168 return Err;
169 break;
170 case dxbc::PartType::SFI0:
171 if (Error Err = parseShaderFeatureFlags(PartData))
172 return Err;
173 break;
174 case dxbc::PartType::HASH:
175 if (Error Err = parseHash(PartData))
176 return Err;
177 break;
178 case dxbc::PartType::PSV0:
179 if (Error Err = parsePSVInfo(PartData))
180 return Err;
181 break;
182 case dxbc::PartType::ISG1:
183 if (Error Err = InputSignature.initialize(PartData))
184 return Err;
185 break;
186 case dxbc::PartType::OSG1:
187 if (Error Err = OutputSignature.initialize(PartData))
188 return Err;
189 break;
190 case dxbc::PartType::PSG1:
191 if (Error Err = PatchConstantSignature.initialize(PartData))
192 return Err;
193 break;
195 break;
196 }
197 }
198
199 // Fully parsing the PSVInfo requires knowing the shader kind which we read
200 // out of the program header in the DXIL part.
201 if (PSVInfo) {
202 if (!DXIL)
203 return parseFailed("Cannot fully parse pipeline state validation "
204 "information without DXIL part.");
205 if (Error Err = PSVInfo->parse(DXIL->first.ShaderKind))
206 return Err;
207 }
208 return Error::success();
209}
210
212 DXContainer Container(Object);
213 if (Error Err = Container.parseHeader())
214 return std::move(Err);
215 if (Error Err = Container.parsePartOffsets())
216 return std::move(Err);
217 return Container;
218}
219
220void DXContainer::PartIterator::updateIteratorImpl(const uint32_t Offset) {
221 StringRef Buffer = Container.Data.getBuffer();
222 const char *Current = Buffer.data() + Offset;
223 // Offsets are validated during parsing, so all offsets in the container are
224 // valid and contain enough readable data to read a header.
225 cantFail(readStruct(Buffer, Current, IteratorState.Part));
226 IteratorState.Data =
227 StringRef(Current + sizeof(dxbc::PartHeader), IteratorState.Part.Size);
228 IteratorState.Offset = Offset;
229}
230
232 Triple::EnvironmentType ShaderStage = dxbc::getShaderStage(ShaderKind);
233
234 const char *Current = Data.begin();
235 if (Error Err = readInteger(Data, Current, Size))
236 return Err;
237 Current += sizeof(uint32_t);
238
239 StringRef PSVInfoData = Data.substr(sizeof(uint32_t), Size);
240
241 if (PSVInfoData.size() < Size)
242 return parseFailed(
243 "Pipeline state data extends beyond the bounds of the part");
244
245 using namespace dxbc::PSV;
246
247 const uint32_t PSVVersion = getVersion();
248
249 // Detect the PSVVersion by looking at the size field.
250 if (PSVVersion == 3) {
251 v3::RuntimeInfo Info;
252 if (Error Err = readStruct(PSVInfoData, Current, Info))
253 return Err;
255 Info.swapBytes(ShaderStage);
256 BasicInfo = Info;
257 } else if (PSVVersion == 2) {
258 v2::RuntimeInfo Info;
259 if (Error Err = readStruct(PSVInfoData, Current, Info))
260 return Err;
262 Info.swapBytes(ShaderStage);
263 BasicInfo = Info;
264 } else if (PSVVersion == 1) {
265 v1::RuntimeInfo Info;
266 if (Error Err = readStruct(PSVInfoData, Current, Info))
267 return Err;
269 Info.swapBytes(ShaderStage);
270 BasicInfo = Info;
271 } else if (PSVVersion == 0) {
272 v0::RuntimeInfo Info;
273 if (Error Err = readStruct(PSVInfoData, Current, Info))
274 return Err;
276 Info.swapBytes(ShaderStage);
277 BasicInfo = Info;
278 } else
279 return parseFailed(
280 "Cannot read PSV Runtime Info, unsupported PSV version.");
281
282 Current += Size;
283
284 uint32_t ResourceCount = 0;
285 if (Error Err = readInteger(Data, Current, ResourceCount))
286 return Err;
287 Current += sizeof(uint32_t);
288
289 if (ResourceCount > 0) {
290 if (Error Err = readInteger(Data, Current, Resources.Stride))
291 return Err;
292 Current += sizeof(uint32_t);
293
294 size_t BindingDataSize = Resources.Stride * ResourceCount;
295 Resources.Data = Data.substr(Current - Data.begin(), BindingDataSize);
296
297 if (Resources.Data.size() < BindingDataSize)
298 return parseFailed(
299 "Resource binding data extends beyond the bounds of the part");
300
301 Current += BindingDataSize;
302 } else
303 Resources.Stride = sizeof(v2::ResourceBindInfo);
304
305 // PSV version 0 ends after the resource bindings.
306 if (PSVVersion == 0)
307 return Error::success();
308
309 // String table starts at a 4-byte offset.
310 Current = reinterpret_cast<const char *>(
311 alignTo<4>(reinterpret_cast<uintptr_t>(Current)));
312
313 uint32_t StringTableSize = 0;
314 if (Error Err = readInteger(Data, Current, StringTableSize))
315 return Err;
316 if (StringTableSize % 4 != 0)
317 return parseFailed("String table misaligned");
318 Current += sizeof(uint32_t);
319 StringTable = StringRef(Current, StringTableSize);
320
321 Current += StringTableSize;
322
323 uint32_t SemanticIndexTableSize = 0;
324 if (Error Err = readInteger(Data, Current, SemanticIndexTableSize))
325 return Err;
326 Current += sizeof(uint32_t);
327
328 SemanticIndexTable.reserve(SemanticIndexTableSize);
329 for (uint32_t I = 0; I < SemanticIndexTableSize; ++I) {
330 uint32_t Index = 0;
331 if (Error Err = readInteger(Data, Current, Index))
332 return Err;
333 Current += sizeof(uint32_t);
334 SemanticIndexTable.push_back(Index);
335 }
336
337 uint8_t InputCount = getSigInputCount();
338 uint8_t OutputCount = getSigOutputCount();
339 uint8_t PatchOrPrimCount = getSigPatchOrPrimCount();
340
341 uint32_t ElementCount = InputCount + OutputCount + PatchOrPrimCount;
342
343 if (ElementCount > 0) {
344 if (Error Err = readInteger(Data, Current, SigInputElements.Stride))
345 return Err;
346 Current += sizeof(uint32_t);
347 // Assign the stride to all the arrays.
348 SigOutputElements.Stride = SigPatchOrPrimElements.Stride =
349 SigInputElements.Stride;
350
351 if (Data.end() - Current <
352 (ptrdiff_t)(ElementCount * SigInputElements.Stride))
353 return parseFailed(
354 "Signature elements extend beyond the size of the part");
355
356 size_t InputSize = SigInputElements.Stride * InputCount;
357 SigInputElements.Data = Data.substr(Current - Data.begin(), InputSize);
358 Current += InputSize;
359
360 size_t OutputSize = SigOutputElements.Stride * OutputCount;
361 SigOutputElements.Data = Data.substr(Current - Data.begin(), OutputSize);
362 Current += OutputSize;
363
364 size_t PSize = SigPatchOrPrimElements.Stride * PatchOrPrimCount;
365 SigPatchOrPrimElements.Data = Data.substr(Current - Data.begin(), PSize);
366 Current += PSize;
367 }
368
369 ArrayRef<uint8_t> OutputVectorCounts = getOutputVectorCounts();
370 uint8_t PatchConstOrPrimVectorCount = getPatchConstOrPrimVectorCount();
371 uint8_t InputVectorCount = getInputVectorCount();
372
373 auto maskDwordSize = [](uint8_t Vector) {
374 return (static_cast<uint32_t>(Vector) + 7) >> 3;
375 };
376
377 auto mapTableSize = [maskDwordSize](uint8_t X, uint8_t Y) {
378 return maskDwordSize(Y) * X * 4;
379 };
380
381 if (usesViewID()) {
382 for (uint32_t I = 0; I < OutputVectorCounts.size(); ++I) {
383 // The vector mask is one bit per component and 4 components per vector.
384 // We can compute the number of dwords required by rounding up to the next
385 // multiple of 8.
386 uint32_t NumDwords =
387 maskDwordSize(static_cast<uint32_t>(OutputVectorCounts[I]));
388 size_t NumBytes = NumDwords * sizeof(uint32_t);
389 OutputVectorMasks[I].Data = Data.substr(Current - Data.begin(), NumBytes);
390 Current += NumBytes;
391 }
392
393 if (ShaderStage == Triple::Hull && PatchConstOrPrimVectorCount > 0) {
394 uint32_t NumDwords = maskDwordSize(PatchConstOrPrimVectorCount);
395 size_t NumBytes = NumDwords * sizeof(uint32_t);
396 PatchOrPrimMasks.Data = Data.substr(Current - Data.begin(), NumBytes);
397 Current += NumBytes;
398 }
399 }
400
401 // Input/Output mapping table
402 for (uint32_t I = 0; I < OutputVectorCounts.size(); ++I) {
403 if (InputVectorCount == 0 || OutputVectorCounts[I] == 0)
404 continue;
405 uint32_t NumDwords = mapTableSize(InputVectorCount, OutputVectorCounts[I]);
406 size_t NumBytes = NumDwords * sizeof(uint32_t);
407 InputOutputMap[I].Data = Data.substr(Current - Data.begin(), NumBytes);
408 Current += NumBytes;
409 }
410
411 // Hull shader: Input/Patch mapping table
412 if (ShaderStage == Triple::Hull && PatchConstOrPrimVectorCount > 0 &&
413 InputVectorCount > 0) {
414 uint32_t NumDwords =
415 mapTableSize(InputVectorCount, PatchConstOrPrimVectorCount);
416 size_t NumBytes = NumDwords * sizeof(uint32_t);
417 InputPatchMap.Data = Data.substr(Current - Data.begin(), NumBytes);
418 Current += NumBytes;
419 }
420
421 // Domain Shader: Patch/Output mapping table
422 if (ShaderStage == Triple::Domain && PatchConstOrPrimVectorCount > 0 &&
423 OutputVectorCounts[0] > 0) {
424 uint32_t NumDwords =
425 mapTableSize(PatchConstOrPrimVectorCount, OutputVectorCounts[0]);
426 size_t NumBytes = NumDwords * sizeof(uint32_t);
427 PatchOutputMap.Data = Data.substr(Current - Data.begin(), NumBytes);
428 Current += NumBytes;
429 }
430
431 return Error::success();
432}
433
435 if (const auto *P = std::get_if<dxbc::PSV::v3::RuntimeInfo>(&BasicInfo))
436 return P->SigInputElements;
437 if (const auto *P = std::get_if<dxbc::PSV::v2::RuntimeInfo>(&BasicInfo))
438 return P->SigInputElements;
439 if (const auto *P = std::get_if<dxbc::PSV::v1::RuntimeInfo>(&BasicInfo))
440 return P->SigInputElements;
441 return 0;
442}
443
445 if (const auto *P = std::get_if<dxbc::PSV::v3::RuntimeInfo>(&BasicInfo))
446 return P->SigOutputElements;
447 if (const auto *P = std::get_if<dxbc::PSV::v2::RuntimeInfo>(&BasicInfo))
448 return P->SigOutputElements;
449 if (const auto *P = std::get_if<dxbc::PSV::v1::RuntimeInfo>(&BasicInfo))
450 return P->SigOutputElements;
451 return 0;
452}
453
455 if (const auto *P = std::get_if<dxbc::PSV::v3::RuntimeInfo>(&BasicInfo))
456 return P->SigPatchOrPrimElements;
457 if (const auto *P = std::get_if<dxbc::PSV::v2::RuntimeInfo>(&BasicInfo))
458 return P->SigPatchOrPrimElements;
459 if (const auto *P = std::get_if<dxbc::PSV::v1::RuntimeInfo>(&BasicInfo))
460 return P->SigPatchOrPrimElements;
461 return 0;
462}
#define offsetof(TYPE, MEMBER)
write Write Bitcode
Analysis containing CSE Info
Definition: CSEInfo.cpp:27
uint64_t Size
static GCMetadataPrinterRegistry::Add< ErlangGCPrinter > X("erlang", "erlang-compatible garbage collector")
#define I(x, y, z)
Definition: MD5.cpp:58
static Error parseFailed(const Twine &Msg)
Definition: DXContainer.cpp:18
static Error readStruct(StringRef Buffer, const char *Src, T &Struct)
Definition: DXContainer.cpp:23
static Error readInteger(StringRef Buffer, const char *Src, T &Val, Twine Str="structure")
Definition: DXContainer.cpp:36
static GCMetadataPrinterRegistry::Add< OcamlGCMetadataPrinter > Y("ocaml", "ocaml 3.10-compatible collector")
#define P(N)
if(VerifyEach)
@ Struct
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory),...
Definition: ArrayRef.h:41
size_t size() const
size - Get the array size.
Definition: ArrayRef.h:165
Lightweight error class with error context and mandatory checking.
Definition: Error.h:160
static ErrorSuccess success()
Create a success value.
Definition: Error.h:334
Tagged union holding either a T or a Error.
Definition: Error.h:474
StringRef getBuffer() const
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:50
constexpr StringRef substr(size_t Start, size_t N=npos) const
Return a reference to the substring from [Start, Start + N).
Definition: StringRef.h:567
iterator begin() const
Definition: StringRef.h:111
constexpr size_t size() const
size - Get the string size.
Definition: StringRef.h:137
constexpr const char * data() const
data - Get a pointer to the start of the string (which may not be null terminated).
Definition: StringRef.h:131
iterator end() const
Definition: StringRef.h:113
Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...
Definition: Twine.h:81
static Expected< DXContainer > create(MemoryBufferRef Object)
Error parse(uint16_t ShaderKind)
Error initialize(StringRef Part)
PartType parsePartType(StringRef S)
Definition: DXContainer.cpp:21
Triple::EnvironmentType getShaderStage(uint32_t Kind)
Definition: DXContainer.h:41
constexpr bool IsBigEndianHost
Definition: SwapByteOrder.h:26
void swapByteOrder(T &Value)
Definition: SwapByteOrder.h:61
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
@ Offset
Definition: DWP.cpp:456
auto formatv(const char *Fmt, Ts &&...Vals) -> formatv_object< decltype(std::make_tuple(support::detail::build_format_adapter(std::forward< Ts >(Vals))...))>
void cantFail(Error Err, const char *Msg=nullptr)
Report a fatal error if Err is a failure value.
Definition: Error.h:749
Use this type to describe the size and type of a DXIL container part.
Definition: DXContainer.h:93