xref: /aosp_15_r20/external/angle/src/common/spirv/spirv_instruction_parser_autogen.h (revision 8975f5c5ed3d1c378011245431ada316dfb6f244) 
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.h:
9 //   Functions to parse SPIR-V binary for each instruction.
10 
11 #ifndef COMMON_SPIRV_SPIRVINSTRUCTIONPARSERAUTOGEN_H_
12 #define COMMON_SPIRV_SPIRVINSTRUCTIONPARSERAUTOGEN_H_
13 
14 #include <spirv/unified1/spirv.hpp>
15 
16 #include "spirv_types.h"
17 
18 namespace angle
19 {
20 namespace spirv
21 {
22 void GetInstructionOpAndLength(const uint32_t *_instruction, spv::Op *opOut, uint32_t *lengthOut);
23 void ParseUndef(const uint32_t *_instruction, IdResultType *idResultType1, IdResult *idResult2);
24 void ParseSourceContinued(const uint32_t *_instruction, LiteralString *continuedSource);
25 void ParseSource(const uint32_t *_instruction,
26                  spv::SourceLanguage *sourceLanguage1,
27                  LiteralInteger *version,
28                  IdRef *file,
29                  LiteralString *source);
30 void ParseSourceExtension(const uint32_t *_instruction, LiteralString *extension);
31 void ParseName(const uint32_t *_instruction, IdRef *target, LiteralString *name);
32 void ParseMemberName(const uint32_t *_instruction,
33                      IdRef *type,
34                      LiteralInteger *member,
35                      LiteralString *name);
36 void ParseString(const uint32_t *_instruction, IdResult *idResult1, LiteralString *string);
37 void ParseLine(const uint32_t *_instruction,
38                IdRef *file,
39                LiteralInteger *line,
40                LiteralInteger *column);
41 void ParseExtension(const uint32_t *_instruction, LiteralString *name);
42 void ParseExtInstImport(const uint32_t *_instruction, IdResult *idResult1, LiteralString *name);
43 void ParseExtInst(const uint32_t *_instruction,
44                   IdResultType *idResultType1,
45                   IdResult *idResult2,
46                   IdRef *set,
47                   LiteralExtInstInteger *instruction,
48                   IdRefList *operandList);
49 void ParseMemoryModel(const uint32_t *_instruction,
50                       spv::AddressingModel *addressingModel1,
51                       spv::MemoryModel *memoryModel2);
52 void ParseEntryPoint(const uint32_t *_instruction,
53                      spv::ExecutionModel *executionModel1,
54                      IdRef *entryPoint,
55                      LiteralString *name,
56                      IdRefList *interfaceList);
57 void ParseExecutionMode(const uint32_t *_instruction,
58                         IdRef *entryPoint,
59                         spv::ExecutionMode *mode,
60                         LiteralIntegerList *operandsList);
61 void ParseCapability(const uint32_t *_instruction, spv::Capability *capability);
62 void ParseTypeVoid(const uint32_t *_instruction, IdResult *idResult1);
63 void ParseTypeBool(const uint32_t *_instruction, IdResult *idResult1);
64 void ParseTypeInt(const uint32_t *_instruction,
65                   IdResult *idResult1,
66                   LiteralInteger *width,
67                   LiteralInteger *signedness);
68 void ParseTypeFloat(const uint32_t *_instruction,
69                     IdResult *idResult1,
70                     LiteralInteger *width,
71                     spv::FPEncoding *floatingPointEncoding);
72 void ParseTypeVector(const uint32_t *_instruction,
73                      IdResult *idResult1,
74                      IdRef *componentType,
75                      LiteralInteger *componentCount);
76 void ParseTypeMatrix(const uint32_t *_instruction,
77                      IdResult *idResult1,
78                      IdRef *columnType,
79                      LiteralInteger *columnCount);
80 void ParseTypeImage(const uint32_t *_instruction,
81                     IdResult *idResult1,
82                     IdRef *sampledType,
83                     spv::Dim *dim3,
84                     LiteralInteger *depth,
85                     LiteralInteger *arrayed,
86                     LiteralInteger *mS,
87                     LiteralInteger *sampled,
88                     spv::ImageFormat *imageFormat8,
89                     spv::AccessQualifier *accessQualifier9);
90 void ParseTypeSampler(const uint32_t *_instruction, IdResult *idResult1);
91 void ParseTypeSampledImage(const uint32_t *_instruction, IdResult *idResult1, IdRef *imageType);
92 void ParseTypeArray(const uint32_t *_instruction,
93                     IdResult *idResult1,
94                     IdRef *elementType,
95                     IdRef *length);
96 void ParseTypeRuntimeArray(const uint32_t *_instruction, IdResult *idResult1, IdRef *elementType);
97 void ParseTypeStruct(const uint32_t *_instruction, IdResult *idResult1, IdRefList *memberList);
98 void ParseTypePointer(const uint32_t *_instruction,
99                       IdResult *idResult1,
100                       spv::StorageClass *storageClass2,
101                       IdRef *type);
102 void ParseTypeFunction(const uint32_t *_instruction,
103                        IdResult *idResult1,
104                        IdRef *returnType,
105                        IdRefList *parameterList);
106 void ParseConstantTrue(const uint32_t *_instruction,
107                        IdResultType *idResultType1,
108                        IdResult *idResult2);
109 void ParseConstantFalse(const uint32_t *_instruction,
110                         IdResultType *idResultType1,
111                         IdResult *idResult2);
112 void ParseConstant(const uint32_t *_instruction,
113                    IdResultType *idResultType1,
114                    IdResult *idResult2,
115                    LiteralContextDependentNumber *value);
116 void ParseConstantComposite(const uint32_t *_instruction,
117                             IdResultType *idResultType1,
118                             IdResult *idResult2,
119                             IdRefList *constituentsList);
120 void ParseConstantNull(const uint32_t *_instruction,
121                        IdResultType *idResultType1,
122                        IdResult *idResult2);
123 void ParseSpecConstantTrue(const uint32_t *_instruction,
124                            IdResultType *idResultType1,
125                            IdResult *idResult2);
126 void ParseSpecConstantFalse(const uint32_t *_instruction,
127                             IdResultType *idResultType1,
128                             IdResult *idResult2);
129 void ParseSpecConstant(const uint32_t *_instruction,
130                        IdResultType *idResultType1,
131                        IdResult *idResult2,
132                        LiteralContextDependentNumber *value);
133 void ParseSpecConstantComposite(const uint32_t *_instruction,
134                                 IdResultType *idResultType1,
135                                 IdResult *idResult2,
136                                 IdRefList *constituentsList);
137 void ParseFunction(const uint32_t *_instruction,
138                    IdResultType *idResultType1,
139                    IdResult *idResult2,
140                    spv::FunctionControlMask *functionControl3,
141                    IdRef *functionType);
142 void ParseFunctionParameter(const uint32_t *_instruction,
143                             IdResultType *idResultType1,
144                             IdResult *idResult2);
145 void ParseFunctionCall(const uint32_t *_instruction,
146                        IdResultType *idResultType1,
147                        IdResult *idResult2,
148                        IdRef *function,
149                        IdRefList *argumentList);
150 void ParseVariable(const uint32_t *_instruction,
151                    IdResultType *idResultType1,
152                    IdResult *idResult2,
153                    spv::StorageClass *storageClass3,
154                    IdRef *initializer);
155 void ParseImageTexelPointer(const uint32_t *_instruction,
156                             IdResultType *idResultType1,
157                             IdResult *idResult2,
158                             IdRef *image,
159                             IdRef *coordinate,
160                             IdRef *sample);
161 void ParseLoad(const uint32_t *_instruction,
162                IdResultType *idResultType1,
163                IdResult *idResult2,
164                IdRef *pointer,
165                spv::MemoryAccessMask *memoryAccess4);
166 void ParseStore(const uint32_t *_instruction,
167                 IdRef *pointer,
168                 IdRef *object,
169                 spv::MemoryAccessMask *memoryAccess3);
170 void ParseCopyMemory(const uint32_t *_instruction,
171                      IdRef *target,
172                      IdRef *source,
173                      spv::MemoryAccessMask *memoryAccess3,
174                      spv::MemoryAccessMask *memoryAccess4);
175 void ParseAccessChain(const uint32_t *_instruction,
176                       IdResultType *idResultType1,
177                       IdResult *idResult2,
178                       IdRef *base,
179                       IdRefList *indexesList);
180 void ParseInBoundsAccessChain(const uint32_t *_instruction,
181                               IdResultType *idResultType1,
182                               IdResult *idResult2,
183                               IdRef *base,
184                               IdRefList *indexesList);
185 void ParseArrayLength(const uint32_t *_instruction,
186                       IdResultType *idResultType1,
187                       IdResult *idResult2,
188                       IdRef *structure,
189                       LiteralInteger *arraymember);
190 void ParseDecorate(const uint32_t *_instruction,
191                    IdRef *target,
192                    spv::Decoration *decoration2,
193                    LiteralIntegerList *valuesList);
194 void ParseMemberDecorate(const uint32_t *_instruction,
195                          IdRef *structureType,
196                          LiteralInteger *member,
197                          spv::Decoration *decoration3,
198                          LiteralIntegerList *valuesList);
199 void ParseDecorationGroup(const uint32_t *_instruction, IdResult *idResult1);
200 void ParseGroupDecorate(const uint32_t *_instruction,
201                         IdRef *decorationGroup,
202                         IdRefList *targetsList);
203 void ParseGroupMemberDecorate(const uint32_t *_instruction,
204                               IdRef *decorationGroup,
205                               PairIdRefLiteralIntegerList *targetsPairList);
206 void ParseVectorExtractDynamic(const uint32_t *_instruction,
207                                IdResultType *idResultType1,
208                                IdResult *idResult2,
209                                IdRef *vector,
210                                IdRef *index);
211 void ParseVectorInsertDynamic(const uint32_t *_instruction,
212                               IdResultType *idResultType1,
213                               IdResult *idResult2,
214                               IdRef *vector,
215                               IdRef *component,
216                               IdRef *index);
217 void ParseVectorShuffle(const uint32_t *_instruction,
218                         IdResultType *idResultType1,
219                         IdResult *idResult2,
220                         IdRef *vector1,
221                         IdRef *vector2,
222                         LiteralIntegerList *componentsList);
223 void ParseCompositeConstruct(const uint32_t *_instruction,
224                              IdResultType *idResultType1,
225                              IdResult *idResult2,
226                              IdRefList *constituentsList);
227 void ParseCompositeExtract(const uint32_t *_instruction,
228                            IdResultType *idResultType1,
229                            IdResult *idResult2,
230                            IdRef *composite,
231                            LiteralIntegerList *indexesList);
232 void ParseCompositeInsert(const uint32_t *_instruction,
233                           IdResultType *idResultType1,
234                           IdResult *idResult2,
235                           IdRef *object,
236                           IdRef *composite,
237                           LiteralIntegerList *indexesList);
238 void ParseCopyObject(const uint32_t *_instruction,
239                      IdResultType *idResultType1,
240                      IdResult *idResult2,
241                      IdRef *operand);
242 void ParseTranspose(const uint32_t *_instruction,
243                     IdResultType *idResultType1,
244                     IdResult *idResult2,
245                     IdRef *matrix);
246 void ParseSampledImage(const uint32_t *_instruction,
247                        IdResultType *idResultType1,
248                        IdResult *idResult2,
249                        IdRef *image,
250                        IdRef *sampler);
251 void ParseImageSampleImplicitLod(const uint32_t *_instruction,
252                                  IdResultType *idResultType1,
253                                  IdResult *idResult2,
254                                  IdRef *sampledImage,
255                                  IdRef *coordinate,
256                                  spv::ImageOperandsMask *imageOperands5,
257                                  IdRefList *imageOperandIdsList);
258 void ParseImageSampleExplicitLod(const uint32_t *_instruction,
259                                  IdResultType *idResultType1,
260                                  IdResult *idResult2,
261                                  IdRef *sampledImage,
262                                  IdRef *coordinate,
263                                  spv::ImageOperandsMask *imageOperands5,
264                                  IdRefList *imageOperandIdsList);
265 void ParseImageSampleDrefImplicitLod(const uint32_t *_instruction,
266                                      IdResultType *idResultType1,
267                                      IdResult *idResult2,
268                                      IdRef *sampledImage,
269                                      IdRef *coordinate,
270                                      IdRef *dref,
271                                      spv::ImageOperandsMask *imageOperands6,
272                                      IdRefList *imageOperandIdsList);
273 void ParseImageSampleDrefExplicitLod(const uint32_t *_instruction,
274                                      IdResultType *idResultType1,
275                                      IdResult *idResult2,
276                                      IdRef *sampledImage,
277                                      IdRef *coordinate,
278                                      IdRef *dref,
279                                      spv::ImageOperandsMask *imageOperands6,
280                                      IdRefList *imageOperandIdsList);
281 void ParseImageSampleProjImplicitLod(const uint32_t *_instruction,
282                                      IdResultType *idResultType1,
283                                      IdResult *idResult2,
284                                      IdRef *sampledImage,
285                                      IdRef *coordinate,
286                                      spv::ImageOperandsMask *imageOperands5,
287                                      IdRefList *imageOperandIdsList);
288 void ParseImageSampleProjExplicitLod(const uint32_t *_instruction,
289                                      IdResultType *idResultType1,
290                                      IdResult *idResult2,
291                                      IdRef *sampledImage,
292                                      IdRef *coordinate,
293                                      spv::ImageOperandsMask *imageOperands5,
294                                      IdRefList *imageOperandIdsList);
295 void ParseImageSampleProjDrefImplicitLod(const uint32_t *_instruction,
296                                          IdResultType *idResultType1,
297                                          IdResult *idResult2,
298                                          IdRef *sampledImage,
299                                          IdRef *coordinate,
300                                          IdRef *dref,
301                                          spv::ImageOperandsMask *imageOperands6,
302                                          IdRefList *imageOperandIdsList);
303 void ParseImageSampleProjDrefExplicitLod(const uint32_t *_instruction,
304                                          IdResultType *idResultType1,
305                                          IdResult *idResult2,
306                                          IdRef *sampledImage,
307                                          IdRef *coordinate,
308                                          IdRef *dref,
309                                          spv::ImageOperandsMask *imageOperands6,
310                                          IdRefList *imageOperandIdsList);
311 void ParseImageFetch(const uint32_t *_instruction,
312                      IdResultType *idResultType1,
313                      IdResult *idResult2,
314                      IdRef *image,
315                      IdRef *coordinate,
316                      spv::ImageOperandsMask *imageOperands5,
317                      IdRefList *imageOperandIdsList);
318 void ParseImageGather(const uint32_t *_instruction,
319                       IdResultType *idResultType1,
320                       IdResult *idResult2,
321                       IdRef *sampledImage,
322                       IdRef *coordinate,
323                       IdRef *component,
324                       spv::ImageOperandsMask *imageOperands6,
325                       IdRefList *imageOperandIdsList);
326 void ParseImageDrefGather(const uint32_t *_instruction,
327                           IdResultType *idResultType1,
328                           IdResult *idResult2,
329                           IdRef *sampledImage,
330                           IdRef *coordinate,
331                           IdRef *dref,
332                           spv::ImageOperandsMask *imageOperands6,
333                           IdRefList *imageOperandIdsList);
334 void ParseImageRead(const uint32_t *_instruction,
335                     IdResultType *idResultType1,
336                     IdResult *idResult2,
337                     IdRef *image,
338                     IdRef *coordinate,
339                     spv::ImageOperandsMask *imageOperands5,
340                     IdRefList *imageOperandIdsList);
341 void ParseImageWrite(const uint32_t *_instruction,
342                      IdRef *image,
343                      IdRef *coordinate,
344                      IdRef *texel,
345                      spv::ImageOperandsMask *imageOperands4,
346                      IdRefList *imageOperandIdsList);
347 void ParseImage(const uint32_t *_instruction,
348                 IdResultType *idResultType1,
349                 IdResult *idResult2,
350                 IdRef *sampledImage);
351 void ParseImageQuerySizeLod(const uint32_t *_instruction,
352                             IdResultType *idResultType1,
353                             IdResult *idResult2,
354                             IdRef *image,
355                             IdRef *levelofDetail);
356 void ParseImageQuerySize(const uint32_t *_instruction,
357                          IdResultType *idResultType1,
358                          IdResult *idResult2,
359                          IdRef *image);
360 void ParseImageQueryLod(const uint32_t *_instruction,
361                         IdResultType *idResultType1,
362                         IdResult *idResult2,
363                         IdRef *sampledImage,
364                         IdRef *coordinate);
365 void ParseImageQueryLevels(const uint32_t *_instruction,
366                            IdResultType *idResultType1,
367                            IdResult *idResult2,
368                            IdRef *image);
369 void ParseImageQuerySamples(const uint32_t *_instruction,
370                             IdResultType *idResultType1,
371                             IdResult *idResult2,
372                             IdRef *image);
373 void ParseConvertFToU(const uint32_t *_instruction,
374                       IdResultType *idResultType1,
375                       IdResult *idResult2,
376                       IdRef *floatValue);
377 void ParseConvertFToS(const uint32_t *_instruction,
378                       IdResultType *idResultType1,
379                       IdResult *idResult2,
380                       IdRef *floatValue);
381 void ParseConvertSToF(const uint32_t *_instruction,
382                       IdResultType *idResultType1,
383                       IdResult *idResult2,
384                       IdRef *signedValue);
385 void ParseConvertUToF(const uint32_t *_instruction,
386                       IdResultType *idResultType1,
387                       IdResult *idResult2,
388                       IdRef *unsignedValue);
389 void ParseUConvert(const uint32_t *_instruction,
390                    IdResultType *idResultType1,
391                    IdResult *idResult2,
392                    IdRef *unsignedValue);
393 void ParseSConvert(const uint32_t *_instruction,
394                    IdResultType *idResultType1,
395                    IdResult *idResult2,
396                    IdRef *signedValue);
397 void ParseFConvert(const uint32_t *_instruction,
398                    IdResultType *idResultType1,
399                    IdResult *idResult2,
400                    IdRef *floatValue);
401 void ParseQuantizeToF16(const uint32_t *_instruction,
402                         IdResultType *idResultType1,
403                         IdResult *idResult2,
404                         IdRef *value);
405 void ParseBitcast(const uint32_t *_instruction,
406                   IdResultType *idResultType1,
407                   IdResult *idResult2,
408                   IdRef *operand);
409 void ParseSNegate(const uint32_t *_instruction,
410                   IdResultType *idResultType1,
411                   IdResult *idResult2,
412                   IdRef *operand);
413 void ParseFNegate(const uint32_t *_instruction,
414                   IdResultType *idResultType1,
415                   IdResult *idResult2,
416                   IdRef *operand);
417 void ParseIAdd(const uint32_t *_instruction,
418                IdResultType *idResultType1,
419                IdResult *idResult2,
420                IdRef *operand1,
421                IdRef *operand2);
422 void ParseFAdd(const uint32_t *_instruction,
423                IdResultType *idResultType1,
424                IdResult *idResult2,
425                IdRef *operand1,
426                IdRef *operand2);
427 void ParseISub(const uint32_t *_instruction,
428                IdResultType *idResultType1,
429                IdResult *idResult2,
430                IdRef *operand1,
431                IdRef *operand2);
432 void ParseFSub(const uint32_t *_instruction,
433                IdResultType *idResultType1,
434                IdResult *idResult2,
435                IdRef *operand1,
436                IdRef *operand2);
437 void ParseIMul(const uint32_t *_instruction,
438                IdResultType *idResultType1,
439                IdResult *idResult2,
440                IdRef *operand1,
441                IdRef *operand2);
442 void ParseFMul(const uint32_t *_instruction,
443                IdResultType *idResultType1,
444                IdResult *idResult2,
445                IdRef *operand1,
446                IdRef *operand2);
447 void ParseUDiv(const uint32_t *_instruction,
448                IdResultType *idResultType1,
449                IdResult *idResult2,
450                IdRef *operand1,
451                IdRef *operand2);
452 void ParseSDiv(const uint32_t *_instruction,
453                IdResultType *idResultType1,
454                IdResult *idResult2,
455                IdRef *operand1,
456                IdRef *operand2);
457 void ParseFDiv(const uint32_t *_instruction,
458                IdResultType *idResultType1,
459                IdResult *idResult2,
460                IdRef *operand1,
461                IdRef *operand2);
462 void ParseUMod(const uint32_t *_instruction,
463                IdResultType *idResultType1,
464                IdResult *idResult2,
465                IdRef *operand1,
466                IdRef *operand2);
467 void ParseSRem(const uint32_t *_instruction,
468                IdResultType *idResultType1,
469                IdResult *idResult2,
470                IdRef *operand1,
471                IdRef *operand2);
472 void ParseSMod(const uint32_t *_instruction,
473                IdResultType *idResultType1,
474                IdResult *idResult2,
475                IdRef *operand1,
476                IdRef *operand2);
477 void ParseFRem(const uint32_t *_instruction,
478                IdResultType *idResultType1,
479                IdResult *idResult2,
480                IdRef *operand1,
481                IdRef *operand2);
482 void ParseFMod(const uint32_t *_instruction,
483                IdResultType *idResultType1,
484                IdResult *idResult2,
485                IdRef *operand1,
486                IdRef *operand2);
487 void ParseVectorTimesScalar(const uint32_t *_instruction,
488                             IdResultType *idResultType1,
489                             IdResult *idResult2,
490                             IdRef *vector,
491                             IdRef *scalar);
492 void ParseMatrixTimesScalar(const uint32_t *_instruction,
493                             IdResultType *idResultType1,
494                             IdResult *idResult2,
495                             IdRef *matrix,
496                             IdRef *scalar);
497 void ParseVectorTimesMatrix(const uint32_t *_instruction,
498                             IdResultType *idResultType1,
499                             IdResult *idResult2,
500                             IdRef *vector,
501                             IdRef *matrix);
502 void ParseMatrixTimesVector(const uint32_t *_instruction,
503                             IdResultType *idResultType1,
504                             IdResult *idResult2,
505                             IdRef *matrix,
506                             IdRef *vector);
507 void ParseMatrixTimesMatrix(const uint32_t *_instruction,
508                             IdResultType *idResultType1,
509                             IdResult *idResult2,
510                             IdRef *leftMatrix,
511                             IdRef *rightMatrix);
512 void ParseOuterProduct(const uint32_t *_instruction,
513                        IdResultType *idResultType1,
514                        IdResult *idResult2,
515                        IdRef *vector1,
516                        IdRef *vector2);
517 void ParseDot(const uint32_t *_instruction,
518               IdResultType *idResultType1,
519               IdResult *idResult2,
520               IdRef *vector1,
521               IdRef *vector2);
522 void ParseIAddCarry(const uint32_t *_instruction,
523                     IdResultType *idResultType1,
524                     IdResult *idResult2,
525                     IdRef *operand1,
526                     IdRef *operand2);
527 void ParseISubBorrow(const uint32_t *_instruction,
528                      IdResultType *idResultType1,
529                      IdResult *idResult2,
530                      IdRef *operand1,
531                      IdRef *operand2);
532 void ParseUMulExtended(const uint32_t *_instruction,
533                        IdResultType *idResultType1,
534                        IdResult *idResult2,
535                        IdRef *operand1,
536                        IdRef *operand2);
537 void ParseSMulExtended(const uint32_t *_instruction,
538                        IdResultType *idResultType1,
539                        IdResult *idResult2,
540                        IdRef *operand1,
541                        IdRef *operand2);
542 void ParseAny(const uint32_t *_instruction,
543               IdResultType *idResultType1,
544               IdResult *idResult2,
545               IdRef *vector);
546 void ParseAll(const uint32_t *_instruction,
547               IdResultType *idResultType1,
548               IdResult *idResult2,
549               IdRef *vector);
550 void ParseIsNan(const uint32_t *_instruction,
551                 IdResultType *idResultType1,
552                 IdResult *idResult2,
553                 IdRef *x);
554 void ParseIsInf(const uint32_t *_instruction,
555                 IdResultType *idResultType1,
556                 IdResult *idResult2,
557                 IdRef *x);
558 void ParseLogicalEqual(const uint32_t *_instruction,
559                        IdResultType *idResultType1,
560                        IdResult *idResult2,
561                        IdRef *operand1,
562                        IdRef *operand2);
563 void ParseLogicalNotEqual(const uint32_t *_instruction,
564                           IdResultType *idResultType1,
565                           IdResult *idResult2,
566                           IdRef *operand1,
567                           IdRef *operand2);
568 void ParseLogicalOr(const uint32_t *_instruction,
569                     IdResultType *idResultType1,
570                     IdResult *idResult2,
571                     IdRef *operand1,
572                     IdRef *operand2);
573 void ParseLogicalAnd(const uint32_t *_instruction,
574                      IdResultType *idResultType1,
575                      IdResult *idResult2,
576                      IdRef *operand1,
577                      IdRef *operand2);
578 void ParseLogicalNot(const uint32_t *_instruction,
579                      IdResultType *idResultType1,
580                      IdResult *idResult2,
581                      IdRef *operand);
582 void ParseSelect(const uint32_t *_instruction,
583                  IdResultType *idResultType1,
584                  IdResult *idResult2,
585                  IdRef *condition,
586                  IdRef *object1,
587                  IdRef *object2);
588 void ParseIEqual(const uint32_t *_instruction,
589                  IdResultType *idResultType1,
590                  IdResult *idResult2,
591                  IdRef *operand1,
592                  IdRef *operand2);
593 void ParseINotEqual(const uint32_t *_instruction,
594                     IdResultType *idResultType1,
595                     IdResult *idResult2,
596                     IdRef *operand1,
597                     IdRef *operand2);
598 void ParseUGreaterThan(const uint32_t *_instruction,
599                        IdResultType *idResultType1,
600                        IdResult *idResult2,
601                        IdRef *operand1,
602                        IdRef *operand2);
603 void ParseSGreaterThan(const uint32_t *_instruction,
604                        IdResultType *idResultType1,
605                        IdResult *idResult2,
606                        IdRef *operand1,
607                        IdRef *operand2);
608 void ParseUGreaterThanEqual(const uint32_t *_instruction,
609                             IdResultType *idResultType1,
610                             IdResult *idResult2,
611                             IdRef *operand1,
612                             IdRef *operand2);
613 void ParseSGreaterThanEqual(const uint32_t *_instruction,
614                             IdResultType *idResultType1,
615                             IdResult *idResult2,
616                             IdRef *operand1,
617                             IdRef *operand2);
618 void ParseULessThan(const uint32_t *_instruction,
619                     IdResultType *idResultType1,
620                     IdResult *idResult2,
621                     IdRef *operand1,
622                     IdRef *operand2);
623 void ParseSLessThan(const uint32_t *_instruction,
624                     IdResultType *idResultType1,
625                     IdResult *idResult2,
626                     IdRef *operand1,
627                     IdRef *operand2);
628 void ParseULessThanEqual(const uint32_t *_instruction,
629                          IdResultType *idResultType1,
630                          IdResult *idResult2,
631                          IdRef *operand1,
632                          IdRef *operand2);
633 void ParseSLessThanEqual(const uint32_t *_instruction,
634                          IdResultType *idResultType1,
635                          IdResult *idResult2,
636                          IdRef *operand1,
637                          IdRef *operand2);
638 void ParseFOrdEqual(const uint32_t *_instruction,
639                     IdResultType *idResultType1,
640                     IdResult *idResult2,
641                     IdRef *operand1,
642                     IdRef *operand2);
643 void ParseFUnordEqual(const uint32_t *_instruction,
644                       IdResultType *idResultType1,
645                       IdResult *idResult2,
646                       IdRef *operand1,
647                       IdRef *operand2);
648 void ParseFOrdNotEqual(const uint32_t *_instruction,
649                        IdResultType *idResultType1,
650                        IdResult *idResult2,
651                        IdRef *operand1,
652                        IdRef *operand2);
653 void ParseFUnordNotEqual(const uint32_t *_instruction,
654                          IdResultType *idResultType1,
655                          IdResult *idResult2,
656                          IdRef *operand1,
657                          IdRef *operand2);
658 void ParseFOrdLessThan(const uint32_t *_instruction,
659                        IdResultType *idResultType1,
660                        IdResult *idResult2,
661                        IdRef *operand1,
662                        IdRef *operand2);
663 void ParseFUnordLessThan(const uint32_t *_instruction,
664                          IdResultType *idResultType1,
665                          IdResult *idResult2,
666                          IdRef *operand1,
667                          IdRef *operand2);
668 void ParseFOrdGreaterThan(const uint32_t *_instruction,
669                           IdResultType *idResultType1,
670                           IdResult *idResult2,
671                           IdRef *operand1,
672                           IdRef *operand2);
673 void ParseFUnordGreaterThan(const uint32_t *_instruction,
674                             IdResultType *idResultType1,
675                             IdResult *idResult2,
676                             IdRef *operand1,
677                             IdRef *operand2);
678 void ParseFOrdLessThanEqual(const uint32_t *_instruction,
679                             IdResultType *idResultType1,
680                             IdResult *idResult2,
681                             IdRef *operand1,
682                             IdRef *operand2);
683 void ParseFUnordLessThanEqual(const uint32_t *_instruction,
684                               IdResultType *idResultType1,
685                               IdResult *idResult2,
686                               IdRef *operand1,
687                               IdRef *operand2);
688 void ParseFOrdGreaterThanEqual(const uint32_t *_instruction,
689                                IdResultType *idResultType1,
690                                IdResult *idResult2,
691                                IdRef *operand1,
692                                IdRef *operand2);
693 void ParseFUnordGreaterThanEqual(const uint32_t *_instruction,
694                                  IdResultType *idResultType1,
695                                  IdResult *idResult2,
696                                  IdRef *operand1,
697                                  IdRef *operand2);
698 void ParseShiftRightLogical(const uint32_t *_instruction,
699                             IdResultType *idResultType1,
700                             IdResult *idResult2,
701                             IdRef *base,
702                             IdRef *shift);
703 void ParseShiftRightArithmetic(const uint32_t *_instruction,
704                                IdResultType *idResultType1,
705                                IdResult *idResult2,
706                                IdRef *base,
707                                IdRef *shift);
708 void ParseShiftLeftLogical(const uint32_t *_instruction,
709                            IdResultType *idResultType1,
710                            IdResult *idResult2,
711                            IdRef *base,
712                            IdRef *shift);
713 void ParseBitwiseOr(const uint32_t *_instruction,
714                     IdResultType *idResultType1,
715                     IdResult *idResult2,
716                     IdRef *operand1,
717                     IdRef *operand2);
718 void ParseBitwiseXor(const uint32_t *_instruction,
719                      IdResultType *idResultType1,
720                      IdResult *idResult2,
721                      IdRef *operand1,
722                      IdRef *operand2);
723 void ParseBitwiseAnd(const uint32_t *_instruction,
724                      IdResultType *idResultType1,
725                      IdResult *idResult2,
726                      IdRef *operand1,
727                      IdRef *operand2);
728 void ParseNot(const uint32_t *_instruction,
729               IdResultType *idResultType1,
730               IdResult *idResult2,
731               IdRef *operand);
732 void ParseBitFieldInsert(const uint32_t *_instruction,
733                          IdResultType *idResultType1,
734                          IdResult *idResult2,
735                          IdRef *base,
736                          IdRef *insert,
737                          IdRef *offset,
738                          IdRef *count);
739 void ParseBitFieldSExtract(const uint32_t *_instruction,
740                            IdResultType *idResultType1,
741                            IdResult *idResult2,
742                            IdRef *base,
743                            IdRef *offset,
744                            IdRef *count);
745 void ParseBitFieldUExtract(const uint32_t *_instruction,
746                            IdResultType *idResultType1,
747                            IdResult *idResult2,
748                            IdRef *base,
749                            IdRef *offset,
750                            IdRef *count);
751 void ParseBitReverse(const uint32_t *_instruction,
752                      IdResultType *idResultType1,
753                      IdResult *idResult2,
754                      IdRef *base);
755 void ParseBitCount(const uint32_t *_instruction,
756                    IdResultType *idResultType1,
757                    IdResult *idResult2,
758                    IdRef *base);
759 void ParseDPdx(const uint32_t *_instruction,
760                IdResultType *idResultType1,
761                IdResult *idResult2,
762                IdRef *p);
763 void ParseDPdy(const uint32_t *_instruction,
764                IdResultType *idResultType1,
765                IdResult *idResult2,
766                IdRef *p);
767 void ParseFwidth(const uint32_t *_instruction,
768                  IdResultType *idResultType1,
769                  IdResult *idResult2,
770                  IdRef *p);
771 void ParseDPdxFine(const uint32_t *_instruction,
772                    IdResultType *idResultType1,
773                    IdResult *idResult2,
774                    IdRef *p);
775 void ParseDPdyFine(const uint32_t *_instruction,
776                    IdResultType *idResultType1,
777                    IdResult *idResult2,
778                    IdRef *p);
779 void ParseFwidthFine(const uint32_t *_instruction,
780                      IdResultType *idResultType1,
781                      IdResult *idResult2,
782                      IdRef *p);
783 void ParseDPdxCoarse(const uint32_t *_instruction,
784                      IdResultType *idResultType1,
785                      IdResult *idResult2,
786                      IdRef *p);
787 void ParseDPdyCoarse(const uint32_t *_instruction,
788                      IdResultType *idResultType1,
789                      IdResult *idResult2,
790                      IdRef *p);
791 void ParseFwidthCoarse(const uint32_t *_instruction,
792                        IdResultType *idResultType1,
793                        IdResult *idResult2,
794                        IdRef *p);
795 void ParseEmitStreamVertex(const uint32_t *_instruction, IdRef *stream);
796 void ParseEndStreamPrimitive(const uint32_t *_instruction, IdRef *stream);
797 void ParseControlBarrier(const uint32_t *_instruction,
798                          IdScope *execution,
799                          IdScope *memory,
800                          IdMemorySemantics *semantics);
801 void ParseMemoryBarrier(const uint32_t *_instruction,
802                         IdScope *memory,
803                         IdMemorySemantics *semantics);
804 void ParseAtomicLoad(const uint32_t *_instruction,
805                      IdResultType *idResultType1,
806                      IdResult *idResult2,
807                      IdRef *pointer,
808                      IdScope *memory,
809                      IdMemorySemantics *semantics);
810 void ParseAtomicStore(const uint32_t *_instruction,
811                       IdRef *pointer,
812                       IdScope *memory,
813                       IdMemorySemantics *semantics,
814                       IdRef *value);
815 void ParseAtomicExchange(const uint32_t *_instruction,
816                          IdResultType *idResultType1,
817                          IdResult *idResult2,
818                          IdRef *pointer,
819                          IdScope *memory,
820                          IdMemorySemantics *semantics,
821                          IdRef *value);
822 void ParseAtomicCompareExchange(const uint32_t *_instruction,
823                                 IdResultType *idResultType1,
824                                 IdResult *idResult2,
825                                 IdRef *pointer,
826                                 IdScope *memory,
827                                 IdMemorySemantics *equal,
828                                 IdMemorySemantics *unequal,
829                                 IdRef *value,
830                                 IdRef *comparator);
831 void ParseAtomicIIncrement(const uint32_t *_instruction,
832                            IdResultType *idResultType1,
833                            IdResult *idResult2,
834                            IdRef *pointer,
835                            IdScope *memory,
836                            IdMemorySemantics *semantics);
837 void ParseAtomicIDecrement(const uint32_t *_instruction,
838                            IdResultType *idResultType1,
839                            IdResult *idResult2,
840                            IdRef *pointer,
841                            IdScope *memory,
842                            IdMemorySemantics *semantics);
843 void ParseAtomicIAdd(const uint32_t *_instruction,
844                      IdResultType *idResultType1,
845                      IdResult *idResult2,
846                      IdRef *pointer,
847                      IdScope *memory,
848                      IdMemorySemantics *semantics,
849                      IdRef *value);
850 void ParseAtomicISub(const uint32_t *_instruction,
851                      IdResultType *idResultType1,
852                      IdResult *idResult2,
853                      IdRef *pointer,
854                      IdScope *memory,
855                      IdMemorySemantics *semantics,
856                      IdRef *value);
857 void ParseAtomicSMin(const uint32_t *_instruction,
858                      IdResultType *idResultType1,
859                      IdResult *idResult2,
860                      IdRef *pointer,
861                      IdScope *memory,
862                      IdMemorySemantics *semantics,
863                      IdRef *value);
864 void ParseAtomicUMin(const uint32_t *_instruction,
865                      IdResultType *idResultType1,
866                      IdResult *idResult2,
867                      IdRef *pointer,
868                      IdScope *memory,
869                      IdMemorySemantics *semantics,
870                      IdRef *value);
871 void ParseAtomicSMax(const uint32_t *_instruction,
872                      IdResultType *idResultType1,
873                      IdResult *idResult2,
874                      IdRef *pointer,
875                      IdScope *memory,
876                      IdMemorySemantics *semantics,
877                      IdRef *value);
878 void ParseAtomicUMax(const uint32_t *_instruction,
879                      IdResultType *idResultType1,
880                      IdResult *idResult2,
881                      IdRef *pointer,
882                      IdScope *memory,
883                      IdMemorySemantics *semantics,
884                      IdRef *value);
885 void ParseAtomicAnd(const uint32_t *_instruction,
886                     IdResultType *idResultType1,
887                     IdResult *idResult2,
888                     IdRef *pointer,
889                     IdScope *memory,
890                     IdMemorySemantics *semantics,
891                     IdRef *value);
892 void ParseAtomicOr(const uint32_t *_instruction,
893                    IdResultType *idResultType1,
894                    IdResult *idResult2,
895                    IdRef *pointer,
896                    IdScope *memory,
897                    IdMemorySemantics *semantics,
898                    IdRef *value);
899 void ParseAtomicXor(const uint32_t *_instruction,
900                     IdResultType *idResultType1,
901                     IdResult *idResult2,
902                     IdRef *pointer,
903                     IdScope *memory,
904                     IdMemorySemantics *semantics,
905                     IdRef *value);
906 void ParsePhi(const uint32_t *_instruction,
907               IdResultType *idResultType1,
908               IdResult *idResult2,
909               PairIdRefIdRefList *variableParentPairList);
910 void ParseLoopMerge(const uint32_t *_instruction,
911                     IdRef *mergeBlock,
912                     IdRef *continueTarget,
913                     spv::LoopControlMask *loopControl3);
914 void ParseSelectionMerge(const uint32_t *_instruction,
915                          IdRef *mergeBlock,
916                          spv::SelectionControlMask *selectionControl2);
917 void ParseLabel(const uint32_t *_instruction, IdResult *idResult1);
918 void ParseBranch(const uint32_t *_instruction, IdRef *targetLabel);
919 void ParseBranchConditional(const uint32_t *_instruction,
920                             IdRef *condition,
921                             IdRef *trueLabel,
922                             IdRef *falseLabel,
923                             LiteralIntegerList *branchweightsList);
924 void ParseSwitch(const uint32_t *_instruction,
925                  IdRef *selector,
926                  IdRef *default_,
927                  PairLiteralIntegerIdRefList *targetPairList);
928 void ParseReturnValue(const uint32_t *_instruction, IdRef *value);
929 void ParseImageSparseSampleImplicitLod(const uint32_t *_instruction,
930                                        IdResultType *idResultType1,
931                                        IdResult *idResult2,
932                                        IdRef *sampledImage,
933                                        IdRef *coordinate,
934                                        spv::ImageOperandsMask *imageOperands5,
935                                        IdRefList *imageOperandIdsList);
936 void ParseImageSparseSampleExplicitLod(const uint32_t *_instruction,
937                                        IdResultType *idResultType1,
938                                        IdResult *idResult2,
939                                        IdRef *sampledImage,
940                                        IdRef *coordinate,
941                                        spv::ImageOperandsMask *imageOperands5,
942                                        IdRefList *imageOperandIdsList);
943 void ParseImageSparseSampleDrefImplicitLod(const uint32_t *_instruction,
944                                            IdResultType *idResultType1,
945                                            IdResult *idResult2,
946                                            IdRef *sampledImage,
947                                            IdRef *coordinate,
948                                            IdRef *dref,
949                                            spv::ImageOperandsMask *imageOperands6,
950                                            IdRefList *imageOperandIdsList);
951 void ParseImageSparseSampleDrefExplicitLod(const uint32_t *_instruction,
952                                            IdResultType *idResultType1,
953                                            IdResult *idResult2,
954                                            IdRef *sampledImage,
955                                            IdRef *coordinate,
956                                            IdRef *dref,
957                                            spv::ImageOperandsMask *imageOperands6,
958                                            IdRefList *imageOperandIdsList);
959 void ParseImageSparseSampleProjImplicitLod(const uint32_t *_instruction,
960                                            IdResultType *idResultType1,
961                                            IdResult *idResult2,
962                                            IdRef *sampledImage,
963                                            IdRef *coordinate,
964                                            spv::ImageOperandsMask *imageOperands5,
965                                            IdRefList *imageOperandIdsList);
966 void ParseImageSparseSampleProjExplicitLod(const uint32_t *_instruction,
967                                            IdResultType *idResultType1,
968                                            IdResult *idResult2,
969                                            IdRef *sampledImage,
970                                            IdRef *coordinate,
971                                            spv::ImageOperandsMask *imageOperands5,
972                                            IdRefList *imageOperandIdsList);
973 void ParseImageSparseSampleProjDrefImplicitLod(const uint32_t *_instruction,
974                                                IdResultType *idResultType1,
975                                                IdResult *idResult2,
976                                                IdRef *sampledImage,
977                                                IdRef *coordinate,
978                                                IdRef *dref,
979                                                spv::ImageOperandsMask *imageOperands6,
980                                                IdRefList *imageOperandIdsList);
981 void ParseImageSparseSampleProjDrefExplicitLod(const uint32_t *_instruction,
982                                                IdResultType *idResultType1,
983                                                IdResult *idResult2,
984                                                IdRef *sampledImage,
985                                                IdRef *coordinate,
986                                                IdRef *dref,
987                                                spv::ImageOperandsMask *imageOperands6,
988                                                IdRefList *imageOperandIdsList);
989 void ParseImageSparseFetch(const uint32_t *_instruction,
990                            IdResultType *idResultType1,
991                            IdResult *idResult2,
992                            IdRef *image,
993                            IdRef *coordinate,
994                            spv::ImageOperandsMask *imageOperands5,
995                            IdRefList *imageOperandIdsList);
996 void ParseImageSparseGather(const uint32_t *_instruction,
997                             IdResultType *idResultType1,
998                             IdResult *idResult2,
999                             IdRef *sampledImage,
1000                             IdRef *coordinate,
1001                             IdRef *component,
1002                             spv::ImageOperandsMask *imageOperands6,
1003                             IdRefList *imageOperandIdsList);
1004 void ParseImageSparseDrefGather(const uint32_t *_instruction,
1005                                 IdResultType *idResultType1,
1006                                 IdResult *idResult2,
1007                                 IdRef *sampledImage,
1008                                 IdRef *coordinate,
1009                                 IdRef *dref,
1010                                 spv::ImageOperandsMask *imageOperands6,
1011                                 IdRefList *imageOperandIdsList);
1012 void ParseImageSparseTexelsResident(const uint32_t *_instruction,
1013                                     IdResultType *idResultType1,
1014                                     IdResult *idResult2,
1015                                     IdRef *residentCode);
1016 void ParseImageSparseRead(const uint32_t *_instruction,
1017                           IdResultType *idResultType1,
1018                           IdResult *idResult2,
1019                           IdRef *image,
1020                           IdRef *coordinate,
1021                           spv::ImageOperandsMask *imageOperands5,
1022                           IdRefList *imageOperandIdsList);
1023 void ParseModuleProcessed(const uint32_t *_instruction, LiteralString *process);
1024 void ParseExecutionModeId(const uint32_t *_instruction,
1025                           IdRef *entryPoint,
1026                           spv::ExecutionMode *mode,
1027                           LiteralIntegerList *operandsList);
1028 void ParseGroupNonUniformElect(const uint32_t *_instruction,
1029                                IdResultType *idResultType1,
1030                                IdResult *idResult2,
1031                                IdScope *execution);
1032 void ParseGroupNonUniformAll(const uint32_t *_instruction,
1033                              IdResultType *idResultType1,
1034                              IdResult *idResult2,
1035                              IdScope *execution,
1036                              IdRef *predicate);
1037 void ParseGroupNonUniformAny(const uint32_t *_instruction,
1038                              IdResultType *idResultType1,
1039                              IdResult *idResult2,
1040                              IdScope *execution,
1041                              IdRef *predicate);
1042 void ParseGroupNonUniformAllEqual(const uint32_t *_instruction,
1043                                   IdResultType *idResultType1,
1044                                   IdResult *idResult2,
1045                                   IdScope *execution,
1046                                   IdRef *value);
1047 void ParseGroupNonUniformBroadcast(const uint32_t *_instruction,
1048                                    IdResultType *idResultType1,
1049                                    IdResult *idResult2,
1050                                    IdScope *execution,
1051                                    IdRef *value,
1052                                    IdRef *id);
1053 void ParseGroupNonUniformBroadcastFirst(const uint32_t *_instruction,
1054                                         IdResultType *idResultType1,
1055                                         IdResult *idResult2,
1056                                         IdScope *execution,
1057                                         IdRef *value);
1058 void ParseGroupNonUniformBallot(const uint32_t *_instruction,
1059                                 IdResultType *idResultType1,
1060                                 IdResult *idResult2,
1061                                 IdScope *execution,
1062                                 IdRef *predicate);
1063 void ParseGroupNonUniformInverseBallot(const uint32_t *_instruction,
1064                                        IdResultType *idResultType1,
1065                                        IdResult *idResult2,
1066                                        IdScope *execution,
1067                                        IdRef *value);
1068 void ParseGroupNonUniformBallotBitExtract(const uint32_t *_instruction,
1069                                           IdResultType *idResultType1,
1070                                           IdResult *idResult2,
1071                                           IdScope *execution,
1072                                           IdRef *value,
1073                                           IdRef *index);
1074 void ParseGroupNonUniformBallotBitCount(const uint32_t *_instruction,
1075                                         IdResultType *idResultType1,
1076                                         IdResult *idResult2,
1077                                         IdScope *execution,
1078                                         spv::GroupOperation *operation,
1079                                         IdRef *value);
1080 void ParseGroupNonUniformBallotFindLSB(const uint32_t *_instruction,
1081                                        IdResultType *idResultType1,
1082                                        IdResult *idResult2,
1083                                        IdScope *execution,
1084                                        IdRef *value);
1085 void ParseGroupNonUniformBallotFindMSB(const uint32_t *_instruction,
1086                                        IdResultType *idResultType1,
1087                                        IdResult *idResult2,
1088                                        IdScope *execution,
1089                                        IdRef *value);
1090 void ParseGroupNonUniformShuffle(const uint32_t *_instruction,
1091                                  IdResultType *idResultType1,
1092                                  IdResult *idResult2,
1093                                  IdScope *execution,
1094                                  IdRef *value,
1095                                  IdRef *id);
1096 void ParseGroupNonUniformShuffleXor(const uint32_t *_instruction,
1097                                     IdResultType *idResultType1,
1098                                     IdResult *idResult2,
1099                                     IdScope *execution,
1100                                     IdRef *value,
1101                                     IdRef *mask);
1102 void ParseGroupNonUniformShuffleUp(const uint32_t *_instruction,
1103                                    IdResultType *idResultType1,
1104                                    IdResult *idResult2,
1105                                    IdScope *execution,
1106                                    IdRef *value,
1107                                    IdRef *delta);
1108 void ParseGroupNonUniformShuffleDown(const uint32_t *_instruction,
1109                                      IdResultType *idResultType1,
1110                                      IdResult *idResult2,
1111                                      IdScope *execution,
1112                                      IdRef *value,
1113                                      IdRef *delta);
1114 void ParseGroupNonUniformIAdd(const uint32_t *_instruction,
1115                               IdResultType *idResultType1,
1116                               IdResult *idResult2,
1117                               IdScope *execution,
1118                               spv::GroupOperation *operation,
1119                               IdRef *value,
1120                               IdRef *clusterSize);
1121 void ParseGroupNonUniformFAdd(const uint32_t *_instruction,
1122                               IdResultType *idResultType1,
1123                               IdResult *idResult2,
1124                               IdScope *execution,
1125                               spv::GroupOperation *operation,
1126                               IdRef *value,
1127                               IdRef *clusterSize);
1128 void ParseGroupNonUniformIMul(const uint32_t *_instruction,
1129                               IdResultType *idResultType1,
1130                               IdResult *idResult2,
1131                               IdScope *execution,
1132                               spv::GroupOperation *operation,
1133                               IdRef *value,
1134                               IdRef *clusterSize);
1135 void ParseGroupNonUniformFMul(const uint32_t *_instruction,
1136                               IdResultType *idResultType1,
1137                               IdResult *idResult2,
1138                               IdScope *execution,
1139                               spv::GroupOperation *operation,
1140                               IdRef *value,
1141                               IdRef *clusterSize);
1142 void ParseGroupNonUniformSMin(const uint32_t *_instruction,
1143                               IdResultType *idResultType1,
1144                               IdResult *idResult2,
1145                               IdScope *execution,
1146                               spv::GroupOperation *operation,
1147                               IdRef *value,
1148                               IdRef *clusterSize);
1149 void ParseGroupNonUniformUMin(const uint32_t *_instruction,
1150                               IdResultType *idResultType1,
1151                               IdResult *idResult2,
1152                               IdScope *execution,
1153                               spv::GroupOperation *operation,
1154                               IdRef *value,
1155                               IdRef *clusterSize);
1156 void ParseGroupNonUniformFMin(const uint32_t *_instruction,
1157                               IdResultType *idResultType1,
1158                               IdResult *idResult2,
1159                               IdScope *execution,
1160                               spv::GroupOperation *operation,
1161                               IdRef *value,
1162                               IdRef *clusterSize);
1163 void ParseGroupNonUniformSMax(const uint32_t *_instruction,
1164                               IdResultType *idResultType1,
1165                               IdResult *idResult2,
1166                               IdScope *execution,
1167                               spv::GroupOperation *operation,
1168                               IdRef *value,
1169                               IdRef *clusterSize);
1170 void ParseGroupNonUniformUMax(const uint32_t *_instruction,
1171                               IdResultType *idResultType1,
1172                               IdResult *idResult2,
1173                               IdScope *execution,
1174                               spv::GroupOperation *operation,
1175                               IdRef *value,
1176                               IdRef *clusterSize);
1177 void ParseGroupNonUniformFMax(const uint32_t *_instruction,
1178                               IdResultType *idResultType1,
1179                               IdResult *idResult2,
1180                               IdScope *execution,
1181                               spv::GroupOperation *operation,
1182                               IdRef *value,
1183                               IdRef *clusterSize);
1184 void ParseGroupNonUniformBitwiseAnd(const uint32_t *_instruction,
1185                                     IdResultType *idResultType1,
1186                                     IdResult *idResult2,
1187                                     IdScope *execution,
1188                                     spv::GroupOperation *operation,
1189                                     IdRef *value,
1190                                     IdRef *clusterSize);
1191 void ParseGroupNonUniformBitwiseOr(const uint32_t *_instruction,
1192                                    IdResultType *idResultType1,
1193                                    IdResult *idResult2,
1194                                    IdScope *execution,
1195                                    spv::GroupOperation *operation,
1196                                    IdRef *value,
1197                                    IdRef *clusterSize);
1198 void ParseGroupNonUniformBitwiseXor(const uint32_t *_instruction,
1199                                     IdResultType *idResultType1,
1200                                     IdResult *idResult2,
1201                                     IdScope *execution,
1202                                     spv::GroupOperation *operation,
1203                                     IdRef *value,
1204                                     IdRef *clusterSize);
1205 void ParseGroupNonUniformLogicalAnd(const uint32_t *_instruction,
1206                                     IdResultType *idResultType1,
1207                                     IdResult *idResult2,
1208                                     IdScope *execution,
1209                                     spv::GroupOperation *operation,
1210                                     IdRef *value,
1211                                     IdRef *clusterSize);
1212 void ParseGroupNonUniformLogicalOr(const uint32_t *_instruction,
1213                                    IdResultType *idResultType1,
1214                                    IdResult *idResult2,
1215                                    IdScope *execution,
1216                                    spv::GroupOperation *operation,
1217                                    IdRef *value,
1218                                    IdRef *clusterSize);
1219 void ParseGroupNonUniformLogicalXor(const uint32_t *_instruction,
1220                                     IdResultType *idResultType1,
1221                                     IdResult *idResult2,
1222                                     IdScope *execution,
1223                                     spv::GroupOperation *operation,
1224                                     IdRef *value,
1225                                     IdRef *clusterSize);
1226 void ParseGroupNonUniformQuadBroadcast(const uint32_t *_instruction,
1227                                        IdResultType *idResultType1,
1228                                        IdResult *idResult2,
1229                                        IdScope *execution,
1230                                        IdRef *value,
1231                                        IdRef *index);
1232 void ParseGroupNonUniformQuadSwap(const uint32_t *_instruction,
1233                                   IdResultType *idResultType1,
1234                                   IdResult *idResult2,
1235                                   IdScope *execution,
1236                                   IdRef *value,
1237                                   IdRef *direction);
1238 void ParseCopyLogical(const uint32_t *_instruction,
1239                       IdResultType *idResultType1,
1240                       IdResult *idResult2,
1241                       IdRef *operand);
1242 void ParsePtrEqual(const uint32_t *_instruction,
1243                    IdResultType *idResultType1,
1244                    IdResult *idResult2,
1245                    IdRef *operand1,
1246                    IdRef *operand2);
1247 void ParsePtrNotEqual(const uint32_t *_instruction,
1248                       IdResultType *idResultType1,
1249                       IdResult *idResult2,
1250                       IdRef *operand1,
1251                       IdRef *operand2);
1252 
1253 }  // namespace spirv
1254 }  // namespace angle
1255 
1256 #endif  // COMMON_SPIRV_SPIRVINSTRUCTIONPARSERAUTOGEN_H_
1257