spirv: Rewrite CFG construction
[mesa.git] / src / compiler / spirv / vtn_private.h
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 #ifndef _VTN_PRIVATE_H_
29 #define _VTN_PRIVATE_H_
30
31 #include <setjmp.h>
32
33 #include "nir/nir.h"
34 #include "nir/nir_builder.h"
35 #include "util/u_dynarray.h"
36 #include "nir_spirv.h"
37 #include "spirv.h"
38
39 struct vtn_builder;
40 struct vtn_decoration;
41
42 void vtn_log(struct vtn_builder *b, enum nir_spirv_debug_level level,
43 size_t spirv_offset, const char *message);
44
45 void vtn_logf(struct vtn_builder *b, enum nir_spirv_debug_level level,
46 size_t spirv_offset, const char *fmt, ...) PRINTFLIKE(4, 5);
47
48 #define vtn_info(...) vtn_logf(b, NIR_SPIRV_DEBUG_LEVEL_INFO, 0, __VA_ARGS__)
49
50 void _vtn_warn(struct vtn_builder *b, const char *file, unsigned line,
51 const char *fmt, ...) PRINTFLIKE(4, 5);
52 #define vtn_warn(...) _vtn_warn(b, __FILE__, __LINE__, __VA_ARGS__)
53
54 void _vtn_err(struct vtn_builder *b, const char *file, unsigned line,
55 const char *fmt, ...) PRINTFLIKE(4, 5);
56 #define vtn_err(...) _vtn_err(b, __FILE__, __LINE__, __VA_ARGS__)
57
58 /** Fail SPIR-V parsing
59 *
60 * This function logs an error and then bails out of the shader compile using
61 * longjmp. This being safe relies on two things:
62 *
63 * 1) We must guarantee that setjmp is called after allocating the builder
64 * and setting up b->debug (so that logging works) but before before any
65 * errors have a chance to occur.
66 *
67 * 2) While doing the SPIR-V -> NIR conversion, we need to be careful to
68 * ensure that all heap allocations happen through ralloc and are parented
69 * to the builder. This way they will get properly cleaned up on error.
70 *
71 * 3) We must ensure that _vtn_fail is never called while a mutex lock or a
72 * reference to any other resource is held with the exception of ralloc
73 * objects which are parented to the builder.
74 *
75 * So long as these two things continue to hold, we can easily longjmp back to
76 * spirv_to_nir(), clean up the builder, and return NULL.
77 */
78 NORETURN void
79 _vtn_fail(struct vtn_builder *b, const char *file, unsigned line,
80 const char *fmt, ...) PRINTFLIKE(4, 5);
81
82 #define vtn_fail(...) _vtn_fail(b, __FILE__, __LINE__, __VA_ARGS__)
83
84 /** Fail if the given expression evaluates to true */
85 #define vtn_fail_if(expr, ...) \
86 do { \
87 if (unlikely(expr)) \
88 vtn_fail(__VA_ARGS__); \
89 } while (0)
90
91 #define _vtn_fail_with(t, msg, v) \
92 vtn_fail("%s: %s (%u)\n", msg, spirv_ ## t ## _to_string(v), v)
93
94 #define vtn_fail_with_decoration(msg, v) _vtn_fail_with(decoration, msg, v)
95 #define vtn_fail_with_opcode(msg, v) _vtn_fail_with(op, msg, v)
96
97 /** Assert that a condition is true and, if it isn't, vtn_fail
98 *
99 * This macro is transitional only and should not be used in new code. Use
100 * vtn_fail_if and provide a real message instead.
101 */
102 #define vtn_assert(expr) \
103 do { \
104 if (!likely(expr)) \
105 vtn_fail("%s", #expr); \
106 } while (0)
107
108 enum vtn_value_type {
109 vtn_value_type_invalid = 0,
110 vtn_value_type_undef,
111 vtn_value_type_string,
112 vtn_value_type_decoration_group,
113 vtn_value_type_type,
114 vtn_value_type_constant,
115 vtn_value_type_pointer,
116 vtn_value_type_function,
117 vtn_value_type_block,
118 vtn_value_type_ssa,
119 vtn_value_type_extension,
120 vtn_value_type_image_pointer,
121 vtn_value_type_sampled_image,
122 };
123
124 enum vtn_branch_type {
125 vtn_branch_type_none,
126 vtn_branch_type_if_merge,
127 vtn_branch_type_switch_break,
128 vtn_branch_type_switch_fallthrough,
129 vtn_branch_type_loop_break,
130 vtn_branch_type_loop_continue,
131 vtn_branch_type_loop_back_edge,
132 vtn_branch_type_discard,
133 vtn_branch_type_return,
134 };
135
136 enum vtn_cf_node_type {
137 vtn_cf_node_type_block,
138 vtn_cf_node_type_if,
139 vtn_cf_node_type_loop,
140 vtn_cf_node_type_case,
141 vtn_cf_node_type_switch,
142 vtn_cf_node_type_function,
143 };
144
145 struct vtn_cf_node {
146 struct list_head link;
147 struct vtn_cf_node *parent;
148 enum vtn_cf_node_type type;
149 };
150
151 struct vtn_loop {
152 struct vtn_cf_node node;
153
154 /* The main body of the loop */
155 struct list_head body;
156
157 /* The "continue" part of the loop. This gets executed after the body
158 * and is where you go when you hit a continue.
159 */
160 struct list_head cont_body;
161
162 struct vtn_block *header_block;
163 struct vtn_block *cont_block;
164 struct vtn_block *break_block;
165
166 SpvLoopControlMask control;
167 };
168
169 struct vtn_if {
170 struct vtn_cf_node node;
171
172 uint32_t condition;
173
174 enum vtn_branch_type then_type;
175 struct list_head then_body;
176
177 enum vtn_branch_type else_type;
178 struct list_head else_body;
179
180 struct vtn_block *merge_block;
181
182 SpvSelectionControlMask control;
183 };
184
185 struct vtn_case {
186 struct vtn_cf_node node;
187
188 enum vtn_branch_type type;
189 struct list_head body;
190
191 /* The fallthrough case, if any */
192 struct vtn_case *fallthrough;
193
194 /* The uint32_t values that map to this case */
195 struct util_dynarray values;
196
197 /* True if this is the default case */
198 bool is_default;
199
200 /* Initialized to false; used when sorting the list of cases */
201 bool visited;
202 };
203
204 struct vtn_switch {
205 struct vtn_cf_node node;
206
207 uint32_t selector;
208
209 struct list_head cases;
210
211 struct vtn_block *break_block;
212 };
213
214 struct vtn_block {
215 struct vtn_cf_node node;
216
217 /** A pointer to the label instruction */
218 const uint32_t *label;
219
220 /** A pointer to the merge instruction (or NULL if non exists) */
221 const uint32_t *merge;
222
223 /** A pointer to the branch instruction that ends this block */
224 const uint32_t *branch;
225
226 enum vtn_branch_type branch_type;
227
228 /* The CF node for which this is a merge target
229 *
230 * The SPIR-V spec requires that any given block can be the merge target
231 * for at most one merge instruction. If this block is a merge target,
232 * this points back to the block containing that merge instruction.
233 */
234 struct vtn_cf_node *merge_cf_node;
235
236 /** Points to the loop that this block starts (if it starts a loop) */
237 struct vtn_loop *loop;
238
239 /** Points to the switch case started by this block (if any) */
240 struct vtn_case *switch_case;
241
242 /** Every block ends in a nop intrinsic so that we can find it again */
243 nir_intrinsic_instr *end_nop;
244 };
245
246 struct vtn_function {
247 struct vtn_cf_node node;
248
249 struct vtn_type *type;
250
251 bool referenced;
252 bool emitted;
253
254 nir_function_impl *impl;
255 struct vtn_block *start_block;
256
257 struct list_head body;
258
259 const uint32_t *end;
260
261 SpvFunctionControlMask control;
262 };
263
264 #define VTN_DECL_CF_NODE_CAST(_type) \
265 static inline struct vtn_##_type * \
266 vtn_cf_node_as_##_type(struct vtn_cf_node *node) \
267 { \
268 assert(node->type == vtn_cf_node_type_##_type); \
269 return (struct vtn_##_type *)node; \
270 }
271
272 VTN_DECL_CF_NODE_CAST(block)
273 VTN_DECL_CF_NODE_CAST(loop)
274 VTN_DECL_CF_NODE_CAST(if)
275 VTN_DECL_CF_NODE_CAST(case)
276 VTN_DECL_CF_NODE_CAST(switch)
277 VTN_DECL_CF_NODE_CAST(function)
278
279 #define vtn_foreach_cf_node(node, cf_list) \
280 list_for_each_entry(struct vtn_cf_node, node, cf_list, link)
281
282 typedef bool (*vtn_instruction_handler)(struct vtn_builder *, SpvOp,
283 const uint32_t *, unsigned);
284
285 void vtn_build_cfg(struct vtn_builder *b, const uint32_t *words,
286 const uint32_t *end);
287 void vtn_function_emit(struct vtn_builder *b, struct vtn_function *func,
288 vtn_instruction_handler instruction_handler);
289 void vtn_handle_function_call(struct vtn_builder *b, SpvOp opcode,
290 const uint32_t *w, unsigned count);
291
292 const uint32_t *
293 vtn_foreach_instruction(struct vtn_builder *b, const uint32_t *start,
294 const uint32_t *end, vtn_instruction_handler handler);
295
296 struct vtn_ssa_value {
297 union {
298 nir_ssa_def *def;
299 struct vtn_ssa_value **elems;
300 };
301
302 /* For matrices, if this is non-NULL, then this value is actually the
303 * transpose of some other value. The value that `transposed` points to
304 * always dominates this value.
305 */
306 struct vtn_ssa_value *transposed;
307
308 const struct glsl_type *type;
309
310 /* Access qualifiers */
311 enum gl_access_qualifier access;
312 };
313
314 enum vtn_base_type {
315 vtn_base_type_void,
316 vtn_base_type_scalar,
317 vtn_base_type_vector,
318 vtn_base_type_matrix,
319 vtn_base_type_array,
320 vtn_base_type_struct,
321 vtn_base_type_pointer,
322 vtn_base_type_image,
323 vtn_base_type_sampler,
324 vtn_base_type_sampled_image,
325 vtn_base_type_function,
326 };
327
328 struct vtn_type {
329 enum vtn_base_type base_type;
330
331 const struct glsl_type *type;
332
333 /* The SPIR-V id of the given type. */
334 uint32_t id;
335
336 /* Specifies the length of complex types.
337 *
338 * For Workgroup pointers, this is the size of the referenced type.
339 */
340 unsigned length;
341
342 /* for arrays, matrices and pointers, the array stride */
343 unsigned stride;
344
345 /* Access qualifiers */
346 enum gl_access_qualifier access;
347
348 union {
349 /* Members for scalar, vector, and array-like types */
350 struct {
351 /* for arrays, the vtn_type for the elements of the array */
352 struct vtn_type *array_element;
353
354 /* for matrices, whether the matrix is stored row-major */
355 bool row_major:1;
356
357 /* Whether this type, or a parent type, has been decorated as a
358 * builtin
359 */
360 bool is_builtin:1;
361
362 /* Which built-in to use */
363 SpvBuiltIn builtin;
364 };
365
366 /* Members for struct types */
367 struct {
368 /* for structures, the vtn_type for each member */
369 struct vtn_type **members;
370
371 /* for structs, the offset of each member */
372 unsigned *offsets;
373
374 /* for structs, whether it was decorated as a "non-SSBO-like" block */
375 bool block:1;
376
377 /* for structs, whether it was decorated as an "SSBO-like" block */
378 bool buffer_block:1;
379
380 /* for structs with block == true, whether this is a builtin block
381 * (i.e. a block that contains only builtins).
382 */
383 bool builtin_block:1;
384
385 /* for structs and unions it specifies the minimum alignment of the
386 * members. 0 means packed.
387 *
388 * Set by CPacked and Alignment Decorations in kernels.
389 */
390 bool packed:1;
391 };
392
393 /* Members for pointer types */
394 struct {
395 /* For pointers, the vtn_type for dereferenced type */
396 struct vtn_type *deref;
397
398 /* Storage class for pointers */
399 SpvStorageClass storage_class;
400
401 /* Required alignment for pointers */
402 uint32_t align;
403 };
404
405 /* Members for image types */
406 struct {
407 /* For images, indicates whether it's sampled or storage */
408 bool sampled;
409
410 /* Image format for image_load_store type images */
411 unsigned image_format;
412
413 /* Access qualifier for storage images */
414 SpvAccessQualifier access_qualifier;
415 };
416
417 /* Members for sampled image types */
418 struct {
419 /* For sampled images, the image type */
420 struct vtn_type *image;
421 };
422
423 /* Members for function types */
424 struct {
425 /* For functions, the vtn_type for each parameter */
426 struct vtn_type **params;
427
428 /* Return type for functions */
429 struct vtn_type *return_type;
430 };
431 };
432 };
433
434 bool vtn_type_contains_block(struct vtn_builder *b, struct vtn_type *type);
435
436 bool vtn_types_compatible(struct vtn_builder *b,
437 struct vtn_type *t1, struct vtn_type *t2);
438
439 struct vtn_type *vtn_type_without_array(struct vtn_type *type);
440
441 struct vtn_variable;
442
443 enum vtn_access_mode {
444 vtn_access_mode_id,
445 vtn_access_mode_literal,
446 };
447
448 struct vtn_access_link {
449 enum vtn_access_mode mode;
450 int64_t id;
451 };
452
453 struct vtn_access_chain {
454 uint32_t length;
455
456 /** Whether or not to treat the base pointer as an array. This is only
457 * true if this access chain came from an OpPtrAccessChain.
458 */
459 bool ptr_as_array;
460
461 /* Access qualifiers */
462 enum gl_access_qualifier access;
463
464 /** Struct elements and array offsets.
465 *
466 * This is an array of 1 so that it can conveniently be created on the
467 * stack but the real length is given by the length field.
468 */
469 struct vtn_access_link link[1];
470 };
471
472 enum vtn_variable_mode {
473 vtn_variable_mode_function,
474 vtn_variable_mode_private,
475 vtn_variable_mode_uniform,
476 vtn_variable_mode_ubo,
477 vtn_variable_mode_ssbo,
478 vtn_variable_mode_phys_ssbo,
479 vtn_variable_mode_push_constant,
480 vtn_variable_mode_workgroup,
481 vtn_variable_mode_cross_workgroup,
482 vtn_variable_mode_input,
483 vtn_variable_mode_output,
484 vtn_variable_mode_image,
485 };
486
487 struct vtn_pointer {
488 /** The variable mode for the referenced data */
489 enum vtn_variable_mode mode;
490
491 /** The dereferenced type of this pointer */
492 struct vtn_type *type;
493
494 /** The pointer type of this pointer
495 *
496 * This may be NULL for some temporary pointers constructed as part of a
497 * large load, store, or copy. It MUST be valid for all pointers which are
498 * stored as SPIR-V SSA values.
499 */
500 struct vtn_type *ptr_type;
501
502 /** The referenced variable, if known
503 *
504 * This field may be NULL if the pointer uses a (block_index, offset) pair
505 * instead of an access chain or if the access chain starts at a deref.
506 */
507 struct vtn_variable *var;
508
509 /** The NIR deref corresponding to this pointer */
510 nir_deref_instr *deref;
511
512 /** A (block_index, offset) pair representing a UBO or SSBO position. */
513 struct nir_ssa_def *block_index;
514 struct nir_ssa_def *offset;
515
516 /* Access qualifiers */
517 enum gl_access_qualifier access;
518 };
519
520 bool vtn_mode_uses_ssa_offset(struct vtn_builder *b,
521 enum vtn_variable_mode mode);
522
523 static inline bool vtn_pointer_uses_ssa_offset(struct vtn_builder *b,
524 struct vtn_pointer *ptr)
525 {
526 return vtn_mode_uses_ssa_offset(b, ptr->mode);
527 }
528
529
530 struct vtn_variable {
531 enum vtn_variable_mode mode;
532
533 struct vtn_type *type;
534
535 unsigned descriptor_set;
536 unsigned binding;
537 bool explicit_binding;
538 unsigned offset;
539 unsigned input_attachment_index;
540 bool patch;
541
542 nir_variable *var;
543
544 /* If the variable is a struct with a location set on it then this will be
545 * stored here. This will be used to calculate locations for members that
546 * don’t have their own explicit location.
547 */
548 int base_location;
549
550 int shared_location;
551
552 /**
553 * In some early released versions of GLSLang, it implemented all function
554 * calls by making copies of all parameters into temporary variables and
555 * passing those variables into the function. It even did so for samplers
556 * and images which violates the SPIR-V spec. Unfortunately, two games
557 * (Talos Principle and Doom) shipped with this old version of GLSLang and
558 * also happen to pass samplers into functions. Talos Principle received
559 * an update fairly shortly after release with an updated GLSLang. Doom,
560 * on the other hand, has never received an update so we need to work
561 * around this GLSLang issue in SPIR-V -> NIR. Hopefully, we can drop this
562 * hack at some point in the future.
563 */
564 struct vtn_pointer *copy_prop_sampler;
565
566 /* Access qualifiers. */
567 enum gl_access_qualifier access;
568 };
569
570 struct vtn_image_pointer {
571 struct vtn_pointer *image;
572 nir_ssa_def *coord;
573 nir_ssa_def *sample;
574 nir_ssa_def *lod;
575 };
576
577 struct vtn_sampled_image {
578 struct vtn_pointer *image; /* Image or array of images */
579 struct vtn_pointer *sampler; /* Sampler */
580 };
581
582 struct vtn_value {
583 enum vtn_value_type value_type;
584 const char *name;
585 struct vtn_decoration *decoration;
586 struct vtn_type *type;
587 union {
588 void *ptr;
589 char *str;
590 nir_constant *constant;
591 struct vtn_pointer *pointer;
592 struct vtn_image_pointer *image;
593 struct vtn_sampled_image *sampled_image;
594 struct vtn_function *func;
595 struct vtn_block *block;
596 struct vtn_ssa_value *ssa;
597 vtn_instruction_handler ext_handler;
598 };
599 };
600
601 #define VTN_DEC_DECORATION -1
602 #define VTN_DEC_EXECUTION_MODE -2
603 #define VTN_DEC_STRUCT_MEMBER0 0
604
605 struct vtn_decoration {
606 struct vtn_decoration *next;
607
608 /* Specifies how to apply this decoration. Negative values represent a
609 * decoration or execution mode. (See the VTN_DEC_ #defines above.)
610 * Non-negative values specify that it applies to a structure member.
611 */
612 int scope;
613
614 const uint32_t *operands;
615 struct vtn_value *group;
616
617 union {
618 SpvDecoration decoration;
619 SpvExecutionMode exec_mode;
620 };
621 };
622
623 struct vtn_builder {
624 nir_builder nb;
625
626 /* Used by vtn_fail to jump back to the beginning of SPIR-V compilation */
627 jmp_buf fail_jump;
628
629 const uint32_t *spirv;
630 size_t spirv_word_count;
631
632 nir_shader *shader;
633 struct spirv_to_nir_options *options;
634 struct vtn_block *block;
635
636 /* Current offset, file, line, and column. Useful for debugging. Set
637 * automatically by vtn_foreach_instruction.
638 */
639 size_t spirv_offset;
640 char *file;
641 int line, col;
642
643 /*
644 * In SPIR-V, constants are global, whereas in NIR, the load_const
645 * instruction we use is per-function. So while we parse each function, we
646 * keep a hash table of constants we've resolved to nir_ssa_value's so
647 * far, and we lazily resolve them when we see them used in a function.
648 */
649 struct hash_table *const_table;
650
651 /*
652 * Map from phi instructions (pointer to the start of the instruction)
653 * to the variable corresponding to it.
654 */
655 struct hash_table *phi_table;
656
657 unsigned num_specializations;
658 struct nir_spirv_specialization *specializations;
659
660 unsigned value_id_bound;
661 struct vtn_value *values;
662
663 /* True if we should watch out for GLSLang issue #179 */
664 bool wa_glslang_179;
665
666 /* True if we need to fix up CS OpControlBarrier */
667 bool wa_glslang_cs_barrier;
668
669 gl_shader_stage entry_point_stage;
670 const char *entry_point_name;
671 struct vtn_value *entry_point;
672 struct vtn_value *workgroup_size_builtin;
673 bool variable_pointers;
674
675 struct vtn_function *func;
676 struct list_head functions;
677
678 /* Current function parameter index */
679 unsigned func_param_idx;
680
681 bool has_loop_continue;
682
683 /* false by default, set to true by the ContractionOff execution mode */
684 bool exact;
685
686 /* when a physical memory model is choosen */
687 bool physical_ptrs;
688 };
689
690 nir_ssa_def *
691 vtn_pointer_to_ssa(struct vtn_builder *b, struct vtn_pointer *ptr);
692 struct vtn_pointer *
693 vtn_pointer_from_ssa(struct vtn_builder *b, nir_ssa_def *ssa,
694 struct vtn_type *ptr_type);
695
696 static inline struct vtn_value *
697 vtn_untyped_value(struct vtn_builder *b, uint32_t value_id)
698 {
699 vtn_fail_if(value_id >= b->value_id_bound,
700 "SPIR-V id %u is out-of-bounds", value_id);
701 return &b->values[value_id];
702 }
703
704 /* Consider not using this function directly and instead use
705 * vtn_push_ssa/vtn_push_value_pointer so that appropriate applying of
706 * decorations is handled by common code.
707 */
708 static inline struct vtn_value *
709 vtn_push_value(struct vtn_builder *b, uint32_t value_id,
710 enum vtn_value_type value_type)
711 {
712 struct vtn_value *val = vtn_untyped_value(b, value_id);
713
714 vtn_fail_if(val->value_type != vtn_value_type_invalid,
715 "SPIR-V id %u has already been written by another instruction",
716 value_id);
717
718 val->value_type = value_type;
719
720 return &b->values[value_id];
721 }
722
723 static inline struct vtn_value *
724 vtn_value(struct vtn_builder *b, uint32_t value_id,
725 enum vtn_value_type value_type)
726 {
727 struct vtn_value *val = vtn_untyped_value(b, value_id);
728 vtn_fail_if(val->value_type != value_type,
729 "SPIR-V id %u is the wrong kind of value", value_id);
730 return val;
731 }
732
733 bool
734 vtn_set_instruction_result_type(struct vtn_builder *b, SpvOp opcode,
735 const uint32_t *w, unsigned count);
736
737 static inline uint64_t
738 vtn_constant_uint(struct vtn_builder *b, uint32_t value_id)
739 {
740 struct vtn_value *val = vtn_value(b, value_id, vtn_value_type_constant);
741
742 vtn_fail_if(val->type->base_type != vtn_base_type_scalar ||
743 !glsl_type_is_integer(val->type->type),
744 "Expected id %u to be an integer constant", value_id);
745
746 switch (glsl_get_bit_size(val->type->type)) {
747 case 8: return val->constant->values[0].u8;
748 case 16: return val->constant->values[0].u16;
749 case 32: return val->constant->values[0].u32;
750 case 64: return val->constant->values[0].u64;
751 default: unreachable("Invalid bit size");
752 }
753 }
754
755 static inline int64_t
756 vtn_constant_int(struct vtn_builder *b, uint32_t value_id)
757 {
758 struct vtn_value *val = vtn_value(b, value_id, vtn_value_type_constant);
759
760 vtn_fail_if(val->type->base_type != vtn_base_type_scalar ||
761 !glsl_type_is_integer(val->type->type),
762 "Expected id %u to be an integer constant", value_id);
763
764 switch (glsl_get_bit_size(val->type->type)) {
765 case 8: return val->constant->values[0].i8;
766 case 16: return val->constant->values[0].i16;
767 case 32: return val->constant->values[0].i32;
768 case 64: return val->constant->values[0].i64;
769 default: unreachable("Invalid bit size");
770 }
771 }
772
773 static inline enum gl_access_qualifier vtn_value_access(struct vtn_value *value)
774 {
775 switch (value->value_type) {
776 case vtn_value_type_invalid:
777 case vtn_value_type_undef:
778 case vtn_value_type_string:
779 case vtn_value_type_decoration_group:
780 case vtn_value_type_constant:
781 case vtn_value_type_function:
782 case vtn_value_type_block:
783 case vtn_value_type_extension:
784 return 0;
785 case vtn_value_type_type:
786 return value->type->access;
787 case vtn_value_type_pointer:
788 return value->pointer->access;
789 case vtn_value_type_ssa:
790 return value->ssa->access;
791 case vtn_value_type_image_pointer:
792 return value->image->image->access;
793 case vtn_value_type_sampled_image:
794 return value->sampled_image->image->access |
795 value->sampled_image->sampler->access;
796 }
797
798 unreachable("invalid type");
799 }
800
801 struct vtn_ssa_value *vtn_ssa_value(struct vtn_builder *b, uint32_t value_id);
802
803 struct vtn_value *vtn_push_value_pointer(struct vtn_builder *b,
804 uint32_t value_id,
805 struct vtn_pointer *ptr);
806
807 struct vtn_value *vtn_push_ssa(struct vtn_builder *b, uint32_t value_id,
808 struct vtn_type *type, struct vtn_ssa_value *ssa);
809
810 struct vtn_ssa_value *vtn_create_ssa_value(struct vtn_builder *b,
811 const struct glsl_type *type);
812
813 struct vtn_ssa_value *vtn_ssa_transpose(struct vtn_builder *b,
814 struct vtn_ssa_value *src);
815
816 nir_ssa_def *vtn_vector_extract(struct vtn_builder *b, nir_ssa_def *src,
817 unsigned index);
818 nir_ssa_def *vtn_vector_extract_dynamic(struct vtn_builder *b, nir_ssa_def *src,
819 nir_ssa_def *index);
820 nir_ssa_def *vtn_vector_insert(struct vtn_builder *b, nir_ssa_def *src,
821 nir_ssa_def *insert, unsigned index);
822 nir_ssa_def *vtn_vector_insert_dynamic(struct vtn_builder *b, nir_ssa_def *src,
823 nir_ssa_def *insert, nir_ssa_def *index);
824
825 nir_deref_instr *vtn_nir_deref(struct vtn_builder *b, uint32_t id);
826
827 struct vtn_pointer *vtn_pointer_for_variable(struct vtn_builder *b,
828 struct vtn_variable *var,
829 struct vtn_type *ptr_type);
830
831 nir_deref_instr *vtn_pointer_to_deref(struct vtn_builder *b,
832 struct vtn_pointer *ptr);
833 nir_ssa_def *
834 vtn_pointer_to_offset(struct vtn_builder *b, struct vtn_pointer *ptr,
835 nir_ssa_def **index_out);
836
837 struct vtn_ssa_value *
838 vtn_local_load(struct vtn_builder *b, nir_deref_instr *src,
839 enum gl_access_qualifier access);
840
841 void vtn_local_store(struct vtn_builder *b, struct vtn_ssa_value *src,
842 nir_deref_instr *dest,
843 enum gl_access_qualifier access);
844
845 struct vtn_ssa_value *
846 vtn_variable_load(struct vtn_builder *b, struct vtn_pointer *src);
847
848 void vtn_variable_store(struct vtn_builder *b, struct vtn_ssa_value *src,
849 struct vtn_pointer *dest);
850
851 void vtn_handle_variables(struct vtn_builder *b, SpvOp opcode,
852 const uint32_t *w, unsigned count);
853
854
855 typedef void (*vtn_decoration_foreach_cb)(struct vtn_builder *,
856 struct vtn_value *,
857 int member,
858 const struct vtn_decoration *,
859 void *);
860
861 void vtn_foreach_decoration(struct vtn_builder *b, struct vtn_value *value,
862 vtn_decoration_foreach_cb cb, void *data);
863
864 typedef void (*vtn_execution_mode_foreach_cb)(struct vtn_builder *,
865 struct vtn_value *,
866 const struct vtn_decoration *,
867 void *);
868
869 void vtn_foreach_execution_mode(struct vtn_builder *b, struct vtn_value *value,
870 vtn_execution_mode_foreach_cb cb, void *data);
871
872 nir_op vtn_nir_alu_op_for_spirv_opcode(struct vtn_builder *b,
873 SpvOp opcode, bool *swap,
874 unsigned src_bit_size, unsigned dst_bit_size);
875
876 void vtn_handle_alu(struct vtn_builder *b, SpvOp opcode,
877 const uint32_t *w, unsigned count);
878
879 void vtn_handle_bitcast(struct vtn_builder *b, const uint32_t *w,
880 unsigned count);
881
882 void vtn_handle_subgroup(struct vtn_builder *b, SpvOp opcode,
883 const uint32_t *w, unsigned count);
884
885 bool vtn_handle_glsl450_instruction(struct vtn_builder *b, SpvOp ext_opcode,
886 const uint32_t *words, unsigned count);
887
888 bool vtn_handle_opencl_instruction(struct vtn_builder *b, SpvOp ext_opcode,
889 const uint32_t *words, unsigned count);
890
891 struct vtn_builder* vtn_create_builder(const uint32_t *words, size_t word_count,
892 gl_shader_stage stage, const char *entry_point_name,
893 const struct spirv_to_nir_options *options);
894
895 void vtn_handle_entry_point(struct vtn_builder *b, const uint32_t *w,
896 unsigned count);
897
898 void vtn_handle_decoration(struct vtn_builder *b, SpvOp opcode,
899 const uint32_t *w, unsigned count);
900
901 enum vtn_variable_mode vtn_storage_class_to_mode(struct vtn_builder *b,
902 SpvStorageClass class,
903 struct vtn_type *interface_type,
904 nir_variable_mode *nir_mode_out);
905
906 nir_address_format vtn_mode_to_address_format(struct vtn_builder *b,
907 enum vtn_variable_mode);
908
909 static inline uint32_t
910 vtn_align_u32(uint32_t v, uint32_t a)
911 {
912 assert(a != 0 && a == (a & -((int32_t) a)));
913 return (v + a - 1) & ~(a - 1);
914 }
915
916 static inline uint64_t
917 vtn_u64_literal(const uint32_t *w)
918 {
919 return (uint64_t)w[1] << 32 | w[0];
920 }
921
922 bool vtn_handle_amd_gcn_shader_instruction(struct vtn_builder *b, SpvOp ext_opcode,
923 const uint32_t *words, unsigned count);
924
925 bool vtn_handle_amd_shader_ballot_instruction(struct vtn_builder *b, SpvOp ext_opcode,
926 const uint32_t *w, unsigned count);
927
928 bool vtn_handle_amd_shader_trinary_minmax_instruction(struct vtn_builder *b, SpvOp ext_opcode,
929 const uint32_t *words, unsigned count);
930
931 bool vtn_handle_amd_shader_explicit_vertex_parameter_instruction(struct vtn_builder *b,
932 SpvOp ext_opcode,
933 const uint32_t *words,
934 unsigned count);
935
936 SpvMemorySemanticsMask vtn_storage_class_to_memory_semantics(SpvStorageClass sc);
937
938 void vtn_emit_memory_barrier(struct vtn_builder *b, SpvScope scope,
939 SpvMemorySemanticsMask semantics);
940
941 #endif /* _VTN_PRIVATE_H_ */