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