1//===- DXILSignatureAnalysis.cpp - Semantic signatures --------------------===//
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#include "DXILSignatureAnalysis.h"
10#include "DirectX.h"
11#include "llvm/ADT/STLExtras.h"
12#include "llvm/ADT/StringExtras.h"
13#include "llvm/Analysis/DXILMetadataAnalysis.h"
14#include "llvm/Frontend/HLSL/SemanticSignaturePacking.h"
15#include "llvm/IR/Constants.h"
16#include "llvm/IR/InstIterator.h"
17#include "llvm/IR/IntrinsicInst.h"
18#include "llvm/IR/IntrinsicsDirectX.h"
19#include "llvm/IR/Module.h"
20#include "llvm/InitializePasses.h"
21#include "llvm/MC/DXContainerPSVInfo.h"
22#include "llvm/Support/Error.h"
23#include "llvm/Support/raw_ostream.h"
24#include <array>
25#include <set>
26
27using namespace llvm;
28using namespace llvm::dxil;
29using namespace llvm::hlsl;
30
31static Error signatureError(const Twine &Message) {
32 return createStringError(EC: inconvertibleErrorCode(), S: Message);
33}
34
35static bool isSignatureAccess(const IntrinsicInst &I) {
36 return I.getIntrinsicID() == Intrinsic::dx_load_input ||
37 I.getIntrinsicID() == Intrinsic::dx_store_output;
38}
39
40// Validate widths before fromMetadata extracts integer values or narrows them.
41static Error checkElementNode(const MDNode *Node) {
42 if (!Node || Node->getNumOperands() != 13)
43 return signatureError(Message: "expected a 13-operand signature element");
44 for (unsigned I = 0; I != 13; ++I) {
45 if (I == 1 || I == 4)
46 continue;
47 auto *CI = mdconst::dyn_extract_or_null<ConstantInt>(MD: Node->getOperand(I));
48 unsigned Width = (I == 7 || (I >= 9 && I <= 11)) ? 8 : 32;
49 if (!CI || CI->getBitWidth() != Width)
50 return signatureError(Message: "expected i" + Twine(Width) + " at operand " +
51 Twine(I));
52 }
53 if (!isa_and_nonnull<MDString>(Val: Node->getOperand(I: 1)))
54 return signatureError(Message: "expected semantic name string");
55 auto *Indices = dyn_cast_or_null<MDNode>(Val: Node->getOperand(I: 4));
56 if (!Indices)
57 return signatureError(Message: "expected semantic indices node");
58 for (const MDOperand &Index : Indices->operands()) {
59 auto *CI = mdconst::dyn_extract_or_null<ConstantInt>(MD: Index);
60 if (!CI || CI->getBitWidth() != 32)
61 return signatureError(Message: "expected i32 semantic index");
62 }
63 return Error::success();
64}
65
66static bool isIntegerComponent(ElementType Type) {
67 return Type == ElementType::I1 || Type == ElementType::I16 ||
68 Type == ElementType::U16 || Type == ElementType::I32 ||
69 Type == ElementType::U32;
70}
71
72static Error diagnoseSemanticType(const SemanticSignatureElement &E) {
73 switch (E.SemanticKind) {
74 case dxbc::PSV::SemanticKind::Position:
75 if (E.Rows != 1 || E.Cols != 4 ||
76 (E.CompType != ElementType::F16 && E.CompType != ElementType::F32))
77 return signatureError(
78 Message: "SV_Position requires one row of four floating-point components");
79 break;
80 case dxbc::PSV::SemanticKind::VertexID:
81 if (E.Rows != 1 || E.Cols != 1 ||
82 (E.CompType != ElementType::I16 && E.CompType != ElementType::U16 &&
83 E.CompType != ElementType::I32 && E.CompType != ElementType::U32))
84 return signatureError(
85 Message: "SV_VertexID requires a scalar 16- or 32-bit integer");
86 break;
87 case dxbc::PSV::SemanticKind::InstanceID:
88 if (E.Rows != 1 || E.Cols != 1 ||
89 (E.CompType != ElementType::U16 && E.CompType != ElementType::U32))
90 return signatureError(
91 Message: "SV_InstanceID requires a scalar 16- or 32-bit unsigned integer");
92 break;
93 case dxbc::PSV::SemanticKind::ShadingRate:
94 if (E.Rows != 1 || E.Cols != 1 ||
95 (E.CompType != ElementType::U16 && E.CompType != ElementType::U32))
96 return signatureError(
97 Message: "SV_ShadingRate requires a scalar 16- or 32-bit unsigned integer");
98 break;
99 case dxbc::PSV::SemanticKind::SampleIndex:
100 if (E.Rows != 1 || E.Cols != 1 ||
101 (E.CompType != ElementType::U16 && E.CompType != ElementType::U32))
102 return signatureError(
103 Message: "SV_SampleIndex requires a scalar 16- or 32-bit unsigned integer");
104 break;
105 case dxbc::PSV::SemanticKind::PrimitiveID:
106 if (E.Rows != 1 || E.Cols != 1 ||
107 (E.CompType != ElementType::U16 && E.CompType != ElementType::U32))
108 return signatureError(
109 Message: "SV_PrimitiveID requires a scalar 16- or 32-bit unsigned integer");
110 break;
111 case dxbc::PSV::SemanticKind::IsFrontFace:
112 if (E.Rows != 1 || E.Cols != 1 ||
113 (E.CompType != ElementType::I32 && E.CompType != ElementType::U32))
114 return signatureError(Message: "SV_IsFrontFace requires a scalar 32-bit integer");
115 break;
116 case dxbc::PSV::SemanticKind::Barycentrics:
117 if (E.Rows != 1 || E.Cols != 3 ||
118 (E.CompType != ElementType::F16 && E.CompType != ElementType::F32))
119 return signatureError(Message: "SV_Barycentrics requires one row of three 16- or "
120 "32-bit floating-point components");
121 break;
122 default:
123 break;
124 }
125 return Error::success();
126}
127
128static Error diagnoseSemanticIndex(const SemanticSignatureElement &E) {
129 switch (E.SemanticKind) {
130 case dxbc::PSV::SemanticKind::Target:
131 if (E.Rows != 1 || E.SemanticIndices.front() >= 8)
132 return signatureError(
133 Message: "pixel targets require one row and an index within 0-7");
134 break;
135 case dxbc::PSV::SemanticKind::VertexID:
136 if (E.SemanticIndices.front() != 0)
137 return signatureError(Message: "SV_VertexID requires semantic index 0");
138 break;
139 case dxbc::PSV::SemanticKind::Barycentrics:
140 if (E.SemanticIndices.front() != 0)
141 return signatureError(Message: "SV_Barycentrics requires semantic index 0");
142 break;
143 case dxbc::PSV::SemanticKind::SampleIndex:
144 if (E.SemanticIndices.front() != 0)
145 return signatureError(Message: "SV_SampleIndex requires semantic index 0");
146 break;
147 case dxbc::PSV::SemanticKind::PrimitiveID:
148 if (E.SemanticIndices.front() != 0)
149 return signatureError(Message: "SV_PrimitiveID requires semantic index 0");
150 break;
151 case dxbc::PSV::SemanticKind::IsFrontFace:
152 if (E.SemanticIndices.front() != 0)
153 return signatureError(Message: "SV_IsFrontFace requires semantic index 0");
154 break;
155 default:
156 break;
157 }
158 return Error::success();
159}
160
161static Error
162diagnoseSemanticShaderModel(const SemanticSignatureElement &E,
163 const VersionTuple &ShaderModelVersion) {
164 switch (E.SemanticKind) {
165 case dxbc::PSV::SemanticKind::Barycentrics:
166 if (ShaderModelVersion < VersionTuple(6, 1))
167 return signatureError(Message: "SV_Barycentrics requires shader model 6.1");
168 break;
169 default:
170 break;
171 }
172 return Error::success();
173}
174
175static Error parseSignature(Metadata *MD,
176 SmallVectorImpl<SemanticSignatureElement> &Out,
177 ModuleSignatureInfo &Info,
178 Triple::EnvironmentType Stage, IOType IO,
179 const VersionTuple &ShaderModelVersion,
180 bool Native16, unsigned &Extent) {
181 if (!MD)
182 return Error::success();
183 auto *List = dyn_cast<MDNode>(Val: MD);
184 if (!List)
185 return signatureError(Message: "expected a signature element list or null");
186
187 std::set<std::pair<std::string, uint32_t>> Semantics;
188 constexpr unsigned MaxAllocatedElements = MaxSignatureRows * 4;
189 unsigned NumAllocated = 0;
190 std::array<uint8_t, MaxSignatureRows> AllocatedColumns = {};
191 std::array<dxbc::PSV::InterpolationMode, MaxSignatureRows> RowModes = {};
192 std::array<bool, MaxSignatureRows> RowNative16 = {};
193 for (const MDOperand &Op : List->operands()) {
194 auto *Node = dyn_cast_or_null<MDNode>(Val: Op);
195 if (Error Err = checkElementNode(Node))
196 return Err;
197 auto Parsed = SemanticSignatureElement::fromMetadata(Node);
198 if (!Parsed)
199 return Parsed.takeError();
200 SemanticSignatureElement E = std::move(*Parsed);
201 if (E.SigId != Out.size())
202 return signatureError(Message: "signature IDs must be dense and in list order");
203 if (Stage != Triple::Vertex && Stage != Triple::Pixel)
204 return signatureError(Message: "nonempty signatures are currently supported only "
205 "for vertex and pixel entries");
206 if (!E.Rows || E.Rows > MaxSignatureRows)
207 return signatureError(Message: "signature row count must be within 1-32");
208 if (E.SemanticName.empty() || E.SemanticName.contains(C: '\0'))
209 return signatureError(Message: "invalid semantic name");
210 if (E.CompType != ElementType::F16 && E.CompType != ElementType::F32 &&
211 !isIntegerComponent(Type: E.CompType))
212 return signatureError(Message: "unsupported signature component type");
213 if (E.GSStream != 0)
214 return signatureError(Message: "nonzero stream requires a geometry output");
215 auto NamedKind = getSemanticKind(SemanticName: E.SemanticName);
216 auto Interpretation = getInterpretationKind(SemanticKind: NamedKind, ShaderStage: Stage, IOTy: IO);
217 if (Interpretation == SemanticInterpretation::Invalid)
218 return signatureError(Message: "invalid or unsupported semantic for this stage "
219 "and signature category");
220 if (Interpretation == SemanticInterpretation::NotAllocated)
221 return signatureError(Message: "semantic accessed by a dedicated intrinsic must "
222 "not appear in an input/output signature");
223 auto ExpectedKind = Interpretation == SemanticInterpretation::Arbitrary
224 ? dxbc::PSV::SemanticKind::Arbitrary
225 : NamedKind;
226 if (E.SemanticKind != ExpectedKind)
227 return signatureError(Message: "semantic name and kind disagree at this signature "
228 "point");
229 if (Interpretation == SemanticInterpretation::NotPacked) {
230 if (E.isAllocated())
231 return signatureError(Message: E.SemanticName +
232 " must not have an allocated location");
233 } else {
234 if (!E.isAllocated())
235 return signatureError(Message: "signature element " + Twine(E.SigId) + " ('" +
236 E.SemanticName + "') has no allocated location");
237 if (E.StartRow >= MaxSignatureRows ||
238 E.Rows > MaxSignatureRows - E.StartRow || E.StartCol + E.Cols > 4)
239 return signatureError(
240 Message: "allocated signature element exceeds register bounds");
241 }
242 if (E.InterpMode == dxbc::PSV::InterpolationMode::Invalid)
243 return signatureError(Message: "invalid interpolation mode");
244
245 for (uint32_t Index : E.SemanticIndices)
246 if (!Semantics.emplace(args: E.SemanticName.upper(), args&: Index).second)
247 return signatureError(Message: "duplicate semantic name and index");
248 if (Error Err = diagnoseSemanticType(E))
249 return Err;
250 if (Error Err = diagnoseSemanticIndex(E))
251 return Err;
252 if (Error Err = diagnoseSemanticShaderModel(E, ShaderModelVersion))
253 return Err;
254 if (E.SemanticKind == dxbc::PSV::SemanticKind::Barycentrics) {
255 using Mode = dxbc::PSV::InterpolationMode;
256 if (E.InterpMode == Mode::Undefined || E.InterpMode == Mode::Constant)
257 return signatureError(Message: "SV_Barycentrics requires perspective or "
258 "noperspective interpolation");
259 }
260
261 if (Stage == Triple::Vertex && IO == IOType::In &&
262 (E.StartRow != Extent || E.StartCol != 0))
263 return signatureError(Message: "vertex inputs require stacked locations in "
264 "signature order (element " +
265 Twine(E.SigId) + ")");
266 if (Interpretation == SemanticInterpretation::Target &&
267 (E.StartRow != E.SemanticIndices.front() || E.StartCol != 0))
268 return signatureError(Message: "pixel target location must match its semantic "
269 "index at column 0");
270 if (Stage == Triple::Pixel && IO == IOType::In &&
271 isIntegerComponent(Type: E.CompType) &&
272 E.InterpMode != dxbc::PSV::InterpolationMode::Constant)
273 return signatureError(
274 Message: "integer pixel inputs require constant interpolation");
275
276 if (E.isAllocated()) {
277 if (++NumAllocated > MaxAllocatedElements)
278 return signatureError(Message: "too many signature elements");
279 // Co-packed elements must obey row constraints, even when their component
280 // masks do not overlap. Min-precision types occupy 32-bit components.
281 bool IsNative16 = Native16 && (E.CompType == ElementType::F16 ||
282 E.CompType == ElementType::I16 ||
283 E.CompType == ElementType::U16);
284 uint8_t Mask = E.getDeclaredMask();
285 for (unsigned Row = E.StartRow; Row != E.StartRow + E.Rows; ++Row) {
286 if (AllocatedColumns[Row] & Mask)
287 return signatureError(Message: "signature elements overlap at row " +
288 Twine(Row) + " (element " + Twine(E.SigId) +
289 ")");
290 if (AllocatedColumns[Row] && RowModes[Row] != E.InterpMode)
291 return signatureError(
292 Message: "signature elements have different interpolation "
293 "modes at row " +
294 Twine(Row) + " (element " + Twine(E.SigId) + ")");
295 if (AllocatedColumns[Row] && RowNative16[Row] != IsNative16)
296 return signatureError(Message: "signature elements have different component "
297 "widths at row " +
298 Twine(Row) + " (element " + Twine(E.SigId) +
299 ")");
300 AllocatedColumns[Row] |= Mask;
301 RowModes[Row] = E.InterpMode;
302 RowNative16[Row] = IsNative16;
303 }
304 Extent = std::max(a: Extent, b: E.StartRow + E.Rows);
305 }
306 E.SemanticName = Info.Names.insert(key: E.SemanticName).first->getKey();
307
308 // Access masks will be recomputed so reset to 0 here.
309 E.UsageMask = 0;
310 E.DynIndexMask = 0;
311 Out.push_back(Elt: std::move(E));
312 }
313 return Error::success();
314}
315
316static Error analyzeAccess(const IntrinsicInst &I, EntrySignature &Sig) {
317 bool Input = I.getIntrinsicID() == Intrinsic::dx_load_input;
318 auto &Elements = Input ? Sig.Inputs : Sig.Outputs;
319 auto *ID = dyn_cast<ConstantInt>(Val: I.getArgOperand(i: 0));
320 auto *Col = dyn_cast<ConstantInt>(Val: I.getArgOperand(i: 2));
321 StringRef Category = Input ? "input" : "output";
322 assert(ID && "signature ID is marked as ImmArg and must be constant");
323 if (ID->getZExtValue() >= Elements.size())
324 return signatureError(Message: Category +
325 " signature: signature access has an invalid element "
326 "ID " +
327 Twine(ID->getZExtValue()));
328 auto &E = Elements[ID->getZExtValue()];
329 auto AccessError = [&](const Twine &Message) {
330 return signatureError(Message: Category + " signature element " + Twine(E.SigId) +
331 " ('" + E.SemanticName + "'): " + Message);
332 };
333 if (E.SemanticKind == dxbc::PSV::SemanticKind::SampleIndex)
334 return AccessError("must not be read with dx.op.load/store");
335 Type *Ty = Input ? I.getType() : I.getArgOperand(i: 3)->getType();
336 unsigned Width = 1;
337 if (auto *VT = dyn_cast<FixedVectorType>(Val: Ty)) {
338 Width = VT->getNumElements();
339 Ty = VT->getElementType();
340 }
341 if (!Col || Col->getZExtValue() >= E.Cols ||
342 Width > E.Cols - Col->getZExtValue())
343 return AccessError("signature access has an invalid component index");
344 auto *Row = dyn_cast<ConstantInt>(Val: I.getArgOperand(i: 1));
345 if (Row && Row->getZExtValue() >= E.Rows)
346 return AccessError("signature access has an invalid row index");
347 if (!Row && E.Rows == 1)
348 return AccessError(
349 "dynamic indexing requires a multi-row signature element");
350 bool CorrectType = false;
351 switch (E.CompType) {
352 case ElementType::F16:
353 CorrectType = Ty->isHalfTy();
354 break;
355 case ElementType::F32:
356 CorrectType = Ty->isFloatTy();
357 break;
358 case ElementType::I16:
359 case ElementType::U16:
360 CorrectType = Ty->isIntegerTy(BitWidth: 16);
361 break;
362 case ElementType::I1:
363 // Boolean signature elements use the i32 load/store overload.
364 CorrectType = Ty->isIntegerTy(BitWidth: 32);
365 break;
366 case ElementType::I32:
367 case ElementType::U32:
368 CorrectType = Ty->isIntegerTy(BitWidth: 32);
369 break;
370 default:
371 llvm_unreachable("invalid signature component type");
372 }
373 if (!CorrectType)
374 return AccessError("signature access type disagrees with its element");
375 uint8_t Mask = ((1U << Width) - 1) << Col->getZExtValue();
376 E.UsageMask |= Mask << E.getStartColOrZero();
377 if (!Row)
378 E.DynIndexMask |= Mask;
379 return Error::success();
380}
381
382static void buildDependencyMap(EntrySignature &Sig) {
383 // Each output vector needs four component bits, so one 32-bit word holds
384 // eight vectors. Adding seven rounds up to include a partially filled word.
385 unsigned Words = (Sig.OutputVectors + 7) / 8;
386 Sig.InputOutputMap.assign(NumElts: Sig.InputVectors * 4 * Words, Elt: 0);
387 // Conservatively connect every accessed input component to every written
388 // output component. This includes control, memory, call, and dynamic-index
389 // dependencies without incorrectly claiming that unknown dependencies are
390 // absent. Unused components and padding remain zero. Both DXIL and PSV use
391 // this same map; a more precise dependency analysis can refine it later.
392 for (const auto &Input : Sig.Inputs) {
393 if (!Input.isAllocated())
394 continue;
395 for (unsigned IR = 0; IR != Input.Rows; ++IR)
396 for (unsigned IC = 0; IC != 4; ++IC) {
397 if (!(Input.UsageMask & (1U << IC)))
398 continue;
399 unsigned Base = ((Input.StartRow + IR) * 4 + IC) * Words;
400 for (const auto &Output : Sig.Outputs)
401 for (unsigned OR = 0; OR != Output.Rows; ++OR)
402 for (unsigned OC = 0; OC != 4; ++OC) {
403 if (!(Output.UsageMask & (1U << OC)))
404 continue;
405 unsigned Bit = (Output.StartRow + OR) * 4 + OC;
406 Sig.InputOutputMap[Base + Bit / 32] |= 1U << (Bit % 32);
407 }
408 }
409 }
410}
411
412static Expected<ModuleSignatureInfo>
413analyzeModule(Module &M, const ModuleMetadataInfo &MMI) {
414 ModuleSignatureInfo Info;
415 if (NamedMDNode *Table = M.getNamedMetadata(Name: "dx.semantic.signatures")) {
416 for (const MDNode *Record : Table->operands()) {
417 if (Record->getNumOperands() != 3)
418 return signatureError(
419 Message: "expected an entry/input/output signature triple");
420 auto *VAM = dyn_cast_or_null<ValueAsMetadata>(Val: Record->getOperand(I: 0));
421 auto *F = VAM ? dyn_cast<Function>(Val: VAM->getValue()) : nullptr;
422 if (!F || F->getParent() != &M || F->isDeclaration())
423 return signatureError(
424 Message: "signature entry must be a defined function in the module");
425 auto EP =
426 llvm::find_if(Range: MMI.EntryPropertyVec,
427 P: [F](const EntryProperties &E) { return E.Entry == F; });
428 if (EP == MMI.EntryPropertyVec.end())
429 return signatureError(Message: "signature function is not a shader entry");
430 if (Info.Entries.contains(Val: F))
431 return signatureError(Message: "duplicate signature record for entry '" +
432 F->getName() + "'");
433 EntrySignature Sig;
434 Sig.Stage = EP->ShaderStage;
435 if (auto *Native = mdconst::dyn_extract_or_null<ConstantInt>(
436 MD: M.getModuleFlag(Key: "dx.nativelowprec")))
437 Sig.UseNative16Bit = !Native->isZero();
438 if (Sig.UseNative16Bit && MMI.ShaderModelVersion < VersionTuple(6, 2))
439 return signatureError(
440 Message: "native 16-bit signatures require shader model 6.2");
441 auto AddContext = [&](Error Err, StringRef Category) -> Error {
442 return signatureError(Message: "entry '" + F->getName() + "' " + Category +
443 " signature: " + toString(E: std::move(Err)));
444 };
445 if (Error Err = parseSignature(
446 MD: Record->getOperand(I: 1), Out&: Sig.Inputs, Info, Stage: Sig.Stage, IO: IOType::In,
447 ShaderModelVersion: MMI.ShaderModelVersion, Native16: Sig.UseNative16Bit, Extent&: Sig.InputVectors))
448 return AddContext(std::move(Err), "input");
449 if (Error Err = parseSignature(
450 MD: Record->getOperand(I: 2), Out&: Sig.Outputs, Info, Stage: Sig.Stage, IO: IOType::Out,
451 ShaderModelVersion: MMI.ShaderModelVersion, Native16: Sig.UseNative16Bit, Extent&: Sig.OutputVectors))
452 return AddContext(std::move(Err), "output");
453 for (const Instruction &I : instructions(F))
454 if (auto *II = dyn_cast<IntrinsicInst>(Val: &I);
455 II && isSignatureAccess(I: *II))
456 if (Error Err = analyzeAccess(I: *II, Sig))
457 return signatureError(Message: "entry '" + F->getName() +
458 "': " + toString(E: std::move(Err)));
459 buildDependencyMap(Sig);
460 Info.Entries.try_emplace(Key: F, Args: std::move(Sig));
461 }
462 }
463 // Signature IDs are local to an entry. Do not guess which entry a helper's
464 // accesses belong to, even if that helper happens to have a single caller.
465 for (const Function &F : M)
466 if (!Info.Entries.contains(Val: &F))
467 for (const Instruction &I : instructions(F))
468 if (auto *II = dyn_cast<IntrinsicInst>(Val: &I);
469 II && isSignatureAccess(I: *II))
470 return signatureError(Message: "signature access in function '" + F.getName() +
471 "' has no entry signature metadata");
472 return std::move(Info);
473}
474
475static ModuleSignatureInfo collectSignatures(Module &M,
476 const ModuleMetadataInfo &MMI) {
477 auto Result = analyzeModule(M, MMI);
478 if (!Result) {
479 M.getContext().emitError(ErrorStr: "Invalid semantic signature: " +
480 toString(E: Result.takeError()));
481 return ModuleSignatureInfo();
482 }
483 return std::move(*Result);
484}
485
486static MDNode *emitSignature(LLVMContext &Ctx,
487 ArrayRef<SemanticSignatureElement> Elements,
488 VersionTuple ValidatorVersion) {
489 if (Elements.empty())
490 return nullptr;
491 auto I32 = [&](uint32_t V) {
492 return ConstantAsMetadata::get(C: ConstantInt::get(Ty: Type::getInt32Ty(C&: Ctx), V));
493 };
494 auto I8 = [&](uint8_t V) {
495 return ConstantAsMetadata::get(C: ConstantInt::get(Ty: Type::getInt8Ty(C&: Ctx), V));
496 };
497 SmallVector<Metadata *> Nodes;
498 for (const auto &E : Elements) {
499 SmallVector<Metadata *> Indices, Props;
500 for (uint32_t Index : E.SemanticIndices)
501 Indices.push_back(Elt: I32(Index));
502 if (E.GSStream)
503 Props.append(IL: {I32(0), I32(E.GSStream)});
504 if (E.DynIndexMask)
505 Props.append(IL: {I32(2), I32(E.DynIndexMask)});
506 if (E.UsageMask &&
507 (ValidatorVersion.empty() || ValidatorVersion == VersionTuple(0, 0) ||
508 ValidatorVersion >= VersionTuple(1, 5)))
509 Props.append(IL: {I32(3), I32(E.UsageMask >> E.getStartColOrZero())});
510 Nodes.push_back(Elt: MDNode::get(
511 Context&: Ctx, MDs: {I32(E.SigId), MDString::get(Context&: Ctx, Str: E.SemanticName),
512 I8(static_cast<uint8_t>(E.CompType)),
513 I8(static_cast<uint8_t>(E.SemanticKind)),
514 MDNode::get(Context&: Ctx, MDs: Indices), I8(static_cast<uint8_t>(E.InterpMode)),
515 I32(E.Rows), I8(E.Cols), I32(E.StartRow), I8(E.StartCol),
516 Props.empty() ? nullptr : MDNode::get(Context&: Ctx, MDs: Props)}));
517 }
518 return MDNode::get(Context&: Ctx, MDs: Nodes);
519}
520
521static dxbc::SigComponentType getComponentType(ElementType Type, bool Legacy) {
522 switch (Type) {
523 case ElementType::I1:
524 return Legacy ? dxbc::SigComponentType::Unknown
525 : dxbc::SigComponentType::UInt32;
526 case ElementType::I16:
527 return dxbc::SigComponentType::SInt16;
528 case ElementType::U16:
529 return dxbc::SigComponentType::UInt16;
530 case ElementType::I32:
531 return dxbc::SigComponentType::SInt32;
532 case ElementType::U32:
533 return dxbc::SigComponentType::UInt32;
534 case ElementType::F16:
535 return dxbc::SigComponentType::Float16;
536 case ElementType::F32:
537 return dxbc::SigComponentType::Float32;
538 default:
539 llvm_unreachable("invalid signature component type");
540 }
541}
542
543static dxbc::D3DSystemValue getSystemValue(dxbc::PSV::SemanticKind Kind) {
544 using KindTy = dxbc::PSV::SemanticKind;
545 switch (Kind) {
546 case KindTy::Arbitrary:
547 return dxbc::D3DSystemValue::Undefined;
548 case KindTy::VertexID:
549 return dxbc::D3DSystemValue::VertexID;
550 case KindTy::InstanceID:
551 return dxbc::D3DSystemValue::InstanceID;
552 case KindTy::Position:
553 return dxbc::D3DSystemValue::Position;
554 case KindTy::IsFrontFace:
555 return dxbc::D3DSystemValue::IsFrontFace;
556 case KindTy::ClipDistance:
557 return dxbc::D3DSystemValue::ClipDistance;
558 case KindTy::CullDistance:
559 return dxbc::D3DSystemValue::CullDistance;
560 case KindTy::Target:
561 return dxbc::D3DSystemValue::Target;
562 case KindTy::ShadingRate:
563 return dxbc::D3DSystemValue::ShadingRate;
564 case KindTy::Barycentrics:
565 return dxbc::D3DSystemValue::Barycentrics;
566 case KindTy::SampleIndex:
567 return dxbc::D3DSystemValue::SampleIndex;
568 case KindTy::PrimitiveID:
569 return dxbc::D3DSystemValue::PrimitiveID;
570 default:
571 llvm_unreachable("validated vertex/pixel signature semantic");
572 }
573}
574
575// The DXIL reader normalizes system-value semantic names when loading module
576// metadata. The validator then recreates ISG1/OSG1 from those normalized names
577// and compares the parts byte-for-byte, so the container must use the same
578// spelling even if HLSL (or the source metadata) used a different casing.
579static StringRef getContainerSemanticName(const SemanticSignatureElement &E) {
580 using Kind = dxbc::PSV::SemanticKind;
581 switch (E.SemanticKind) {
582 case Kind::Arbitrary:
583 return E.SemanticName;
584 case Kind::VertexID:
585 return "SV_VertexID";
586 case Kind::InstanceID:
587 return "SV_InstanceID";
588 case Kind::Position:
589 return "SV_Position";
590 case Kind::IsFrontFace:
591 return "SV_IsFrontFace";
592 case Kind::ClipDistance:
593 return "SV_ClipDistance";
594 case Kind::CullDistance:
595 return "SV_CullDistance";
596 case Kind::Target:
597 return "SV_Target";
598 case Kind::ShadingRate:
599 return "SV_ShadingRate";
600 case Kind::Barycentrics:
601 return "SV_Barycentrics";
602 case Kind::SampleIndex:
603 return "SV_SampleIndex";
604 case Kind::PrimitiveID:
605 return "SV_PrimitiveID";
606 default:
607 llvm_unreachable("validated vertex/pixel signature semantic");
608 }
609}
610
611static void buildSignature(mcdxbc::Signature &Sig,
612 ArrayRef<SemanticSignatureElement> Elements,
613 bool Input, bool Native16, bool Legacy) {
614 for (const auto &E : Elements) {
615 uint8_t Mask = E.getDeclaredMask();
616 uint8_t ExclusiveMask =
617 Input ? E.getAlwaysReadsMask() : E.getNeverWritesMask();
618 if (Legacy)
619 ExclusiveMask = Input ? 0 : static_cast<uint8_t>(~Mask);
620 for (auto [Row, Index] : enumerate(First: E.SemanticIndices))
621 Sig.addParam(Stream: E.GSStream, Name: getContainerSemanticName(E), Index,
622 SystemValue: getSystemValue(Kind: E.SemanticKind),
623 CompType: getComponentType(Type: E.CompType, Legacy),
624 Register: E.isAllocated() ? E.StartRow + Row : UnallocatedRow, Mask,
625 ExclusiveMask, MinPrecision: E.getMinPrecision(UseMinPrecision: !Native16));
626 }
627}
628
629static void buildPSVElements(SmallVectorImpl<mcdxbc::PSVSignatureElement> &Dest,
630 ArrayRef<SemanticSignatureElement> Elements,
631 bool Legacy) {
632 for (const auto &E : Elements) {
633 auto Type = getComponentType(Type: E.CompType, Legacy);
634 // SigComponentType and PSV ComponentType share COMPONENT_TYPE definitions.
635 Dest.push_back(
636 Elt: {.Name: E.SemanticKind == dxbc::PSV::SemanticKind::Arbitrary ? E.SemanticName
637 : StringRef(),
638 .Indices: E.SemanticIndices,
639 .StartRow: E.isAllocated() ? static_cast<uint8_t>(E.StartRow) : uint8_t(0),
640 .Cols: E.Cols, .StartCol: E.getStartColOrZero(), .Allocated: E.isAllocated(), .Kind: E.SemanticKind,
641 .Type: static_cast<dxbc::PSV::ComponentType>(Type), .Mode: E.InterpMode,
642 .DynamicMask: E.DynIndexMask, .Stream: static_cast<uint8_t>(E.GSStream)});
643 }
644}
645
646MDTuple *EntrySignature::getAsMetadata(LLVMContext &Ctx,
647 VersionTuple ValidatorVersion) const {
648 if (Inputs.empty() && Outputs.empty())
649 return nullptr;
650 return MDNode::get(Context&: Ctx,
651 MDs: {emitSignature(Ctx, Elements: Inputs, ValidatorVersion),
652 emitSignature(Ctx, Elements: Outputs, ValidatorVersion), nullptr});
653}
654
655void EntrySignature::buildSignatures(mcdxbc::Signature &Input,
656 mcdxbc::Signature &Output,
657 VersionTuple ValidatorVersion) const {
658 bool Legacy = !ValidatorVersion.empty() &&
659 ValidatorVersion != VersionTuple(0, 0) &&
660 ValidatorVersion < VersionTuple(1, 5);
661 buildSignature(Sig&: Input, Elements: Inputs, Input: true, Native16: UseNative16Bit, Legacy);
662 buildSignature(Sig&: Output, Elements: Outputs, Input: false, Native16: UseNative16Bit, Legacy);
663}
664
665SmallVector<uint32_t> EntrySignature::getViewIDOutputMask() const {
666 // Each output vector needs four component bits, so one 32-bit word holds
667 // eight vectors. Conservatively mark every written output component as
668 // dependent on the view ID, matching the conservative input/output map.
669 SmallVector<uint32_t> Mask((OutputVectors + 7) / 8, 0);
670 for (const auto &Output : Outputs) {
671 if (!Output.isAllocated())
672 continue;
673 for (unsigned R = 0; R != Output.Rows; ++R)
674 for (unsigned C = 0; C != 4; ++C) {
675 if (!(Output.UsageMask & (1U << C)))
676 continue;
677 unsigned Bit = (Output.StartRow + R) * 4 + C;
678 Mask[Bit / 32] |= 1U << (Bit % 32);
679 }
680 }
681 return Mask;
682}
683
684void EntrySignature::updatePSV(mcdxbc::PSVRuntimeInfo &PSV,
685 VersionTuple ValidatorVersion,
686 bool UsesViewID) const {
687 bool Legacy = !ValidatorVersion.empty() &&
688 ValidatorVersion != VersionTuple(0, 0) &&
689 ValidatorVersion < VersionTuple(1, 5);
690 buildPSVElements(Dest&: PSV.InputElements, Elements: Inputs, Legacy);
691 buildPSVElements(Dest&: PSV.OutputElements, Elements: Outputs, Legacy);
692 PSV.BaseData.SigInputVectors = InputVectors;
693 PSV.BaseData.SigOutputVectors[0] = OutputVectors;
694 PSV.InputOutputMap[0] = InputOutputMap;
695 if (UsesViewID)
696 PSV.OutputVectorMasks[0] = getViewIDOutputMask();
697 if (Stage == Triple::Vertex)
698 PSV.BaseData.StageInfo.VS.OutputPositionPresent =
699 llvm::any_of(Range: Outputs, P: [](const auto &E) {
700 return E.SemanticKind == dxbc::PSV::SemanticKind::Position;
701 });
702 if (Stage == Triple::Pixel)
703 PSV.BaseData.StageInfo.PS.SampleFrequency =
704 llvm::any_of(Range: Inputs, P: [](const auto &E) {
705 return E.InterpMode == dxbc::PSV::InterpolationMode::LinearSample ||
706 E.InterpMode ==
707 dxbc::PSV::InterpolationMode::LinearNoperspectiveSample ||
708 E.SemanticKind == dxbc::PSV::SemanticKind::SampleIndex;
709 });
710}
711
712SmallVector<uint32_t>
713EntrySignature::getDependencyState(bool UsesViewID) const {
714 SmallVector<uint32_t> State = {InputVectors * 4, OutputVectors * 4};
715 if (UsesViewID)
716 llvm::append_range(C&: State, R: getViewIDOutputMask());
717 llvm::append_range(C&: State, R: InputOutputMap);
718 return State;
719}
720
721void EntrySignature::print(raw_ostream &OS) const {
722 auto Print = [&](StringRef Name, ArrayRef<SemanticSignatureElement> Elements,
723 unsigned Vectors) {
724 OS << " " << Name << ": " << Elements.size() << " elements, " << Vectors
725 << " vectors\n";
726 for (const auto &E : Elements)
727 OS << " " << E.SigId << ": " << E.SemanticName << " rows=" << E.Rows
728 << " cols=" << unsigned(E.Cols) << " at " << E.StartRow << ":"
729 << unsigned(E.StartCol) << " usage=" << unsigned(E.UsageMask)
730 << " dynamic=" << unsigned(E.DynIndexMask) << '\n';
731 };
732 Print("Inputs", Inputs, InputVectors);
733 Print("Outputs", Outputs, OutputVectors);
734}
735
736void ModuleSignatureInfo::print(raw_ostream &OS, const Module &M) const {
737 for (const Function &F : M)
738 if (const auto *Sig = get(F: &F)) {
739 OS << "Semantic signatures for '" << F.getName() << "':\n";
740 Sig->print(OS);
741 }
742}
743
744AnalysisKey SignatureAnalysis::Key;
745ModuleSignatureInfo SignatureAnalysis::run(Module &M,
746 ModuleAnalysisManager &AM) {
747 return collectSignatures(M, MMI: AM.getResult<DXILMetadataAnalysis>(IR&: M));
748}
749
750PreservedAnalyses SignatureAnalysisPrinterPass::run(Module &M,
751 ModuleAnalysisManager &AM) {
752 AM.getResult<SignatureAnalysis>(IR&: M).print(OS, M);
753 return PreservedAnalyses::all();
754}
755
756bool SignatureAnalysisWrapper::runOnModule(Module &M) {
757 Info = std::make_unique<ModuleSignatureInfo>(args: collectSignatures(
758 M, MMI: getAnalysis<DXILMetadataAnalysisWrapperPass>().getModuleMetadata()));
759 return false;
760}
761
762void SignatureAnalysisWrapper::getAnalysisUsage(AnalysisUsage &AU) const {
763 AU.setPreservesAll();
764 AU.addRequired<DXILMetadataAnalysisWrapperPass>();
765}
766
767void SignatureAnalysisWrapper::print(raw_ostream &OS, const Module *M) const {
768 if (Info)
769 Info->print(OS, M: *M);
770}
771
772char SignatureAnalysisWrapper::ID;
773INITIALIZE_PASS_BEGIN(SignatureAnalysisWrapper, "dxil-signature-analysis",
774 "DXIL Semantic Signature Analysis", false, true)
775INITIALIZE_PASS_DEPENDENCY(DXILMetadataAnalysisWrapperPass)
776INITIALIZE_PASS_END(SignatureAnalysisWrapper, "dxil-signature-analysis",
777 "DXIL Semantic Signature Analysis", false, true)
778