• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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 &parameterList)
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 void WriteGroupNonUniformBitwiseOr(Blob *blob,
3630                                    IdResultType idResultType1,
3631                                    IdResult idResult2,
3632                                    IdScope execution,
3633                                    spv::GroupOperation operation,
3634                                    IdRef value,
3635                                    const IdRef *clusterSize)
3636 {
3637     const size_t startSize = blob->size();
3638     blob->push_back(0);
3639     blob->push_back(idResultType1);
3640     blob->push_back(idResult2);
3641     blob->push_back(execution);
3642     blob->push_back(operation);
3643     blob->push_back(value);
3644     if (clusterSize)
3645     {
3646         blob->push_back(*clusterSize);
3647     }
3648     (*blob)[startSize] = MakeLengthOp(blob->size() - startSize, spv::OpGroupNonUniformBitwiseOr);
3649 }
WriteGroupNonUniformBitwiseXor(Blob * blob,IdResultType idResultType1,IdResult idResult2,IdScope execution,spv::GroupOperation operation,IdRef value,const IdRef * clusterSize)3650 void WriteGroupNonUniformBitwiseXor(Blob *blob,
3651                                     IdResultType idResultType1,
3652                                     IdResult idResult2,
3653                                     IdScope execution,
3654                                     spv::GroupOperation operation,
3655                                     IdRef value,
3656                                     const IdRef *clusterSize)
3657 {
3658     const size_t startSize = blob->size();
3659     blob->push_back(0);
3660     blob->push_back(idResultType1);
3661     blob->push_back(idResult2);
3662     blob->push_back(execution);
3663     blob->push_back(operation);
3664     blob->push_back(value);
3665     if (clusterSize)
3666     {
3667         blob->push_back(*clusterSize);
3668     }
3669     (*blob)[startSize] = MakeLengthOp(blob->size() - startSize, spv::OpGroupNonUniformBitwiseXor);
3670 }
WriteGroupNonUniformLogicalAnd(Blob * blob,IdResultType idResultType1,IdResult idResult2,IdScope execution,spv::GroupOperation operation,IdRef value,const IdRef * clusterSize)3671 void WriteGroupNonUniformLogicalAnd(Blob *blob,
3672                                     IdResultType idResultType1,
3673                                     IdResult idResult2,
3674                                     IdScope execution,
3675                                     spv::GroupOperation operation,
3676                                     IdRef value,
3677                                     const IdRef *clusterSize)
3678 {
3679     const size_t startSize = blob->size();
3680     blob->push_back(0);
3681     blob->push_back(idResultType1);
3682     blob->push_back(idResult2);
3683     blob->push_back(execution);
3684     blob->push_back(operation);
3685     blob->push_back(value);
3686     if (clusterSize)
3687     {
3688         blob->push_back(*clusterSize);
3689     }
3690     (*blob)[startSize] = MakeLengthOp(blob->size() - startSize, spv::OpGroupNonUniformLogicalAnd);
3691 }
WriteGroupNonUniformLogicalOr(Blob * blob,IdResultType idResultType1,IdResult idResult2,IdScope execution,spv::GroupOperation operation,IdRef value,const IdRef * clusterSize)3692 void WriteGroupNonUniformLogicalOr(Blob *blob,
3693                                    IdResultType idResultType1,
3694                                    IdResult idResult2,
3695                                    IdScope execution,
3696                                    spv::GroupOperation operation,
3697                                    IdRef value,
3698                                    const IdRef *clusterSize)
3699 {
3700     const size_t startSize = blob->size();
3701     blob->push_back(0);
3702     blob->push_back(idResultType1);
3703     blob->push_back(idResult2);
3704     blob->push_back(execution);
3705     blob->push_back(operation);
3706     blob->push_back(value);
3707     if (clusterSize)
3708     {
3709         blob->push_back(*clusterSize);
3710     }
3711     (*blob)[startSize] = MakeLengthOp(blob->size() - startSize, spv::OpGroupNonUniformLogicalOr);
3712 }
WriteGroupNonUniformLogicalXor(Blob * blob,IdResultType idResultType1,IdResult idResult2,IdScope execution,spv::GroupOperation operation,IdRef value,const IdRef * clusterSize)3713 void WriteGroupNonUniformLogicalXor(Blob *blob,
3714                                     IdResultType idResultType1,
3715                                     IdResult idResult2,
3716                                     IdScope execution,
3717                                     spv::GroupOperation operation,
3718                                     IdRef value,
3719                                     const IdRef *clusterSize)
3720 {
3721     const size_t startSize = blob->size();
3722     blob->push_back(0);
3723     blob->push_back(idResultType1);
3724     blob->push_back(idResult2);
3725     blob->push_back(execution);
3726     blob->push_back(operation);
3727     blob->push_back(value);
3728     if (clusterSize)
3729     {
3730         blob->push_back(*clusterSize);
3731     }
3732     (*blob)[startSize] = MakeLengthOp(blob->size() - startSize, spv::OpGroupNonUniformLogicalXor);
3733 }
WriteGroupNonUniformQuadBroadcast(Blob * blob,IdResultType idResultType1,IdResult idResult2,IdScope execution,IdRef value,IdRef index)3734 void WriteGroupNonUniformQuadBroadcast(Blob *blob,
3735                                        IdResultType idResultType1,
3736                                        IdResult idResult2,
3737                                        IdScope execution,
3738                                        IdRef value,
3739                                        IdRef index)
3740 {
3741     const size_t startSize = blob->size();
3742     blob->push_back(0);
3743     blob->push_back(idResultType1);
3744     blob->push_back(idResult2);
3745     blob->push_back(execution);
3746     blob->push_back(value);
3747     blob->push_back(index);
3748     (*blob)[startSize] =
3749         MakeLengthOp(blob->size() - startSize, spv::OpGroupNonUniformQuadBroadcast);
3750 }
WriteGroupNonUniformQuadSwap(Blob * blob,IdResultType idResultType1,IdResult idResult2,IdScope execution,IdRef value,IdRef direction)3751 void WriteGroupNonUniformQuadSwap(Blob *blob,
3752                                   IdResultType idResultType1,
3753                                   IdResult idResult2,
3754                                   IdScope execution,
3755                                   IdRef value,
3756                                   IdRef direction)
3757 {
3758     const size_t startSize = blob->size();
3759     blob->push_back(0);
3760     blob->push_back(idResultType1);
3761     blob->push_back(idResult2);
3762     blob->push_back(execution);
3763     blob->push_back(value);
3764     blob->push_back(direction);
3765     (*blob)[startSize] = MakeLengthOp(blob->size() - startSize, spv::OpGroupNonUniformQuadSwap);
3766 }
WriteCopyLogical(Blob * blob,IdResultType idResultType1,IdResult idResult2,IdRef operand)3767 void WriteCopyLogical(Blob *blob, IdResultType idResultType1, IdResult idResult2, IdRef operand)
3768 {
3769     const size_t startSize = blob->size();
3770     blob->push_back(0);
3771     blob->push_back(idResultType1);
3772     blob->push_back(idResult2);
3773     blob->push_back(operand);
3774     (*blob)[startSize] = MakeLengthOp(blob->size() - startSize, spv::OpCopyLogical);
3775 }
WritePtrEqual(Blob * blob,IdResultType idResultType1,IdResult idResult2,IdRef operand1,IdRef operand2)3776 void WritePtrEqual(Blob *blob,
3777                    IdResultType idResultType1,
3778                    IdResult idResult2,
3779                    IdRef operand1,
3780                    IdRef operand2)
3781 {
3782     const size_t startSize = blob->size();
3783     blob->push_back(0);
3784     blob->push_back(idResultType1);
3785     blob->push_back(idResult2);
3786     blob->push_back(operand1);
3787     blob->push_back(operand2);
3788     (*blob)[startSize] = MakeLengthOp(blob->size() - startSize, spv::OpPtrEqual);
3789 }
WritePtrNotEqual(Blob * blob,IdResultType idResultType1,IdResult idResult2,IdRef operand1,IdRef operand2)3790 void WritePtrNotEqual(Blob *blob,
3791                       IdResultType idResultType1,
3792                       IdResult idResult2,
3793                       IdRef operand1,
3794                       IdRef operand2)
3795 {
3796     const size_t startSize = blob->size();
3797     blob->push_back(0);
3798     blob->push_back(idResultType1);
3799     blob->push_back(idResult2);
3800     blob->push_back(operand1);
3801     blob->push_back(operand2);
3802     (*blob)[startSize] = MakeLengthOp(blob->size() - startSize, spv::OpPtrNotEqual);
3803 }
WriteBeginInvocationInterlockEXT(Blob * blob)3804 void WriteBeginInvocationInterlockEXT(Blob *blob)
3805 {
3806     const size_t startSize = blob->size();
3807     blob->push_back(0);
3808 
3809     (*blob)[startSize] = MakeLengthOp(blob->size() - startSize, spv::OpBeginInvocationInterlockEXT);
3810 }
WriteEndInvocationInterlockEXT(Blob * blob)3811 void WriteEndInvocationInterlockEXT(Blob *blob)
3812 {
3813     const size_t startSize = blob->size();
3814     blob->push_back(0);
3815 
3816     (*blob)[startSize] = MakeLengthOp(blob->size() - startSize, spv::OpEndInvocationInterlockEXT);
3817 }
3818 
3819 }  // namespace spirv
3820 }  // namespace angle
3821