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