1 /*
2 * Copyright © 2015 Intel Corporation
3 *
4 * Permission is hereby granted, free of charge, to any person obtaining a
5 * copy of this software and associated documentation files (the "Software"),
6 * to deal in the Software without restriction, including without limitation
7 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
8 * and/or sell copies of the Software, and to permit persons to whom the
9 * Software is furnished to do so, subject to the following conditions:
10 *
11 * The above copyright notice and this permission notice (including the next
12 * paragraph) shall be included in all copies or substantial portions of the
13 * Software.
14 *
15 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
18 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
20 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
21 * IN THE SOFTWARE.
22 *
23 * Authors:
24 * Jason Ekstrand (jason@jlekstrand.net)
25 *
26 */
27
28 #include "nir/nir.h"
29 #include "nir/nir_builder.h"
30 #include "nir/nir_array.h"
31 #include "nir_spirv.h"
32 #include "spirv.h"
33
34 struct vtn_builder;
35 struct vtn_decoration;
36
37 enum vtn_value_type {
38 vtn_value_type_invalid = 0,
39 vtn_value_type_undef,
40 vtn_value_type_string,
41 vtn_value_type_decoration_group,
42 vtn_value_type_type,
43 vtn_value_type_constant,
44 vtn_value_type_access_chain,
45 vtn_value_type_function,
46 vtn_value_type_block,
47 vtn_value_type_ssa,
48 vtn_value_type_extension,
49 vtn_value_type_image_pointer,
50 vtn_value_type_sampled_image,
51 };
52
53 enum vtn_branch_type {
54 vtn_branch_type_none,
55 vtn_branch_type_switch_break,
56 vtn_branch_type_switch_fallthrough,
57 vtn_branch_type_loop_break,
58 vtn_branch_type_loop_continue,
59 vtn_branch_type_discard,
60 vtn_branch_type_return,
61 };
62
63 enum vtn_cf_node_type {
64 vtn_cf_node_type_block,
65 vtn_cf_node_type_if,
66 vtn_cf_node_type_loop,
67 vtn_cf_node_type_switch,
68 };
69
70 struct vtn_cf_node {
71 struct list_head link;
72 enum vtn_cf_node_type type;
73 };
74
75 struct vtn_loop {
76 struct vtn_cf_node node;
77
78 /* The main body of the loop */
79 struct list_head body;
80
81 /* The "continue" part of the loop. This gets executed after the body
82 * and is where you go when you hit a continue.
83 */
84 struct list_head cont_body;
85
86 SpvLoopControlMask control;
87 };
88
89 struct vtn_if {
90 struct vtn_cf_node node;
91
92 uint32_t condition;
93
94 enum vtn_branch_type then_type;
95 struct list_head then_body;
96
97 enum vtn_branch_type else_type;
98 struct list_head else_body;
99
100 SpvSelectionControlMask control;
101 };
102
103 struct vtn_case {
104 struct list_head link;
105
106 struct list_head body;
107
108 /* The block that starts this case */
109 struct vtn_block *start_block;
110
111 /* The fallthrough case, if any */
112 struct vtn_case *fallthrough;
113
114 /* The uint32_t values that map to this case */
115 nir_array values;
116
117 /* True if this is the default case */
118 bool is_default;
119
120 /* Initialized to false; used when sorting the list of cases */
121 bool visited;
122 };
123
124 struct vtn_switch {
125 struct vtn_cf_node node;
126
127 uint32_t selector;
128
129 struct list_head cases;
130 };
131
132 struct vtn_block {
133 struct vtn_cf_node node;
134
135 /** A pointer to the label instruction */
136 const uint32_t *label;
137
138 /** A pointer to the merge instruction (or NULL if non exists) */
139 const uint32_t *merge;
140
141 /** A pointer to the branch instruction that ends this block */
142 const uint32_t *branch;
143
144 enum vtn_branch_type branch_type;
145
146 /** Points to the loop that this block starts (if it starts a loop) */
147 struct vtn_loop *loop;
148
149 /** Points to the switch case started by this block (if any) */
150 struct vtn_case *switch_case;
151
152 /** Every block ends in a nop intrinsic so that we can find it again */
153 nir_intrinsic_instr *end_nop;
154 };
155
156 struct vtn_function {
157 struct exec_node node;
158
159 nir_function_impl *impl;
160 struct vtn_block *start_block;
161
162 struct list_head body;
163
164 const uint32_t *end;
165
166 SpvFunctionControlMask control;
167 };
168
169 typedef bool (*vtn_instruction_handler)(struct vtn_builder *, uint32_t,
170 const uint32_t *, unsigned);
171
172 void vtn_build_cfg(struct vtn_builder *b, const uint32_t *words,
173 const uint32_t *end);
174 void vtn_function_emit(struct vtn_builder *b, struct vtn_function *func,
175 vtn_instruction_handler instruction_handler);
176
177 const uint32_t *
178 vtn_foreach_instruction(struct vtn_builder *b, const uint32_t *start,
179 const uint32_t *end, vtn_instruction_handler handler);
180
181 struct vtn_ssa_value {
182 union {
183 nir_ssa_def *def;
184 struct vtn_ssa_value **elems;
185 };
186
187 /* For matrices, if this is non-NULL, then this value is actually the
188 * transpose of some other value. The value that `transposed` points to
189 * always dominates this value.
190 */
191 struct vtn_ssa_value *transposed;
192
193 const struct glsl_type *type;
194 };
195
196 struct vtn_type {
197 const struct glsl_type *type;
198
199 /* The value that declares this type. Used for finding decorations */
200 struct vtn_value *val;
201
202 /* for matrices, whether the matrix is stored row-major */
203 bool row_major;
204
205 /* for structs, the offset of each member */
206 unsigned *offsets;
207
208 /* for structs, whether it was decorated as a "non-SSBO-like" block */
209 bool block;
210
211 /* for structs, whether it was decorated as an "SSBO-like" block */
212 bool buffer_block;
213
214 /* for structs with block == true, whether this is a builtin block (i.e. a
215 * block that contains only builtins).
216 */
217 bool builtin_block;
218
219 /* Image format for image_load_store type images */
220 unsigned image_format;
221
222 /* Access qualifier for storage images */
223 SpvAccessQualifier access_qualifier;
224
225 /* for arrays and matrices, the array stride */
226 unsigned stride;
227
228 /* for arrays, the vtn_type for the elements of the array */
229 struct vtn_type *array_element;
230
231 /* for structures, the vtn_type for each member */
232 struct vtn_type **members;
233
234 /* Whether this type, or a parent type, has been decorated as a builtin */
235 bool is_builtin;
236
237 SpvBuiltIn builtin;
238 };
239
240 struct vtn_variable;
241
242 enum vtn_access_mode {
243 vtn_access_mode_id,
244 vtn_access_mode_literal,
245 };
246
247 struct vtn_access_link {
248 enum vtn_access_mode mode;
249 uint32_t id;
250 };
251
252 struct vtn_access_chain {
253 struct vtn_variable *var;
254
255 uint32_t length;
256
257 /* Struct elements and array offsets */
258 struct vtn_access_link link[0];
259 };
260
261 enum vtn_variable_mode {
262 vtn_variable_mode_local,
263 vtn_variable_mode_global,
264 vtn_variable_mode_param,
265 vtn_variable_mode_ubo,
266 vtn_variable_mode_ssbo,
267 vtn_variable_mode_push_constant,
268 vtn_variable_mode_image,
269 vtn_variable_mode_sampler,
270 vtn_variable_mode_workgroup,
271 vtn_variable_mode_input,
272 vtn_variable_mode_output,
273 };
274
275 struct vtn_variable {
276 enum vtn_variable_mode mode;
277
278 struct vtn_type *type;
279
280 unsigned descriptor_set;
281 unsigned binding;
282 unsigned input_attachment_index;
283 bool patch;
284
285 nir_variable *var;
286 nir_variable **members;
287
288 struct vtn_access_chain chain;
289 };
290
291 struct vtn_image_pointer {
292 struct vtn_access_chain *image;
293 nir_ssa_def *coord;
294 nir_ssa_def *sample;
295 };
296
297 struct vtn_sampled_image {
298 struct vtn_access_chain *image; /* Image or array of images */
299 struct vtn_access_chain *sampler; /* Sampler */
300 };
301
302 struct vtn_value {
303 enum vtn_value_type value_type;
304 const char *name;
305 struct vtn_decoration *decoration;
306 union {
307 void *ptr;
308 char *str;
309 struct vtn_type *type;
310 struct {
311 nir_constant *constant;
312 const struct glsl_type *const_type;
313 };
314 struct vtn_access_chain *access_chain;
315 struct vtn_image_pointer *image;
316 struct vtn_sampled_image *sampled_image;
317 struct vtn_function *func;
318 struct vtn_block *block;
319 struct vtn_ssa_value *ssa;
320 vtn_instruction_handler ext_handler;
321 };
322 };
323
324 #define VTN_DEC_DECORATION -1
325 #define VTN_DEC_EXECUTION_MODE -2
326 #define VTN_DEC_STRUCT_MEMBER0 0
327
328 struct vtn_decoration {
329 struct vtn_decoration *next;
330
331 /* Specifies how to apply this decoration. Negative values represent a
332 * decoration or execution mode. (See the VTN_DEC_ #defines above.)
333 * Non-negative values specify that it applies to a structure member.
334 */
335 int scope;
336
337 const uint32_t *literals;
338 struct vtn_value *group;
339
340 union {
341 SpvDecoration decoration;
342 SpvExecutionMode exec_mode;
343 };
344 };
345
346 struct vtn_builder {
347 nir_builder nb;
348
349 nir_shader *shader;
350 nir_function_impl *impl;
351 const struct nir_spirv_supported_extensions *ext;
352 struct vtn_block *block;
353
354 /* Current file, line, and column. Useful for debugging. Set
355 * automatically by vtn_foreach_instruction.
356 */
357 char *file;
358 int line, col;
359
360 /*
361 * In SPIR-V, constants are global, whereas in NIR, the load_const
362 * instruction we use is per-function. So while we parse each function, we
363 * keep a hash table of constants we've resolved to nir_ssa_value's so
364 * far, and we lazily resolve them when we see them used in a function.
365 */
366 struct hash_table *const_table;
367
368 /*
369 * Map from phi instructions (pointer to the start of the instruction)
370 * to the variable corresponding to it.
371 */
372 struct hash_table *phi_table;
373
374 unsigned num_specializations;
375 struct nir_spirv_specialization *specializations;
376
377 unsigned value_id_bound;
378 struct vtn_value *values;
379
380 gl_shader_stage entry_point_stage;
381 const char *entry_point_name;
382 struct vtn_value *entry_point;
383 bool origin_upper_left;
384 bool pixel_center_integer;
385
386 struct vtn_function *func;
387 struct exec_list functions;
388
389 /* Current function parameter index */
390 unsigned func_param_idx;
391
392 bool has_loop_continue;
393 };
394
395 static inline struct vtn_value *
vtn_push_value(struct vtn_builder * b,uint32_t value_id,enum vtn_value_type value_type)396 vtn_push_value(struct vtn_builder *b, uint32_t value_id,
397 enum vtn_value_type value_type)
398 {
399 assert(value_id < b->value_id_bound);
400 assert(b->values[value_id].value_type == vtn_value_type_invalid);
401
402 b->values[value_id].value_type = value_type;
403
404 return &b->values[value_id];
405 }
406
407 static inline struct vtn_value *
vtn_untyped_value(struct vtn_builder * b,uint32_t value_id)408 vtn_untyped_value(struct vtn_builder *b, uint32_t value_id)
409 {
410 assert(value_id < b->value_id_bound);
411 return &b->values[value_id];
412 }
413
414 static inline struct vtn_value *
vtn_value(struct vtn_builder * b,uint32_t value_id,enum vtn_value_type value_type)415 vtn_value(struct vtn_builder *b, uint32_t value_id,
416 enum vtn_value_type value_type)
417 {
418 struct vtn_value *val = vtn_untyped_value(b, value_id);
419 assert(val->value_type == value_type);
420 return val;
421 }
422
423 void _vtn_warn(const char *file, int line, const char *msg, ...);
424 #define vtn_warn(...) _vtn_warn(__FILE__, __LINE__, __VA_ARGS__)
425
426 struct vtn_ssa_value *vtn_ssa_value(struct vtn_builder *b, uint32_t value_id);
427
428 struct vtn_ssa_value *vtn_create_ssa_value(struct vtn_builder *b,
429 const struct glsl_type *type);
430
431 struct vtn_ssa_value *vtn_ssa_transpose(struct vtn_builder *b,
432 struct vtn_ssa_value *src);
433
434 nir_ssa_def *vtn_vector_extract(struct vtn_builder *b, nir_ssa_def *src,
435 unsigned index);
436 nir_ssa_def *vtn_vector_extract_dynamic(struct vtn_builder *b, nir_ssa_def *src,
437 nir_ssa_def *index);
438 nir_ssa_def *vtn_vector_insert(struct vtn_builder *b, nir_ssa_def *src,
439 nir_ssa_def *insert, unsigned index);
440 nir_ssa_def *vtn_vector_insert_dynamic(struct vtn_builder *b, nir_ssa_def *src,
441 nir_ssa_def *insert, nir_ssa_def *index);
442
443 nir_deref_var *vtn_nir_deref(struct vtn_builder *b, uint32_t id);
444
445 nir_deref_var *vtn_access_chain_to_deref(struct vtn_builder *b,
446 struct vtn_access_chain *chain);
447 nir_ssa_def *
448 vtn_access_chain_to_offset(struct vtn_builder *b,
449 struct vtn_access_chain *chain,
450 nir_ssa_def **index_out, struct vtn_type **type_out,
451 unsigned *end_idx_out, bool stop_at_matrix);
452
453 struct vtn_ssa_value *vtn_local_load(struct vtn_builder *b, nir_deref_var *src);
454
455 void vtn_local_store(struct vtn_builder *b, struct vtn_ssa_value *src,
456 nir_deref_var *dest);
457
458 struct vtn_ssa_value *
459 vtn_variable_load(struct vtn_builder *b, struct vtn_access_chain *src);
460
461 void vtn_variable_store(struct vtn_builder *b, struct vtn_ssa_value *src,
462 struct vtn_access_chain *dest);
463
464 void vtn_handle_variables(struct vtn_builder *b, SpvOp opcode,
465 const uint32_t *w, unsigned count);
466
467
468 typedef void (*vtn_decoration_foreach_cb)(struct vtn_builder *,
469 struct vtn_value *,
470 int member,
471 const struct vtn_decoration *,
472 void *);
473
474 void vtn_foreach_decoration(struct vtn_builder *b, struct vtn_value *value,
475 vtn_decoration_foreach_cb cb, void *data);
476
477 typedef void (*vtn_execution_mode_foreach_cb)(struct vtn_builder *,
478 struct vtn_value *,
479 const struct vtn_decoration *,
480 void *);
481
482 void vtn_foreach_execution_mode(struct vtn_builder *b, struct vtn_value *value,
483 vtn_execution_mode_foreach_cb cb, void *data);
484
485 nir_op vtn_nir_alu_op_for_spirv_opcode(SpvOp opcode, bool *swap,
486 nir_alu_type src, nir_alu_type dst);
487
488 void vtn_handle_alu(struct vtn_builder *b, SpvOp opcode,
489 const uint32_t *w, unsigned count);
490
491 bool vtn_handle_glsl450_instruction(struct vtn_builder *b, uint32_t ext_opcode,
492 const uint32_t *words, unsigned count);
493
494 static inline uint64_t
vtn_u64_literal(const uint32_t * w)495 vtn_u64_literal(const uint32_t *w)
496 {
497 return (uint64_t)w[1] << 32 | w[0];
498 }
499