blob: 6c440080db0b62135bedea0949d8111714fb46e7 [file] [log] [blame]
Kenneth Benzie (Benie)83e5a292015-05-22 18:26:19 +01001// Copyright (c) 2015 The Khronos Group Inc.
2//
3// Permission is hereby granted, free of charge, to any person obtaining a
4// copy of this software and/or associated documentation files (the
5// "Materials"), to deal in the Materials without restriction, including
6// without limitation the rights to use, copy, modify, merge, publish,
7// distribute, sublicense, and/or sell copies of the Materials, and to
8// permit persons to whom the Materials are furnished to do so, subject to
9// the following conditions:
10//
11// The above copyright notice and this permission notice shall be included
12// in all copies or substantial portions of the Materials.
13//
14// MODIFICATIONS TO THIS FILE MAY MEAN IT NO LONGER ACCURATELY REFLECTS
15// KHRONOS STANDARDS. THE UNMODIFIED, NORMATIVE VERSIONS OF KHRONOS
16// SPECIFICATIONS AND HEADER INFORMATION ARE LOCATED AT
17// https://www.khronos.org/registry/
18//
19// THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
20// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
21// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
22// IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
23// CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
24// TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
25// MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS.
26
27#include <libspirv/libspirv.h>
Lei Zhang610c5252015-09-09 10:36:48 -040028#include <utils/bitwisecast.h>
29
Kenneth Benzie (Benie)83e5a292015-05-22 18:26:19 +010030#include "binary.h"
31#include "diagnostic.h"
32#include "ext_inst.h"
33#include "opcode.h"
34#include "operand.h"
35#include "text.h"
36
37#include <assert.h>
38#include <stdio.h>
David Netoaffa6962015-08-24 15:33:14 -040039#include <cstdlib>
Kenneth Benzie (Benie)83e5a292015-05-22 18:26:19 +010040#include <string.h>
41
42#include <string>
43#include <vector>
44#include <unordered_map>
45
Lei Zhang610c5252015-09-09 10:36:48 -040046using spvutils::BitwiseCast;
47
Kenneth Benzie (Benie)83e5a292015-05-22 18:26:19 +010048// Structures
49
50struct spv_named_id_table_t {
51 std::unordered_map<std::string, uint32_t> namedIds;
52};
53
54// Text API
55
56std::string getWord(const char *str) {
57 size_t index = 0;
58 while (true) {
59 switch (str[index]) {
60 case '\0':
61 case '\t':
62 case '\n':
63 case ' ':
64 break;
65 default:
66 index++;
67 }
68 }
69 return std::string(str, str + index);
70}
71
72spv_named_id_table spvNamedIdTableCreate() {
73 return new spv_named_id_table_t();
74}
75
76void spvNamedIdTableDestory(spv_named_id_table table) { delete table; }
77
78uint32_t spvNamedIdAssignOrGet(spv_named_id_table table, const char *textValue,
79 uint32_t *pBound) {
80 if (table->namedIds.end() == table->namedIds.find(textValue)) {
81 table->namedIds[textValue] = *pBound;
82 }
83 return table->namedIds[textValue];
84}
85
86int32_t spvTextIsNamedId(const char *textValue) {
87 // TODO: Strengthen the parsing of textValue to only include allow names that
88 // match: ([a-z]|[A-Z])(_|[a-z]|[A-Z]|[0-9])*
89 switch (textValue[0]) {
90 case '0':
91 case '1':
92 case '2':
93 case '3':
94 case '4':
95 case '5':
96 case '6':
97 case '7':
98 case '8':
99 case '9':
100 return false;
101 default:
102 break;
103 }
104 return true;
105}
106
107spv_result_t spvTextAdvanceLine(const spv_text text, spv_position position) {
108 while (true) {
109 switch (text->str[position->index]) {
110 case '\0':
111 return SPV_END_OF_STREAM;
112 case '\n':
113 position->column = 0;
114 position->line++;
115 position->index++;
116 return SPV_SUCCESS;
117 default:
Lei Zhangee87cc22015-08-21 11:51:28 -0400118 position->column++;
Kenneth Benzie (Benie)83e5a292015-05-22 18:26:19 +0100119 position->index++;
120 break;
121 }
122 }
123}
124
125spv_result_t spvTextAdvance(const spv_text text, spv_position position) {
126 // NOTE: Consume white space, otherwise don't advance.
127 switch (text->str[position->index]) {
128 case '\0':
129 return SPV_END_OF_STREAM;
130 case ';':
Lei Zhangee87cc22015-08-21 11:51:28 -0400131 if (spv_result_t error = spvTextAdvanceLine(text, position)) return error;
132 return spvTextAdvance(text, position);
Kenneth Benzie (Benie)83e5a292015-05-22 18:26:19 +0100133 case ' ':
134 case '\t':
135 position->column++;
136 position->index++;
137 return spvTextAdvance(text, position);
138 case '\n':
139 position->column = 0;
140 position->line++;
141 position->index++;
142 return spvTextAdvance(text, position);
143 default:
144 break;
145 }
146
147 return SPV_SUCCESS;
148}
149
150spv_result_t spvTextWordGet(const spv_text text,
151 const spv_position startPosition, std::string &word,
152 spv_position endPosition) {
153 spvCheck(!text->str || !text->length, return SPV_ERROR_INVALID_TEXT);
154 spvCheck(!startPosition || !endPosition, return SPV_ERROR_INVALID_POINTER);
155
156 *endPosition = *startPosition;
157
David Netoe7ee4c42015-08-25 14:21:13 -0400158 bool quoting = false;
159 bool escaping = false;
160
Kenneth Benzie (Benie)83e5a292015-05-22 18:26:19 +0100161 // NOTE: Assumes first character is not white space!
162 while (true) {
David Netoe7ee4c42015-08-25 14:21:13 -0400163 const char ch = text->str[endPosition->index];
164 if (ch == '\\')
165 escaping = !escaping;
166 else {
167 switch (ch) {
168 case '"':
169 if (!escaping) quoting = !quoting;
170 break;
171 case ' ':
172 case ';':
173 case '\t':
174 case '\n':
175 if (escaping || quoting) break;
Lei Zhange78a7c12015-09-10 17:07:21 -0400176 // Fall through.
David Netoe7ee4c42015-08-25 14:21:13 -0400177 case '\0': { // NOTE: End of word found!
178 word.assign(text->str + startPosition->index,
179 (size_t)(endPosition->index - startPosition->index));
180 return SPV_SUCCESS;
181 }
182 default:
183 break;
Kenneth Benzie (Benie)83e5a292015-05-22 18:26:19 +0100184 }
David Netoe7ee4c42015-08-25 14:21:13 -0400185 escaping = false;
Kenneth Benzie (Benie)83e5a292015-05-22 18:26:19 +0100186 }
187
188 endPosition->column++;
189 endPosition->index++;
190 }
191}
192
David Netoc9786432015-09-01 18:05:14 -0400193namespace {
194
Lei Zhangdfc50082015-08-21 11:50:55 -0400195// Returns true if the string at the given position in text starts with "Op".
David Netoc9786432015-09-01 18:05:14 -0400196bool spvStartsWithOp(const spv_text text, const spv_position position) {
David Neto78c3b432015-08-27 13:03:52 -0400197 if (text->length < position->index + 3) return false;
198 char ch0 = text->str[position->index];
199 char ch1 = text->str[position->index + 1];
200 char ch2 = text->str[position->index + 2];
201 return ('O' == ch0 && 'p' == ch1 && ('A' <= ch2 && ch2 <= 'Z'));
Lei Zhangdfc50082015-08-21 11:50:55 -0400202}
203
Lei Zhange78a7c12015-09-10 17:07:21 -0400204} // anonymous namespace
David Netoc9786432015-09-01 18:05:14 -0400205
Lei Zhangdfc50082015-08-21 11:50:55 -0400206// Returns true if a new instruction begins at the given position in text.
Lei Zhange78a7c12015-09-10 17:07:21 -0400207bool spvTextIsStartOfNewInst(const spv_text text, const spv_position position) {
Lei Zhangdfc50082015-08-21 11:50:55 -0400208 spv_position_t nextPosition = *position;
209 if (spvTextAdvance(text, &nextPosition)) return false;
David Neto78c3b432015-08-27 13:03:52 -0400210 if (spvStartsWithOp(text, &nextPosition)) return true;
Lei Zhangdfc50082015-08-21 11:50:55 -0400211
212 std::string word;
David Neto78c3b432015-08-27 13:03:52 -0400213 spv_position_t startPosition = *position;
Lei Zhangdfc50082015-08-21 11:50:55 -0400214 if (spvTextWordGet(text, &startPosition, word, &nextPosition)) return false;
215 if ('%' != word.front()) return false;
216
217 if (spvTextAdvance(text, &nextPosition)) return false;
218 startPosition = nextPosition;
219 if (spvTextWordGet(text, &startPosition, word, &nextPosition)) return false;
220 if ("=" != word) return false;
221
222 if (spvTextAdvance(text, &nextPosition)) return false;
223 startPosition = nextPosition;
224 if (spvStartsWithOp(text, &startPosition)) return true;
225 return false;
226}
227
Kenneth Benzie (Benie)83e5a292015-05-22 18:26:19 +0100228spv_result_t spvTextStringGet(const spv_text text,
229 const spv_position startPosition,
230 std::string &string, spv_position endPosition) {
231 spvCheck(!text->str || !text->length, return SPV_ERROR_INVALID_TEXT);
232 spvCheck(!startPosition || !endPosition, return SPV_ERROR_INVALID_POINTER);
233
234 spvCheck('"' != text->str[startPosition->index],
235 return SPV_ERROR_INVALID_TEXT);
236
237 *endPosition = *startPosition;
238
239 // NOTE: Assumes first character is not white space
240 while (true) {
241 endPosition->column++;
242 endPosition->index++;
243
244 switch (text->str[endPosition->index]) {
245 case '"': {
246 endPosition->column++;
247 endPosition->index++;
248
249 string.assign(text->str + startPosition->index,
250 (size_t)(endPosition->index - startPosition->index));
251
252 return SPV_SUCCESS;
253 }
254 case '\n':
255 case '\0':
256 return SPV_ERROR_INVALID_TEXT;
257 default:
258 break;
259 }
260 }
261}
262
263spv_result_t spvTextToUInt32(const char *textValue, uint32_t *pValue) {
264 char *endPtr = nullptr;
265 *pValue = strtoul(textValue, &endPtr, 0);
266 if (0 == *pValue && textValue == endPtr) {
267 return SPV_ERROR_INVALID_TEXT;
268 }
269 return SPV_SUCCESS;
270}
271
272spv_result_t spvTextToLiteral(const char *textValue, spv_literal_t *pLiteral) {
273 bool isSigned = false;
David Netoaffa6962015-08-24 15:33:14 -0400274 int numPeriods = 0;
Kenneth Benzie (Benie)83e5a292015-05-22 18:26:19 +0100275 bool isString = false;
276
David Netoaffa6962015-08-24 15:33:14 -0400277 const size_t len = strlen(textValue);
David Neto98290a22015-08-24 16:27:02 -0400278 if (len == 0) return SPV_FAILED_MATCH;
279
David Netoaffa6962015-08-24 15:33:14 -0400280 for (uint64_t index = 0; index < len; ++index) {
Kenneth Benzie (Benie)83e5a292015-05-22 18:26:19 +0100281 switch (textValue[index]) {
282 case '0':
283 case '1':
284 case '2':
285 case '3':
286 case '4':
287 case '5':
288 case '6':
289 case '7':
290 case '8':
291 case '9':
292 break;
293 case '.':
David Netoaffa6962015-08-24 15:33:14 -0400294 numPeriods++;
295 break;
296 case '-':
297 if (index == 0) {
298 isSigned = true;
299 } else {
300 isString = true;
301 }
Kenneth Benzie (Benie)83e5a292015-05-22 18:26:19 +0100302 break;
303 default:
304 isString = true;
Lei Zhange78a7c12015-09-10 17:07:21 -0400305 index = len; // break out of the loop too.
Kenneth Benzie (Benie)83e5a292015-05-22 18:26:19 +0100306 break;
307 }
308 }
309
David Netoaffa6962015-08-24 15:33:14 -0400310 pLiteral->type = spv_literal_type_t(99);
311
Lei Zhange78a7c12015-09-10 17:07:21 -0400312 if (isString || numPeriods > 1 || (isSigned && len == 1)) {
David Netoaffa6962015-08-24 15:33:14 -0400313 // TODO(dneto): Allow escaping.
David Neto98290a22015-08-24 16:27:02 -0400314 if (len < 2 || textValue[0] != '"' || textValue[len - 1] != '"')
315 return SPV_FAILED_MATCH;
Kenneth Benzie (Benie)83e5a292015-05-22 18:26:19 +0100316 pLiteral->type = SPV_LITERAL_TYPE_STRING;
David Netoaffa6962015-08-24 15:33:14 -0400317 // Need room for the null-terminator.
David Neto98290a22015-08-24 16:27:02 -0400318 if (len >= sizeof(pLiteral->value.str)) return SPV_ERROR_OUT_OF_MEMORY;
Lei Zhange78a7c12015-09-10 17:07:21 -0400319 strncpy(pLiteral->value.str, textValue + 1, len - 2);
320 pLiteral->value.str[len - 2] = 0;
David Netoaffa6962015-08-24 15:33:14 -0400321 } else if (numPeriods == 1) {
322 double d = std::strtod(textValue, nullptr);
Kenneth Benzie (Benie)83e5a292015-05-22 18:26:19 +0100323 float f = (float)d;
324 if (d == (double)f) {
325 pLiteral->type = SPV_LITERAL_TYPE_FLOAT_32;
326 pLiteral->value.f = f;
327 } else {
328 pLiteral->type = SPV_LITERAL_TYPE_FLOAT_64;
329 pLiteral->value.d = d;
330 }
331 } else if (isSigned) {
332 int64_t i64 = strtoll(textValue, nullptr, 10);
333 int32_t i32 = (int32_t)i64;
334 if (i64 == (int64_t)i32) {
335 pLiteral->type = SPV_LITERAL_TYPE_INT_32;
336 pLiteral->value.i32 = i32;
337 } else {
338 pLiteral->type = SPV_LITERAL_TYPE_INT_64;
339 pLiteral->value.i64 = i64;
340 }
341 } else {
342 uint64_t u64 = strtoull(textValue, nullptr, 10);
343 uint32_t u32 = (uint32_t)u64;
344 if (u64 == (uint64_t)u32) {
345 pLiteral->type = SPV_LITERAL_TYPE_UINT_32;
346 pLiteral->value.u32 = u32;
347 } else {
348 pLiteral->type = SPV_LITERAL_TYPE_UINT_64;
349 pLiteral->value.u64 = u64;
350 }
351 }
352
353 return SPV_SUCCESS;
354}
355
356spv_result_t spvTextEncodeOperand(
357 const spv_operand_type_t type, const char *textValue,
358 const spv_operand_table operandTable, const spv_ext_inst_table extInstTable,
359 spv_named_id_table namedIdTable, spv_instruction_t *pInst,
Lei Zhange78a7c12015-09-10 17:07:21 -0400360 spv_operand_pattern_t *pExpectedOperands, uint32_t *pBound,
Kenneth Benzie (Benie)83e5a292015-05-22 18:26:19 +0100361 const spv_position position, spv_diagnostic *pDiagnostic) {
362 // NOTE: Handle immediate int in the stream
363 if ('!' == textValue[0]) {
364 const char *begin = textValue + 1;
365 char *end = nullptr;
366 uint32_t immediateInt = strtoul(begin, &end, 0);
367 size_t size = strlen(textValue);
368 size_t length = (end - begin);
369 spvCheck(size - 1 != length, DIAGNOSTIC << "Invalid immediate integer '"
370 << textValue << "'.";
371 return SPV_ERROR_INVALID_TEXT);
372 position->column += size;
373 position->index += size;
374 pInst->words[pInst->wordCount] = immediateInt;
375 pInst->wordCount += 1;
376 return SPV_SUCCESS;
377 }
378
379 switch (type) {
David Netoe3f70b92015-08-27 13:50:05 -0400380 case SPV_OPERAND_TYPE_ID:
David Neto78c3b432015-08-27 13:03:52 -0400381 case SPV_OPERAND_TYPE_ID_IN_OPTIONAL_TUPLE:
382 case SPV_OPERAND_TYPE_OPTIONAL_ID:
David Netoe3f70b92015-08-27 13:50:05 -0400383 case SPV_OPERAND_TYPE_RESULT_ID: {
Lei Zhangabafd5e2015-08-21 11:52:29 -0400384 if ('%' == textValue[0]) {
Kenneth Benzie (Benie)83e5a292015-05-22 18:26:19 +0100385 textValue++;
386 }
Lei Zhangabafd5e2015-08-21 11:52:29 -0400387 // TODO: Force all ID's to be prefixed with '%'.
Kenneth Benzie (Benie)83e5a292015-05-22 18:26:19 +0100388 uint32_t id = 0;
389 if (spvTextIsNamedId(textValue)) {
390 id = spvNamedIdAssignOrGet(namedIdTable, textValue, pBound);
391 } else {
392 spvCheck(spvTextToUInt32(textValue, &id),
David Neto78c3b432015-08-27 13:03:52 -0400393 DIAGNOSTIC
394 << "Invalid "
395 << ((type == SPV_OPERAND_TYPE_RESULT_ID) ? "result " : "")
396 << "ID '" << textValue << "'.";
397 return (spvOperandIsOptional(type) ? SPV_FAILED_MATCH
398 : SPV_ERROR_INVALID_TEXT));
Kenneth Benzie (Benie)83e5a292015-05-22 18:26:19 +0100399 }
400 pInst->words[pInst->wordCount++] = id;
401 if (*pBound <= id) {
402 *pBound = id + 1;
403 }
404 } break;
405 case SPV_OPERAND_TYPE_LITERAL_NUMBER: {
406 // NOTE: Special case for extension instruction lookup
407 if (OpExtInst == pInst->opcode) {
408 spv_ext_inst_desc extInst;
409 spvCheck(spvExtInstTableNameLookup(extInstTable, pInst->extInstType,
410 textValue, &extInst),
411 DIAGNOSTIC << "Invalid extended instruction name '"
412 << textValue << "'.";
413 return SPV_ERROR_INVALID_TEXT);
414 pInst->words[pInst->wordCount++] = extInst->ext_inst;
David Neto78c3b432015-08-27 13:03:52 -0400415
416 // Prepare to parse the operands for the extended instructions.
417 spvPrependOperandTypes(extInst->operandTypes, pExpectedOperands);
418
Kenneth Benzie (Benie)83e5a292015-05-22 18:26:19 +0100419 return SPV_SUCCESS;
420 }
421
422 // TODO: Literal numbers can be any number up to 64 bits wide. This
423 // includes integers and floating point numbers.
David Neto78c3b432015-08-27 13:03:52 -0400424 // TODO(dneto): Suggest using spvTextToLiteral and looking for an
425 // appropriate result type.
Kenneth Benzie (Benie)83e5a292015-05-22 18:26:19 +0100426 spvCheck(spvTextToUInt32(textValue, &pInst->words[pInst->wordCount++]),
427 DIAGNOSTIC << "Invalid literal number '" << textValue << "'.";
428 return SPV_ERROR_INVALID_TEXT);
429 } break;
David Neto78c3b432015-08-27 13:03:52 -0400430 case SPV_OPERAND_TYPE_LITERAL:
431 case SPV_OPERAND_TYPE_LITERAL_IN_OPTIONAL_TUPLE:
432 case SPV_OPERAND_TYPE_OPTIONAL_LITERAL: {
Kenneth Benzie (Benie)83e5a292015-05-22 18:26:19 +0100433 spv_literal_t literal = {};
David Neto78c3b432015-08-27 13:03:52 -0400434 // TODO(dneto): Is return code different for optional operands?
Kenneth Benzie (Benie)83e5a292015-05-22 18:26:19 +0100435 spvCheck(spvTextToLiteral(textValue, &literal),
436 DIAGNOSTIC << "Invalid literal '" << textValue << "'.";
437 return SPV_ERROR_INVALID_TEXT);
438 switch (literal.type) {
Andrew Woloszyn4b4acde2015-09-10 10:28:22 -0400439 // We do not have to print diagnostics here because spvBinaryEncode*
440 // prints diagnostic messages on failure.
Kenneth Benzie (Benie)83e5a292015-05-22 18:26:19 +0100441 case SPV_LITERAL_TYPE_INT_32:
Lei Zhang610c5252015-09-09 10:36:48 -0400442 spvCheck(spvBinaryEncodeU32(BitwiseCast<uint32_t>(literal.value.i32),
443 pInst, position, pDiagnostic),
Kenneth Benzie (Benie)83e5a292015-05-22 18:26:19 +0100444 return SPV_ERROR_INVALID_TEXT);
445 break;
446 case SPV_LITERAL_TYPE_INT_64: {
Lei Zhang610c5252015-09-09 10:36:48 -0400447 spvCheck(spvBinaryEncodeU64(BitwiseCast<uint64_t>(literal.value.i64),
448 pInst, position, pDiagnostic),
Kenneth Benzie (Benie)83e5a292015-05-22 18:26:19 +0100449 return SPV_ERROR_INVALID_TEXT);
450 } break;
451 case SPV_LITERAL_TYPE_UINT_32: {
452 spvCheck(spvBinaryEncodeU32(literal.value.u32, pInst, position,
453 pDiagnostic),
454 return SPV_ERROR_INVALID_TEXT);
455 } break;
456 case SPV_LITERAL_TYPE_UINT_64: {
Lei Zhang610c5252015-09-09 10:36:48 -0400457 spvCheck(spvBinaryEncodeU64(BitwiseCast<uint64_t>(literal.value.u64),
458 pInst, position, pDiagnostic),
Kenneth Benzie (Benie)83e5a292015-05-22 18:26:19 +0100459 return SPV_ERROR_INVALID_TEXT);
460 } break;
461 case SPV_LITERAL_TYPE_FLOAT_32: {
Lei Zhang610c5252015-09-09 10:36:48 -0400462 spvCheck(spvBinaryEncodeU32(BitwiseCast<uint32_t>(literal.value.f),
463 pInst, position, pDiagnostic),
Kenneth Benzie (Benie)83e5a292015-05-22 18:26:19 +0100464 return SPV_ERROR_INVALID_TEXT);
465 } break;
466 case SPV_LITERAL_TYPE_FLOAT_64: {
Lei Zhang610c5252015-09-09 10:36:48 -0400467 spvCheck(spvBinaryEncodeU64(BitwiseCast<uint64_t>(literal.value.d),
468 pInst, position, pDiagnostic),
Kenneth Benzie (Benie)83e5a292015-05-22 18:26:19 +0100469 return SPV_ERROR_INVALID_TEXT);
470 } break;
471 case SPV_LITERAL_TYPE_STRING: {
472 spvCheck(spvBinaryEncodeString(literal.value.str, pInst, position,
473 pDiagnostic),
474 return SPV_ERROR_INVALID_TEXT);
475 } break;
476 default:
477 DIAGNOSTIC << "Invalid literal '" << textValue << "'";
478 return SPV_ERROR_INVALID_TEXT;
479 }
480 } break;
David Neto78c3b432015-08-27 13:03:52 -0400481 case SPV_OPERAND_TYPE_LITERAL_STRING:
482 case SPV_OPERAND_TYPE_OPTIONAL_LITERAL_STRING: {
Kenneth Benzie (Benie)83e5a292015-05-22 18:26:19 +0100483 size_t len = strlen(textValue);
484 spvCheck('"' != textValue[0] && '"' != textValue[len - 1],
Lei Zhange78a7c12015-09-10 17:07:21 -0400485 if (spvOperandIsOptional(type)) return SPV_FAILED_MATCH;
Kenneth Benzie (Benie)83e5a292015-05-22 18:26:19 +0100486 DIAGNOSTIC << "Invalid literal string '" << textValue
487 << "', expected quotes.";
David Neto78c3b432015-08-27 13:03:52 -0400488 return SPV_ERROR_INVALID_TEXT;);
Kenneth Benzie (Benie)83e5a292015-05-22 18:26:19 +0100489 // NOTE: Strip quotes
490 std::string text(textValue + 1, len - 2);
491
492 // NOTE: Special case for extended instruction library import
493 if (OpExtInstImport == pInst->opcode) {
494 pInst->extInstType = spvExtInstImportTypeGet(text.c_str());
495 }
496
497 spvCheck(
498 spvBinaryEncodeString(text.c_str(), pInst, position, pDiagnostic),
499 return SPV_ERROR_INVALID_TEXT);
500 } break;
David Neto78c3b432015-08-27 13:03:52 -0400501 case SPV_OPERAND_TYPE_OPTIONAL_IMAGE:
502 assert(0 && " Handle optional optional image operands");
503 break;
Kenneth Benzie (Benie)83e5a292015-05-22 18:26:19 +0100504 default: {
505 // NOTE: All non literal operands are handled here using the operand
506 // table.
507 spv_operand_desc entry;
508 spvCheck(spvOperandTableNameLookup(operandTable, type, textValue, &entry),
509 DIAGNOSTIC << "Invalid " << spvOperandTypeStr(type) << " '"
510 << textValue << "'.";
511 return SPV_ERROR_INVALID_TEXT;);
512 spvCheck(spvBinaryEncodeU32(entry->value, pInst, position, pDiagnostic),
513 DIAGNOSTIC << "Invalid " << spvOperandTypeStr(type) << " '"
514 << textValue << "'.";
515 return SPV_ERROR_INVALID_TEXT;);
David Neto78c3b432015-08-27 13:03:52 -0400516
517 // Prepare to parse the operands for this logical operand.
518 spvPrependOperandTypes(entry->operandTypes, pExpectedOperands);
Kenneth Benzie (Benie)83e5a292015-05-22 18:26:19 +0100519 } break;
520 }
521 return SPV_SUCCESS;
522}
523
524spv_result_t spvTextEncodeOpcode(
Lei Zhang06efdc52015-09-10 14:00:00 -0400525 const spv_text text, spv_assembly_syntax_format_t format,
526 const spv_opcode_table opcodeTable, const spv_operand_table operandTable,
527 const spv_ext_inst_table extInstTable, spv_named_id_table namedIdTable,
528 uint32_t *pBound, spv_instruction_t *pInst, spv_position position,
529 spv_diagnostic *pDiagnostic) {
Lei Zhangdfc50082015-08-21 11:50:55 -0400530 // An assembly instruction has two possible formats:
Lei Zhang06efdc52015-09-10 14:00:00 -0400531 // 1(CAF): <opcode> <operand>..., e.g., "OpTypeVoid %void".
532 // 2(AAF): <result-id> = <opcode> <operand>..., e.g., "%void = OpTypeVoid".
Lei Zhangdfc50082015-08-21 11:50:55 -0400533
Lei Zhang06efdc52015-09-10 14:00:00 -0400534 std::string firstWord;
Kenneth Benzie (Benie)83e5a292015-05-22 18:26:19 +0100535 spv_position_t nextPosition = {};
Lei Zhang06efdc52015-09-10 14:00:00 -0400536 spv_result_t error = spvTextWordGet(text, position, firstWord, &nextPosition);
Andrew Woloszyn4b4acde2015-09-10 10:28:22 -0400537 spvCheck(error, DIAGNOSTIC << "Internal Error"; return error);
Kenneth Benzie (Benie)83e5a292015-05-22 18:26:19 +0100538
539 // NOTE: Handle insertion of an immediate integer into the binary stream
Dejan Mircevski92a225b2015-09-10 14:55:33 -0400540 if ('!' == text->str[position->index]) {
Lei Zhang06efdc52015-09-10 14:00:00 -0400541 const char *begin = firstWord.data() + 1;
Kenneth Benzie (Benie)83e5a292015-05-22 18:26:19 +0100542 char *end = nullptr;
543 uint32_t immediateInt = strtoul(begin, &end, 0);
Lei Zhang06efdc52015-09-10 14:00:00 -0400544 size_t size = firstWord.size() - 1;
Kenneth Benzie (Benie)83e5a292015-05-22 18:26:19 +0100545 spvCheck(size != (size_t)(end - begin),
Lei Zhang06efdc52015-09-10 14:00:00 -0400546 DIAGNOSTIC << "Invalid immediate integer '" << firstWord << "'.";
Kenneth Benzie (Benie)83e5a292015-05-22 18:26:19 +0100547 return SPV_ERROR_INVALID_TEXT);
Lei Zhang06efdc52015-09-10 14:00:00 -0400548 position->column += firstWord.size();
549 position->index += firstWord.size();
Kenneth Benzie (Benie)83e5a292015-05-22 18:26:19 +0100550 pInst->words[0] = immediateInt;
551 pInst->wordCount = 1;
552 return SPV_SUCCESS;
553 }
554
Lei Zhang06efdc52015-09-10 14:00:00 -0400555 std::string opcodeName;
Lei Zhangdfc50082015-08-21 11:50:55 -0400556 std::string result_id;
557 spv_position_t result_id_position = {};
Lei Zhang06efdc52015-09-10 14:00:00 -0400558 if (spvStartsWithOp(text, position)) {
559 opcodeName = firstWord;
560 } else {
561 // If the first word of this instruction is not an opcode, we must be
562 // processing AAF now.
563 spvCheck(
564 SPV_ASSEMBLY_SYNTAX_FORMAT_ASSIGNMENT != format,
565 DIAGNOSTIC
566 << "Expected <opcode> at the beginning of an instruction, found '"
567 << firstWord << "'.";
568 return SPV_ERROR_INVALID_TEXT);
569
570 result_id = firstWord;
Lei Zhangdfc50082015-08-21 11:50:55 -0400571 spvCheck('%' != result_id.front(),
572 DIAGNOSTIC << "Expected <opcode> or <result-id> at the beginning "
573 "of an instruction, found '"
574 << result_id << "'.";
575 return SPV_ERROR_INVALID_TEXT);
576 result_id_position = *position;
Lei Zhang06efdc52015-09-10 14:00:00 -0400577
578 // The '=' sign.
Lei Zhangdfc50082015-08-21 11:50:55 -0400579 *position = nextPosition;
580 spvCheck(spvTextAdvance(text, position),
581 DIAGNOSTIC << "Expected '=', found end of stream.";
582 return SPV_ERROR_INVALID_TEXT);
Lei Zhangdfc50082015-08-21 11:50:55 -0400583 std::string equal_sign;
584 error = spvTextWordGet(text, position, equal_sign, &nextPosition);
585 spvCheck("=" != equal_sign, DIAGNOSTIC << "'=' expected after result id.";
586 return SPV_ERROR_INVALID_TEXT);
587
588 // The <opcode> after the '=' sign.
589 *position = nextPosition;
590 spvCheck(spvTextAdvance(text, position),
591 DIAGNOSTIC << "Expected opcode, found end of stream.";
592 return SPV_ERROR_INVALID_TEXT);
Lei Zhang977e9bc2015-08-21 11:52:03 -0400593 error = spvTextWordGet(text, position, opcodeName, &nextPosition);
Andrew Woloszyn4b4acde2015-09-10 10:28:22 -0400594 spvCheck(error, DIAGNOSTIC << "Internal Error"; return error);
Lei Zhangdfc50082015-08-21 11:50:55 -0400595 spvCheck(!spvStartsWithOp(text, position),
596 DIAGNOSTIC << "Invalid Opcode prefix '" << opcodeName << "'.";
597 return SPV_ERROR_INVALID_TEXT);
Lei Zhangdfc50082015-08-21 11:50:55 -0400598 }
599
Kenneth Benzie (Benie)83e5a292015-05-22 18:26:19 +0100600 // NOTE: The table contains Opcode names without the "Op" prefix.
601 const char *pInstName = opcodeName.data() + 2;
602
603 spv_opcode_desc opcodeEntry;
Lei Zhangdfc50082015-08-21 11:50:55 -0400604 error = spvOpcodeTableNameLookup(opcodeTable, pInstName, &opcodeEntry);
Kenneth Benzie (Benie)83e5a292015-05-22 18:26:19 +0100605 spvCheck(error, DIAGNOSTIC << "Invalid Opcode name '"
606 << getWord(text->str + position->index) << "'";
607 return error);
Lei Zhang06efdc52015-09-10 14:00:00 -0400608 if (SPV_ASSEMBLY_SYNTAX_FORMAT_ASSIGNMENT == format) {
609 // If this instruction has <result-id>, check it follows AAF.
610 spvCheck(opcodeEntry->hasResult && result_id.empty(),
611 DIAGNOSTIC << "Expected <result-id> at the beginning of an "
612 "instruction, found '"
613 << firstWord << "'.";
614 return SPV_ERROR_INVALID_TEXT);
615 }
Kenneth Benzie (Benie)83e5a292015-05-22 18:26:19 +0100616 pInst->opcode = opcodeEntry->opcode;
617 *position = nextPosition;
618 pInst->wordCount++;
619
David Neto78c3b432015-08-27 13:03:52 -0400620 // Maintains the ordered list of expected operand types.
621 // For many instructions we only need the {numTypes, operandTypes}
622 // entries in opcodeEntry. However, sometimes we need to modify
623 // the list as we parse the operands. This occurs when an operand
624 // has its own logical operands (such as the LocalSize operand for
625 // ExecutionMode), or for extended instructions that may have their
626 // own operands depending on the selected extended instruction.
627 spv_operand_pattern_t expectedOperands(
628 opcodeEntry->operandTypes,
629 opcodeEntry->operandTypes + opcodeEntry->numTypes);
Lei Zhangdfc50082015-08-21 11:50:55 -0400630
David Neto78c3b432015-08-27 13:03:52 -0400631 while (!expectedOperands.empty()) {
632 const spv_operand_type_t type = expectedOperands.front();
633 expectedOperands.pop_front();
634
635 // Expand optional tuples lazily.
Lei Zhange78a7c12015-09-10 17:07:21 -0400636 if (spvExpandOperandSequenceOnce(type, &expectedOperands)) continue;
David Neto78c3b432015-08-27 13:03:52 -0400637
638 if (type == SPV_OPERAND_TYPE_RESULT_ID && !result_id.empty()) {
639 // Handle the <result-id> for value generating instructions.
640 // We've already consumed it from the text stream. Here
641 // we inject its words into the instruction.
Lei Zhange78a7c12015-09-10 17:07:21 -0400642 error = spvTextEncodeOperand(SPV_OPERAND_TYPE_RESULT_ID,
643 result_id.c_str(), operandTable,
644 extInstTable, namedIdTable, pInst, nullptr,
645 pBound, &result_id_position, pDiagnostic);
Lei Zhangdfc50082015-08-21 11:50:55 -0400646 spvCheck(error, return error);
Kenneth Benzie (Benie)83e5a292015-05-22 18:26:19 +0100647 } else {
David Neto78c3b432015-08-27 13:03:52 -0400648 // Find the next word.
649 error = spvTextAdvance(text, position);
650 if (error == SPV_END_OF_STREAM) {
651 if (spvOperandIsOptional(type)) {
Lei Zhange78a7c12015-09-10 17:07:21 -0400652 // This would have been the last potential operand for the
653 // instruction,
David Neto78c3b432015-08-27 13:03:52 -0400654 // and we didn't find one. We're finished parsing this instruction.
655 break;
656 } else {
657 DIAGNOSTIC << "Expected operand, found end of stream.";
658 return SPV_ERROR_INVALID_TEXT;
659 }
Kenneth Benzie (Benie)83e5a292015-05-22 18:26:19 +0100660 }
David Neto78c3b432015-08-27 13:03:52 -0400661 assert(error == SPV_SUCCESS && "Somebody added another way to fail");
662
663 if (spvTextIsStartOfNewInst(text, position)) {
664 if (spvOperandIsOptional(type)) {
665 break;
666 } else {
667 DIAGNOSTIC << "Expected operand, found next instruction instead.";
668 return SPV_ERROR_INVALID_TEXT;
669 }
670 }
671
672 std::string operandValue;
673 error = spvTextWordGet(text, position, operandValue, &nextPosition);
Andrew Woloszyn4b4acde2015-09-10 10:28:22 -0400674 spvCheck(error, DIAGNOSTIC << "Internal Error"; return error);
David Neto78c3b432015-08-27 13:03:52 -0400675
676 error = spvTextEncodeOperand(
Lei Zhange78a7c12015-09-10 17:07:21 -0400677 type, operandValue.c_str(), operandTable, extInstTable, namedIdTable,
678 pInst, &expectedOperands, pBound, position, pDiagnostic);
David Neto78c3b432015-08-27 13:03:52 -0400679
680 if (error == SPV_FAILED_MATCH && spvOperandIsOptional(type))
681 return SPV_SUCCESS;
682
683 spvCheck(error, return error);
684
685 *position = nextPosition;
Kenneth Benzie (Benie)83e5a292015-05-22 18:26:19 +0100686 }
687 }
688
689 pInst->words[0] = spvOpcodeMake(pInst->wordCount, opcodeEntry->opcode);
690
691 return SPV_SUCCESS;
692}
693
David Netoc9786432015-09-01 18:05:14 -0400694namespace {
695
696// Translates a given assembly language module into binary form.
697// If a diagnostic is generated, it is not yet marked as being
698// for a text-based input.
699spv_result_t spvTextToBinaryInternal(const spv_text text,
Lei Zhang06efdc52015-09-10 14:00:00 -0400700 spv_assembly_syntax_format_t format,
David Netoc9786432015-09-01 18:05:14 -0400701 const spv_opcode_table opcodeTable,
702 const spv_operand_table operandTable,
703 const spv_ext_inst_table extInstTable,
704 spv_binary *pBinary,
705 spv_diagnostic *pDiagnostic) {
Kenneth Benzie (Benie)83e5a292015-05-22 18:26:19 +0100706 spv_position_t position = {};
707 spvCheck(!text->str || !text->length, DIAGNOSTIC << "Text stream is empty.";
708 return SPV_ERROR_INVALID_TEXT);
709 spvCheck(!opcodeTable || !operandTable || !extInstTable,
710 return SPV_ERROR_INVALID_TABLE);
711 spvCheck(!pBinary, return SPV_ERROR_INVALID_POINTER);
712 spvCheck(!pDiagnostic, return SPV_ERROR_INVALID_DIAGNOSTIC);
713
714 // NOTE: Ensure diagnostic is zero initialised
715 *pDiagnostic = {};
716
717 uint32_t bound = 1;
718
719 std::vector<spv_instruction_t> instructions;
720
721 spvCheck(spvTextAdvance(text, &position), DIAGNOSTIC
722 << "Text stream is empty.";
723 return SPV_ERROR_INVALID_TEXT);
724
725 spv_named_id_table namedIdTable = spvNamedIdTableCreate();
726 spvCheck(!namedIdTable, return SPV_ERROR_OUT_OF_MEMORY);
727
728 spv_ext_inst_type_t extInstType = SPV_EXT_INST_TYPE_NONE;
729 while (text->length > position.index) {
730 spv_instruction_t inst = {};
731 inst.extInstType = extInstType;
732
Lei Zhang06efdc52015-09-10 14:00:00 -0400733 spvCheck(spvTextEncodeOpcode(text, format, opcodeTable, operandTable,
734 extInstTable, namedIdTable, &bound, &inst,
735 &position, pDiagnostic),
Kenneth Benzie (Benie)83e5a292015-05-22 18:26:19 +0100736 spvNamedIdTableDestory(namedIdTable);
737 return SPV_ERROR_INVALID_TEXT);
738 extInstType = inst.extInstType;
739
740 instructions.push_back(inst);
741
742 spvCheck(spvTextAdvance(text, &position), break);
743 }
744
745 spvNamedIdTableDestory(namedIdTable);
746
747 size_t totalSize = SPV_INDEX_INSTRUCTION;
748 for (auto &inst : instructions) {
749 totalSize += inst.wordCount;
750 }
751
752 uint32_t *data = new uint32_t[totalSize];
753 spvCheck(!data, return SPV_ERROR_OUT_OF_MEMORY);
754 uint64_t currentIndex = SPV_INDEX_INSTRUCTION;
755 for (auto &inst : instructions) {
756 memcpy(data + currentIndex, inst.words, sizeof(uint32_t) * inst.wordCount);
757 currentIndex += inst.wordCount;
758 }
759
760 spv_binary binary = new spv_binary_t();
761 spvCheck(!binary, delete[] data; return SPV_ERROR_OUT_OF_MEMORY);
762 binary->code = data;
763 binary->wordCount = totalSize;
764
765 spv_result_t error = spvBinaryHeaderSet(binary, bound);
766 spvCheck(error, spvBinaryDestroy(binary); return error);
767
768 *pBinary = binary;
769
770 return SPV_SUCCESS;
771}
772
Lei Zhange78a7c12015-09-10 17:07:21 -0400773} // anonymous namespace
David Netoc9786432015-09-01 18:05:14 -0400774
Lei Zhang06efdc52015-09-10 14:00:00 -0400775spv_result_t spvTextToBinary(const char *input_text,
Andrew Woloszyncfeac482015-09-09 13:04:32 -0400776 const uint64_t input_text_size,
David Netoc9786432015-09-01 18:05:14 -0400777 const spv_opcode_table opcodeTable,
778 const spv_operand_table operandTable,
779 const spv_ext_inst_table extInstTable,
780 spv_binary *pBinary, spv_diagnostic *pDiagnostic) {
Lei Zhang06efdc52015-09-10 14:00:00 -0400781 return spvTextWithFormatToBinary(
782 input_text, input_text_size, SPV_ASSEMBLY_SYNTAX_FORMAT_DEFAULT,
783 opcodeTable, operandTable, extInstTable, pBinary, pDiagnostic);
784}
785
786spv_result_t spvTextWithFormatToBinary(
787 const char *input_text, const uint64_t input_text_size,
788 spv_assembly_syntax_format_t format, const spv_opcode_table opcodeTable,
789 const spv_operand_table operandTable, const spv_ext_inst_table extInstTable,
790 spv_binary *pBinary, spv_diagnostic *pDiagnostic) {
Andrew Woloszyncfeac482015-09-09 13:04:32 -0400791 spv_text_t text = {input_text, input_text_size};
792
Lei Zhang06efdc52015-09-10 14:00:00 -0400793 spv_result_t result =
794 spvTextToBinaryInternal(&text, format, opcodeTable, operandTable,
795 extInstTable, pBinary, pDiagnostic);
David Netoc9786432015-09-01 18:05:14 -0400796 if (pDiagnostic && *pDiagnostic) (*pDiagnostic)->isTextSource = true;
797
798 return result;
799}
800
Kenneth Benzie (Benie)83e5a292015-05-22 18:26:19 +0100801void spvTextDestroy(spv_text text) {
802 spvCheck(!text, return );
803 if (text->str) {
804 delete[] text->str;
805 }
806 delete text;
807}