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_parser_autogen.cpp:
9 // Functions to parse SPIR-V binary for each instruction.
10
11 #include "spirv_instruction_parser_autogen.h"
12
13 #include <string.h>
14
15 #include "common/debug.h"
16
17 namespace angle
18 {
19 namespace spirv
20 {
21
GetInstructionOpAndLength(const uint32_t * _instruction,spv::Op * opOut,uint32_t * lengthOut)22 void GetInstructionOpAndLength(const uint32_t *_instruction, spv::Op *opOut, uint32_t *lengthOut)
23 {
24 constexpr uint32_t kOpMask = 0xFFFFu;
25 *opOut = static_cast<spv::Op>(_instruction[0] & kOpMask);
26 *lengthOut = _instruction[0] >> 16;
27 }
ParseUndef(const uint32_t * _instruction,IdResultType * idResultType1,IdResult * idResult2)28 void ParseUndef(const uint32_t *_instruction, IdResultType *idResultType1, IdResult *idResult2)
29 {
30 spv::Op _op;
31 uint32_t _length;
32 GetInstructionOpAndLength(_instruction, &_op, &_length);
33 ASSERT(_op == spv::OpUndef);
34 uint32_t _o = 1;
35 *idResultType1 = IdResultType(_instruction[_o++]);
36 *idResult2 = IdResult(_instruction[_o++]);
37 }
ParseSourceContinued(const uint32_t * _instruction,LiteralString * continuedSource)38 void ParseSourceContinued(const uint32_t *_instruction, LiteralString *continuedSource)
39 {
40 spv::Op _op;
41 uint32_t _length;
42 GetInstructionOpAndLength(_instruction, &_op, &_length);
43 ASSERT(_op == spv::OpSourceContinued);
44 uint32_t _o = 1;
45 ASSERT(IsLittleEndian());
46 *continuedSource = reinterpret_cast<const char *>(&_instruction[_o]);
47 _o += strlen(*continuedSource) / 4 + 1;
48 }
ParseSource(const uint32_t * _instruction,spv::SourceLanguage * sourceLanguage1,LiteralInteger * version,IdRef * file,LiteralString * source)49 void ParseSource(const uint32_t *_instruction,
50 spv::SourceLanguage *sourceLanguage1,
51 LiteralInteger *version,
52 IdRef *file,
53 LiteralString *source)
54 {
55 spv::Op _op;
56 uint32_t _length;
57 GetInstructionOpAndLength(_instruction, &_op, &_length);
58 ASSERT(_op == spv::OpSource);
59 uint32_t _o = 1;
60 *sourceLanguage1 = spv::SourceLanguage(_instruction[_o++]);
61 *version = LiteralInteger(_instruction[_o++]);
62 if (file && _o < _length)
63 {
64 *file = IdRef(_instruction[_o++]);
65 }
66 if (source && _o < _length)
67 {
68 ASSERT(IsLittleEndian());
69 *source = reinterpret_cast<const char *>(&_instruction[_o]);
70 _o += strlen(*source) / 4 + 1;
71 }
72 }
ParseSourceExtension(const uint32_t * _instruction,LiteralString * extension)73 void ParseSourceExtension(const uint32_t *_instruction, LiteralString *extension)
74 {
75 spv::Op _op;
76 uint32_t _length;
77 GetInstructionOpAndLength(_instruction, &_op, &_length);
78 ASSERT(_op == spv::OpSourceExtension);
79 uint32_t _o = 1;
80 ASSERT(IsLittleEndian());
81 *extension = reinterpret_cast<const char *>(&_instruction[_o]);
82 _o += strlen(*extension) / 4 + 1;
83 }
ParseName(const uint32_t * _instruction,IdRef * target,LiteralString * name)84 void ParseName(const uint32_t *_instruction, IdRef *target, LiteralString *name)
85 {
86 spv::Op _op;
87 uint32_t _length;
88 GetInstructionOpAndLength(_instruction, &_op, &_length);
89 ASSERT(_op == spv::OpName);
90 uint32_t _o = 1;
91 *target = IdRef(_instruction[_o++]);
92 ASSERT(IsLittleEndian());
93 *name = reinterpret_cast<const char *>(&_instruction[_o]);
94 _o += strlen(*name) / 4 + 1;
95 }
ParseMemberName(const uint32_t * _instruction,IdRef * type,LiteralInteger * member,LiteralString * name)96 void ParseMemberName(const uint32_t *_instruction,
97 IdRef *type,
98 LiteralInteger *member,
99 LiteralString *name)
100 {
101 spv::Op _op;
102 uint32_t _length;
103 GetInstructionOpAndLength(_instruction, &_op, &_length);
104 ASSERT(_op == spv::OpMemberName);
105 uint32_t _o = 1;
106 *type = IdRef(_instruction[_o++]);
107 *member = LiteralInteger(_instruction[_o++]);
108 ASSERT(IsLittleEndian());
109 *name = reinterpret_cast<const char *>(&_instruction[_o]);
110 _o += strlen(*name) / 4 + 1;
111 }
ParseString(const uint32_t * _instruction,IdResult * idResult1,LiteralString * string)112 void ParseString(const uint32_t *_instruction, IdResult *idResult1, LiteralString *string)
113 {
114 spv::Op _op;
115 uint32_t _length;
116 GetInstructionOpAndLength(_instruction, &_op, &_length);
117 ASSERT(_op == spv::OpString);
118 uint32_t _o = 1;
119 *idResult1 = IdResult(_instruction[_o++]);
120 ASSERT(IsLittleEndian());
121 *string = reinterpret_cast<const char *>(&_instruction[_o]);
122 _o += strlen(*string) / 4 + 1;
123 }
ParseLine(const uint32_t * _instruction,IdRef * file,LiteralInteger * line,LiteralInteger * column)124 void ParseLine(const uint32_t *_instruction,
125 IdRef *file,
126 LiteralInteger *line,
127 LiteralInteger *column)
128 {
129 spv::Op _op;
130 uint32_t _length;
131 GetInstructionOpAndLength(_instruction, &_op, &_length);
132 ASSERT(_op == spv::OpLine);
133 uint32_t _o = 1;
134 *file = IdRef(_instruction[_o++]);
135 *line = LiteralInteger(_instruction[_o++]);
136 *column = LiteralInteger(_instruction[_o++]);
137 }
ParseExtension(const uint32_t * _instruction,LiteralString * name)138 void ParseExtension(const uint32_t *_instruction, LiteralString *name)
139 {
140 spv::Op _op;
141 uint32_t _length;
142 GetInstructionOpAndLength(_instruction, &_op, &_length);
143 ASSERT(_op == spv::OpExtension);
144 uint32_t _o = 1;
145 ASSERT(IsLittleEndian());
146 *name = reinterpret_cast<const char *>(&_instruction[_o]);
147 _o += strlen(*name) / 4 + 1;
148 }
ParseExtInstImport(const uint32_t * _instruction,IdResult * idResult1,LiteralString * name)149 void ParseExtInstImport(const uint32_t *_instruction, IdResult *idResult1, LiteralString *name)
150 {
151 spv::Op _op;
152 uint32_t _length;
153 GetInstructionOpAndLength(_instruction, &_op, &_length);
154 ASSERT(_op == spv::OpExtInstImport);
155 uint32_t _o = 1;
156 *idResult1 = IdResult(_instruction[_o++]);
157 ASSERT(IsLittleEndian());
158 *name = reinterpret_cast<const char *>(&_instruction[_o]);
159 _o += strlen(*name) / 4 + 1;
160 }
ParseExtInst(const uint32_t * _instruction,IdResultType * idResultType1,IdResult * idResult2,IdRef * set,LiteralExtInstInteger * instruction,IdRefList * operandList)161 void ParseExtInst(const uint32_t *_instruction,
162 IdResultType *idResultType1,
163 IdResult *idResult2,
164 IdRef *set,
165 LiteralExtInstInteger *instruction,
166 IdRefList *operandList)
167 {
168 spv::Op _op;
169 uint32_t _length;
170 GetInstructionOpAndLength(_instruction, &_op, &_length);
171 ASSERT(_op == spv::OpExtInst);
172 uint32_t _o = 1;
173 *idResultType1 = IdResultType(_instruction[_o++]);
174 *idResult2 = IdResult(_instruction[_o++]);
175 *set = IdRef(_instruction[_o++]);
176 *instruction = LiteralExtInstInteger(_instruction[_o++]);
177 if (operandList)
178 {
179 while (_o < _length)
180 {
181 operandList->emplace_back(_instruction[_o++]);
182 }
183 }
184 }
ParseMemoryModel(const uint32_t * _instruction,spv::AddressingModel * addressingModel1,spv::MemoryModel * memoryModel2)185 void ParseMemoryModel(const uint32_t *_instruction,
186 spv::AddressingModel *addressingModel1,
187 spv::MemoryModel *memoryModel2)
188 {
189 spv::Op _op;
190 uint32_t _length;
191 GetInstructionOpAndLength(_instruction, &_op, &_length);
192 ASSERT(_op == spv::OpMemoryModel);
193 uint32_t _o = 1;
194 *addressingModel1 = spv::AddressingModel(_instruction[_o++]);
195 *memoryModel2 = spv::MemoryModel(_instruction[_o++]);
196 }
ParseEntryPoint(const uint32_t * _instruction,spv::ExecutionModel * executionModel1,IdRef * entryPoint,LiteralString * name,IdRefList * interfaceList)197 void ParseEntryPoint(const uint32_t *_instruction,
198 spv::ExecutionModel *executionModel1,
199 IdRef *entryPoint,
200 LiteralString *name,
201 IdRefList *interfaceList)
202 {
203 spv::Op _op;
204 uint32_t _length;
205 GetInstructionOpAndLength(_instruction, &_op, &_length);
206 ASSERT(_op == spv::OpEntryPoint);
207 uint32_t _o = 1;
208 *executionModel1 = spv::ExecutionModel(_instruction[_o++]);
209 *entryPoint = IdRef(_instruction[_o++]);
210 ASSERT(IsLittleEndian());
211 *name = reinterpret_cast<const char *>(&_instruction[_o]);
212 _o += strlen(*name) / 4 + 1;
213 if (interfaceList)
214 {
215 while (_o < _length)
216 {
217 interfaceList->emplace_back(_instruction[_o++]);
218 }
219 }
220 }
ParseExecutionMode(const uint32_t * _instruction,IdRef * entryPoint,spv::ExecutionMode * mode,LiteralIntegerList * operandsList)221 void ParseExecutionMode(const uint32_t *_instruction,
222 IdRef *entryPoint,
223 spv::ExecutionMode *mode,
224 LiteralIntegerList *operandsList)
225 {
226 spv::Op _op;
227 uint32_t _length;
228 GetInstructionOpAndLength(_instruction, &_op, &_length);
229 ASSERT(_op == spv::OpExecutionMode);
230 uint32_t _o = 1;
231 *entryPoint = IdRef(_instruction[_o++]);
232 *mode = spv::ExecutionMode(_instruction[_o++]);
233 if (operandsList)
234 {
235 while (_o < _length)
236 {
237 operandsList->emplace_back(_instruction[_o++]);
238 }
239 }
240 }
ParseCapability(const uint32_t * _instruction,spv::Capability * capability)241 void ParseCapability(const uint32_t *_instruction, spv::Capability *capability)
242 {
243 spv::Op _op;
244 uint32_t _length;
245 GetInstructionOpAndLength(_instruction, &_op, &_length);
246 ASSERT(_op == spv::OpCapability);
247 uint32_t _o = 1;
248 *capability = spv::Capability(_instruction[_o++]);
249 }
ParseTypeVoid(const uint32_t * _instruction,IdResult * idResult1)250 void ParseTypeVoid(const uint32_t *_instruction, IdResult *idResult1)
251 {
252 spv::Op _op;
253 uint32_t _length;
254 GetInstructionOpAndLength(_instruction, &_op, &_length);
255 ASSERT(_op == spv::OpTypeVoid);
256 uint32_t _o = 1;
257 *idResult1 = IdResult(_instruction[_o++]);
258 }
ParseTypeBool(const uint32_t * _instruction,IdResult * idResult1)259 void ParseTypeBool(const uint32_t *_instruction, IdResult *idResult1)
260 {
261 spv::Op _op;
262 uint32_t _length;
263 GetInstructionOpAndLength(_instruction, &_op, &_length);
264 ASSERT(_op == spv::OpTypeBool);
265 uint32_t _o = 1;
266 *idResult1 = IdResult(_instruction[_o++]);
267 }
ParseTypeInt(const uint32_t * _instruction,IdResult * idResult1,LiteralInteger * width,LiteralInteger * signedness)268 void ParseTypeInt(const uint32_t *_instruction,
269 IdResult *idResult1,
270 LiteralInteger *width,
271 LiteralInteger *signedness)
272 {
273 spv::Op _op;
274 uint32_t _length;
275 GetInstructionOpAndLength(_instruction, &_op, &_length);
276 ASSERT(_op == spv::OpTypeInt);
277 uint32_t _o = 1;
278 *idResult1 = IdResult(_instruction[_o++]);
279 *width = LiteralInteger(_instruction[_o++]);
280 *signedness = LiteralInteger(_instruction[_o++]);
281 }
ParseTypeFloat(const uint32_t * _instruction,IdResult * idResult1,LiteralInteger * width,spv::FPEncoding * floatingPointEncoding)282 void ParseTypeFloat(const uint32_t *_instruction,
283 IdResult *idResult1,
284 LiteralInteger *width,
285 spv::FPEncoding *floatingPointEncoding)
286 {
287 spv::Op _op;
288 uint32_t _length;
289 GetInstructionOpAndLength(_instruction, &_op, &_length);
290 ASSERT(_op == spv::OpTypeFloat);
291 uint32_t _o = 1;
292 *idResult1 = IdResult(_instruction[_o++]);
293 *width = LiteralInteger(_instruction[_o++]);
294 if (floatingPointEncoding && _o < _length)
295 {
296 *floatingPointEncoding = spv::FPEncoding(_instruction[_o++]);
297 }
298 }
ParseTypeVector(const uint32_t * _instruction,IdResult * idResult1,IdRef * componentType,LiteralInteger * componentCount)299 void ParseTypeVector(const uint32_t *_instruction,
300 IdResult *idResult1,
301 IdRef *componentType,
302 LiteralInteger *componentCount)
303 {
304 spv::Op _op;
305 uint32_t _length;
306 GetInstructionOpAndLength(_instruction, &_op, &_length);
307 ASSERT(_op == spv::OpTypeVector);
308 uint32_t _o = 1;
309 *idResult1 = IdResult(_instruction[_o++]);
310 *componentType = IdRef(_instruction[_o++]);
311 *componentCount = LiteralInteger(_instruction[_o++]);
312 }
ParseTypeMatrix(const uint32_t * _instruction,IdResult * idResult1,IdRef * columnType,LiteralInteger * columnCount)313 void ParseTypeMatrix(const uint32_t *_instruction,
314 IdResult *idResult1,
315 IdRef *columnType,
316 LiteralInteger *columnCount)
317 {
318 spv::Op _op;
319 uint32_t _length;
320 GetInstructionOpAndLength(_instruction, &_op, &_length);
321 ASSERT(_op == spv::OpTypeMatrix);
322 uint32_t _o = 1;
323 *idResult1 = IdResult(_instruction[_o++]);
324 *columnType = IdRef(_instruction[_o++]);
325 *columnCount = LiteralInteger(_instruction[_o++]);
326 }
ParseTypeImage(const uint32_t * _instruction,IdResult * idResult1,IdRef * sampledType,spv::Dim * dim3,LiteralInteger * depth,LiteralInteger * arrayed,LiteralInteger * mS,LiteralInteger * sampled,spv::ImageFormat * imageFormat8,spv::AccessQualifier * accessQualifier9)327 void ParseTypeImage(const uint32_t *_instruction,
328 IdResult *idResult1,
329 IdRef *sampledType,
330 spv::Dim *dim3,
331 LiteralInteger *depth,
332 LiteralInteger *arrayed,
333 LiteralInteger *mS,
334 LiteralInteger *sampled,
335 spv::ImageFormat *imageFormat8,
336 spv::AccessQualifier *accessQualifier9)
337 {
338 spv::Op _op;
339 uint32_t _length;
340 GetInstructionOpAndLength(_instruction, &_op, &_length);
341 ASSERT(_op == spv::OpTypeImage);
342 uint32_t _o = 1;
343 *idResult1 = IdResult(_instruction[_o++]);
344 *sampledType = IdRef(_instruction[_o++]);
345 *dim3 = spv::Dim(_instruction[_o++]);
346 *depth = LiteralInteger(_instruction[_o++]);
347 *arrayed = LiteralInteger(_instruction[_o++]);
348 *mS = LiteralInteger(_instruction[_o++]);
349 *sampled = LiteralInteger(_instruction[_o++]);
350 *imageFormat8 = spv::ImageFormat(_instruction[_o++]);
351 if (accessQualifier9 && _o < _length)
352 {
353 *accessQualifier9 = spv::AccessQualifier(_instruction[_o++]);
354 }
355 }
ParseTypeSampler(const uint32_t * _instruction,IdResult * idResult1)356 void ParseTypeSampler(const uint32_t *_instruction, IdResult *idResult1)
357 {
358 spv::Op _op;
359 uint32_t _length;
360 GetInstructionOpAndLength(_instruction, &_op, &_length);
361 ASSERT(_op == spv::OpTypeSampler);
362 uint32_t _o = 1;
363 *idResult1 = IdResult(_instruction[_o++]);
364 }
ParseTypeSampledImage(const uint32_t * _instruction,IdResult * idResult1,IdRef * imageType)365 void ParseTypeSampledImage(const uint32_t *_instruction, IdResult *idResult1, IdRef *imageType)
366 {
367 spv::Op _op;
368 uint32_t _length;
369 GetInstructionOpAndLength(_instruction, &_op, &_length);
370 ASSERT(_op == spv::OpTypeSampledImage);
371 uint32_t _o = 1;
372 *idResult1 = IdResult(_instruction[_o++]);
373 *imageType = IdRef(_instruction[_o++]);
374 }
ParseTypeArray(const uint32_t * _instruction,IdResult * idResult1,IdRef * elementType,IdRef * length)375 void ParseTypeArray(const uint32_t *_instruction,
376 IdResult *idResult1,
377 IdRef *elementType,
378 IdRef *length)
379 {
380 spv::Op _op;
381 uint32_t _length;
382 GetInstructionOpAndLength(_instruction, &_op, &_length);
383 ASSERT(_op == spv::OpTypeArray);
384 uint32_t _o = 1;
385 *idResult1 = IdResult(_instruction[_o++]);
386 *elementType = IdRef(_instruction[_o++]);
387 *length = IdRef(_instruction[_o++]);
388 }
ParseTypeRuntimeArray(const uint32_t * _instruction,IdResult * idResult1,IdRef * elementType)389 void ParseTypeRuntimeArray(const uint32_t *_instruction, IdResult *idResult1, IdRef *elementType)
390 {
391 spv::Op _op;
392 uint32_t _length;
393 GetInstructionOpAndLength(_instruction, &_op, &_length);
394 ASSERT(_op == spv::OpTypeRuntimeArray);
395 uint32_t _o = 1;
396 *idResult1 = IdResult(_instruction[_o++]);
397 *elementType = IdRef(_instruction[_o++]);
398 }
ParseTypeStruct(const uint32_t * _instruction,IdResult * idResult1,IdRefList * memberList)399 void ParseTypeStruct(const uint32_t *_instruction, IdResult *idResult1, IdRefList *memberList)
400 {
401 spv::Op _op;
402 uint32_t _length;
403 GetInstructionOpAndLength(_instruction, &_op, &_length);
404 ASSERT(_op == spv::OpTypeStruct);
405 uint32_t _o = 1;
406 *idResult1 = IdResult(_instruction[_o++]);
407 if (memberList)
408 {
409 while (_o < _length)
410 {
411 memberList->emplace_back(_instruction[_o++]);
412 }
413 }
414 }
ParseTypePointer(const uint32_t * _instruction,IdResult * idResult1,spv::StorageClass * storageClass2,IdRef * type)415 void ParseTypePointer(const uint32_t *_instruction,
416 IdResult *idResult1,
417 spv::StorageClass *storageClass2,
418 IdRef *type)
419 {
420 spv::Op _op;
421 uint32_t _length;
422 GetInstructionOpAndLength(_instruction, &_op, &_length);
423 ASSERT(_op == spv::OpTypePointer);
424 uint32_t _o = 1;
425 *idResult1 = IdResult(_instruction[_o++]);
426 *storageClass2 = spv::StorageClass(_instruction[_o++]);
427 *type = IdRef(_instruction[_o++]);
428 }
ParseTypeFunction(const uint32_t * _instruction,IdResult * idResult1,IdRef * returnType,IdRefList * parameterList)429 void ParseTypeFunction(const uint32_t *_instruction,
430 IdResult *idResult1,
431 IdRef *returnType,
432 IdRefList *parameterList)
433 {
434 spv::Op _op;
435 uint32_t _length;
436 GetInstructionOpAndLength(_instruction, &_op, &_length);
437 ASSERT(_op == spv::OpTypeFunction);
438 uint32_t _o = 1;
439 *idResult1 = IdResult(_instruction[_o++]);
440 *returnType = IdRef(_instruction[_o++]);
441 if (parameterList)
442 {
443 while (_o < _length)
444 {
445 parameterList->emplace_back(_instruction[_o++]);
446 }
447 }
448 }
ParseConstantTrue(const uint32_t * _instruction,IdResultType * idResultType1,IdResult * idResult2)449 void ParseConstantTrue(const uint32_t *_instruction,
450 IdResultType *idResultType1,
451 IdResult *idResult2)
452 {
453 spv::Op _op;
454 uint32_t _length;
455 GetInstructionOpAndLength(_instruction, &_op, &_length);
456 ASSERT(_op == spv::OpConstantTrue);
457 uint32_t _o = 1;
458 *idResultType1 = IdResultType(_instruction[_o++]);
459 *idResult2 = IdResult(_instruction[_o++]);
460 }
ParseConstantFalse(const uint32_t * _instruction,IdResultType * idResultType1,IdResult * idResult2)461 void ParseConstantFalse(const uint32_t *_instruction,
462 IdResultType *idResultType1,
463 IdResult *idResult2)
464 {
465 spv::Op _op;
466 uint32_t _length;
467 GetInstructionOpAndLength(_instruction, &_op, &_length);
468 ASSERT(_op == spv::OpConstantFalse);
469 uint32_t _o = 1;
470 *idResultType1 = IdResultType(_instruction[_o++]);
471 *idResult2 = IdResult(_instruction[_o++]);
472 }
ParseConstant(const uint32_t * _instruction,IdResultType * idResultType1,IdResult * idResult2,LiteralContextDependentNumber * value)473 void ParseConstant(const uint32_t *_instruction,
474 IdResultType *idResultType1,
475 IdResult *idResult2,
476 LiteralContextDependentNumber *value)
477 {
478 spv::Op _op;
479 uint32_t _length;
480 GetInstructionOpAndLength(_instruction, &_op, &_length);
481 ASSERT(_op == spv::OpConstant);
482 uint32_t _o = 1;
483 *idResultType1 = IdResultType(_instruction[_o++]);
484 *idResult2 = IdResult(_instruction[_o++]);
485 *value = LiteralContextDependentNumber(_instruction[_o++]);
486 }
ParseConstantComposite(const uint32_t * _instruction,IdResultType * idResultType1,IdResult * idResult2,IdRefList * constituentsList)487 void ParseConstantComposite(const uint32_t *_instruction,
488 IdResultType *idResultType1,
489 IdResult *idResult2,
490 IdRefList *constituentsList)
491 {
492 spv::Op _op;
493 uint32_t _length;
494 GetInstructionOpAndLength(_instruction, &_op, &_length);
495 ASSERT(_op == spv::OpConstantComposite);
496 uint32_t _o = 1;
497 *idResultType1 = IdResultType(_instruction[_o++]);
498 *idResult2 = IdResult(_instruction[_o++]);
499 if (constituentsList)
500 {
501 while (_o < _length)
502 {
503 constituentsList->emplace_back(_instruction[_o++]);
504 }
505 }
506 }
ParseConstantNull(const uint32_t * _instruction,IdResultType * idResultType1,IdResult * idResult2)507 void ParseConstantNull(const uint32_t *_instruction,
508 IdResultType *idResultType1,
509 IdResult *idResult2)
510 {
511 spv::Op _op;
512 uint32_t _length;
513 GetInstructionOpAndLength(_instruction, &_op, &_length);
514 ASSERT(_op == spv::OpConstantNull);
515 uint32_t _o = 1;
516 *idResultType1 = IdResultType(_instruction[_o++]);
517 *idResult2 = IdResult(_instruction[_o++]);
518 }
ParseSpecConstantTrue(const uint32_t * _instruction,IdResultType * idResultType1,IdResult * idResult2)519 void ParseSpecConstantTrue(const uint32_t *_instruction,
520 IdResultType *idResultType1,
521 IdResult *idResult2)
522 {
523 spv::Op _op;
524 uint32_t _length;
525 GetInstructionOpAndLength(_instruction, &_op, &_length);
526 ASSERT(_op == spv::OpSpecConstantTrue);
527 uint32_t _o = 1;
528 *idResultType1 = IdResultType(_instruction[_o++]);
529 *idResult2 = IdResult(_instruction[_o++]);
530 }
ParseSpecConstantFalse(const uint32_t * _instruction,IdResultType * idResultType1,IdResult * idResult2)531 void ParseSpecConstantFalse(const uint32_t *_instruction,
532 IdResultType *idResultType1,
533 IdResult *idResult2)
534 {
535 spv::Op _op;
536 uint32_t _length;
537 GetInstructionOpAndLength(_instruction, &_op, &_length);
538 ASSERT(_op == spv::OpSpecConstantFalse);
539 uint32_t _o = 1;
540 *idResultType1 = IdResultType(_instruction[_o++]);
541 *idResult2 = IdResult(_instruction[_o++]);
542 }
ParseSpecConstant(const uint32_t * _instruction,IdResultType * idResultType1,IdResult * idResult2,LiteralContextDependentNumber * value)543 void ParseSpecConstant(const uint32_t *_instruction,
544 IdResultType *idResultType1,
545 IdResult *idResult2,
546 LiteralContextDependentNumber *value)
547 {
548 spv::Op _op;
549 uint32_t _length;
550 GetInstructionOpAndLength(_instruction, &_op, &_length);
551 ASSERT(_op == spv::OpSpecConstant);
552 uint32_t _o = 1;
553 *idResultType1 = IdResultType(_instruction[_o++]);
554 *idResult2 = IdResult(_instruction[_o++]);
555 *value = LiteralContextDependentNumber(_instruction[_o++]);
556 }
ParseSpecConstantComposite(const uint32_t * _instruction,IdResultType * idResultType1,IdResult * idResult2,IdRefList * constituentsList)557 void ParseSpecConstantComposite(const uint32_t *_instruction,
558 IdResultType *idResultType1,
559 IdResult *idResult2,
560 IdRefList *constituentsList)
561 {
562 spv::Op _op;
563 uint32_t _length;
564 GetInstructionOpAndLength(_instruction, &_op, &_length);
565 ASSERT(_op == spv::OpSpecConstantComposite);
566 uint32_t _o = 1;
567 *idResultType1 = IdResultType(_instruction[_o++]);
568 *idResult2 = IdResult(_instruction[_o++]);
569 if (constituentsList)
570 {
571 while (_o < _length)
572 {
573 constituentsList->emplace_back(_instruction[_o++]);
574 }
575 }
576 }
ParseFunction(const uint32_t * _instruction,IdResultType * idResultType1,IdResult * idResult2,spv::FunctionControlMask * functionControl3,IdRef * functionType)577 void ParseFunction(const uint32_t *_instruction,
578 IdResultType *idResultType1,
579 IdResult *idResult2,
580 spv::FunctionControlMask *functionControl3,
581 IdRef *functionType)
582 {
583 spv::Op _op;
584 uint32_t _length;
585 GetInstructionOpAndLength(_instruction, &_op, &_length);
586 ASSERT(_op == spv::OpFunction);
587 uint32_t _o = 1;
588 *idResultType1 = IdResultType(_instruction[_o++]);
589 *idResult2 = IdResult(_instruction[_o++]);
590 *functionControl3 = spv::FunctionControlMask(_instruction[_o++]);
591 *functionType = IdRef(_instruction[_o++]);
592 }
ParseFunctionParameter(const uint32_t * _instruction,IdResultType * idResultType1,IdResult * idResult2)593 void ParseFunctionParameter(const uint32_t *_instruction,
594 IdResultType *idResultType1,
595 IdResult *idResult2)
596 {
597 spv::Op _op;
598 uint32_t _length;
599 GetInstructionOpAndLength(_instruction, &_op, &_length);
600 ASSERT(_op == spv::OpFunctionParameter);
601 uint32_t _o = 1;
602 *idResultType1 = IdResultType(_instruction[_o++]);
603 *idResult2 = IdResult(_instruction[_o++]);
604 }
ParseFunctionCall(const uint32_t * _instruction,IdResultType * idResultType1,IdResult * idResult2,IdRef * function,IdRefList * argumentList)605 void ParseFunctionCall(const uint32_t *_instruction,
606 IdResultType *idResultType1,
607 IdResult *idResult2,
608 IdRef *function,
609 IdRefList *argumentList)
610 {
611 spv::Op _op;
612 uint32_t _length;
613 GetInstructionOpAndLength(_instruction, &_op, &_length);
614 ASSERT(_op == spv::OpFunctionCall);
615 uint32_t _o = 1;
616 *idResultType1 = IdResultType(_instruction[_o++]);
617 *idResult2 = IdResult(_instruction[_o++]);
618 *function = IdRef(_instruction[_o++]);
619 if (argumentList)
620 {
621 while (_o < _length)
622 {
623 argumentList->emplace_back(_instruction[_o++]);
624 }
625 }
626 }
ParseVariable(const uint32_t * _instruction,IdResultType * idResultType1,IdResult * idResult2,spv::StorageClass * storageClass3,IdRef * initializer)627 void ParseVariable(const uint32_t *_instruction,
628 IdResultType *idResultType1,
629 IdResult *idResult2,
630 spv::StorageClass *storageClass3,
631 IdRef *initializer)
632 {
633 spv::Op _op;
634 uint32_t _length;
635 GetInstructionOpAndLength(_instruction, &_op, &_length);
636 ASSERT(_op == spv::OpVariable);
637 uint32_t _o = 1;
638 *idResultType1 = IdResultType(_instruction[_o++]);
639 *idResult2 = IdResult(_instruction[_o++]);
640 *storageClass3 = spv::StorageClass(_instruction[_o++]);
641 if (initializer && _o < _length)
642 {
643 *initializer = IdRef(_instruction[_o++]);
644 }
645 }
ParseImageTexelPointer(const uint32_t * _instruction,IdResultType * idResultType1,IdResult * idResult2,IdRef * image,IdRef * coordinate,IdRef * sample)646 void ParseImageTexelPointer(const uint32_t *_instruction,
647 IdResultType *idResultType1,
648 IdResult *idResult2,
649 IdRef *image,
650 IdRef *coordinate,
651 IdRef *sample)
652 {
653 spv::Op _op;
654 uint32_t _length;
655 GetInstructionOpAndLength(_instruction, &_op, &_length);
656 ASSERT(_op == spv::OpImageTexelPointer);
657 uint32_t _o = 1;
658 *idResultType1 = IdResultType(_instruction[_o++]);
659 *idResult2 = IdResult(_instruction[_o++]);
660 *image = IdRef(_instruction[_o++]);
661 *coordinate = IdRef(_instruction[_o++]);
662 *sample = IdRef(_instruction[_o++]);
663 }
ParseLoad(const uint32_t * _instruction,IdResultType * idResultType1,IdResult * idResult2,IdRef * pointer,spv::MemoryAccessMask * memoryAccess4)664 void ParseLoad(const uint32_t *_instruction,
665 IdResultType *idResultType1,
666 IdResult *idResult2,
667 IdRef *pointer,
668 spv::MemoryAccessMask *memoryAccess4)
669 {
670 spv::Op _op;
671 uint32_t _length;
672 GetInstructionOpAndLength(_instruction, &_op, &_length);
673 ASSERT(_op == spv::OpLoad);
674 uint32_t _o = 1;
675 *idResultType1 = IdResultType(_instruction[_o++]);
676 *idResult2 = IdResult(_instruction[_o++]);
677 *pointer = IdRef(_instruction[_o++]);
678 if (memoryAccess4 && _o < _length)
679 {
680 *memoryAccess4 = spv::MemoryAccessMask(_instruction[_o++]);
681 }
682 }
ParseStore(const uint32_t * _instruction,IdRef * pointer,IdRef * object,spv::MemoryAccessMask * memoryAccess3)683 void ParseStore(const uint32_t *_instruction,
684 IdRef *pointer,
685 IdRef *object,
686 spv::MemoryAccessMask *memoryAccess3)
687 {
688 spv::Op _op;
689 uint32_t _length;
690 GetInstructionOpAndLength(_instruction, &_op, &_length);
691 ASSERT(_op == spv::OpStore);
692 uint32_t _o = 1;
693 *pointer = IdRef(_instruction[_o++]);
694 *object = IdRef(_instruction[_o++]);
695 if (memoryAccess3 && _o < _length)
696 {
697 *memoryAccess3 = spv::MemoryAccessMask(_instruction[_o++]);
698 }
699 }
ParseCopyMemory(const uint32_t * _instruction,IdRef * target,IdRef * source,spv::MemoryAccessMask * memoryAccess3,spv::MemoryAccessMask * memoryAccess4)700 void ParseCopyMemory(const uint32_t *_instruction,
701 IdRef *target,
702 IdRef *source,
703 spv::MemoryAccessMask *memoryAccess3,
704 spv::MemoryAccessMask *memoryAccess4)
705 {
706 spv::Op _op;
707 uint32_t _length;
708 GetInstructionOpAndLength(_instruction, &_op, &_length);
709 ASSERT(_op == spv::OpCopyMemory);
710 uint32_t _o = 1;
711 *target = IdRef(_instruction[_o++]);
712 *source = IdRef(_instruction[_o++]);
713 if (memoryAccess3 && _o < _length)
714 {
715 *memoryAccess3 = spv::MemoryAccessMask(_instruction[_o++]);
716 }
717 if (memoryAccess4 && _o < _length)
718 {
719 *memoryAccess4 = spv::MemoryAccessMask(_instruction[_o++]);
720 }
721 }
ParseAccessChain(const uint32_t * _instruction,IdResultType * idResultType1,IdResult * idResult2,IdRef * base,IdRefList * indexesList)722 void ParseAccessChain(const uint32_t *_instruction,
723 IdResultType *idResultType1,
724 IdResult *idResult2,
725 IdRef *base,
726 IdRefList *indexesList)
727 {
728 spv::Op _op;
729 uint32_t _length;
730 GetInstructionOpAndLength(_instruction, &_op, &_length);
731 ASSERT(_op == spv::OpAccessChain);
732 uint32_t _o = 1;
733 *idResultType1 = IdResultType(_instruction[_o++]);
734 *idResult2 = IdResult(_instruction[_o++]);
735 *base = IdRef(_instruction[_o++]);
736 if (indexesList)
737 {
738 while (_o < _length)
739 {
740 indexesList->emplace_back(_instruction[_o++]);
741 }
742 }
743 }
ParseInBoundsAccessChain(const uint32_t * _instruction,IdResultType * idResultType1,IdResult * idResult2,IdRef * base,IdRefList * indexesList)744 void ParseInBoundsAccessChain(const uint32_t *_instruction,
745 IdResultType *idResultType1,
746 IdResult *idResult2,
747 IdRef *base,
748 IdRefList *indexesList)
749 {
750 spv::Op _op;
751 uint32_t _length;
752 GetInstructionOpAndLength(_instruction, &_op, &_length);
753 ASSERT(_op == spv::OpInBoundsAccessChain);
754 uint32_t _o = 1;
755 *idResultType1 = IdResultType(_instruction[_o++]);
756 *idResult2 = IdResult(_instruction[_o++]);
757 *base = IdRef(_instruction[_o++]);
758 if (indexesList)
759 {
760 while (_o < _length)
761 {
762 indexesList->emplace_back(_instruction[_o++]);
763 }
764 }
765 }
ParseArrayLength(const uint32_t * _instruction,IdResultType * idResultType1,IdResult * idResult2,IdRef * structure,LiteralInteger * arraymember)766 void ParseArrayLength(const uint32_t *_instruction,
767 IdResultType *idResultType1,
768 IdResult *idResult2,
769 IdRef *structure,
770 LiteralInteger *arraymember)
771 {
772 spv::Op _op;
773 uint32_t _length;
774 GetInstructionOpAndLength(_instruction, &_op, &_length);
775 ASSERT(_op == spv::OpArrayLength);
776 uint32_t _o = 1;
777 *idResultType1 = IdResultType(_instruction[_o++]);
778 *idResult2 = IdResult(_instruction[_o++]);
779 *structure = IdRef(_instruction[_o++]);
780 *arraymember = LiteralInteger(_instruction[_o++]);
781 }
ParseDecorate(const uint32_t * _instruction,IdRef * target,spv::Decoration * decoration2,LiteralIntegerList * valuesList)782 void ParseDecorate(const uint32_t *_instruction,
783 IdRef *target,
784 spv::Decoration *decoration2,
785 LiteralIntegerList *valuesList)
786 {
787 spv::Op _op;
788 uint32_t _length;
789 GetInstructionOpAndLength(_instruction, &_op, &_length);
790 ASSERT(_op == spv::OpDecorate);
791 uint32_t _o = 1;
792 *target = IdRef(_instruction[_o++]);
793 *decoration2 = spv::Decoration(_instruction[_o++]);
794 if (valuesList)
795 {
796 while (_o < _length)
797 {
798 valuesList->emplace_back(_instruction[_o++]);
799 }
800 }
801 }
ParseMemberDecorate(const uint32_t * _instruction,IdRef * structureType,LiteralInteger * member,spv::Decoration * decoration3,LiteralIntegerList * valuesList)802 void ParseMemberDecorate(const uint32_t *_instruction,
803 IdRef *structureType,
804 LiteralInteger *member,
805 spv::Decoration *decoration3,
806 LiteralIntegerList *valuesList)
807 {
808 spv::Op _op;
809 uint32_t _length;
810 GetInstructionOpAndLength(_instruction, &_op, &_length);
811 ASSERT(_op == spv::OpMemberDecorate);
812 uint32_t _o = 1;
813 *structureType = IdRef(_instruction[_o++]);
814 *member = LiteralInteger(_instruction[_o++]);
815 *decoration3 = spv::Decoration(_instruction[_o++]);
816 if (valuesList)
817 {
818 while (_o < _length)
819 {
820 valuesList->emplace_back(_instruction[_o++]);
821 }
822 }
823 }
ParseDecorationGroup(const uint32_t * _instruction,IdResult * idResult1)824 void ParseDecorationGroup(const uint32_t *_instruction, IdResult *idResult1)
825 {
826 spv::Op _op;
827 uint32_t _length;
828 GetInstructionOpAndLength(_instruction, &_op, &_length);
829 ASSERT(_op == spv::OpDecorationGroup);
830 uint32_t _o = 1;
831 *idResult1 = IdResult(_instruction[_o++]);
832 }
ParseGroupDecorate(const uint32_t * _instruction,IdRef * decorationGroup,IdRefList * targetsList)833 void ParseGroupDecorate(const uint32_t *_instruction,
834 IdRef *decorationGroup,
835 IdRefList *targetsList)
836 {
837 spv::Op _op;
838 uint32_t _length;
839 GetInstructionOpAndLength(_instruction, &_op, &_length);
840 ASSERT(_op == spv::OpGroupDecorate);
841 uint32_t _o = 1;
842 *decorationGroup = IdRef(_instruction[_o++]);
843 if (targetsList)
844 {
845 while (_o < _length)
846 {
847 targetsList->emplace_back(_instruction[_o++]);
848 }
849 }
850 }
ParseGroupMemberDecorate(const uint32_t * _instruction,IdRef * decorationGroup,PairIdRefLiteralIntegerList * targetsPairList)851 void ParseGroupMemberDecorate(const uint32_t *_instruction,
852 IdRef *decorationGroup,
853 PairIdRefLiteralIntegerList *targetsPairList)
854 {
855 spv::Op _op;
856 uint32_t _length;
857 GetInstructionOpAndLength(_instruction, &_op, &_length);
858 ASSERT(_op == spv::OpGroupMemberDecorate);
859 uint32_t _o = 1;
860 *decorationGroup = IdRef(_instruction[_o++]);
861 if (targetsPairList)
862 {
863 while (_o < _length)
864 {
865 targetsPairList->emplace_back(PairIdRefLiteralInteger{
866 IdRef(_instruction[_o]), LiteralInteger(_instruction[_o + 1])});
867 _o += 2;
868 }
869 }
870 }
ParseVectorExtractDynamic(const uint32_t * _instruction,IdResultType * idResultType1,IdResult * idResult2,IdRef * vector,IdRef * index)871 void ParseVectorExtractDynamic(const uint32_t *_instruction,
872 IdResultType *idResultType1,
873 IdResult *idResult2,
874 IdRef *vector,
875 IdRef *index)
876 {
877 spv::Op _op;
878 uint32_t _length;
879 GetInstructionOpAndLength(_instruction, &_op, &_length);
880 ASSERT(_op == spv::OpVectorExtractDynamic);
881 uint32_t _o = 1;
882 *idResultType1 = IdResultType(_instruction[_o++]);
883 *idResult2 = IdResult(_instruction[_o++]);
884 *vector = IdRef(_instruction[_o++]);
885 *index = IdRef(_instruction[_o++]);
886 }
ParseVectorInsertDynamic(const uint32_t * _instruction,IdResultType * idResultType1,IdResult * idResult2,IdRef * vector,IdRef * component,IdRef * index)887 void ParseVectorInsertDynamic(const uint32_t *_instruction,
888 IdResultType *idResultType1,
889 IdResult *idResult2,
890 IdRef *vector,
891 IdRef *component,
892 IdRef *index)
893 {
894 spv::Op _op;
895 uint32_t _length;
896 GetInstructionOpAndLength(_instruction, &_op, &_length);
897 ASSERT(_op == spv::OpVectorInsertDynamic);
898 uint32_t _o = 1;
899 *idResultType1 = IdResultType(_instruction[_o++]);
900 *idResult2 = IdResult(_instruction[_o++]);
901 *vector = IdRef(_instruction[_o++]);
902 *component = IdRef(_instruction[_o++]);
903 *index = IdRef(_instruction[_o++]);
904 }
ParseVectorShuffle(const uint32_t * _instruction,IdResultType * idResultType1,IdResult * idResult2,IdRef * vector1,IdRef * vector2,LiteralIntegerList * componentsList)905 void ParseVectorShuffle(const uint32_t *_instruction,
906 IdResultType *idResultType1,
907 IdResult *idResult2,
908 IdRef *vector1,
909 IdRef *vector2,
910 LiteralIntegerList *componentsList)
911 {
912 spv::Op _op;
913 uint32_t _length;
914 GetInstructionOpAndLength(_instruction, &_op, &_length);
915 ASSERT(_op == spv::OpVectorShuffle);
916 uint32_t _o = 1;
917 *idResultType1 = IdResultType(_instruction[_o++]);
918 *idResult2 = IdResult(_instruction[_o++]);
919 *vector1 = IdRef(_instruction[_o++]);
920 *vector2 = IdRef(_instruction[_o++]);
921 if (componentsList)
922 {
923 while (_o < _length)
924 {
925 componentsList->emplace_back(_instruction[_o++]);
926 }
927 }
928 }
ParseCompositeConstruct(const uint32_t * _instruction,IdResultType * idResultType1,IdResult * idResult2,IdRefList * constituentsList)929 void ParseCompositeConstruct(const uint32_t *_instruction,
930 IdResultType *idResultType1,
931 IdResult *idResult2,
932 IdRefList *constituentsList)
933 {
934 spv::Op _op;
935 uint32_t _length;
936 GetInstructionOpAndLength(_instruction, &_op, &_length);
937 ASSERT(_op == spv::OpCompositeConstruct);
938 uint32_t _o = 1;
939 *idResultType1 = IdResultType(_instruction[_o++]);
940 *idResult2 = IdResult(_instruction[_o++]);
941 if (constituentsList)
942 {
943 while (_o < _length)
944 {
945 constituentsList->emplace_back(_instruction[_o++]);
946 }
947 }
948 }
ParseCompositeExtract(const uint32_t * _instruction,IdResultType * idResultType1,IdResult * idResult2,IdRef * composite,LiteralIntegerList * indexesList)949 void ParseCompositeExtract(const uint32_t *_instruction,
950 IdResultType *idResultType1,
951 IdResult *idResult2,
952 IdRef *composite,
953 LiteralIntegerList *indexesList)
954 {
955 spv::Op _op;
956 uint32_t _length;
957 GetInstructionOpAndLength(_instruction, &_op, &_length);
958 ASSERT(_op == spv::OpCompositeExtract);
959 uint32_t _o = 1;
960 *idResultType1 = IdResultType(_instruction[_o++]);
961 *idResult2 = IdResult(_instruction[_o++]);
962 *composite = IdRef(_instruction[_o++]);
963 if (indexesList)
964 {
965 while (_o < _length)
966 {
967 indexesList->emplace_back(_instruction[_o++]);
968 }
969 }
970 }
ParseCompositeInsert(const uint32_t * _instruction,IdResultType * idResultType1,IdResult * idResult2,IdRef * object,IdRef * composite,LiteralIntegerList * indexesList)971 void ParseCompositeInsert(const uint32_t *_instruction,
972 IdResultType *idResultType1,
973 IdResult *idResult2,
974 IdRef *object,
975 IdRef *composite,
976 LiteralIntegerList *indexesList)
977 {
978 spv::Op _op;
979 uint32_t _length;
980 GetInstructionOpAndLength(_instruction, &_op, &_length);
981 ASSERT(_op == spv::OpCompositeInsert);
982 uint32_t _o = 1;
983 *idResultType1 = IdResultType(_instruction[_o++]);
984 *idResult2 = IdResult(_instruction[_o++]);
985 *object = IdRef(_instruction[_o++]);
986 *composite = IdRef(_instruction[_o++]);
987 if (indexesList)
988 {
989 while (_o < _length)
990 {
991 indexesList->emplace_back(_instruction[_o++]);
992 }
993 }
994 }
ParseCopyObject(const uint32_t * _instruction,IdResultType * idResultType1,IdResult * idResult2,IdRef * operand)995 void ParseCopyObject(const uint32_t *_instruction,
996 IdResultType *idResultType1,
997 IdResult *idResult2,
998 IdRef *operand)
999 {
1000 spv::Op _op;
1001 uint32_t _length;
1002 GetInstructionOpAndLength(_instruction, &_op, &_length);
1003 ASSERT(_op == spv::OpCopyObject);
1004 uint32_t _o = 1;
1005 *idResultType1 = IdResultType(_instruction[_o++]);
1006 *idResult2 = IdResult(_instruction[_o++]);
1007 *operand = IdRef(_instruction[_o++]);
1008 }
ParseTranspose(const uint32_t * _instruction,IdResultType * idResultType1,IdResult * idResult2,IdRef * matrix)1009 void ParseTranspose(const uint32_t *_instruction,
1010 IdResultType *idResultType1,
1011 IdResult *idResult2,
1012 IdRef *matrix)
1013 {
1014 spv::Op _op;
1015 uint32_t _length;
1016 GetInstructionOpAndLength(_instruction, &_op, &_length);
1017 ASSERT(_op == spv::OpTranspose);
1018 uint32_t _o = 1;
1019 *idResultType1 = IdResultType(_instruction[_o++]);
1020 *idResult2 = IdResult(_instruction[_o++]);
1021 *matrix = IdRef(_instruction[_o++]);
1022 }
ParseSampledImage(const uint32_t * _instruction,IdResultType * idResultType1,IdResult * idResult2,IdRef * image,IdRef * sampler)1023 void ParseSampledImage(const uint32_t *_instruction,
1024 IdResultType *idResultType1,
1025 IdResult *idResult2,
1026 IdRef *image,
1027 IdRef *sampler)
1028 {
1029 spv::Op _op;
1030 uint32_t _length;
1031 GetInstructionOpAndLength(_instruction, &_op, &_length);
1032 ASSERT(_op == spv::OpSampledImage);
1033 uint32_t _o = 1;
1034 *idResultType1 = IdResultType(_instruction[_o++]);
1035 *idResult2 = IdResult(_instruction[_o++]);
1036 *image = IdRef(_instruction[_o++]);
1037 *sampler = IdRef(_instruction[_o++]);
1038 }
ParseImageSampleImplicitLod(const uint32_t * _instruction,IdResultType * idResultType1,IdResult * idResult2,IdRef * sampledImage,IdRef * coordinate,spv::ImageOperandsMask * imageOperands5,IdRefList * imageOperandIdsList)1039 void ParseImageSampleImplicitLod(const uint32_t *_instruction,
1040 IdResultType *idResultType1,
1041 IdResult *idResult2,
1042 IdRef *sampledImage,
1043 IdRef *coordinate,
1044 spv::ImageOperandsMask *imageOperands5,
1045 IdRefList *imageOperandIdsList)
1046 {
1047 spv::Op _op;
1048 uint32_t _length;
1049 GetInstructionOpAndLength(_instruction, &_op, &_length);
1050 ASSERT(_op == spv::OpImageSampleImplicitLod);
1051 uint32_t _o = 1;
1052 *idResultType1 = IdResultType(_instruction[_o++]);
1053 *idResult2 = IdResult(_instruction[_o++]);
1054 *sampledImage = IdRef(_instruction[_o++]);
1055 *coordinate = IdRef(_instruction[_o++]);
1056 if (imageOperands5 && _o < _length)
1057 {
1058 *imageOperands5 = spv::ImageOperandsMask(_instruction[_o++]);
1059 }
1060 if (imageOperandIdsList)
1061 {
1062 while (_o < _length)
1063 {
1064 imageOperandIdsList->emplace_back(_instruction[_o++]);
1065 }
1066 }
1067 }
ParseImageSampleExplicitLod(const uint32_t * _instruction,IdResultType * idResultType1,IdResult * idResult2,IdRef * sampledImage,IdRef * coordinate,spv::ImageOperandsMask * imageOperands5,IdRefList * imageOperandIdsList)1068 void ParseImageSampleExplicitLod(const uint32_t *_instruction,
1069 IdResultType *idResultType1,
1070 IdResult *idResult2,
1071 IdRef *sampledImage,
1072 IdRef *coordinate,
1073 spv::ImageOperandsMask *imageOperands5,
1074 IdRefList *imageOperandIdsList)
1075 {
1076 spv::Op _op;
1077 uint32_t _length;
1078 GetInstructionOpAndLength(_instruction, &_op, &_length);
1079 ASSERT(_op == spv::OpImageSampleExplicitLod);
1080 uint32_t _o = 1;
1081 *idResultType1 = IdResultType(_instruction[_o++]);
1082 *idResult2 = IdResult(_instruction[_o++]);
1083 *sampledImage = IdRef(_instruction[_o++]);
1084 *coordinate = IdRef(_instruction[_o++]);
1085 *imageOperands5 = spv::ImageOperandsMask(_instruction[_o++]);
1086 if (imageOperandIdsList)
1087 {
1088 while (_o < _length)
1089 {
1090 imageOperandIdsList->emplace_back(_instruction[_o++]);
1091 }
1092 }
1093 }
ParseImageSampleDrefImplicitLod(const uint32_t * _instruction,IdResultType * idResultType1,IdResult * idResult2,IdRef * sampledImage,IdRef * coordinate,IdRef * dref,spv::ImageOperandsMask * imageOperands6,IdRefList * imageOperandIdsList)1094 void ParseImageSampleDrefImplicitLod(const uint32_t *_instruction,
1095 IdResultType *idResultType1,
1096 IdResult *idResult2,
1097 IdRef *sampledImage,
1098 IdRef *coordinate,
1099 IdRef *dref,
1100 spv::ImageOperandsMask *imageOperands6,
1101 IdRefList *imageOperandIdsList)
1102 {
1103 spv::Op _op;
1104 uint32_t _length;
1105 GetInstructionOpAndLength(_instruction, &_op, &_length);
1106 ASSERT(_op == spv::OpImageSampleDrefImplicitLod);
1107 uint32_t _o = 1;
1108 *idResultType1 = IdResultType(_instruction[_o++]);
1109 *idResult2 = IdResult(_instruction[_o++]);
1110 *sampledImage = IdRef(_instruction[_o++]);
1111 *coordinate = IdRef(_instruction[_o++]);
1112 *dref = IdRef(_instruction[_o++]);
1113 if (imageOperands6 && _o < _length)
1114 {
1115 *imageOperands6 = spv::ImageOperandsMask(_instruction[_o++]);
1116 }
1117 if (imageOperandIdsList)
1118 {
1119 while (_o < _length)
1120 {
1121 imageOperandIdsList->emplace_back(_instruction[_o++]);
1122 }
1123 }
1124 }
ParseImageSampleDrefExplicitLod(const uint32_t * _instruction,IdResultType * idResultType1,IdResult * idResult2,IdRef * sampledImage,IdRef * coordinate,IdRef * dref,spv::ImageOperandsMask * imageOperands6,IdRefList * imageOperandIdsList)1125 void ParseImageSampleDrefExplicitLod(const uint32_t *_instruction,
1126 IdResultType *idResultType1,
1127 IdResult *idResult2,
1128 IdRef *sampledImage,
1129 IdRef *coordinate,
1130 IdRef *dref,
1131 spv::ImageOperandsMask *imageOperands6,
1132 IdRefList *imageOperandIdsList)
1133 {
1134 spv::Op _op;
1135 uint32_t _length;
1136 GetInstructionOpAndLength(_instruction, &_op, &_length);
1137 ASSERT(_op == spv::OpImageSampleDrefExplicitLod);
1138 uint32_t _o = 1;
1139 *idResultType1 = IdResultType(_instruction[_o++]);
1140 *idResult2 = IdResult(_instruction[_o++]);
1141 *sampledImage = IdRef(_instruction[_o++]);
1142 *coordinate = IdRef(_instruction[_o++]);
1143 *dref = IdRef(_instruction[_o++]);
1144 *imageOperands6 = spv::ImageOperandsMask(_instruction[_o++]);
1145 if (imageOperandIdsList)
1146 {
1147 while (_o < _length)
1148 {
1149 imageOperandIdsList->emplace_back(_instruction[_o++]);
1150 }
1151 }
1152 }
ParseImageSampleProjImplicitLod(const uint32_t * _instruction,IdResultType * idResultType1,IdResult * idResult2,IdRef * sampledImage,IdRef * coordinate,spv::ImageOperandsMask * imageOperands5,IdRefList * imageOperandIdsList)1153 void ParseImageSampleProjImplicitLod(const uint32_t *_instruction,
1154 IdResultType *idResultType1,
1155 IdResult *idResult2,
1156 IdRef *sampledImage,
1157 IdRef *coordinate,
1158 spv::ImageOperandsMask *imageOperands5,
1159 IdRefList *imageOperandIdsList)
1160 {
1161 spv::Op _op;
1162 uint32_t _length;
1163 GetInstructionOpAndLength(_instruction, &_op, &_length);
1164 ASSERT(_op == spv::OpImageSampleProjImplicitLod);
1165 uint32_t _o = 1;
1166 *idResultType1 = IdResultType(_instruction[_o++]);
1167 *idResult2 = IdResult(_instruction[_o++]);
1168 *sampledImage = IdRef(_instruction[_o++]);
1169 *coordinate = IdRef(_instruction[_o++]);
1170 if (imageOperands5 && _o < _length)
1171 {
1172 *imageOperands5 = spv::ImageOperandsMask(_instruction[_o++]);
1173 }
1174 if (imageOperandIdsList)
1175 {
1176 while (_o < _length)
1177 {
1178 imageOperandIdsList->emplace_back(_instruction[_o++]);
1179 }
1180 }
1181 }
ParseImageSampleProjExplicitLod(const uint32_t * _instruction,IdResultType * idResultType1,IdResult * idResult2,IdRef * sampledImage,IdRef * coordinate,spv::ImageOperandsMask * imageOperands5,IdRefList * imageOperandIdsList)1182 void ParseImageSampleProjExplicitLod(const uint32_t *_instruction,
1183 IdResultType *idResultType1,
1184 IdResult *idResult2,
1185 IdRef *sampledImage,
1186 IdRef *coordinate,
1187 spv::ImageOperandsMask *imageOperands5,
1188 IdRefList *imageOperandIdsList)
1189 {
1190 spv::Op _op;
1191 uint32_t _length;
1192 GetInstructionOpAndLength(_instruction, &_op, &_length);
1193 ASSERT(_op == spv::OpImageSampleProjExplicitLod);
1194 uint32_t _o = 1;
1195 *idResultType1 = IdResultType(_instruction[_o++]);
1196 *idResult2 = IdResult(_instruction[_o++]);
1197 *sampledImage = IdRef(_instruction[_o++]);
1198 *coordinate = IdRef(_instruction[_o++]);
1199 *imageOperands5 = spv::ImageOperandsMask(_instruction[_o++]);
1200 if (imageOperandIdsList)
1201 {
1202 while (_o < _length)
1203 {
1204 imageOperandIdsList->emplace_back(_instruction[_o++]);
1205 }
1206 }
1207 }
ParseImageSampleProjDrefImplicitLod(const uint32_t * _instruction,IdResultType * idResultType1,IdResult * idResult2,IdRef * sampledImage,IdRef * coordinate,IdRef * dref,spv::ImageOperandsMask * imageOperands6,IdRefList * imageOperandIdsList)1208 void ParseImageSampleProjDrefImplicitLod(const uint32_t *_instruction,
1209 IdResultType *idResultType1,
1210 IdResult *idResult2,
1211 IdRef *sampledImage,
1212 IdRef *coordinate,
1213 IdRef *dref,
1214 spv::ImageOperandsMask *imageOperands6,
1215 IdRefList *imageOperandIdsList)
1216 {
1217 spv::Op _op;
1218 uint32_t _length;
1219 GetInstructionOpAndLength(_instruction, &_op, &_length);
1220 ASSERT(_op == spv::OpImageSampleProjDrefImplicitLod);
1221 uint32_t _o = 1;
1222 *idResultType1 = IdResultType(_instruction[_o++]);
1223 *idResult2 = IdResult(_instruction[_o++]);
1224 *sampledImage = IdRef(_instruction[_o++]);
1225 *coordinate = IdRef(_instruction[_o++]);
1226 *dref = IdRef(_instruction[_o++]);
1227 if (imageOperands6 && _o < _length)
1228 {
1229 *imageOperands6 = spv::ImageOperandsMask(_instruction[_o++]);
1230 }
1231 if (imageOperandIdsList)
1232 {
1233 while (_o < _length)
1234 {
1235 imageOperandIdsList->emplace_back(_instruction[_o++]);
1236 }
1237 }
1238 }
ParseImageSampleProjDrefExplicitLod(const uint32_t * _instruction,IdResultType * idResultType1,IdResult * idResult2,IdRef * sampledImage,IdRef * coordinate,IdRef * dref,spv::ImageOperandsMask * imageOperands6,IdRefList * imageOperandIdsList)1239 void ParseImageSampleProjDrefExplicitLod(const uint32_t *_instruction,
1240 IdResultType *idResultType1,
1241 IdResult *idResult2,
1242 IdRef *sampledImage,
1243 IdRef *coordinate,
1244 IdRef *dref,
1245 spv::ImageOperandsMask *imageOperands6,
1246 IdRefList *imageOperandIdsList)
1247 {
1248 spv::Op _op;
1249 uint32_t _length;
1250 GetInstructionOpAndLength(_instruction, &_op, &_length);
1251 ASSERT(_op == spv::OpImageSampleProjDrefExplicitLod);
1252 uint32_t _o = 1;
1253 *idResultType1 = IdResultType(_instruction[_o++]);
1254 *idResult2 = IdResult(_instruction[_o++]);
1255 *sampledImage = IdRef(_instruction[_o++]);
1256 *coordinate = IdRef(_instruction[_o++]);
1257 *dref = IdRef(_instruction[_o++]);
1258 *imageOperands6 = spv::ImageOperandsMask(_instruction[_o++]);
1259 if (imageOperandIdsList)
1260 {
1261 while (_o < _length)
1262 {
1263 imageOperandIdsList->emplace_back(_instruction[_o++]);
1264 }
1265 }
1266 }
ParseImageFetch(const uint32_t * _instruction,IdResultType * idResultType1,IdResult * idResult2,IdRef * image,IdRef * coordinate,spv::ImageOperandsMask * imageOperands5,IdRefList * imageOperandIdsList)1267 void ParseImageFetch(const uint32_t *_instruction,
1268 IdResultType *idResultType1,
1269 IdResult *idResult2,
1270 IdRef *image,
1271 IdRef *coordinate,
1272 spv::ImageOperandsMask *imageOperands5,
1273 IdRefList *imageOperandIdsList)
1274 {
1275 spv::Op _op;
1276 uint32_t _length;
1277 GetInstructionOpAndLength(_instruction, &_op, &_length);
1278 ASSERT(_op == spv::OpImageFetch);
1279 uint32_t _o = 1;
1280 *idResultType1 = IdResultType(_instruction[_o++]);
1281 *idResult2 = IdResult(_instruction[_o++]);
1282 *image = IdRef(_instruction[_o++]);
1283 *coordinate = IdRef(_instruction[_o++]);
1284 if (imageOperands5 && _o < _length)
1285 {
1286 *imageOperands5 = spv::ImageOperandsMask(_instruction[_o++]);
1287 }
1288 if (imageOperandIdsList)
1289 {
1290 while (_o < _length)
1291 {
1292 imageOperandIdsList->emplace_back(_instruction[_o++]);
1293 }
1294 }
1295 }
ParseImageGather(const uint32_t * _instruction,IdResultType * idResultType1,IdResult * idResult2,IdRef * sampledImage,IdRef * coordinate,IdRef * component,spv::ImageOperandsMask * imageOperands6,IdRefList * imageOperandIdsList)1296 void ParseImageGather(const uint32_t *_instruction,
1297 IdResultType *idResultType1,
1298 IdResult *idResult2,
1299 IdRef *sampledImage,
1300 IdRef *coordinate,
1301 IdRef *component,
1302 spv::ImageOperandsMask *imageOperands6,
1303 IdRefList *imageOperandIdsList)
1304 {
1305 spv::Op _op;
1306 uint32_t _length;
1307 GetInstructionOpAndLength(_instruction, &_op, &_length);
1308 ASSERT(_op == spv::OpImageGather);
1309 uint32_t _o = 1;
1310 *idResultType1 = IdResultType(_instruction[_o++]);
1311 *idResult2 = IdResult(_instruction[_o++]);
1312 *sampledImage = IdRef(_instruction[_o++]);
1313 *coordinate = IdRef(_instruction[_o++]);
1314 *component = IdRef(_instruction[_o++]);
1315 if (imageOperands6 && _o < _length)
1316 {
1317 *imageOperands6 = spv::ImageOperandsMask(_instruction[_o++]);
1318 }
1319 if (imageOperandIdsList)
1320 {
1321 while (_o < _length)
1322 {
1323 imageOperandIdsList->emplace_back(_instruction[_o++]);
1324 }
1325 }
1326 }
ParseImageDrefGather(const uint32_t * _instruction,IdResultType * idResultType1,IdResult * idResult2,IdRef * sampledImage,IdRef * coordinate,IdRef * dref,spv::ImageOperandsMask * imageOperands6,IdRefList * imageOperandIdsList)1327 void ParseImageDrefGather(const uint32_t *_instruction,
1328 IdResultType *idResultType1,
1329 IdResult *idResult2,
1330 IdRef *sampledImage,
1331 IdRef *coordinate,
1332 IdRef *dref,
1333 spv::ImageOperandsMask *imageOperands6,
1334 IdRefList *imageOperandIdsList)
1335 {
1336 spv::Op _op;
1337 uint32_t _length;
1338 GetInstructionOpAndLength(_instruction, &_op, &_length);
1339 ASSERT(_op == spv::OpImageDrefGather);
1340 uint32_t _o = 1;
1341 *idResultType1 = IdResultType(_instruction[_o++]);
1342 *idResult2 = IdResult(_instruction[_o++]);
1343 *sampledImage = IdRef(_instruction[_o++]);
1344 *coordinate = IdRef(_instruction[_o++]);
1345 *dref = IdRef(_instruction[_o++]);
1346 if (imageOperands6 && _o < _length)
1347 {
1348 *imageOperands6 = spv::ImageOperandsMask(_instruction[_o++]);
1349 }
1350 if (imageOperandIdsList)
1351 {
1352 while (_o < _length)
1353 {
1354 imageOperandIdsList->emplace_back(_instruction[_o++]);
1355 }
1356 }
1357 }
ParseImageRead(const uint32_t * _instruction,IdResultType * idResultType1,IdResult * idResult2,IdRef * image,IdRef * coordinate,spv::ImageOperandsMask * imageOperands5,IdRefList * imageOperandIdsList)1358 void ParseImageRead(const uint32_t *_instruction,
1359 IdResultType *idResultType1,
1360 IdResult *idResult2,
1361 IdRef *image,
1362 IdRef *coordinate,
1363 spv::ImageOperandsMask *imageOperands5,
1364 IdRefList *imageOperandIdsList)
1365 {
1366 spv::Op _op;
1367 uint32_t _length;
1368 GetInstructionOpAndLength(_instruction, &_op, &_length);
1369 ASSERT(_op == spv::OpImageRead);
1370 uint32_t _o = 1;
1371 *idResultType1 = IdResultType(_instruction[_o++]);
1372 *idResult2 = IdResult(_instruction[_o++]);
1373 *image = IdRef(_instruction[_o++]);
1374 *coordinate = IdRef(_instruction[_o++]);
1375 if (imageOperands5 && _o < _length)
1376 {
1377 *imageOperands5 = spv::ImageOperandsMask(_instruction[_o++]);
1378 }
1379 if (imageOperandIdsList)
1380 {
1381 while (_o < _length)
1382 {
1383 imageOperandIdsList->emplace_back(_instruction[_o++]);
1384 }
1385 }
1386 }
ParseImageWrite(const uint32_t * _instruction,IdRef * image,IdRef * coordinate,IdRef * texel,spv::ImageOperandsMask * imageOperands4,IdRefList * imageOperandIdsList)1387 void ParseImageWrite(const uint32_t *_instruction,
1388 IdRef *image,
1389 IdRef *coordinate,
1390 IdRef *texel,
1391 spv::ImageOperandsMask *imageOperands4,
1392 IdRefList *imageOperandIdsList)
1393 {
1394 spv::Op _op;
1395 uint32_t _length;
1396 GetInstructionOpAndLength(_instruction, &_op, &_length);
1397 ASSERT(_op == spv::OpImageWrite);
1398 uint32_t _o = 1;
1399 *image = IdRef(_instruction[_o++]);
1400 *coordinate = IdRef(_instruction[_o++]);
1401 *texel = IdRef(_instruction[_o++]);
1402 if (imageOperands4 && _o < _length)
1403 {
1404 *imageOperands4 = spv::ImageOperandsMask(_instruction[_o++]);
1405 }
1406 if (imageOperandIdsList)
1407 {
1408 while (_o < _length)
1409 {
1410 imageOperandIdsList->emplace_back(_instruction[_o++]);
1411 }
1412 }
1413 }
ParseImage(const uint32_t * _instruction,IdResultType * idResultType1,IdResult * idResult2,IdRef * sampledImage)1414 void ParseImage(const uint32_t *_instruction,
1415 IdResultType *idResultType1,
1416 IdResult *idResult2,
1417 IdRef *sampledImage)
1418 {
1419 spv::Op _op;
1420 uint32_t _length;
1421 GetInstructionOpAndLength(_instruction, &_op, &_length);
1422 ASSERT(_op == spv::OpImage);
1423 uint32_t _o = 1;
1424 *idResultType1 = IdResultType(_instruction[_o++]);
1425 *idResult2 = IdResult(_instruction[_o++]);
1426 *sampledImage = IdRef(_instruction[_o++]);
1427 }
ParseImageQuerySizeLod(const uint32_t * _instruction,IdResultType * idResultType1,IdResult * idResult2,IdRef * image,IdRef * levelofDetail)1428 void ParseImageQuerySizeLod(const uint32_t *_instruction,
1429 IdResultType *idResultType1,
1430 IdResult *idResult2,
1431 IdRef *image,
1432 IdRef *levelofDetail)
1433 {
1434 spv::Op _op;
1435 uint32_t _length;
1436 GetInstructionOpAndLength(_instruction, &_op, &_length);
1437 ASSERT(_op == spv::OpImageQuerySizeLod);
1438 uint32_t _o = 1;
1439 *idResultType1 = IdResultType(_instruction[_o++]);
1440 *idResult2 = IdResult(_instruction[_o++]);
1441 *image = IdRef(_instruction[_o++]);
1442 *levelofDetail = IdRef(_instruction[_o++]);
1443 }
ParseImageQuerySize(const uint32_t * _instruction,IdResultType * idResultType1,IdResult * idResult2,IdRef * image)1444 void ParseImageQuerySize(const uint32_t *_instruction,
1445 IdResultType *idResultType1,
1446 IdResult *idResult2,
1447 IdRef *image)
1448 {
1449 spv::Op _op;
1450 uint32_t _length;
1451 GetInstructionOpAndLength(_instruction, &_op, &_length);
1452 ASSERT(_op == spv::OpImageQuerySize);
1453 uint32_t _o = 1;
1454 *idResultType1 = IdResultType(_instruction[_o++]);
1455 *idResult2 = IdResult(_instruction[_o++]);
1456 *image = IdRef(_instruction[_o++]);
1457 }
ParseImageQueryLod(const uint32_t * _instruction,IdResultType * idResultType1,IdResult * idResult2,IdRef * sampledImage,IdRef * coordinate)1458 void ParseImageQueryLod(const uint32_t *_instruction,
1459 IdResultType *idResultType1,
1460 IdResult *idResult2,
1461 IdRef *sampledImage,
1462 IdRef *coordinate)
1463 {
1464 spv::Op _op;
1465 uint32_t _length;
1466 GetInstructionOpAndLength(_instruction, &_op, &_length);
1467 ASSERT(_op == spv::OpImageQueryLod);
1468 uint32_t _o = 1;
1469 *idResultType1 = IdResultType(_instruction[_o++]);
1470 *idResult2 = IdResult(_instruction[_o++]);
1471 *sampledImage = IdRef(_instruction[_o++]);
1472 *coordinate = IdRef(_instruction[_o++]);
1473 }
ParseImageQueryLevels(const uint32_t * _instruction,IdResultType * idResultType1,IdResult * idResult2,IdRef * image)1474 void ParseImageQueryLevels(const uint32_t *_instruction,
1475 IdResultType *idResultType1,
1476 IdResult *idResult2,
1477 IdRef *image)
1478 {
1479 spv::Op _op;
1480 uint32_t _length;
1481 GetInstructionOpAndLength(_instruction, &_op, &_length);
1482 ASSERT(_op == spv::OpImageQueryLevels);
1483 uint32_t _o = 1;
1484 *idResultType1 = IdResultType(_instruction[_o++]);
1485 *idResult2 = IdResult(_instruction[_o++]);
1486 *image = IdRef(_instruction[_o++]);
1487 }
ParseImageQuerySamples(const uint32_t * _instruction,IdResultType * idResultType1,IdResult * idResult2,IdRef * image)1488 void ParseImageQuerySamples(const uint32_t *_instruction,
1489 IdResultType *idResultType1,
1490 IdResult *idResult2,
1491 IdRef *image)
1492 {
1493 spv::Op _op;
1494 uint32_t _length;
1495 GetInstructionOpAndLength(_instruction, &_op, &_length);
1496 ASSERT(_op == spv::OpImageQuerySamples);
1497 uint32_t _o = 1;
1498 *idResultType1 = IdResultType(_instruction[_o++]);
1499 *idResult2 = IdResult(_instruction[_o++]);
1500 *image = IdRef(_instruction[_o++]);
1501 }
ParseConvertFToU(const uint32_t * _instruction,IdResultType * idResultType1,IdResult * idResult2,IdRef * floatValue)1502 void ParseConvertFToU(const uint32_t *_instruction,
1503 IdResultType *idResultType1,
1504 IdResult *idResult2,
1505 IdRef *floatValue)
1506 {
1507 spv::Op _op;
1508 uint32_t _length;
1509 GetInstructionOpAndLength(_instruction, &_op, &_length);
1510 ASSERT(_op == spv::OpConvertFToU);
1511 uint32_t _o = 1;
1512 *idResultType1 = IdResultType(_instruction[_o++]);
1513 *idResult2 = IdResult(_instruction[_o++]);
1514 *floatValue = IdRef(_instruction[_o++]);
1515 }
ParseConvertFToS(const uint32_t * _instruction,IdResultType * idResultType1,IdResult * idResult2,IdRef * floatValue)1516 void ParseConvertFToS(const uint32_t *_instruction,
1517 IdResultType *idResultType1,
1518 IdResult *idResult2,
1519 IdRef *floatValue)
1520 {
1521 spv::Op _op;
1522 uint32_t _length;
1523 GetInstructionOpAndLength(_instruction, &_op, &_length);
1524 ASSERT(_op == spv::OpConvertFToS);
1525 uint32_t _o = 1;
1526 *idResultType1 = IdResultType(_instruction[_o++]);
1527 *idResult2 = IdResult(_instruction[_o++]);
1528 *floatValue = IdRef(_instruction[_o++]);
1529 }
ParseConvertSToF(const uint32_t * _instruction,IdResultType * idResultType1,IdResult * idResult2,IdRef * signedValue)1530 void ParseConvertSToF(const uint32_t *_instruction,
1531 IdResultType *idResultType1,
1532 IdResult *idResult2,
1533 IdRef *signedValue)
1534 {
1535 spv::Op _op;
1536 uint32_t _length;
1537 GetInstructionOpAndLength(_instruction, &_op, &_length);
1538 ASSERT(_op == spv::OpConvertSToF);
1539 uint32_t _o = 1;
1540 *idResultType1 = IdResultType(_instruction[_o++]);
1541 *idResult2 = IdResult(_instruction[_o++]);
1542 *signedValue = IdRef(_instruction[_o++]);
1543 }
ParseConvertUToF(const uint32_t * _instruction,IdResultType * idResultType1,IdResult * idResult2,IdRef * unsignedValue)1544 void ParseConvertUToF(const uint32_t *_instruction,
1545 IdResultType *idResultType1,
1546 IdResult *idResult2,
1547 IdRef *unsignedValue)
1548 {
1549 spv::Op _op;
1550 uint32_t _length;
1551 GetInstructionOpAndLength(_instruction, &_op, &_length);
1552 ASSERT(_op == spv::OpConvertUToF);
1553 uint32_t _o = 1;
1554 *idResultType1 = IdResultType(_instruction[_o++]);
1555 *idResult2 = IdResult(_instruction[_o++]);
1556 *unsignedValue = IdRef(_instruction[_o++]);
1557 }
ParseUConvert(const uint32_t * _instruction,IdResultType * idResultType1,IdResult * idResult2,IdRef * unsignedValue)1558 void ParseUConvert(const uint32_t *_instruction,
1559 IdResultType *idResultType1,
1560 IdResult *idResult2,
1561 IdRef *unsignedValue)
1562 {
1563 spv::Op _op;
1564 uint32_t _length;
1565 GetInstructionOpAndLength(_instruction, &_op, &_length);
1566 ASSERT(_op == spv::OpUConvert);
1567 uint32_t _o = 1;
1568 *idResultType1 = IdResultType(_instruction[_o++]);
1569 *idResult2 = IdResult(_instruction[_o++]);
1570 *unsignedValue = IdRef(_instruction[_o++]);
1571 }
ParseSConvert(const uint32_t * _instruction,IdResultType * idResultType1,IdResult * idResult2,IdRef * signedValue)1572 void ParseSConvert(const uint32_t *_instruction,
1573 IdResultType *idResultType1,
1574 IdResult *idResult2,
1575 IdRef *signedValue)
1576 {
1577 spv::Op _op;
1578 uint32_t _length;
1579 GetInstructionOpAndLength(_instruction, &_op, &_length);
1580 ASSERT(_op == spv::OpSConvert);
1581 uint32_t _o = 1;
1582 *idResultType1 = IdResultType(_instruction[_o++]);
1583 *idResult2 = IdResult(_instruction[_o++]);
1584 *signedValue = IdRef(_instruction[_o++]);
1585 }
ParseFConvert(const uint32_t * _instruction,IdResultType * idResultType1,IdResult * idResult2,IdRef * floatValue)1586 void ParseFConvert(const uint32_t *_instruction,
1587 IdResultType *idResultType1,
1588 IdResult *idResult2,
1589 IdRef *floatValue)
1590 {
1591 spv::Op _op;
1592 uint32_t _length;
1593 GetInstructionOpAndLength(_instruction, &_op, &_length);
1594 ASSERT(_op == spv::OpFConvert);
1595 uint32_t _o = 1;
1596 *idResultType1 = IdResultType(_instruction[_o++]);
1597 *idResult2 = IdResult(_instruction[_o++]);
1598 *floatValue = IdRef(_instruction[_o++]);
1599 }
ParseQuantizeToF16(const uint32_t * _instruction,IdResultType * idResultType1,IdResult * idResult2,IdRef * value)1600 void ParseQuantizeToF16(const uint32_t *_instruction,
1601 IdResultType *idResultType1,
1602 IdResult *idResult2,
1603 IdRef *value)
1604 {
1605 spv::Op _op;
1606 uint32_t _length;
1607 GetInstructionOpAndLength(_instruction, &_op, &_length);
1608 ASSERT(_op == spv::OpQuantizeToF16);
1609 uint32_t _o = 1;
1610 *idResultType1 = IdResultType(_instruction[_o++]);
1611 *idResult2 = IdResult(_instruction[_o++]);
1612 *value = IdRef(_instruction[_o++]);
1613 }
ParseBitcast(const uint32_t * _instruction,IdResultType * idResultType1,IdResult * idResult2,IdRef * operand)1614 void ParseBitcast(const uint32_t *_instruction,
1615 IdResultType *idResultType1,
1616 IdResult *idResult2,
1617 IdRef *operand)
1618 {
1619 spv::Op _op;
1620 uint32_t _length;
1621 GetInstructionOpAndLength(_instruction, &_op, &_length);
1622 ASSERT(_op == spv::OpBitcast);
1623 uint32_t _o = 1;
1624 *idResultType1 = IdResultType(_instruction[_o++]);
1625 *idResult2 = IdResult(_instruction[_o++]);
1626 *operand = IdRef(_instruction[_o++]);
1627 }
ParseSNegate(const uint32_t * _instruction,IdResultType * idResultType1,IdResult * idResult2,IdRef * operand)1628 void ParseSNegate(const uint32_t *_instruction,
1629 IdResultType *idResultType1,
1630 IdResult *idResult2,
1631 IdRef *operand)
1632 {
1633 spv::Op _op;
1634 uint32_t _length;
1635 GetInstructionOpAndLength(_instruction, &_op, &_length);
1636 ASSERT(_op == spv::OpSNegate);
1637 uint32_t _o = 1;
1638 *idResultType1 = IdResultType(_instruction[_o++]);
1639 *idResult2 = IdResult(_instruction[_o++]);
1640 *operand = IdRef(_instruction[_o++]);
1641 }
ParseFNegate(const uint32_t * _instruction,IdResultType * idResultType1,IdResult * idResult2,IdRef * operand)1642 void ParseFNegate(const uint32_t *_instruction,
1643 IdResultType *idResultType1,
1644 IdResult *idResult2,
1645 IdRef *operand)
1646 {
1647 spv::Op _op;
1648 uint32_t _length;
1649 GetInstructionOpAndLength(_instruction, &_op, &_length);
1650 ASSERT(_op == spv::OpFNegate);
1651 uint32_t _o = 1;
1652 *idResultType1 = IdResultType(_instruction[_o++]);
1653 *idResult2 = IdResult(_instruction[_o++]);
1654 *operand = IdRef(_instruction[_o++]);
1655 }
ParseIAdd(const uint32_t * _instruction,IdResultType * idResultType1,IdResult * idResult2,IdRef * operand1,IdRef * operand2)1656 void ParseIAdd(const uint32_t *_instruction,
1657 IdResultType *idResultType1,
1658 IdResult *idResult2,
1659 IdRef *operand1,
1660 IdRef *operand2)
1661 {
1662 spv::Op _op;
1663 uint32_t _length;
1664 GetInstructionOpAndLength(_instruction, &_op, &_length);
1665 ASSERT(_op == spv::OpIAdd);
1666 uint32_t _o = 1;
1667 *idResultType1 = IdResultType(_instruction[_o++]);
1668 *idResult2 = IdResult(_instruction[_o++]);
1669 *operand1 = IdRef(_instruction[_o++]);
1670 *operand2 = IdRef(_instruction[_o++]);
1671 }
ParseFAdd(const uint32_t * _instruction,IdResultType * idResultType1,IdResult * idResult2,IdRef * operand1,IdRef * operand2)1672 void ParseFAdd(const uint32_t *_instruction,
1673 IdResultType *idResultType1,
1674 IdResult *idResult2,
1675 IdRef *operand1,
1676 IdRef *operand2)
1677 {
1678 spv::Op _op;
1679 uint32_t _length;
1680 GetInstructionOpAndLength(_instruction, &_op, &_length);
1681 ASSERT(_op == spv::OpFAdd);
1682 uint32_t _o = 1;
1683 *idResultType1 = IdResultType(_instruction[_o++]);
1684 *idResult2 = IdResult(_instruction[_o++]);
1685 *operand1 = IdRef(_instruction[_o++]);
1686 *operand2 = IdRef(_instruction[_o++]);
1687 }
ParseISub(const uint32_t * _instruction,IdResultType * idResultType1,IdResult * idResult2,IdRef * operand1,IdRef * operand2)1688 void ParseISub(const uint32_t *_instruction,
1689 IdResultType *idResultType1,
1690 IdResult *idResult2,
1691 IdRef *operand1,
1692 IdRef *operand2)
1693 {
1694 spv::Op _op;
1695 uint32_t _length;
1696 GetInstructionOpAndLength(_instruction, &_op, &_length);
1697 ASSERT(_op == spv::OpISub);
1698 uint32_t _o = 1;
1699 *idResultType1 = IdResultType(_instruction[_o++]);
1700 *idResult2 = IdResult(_instruction[_o++]);
1701 *operand1 = IdRef(_instruction[_o++]);
1702 *operand2 = IdRef(_instruction[_o++]);
1703 }
ParseFSub(const uint32_t * _instruction,IdResultType * idResultType1,IdResult * idResult2,IdRef * operand1,IdRef * operand2)1704 void ParseFSub(const uint32_t *_instruction,
1705 IdResultType *idResultType1,
1706 IdResult *idResult2,
1707 IdRef *operand1,
1708 IdRef *operand2)
1709 {
1710 spv::Op _op;
1711 uint32_t _length;
1712 GetInstructionOpAndLength(_instruction, &_op, &_length);
1713 ASSERT(_op == spv::OpFSub);
1714 uint32_t _o = 1;
1715 *idResultType1 = IdResultType(_instruction[_o++]);
1716 *idResult2 = IdResult(_instruction[_o++]);
1717 *operand1 = IdRef(_instruction[_o++]);
1718 *operand2 = IdRef(_instruction[_o++]);
1719 }
ParseIMul(const uint32_t * _instruction,IdResultType * idResultType1,IdResult * idResult2,IdRef * operand1,IdRef * operand2)1720 void ParseIMul(const uint32_t *_instruction,
1721 IdResultType *idResultType1,
1722 IdResult *idResult2,
1723 IdRef *operand1,
1724 IdRef *operand2)
1725 {
1726 spv::Op _op;
1727 uint32_t _length;
1728 GetInstructionOpAndLength(_instruction, &_op, &_length);
1729 ASSERT(_op == spv::OpIMul);
1730 uint32_t _o = 1;
1731 *idResultType1 = IdResultType(_instruction[_o++]);
1732 *idResult2 = IdResult(_instruction[_o++]);
1733 *operand1 = IdRef(_instruction[_o++]);
1734 *operand2 = IdRef(_instruction[_o++]);
1735 }
ParseFMul(const uint32_t * _instruction,IdResultType * idResultType1,IdResult * idResult2,IdRef * operand1,IdRef * operand2)1736 void ParseFMul(const uint32_t *_instruction,
1737 IdResultType *idResultType1,
1738 IdResult *idResult2,
1739 IdRef *operand1,
1740 IdRef *operand2)
1741 {
1742 spv::Op _op;
1743 uint32_t _length;
1744 GetInstructionOpAndLength(_instruction, &_op, &_length);
1745 ASSERT(_op == spv::OpFMul);
1746 uint32_t _o = 1;
1747 *idResultType1 = IdResultType(_instruction[_o++]);
1748 *idResult2 = IdResult(_instruction[_o++]);
1749 *operand1 = IdRef(_instruction[_o++]);
1750 *operand2 = IdRef(_instruction[_o++]);
1751 }
ParseUDiv(const uint32_t * _instruction,IdResultType * idResultType1,IdResult * idResult2,IdRef * operand1,IdRef * operand2)1752 void ParseUDiv(const uint32_t *_instruction,
1753 IdResultType *idResultType1,
1754 IdResult *idResult2,
1755 IdRef *operand1,
1756 IdRef *operand2)
1757 {
1758 spv::Op _op;
1759 uint32_t _length;
1760 GetInstructionOpAndLength(_instruction, &_op, &_length);
1761 ASSERT(_op == spv::OpUDiv);
1762 uint32_t _o = 1;
1763 *idResultType1 = IdResultType(_instruction[_o++]);
1764 *idResult2 = IdResult(_instruction[_o++]);
1765 *operand1 = IdRef(_instruction[_o++]);
1766 *operand2 = IdRef(_instruction[_o++]);
1767 }
ParseSDiv(const uint32_t * _instruction,IdResultType * idResultType1,IdResult * idResult2,IdRef * operand1,IdRef * operand2)1768 void ParseSDiv(const uint32_t *_instruction,
1769 IdResultType *idResultType1,
1770 IdResult *idResult2,
1771 IdRef *operand1,
1772 IdRef *operand2)
1773 {
1774 spv::Op _op;
1775 uint32_t _length;
1776 GetInstructionOpAndLength(_instruction, &_op, &_length);
1777 ASSERT(_op == spv::OpSDiv);
1778 uint32_t _o = 1;
1779 *idResultType1 = IdResultType(_instruction[_o++]);
1780 *idResult2 = IdResult(_instruction[_o++]);
1781 *operand1 = IdRef(_instruction[_o++]);
1782 *operand2 = IdRef(_instruction[_o++]);
1783 }
ParseFDiv(const uint32_t * _instruction,IdResultType * idResultType1,IdResult * idResult2,IdRef * operand1,IdRef * operand2)1784 void ParseFDiv(const uint32_t *_instruction,
1785 IdResultType *idResultType1,
1786 IdResult *idResult2,
1787 IdRef *operand1,
1788 IdRef *operand2)
1789 {
1790 spv::Op _op;
1791 uint32_t _length;
1792 GetInstructionOpAndLength(_instruction, &_op, &_length);
1793 ASSERT(_op == spv::OpFDiv);
1794 uint32_t _o = 1;
1795 *idResultType1 = IdResultType(_instruction[_o++]);
1796 *idResult2 = IdResult(_instruction[_o++]);
1797 *operand1 = IdRef(_instruction[_o++]);
1798 *operand2 = IdRef(_instruction[_o++]);
1799 }
ParseUMod(const uint32_t * _instruction,IdResultType * idResultType1,IdResult * idResult2,IdRef * operand1,IdRef * operand2)1800 void ParseUMod(const uint32_t *_instruction,
1801 IdResultType *idResultType1,
1802 IdResult *idResult2,
1803 IdRef *operand1,
1804 IdRef *operand2)
1805 {
1806 spv::Op _op;
1807 uint32_t _length;
1808 GetInstructionOpAndLength(_instruction, &_op, &_length);
1809 ASSERT(_op == spv::OpUMod);
1810 uint32_t _o = 1;
1811 *idResultType1 = IdResultType(_instruction[_o++]);
1812 *idResult2 = IdResult(_instruction[_o++]);
1813 *operand1 = IdRef(_instruction[_o++]);
1814 *operand2 = IdRef(_instruction[_o++]);
1815 }
ParseSRem(const uint32_t * _instruction,IdResultType * idResultType1,IdResult * idResult2,IdRef * operand1,IdRef * operand2)1816 void ParseSRem(const uint32_t *_instruction,
1817 IdResultType *idResultType1,
1818 IdResult *idResult2,
1819 IdRef *operand1,
1820 IdRef *operand2)
1821 {
1822 spv::Op _op;
1823 uint32_t _length;
1824 GetInstructionOpAndLength(_instruction, &_op, &_length);
1825 ASSERT(_op == spv::OpSRem);
1826 uint32_t _o = 1;
1827 *idResultType1 = IdResultType(_instruction[_o++]);
1828 *idResult2 = IdResult(_instruction[_o++]);
1829 *operand1 = IdRef(_instruction[_o++]);
1830 *operand2 = IdRef(_instruction[_o++]);
1831 }
ParseSMod(const uint32_t * _instruction,IdResultType * idResultType1,IdResult * idResult2,IdRef * operand1,IdRef * operand2)1832 void ParseSMod(const uint32_t *_instruction,
1833 IdResultType *idResultType1,
1834 IdResult *idResult2,
1835 IdRef *operand1,
1836 IdRef *operand2)
1837 {
1838 spv::Op _op;
1839 uint32_t _length;
1840 GetInstructionOpAndLength(_instruction, &_op, &_length);
1841 ASSERT(_op == spv::OpSMod);
1842 uint32_t _o = 1;
1843 *idResultType1 = IdResultType(_instruction[_o++]);
1844 *idResult2 = IdResult(_instruction[_o++]);
1845 *operand1 = IdRef(_instruction[_o++]);
1846 *operand2 = IdRef(_instruction[_o++]);
1847 }
ParseFRem(const uint32_t * _instruction,IdResultType * idResultType1,IdResult * idResult2,IdRef * operand1,IdRef * operand2)1848 void ParseFRem(const uint32_t *_instruction,
1849 IdResultType *idResultType1,
1850 IdResult *idResult2,
1851 IdRef *operand1,
1852 IdRef *operand2)
1853 {
1854 spv::Op _op;
1855 uint32_t _length;
1856 GetInstructionOpAndLength(_instruction, &_op, &_length);
1857 ASSERT(_op == spv::OpFRem);
1858 uint32_t _o = 1;
1859 *idResultType1 = IdResultType(_instruction[_o++]);
1860 *idResult2 = IdResult(_instruction[_o++]);
1861 *operand1 = IdRef(_instruction[_o++]);
1862 *operand2 = IdRef(_instruction[_o++]);
1863 }
ParseFMod(const uint32_t * _instruction,IdResultType * idResultType1,IdResult * idResult2,IdRef * operand1,IdRef * operand2)1864 void ParseFMod(const uint32_t *_instruction,
1865 IdResultType *idResultType1,
1866 IdResult *idResult2,
1867 IdRef *operand1,
1868 IdRef *operand2)
1869 {
1870 spv::Op _op;
1871 uint32_t _length;
1872 GetInstructionOpAndLength(_instruction, &_op, &_length);
1873 ASSERT(_op == spv::OpFMod);
1874 uint32_t _o = 1;
1875 *idResultType1 = IdResultType(_instruction[_o++]);
1876 *idResult2 = IdResult(_instruction[_o++]);
1877 *operand1 = IdRef(_instruction[_o++]);
1878 *operand2 = IdRef(_instruction[_o++]);
1879 }
ParseVectorTimesScalar(const uint32_t * _instruction,IdResultType * idResultType1,IdResult * idResult2,IdRef * vector,IdRef * scalar)1880 void ParseVectorTimesScalar(const uint32_t *_instruction,
1881 IdResultType *idResultType1,
1882 IdResult *idResult2,
1883 IdRef *vector,
1884 IdRef *scalar)
1885 {
1886 spv::Op _op;
1887 uint32_t _length;
1888 GetInstructionOpAndLength(_instruction, &_op, &_length);
1889 ASSERT(_op == spv::OpVectorTimesScalar);
1890 uint32_t _o = 1;
1891 *idResultType1 = IdResultType(_instruction[_o++]);
1892 *idResult2 = IdResult(_instruction[_o++]);
1893 *vector = IdRef(_instruction[_o++]);
1894 *scalar = IdRef(_instruction[_o++]);
1895 }
ParseMatrixTimesScalar(const uint32_t * _instruction,IdResultType * idResultType1,IdResult * idResult2,IdRef * matrix,IdRef * scalar)1896 void ParseMatrixTimesScalar(const uint32_t *_instruction,
1897 IdResultType *idResultType1,
1898 IdResult *idResult2,
1899 IdRef *matrix,
1900 IdRef *scalar)
1901 {
1902 spv::Op _op;
1903 uint32_t _length;
1904 GetInstructionOpAndLength(_instruction, &_op, &_length);
1905 ASSERT(_op == spv::OpMatrixTimesScalar);
1906 uint32_t _o = 1;
1907 *idResultType1 = IdResultType(_instruction[_o++]);
1908 *idResult2 = IdResult(_instruction[_o++]);
1909 *matrix = IdRef(_instruction[_o++]);
1910 *scalar = IdRef(_instruction[_o++]);
1911 }
ParseVectorTimesMatrix(const uint32_t * _instruction,IdResultType * idResultType1,IdResult * idResult2,IdRef * vector,IdRef * matrix)1912 void ParseVectorTimesMatrix(const uint32_t *_instruction,
1913 IdResultType *idResultType1,
1914 IdResult *idResult2,
1915 IdRef *vector,
1916 IdRef *matrix)
1917 {
1918 spv::Op _op;
1919 uint32_t _length;
1920 GetInstructionOpAndLength(_instruction, &_op, &_length);
1921 ASSERT(_op == spv::OpVectorTimesMatrix);
1922 uint32_t _o = 1;
1923 *idResultType1 = IdResultType(_instruction[_o++]);
1924 *idResult2 = IdResult(_instruction[_o++]);
1925 *vector = IdRef(_instruction[_o++]);
1926 *matrix = IdRef(_instruction[_o++]);
1927 }
ParseMatrixTimesVector(const uint32_t * _instruction,IdResultType * idResultType1,IdResult * idResult2,IdRef * matrix,IdRef * vector)1928 void ParseMatrixTimesVector(const uint32_t *_instruction,
1929 IdResultType *idResultType1,
1930 IdResult *idResult2,
1931 IdRef *matrix,
1932 IdRef *vector)
1933 {
1934 spv::Op _op;
1935 uint32_t _length;
1936 GetInstructionOpAndLength(_instruction, &_op, &_length);
1937 ASSERT(_op == spv::OpMatrixTimesVector);
1938 uint32_t _o = 1;
1939 *idResultType1 = IdResultType(_instruction[_o++]);
1940 *idResult2 = IdResult(_instruction[_o++]);
1941 *matrix = IdRef(_instruction[_o++]);
1942 *vector = IdRef(_instruction[_o++]);
1943 }
ParseMatrixTimesMatrix(const uint32_t * _instruction,IdResultType * idResultType1,IdResult * idResult2,IdRef * leftMatrix,IdRef * rightMatrix)1944 void ParseMatrixTimesMatrix(const uint32_t *_instruction,
1945 IdResultType *idResultType1,
1946 IdResult *idResult2,
1947 IdRef *leftMatrix,
1948 IdRef *rightMatrix)
1949 {
1950 spv::Op _op;
1951 uint32_t _length;
1952 GetInstructionOpAndLength(_instruction, &_op, &_length);
1953 ASSERT(_op == spv::OpMatrixTimesMatrix);
1954 uint32_t _o = 1;
1955 *idResultType1 = IdResultType(_instruction[_o++]);
1956 *idResult2 = IdResult(_instruction[_o++]);
1957 *leftMatrix = IdRef(_instruction[_o++]);
1958 *rightMatrix = IdRef(_instruction[_o++]);
1959 }
ParseOuterProduct(const uint32_t * _instruction,IdResultType * idResultType1,IdResult * idResult2,IdRef * vector1,IdRef * vector2)1960 void ParseOuterProduct(const uint32_t *_instruction,
1961 IdResultType *idResultType1,
1962 IdResult *idResult2,
1963 IdRef *vector1,
1964 IdRef *vector2)
1965 {
1966 spv::Op _op;
1967 uint32_t _length;
1968 GetInstructionOpAndLength(_instruction, &_op, &_length);
1969 ASSERT(_op == spv::OpOuterProduct);
1970 uint32_t _o = 1;
1971 *idResultType1 = IdResultType(_instruction[_o++]);
1972 *idResult2 = IdResult(_instruction[_o++]);
1973 *vector1 = IdRef(_instruction[_o++]);
1974 *vector2 = IdRef(_instruction[_o++]);
1975 }
ParseDot(const uint32_t * _instruction,IdResultType * idResultType1,IdResult * idResult2,IdRef * vector1,IdRef * vector2)1976 void ParseDot(const uint32_t *_instruction,
1977 IdResultType *idResultType1,
1978 IdResult *idResult2,
1979 IdRef *vector1,
1980 IdRef *vector2)
1981 {
1982 spv::Op _op;
1983 uint32_t _length;
1984 GetInstructionOpAndLength(_instruction, &_op, &_length);
1985 ASSERT(_op == spv::OpDot);
1986 uint32_t _o = 1;
1987 *idResultType1 = IdResultType(_instruction[_o++]);
1988 *idResult2 = IdResult(_instruction[_o++]);
1989 *vector1 = IdRef(_instruction[_o++]);
1990 *vector2 = IdRef(_instruction[_o++]);
1991 }
ParseIAddCarry(const uint32_t * _instruction,IdResultType * idResultType1,IdResult * idResult2,IdRef * operand1,IdRef * operand2)1992 void ParseIAddCarry(const uint32_t *_instruction,
1993 IdResultType *idResultType1,
1994 IdResult *idResult2,
1995 IdRef *operand1,
1996 IdRef *operand2)
1997 {
1998 spv::Op _op;
1999 uint32_t _length;
2000 GetInstructionOpAndLength(_instruction, &_op, &_length);
2001 ASSERT(_op == spv::OpIAddCarry);
2002 uint32_t _o = 1;
2003 *idResultType1 = IdResultType(_instruction[_o++]);
2004 *idResult2 = IdResult(_instruction[_o++]);
2005 *operand1 = IdRef(_instruction[_o++]);
2006 *operand2 = IdRef(_instruction[_o++]);
2007 }
ParseISubBorrow(const uint32_t * _instruction,IdResultType * idResultType1,IdResult * idResult2,IdRef * operand1,IdRef * operand2)2008 void ParseISubBorrow(const uint32_t *_instruction,
2009 IdResultType *idResultType1,
2010 IdResult *idResult2,
2011 IdRef *operand1,
2012 IdRef *operand2)
2013 {
2014 spv::Op _op;
2015 uint32_t _length;
2016 GetInstructionOpAndLength(_instruction, &_op, &_length);
2017 ASSERT(_op == spv::OpISubBorrow);
2018 uint32_t _o = 1;
2019 *idResultType1 = IdResultType(_instruction[_o++]);
2020 *idResult2 = IdResult(_instruction[_o++]);
2021 *operand1 = IdRef(_instruction[_o++]);
2022 *operand2 = IdRef(_instruction[_o++]);
2023 }
ParseUMulExtended(const uint32_t * _instruction,IdResultType * idResultType1,IdResult * idResult2,IdRef * operand1,IdRef * operand2)2024 void ParseUMulExtended(const uint32_t *_instruction,
2025 IdResultType *idResultType1,
2026 IdResult *idResult2,
2027 IdRef *operand1,
2028 IdRef *operand2)
2029 {
2030 spv::Op _op;
2031 uint32_t _length;
2032 GetInstructionOpAndLength(_instruction, &_op, &_length);
2033 ASSERT(_op == spv::OpUMulExtended);
2034 uint32_t _o = 1;
2035 *idResultType1 = IdResultType(_instruction[_o++]);
2036 *idResult2 = IdResult(_instruction[_o++]);
2037 *operand1 = IdRef(_instruction[_o++]);
2038 *operand2 = IdRef(_instruction[_o++]);
2039 }
ParseSMulExtended(const uint32_t * _instruction,IdResultType * idResultType1,IdResult * idResult2,IdRef * operand1,IdRef * operand2)2040 void ParseSMulExtended(const uint32_t *_instruction,
2041 IdResultType *idResultType1,
2042 IdResult *idResult2,
2043 IdRef *operand1,
2044 IdRef *operand2)
2045 {
2046 spv::Op _op;
2047 uint32_t _length;
2048 GetInstructionOpAndLength(_instruction, &_op, &_length);
2049 ASSERT(_op == spv::OpSMulExtended);
2050 uint32_t _o = 1;
2051 *idResultType1 = IdResultType(_instruction[_o++]);
2052 *idResult2 = IdResult(_instruction[_o++]);
2053 *operand1 = IdRef(_instruction[_o++]);
2054 *operand2 = IdRef(_instruction[_o++]);
2055 }
ParseAny(const uint32_t * _instruction,IdResultType * idResultType1,IdResult * idResult2,IdRef * vector)2056 void ParseAny(const uint32_t *_instruction,
2057 IdResultType *idResultType1,
2058 IdResult *idResult2,
2059 IdRef *vector)
2060 {
2061 spv::Op _op;
2062 uint32_t _length;
2063 GetInstructionOpAndLength(_instruction, &_op, &_length);
2064 ASSERT(_op == spv::OpAny);
2065 uint32_t _o = 1;
2066 *idResultType1 = IdResultType(_instruction[_o++]);
2067 *idResult2 = IdResult(_instruction[_o++]);
2068 *vector = IdRef(_instruction[_o++]);
2069 }
ParseAll(const uint32_t * _instruction,IdResultType * idResultType1,IdResult * idResult2,IdRef * vector)2070 void ParseAll(const uint32_t *_instruction,
2071 IdResultType *idResultType1,
2072 IdResult *idResult2,
2073 IdRef *vector)
2074 {
2075 spv::Op _op;
2076 uint32_t _length;
2077 GetInstructionOpAndLength(_instruction, &_op, &_length);
2078 ASSERT(_op == spv::OpAll);
2079 uint32_t _o = 1;
2080 *idResultType1 = IdResultType(_instruction[_o++]);
2081 *idResult2 = IdResult(_instruction[_o++]);
2082 *vector = IdRef(_instruction[_o++]);
2083 }
ParseIsNan(const uint32_t * _instruction,IdResultType * idResultType1,IdResult * idResult2,IdRef * x)2084 void ParseIsNan(const uint32_t *_instruction,
2085 IdResultType *idResultType1,
2086 IdResult *idResult2,
2087 IdRef *x)
2088 {
2089 spv::Op _op;
2090 uint32_t _length;
2091 GetInstructionOpAndLength(_instruction, &_op, &_length);
2092 ASSERT(_op == spv::OpIsNan);
2093 uint32_t _o = 1;
2094 *idResultType1 = IdResultType(_instruction[_o++]);
2095 *idResult2 = IdResult(_instruction[_o++]);
2096 *x = IdRef(_instruction[_o++]);
2097 }
ParseIsInf(const uint32_t * _instruction,IdResultType * idResultType1,IdResult * idResult2,IdRef * x)2098 void ParseIsInf(const uint32_t *_instruction,
2099 IdResultType *idResultType1,
2100 IdResult *idResult2,
2101 IdRef *x)
2102 {
2103 spv::Op _op;
2104 uint32_t _length;
2105 GetInstructionOpAndLength(_instruction, &_op, &_length);
2106 ASSERT(_op == spv::OpIsInf);
2107 uint32_t _o = 1;
2108 *idResultType1 = IdResultType(_instruction[_o++]);
2109 *idResult2 = IdResult(_instruction[_o++]);
2110 *x = IdRef(_instruction[_o++]);
2111 }
ParseLogicalEqual(const uint32_t * _instruction,IdResultType * idResultType1,IdResult * idResult2,IdRef * operand1,IdRef * operand2)2112 void ParseLogicalEqual(const uint32_t *_instruction,
2113 IdResultType *idResultType1,
2114 IdResult *idResult2,
2115 IdRef *operand1,
2116 IdRef *operand2)
2117 {
2118 spv::Op _op;
2119 uint32_t _length;
2120 GetInstructionOpAndLength(_instruction, &_op, &_length);
2121 ASSERT(_op == spv::OpLogicalEqual);
2122 uint32_t _o = 1;
2123 *idResultType1 = IdResultType(_instruction[_o++]);
2124 *idResult2 = IdResult(_instruction[_o++]);
2125 *operand1 = IdRef(_instruction[_o++]);
2126 *operand2 = IdRef(_instruction[_o++]);
2127 }
ParseLogicalNotEqual(const uint32_t * _instruction,IdResultType * idResultType1,IdResult * idResult2,IdRef * operand1,IdRef * operand2)2128 void ParseLogicalNotEqual(const uint32_t *_instruction,
2129 IdResultType *idResultType1,
2130 IdResult *idResult2,
2131 IdRef *operand1,
2132 IdRef *operand2)
2133 {
2134 spv::Op _op;
2135 uint32_t _length;
2136 GetInstructionOpAndLength(_instruction, &_op, &_length);
2137 ASSERT(_op == spv::OpLogicalNotEqual);
2138 uint32_t _o = 1;
2139 *idResultType1 = IdResultType(_instruction[_o++]);
2140 *idResult2 = IdResult(_instruction[_o++]);
2141 *operand1 = IdRef(_instruction[_o++]);
2142 *operand2 = IdRef(_instruction[_o++]);
2143 }
ParseLogicalOr(const uint32_t * _instruction,IdResultType * idResultType1,IdResult * idResult2,IdRef * operand1,IdRef * operand2)2144 void ParseLogicalOr(const uint32_t *_instruction,
2145 IdResultType *idResultType1,
2146 IdResult *idResult2,
2147 IdRef *operand1,
2148 IdRef *operand2)
2149 {
2150 spv::Op _op;
2151 uint32_t _length;
2152 GetInstructionOpAndLength(_instruction, &_op, &_length);
2153 ASSERT(_op == spv::OpLogicalOr);
2154 uint32_t _o = 1;
2155 *idResultType1 = IdResultType(_instruction[_o++]);
2156 *idResult2 = IdResult(_instruction[_o++]);
2157 *operand1 = IdRef(_instruction[_o++]);
2158 *operand2 = IdRef(_instruction[_o++]);
2159 }
ParseLogicalAnd(const uint32_t * _instruction,IdResultType * idResultType1,IdResult * idResult2,IdRef * operand1,IdRef * operand2)2160 void ParseLogicalAnd(const uint32_t *_instruction,
2161 IdResultType *idResultType1,
2162 IdResult *idResult2,
2163 IdRef *operand1,
2164 IdRef *operand2)
2165 {
2166 spv::Op _op;
2167 uint32_t _length;
2168 GetInstructionOpAndLength(_instruction, &_op, &_length);
2169 ASSERT(_op == spv::OpLogicalAnd);
2170 uint32_t _o = 1;
2171 *idResultType1 = IdResultType(_instruction[_o++]);
2172 *idResult2 = IdResult(_instruction[_o++]);
2173 *operand1 = IdRef(_instruction[_o++]);
2174 *operand2 = IdRef(_instruction[_o++]);
2175 }
ParseLogicalNot(const uint32_t * _instruction,IdResultType * idResultType1,IdResult * idResult2,IdRef * operand)2176 void ParseLogicalNot(const uint32_t *_instruction,
2177 IdResultType *idResultType1,
2178 IdResult *idResult2,
2179 IdRef *operand)
2180 {
2181 spv::Op _op;
2182 uint32_t _length;
2183 GetInstructionOpAndLength(_instruction, &_op, &_length);
2184 ASSERT(_op == spv::OpLogicalNot);
2185 uint32_t _o = 1;
2186 *idResultType1 = IdResultType(_instruction[_o++]);
2187 *idResult2 = IdResult(_instruction[_o++]);
2188 *operand = IdRef(_instruction[_o++]);
2189 }
ParseSelect(const uint32_t * _instruction,IdResultType * idResultType1,IdResult * idResult2,IdRef * condition,IdRef * object1,IdRef * object2)2190 void ParseSelect(const uint32_t *_instruction,
2191 IdResultType *idResultType1,
2192 IdResult *idResult2,
2193 IdRef *condition,
2194 IdRef *object1,
2195 IdRef *object2)
2196 {
2197 spv::Op _op;
2198 uint32_t _length;
2199 GetInstructionOpAndLength(_instruction, &_op, &_length);
2200 ASSERT(_op == spv::OpSelect);
2201 uint32_t _o = 1;
2202 *idResultType1 = IdResultType(_instruction[_o++]);
2203 *idResult2 = IdResult(_instruction[_o++]);
2204 *condition = IdRef(_instruction[_o++]);
2205 *object1 = IdRef(_instruction[_o++]);
2206 *object2 = IdRef(_instruction[_o++]);
2207 }
ParseIEqual(const uint32_t * _instruction,IdResultType * idResultType1,IdResult * idResult2,IdRef * operand1,IdRef * operand2)2208 void ParseIEqual(const uint32_t *_instruction,
2209 IdResultType *idResultType1,
2210 IdResult *idResult2,
2211 IdRef *operand1,
2212 IdRef *operand2)
2213 {
2214 spv::Op _op;
2215 uint32_t _length;
2216 GetInstructionOpAndLength(_instruction, &_op, &_length);
2217 ASSERT(_op == spv::OpIEqual);
2218 uint32_t _o = 1;
2219 *idResultType1 = IdResultType(_instruction[_o++]);
2220 *idResult2 = IdResult(_instruction[_o++]);
2221 *operand1 = IdRef(_instruction[_o++]);
2222 *operand2 = IdRef(_instruction[_o++]);
2223 }
ParseINotEqual(const uint32_t * _instruction,IdResultType * idResultType1,IdResult * idResult2,IdRef * operand1,IdRef * operand2)2224 void ParseINotEqual(const uint32_t *_instruction,
2225 IdResultType *idResultType1,
2226 IdResult *idResult2,
2227 IdRef *operand1,
2228 IdRef *operand2)
2229 {
2230 spv::Op _op;
2231 uint32_t _length;
2232 GetInstructionOpAndLength(_instruction, &_op, &_length);
2233 ASSERT(_op == spv::OpINotEqual);
2234 uint32_t _o = 1;
2235 *idResultType1 = IdResultType(_instruction[_o++]);
2236 *idResult2 = IdResult(_instruction[_o++]);
2237 *operand1 = IdRef(_instruction[_o++]);
2238 *operand2 = IdRef(_instruction[_o++]);
2239 }
ParseUGreaterThan(const uint32_t * _instruction,IdResultType * idResultType1,IdResult * idResult2,IdRef * operand1,IdRef * operand2)2240 void ParseUGreaterThan(const uint32_t *_instruction,
2241 IdResultType *idResultType1,
2242 IdResult *idResult2,
2243 IdRef *operand1,
2244 IdRef *operand2)
2245 {
2246 spv::Op _op;
2247 uint32_t _length;
2248 GetInstructionOpAndLength(_instruction, &_op, &_length);
2249 ASSERT(_op == spv::OpUGreaterThan);
2250 uint32_t _o = 1;
2251 *idResultType1 = IdResultType(_instruction[_o++]);
2252 *idResult2 = IdResult(_instruction[_o++]);
2253 *operand1 = IdRef(_instruction[_o++]);
2254 *operand2 = IdRef(_instruction[_o++]);
2255 }
ParseSGreaterThan(const uint32_t * _instruction,IdResultType * idResultType1,IdResult * idResult2,IdRef * operand1,IdRef * operand2)2256 void ParseSGreaterThan(const uint32_t *_instruction,
2257 IdResultType *idResultType1,
2258 IdResult *idResult2,
2259 IdRef *operand1,
2260 IdRef *operand2)
2261 {
2262 spv::Op _op;
2263 uint32_t _length;
2264 GetInstructionOpAndLength(_instruction, &_op, &_length);
2265 ASSERT(_op == spv::OpSGreaterThan);
2266 uint32_t _o = 1;
2267 *idResultType1 = IdResultType(_instruction[_o++]);
2268 *idResult2 = IdResult(_instruction[_o++]);
2269 *operand1 = IdRef(_instruction[_o++]);
2270 *operand2 = IdRef(_instruction[_o++]);
2271 }
ParseUGreaterThanEqual(const uint32_t * _instruction,IdResultType * idResultType1,IdResult * idResult2,IdRef * operand1,IdRef * operand2)2272 void ParseUGreaterThanEqual(const uint32_t *_instruction,
2273 IdResultType *idResultType1,
2274 IdResult *idResult2,
2275 IdRef *operand1,
2276 IdRef *operand2)
2277 {
2278 spv::Op _op;
2279 uint32_t _length;
2280 GetInstructionOpAndLength(_instruction, &_op, &_length);
2281 ASSERT(_op == spv::OpUGreaterThanEqual);
2282 uint32_t _o = 1;
2283 *idResultType1 = IdResultType(_instruction[_o++]);
2284 *idResult2 = IdResult(_instruction[_o++]);
2285 *operand1 = IdRef(_instruction[_o++]);
2286 *operand2 = IdRef(_instruction[_o++]);
2287 }
ParseSGreaterThanEqual(const uint32_t * _instruction,IdResultType * idResultType1,IdResult * idResult2,IdRef * operand1,IdRef * operand2)2288 void ParseSGreaterThanEqual(const uint32_t *_instruction,
2289 IdResultType *idResultType1,
2290 IdResult *idResult2,
2291 IdRef *operand1,
2292 IdRef *operand2)
2293 {
2294 spv::Op _op;
2295 uint32_t _length;
2296 GetInstructionOpAndLength(_instruction, &_op, &_length);
2297 ASSERT(_op == spv::OpSGreaterThanEqual);
2298 uint32_t _o = 1;
2299 *idResultType1 = IdResultType(_instruction[_o++]);
2300 *idResult2 = IdResult(_instruction[_o++]);
2301 *operand1 = IdRef(_instruction[_o++]);
2302 *operand2 = IdRef(_instruction[_o++]);
2303 }
ParseULessThan(const uint32_t * _instruction,IdResultType * idResultType1,IdResult * idResult2,IdRef * operand1,IdRef * operand2)2304 void ParseULessThan(const uint32_t *_instruction,
2305 IdResultType *idResultType1,
2306 IdResult *idResult2,
2307 IdRef *operand1,
2308 IdRef *operand2)
2309 {
2310 spv::Op _op;
2311 uint32_t _length;
2312 GetInstructionOpAndLength(_instruction, &_op, &_length);
2313 ASSERT(_op == spv::OpULessThan);
2314 uint32_t _o = 1;
2315 *idResultType1 = IdResultType(_instruction[_o++]);
2316 *idResult2 = IdResult(_instruction[_o++]);
2317 *operand1 = IdRef(_instruction[_o++]);
2318 *operand2 = IdRef(_instruction[_o++]);
2319 }
ParseSLessThan(const uint32_t * _instruction,IdResultType * idResultType1,IdResult * idResult2,IdRef * operand1,IdRef * operand2)2320 void ParseSLessThan(const uint32_t *_instruction,
2321 IdResultType *idResultType1,
2322 IdResult *idResult2,
2323 IdRef *operand1,
2324 IdRef *operand2)
2325 {
2326 spv::Op _op;
2327 uint32_t _length;
2328 GetInstructionOpAndLength(_instruction, &_op, &_length);
2329 ASSERT(_op == spv::OpSLessThan);
2330 uint32_t _o = 1;
2331 *idResultType1 = IdResultType(_instruction[_o++]);
2332 *idResult2 = IdResult(_instruction[_o++]);
2333 *operand1 = IdRef(_instruction[_o++]);
2334 *operand2 = IdRef(_instruction[_o++]);
2335 }
ParseULessThanEqual(const uint32_t * _instruction,IdResultType * idResultType1,IdResult * idResult2,IdRef * operand1,IdRef * operand2)2336 void ParseULessThanEqual(const uint32_t *_instruction,
2337 IdResultType *idResultType1,
2338 IdResult *idResult2,
2339 IdRef *operand1,
2340 IdRef *operand2)
2341 {
2342 spv::Op _op;
2343 uint32_t _length;
2344 GetInstructionOpAndLength(_instruction, &_op, &_length);
2345 ASSERT(_op == spv::OpULessThanEqual);
2346 uint32_t _o = 1;
2347 *idResultType1 = IdResultType(_instruction[_o++]);
2348 *idResult2 = IdResult(_instruction[_o++]);
2349 *operand1 = IdRef(_instruction[_o++]);
2350 *operand2 = IdRef(_instruction[_o++]);
2351 }
ParseSLessThanEqual(const uint32_t * _instruction,IdResultType * idResultType1,IdResult * idResult2,IdRef * operand1,IdRef * operand2)2352 void ParseSLessThanEqual(const uint32_t *_instruction,
2353 IdResultType *idResultType1,
2354 IdResult *idResult2,
2355 IdRef *operand1,
2356 IdRef *operand2)
2357 {
2358 spv::Op _op;
2359 uint32_t _length;
2360 GetInstructionOpAndLength(_instruction, &_op, &_length);
2361 ASSERT(_op == spv::OpSLessThanEqual);
2362 uint32_t _o = 1;
2363 *idResultType1 = IdResultType(_instruction[_o++]);
2364 *idResult2 = IdResult(_instruction[_o++]);
2365 *operand1 = IdRef(_instruction[_o++]);
2366 *operand2 = IdRef(_instruction[_o++]);
2367 }
ParseFOrdEqual(const uint32_t * _instruction,IdResultType * idResultType1,IdResult * idResult2,IdRef * operand1,IdRef * operand2)2368 void ParseFOrdEqual(const uint32_t *_instruction,
2369 IdResultType *idResultType1,
2370 IdResult *idResult2,
2371 IdRef *operand1,
2372 IdRef *operand2)
2373 {
2374 spv::Op _op;
2375 uint32_t _length;
2376 GetInstructionOpAndLength(_instruction, &_op, &_length);
2377 ASSERT(_op == spv::OpFOrdEqual);
2378 uint32_t _o = 1;
2379 *idResultType1 = IdResultType(_instruction[_o++]);
2380 *idResult2 = IdResult(_instruction[_o++]);
2381 *operand1 = IdRef(_instruction[_o++]);
2382 *operand2 = IdRef(_instruction[_o++]);
2383 }
ParseFUnordEqual(const uint32_t * _instruction,IdResultType * idResultType1,IdResult * idResult2,IdRef * operand1,IdRef * operand2)2384 void ParseFUnordEqual(const uint32_t *_instruction,
2385 IdResultType *idResultType1,
2386 IdResult *idResult2,
2387 IdRef *operand1,
2388 IdRef *operand2)
2389 {
2390 spv::Op _op;
2391 uint32_t _length;
2392 GetInstructionOpAndLength(_instruction, &_op, &_length);
2393 ASSERT(_op == spv::OpFUnordEqual);
2394 uint32_t _o = 1;
2395 *idResultType1 = IdResultType(_instruction[_o++]);
2396 *idResult2 = IdResult(_instruction[_o++]);
2397 *operand1 = IdRef(_instruction[_o++]);
2398 *operand2 = IdRef(_instruction[_o++]);
2399 }
ParseFOrdNotEqual(const uint32_t * _instruction,IdResultType * idResultType1,IdResult * idResult2,IdRef * operand1,IdRef * operand2)2400 void ParseFOrdNotEqual(const uint32_t *_instruction,
2401 IdResultType *idResultType1,
2402 IdResult *idResult2,
2403 IdRef *operand1,
2404 IdRef *operand2)
2405 {
2406 spv::Op _op;
2407 uint32_t _length;
2408 GetInstructionOpAndLength(_instruction, &_op, &_length);
2409 ASSERT(_op == spv::OpFOrdNotEqual);
2410 uint32_t _o = 1;
2411 *idResultType1 = IdResultType(_instruction[_o++]);
2412 *idResult2 = IdResult(_instruction[_o++]);
2413 *operand1 = IdRef(_instruction[_o++]);
2414 *operand2 = IdRef(_instruction[_o++]);
2415 }
ParseFUnordNotEqual(const uint32_t * _instruction,IdResultType * idResultType1,IdResult * idResult2,IdRef * operand1,IdRef * operand2)2416 void ParseFUnordNotEqual(const uint32_t *_instruction,
2417 IdResultType *idResultType1,
2418 IdResult *idResult2,
2419 IdRef *operand1,
2420 IdRef *operand2)
2421 {
2422 spv::Op _op;
2423 uint32_t _length;
2424 GetInstructionOpAndLength(_instruction, &_op, &_length);
2425 ASSERT(_op == spv::OpFUnordNotEqual);
2426 uint32_t _o = 1;
2427 *idResultType1 = IdResultType(_instruction[_o++]);
2428 *idResult2 = IdResult(_instruction[_o++]);
2429 *operand1 = IdRef(_instruction[_o++]);
2430 *operand2 = IdRef(_instruction[_o++]);
2431 }
ParseFOrdLessThan(const uint32_t * _instruction,IdResultType * idResultType1,IdResult * idResult2,IdRef * operand1,IdRef * operand2)2432 void ParseFOrdLessThan(const uint32_t *_instruction,
2433 IdResultType *idResultType1,
2434 IdResult *idResult2,
2435 IdRef *operand1,
2436 IdRef *operand2)
2437 {
2438 spv::Op _op;
2439 uint32_t _length;
2440 GetInstructionOpAndLength(_instruction, &_op, &_length);
2441 ASSERT(_op == spv::OpFOrdLessThan);
2442 uint32_t _o = 1;
2443 *idResultType1 = IdResultType(_instruction[_o++]);
2444 *idResult2 = IdResult(_instruction[_o++]);
2445 *operand1 = IdRef(_instruction[_o++]);
2446 *operand2 = IdRef(_instruction[_o++]);
2447 }
ParseFUnordLessThan(const uint32_t * _instruction,IdResultType * idResultType1,IdResult * idResult2,IdRef * operand1,IdRef * operand2)2448 void ParseFUnordLessThan(const uint32_t *_instruction,
2449 IdResultType *idResultType1,
2450 IdResult *idResult2,
2451 IdRef *operand1,
2452 IdRef *operand2)
2453 {
2454 spv::Op _op;
2455 uint32_t _length;
2456 GetInstructionOpAndLength(_instruction, &_op, &_length);
2457 ASSERT(_op == spv::OpFUnordLessThan);
2458 uint32_t _o = 1;
2459 *idResultType1 = IdResultType(_instruction[_o++]);
2460 *idResult2 = IdResult(_instruction[_o++]);
2461 *operand1 = IdRef(_instruction[_o++]);
2462 *operand2 = IdRef(_instruction[_o++]);
2463 }
ParseFOrdGreaterThan(const uint32_t * _instruction,IdResultType * idResultType1,IdResult * idResult2,IdRef * operand1,IdRef * operand2)2464 void ParseFOrdGreaterThan(const uint32_t *_instruction,
2465 IdResultType *idResultType1,
2466 IdResult *idResult2,
2467 IdRef *operand1,
2468 IdRef *operand2)
2469 {
2470 spv::Op _op;
2471 uint32_t _length;
2472 GetInstructionOpAndLength(_instruction, &_op, &_length);
2473 ASSERT(_op == spv::OpFOrdGreaterThan);
2474 uint32_t _o = 1;
2475 *idResultType1 = IdResultType(_instruction[_o++]);
2476 *idResult2 = IdResult(_instruction[_o++]);
2477 *operand1 = IdRef(_instruction[_o++]);
2478 *operand2 = IdRef(_instruction[_o++]);
2479 }
ParseFUnordGreaterThan(const uint32_t * _instruction,IdResultType * idResultType1,IdResult * idResult2,IdRef * operand1,IdRef * operand2)2480 void ParseFUnordGreaterThan(const uint32_t *_instruction,
2481 IdResultType *idResultType1,
2482 IdResult *idResult2,
2483 IdRef *operand1,
2484 IdRef *operand2)
2485 {
2486 spv::Op _op;
2487 uint32_t _length;
2488 GetInstructionOpAndLength(_instruction, &_op, &_length);
2489 ASSERT(_op == spv::OpFUnordGreaterThan);
2490 uint32_t _o = 1;
2491 *idResultType1 = IdResultType(_instruction[_o++]);
2492 *idResult2 = IdResult(_instruction[_o++]);
2493 *operand1 = IdRef(_instruction[_o++]);
2494 *operand2 = IdRef(_instruction[_o++]);
2495 }
ParseFOrdLessThanEqual(const uint32_t * _instruction,IdResultType * idResultType1,IdResult * idResult2,IdRef * operand1,IdRef * operand2)2496 void ParseFOrdLessThanEqual(const uint32_t *_instruction,
2497 IdResultType *idResultType1,
2498 IdResult *idResult2,
2499 IdRef *operand1,
2500 IdRef *operand2)
2501 {
2502 spv::Op _op;
2503 uint32_t _length;
2504 GetInstructionOpAndLength(_instruction, &_op, &_length);
2505 ASSERT(_op == spv::OpFOrdLessThanEqual);
2506 uint32_t _o = 1;
2507 *idResultType1 = IdResultType(_instruction[_o++]);
2508 *idResult2 = IdResult(_instruction[_o++]);
2509 *operand1 = IdRef(_instruction[_o++]);
2510 *operand2 = IdRef(_instruction[_o++]);
2511 }
ParseFUnordLessThanEqual(const uint32_t * _instruction,IdResultType * idResultType1,IdResult * idResult2,IdRef * operand1,IdRef * operand2)2512 void ParseFUnordLessThanEqual(const uint32_t *_instruction,
2513 IdResultType *idResultType1,
2514 IdResult *idResult2,
2515 IdRef *operand1,
2516 IdRef *operand2)
2517 {
2518 spv::Op _op;
2519 uint32_t _length;
2520 GetInstructionOpAndLength(_instruction, &_op, &_length);
2521 ASSERT(_op == spv::OpFUnordLessThanEqual);
2522 uint32_t _o = 1;
2523 *idResultType1 = IdResultType(_instruction[_o++]);
2524 *idResult2 = IdResult(_instruction[_o++]);
2525 *operand1 = IdRef(_instruction[_o++]);
2526 *operand2 = IdRef(_instruction[_o++]);
2527 }
ParseFOrdGreaterThanEqual(const uint32_t * _instruction,IdResultType * idResultType1,IdResult * idResult2,IdRef * operand1,IdRef * operand2)2528 void ParseFOrdGreaterThanEqual(const uint32_t *_instruction,
2529 IdResultType *idResultType1,
2530 IdResult *idResult2,
2531 IdRef *operand1,
2532 IdRef *operand2)
2533 {
2534 spv::Op _op;
2535 uint32_t _length;
2536 GetInstructionOpAndLength(_instruction, &_op, &_length);
2537 ASSERT(_op == spv::OpFOrdGreaterThanEqual);
2538 uint32_t _o = 1;
2539 *idResultType1 = IdResultType(_instruction[_o++]);
2540 *idResult2 = IdResult(_instruction[_o++]);
2541 *operand1 = IdRef(_instruction[_o++]);
2542 *operand2 = IdRef(_instruction[_o++]);
2543 }
ParseFUnordGreaterThanEqual(const uint32_t * _instruction,IdResultType * idResultType1,IdResult * idResult2,IdRef * operand1,IdRef * operand2)2544 void ParseFUnordGreaterThanEqual(const uint32_t *_instruction,
2545 IdResultType *idResultType1,
2546 IdResult *idResult2,
2547 IdRef *operand1,
2548 IdRef *operand2)
2549 {
2550 spv::Op _op;
2551 uint32_t _length;
2552 GetInstructionOpAndLength(_instruction, &_op, &_length);
2553 ASSERT(_op == spv::OpFUnordGreaterThanEqual);
2554 uint32_t _o = 1;
2555 *idResultType1 = IdResultType(_instruction[_o++]);
2556 *idResult2 = IdResult(_instruction[_o++]);
2557 *operand1 = IdRef(_instruction[_o++]);
2558 *operand2 = IdRef(_instruction[_o++]);
2559 }
ParseShiftRightLogical(const uint32_t * _instruction,IdResultType * idResultType1,IdResult * idResult2,IdRef * base,IdRef * shift)2560 void ParseShiftRightLogical(const uint32_t *_instruction,
2561 IdResultType *idResultType1,
2562 IdResult *idResult2,
2563 IdRef *base,
2564 IdRef *shift)
2565 {
2566 spv::Op _op;
2567 uint32_t _length;
2568 GetInstructionOpAndLength(_instruction, &_op, &_length);
2569 ASSERT(_op == spv::OpShiftRightLogical);
2570 uint32_t _o = 1;
2571 *idResultType1 = IdResultType(_instruction[_o++]);
2572 *idResult2 = IdResult(_instruction[_o++]);
2573 *base = IdRef(_instruction[_o++]);
2574 *shift = IdRef(_instruction[_o++]);
2575 }
ParseShiftRightArithmetic(const uint32_t * _instruction,IdResultType * idResultType1,IdResult * idResult2,IdRef * base,IdRef * shift)2576 void ParseShiftRightArithmetic(const uint32_t *_instruction,
2577 IdResultType *idResultType1,
2578 IdResult *idResult2,
2579 IdRef *base,
2580 IdRef *shift)
2581 {
2582 spv::Op _op;
2583 uint32_t _length;
2584 GetInstructionOpAndLength(_instruction, &_op, &_length);
2585 ASSERT(_op == spv::OpShiftRightArithmetic);
2586 uint32_t _o = 1;
2587 *idResultType1 = IdResultType(_instruction[_o++]);
2588 *idResult2 = IdResult(_instruction[_o++]);
2589 *base = IdRef(_instruction[_o++]);
2590 *shift = IdRef(_instruction[_o++]);
2591 }
ParseShiftLeftLogical(const uint32_t * _instruction,IdResultType * idResultType1,IdResult * idResult2,IdRef * base,IdRef * shift)2592 void ParseShiftLeftLogical(const uint32_t *_instruction,
2593 IdResultType *idResultType1,
2594 IdResult *idResult2,
2595 IdRef *base,
2596 IdRef *shift)
2597 {
2598 spv::Op _op;
2599 uint32_t _length;
2600 GetInstructionOpAndLength(_instruction, &_op, &_length);
2601 ASSERT(_op == spv::OpShiftLeftLogical);
2602 uint32_t _o = 1;
2603 *idResultType1 = IdResultType(_instruction[_o++]);
2604 *idResult2 = IdResult(_instruction[_o++]);
2605 *base = IdRef(_instruction[_o++]);
2606 *shift = IdRef(_instruction[_o++]);
2607 }
ParseBitwiseOr(const uint32_t * _instruction,IdResultType * idResultType1,IdResult * idResult2,IdRef * operand1,IdRef * operand2)2608 void ParseBitwiseOr(const uint32_t *_instruction,
2609 IdResultType *idResultType1,
2610 IdResult *idResult2,
2611 IdRef *operand1,
2612 IdRef *operand2)
2613 {
2614 spv::Op _op;
2615 uint32_t _length;
2616 GetInstructionOpAndLength(_instruction, &_op, &_length);
2617 ASSERT(_op == spv::OpBitwiseOr);
2618 uint32_t _o = 1;
2619 *idResultType1 = IdResultType(_instruction[_o++]);
2620 *idResult2 = IdResult(_instruction[_o++]);
2621 *operand1 = IdRef(_instruction[_o++]);
2622 *operand2 = IdRef(_instruction[_o++]);
2623 }
ParseBitwiseXor(const uint32_t * _instruction,IdResultType * idResultType1,IdResult * idResult2,IdRef * operand1,IdRef * operand2)2624 void ParseBitwiseXor(const uint32_t *_instruction,
2625 IdResultType *idResultType1,
2626 IdResult *idResult2,
2627 IdRef *operand1,
2628 IdRef *operand2)
2629 {
2630 spv::Op _op;
2631 uint32_t _length;
2632 GetInstructionOpAndLength(_instruction, &_op, &_length);
2633 ASSERT(_op == spv::OpBitwiseXor);
2634 uint32_t _o = 1;
2635 *idResultType1 = IdResultType(_instruction[_o++]);
2636 *idResult2 = IdResult(_instruction[_o++]);
2637 *operand1 = IdRef(_instruction[_o++]);
2638 *operand2 = IdRef(_instruction[_o++]);
2639 }
ParseBitwiseAnd(const uint32_t * _instruction,IdResultType * idResultType1,IdResult * idResult2,IdRef * operand1,IdRef * operand2)2640 void ParseBitwiseAnd(const uint32_t *_instruction,
2641 IdResultType *idResultType1,
2642 IdResult *idResult2,
2643 IdRef *operand1,
2644 IdRef *operand2)
2645 {
2646 spv::Op _op;
2647 uint32_t _length;
2648 GetInstructionOpAndLength(_instruction, &_op, &_length);
2649 ASSERT(_op == spv::OpBitwiseAnd);
2650 uint32_t _o = 1;
2651 *idResultType1 = IdResultType(_instruction[_o++]);
2652 *idResult2 = IdResult(_instruction[_o++]);
2653 *operand1 = IdRef(_instruction[_o++]);
2654 *operand2 = IdRef(_instruction[_o++]);
2655 }
ParseNot(const uint32_t * _instruction,IdResultType * idResultType1,IdResult * idResult2,IdRef * operand)2656 void ParseNot(const uint32_t *_instruction,
2657 IdResultType *idResultType1,
2658 IdResult *idResult2,
2659 IdRef *operand)
2660 {
2661 spv::Op _op;
2662 uint32_t _length;
2663 GetInstructionOpAndLength(_instruction, &_op, &_length);
2664 ASSERT(_op == spv::OpNot);
2665 uint32_t _o = 1;
2666 *idResultType1 = IdResultType(_instruction[_o++]);
2667 *idResult2 = IdResult(_instruction[_o++]);
2668 *operand = IdRef(_instruction[_o++]);
2669 }
ParseBitFieldInsert(const uint32_t * _instruction,IdResultType * idResultType1,IdResult * idResult2,IdRef * base,IdRef * insert,IdRef * offset,IdRef * count)2670 void ParseBitFieldInsert(const uint32_t *_instruction,
2671 IdResultType *idResultType1,
2672 IdResult *idResult2,
2673 IdRef *base,
2674 IdRef *insert,
2675 IdRef *offset,
2676 IdRef *count)
2677 {
2678 spv::Op _op;
2679 uint32_t _length;
2680 GetInstructionOpAndLength(_instruction, &_op, &_length);
2681 ASSERT(_op == spv::OpBitFieldInsert);
2682 uint32_t _o = 1;
2683 *idResultType1 = IdResultType(_instruction[_o++]);
2684 *idResult2 = IdResult(_instruction[_o++]);
2685 *base = IdRef(_instruction[_o++]);
2686 *insert = IdRef(_instruction[_o++]);
2687 *offset = IdRef(_instruction[_o++]);
2688 *count = IdRef(_instruction[_o++]);
2689 }
ParseBitFieldSExtract(const uint32_t * _instruction,IdResultType * idResultType1,IdResult * idResult2,IdRef * base,IdRef * offset,IdRef * count)2690 void ParseBitFieldSExtract(const uint32_t *_instruction,
2691 IdResultType *idResultType1,
2692 IdResult *idResult2,
2693 IdRef *base,
2694 IdRef *offset,
2695 IdRef *count)
2696 {
2697 spv::Op _op;
2698 uint32_t _length;
2699 GetInstructionOpAndLength(_instruction, &_op, &_length);
2700 ASSERT(_op == spv::OpBitFieldSExtract);
2701 uint32_t _o = 1;
2702 *idResultType1 = IdResultType(_instruction[_o++]);
2703 *idResult2 = IdResult(_instruction[_o++]);
2704 *base = IdRef(_instruction[_o++]);
2705 *offset = IdRef(_instruction[_o++]);
2706 *count = IdRef(_instruction[_o++]);
2707 }
ParseBitFieldUExtract(const uint32_t * _instruction,IdResultType * idResultType1,IdResult * idResult2,IdRef * base,IdRef * offset,IdRef * count)2708 void ParseBitFieldUExtract(const uint32_t *_instruction,
2709 IdResultType *idResultType1,
2710 IdResult *idResult2,
2711 IdRef *base,
2712 IdRef *offset,
2713 IdRef *count)
2714 {
2715 spv::Op _op;
2716 uint32_t _length;
2717 GetInstructionOpAndLength(_instruction, &_op, &_length);
2718 ASSERT(_op == spv::OpBitFieldUExtract);
2719 uint32_t _o = 1;
2720 *idResultType1 = IdResultType(_instruction[_o++]);
2721 *idResult2 = IdResult(_instruction[_o++]);
2722 *base = IdRef(_instruction[_o++]);
2723 *offset = IdRef(_instruction[_o++]);
2724 *count = IdRef(_instruction[_o++]);
2725 }
ParseBitReverse(const uint32_t * _instruction,IdResultType * idResultType1,IdResult * idResult2,IdRef * base)2726 void ParseBitReverse(const uint32_t *_instruction,
2727 IdResultType *idResultType1,
2728 IdResult *idResult2,
2729 IdRef *base)
2730 {
2731 spv::Op _op;
2732 uint32_t _length;
2733 GetInstructionOpAndLength(_instruction, &_op, &_length);
2734 ASSERT(_op == spv::OpBitReverse);
2735 uint32_t _o = 1;
2736 *idResultType1 = IdResultType(_instruction[_o++]);
2737 *idResult2 = IdResult(_instruction[_o++]);
2738 *base = IdRef(_instruction[_o++]);
2739 }
ParseBitCount(const uint32_t * _instruction,IdResultType * idResultType1,IdResult * idResult2,IdRef * base)2740 void ParseBitCount(const uint32_t *_instruction,
2741 IdResultType *idResultType1,
2742 IdResult *idResult2,
2743 IdRef *base)
2744 {
2745 spv::Op _op;
2746 uint32_t _length;
2747 GetInstructionOpAndLength(_instruction, &_op, &_length);
2748 ASSERT(_op == spv::OpBitCount);
2749 uint32_t _o = 1;
2750 *idResultType1 = IdResultType(_instruction[_o++]);
2751 *idResult2 = IdResult(_instruction[_o++]);
2752 *base = IdRef(_instruction[_o++]);
2753 }
ParseDPdx(const uint32_t * _instruction,IdResultType * idResultType1,IdResult * idResult2,IdRef * p)2754 void ParseDPdx(const uint32_t *_instruction,
2755 IdResultType *idResultType1,
2756 IdResult *idResult2,
2757 IdRef *p)
2758 {
2759 spv::Op _op;
2760 uint32_t _length;
2761 GetInstructionOpAndLength(_instruction, &_op, &_length);
2762 ASSERT(_op == spv::OpDPdx);
2763 uint32_t _o = 1;
2764 *idResultType1 = IdResultType(_instruction[_o++]);
2765 *idResult2 = IdResult(_instruction[_o++]);
2766 *p = IdRef(_instruction[_o++]);
2767 }
ParseDPdy(const uint32_t * _instruction,IdResultType * idResultType1,IdResult * idResult2,IdRef * p)2768 void ParseDPdy(const uint32_t *_instruction,
2769 IdResultType *idResultType1,
2770 IdResult *idResult2,
2771 IdRef *p)
2772 {
2773 spv::Op _op;
2774 uint32_t _length;
2775 GetInstructionOpAndLength(_instruction, &_op, &_length);
2776 ASSERT(_op == spv::OpDPdy);
2777 uint32_t _o = 1;
2778 *idResultType1 = IdResultType(_instruction[_o++]);
2779 *idResult2 = IdResult(_instruction[_o++]);
2780 *p = IdRef(_instruction[_o++]);
2781 }
ParseFwidth(const uint32_t * _instruction,IdResultType * idResultType1,IdResult * idResult2,IdRef * p)2782 void ParseFwidth(const uint32_t *_instruction,
2783 IdResultType *idResultType1,
2784 IdResult *idResult2,
2785 IdRef *p)
2786 {
2787 spv::Op _op;
2788 uint32_t _length;
2789 GetInstructionOpAndLength(_instruction, &_op, &_length);
2790 ASSERT(_op == spv::OpFwidth);
2791 uint32_t _o = 1;
2792 *idResultType1 = IdResultType(_instruction[_o++]);
2793 *idResult2 = IdResult(_instruction[_o++]);
2794 *p = IdRef(_instruction[_o++]);
2795 }
ParseDPdxFine(const uint32_t * _instruction,IdResultType * idResultType1,IdResult * idResult2,IdRef * p)2796 void ParseDPdxFine(const uint32_t *_instruction,
2797 IdResultType *idResultType1,
2798 IdResult *idResult2,
2799 IdRef *p)
2800 {
2801 spv::Op _op;
2802 uint32_t _length;
2803 GetInstructionOpAndLength(_instruction, &_op, &_length);
2804 ASSERT(_op == spv::OpDPdxFine);
2805 uint32_t _o = 1;
2806 *idResultType1 = IdResultType(_instruction[_o++]);
2807 *idResult2 = IdResult(_instruction[_o++]);
2808 *p = IdRef(_instruction[_o++]);
2809 }
ParseDPdyFine(const uint32_t * _instruction,IdResultType * idResultType1,IdResult * idResult2,IdRef * p)2810 void ParseDPdyFine(const uint32_t *_instruction,
2811 IdResultType *idResultType1,
2812 IdResult *idResult2,
2813 IdRef *p)
2814 {
2815 spv::Op _op;
2816 uint32_t _length;
2817 GetInstructionOpAndLength(_instruction, &_op, &_length);
2818 ASSERT(_op == spv::OpDPdyFine);
2819 uint32_t _o = 1;
2820 *idResultType1 = IdResultType(_instruction[_o++]);
2821 *idResult2 = IdResult(_instruction[_o++]);
2822 *p = IdRef(_instruction[_o++]);
2823 }
ParseFwidthFine(const uint32_t * _instruction,IdResultType * idResultType1,IdResult * idResult2,IdRef * p)2824 void ParseFwidthFine(const uint32_t *_instruction,
2825 IdResultType *idResultType1,
2826 IdResult *idResult2,
2827 IdRef *p)
2828 {
2829 spv::Op _op;
2830 uint32_t _length;
2831 GetInstructionOpAndLength(_instruction, &_op, &_length);
2832 ASSERT(_op == spv::OpFwidthFine);
2833 uint32_t _o = 1;
2834 *idResultType1 = IdResultType(_instruction[_o++]);
2835 *idResult2 = IdResult(_instruction[_o++]);
2836 *p = IdRef(_instruction[_o++]);
2837 }
ParseDPdxCoarse(const uint32_t * _instruction,IdResultType * idResultType1,IdResult * idResult2,IdRef * p)2838 void ParseDPdxCoarse(const uint32_t *_instruction,
2839 IdResultType *idResultType1,
2840 IdResult *idResult2,
2841 IdRef *p)
2842 {
2843 spv::Op _op;
2844 uint32_t _length;
2845 GetInstructionOpAndLength(_instruction, &_op, &_length);
2846 ASSERT(_op == spv::OpDPdxCoarse);
2847 uint32_t _o = 1;
2848 *idResultType1 = IdResultType(_instruction[_o++]);
2849 *idResult2 = IdResult(_instruction[_o++]);
2850 *p = IdRef(_instruction[_o++]);
2851 }
ParseDPdyCoarse(const uint32_t * _instruction,IdResultType * idResultType1,IdResult * idResult2,IdRef * p)2852 void ParseDPdyCoarse(const uint32_t *_instruction,
2853 IdResultType *idResultType1,
2854 IdResult *idResult2,
2855 IdRef *p)
2856 {
2857 spv::Op _op;
2858 uint32_t _length;
2859 GetInstructionOpAndLength(_instruction, &_op, &_length);
2860 ASSERT(_op == spv::OpDPdyCoarse);
2861 uint32_t _o = 1;
2862 *idResultType1 = IdResultType(_instruction[_o++]);
2863 *idResult2 = IdResult(_instruction[_o++]);
2864 *p = IdRef(_instruction[_o++]);
2865 }
ParseFwidthCoarse(const uint32_t * _instruction,IdResultType * idResultType1,IdResult * idResult2,IdRef * p)2866 void ParseFwidthCoarse(const uint32_t *_instruction,
2867 IdResultType *idResultType1,
2868 IdResult *idResult2,
2869 IdRef *p)
2870 {
2871 spv::Op _op;
2872 uint32_t _length;
2873 GetInstructionOpAndLength(_instruction, &_op, &_length);
2874 ASSERT(_op == spv::OpFwidthCoarse);
2875 uint32_t _o = 1;
2876 *idResultType1 = IdResultType(_instruction[_o++]);
2877 *idResult2 = IdResult(_instruction[_o++]);
2878 *p = IdRef(_instruction[_o++]);
2879 }
ParseEmitStreamVertex(const uint32_t * _instruction,IdRef * stream)2880 void ParseEmitStreamVertex(const uint32_t *_instruction, IdRef *stream)
2881 {
2882 spv::Op _op;
2883 uint32_t _length;
2884 GetInstructionOpAndLength(_instruction, &_op, &_length);
2885 ASSERT(_op == spv::OpEmitStreamVertex);
2886 uint32_t _o = 1;
2887 *stream = IdRef(_instruction[_o++]);
2888 }
ParseEndStreamPrimitive(const uint32_t * _instruction,IdRef * stream)2889 void ParseEndStreamPrimitive(const uint32_t *_instruction, IdRef *stream)
2890 {
2891 spv::Op _op;
2892 uint32_t _length;
2893 GetInstructionOpAndLength(_instruction, &_op, &_length);
2894 ASSERT(_op == spv::OpEndStreamPrimitive);
2895 uint32_t _o = 1;
2896 *stream = IdRef(_instruction[_o++]);
2897 }
ParseControlBarrier(const uint32_t * _instruction,IdScope * execution,IdScope * memory,IdMemorySemantics * semantics)2898 void ParseControlBarrier(const uint32_t *_instruction,
2899 IdScope *execution,
2900 IdScope *memory,
2901 IdMemorySemantics *semantics)
2902 {
2903 spv::Op _op;
2904 uint32_t _length;
2905 GetInstructionOpAndLength(_instruction, &_op, &_length);
2906 ASSERT(_op == spv::OpControlBarrier);
2907 uint32_t _o = 1;
2908 *execution = IdScope(_instruction[_o++]);
2909 *memory = IdScope(_instruction[_o++]);
2910 *semantics = IdMemorySemantics(_instruction[_o++]);
2911 }
ParseMemoryBarrier(const uint32_t * _instruction,IdScope * memory,IdMemorySemantics * semantics)2912 void ParseMemoryBarrier(const uint32_t *_instruction, IdScope *memory, IdMemorySemantics *semantics)
2913 {
2914 spv::Op _op;
2915 uint32_t _length;
2916 GetInstructionOpAndLength(_instruction, &_op, &_length);
2917 ASSERT(_op == spv::OpMemoryBarrier);
2918 uint32_t _o = 1;
2919 *memory = IdScope(_instruction[_o++]);
2920 *semantics = IdMemorySemantics(_instruction[_o++]);
2921 }
ParseAtomicLoad(const uint32_t * _instruction,IdResultType * idResultType1,IdResult * idResult2,IdRef * pointer,IdScope * memory,IdMemorySemantics * semantics)2922 void ParseAtomicLoad(const uint32_t *_instruction,
2923 IdResultType *idResultType1,
2924 IdResult *idResult2,
2925 IdRef *pointer,
2926 IdScope *memory,
2927 IdMemorySemantics *semantics)
2928 {
2929 spv::Op _op;
2930 uint32_t _length;
2931 GetInstructionOpAndLength(_instruction, &_op, &_length);
2932 ASSERT(_op == spv::OpAtomicLoad);
2933 uint32_t _o = 1;
2934 *idResultType1 = IdResultType(_instruction[_o++]);
2935 *idResult2 = IdResult(_instruction[_o++]);
2936 *pointer = IdRef(_instruction[_o++]);
2937 *memory = IdScope(_instruction[_o++]);
2938 *semantics = IdMemorySemantics(_instruction[_o++]);
2939 }
ParseAtomicStore(const uint32_t * _instruction,IdRef * pointer,IdScope * memory,IdMemorySemantics * semantics,IdRef * value)2940 void ParseAtomicStore(const uint32_t *_instruction,
2941 IdRef *pointer,
2942 IdScope *memory,
2943 IdMemorySemantics *semantics,
2944 IdRef *value)
2945 {
2946 spv::Op _op;
2947 uint32_t _length;
2948 GetInstructionOpAndLength(_instruction, &_op, &_length);
2949 ASSERT(_op == spv::OpAtomicStore);
2950 uint32_t _o = 1;
2951 *pointer = IdRef(_instruction[_o++]);
2952 *memory = IdScope(_instruction[_o++]);
2953 *semantics = IdMemorySemantics(_instruction[_o++]);
2954 *value = IdRef(_instruction[_o++]);
2955 }
ParseAtomicExchange(const uint32_t * _instruction,IdResultType * idResultType1,IdResult * idResult2,IdRef * pointer,IdScope * memory,IdMemorySemantics * semantics,IdRef * value)2956 void ParseAtomicExchange(const uint32_t *_instruction,
2957 IdResultType *idResultType1,
2958 IdResult *idResult2,
2959 IdRef *pointer,
2960 IdScope *memory,
2961 IdMemorySemantics *semantics,
2962 IdRef *value)
2963 {
2964 spv::Op _op;
2965 uint32_t _length;
2966 GetInstructionOpAndLength(_instruction, &_op, &_length);
2967 ASSERT(_op == spv::OpAtomicExchange);
2968 uint32_t _o = 1;
2969 *idResultType1 = IdResultType(_instruction[_o++]);
2970 *idResult2 = IdResult(_instruction[_o++]);
2971 *pointer = IdRef(_instruction[_o++]);
2972 *memory = IdScope(_instruction[_o++]);
2973 *semantics = IdMemorySemantics(_instruction[_o++]);
2974 *value = IdRef(_instruction[_o++]);
2975 }
ParseAtomicCompareExchange(const uint32_t * _instruction,IdResultType * idResultType1,IdResult * idResult2,IdRef * pointer,IdScope * memory,IdMemorySemantics * equal,IdMemorySemantics * unequal,IdRef * value,IdRef * comparator)2976 void ParseAtomicCompareExchange(const uint32_t *_instruction,
2977 IdResultType *idResultType1,
2978 IdResult *idResult2,
2979 IdRef *pointer,
2980 IdScope *memory,
2981 IdMemorySemantics *equal,
2982 IdMemorySemantics *unequal,
2983 IdRef *value,
2984 IdRef *comparator)
2985 {
2986 spv::Op _op;
2987 uint32_t _length;
2988 GetInstructionOpAndLength(_instruction, &_op, &_length);
2989 ASSERT(_op == spv::OpAtomicCompareExchange);
2990 uint32_t _o = 1;
2991 *idResultType1 = IdResultType(_instruction[_o++]);
2992 *idResult2 = IdResult(_instruction[_o++]);
2993 *pointer = IdRef(_instruction[_o++]);
2994 *memory = IdScope(_instruction[_o++]);
2995 *equal = IdMemorySemantics(_instruction[_o++]);
2996 *unequal = IdMemorySemantics(_instruction[_o++]);
2997 *value = IdRef(_instruction[_o++]);
2998 *comparator = IdRef(_instruction[_o++]);
2999 }
ParseAtomicIIncrement(const uint32_t * _instruction,IdResultType * idResultType1,IdResult * idResult2,IdRef * pointer,IdScope * memory,IdMemorySemantics * semantics)3000 void ParseAtomicIIncrement(const uint32_t *_instruction,
3001 IdResultType *idResultType1,
3002 IdResult *idResult2,
3003 IdRef *pointer,
3004 IdScope *memory,
3005 IdMemorySemantics *semantics)
3006 {
3007 spv::Op _op;
3008 uint32_t _length;
3009 GetInstructionOpAndLength(_instruction, &_op, &_length);
3010 ASSERT(_op == spv::OpAtomicIIncrement);
3011 uint32_t _o = 1;
3012 *idResultType1 = IdResultType(_instruction[_o++]);
3013 *idResult2 = IdResult(_instruction[_o++]);
3014 *pointer = IdRef(_instruction[_o++]);
3015 *memory = IdScope(_instruction[_o++]);
3016 *semantics = IdMemorySemantics(_instruction[_o++]);
3017 }
ParseAtomicIDecrement(const uint32_t * _instruction,IdResultType * idResultType1,IdResult * idResult2,IdRef * pointer,IdScope * memory,IdMemorySemantics * semantics)3018 void ParseAtomicIDecrement(const uint32_t *_instruction,
3019 IdResultType *idResultType1,
3020 IdResult *idResult2,
3021 IdRef *pointer,
3022 IdScope *memory,
3023 IdMemorySemantics *semantics)
3024 {
3025 spv::Op _op;
3026 uint32_t _length;
3027 GetInstructionOpAndLength(_instruction, &_op, &_length);
3028 ASSERT(_op == spv::OpAtomicIDecrement);
3029 uint32_t _o = 1;
3030 *idResultType1 = IdResultType(_instruction[_o++]);
3031 *idResult2 = IdResult(_instruction[_o++]);
3032 *pointer = IdRef(_instruction[_o++]);
3033 *memory = IdScope(_instruction[_o++]);
3034 *semantics = IdMemorySemantics(_instruction[_o++]);
3035 }
ParseAtomicIAdd(const uint32_t * _instruction,IdResultType * idResultType1,IdResult * idResult2,IdRef * pointer,IdScope * memory,IdMemorySemantics * semantics,IdRef * value)3036 void ParseAtomicIAdd(const uint32_t *_instruction,
3037 IdResultType *idResultType1,
3038 IdResult *idResult2,
3039 IdRef *pointer,
3040 IdScope *memory,
3041 IdMemorySemantics *semantics,
3042 IdRef *value)
3043 {
3044 spv::Op _op;
3045 uint32_t _length;
3046 GetInstructionOpAndLength(_instruction, &_op, &_length);
3047 ASSERT(_op == spv::OpAtomicIAdd);
3048 uint32_t _o = 1;
3049 *idResultType1 = IdResultType(_instruction[_o++]);
3050 *idResult2 = IdResult(_instruction[_o++]);
3051 *pointer = IdRef(_instruction[_o++]);
3052 *memory = IdScope(_instruction[_o++]);
3053 *semantics = IdMemorySemantics(_instruction[_o++]);
3054 *value = IdRef(_instruction[_o++]);
3055 }
ParseAtomicISub(const uint32_t * _instruction,IdResultType * idResultType1,IdResult * idResult2,IdRef * pointer,IdScope * memory,IdMemorySemantics * semantics,IdRef * value)3056 void ParseAtomicISub(const uint32_t *_instruction,
3057 IdResultType *idResultType1,
3058 IdResult *idResult2,
3059 IdRef *pointer,
3060 IdScope *memory,
3061 IdMemorySemantics *semantics,
3062 IdRef *value)
3063 {
3064 spv::Op _op;
3065 uint32_t _length;
3066 GetInstructionOpAndLength(_instruction, &_op, &_length);
3067 ASSERT(_op == spv::OpAtomicISub);
3068 uint32_t _o = 1;
3069 *idResultType1 = IdResultType(_instruction[_o++]);
3070 *idResult2 = IdResult(_instruction[_o++]);
3071 *pointer = IdRef(_instruction[_o++]);
3072 *memory = IdScope(_instruction[_o++]);
3073 *semantics = IdMemorySemantics(_instruction[_o++]);
3074 *value = IdRef(_instruction[_o++]);
3075 }
ParseAtomicSMin(const uint32_t * _instruction,IdResultType * idResultType1,IdResult * idResult2,IdRef * pointer,IdScope * memory,IdMemorySemantics * semantics,IdRef * value)3076 void ParseAtomicSMin(const uint32_t *_instruction,
3077 IdResultType *idResultType1,
3078 IdResult *idResult2,
3079 IdRef *pointer,
3080 IdScope *memory,
3081 IdMemorySemantics *semantics,
3082 IdRef *value)
3083 {
3084 spv::Op _op;
3085 uint32_t _length;
3086 GetInstructionOpAndLength(_instruction, &_op, &_length);
3087 ASSERT(_op == spv::OpAtomicSMin);
3088 uint32_t _o = 1;
3089 *idResultType1 = IdResultType(_instruction[_o++]);
3090 *idResult2 = IdResult(_instruction[_o++]);
3091 *pointer = IdRef(_instruction[_o++]);
3092 *memory = IdScope(_instruction[_o++]);
3093 *semantics = IdMemorySemantics(_instruction[_o++]);
3094 *value = IdRef(_instruction[_o++]);
3095 }
ParseAtomicUMin(const uint32_t * _instruction,IdResultType * idResultType1,IdResult * idResult2,IdRef * pointer,IdScope * memory,IdMemorySemantics * semantics,IdRef * value)3096 void ParseAtomicUMin(const uint32_t *_instruction,
3097 IdResultType *idResultType1,
3098 IdResult *idResult2,
3099 IdRef *pointer,
3100 IdScope *memory,
3101 IdMemorySemantics *semantics,
3102 IdRef *value)
3103 {
3104 spv::Op _op;
3105 uint32_t _length;
3106 GetInstructionOpAndLength(_instruction, &_op, &_length);
3107 ASSERT(_op == spv::OpAtomicUMin);
3108 uint32_t _o = 1;
3109 *idResultType1 = IdResultType(_instruction[_o++]);
3110 *idResult2 = IdResult(_instruction[_o++]);
3111 *pointer = IdRef(_instruction[_o++]);
3112 *memory = IdScope(_instruction[_o++]);
3113 *semantics = IdMemorySemantics(_instruction[_o++]);
3114 *value = IdRef(_instruction[_o++]);
3115 }
ParseAtomicSMax(const uint32_t * _instruction,IdResultType * idResultType1,IdResult * idResult2,IdRef * pointer,IdScope * memory,IdMemorySemantics * semantics,IdRef * value)3116 void ParseAtomicSMax(const uint32_t *_instruction,
3117 IdResultType *idResultType1,
3118 IdResult *idResult2,
3119 IdRef *pointer,
3120 IdScope *memory,
3121 IdMemorySemantics *semantics,
3122 IdRef *value)
3123 {
3124 spv::Op _op;
3125 uint32_t _length;
3126 GetInstructionOpAndLength(_instruction, &_op, &_length);
3127 ASSERT(_op == spv::OpAtomicSMax);
3128 uint32_t _o = 1;
3129 *idResultType1 = IdResultType(_instruction[_o++]);
3130 *idResult2 = IdResult(_instruction[_o++]);
3131 *pointer = IdRef(_instruction[_o++]);
3132 *memory = IdScope(_instruction[_o++]);
3133 *semantics = IdMemorySemantics(_instruction[_o++]);
3134 *value = IdRef(_instruction[_o++]);
3135 }
ParseAtomicUMax(const uint32_t * _instruction,IdResultType * idResultType1,IdResult * idResult2,IdRef * pointer,IdScope * memory,IdMemorySemantics * semantics,IdRef * value)3136 void ParseAtomicUMax(const uint32_t *_instruction,
3137 IdResultType *idResultType1,
3138 IdResult *idResult2,
3139 IdRef *pointer,
3140 IdScope *memory,
3141 IdMemorySemantics *semantics,
3142 IdRef *value)
3143 {
3144 spv::Op _op;
3145 uint32_t _length;
3146 GetInstructionOpAndLength(_instruction, &_op, &_length);
3147 ASSERT(_op == spv::OpAtomicUMax);
3148 uint32_t _o = 1;
3149 *idResultType1 = IdResultType(_instruction[_o++]);
3150 *idResult2 = IdResult(_instruction[_o++]);
3151 *pointer = IdRef(_instruction[_o++]);
3152 *memory = IdScope(_instruction[_o++]);
3153 *semantics = IdMemorySemantics(_instruction[_o++]);
3154 *value = IdRef(_instruction[_o++]);
3155 }
ParseAtomicAnd(const uint32_t * _instruction,IdResultType * idResultType1,IdResult * idResult2,IdRef * pointer,IdScope * memory,IdMemorySemantics * semantics,IdRef * value)3156 void ParseAtomicAnd(const uint32_t *_instruction,
3157 IdResultType *idResultType1,
3158 IdResult *idResult2,
3159 IdRef *pointer,
3160 IdScope *memory,
3161 IdMemorySemantics *semantics,
3162 IdRef *value)
3163 {
3164 spv::Op _op;
3165 uint32_t _length;
3166 GetInstructionOpAndLength(_instruction, &_op, &_length);
3167 ASSERT(_op == spv::OpAtomicAnd);
3168 uint32_t _o = 1;
3169 *idResultType1 = IdResultType(_instruction[_o++]);
3170 *idResult2 = IdResult(_instruction[_o++]);
3171 *pointer = IdRef(_instruction[_o++]);
3172 *memory = IdScope(_instruction[_o++]);
3173 *semantics = IdMemorySemantics(_instruction[_o++]);
3174 *value = IdRef(_instruction[_o++]);
3175 }
ParseAtomicOr(const uint32_t * _instruction,IdResultType * idResultType1,IdResult * idResult2,IdRef * pointer,IdScope * memory,IdMemorySemantics * semantics,IdRef * value)3176 void ParseAtomicOr(const uint32_t *_instruction,
3177 IdResultType *idResultType1,
3178 IdResult *idResult2,
3179 IdRef *pointer,
3180 IdScope *memory,
3181 IdMemorySemantics *semantics,
3182 IdRef *value)
3183 {
3184 spv::Op _op;
3185 uint32_t _length;
3186 GetInstructionOpAndLength(_instruction, &_op, &_length);
3187 ASSERT(_op == spv::OpAtomicOr);
3188 uint32_t _o = 1;
3189 *idResultType1 = IdResultType(_instruction[_o++]);
3190 *idResult2 = IdResult(_instruction[_o++]);
3191 *pointer = IdRef(_instruction[_o++]);
3192 *memory = IdScope(_instruction[_o++]);
3193 *semantics = IdMemorySemantics(_instruction[_o++]);
3194 *value = IdRef(_instruction[_o++]);
3195 }
ParseAtomicXor(const uint32_t * _instruction,IdResultType * idResultType1,IdResult * idResult2,IdRef * pointer,IdScope * memory,IdMemorySemantics * semantics,IdRef * value)3196 void ParseAtomicXor(const uint32_t *_instruction,
3197 IdResultType *idResultType1,
3198 IdResult *idResult2,
3199 IdRef *pointer,
3200 IdScope *memory,
3201 IdMemorySemantics *semantics,
3202 IdRef *value)
3203 {
3204 spv::Op _op;
3205 uint32_t _length;
3206 GetInstructionOpAndLength(_instruction, &_op, &_length);
3207 ASSERT(_op == spv::OpAtomicXor);
3208 uint32_t _o = 1;
3209 *idResultType1 = IdResultType(_instruction[_o++]);
3210 *idResult2 = IdResult(_instruction[_o++]);
3211 *pointer = IdRef(_instruction[_o++]);
3212 *memory = IdScope(_instruction[_o++]);
3213 *semantics = IdMemorySemantics(_instruction[_o++]);
3214 *value = IdRef(_instruction[_o++]);
3215 }
ParsePhi(const uint32_t * _instruction,IdResultType * idResultType1,IdResult * idResult2,PairIdRefIdRefList * variableParentPairList)3216 void ParsePhi(const uint32_t *_instruction,
3217 IdResultType *idResultType1,
3218 IdResult *idResult2,
3219 PairIdRefIdRefList *variableParentPairList)
3220 {
3221 spv::Op _op;
3222 uint32_t _length;
3223 GetInstructionOpAndLength(_instruction, &_op, &_length);
3224 ASSERT(_op == spv::OpPhi);
3225 uint32_t _o = 1;
3226 *idResultType1 = IdResultType(_instruction[_o++]);
3227 *idResult2 = IdResult(_instruction[_o++]);
3228 if (variableParentPairList)
3229 {
3230 while (_o < _length)
3231 {
3232 variableParentPairList->emplace_back(
3233 PairIdRefIdRef{IdRef(_instruction[_o]), IdRef(_instruction[_o + 1])});
3234 _o += 2;
3235 }
3236 }
3237 }
ParseLoopMerge(const uint32_t * _instruction,IdRef * mergeBlock,IdRef * continueTarget,spv::LoopControlMask * loopControl3)3238 void ParseLoopMerge(const uint32_t *_instruction,
3239 IdRef *mergeBlock,
3240 IdRef *continueTarget,
3241 spv::LoopControlMask *loopControl3)
3242 {
3243 spv::Op _op;
3244 uint32_t _length;
3245 GetInstructionOpAndLength(_instruction, &_op, &_length);
3246 ASSERT(_op == spv::OpLoopMerge);
3247 uint32_t _o = 1;
3248 *mergeBlock = IdRef(_instruction[_o++]);
3249 *continueTarget = IdRef(_instruction[_o++]);
3250 *loopControl3 = spv::LoopControlMask(_instruction[_o++]);
3251 }
ParseSelectionMerge(const uint32_t * _instruction,IdRef * mergeBlock,spv::SelectionControlMask * selectionControl2)3252 void ParseSelectionMerge(const uint32_t *_instruction,
3253 IdRef *mergeBlock,
3254 spv::SelectionControlMask *selectionControl2)
3255 {
3256 spv::Op _op;
3257 uint32_t _length;
3258 GetInstructionOpAndLength(_instruction, &_op, &_length);
3259 ASSERT(_op == spv::OpSelectionMerge);
3260 uint32_t _o = 1;
3261 *mergeBlock = IdRef(_instruction[_o++]);
3262 *selectionControl2 = spv::SelectionControlMask(_instruction[_o++]);
3263 }
ParseLabel(const uint32_t * _instruction,IdResult * idResult1)3264 void ParseLabel(const uint32_t *_instruction, IdResult *idResult1)
3265 {
3266 spv::Op _op;
3267 uint32_t _length;
3268 GetInstructionOpAndLength(_instruction, &_op, &_length);
3269 ASSERT(_op == spv::OpLabel);
3270 uint32_t _o = 1;
3271 *idResult1 = IdResult(_instruction[_o++]);
3272 }
ParseBranch(const uint32_t * _instruction,IdRef * targetLabel)3273 void ParseBranch(const uint32_t *_instruction, IdRef *targetLabel)
3274 {
3275 spv::Op _op;
3276 uint32_t _length;
3277 GetInstructionOpAndLength(_instruction, &_op, &_length);
3278 ASSERT(_op == spv::OpBranch);
3279 uint32_t _o = 1;
3280 *targetLabel = IdRef(_instruction[_o++]);
3281 }
ParseBranchConditional(const uint32_t * _instruction,IdRef * condition,IdRef * trueLabel,IdRef * falseLabel,LiteralIntegerList * branchweightsList)3282 void ParseBranchConditional(const uint32_t *_instruction,
3283 IdRef *condition,
3284 IdRef *trueLabel,
3285 IdRef *falseLabel,
3286 LiteralIntegerList *branchweightsList)
3287 {
3288 spv::Op _op;
3289 uint32_t _length;
3290 GetInstructionOpAndLength(_instruction, &_op, &_length);
3291 ASSERT(_op == spv::OpBranchConditional);
3292 uint32_t _o = 1;
3293 *condition = IdRef(_instruction[_o++]);
3294 *trueLabel = IdRef(_instruction[_o++]);
3295 *falseLabel = IdRef(_instruction[_o++]);
3296 if (branchweightsList)
3297 {
3298 while (_o < _length)
3299 {
3300 branchweightsList->emplace_back(_instruction[_o++]);
3301 }
3302 }
3303 }
ParseSwitch(const uint32_t * _instruction,IdRef * selector,IdRef * default_,PairLiteralIntegerIdRefList * targetPairList)3304 void ParseSwitch(const uint32_t *_instruction,
3305 IdRef *selector,
3306 IdRef *default_,
3307 PairLiteralIntegerIdRefList *targetPairList)
3308 {
3309 spv::Op _op;
3310 uint32_t _length;
3311 GetInstructionOpAndLength(_instruction, &_op, &_length);
3312 ASSERT(_op == spv::OpSwitch);
3313 uint32_t _o = 1;
3314 *selector = IdRef(_instruction[_o++]);
3315 *default_ = IdRef(_instruction[_o++]);
3316 if (targetPairList)
3317 {
3318 while (_o < _length)
3319 {
3320 targetPairList->emplace_back(PairLiteralIntegerIdRef{LiteralInteger(_instruction[_o]),
3321 IdRef(_instruction[_o + 1])});
3322 _o += 2;
3323 }
3324 }
3325 }
ParseReturnValue(const uint32_t * _instruction,IdRef * value)3326 void ParseReturnValue(const uint32_t *_instruction, IdRef *value)
3327 {
3328 spv::Op _op;
3329 uint32_t _length;
3330 GetInstructionOpAndLength(_instruction, &_op, &_length);
3331 ASSERT(_op == spv::OpReturnValue);
3332 uint32_t _o = 1;
3333 *value = IdRef(_instruction[_o++]);
3334 }
ParseImageSparseSampleImplicitLod(const uint32_t * _instruction,IdResultType * idResultType1,IdResult * idResult2,IdRef * sampledImage,IdRef * coordinate,spv::ImageOperandsMask * imageOperands5,IdRefList * imageOperandIdsList)3335 void ParseImageSparseSampleImplicitLod(const uint32_t *_instruction,
3336 IdResultType *idResultType1,
3337 IdResult *idResult2,
3338 IdRef *sampledImage,
3339 IdRef *coordinate,
3340 spv::ImageOperandsMask *imageOperands5,
3341 IdRefList *imageOperandIdsList)
3342 {
3343 spv::Op _op;
3344 uint32_t _length;
3345 GetInstructionOpAndLength(_instruction, &_op, &_length);
3346 ASSERT(_op == spv::OpImageSparseSampleImplicitLod);
3347 uint32_t _o = 1;
3348 *idResultType1 = IdResultType(_instruction[_o++]);
3349 *idResult2 = IdResult(_instruction[_o++]);
3350 *sampledImage = IdRef(_instruction[_o++]);
3351 *coordinate = IdRef(_instruction[_o++]);
3352 if (imageOperands5 && _o < _length)
3353 {
3354 *imageOperands5 = spv::ImageOperandsMask(_instruction[_o++]);
3355 }
3356 if (imageOperandIdsList)
3357 {
3358 while (_o < _length)
3359 {
3360 imageOperandIdsList->emplace_back(_instruction[_o++]);
3361 }
3362 }
3363 }
ParseImageSparseSampleExplicitLod(const uint32_t * _instruction,IdResultType * idResultType1,IdResult * idResult2,IdRef * sampledImage,IdRef * coordinate,spv::ImageOperandsMask * imageOperands5,IdRefList * imageOperandIdsList)3364 void ParseImageSparseSampleExplicitLod(const uint32_t *_instruction,
3365 IdResultType *idResultType1,
3366 IdResult *idResult2,
3367 IdRef *sampledImage,
3368 IdRef *coordinate,
3369 spv::ImageOperandsMask *imageOperands5,
3370 IdRefList *imageOperandIdsList)
3371 {
3372 spv::Op _op;
3373 uint32_t _length;
3374 GetInstructionOpAndLength(_instruction, &_op, &_length);
3375 ASSERT(_op == spv::OpImageSparseSampleExplicitLod);
3376 uint32_t _o = 1;
3377 *idResultType1 = IdResultType(_instruction[_o++]);
3378 *idResult2 = IdResult(_instruction[_o++]);
3379 *sampledImage = IdRef(_instruction[_o++]);
3380 *coordinate = IdRef(_instruction[_o++]);
3381 *imageOperands5 = spv::ImageOperandsMask(_instruction[_o++]);
3382 if (imageOperandIdsList)
3383 {
3384 while (_o < _length)
3385 {
3386 imageOperandIdsList->emplace_back(_instruction[_o++]);
3387 }
3388 }
3389 }
ParseImageSparseSampleDrefImplicitLod(const uint32_t * _instruction,IdResultType * idResultType1,IdResult * idResult2,IdRef * sampledImage,IdRef * coordinate,IdRef * dref,spv::ImageOperandsMask * imageOperands6,IdRefList * imageOperandIdsList)3390 void ParseImageSparseSampleDrefImplicitLod(const uint32_t *_instruction,
3391 IdResultType *idResultType1,
3392 IdResult *idResult2,
3393 IdRef *sampledImage,
3394 IdRef *coordinate,
3395 IdRef *dref,
3396 spv::ImageOperandsMask *imageOperands6,
3397 IdRefList *imageOperandIdsList)
3398 {
3399 spv::Op _op;
3400 uint32_t _length;
3401 GetInstructionOpAndLength(_instruction, &_op, &_length);
3402 ASSERT(_op == spv::OpImageSparseSampleDrefImplicitLod);
3403 uint32_t _o = 1;
3404 *idResultType1 = IdResultType(_instruction[_o++]);
3405 *idResult2 = IdResult(_instruction[_o++]);
3406 *sampledImage = IdRef(_instruction[_o++]);
3407 *coordinate = IdRef(_instruction[_o++]);
3408 *dref = IdRef(_instruction[_o++]);
3409 if (imageOperands6 && _o < _length)
3410 {
3411 *imageOperands6 = spv::ImageOperandsMask(_instruction[_o++]);
3412 }
3413 if (imageOperandIdsList)
3414 {
3415 while (_o < _length)
3416 {
3417 imageOperandIdsList->emplace_back(_instruction[_o++]);
3418 }
3419 }
3420 }
ParseImageSparseSampleDrefExplicitLod(const uint32_t * _instruction,IdResultType * idResultType1,IdResult * idResult2,IdRef * sampledImage,IdRef * coordinate,IdRef * dref,spv::ImageOperandsMask * imageOperands6,IdRefList * imageOperandIdsList)3421 void ParseImageSparseSampleDrefExplicitLod(const uint32_t *_instruction,
3422 IdResultType *idResultType1,
3423 IdResult *idResult2,
3424 IdRef *sampledImage,
3425 IdRef *coordinate,
3426 IdRef *dref,
3427 spv::ImageOperandsMask *imageOperands6,
3428 IdRefList *imageOperandIdsList)
3429 {
3430 spv::Op _op;
3431 uint32_t _length;
3432 GetInstructionOpAndLength(_instruction, &_op, &_length);
3433 ASSERT(_op == spv::OpImageSparseSampleDrefExplicitLod);
3434 uint32_t _o = 1;
3435 *idResultType1 = IdResultType(_instruction[_o++]);
3436 *idResult2 = IdResult(_instruction[_o++]);
3437 *sampledImage = IdRef(_instruction[_o++]);
3438 *coordinate = IdRef(_instruction[_o++]);
3439 *dref = IdRef(_instruction[_o++]);
3440 *imageOperands6 = spv::ImageOperandsMask(_instruction[_o++]);
3441 if (imageOperandIdsList)
3442 {
3443 while (_o < _length)
3444 {
3445 imageOperandIdsList->emplace_back(_instruction[_o++]);
3446 }
3447 }
3448 }
ParseImageSparseSampleProjImplicitLod(const uint32_t * _instruction,IdResultType * idResultType1,IdResult * idResult2,IdRef * sampledImage,IdRef * coordinate,spv::ImageOperandsMask * imageOperands5,IdRefList * imageOperandIdsList)3449 void ParseImageSparseSampleProjImplicitLod(const uint32_t *_instruction,
3450 IdResultType *idResultType1,
3451 IdResult *idResult2,
3452 IdRef *sampledImage,
3453 IdRef *coordinate,
3454 spv::ImageOperandsMask *imageOperands5,
3455 IdRefList *imageOperandIdsList)
3456 {
3457 spv::Op _op;
3458 uint32_t _length;
3459 GetInstructionOpAndLength(_instruction, &_op, &_length);
3460 ASSERT(_op == spv::OpImageSparseSampleProjImplicitLod);
3461 uint32_t _o = 1;
3462 *idResultType1 = IdResultType(_instruction[_o++]);
3463 *idResult2 = IdResult(_instruction[_o++]);
3464 *sampledImage = IdRef(_instruction[_o++]);
3465 *coordinate = IdRef(_instruction[_o++]);
3466 if (imageOperands5 && _o < _length)
3467 {
3468 *imageOperands5 = spv::ImageOperandsMask(_instruction[_o++]);
3469 }
3470 if (imageOperandIdsList)
3471 {
3472 while (_o < _length)
3473 {
3474 imageOperandIdsList->emplace_back(_instruction[_o++]);
3475 }
3476 }
3477 }
ParseImageSparseSampleProjExplicitLod(const uint32_t * _instruction,IdResultType * idResultType1,IdResult * idResult2,IdRef * sampledImage,IdRef * coordinate,spv::ImageOperandsMask * imageOperands5,IdRefList * imageOperandIdsList)3478 void ParseImageSparseSampleProjExplicitLod(const uint32_t *_instruction,
3479 IdResultType *idResultType1,
3480 IdResult *idResult2,
3481 IdRef *sampledImage,
3482 IdRef *coordinate,
3483 spv::ImageOperandsMask *imageOperands5,
3484 IdRefList *imageOperandIdsList)
3485 {
3486 spv::Op _op;
3487 uint32_t _length;
3488 GetInstructionOpAndLength(_instruction, &_op, &_length);
3489 ASSERT(_op == spv::OpImageSparseSampleProjExplicitLod);
3490 uint32_t _o = 1;
3491 *idResultType1 = IdResultType(_instruction[_o++]);
3492 *idResult2 = IdResult(_instruction[_o++]);
3493 *sampledImage = IdRef(_instruction[_o++]);
3494 *coordinate = IdRef(_instruction[_o++]);
3495 *imageOperands5 = spv::ImageOperandsMask(_instruction[_o++]);
3496 if (imageOperandIdsList)
3497 {
3498 while (_o < _length)
3499 {
3500 imageOperandIdsList->emplace_back(_instruction[_o++]);
3501 }
3502 }
3503 }
ParseImageSparseSampleProjDrefImplicitLod(const uint32_t * _instruction,IdResultType * idResultType1,IdResult * idResult2,IdRef * sampledImage,IdRef * coordinate,IdRef * dref,spv::ImageOperandsMask * imageOperands6,IdRefList * imageOperandIdsList)3504 void ParseImageSparseSampleProjDrefImplicitLod(const uint32_t *_instruction,
3505 IdResultType *idResultType1,
3506 IdResult *idResult2,
3507 IdRef *sampledImage,
3508 IdRef *coordinate,
3509 IdRef *dref,
3510 spv::ImageOperandsMask *imageOperands6,
3511 IdRefList *imageOperandIdsList)
3512 {
3513 spv::Op _op;
3514 uint32_t _length;
3515 GetInstructionOpAndLength(_instruction, &_op, &_length);
3516 ASSERT(_op == spv::OpImageSparseSampleProjDrefImplicitLod);
3517 uint32_t _o = 1;
3518 *idResultType1 = IdResultType(_instruction[_o++]);
3519 *idResult2 = IdResult(_instruction[_o++]);
3520 *sampledImage = IdRef(_instruction[_o++]);
3521 *coordinate = IdRef(_instruction[_o++]);
3522 *dref = IdRef(_instruction[_o++]);
3523 if (imageOperands6 && _o < _length)
3524 {
3525 *imageOperands6 = spv::ImageOperandsMask(_instruction[_o++]);
3526 }
3527 if (imageOperandIdsList)
3528 {
3529 while (_o < _length)
3530 {
3531 imageOperandIdsList->emplace_back(_instruction[_o++]);
3532 }
3533 }
3534 }
ParseImageSparseSampleProjDrefExplicitLod(const uint32_t * _instruction,IdResultType * idResultType1,IdResult * idResult2,IdRef * sampledImage,IdRef * coordinate,IdRef * dref,spv::ImageOperandsMask * imageOperands6,IdRefList * imageOperandIdsList)3535 void ParseImageSparseSampleProjDrefExplicitLod(const uint32_t *_instruction,
3536 IdResultType *idResultType1,
3537 IdResult *idResult2,
3538 IdRef *sampledImage,
3539 IdRef *coordinate,
3540 IdRef *dref,
3541 spv::ImageOperandsMask *imageOperands6,
3542 IdRefList *imageOperandIdsList)
3543 {
3544 spv::Op _op;
3545 uint32_t _length;
3546 GetInstructionOpAndLength(_instruction, &_op, &_length);
3547 ASSERT(_op == spv::OpImageSparseSampleProjDrefExplicitLod);
3548 uint32_t _o = 1;
3549 *idResultType1 = IdResultType(_instruction[_o++]);
3550 *idResult2 = IdResult(_instruction[_o++]);
3551 *sampledImage = IdRef(_instruction[_o++]);
3552 *coordinate = IdRef(_instruction[_o++]);
3553 *dref = IdRef(_instruction[_o++]);
3554 *imageOperands6 = spv::ImageOperandsMask(_instruction[_o++]);
3555 if (imageOperandIdsList)
3556 {
3557 while (_o < _length)
3558 {
3559 imageOperandIdsList->emplace_back(_instruction[_o++]);
3560 }
3561 }
3562 }
ParseImageSparseFetch(const uint32_t * _instruction,IdResultType * idResultType1,IdResult * idResult2,IdRef * image,IdRef * coordinate,spv::ImageOperandsMask * imageOperands5,IdRefList * imageOperandIdsList)3563 void ParseImageSparseFetch(const uint32_t *_instruction,
3564 IdResultType *idResultType1,
3565 IdResult *idResult2,
3566 IdRef *image,
3567 IdRef *coordinate,
3568 spv::ImageOperandsMask *imageOperands5,
3569 IdRefList *imageOperandIdsList)
3570 {
3571 spv::Op _op;
3572 uint32_t _length;
3573 GetInstructionOpAndLength(_instruction, &_op, &_length);
3574 ASSERT(_op == spv::OpImageSparseFetch);
3575 uint32_t _o = 1;
3576 *idResultType1 = IdResultType(_instruction[_o++]);
3577 *idResult2 = IdResult(_instruction[_o++]);
3578 *image = IdRef(_instruction[_o++]);
3579 *coordinate = IdRef(_instruction[_o++]);
3580 if (imageOperands5 && _o < _length)
3581 {
3582 *imageOperands5 = spv::ImageOperandsMask(_instruction[_o++]);
3583 }
3584 if (imageOperandIdsList)
3585 {
3586 while (_o < _length)
3587 {
3588 imageOperandIdsList->emplace_back(_instruction[_o++]);
3589 }
3590 }
3591 }
ParseImageSparseGather(const uint32_t * _instruction,IdResultType * idResultType1,IdResult * idResult2,IdRef * sampledImage,IdRef * coordinate,IdRef * component,spv::ImageOperandsMask * imageOperands6,IdRefList * imageOperandIdsList)3592 void ParseImageSparseGather(const uint32_t *_instruction,
3593 IdResultType *idResultType1,
3594 IdResult *idResult2,
3595 IdRef *sampledImage,
3596 IdRef *coordinate,
3597 IdRef *component,
3598 spv::ImageOperandsMask *imageOperands6,
3599 IdRefList *imageOperandIdsList)
3600 {
3601 spv::Op _op;
3602 uint32_t _length;
3603 GetInstructionOpAndLength(_instruction, &_op, &_length);
3604 ASSERT(_op == spv::OpImageSparseGather);
3605 uint32_t _o = 1;
3606 *idResultType1 = IdResultType(_instruction[_o++]);
3607 *idResult2 = IdResult(_instruction[_o++]);
3608 *sampledImage = IdRef(_instruction[_o++]);
3609 *coordinate = IdRef(_instruction[_o++]);
3610 *component = IdRef(_instruction[_o++]);
3611 if (imageOperands6 && _o < _length)
3612 {
3613 *imageOperands6 = spv::ImageOperandsMask(_instruction[_o++]);
3614 }
3615 if (imageOperandIdsList)
3616 {
3617 while (_o < _length)
3618 {
3619 imageOperandIdsList->emplace_back(_instruction[_o++]);
3620 }
3621 }
3622 }
ParseImageSparseDrefGather(const uint32_t * _instruction,IdResultType * idResultType1,IdResult * idResult2,IdRef * sampledImage,IdRef * coordinate,IdRef * dref,spv::ImageOperandsMask * imageOperands6,IdRefList * imageOperandIdsList)3623 void ParseImageSparseDrefGather(const uint32_t *_instruction,
3624 IdResultType *idResultType1,
3625 IdResult *idResult2,
3626 IdRef *sampledImage,
3627 IdRef *coordinate,
3628 IdRef *dref,
3629 spv::ImageOperandsMask *imageOperands6,
3630 IdRefList *imageOperandIdsList)
3631 {
3632 spv::Op _op;
3633 uint32_t _length;
3634 GetInstructionOpAndLength(_instruction, &_op, &_length);
3635 ASSERT(_op == spv::OpImageSparseDrefGather);
3636 uint32_t _o = 1;
3637 *idResultType1 = IdResultType(_instruction[_o++]);
3638 *idResult2 = IdResult(_instruction[_o++]);
3639 *sampledImage = IdRef(_instruction[_o++]);
3640 *coordinate = IdRef(_instruction[_o++]);
3641 *dref = IdRef(_instruction[_o++]);
3642 if (imageOperands6 && _o < _length)
3643 {
3644 *imageOperands6 = spv::ImageOperandsMask(_instruction[_o++]);
3645 }
3646 if (imageOperandIdsList)
3647 {
3648 while (_o < _length)
3649 {
3650 imageOperandIdsList->emplace_back(_instruction[_o++]);
3651 }
3652 }
3653 }
ParseImageSparseTexelsResident(const uint32_t * _instruction,IdResultType * idResultType1,IdResult * idResult2,IdRef * residentCode)3654 void ParseImageSparseTexelsResident(const uint32_t *_instruction,
3655 IdResultType *idResultType1,
3656 IdResult *idResult2,
3657 IdRef *residentCode)
3658 {
3659 spv::Op _op;
3660 uint32_t _length;
3661 GetInstructionOpAndLength(_instruction, &_op, &_length);
3662 ASSERT(_op == spv::OpImageSparseTexelsResident);
3663 uint32_t _o = 1;
3664 *idResultType1 = IdResultType(_instruction[_o++]);
3665 *idResult2 = IdResult(_instruction[_o++]);
3666 *residentCode = IdRef(_instruction[_o++]);
3667 }
ParseImageSparseRead(const uint32_t * _instruction,IdResultType * idResultType1,IdResult * idResult2,IdRef * image,IdRef * coordinate,spv::ImageOperandsMask * imageOperands5,IdRefList * imageOperandIdsList)3668 void ParseImageSparseRead(const uint32_t *_instruction,
3669 IdResultType *idResultType1,
3670 IdResult *idResult2,
3671 IdRef *image,
3672 IdRef *coordinate,
3673 spv::ImageOperandsMask *imageOperands5,
3674 IdRefList *imageOperandIdsList)
3675 {
3676 spv::Op _op;
3677 uint32_t _length;
3678 GetInstructionOpAndLength(_instruction, &_op, &_length);
3679 ASSERT(_op == spv::OpImageSparseRead);
3680 uint32_t _o = 1;
3681 *idResultType1 = IdResultType(_instruction[_o++]);
3682 *idResult2 = IdResult(_instruction[_o++]);
3683 *image = IdRef(_instruction[_o++]);
3684 *coordinate = IdRef(_instruction[_o++]);
3685 if (imageOperands5 && _o < _length)
3686 {
3687 *imageOperands5 = spv::ImageOperandsMask(_instruction[_o++]);
3688 }
3689 if (imageOperandIdsList)
3690 {
3691 while (_o < _length)
3692 {
3693 imageOperandIdsList->emplace_back(_instruction[_o++]);
3694 }
3695 }
3696 }
ParseModuleProcessed(const uint32_t * _instruction,LiteralString * process)3697 void ParseModuleProcessed(const uint32_t *_instruction, LiteralString *process)
3698 {
3699 spv::Op _op;
3700 uint32_t _length;
3701 GetInstructionOpAndLength(_instruction, &_op, &_length);
3702 ASSERT(_op == spv::OpModuleProcessed);
3703 uint32_t _o = 1;
3704 ASSERT(IsLittleEndian());
3705 *process = reinterpret_cast<const char *>(&_instruction[_o]);
3706 _o += strlen(*process) / 4 + 1;
3707 }
ParseExecutionModeId(const uint32_t * _instruction,IdRef * entryPoint,spv::ExecutionMode * mode,LiteralIntegerList * operandsList)3708 void ParseExecutionModeId(const uint32_t *_instruction,
3709 IdRef *entryPoint,
3710 spv::ExecutionMode *mode,
3711 LiteralIntegerList *operandsList)
3712 {
3713 spv::Op _op;
3714 uint32_t _length;
3715 GetInstructionOpAndLength(_instruction, &_op, &_length);
3716 ASSERT(_op == spv::OpExecutionModeId);
3717 uint32_t _o = 1;
3718 *entryPoint = IdRef(_instruction[_o++]);
3719 *mode = spv::ExecutionMode(_instruction[_o++]);
3720 if (operandsList)
3721 {
3722 while (_o < _length)
3723 {
3724 operandsList->emplace_back(_instruction[_o++]);
3725 }
3726 }
3727 }
ParseGroupNonUniformElect(const uint32_t * _instruction,IdResultType * idResultType1,IdResult * idResult2,IdScope * execution)3728 void ParseGroupNonUniformElect(const uint32_t *_instruction,
3729 IdResultType *idResultType1,
3730 IdResult *idResult2,
3731 IdScope *execution)
3732 {
3733 spv::Op _op;
3734 uint32_t _length;
3735 GetInstructionOpAndLength(_instruction, &_op, &_length);
3736 ASSERT(_op == spv::OpGroupNonUniformElect);
3737 uint32_t _o = 1;
3738 *idResultType1 = IdResultType(_instruction[_o++]);
3739 *idResult2 = IdResult(_instruction[_o++]);
3740 *execution = IdScope(_instruction[_o++]);
3741 }
ParseGroupNonUniformAll(const uint32_t * _instruction,IdResultType * idResultType1,IdResult * idResult2,IdScope * execution,IdRef * predicate)3742 void ParseGroupNonUniformAll(const uint32_t *_instruction,
3743 IdResultType *idResultType1,
3744 IdResult *idResult2,
3745 IdScope *execution,
3746 IdRef *predicate)
3747 {
3748 spv::Op _op;
3749 uint32_t _length;
3750 GetInstructionOpAndLength(_instruction, &_op, &_length);
3751 ASSERT(_op == spv::OpGroupNonUniformAll);
3752 uint32_t _o = 1;
3753 *idResultType1 = IdResultType(_instruction[_o++]);
3754 *idResult2 = IdResult(_instruction[_o++]);
3755 *execution = IdScope(_instruction[_o++]);
3756 *predicate = IdRef(_instruction[_o++]);
3757 }
ParseGroupNonUniformAny(const uint32_t * _instruction,IdResultType * idResultType1,IdResult * idResult2,IdScope * execution,IdRef * predicate)3758 void ParseGroupNonUniformAny(const uint32_t *_instruction,
3759 IdResultType *idResultType1,
3760 IdResult *idResult2,
3761 IdScope *execution,
3762 IdRef *predicate)
3763 {
3764 spv::Op _op;
3765 uint32_t _length;
3766 GetInstructionOpAndLength(_instruction, &_op, &_length);
3767 ASSERT(_op == spv::OpGroupNonUniformAny);
3768 uint32_t _o = 1;
3769 *idResultType1 = IdResultType(_instruction[_o++]);
3770 *idResult2 = IdResult(_instruction[_o++]);
3771 *execution = IdScope(_instruction[_o++]);
3772 *predicate = IdRef(_instruction[_o++]);
3773 }
ParseGroupNonUniformAllEqual(const uint32_t * _instruction,IdResultType * idResultType1,IdResult * idResult2,IdScope * execution,IdRef * value)3774 void ParseGroupNonUniformAllEqual(const uint32_t *_instruction,
3775 IdResultType *idResultType1,
3776 IdResult *idResult2,
3777 IdScope *execution,
3778 IdRef *value)
3779 {
3780 spv::Op _op;
3781 uint32_t _length;
3782 GetInstructionOpAndLength(_instruction, &_op, &_length);
3783 ASSERT(_op == spv::OpGroupNonUniformAllEqual);
3784 uint32_t _o = 1;
3785 *idResultType1 = IdResultType(_instruction[_o++]);
3786 *idResult2 = IdResult(_instruction[_o++]);
3787 *execution = IdScope(_instruction[_o++]);
3788 *value = IdRef(_instruction[_o++]);
3789 }
ParseGroupNonUniformBroadcast(const uint32_t * _instruction,IdResultType * idResultType1,IdResult * idResult2,IdScope * execution,IdRef * value,IdRef * id)3790 void ParseGroupNonUniformBroadcast(const uint32_t *_instruction,
3791 IdResultType *idResultType1,
3792 IdResult *idResult2,
3793 IdScope *execution,
3794 IdRef *value,
3795 IdRef *id)
3796 {
3797 spv::Op _op;
3798 uint32_t _length;
3799 GetInstructionOpAndLength(_instruction, &_op, &_length);
3800 ASSERT(_op == spv::OpGroupNonUniformBroadcast);
3801 uint32_t _o = 1;
3802 *idResultType1 = IdResultType(_instruction[_o++]);
3803 *idResult2 = IdResult(_instruction[_o++]);
3804 *execution = IdScope(_instruction[_o++]);
3805 *value = IdRef(_instruction[_o++]);
3806 *id = IdRef(_instruction[_o++]);
3807 }
ParseGroupNonUniformBroadcastFirst(const uint32_t * _instruction,IdResultType * idResultType1,IdResult * idResult2,IdScope * execution,IdRef * value)3808 void ParseGroupNonUniformBroadcastFirst(const uint32_t *_instruction,
3809 IdResultType *idResultType1,
3810 IdResult *idResult2,
3811 IdScope *execution,
3812 IdRef *value)
3813 {
3814 spv::Op _op;
3815 uint32_t _length;
3816 GetInstructionOpAndLength(_instruction, &_op, &_length);
3817 ASSERT(_op == spv::OpGroupNonUniformBroadcastFirst);
3818 uint32_t _o = 1;
3819 *idResultType1 = IdResultType(_instruction[_o++]);
3820 *idResult2 = IdResult(_instruction[_o++]);
3821 *execution = IdScope(_instruction[_o++]);
3822 *value = IdRef(_instruction[_o++]);
3823 }
ParseGroupNonUniformBallot(const uint32_t * _instruction,IdResultType * idResultType1,IdResult * idResult2,IdScope * execution,IdRef * predicate)3824 void ParseGroupNonUniformBallot(const uint32_t *_instruction,
3825 IdResultType *idResultType1,
3826 IdResult *idResult2,
3827 IdScope *execution,
3828 IdRef *predicate)
3829 {
3830 spv::Op _op;
3831 uint32_t _length;
3832 GetInstructionOpAndLength(_instruction, &_op, &_length);
3833 ASSERT(_op == spv::OpGroupNonUniformBallot);
3834 uint32_t _o = 1;
3835 *idResultType1 = IdResultType(_instruction[_o++]);
3836 *idResult2 = IdResult(_instruction[_o++]);
3837 *execution = IdScope(_instruction[_o++]);
3838 *predicate = IdRef(_instruction[_o++]);
3839 }
ParseGroupNonUniformInverseBallot(const uint32_t * _instruction,IdResultType * idResultType1,IdResult * idResult2,IdScope * execution,IdRef * value)3840 void ParseGroupNonUniformInverseBallot(const uint32_t *_instruction,
3841 IdResultType *idResultType1,
3842 IdResult *idResult2,
3843 IdScope *execution,
3844 IdRef *value)
3845 {
3846 spv::Op _op;
3847 uint32_t _length;
3848 GetInstructionOpAndLength(_instruction, &_op, &_length);
3849 ASSERT(_op == spv::OpGroupNonUniformInverseBallot);
3850 uint32_t _o = 1;
3851 *idResultType1 = IdResultType(_instruction[_o++]);
3852 *idResult2 = IdResult(_instruction[_o++]);
3853 *execution = IdScope(_instruction[_o++]);
3854 *value = IdRef(_instruction[_o++]);
3855 }
ParseGroupNonUniformBallotBitExtract(const uint32_t * _instruction,IdResultType * idResultType1,IdResult * idResult2,IdScope * execution,IdRef * value,IdRef * index)3856 void ParseGroupNonUniformBallotBitExtract(const uint32_t *_instruction,
3857 IdResultType *idResultType1,
3858 IdResult *idResult2,
3859 IdScope *execution,
3860 IdRef *value,
3861 IdRef *index)
3862 {
3863 spv::Op _op;
3864 uint32_t _length;
3865 GetInstructionOpAndLength(_instruction, &_op, &_length);
3866 ASSERT(_op == spv::OpGroupNonUniformBallotBitExtract);
3867 uint32_t _o = 1;
3868 *idResultType1 = IdResultType(_instruction[_o++]);
3869 *idResult2 = IdResult(_instruction[_o++]);
3870 *execution = IdScope(_instruction[_o++]);
3871 *value = IdRef(_instruction[_o++]);
3872 *index = IdRef(_instruction[_o++]);
3873 }
ParseGroupNonUniformBallotBitCount(const uint32_t * _instruction,IdResultType * idResultType1,IdResult * idResult2,IdScope * execution,spv::GroupOperation * operation,IdRef * value)3874 void ParseGroupNonUniformBallotBitCount(const uint32_t *_instruction,
3875 IdResultType *idResultType1,
3876 IdResult *idResult2,
3877 IdScope *execution,
3878 spv::GroupOperation *operation,
3879 IdRef *value)
3880 {
3881 spv::Op _op;
3882 uint32_t _length;
3883 GetInstructionOpAndLength(_instruction, &_op, &_length);
3884 ASSERT(_op == spv::OpGroupNonUniformBallotBitCount);
3885 uint32_t _o = 1;
3886 *idResultType1 = IdResultType(_instruction[_o++]);
3887 *idResult2 = IdResult(_instruction[_o++]);
3888 *execution = IdScope(_instruction[_o++]);
3889 *operation = spv::GroupOperation(_instruction[_o++]);
3890 *value = IdRef(_instruction[_o++]);
3891 }
ParseGroupNonUniformBallotFindLSB(const uint32_t * _instruction,IdResultType * idResultType1,IdResult * idResult2,IdScope * execution,IdRef * value)3892 void ParseGroupNonUniformBallotFindLSB(const uint32_t *_instruction,
3893 IdResultType *idResultType1,
3894 IdResult *idResult2,
3895 IdScope *execution,
3896 IdRef *value)
3897 {
3898 spv::Op _op;
3899 uint32_t _length;
3900 GetInstructionOpAndLength(_instruction, &_op, &_length);
3901 ASSERT(_op == spv::OpGroupNonUniformBallotFindLSB);
3902 uint32_t _o = 1;
3903 *idResultType1 = IdResultType(_instruction[_o++]);
3904 *idResult2 = IdResult(_instruction[_o++]);
3905 *execution = IdScope(_instruction[_o++]);
3906 *value = IdRef(_instruction[_o++]);
3907 }
ParseGroupNonUniformBallotFindMSB(const uint32_t * _instruction,IdResultType * idResultType1,IdResult * idResult2,IdScope * execution,IdRef * value)3908 void ParseGroupNonUniformBallotFindMSB(const uint32_t *_instruction,
3909 IdResultType *idResultType1,
3910 IdResult *idResult2,
3911 IdScope *execution,
3912 IdRef *value)
3913 {
3914 spv::Op _op;
3915 uint32_t _length;
3916 GetInstructionOpAndLength(_instruction, &_op, &_length);
3917 ASSERT(_op == spv::OpGroupNonUniformBallotFindMSB);
3918 uint32_t _o = 1;
3919 *idResultType1 = IdResultType(_instruction[_o++]);
3920 *idResult2 = IdResult(_instruction[_o++]);
3921 *execution = IdScope(_instruction[_o++]);
3922 *value = IdRef(_instruction[_o++]);
3923 }
ParseGroupNonUniformShuffle(const uint32_t * _instruction,IdResultType * idResultType1,IdResult * idResult2,IdScope * execution,IdRef * value,IdRef * id)3924 void ParseGroupNonUniformShuffle(const uint32_t *_instruction,
3925 IdResultType *idResultType1,
3926 IdResult *idResult2,
3927 IdScope *execution,
3928 IdRef *value,
3929 IdRef *id)
3930 {
3931 spv::Op _op;
3932 uint32_t _length;
3933 GetInstructionOpAndLength(_instruction, &_op, &_length);
3934 ASSERT(_op == spv::OpGroupNonUniformShuffle);
3935 uint32_t _o = 1;
3936 *idResultType1 = IdResultType(_instruction[_o++]);
3937 *idResult2 = IdResult(_instruction[_o++]);
3938 *execution = IdScope(_instruction[_o++]);
3939 *value = IdRef(_instruction[_o++]);
3940 *id = IdRef(_instruction[_o++]);
3941 }
ParseGroupNonUniformShuffleXor(const uint32_t * _instruction,IdResultType * idResultType1,IdResult * idResult2,IdScope * execution,IdRef * value,IdRef * mask)3942 void ParseGroupNonUniformShuffleXor(const uint32_t *_instruction,
3943 IdResultType *idResultType1,
3944 IdResult *idResult2,
3945 IdScope *execution,
3946 IdRef *value,
3947 IdRef *mask)
3948 {
3949 spv::Op _op;
3950 uint32_t _length;
3951 GetInstructionOpAndLength(_instruction, &_op, &_length);
3952 ASSERT(_op == spv::OpGroupNonUniformShuffleXor);
3953 uint32_t _o = 1;
3954 *idResultType1 = IdResultType(_instruction[_o++]);
3955 *idResult2 = IdResult(_instruction[_o++]);
3956 *execution = IdScope(_instruction[_o++]);
3957 *value = IdRef(_instruction[_o++]);
3958 *mask = IdRef(_instruction[_o++]);
3959 }
ParseGroupNonUniformShuffleUp(const uint32_t * _instruction,IdResultType * idResultType1,IdResult * idResult2,IdScope * execution,IdRef * value,IdRef * delta)3960 void ParseGroupNonUniformShuffleUp(const uint32_t *_instruction,
3961 IdResultType *idResultType1,
3962 IdResult *idResult2,
3963 IdScope *execution,
3964 IdRef *value,
3965 IdRef *delta)
3966 {
3967 spv::Op _op;
3968 uint32_t _length;
3969 GetInstructionOpAndLength(_instruction, &_op, &_length);
3970 ASSERT(_op == spv::OpGroupNonUniformShuffleUp);
3971 uint32_t _o = 1;
3972 *idResultType1 = IdResultType(_instruction[_o++]);
3973 *idResult2 = IdResult(_instruction[_o++]);
3974 *execution = IdScope(_instruction[_o++]);
3975 *value = IdRef(_instruction[_o++]);
3976 *delta = IdRef(_instruction[_o++]);
3977 }
ParseGroupNonUniformShuffleDown(const uint32_t * _instruction,IdResultType * idResultType1,IdResult * idResult2,IdScope * execution,IdRef * value,IdRef * delta)3978 void ParseGroupNonUniformShuffleDown(const uint32_t *_instruction,
3979 IdResultType *idResultType1,
3980 IdResult *idResult2,
3981 IdScope *execution,
3982 IdRef *value,
3983 IdRef *delta)
3984 {
3985 spv::Op _op;
3986 uint32_t _length;
3987 GetInstructionOpAndLength(_instruction, &_op, &_length);
3988 ASSERT(_op == spv::OpGroupNonUniformShuffleDown);
3989 uint32_t _o = 1;
3990 *idResultType1 = IdResultType(_instruction[_o++]);
3991 *idResult2 = IdResult(_instruction[_o++]);
3992 *execution = IdScope(_instruction[_o++]);
3993 *value = IdRef(_instruction[_o++]);
3994 *delta = IdRef(_instruction[_o++]);
3995 }
ParseGroupNonUniformIAdd(const uint32_t * _instruction,IdResultType * idResultType1,IdResult * idResult2,IdScope * execution,spv::GroupOperation * operation,IdRef * value,IdRef * clusterSize)3996 void ParseGroupNonUniformIAdd(const uint32_t *_instruction,
3997 IdResultType *idResultType1,
3998 IdResult *idResult2,
3999 IdScope *execution,
4000 spv::GroupOperation *operation,
4001 IdRef *value,
4002 IdRef *clusterSize)
4003 {
4004 spv::Op _op;
4005 uint32_t _length;
4006 GetInstructionOpAndLength(_instruction, &_op, &_length);
4007 ASSERT(_op == spv::OpGroupNonUniformIAdd);
4008 uint32_t _o = 1;
4009 *idResultType1 = IdResultType(_instruction[_o++]);
4010 *idResult2 = IdResult(_instruction[_o++]);
4011 *execution = IdScope(_instruction[_o++]);
4012 *operation = spv::GroupOperation(_instruction[_o++]);
4013 *value = IdRef(_instruction[_o++]);
4014 if (clusterSize && _o < _length)
4015 {
4016 *clusterSize = IdRef(_instruction[_o++]);
4017 }
4018 }
ParseGroupNonUniformFAdd(const uint32_t * _instruction,IdResultType * idResultType1,IdResult * idResult2,IdScope * execution,spv::GroupOperation * operation,IdRef * value,IdRef * clusterSize)4019 void ParseGroupNonUniformFAdd(const uint32_t *_instruction,
4020 IdResultType *idResultType1,
4021 IdResult *idResult2,
4022 IdScope *execution,
4023 spv::GroupOperation *operation,
4024 IdRef *value,
4025 IdRef *clusterSize)
4026 {
4027 spv::Op _op;
4028 uint32_t _length;
4029 GetInstructionOpAndLength(_instruction, &_op, &_length);
4030 ASSERT(_op == spv::OpGroupNonUniformFAdd);
4031 uint32_t _o = 1;
4032 *idResultType1 = IdResultType(_instruction[_o++]);
4033 *idResult2 = IdResult(_instruction[_o++]);
4034 *execution = IdScope(_instruction[_o++]);
4035 *operation = spv::GroupOperation(_instruction[_o++]);
4036 *value = IdRef(_instruction[_o++]);
4037 if (clusterSize && _o < _length)
4038 {
4039 *clusterSize = IdRef(_instruction[_o++]);
4040 }
4041 }
ParseGroupNonUniformIMul(const uint32_t * _instruction,IdResultType * idResultType1,IdResult * idResult2,IdScope * execution,spv::GroupOperation * operation,IdRef * value,IdRef * clusterSize)4042 void ParseGroupNonUniformIMul(const uint32_t *_instruction,
4043 IdResultType *idResultType1,
4044 IdResult *idResult2,
4045 IdScope *execution,
4046 spv::GroupOperation *operation,
4047 IdRef *value,
4048 IdRef *clusterSize)
4049 {
4050 spv::Op _op;
4051 uint32_t _length;
4052 GetInstructionOpAndLength(_instruction, &_op, &_length);
4053 ASSERT(_op == spv::OpGroupNonUniformIMul);
4054 uint32_t _o = 1;
4055 *idResultType1 = IdResultType(_instruction[_o++]);
4056 *idResult2 = IdResult(_instruction[_o++]);
4057 *execution = IdScope(_instruction[_o++]);
4058 *operation = spv::GroupOperation(_instruction[_o++]);
4059 *value = IdRef(_instruction[_o++]);
4060 if (clusterSize && _o < _length)
4061 {
4062 *clusterSize = IdRef(_instruction[_o++]);
4063 }
4064 }
ParseGroupNonUniformFMul(const uint32_t * _instruction,IdResultType * idResultType1,IdResult * idResult2,IdScope * execution,spv::GroupOperation * operation,IdRef * value,IdRef * clusterSize)4065 void ParseGroupNonUniformFMul(const uint32_t *_instruction,
4066 IdResultType *idResultType1,
4067 IdResult *idResult2,
4068 IdScope *execution,
4069 spv::GroupOperation *operation,
4070 IdRef *value,
4071 IdRef *clusterSize)
4072 {
4073 spv::Op _op;
4074 uint32_t _length;
4075 GetInstructionOpAndLength(_instruction, &_op, &_length);
4076 ASSERT(_op == spv::OpGroupNonUniformFMul);
4077 uint32_t _o = 1;
4078 *idResultType1 = IdResultType(_instruction[_o++]);
4079 *idResult2 = IdResult(_instruction[_o++]);
4080 *execution = IdScope(_instruction[_o++]);
4081 *operation = spv::GroupOperation(_instruction[_o++]);
4082 *value = IdRef(_instruction[_o++]);
4083 if (clusterSize && _o < _length)
4084 {
4085 *clusterSize = IdRef(_instruction[_o++]);
4086 }
4087 }
ParseGroupNonUniformSMin(const uint32_t * _instruction,IdResultType * idResultType1,IdResult * idResult2,IdScope * execution,spv::GroupOperation * operation,IdRef * value,IdRef * clusterSize)4088 void ParseGroupNonUniformSMin(const uint32_t *_instruction,
4089 IdResultType *idResultType1,
4090 IdResult *idResult2,
4091 IdScope *execution,
4092 spv::GroupOperation *operation,
4093 IdRef *value,
4094 IdRef *clusterSize)
4095 {
4096 spv::Op _op;
4097 uint32_t _length;
4098 GetInstructionOpAndLength(_instruction, &_op, &_length);
4099 ASSERT(_op == spv::OpGroupNonUniformSMin);
4100 uint32_t _o = 1;
4101 *idResultType1 = IdResultType(_instruction[_o++]);
4102 *idResult2 = IdResult(_instruction[_o++]);
4103 *execution = IdScope(_instruction[_o++]);
4104 *operation = spv::GroupOperation(_instruction[_o++]);
4105 *value = IdRef(_instruction[_o++]);
4106 if (clusterSize && _o < _length)
4107 {
4108 *clusterSize = IdRef(_instruction[_o++]);
4109 }
4110 }
ParseGroupNonUniformUMin(const uint32_t * _instruction,IdResultType * idResultType1,IdResult * idResult2,IdScope * execution,spv::GroupOperation * operation,IdRef * value,IdRef * clusterSize)4111 void ParseGroupNonUniformUMin(const uint32_t *_instruction,
4112 IdResultType *idResultType1,
4113 IdResult *idResult2,
4114 IdScope *execution,
4115 spv::GroupOperation *operation,
4116 IdRef *value,
4117 IdRef *clusterSize)
4118 {
4119 spv::Op _op;
4120 uint32_t _length;
4121 GetInstructionOpAndLength(_instruction, &_op, &_length);
4122 ASSERT(_op == spv::OpGroupNonUniformUMin);
4123 uint32_t _o = 1;
4124 *idResultType1 = IdResultType(_instruction[_o++]);
4125 *idResult2 = IdResult(_instruction[_o++]);
4126 *execution = IdScope(_instruction[_o++]);
4127 *operation = spv::GroupOperation(_instruction[_o++]);
4128 *value = IdRef(_instruction[_o++]);
4129 if (clusterSize && _o < _length)
4130 {
4131 *clusterSize = IdRef(_instruction[_o++]);
4132 }
4133 }
ParseGroupNonUniformFMin(const uint32_t * _instruction,IdResultType * idResultType1,IdResult * idResult2,IdScope * execution,spv::GroupOperation * operation,IdRef * value,IdRef * clusterSize)4134 void ParseGroupNonUniformFMin(const uint32_t *_instruction,
4135 IdResultType *idResultType1,
4136 IdResult *idResult2,
4137 IdScope *execution,
4138 spv::GroupOperation *operation,
4139 IdRef *value,
4140 IdRef *clusterSize)
4141 {
4142 spv::Op _op;
4143 uint32_t _length;
4144 GetInstructionOpAndLength(_instruction, &_op, &_length);
4145 ASSERT(_op == spv::OpGroupNonUniformFMin);
4146 uint32_t _o = 1;
4147 *idResultType1 = IdResultType(_instruction[_o++]);
4148 *idResult2 = IdResult(_instruction[_o++]);
4149 *execution = IdScope(_instruction[_o++]);
4150 *operation = spv::GroupOperation(_instruction[_o++]);
4151 *value = IdRef(_instruction[_o++]);
4152 if (clusterSize && _o < _length)
4153 {
4154 *clusterSize = IdRef(_instruction[_o++]);
4155 }
4156 }
ParseGroupNonUniformSMax(const uint32_t * _instruction,IdResultType * idResultType1,IdResult * idResult2,IdScope * execution,spv::GroupOperation * operation,IdRef * value,IdRef * clusterSize)4157 void ParseGroupNonUniformSMax(const uint32_t *_instruction,
4158 IdResultType *idResultType1,
4159 IdResult *idResult2,
4160 IdScope *execution,
4161 spv::GroupOperation *operation,
4162 IdRef *value,
4163 IdRef *clusterSize)
4164 {
4165 spv::Op _op;
4166 uint32_t _length;
4167 GetInstructionOpAndLength(_instruction, &_op, &_length);
4168 ASSERT(_op == spv::OpGroupNonUniformSMax);
4169 uint32_t _o = 1;
4170 *idResultType1 = IdResultType(_instruction[_o++]);
4171 *idResult2 = IdResult(_instruction[_o++]);
4172 *execution = IdScope(_instruction[_o++]);
4173 *operation = spv::GroupOperation(_instruction[_o++]);
4174 *value = IdRef(_instruction[_o++]);
4175 if (clusterSize && _o < _length)
4176 {
4177 *clusterSize = IdRef(_instruction[_o++]);
4178 }
4179 }
ParseGroupNonUniformUMax(const uint32_t * _instruction,IdResultType * idResultType1,IdResult * idResult2,IdScope * execution,spv::GroupOperation * operation,IdRef * value,IdRef * clusterSize)4180 void ParseGroupNonUniformUMax(const uint32_t *_instruction,
4181 IdResultType *idResultType1,
4182 IdResult *idResult2,
4183 IdScope *execution,
4184 spv::GroupOperation *operation,
4185 IdRef *value,
4186 IdRef *clusterSize)
4187 {
4188 spv::Op _op;
4189 uint32_t _length;
4190 GetInstructionOpAndLength(_instruction, &_op, &_length);
4191 ASSERT(_op == spv::OpGroupNonUniformUMax);
4192 uint32_t _o = 1;
4193 *idResultType1 = IdResultType(_instruction[_o++]);
4194 *idResult2 = IdResult(_instruction[_o++]);
4195 *execution = IdScope(_instruction[_o++]);
4196 *operation = spv::GroupOperation(_instruction[_o++]);
4197 *value = IdRef(_instruction[_o++]);
4198 if (clusterSize && _o < _length)
4199 {
4200 *clusterSize = IdRef(_instruction[_o++]);
4201 }
4202 }
ParseGroupNonUniformFMax(const uint32_t * _instruction,IdResultType * idResultType1,IdResult * idResult2,IdScope * execution,spv::GroupOperation * operation,IdRef * value,IdRef * clusterSize)4203 void ParseGroupNonUniformFMax(const uint32_t *_instruction,
4204 IdResultType *idResultType1,
4205 IdResult *idResult2,
4206 IdScope *execution,
4207 spv::GroupOperation *operation,
4208 IdRef *value,
4209 IdRef *clusterSize)
4210 {
4211 spv::Op _op;
4212 uint32_t _length;
4213 GetInstructionOpAndLength(_instruction, &_op, &_length);
4214 ASSERT(_op == spv::OpGroupNonUniformFMax);
4215 uint32_t _o = 1;
4216 *idResultType1 = IdResultType(_instruction[_o++]);
4217 *idResult2 = IdResult(_instruction[_o++]);
4218 *execution = IdScope(_instruction[_o++]);
4219 *operation = spv::GroupOperation(_instruction[_o++]);
4220 *value = IdRef(_instruction[_o++]);
4221 if (clusterSize && _o < _length)
4222 {
4223 *clusterSize = IdRef(_instruction[_o++]);
4224 }
4225 }
ParseGroupNonUniformBitwiseAnd(const uint32_t * _instruction,IdResultType * idResultType1,IdResult * idResult2,IdScope * execution,spv::GroupOperation * operation,IdRef * value,IdRef * clusterSize)4226 void ParseGroupNonUniformBitwiseAnd(const uint32_t *_instruction,
4227 IdResultType *idResultType1,
4228 IdResult *idResult2,
4229 IdScope *execution,
4230 spv::GroupOperation *operation,
4231 IdRef *value,
4232 IdRef *clusterSize)
4233 {
4234 spv::Op _op;
4235 uint32_t _length;
4236 GetInstructionOpAndLength(_instruction, &_op, &_length);
4237 ASSERT(_op == spv::OpGroupNonUniformBitwiseAnd);
4238 uint32_t _o = 1;
4239 *idResultType1 = IdResultType(_instruction[_o++]);
4240 *idResult2 = IdResult(_instruction[_o++]);
4241 *execution = IdScope(_instruction[_o++]);
4242 *operation = spv::GroupOperation(_instruction[_o++]);
4243 *value = IdRef(_instruction[_o++]);
4244 if (clusterSize && _o < _length)
4245 {
4246 *clusterSize = IdRef(_instruction[_o++]);
4247 }
4248 }
ParseGroupNonUniformBitwiseOr(const uint32_t * _instruction,IdResultType * idResultType1,IdResult * idResult2,IdScope * execution,spv::GroupOperation * operation,IdRef * value,IdRef * clusterSize)4249 void ParseGroupNonUniformBitwiseOr(const uint32_t *_instruction,
4250 IdResultType *idResultType1,
4251 IdResult *idResult2,
4252 IdScope *execution,
4253 spv::GroupOperation *operation,
4254 IdRef *value,
4255 IdRef *clusterSize)
4256 {
4257 spv::Op _op;
4258 uint32_t _length;
4259 GetInstructionOpAndLength(_instruction, &_op, &_length);
4260 ASSERT(_op == spv::OpGroupNonUniformBitwiseOr);
4261 uint32_t _o = 1;
4262 *idResultType1 = IdResultType(_instruction[_o++]);
4263 *idResult2 = IdResult(_instruction[_o++]);
4264 *execution = IdScope(_instruction[_o++]);
4265 *operation = spv::GroupOperation(_instruction[_o++]);
4266 *value = IdRef(_instruction[_o++]);
4267 if (clusterSize && _o < _length)
4268 {
4269 *clusterSize = IdRef(_instruction[_o++]);
4270 }
4271 }
ParseGroupNonUniformBitwiseXor(const uint32_t * _instruction,IdResultType * idResultType1,IdResult * idResult2,IdScope * execution,spv::GroupOperation * operation,IdRef * value,IdRef * clusterSize)4272 void ParseGroupNonUniformBitwiseXor(const uint32_t *_instruction,
4273 IdResultType *idResultType1,
4274 IdResult *idResult2,
4275 IdScope *execution,
4276 spv::GroupOperation *operation,
4277 IdRef *value,
4278 IdRef *clusterSize)
4279 {
4280 spv::Op _op;
4281 uint32_t _length;
4282 GetInstructionOpAndLength(_instruction, &_op, &_length);
4283 ASSERT(_op == spv::OpGroupNonUniformBitwiseXor);
4284 uint32_t _o = 1;
4285 *idResultType1 = IdResultType(_instruction[_o++]);
4286 *idResult2 = IdResult(_instruction[_o++]);
4287 *execution = IdScope(_instruction[_o++]);
4288 *operation = spv::GroupOperation(_instruction[_o++]);
4289 *value = IdRef(_instruction[_o++]);
4290 if (clusterSize && _o < _length)
4291 {
4292 *clusterSize = IdRef(_instruction[_o++]);
4293 }
4294 }
ParseGroupNonUniformLogicalAnd(const uint32_t * _instruction,IdResultType * idResultType1,IdResult * idResult2,IdScope * execution,spv::GroupOperation * operation,IdRef * value,IdRef * clusterSize)4295 void ParseGroupNonUniformLogicalAnd(const uint32_t *_instruction,
4296 IdResultType *idResultType1,
4297 IdResult *idResult2,
4298 IdScope *execution,
4299 spv::GroupOperation *operation,
4300 IdRef *value,
4301 IdRef *clusterSize)
4302 {
4303 spv::Op _op;
4304 uint32_t _length;
4305 GetInstructionOpAndLength(_instruction, &_op, &_length);
4306 ASSERT(_op == spv::OpGroupNonUniformLogicalAnd);
4307 uint32_t _o = 1;
4308 *idResultType1 = IdResultType(_instruction[_o++]);
4309 *idResult2 = IdResult(_instruction[_o++]);
4310 *execution = IdScope(_instruction[_o++]);
4311 *operation = spv::GroupOperation(_instruction[_o++]);
4312 *value = IdRef(_instruction[_o++]);
4313 if (clusterSize && _o < _length)
4314 {
4315 *clusterSize = IdRef(_instruction[_o++]);
4316 }
4317 }
ParseGroupNonUniformLogicalOr(const uint32_t * _instruction,IdResultType * idResultType1,IdResult * idResult2,IdScope * execution,spv::GroupOperation * operation,IdRef * value,IdRef * clusterSize)4318 void ParseGroupNonUniformLogicalOr(const uint32_t *_instruction,
4319 IdResultType *idResultType1,
4320 IdResult *idResult2,
4321 IdScope *execution,
4322 spv::GroupOperation *operation,
4323 IdRef *value,
4324 IdRef *clusterSize)
4325 {
4326 spv::Op _op;
4327 uint32_t _length;
4328 GetInstructionOpAndLength(_instruction, &_op, &_length);
4329 ASSERT(_op == spv::OpGroupNonUniformLogicalOr);
4330 uint32_t _o = 1;
4331 *idResultType1 = IdResultType(_instruction[_o++]);
4332 *idResult2 = IdResult(_instruction[_o++]);
4333 *execution = IdScope(_instruction[_o++]);
4334 *operation = spv::GroupOperation(_instruction[_o++]);
4335 *value = IdRef(_instruction[_o++]);
4336 if (clusterSize && _o < _length)
4337 {
4338 *clusterSize = IdRef(_instruction[_o++]);
4339 }
4340 }
ParseGroupNonUniformLogicalXor(const uint32_t * _instruction,IdResultType * idResultType1,IdResult * idResult2,IdScope * execution,spv::GroupOperation * operation,IdRef * value,IdRef * clusterSize)4341 void ParseGroupNonUniformLogicalXor(const uint32_t *_instruction,
4342 IdResultType *idResultType1,
4343 IdResult *idResult2,
4344 IdScope *execution,
4345 spv::GroupOperation *operation,
4346 IdRef *value,
4347 IdRef *clusterSize)
4348 {
4349 spv::Op _op;
4350 uint32_t _length;
4351 GetInstructionOpAndLength(_instruction, &_op, &_length);
4352 ASSERT(_op == spv::OpGroupNonUniformLogicalXor);
4353 uint32_t _o = 1;
4354 *idResultType1 = IdResultType(_instruction[_o++]);
4355 *idResult2 = IdResult(_instruction[_o++]);
4356 *execution = IdScope(_instruction[_o++]);
4357 *operation = spv::GroupOperation(_instruction[_o++]);
4358 *value = IdRef(_instruction[_o++]);
4359 if (clusterSize && _o < _length)
4360 {
4361 *clusterSize = IdRef(_instruction[_o++]);
4362 }
4363 }
ParseGroupNonUniformQuadBroadcast(const uint32_t * _instruction,IdResultType * idResultType1,IdResult * idResult2,IdScope * execution,IdRef * value,IdRef * index)4364 void ParseGroupNonUniformQuadBroadcast(const uint32_t *_instruction,
4365 IdResultType *idResultType1,
4366 IdResult *idResult2,
4367 IdScope *execution,
4368 IdRef *value,
4369 IdRef *index)
4370 {
4371 spv::Op _op;
4372 uint32_t _length;
4373 GetInstructionOpAndLength(_instruction, &_op, &_length);
4374 ASSERT(_op == spv::OpGroupNonUniformQuadBroadcast);
4375 uint32_t _o = 1;
4376 *idResultType1 = IdResultType(_instruction[_o++]);
4377 *idResult2 = IdResult(_instruction[_o++]);
4378 *execution = IdScope(_instruction[_o++]);
4379 *value = IdRef(_instruction[_o++]);
4380 *index = IdRef(_instruction[_o++]);
4381 }
ParseGroupNonUniformQuadSwap(const uint32_t * _instruction,IdResultType * idResultType1,IdResult * idResult2,IdScope * execution,IdRef * value,IdRef * direction)4382 void ParseGroupNonUniformQuadSwap(const uint32_t *_instruction,
4383 IdResultType *idResultType1,
4384 IdResult *idResult2,
4385 IdScope *execution,
4386 IdRef *value,
4387 IdRef *direction)
4388 {
4389 spv::Op _op;
4390 uint32_t _length;
4391 GetInstructionOpAndLength(_instruction, &_op, &_length);
4392 ASSERT(_op == spv::OpGroupNonUniformQuadSwap);
4393 uint32_t _o = 1;
4394 *idResultType1 = IdResultType(_instruction[_o++]);
4395 *idResult2 = IdResult(_instruction[_o++]);
4396 *execution = IdScope(_instruction[_o++]);
4397 *value = IdRef(_instruction[_o++]);
4398 *direction = IdRef(_instruction[_o++]);
4399 }
ParseCopyLogical(const uint32_t * _instruction,IdResultType * idResultType1,IdResult * idResult2,IdRef * operand)4400