Skip to content

Commit 1bf6408

Browse files
author
joaosaffran
committed
wip: implementing comments
1 parent 30098e1 commit 1bf6408

File tree

4 files changed

+217
-131
lines changed

4 files changed

+217
-131
lines changed

‎llvm/include/llvm/Object/DXContainer.h

Lines changed: 157 additions & 97 deletions
Original file line numberDiff line numberDiff line change
@@ -23,6 +23,9 @@
2323
#include "llvm/Support/MemoryBufferRef.h"
2424
#include "llvm/TargetParser/Triple.h"
2525
#include <array>
26+
#include <cstddef>
27+
#include <cstdint>
28+
#include <memory>
2629
#include <variant>
2730

2831
namespace llvm {
@@ -127,99 +130,132 @@ struct RootParameter {
127130
RootParameter() = default;
128131
};
129132

130-
struct ViewRootParameter {
131-
ViewArray<dxbc::RootParameterHeader> HeaderView;
132-
StringRef Data;
133-
134-
ViewRootParameter() = default;
135-
ViewRootParameter(ViewArray<dxbc::RootParameterHeader> HV, StringRef D)
136-
: HeaderView(HV), Data(D) {}
137-
138-
using value_type = DirectX::RootParameter;
139-
struct iterator {
140-
const ViewArray<dxbc::RootParameterHeader> HeaderView;
141-
ViewArray<dxbc::RootParameterHeader>::iterator Current;
142-
StringRef Data;
143-
144-
iterator(const ViewRootParameter &VRP,
145-
ViewArray<dxbc::RootParameterHeader>::iterator C)
146-
: HeaderView(VRP.HeaderView), Current(C), Data(VRP.Data) {}
147-
iterator(const iterator &) = default;
148-
149-
template <typename T>
150-
static Error readParameter(StringRef Buffer, const char *Src, T &Struct) {
151-
// Don't read before the beginning or past the end of the file
152-
if (Src < Buffer.begin() || Src + sizeof(T) > Buffer.end())
153-
return make_error<GenericBinaryError>(
154-
"Reading structure out of file bounds", object_error::parse_failed);
155-
156-
memcpy(&Struct, Src, sizeof(T));
157-
// DXContainer is always little endian
158-
if (sys::IsBigEndianHost)
159-
Struct.swapBytes();
160-
return Error::success();
161-
}
162-
163-
static Error validationFailed(const Twine &Msg) {
164-
return make_error<StringError>(Msg.str(), inconvertibleErrorCode());
165-
}
166-
167-
llvm::Expected<value_type> operator*() {
168-
value_type Parameter;
169-
std::memset(&Parameter.Header, 0, sizeof(dxbc::RootParameterHeader));
170-
memcpy(&Parameter.Header, Current.Current,
171-
sizeof(dxbc::RootParameterHeader));
172-
173-
switch (Parameter.Header.ParameterType) {
174-
case dxbc::RootParameterType::Constants32Bit:
175-
std::memset(&Parameter.Constants, 0, sizeof(dxbc::RootConstants));
176-
if (Error Err = readParameter(
177-
Data, Data.begin() + Parameter.Header.ParameterOffset,
178-
Parameter.Constants))
179-
return Err;
180-
break;
181-
}
182-
183-
return Parameter;
184-
}
185-
186-
iterator operator++() {
187-
if (Current != HeaderView.end())
188-
Current++;
189-
return *this;
190-
}
191-
192-
iterator operator++(int I) {
193-
iterator Tmp = *this;
194-
for (; I > 0; I--)
195-
++Tmp;
196-
return Tmp;
197-
}
198-
199-
iterator operator--() {
200-
if (Current != HeaderView.begin())
201-
Current--;
202-
return *this;
203-
}
204-
205-
iterator operator--(int I) {
206-
iterator Tmp = *this;
207-
for (; I > 0; I--)
208-
--Tmp;
209-
return Tmp;
210-
}
211-
212-
bool operator==(iterator I) { return I.Current == Current; }
213-
bool operator!=(const iterator I) { return !(*this == I); }
214-
};
215-
216-
iterator begin() const { return iterator(*this, this->HeaderView.begin()); }
217-
218-
iterator end() const { return iterator(*this, this->HeaderView.end()); }
133+
// struct ViewRootParameter {
134+
// ViewArray<dxbc::RootParameterHeader> HeaderView;
135+
// StringRef Data;
136+
137+
// ViewRootParameter() = default;
138+
// ViewRootParameter(ViewArray<dxbc::RootParameterHeader> HV, StringRef D)
139+
// : HeaderView(HV), Data(D) {}
140+
141+
// using value_type = DirectX::RootParameter;
142+
// struct iterator {
143+
// const ViewArray<dxbc::RootParameterHeader> HeaderView;
144+
// ViewArray<dxbc::RootParameterHeader>::iterator Current;
145+
// StringRef Data;
146+
147+
// iterator(const ViewRootParameter &VRP,
148+
// ViewArray<dxbc::RootParameterHeader>::iterator C)
149+
// : HeaderView(VRP.HeaderView), Current(C), Data(VRP.Data) {}
150+
// iterator(const iterator &) = default;
151+
152+
// template <typename T>
153+
// static Error readParameter(StringRef Buffer, const char *Src, T &Struct)
154+
// {
155+
// // Don't read before the beginning or past the end of the file
156+
// if (Src < Buffer.begin() || Src + sizeof(T) > Buffer.end())
157+
// return make_error<GenericBinaryError>(
158+
// "Reading structure out of file bounds",
159+
// object_error::parse_failed);
160+
161+
// memcpy(&Struct, Src, sizeof(T));
162+
// // DXContainer is always little endian
163+
// if (sys::IsBigEndianHost)
164+
// Struct.swapBytes();
165+
// return Error::success();
166+
// }
167+
168+
// static Error validationFailed(const Twine &Msg) {
169+
// return make_error<StringError>(Msg.str(), inconvertibleErrorCode());
170+
// }
171+
172+
// llvm::Expected<value_type> operator*() {
173+
// value_type Parameter;
174+
// std::memset(&Parameter.Header, 0, sizeof(dxbc::RootParameterHeader));
175+
// memcpy(&Parameter.Header, Current.Current,
176+
// sizeof(dxbc::RootParameterHeader));
177+
178+
// switch (Parameter.Header.ParameterType) {
179+
// case dxbc::RootParameterType::Constants32Bit:
180+
// std::memset(&Parameter.Constants, 0, sizeof(dxbc::RootConstants));
181+
// if (Error Err = readParameter(
182+
// Data, Data.begin() + Parameter.Header.ParameterOffset,
183+
// Parameter.Constants))
184+
// return Err;
185+
// break;
186+
// }
187+
188+
// return Parameter;
189+
// }
190+
191+
// iterator operator++() {
192+
// if (Current != HeaderView.end())
193+
// Current++;
194+
// return *this;
195+
// }
196+
197+
// iterator operator++(int I) {
198+
// iterator Tmp = *this;
199+
// for (; I > 0; I--)
200+
// ++Tmp;
201+
// return Tmp;
202+
// }
203+
204+
// iterator operator--() {
205+
// if (Current != HeaderView.begin())
206+
// Current--;
207+
// return *this;
208+
// }
209+
210+
// iterator operator--(int I) {
211+
// iterator Tmp = *this;
212+
// for (; I > 0; I--)
213+
// --Tmp;
214+
// return Tmp;
215+
// }
216+
217+
// bool operator==(iterator I) { return I.Current == Current; }
218+
// bool operator!=(const iterator I) { return !(*this == I); }
219+
// };
220+
221+
// iterator begin() const { return iterator(*this, this->HeaderView.begin());
222+
// }
223+
224+
// iterator end() const { return iterator(*this, this->HeaderView.end()); }
225+
226+
// size_t size() const { return HeaderView.size(); }
227+
228+
// bool isEmpty() const { return HeaderView.isEmpty(); }
229+
// };
230+
231+
struct RootParameterView {
232+
const dxbc::RootParameterHeader &Header;
233+
StringRef ParamData;
234+
RootParameterView(const dxbc::RootParameterHeader &H, StringRef P)
235+
: Header(H), ParamData(P) {}
236+
237+
template <typename T> Expected<T> readParameter() {
238+
T Struct;
239+
if (sizeof(T) > ParamData.size())
240+
return make_error<GenericBinaryError>(
241+
"Reading structure out of file bounds", object_error::parse_failed);
242+
243+
memcpy(&Struct, ParamData.data(), sizeof(T));
244+
// DXContainer is always little endian
245+
if (sys::IsBigEndianHost)
246+
Struct.swapBytes();
247+
return Struct;
248+
}
249+
};
219250

220-
size_t size() const { return HeaderView.size(); }
251+
struct RootConstantView : RootParameterView {
252+
static bool classof(const RootParameterView *V) {
253+
return V->Header.ParameterType == dxbc::RootParameterType::Constants32Bit;
254+
}
221255

222-
bool isEmpty() const { return HeaderView.isEmpty(); }
256+
llvm::Expected<dxbc::RootConstants> read() {
257+
return readParameter<dxbc::RootConstants>();
258+
}
223259
};
224260

225261
class RootSignature {
@@ -231,9 +267,11 @@ class RootSignature {
231267
uint32_t StaticSamplersOffset = 0;
232268
uint32_t Flags = 0;
233269

234-
ViewRootParameter Parameters;
270+
ViewArray<dxbc::RootParameterHeader> ParametersHeaders;
271+
size_t ParameterSpaceOffset;
272+
StringRef ParameterSpace;
235273

236-
using param_iterator = ViewRootParameter::iterator;
274+
using param_header_iterator = ViewArray<dxbc::RootParameterHeader>::iterator;
237275

238276
public:
239277
RootSignature() {}
@@ -244,12 +282,34 @@ class RootSignature {
244282
uint32_t getRootParametersOffset() const { return RootParametersOffset; }
245283
uint32_t getNumStaticSamplers() const { return NumStaticSamplers; }
246284
uint32_t getStaticSamplersOffset() const { return StaticSamplersOffset; }
247-
llvm::iterator_range<param_iterator> params() const {
248-
return llvm::make_range(Parameters.begin(), Parameters.end());
285+
llvm::iterator_range<param_header_iterator> param_header() const {
286+
return llvm::make_range(ParametersHeaders.begin(), ParametersHeaders.end());
287+
}
288+
param_header_iterator param_header_begin() {
289+
return ParametersHeaders.begin();
249290
}
250-
param_iterator param_begin() { return Parameters.begin(); }
251-
param_iterator param_end() { return Parameters.end(); }
291+
param_header_iterator param_header_end() { return ParametersHeaders.end(); }
252292
uint32_t getFlags() const { return Flags; }
293+
RootParameterView
294+
getParameter(const dxbc::RootParameterHeader &Header) const {
295+
size_t CorrectOffset = Header.ParameterOffset - ParameterSpaceOffset;
296+
StringRef Data;
297+
298+
size_t DataSize = 0;
299+
300+
switch (Header.ParameterType) {
301+
case dxbc::RootParameterType::Constants32Bit:
302+
DataSize = sizeof(dxbc::RootConstants);
303+
if (CorrectOffset + DataSize > ParameterSpace.size()) {
304+
// throw
305+
}
306+
Data = ParameterSpace.substr(CorrectOffset, DataSize);
307+
break;
308+
}
309+
310+
RootParameterView View = RootParameterView(Header, Data);
311+
return View;
312+
}
253313
};
254314

255315
class PSVRuntimeInfo {

‎llvm/lib/Object/DXContainer.cpp

Lines changed: 15 additions & 12 deletions
Original file line numberDiff line numberDiff line change
@@ -294,24 +294,27 @@ Error DirectX::RootSignature::parse(StringRef Data) {
294294

295295
assert(Current == Begin + RootParametersOffset);
296296

297-
Parameters.HeaderView.Data = Data.substr(
297+
ParametersHeaders.Data = Data.substr(
298298
RootParametersOffset, NumParameters * sizeof(dxbc::RootParameterHeader));
299-
Parameters.Data = Data;
300299

301-
for (auto P : params()) {
302-
if (!P)
303-
return P.takeError();
300+
ParameterSpaceOffset =
301+
RootParametersOffset + NumParameters * sizeof(dxbc::RootParameterHeader);
302+
size_t ParameterSpaceEnd =
303+
Data.size() - ((NumStaticSamplers == 0) ? 0 : StaticSamplersOffset);
304304

305-
if (!dxbc::RootSignatureVerifier::verifyParameterType(
306-
P->Header.ParameterType))
305+
ParameterSpace = Data.substr(ParameterSpaceOffset,
306+
ParameterSpaceEnd - ParameterSpaceOffset);
307+
308+
for (auto P : param_header()) {
309+
310+
if (!dxbc::RootSignatureVerifier::verifyParameterType(P.ParameterType))
307311
return validationFailed("unsupported parameter type value read: " +
308-
llvm::Twine((uint32_t)P->Header.ParameterType));
312+
llvm::Twine((uint32_t)P.ParameterType));
309313

310314
if (!dxbc::RootSignatureVerifier::verifyShaderVisibility(
311-
P->Header.ShaderVisibility))
312-
return validationFailed(
313-
"unsupported shader visility flag value read: " +
314-
llvm::Twine((uint32_t)P->Header.ShaderVisibility));
315+
P.ShaderVisibility))
316+
return validationFailed("unsupported shader visility flag value read: " +
317+
llvm::Twine((uint32_t)P.ShaderVisibility));
315318
}
316319
return Error::success();
317320
}

‎llvm/lib/ObjectYAML/DXContainerYAML.cpp

Lines changed: 16 additions & 12 deletions
Original file line numberDiff line numberDiff line change
@@ -14,6 +14,9 @@
1414
#include "llvm/ObjectYAML/DXContainerYAML.h"
1515
#include "llvm/ADT/ScopeExit.h"
1616
#include "llvm/BinaryFormat/DXContainer.h"
17+
#include "llvm/Object/DXContainer.h"
18+
#include "llvm/Support/Casting.h"
19+
#include "llvm/Support/Error.h"
1720
#include "llvm/Support/ScopedPrinter.h"
1821

1922
namespace llvm {
@@ -35,22 +38,23 @@ DXContainerYAML::RootSignatureYamlDesc::RootSignatureYamlDesc(
3538
NumStaticSamplers(Data.getNumStaticSamplers()),
3639
StaticSamplersOffset(Data.getStaticSamplersOffset()) {
3740
uint32_t Flags = Data.getFlags();
38-
for (auto P : Data.params()) {
39-
if (!P)
40-
llvm_unreachable("Parameters are validated on read.");
41+
for (const auto &PH : Data.param_header()) {
4142

4243
auto NewP = RootParameterYamlDesc();
43-
NewP.Offset = P->Header.ParameterOffset;
44-
NewP.Type = P->Header.ParameterType;
45-
NewP.Visibility = P->Header.ShaderVisibility;
44+
NewP.Offset = PH.ParameterOffset;
45+
NewP.Type = PH.ParameterType;
46+
NewP.Visibility = PH.ShaderVisibility;
4647

47-
switch (NewP.Type) {
48+
auto ParamView = Data.getParameter(PH);
4849

49-
case dxbc::RootParameterType::Constants32Bit:
50-
NewP.Constants.NumOfConstants = P->Constants.NumOfConstants;
51-
NewP.Constants.Register = P->Constants.Register;
52-
NewP.Constants.Space = P->Constants.Space;
53-
break;
50+
if (auto *RCV = dyn_cast<object::DirectX::RootConstantView>(&ParamView)) {
51+
auto Constants = RCV->read();
52+
if (!Constants)
53+
llvm::errs() << "Error: " << Constants.takeError() << "\n";
54+
55+
NewP.Constants.NumOfConstants = Constants->NumOfConstants;
56+
NewP.Constants.Register = Constants->Register;
57+
NewP.Constants.Space = Constants->Space;
5458
}
5559
Parameters.push_back(NewP);
5660
}

0 commit comments

Comments
 (0)