xref: /openbsd-src/gnu/llvm/llvm/lib/Object/DXContainer.cpp (revision d415bd752c734aee168c4ee86ff32e8cc249eb16)
1*d415bd75Srobert //===- DXContainer.cpp - DXContainer object file implementation -----------===//
2*d415bd75Srobert //
3*d415bd75Srobert // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4*d415bd75Srobert // See https://llvm.org/LICENSE.txt for license information.
5*d415bd75Srobert // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6*d415bd75Srobert //
7*d415bd75Srobert //===----------------------------------------------------------------------===//
8*d415bd75Srobert 
9*d415bd75Srobert #include "llvm/Object/DXContainer.h"
10*d415bd75Srobert #include "llvm/BinaryFormat/DXContainer.h"
11*d415bd75Srobert #include "llvm/Object/Error.h"
12*d415bd75Srobert #include "llvm/Support/FormatVariadic.h"
13*d415bd75Srobert 
14*d415bd75Srobert using namespace llvm;
15*d415bd75Srobert using namespace llvm::object;
16*d415bd75Srobert 
parseFailed(const Twine & Msg)17*d415bd75Srobert static Error parseFailed(const Twine &Msg) {
18*d415bd75Srobert   return make_error<GenericBinaryError>(Msg.str(), object_error::parse_failed);
19*d415bd75Srobert }
20*d415bd75Srobert 
21*d415bd75Srobert template <typename T>
readStruct(StringRef Buffer,const char * Src,T & Struct)22*d415bd75Srobert static Error readStruct(StringRef Buffer, const char *Src, T &Struct) {
23*d415bd75Srobert   // Don't read before the beginning or past the end of the file
24*d415bd75Srobert   if (Src < Buffer.begin() || Src + sizeof(T) > Buffer.end())
25*d415bd75Srobert     return parseFailed("Reading structure out of file bounds");
26*d415bd75Srobert 
27*d415bd75Srobert   memcpy(&Struct, Src, sizeof(T));
28*d415bd75Srobert   // DXContainer is always little endian
29*d415bd75Srobert   if (sys::IsBigEndianHost)
30*d415bd75Srobert     Struct.swapBytes();
31*d415bd75Srobert   return Error::success();
32*d415bd75Srobert }
33*d415bd75Srobert 
34*d415bd75Srobert template <typename T>
readInteger(StringRef Buffer,const char * Src,T & Val,Twine Str="structure")35*d415bd75Srobert static Error readInteger(StringRef Buffer, const char *Src, T &Val,
36*d415bd75Srobert                          Twine Str = "structure") {
37*d415bd75Srobert   static_assert(std::is_integral_v<T>,
38*d415bd75Srobert                 "Cannot call readInteger on non-integral type.");
39*d415bd75Srobert   // Don't read before the beginning or past the end of the file
40*d415bd75Srobert   if (Src < Buffer.begin() || Src + sizeof(T) > Buffer.end())
41*d415bd75Srobert     return parseFailed(Twine("Reading ") + Str + " out of file bounds");
42*d415bd75Srobert 
43*d415bd75Srobert   // The DXContainer offset table is comprised of uint32_t values but not padded
44*d415bd75Srobert   // to a 64-bit boundary. So Parts may start unaligned if there is an odd
45*d415bd75Srobert   // number of parts and part data itself is not required to be padded.
46*d415bd75Srobert   if (reinterpret_cast<uintptr_t>(Src) % alignof(T) != 0)
47*d415bd75Srobert     memcpy(reinterpret_cast<char *>(&Val), Src, sizeof(T));
48*d415bd75Srobert   else
49*d415bd75Srobert     Val = *reinterpret_cast<const T *>(Src);
50*d415bd75Srobert   // DXContainer is always little endian
51*d415bd75Srobert   if (sys::IsBigEndianHost)
52*d415bd75Srobert     sys::swapByteOrder(Val);
53*d415bd75Srobert   return Error::success();
54*d415bd75Srobert }
55*d415bd75Srobert 
DXContainer(MemoryBufferRef O)56*d415bd75Srobert DXContainer::DXContainer(MemoryBufferRef O) : Data(O) {}
57*d415bd75Srobert 
parseHeader()58*d415bd75Srobert Error DXContainer::parseHeader() {
59*d415bd75Srobert   return readStruct(Data.getBuffer(), Data.getBuffer().data(), Header);
60*d415bd75Srobert }
61*d415bd75Srobert 
parseDXILHeader(StringRef Part)62*d415bd75Srobert Error DXContainer::parseDXILHeader(StringRef Part) {
63*d415bd75Srobert   if (DXIL)
64*d415bd75Srobert     return parseFailed("More than one DXIL part is present in the file");
65*d415bd75Srobert   const char *Current = Part.begin();
66*d415bd75Srobert   dxbc::ProgramHeader Header;
67*d415bd75Srobert   if (Error Err = readStruct(Part, Current, Header))
68*d415bd75Srobert     return Err;
69*d415bd75Srobert   Current += offsetof(dxbc::ProgramHeader, Bitcode) + Header.Bitcode.Offset;
70*d415bd75Srobert   DXIL.emplace(std::make_pair(Header, Current));
71*d415bd75Srobert   return Error::success();
72*d415bd75Srobert }
73*d415bd75Srobert 
parseShaderFlags(StringRef Part)74*d415bd75Srobert Error DXContainer::parseShaderFlags(StringRef Part) {
75*d415bd75Srobert   if (ShaderFlags)
76*d415bd75Srobert     return parseFailed("More than one SFI0 part is present in the file");
77*d415bd75Srobert   uint64_t FlagValue = 0;
78*d415bd75Srobert   if (Error Err = readInteger(Part, Part.begin(), FlagValue))
79*d415bd75Srobert     return Err;
80*d415bd75Srobert   ShaderFlags = FlagValue;
81*d415bd75Srobert   return Error::success();
82*d415bd75Srobert }
83*d415bd75Srobert 
parseHash(StringRef Part)84*d415bd75Srobert Error DXContainer::parseHash(StringRef Part) {
85*d415bd75Srobert   if (Hash)
86*d415bd75Srobert     return parseFailed("More than one HASH part is present in the file");
87*d415bd75Srobert   dxbc::ShaderHash ReadHash;
88*d415bd75Srobert   if (Error Err = readStruct(Part, Part.begin(), ReadHash))
89*d415bd75Srobert     return Err;
90*d415bd75Srobert   Hash = ReadHash;
91*d415bd75Srobert   return Error::success();
92*d415bd75Srobert }
93*d415bd75Srobert 
parsePartOffsets()94*d415bd75Srobert Error DXContainer::parsePartOffsets() {
95*d415bd75Srobert   uint32_t LastOffset =
96*d415bd75Srobert       sizeof(dxbc::Header) + (Header.PartCount * sizeof(uint32_t));
97*d415bd75Srobert   const char *Current = Data.getBuffer().data() + sizeof(dxbc::Header);
98*d415bd75Srobert   for (uint32_t Part = 0; Part < Header.PartCount; ++Part) {
99*d415bd75Srobert     uint32_t PartOffset;
100*d415bd75Srobert     if (Error Err = readInteger(Data.getBuffer(), Current, PartOffset))
101*d415bd75Srobert       return Err;
102*d415bd75Srobert     if (PartOffset < LastOffset)
103*d415bd75Srobert       return parseFailed(
104*d415bd75Srobert           formatv(
105*d415bd75Srobert               "Part offset for part {0} begins before the previous part ends",
106*d415bd75Srobert               Part)
107*d415bd75Srobert               .str());
108*d415bd75Srobert     Current += sizeof(uint32_t);
109*d415bd75Srobert     if (PartOffset >= Data.getBufferSize())
110*d415bd75Srobert       return parseFailed("Part offset points beyond boundary of the file");
111*d415bd75Srobert     // To prevent overflow when reading the part name, we subtract the part name
112*d415bd75Srobert     // size from the buffer size, rather than adding to the offset. Since the
113*d415bd75Srobert     // file header is larger than the part header we can't reach this code
114*d415bd75Srobert     // unless the buffer is at least as large as a part header, so this
115*d415bd75Srobert     // subtraction can't underflow.
116*d415bd75Srobert     if (PartOffset >= Data.getBufferSize() - sizeof(dxbc::PartHeader::Name))
117*d415bd75Srobert       return parseFailed("File not large enough to read part name");
118*d415bd75Srobert     PartOffsets.push_back(PartOffset);
119*d415bd75Srobert 
120*d415bd75Srobert     dxbc::PartType PT =
121*d415bd75Srobert         dxbc::parsePartType(Data.getBuffer().substr(PartOffset, 4));
122*d415bd75Srobert     uint32_t PartDataStart = PartOffset + sizeof(dxbc::PartHeader);
123*d415bd75Srobert     uint32_t PartSize;
124*d415bd75Srobert     if (Error Err = readInteger(Data.getBuffer(),
125*d415bd75Srobert                                 Data.getBufferStart() + PartOffset + 4,
126*d415bd75Srobert                                 PartSize, "part size"))
127*d415bd75Srobert       return Err;
128*d415bd75Srobert     StringRef PartData = Data.getBuffer().substr(PartDataStart, PartSize);
129*d415bd75Srobert     LastOffset = PartOffset + PartSize;
130*d415bd75Srobert     switch (PT) {
131*d415bd75Srobert     case dxbc::PartType::DXIL:
132*d415bd75Srobert       if (Error Err = parseDXILHeader(PartData))
133*d415bd75Srobert         return Err;
134*d415bd75Srobert       break;
135*d415bd75Srobert     case dxbc::PartType::SFI0:
136*d415bd75Srobert       if (Error Err = parseShaderFlags(PartData))
137*d415bd75Srobert         return Err;
138*d415bd75Srobert       break;
139*d415bd75Srobert     case dxbc::PartType::HASH:
140*d415bd75Srobert       if (Error Err = parseHash(PartData))
141*d415bd75Srobert         return Err;
142*d415bd75Srobert       break;
143*d415bd75Srobert     case dxbc::PartType::Unknown:
144*d415bd75Srobert       break;
145*d415bd75Srobert     }
146*d415bd75Srobert   }
147*d415bd75Srobert   return Error::success();
148*d415bd75Srobert }
149*d415bd75Srobert 
create(MemoryBufferRef Object)150*d415bd75Srobert Expected<DXContainer> DXContainer::create(MemoryBufferRef Object) {
151*d415bd75Srobert   DXContainer Container(Object);
152*d415bd75Srobert   if (Error Err = Container.parseHeader())
153*d415bd75Srobert     return std::move(Err);
154*d415bd75Srobert   if (Error Err = Container.parsePartOffsets())
155*d415bd75Srobert     return std::move(Err);
156*d415bd75Srobert   return Container;
157*d415bd75Srobert }
158*d415bd75Srobert 
updateIteratorImpl(const uint32_t Offset)159*d415bd75Srobert void DXContainer::PartIterator::updateIteratorImpl(const uint32_t Offset) {
160*d415bd75Srobert   StringRef Buffer = Container.Data.getBuffer();
161*d415bd75Srobert   const char *Current = Buffer.data() + Offset;
162*d415bd75Srobert   // Offsets are validated during parsing, so all offsets in the container are
163*d415bd75Srobert   // valid and contain enough readable data to read a header.
164*d415bd75Srobert   cantFail(readStruct(Buffer, Current, IteratorState.Part));
165*d415bd75Srobert   IteratorState.Data =
166*d415bd75Srobert       StringRef(Current + sizeof(dxbc::PartHeader), IteratorState.Part.Size);
167*d415bd75Srobert   IteratorState.Offset = Offset;
168*d415bd75Srobert }
169