1 // GENERATED FILE - DO NOT EDIT.
2 // Generated by gen_spirv_builder_and_parser.py using data from spirv.core.grammar.json.
3 //
4 // Copyright 2021 The ANGLE Project Authors. All rights reserved.
5 // Use of this source code is governed by a BSD-style license that can be
6 // found in the LICENSE file.
7 //
8 // spirv_instruction_builder_autogen.cpp:
9 // Functions to generate SPIR-V binary for each instruction.
10
11 #include "spirv_instruction_builder_autogen.h"
12
13 #include <string.h>
14
15 #include "common/debug.h"
16
17 namespace angle
18 {
19 namespace spirv
20 {
21 namespace
22 {
MakeLengthOp(size_t length,spv::Op op)23 uint32_t MakeLengthOp(size_t length, spv::Op op)
24 {
25 ASSERT(length <= 0xFFFFu);
26 ASSERT(op <= 0xFFFFu);
27
28 // It's easy for a complex shader to be crafted to hit the length limit,
29 // turn that into a crash instead of a security bug. Ideally, the compiler
30 // would gracefully fail compilation, so this is more of a safety net.
31 if (ANGLE_UNLIKELY(length > 0xFFFFu))
32 {
33 ERR() << "Complex shader not representible in SPIR-V";
34 ANGLE_CRASH();
35 }
36
37 return static_cast<uint32_t>(length) << 16 | op;
38 }
39 } // anonymous namespace
40
WriteSpirvHeader(std::vector<uint32_t> * blob,uint32_t version,uint32_t idCount)41 void WriteSpirvHeader(std::vector<uint32_t> *blob, uint32_t version, uint32_t idCount)
42 {
43 // Header:
44 //
45 // - Magic number
46 // - Version (1.X)
47 // - ANGLE's Generator number:
48 // * 24 for tool id (higher 16 bits)
49 // * 1 for tool version (lower 16 bits))
50 // - Bound (idCount)
51 // - 0 (reserved)
52 constexpr uint32_t kANGLEGeneratorId = 24;
53 constexpr uint32_t kANGLEGeneratorVersion = 1;
54
55 ASSERT(blob->empty());
56
57 blob->push_back(spv::MagicNumber);
58 blob->push_back(version);
59 blob->push_back(kANGLEGeneratorId << 16 | kANGLEGeneratorVersion);
60 blob->push_back(idCount);
61 blob->push_back(0x00000000);
62 }
63
WriteNop(Blob * blob)64 void WriteNop(Blob *blob)
65 {
66 const size_t startSize = blob->size();
67 blob->push_back(0);
68
69 (*blob)[startSize] = MakeLengthOp(blob->size() - startSize, spv::OpNop);
70 }
WriteUndef(Blob * blob,IdResultType idResultType1,IdResult idResult2)71 void WriteUndef(Blob *blob, IdResultType idResultType1, IdResult idResult2)
72 {
73 const size_t startSize = blob->size();
74 blob->push_back(0);
75 blob->push_back(idResultType1);
76 blob->push_back(idResult2);
77 (*blob)[startSize] = MakeLengthOp(blob->size() - startSize, spv::OpUndef);
78 }
WriteSourceContinued(Blob * blob,LiteralString continuedSource)79 void WriteSourceContinued(Blob *blob, LiteralString continuedSource)
80 {
81 const size_t startSize = blob->size();
82 blob->push_back(0);
83 {
84 size_t d = blob->size();
85 blob->resize(d + strlen(continuedSource) / 4 + 1, 0);
86 ASSERT(IsLittleEndian());
87 strcpy(reinterpret_cast<char *>(blob->data() + d), continuedSource);
88 }
89 (*blob)[startSize] = MakeLengthOp(blob->size() - startSize, spv::OpSourceContinued);
90 }
WriteSource(Blob * blob,spv::SourceLanguage sourceLanguage1,LiteralInteger version,const IdRef * file,const LiteralString * source)91 void WriteSource(Blob *blob,
92 spv::SourceLanguage sourceLanguage1,
93 LiteralInteger version,
94 const IdRef *file,
95 const LiteralString *source)
96 {
97 const size_t startSize = blob->size();
98 blob->push_back(0);
99 blob->push_back(sourceLanguage1);
100 blob->push_back(version);
101 if (file)
102 {
103 blob->push_back(*file);
104 }
105 if (source)
106 {
107 {
108 size_t d = blob->size();
109 blob->resize(d + strlen(*source) / 4 + 1, 0);
110 ASSERT(IsLittleEndian());
111 strcpy(reinterpret_cast<char *>(blob->data() + d), *source);
112 }
113 }
114 (*blob)[startSize] = MakeLengthOp(blob->size() - startSize, spv::OpSource);
115 }
WriteSourceExtension(Blob * blob,LiteralString extension)116 void WriteSourceExtension(Blob *blob, LiteralString extension)
117 {
118 const size_t startSize = blob->size();
119 blob->push_back(0);
120 {
121 size_t d = blob->size();
122 blob->resize(d + strlen(extension) / 4 + 1, 0);
123 ASSERT(IsLittleEndian());
124 strcpy(reinterpret_cast<char *>(blob->data() + d), extension);
125 }
126 (*blob)[startSize] = MakeLengthOp(blob->size() - startSize, spv::OpSourceExtension);
127 }
WriteName(Blob * blob,IdRef target,LiteralString name)128 void WriteName(Blob *blob, IdRef target, LiteralString name)
129 {
130 const size_t startSize = blob->size();
131 blob->push_back(0);
132 blob->push_back(target);
133 {
134 size_t d = blob->size();
135 blob->resize(d + strlen(name) / 4 + 1, 0);
136 ASSERT(IsLittleEndian());
137 strcpy(reinterpret_cast<char *>(blob->data() + d), name);
138 }
139 (*blob)[startSize] = MakeLengthOp(blob->size() - startSize, spv::OpName);
140 }
WriteMemberName(Blob * blob,IdRef type,LiteralInteger member,LiteralString name)141 void WriteMemberName(Blob *blob, IdRef type, LiteralInteger member, LiteralString name)
142 {
143 const size_t startSize = blob->size();
144 blob->push_back(0);
145 blob->push_back(type);
146 blob->push_back(member);
147 {
148 size_t d = blob->size();
149 blob->resize(d + strlen(name) / 4 + 1, 0);
150 ASSERT(IsLittleEndian());
151 strcpy(reinterpret_cast<char *>(blob->data() + d), name);
152 }
153 (*blob)[startSize] = MakeLengthOp(blob->size() - startSize, spv::OpMemberName);
154 }
WriteString(Blob * blob,IdResult idResult1,LiteralString string)155 void WriteString(Blob *blob, IdResult idResult1, LiteralString string)
156 {
157 const size_t startSize = blob->size();
158 blob->push_back(0);
159 blob->push_back(idResult1);
160 {
161 size_t d = blob->size();
162 blob->resize(d + strlen(string) / 4 + 1, 0);
163 ASSERT(IsLittleEndian());
164 strcpy(reinterpret_cast<char *>(blob->data() + d), string);
165 }
166 (*blob)[startSize] = MakeLengthOp(blob->size() - startSize, spv::OpString);
167 }
WriteLine(Blob * blob,IdRef file,LiteralInteger line,LiteralInteger column)168 void WriteLine(Blob *blob, IdRef file, LiteralInteger line, LiteralInteger column)
169 {
170 const size_t startSize = blob->size();
171 blob->push_back(0);
172 blob->push_back(file);
173 blob->push_back(line);
174 blob->push_back(column);
175 (*blob)[startSize] = MakeLengthOp(blob->size() - startSize, spv::OpLine);
176 }
WriteExtension(Blob * blob,LiteralString name)177 void WriteExtension(Blob *blob, LiteralString name)
178 {
179 const size_t startSize = blob->size();
180 blob->push_back(0);
181 {
182 size_t d = blob->size();
183 blob->resize(d + strlen(name) / 4 + 1, 0);
184 ASSERT(IsLittleEndian());
185 strcpy(reinterpret_cast<char *>(blob->data() + d), name);
186 }
187 (*blob)[startSize] = MakeLengthOp(blob->size() - startSize, spv::OpExtension);
188 }
WriteExtInstImport(Blob * blob,IdResult idResult1,LiteralString name)189 void WriteExtInstImport(Blob *blob, IdResult idResult1, LiteralString name)
190 {
191 const size_t startSize = blob->size();
192 blob->push_back(0);
193 blob->push_back(idResult1);
194 {
195 size_t d = blob->size();
196 blob->resize(d + strlen(name) / 4 + 1, 0);
197 ASSERT(IsLittleEndian());
198 strcpy(reinterpret_cast<char *>(blob->data() + d), name);
199 }
200 (*blob)[startSize] = MakeLengthOp(blob->size() - startSize, spv::OpExtInstImport);
201 }
WriteExtInst(Blob * blob,IdResultType idResultType1,IdResult idResult2,IdRef set,LiteralExtInstInteger instruction,const IdRefList & operandList)202 void WriteExtInst(Blob *blob,
203 IdResultType idResultType1,
204 IdResult idResult2,
205 IdRef set,
206 LiteralExtInstInteger instruction,
207 const IdRefList &operandList)
208 {
209 const size_t startSize = blob->size();
210 blob->push_back(0);
211 blob->push_back(idResultType1);
212 blob->push_back(idResult2);
213 blob->push_back(set);
214 blob->push_back(instruction);
215 for (const auto &operand : operandList)
216 {
217 blob->push_back(operand);
218 }
219 (*blob)[startSize] = MakeLengthOp(blob->size() - startSize, spv::OpExtInst);
220 }
WriteMemoryModel(Blob * blob,spv::AddressingModel addressingModel1,spv::MemoryModel memoryModel2)221 void WriteMemoryModel(Blob *blob,
222 spv::AddressingModel addressingModel1,
223 spv::MemoryModel memoryModel2)
224 {
225 const size_t startSize = blob->size();
226 blob->push_back(0);
227 blob->push_back(addressingModel1);
228 blob->push_back(memoryModel2);
229 (*blob)[startSize] = MakeLengthOp(blob->size() - startSize, spv::OpMemoryModel);
230 }
WriteEntryPoint(Blob * blob,spv::ExecutionModel executionModel1,IdRef entryPoint,LiteralString name,const IdRefList & interfaceList)231 void WriteEntryPoint(Blob *blob,
232 spv::ExecutionModel executionModel1,
233 IdRef entryPoint,
234 LiteralString name,
235 const IdRefList &interfaceList)
236 {
237 const size_t startSize = blob->size();
238 blob->push_back(0);
239 blob->push_back(executionModel1);
240 blob->push_back(entryPoint);
241 {
242 size_t d = blob->size();
243 blob->resize(d + strlen(name) / 4 + 1, 0);
244 ASSERT(IsLittleEndian());
245 strcpy(reinterpret_cast<char *>(blob->data() + d), name);
246 }
247 for (const auto &operand : interfaceList)
248 {
249 blob->push_back(operand);
250 }
251 (*blob)[startSize] = MakeLengthOp(blob->size() - startSize, spv::OpEntryPoint);
252 }
WriteExecutionMode(Blob * blob,IdRef entryPoint,spv::ExecutionMode mode,const LiteralIntegerList & operandsList)253 void WriteExecutionMode(Blob *blob,
254 IdRef entryPoint,
255 spv::ExecutionMode mode,
256 const LiteralIntegerList &operandsList)
257 {
258 const size_t startSize = blob->size();
259 blob->push_back(0);
260 blob->push_back(entryPoint);
261 blob->push_back(mode);
262 for (const auto &operand : operandsList)
263 {
264 blob->push_back(operand);
265 }
266 (*blob)[startSize] = MakeLengthOp(blob->size() - startSize, spv::OpExecutionMode);
267 }
WriteCapability(Blob * blob,spv::Capability capability)268 void WriteCapability(Blob *blob, spv::Capability capability)
269 {
270 const size_t startSize = blob->size();
271 blob->push_back(0);
272 blob->push_back(capability);
273 (*blob)[startSize] = MakeLengthOp(blob->size() - startSize, spv::OpCapability);
274 }
WriteTypeVoid(Blob * blob,IdResult idResult1)275 void WriteTypeVoid(Blob *blob, IdResult idResult1)
276 {
277 const size_t startSize = blob->size();
278 blob->push_back(0);
279 blob->push_back(idResult1);
280 (*blob)[startSize] = MakeLengthOp(blob->size() - startSize, spv::OpTypeVoid);
281 }
WriteTypeBool(Blob * blob,IdResult idResult1)282 void WriteTypeBool(Blob *blob, IdResult idResult1)
283 {
284 const size_t startSize = blob->size();
285 blob->push_back(0);
286 blob->push_back(idResult1);
287 (*blob)[startSize] = MakeLengthOp(blob->size() - startSize, spv::OpTypeBool);
288 }
WriteTypeInt(Blob * blob,IdResult idResult1,LiteralInteger width,LiteralInteger signedness)289 void WriteTypeInt(Blob *blob, IdResult idResult1, LiteralInteger width, LiteralInteger signedness)
290 {
291 const size_t startSize = blob->size();
292 blob->push_back(0);
293 blob->push_back(idResult1);
294 blob->push_back(width);
295 blob->push_back(signedness);
296 (*blob)[startSize] = MakeLengthOp(blob->size() - startSize, spv::OpTypeInt);
297 }
WriteTypeFloat(Blob * blob,IdResult idResult1,LiteralInteger width)298 void WriteTypeFloat(Blob *blob, IdResult idResult1, LiteralInteger width)
299 {
300 const size_t startSize = blob->size();
301 blob->push_back(0);
302 blob->push_back(idResult1);
303 blob->push_back(width);
304 (*blob)[startSize] = MakeLengthOp(blob->size() - startSize, spv::OpTypeFloat);
305 }
WriteTypeVector(Blob * blob,IdResult idResult1,IdRef componentType,LiteralInteger componentCount)306 void WriteTypeVector(Blob *blob,
307 IdResult idResult1,
308 IdRef componentType,
309 LiteralInteger componentCount)
310 {
311 const size_t startSize = blob->size();
312 blob->push_back(0);
313 blob->push_back(idResult1);
314 blob->push_back(componentType);
315 blob->push_back(componentCount);
316 (*blob)[startSize] = MakeLengthOp(blob->size() - startSize, spv::OpTypeVector);
317 }
WriteTypeMatrix(Blob * blob,IdResult idResult1,IdRef columnType,LiteralInteger columnCount)318 void WriteTypeMatrix(Blob *blob, IdResult idResult1, IdRef columnType, LiteralInteger columnCount)
319 {
320 const size_t startSize = blob->size();
321 blob->push_back(0);
322 blob->push_back(idResult1);
323 blob->push_back(columnType);
324 blob->push_back(columnCount);
325 (*blob)[startSize] = MakeLengthOp(blob->size() - startSize, spv::OpTypeMatrix);
326 }
WriteTypeImage(Blob * blob,IdResult idResult1,IdRef sampledType,spv::Dim dim3,LiteralInteger depth,LiteralInteger arrayed,LiteralInteger mS,LiteralInteger sampled,spv::ImageFormat imageFormat8,const spv::AccessQualifier * accessQualifier9)327 void WriteTypeImage(Blob *blob,
328 IdResult idResult1,
329 IdRef sampledType,
330 spv::Dim dim3,
331 LiteralInteger depth,
332 LiteralInteger arrayed,
333 LiteralInteger mS,
334 LiteralInteger sampled,
335 spv::ImageFormat imageFormat8,
336 const spv::AccessQualifier *accessQualifier9)
337 {
338 const size_t startSize = blob->size();
339 blob->push_back(0);
340 blob->push_back(idResult1);
341 blob->push_back(sampledType);
342 blob->push_back(dim3);
343 blob->push_back(depth);
344 blob->push_back(arrayed);
345 blob->push_back(mS);
346 blob->push_back(sampled);
347 blob->push_back(imageFormat8);
348 if (accessQualifier9)
349 {
350 blob->push_back(*accessQualifier9);
351 }
352 (*blob)[startSize] = MakeLengthOp(blob->size() - startSize, spv::OpTypeImage);
353 }
WriteTypeSampler(Blob * blob,IdResult idResult1)354 void WriteTypeSampler(Blob *blob, IdResult idResult1)
355 {
356 const size_t startSize = blob->size();
357 blob->push_back(0);
358 blob->push_back(idResult1);
359 (*blob)[startSize] = MakeLengthOp(blob->size() - startSize, spv::OpTypeSampler);
360 }
WriteTypeSampledImage(Blob * blob,IdResult idResult1,IdRef imageType)361 void WriteTypeSampledImage(Blob *blob, IdResult idResult1, IdRef imageType)
362 {
363 const size_t startSize = blob->size();
364 blob->push_back(0);
365 blob->push_back(idResult1);
366 blob->push_back(imageType);
367 (*blob)[startSize] = MakeLengthOp(blob->size() - startSize, spv::OpTypeSampledImage);
368 }
WriteTypeArray(Blob * blob,IdResult idResult1,IdRef elementType,IdRef length)369 void WriteTypeArray(Blob *blob, IdResult idResult1, IdRef elementType, IdRef length)
370 {
371 const size_t startSize = blob->size();
372 blob->push_back(0);
373 blob->push_back(idResult1);
374 blob->push_back(elementType);
375 blob->push_back(length);
376 (*blob)[startSize] = MakeLengthOp(blob->size() - startSize, spv::OpTypeArray);
377 }
WriteTypeRuntimeArray(Blob * blob,IdResult idResult1,IdRef elementType)378 void WriteTypeRuntimeArray(Blob *blob, IdResult idResult1, IdRef elementType)
379 {
380 const size_t startSize = blob->size();
381 blob->push_back(0);
382 blob->push_back(idResult1);
383 blob->push_back(elementType);
384 (*blob)[startSize] = MakeLengthOp(blob->size() - startSize, spv::OpTypeRuntimeArray);
385 }
WriteTypeStruct(Blob * blob,IdResult idResult1,const IdRefList & memberList)386 void WriteTypeStruct(Blob *blob, IdResult idResult1, const IdRefList &memberList)
387 {
388 const size_t startSize = blob->size();
389 blob->push_back(0);
390 blob->push_back(idResult1);
391 for (const auto &operand : memberList)
392 {
393 blob->push_back(operand);
394 }
395 (*blob)[startSize] = MakeLengthOp(blob->size() - startSize, spv::OpTypeStruct);
396 }
WriteTypePointer(Blob * blob,IdResult idResult1,spv::StorageClass storageClass2,IdRef type)397 void WriteTypePointer(Blob *blob, IdResult idResult1, spv::StorageClass storageClass2, IdRef type)
398 {
399 const size_t startSize = blob->size();
400 blob->push_back(0);
401 blob->push_back(idResult1);
402 blob->push_back(storageClass2);
403 blob->push_back(type);
404 (*blob)[startSize] = MakeLengthOp(blob->size() - startSize, spv::OpTypePointer);
405 }
WriteTypeFunction(Blob * blob,IdResult idResult1,IdRef returnType,const IdRefList & parameterList)406 void WriteTypeFunction(Blob *blob,
407 IdResult idResult1,
408 IdRef returnType,
409 const IdRefList ¶meterList)
410 {
411 const size_t startSize = blob->size();
412 blob->push_back(0);
413 blob->push_back(idResult1);
414 blob->push_back(returnType);
415 for (const auto &operand : parameterList)
416 {
417 blob->push_back(operand);
418 }
419 (*blob)[startSize] = MakeLengthOp(blob->size() - startSize, spv::OpTypeFunction);
420 }
WriteConstantTrue(Blob * blob,IdResultType idResultType1,IdResult idResult2)421 void WriteConstantTrue(Blob *blob, IdResultType idResultType1, IdResult idResult2)
422 {
423 const size_t startSize = blob->size();
424 blob->push_back(0);
425 blob->push_back(idResultType1);
426 blob->push_back(idResult2);
427 (*blob)[startSize] = MakeLengthOp(blob->size() - startSize, spv::OpConstantTrue);
428 }
WriteConstantFalse(Blob * blob,IdResultType idResultType1,IdResult idResult2)429 void WriteConstantFalse(Blob *blob, IdResultType idResultType1, IdResult idResult2)
430 {
431 const size_t startSize = blob->size();
432 blob->push_back(0);
433 blob->push_back(idResultType1);
434 blob->push_back(idResult2);
435 (*blob)[startSize] = MakeLengthOp(blob->size() - startSize, spv::OpConstantFalse);
436 }
WriteConstant(Blob * blob,IdResultType idResultType1,IdResult idResult2,LiteralContextDependentNumber value)437 void WriteConstant(Blob *blob,
438 IdResultType idResultType1,
439 IdResult idResult2,
440 LiteralContextDependentNumber value)
441 {
442 const size_t startSize = blob->size();
443 blob->push_back(0);
444 blob->push_back(idResultType1);
445 blob->push_back(idResult2);
446 blob->push_back(value);
447 (*blob)[startSize] = MakeLengthOp(blob->size() - startSize, spv::OpConstant);
448 }
WriteConstantComposite(Blob * blob,IdResultType idResultType1,IdResult idResult2,const IdRefList & constituentsList)449 void WriteConstantComposite(Blob *blob,
450 IdResultType idResultType1,
451 IdResult idResult2,
452 const IdRefList &constituentsList)
453 {
454 const size_t startSize = blob->size();
455 blob->push_back(0);
456 blob->push_back(idResultType1);
457 blob->push_back(idResult2);
458 for (const auto &operand : constituentsList)
459 {
460 blob->push_back(operand);
461 }
462 (*blob)[startSize] = MakeLengthOp(blob->size() - startSize, spv::OpConstantComposite);
463 }
WriteConstantNull(Blob * blob,IdResultType idResultType1,IdResult idResult2)464 void WriteConstantNull(Blob *blob, IdResultType idResultType1, IdResult idResult2)
465 {
466 const size_t startSize = blob->size();
467 blob->push_back(0);
468 blob->push_back(idResultType1);
469 blob->push_back(idResult2);
470 (*blob)[startSize] = MakeLengthOp(blob->size() - startSize, spv::OpConstantNull);
471 }
WriteSpecConstantTrue(Blob * blob,IdResultType idResultType1,IdResult idResult2)472 void WriteSpecConstantTrue(Blob *blob, IdResultType idResultType1, IdResult idResult2)
473 {
474 const size_t startSize = blob->size();
475 blob->push_back(0);
476 blob->push_back(idResultType1);
477 blob->push_back(idResult2);
478 (*blob)[startSize] = MakeLengthOp(blob->size() - startSize, spv::OpSpecConstantTrue);
479 }
WriteSpecConstantFalse(Blob * blob,IdResultType idResultType1,IdResult idResult2)480 void WriteSpecConstantFalse(Blob *blob, IdResultType idResultType1, IdResult idResult2)
481 {
482 const size_t startSize = blob->size();
483 blob->push_back(0);
484 blob->push_back(idResultType1);
485 blob->push_back(idResult2);
486 (*blob)[startSize] = MakeLengthOp(blob->size() - startSize, spv::OpSpecConstantFalse);
487 }
WriteSpecConstant(Blob * blob,IdResultType idResultType1,IdResult idResult2,LiteralContextDependentNumber value)488 void WriteSpecConstant(Blob *blob,
489 IdResultType idResultType1,
490 IdResult idResult2,
491 LiteralContextDependentNumber value)
492 {
493 const size_t startSize = blob->size();
494 blob->push_back(0);
495 blob->push_back(idResultType1);
496 blob->push_back(idResult2);
497 blob->push_back(value);
498 (*blob)[startSize] = MakeLengthOp(blob->size() - startSize, spv::OpSpecConstant);
499 }
WriteSpecConstantComposite(Blob * blob,IdResultType idResultType1,IdResult idResult2,const IdRefList & constituentsList)500 void WriteSpecConstantComposite(Blob *blob,
501 IdResultType idResultType1,
502 IdResult idResult2,
503 const IdRefList &constituentsList)
504 {
505 const size_t startSize = blob->size();
506 blob->push_back(0);
507 blob->push_back(idResultType1);
508 blob->push_back(idResult2);
509 for (const auto &operand : constituentsList)
510 {
511 blob->push_back(operand);
512 }
513 (*blob)[startSize] = MakeLengthOp(blob->size() - startSize, spv::OpSpecConstantComposite);
514 }
WriteFunction(Blob * blob,IdResultType idResultType1,IdResult idResult2,spv::FunctionControlMask functionControl3,IdRef functionType)515 void WriteFunction(Blob *blob,
516 IdResultType idResultType1,
517 IdResult idResult2,
518 spv::FunctionControlMask functionControl3,
519 IdRef functionType)
520 {
521 const size_t startSize = blob->size();
522 blob->push_back(0);
523 blob->push_back(idResultType1);
524 blob->push_back(idResult2);
525 blob->push_back(functionControl3);
526 blob->push_back(functionType);
527 (*blob)[startSize] = MakeLengthOp(blob->size() - startSize, spv::OpFunction);
528 }
WriteFunctionParameter(Blob * blob,IdResultType idResultType1,IdResult idResult2)529 void WriteFunctionParameter(Blob *blob, IdResultType idResultType1, IdResult idResult2)
530 {
531 const size_t startSize = blob->size();
532 blob->push_back(0);
533 blob->push_back(idResultType1);
534 blob->push_back(idResult2);
535 (*blob)[startSize] = MakeLengthOp(blob->size() - startSize, spv::OpFunctionParameter);
536 }
WriteFunctionEnd(Blob * blob)537 void WriteFunctionEnd(Blob *blob)
538 {
539 const size_t startSize = blob->size();
540 blob->push_back(0);
541
542 (*blob)[startSize] = MakeLengthOp(blob->size() - startSize, spv::OpFunctionEnd);
543 }
WriteFunctionCall(Blob * blob,IdResultType idResultType1,IdResult idResult2,IdRef function,const IdRefList & argumentList)544 void WriteFunctionCall(Blob *blob,
545 IdResultType idResultType1,
546 IdResult idResult2,
547 IdRef function,
548 const IdRefList &argumentList)
549 {
550 const size_t startSize = blob->size();
551 blob->push_back(0);
552 blob->push_back(idResultType1);
553 blob->push_back(idResult2);
554 blob->push_back(function);
555 for (const auto &operand : argumentList)
556 {
557 blob->push_back(operand);
558 }
559 (*blob)[startSize] = MakeLengthOp(blob->size() - startSize, spv::OpFunctionCall);
560 }
WriteVariable(Blob * blob,IdResultType idResultType1,IdResult idResult2,spv::StorageClass storageClass3,const IdRef * initializer)561 void WriteVariable(Blob *blob,
562 IdResultType idResultType1,
563 IdResult idResult2,
564 spv::StorageClass storageClass3,
565 const IdRef *initializer)
566 {
567 const size_t startSize = blob->size();
568 blob->push_back(0);
569 blob->push_back(idResultType1);
570 blob->push_back(idResult2);
571 blob->push_back(storageClass3);
572 if (initializer)
573 {
574 blob->push_back(*initializer);
575 }
576 (*blob)[startSize] = MakeLengthOp(blob->size() - startSize, spv::OpVariable);
577 }
WriteImageTexelPointer(Blob * blob,IdResultType idResultType1,IdResult idResult2,IdRef image,IdRef coordinate,IdRef sample)578 void WriteImageTexelPointer(Blob *blob,
579 IdResultType idResultType1,
580 IdResult idResult2,
581 IdRef image,
582 IdRef coordinate,
583 IdRef sample)
584 {
585 const size_t startSize = blob->size();
586 blob->push_back(0);
587 blob->push_back(idResultType1);
588 blob->push_back(idResult2);
589 blob->push_back(image);
590 blob->push_back(coordinate);
591 blob->push_back(sample);
592 (*blob)[startSize] = MakeLengthOp(blob->size() - startSize, spv::OpImageTexelPointer);
593 }
WriteLoad(Blob * blob,IdResultType idResultType1,IdResult idResult2,IdRef pointer,const spv::MemoryAccessMask * memoryAccess4)594 void WriteLoad(Blob *blob,
595 IdResultType idResultType1,
596 IdResult idResult2,
597 IdRef pointer,
598 const spv::MemoryAccessMask *memoryAccess4)
599 {
600 const size_t startSize = blob->size();
601 blob->push_back(0);
602 blob->push_back(idResultType1);
603 blob->push_back(idResult2);
604 blob->push_back(pointer);
605 if (memoryAccess4)
606 {
607 blob->push_back(*memoryAccess4);
608 }
609 (*blob)[startSize] = MakeLengthOp(blob->size() - startSize, spv::OpLoad);
610 }
WriteStore(Blob * blob,IdRef pointer,IdRef object,const spv::MemoryAccessMask * memoryAccess3)611 void WriteStore(Blob *blob, IdRef pointer, IdRef object, const spv::MemoryAccessMask *memoryAccess3)
612 {
613 const size_t startSize = blob->size();
614 blob->push_back(0);
615 blob->push_back(pointer);
616 blob->push_back(object);
617 if (memoryAccess3)
618 {
619 blob->push_back(*memoryAccess3);
620 }
621 (*blob)[startSize] = MakeLengthOp(blob->size() - startSize, spv::OpStore);
622 }
WriteCopyMemory(Blob * blob,IdRef target,IdRef source,const spv::MemoryAccessMask * memoryAccess3,const spv::MemoryAccessMask * memoryAccess4)623 void WriteCopyMemory(Blob *blob,
624 IdRef target,
625 IdRef source,
626 const spv::MemoryAccessMask *memoryAccess3,
627 const spv::MemoryAccessMask *memoryAccess4)
628 {
629 const size_t startSize = blob->size();
630 blob->push_back(0);
631 blob->push_back(target);
632 blob->push_back(source);
633 if (memoryAccess3)
634 {
635 blob->push_back(*memoryAccess3);
636 }
637 if (memoryAccess4)
638 {
639 blob->push_back(*memoryAccess4);
640 }
641 (*blob)[startSize] = MakeLengthOp(blob->size() - startSize, spv::OpCopyMemory);
642 }
WriteAccessChain(Blob * blob,IdResultType idResultType1,IdResult idResult2,IdRef base,const IdRefList & indexesList)643 void WriteAccessChain(Blob *blob,
644 IdResultType idResultType1,
645 IdResult idResult2,
646 IdRef base,
647 const IdRefList &indexesList)
648 {
649 const size_t startSize = blob->size();
650 blob->push_back(0);
651 blob->push_back(idResultType1);
652 blob->push_back(idResult2);
653 blob->push_back(base);
654 for (const auto &operand : indexesList)
655 {
656 blob->push_back(operand);
657 }
658 (*blob)[startSize] = MakeLengthOp(blob->size() - startSize, spv::OpAccessChain);
659 }
WriteInBoundsAccessChain(Blob * blob,IdResultType idResultType1,IdResult idResult2,IdRef base,const IdRefList & indexesList)660 void WriteInBoundsAccessChain(Blob *blob,
661 IdResultType idResultType1,
662 IdResult idResult2,
663 IdRef base,
664 const IdRefList &indexesList)
665 {
666 const size_t startSize = blob->size();
667 blob->push_back(0);
668 blob->push_back(idResultType1);
669 blob->push_back(idResult2);
670 blob->push_back(base);
671 for (const auto &operand : indexesList)
672 {
673 blob->push_back(operand);
674 }
675 (*blob)[startSize] = MakeLengthOp(blob->size() - startSize, spv::OpInBoundsAccessChain);
676 }
WriteArrayLength(Blob * blob,IdResultType idResultType1,IdResult idResult2,IdRef structure,LiteralInteger arraymember)677 void WriteArrayLength(Blob *blob,
678 IdResultType idResultType1,
679 IdResult idResult2,
680 IdRef structure,
681 LiteralInteger arraymember)
682 {
683 const size_t startSize = blob->size();
684 blob->push_back(0);
685 blob->push_back(idResultType1);
686 blob->push_back(idResult2);
687 blob->push_back(structure);
688 blob->push_back(arraymember);
689 (*blob)[startSize] = MakeLengthOp(blob->size() - startSize, spv::OpArrayLength);
690 }
WriteDecorate(Blob * blob,IdRef target,spv::Decoration decoration2,const LiteralIntegerList & valuesList)691 void WriteDecorate(Blob *blob,
692 IdRef target,
693 spv::Decoration decoration2,
694 const LiteralIntegerList &valuesList)
695 {
696 const size_t startSize = blob->size();
697 blob->push_back(0);
698 blob->push_back(target);
699 blob->push_back(decoration2);
700 for (const auto &operand : valuesList)
701 {
702 blob->push_back(operand);
703 }
704 (*blob)[startSize] = MakeLengthOp(blob->size() - startSize, spv::OpDecorate);
705 }
WriteMemberDecorate(Blob * blob,IdRef structureType,LiteralInteger member,spv::Decoration decoration3,const LiteralIntegerList & valuesList)706 void WriteMemberDecorate(Blob *blob,
707 IdRef structureType,
708 LiteralInteger member,
709 spv::Decoration decoration3,
710 const LiteralIntegerList &valuesList)
711 {
712 const size_t startSize = blob->size();
713 blob->push_back(0);
714 blob->push_back(structureType);
715 blob->push_back(member);
716 blob->push_back(decoration3);
717 for (const auto &operand : valuesList)
718 {
719 blob->push_back(operand);
720 }
721 (*blob)[startSize] = MakeLengthOp(blob->size() - startSize, spv::OpMemberDecorate);
722 }
WriteDecorationGroup(Blob * blob,IdResult idResult1)723 void WriteDecorationGroup(Blob *blob, IdResult idResult1)
724 {
725 const size_t startSize = blob->size();
726 blob->push_back(0);
727 blob->push_back(idResult1);
728 (*blob)[startSize] = MakeLengthOp(blob->size() - startSize, spv::OpDecorationGroup);
729 }
WriteGroupDecorate(Blob * blob,IdRef decorationGroup,const IdRefList & targetsList)730 void WriteGroupDecorate(Blob *blob, IdRef decorationGroup, const IdRefList &targetsList)
731 {
732 const size_t startSize = blob->size();
733 blob->push_back(0);
734 blob->push_back(decorationGroup);
735 for (const auto &operand : targetsList)
736 {
737 blob->push_back(operand);
738 }
739 (*blob)[startSize] = MakeLengthOp(blob->size() - startSize, spv::OpGroupDecorate);
740 }
WriteGroupMemberDecorate(Blob * blob,IdRef decorationGroup,const PairIdRefLiteralIntegerList & targetsPairList)741 void WriteGroupMemberDecorate(Blob *blob,
742 IdRef decorationGroup,
743 const PairIdRefLiteralIntegerList &targetsPairList)
744 {
745 const size_t startSize = blob->size();
746 blob->push_back(0);
747 blob->push_back(decorationGroup);
748 for (const auto &operand : targetsPairList)
749 {
750 blob->push_back(operand.id);
751 blob->push_back(operand.literal);
752 }
753 (*blob)[startSize] = MakeLengthOp(blob->size() - startSize, spv::OpGroupMemberDecorate);
754 }
WriteVectorExtractDynamic(Blob * blob,IdResultType idResultType1,IdResult idResult2,IdRef vector,IdRef index)755 void WriteVectorExtractDynamic(Blob *blob,
756 IdResultType idResultType1,
757 IdResult idResult2,
758 IdRef vector,
759 IdRef index)
760 {
761 const size_t startSize = blob->size();
762 blob->push_back(0);
763 blob->push_back(idResultType1);
764 blob->push_back(idResult2);
765 blob->push_back(vector);
766 blob->push_back(index);
767 (*blob)[startSize] = MakeLengthOp(blob->size() - startSize, spv::OpVectorExtractDynamic);
768 }
WriteVectorInsertDynamic(Blob * blob,IdResultType idResultType1,IdResult idResult2,IdRef vector,IdRef component,IdRef index)769 void WriteVectorInsertDynamic(Blob *blob,
770 IdResultType idResultType1,
771 IdResult idResult2,
772 IdRef vector,
773 IdRef component,
774 IdRef index)
775 {
776 const size_t startSize = blob->size();
777 blob->push_back(0);
778 blob->push_back(idResultType1);
779 blob->push_back(idResult2);
780 blob->push_back(vector);
781 blob->push_back(component);
782 blob->push_back(index);
783 (*blob)[startSize] = MakeLengthOp(blob->size() - startSize, spv::OpVectorInsertDynamic);
784 }
WriteVectorShuffle(Blob * blob,IdResultType idResultType1,IdResult idResult2,IdRef vector1,IdRef vector2,const LiteralIntegerList & componentsList)785 void WriteVectorShuffle(Blob *blob,
786 IdResultType idResultType1,
787 IdResult idResult2,
788 IdRef vector1,
789 IdRef vector2,
790 const LiteralIntegerList &componentsList)
791 {
792 const size_t startSize = blob->size();
793 blob->push_back(0);
794 blob->push_back(idResultType1);
795 blob->push_back(idResult2);
796 blob->push_back(vector1);
797 blob->push_back(vector2);
798 for (const auto &operand : componentsList)
799 {
800 blob->push_back(operand);
801 }
802 (*blob)[startSize] = MakeLengthOp(blob->size() - startSize, spv::OpVectorShuffle);
803 }
WriteCompositeConstruct(Blob * blob,IdResultType idResultType1,IdResult idResult2,const IdRefList & constituentsList)804 void WriteCompositeConstruct(Blob *blob,
805 IdResultType idResultType1,
806 IdResult idResult2,
807 const IdRefList &constituentsList)
808 {
809 const size_t startSize = blob->size();
810 blob->push_back(0);
811 blob->push_back(idResultType1);
812 blob->push_back(idResult2);
813 for (const auto &operand : constituentsList)
814 {
815 blob->push_back(operand);
816 }
817 (*blob)[startSize] = MakeLengthOp(blob->size() - startSize, spv::OpCompositeConstruct);
818 }
WriteCompositeExtract(Blob * blob,IdResultType idResultType1,IdResult idResult2,IdRef composite,const LiteralIntegerList & indexesList)819 void WriteCompositeExtract(Blob *blob,
820 IdResultType idResultType1,
821 IdResult idResult2,
822 IdRef composite,
823 const LiteralIntegerList &indexesList)
824 {
825 const size_t startSize = blob->size();
826 blob->push_back(0);
827 blob->push_back(idResultType1);
828 blob->push_back(idResult2);
829 blob->push_back(composite);
830 for (const auto &operand : indexesList)
831 {
832 blob->push_back(operand);
833 }
834 (*blob)[startSize] = MakeLengthOp(blob->size() - startSize, spv::OpCompositeExtract);
835 }
WriteCompositeInsert(Blob * blob,IdResultType idResultType1,IdResult idResult2,IdRef object,IdRef composite,const LiteralIntegerList & indexesList)836 void WriteCompositeInsert(Blob *blob,
837 IdResultType idResultType1,
838 IdResult idResult2,
839 IdRef object,
840 IdRef composite,
841 const LiteralIntegerList &indexesList)
842 {
843 const size_t startSize = blob->size();
844 blob->push_back(0);
845 blob->push_back(idResultType1);
846 blob->push_back(idResult2);
847 blob->push_back(object);
848 blob->push_back(composite);
849 for (const auto &operand : indexesList)
850 {
851 blob->push_back(operand);
852 }
853 (*blob)[startSize] = MakeLengthOp(blob->size() - startSize, spv::OpCompositeInsert);
854 }
WriteCopyObject(Blob * blob,IdResultType idResultType1,IdResult idResult2,IdRef operand)855 void WriteCopyObject(Blob *blob, IdResultType idResultType1, IdResult idResult2, IdRef operand)
856 {
857 const size_t startSize = blob->size();
858 blob->push_back(0);
859 blob->push_back(idResultType1);
860 blob->push_back(idResult2);
861 blob->push_back(operand);
862 (*blob)[startSize] = MakeLengthOp(blob->size() - startSize, spv::OpCopyObject);
863 }
WriteTranspose(Blob * blob,IdResultType idResultType1,IdResult idResult2,IdRef matrix)864 void WriteTranspose(Blob *blob, IdResultType idResultType1, IdResult idResult2, IdRef matrix)
865 {
866 const size_t startSize = blob->size();
867 blob->push_back(0);
868 blob->push_back(idResultType1);
869 blob->push_back(idResult2);
870 blob->push_back(matrix);
871 (*blob)[startSize] = MakeLengthOp(blob->size() - startSize, spv::OpTranspose);
872 }
WriteSampledImage(Blob * blob,IdResultType idResultType1,IdResult idResult2,IdRef image,IdRef sampler)873 void WriteSampledImage(Blob *blob,
874 IdResultType idResultType1,
875 IdResult idResult2,
876 IdRef image,
877 IdRef sampler)
878 {
879 const size_t startSize = blob->size();
880 blob->push_back(0);
881 blob->push_back(idResultType1);
882 blob->push_back(idResult2);
883 blob->push_back(image);
884 blob->push_back(sampler);
885 (*blob)[startSize] = MakeLengthOp(blob->size() - startSize, spv::OpSampledImage);
886 }
WriteImageSampleImplicitLod(Blob * blob,IdResultType idResultType1,IdResult idResult2,IdRef sampledImage,IdRef coordinate,const spv::ImageOperandsMask * imageOperands5,const IdRefList & imageOperandIdsList)887 void WriteImageSampleImplicitLod(Blob *blob,
888 IdResultType idResultType1,
889 IdResult idResult2,
890 IdRef sampledImage,
891 IdRef coordinate,
892 const spv::ImageOperandsMask *imageOperands5,
893 const IdRefList &imageOperandIdsList)
894 {
895 const size_t startSize = blob->size();
896 blob->push_back(0);
897 blob->push_back(idResultType1);
898 blob->push_back(idResult2);
899 blob->push_back(sampledImage);
900 blob->push_back(coordinate);
901 if (imageOperands5)
902 {
903 blob->push_back(*imageOperands5);
904 }
905 for (const auto &operand : imageOperandIdsList)
906 {
907 blob->push_back(operand);
908 }
909 (*blob)[startSize] = MakeLengthOp(blob->size() - startSize, spv::OpImageSampleImplicitLod);
910 }
WriteImageSampleExplicitLod(Blob * blob,IdResultType idResultType1,IdResult idResult2,IdRef sampledImage,IdRef coordinate,spv::ImageOperandsMask imageOperands5,const IdRefList & imageOperandIdsList)911 void WriteImageSampleExplicitLod(Blob *blob,
912 IdResultType idResultType1,
913 IdResult idResult2,
914 IdRef sampledImage,
915 IdRef coordinate,
916 spv::ImageOperandsMask imageOperands5,
917 const IdRefList &imageOperandIdsList)
918 {
919 const size_t startSize = blob->size();
920 blob->push_back(0);
921 blob->push_back(idResultType1);
922 blob->push_back(idResult2);
923 blob->push_back(sampledImage);
924 blob->push_back(coordinate);
925 blob->push_back(imageOperands5);
926 for (const auto &operand : imageOperandIdsList)
927 {
928 blob->push_back(operand);
929 }
930 (*blob)[startSize] = MakeLengthOp(blob->size() - startSize, spv::OpImageSampleExplicitLod);
931 }
WriteImageSampleDrefImplicitLod(Blob * blob,IdResultType idResultType1,IdResult idResult2,IdRef sampledImage,IdRef coordinate,IdRef dref,const spv::ImageOperandsMask * imageOperands6,const IdRefList & imageOperandIdsList)932 void WriteImageSampleDrefImplicitLod(Blob *blob,
933 IdResultType idResultType1,
934 IdResult idResult2,
935 IdRef sampledImage,
936 IdRef coordinate,
937 IdRef dref,
938 const spv::ImageOperandsMask *imageOperands6,
939 const IdRefList &imageOperandIdsList)
940 {
941 const size_t startSize = blob->size();
942 blob->push_back(0);
943 blob->push_back(idResultType1);
944 blob->push_back(idResult2);
945 blob->push_back(sampledImage);
946 blob->push_back(coordinate);
947 blob->push_back(dref);
948 if (imageOperands6)
949 {
950 blob->push_back(*imageOperands6);
951 }
952 for (const auto &operand : imageOperandIdsList)
953 {
954 blob->push_back(operand);
955 }
956 (*blob)[startSize] = MakeLengthOp(blob->size() - startSize, spv::OpImageSampleDrefImplicitLod);
957 }
WriteImageSampleDrefExplicitLod(Blob * blob,IdResultType idResultType1,IdResult idResult2,IdRef sampledImage,IdRef coordinate,IdRef dref,spv::ImageOperandsMask imageOperands6,const IdRefList & imageOperandIdsList)958 void WriteImageSampleDrefExplicitLod(Blob *blob,
959 IdResultType idResultType1,
960 IdResult idResult2,
961 IdRef sampledImage,
962 IdRef coordinate,
963 IdRef dref,
964 spv::ImageOperandsMask imageOperands6,
965 const IdRefList &imageOperandIdsList)
966 {
967 const size_t startSize = blob->size();
968 blob->push_back(0);
969 blob->push_back(idResultType1);
970 blob->push_back(idResult2);
971 blob->push_back(sampledImage);
972 blob->push_back(coordinate);
973 blob->push_back(dref);
974 blob->push_back(imageOperands6);
975 for (const auto &operand : imageOperandIdsList)
976 {
977 blob->push_back(operand);
978 }
979 (*blob)[startSize] = MakeLengthOp(blob->size() - startSize, spv::OpImageSampleDrefExplicitLod);
980 }
WriteImageSampleProjImplicitLod(Blob * blob,IdResultType idResultType1,IdResult idResult2,IdRef sampledImage,IdRef coordinate,const spv::ImageOperandsMask * imageOperands5,const IdRefList & imageOperandIdsList)981 void WriteImageSampleProjImplicitLod(Blob *blob,
982 IdResultType idResultType1,
983 IdResult idResult2,
984 IdRef sampledImage,
985 IdRef coordinate,
986 const spv::ImageOperandsMask *imageOperands5,
987 const IdRefList &imageOperandIdsList)
988 {
989 const size_t startSize = blob->size();
990 blob->push_back(0);
991 blob->push_back(idResultType1);
992 blob->push_back(idResult2);
993 blob->push_back(sampledImage);
994 blob->push_back(coordinate);
995 if (imageOperands5)
996 {
997 blob->push_back(*imageOperands5);
998 }
999 for (const auto &operand : imageOperandIdsList)
1000 {
1001 blob->push_back(operand);
1002 }
1003 (*blob)[startSize] = MakeLengthOp(blob->size() - startSize, spv::OpImageSampleProjImplicitLod);
1004 }
WriteImageSampleProjExplicitLod(Blob * blob,IdResultType idResultType1,IdResult idResult2,IdRef sampledImage,IdRef coordinate,spv::ImageOperandsMask imageOperands5,const IdRefList & imageOperandIdsList)1005 void WriteImageSampleProjExplicitLod(Blob *blob,
1006 IdResultType idResultType1,
1007 IdResult idResult2,
1008 IdRef sampledImage,
1009 IdRef coordinate,
1010 spv::ImageOperandsMask imageOperands5,
1011 const IdRefList &imageOperandIdsList)
1012 {
1013 const size_t startSize = blob->size();
1014 blob->push_back(0);
1015 blob->push_back(idResultType1);
1016 blob->push_back(idResult2);
1017 blob->push_back(sampledImage);
1018 blob->push_back(coordinate);
1019 blob->push_back(imageOperands5);
1020 for (const auto &operand : imageOperandIdsList)
1021 {
1022 blob->push_back(operand);
1023 }
1024 (*blob)[startSize] = MakeLengthOp(blob->size() - startSize, spv::OpImageSampleProjExplicitLod);
1025 }
WriteImageSampleProjDrefImplicitLod(Blob * blob,IdResultType idResultType1,IdResult idResult2,IdRef sampledImage,IdRef coordinate,IdRef dref,const spv::ImageOperandsMask * imageOperands6,const IdRefList & imageOperandIdsList)1026 void WriteImageSampleProjDrefImplicitLod(Blob *blob,
1027 IdResultType idResultType1,
1028 IdResult idResult2,
1029 IdRef sampledImage,
1030 IdRef coordinate,
1031 IdRef dref,
1032 const spv::ImageOperandsMask *imageOperands6,
1033 const IdRefList &imageOperandIdsList)
1034 {
1035 const size_t startSize = blob->size();
1036 blob->push_back(0);
1037 blob->push_back(idResultType1);
1038 blob->push_back(idResult2);
1039 blob->push_back(sampledImage);
1040 blob->push_back(coordinate);
1041 blob->push_back(dref);
1042 if (imageOperands6)
1043 {
1044 blob->push_back(*imageOperands6);
1045 }
1046 for (const auto &operand : imageOperandIdsList)
1047 {
1048 blob->push_back(operand);
1049 }
1050 (*blob)[startSize] =
1051 MakeLengthOp(blob->size() - startSize, spv::OpImageSampleProjDrefImplicitLod);
1052 }
WriteImageSampleProjDrefExplicitLod(Blob * blob,IdResultType idResultType1,IdResult idResult2,IdRef sampledImage,IdRef coordinate,IdRef dref,spv::ImageOperandsMask imageOperands6,const IdRefList & imageOperandIdsList)1053 void WriteImageSampleProjDrefExplicitLod(Blob *blob,
1054 IdResultType idResultType1,
1055 IdResult idResult2,
1056 IdRef sampledImage,
1057 IdRef coordinate,
1058 IdRef dref,
1059 spv::ImageOperandsMask imageOperands6,
1060 const IdRefList &imageOperandIdsList)
1061 {
1062 const size_t startSize = blob->size();
1063 blob->push_back(0);
1064 blob->push_back(idResultType1);
1065 blob->push_back(idResult2);
1066 blob->push_back(sampledImage);
1067 blob->push_back(coordinate);
1068 blob->push_back(dref);
1069 blob->push_back(imageOperands6);
1070 for (const auto &operand : imageOperandIdsList)
1071 {
1072 blob->push_back(operand);
1073 }
1074 (*blob)[startSize] =
1075 MakeLengthOp(blob->size() - startSize, spv::OpImageSampleProjDrefExplicitLod);
1076 }
WriteImageFetch(Blob * blob,IdResultType idResultType1,IdResult idResult2,IdRef image,IdRef coordinate,const spv::ImageOperandsMask * imageOperands5,const IdRefList & imageOperandIdsList)1077 void WriteImageFetch(Blob *blob,
1078 IdResultType idResultType1,
1079 IdResult idResult2,
1080 IdRef image,
1081 IdRef coordinate,
1082 const spv::ImageOperandsMask *imageOperands5,
1083 const IdRefList &imageOperandIdsList)
1084 {
1085 const size_t startSize = blob->size();
1086 blob->push_back(0);
1087 blob->push_back(idResultType1);
1088 blob->push_back(idResult2);
1089 blob->push_back(image);
1090 blob->push_back(coordinate);
1091 if (imageOperands5)
1092 {
1093 blob->push_back(*imageOperands5);
1094 }
1095 for (const auto &operand : imageOperandIdsList)
1096 {
1097 blob->push_back(operand);
1098 }
1099 (*blob)[startSize] = MakeLengthOp(blob->size() - startSize, spv::OpImageFetch);
1100 }
WriteImageGather(Blob * blob,IdResultType idResultType1,IdResult idResult2,IdRef sampledImage,IdRef coordinate,IdRef component,const spv::ImageOperandsMask * imageOperands6,const IdRefList & imageOperandIdsList)1101 void WriteImageGather(Blob *blob,
1102 IdResultType idResultType1,
1103 IdResult idResult2,
1104 IdRef sampledImage,
1105 IdRef coordinate,
1106 IdRef component,
1107 const spv::ImageOperandsMask *imageOperands6,
1108 const IdRefList &imageOperandIdsList)
1109 {
1110 const size_t startSize = blob->size();
1111 blob->push_back(0);
1112 blob->push_back(idResultType1);
1113 blob->push_back(idResult2);
1114 blob->push_back(sampledImage);
1115 blob->push_back(coordinate);
1116 blob->push_back(component);
1117 if (imageOperands6)
1118 {
1119 blob->push_back(*imageOperands6);
1120 }
1121 for (const auto &operand : imageOperandIdsList)
1122 {
1123 blob->push_back(operand);
1124 }
1125 (*blob)[startSize] = MakeLengthOp(blob->size() - startSize, spv::OpImageGather);
1126 }
WriteImageDrefGather(Blob * blob,IdResultType idResultType1,IdResult idResult2,IdRef sampledImage,IdRef coordinate,IdRef dref,const spv::ImageOperandsMask * imageOperands6,const IdRefList & imageOperandIdsList)1127 void WriteImageDrefGather(Blob *blob,
1128 IdResultType idResultType1,
1129 IdResult idResult2,
1130 IdRef sampledImage,
1131 IdRef coordinate,
1132 IdRef dref,
1133 const spv::ImageOperandsMask *imageOperands6,
1134 const IdRefList &imageOperandIdsList)
1135 {
1136 const size_t startSize = blob->size();
1137 blob->push_back(0);
1138 blob->push_back(idResultType1);
1139 blob->push_back(idResult2);
1140 blob->push_back(sampledImage);
1141 blob->push_back(coordinate);
1142 blob->push_back(dref);
1143 if (imageOperands6)
1144 {
1145 blob->push_back(*imageOperands6);
1146 }
1147 for (const auto &operand : imageOperandIdsList)
1148 {
1149 blob->push_back(operand);
1150 }
1151 (*blob)[startSize] = MakeLengthOp(blob->size() - startSize, spv::OpImageDrefGather);
1152 }
WriteImageRead(Blob * blob,IdResultType idResultType1,IdResult idResult2,IdRef image,IdRef coordinate,const spv::ImageOperandsMask * imageOperands5,const IdRefList & imageOperandIdsList)1153 void WriteImageRead(Blob *blob,
1154 IdResultType idResultType1,
1155 IdResult idResult2,
1156 IdRef image,
1157 IdRef coordinate,
1158 const spv::ImageOperandsMask *imageOperands5,
1159 const IdRefList &imageOperandIdsList)
1160 {
1161 const size_t startSize = blob->size();
1162 blob->push_back(0);
1163 blob->push_back(idResultType1);
1164 blob->push_back(idResult2);
1165 blob->push_back(image);
1166 blob->push_back(coordinate);
1167 if (imageOperands5)
1168 {
1169 blob->push_back(*imageOperands5);
1170 }
1171 for (const auto &operand : imageOperandIdsList)
1172 {
1173 blob->push_back(operand);
1174 }
1175 (*blob)[startSize] = MakeLengthOp(blob->size() - startSize, spv::OpImageRead);
1176 }
WriteImageWrite(Blob * blob,IdRef image,IdRef coordinate,IdRef texel,const spv::ImageOperandsMask * imageOperands4,const IdRefList & imageOperandIdsList)1177 void WriteImageWrite(Blob *blob,
1178 IdRef image,
1179 IdRef coordinate,
1180 IdRef texel,
1181 const spv::ImageOperandsMask *imageOperands4,
1182 const IdRefList &imageOperandIdsList)
1183 {
1184 const size_t startSize = blob->size();
1185 blob->push_back(0);
1186 blob->push_back(image);
1187 blob->push_back(coordinate);
1188 blob->push_back(texel);
1189 if (imageOperands4)
1190 {
1191 blob->push_back(*imageOperands4);
1192 }
1193 for (const auto &operand : imageOperandIdsList)
1194 {
1195 blob->push_back(operand);
1196 }
1197 (*blob)[startSize] = MakeLengthOp(blob->size() - startSize, spv::OpImageWrite);
1198 }
WriteImage(Blob * blob,IdResultType idResultType1,IdResult idResult2,IdRef sampledImage)1199 void WriteImage(Blob *blob, IdResultType idResultType1, IdResult idResult2, IdRef sampledImage)
1200 {
1201 const size_t startSize = blob->size();
1202 blob->push_back(0);
1203 blob->push_back(idResultType1);
1204 blob->push_back(idResult2);
1205 blob->push_back(sampledImage);
1206 (*blob)[startSize] = MakeLengthOp(blob->size() - startSize, spv::OpImage);
1207 }
WriteImageQuerySizeLod(Blob * blob,IdResultType idResultType1,IdResult idResult2,IdRef image,IdRef levelofDetail)1208 void WriteImageQuerySizeLod(Blob *blob,
1209 IdResultType idResultType1,
1210 IdResult idResult2,
1211 IdRef image,
1212 IdRef levelofDetail)
1213 {
1214 const size_t startSize = blob->size();
1215 blob->push_back(0);
1216 blob->push_back(idResultType1);
1217 blob->push_back(idResult2);
1218 blob->push_back(image);
1219 blob->push_back(levelofDetail);
1220 (*blob)[startSize] = MakeLengthOp(blob->size() - startSize, spv::OpImageQuerySizeLod);
1221 }
WriteImageQuerySize(Blob * blob,IdResultType idResultType1,IdResult idResult2,IdRef image)1222 void WriteImageQuerySize(Blob *blob, IdResultType idResultType1, IdResult idResult2, IdRef image)
1223 {
1224 const size_t startSize = blob->size();
1225 blob->push_back(0);
1226 blob->push_back(idResultType1);
1227 blob->push_back(idResult2);
1228 blob->push_back(image);
1229 (*blob)[startSize] = MakeLengthOp(blob->size() - startSize, spv::OpImageQuerySize);
1230 }
WriteImageQueryLod(Blob * blob,IdResultType idResultType1,IdResult idResult2,IdRef sampledImage,IdRef coordinate)1231 void WriteImageQueryLod(Blob *blob,
1232 IdResultType idResultType1,
1233 IdResult idResult2,
1234 IdRef sampledImage,
1235 IdRef coordinate)
1236 {
1237 const size_t startSize = blob->size();
1238 blob->push_back(0);
1239 blob->push_back(idResultType1);
1240 blob->push_back(idResult2);
1241 blob->push_back(sampledImage);
1242 blob->push_back(coordinate);
1243 (*blob)[startSize] = MakeLengthOp(blob->size() - startSize, spv::OpImageQueryLod);
1244 }
WriteImageQueryLevels(Blob * blob,IdResultType idResultType1,IdResult idResult2,IdRef image)1245 void WriteImageQueryLevels(Blob *blob, IdResultType idResultType1, IdResult idResult2, IdRef image)
1246 {
1247 const size_t startSize = blob->size();
1248 blob->push_back(0);
1249 blob->push_back(idResultType1);
1250 blob->push_back(idResult2);
1251 blob->push_back(image);
1252 (*blob)[startSize] = MakeLengthOp(blob->size() - startSize, spv::OpImageQueryLevels);
1253 }
WriteImageQuerySamples(Blob * blob,IdResultType idResultType1,IdResult idResult2,IdRef image)1254 void WriteImageQuerySamples(Blob *blob, IdResultType idResultType1, IdResult idResult2, IdRef image)
1255 {
1256 const size_t startSize = blob->size();
1257 blob->push_back(0);
1258 blob->push_back(idResultType1);
1259 blob->push_back(idResult2);
1260 blob->push_back(image);
1261 (*blob)[startSize] = MakeLengthOp(blob->size() - startSize, spv::OpImageQuerySamples);
1262 }
WriteConvertFToU(Blob * blob,IdResultType idResultType1,IdResult idResult2,IdRef floatValue)1263 void WriteConvertFToU(Blob *blob, IdResultType idResultType1, IdResult idResult2, IdRef floatValue)
1264 {
1265 const size_t startSize = blob->size();
1266 blob->push_back(0);
1267 blob->push_back(idResultType1);
1268 blob->push_back(idResult2);
1269 blob->push_back(floatValue);
1270 (*blob)[startSize] = MakeLengthOp(blob->size() - startSize, spv::OpConvertFToU);
1271 }
WriteConvertFToS(Blob * blob,IdResultType idResultType1,IdResult idResult2,IdRef floatValue)1272 void WriteConvertFToS(Blob *blob, IdResultType idResultType1, IdResult idResult2, IdRef floatValue)
1273 {
1274 const size_t startSize = blob->size();
1275 blob->push_back(0);
1276 blob->push_back(idResultType1);
1277 blob->push_back(idResult2);
1278 blob->push_back(floatValue);
1279 (*blob)[startSize] = MakeLengthOp(blob->size() - startSize, spv::OpConvertFToS);
1280 }
WriteConvertSToF(Blob * blob,IdResultType idResultType1,IdResult idResult2,IdRef signedValue)1281 void WriteConvertSToF(Blob *blob, IdResultType idResultType1, IdResult idResult2, IdRef signedValue)
1282 {
1283 const size_t startSize = blob->size();
1284 blob->push_back(0);
1285 blob->push_back(idResultType1);
1286 blob->push_back(idResult2);
1287 blob->push_back(signedValue);
1288 (*blob)[startSize] = MakeLengthOp(blob->size() - startSize, spv::OpConvertSToF);
1289 }
WriteConvertUToF(Blob * blob,IdResultType idResultType1,IdResult idResult2,IdRef unsignedValue)1290 void WriteConvertUToF(Blob *blob,
1291 IdResultType idResultType1,
1292 IdResult idResult2,
1293 IdRef unsignedValue)
1294 {
1295 const size_t startSize = blob->size();
1296 blob->push_back(0);
1297 blob->push_back(idResultType1);
1298 blob->push_back(idResult2);
1299 blob->push_back(unsignedValue);
1300 (*blob)[startSize] = MakeLengthOp(blob->size() - startSize, spv::OpConvertUToF);
1301 }
WriteUConvert(Blob * blob,IdResultType idResultType1,IdResult idResult2,IdRef unsignedValue)1302 void WriteUConvert(Blob *blob, IdResultType idResultType1, IdResult idResult2, IdRef unsignedValue)
1303 {
1304 const size_t startSize = blob->size();
1305 blob->push_back(0);
1306 blob->push_back(idResultType1);
1307 blob->push_back(idResult2);
1308 blob->push_back(unsignedValue);
1309 (*blob)[startSize] = MakeLengthOp(blob->size() - startSize, spv::OpUConvert);
1310 }
WriteSConvert(Blob * blob,IdResultType idResultType1,IdResult idResult2,IdRef signedValue)1311 void WriteSConvert(Blob *blob, IdResultType idResultType1, IdResult idResult2, IdRef signedValue)
1312 {
1313 const size_t startSize = blob->size();
1314 blob->push_back(0);
1315 blob->push_back(idResultType1);
1316 blob->push_back(idResult2);
1317 blob->push_back(signedValue);
1318 (*blob)[startSize] = MakeLengthOp(blob->size() - startSize, spv::OpSConvert);
1319 }
WriteFConvert(Blob * blob,IdResultType idResultType1,IdResult idResult2,IdRef floatValue)1320 void WriteFConvert(Blob *blob, IdResultType idResultType1, IdResult idResult2, IdRef floatValue)
1321 {
1322 const size_t startSize = blob->size();
1323 blob->push_back(0);
1324 blob->push_back(idResultType1);
1325 blob->push_back(idResult2);
1326 blob->push_back(floatValue);
1327 (*blob)[startSize] = MakeLengthOp(blob->size() - startSize, spv::OpFConvert);
1328 }
WriteQuantizeToF16(Blob * blob,IdResultType idResultType1,IdResult idResult2,IdRef value)1329 void WriteQuantizeToF16(Blob *blob, IdResultType idResultType1, IdResult idResult2, IdRef value)
1330 {
1331 const size_t startSize = blob->size();
1332 blob->push_back(0);
1333 blob->push_back(idResultType1);
1334 blob->push_back(idResult2);
1335 blob->push_back(value);
1336 (*blob)[startSize] = MakeLengthOp(blob->size() - startSize, spv::OpQuantizeToF16);
1337 }
WriteBitcast(Blob * blob,IdResultType idResultType1,IdResult idResult2,IdRef operand)1338 void WriteBitcast(Blob *blob, IdResultType idResultType1, IdResult idResult2, IdRef operand)
1339 {
1340 const size_t startSize = blob->size();
1341 blob->push_back(0);
1342 blob->push_back(idResultType1);
1343 blob->push_back(idResult2);
1344 blob->push_back(operand);
1345 (*blob)[startSize] = MakeLengthOp(blob->size() - startSize, spv::OpBitcast);
1346 }
WriteSNegate(Blob * blob,IdResultType idResultType1,IdResult idResult2,IdRef operand)1347 void WriteSNegate(Blob *blob, IdResultType idResultType1, IdResult idResult2, IdRef operand)
1348 {
1349 const size_t startSize = blob->size();
1350 blob->push_back(0);
1351 blob->push_back(idResultType1);
1352 blob->push_back(idResult2);
1353 blob->push_back(operand);
1354 (*blob)[startSize] = MakeLengthOp(blob->size() - startSize, spv::OpSNegate);
1355 }
WriteFNegate(Blob * blob,IdResultType idResultType1,IdResult idResult2,IdRef operand)1356 void WriteFNegate(Blob *blob, IdResultType idResultType1, IdResult idResult2, IdRef operand)
1357 {
1358 const size_t startSize = blob->size();
1359 blob->push_back(0);
1360 blob->push_back(idResultType1);
1361 blob->push_back(idResult2);
1362 blob->push_back(operand);
1363 (*blob)[startSize] = MakeLengthOp(blob->size() - startSize, spv::OpFNegate);
1364 }
WriteIAdd(Blob * blob,IdResultType idResultType1,IdResult idResult2,IdRef operand1,IdRef operand2)1365 void WriteIAdd(Blob *blob,
1366 IdResultType idResultType1,
1367 IdResult idResult2,
1368 IdRef operand1,
1369 IdRef operand2)
1370 {
1371 const size_t startSize = blob->size();
1372 blob->push_back(0);
1373 blob->push_back(idResultType1);
1374 blob->push_back(idResult2);
1375 blob->push_back(operand1);
1376 blob->push_back(operand2);
1377 (*blob)[startSize] = MakeLengthOp(blob->size() - startSize, spv::OpIAdd);
1378 }
WriteFAdd(Blob * blob,IdResultType idResultType1,IdResult idResult2,IdRef operand1,IdRef operand2)1379 void WriteFAdd(Blob *blob,
1380 IdResultType idResultType1,
1381 IdResult idResult2,
1382 IdRef operand1,
1383 IdRef operand2)
1384 {
1385 const size_t startSize = blob->size();
1386 blob->push_back(0);
1387 blob->push_back(idResultType1);
1388 blob->push_back(idResult2);
1389 blob->push_back(operand1);
1390 blob->push_back(operand2);
1391 (*blob)[startSize] = MakeLengthOp(blob->size() - startSize, spv::OpFAdd);
1392 }
WriteISub(Blob * blob,IdResultType idResultType1,IdResult idResult2,IdRef operand1,IdRef operand2)1393 void WriteISub(Blob *blob,
1394 IdResultType idResultType1,
1395 IdResult idResult2,
1396 IdRef operand1,
1397 IdRef operand2)
1398 {
1399 const size_t startSize = blob->size();
1400 blob->push_back(0);
1401 blob->push_back(idResultType1);
1402 blob->push_back(idResult2);
1403 blob->push_back(operand1);
1404 blob->push_back(operand2);
1405 (*blob)[startSize] = MakeLengthOp(blob->size() - startSize, spv::OpISub);
1406 }
WriteFSub(Blob * blob,IdResultType idResultType1,IdResult idResult2,IdRef operand1,IdRef operand2)1407 void WriteFSub(Blob *blob,
1408 IdResultType idResultType1,
1409 IdResult idResult2,
1410 IdRef operand1,
1411 IdRef operand2)
1412 {
1413 const size_t startSize = blob->size();
1414 blob->push_back(0);
1415 blob->push_back(idResultType1);
1416 blob->push_back(idResult2);
1417 blob->push_back(operand1);
1418 blob->push_back(operand2);
1419 (*blob)[startSize] = MakeLengthOp(blob->size() - startSize, spv::OpFSub);
1420 }
WriteIMul(Blob * blob,IdResultType idResultType1,IdResult idResult2,IdRef operand1,IdRef operand2)1421 void WriteIMul(Blob *blob,
1422 IdResultType idResultType1,
1423 IdResult idResult2,
1424 IdRef operand1,
1425 IdRef operand2)
1426 {
1427 const size_t startSize = blob->size();
1428 blob->push_back(0);
1429 blob->push_back(idResultType1);
1430 blob->push_back(idResult2);
1431 blob->push_back(operand1);
1432 blob->push_back(operand2);
1433 (*blob)[startSize] = MakeLengthOp(blob->size() - startSize, spv::OpIMul);
1434 }
WriteFMul(Blob * blob,IdResultType idResultType1,IdResult idResult2,IdRef operand1,IdRef operand2)1435 void WriteFMul(Blob *blob,
1436 IdResultType idResultType1,
1437 IdResult idResult2,
1438 IdRef operand1,
1439 IdRef operand2)
1440 {
1441 const size_t startSize = blob->size();
1442 blob->push_back(0);
1443 blob->push_back(idResultType1);
1444 blob->push_back(idResult2);
1445 blob->push_back(operand1);
1446 blob->push_back(operand2);
1447 (*blob)[startSize] = MakeLengthOp(blob->size() - startSize, spv::OpFMul);
1448 }
WriteUDiv(Blob * blob,IdResultType idResultType1,IdResult idResult2,IdRef operand1,IdRef operand2)1449 void WriteUDiv(Blob *blob,
1450 IdResultType idResultType1,
1451 IdResult idResult2,
1452 IdRef operand1,
1453 IdRef operand2)
1454 {
1455 const size_t startSize = blob->size();
1456 blob->push_back(0);
1457 blob->push_back(idResultType1);
1458 blob->push_back(idResult2);
1459 blob->push_back(operand1);
1460 blob->push_back(operand2);
1461 (*blob)[startSize] = MakeLengthOp(blob->size() - startSize, spv::OpUDiv);
1462 }
WriteSDiv(Blob * blob,IdResultType idResultType1,IdResult idResult2,IdRef operand1,IdRef operand2)1463 void WriteSDiv(Blob *blob,
1464 IdResultType idResultType1,
1465 IdResult idResult2,
1466 IdRef operand1,
1467 IdRef operand2)
1468 {
1469 const size_t startSize = blob->size();
1470 blob->push_back(0);
1471 blob->push_back(idResultType1);
1472 blob->push_back(idResult2);
1473 blob->push_back(operand1);
1474 blob->push_back(operand2);
1475 (*blob)[startSize] = MakeLengthOp(blob->size() - startSize, spv::OpSDiv);
1476 }
WriteFDiv(Blob * blob,IdResultType idResultType1,IdResult idResult2,IdRef operand1,IdRef operand2)1477 void WriteFDiv(Blob *blob,
1478 IdResultType idResultType1,
1479 IdResult idResult2,
1480 IdRef operand1,
1481 IdRef operand2)
1482 {
1483 const size_t startSize = blob->size();
1484 blob->push_back(0);
1485 blob->push_back(idResultType1);
1486 blob->push_back(idResult2);
1487 blob->push_back(operand1);
1488 blob->push_back(operand2);
1489 (*blob)[startSize] = MakeLengthOp(blob->size() - startSize, spv::OpFDiv);
1490 }
WriteUMod(Blob * blob,IdResultType idResultType1,IdResult idResult2,IdRef operand1,IdRef operand2)1491 void WriteUMod(Blob *blob,
1492 IdResultType idResultType1,
1493 IdResult idResult2,
1494 IdRef operand1,
1495 IdRef operand2)
1496 {
1497 const size_t startSize = blob->size();
1498 blob->push_back(0);
1499 blob->push_back(idResultType1);
1500 blob->push_back(idResult2);
1501 blob->push_back(operand1);
1502 blob->push_back(operand2);
1503 (*blob)[startSize] = MakeLengthOp(blob->size() - startSize, spv::OpUMod);
1504 }
WriteSRem(Blob * blob,IdResultType idResultType1,IdResult idResult2,IdRef operand1,IdRef operand2)1505 void WriteSRem(Blob *blob,
1506 IdResultType idResultType1,
1507 IdResult idResult2,
1508 IdRef operand1,
1509 IdRef operand2)
1510 {
1511 const size_t startSize = blob->size();
1512 blob->push_back(0);
1513 blob->push_back(idResultType1);
1514 blob->push_back(idResult2);
1515 blob->push_back(operand1);
1516 blob->push_back(operand2);
1517 (*blob)[startSize] = MakeLengthOp(blob->size() - startSize, spv::OpSRem);
1518 }
WriteSMod(Blob * blob,IdResultType idResultType1,IdResult idResult2,IdRef operand1,IdRef operand2)1519 void WriteSMod(Blob *blob,
1520 IdResultType idResultType1,
1521 IdResult idResult2,
1522 IdRef operand1,
1523 IdRef operand2)
1524 {
1525 const size_t startSize = blob->size();
1526 blob->push_back(0);
1527 blob->push_back(idResultType1);
1528 blob->push_back(idResult2);
1529 blob->push_back(operand1);
1530 blob->push_back(operand2);
1531 (*blob)[startSize] = MakeLengthOp(blob->size() - startSize, spv::OpSMod);
1532 }
WriteFRem(Blob * blob,IdResultType idResultType1,IdResult idResult2,IdRef operand1,IdRef operand2)1533 void WriteFRem(Blob *blob,
1534 IdResultType idResultType1,
1535 IdResult idResult2,
1536 IdRef operand1,
1537 IdRef operand2)
1538 {
1539 const size_t startSize = blob->size();
1540 blob->push_back(0);
1541 blob->push_back(idResultType1);
1542 blob->push_back(idResult2);
1543 blob->push_back(operand1);
1544 blob->push_back(operand2);
1545 (*blob)[startSize] = MakeLengthOp(blob->size() - startSize, spv::OpFRem);
1546 }
WriteFMod(Blob * blob,IdResultType idResultType1,IdResult idResult2,IdRef operand1,IdRef operand2)1547 void WriteFMod(Blob *blob,
1548 IdResultType idResultType1,
1549 IdResult idResult2,
1550 IdRef operand1,
1551 IdRef operand2)
1552 {
1553 const size_t startSize = blob->size();
1554 blob->push_back(0);
1555 blob->push_back(idResultType1);
1556 blob->push_back(idResult2);
1557 blob->push_back(operand1);
1558 blob->push_back(operand2);
1559 (*blob)[startSize] = MakeLengthOp(blob->size() - startSize, spv::OpFMod);
1560 }
WriteVectorTimesScalar(Blob * blob,IdResultType idResultType1,IdResult idResult2,IdRef vector,IdRef scalar)1561 void WriteVectorTimesScalar(Blob *blob,
1562 IdResultType idResultType1,
1563 IdResult idResult2,
1564 IdRef vector,
1565 IdRef scalar)
1566 {
1567 const size_t startSize = blob->size();
1568 blob->push_back(0);
1569 blob->push_back(idResultType1);
1570 blob->push_back(idResult2);
1571 blob->push_back(vector);
1572 blob->push_back(scalar);
1573 (*blob)[startSize] = MakeLengthOp(blob->size() - startSize, spv::OpVectorTimesScalar);
1574 }
WriteMatrixTimesScalar(Blob * blob,IdResultType idResultType1,IdResult idResult2,IdRef matrix,IdRef scalar)1575 void WriteMatrixTimesScalar(Blob *blob,
1576 IdResultType idResultType1,
1577 IdResult idResult2,
1578 IdRef matrix,
1579 IdRef scalar)
1580 {
1581 const size_t startSize = blob->size();
1582 blob->push_back(0);
1583 blob->push_back(idResultType1);
1584 blob->push_back(idResult2);
1585 blob->push_back(matrix);
1586 blob->push_back(scalar);
1587 (*blob)[startSize] = MakeLengthOp(blob->size() - startSize, spv::OpMatrixTimesScalar);
1588 }
WriteVectorTimesMatrix(Blob * blob,IdResultType idResultType1,IdResult idResult2,IdRef vector,IdRef matrix)1589 void WriteVectorTimesMatrix(Blob *blob,
1590 IdResultType idResultType1,
1591 IdResult idResult2,
1592 IdRef vector,
1593 IdRef matrix)
1594 {
1595 const size_t startSize = blob->size();
1596 blob->push_back(0);
1597 blob->push_back(idResultType1);
1598 blob->push_back(idResult2);
1599 blob->push_back(vector);
1600 blob->push_back(matrix);
1601 (*blob)[startSize] = MakeLengthOp(blob->size() - startSize, spv::OpVectorTimesMatrix);
1602 }
WriteMatrixTimesVector(Blob * blob,IdResultType idResultType1,IdResult idResult2,IdRef matrix,IdRef vector)1603 void WriteMatrixTimesVector(Blob *blob,
1604 IdResultType idResultType1,
1605 IdResult idResult2,
1606 IdRef matrix,
1607 IdRef vector)
1608 {
1609 const size_t startSize = blob->size();
1610 blob->push_back(0);
1611 blob->push_back(idResultType1);
1612 blob->push_back(idResult2);
1613 blob->push_back(matrix);
1614 blob->push_back(vector);
1615 (*blob)[startSize] = MakeLengthOp(blob->size() - startSize, spv::OpMatrixTimesVector);
1616 }
WriteMatrixTimesMatrix(Blob * blob,IdResultType idResultType1,IdResult idResult2,IdRef leftMatrix,IdRef rightMatrix)1617 void WriteMatrixTimesMatrix(Blob *blob,
1618 IdResultType idResultType1,
1619 IdResult idResult2,
1620 IdRef leftMatrix,
1621 IdRef rightMatrix)
1622 {
1623 const size_t startSize = blob->size();
1624 blob->push_back(0);
1625 blob->push_back(idResultType1);
1626 blob->push_back(idResult2);
1627 blob->push_back(leftMatrix);
1628 blob->push_back(rightMatrix);
1629 (*blob)[startSize] = MakeLengthOp(blob->size() - startSize, spv::OpMatrixTimesMatrix);
1630 }
WriteOuterProduct(Blob * blob,IdResultType idResultType1,IdResult idResult2,IdRef vector1,IdRef vector2)1631 void WriteOuterProduct(Blob *blob,
1632 IdResultType idResultType1,
1633 IdResult idResult2,
1634 IdRef vector1,
1635 IdRef vector2)
1636 {
1637 const size_t startSize = blob->size();
1638 blob->push_back(0);
1639 blob->push_back(idResultType1);
1640 blob->push_back(idResult2);
1641 blob->push_back(vector1);
1642 blob->push_back(vector2);
1643 (*blob)[startSize] = MakeLengthOp(blob->size() - startSize, spv::OpOuterProduct);
1644 }
WriteDot(Blob * blob,IdResultType idResultType1,IdResult idResult2,IdRef vector1,IdRef vector2)1645 void WriteDot(Blob *blob,
1646 IdResultType idResultType1,
1647 IdResult idResult2,
1648 IdRef vector1,
1649 IdRef vector2)
1650 {
1651 const size_t startSize = blob->size();
1652 blob->push_back(0);
1653 blob->push_back(idResultType1);
1654 blob->push_back(idResult2);
1655 blob->push_back(vector1);
1656 blob->push_back(vector2);
1657 (*blob)[startSize] = MakeLengthOp(blob->size() - startSize, spv::OpDot);
1658 }
WriteIAddCarry(Blob * blob,IdResultType idResultType1,IdResult idResult2,IdRef operand1,IdRef operand2)1659 void WriteIAddCarry(Blob *blob,
1660 IdResultType idResultType1,
1661 IdResult idResult2,
1662 IdRef operand1,
1663 IdRef operand2)
1664 {
1665 const size_t startSize = blob->size();
1666 blob->push_back(0);
1667 blob->push_back(idResultType1);
1668 blob->push_back(idResult2);
1669 blob->push_back(operand1);
1670 blob->push_back(operand2);
1671 (*blob)[startSize] = MakeLengthOp(blob->size() - startSize, spv::OpIAddCarry);
1672 }
WriteISubBorrow(Blob * blob,IdResultType idResultType1,IdResult idResult2,IdRef operand1,IdRef operand2)1673 void WriteISubBorrow(Blob *blob,
1674 IdResultType idResultType1,
1675 IdResult idResult2,
1676 IdRef operand1,
1677 IdRef operand2)
1678 {
1679 const size_t startSize = blob->size();
1680 blob->push_back(0);
1681 blob->push_back(idResultType1);
1682 blob->push_back(idResult2);
1683 blob->push_back(operand1);
1684 blob->push_back(operand2);
1685 (*blob)[startSize] = MakeLengthOp(blob->size() - startSize, spv::OpISubBorrow);
1686 }
WriteUMulExtended(Blob * blob,IdResultType idResultType1,IdResult idResult2,IdRef operand1,IdRef operand2)1687 void WriteUMulExtended(Blob *blob,
1688 IdResultType idResultType1,
1689 IdResult idResult2,
1690 IdRef operand1,
1691 IdRef operand2)
1692 {
1693 const size_t startSize = blob->size();
1694 blob->push_back(0);
1695 blob->push_back(idResultType1);
1696 blob->push_back(idResult2);
1697 blob->push_back(operand1);
1698 blob->push_back(operand2);
1699 (*blob)[startSize] = MakeLengthOp(blob->size() - startSize, spv::OpUMulExtended);
1700 }
WriteSMulExtended(Blob * blob,IdResultType idResultType1,IdResult idResult2,IdRef operand1,IdRef operand2)1701 void WriteSMulExtended(Blob *blob,
1702 IdResultType idResultType1,
1703 IdResult idResult2,
1704 IdRef operand1,
1705 IdRef operand2)
1706 {
1707 const size_t startSize = blob->size();
1708 blob->push_back(0);
1709 blob->push_back(idResultType1);
1710 blob->push_back(idResult2);
1711 blob->push_back(operand1);
1712 blob->push_back(operand2);
1713 (*blob)[startSize] = MakeLengthOp(blob->size() - startSize, spv::OpSMulExtended);
1714 }
WriteAny(Blob * blob,IdResultType idResultType1,IdResult idResult2,IdRef vector)1715 void WriteAny(Blob *blob, IdResultType idResultType1, IdResult idResult2, IdRef vector)
1716 {
1717 const size_t startSize = blob->size();
1718 blob->push_back(0);
1719 blob->push_back(idResultType1);
1720 blob->push_back(idResult2);
1721 blob->push_back(vector);
1722 (*blob)[startSize] = MakeLengthOp(blob->size() - startSize, spv::OpAny);
1723 }
WriteAll(Blob * blob,IdResultType idResultType1,IdResult idResult2,IdRef vector)1724 void WriteAll(Blob *blob, IdResultType idResultType1, IdResult idResult2, IdRef vector)
1725 {
1726 const size_t startSize = blob->size();
1727 blob->push_back(0);
1728 blob->push_back(idResultType1);
1729 blob->push_back(idResult2);
1730 blob->push_back(vector);
1731 (*blob)[startSize] = MakeLengthOp(blob->size() - startSize, spv::OpAll);
1732 }
WriteIsNan(Blob * blob,IdResultType idResultType1,IdResult idResult2,IdRef x)1733 void WriteIsNan(Blob *blob, IdResultType idResultType1, IdResult idResult2, IdRef x)
1734 {
1735 const size_t startSize = blob->size();
1736 blob->push_back(0);
1737 blob->push_back(idResultType1);
1738 blob->push_back(idResult2);
1739 blob->push_back(x);
1740 (*blob)[startSize] = MakeLengthOp(blob->size() - startSize, spv::OpIsNan);
1741 }
WriteIsInf(Blob * blob,IdResultType idResultType1,IdResult idResult2,IdRef x)1742 void WriteIsInf(Blob *blob, IdResultType idResultType1, IdResult idResult2, IdRef x)
1743 {
1744 const size_t startSize = blob->size();
1745 blob->push_back(0);
1746 blob->push_back(idResultType1);
1747 blob->push_back(idResult2);
1748 blob->push_back(x);
1749 (*blob)[startSize] = MakeLengthOp(blob->size() - startSize, spv::OpIsInf);
1750 }
WriteLogicalEqual(Blob * blob,IdResultType idResultType1,IdResult idResult2,IdRef operand1,IdRef operand2)1751 void WriteLogicalEqual(Blob *blob,
1752 IdResultType idResultType1,
1753 IdResult idResult2,
1754 IdRef operand1,
1755 IdRef operand2)
1756 {
1757 const size_t startSize = blob->size();
1758 blob->push_back(0);
1759 blob->push_back(idResultType1);
1760 blob->push_back(idResult2);
1761 blob->push_back(operand1);
1762 blob->push_back(operand2);
1763 (*blob)[startSize] = MakeLengthOp(blob->size() - startSize, spv::OpLogicalEqual);
1764 }
WriteLogicalNotEqual(Blob * blob,IdResultType idResultType1,IdResult idResult2,IdRef operand1,IdRef operand2)1765 void WriteLogicalNotEqual(Blob *blob,
1766 IdResultType idResultType1,
1767 IdResult idResult2,
1768 IdRef operand1,
1769 IdRef operand2)
1770 {
1771 const size_t startSize = blob->size();
1772 blob->push_back(0);
1773 blob->push_back(idResultType1);
1774 blob->push_back(idResult2);
1775 blob->push_back(operand1);
1776 blob->push_back(operand2);
1777 (*blob)[startSize] = MakeLengthOp(blob->size() - startSize, spv::OpLogicalNotEqual);
1778 }
WriteLogicalOr(Blob * blob,IdResultType idResultType1,IdResult idResult2,IdRef operand1,IdRef operand2)1779 void WriteLogicalOr(Blob *blob,
1780 IdResultType idResultType1,
1781 IdResult idResult2,
1782 IdRef operand1,
1783 IdRef operand2)
1784 {
1785 const size_t startSize = blob->size();
1786 blob->push_back(0);
1787 blob->push_back(idResultType1);
1788 blob->push_back(idResult2);
1789 blob->push_back(operand1);
1790 blob->push_back(operand2);
1791 (*blob)[startSize] = MakeLengthOp(blob->size() - startSize, spv::OpLogicalOr);
1792 }
WriteLogicalAnd(Blob * blob,IdResultType idResultType1,IdResult idResult2,IdRef operand1,IdRef operand2)1793 void WriteLogicalAnd(Blob *blob,
1794 IdResultType idResultType1,
1795 IdResult idResult2,
1796 IdRef operand1,
1797 IdRef operand2)
1798 {
1799 const size_t startSize = blob->size();
1800 blob->push_back(0);
1801 blob->push_back(idResultType1);
1802 blob->push_back(idResult2);
1803 blob->push_back(operand1);
1804 blob->push_back(operand2);
1805 (*blob)[startSize] = MakeLengthOp(blob->size() - startSize, spv::OpLogicalAnd);
1806 }
WriteLogicalNot(Blob * blob,IdResultType idResultType1,IdResult idResult2,IdRef operand)1807 void WriteLogicalNot(Blob *blob, IdResultType idResultType1, IdResult idResult2, IdRef operand)
1808 {
1809 const size_t startSize = blob->size();
1810 blob->push_back(0);
1811 blob->push_back(idResultType1);
1812 blob->push_back(idResult2);
1813 blob->push_back(operand);
1814 (*blob)[startSize] = MakeLengthOp(blob->size() - startSize, spv::OpLogicalNot);
1815 }
WriteSelect(Blob * blob,IdResultType idResultType1,IdResult idResult2,IdRef condition,IdRef object1,IdRef object2)1816 void WriteSelect(Blob *blob,
1817 IdResultType idResultType1,
1818 IdResult idResult2,
1819 IdRef condition,
1820 IdRef object1,
1821 IdRef object2)
1822 {
1823 const size_t startSize = blob->size();
1824 blob->push_back(0);
1825 blob->push_back(idResultType1);
1826 blob->push_back(idResult2);
1827 blob->push_back(condition);
1828 blob->push_back(object1);
1829 blob->push_back(object2);
1830 (*blob)[startSize] = MakeLengthOp(blob->size() - startSize, spv::OpSelect);
1831 }
WriteIEqual(Blob * blob,IdResultType idResultType1,IdResult idResult2,IdRef operand1,IdRef operand2)1832 void WriteIEqual(Blob *blob,
1833 IdResultType idResultType1,
1834 IdResult idResult2,
1835 IdRef operand1,
1836 IdRef operand2)
1837 {
1838 const size_t startSize = blob->size();
1839 blob->push_back(0);
1840 blob->push_back(idResultType1);
1841 blob->push_back(idResult2);
1842 blob->push_back(operand1);
1843 blob->push_back(operand2);
1844 (*blob)[startSize] = MakeLengthOp(blob->size() - startSize, spv::OpIEqual);
1845 }
WriteINotEqual(Blob * blob,IdResultType idResultType1,IdResult idResult2,IdRef operand1,IdRef operand2)1846 void WriteINotEqual(Blob *blob,
1847 IdResultType idResultType1,
1848 IdResult idResult2,
1849 IdRef operand1,
1850 IdRef operand2)
1851 {
1852 const size_t startSize = blob->size();
1853 blob->push_back(0);
1854 blob->push_back(idResultType1);
1855 blob->push_back(idResult2);
1856 blob->push_back(operand1);
1857 blob->push_back(operand2);
1858 (*blob)[startSize] = MakeLengthOp(blob->size() - startSize, spv::OpINotEqual);
1859 }
WriteUGreaterThan(Blob * blob,IdResultType idResultType1,IdResult idResult2,IdRef operand1,IdRef operand2)1860 void WriteUGreaterThan(Blob *blob,
1861 IdResultType idResultType1,
1862 IdResult idResult2,
1863 IdRef operand1,
1864 IdRef operand2)
1865 {
1866 const size_t startSize = blob->size();
1867 blob->push_back(0);
1868 blob->push_back(idResultType1);
1869 blob->push_back(idResult2);
1870 blob->push_back(operand1);
1871 blob->push_back(operand2);
1872 (*blob)[startSize] = MakeLengthOp(blob->size() - startSize, spv::OpUGreaterThan);
1873 }
WriteSGreaterThan(Blob * blob,IdResultType idResultType1,IdResult idResult2,IdRef operand1,IdRef operand2)1874 void WriteSGreaterThan(Blob *blob,
1875 IdResultType idResultType1,
1876 IdResult idResult2,
1877 IdRef operand1,
1878 IdRef operand2)
1879 {
1880 const size_t startSize = blob->size();
1881 blob->push_back(0);
1882 blob->push_back(idResultType1);
1883 blob->push_back(idResult2);
1884 blob->push_back(operand1);
1885 blob->push_back(operand2);
1886 (*blob)[startSize] = MakeLengthOp(blob->size() - startSize, spv::OpSGreaterThan);
1887 }
WriteUGreaterThanEqual(Blob * blob,IdResultType idResultType1,IdResult idResult2,IdRef operand1,IdRef operand2)1888 void WriteUGreaterThanEqual(Blob *blob,
1889 IdResultType idResultType1,
1890 IdResult idResult2,
1891 IdRef operand1,
1892 IdRef operand2)
1893 {
1894 const size_t startSize = blob->size();
1895 blob->push_back(0);
1896 blob->push_back(idResultType1);
1897 blob->push_back(idResult2);
1898 blob->push_back(operand1);
1899 blob->push_back(operand2);
1900 (*blob)[startSize] = MakeLengthOp(blob->size() - startSize, spv::OpUGreaterThanEqual);
1901 }
WriteSGreaterThanEqual(Blob * blob,IdResultType idResultType1,IdResult idResult2,IdRef operand1,IdRef operand2)1902 void WriteSGreaterThanEqual(Blob *blob,
1903 IdResultType idResultType1,
1904 IdResult idResult2,
1905 IdRef operand1,
1906 IdRef operand2)
1907 {
1908 const size_t startSize = blob->size();
1909 blob->push_back(0);
1910 blob->push_back(idResultType1);
1911 blob->push_back(idResult2);
1912 blob->push_back(operand1);
1913 blob->push_back(operand2);
1914 (*blob)[startSize] = MakeLengthOp(blob->size() - startSize, spv::OpSGreaterThanEqual);
1915 }
WriteULessThan(Blob * blob,IdResultType idResultType1,IdResult idResult2,IdRef operand1,IdRef operand2)1916 void WriteULessThan(Blob *blob,
1917 IdResultType idResultType1,
1918 IdResult idResult2,
1919 IdRef operand1,
1920 IdRef operand2)
1921 {
1922 const size_t startSize = blob->size();
1923 blob->push_back(0);
1924 blob->push_back(idResultType1);
1925 blob->push_back(idResult2);
1926 blob->push_back(operand1);
1927 blob->push_back(operand2);
1928 (*blob)[startSize] = MakeLengthOp(blob->size() - startSize, spv::OpULessThan);
1929 }
WriteSLessThan(Blob * blob,IdResultType idResultType1,IdResult idResult2,IdRef operand1,IdRef operand2)1930 void WriteSLessThan(Blob *blob,
1931 IdResultType idResultType1,
1932 IdResult idResult2,
1933 IdRef operand1,
1934 IdRef operand2)
1935 {
1936 const size_t startSize = blob->size();
1937 blob->push_back(0);
1938 blob->push_back(idResultType1);
1939 blob->push_back(idResult2);
1940 blob->push_back(operand1);
1941 blob->push_back(operand2);
1942 (*blob)[startSize] = MakeLengthOp(blob->size() - startSize, spv::OpSLessThan);
1943 }
WriteULessThanEqual(Blob * blob,IdResultType idResultType1,IdResult idResult2,IdRef operand1,IdRef operand2)1944 void WriteULessThanEqual(Blob *blob,
1945 IdResultType idResultType1,
1946 IdResult idResult2,
1947 IdRef operand1,
1948 IdRef operand2)
1949 {
1950 const size_t startSize = blob->size();
1951 blob->push_back(0);
1952 blob->push_back(idResultType1);
1953 blob->push_back(idResult2);
1954 blob->push_back(operand1);
1955 blob->push_back(operand2);
1956 (*blob)[startSize] = MakeLengthOp(blob->size() - startSize, spv::OpULessThanEqual);
1957 }
WriteSLessThanEqual(Blob * blob,IdResultType idResultType1,IdResult idResult2,IdRef operand1,IdRef operand2)1958 void WriteSLessThanEqual(Blob *blob,
1959 IdResultType idResultType1,
1960 IdResult idResult2,
1961 IdRef operand1,
1962 IdRef operand2)
1963 {
1964 const size_t startSize = blob->size();
1965 blob->push_back(0);
1966 blob->push_back(idResultType1);
1967 blob->push_back(idResult2);
1968 blob->push_back(operand1);
1969 blob->push_back(operand2);
1970 (*blob)[startSize] = MakeLengthOp(blob->size() - startSize, spv::OpSLessThanEqual);
1971 }
WriteFOrdEqual(Blob * blob,IdResultType idResultType1,IdResult idResult2,IdRef operand1,IdRef operand2)1972 void WriteFOrdEqual(Blob *blob,
1973 IdResultType idResultType1,
1974 IdResult idResult2,
1975 IdRef operand1,
1976 IdRef operand2)
1977 {
1978 const size_t startSize = blob->size();
1979 blob->push_back(0);
1980 blob->push_back(idResultType1);
1981 blob->push_back(idResult2);
1982 blob->push_back(operand1);
1983 blob->push_back(operand2);
1984 (*blob)[startSize] = MakeLengthOp(blob->size() - startSize, spv::OpFOrdEqual);
1985 }
WriteFUnordEqual(Blob * blob,IdResultType idResultType1,IdResult idResult2,IdRef operand1,IdRef operand2)1986 void WriteFUnordEqual(Blob *blob,
1987 IdResultType idResultType1,
1988 IdResult idResult2,
1989 IdRef operand1,
1990 IdRef operand2)
1991 {
1992 const size_t startSize = blob->size();
1993 blob->push_back(0);
1994 blob->push_back(idResultType1);
1995 blob->push_back(idResult2);
1996 blob->push_back(operand1);
1997 blob->push_back(operand2);
1998 (*blob)[startSize] = MakeLengthOp(blob->size() - startSize, spv::OpFUnordEqual);
1999 }
WriteFOrdNotEqual(Blob * blob,IdResultType idResultType1,IdResult idResult2,IdRef operand1,IdRef operand2)2000 void WriteFOrdNotEqual(Blob *blob,
2001 IdResultType idResultType1,
2002 IdResult idResult2,
2003 IdRef operand1,
2004 IdRef operand2)
2005 {
2006 const size_t startSize = blob->size();
2007 blob->push_back(0);
2008 blob->push_back(idResultType1);
2009 blob->push_back(idResult2);
2010 blob->push_back(operand1);
2011 blob->push_back(operand2);
2012 (*blob)[startSize] = MakeLengthOp(blob->size() - startSize, spv::OpFOrdNotEqual);
2013 }
WriteFUnordNotEqual(Blob * blob,IdResultType idResultType1,IdResult idResult2,IdRef operand1,IdRef operand2)2014 void WriteFUnordNotEqual(Blob *blob,
2015 IdResultType idResultType1,
2016 IdResult idResult2,
2017 IdRef operand1,
2018 IdRef operand2)
2019 {
2020 const size_t startSize = blob->size();
2021 blob->push_back(0);
2022 blob->push_back(idResultType1);
2023 blob->push_back(idResult2);
2024 blob->push_back(operand1);
2025 blob->push_back(operand2);
2026 (*blob)[startSize] = MakeLengthOp(blob->size() - startSize, spv::OpFUnordNotEqual);
2027 }
WriteFOrdLessThan(Blob * blob,IdResultType idResultType1,IdResult idResult2,IdRef operand1,IdRef operand2)2028 void WriteFOrdLessThan(Blob *blob,
2029 IdResultType idResultType1,
2030 IdResult idResult2,
2031 IdRef operand1,
2032 IdRef operand2)
2033 {
2034 const size_t startSize = blob->size();
2035 blob->push_back(0);
2036 blob->push_back(idResultType1);
2037 blob->push_back(idResult2);
2038 blob->push_back(operand1);
2039 blob->push_back(operand2);
2040 (*blob)[startSize] = MakeLengthOp(blob->size() - startSize, spv::OpFOrdLessThan);
2041 }
WriteFUnordLessThan(Blob * blob,IdResultType idResultType1,IdResult idResult2,IdRef operand1,IdRef operand2)2042 void WriteFUnordLessThan(Blob *blob,
2043 IdResultType idResultType1,
2044 IdResult idResult2,
2045 IdRef operand1,
2046 IdRef operand2)
2047 {
2048 const size_t startSize = blob->size();
2049 blob->push_back(0);
2050 blob->push_back(idResultType1);
2051 blob->push_back(idResult2);
2052 blob->push_back(operand1);
2053 blob->push_back(operand2);
2054 (*blob)[startSize] = MakeLengthOp(blob->size() - startSize, spv::OpFUnordLessThan);
2055 }
WriteFOrdGreaterThan(Blob * blob,IdResultType idResultType1,IdResult idResult2,IdRef operand1,IdRef operand2)2056 void WriteFOrdGreaterThan(Blob *blob,
2057 IdResultType idResultType1,
2058 IdResult idResult2,
2059 IdRef operand1,
2060 IdRef operand2)
2061 {
2062 const size_t startSize = blob->size();
2063 blob->push_back(0);
2064 blob->push_back(idResultType1);
2065 blob->push_back(idResult2);
2066 blob->push_back(operand1);
2067 blob->push_back(operand2);
2068 (*blob)[startSize] = MakeLengthOp(blob->size() - startSize, spv::OpFOrdGreaterThan);
2069 }
WriteFUnordGreaterThan(Blob * blob,IdResultType idResultType1,IdResult idResult2,IdRef operand1,IdRef operand2)2070 void WriteFUnordGreaterThan(Blob *blob,
2071 IdResultType idResultType1,
2072 IdResult idResult2,
2073 IdRef operand1,
2074 IdRef operand2)
2075 {
2076 const size_t startSize = blob->size();
2077 blob->push_back(0);
2078 blob->push_back(idResultType1);
2079 blob->push_back(idResult2);
2080 blob->push_back(operand1);
2081 blob->push_back(operand2);
2082 (*blob)[startSize] = MakeLengthOp(blob->size() - startSize, spv::OpFUnordGreaterThan);
2083 }
WriteFOrdLessThanEqual(Blob * blob,IdResultType idResultType1,IdResult idResult2,IdRef operand1,IdRef operand2)2084 void WriteFOrdLessThanEqual(Blob *blob,
2085 IdResultType idResultType1,
2086 IdResult idResult2,
2087 IdRef operand1,
2088 IdRef operand2)
2089 {
2090 const size_t startSize = blob->size();
2091 blob->push_back(0);
2092 blob->push_back(idResultType1);
2093 blob->push_back(idResult2);
2094 blob->push_back(operand1);
2095 blob->push_back(operand2);
2096 (*blob)[startSize] = MakeLengthOp(blob->size() - startSize, spv::OpFOrdLessThanEqual);
2097 }
WriteFUnordLessThanEqual(Blob * blob,IdResultType idResultType1,IdResult idResult2,IdRef operand1,IdRef operand2)2098 void WriteFUnordLessThanEqual(Blob *blob,
2099 IdResultType idResultType1,
2100 IdResult idResult2,
2101 IdRef operand1,
2102 IdRef operand2)
2103 {
2104 const size_t startSize = blob->size();
2105 blob->push_back(0);
2106 blob->push_back(idResultType1);
2107 blob->push_back(idResult2);
2108 blob->push_back(operand1);
2109 blob->push_back(operand2);
2110 (*blob)[startSize] = MakeLengthOp(blob->size() - startSize, spv::OpFUnordLessThanEqual);
2111 }
WriteFOrdGreaterThanEqual(Blob * blob,IdResultType idResultType1,IdResult idResult2,IdRef operand1,IdRef operand2)2112 void WriteFOrdGreaterThanEqual(Blob *blob,
2113 IdResultType idResultType1,
2114 IdResult idResult2,
2115 IdRef operand1,
2116 IdRef operand2)
2117 {
2118 const size_t startSize = blob->size();
2119 blob->push_back(0);
2120 blob->push_back(idResultType1);
2121 blob->push_back(idResult2);
2122 blob->push_back(operand1);
2123 blob->push_back(operand2);
2124 (*blob)[startSize] = MakeLengthOp(blob->size() - startSize, spv::OpFOrdGreaterThanEqual);
2125 }
WriteFUnordGreaterThanEqual(Blob * blob,IdResultType idResultType1,IdResult idResult2,IdRef operand1,IdRef operand2)2126 void WriteFUnordGreaterThanEqual(Blob *blob,
2127 IdResultType idResultType1,
2128 IdResult idResult2,
2129 IdRef operand1,
2130 IdRef operand2)
2131 {
2132 const size_t startSize = blob->size();
2133 blob->push_back(0);
2134 blob->push_back(idResultType1);
2135 blob->push_back(idResult2);
2136 blob->push_back(operand1);
2137 blob->push_back(operand2);
2138 (*blob)[startSize] = MakeLengthOp(blob->size() - startSize, spv::OpFUnordGreaterThanEqual);
2139 }
WriteShiftRightLogical(Blob * blob,IdResultType idResultType1,IdResult idResult2,IdRef base,IdRef shift)2140 void WriteShiftRightLogical(Blob *blob,
2141 IdResultType idResultType1,
2142 IdResult idResult2,
2143 IdRef base,
2144 IdRef shift)
2145 {
2146 const size_t startSize = blob->size();
2147 blob->push_back(0);
2148 blob->push_back(idResultType1);
2149 blob->push_back(idResult2);
2150 blob->push_back(base);
2151 blob->push_back(shift);
2152 (*blob)[startSize] = MakeLengthOp(blob->size() - startSize, spv::OpShiftRightLogical);
2153 }
WriteShiftRightArithmetic(Blob * blob,IdResultType idResultType1,IdResult idResult2,IdRef base,IdRef shift)2154 void WriteShiftRightArithmetic(Blob *blob,
2155 IdResultType idResultType1,
2156 IdResult idResult2,
2157 IdRef base,
2158 IdRef shift)
2159 {
2160 const size_t startSize = blob->size();
2161 blob->push_back(0);
2162 blob->push_back(idResultType1);
2163 blob->push_back(idResult2);
2164 blob->push_back(base);
2165 blob->push_back(shift);
2166 (*blob)[startSize] = MakeLengthOp(blob->size() - startSize, spv::OpShiftRightArithmetic);
2167 }
WriteShiftLeftLogical(Blob * blob,IdResultType idResultType1,IdResult idResult2,IdRef base,IdRef shift)2168 void WriteShiftLeftLogical(Blob *blob,
2169 IdResultType idResultType1,
2170 IdResult idResult2,
2171 IdRef base,
2172 IdRef shift)
2173 {
2174 const size_t startSize = blob->size();
2175 blob->push_back(0);
2176 blob->push_back(idResultType1);
2177 blob->push_back(idResult2);
2178 blob->push_back(base);
2179 blob->push_back(shift);
2180 (*blob)[startSize] = MakeLengthOp(blob->size() - startSize, spv::OpShiftLeftLogical);
2181 }
WriteBitwiseOr(Blob * blob,IdResultType idResultType1,IdResult idResult2,IdRef operand1,IdRef operand2)2182 void WriteBitwiseOr(Blob *blob,
2183 IdResultType idResultType1,
2184 IdResult idResult2,
2185 IdRef operand1,
2186 IdRef operand2)
2187 {
2188 const size_t startSize = blob->size();
2189 blob->push_back(0);
2190 blob->push_back(idResultType1);
2191 blob->push_back(idResult2);
2192 blob->push_back(operand1);
2193 blob->push_back(operand2);
2194 (*blob)[startSize] = MakeLengthOp(blob->size() - startSize, spv::OpBitwiseOr);
2195 }
WriteBitwiseXor(Blob * blob,IdResultType idResultType1,IdResult idResult2,IdRef operand1,IdRef operand2)2196 void WriteBitwiseXor(Blob *blob,
2197 IdResultType idResultType1,
2198 IdResult idResult2,
2199 IdRef operand1,
2200 IdRef operand2)
2201 {
2202 const size_t startSize = blob->size();
2203 blob->push_back(0);
2204 blob->push_back(idResultType1);
2205 blob->push_back(idResult2);
2206 blob->push_back(operand1);
2207 blob->push_back(operand2);
2208 (*blob)[startSize] = MakeLengthOp(blob->size() - startSize, spv::OpBitwiseXor);
2209 }
WriteBitwiseAnd(Blob * blob,IdResultType idResultType1,IdResult idResult2,IdRef operand1,IdRef operand2)2210 void WriteBitwiseAnd(Blob *blob,
2211 IdResultType idResultType1,
2212 IdResult idResult2,
2213 IdRef operand1,
2214 IdRef operand2)
2215 {
2216 const size_t startSize = blob->size();
2217 blob->push_back(0);
2218 blob->push_back(idResultType1);
2219 blob->push_back(idResult2);
2220 blob->push_back(operand1);
2221 blob->push_back(operand2);
2222 (*blob)[startSize] = MakeLengthOp(blob->size() - startSize, spv::OpBitwiseAnd);
2223 }
WriteNot(Blob * blob,IdResultType idResultType1,IdResult idResult2,IdRef operand)2224 void WriteNot(Blob *blob, IdResultType idResultType1, IdResult idResult2, IdRef operand)
2225 {
2226 const size_t startSize = blob->size();
2227 blob->push_back(0);
2228 blob->push_back(idResultType1);
2229 blob->push_back(idResult2);
2230 blob->push_back(operand);
2231 (*blob)[startSize] = MakeLengthOp(blob->size() - startSize, spv::OpNot);
2232 }
WriteBitFieldInsert(Blob * blob,IdResultType idResultType1,IdResult idResult2,IdRef base,IdRef insert,IdRef offset,IdRef count)2233 void WriteBitFieldInsert(Blob *blob,
2234 IdResultType idResultType1,
2235 IdResult idResult2,
2236 IdRef base,
2237 IdRef insert,
2238 IdRef offset,
2239 IdRef count)
2240 {
2241 const size_t startSize = blob->size();
2242 blob->push_back(0);
2243 blob->push_back(idResultType1);
2244 blob->push_back(idResult2);
2245 blob->push_back(base);
2246 blob->push_back(insert);
2247 blob->push_back(offset);
2248 blob->push_back(count);
2249 (*blob)[startSize] = MakeLengthOp(blob->size() - startSize, spv::OpBitFieldInsert);
2250 }
WriteBitFieldSExtract(Blob * blob,IdResultType idResultType1,IdResult idResult2,IdRef base,IdRef offset,IdRef count)2251 void WriteBitFieldSExtract(Blob *blob,
2252 IdResultType idResultType1,
2253 IdResult idResult2,
2254 IdRef base,
2255 IdRef offset,
2256 IdRef count)
2257 {
2258 const size_t startSize = blob->size();
2259 blob->push_back(0);
2260 blob->push_back(idResultType1);
2261 blob->push_back(idResult2);
2262 blob->push_back(base);
2263 blob->push_back(offset);
2264 blob->push_back(count);
2265 (*blob)[startSize] = MakeLengthOp(blob->size() - startSize, spv::OpBitFieldSExtract);
2266 }
WriteBitFieldUExtract(Blob * blob,IdResultType idResultType1,IdResult idResult2,IdRef base,IdRef offset,IdRef count)2267 void WriteBitFieldUExtract(Blob *blob,
2268 IdResultType idResultType1,
2269 IdResult idResult2,
2270 IdRef base,
2271 IdRef offset,
2272 IdRef count)
2273 {
2274 const size_t startSize = blob->size();
2275 blob->push_back(0);
2276 blob->push_back(idResultType1);
2277 blob->push_back(idResult2);
2278 blob->push_back(base);
2279 blob->push_back(offset);
2280 blob->push_back(count);
2281 (*blob)[startSize] = MakeLengthOp(blob->size() - startSize, spv::OpBitFieldUExtract);
2282 }
WriteBitReverse(Blob * blob,IdResultType idResultType1,IdResult idResult2,IdRef base)2283 void WriteBitReverse(Blob *blob, IdResultType idResultType1, IdResult idResult2, IdRef base)
2284 {
2285 const size_t startSize = blob->size();
2286 blob->push_back(0);
2287 blob->push_back(idResultType1);
2288 blob->push_back(idResult2);
2289 blob->push_back(base);
2290 (*blob)[startSize] = MakeLengthOp(blob->size() - startSize, spv::OpBitReverse);
2291 }
WriteBitCount(Blob * blob,IdResultType idResultType1,IdResult idResult2,IdRef base)2292 void WriteBitCount(Blob *blob, IdResultType idResultType1, IdResult idResult2, IdRef base)
2293 {
2294 const size_t startSize = blob->size();
2295 blob->push_back(0);
2296 blob->push_back(idResultType1);
2297 blob->push_back(idResult2);
2298 blob->push_back(base);
2299 (*blob)[startSize] = MakeLengthOp(blob->size() - startSize, spv::OpBitCount);
2300 }
WriteDPdx(Blob * blob,IdResultType idResultType1,IdResult idResult2,IdRef p)2301 void WriteDPdx(Blob *blob, IdResultType idResultType1, IdResult idResult2, IdRef p)
2302 {
2303 const size_t startSize = blob->size();
2304 blob->push_back(0);
2305 blob->push_back(idResultType1);
2306 blob->push_back(idResult2);
2307 blob->push_back(p);
2308 (*blob)[startSize] = MakeLengthOp(blob->size() - startSize, spv::OpDPdx);
2309 }
WriteDPdy(Blob * blob,IdResultType idResultType1,IdResult idResult2,IdRef p)2310 void WriteDPdy(Blob *blob, IdResultType idResultType1, IdResult idResult2, IdRef p)
2311 {
2312 const size_t startSize = blob->size();
2313 blob->push_back(0);
2314 blob->push_back(idResultType1);
2315 blob->push_back(idResult2);
2316 blob->push_back(p);
2317 (*blob)[startSize] = MakeLengthOp(blob->size() - startSize, spv::OpDPdy);
2318 }
WriteFwidth(Blob * blob,IdResultType idResultType1,IdResult idResult2,IdRef p)2319 void WriteFwidth(Blob *blob, IdResultType idResultType1, IdResult idResult2, IdRef p)
2320 {
2321 const size_t startSize = blob->size();
2322 blob->push_back(0);
2323 blob->push_back(idResultType1);
2324 blob->push_back(idResult2);
2325 blob->push_back(p);
2326 (*blob)[startSize] = MakeLengthOp(blob->size() - startSize, spv::OpFwidth);
2327 }
WriteDPdxFine(Blob * blob,IdResultType idResultType1,IdResult idResult2,IdRef p)2328 void WriteDPdxFine(Blob *blob, IdResultType idResultType1, IdResult idResult2, IdRef p)
2329 {
2330 const size_t startSize = blob->size();
2331 blob->push_back(0);
2332 blob->push_back(idResultType1);
2333 blob->push_back(idResult2);
2334 blob->push_back(p);
2335 (*blob)[startSize] = MakeLengthOp(blob->size() - startSize, spv::OpDPdxFine);
2336 }
WriteDPdyFine(Blob * blob,IdResultType idResultType1,IdResult idResult2,IdRef p)2337 void WriteDPdyFine(Blob *blob, IdResultType idResultType1, IdResult idResult2, IdRef p)
2338 {
2339 const size_t startSize = blob->size();
2340 blob->push_back(0);
2341 blob->push_back(idResultType1);
2342 blob->push_back(idResult2);
2343 blob->push_back(p);
2344 (*blob)[startSize] = MakeLengthOp(blob->size() - startSize, spv::OpDPdyFine);
2345 }
WriteFwidthFine(Blob * blob,IdResultType idResultType1,IdResult idResult2,IdRef p)2346 void WriteFwidthFine(Blob *blob, IdResultType idResultType1, IdResult idResult2, IdRef p)
2347 {
2348 const size_t startSize = blob->size();
2349 blob->push_back(0);
2350 blob->push_back(idResultType1);
2351 blob->push_back(idResult2);
2352 blob->push_back(p);
2353 (*blob)[startSize] = MakeLengthOp(blob->size() - startSize, spv::OpFwidthFine);
2354 }
WriteDPdxCoarse(Blob * blob,IdResultType idResultType1,IdResult idResult2,IdRef p)2355 void WriteDPdxCoarse(Blob *blob, IdResultType idResultType1, IdResult idResult2, IdRef p)
2356 {
2357 const size_t startSize = blob->size();
2358 blob->push_back(0);
2359 blob->push_back(idResultType1);
2360 blob->push_back(idResult2);
2361 blob->push_back(p);
2362 (*blob)[startSize] = MakeLengthOp(blob->size() - startSize, spv::OpDPdxCoarse);
2363 }
WriteDPdyCoarse(Blob * blob,IdResultType idResultType1,IdResult idResult2,IdRef p)2364 void WriteDPdyCoarse(Blob *blob, IdResultType idResultType1, IdResult idResult2, IdRef p)
2365 {
2366 const size_t startSize = blob->size();
2367 blob->push_back(0);
2368 blob->push_back(idResultType1);
2369 blob->push_back(idResult2);
2370 blob->push_back(p);
2371 (*blob)[startSize] = MakeLengthOp(blob->size() - startSize, spv::OpDPdyCoarse);
2372 }
WriteFwidthCoarse(Blob * blob,IdResultType idResultType1,IdResult idResult2,IdRef p)2373 void WriteFwidthCoarse(Blob *blob, IdResultType idResultType1, IdResult idResult2, IdRef p)
2374 {
2375 const size_t startSize = blob->size();
2376 blob->push_back(0);
2377 blob->push_back(idResultType1);
2378 blob->push_back(idResult2);
2379 blob->push_back(p);
2380 (*blob)[startSize] = MakeLengthOp(blob->size() - startSize, spv::OpFwidthCoarse);
2381 }
WriteEmitVertex(Blob * blob)2382 void WriteEmitVertex(Blob *blob)
2383 {
2384 const size_t startSize = blob->size();
2385 blob->push_back(0);
2386
2387 (*blob)[startSize] = MakeLengthOp(blob->size() - startSize, spv::OpEmitVertex);
2388 }
WriteEndPrimitive(Blob * blob)2389 void WriteEndPrimitive(Blob *blob)
2390 {
2391 const size_t startSize = blob->size();
2392 blob->push_back(0);
2393
2394 (*blob)[startSize] = MakeLengthOp(blob->size() - startSize, spv::OpEndPrimitive);
2395 }
WriteEmitStreamVertex(Blob * blob,IdRef stream)2396 void WriteEmitStreamVertex(Blob *blob, IdRef stream)
2397 {
2398 const size_t startSize = blob->size();
2399 blob->push_back(0);
2400 blob->push_back(stream);
2401 (*blob)[startSize] = MakeLengthOp(blob->size() - startSize, spv::OpEmitStreamVertex);
2402 }
WriteEndStreamPrimitive(Blob * blob,IdRef stream)2403 void WriteEndStreamPrimitive(Blob *blob, IdRef stream)
2404 {
2405 const size_t startSize = blob->size();
2406 blob->push_back(0);
2407 blob->push_back(stream);
2408 (*blob)[startSize] = MakeLengthOp(blob->size() - startSize, spv::OpEndStreamPrimitive);
2409 }
WriteControlBarrier(Blob * blob,IdScope execution,IdScope memory,IdMemorySemantics semantics)2410 void WriteControlBarrier(Blob *blob, IdScope execution, IdScope memory, IdMemorySemantics semantics)
2411 {
2412 const size_t startSize = blob->size();
2413 blob->push_back(0);
2414 blob->push_back(execution);
2415 blob->push_back(memory);
2416 blob->push_back(semantics);
2417 (*blob)[startSize] = MakeLengthOp(blob->size() - startSize, spv::OpControlBarrier);
2418 }
WriteMemoryBarrier(Blob * blob,IdScope memory,IdMemorySemantics semantics)2419 void WriteMemoryBarrier(Blob *blob, IdScope memory, IdMemorySemantics semantics)
2420 {
2421 const size_t startSize = blob->size();
2422 blob->push_back(0);
2423 blob->push_back(memory);
2424 blob->push_back(semantics);
2425 (*blob)[startSize] = MakeLengthOp(blob->size() - startSize, spv::OpMemoryBarrier);
2426 }
WriteAtomicLoad(Blob * blob,IdResultType idResultType1,IdResult idResult2,IdRef pointer,IdScope memory,IdMemorySemantics semantics)2427 void WriteAtomicLoad(Blob *blob,
2428 IdResultType idResultType1,
2429 IdResult idResult2,
2430 IdRef pointer,
2431 IdScope memory,
2432 IdMemorySemantics semantics)
2433 {
2434 const size_t startSize = blob->size();
2435 blob->push_back(0);
2436 blob->push_back(idResultType1);
2437 blob->push_back(idResult2);
2438 blob->push_back(pointer);
2439 blob->push_back(memory);
2440 blob->push_back(semantics);
2441 (*blob)[startSize] = MakeLengthOp(blob->size() - startSize, spv::OpAtomicLoad);
2442 }
WriteAtomicStore(Blob * blob,IdRef pointer,IdScope memory,IdMemorySemantics semantics,IdRef value)2443 void WriteAtomicStore(Blob *blob,
2444 IdRef pointer,
2445 IdScope memory,
2446 IdMemorySemantics semantics,
2447 IdRef value)
2448 {
2449 const size_t startSize = blob->size();
2450 blob->push_back(0);
2451 blob->push_back(pointer);
2452 blob->push_back(memory);
2453 blob->push_back(semantics);
2454 blob->push_back(value);
2455 (*blob)[startSize] = MakeLengthOp(blob->size() - startSize, spv::OpAtomicStore);
2456 }
WriteAtomicExchange(Blob * blob,IdResultType idResultType1,IdResult idResult2,IdRef pointer,IdScope memory,IdMemorySemantics semantics,IdRef value)2457 void WriteAtomicExchange(Blob *blob,
2458 IdResultType idResultType1,
2459 IdResult idResult2,
2460 IdRef pointer,
2461 IdScope memory,
2462 IdMemorySemantics semantics,
2463 IdRef value)
2464 {
2465 const size_t startSize = blob->size();
2466 blob->push_back(0);
2467 blob->push_back(idResultType1);
2468 blob->push_back(idResult2);
2469 blob->push_back(pointer);
2470 blob->push_back(memory);
2471 blob->push_back(semantics);
2472 blob->push_back(value);
2473 (*blob)[startSize] = MakeLengthOp(blob->size() - startSize, spv::OpAtomicExchange);
2474 }
WriteAtomicCompareExchange(Blob * blob,IdResultType idResultType1,IdResult idResult2,IdRef pointer,IdScope memory,IdMemorySemantics equal,IdMemorySemantics unequal,IdRef value,IdRef comparator)2475 void WriteAtomicCompareExchange(Blob *blob,
2476 IdResultType idResultType1,
2477 IdResult idResult2,
2478 IdRef pointer,
2479 IdScope memory,
2480 IdMemorySemantics equal,
2481 IdMemorySemantics unequal,
2482 IdRef value,
2483 IdRef comparator)
2484 {
2485 const size_t startSize = blob->size();
2486 blob->push_back(0);
2487 blob->push_back(idResultType1);
2488 blob->push_back(idResult2);
2489 blob->push_back(pointer);
2490 blob->push_back(memory);
2491 blob->push_back(equal);
2492 blob->push_back(unequal);
2493 blob->push_back(value);
2494 blob->push_back(comparator);
2495 (*blob)[startSize] = MakeLengthOp(blob->size() - startSize, spv::OpAtomicCompareExchange);
2496 }
WriteAtomicIIncrement(Blob * blob,IdResultType idResultType1,IdResult idResult2,IdRef pointer,IdScope memory,IdMemorySemantics semantics)2497 void WriteAtomicIIncrement(Blob *blob,
2498 IdResultType idResultType1,
2499 IdResult idResult2,
2500 IdRef pointer,
2501 IdScope memory,
2502 IdMemorySemantics semantics)
2503 {
2504 const size_t startSize = blob->size();
2505 blob->push_back(0);
2506 blob->push_back(idResultType1);
2507 blob->push_back(idResult2);
2508 blob->push_back(pointer);
2509 blob->push_back(memory);
2510 blob->push_back(semantics);
2511 (*blob)[startSize] = MakeLengthOp(blob->size() - startSize, spv::OpAtomicIIncrement);
2512 }
WriteAtomicIDecrement(Blob * blob,IdResultType idResultType1,IdResult idResult2,IdRef pointer,IdScope memory,IdMemorySemantics semantics)2513 void WriteAtomicIDecrement(Blob *blob,
2514 IdResultType idResultType1,
2515 IdResult idResult2,
2516 IdRef pointer,
2517 IdScope memory,
2518 IdMemorySemantics semantics)
2519 {
2520 const size_t startSize = blob->size();
2521 blob->push_back(0);
2522 blob->push_back(idResultType1);
2523 blob->push_back(idResult2);
2524 blob->push_back(pointer);
2525 blob->push_back(memory);
2526 blob->push_back(semantics);
2527 (*blob)[startSize] = MakeLengthOp(blob->size() - startSize, spv::OpAtomicIDecrement);
2528 }
WriteAtomicIAdd(Blob * blob,IdResultType idResultType1,IdResult idResult2,IdRef pointer,IdScope memory,IdMemorySemantics semantics,IdRef value)2529 void WriteAtomicIAdd(Blob *blob,
2530 IdResultType idResultType1,
2531 IdResult idResult2,
2532 IdRef pointer,
2533 IdScope memory,
2534 IdMemorySemantics semantics,
2535 IdRef value)
2536 {
2537 const size_t startSize = blob->size();
2538 blob->push_back(0);
2539 blob->push_back(idResultType1);
2540 blob->push_back(idResult2);
2541 blob->push_back(pointer);
2542 blob->push_back(memory);
2543 blob->push_back(semantics);
2544 blob->push_back(value);
2545 (*blob)[startSize] = MakeLengthOp(blob->size() - startSize, spv::OpAtomicIAdd);
2546 }
WriteAtomicISub(Blob * blob,IdResultType idResultType1,IdResult idResult2,IdRef pointer,IdScope memory,IdMemorySemantics semantics,IdRef value)2547 void WriteAtomicISub(Blob *blob,
2548 IdResultType idResultType1,
2549 IdResult idResult2,
2550 IdRef pointer,
2551 IdScope memory,
2552 IdMemorySemantics semantics,
2553 IdRef value)
2554 {
2555 const size_t startSize = blob->size();
2556 blob->push_back(0);
2557 blob->push_back(idResultType1);
2558 blob->push_back(idResult2);
2559 blob->push_back(pointer);
2560 blob->push_back(memory);
2561 blob->push_back(semantics);
2562 blob->push_back(value);
2563 (*blob)[startSize] = MakeLengthOp(blob->size() - startSize, spv::OpAtomicISub);
2564 }
WriteAtomicSMin(Blob * blob,IdResultType idResultType1,IdResult idResult2,IdRef pointer,IdScope memory,IdMemorySemantics semantics,IdRef value)2565 void WriteAtomicSMin(Blob *blob,
2566 IdResultType idResultType1,
2567 IdResult idResult2,
2568 IdRef pointer,
2569 IdScope memory,
2570 IdMemorySemantics semantics,
2571 IdRef value)
2572 {
2573 const size_t startSize = blob->size();
2574 blob->push_back(0);
2575 blob->push_back(idResultType1);
2576 blob->push_back(idResult2);
2577 blob->push_back(pointer);
2578 blob->push_back(memory);
2579 blob->push_back(semantics);
2580 blob->push_back(value);
2581 (*blob)[startSize] = MakeLengthOp(blob->size() - startSize, spv::OpAtomicSMin);
2582 }
WriteAtomicUMin(Blob * blob,IdResultType idResultType1,IdResult idResult2,IdRef pointer,IdScope memory,IdMemorySemantics semantics,IdRef value)2583 void WriteAtomicUMin(Blob *blob,
2584 IdResultType idResultType1,
2585 IdResult idResult2,
2586 IdRef pointer,
2587 IdScope memory,
2588 IdMemorySemantics semantics,
2589 IdRef value)
2590 {
2591 const size_t startSize = blob->size();
2592 blob->push_back(0);
2593 blob->push_back(idResultType1);
2594 blob->push_back(idResult2);
2595 blob->push_back(pointer);
2596 blob->push_back(memory);
2597 blob->push_back(semantics);
2598 blob->push_back(value);
2599 (*blob)[startSize] = MakeLengthOp(blob->size() - startSize, spv::OpAtomicUMin);
2600 }
WriteAtomicSMax(Blob * blob,IdResultType idResultType1,IdResult idResult2,IdRef pointer,IdScope memory,IdMemorySemantics semantics,IdRef value)2601 void WriteAtomicSMax(Blob *blob,
2602 IdResultType idResultType1,
2603 IdResult idResult2,
2604 IdRef pointer,
2605 IdScope memory,
2606 IdMemorySemantics semantics,
2607 IdRef value)
2608 {
2609 const size_t startSize = blob->size();
2610 blob->push_back(0);
2611 blob->push_back(idResultType1);
2612 blob->push_back(idResult2);
2613 blob->push_back(pointer);
2614 blob->push_back(memory);
2615 blob->push_back(semantics);
2616 blob->push_back(value);
2617 (*blob)[startSize] = MakeLengthOp(blob->size() - startSize, spv::OpAtomicSMax);
2618 }
WriteAtomicUMax(Blob * blob,IdResultType idResultType1,IdResult idResult2,IdRef pointer,IdScope memory,IdMemorySemantics semantics,IdRef value)2619 void WriteAtomicUMax(Blob *blob,
2620 IdResultType idResultType1,
2621 IdResult idResult2,
2622 IdRef pointer,
2623 IdScope memory,
2624 IdMemorySemantics semantics,
2625 IdRef value)
2626 {
2627 const size_t startSize = blob->size();
2628 blob->push_back(0);
2629 blob->push_back(idResultType1);
2630 blob->push_back(idResult2);
2631 blob->push_back(pointer);
2632 blob->push_back(memory);
2633 blob->push_back(semantics);
2634 blob->push_back(value);
2635 (*blob)[startSize] = MakeLengthOp(blob->size() - startSize, spv::OpAtomicUMax);
2636 }
WriteAtomicAnd(Blob * blob,IdResultType idResultType1,IdResult idResult2,IdRef pointer,IdScope memory,IdMemorySemantics semantics,IdRef value)2637 void WriteAtomicAnd(Blob *blob,
2638 IdResultType idResultType1,
2639 IdResult idResult2,
2640 IdRef pointer,
2641 IdScope memory,
2642 IdMemorySemantics semantics,
2643 IdRef value)
2644 {
2645 const size_t startSize = blob->size();
2646 blob->push_back(0);
2647 blob->push_back(idResultType1);
2648 blob->push_back(idResult2);
2649 blob->push_back(pointer);
2650 blob->push_back(memory);
2651 blob->push_back(semantics);
2652 blob->push_back(value);
2653 (*blob)[startSize] = MakeLengthOp(blob->size() - startSize, spv::OpAtomicAnd);
2654 }
WriteAtomicOr(Blob * blob,IdResultType idResultType1,IdResult idResult2,IdRef pointer,IdScope memory,IdMemorySemantics semantics,IdRef value)2655 void WriteAtomicOr(Blob *blob,
2656 IdResultType idResultType1,
2657 IdResult idResult2,
2658 IdRef pointer,
2659 IdScope memory,
2660 IdMemorySemantics semantics,
2661 IdRef value)
2662 {
2663 const size_t startSize = blob->size();
2664 blob->push_back(0);
2665 blob->push_back(idResultType1);
2666 blob->push_back(idResult2);
2667 blob->push_back(pointer);
2668 blob->push_back(memory);
2669 blob->push_back(semantics);
2670 blob->push_back(value);
2671 (*blob)[startSize] = MakeLengthOp(blob->size() - startSize, spv::OpAtomicOr);
2672 }
WriteAtomicXor(Blob * blob,IdResultType idResultType1,IdResult idResult2,IdRef pointer,IdScope memory,IdMemorySemantics semantics,IdRef value)2673 void WriteAtomicXor(Blob *blob,
2674 IdResultType idResultType1,
2675 IdResult idResult2,
2676 IdRef pointer,
2677 IdScope memory,
2678 IdMemorySemantics semantics,
2679 IdRef value)
2680 {
2681 const size_t startSize = blob->size();
2682 blob->push_back(0);
2683 blob->push_back(idResultType1);
2684 blob->push_back(idResult2);
2685 blob->push_back(pointer);
2686 blob->push_back(memory);
2687 blob->push_back(semantics);
2688 blob->push_back(value);
2689 (*blob)[startSize] = MakeLengthOp(blob->size() - startSize, spv::OpAtomicXor);
2690 }
WritePhi(Blob * blob,IdResultType idResultType1,IdResult idResult2,const PairIdRefIdRefList & variableParentPairList)2691 void WritePhi(Blob *blob,
2692 IdResultType idResultType1,
2693 IdResult idResult2,
2694 const PairIdRefIdRefList &variableParentPairList)
2695 {
2696 const size_t startSize = blob->size();
2697 blob->push_back(0);
2698 blob->push_back(idResultType1);
2699 blob->push_back(idResult2);
2700 for (const auto &operand : variableParentPairList)
2701 {
2702 blob->push_back(operand.id1);
2703 blob->push_back(operand.id2);
2704 }
2705 (*blob)[startSize] = MakeLengthOp(blob->size() - startSize, spv::OpPhi);
2706 }
WriteLoopMerge(Blob * blob,IdRef mergeBlock,IdRef continueTarget,spv::LoopControlMask loopControl3)2707 void WriteLoopMerge(Blob *blob,
2708 IdRef mergeBlock,
2709 IdRef continueTarget,
2710 spv::LoopControlMask loopControl3)
2711 {
2712 const size_t startSize = blob->size();
2713 blob->push_back(0);
2714 blob->push_back(mergeBlock);
2715 blob->push_back(continueTarget);
2716 blob->push_back(loopControl3);
2717 (*blob)[startSize] = MakeLengthOp(blob->size() - startSize, spv::OpLoopMerge);
2718 }
WriteSelectionMerge(Blob * blob,IdRef mergeBlock,spv::SelectionControlMask selectionControl2)2719 void WriteSelectionMerge(Blob *blob, IdRef mergeBlock, spv::SelectionControlMask selectionControl2)
2720 {
2721 const size_t startSize = blob->size();
2722 blob->push_back(0);
2723 blob->push_back(mergeBlock);
2724 blob->push_back(selectionControl2);
2725 (*blob)[startSize] = MakeLengthOp(blob->size() - startSize, spv::OpSelectionMerge);
2726 }
WriteLabel(Blob * blob,IdResult idResult1)2727 void WriteLabel(Blob *blob, IdResult idResult1)
2728 {
2729 const size_t startSize = blob->size();
2730 blob->push_back(0);
2731 blob->push_back(idResult1);
2732 (*blob)[startSize] = MakeLengthOp(blob->size() - startSize, spv::OpLabel);
2733 }
WriteBranch(Blob * blob,IdRef targetLabel)2734 void WriteBranch(Blob *blob, IdRef targetLabel)
2735 {
2736 const size_t startSize = blob->size();
2737 blob->push_back(0);
2738 blob->push_back(targetLabel);
2739 (*blob)[startSize] = MakeLengthOp(blob->size() - startSize, spv::OpBranch);
2740 }
WriteBranchConditional(Blob * blob,IdRef condition,IdRef trueLabel,IdRef falseLabel,const LiteralIntegerList & branchweightsList)2741 void WriteBranchConditional(Blob *blob,
2742 IdRef condition,
2743 IdRef trueLabel,
2744 IdRef falseLabel,
2745 const LiteralIntegerList &branchweightsList)
2746 {
2747 const size_t startSize = blob->size();
2748 blob->push_back(0);
2749 blob->push_back(condition);
2750 blob->push_back(trueLabel);
2751 blob->push_back(falseLabel);
2752 for (const auto &operand : branchweightsList)
2753 {
2754 blob->push_back(operand);
2755 }
2756 (*blob)[startSize] = MakeLengthOp(blob->size() - startSize, spv::OpBranchConditional);
2757 }
WriteSwitch(Blob * blob,IdRef selector,IdRef default_,const PairLiteralIntegerIdRefList & targetPairList)2758 void WriteSwitch(Blob *blob,
2759 IdRef selector,
2760 IdRef default_,
2761 const PairLiteralIntegerIdRefList &targetPairList)
2762 {
2763 const size_t startSize = blob->size();
2764 blob->push_back(0);
2765 blob->push_back(selector);
2766 blob->push_back(default_);
2767 for (const auto &operand : targetPairList)
2768 {
2769 blob->push_back(operand.literal);
2770 blob->push_back(operand.id);
2771 }
2772 (*blob)[startSize] = MakeLengthOp(blob->size() - startSize, spv::OpSwitch);
2773 }
WriteKill(Blob * blob)2774 void WriteKill(Blob *blob)
2775 {
2776 const size_t startSize = blob->size();
2777 blob->push_back(0);
2778
2779 (*blob)[startSize] = MakeLengthOp(blob->size() - startSize, spv::OpKill);
2780 }
WriteReturn(Blob * blob)2781 void WriteReturn(Blob *blob)
2782 {
2783 const size_t startSize = blob->size();
2784 blob->push_back(0);
2785
2786 (*blob)[startSize] = MakeLengthOp(blob->size() - startSize, spv::OpReturn);
2787 }
WriteReturnValue(Blob * blob,IdRef value)2788 void WriteReturnValue(Blob *blob, IdRef value)
2789 {
2790 const size_t startSize = blob->size();
2791 blob->push_back(0);
2792 blob->push_back(value);
2793 (*blob)[startSize] = MakeLengthOp(blob->size() - startSize, spv::OpReturnValue);
2794 }
WriteUnreachable(Blob * blob)2795 void WriteUnreachable(Blob *blob)
2796 {
2797 const size_t startSize = blob->size();
2798 blob->push_back(0);
2799
2800 (*blob)[startSize] = MakeLengthOp(blob->size() - startSize, spv::OpUnreachable);
2801 }
WriteImageSparseSampleImplicitLod(Blob * blob,IdResultType idResultType1,IdResult idResult2,IdRef sampledImage,IdRef coordinate,const spv::ImageOperandsMask * imageOperands5,const IdRefList & imageOperandIdsList)2802 void WriteImageSparseSampleImplicitLod(Blob *blob,
2803 IdResultType idResultType1,
2804 IdResult idResult2,
2805 IdRef sampledImage,
2806 IdRef coordinate,
2807 const spv::ImageOperandsMask *imageOperands5,
2808 const IdRefList &imageOperandIdsList)
2809 {
2810 const size_t startSize = blob->size();
2811 blob->push_back(0);
2812 blob->push_back(idResultType1);
2813 blob->push_back(idResult2);
2814 blob->push_back(sampledImage);
2815 blob->push_back(coordinate);
2816 if (imageOperands5)
2817 {
2818 blob->push_back(*imageOperands5);
2819 }
2820 for (const auto &operand : imageOperandIdsList)
2821 {
2822 blob->push_back(operand);
2823 }
2824 (*blob)[startSize] =
2825 MakeLengthOp(blob->size() - startSize, spv::OpImageSparseSampleImplicitLod);
2826 }
WriteImageSparseSampleExplicitLod(Blob * blob,IdResultType idResultType1,IdResult idResult2,IdRef sampledImage,IdRef coordinate,spv::ImageOperandsMask imageOperands5,const IdRefList & imageOperandIdsList)2827 void WriteImageSparseSampleExplicitLod(Blob *blob,
2828 IdResultType idResultType1,
2829 IdResult idResult2,
2830 IdRef sampledImage,
2831 IdRef coordinate,
2832 spv::ImageOperandsMask imageOperands5,
2833 const IdRefList &imageOperandIdsList)
2834 {
2835 const size_t startSize = blob->size();
2836 blob->push_back(0);
2837 blob->push_back(idResultType1);
2838 blob->push_back(idResult2);
2839 blob->push_back(sampledImage);
2840 blob->push_back(coordinate);
2841 blob->push_back(imageOperands5);
2842 for (const auto &operand : imageOperandIdsList)
2843 {
2844 blob->push_back(operand);
2845 }
2846 (*blob)[startSize] =
2847 MakeLengthOp(blob->size() - startSize, spv::OpImageSparseSampleExplicitLod);
2848 }
WriteImageSparseSampleDrefImplicitLod(Blob * blob,IdResultType idResultType1,IdResult idResult2,IdRef sampledImage,IdRef coordinate,IdRef dref,const spv::ImageOperandsMask * imageOperands6,const IdRefList & imageOperandIdsList)2849 void WriteImageSparseSampleDrefImplicitLod(Blob *blob,
2850 IdResultType idResultType1,
2851 IdResult idResult2,
2852 IdRef sampledImage,
2853 IdRef coordinate,
2854 IdRef dref,
2855 const spv::ImageOperandsMask *imageOperands6,
2856 const IdRefList &imageOperandIdsList)
2857 {
2858 const size_t startSize = blob->size();
2859 blob->push_back(0);
2860 blob->push_back(idResultType1);
2861 blob->push_back(idResult2);
2862 blob->push_back(sampledImage);
2863 blob->push_back(coordinate);
2864 blob->push_back(dref);
2865 if (imageOperands6)
2866 {
2867 blob->push_back(*imageOperands6);
2868 }
2869 for (const auto &operand : imageOperandIdsList)
2870 {
2871 blob->push_back(operand);
2872 }
2873 (*blob)[startSize] =
2874 MakeLengthOp(blob->size() - startSize, spv::OpImageSparseSampleDrefImplicitLod);
2875 }
WriteImageSparseSampleDrefExplicitLod(Blob * blob,IdResultType idResultType1,IdResult idResult2,IdRef sampledImage,IdRef coordinate,IdRef dref,spv::ImageOperandsMask imageOperands6,const IdRefList & imageOperandIdsList)2876 void WriteImageSparseSampleDrefExplicitLod(Blob *blob,
2877 IdResultType idResultType1,
2878 IdResult idResult2,
2879 IdRef sampledImage,
2880 IdRef coordinate,
2881 IdRef dref,
2882 spv::ImageOperandsMask imageOperands6,
2883 const IdRefList &imageOperandIdsList)
2884 {
2885 const size_t startSize = blob->size();
2886 blob->push_back(0);
2887 blob->push_back(idResultType1);
2888 blob->push_back(idResult2);
2889 blob->push_back(sampledImage);
2890 blob->push_back(coordinate);
2891 blob->push_back(dref);
2892 blob->push_back(imageOperands6);
2893 for (const auto &operand : imageOperandIdsList)
2894 {
2895 blob->push_back(operand);
2896 }
2897 (*blob)[startSize] =
2898 MakeLengthOp(blob->size() - startSize, spv::OpImageSparseSampleDrefExplicitLod);
2899 }
WriteImageSparseSampleProjImplicitLod(Blob * blob,IdResultType idResultType1,IdResult idResult2,IdRef sampledImage,IdRef coordinate,const spv::ImageOperandsMask * imageOperands5,const IdRefList & imageOperandIdsList)2900 void WriteImageSparseSampleProjImplicitLod(Blob *blob,
2901 IdResultType idResultType1,
2902 IdResult idResult2,
2903 IdRef sampledImage,
2904 IdRef coordinate,
2905 const spv::ImageOperandsMask *imageOperands5,
2906 const IdRefList &imageOperandIdsList)
2907 {
2908 const size_t startSize = blob->size();
2909 blob->push_back(0);
2910 blob->push_back(idResultType1);
2911 blob->push_back(idResult2);
2912 blob->push_back(sampledImage);
2913 blob->push_back(coordinate);
2914 if (imageOperands5)
2915 {
2916 blob->push_back(*imageOperands5);
2917 }
2918 for (const auto &operand : imageOperandIdsList)
2919 {
2920 blob->push_back(operand);
2921 }
2922 (*blob)[startSize] =
2923 MakeLengthOp(blob->size() - startSize, spv::OpImageSparseSampleProjImplicitLod);
2924 }
WriteImageSparseSampleProjExplicitLod(Blob * blob,IdResultType idResultType1,IdResult idResult2,IdRef sampledImage,IdRef coordinate,spv::ImageOperandsMask imageOperands5,const IdRefList & imageOperandIdsList)2925 void WriteImageSparseSampleProjExplicitLod(Blob *blob,
2926 IdResultType idResultType1,
2927 IdResult idResult2,
2928 IdRef sampledImage,
2929 IdRef coordinate,
2930 spv::ImageOperandsMask imageOperands5,
2931 const IdRefList &imageOperandIdsList)
2932 {
2933 const size_t startSize = blob->size();
2934 blob->push_back(0);
2935 blob->push_back(idResultType1);
2936 blob->push_back(idResult2);
2937 blob->push_back(sampledImage);
2938 blob->push_back(coordinate);
2939 blob->push_back(imageOperands5);
2940 for (const auto &operand : imageOperandIdsList)
2941 {
2942 blob->push_back(operand);
2943 }
2944 (*blob)[startSize] =
2945 MakeLengthOp(blob->size() - startSize, spv::OpImageSparseSampleProjExplicitLod);
2946 }
WriteImageSparseSampleProjDrefImplicitLod(Blob * blob,IdResultType idResultType1,IdResult idResult2,IdRef sampledImage,IdRef coordinate,IdRef dref,const spv::ImageOperandsMask * imageOperands6,const IdRefList & imageOperandIdsList)2947 void WriteImageSparseSampleProjDrefImplicitLod(Blob *blob,
2948 IdResultType idResultType1,
2949 IdResult idResult2,
2950 IdRef sampledImage,
2951 IdRef coordinate,
2952 IdRef dref,
2953 const spv::ImageOperandsMask *imageOperands6,
2954 const IdRefList &imageOperandIdsList)
2955 {
2956 const size_t startSize = blob->size();
2957 blob->push_back(0);
2958 blob->push_back(idResultType1);
2959 blob->push_back(idResult2);
2960 blob->push_back(sampledImage);
2961 blob->push_back(coordinate);
2962 blob->push_back(dref);
2963 if (imageOperands6)
2964 {
2965 blob->push_back(*imageOperands6);
2966 }
2967 for (const auto &operand : imageOperandIdsList)
2968 {
2969 blob->push_back(operand);
2970 }
2971 (*blob)[startSize] =
2972 MakeLengthOp(blob->size() - startSize, spv::OpImageSparseSampleProjDrefImplicitLod);
2973 }
WriteImageSparseSampleProjDrefExplicitLod(Blob * blob,IdResultType idResultType1,IdResult idResult2,IdRef sampledImage,IdRef coordinate,IdRef dref,spv::ImageOperandsMask imageOperands6,const IdRefList & imageOperandIdsList)2974 void WriteImageSparseSampleProjDrefExplicitLod(Blob *blob,
2975 IdResultType idResultType1,
2976 IdResult idResult2,
2977 IdRef sampledImage,
2978 IdRef coordinate,
2979 IdRef dref,
2980 spv::ImageOperandsMask imageOperands6,
2981 const IdRefList &imageOperandIdsList)
2982 {
2983 const size_t startSize = blob->size();
2984 blob->push_back(0);
2985 blob->push_back(idResultType1);
2986 blob->push_back(idResult2);
2987 blob->push_back(sampledImage);
2988 blob->push_back(coordinate);
2989 blob->push_back(dref);
2990 blob->push_back(imageOperands6);
2991 for (const auto &operand : imageOperandIdsList)
2992 {
2993 blob->push_back(operand);
2994 }
2995 (*blob)[startSize] =
2996 MakeLengthOp(blob->size() - startSize, spv::OpImageSparseSampleProjDrefExplicitLod);
2997 }
WriteImageSparseFetch(Blob * blob,IdResultType idResultType1,IdResult idResult2,IdRef image,IdRef coordinate,const spv::ImageOperandsMask * imageOperands5,const IdRefList & imageOperandIdsList)2998 void WriteImageSparseFetch(Blob *blob,
2999 IdResultType idResultType1,
3000 IdResult idResult2,
3001 IdRef image,
3002 IdRef coordinate,
3003 const spv::ImageOperandsMask *imageOperands5,
3004 const IdRefList &imageOperandIdsList)
3005 {
3006 const size_t startSize = blob->size();
3007 blob->push_back(0);
3008 blob->push_back(idResultType1);
3009 blob->push_back(idResult2);
3010 blob->push_back(image);
3011 blob->push_back(coordinate);
3012 if (imageOperands5)
3013 {
3014 blob->push_back(*imageOperands5);
3015 }
3016 for (const auto &operand : imageOperandIdsList)
3017 {
3018 blob->push_back(operand);
3019 }
3020 (*blob)[startSize] = MakeLengthOp(blob->size() - startSize, spv::OpImageSparseFetch);
3021 }
WriteImageSparseGather(Blob * blob,IdResultType idResultType1,IdResult idResult2,IdRef sampledImage,IdRef coordinate,IdRef component,const spv::ImageOperandsMask * imageOperands6,const IdRefList & imageOperandIdsList)3022 void WriteImageSparseGather(Blob *blob,
3023 IdResultType idResultType1,
3024 IdResult idResult2,
3025 IdRef sampledImage,
3026 IdRef coordinate,
3027 IdRef component,
3028 const spv::ImageOperandsMask *imageOperands6,
3029 const IdRefList &imageOperandIdsList)
3030 {
3031 const size_t startSize = blob->size();
3032 blob->push_back(0);
3033 blob->push_back(idResultType1);
3034 blob->push_back(idResult2);
3035 blob->push_back(sampledImage);
3036 blob->push_back(coordinate);
3037 blob->push_back(component);
3038 if (imageOperands6)
3039 {
3040 blob->push_back(*imageOperands6);
3041 }
3042 for (const auto &operand : imageOperandIdsList)
3043 {
3044 blob->push_back(operand);
3045 }
3046 (*blob)[startSize] = MakeLengthOp(blob->size() - startSize, spv::OpImageSparseGather);
3047 }
WriteImageSparseDrefGather(Blob * blob,IdResultType idResultType1,IdResult idResult2,IdRef sampledImage,IdRef coordinate,IdRef dref,const spv::ImageOperandsMask * imageOperands6,const IdRefList & imageOperandIdsList)3048 void WriteImageSparseDrefGather(Blob *blob,
3049 IdResultType idResultType1,
3050 IdResult idResult2,
3051 IdRef sampledImage,
3052 IdRef coordinate,
3053 IdRef dref,
3054 const spv::ImageOperandsMask *imageOperands6,
3055 const IdRefList &imageOperandIdsList)
3056 {
3057 const size_t startSize = blob->size();
3058 blob->push_back(0);
3059 blob->push_back(idResultType1);
3060 blob->push_back(idResult2);
3061 blob->push_back(sampledImage);
3062 blob->push_back(coordinate);
3063 blob->push_back(dref);
3064 if (imageOperands6)
3065 {
3066 blob->push_back(*imageOperands6);
3067 }
3068 for (const auto &operand : imageOperandIdsList)
3069 {
3070 blob->push_back(operand);
3071 }
3072 (*blob)[startSize] = MakeLengthOp(blob->size() - startSize, spv::OpImageSparseDrefGather);
3073 }
WriteImageSparseTexelsResident(Blob * blob,IdResultType idResultType1,IdResult idResult2,IdRef residentCode)3074 void WriteImageSparseTexelsResident(Blob *blob,
3075 IdResultType idResultType1,
3076 IdResult idResult2,
3077 IdRef residentCode)
3078 {
3079 const size_t startSize = blob->size();
3080 blob->push_back(0);
3081 blob->push_back(idResultType1);
3082 blob->push_back(idResult2);
3083 blob->push_back(residentCode);
3084 (*blob)[startSize] = MakeLengthOp(blob->size() - startSize, spv::OpImageSparseTexelsResident);
3085 }
WriteNoLine(Blob * blob)3086 void WriteNoLine(Blob *blob)
3087 {
3088 const size_t startSize = blob->size();
3089 blob->push_back(0);
3090
3091 (*blob)[startSize] = MakeLengthOp(blob->size() - startSize, spv::OpNoLine);
3092 }
WriteImageSparseRead(Blob * blob,IdResultType idResultType1,IdResult idResult2,IdRef image,IdRef coordinate,const spv::ImageOperandsMask * imageOperands5,const IdRefList & imageOperandIdsList)3093 void WriteImageSparseRead(Blob *blob,
3094 IdResultType idResultType1,
3095 IdResult idResult2,
3096 IdRef image,
3097 IdRef coordinate,
3098 const spv::ImageOperandsMask *imageOperands5,
3099 const IdRefList &imageOperandIdsList)
3100 {
3101 const size_t startSize = blob->size();
3102 blob->push_back(0);
3103 blob->push_back(idResultType1);
3104 blob->push_back(idResult2);
3105 blob->push_back(image);
3106 blob->push_back(coordinate);
3107 if (imageOperands5)
3108 {
3109 blob->push_back(*imageOperands5);
3110 }
3111 for (const auto &operand : imageOperandIdsList)
3112 {
3113 blob->push_back(operand);
3114 }
3115 (*blob)[startSize] = MakeLengthOp(blob->size() - startSize, spv::OpImageSparseRead);
3116 }
WriteModuleProcessed(Blob * blob,LiteralString process)3117 void WriteModuleProcessed(Blob *blob, LiteralString process)
3118 {
3119 const size_t startSize = blob->size();
3120 blob->push_back(0);
3121 {
3122 size_t d = blob->size();
3123 blob->resize(d + strlen(process) / 4 + 1, 0);
3124 ASSERT(IsLittleEndian());
3125 strcpy(reinterpret_cast<char *>(blob->data() + d), process);
3126 }
3127 (*blob)[startSize] = MakeLengthOp(blob->size() - startSize, spv::OpModuleProcessed);
3128 }
WriteExecutionModeId(Blob * blob,IdRef entryPoint,spv::ExecutionMode mode,const LiteralIntegerList & operandsList)3129 void WriteExecutionModeId(Blob *blob,
3130 IdRef entryPoint,
3131 spv::ExecutionMode mode,
3132 const LiteralIntegerList &operandsList)
3133 {
3134 const size_t startSize = blob->size();
3135 blob->push_back(0);
3136 blob->push_back(entryPoint);
3137 blob->push_back(mode);
3138 for (const auto &operand : operandsList)
3139 {
3140 blob->push_back(operand);
3141 }
3142 (*blob)[startSize] = MakeLengthOp(blob->size() - startSize, spv::OpExecutionModeId);
3143 }
WriteGroupNonUniformElect(Blob * blob,IdResultType idResultType1,IdResult idResult2,IdScope execution)3144 void WriteGroupNonUniformElect(Blob *blob,
3145 IdResultType idResultType1,
3146 IdResult idResult2,
3147 IdScope execution)
3148 {
3149 const size_t startSize = blob->size();
3150 blob->push_back(0);
3151 blob->push_back(idResultType1);
3152 blob->push_back(idResult2);
3153 blob->push_back(execution);
3154 (*blob)[startSize] = MakeLengthOp(blob->size() - startSize, spv::OpGroupNonUniformElect);
3155 }
WriteGroupNonUniformAll(Blob * blob,IdResultType idResultType1,IdResult idResult2,IdScope execution,IdRef predicate)3156 void WriteGroupNonUniformAll(Blob *blob,
3157 IdResultType idResultType1,
3158 IdResult idResult2,
3159 IdScope execution,
3160 IdRef predicate)
3161 {
3162 const size_t startSize = blob->size();
3163 blob->push_back(0);
3164 blob->push_back(idResultType1);
3165 blob->push_back(idResult2);
3166 blob->push_back(execution);
3167 blob->push_back(predicate);
3168 (*blob)[startSize] = MakeLengthOp(blob->size() - startSize, spv::OpGroupNonUniformAll);
3169 }
WriteGroupNonUniformAny(Blob * blob,IdResultType idResultType1,IdResult idResult2,IdScope execution,IdRef predicate)3170 void WriteGroupNonUniformAny(Blob *blob,
3171 IdResultType idResultType1,
3172 IdResult idResult2,
3173 IdScope execution,
3174 IdRef predicate)
3175 {
3176 const size_t startSize = blob->size();
3177 blob->push_back(0);
3178 blob->push_back(idResultType1);
3179 blob->push_back(idResult2);
3180 blob->push_back(execution);
3181 blob->push_back(predicate);
3182 (*blob)[startSize] = MakeLengthOp(blob->size() - startSize, spv::OpGroupNonUniformAny);
3183 }
WriteGroupNonUniformAllEqual(Blob * blob,IdResultType idResultType1,IdResult idResult2,IdScope execution,IdRef value)3184 void WriteGroupNonUniformAllEqual(Blob *blob,
3185 IdResultType idResultType1,
3186 IdResult idResult2,
3187 IdScope execution,
3188 IdRef value)
3189 {
3190 const size_t startSize = blob->size();
3191 blob->push_back(0);
3192 blob->push_back(idResultType1);
3193 blob->push_back(idResult2);
3194 blob->push_back(execution);
3195 blob->push_back(value);
3196 (*blob)[startSize] = MakeLengthOp(blob->size() - startSize, spv::OpGroupNonUniformAllEqual);
3197 }
WriteGroupNonUniformBroadcast(Blob * blob,IdResultType idResultType1,IdResult idResult2,IdScope execution,IdRef value,IdRef id)3198 void WriteGroupNonUniformBroadcast(Blob *blob,
3199 IdResultType idResultType1,
3200 IdResult idResult2,
3201 IdScope execution,
3202 IdRef value,
3203 IdRef id)
3204 {
3205 const size_t startSize = blob->size();
3206 blob->push_back(0);
3207 blob->push_back(idResultType1);
3208 blob->push_back(idResult2);
3209 blob->push_back(execution);
3210 blob->push_back(value);
3211 blob->push_back(id);
3212 (*blob)[startSize] = MakeLengthOp(blob->size() - startSize, spv::OpGroupNonUniformBroadcast);
3213 }
WriteGroupNonUniformBroadcastFirst(Blob * blob,IdResultType idResultType1,IdResult idResult2,IdScope execution,IdRef value)3214 void WriteGroupNonUniformBroadcastFirst(Blob *blob,
3215 IdResultType idResultType1,
3216 IdResult idResult2,
3217 IdScope execution,
3218 IdRef value)
3219 {
3220 const size_t startSize = blob->size();
3221 blob->push_back(0);
3222 blob->push_back(idResultType1);
3223 blob->push_back(idResult2);
3224 blob->push_back(execution);
3225 blob->push_back(value);
3226 (*blob)[startSize] =
3227 MakeLengthOp(blob->size() - startSize, spv::OpGroupNonUniformBroadcastFirst);
3228 }
WriteGroupNonUniformBallot(Blob * blob,IdResultType idResultType1,IdResult idResult2,IdScope execution,IdRef predicate)3229 void WriteGroupNonUniformBallot(Blob *blob,
3230 IdResultType idResultType1,
3231 IdResult idResult2,
3232 IdScope execution,
3233 IdRef predicate)
3234 {
3235 const size_t startSize = blob->size();
3236 blob->push_back(0);
3237 blob->push_back(idResultType1);
3238 blob->push_back(idResult2);
3239 blob->push_back(execution);
3240 blob->push_back(predicate);
3241 (*blob)[startSize] = MakeLengthOp(blob->size() - startSize, spv::OpGroupNonUniformBallot);
3242 }
WriteGroupNonUniformInverseBallot(Blob * blob,IdResultType idResultType1,IdResult idResult2,IdScope execution,IdRef value)3243 void WriteGroupNonUniformInverseBallot(Blob *blob,
3244 IdResultType idResultType1,
3245 IdResult idResult2,
3246 IdScope execution,
3247 IdRef value)
3248 {
3249 const size_t startSize = blob->size();
3250 blob->push_back(0);
3251 blob->push_back(idResultType1);
3252 blob->push_back(idResult2);
3253 blob->push_back(execution);
3254 blob->push_back(value);
3255 (*blob)[startSize] =
3256 MakeLengthOp(blob->size() - startSize, spv::OpGroupNonUniformInverseBallot);
3257 }
WriteGroupNonUniformBallotBitExtract(Blob * blob,IdResultType idResultType1,IdResult idResult2,IdScope execution,IdRef value,IdRef index)3258 void WriteGroupNonUniformBallotBitExtract(Blob *blob,
3259 IdResultType idResultType1,
3260 IdResult idResult2,
3261 IdScope execution,
3262 IdRef value,
3263 IdRef index)
3264 {
3265 const size_t startSize = blob->size();
3266 blob->push_back(0);
3267 blob->push_back(idResultType1);
3268 blob->push_back(idResult2);
3269 blob->push_back(execution);
3270 blob->push_back(value);
3271 blob->push_back(index);
3272 (*blob)[startSize] =
3273 MakeLengthOp(blob->size() - startSize, spv::OpGroupNonUniformBallotBitExtract);
3274 }
WriteGroupNonUniformBallotBitCount(Blob * blob,IdResultType idResultType1,IdResult idResult2,IdScope execution,spv::GroupOperation operation,IdRef value)3275 void WriteGroupNonUniformBallotBitCount(Blob *blob,
3276 IdResultType idResultType1,
3277 IdResult idResult2,
3278 IdScope execution,
3279 spv::GroupOperation operation,
3280 IdRef value)
3281 {
3282 const size_t startSize = blob->size();
3283 blob->push_back(0);
3284 blob->push_back(idResultType1);
3285 blob->push_back(idResult2);
3286 blob->push_back(execution);
3287 blob->push_back(operation);
3288 blob->push_back(value);
3289 (*blob)[startSize] =
3290 MakeLengthOp(blob->size() - startSize, spv::OpGroupNonUniformBallotBitCount);
3291 }
WriteGroupNonUniformBallotFindLSB(Blob * blob,IdResultType idResultType1,IdResult idResult2,IdScope execution,IdRef value)3292 void WriteGroupNonUniformBallotFindLSB(Blob *blob,
3293 IdResultType idResultType1,
3294 IdResult idResult2,
3295 IdScope execution,
3296 IdRef value)
3297 {
3298 const size_t startSize = blob->size();
3299 blob->push_back(0);
3300 blob->push_back(idResultType1);
3301 blob->push_back(idResult2);
3302 blob->push_back(execution);
3303 blob->push_back(value);
3304 (*blob)[startSize] =
3305 MakeLengthOp(blob->size() - startSize, spv::OpGroupNonUniformBallotFindLSB);
3306 }
WriteGroupNonUniformBallotFindMSB(Blob * blob,IdResultType idResultType1,IdResult idResult2,IdScope execution,IdRef value)3307 void WriteGroupNonUniformBallotFindMSB(Blob *blob,
3308 IdResultType idResultType1,
3309 IdResult idResult2,
3310 IdScope execution,
3311 IdRef value)
3312 {
3313 const size_t startSize = blob->size();
3314 blob->push_back(0);
3315 blob->push_back(idResultType1);
3316 blob->push_back(idResult2);
3317 blob->push_back(execution);
3318 blob->push_back(value);
3319 (*blob)[startSize] =
3320 MakeLengthOp(blob->size() - startSize, spv::OpGroupNonUniformBallotFindMSB);
3321 }
WriteGroupNonUniformShuffle(Blob * blob,IdResultType idResultType1,IdResult idResult2,IdScope execution,IdRef value,IdRef id)3322 void WriteGroupNonUniformShuffle(Blob *blob,
3323 IdResultType idResultType1,
3324 IdResult idResult2,
3325 IdScope execution,
3326 IdRef value,
3327 IdRef id)
3328 {
3329 const size_t startSize = blob->size();
3330 blob->push_back(0);
3331 blob->push_back(idResultType1);
3332 blob->push_back(idResult2);
3333 blob->push_back(execution);
3334 blob->push_back(value);
3335 blob->push_back(id);
3336 (*blob)[startSize] = MakeLengthOp(blob->size() - startSize, spv::OpGroupNonUniformShuffle);
3337 }
WriteGroupNonUniformShuffleXor(Blob * blob,IdResultType idResultType1,IdResult idResult2,IdScope execution,IdRef value,IdRef mask)3338 void WriteGroupNonUniformShuffleXor(Blob *blob,
3339 IdResultType idResultType1,
3340 IdResult idResult2,
3341 IdScope execution,
3342 IdRef value,
3343 IdRef mask)
3344 {
3345 const size_t startSize = blob->size();
3346 blob->push_back(0);
3347 blob->push_back(idResultType1);
3348 blob->push_back(idResult2);
3349 blob->push_back(execution);
3350 blob->push_back(value);
3351 blob->push_back(mask);
3352 (*blob)[startSize] = MakeLengthOp(blob->size() - startSize, spv::OpGroupNonUniformShuffleXor);
3353 }
WriteGroupNonUniformShuffleUp(Blob * blob,IdResultType idResultType1,IdResult idResult2,IdScope execution,IdRef value,IdRef delta)3354 void WriteGroupNonUniformShuffleUp(Blob *blob,
3355 IdResultType idResultType1,
3356 IdResult idResult2,
3357 IdScope execution,
3358 IdRef value,
3359 IdRef delta)
3360 {
3361 const size_t startSize = blob->size();
3362 blob->push_back(0);
3363 blob->push_back(idResultType1);
3364 blob->push_back(idResult2);
3365 blob->push_back(execution);
3366 blob->push_back(value);
3367 blob->push_back(delta);
3368 (*blob)[startSize] = MakeLengthOp(blob->size() - startSize, spv::OpGroupNonUniformShuffleUp);
3369 }
WriteGroupNonUniformShuffleDown(Blob * blob,IdResultType idResultType1,IdResult idResult2,IdScope execution,IdRef value,IdRef delta)3370 void WriteGroupNonUniformShuffleDown(Blob *blob,
3371 IdResultType idResultType1,
3372 IdResult idResult2,
3373 IdScope execution,
3374 IdRef value,
3375 IdRef delta)
3376 {
3377 const size_t startSize = blob->size();
3378 blob->push_back(0);
3379 blob->push_back(idResultType1);
3380 blob->push_back(idResult2);
3381 blob->push_back(execution);
3382 blob->push_back(value);
3383 blob->push_back(delta);
3384 (*blob)[startSize] = MakeLengthOp(blob->size() - startSize, spv::OpGroupNonUniformShuffleDown);
3385 }
WriteGroupNonUniformIAdd(Blob * blob,IdResultType idResultType1,IdResult idResult2,IdScope execution,spv::GroupOperation operation,IdRef value,const IdRef * clusterSize)3386 void WriteGroupNonUniformIAdd(Blob *blob,
3387 IdResultType idResultType1,
3388 IdResult idResult2,
3389 IdScope execution,
3390 spv::GroupOperation operation,
3391 IdRef value,
3392 const IdRef *clusterSize)
3393 {
3394 const size_t startSize = blob->size();
3395 blob->push_back(0);
3396 blob->push_back(idResultType1);
3397 blob->push_back(idResult2);
3398 blob->push_back(execution);
3399 blob->push_back(operation);
3400 blob->push_back(value);
3401 if (clusterSize)
3402 {
3403 blob->push_back(*clusterSize);
3404 }
3405 (*blob)[startSize] = MakeLengthOp(blob->size() - startSize, spv::OpGroupNonUniformIAdd);
3406 }
WriteGroupNonUniformFAdd(Blob * blob,IdResultType idResultType1,IdResult idResult2,IdScope execution,spv::GroupOperation operation,IdRef value,const IdRef * clusterSize)3407 void WriteGroupNonUniformFAdd(Blob *blob,
3408 IdResultType idResultType1,
3409 IdResult idResult2,
3410 IdScope execution,
3411 spv::GroupOperation operation,
3412 IdRef value,
3413 const IdRef *clusterSize)
3414 {
3415 const size_t startSize = blob->size();
3416 blob->push_back(0);
3417 blob->push_back(idResultType1);
3418 blob->push_back(idResult2);
3419 blob->push_back(execution);
3420 blob->push_back(operation);
3421 blob->push_back(value);
3422 if (clusterSize)
3423 {
3424 blob->push_back(*clusterSize);
3425 }
3426 (*blob)[startSize] = MakeLengthOp(blob->size() - startSize, spv::OpGroupNonUniformFAdd);
3427 }
WriteGroupNonUniformIMul(Blob * blob,IdResultType idResultType1,IdResult idResult2,IdScope execution,spv::GroupOperation operation,IdRef value,const IdRef * clusterSize)3428 void WriteGroupNonUniformIMul(Blob *blob,
3429 IdResultType idResultType1,
3430 IdResult idResult2,
3431 IdScope execution,
3432 spv::GroupOperation operation,
3433 IdRef value,
3434 const IdRef *clusterSize)
3435 {
3436 const size_t startSize = blob->size();
3437 blob->push_back(0);
3438 blob->push_back(idResultType1);
3439 blob->push_back(idResult2);
3440 blob->push_back(execution);
3441 blob->push_back(operation);
3442 blob->push_back(value);
3443 if (clusterSize)
3444 {
3445 blob->push_back(*clusterSize);
3446 }
3447 (*blob)[startSize] = MakeLengthOp(blob->size() - startSize, spv::OpGroupNonUniformIMul);
3448 }
WriteGroupNonUniformFMul(Blob * blob,IdResultType idResultType1,IdResult idResult2,IdScope execution,spv::GroupOperation operation,IdRef value,const IdRef * clusterSize)3449 void WriteGroupNonUniformFMul(Blob *blob,
3450 IdResultType idResultType1,
3451 IdResult idResult2,
3452 IdScope execution,
3453 spv::GroupOperation operation,
3454 IdRef value,
3455 const IdRef *clusterSize)
3456 {
3457 const size_t startSize = blob->size();
3458 blob->push_back(0);
3459 blob->push_back(idResultType1);
3460 blob->push_back(idResult2);
3461 blob->push_back(execution);
3462 blob->push_back(operation);
3463 blob->push_back(value);
3464 if (clusterSize)
3465 {
3466 blob->push_back(*clusterSize);
3467 }
3468 (*blob)[startSize] = MakeLengthOp(blob->size() - startSize, spv::OpGroupNonUniformFMul);
3469 }
WriteGroupNonUniformSMin(Blob * blob,IdResultType idResultType1,IdResult idResult2,IdScope execution,spv::GroupOperation operation,IdRef value,const IdRef * clusterSize)3470 void WriteGroupNonUniformSMin(Blob *blob,
3471 IdResultType idResultType1,
3472 IdResult idResult2,
3473 IdScope execution,
3474 spv::GroupOperation operation,
3475 IdRef value,
3476 const IdRef *clusterSize)
3477 {
3478 const size_t startSize = blob->size();
3479 blob->push_back(0);
3480 blob->push_back(idResultType1);
3481 blob->push_back(idResult2);
3482 blob->push_back(execution);
3483 blob->push_back(operation);
3484 blob->push_back(value);
3485 if (clusterSize)
3486 {
3487 blob->push_back(*clusterSize);
3488 }
3489 (*blob)[startSize] = MakeLengthOp(blob->size() - startSize, spv::OpGroupNonUniformSMin);
3490 }
WriteGroupNonUniformUMin(Blob * blob,IdResultType idResultType1,IdResult idResult2,IdScope execution,spv::GroupOperation operation,IdRef value,const IdRef * clusterSize)3491 void WriteGroupNonUniformUMin(Blob *blob,
3492 IdResultType idResultType1,
3493 IdResult idResult2,
3494 IdScope execution,
3495 spv::GroupOperation operation,
3496 IdRef value,
3497 const IdRef *clusterSize)
3498 {
3499 const size_t startSize = blob->size();
3500 blob->push_back(0);
3501 blob->push_back(idResultType1);
3502 blob->push_back(idResult2);
3503 blob->push_back(execution);
3504 blob->push_back(operation);
3505 blob->push_back(value);
3506 if (clusterSize)
3507 {
3508 blob->push_back(*clusterSize);
3509 }
3510 (*blob)[startSize] = MakeLengthOp(blob->size() - startSize, spv::OpGroupNonUniformUMin);
3511 }
WriteGroupNonUniformFMin(Blob * blob,IdResultType idResultType1,IdResult idResult2,IdScope execution,spv::GroupOperation operation,IdRef value,const IdRef * clusterSize)3512 void WriteGroupNonUniformFMin(Blob *blob,
3513 IdResultType idResultType1,
3514 IdResult idResult2,
3515 IdScope execution,
3516 spv::GroupOperation operation,
3517 IdRef value,
3518 const IdRef *clusterSize)
3519 {
3520 const size_t startSize = blob->size();
3521 blob->push_back(0);
3522 blob->push_back(idResultType1);
3523 blob->push_back(idResult2);
3524 blob->push_back(execution);
3525 blob->push_back(operation);
3526 blob->push_back(value);
3527 if (clusterSize)
3528 {
3529 blob->push_back(*clusterSize);
3530 }
3531 (*blob)[startSize] = MakeLengthOp(blob->size() - startSize, spv::OpGroupNonUniformFMin);
3532 }
WriteGroupNonUniformSMax(Blob * blob,IdResultType idResultType1,IdResult idResult2,IdScope execution,spv::GroupOperation operation,IdRef value,const IdRef * clusterSize)3533 void WriteGroupNonUniformSMax(Blob *blob,
3534 IdResultType idResultType1,
3535 IdResult idResult2,
3536 IdScope execution,
3537 spv::GroupOperation operation,
3538 IdRef value,
3539 const IdRef *clusterSize)
3540 {
3541 const size_t startSize = blob->size();
3542 blob->push_back(0);
3543 blob->push_back(idResultType1);
3544 blob->push_back(idResult2);
3545 blob->push_back(execution);
3546 blob->push_back(operation);
3547 blob->push_back(value);
3548 if (clusterSize)
3549 {
3550 blob->push_back(*clusterSize);
3551 }
3552 (*blob)[startSize] = MakeLengthOp(blob->size() - startSize, spv::OpGroupNonUniformSMax);
3553 }
WriteGroupNonUniformUMax(Blob * blob,IdResultType idResultType1,IdResult idResult2,IdScope execution,spv::GroupOperation operation,IdRef value,const IdRef * clusterSize)3554 void WriteGroupNonUniformUMax(Blob *blob,
3555 IdResultType idResultType1,
3556 IdResult idResult2,
3557 IdScope execution,
3558 spv::GroupOperation operation,
3559 IdRef value,
3560 const IdRef *clusterSize)
3561 {
3562 const size_t startSize = blob->size();
3563 blob->push_back(0);
3564 blob->push_back(idResultType1);
3565 blob->push_back(idResult2);
3566 blob->push_back(execution);
3567 blob->push_back(operation);
3568 blob->push_back(value);
3569 if (clusterSize)
3570 {
3571 blob->push_back(*clusterSize);
3572 }
3573 (*blob)[startSize] = MakeLengthOp(blob->size() - startSize, spv::OpGroupNonUniformUMax);
3574 }
WriteGroupNonUniformFMax(Blob * blob,IdResultType idResultType1,IdResult idResult2,IdScope execution,spv::GroupOperation operation,IdRef value,const IdRef * clusterSize)3575 void WriteGroupNonUniformFMax(Blob *blob,
3576 IdResultType idResultType1,
3577 IdResult idResult2,
3578 IdScope execution,
3579 spv::GroupOperation operation,
3580 IdRef value,
3581 const IdRef *clusterSize)
3582 {
3583 const size_t startSize = blob->size();
3584 blob->push_back(0);
3585 blob->push_back(idResultType1);
3586 blob->push_back(idResult2);
3587 blob->push_back(execution);
3588 blob->push_back(operation);
3589 blob->push_back(value);
3590 if (clusterSize)
3591 {
3592 blob->push_back(*clusterSize);
3593 }
3594 (*blob)[startSize] = MakeLengthOp(blob->size() - startSize, spv::OpGroupNonUniformFMax);
3595 }
WriteGroupNonUniformBitwiseAnd(Blob * blob,IdResultType idResultType1,IdResult idResult2,IdScope execution,spv::GroupOperation operation,IdRef value,const IdRef * clusterSize)3596 void WriteGroupNonUniformBitwiseAnd(Blob *blob,
3597 IdResultType idResultType1,
3598 IdResult idResult2,
3599 IdScope execution,
3600 spv::GroupOperation operation,
3601 IdRef value,
3602 const IdRef *clusterSize)
3603 {
3604 const size_t startSize = blob->size();
3605 blob->push_back(0);
3606 blob->push_back(idResultType1);
3607 blob->push_back(idResult2);
3608 blob->push_back(execution);
3609 blob->push_back(operation);
3610 blob->push_back(value);
3611 if (clusterSize)
3612 {
3613 blob->push_back(*clusterSize);
3614 }
3615 (*blob)[startSize] = MakeLengthOp(blob->size() - startSize, spv::OpGroupNonUniformBitwiseAnd);
3616 }
WriteGroupNonUniformBitwiseOr(Blob * blob,IdResultType idResultType1,IdResult idResult2,IdScope execution,spv::GroupOperation operation,IdRef value,const IdRef * clusterSize)3617