1//===- llvm/MC/DXContainerPSVInfo.cpp - DXContainer PSVInfo -----*- C++ -*-===//
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 "llvm/MC/DXContainerPSVInfo.h"
10#include "llvm/BinaryFormat/DXContainer.h"
11#include "llvm/MC/StringTableBuilder.h"
12#include "llvm/Support/EndianStream.h"
13#include "llvm/Support/raw_ostream.h"
14
15using namespace llvm;
16using namespace llvm::mcdxbc;
17using namespace llvm::dxbc::PSV;
18
19static constexpr size_t npos = StringRef::npos;
20
21static size_t FindSequence(ArrayRef<uint32_t> Buffer,
22 ArrayRef<uint32_t> Sequence) {
23 if (Buffer.size() < Sequence.size())
24 return npos;
25 for (size_t Idx = 0; Idx <= Buffer.size() - Sequence.size(); ++Idx) {
26 if (0 == memcmp(s1: static_cast<const void *>(&Buffer[Idx]),
27 s2: static_cast<const void *>(Sequence.begin()),
28 n: Sequence.size() * sizeof(uint32_t)))
29 return Idx;
30 }
31 return npos;
32}
33
34static void
35ProcessElementList(StringTableBuilder &StrTabBuilder,
36 SmallVectorImpl<uint32_t> &IndexBuffer,
37 SmallVectorImpl<v0::SignatureElement> &FinalElements,
38 SmallVectorImpl<StringRef> &SemanticNames,
39 ArrayRef<PSVSignatureElement> Elements) {
40 for (const auto &El : Elements) {
41 // Put the name in the string table and the name list.
42 StrTabBuilder.add(S: El.Name);
43 SemanticNames.push_back(Elt: El.Name);
44
45 v0::SignatureElement FinalElement;
46 memset(s: &FinalElement, c: 0, n: sizeof(v0::SignatureElement));
47 FinalElement.Rows = static_cast<uint8_t>(El.Indices.size());
48 FinalElement.StartRow = El.StartRow;
49 FinalElement.Cols = El.Cols;
50 FinalElement.StartCol = El.StartCol;
51 FinalElement.Allocated = El.Allocated;
52 FinalElement.Kind = El.Kind;
53 FinalElement.Type = El.Type;
54 FinalElement.Mode = El.Mode;
55 FinalElement.DynamicMask = El.DynamicMask;
56 FinalElement.Stream = El.Stream;
57
58 size_t Idx = FindSequence(Buffer: IndexBuffer, Sequence: El.Indices);
59 if (Idx == npos) {
60 FinalElement.IndicesOffset = static_cast<uint32_t>(IndexBuffer.size());
61 IndexBuffer.insert(I: IndexBuffer.end(), From: El.Indices.begin(),
62 To: El.Indices.end());
63 } else
64 FinalElement.IndicesOffset = static_cast<uint32_t>(Idx);
65 FinalElements.push_back(Elt: FinalElement);
66 }
67}
68
69void PSVRuntimeInfo::write(raw_ostream &OS, uint32_t Version) const {
70 assert(IsFinalized && "finalize must be called before write");
71
72 uint32_t InfoSize;
73 uint32_t BindingSize;
74 switch (Version) {
75 case 0:
76 InfoSize = sizeof(dxbc::PSV::v0::RuntimeInfo);
77 BindingSize = sizeof(dxbc::PSV::v0::ResourceBindInfo);
78 break;
79 case 1:
80 InfoSize = sizeof(dxbc::PSV::v1::RuntimeInfo);
81 BindingSize = sizeof(dxbc::PSV::v0::ResourceBindInfo);
82 break;
83 case 2:
84 default:
85 InfoSize = sizeof(dxbc::PSV::v2::RuntimeInfo);
86 BindingSize = sizeof(dxbc::PSV::v2::ResourceBindInfo);
87 }
88 // Write the size of the info.
89
90 support::endian::write(os&: OS, value: InfoSize, endian: llvm::endianness::little);
91 // Write the info itself.
92 OS.write(Ptr: reinterpret_cast<const char *>(&BaseData), Size: InfoSize);
93
94 uint32_t ResourceCount = static_cast<uint32_t>(Resources.size());
95
96 support::endian::write(os&: OS, value: ResourceCount, endian: llvm::endianness::little);
97 if (ResourceCount > 0)
98 support::endian::write(os&: OS, value: BindingSize, endian: llvm::endianness::little);
99
100 for (const auto &Res : Resources)
101 OS.write(Ptr: reinterpret_cast<const char *>(&Res), Size: BindingSize);
102
103 // PSV Version 0 stops after the resource list.
104 if (Version == 0)
105 return;
106
107 StringTableBuilder StrTabBuilder((StringTableBuilder::DXContainer));
108 SmallVector<uint32_t, 64> IndexBuffer;
109 SmallVector<v0::SignatureElement, 32> SignatureElements;
110 SmallVector<StringRef, 32> SemanticNames;
111
112 ProcessElementList(StrTabBuilder, IndexBuffer, FinalElements&: SignatureElements,
113 SemanticNames, Elements: InputElements);
114 ProcessElementList(StrTabBuilder, IndexBuffer, FinalElements&: SignatureElements,
115 SemanticNames, Elements: OutputElements);
116 ProcessElementList(StrTabBuilder, IndexBuffer, FinalElements&: SignatureElements,
117 SemanticNames, Elements: PatchOrPrimElements);
118
119 StrTabBuilder.finalize();
120 for (auto ElAndName : zip(t&: SignatureElements, u&: SemanticNames)) {
121 v0::SignatureElement &El = std::get<0>(t&: ElAndName);
122 StringRef Name = std::get<1>(t&: ElAndName);
123 El.NameOffset = static_cast<uint32_t>(StrTabBuilder.getOffset(S: Name));
124 if (sys::IsBigEndianHost)
125 El.swapBytes();
126 }
127
128 support::endian::write(os&: OS, value: static_cast<uint32_t>(StrTabBuilder.getSize()),
129 endian: llvm::endianness::little);
130
131 // Write the string table.
132 StrTabBuilder.write(OS);
133
134 // Write the index table size, then table.
135 support::endian::write(os&: OS, value: static_cast<uint32_t>(IndexBuffer.size()),
136 endian: llvm::endianness::little);
137 for (auto I : IndexBuffer)
138 support::endian::write(os&: OS, value: I, endian: llvm::endianness::little);
139
140 if (SignatureElements.size() > 0) {
141 // write the size of the signature elements.
142 support::endian::write(os&: OS,
143 value: static_cast<uint32_t>(sizeof(v0::SignatureElement)),
144 endian: llvm::endianness::little);
145
146 // write the signature elements.
147 OS.write(Ptr: reinterpret_cast<const char *>(&SignatureElements[0]),
148 Size: SignatureElements.size() * sizeof(v0::SignatureElement));
149 }
150
151 for (const auto &MaskVector : OutputVectorMasks)
152 support::endian::write_array(os&: OS, values: ArrayRef<uint32_t>(MaskVector),
153 endian: llvm::endianness::little);
154 support::endian::write_array(os&: OS, values: ArrayRef<uint32_t>(PatchOrPrimMasks),
155 endian: llvm::endianness::little);
156 for (const auto &MaskVector : InputOutputMap)
157 support::endian::write_array(os&: OS, values: ArrayRef<uint32_t>(MaskVector),
158 endian: llvm::endianness::little);
159 support::endian::write_array(os&: OS, values: ArrayRef<uint32_t>(InputPatchMap),
160 endian: llvm::endianness::little);
161 support::endian::write_array(os&: OS, values: ArrayRef<uint32_t>(PatchOutputMap),
162 endian: llvm::endianness::little);
163}
164
165void Signature::write(raw_ostream &OS) {
166 SmallVector<dxbc::ProgramSignatureElement> SigParams;
167 SigParams.reserve(N: Params.size());
168 StringTableBuilder StrTabBuilder((StringTableBuilder::DWARF));
169
170 // Name offsets are from the start of the part. Pre-calculate the offset to
171 // the start of the string table so that it can be added to the table offset.
172 uint32_t TableStart = sizeof(dxbc::ProgramSignatureHeader) +
173 (sizeof(dxbc::ProgramSignatureElement) * Params.size());
174
175 for (const auto &P : Params) {
176 // zero out the data
177 dxbc::ProgramSignatureElement FinalElement;
178 memset(s: &FinalElement, c: 0, n: sizeof(dxbc::ProgramSignatureElement));
179 FinalElement.Stream = P.Stream;
180 FinalElement.NameOffset =
181 static_cast<uint32_t>(StrTabBuilder.add(S: P.Name)) + TableStart;
182 FinalElement.Index = P.Index;
183 FinalElement.SystemValue = P.SystemValue;
184 FinalElement.CompType = P.CompType;
185 FinalElement.Register = P.Register;
186 FinalElement.Mask = P.Mask;
187 FinalElement.ExclusiveMask = P.ExclusiveMask;
188 FinalElement.MinPrecision = P.MinPrecision;
189 SigParams.push_back(Elt: FinalElement);
190 }
191
192 StrTabBuilder.finalizeInOrder();
193 stable_sort(Range&: SigParams, C: [&](const dxbc::ProgramSignatureElement &L,
194 const dxbc::ProgramSignatureElement R) {
195 return std::tie(args: L.Stream, args: L.Register, args: L.NameOffset) <
196 std::tie(args: R.Stream, args: R.Register, args: R.NameOffset);
197 });
198 if (sys::IsBigEndianHost)
199 for (auto &El : SigParams)
200 El.swapBytes();
201
202 dxbc::ProgramSignatureHeader Header = {.ParamCount: static_cast<uint32_t>(Params.size()),
203 .FirstParamOffset: sizeof(dxbc::ProgramSignatureHeader)};
204 if (sys::IsBigEndianHost)
205 Header.swapBytes();
206 OS.write(Ptr: reinterpret_cast<const char *>(&Header),
207 Size: sizeof(dxbc::ProgramSignatureHeader));
208 OS.write(Ptr: reinterpret_cast<const char *>(SigParams.data()),
209 Size: sizeof(dxbc::ProgramSignatureElement) * SigParams.size());
210 StrTabBuilder.write(OS);
211}
212

source code of llvm/lib/MC/DXContainerPSVInfo.cpp