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