blob: 4a2a2d6c00b3ac6e0d9d3f25ae9335bb4b433d24 [file] [log] [blame]
Dejan Mircevskib6fe02f2016-01-07 13:44:22 -05001// Copyright (c) 2015-2016 The Khronos Group Inc.
Kenneth Benzie (Benie)83e5a292015-05-22 18:26:19 +01002//
David Neto9fc86582016-09-01 15:33:59 -04003// Licensed under the Apache License, Version 2.0 (the "License");
4// you may not use this file except in compliance with the License.
5// You may obtain a copy of the License at
Kenneth Benzie (Benie)83e5a292015-05-22 18:26:19 +01006//
David Neto9fc86582016-09-01 15:33:59 -04007// http://www.apache.org/licenses/LICENSE-2.0
Kenneth Benzie (Benie)83e5a292015-05-22 18:26:19 +01008//
David Neto9fc86582016-09-01 15:33:59 -04009// Unless required by applicable law or agreed to in writing, software
10// distributed under the License is distributed on an "AS IS" BASIS,
11// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12// See the License for the specific language governing permissions and
13// limitations under the License.
Kenneth Benzie (Benie)83e5a292015-05-22 18:26:19 +010014
15#include "operand.h"
16
17#include <assert.h>
18#include <string.h>
Chris Forbes78338d52017-06-27 16:28:22 -070019#include <algorithm>
Kenneth Benzie (Benie)83e5a292015-05-22 18:26:19 +010020
Lei Zhangca1bf942016-04-27 16:47:13 -040021#include "macro.h"
Lei Zhangddbaf322018-03-28 16:42:44 -040022#include "spirv_constant.h"
Alan Baker42840d12018-04-06 14:15:27 -040023#include "spirv_target_env.h"
David Netoba73a7c2016-01-06 13:08:39 -050024
David Neto00fa3932018-02-09 14:29:02 -050025// For now, assume unified1 contains up to SPIR-V 1.3 and no later
26// SPIR-V version.
27// TODO(dneto): Make one set of tables, but with version tags on a
28// per-item basis. https://github.com/KhronosGroup/SPIRV-Tools/issues/1195
29
David Neto00fa3932018-02-09 14:29:02 -050030#include "operand.kinds-unified1.inc"
Lei Zhang16981f82017-09-21 17:24:57 -040031
Lei Zhang1ef6b192018-03-14 13:06:18 -040032static const spv_operand_table_t kOperandTable = {
33 ARRAY_SIZE(pygen_variable_OperandInfoTable),
34 pygen_variable_OperandInfoTable};
Lei Zhang063dbea2017-10-25 12:15:51 -040035
36spv_result_t spvOperandTableGet(spv_operand_table* pOperandTable,
Lei Zhang1ef6b192018-03-14 13:06:18 -040037 spv_target_env) {
Lei Zhang063dbea2017-10-25 12:15:51 -040038 if (!pOperandTable) return SPV_ERROR_INVALID_POINTER;
Kenneth Benzie (Benie)83e5a292015-05-22 18:26:19 +010039
Lei Zhang1ef6b192018-03-14 13:06:18 -040040 *pOperandTable = &kOperandTable;
41 return SPV_SUCCESS;
Kenneth Benzie (Benie)83e5a292015-05-22 18:26:19 +010042}
43
Lei Zhang1ef6b192018-03-14 13:06:18 -040044spv_result_t spvOperandTableNameLookup(spv_target_env env,
45 const spv_operand_table table,
Kenneth Benzie (Benie)83e5a292015-05-22 18:26:19 +010046 const spv_operand_type_t type,
David Neto388c40d2015-09-16 16:42:56 -040047 const char* name,
48 const size_t nameLength,
49 spv_operand_desc* pEntry) {
Lei Zhang40056702015-09-11 14:31:27 -040050 if (!table) return SPV_ERROR_INVALID_TABLE;
51 if (!name || !pEntry) return SPV_ERROR_INVALID_POINTER;
Kenneth Benzie (Benie)83e5a292015-05-22 18:26:19 +010052
Kenneth Benzie (Benie)83e5a292015-05-22 18:26:19 +010053 for (uint64_t typeIndex = 0; typeIndex < table->count; ++typeIndex) {
Lei Zhangca1bf942016-04-27 16:47:13 -040054 const auto& group = table->types[typeIndex];
55 if (type != group.type) continue;
56 for (uint64_t index = 0; index < group.count; ++index) {
57 const auto& entry = group.entries[index];
Lei Zhang1ef6b192018-03-14 13:06:18 -040058 // We considers the current operand as available as long as
59 // 1. The target environment satisfies the minimal requirement of the
60 // operand; or
61 // 2. There is at least one extension enabling this operand.
62 //
63 // Note that the second rule assumes the extension enabling this operand
64 // is indeed requested in the SPIR-V code; checking that should be
65 // validator's work.
Lei Zhangddbaf322018-03-28 16:42:44 -040066 if ((spvVersionForTargetEnv(env) >= entry.minVersion ||
Lei Zhang1ef6b192018-03-14 13:06:18 -040067 entry.numExtensions > 0u) &&
68 nameLength == strlen(entry.name) &&
Lei Zhangca1bf942016-04-27 16:47:13 -040069 !strncmp(entry.name, name, nameLength)) {
70 *pEntry = &entry;
71 return SPV_SUCCESS;
Kenneth Benzie (Benie)83e5a292015-05-22 18:26:19 +010072 }
73 }
74 }
75
76 return SPV_ERROR_INVALID_LOOKUP;
77}
78
Lei Zhang1ef6b192018-03-14 13:06:18 -040079spv_result_t spvOperandTableValueLookup(spv_target_env env,
80 const spv_operand_table table,
Kenneth Benzie (Benie)83e5a292015-05-22 18:26:19 +010081 const spv_operand_type_t type,
82 const uint32_t value,
Dejan Mircevski50babb22015-09-29 10:56:32 -040083 spv_operand_desc* pEntry) {
Lei Zhang40056702015-09-11 14:31:27 -040084 if (!table) return SPV_ERROR_INVALID_TABLE;
85 if (!pEntry) return SPV_ERROR_INVALID_POINTER;
Kenneth Benzie (Benie)83e5a292015-05-22 18:26:19 +010086
Lei Zhang1ef6b192018-03-14 13:06:18 -040087 spv_operand_desc_t needle = {"", value, 0, nullptr, 0, nullptr, {}, ~0u};
88
89 auto comp = [](const spv_operand_desc_t& lhs, const spv_operand_desc_t& rhs) {
90 return lhs.value < rhs.value;
91 };
92
Kenneth Benzie (Benie)83e5a292015-05-22 18:26:19 +010093 for (uint64_t typeIndex = 0; typeIndex < table->count; ++typeIndex) {
Lei Zhangca1bf942016-04-27 16:47:13 -040094 const auto& group = table->types[typeIndex];
95 if (type != group.type) continue;
Lei Zhang1ef6b192018-03-14 13:06:18 -040096
97 const auto beg = group.entries;
98 const auto end = group.entries + group.count;
99
100 // We need to loop here because there can exist multiple symbols for the
101 // same operand value, and they can be introduced in different target
102 // environments, which means they can have different minimal version
103 // requirements. For example, SubgroupEqMaskKHR can exist in any SPIR-V
104 // version as long as the SPV_KHR_shader_ballot extension is there; but
105 // starting from SPIR-V 1.3, SubgroupEqMask, which has the same numeric
106 // value as SubgroupEqMaskKHR, is available in core SPIR-V without extension
107 // requirements.
108 // Assumes the underlying table is already sorted ascendingly according to
109 // opcode value.
110 for (auto it = std::lower_bound(beg, end, needle, comp);
111 it != end && it->value == value; ++it) {
112 // We considers the current operand as available as long as
113 // 1. The target environment satisfies the minimal requirement of the
114 // operand; or
115 // 2. There is at least one extension enabling this operand.
116 //
117 // Note that the second rule assumes the extension enabling this operand
118 // is indeed requested in the SPIR-V code; checking that should be
119 // validator's work.
Lei Zhangddbaf322018-03-28 16:42:44 -0400120 if (spvVersionForTargetEnv(env) >= it->minVersion ||
Lei Zhang1ef6b192018-03-14 13:06:18 -0400121 it->numExtensions > 0u) {
122 *pEntry = it;
Lei Zhangca1bf942016-04-27 16:47:13 -0400123 return SPV_SUCCESS;
Kenneth Benzie (Benie)83e5a292015-05-22 18:26:19 +0100124 }
125 }
126 }
127
128 return SPV_ERROR_INVALID_LOOKUP;
129}
130
Dejan Mircevski50babb22015-09-29 10:56:32 -0400131const char* spvOperandTypeStr(spv_operand_type_t type) {
Kenneth Benzie (Benie)83e5a292015-05-22 18:26:19 +0100132 switch (type) {
133 case SPV_OPERAND_TYPE_ID:
David Netofadbf622015-09-14 17:07:11 -0400134 case SPV_OPERAND_TYPE_OPTIONAL_ID:
David Netofadbf622015-09-14 17:07:11 -0400135 return "ID";
David Neto201caf72015-11-04 17:38:17 -0500136 case SPV_OPERAND_TYPE_TYPE_ID:
137 return "type ID";
Kenneth Benzie (Benie)83e5a292015-05-22 18:26:19 +0100138 case SPV_OPERAND_TYPE_RESULT_ID:
139 return "result ID";
Lei Zhang6483bd72015-10-14 17:02:39 -0400140 case SPV_OPERAND_TYPE_LITERAL_INTEGER:
David Neto201caf72015-11-04 17:38:17 -0500141 case SPV_OPERAND_TYPE_OPTIONAL_LITERAL_INTEGER:
142 case SPV_OPERAND_TYPE_OPTIONAL_LITERAL_NUMBER:
Kenneth Benzie (Benie)83e5a292015-05-22 18:26:19 +0100143 return "literal number";
David Neto201caf72015-11-04 17:38:17 -0500144 case SPV_OPERAND_TYPE_OPTIONAL_TYPED_LITERAL_INTEGER:
145 return "possibly multi-word literal integer";
146 case SPV_OPERAND_TYPE_TYPED_LITERAL_NUMBER:
147 return "possibly multi-word literal number";
148 case SPV_OPERAND_TYPE_EXTENSION_INSTRUCTION_NUMBER:
149 return "extension instruction number";
David Neto0f166be2015-11-11 01:56:49 -0500150 case SPV_OPERAND_TYPE_SPEC_CONSTANT_OP_NUMBER:
151 return "OpSpecConstantOp opcode";
Kenneth Benzie (Benie)83e5a292015-05-22 18:26:19 +0100152 case SPV_OPERAND_TYPE_LITERAL_STRING:
David Neto201caf72015-11-04 17:38:17 -0500153 case SPV_OPERAND_TYPE_OPTIONAL_LITERAL_STRING:
Kenneth Benzie (Benie)83e5a292015-05-22 18:26:19 +0100154 return "literal string";
155 case SPV_OPERAND_TYPE_SOURCE_LANGUAGE:
Dejan Mircevskid2c81cf2015-10-09 11:06:10 -0400156 return "source language";
Kenneth Benzie (Benie)83e5a292015-05-22 18:26:19 +0100157 case SPV_OPERAND_TYPE_EXECUTION_MODEL:
158 return "execution model";
159 case SPV_OPERAND_TYPE_ADDRESSING_MODEL:
160 return "addressing model";
161 case SPV_OPERAND_TYPE_MEMORY_MODEL:
162 return "memory model";
163 case SPV_OPERAND_TYPE_EXECUTION_MODE:
164 return "execution mode";
165 case SPV_OPERAND_TYPE_STORAGE_CLASS:
166 return "storage class";
167 case SPV_OPERAND_TYPE_DIMENSIONALITY:
168 return "dimensionality";
169 case SPV_OPERAND_TYPE_SAMPLER_ADDRESSING_MODE:
David Netod9ad0502015-11-24 18:37:24 -0500170 return "sampler addressing mode";
Kenneth Benzie (Benie)83e5a292015-05-22 18:26:19 +0100171 case SPV_OPERAND_TYPE_SAMPLER_FILTER_MODE:
172 return "sampler filter mode";
David Netob30a0c52015-09-16 15:56:43 -0400173 case SPV_OPERAND_TYPE_SAMPLER_IMAGE_FORMAT:
Dejan Mircevski971b3442015-10-13 12:54:47 -0400174 return "image format";
Kenneth Benzie (Benie)83e5a292015-05-22 18:26:19 +0100175 case SPV_OPERAND_TYPE_FP_FAST_MATH_MODE:
Dejan Mircevski355cc0c2015-10-13 15:02:03 -0400176 return "floating-point fast math mode";
Kenneth Benzie (Benie)83e5a292015-05-22 18:26:19 +0100177 case SPV_OPERAND_TYPE_FP_ROUNDING_MODE:
Dejan Mircevski355cc0c2015-10-13 15:02:03 -0400178 return "floating-point rounding mode";
Kenneth Benzie (Benie)83e5a292015-05-22 18:26:19 +0100179 case SPV_OPERAND_TYPE_LINKAGE_TYPE:
180 return "linkage type";
181 case SPV_OPERAND_TYPE_ACCESS_QUALIFIER:
David Neto2889a0c2016-02-15 13:50:00 -0500182 case SPV_OPERAND_TYPE_OPTIONAL_ACCESS_QUALIFIER:
Kenneth Benzie (Benie)83e5a292015-05-22 18:26:19 +0100183 return "access qualifier";
184 case SPV_OPERAND_TYPE_FUNCTION_PARAMETER_ATTRIBUTE:
185 return "function parameter attribute";
186 case SPV_OPERAND_TYPE_DECORATION:
187 return "decoration";
188 case SPV_OPERAND_TYPE_BUILT_IN:
Dejan Mircevskid7b0f832015-10-13 15:39:38 -0400189 return "built-in";
Kenneth Benzie (Benie)83e5a292015-05-22 18:26:19 +0100190 case SPV_OPERAND_TYPE_SELECTION_CONTROL:
191 return "selection control";
192 case SPV_OPERAND_TYPE_LOOP_CONTROL:
193 return "loop control";
194 case SPV_OPERAND_TYPE_FUNCTION_CONTROL:
195 return "function control";
David Neto64a9be92015-11-18 15:48:32 -0500196 case SPV_OPERAND_TYPE_MEMORY_SEMANTICS_ID:
David Netod9ad0502015-11-24 18:37:24 -0500197 return "memory semantics ID";
David Neto201caf72015-11-04 17:38:17 -0500198 case SPV_OPERAND_TYPE_MEMORY_ACCESS:
David Neto78c3b432015-08-27 13:03:52 -0400199 case SPV_OPERAND_TYPE_OPTIONAL_MEMORY_ACCESS:
Kenneth Benzie (Benie)83e5a292015-05-22 18:26:19 +0100200 return "memory access";
David Neto64a9be92015-11-18 15:48:32 -0500201 case SPV_OPERAND_TYPE_SCOPE_ID:
David Netod9ad0502015-11-24 18:37:24 -0500202 return "scope ID";
Kenneth Benzie (Benie)83e5a292015-05-22 18:26:19 +0100203 case SPV_OPERAND_TYPE_GROUP_OPERATION:
204 return "group operation";
205 case SPV_OPERAND_TYPE_KERNEL_ENQ_FLAGS:
206 return "kernel enqeue flags";
David Neto47994822015-08-27 13:11:01 -0400207 case SPV_OPERAND_TYPE_KERNEL_PROFILING_INFO:
Kenneth Benzie (Benie)83e5a292015-05-22 18:26:19 +0100208 return "kernel profiling info";
209 case SPV_OPERAND_TYPE_CAPABILITY:
210 return "capability";
David Neto201caf72015-11-04 17:38:17 -0500211 case SPV_OPERAND_TYPE_IMAGE:
David Netoee1b3bb2015-09-18 11:19:18 -0400212 case SPV_OPERAND_TYPE_OPTIONAL_IMAGE:
David Netod9ad0502015-11-24 18:37:24 -0500213 return "image";
David Neto201caf72015-11-04 17:38:17 -0500214 case SPV_OPERAND_TYPE_OPTIONAL_CIV:
215 return "context-insensitive value";
David Neto59de6102017-12-03 12:30:08 -0500216 case SPV_OPERAND_TYPE_DEBUG_INFO_FLAGS:
217 return "debug info flags";
218 case SPV_OPERAND_TYPE_DEBUG_BASE_TYPE_ATTRIBUTE_ENCODING:
219 return "debug base type encoding";
220 case SPV_OPERAND_TYPE_DEBUG_COMPOSITE_TYPE:
221 return "debug composite type";
222 case SPV_OPERAND_TYPE_DEBUG_TYPE_QUALIFIER:
223 return "debug type qualifier";
224 case SPV_OPERAND_TYPE_DEBUG_OPERATION:
225 return "debug operation";
David Neto201caf72015-11-04 17:38:17 -0500226
227 // The next values are for values returned from an instruction, not actually
228 // an operand. So the specific strings don't matter. But let's add them
229 // for completeness and ease of testing.
230 case SPV_OPERAND_TYPE_IMAGE_CHANNEL_ORDER:
231 return "image channel order";
232 case SPV_OPERAND_TYPE_IMAGE_CHANNEL_DATA_TYPE:
233 return "image channel data type";
234
David Neto78c3b432015-08-27 13:03:52 -0400235 case SPV_OPERAND_TYPE_NONE:
236 return "NONE";
Kenneth Benzie (Benie)83e5a292015-05-22 18:26:19 +0100237 default:
238 assert(0 && "Unhandled operand type!");
239 break;
240 }
241 return "unknown";
242}
David Neto78c3b432015-08-27 13:03:52 -0400243
Chris Forbes78338d52017-06-27 16:28:22 -0700244void spvPushOperandTypes(const spv_operand_type_t* types,
245 spv_operand_pattern_t* pattern) {
David Neto78c3b432015-08-27 13:03:52 -0400246 const spv_operand_type_t* endTypes;
Dejan Mircevski50babb22015-09-29 10:56:32 -0400247 for (endTypes = types; *endTypes != SPV_OPERAND_TYPE_NONE; ++endTypes)
David Neto78c3b432015-08-27 13:03:52 -0400248 ;
Chris Forbes78338d52017-06-27 16:28:22 -0700249 while (endTypes-- != types) {
Lei Zhang16981f82017-09-21 17:24:57 -0400250 pattern->push_back(*endTypes);
Chris Forbes78338d52017-06-27 16:28:22 -0700251 }
David Neto78c3b432015-08-27 13:03:52 -0400252}
253
Lei Zhang1ef6b192018-03-14 13:06:18 -0400254void spvPushOperandTypesForMask(spv_target_env env,
255 const spv_operand_table operandTable,
Chris Forbes78338d52017-06-27 16:28:22 -0700256 const spv_operand_type_t type,
257 const uint32_t mask,
258 spv_operand_pattern_t* pattern) {
259 // Scan from highest bits to lowest bits because we will append in LIFO
260 // fashion, and we need the operands for lower order bits to be consumed first
Lei Zhang16981f82017-09-21 17:24:57 -0400261 for (uint32_t candidate_bit = (1u << 31u); candidate_bit;
262 candidate_bit >>= 1) {
David Neto5bf88fc2015-09-17 17:06:10 -0400263 if (candidate_bit & mask) {
264 spv_operand_desc entry = nullptr;
Lei Zhang1ef6b192018-03-14 13:06:18 -0400265 if (SPV_SUCCESS == spvOperandTableValueLookup(env, operandTable, type,
David Neto5bf88fc2015-09-17 17:06:10 -0400266 candidate_bit, &entry)) {
Chris Forbes78338d52017-06-27 16:28:22 -0700267 spvPushOperandTypes(entry->operandTypes, pattern);
David Neto5bf88fc2015-09-17 17:06:10 -0400268 }
269 }
270 }
271}
272
David Neto0dbe1842017-12-03 14:26:16 -0500273bool spvOperandIsConcrete(spv_operand_type_t type) {
274 if (spvIsIdType(type) || spvOperandIsConcreteMask(type)) {
275 return true;
276 }
277 switch (type) {
278 case SPV_OPERAND_TYPE_LITERAL_INTEGER:
279 case SPV_OPERAND_TYPE_EXTENSION_INSTRUCTION_NUMBER:
280 case SPV_OPERAND_TYPE_SPEC_CONSTANT_OP_NUMBER:
281 case SPV_OPERAND_TYPE_TYPED_LITERAL_NUMBER:
282 case SPV_OPERAND_TYPE_LITERAL_STRING:
283 case SPV_OPERAND_TYPE_SOURCE_LANGUAGE:
284 case SPV_OPERAND_TYPE_EXECUTION_MODEL:
285 case SPV_OPERAND_TYPE_ADDRESSING_MODEL:
286 case SPV_OPERAND_TYPE_MEMORY_MODEL:
287 case SPV_OPERAND_TYPE_EXECUTION_MODE:
288 case SPV_OPERAND_TYPE_STORAGE_CLASS:
289 case SPV_OPERAND_TYPE_DIMENSIONALITY:
290 case SPV_OPERAND_TYPE_SAMPLER_ADDRESSING_MODE:
291 case SPV_OPERAND_TYPE_SAMPLER_FILTER_MODE:
292 case SPV_OPERAND_TYPE_SAMPLER_IMAGE_FORMAT:
293 case SPV_OPERAND_TYPE_IMAGE_CHANNEL_ORDER:
294 case SPV_OPERAND_TYPE_IMAGE_CHANNEL_DATA_TYPE:
295 case SPV_OPERAND_TYPE_FP_ROUNDING_MODE:
296 case SPV_OPERAND_TYPE_LINKAGE_TYPE:
297 case SPV_OPERAND_TYPE_ACCESS_QUALIFIER:
298 case SPV_OPERAND_TYPE_FUNCTION_PARAMETER_ATTRIBUTE:
299 case SPV_OPERAND_TYPE_DECORATION:
300 case SPV_OPERAND_TYPE_BUILT_IN:
301 case SPV_OPERAND_TYPE_GROUP_OPERATION:
302 case SPV_OPERAND_TYPE_KERNEL_ENQ_FLAGS:
303 case SPV_OPERAND_TYPE_KERNEL_PROFILING_INFO:
304 case SPV_OPERAND_TYPE_CAPABILITY:
David Neto59de6102017-12-03 12:30:08 -0500305 case SPV_OPERAND_TYPE_DEBUG_BASE_TYPE_ATTRIBUTE_ENCODING:
306 case SPV_OPERAND_TYPE_DEBUG_COMPOSITE_TYPE:
307 case SPV_OPERAND_TYPE_DEBUG_TYPE_QUALIFIER:
308 case SPV_OPERAND_TYPE_DEBUG_OPERATION:
David Neto0dbe1842017-12-03 14:26:16 -0500309 return true;
310 default:
311 break;
312 }
313 return false;
314}
315
David Netob5267562016-02-02 12:05:34 -0500316bool spvOperandIsConcreteMask(spv_operand_type_t type) {
David Neto0dbe1842017-12-03 14:26:16 -0500317 switch (type) {
318 case SPV_OPERAND_TYPE_IMAGE:
319 case SPV_OPERAND_TYPE_FP_FAST_MATH_MODE:
320 case SPV_OPERAND_TYPE_SELECTION_CONTROL:
321 case SPV_OPERAND_TYPE_LOOP_CONTROL:
322 case SPV_OPERAND_TYPE_FUNCTION_CONTROL:
323 case SPV_OPERAND_TYPE_MEMORY_ACCESS:
David Neto59de6102017-12-03 12:30:08 -0500324 case SPV_OPERAND_TYPE_DEBUG_INFO_FLAGS:
David Neto0dbe1842017-12-03 14:26:16 -0500325 return true;
326 default:
327 break;
328 }
329 return false;
David Netob5267562016-02-02 12:05:34 -0500330}
331
David Neto78c3b432015-08-27 13:03:52 -0400332bool spvOperandIsOptional(spv_operand_type_t type) {
David Neto201caf72015-11-04 17:38:17 -0500333 return SPV_OPERAND_TYPE_FIRST_OPTIONAL_TYPE <= type &&
334 type <= SPV_OPERAND_TYPE_LAST_OPTIONAL_TYPE;
David Neto78c3b432015-08-27 13:03:52 -0400335}
336
337bool spvOperandIsVariable(spv_operand_type_t type) {
David Neto201caf72015-11-04 17:38:17 -0500338 return SPV_OPERAND_TYPE_FIRST_VARIABLE_TYPE <= type &&
339 type <= SPV_OPERAND_TYPE_LAST_VARIABLE_TYPE;
David Neto78c3b432015-08-27 13:03:52 -0400340}
341
David Neto78c3b432015-08-27 13:03:52 -0400342bool spvExpandOperandSequenceOnce(spv_operand_type_t type,
343 spv_operand_pattern_t* pattern) {
344 switch (type) {
345 case SPV_OPERAND_TYPE_VARIABLE_ID:
Chris Forbes78338d52017-06-27 16:28:22 -0700346 pattern->push_back(type);
347 pattern->push_back(SPV_OPERAND_TYPE_OPTIONAL_ID);
David Neto78c3b432015-08-27 13:03:52 -0400348 return true;
Lei Zhang6483bd72015-10-14 17:02:39 -0400349 case SPV_OPERAND_TYPE_VARIABLE_LITERAL_INTEGER:
Chris Forbes78338d52017-06-27 16:28:22 -0700350 pattern->push_back(type);
351 pattern->push_back(SPV_OPERAND_TYPE_OPTIONAL_LITERAL_INTEGER);
David Neto78c3b432015-08-27 13:03:52 -0400352 return true;
Lei Zhang6483bd72015-10-14 17:02:39 -0400353 case SPV_OPERAND_TYPE_VARIABLE_LITERAL_INTEGER_ID:
David Neto201caf72015-11-04 17:38:17 -0500354 // Represents Zero or more (Literal number, Id) pairs,
355 // where the literal number must be a scalar integer.
Chris Forbes78338d52017-06-27 16:28:22 -0700356 pattern->push_back(type);
357 pattern->push_back(SPV_OPERAND_TYPE_ID);
358 pattern->push_back(SPV_OPERAND_TYPE_OPTIONAL_TYPED_LITERAL_INTEGER);
David Neto78c3b432015-08-27 13:03:52 -0400359 return true;
Lei Zhang6483bd72015-10-14 17:02:39 -0400360 case SPV_OPERAND_TYPE_VARIABLE_ID_LITERAL_INTEGER:
David Neto561dc4e2015-09-25 14:23:29 -0400361 // Represents Zero or more (Id, Literal number) pairs.
Chris Forbes78338d52017-06-27 16:28:22 -0700362 pattern->push_back(type);
363 pattern->push_back(SPV_OPERAND_TYPE_LITERAL_INTEGER);
364 pattern->push_back(SPV_OPERAND_TYPE_OPTIONAL_ID);
David Neto78c3b432015-08-27 13:03:52 -0400365 return true;
David Neto78c3b432015-08-27 13:03:52 -0400366 default:
367 break;
368 }
369 return false;
370}
371
Dejan Mircevski50babb22015-09-29 10:56:32 -0400372spv_operand_type_t spvTakeFirstMatchableOperand(
373 spv_operand_pattern_t* pattern) {
David Neto78c3b432015-08-27 13:03:52 -0400374 assert(!pattern->empty());
375 spv_operand_type_t result;
376 do {
Chris Forbes78338d52017-06-27 16:28:22 -0700377 result = pattern->back();
378 pattern->pop_back();
Dejan Mircevski50babb22015-09-29 10:56:32 -0400379 } while (spvExpandOperandSequenceOnce(result, pattern));
David Neto78c3b432015-08-27 13:03:52 -0400380 return result;
381}
Dejan Mircevski903f9d62015-09-28 17:04:39 -0400382
Dejan Mircevski897bff92015-09-29 10:38:18 -0400383spv_operand_pattern_t spvAlternatePatternFollowingImmediate(
384 const spv_operand_pattern_t& pattern) {
Lei Zhang16981f82017-09-21 17:24:57 -0400385 auto it =
386 std::find(pattern.crbegin(), pattern.crend(), SPV_OPERAND_TYPE_RESULT_ID);
Chris Forbes78338d52017-06-27 16:28:22 -0700387 if (it != pattern.crend()) {
Lei Zhang16981f82017-09-21 17:24:57 -0400388 spv_operand_pattern_t alternatePattern(it - pattern.crbegin() + 2,
389 SPV_OPERAND_TYPE_OPTIONAL_CIV);
Chris Forbes78338d52017-06-27 16:28:22 -0700390 alternatePattern[1] = SPV_OPERAND_TYPE_RESULT_ID;
391 return alternatePattern;
Dejan Mircevski903f9d62015-09-28 17:04:39 -0400392 }
Chris Forbes78338d52017-06-27 16:28:22 -0700393
Dejan Mircevski897bff92015-09-29 10:38:18 -0400394 // No result-id found, so just expect CIVs.
Lei Zhang16981f82017-09-21 17:24:57 -0400395 return {SPV_OPERAND_TYPE_OPTIONAL_CIV};
Dejan Mircevski903f9d62015-09-28 17:04:39 -0400396}
Dejan Mircevski961f5dc2016-01-15 11:25:11 -0500397
398bool spvIsIdType(spv_operand_type_t type) {
399 switch (type) {
400 case SPV_OPERAND_TYPE_ID:
401 case SPV_OPERAND_TYPE_TYPE_ID:
402 case SPV_OPERAND_TYPE_RESULT_ID:
403 case SPV_OPERAND_TYPE_MEMORY_SEMANTICS_ID:
404 case SPV_OPERAND_TYPE_SCOPE_ID:
405 return true;
406 default:
407 return false;
408 }
Dejan Mircevski961f5dc2016-01-15 11:25:11 -0500409}
Andrey Tuganovb36acbe2017-08-09 14:01:12 -0400410
411std::function<bool(unsigned)> spvOperandCanBeForwardDeclaredFunction(
412 SpvOp opcode) {
413 std::function<bool(unsigned index)> out;
414 switch (opcode) {
415 case SpvOpExecutionMode:
416 case SpvOpEntryPoint:
417 case SpvOpName:
418 case SpvOpMemberName:
419 case SpvOpSelectionMerge:
420 case SpvOpDecorate:
421 case SpvOpMemberDecorate:
David Neto5f69f752018-03-05 13:34:13 -0500422 case SpvOpDecorateId:
423 case SpvOpDecorateStringGOOGLE:
424 case SpvOpMemberDecorateStringGOOGLE:
Andrey Tuganovb36acbe2017-08-09 14:01:12 -0400425 case SpvOpTypeStruct:
426 case SpvOpBranch:
427 case SpvOpLoopMerge:
428 out = [](unsigned) { return true; };
429 break;
430 case SpvOpGroupDecorate:
431 case SpvOpGroupMemberDecorate:
432 case SpvOpBranchConditional:
433 case SpvOpSwitch:
434 out = [](unsigned index) { return index != 0; };
435 break;
436
437 case SpvOpFunctionCall:
438 // The Function parameter.
439 out = [](unsigned index) { return index == 2; };
440 break;
441
442 case SpvOpPhi:
443 out = [](unsigned index) { return index > 1; };
444 break;
445
446 case SpvOpEnqueueKernel:
447 // The Invoke parameter.
448 out = [](unsigned index) { return index == 8; };
449 break;
450
451 case SpvOpGetKernelNDrangeSubGroupCount:
452 case SpvOpGetKernelNDrangeMaxSubGroupSize:
453 // The Invoke parameter.
454 out = [](unsigned index) { return index == 3; };
455 break;
456
457 case SpvOpGetKernelWorkGroupSize:
458 case SpvOpGetKernelPreferredWorkGroupSizeMultiple:
459 // The Invoke parameter.
460 out = [](unsigned index) { return index == 2; };
461 break;
462 case SpvOpTypeForwardPointer:
463 out = [](unsigned index) { return index == 0; };
464 break;
465 default:
466 out = [](unsigned) { return false; };
467 break;
468 }
469 return out;
470}