1 | // Copyright (c) 2015-2016 The Khronos Group Inc. |
2 | // |
3 | // 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 |
6 | // |
7 | // http://www.apache.org/licenses/LICENSE-2.0 |
8 | // |
9 | // 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. |
14 | |
15 | #include "source/text_handler.h" |
16 | |
17 | #include <algorithm> |
18 | #include <cassert> |
19 | #include <cstdlib> |
20 | #include <cstring> |
21 | #include <tuple> |
22 | |
23 | #include "source/assembly_grammar.h" |
24 | #include "source/binary.h" |
25 | #include "source/ext_inst.h" |
26 | #include "source/instruction.h" |
27 | #include "source/opcode.h" |
28 | #include "source/text.h" |
29 | #include "source/util/bitutils.h" |
30 | #include "source/util/hex_float.h" |
31 | #include "source/util/parse_number.h" |
32 | #include "source/util/string_utils.h" |
33 | |
34 | namespace spvtools { |
35 | namespace { |
36 | |
37 | // Advances |text| to the start of the next line and writes the new position to |
38 | // |position|. |
39 | spv_result_t advanceLine(spv_text text, spv_position position) { |
40 | while (true) { |
41 | if (position->index >= text->length) return SPV_END_OF_STREAM; |
42 | switch (text->str[position->index]) { |
43 | case '\0': |
44 | return SPV_END_OF_STREAM; |
45 | case '\n': |
46 | position->column = 0; |
47 | position->line++; |
48 | position->index++; |
49 | return SPV_SUCCESS; |
50 | default: |
51 | position->column++; |
52 | position->index++; |
53 | break; |
54 | } |
55 | } |
56 | } |
57 | |
58 | // Advances |text| to first non white space character and writes the new |
59 | // position to |position|. |
60 | // If a null terminator is found during the text advance, SPV_END_OF_STREAM is |
61 | // returned, SPV_SUCCESS otherwise. No error checking is performed on the |
62 | // parameters, its the users responsibility to ensure these are non null. |
63 | spv_result_t advance(spv_text text, spv_position position) { |
64 | // NOTE: Consume white space, otherwise don't advance. |
65 | while (true) { |
66 | if (position->index >= text->length) return SPV_END_OF_STREAM; |
67 | switch (text->str[position->index]) { |
68 | case '\0': |
69 | return SPV_END_OF_STREAM; |
70 | case ';': |
71 | if (spv_result_t error = advanceLine(text, position)) return error; |
72 | continue; |
73 | case ' ': |
74 | case '\t': |
75 | case '\r': |
76 | position->column++; |
77 | position->index++; |
78 | continue; |
79 | case '\n': |
80 | position->column = 0; |
81 | position->line++; |
82 | position->index++; |
83 | continue; |
84 | default: |
85 | return SPV_SUCCESS; |
86 | } |
87 | } |
88 | } |
89 | |
90 | // Fetches the next word from the given text stream starting from the given |
91 | // *position. On success, writes the decoded word into *word and updates |
92 | // *position to the location past the returned word. |
93 | // |
94 | // A word ends at the next comment or whitespace. However, double-quoted |
95 | // strings remain intact, and a backslash always escapes the next character. |
96 | spv_result_t getWord(spv_text text, spv_position position, std::string* word) { |
97 | if (!text->str || !text->length) return SPV_ERROR_INVALID_TEXT; |
98 | if (!position) return SPV_ERROR_INVALID_POINTER; |
99 | |
100 | const size_t start_index = position->index; |
101 | |
102 | bool quoting = false; |
103 | bool escaping = false; |
104 | |
105 | // NOTE: Assumes first character is not white space! |
106 | while (true) { |
107 | if (position->index >= text->length) { |
108 | word->assign(text->str + start_index, text->str + position->index); |
109 | return SPV_SUCCESS; |
110 | } |
111 | const char ch = text->str[position->index]; |
112 | if (ch == '\\') { |
113 | escaping = !escaping; |
114 | } else { |
115 | switch (ch) { |
116 | case '"': |
117 | if (!escaping) quoting = !quoting; |
118 | break; |
119 | case ' ': |
120 | case ';': |
121 | case '\t': |
122 | case '\n': |
123 | case '\r': |
124 | if (escaping || quoting) break; |
125 | word->assign(text->str + start_index, text->str + position->index); |
126 | return SPV_SUCCESS; |
127 | case '\0': { // NOTE: End of word found! |
128 | word->assign(text->str + start_index, text->str + position->index); |
129 | return SPV_SUCCESS; |
130 | } |
131 | default: |
132 | break; |
133 | } |
134 | escaping = false; |
135 | } |
136 | |
137 | position->column++; |
138 | position->index++; |
139 | } |
140 | } |
141 | |
142 | // Returns true if the characters in the text as position represent |
143 | // the start of an Opcode. |
144 | bool startsWithOp(spv_text text, spv_position position) { |
145 | if (text->length < position->index + 3) return false; |
146 | char ch0 = text->str[position->index]; |
147 | char ch1 = text->str[position->index + 1]; |
148 | char ch2 = text->str[position->index + 2]; |
149 | return ('O' == ch0 && 'p' == ch1 && ('A' <= ch2 && ch2 <= 'Z')); |
150 | } |
151 | |
152 | } // namespace |
153 | |
154 | const IdType kUnknownType = {0, false, IdTypeClass::kBottom}; |
155 | |
156 | // TODO(dneto): Reorder AssemblyContext definitions to match declaration order. |
157 | |
158 | // This represents all of the data that is only valid for the duration of |
159 | // a single compilation. |
160 | uint32_t AssemblyContext::spvNamedIdAssignOrGet(const char* textValue) { |
161 | if (!ids_to_preserve_.empty()) { |
162 | uint32_t id = 0; |
163 | if (spvtools::utils::ParseNumber(textValue, &id)) { |
164 | if (ids_to_preserve_.find(id) != ids_to_preserve_.end()) { |
165 | bound_ = std::max(bound_, id + 1); |
166 | return id; |
167 | } |
168 | } |
169 | } |
170 | |
171 | const auto it = named_ids_.find(textValue); |
172 | if (it == named_ids_.end()) { |
173 | uint32_t id = next_id_++; |
174 | if (!ids_to_preserve_.empty()) { |
175 | while (ids_to_preserve_.find(id) != ids_to_preserve_.end()) { |
176 | id = next_id_++; |
177 | } |
178 | } |
179 | |
180 | named_ids_.emplace(textValue, id); |
181 | bound_ = std::max(bound_, id + 1); |
182 | return id; |
183 | } |
184 | |
185 | return it->second; |
186 | } |
187 | |
188 | uint32_t AssemblyContext::getBound() const { return bound_; } |
189 | |
190 | spv_result_t AssemblyContext::advance() { |
191 | return spvtools::advance(text_, ¤t_position_); |
192 | } |
193 | |
194 | spv_result_t AssemblyContext::getWord(std::string* word, |
195 | spv_position next_position) { |
196 | *next_position = current_position_; |
197 | return spvtools::getWord(text_, next_position, word); |
198 | } |
199 | |
200 | bool AssemblyContext::startsWithOp() { |
201 | return spvtools::startsWithOp(text_, ¤t_position_); |
202 | } |
203 | |
204 | bool AssemblyContext::isStartOfNewInst() { |
205 | spv_position_t pos = current_position_; |
206 | if (spvtools::advance(text_, &pos)) return false; |
207 | if (spvtools::startsWithOp(text_, &pos)) return true; |
208 | |
209 | std::string word; |
210 | pos = current_position_; |
211 | if (spvtools::getWord(text_, &pos, &word)) return false; |
212 | if ('%' != word.front()) return false; |
213 | |
214 | if (spvtools::advance(text_, &pos)) return false; |
215 | if (spvtools::getWord(text_, &pos, &word)) return false; |
216 | if ("=" != word) return false; |
217 | |
218 | if (spvtools::advance(text_, &pos)) return false; |
219 | if (spvtools::startsWithOp(text_, &pos)) return true; |
220 | return false; |
221 | } |
222 | |
223 | char AssemblyContext::peek() const { |
224 | return text_->str[current_position_.index]; |
225 | } |
226 | |
227 | bool AssemblyContext::hasText() const { |
228 | return text_->length > current_position_.index; |
229 | } |
230 | |
231 | void AssemblyContext::seekForward(uint32_t size) { |
232 | current_position_.index += size; |
233 | current_position_.column += size; |
234 | } |
235 | |
236 | spv_result_t AssemblyContext::binaryEncodeU32(const uint32_t value, |
237 | spv_instruction_t* pInst) { |
238 | pInst->words.insert(pInst->words.end(), value); |
239 | return SPV_SUCCESS; |
240 | } |
241 | |
242 | spv_result_t AssemblyContext::binaryEncodeNumericLiteral( |
243 | const char* val, spv_result_t error_code, const IdType& type, |
244 | spv_instruction_t* pInst) { |
245 | using spvtools::utils::EncodeNumberStatus; |
246 | // Populate the NumberType from the IdType for parsing. |
247 | spvtools::utils::NumberType number_type; |
248 | switch (type.type_class) { |
249 | case IdTypeClass::kOtherType: |
250 | return diagnostic(SPV_ERROR_INTERNAL) |
251 | << "Unexpected numeric literal type" ; |
252 | case IdTypeClass::kScalarIntegerType: |
253 | if (type.isSigned) { |
254 | number_type = {type.bitwidth, SPV_NUMBER_SIGNED_INT}; |
255 | } else { |
256 | number_type = {type.bitwidth, SPV_NUMBER_UNSIGNED_INT}; |
257 | } |
258 | break; |
259 | case IdTypeClass::kScalarFloatType: |
260 | number_type = {type.bitwidth, SPV_NUMBER_FLOATING}; |
261 | break; |
262 | case IdTypeClass::kBottom: |
263 | // kBottom means the type is unknown and we need to infer the type before |
264 | // parsing the number. The rule is: If there is a decimal point, treat |
265 | // the value as a floating point value, otherwise a integer value, then |
266 | // if the first char of the integer text is '-', treat the integer as a |
267 | // signed integer, otherwise an unsigned integer. |
268 | uint32_t bitwidth = static_cast<uint32_t>(assumedBitWidth(type)); |
269 | if (strchr(val, '.')) { |
270 | number_type = {bitwidth, SPV_NUMBER_FLOATING}; |
271 | } else if (type.isSigned || val[0] == '-') { |
272 | number_type = {bitwidth, SPV_NUMBER_SIGNED_INT}; |
273 | } else { |
274 | number_type = {bitwidth, SPV_NUMBER_UNSIGNED_INT}; |
275 | } |
276 | break; |
277 | } |
278 | |
279 | std::string error_msg; |
280 | EncodeNumberStatus parse_status = ParseAndEncodeNumber( |
281 | val, number_type, |
282 | [this, pInst](uint32_t d) { this->binaryEncodeU32(d, pInst); }, |
283 | &error_msg); |
284 | switch (parse_status) { |
285 | case EncodeNumberStatus::kSuccess: |
286 | return SPV_SUCCESS; |
287 | case EncodeNumberStatus::kInvalidText: |
288 | return diagnostic(error_code) << error_msg; |
289 | case EncodeNumberStatus::kUnsupported: |
290 | return diagnostic(SPV_ERROR_INTERNAL) << error_msg; |
291 | case EncodeNumberStatus::kInvalidUsage: |
292 | return diagnostic(SPV_ERROR_INVALID_TEXT) << error_msg; |
293 | } |
294 | // This line is not reachable, only added to satisfy the compiler. |
295 | return diagnostic(SPV_ERROR_INTERNAL) |
296 | << "Unexpected result code from ParseAndEncodeNumber()" ; |
297 | } |
298 | |
299 | spv_result_t AssemblyContext::binaryEncodeString(const char* value, |
300 | spv_instruction_t* pInst) { |
301 | const size_t length = strlen(value); |
302 | const size_t wordCount = (length / 4) + 1; |
303 | const size_t oldWordCount = pInst->words.size(); |
304 | const size_t newWordCount = oldWordCount + wordCount; |
305 | |
306 | // TODO(dneto): We can just defer this check until later. |
307 | if (newWordCount > SPV_LIMIT_INSTRUCTION_WORD_COUNT_MAX) { |
308 | return diagnostic() << "Instruction too long: more than " |
309 | << SPV_LIMIT_INSTRUCTION_WORD_COUNT_MAX << " words." ; |
310 | } |
311 | |
312 | pInst->words.reserve(newWordCount); |
313 | spvtools::utils::AppendToVector(value, &pInst->words); |
314 | |
315 | return SPV_SUCCESS; |
316 | } |
317 | |
318 | spv_result_t AssemblyContext::recordTypeDefinition( |
319 | const spv_instruction_t* pInst) { |
320 | uint32_t value = pInst->words[1]; |
321 | if (types_.find(value) != types_.end()) { |
322 | return diagnostic() << "Value " << value |
323 | << " has already been used to generate a type" ; |
324 | } |
325 | |
326 | if (pInst->opcode == SpvOpTypeInt) { |
327 | if (pInst->words.size() != 4) |
328 | return diagnostic() << "Invalid OpTypeInt instruction" ; |
329 | types_[value] = {pInst->words[2], pInst->words[3] != 0, |
330 | IdTypeClass::kScalarIntegerType}; |
331 | } else if (pInst->opcode == SpvOpTypeFloat) { |
332 | if (pInst->words.size() != 3) |
333 | return diagnostic() << "Invalid OpTypeFloat instruction" ; |
334 | types_[value] = {pInst->words[2], false, IdTypeClass::kScalarFloatType}; |
335 | } else { |
336 | types_[value] = {0, false, IdTypeClass::kOtherType}; |
337 | } |
338 | return SPV_SUCCESS; |
339 | } |
340 | |
341 | IdType AssemblyContext::getTypeOfTypeGeneratingValue(uint32_t value) const { |
342 | auto type = types_.find(value); |
343 | if (type == types_.end()) { |
344 | return kUnknownType; |
345 | } |
346 | return std::get<1>(*type); |
347 | } |
348 | |
349 | IdType AssemblyContext::getTypeOfValueInstruction(uint32_t value) const { |
350 | auto type_value = value_types_.find(value); |
351 | if (type_value == value_types_.end()) { |
352 | return {0, false, IdTypeClass::kBottom}; |
353 | } |
354 | return getTypeOfTypeGeneratingValue(std::get<1>(*type_value)); |
355 | } |
356 | |
357 | spv_result_t AssemblyContext::recordTypeIdForValue(uint32_t value, |
358 | uint32_t type) { |
359 | bool successfully_inserted = false; |
360 | std::tie(std::ignore, successfully_inserted) = |
361 | value_types_.insert(std::make_pair(value, type)); |
362 | if (!successfully_inserted) |
363 | return diagnostic() << "Value is being defined a second time" ; |
364 | return SPV_SUCCESS; |
365 | } |
366 | |
367 | spv_result_t AssemblyContext::recordIdAsExtInstImport( |
368 | uint32_t id, spv_ext_inst_type_t type) { |
369 | bool successfully_inserted = false; |
370 | std::tie(std::ignore, successfully_inserted) = |
371 | import_id_to_ext_inst_type_.insert(std::make_pair(id, type)); |
372 | if (!successfully_inserted) |
373 | return diagnostic() << "Import Id is being defined a second time" ; |
374 | return SPV_SUCCESS; |
375 | } |
376 | |
377 | spv_ext_inst_type_t AssemblyContext::getExtInstTypeForId(uint32_t id) const { |
378 | auto type = import_id_to_ext_inst_type_.find(id); |
379 | if (type == import_id_to_ext_inst_type_.end()) { |
380 | return SPV_EXT_INST_TYPE_NONE; |
381 | } |
382 | return std::get<1>(*type); |
383 | } |
384 | |
385 | std::set<uint32_t> AssemblyContext::GetNumericIds() const { |
386 | std::set<uint32_t> ids; |
387 | for (const auto& kv : named_ids_) { |
388 | uint32_t id; |
389 | if (spvtools::utils::ParseNumber(kv.first.c_str(), &id)) ids.insert(id); |
390 | } |
391 | return ids; |
392 | } |
393 | |
394 | } // namespace spvtools |
395 | |