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