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