2 * Copyright 2018 Collabora Ltd.
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 * on the rights to use, copy, modify, merge, publish, distribute, sub
8 * license, and/or sell copies of the Software, and to permit persons to whom
9 * the Software is furnished to do so, subject to the following conditions:
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
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 NON-INFRINGEMENT. IN NO EVENT SHALL
18 * THE AUTHOR(S) AND/OR THEIR SUPPLIERS BE LIABLE FOR ANY CLAIM,
19 * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
20 * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
21 * USE OR OTHER DEALINGS IN THE SOFTWARE.
24 #include "nir_to_spirv.h"
25 #include "spirv_builder.h"
28 #include "pipe/p_state.h"
29 #include "util/u_memory.h"
30 #include "util/hash_table.h"
33 struct spirv_builder builder
;
37 gl_shader_stage stage
;
41 SpvId samplers
[PIPE_MAX_SAMPLERS
];
43 SpvId entry_ifaces
[PIPE_MAX_SHADER_INPUTS
* 4 + PIPE_MAX_SHADER_OUTPUTS
* 4];
44 size_t num_entry_ifaces
;
52 struct hash_table
*vars
; /* nir_variable -> SpvId */
54 const SpvId
*block_ids
;
57 SpvId loop_break
, loop_cont
;
59 SpvId front_face_var
, vertex_id_var
;
63 get_fvec_constant(struct ntv_context
*ctx
, unsigned bit_size
,
64 unsigned num_components
, float value
);
67 get_uvec_constant(struct ntv_context
*ctx
, unsigned bit_size
,
68 unsigned num_components
, uint32_t value
);
71 get_ivec_constant(struct ntv_context
*ctx
, unsigned bit_size
,
72 unsigned num_components
, int32_t value
);
75 emit_unop(struct ntv_context
*ctx
, SpvOp op
, SpvId type
, SpvId src
);
78 emit_binop(struct ntv_context
*ctx
, SpvOp op
, SpvId type
,
79 SpvId src0
, SpvId src1
);
82 emit_triop(struct ntv_context
*ctx
, SpvOp op
, SpvId type
,
83 SpvId src0
, SpvId src1
, SpvId src2
);
86 get_bvec_type(struct ntv_context
*ctx
, int num_components
)
88 SpvId bool_type
= spirv_builder_type_bool(&ctx
->builder
);
89 if (num_components
> 1)
90 return spirv_builder_type_vector(&ctx
->builder
, bool_type
,
93 assert(num_components
== 1);
98 block_label(struct ntv_context
*ctx
, nir_block
*block
)
100 assert(block
->index
< ctx
->num_blocks
);
101 return ctx
->block_ids
[block
->index
];
105 emit_float_const(struct ntv_context
*ctx
, int bit_size
, float value
)
107 assert(bit_size
== 32);
108 return spirv_builder_const_float(&ctx
->builder
, bit_size
, value
);
112 emit_uint_const(struct ntv_context
*ctx
, int bit_size
, uint32_t value
)
114 assert(bit_size
== 32);
115 return spirv_builder_const_uint(&ctx
->builder
, bit_size
, value
);
119 emit_int_const(struct ntv_context
*ctx
, int bit_size
, int32_t value
)
121 assert(bit_size
== 32);
122 return spirv_builder_const_int(&ctx
->builder
, bit_size
, value
);
126 get_fvec_type(struct ntv_context
*ctx
, unsigned bit_size
, unsigned num_components
)
128 assert(bit_size
== 32); // only 32-bit floats supported so far
130 SpvId float_type
= spirv_builder_type_float(&ctx
->builder
, bit_size
);
131 if (num_components
> 1)
132 return spirv_builder_type_vector(&ctx
->builder
, float_type
,
135 assert(num_components
== 1);
140 get_ivec_type(struct ntv_context
*ctx
, unsigned bit_size
, unsigned num_components
)
142 assert(bit_size
== 1 || bit_size
== 32); // only 32-bit ints supported so far
144 SpvId int_type
= spirv_builder_type_int(&ctx
->builder
, MAX2(bit_size
, 32));
145 if (num_components
> 1)
146 return spirv_builder_type_vector(&ctx
->builder
, int_type
,
149 assert(num_components
== 1);
154 get_uvec_type(struct ntv_context
*ctx
, unsigned bit_size
, unsigned num_components
)
156 assert(bit_size
== 1 || bit_size
== 32); // only 32-bit uints supported so far
158 SpvId uint_type
= spirv_builder_type_uint(&ctx
->builder
, MAX2(bit_size
, 32));
159 if (num_components
> 1)
160 return spirv_builder_type_vector(&ctx
->builder
, uint_type
,
163 assert(num_components
== 1);
168 get_dest_uvec_type(struct ntv_context
*ctx
, nir_dest
*dest
)
170 return get_uvec_type(ctx
, nir_dest_bit_size(*dest
),
171 nir_dest_num_components(*dest
));
175 get_glsl_basetype(struct ntv_context
*ctx
, enum glsl_base_type type
)
179 return spirv_builder_type_bool(&ctx
->builder
);
181 case GLSL_TYPE_FLOAT
:
182 return spirv_builder_type_float(&ctx
->builder
, 32);
185 return spirv_builder_type_int(&ctx
->builder
, 32);
188 return spirv_builder_type_uint(&ctx
->builder
, 32);
189 /* TODO: handle more types */
192 unreachable("unknown GLSL type");
197 get_glsl_type(struct ntv_context
*ctx
, const struct glsl_type
*type
)
200 if (glsl_type_is_scalar(type
))
201 return get_glsl_basetype(ctx
, glsl_get_base_type(type
));
203 if (glsl_type_is_vector(type
))
204 return spirv_builder_type_vector(&ctx
->builder
,
205 get_glsl_basetype(ctx
, glsl_get_base_type(type
)),
206 glsl_get_vector_elements(type
));
208 if (glsl_type_is_array(type
)) {
209 SpvId ret
= spirv_builder_type_array(&ctx
->builder
,
210 get_glsl_type(ctx
, glsl_get_array_element(type
)),
211 emit_uint_const(ctx
, 32, glsl_get_length(type
)));
212 uint32_t stride
= glsl_get_explicit_stride(type
);
214 spirv_builder_emit_array_stride(&ctx
->builder
, ret
, stride
);
219 unreachable("we shouldn't get here, I think...");
223 emit_input(struct ntv_context
*ctx
, struct nir_variable
*var
)
225 SpvId var_type
= get_glsl_type(ctx
, var
->type
);
226 SpvId pointer_type
= spirv_builder_type_pointer(&ctx
->builder
,
227 SpvStorageClassInput
,
229 SpvId var_id
= spirv_builder_emit_var(&ctx
->builder
, pointer_type
,
230 SpvStorageClassInput
);
233 spirv_builder_emit_name(&ctx
->builder
, var_id
, var
->name
);
235 if (ctx
->stage
== MESA_SHADER_FRAGMENT
) {
236 if (var
->data
.location
>= VARYING_SLOT_VAR0
)
237 spirv_builder_emit_location(&ctx
->builder
, var_id
,
241 else if ((var
->data
.location
>= VARYING_SLOT_COL0
&&
242 var
->data
.location
<= VARYING_SLOT_TEX7
) ||
243 var
->data
.location
== VARYING_SLOT_BFC0
||
244 var
->data
.location
== VARYING_SLOT_BFC1
) {
245 spirv_builder_emit_location(&ctx
->builder
, var_id
,
248 switch (var
->data
.location
) {
249 case VARYING_SLOT_POS
:
250 spirv_builder_emit_builtin(&ctx
->builder
, var_id
, SpvBuiltInFragCoord
);
253 case VARYING_SLOT_PNTC
:
254 spirv_builder_emit_builtin(&ctx
->builder
, var_id
, SpvBuiltInPointCoord
);
258 debug_printf("unknown varying slot: %s\n", gl_varying_slot_name(var
->data
.location
));
259 unreachable("unexpected varying slot");
263 spirv_builder_emit_location(&ctx
->builder
, var_id
,
264 var
->data
.driver_location
);
267 if (var
->data
.location_frac
)
268 spirv_builder_emit_component(&ctx
->builder
, var_id
,
269 var
->data
.location_frac
);
271 if (var
->data
.interpolation
== INTERP_MODE_FLAT
)
272 spirv_builder_emit_decoration(&ctx
->builder
, var_id
, SpvDecorationFlat
);
274 _mesa_hash_table_insert(ctx
->vars
, var
, (void *)(intptr_t)var_id
);
276 assert(ctx
->num_entry_ifaces
< ARRAY_SIZE(ctx
->entry_ifaces
));
277 ctx
->entry_ifaces
[ctx
->num_entry_ifaces
++] = var_id
;
281 emit_output(struct ntv_context
*ctx
, struct nir_variable
*var
)
283 SpvId var_type
= get_glsl_type(ctx
, var
->type
);
284 SpvId pointer_type
= spirv_builder_type_pointer(&ctx
->builder
,
285 SpvStorageClassOutput
,
287 SpvId var_id
= spirv_builder_emit_var(&ctx
->builder
, pointer_type
,
288 SpvStorageClassOutput
);
290 spirv_builder_emit_name(&ctx
->builder
, var_id
, var
->name
);
293 if (ctx
->stage
== MESA_SHADER_VERTEX
) {
294 if (var
->data
.location
>= VARYING_SLOT_VAR0
)
295 spirv_builder_emit_location(&ctx
->builder
, var_id
,
299 else if ((var
->data
.location
>= VARYING_SLOT_COL0
&&
300 var
->data
.location
<= VARYING_SLOT_TEX7
) ||
301 var
->data
.location
== VARYING_SLOT_BFC0
||
302 var
->data
.location
== VARYING_SLOT_BFC1
) {
303 spirv_builder_emit_location(&ctx
->builder
, var_id
,
306 switch (var
->data
.location
) {
307 case VARYING_SLOT_POS
:
308 spirv_builder_emit_builtin(&ctx
->builder
, var_id
, SpvBuiltInPosition
);
311 case VARYING_SLOT_PSIZ
:
312 spirv_builder_emit_builtin(&ctx
->builder
, var_id
, SpvBuiltInPointSize
);
315 case VARYING_SLOT_CLIP_DIST0
:
316 assert(glsl_type_is_array(var
->type
));
317 spirv_builder_emit_builtin(&ctx
->builder
, var_id
, SpvBuiltInClipDistance
);
321 debug_printf("unknown varying slot: %s\n", gl_varying_slot_name(var
->data
.location
));
322 unreachable("unexpected varying slot");
325 } else if (ctx
->stage
== MESA_SHADER_FRAGMENT
) {
326 if (var
->data
.location
>= FRAG_RESULT_DATA0
)
327 spirv_builder_emit_location(&ctx
->builder
, var_id
,
328 var
->data
.location
- FRAG_RESULT_DATA0
);
330 switch (var
->data
.location
) {
331 case FRAG_RESULT_COLOR
:
332 spirv_builder_emit_location(&ctx
->builder
, var_id
, 0);
335 case FRAG_RESULT_DEPTH
:
336 spirv_builder_emit_builtin(&ctx
->builder
, var_id
, SpvBuiltInFragDepth
);
340 spirv_builder_emit_location(&ctx
->builder
, var_id
,
341 var
->data
.driver_location
);
346 if (var
->data
.location_frac
)
347 spirv_builder_emit_component(&ctx
->builder
, var_id
,
348 var
->data
.location_frac
);
350 _mesa_hash_table_insert(ctx
->vars
, var
, (void *)(intptr_t)var_id
);
352 assert(ctx
->num_entry_ifaces
< ARRAY_SIZE(ctx
->entry_ifaces
));
353 ctx
->entry_ifaces
[ctx
->num_entry_ifaces
++] = var_id
;
357 type_to_dim(enum glsl_sampler_dim gdim
, bool *is_ms
)
361 case GLSL_SAMPLER_DIM_1D
:
363 case GLSL_SAMPLER_DIM_2D
:
365 case GLSL_SAMPLER_DIM_3D
:
367 case GLSL_SAMPLER_DIM_CUBE
:
369 case GLSL_SAMPLER_DIM_RECT
:
371 case GLSL_SAMPLER_DIM_BUF
:
373 case GLSL_SAMPLER_DIM_EXTERNAL
:
374 return SpvDim2D
; /* seems dodgy... */
375 case GLSL_SAMPLER_DIM_MS
:
379 fprintf(stderr
, "unknown sampler type %d\n", gdim
);
386 emit_sampler(struct ntv_context
*ctx
, struct nir_variable
*var
)
389 SpvDim dimension
= type_to_dim(glsl_get_sampler_dim(var
->type
), &is_ms
);
390 SpvId float_type
= spirv_builder_type_float(&ctx
->builder
, 32);
391 SpvId image_type
= spirv_builder_type_image(&ctx
->builder
, float_type
,
392 dimension
, false, glsl_sampler_type_is_array(var
->type
), is_ms
, 1,
393 SpvImageFormatUnknown
);
395 SpvId sampled_type
= spirv_builder_type_sampled_image(&ctx
->builder
,
397 SpvId pointer_type
= spirv_builder_type_pointer(&ctx
->builder
,
398 SpvStorageClassUniformConstant
,
400 SpvId var_id
= spirv_builder_emit_var(&ctx
->builder
, pointer_type
,
401 SpvStorageClassUniformConstant
);
404 spirv_builder_emit_name(&ctx
->builder
, var_id
, var
->name
);
406 assert(ctx
->num_samplers
< ARRAY_SIZE(ctx
->samplers
));
407 ctx
->samplers
[ctx
->num_samplers
++] = var_id
;
409 spirv_builder_emit_descriptor_set(&ctx
->builder
, var_id
,
410 var
->data
.descriptor_set
);
411 spirv_builder_emit_binding(&ctx
->builder
, var_id
, var
->data
.binding
);
415 emit_ubo(struct ntv_context
*ctx
, struct nir_variable
*var
)
417 uint32_t size
= glsl_count_attribute_slots(var
->type
, false);
418 SpvId vec4_type
= get_uvec_type(ctx
, 32, 4);
419 SpvId array_length
= emit_uint_const(ctx
, 32, size
);
420 SpvId array_type
= spirv_builder_type_array(&ctx
->builder
, vec4_type
,
422 spirv_builder_emit_array_stride(&ctx
->builder
, array_type
, 16);
424 // wrap UBO-array in a struct
425 SpvId struct_type
= spirv_builder_type_struct(&ctx
->builder
, &array_type
, 1);
427 char struct_name
[100];
428 snprintf(struct_name
, sizeof(struct_name
), "struct_%s", var
->name
);
429 spirv_builder_emit_name(&ctx
->builder
, struct_type
, struct_name
);
432 spirv_builder_emit_decoration(&ctx
->builder
, struct_type
,
434 spirv_builder_emit_member_offset(&ctx
->builder
, struct_type
, 0, 0);
437 SpvId pointer_type
= spirv_builder_type_pointer(&ctx
->builder
,
438 SpvStorageClassUniform
,
441 SpvId var_id
= spirv_builder_emit_var(&ctx
->builder
, pointer_type
,
442 SpvStorageClassUniform
);
444 spirv_builder_emit_name(&ctx
->builder
, var_id
, var
->name
);
446 assert(ctx
->num_ubos
< ARRAY_SIZE(ctx
->ubos
));
447 ctx
->ubos
[ctx
->num_ubos
++] = var_id
;
449 spirv_builder_emit_descriptor_set(&ctx
->builder
, var_id
,
450 var
->data
.descriptor_set
);
451 spirv_builder_emit_binding(&ctx
->builder
, var_id
, var
->data
.binding
);
455 emit_uniform(struct ntv_context
*ctx
, struct nir_variable
*var
)
457 if (var
->data
.mode
== nir_var_mem_ubo
)
460 assert(var
->data
.mode
== nir_var_uniform
);
461 if (glsl_type_is_sampler(var
->type
))
462 emit_sampler(ctx
, var
);
467 get_src_uint_ssa(struct ntv_context
*ctx
, const nir_ssa_def
*ssa
)
469 assert(ssa
->index
< ctx
->num_defs
);
470 assert(ctx
->defs
[ssa
->index
] != 0);
471 return ctx
->defs
[ssa
->index
];
475 get_var_from_reg(struct ntv_context
*ctx
, nir_register
*reg
)
477 assert(reg
->index
< ctx
->num_regs
);
478 assert(ctx
->regs
[reg
->index
] != 0);
479 return ctx
->regs
[reg
->index
];
483 get_src_uint_reg(struct ntv_context
*ctx
, const nir_reg_src
*reg
)
486 assert(!reg
->indirect
);
487 assert(!reg
->base_offset
);
489 SpvId var
= get_var_from_reg(ctx
, reg
->reg
);
490 SpvId type
= get_uvec_type(ctx
, reg
->reg
->bit_size
, reg
->reg
->num_components
);
491 return spirv_builder_emit_load(&ctx
->builder
, type
, var
);
495 get_src_uint(struct ntv_context
*ctx
, nir_src
*src
)
498 return get_src_uint_ssa(ctx
, src
->ssa
);
500 return get_src_uint_reg(ctx
, &src
->reg
);
504 get_alu_src_uint(struct ntv_context
*ctx
, nir_alu_instr
*alu
, unsigned src
)
506 assert(!alu
->src
[src
].negate
);
507 assert(!alu
->src
[src
].abs
);
509 SpvId def
= get_src_uint(ctx
, &alu
->src
[src
].src
);
511 unsigned used_channels
= 0;
512 bool need_swizzle
= false;
513 for (unsigned i
= 0; i
< NIR_MAX_VEC_COMPONENTS
; i
++) {
514 if (!nir_alu_instr_channel_used(alu
, src
, i
))
519 if (alu
->src
[src
].swizzle
[i
] != i
)
522 assert(used_channels
!= 0);
524 unsigned live_channels
= nir_src_num_components(alu
->src
[src
].src
);
525 if (used_channels
!= live_channels
)
531 int bit_size
= nir_src_bit_size(alu
->src
[src
].src
);
532 assert(bit_size
== 1 || bit_size
== 32);
534 SpvId uint_type
= spirv_builder_type_uint(&ctx
->builder
, MAX2(bit_size
, 32));
535 if (used_channels
== 1) {
536 uint32_t indices
[] = { alu
->src
[src
].swizzle
[0] };
537 return spirv_builder_emit_composite_extract(&ctx
->builder
, uint_type
,
539 ARRAY_SIZE(indices
));
540 } else if (live_channels
== 1) {
541 SpvId uvec_type
= spirv_builder_type_vector(&ctx
->builder
, uint_type
,
544 SpvId constituents
[NIR_MAX_VEC_COMPONENTS
];
545 for (unsigned i
= 0; i
< used_channels
; ++i
)
546 constituents
[i
] = def
;
548 return spirv_builder_emit_composite_construct(&ctx
->builder
, uvec_type
,
552 SpvId uvec_type
= spirv_builder_type_vector(&ctx
->builder
, uint_type
,
555 uint32_t components
[NIR_MAX_VEC_COMPONENTS
];
556 size_t num_components
= 0;
557 for (unsigned i
= 0; i
< NIR_MAX_VEC_COMPONENTS
; i
++) {
558 if (!nir_alu_instr_channel_used(alu
, src
, i
))
561 components
[num_components
++] = alu
->src
[src
].swizzle
[i
];
564 return spirv_builder_emit_vector_shuffle(&ctx
->builder
, uvec_type
,
565 def
, def
, components
, num_components
);
570 store_ssa_def_uint(struct ntv_context
*ctx
, nir_ssa_def
*ssa
, SpvId result
)
573 assert(ssa
->index
< ctx
->num_defs
);
574 ctx
->defs
[ssa
->index
] = result
;
578 emit_select(struct ntv_context
*ctx
, SpvId type
, SpvId cond
,
579 SpvId if_true
, SpvId if_false
)
581 return emit_triop(ctx
, SpvOpSelect
, type
, cond
, if_true
, if_false
);
585 bvec_to_uvec(struct ntv_context
*ctx
, SpvId value
, unsigned num_components
)
587 SpvId otype
= get_uvec_type(ctx
, 32, num_components
);
588 SpvId zero
= get_uvec_constant(ctx
, 32, num_components
, 0);
589 SpvId one
= get_uvec_constant(ctx
, 32, num_components
, UINT32_MAX
);
590 return emit_select(ctx
, otype
, value
, one
, zero
);
594 uvec_to_bvec(struct ntv_context
*ctx
, SpvId value
, unsigned num_components
)
596 SpvId type
= get_bvec_type(ctx
, num_components
);
597 SpvId zero
= get_uvec_constant(ctx
, 32, num_components
, 0);
598 return emit_binop(ctx
, SpvOpINotEqual
, type
, value
, zero
);
602 emit_bitcast(struct ntv_context
*ctx
, SpvId type
, SpvId value
)
604 return emit_unop(ctx
, SpvOpBitcast
, type
, value
);
608 bitcast_to_uvec(struct ntv_context
*ctx
, SpvId value
, unsigned bit_size
,
609 unsigned num_components
)
611 SpvId type
= get_uvec_type(ctx
, bit_size
, num_components
);
612 return emit_bitcast(ctx
, type
, value
);
616 bitcast_to_ivec(struct ntv_context
*ctx
, SpvId value
, unsigned bit_size
,
617 unsigned num_components
)
619 SpvId type
= get_ivec_type(ctx
, bit_size
, num_components
);
620 return emit_bitcast(ctx
, type
, value
);
624 bitcast_to_fvec(struct ntv_context
*ctx
, SpvId value
, unsigned bit_size
,
625 unsigned num_components
)
627 SpvId type
= get_fvec_type(ctx
, bit_size
, num_components
);
628 return emit_bitcast(ctx
, type
, value
);
632 store_reg_def(struct ntv_context
*ctx
, nir_reg_dest
*reg
, SpvId result
)
634 SpvId var
= get_var_from_reg(ctx
, reg
->reg
);
636 spirv_builder_emit_store(&ctx
->builder
, var
, result
);
640 store_dest_uint(struct ntv_context
*ctx
, nir_dest
*dest
, SpvId result
)
643 store_ssa_def_uint(ctx
, &dest
->ssa
, result
);
645 store_reg_def(ctx
, &dest
->reg
, result
);
649 store_dest(struct ntv_context
*ctx
, nir_dest
*dest
, SpvId result
, nir_alu_type type
)
651 unsigned num_components
= nir_dest_num_components(*dest
);
652 unsigned bit_size
= nir_dest_bit_size(*dest
);
654 switch (nir_alu_type_get_base_type(type
)) {
656 assert(bit_size
== 1);
657 result
= bvec_to_uvec(ctx
, result
, num_components
);
661 break; /* nothing to do! */
665 result
= bitcast_to_uvec(ctx
, result
, bit_size
, num_components
);
669 unreachable("unsupported nir_alu_type");
672 store_dest_uint(ctx
, dest
, result
);
676 emit_unop(struct ntv_context
*ctx
, SpvOp op
, SpvId type
, SpvId src
)
678 return spirv_builder_emit_unop(&ctx
->builder
, op
, type
, src
);
682 emit_binop(struct ntv_context
*ctx
, SpvOp op
, SpvId type
,
683 SpvId src0
, SpvId src1
)
685 return spirv_builder_emit_binop(&ctx
->builder
, op
, type
, src0
, src1
);
689 emit_triop(struct ntv_context
*ctx
, SpvOp op
, SpvId type
,
690 SpvId src0
, SpvId src1
, SpvId src2
)
692 return spirv_builder_emit_triop(&ctx
->builder
, op
, type
, src0
, src1
, src2
);
696 emit_builtin_unop(struct ntv_context
*ctx
, enum GLSLstd450 op
, SpvId type
,
699 SpvId args
[] = { src
};
700 return spirv_builder_emit_ext_inst(&ctx
->builder
, type
, ctx
->GLSL_std_450
,
701 op
, args
, ARRAY_SIZE(args
));
705 emit_builtin_binop(struct ntv_context
*ctx
, enum GLSLstd450 op
, SpvId type
,
706 SpvId src0
, SpvId src1
)
708 SpvId args
[] = { src0
, src1
};
709 return spirv_builder_emit_ext_inst(&ctx
->builder
, type
, ctx
->GLSL_std_450
,
710 op
, args
, ARRAY_SIZE(args
));
714 emit_builtin_triop(struct ntv_context
*ctx
, enum GLSLstd450 op
, SpvId type
,
715 SpvId src0
, SpvId src1
, SpvId src2
)
717 SpvId args
[] = { src0
, src1
, src2
};
718 return spirv_builder_emit_ext_inst(&ctx
->builder
, type
, ctx
->GLSL_std_450
,
719 op
, args
, ARRAY_SIZE(args
));
723 get_fvec_constant(struct ntv_context
*ctx
, unsigned bit_size
,
724 unsigned num_components
, float value
)
726 assert(bit_size
== 32);
728 SpvId result
= emit_float_const(ctx
, bit_size
, value
);
729 if (num_components
== 1)
732 assert(num_components
> 1);
733 SpvId components
[num_components
];
734 for (int i
= 0; i
< num_components
; i
++)
735 components
[i
] = result
;
737 SpvId type
= get_fvec_type(ctx
, bit_size
, num_components
);
738 return spirv_builder_const_composite(&ctx
->builder
, type
, components
,
743 get_uvec_constant(struct ntv_context
*ctx
, unsigned bit_size
,
744 unsigned num_components
, uint32_t value
)
746 assert(bit_size
== 32);
748 SpvId result
= emit_uint_const(ctx
, bit_size
, value
);
749 if (num_components
== 1)
752 assert(num_components
> 1);
753 SpvId components
[num_components
];
754 for (int i
= 0; i
< num_components
; i
++)
755 components
[i
] = result
;
757 SpvId type
= get_uvec_type(ctx
, bit_size
, num_components
);
758 return spirv_builder_const_composite(&ctx
->builder
, type
, components
,
763 get_ivec_constant(struct ntv_context
*ctx
, unsigned bit_size
,
764 unsigned num_components
, int32_t value
)
766 assert(bit_size
== 32);
768 SpvId result
= emit_int_const(ctx
, bit_size
, value
);
769 if (num_components
== 1)
772 assert(num_components
> 1);
773 SpvId components
[num_components
];
774 for (int i
= 0; i
< num_components
; i
++)
775 components
[i
] = result
;
777 SpvId type
= get_ivec_type(ctx
, bit_size
, num_components
);
778 return spirv_builder_const_composite(&ctx
->builder
, type
, components
,
782 static inline unsigned
783 alu_instr_src_components(const nir_alu_instr
*instr
, unsigned src
)
785 if (nir_op_infos
[instr
->op
].input_sizes
[src
] > 0)
786 return nir_op_infos
[instr
->op
].input_sizes
[src
];
788 if (instr
->dest
.dest
.is_ssa
)
789 return instr
->dest
.dest
.ssa
.num_components
;
791 return instr
->dest
.dest
.reg
.reg
->num_components
;
795 get_alu_src(struct ntv_context
*ctx
, nir_alu_instr
*alu
, unsigned src
)
797 SpvId uint_value
= get_alu_src_uint(ctx
, alu
, src
);
799 unsigned num_components
= alu_instr_src_components(alu
, src
);
800 unsigned bit_size
= nir_src_bit_size(alu
->src
[src
].src
);
801 nir_alu_type type
= nir_op_infos
[alu
->op
].input_types
[src
];
803 switch (nir_alu_type_get_base_type(type
)) {
805 assert(bit_size
== 1);
806 return uvec_to_bvec(ctx
, uint_value
, num_components
);
809 return bitcast_to_ivec(ctx
, uint_value
, bit_size
, num_components
);
815 return bitcast_to_fvec(ctx
, uint_value
, bit_size
, num_components
);
818 unreachable("unknown nir_alu_type");
823 store_alu_result(struct ntv_context
*ctx
, nir_alu_instr
*alu
, SpvId result
)
825 assert(!alu
->dest
.saturate
);
826 return store_dest(ctx
, &alu
->dest
.dest
, result
, nir_op_infos
[alu
->op
].output_type
);
830 get_dest_type(struct ntv_context
*ctx
, nir_dest
*dest
, nir_alu_type type
)
832 unsigned num_components
= nir_dest_num_components(*dest
);
833 unsigned bit_size
= nir_dest_bit_size(*dest
);
835 switch (nir_alu_type_get_base_type(type
)) {
837 return get_bvec_type(ctx
, num_components
);
840 return get_ivec_type(ctx
, bit_size
, num_components
);
843 return get_uvec_type(ctx
, bit_size
, num_components
);
846 return get_fvec_type(ctx
, bit_size
, num_components
);
849 unreachable("unsupported nir_alu_type");
854 emit_alu(struct ntv_context
*ctx
, nir_alu_instr
*alu
)
856 SpvId src
[nir_op_infos
[alu
->op
].num_inputs
];
857 for (unsigned i
= 0; i
< nir_op_infos
[alu
->op
].num_inputs
; i
++)
858 src
[i
] = get_alu_src(ctx
, alu
, i
);
860 SpvId dest_type
= get_dest_type(ctx
, &alu
->dest
.dest
,
861 nir_op_infos
[alu
->op
].output_type
);
862 unsigned bit_size
= nir_dest_bit_size(alu
->dest
.dest
);
863 unsigned num_components
= nir_dest_num_components(alu
->dest
.dest
);
868 assert(nir_op_infos
[alu
->op
].num_inputs
== 1);
872 #define UNOP(nir_op, spirv_op) \
874 assert(nir_op_infos[alu->op].num_inputs == 1); \
875 result = emit_unop(ctx, spirv_op, dest_type, src[0]); \
878 UNOP(nir_op_ineg
, SpvOpSNegate
)
879 UNOP(nir_op_fneg
, SpvOpFNegate
)
880 UNOP(nir_op_fddx
, SpvOpDPdx
)
881 UNOP(nir_op_fddy
, SpvOpDPdy
)
882 UNOP(nir_op_f2i32
, SpvOpConvertFToS
)
883 UNOP(nir_op_f2u32
, SpvOpConvertFToU
)
884 UNOP(nir_op_i2f32
, SpvOpConvertSToF
)
885 UNOP(nir_op_u2f32
, SpvOpConvertUToF
)
886 UNOP(nir_op_inot
, SpvOpNot
)
890 assert(nir_op_infos
[alu
->op
].num_inputs
== 1);
891 result
= emit_select(ctx
, dest_type
, src
[0],
892 get_ivec_constant(ctx
, 32, num_components
, 1),
893 get_ivec_constant(ctx
, 32, num_components
, 0));
897 assert(nir_op_infos
[alu
->op
].num_inputs
== 1);
898 result
= emit_select(ctx
, dest_type
, src
[0],
899 get_fvec_constant(ctx
, 32, num_components
, 1),
900 get_fvec_constant(ctx
, 32, num_components
, 0));
903 #define BUILTIN_UNOP(nir_op, spirv_op) \
905 assert(nir_op_infos[alu->op].num_inputs == 1); \
906 result = emit_builtin_unop(ctx, spirv_op, dest_type, src[0]); \
909 BUILTIN_UNOP(nir_op_iabs
, GLSLstd450SAbs
)
910 BUILTIN_UNOP(nir_op_fabs
, GLSLstd450FAbs
)
911 BUILTIN_UNOP(nir_op_fsqrt
, GLSLstd450Sqrt
)
912 BUILTIN_UNOP(nir_op_frsq
, GLSLstd450InverseSqrt
)
913 BUILTIN_UNOP(nir_op_flog2
, GLSLstd450Log2
)
914 BUILTIN_UNOP(nir_op_fexp2
, GLSLstd450Exp2
)
915 BUILTIN_UNOP(nir_op_ffract
, GLSLstd450Fract
)
916 BUILTIN_UNOP(nir_op_ffloor
, GLSLstd450Floor
)
917 BUILTIN_UNOP(nir_op_fceil
, GLSLstd450Ceil
)
918 BUILTIN_UNOP(nir_op_ftrunc
, GLSLstd450Trunc
)
919 BUILTIN_UNOP(nir_op_fround_even
, GLSLstd450RoundEven
)
920 BUILTIN_UNOP(nir_op_fsign
, GLSLstd450FSign
)
921 BUILTIN_UNOP(nir_op_fsin
, GLSLstd450Sin
)
922 BUILTIN_UNOP(nir_op_fcos
, GLSLstd450Cos
)
926 assert(nir_op_infos
[alu
->op
].num_inputs
== 1);
927 result
= emit_binop(ctx
, SpvOpFDiv
, dest_type
,
928 get_fvec_constant(ctx
, bit_size
, num_components
, 1),
933 assert(nir_op_infos
[alu
->op
].num_inputs
== 1);
934 result
= emit_binop(ctx
, SpvOpFOrdNotEqual
, dest_type
, src
[0],
935 get_fvec_constant(ctx
,
936 nir_src_bit_size(alu
->src
[0].src
),
941 #define BINOP(nir_op, spirv_op) \
943 assert(nir_op_infos[alu->op].num_inputs == 2); \
944 result = emit_binop(ctx, spirv_op, dest_type, src[0], src[1]); \
947 BINOP(nir_op_iadd
, SpvOpIAdd
)
948 BINOP(nir_op_isub
, SpvOpISub
)
949 BINOP(nir_op_imul
, SpvOpIMul
)
950 BINOP(nir_op_idiv
, SpvOpSDiv
)
951 BINOP(nir_op_udiv
, SpvOpUDiv
)
952 BINOP(nir_op_umod
, SpvOpUMod
)
953 BINOP(nir_op_fadd
, SpvOpFAdd
)
954 BINOP(nir_op_fsub
, SpvOpFSub
)
955 BINOP(nir_op_fmul
, SpvOpFMul
)
956 BINOP(nir_op_fdiv
, SpvOpFDiv
)
957 BINOP(nir_op_fmod
, SpvOpFMod
)
958 BINOP(nir_op_ilt
, SpvOpSLessThan
)
959 BINOP(nir_op_ige
, SpvOpSGreaterThanEqual
)
960 BINOP(nir_op_ieq
, SpvOpIEqual
)
961 BINOP(nir_op_ine
, SpvOpINotEqual
)
962 BINOP(nir_op_uge
, SpvOpUGreaterThanEqual
)
963 BINOP(nir_op_flt
, SpvOpFOrdLessThan
)
964 BINOP(nir_op_fge
, SpvOpFOrdGreaterThanEqual
)
965 BINOP(nir_op_feq
, SpvOpFOrdEqual
)
966 BINOP(nir_op_fne
, SpvOpFOrdNotEqual
)
967 BINOP(nir_op_ishl
, SpvOpShiftLeftLogical
)
968 BINOP(nir_op_ishr
, SpvOpShiftRightArithmetic
)
969 BINOP(nir_op_ushr
, SpvOpShiftRightLogical
)
970 BINOP(nir_op_iand
, SpvOpBitwiseAnd
)
971 BINOP(nir_op_ior
, SpvOpBitwiseOr
)
974 #define BUILTIN_BINOP(nir_op, spirv_op) \
976 assert(nir_op_infos[alu->op].num_inputs == 2); \
977 result = emit_builtin_binop(ctx, spirv_op, dest_type, src[0], src[1]); \
980 BUILTIN_BINOP(nir_op_fmin
, GLSLstd450FMin
)
981 BUILTIN_BINOP(nir_op_fmax
, GLSLstd450FMax
)
987 assert(nir_op_infos
[alu
->op
].num_inputs
== 2);
988 result
= emit_binop(ctx
, SpvOpDot
, dest_type
, src
[0], src
[1]);
995 assert(nir_op_infos
[alu
->op
].num_inputs
== 2);
996 int num_components
= nir_dest_num_components(alu
->dest
.dest
);
997 SpvId bool_type
= get_bvec_type(ctx
, num_components
);
999 SpvId zero
= emit_float_const(ctx
, bit_size
, 0.0f
);
1000 SpvId one
= emit_float_const(ctx
, bit_size
, 1.0f
);
1001 if (num_components
> 1) {
1002 SpvId zero_comps
[num_components
], one_comps
[num_components
];
1003 for (int i
= 0; i
< num_components
; i
++) {
1004 zero_comps
[i
] = zero
;
1008 zero
= spirv_builder_const_composite(&ctx
->builder
, dest_type
,
1009 zero_comps
, num_components
);
1010 one
= spirv_builder_const_composite(&ctx
->builder
, dest_type
,
1011 one_comps
, num_components
);
1016 case nir_op_seq
: op
= SpvOpFOrdEqual
; break;
1017 case nir_op_sne
: op
= SpvOpFOrdNotEqual
; break;
1018 case nir_op_slt
: op
= SpvOpFOrdLessThan
; break;
1019 case nir_op_sge
: op
= SpvOpFOrdGreaterThanEqual
; break;
1020 default: unreachable("unexpected op");
1023 result
= emit_binop(ctx
, op
, bool_type
, src
[0], src
[1]);
1024 result
= emit_select(ctx
, dest_type
, result
, one
, zero
);
1029 assert(nir_op_infos
[alu
->op
].num_inputs
== 3);
1030 result
= emit_builtin_triop(ctx
, GLSLstd450FMix
, dest_type
,
1031 src
[0], src
[1], src
[2]);
1035 result
= emit_binop(ctx
, SpvOpFOrdGreaterThan
,
1036 get_bvec_type(ctx
, num_components
),
1038 get_fvec_constant(ctx
,
1039 nir_src_bit_size(alu
->src
[0].src
),
1040 num_components
, 0));
1041 result
= emit_select(ctx
, dest_type
, result
, src
[1], src
[2]);
1045 assert(nir_op_infos
[alu
->op
].num_inputs
== 3);
1046 result
= emit_select(ctx
, dest_type
, src
[0], src
[1], src
[2]);
1049 case nir_op_bany_fnequal2
:
1050 case nir_op_bany_fnequal3
:
1051 case nir_op_bany_fnequal4
:
1052 assert(nir_op_infos
[alu
->op
].num_inputs
== 2);
1053 assert(alu_instr_src_components(alu
, 0) ==
1054 alu_instr_src_components(alu
, 1));
1055 result
= emit_binop(ctx
, SpvOpFOrdNotEqual
,
1056 get_bvec_type(ctx
, alu_instr_src_components(alu
, 0)),
1058 result
= emit_unop(ctx
, SpvOpAny
, dest_type
, result
);
1061 case nir_op_ball_fequal2
:
1062 case nir_op_ball_fequal3
:
1063 case nir_op_ball_fequal4
:
1064 assert(nir_op_infos
[alu
->op
].num_inputs
== 2);
1065 assert(alu_instr_src_components(alu
, 0) ==
1066 alu_instr_src_components(alu
, 1));
1067 result
= emit_binop(ctx
, SpvOpFOrdEqual
,
1068 get_bvec_type(ctx
, alu_instr_src_components(alu
, 0)),
1070 result
= emit_unop(ctx
, SpvOpAll
, dest_type
, result
);
1073 case nir_op_bany_inequal2
:
1074 case nir_op_bany_inequal3
:
1075 case nir_op_bany_inequal4
:
1076 assert(nir_op_infos
[alu
->op
].num_inputs
== 2);
1077 assert(alu_instr_src_components(alu
, 0) ==
1078 alu_instr_src_components(alu
, 1));
1079 result
= emit_binop(ctx
, SpvOpINotEqual
,
1080 get_bvec_type(ctx
, alu_instr_src_components(alu
, 0)),
1082 result
= emit_unop(ctx
, SpvOpAny
, dest_type
, result
);
1085 case nir_op_ball_iequal2
:
1086 case nir_op_ball_iequal3
:
1087 case nir_op_ball_iequal4
:
1088 assert(nir_op_infos
[alu
->op
].num_inputs
== 2);
1089 assert(alu_instr_src_components(alu
, 0) ==
1090 alu_instr_src_components(alu
, 1));
1091 result
= emit_binop(ctx
, SpvOpIEqual
,
1092 get_bvec_type(ctx
, alu_instr_src_components(alu
, 0)),
1094 result
= emit_unop(ctx
, SpvOpAll
, dest_type
, result
);
1100 int num_inputs
= nir_op_infos
[alu
->op
].num_inputs
;
1101 assert(2 <= num_inputs
&& num_inputs
<= 4);
1102 result
= spirv_builder_emit_composite_construct(&ctx
->builder
, dest_type
,
1108 fprintf(stderr
, "emit_alu: not implemented (%s)\n",
1109 nir_op_infos
[alu
->op
].name
);
1111 unreachable("unsupported opcode");
1115 store_alu_result(ctx
, alu
, result
);
1119 emit_load_const(struct ntv_context
*ctx
, nir_load_const_instr
*load_const
)
1121 unsigned bit_size
= load_const
->def
.bit_size
;
1122 unsigned num_components
= load_const
->def
.num_components
;
1125 if (num_components
> 1) {
1126 SpvId components
[num_components
];
1128 if (bit_size
== 1) {
1129 for (int i
= 0; i
< num_components
; i
++)
1130 components
[i
] = spirv_builder_const_bool(&ctx
->builder
,
1131 load_const
->value
[i
].b
);
1133 type
= get_bvec_type(ctx
, num_components
);
1135 for (int i
= 0; i
< num_components
; i
++)
1136 components
[i
] = emit_uint_const(ctx
, bit_size
,
1137 load_const
->value
[i
].u32
);
1139 type
= get_uvec_type(ctx
, bit_size
, num_components
);
1141 constant
= spirv_builder_const_composite(&ctx
->builder
, type
,
1142 components
, num_components
);
1144 assert(num_components
== 1);
1146 constant
= spirv_builder_const_bool(&ctx
->builder
,
1147 load_const
->value
[0].b
);
1149 constant
= emit_uint_const(ctx
, bit_size
, load_const
->value
[0].u32
);
1153 constant
= bvec_to_uvec(ctx
, constant
, num_components
);
1155 store_ssa_def_uint(ctx
, &load_const
->def
, constant
);
1159 emit_load_ubo(struct ntv_context
*ctx
, nir_intrinsic_instr
*intr
)
1161 nir_const_value
*const_block_index
= nir_src_as_const_value(intr
->src
[0]);
1162 assert(const_block_index
); // no dynamic indexing for now
1163 assert(const_block_index
->u32
== 0); // we only support the default UBO for now
1165 nir_const_value
*const_offset
= nir_src_as_const_value(intr
->src
[1]);
1167 SpvId uvec4_type
= get_uvec_type(ctx
, 32, 4);
1168 SpvId pointer_type
= spirv_builder_type_pointer(&ctx
->builder
,
1169 SpvStorageClassUniform
,
1172 unsigned idx
= const_offset
->u32
;
1173 SpvId member
= emit_uint_const(ctx
, 32, 0);
1174 SpvId offset
= emit_uint_const(ctx
, 32, idx
);
1175 SpvId offsets
[] = { member
, offset
};
1176 SpvId ptr
= spirv_builder_emit_access_chain(&ctx
->builder
, pointer_type
,
1177 ctx
->ubos
[0], offsets
,
1178 ARRAY_SIZE(offsets
));
1179 SpvId result
= spirv_builder_emit_load(&ctx
->builder
, uvec4_type
, ptr
);
1181 SpvId type
= get_dest_uvec_type(ctx
, &intr
->dest
);
1182 unsigned num_components
= nir_dest_num_components(intr
->dest
);
1183 if (num_components
== 1) {
1184 uint32_t components
[] = { 0 };
1185 result
= spirv_builder_emit_composite_extract(&ctx
->builder
,
1189 } else if (num_components
< 4) {
1190 SpvId constituents
[num_components
];
1191 SpvId uint_type
= spirv_builder_type_uint(&ctx
->builder
, 32);
1192 for (uint32_t i
= 0; i
< num_components
; ++i
)
1193 constituents
[i
] = spirv_builder_emit_composite_extract(&ctx
->builder
,
1198 result
= spirv_builder_emit_composite_construct(&ctx
->builder
,
1204 store_dest_uint(ctx
, &intr
->dest
, result
);
1206 unreachable("uniform-addressing not yet supported");
1210 emit_discard(struct ntv_context
*ctx
, nir_intrinsic_instr
*intr
)
1212 assert(ctx
->block_started
);
1213 spirv_builder_emit_kill(&ctx
->builder
);
1214 /* discard is weird in NIR, so let's just create an unreachable block after
1215 it and hope that the vulkan driver will DCE any instructinos in it. */
1216 spirv_builder_label(&ctx
->builder
, spirv_builder_new_id(&ctx
->builder
));
1220 emit_load_deref(struct ntv_context
*ctx
, nir_intrinsic_instr
*intr
)
1222 /* uint is a bit of a lie here; it's really just a pointer */
1223 SpvId ptr
= get_src_uint(ctx
, intr
->src
);
1225 nir_variable
*var
= nir_intrinsic_get_var(intr
, 0);
1226 SpvId result
= spirv_builder_emit_load(&ctx
->builder
,
1227 get_glsl_type(ctx
, var
->type
),
1229 unsigned num_components
= nir_dest_num_components(intr
->dest
);
1230 unsigned bit_size
= nir_dest_bit_size(intr
->dest
);
1231 result
= bitcast_to_uvec(ctx
, result
, bit_size
, num_components
);
1232 store_dest_uint(ctx
, &intr
->dest
, result
);
1236 emit_store_deref(struct ntv_context
*ctx
, nir_intrinsic_instr
*intr
)
1238 /* uint is a bit of a lie here; it's really just a pointer */
1239 SpvId ptr
= get_src_uint(ctx
, &intr
->src
[0]);
1240 SpvId src
= get_src_uint(ctx
, &intr
->src
[1]);
1242 nir_variable
*var
= nir_intrinsic_get_var(intr
, 0);
1243 SpvId type
= get_glsl_type(ctx
, glsl_without_array(var
->type
));
1244 SpvId result
= emit_bitcast(ctx
, type
, src
);
1245 spirv_builder_emit_store(&ctx
->builder
, ptr
, result
);
1249 create_builtin_var(struct ntv_context
*ctx
, SpvId var_type
,
1250 SpvStorageClass storage_class
,
1251 const char *name
, SpvBuiltIn builtin
)
1253 SpvId pointer_type
= spirv_builder_type_pointer(&ctx
->builder
,
1256 SpvId var
= spirv_builder_emit_var(&ctx
->builder
, pointer_type
,
1258 spirv_builder_emit_name(&ctx
->builder
, var
, name
);
1259 spirv_builder_emit_builtin(&ctx
->builder
, var
, builtin
);
1261 assert(ctx
->num_entry_ifaces
< ARRAY_SIZE(ctx
->entry_ifaces
));
1262 ctx
->entry_ifaces
[ctx
->num_entry_ifaces
++] = var
;
1267 emit_load_front_face(struct ntv_context
*ctx
, nir_intrinsic_instr
*intr
)
1269 SpvId var_type
= spirv_builder_type_bool(&ctx
->builder
);
1270 if (!ctx
->front_face_var
)
1271 ctx
->front_face_var
= create_builtin_var(ctx
, var_type
,
1272 SpvStorageClassInput
,
1274 SpvBuiltInFrontFacing
);
1276 SpvId result
= spirv_builder_emit_load(&ctx
->builder
, var_type
,
1277 ctx
->front_face_var
);
1278 assert(1 == nir_dest_num_components(intr
->dest
));
1279 result
= bvec_to_uvec(ctx
, result
, 1);
1280 store_dest_uint(ctx
, &intr
->dest
, result
);
1284 emit_load_vertex_id(struct ntv_context
*ctx
, nir_intrinsic_instr
*intr
)
1286 SpvId var_type
= spirv_builder_type_uint(&ctx
->builder
, 32);
1287 if (!ctx
->vertex_id_var
)
1288 ctx
->vertex_id_var
= create_builtin_var(ctx
, var_type
,
1289 SpvStorageClassInput
,
1291 SpvBuiltInVertexIndex
);
1293 SpvId result
= spirv_builder_emit_load(&ctx
->builder
, var_type
,
1294 ctx
->vertex_id_var
);
1295 assert(1 == nir_dest_num_components(intr
->dest
));
1296 store_dest_uint(ctx
, &intr
->dest
, result
);
1300 emit_intrinsic(struct ntv_context
*ctx
, nir_intrinsic_instr
*intr
)
1302 switch (intr
->intrinsic
) {
1303 case nir_intrinsic_load_ubo
:
1304 emit_load_ubo(ctx
, intr
);
1307 case nir_intrinsic_discard
:
1308 emit_discard(ctx
, intr
);
1311 case nir_intrinsic_load_deref
:
1312 emit_load_deref(ctx
, intr
);
1315 case nir_intrinsic_store_deref
:
1316 emit_store_deref(ctx
, intr
);
1319 case nir_intrinsic_load_front_face
:
1320 emit_load_front_face(ctx
, intr
);
1323 case nir_intrinsic_load_vertex_id
:
1324 emit_load_vertex_id(ctx
, intr
);
1328 fprintf(stderr
, "emit_intrinsic: not implemented (%s)\n",
1329 nir_intrinsic_infos
[intr
->intrinsic
].name
);
1330 unreachable("unsupported intrinsic");
1335 emit_undef(struct ntv_context
*ctx
, nir_ssa_undef_instr
*undef
)
1337 SpvId type
= get_uvec_type(ctx
, undef
->def
.bit_size
,
1338 undef
->def
.num_components
);
1340 store_ssa_def_uint(ctx
, &undef
->def
,
1341 spirv_builder_emit_undef(&ctx
->builder
, type
));
1345 get_src_float(struct ntv_context
*ctx
, nir_src
*src
)
1347 SpvId def
= get_src_uint(ctx
, src
);
1348 unsigned num_components
= nir_src_num_components(*src
);
1349 unsigned bit_size
= nir_src_bit_size(*src
);
1350 return bitcast_to_fvec(ctx
, def
, bit_size
, num_components
);
1354 get_src_int(struct ntv_context
*ctx
, nir_src
*src
)
1356 SpvId def
= get_src_uint(ctx
, src
);
1357 unsigned num_components
= nir_src_num_components(*src
);
1358 unsigned bit_size
= nir_src_bit_size(*src
);
1359 return bitcast_to_ivec(ctx
, def
, bit_size
, num_components
);
1363 emit_tex(struct ntv_context
*ctx
, nir_tex_instr
*tex
)
1365 assert(tex
->op
== nir_texop_tex
||
1366 tex
->op
== nir_texop_txb
||
1367 tex
->op
== nir_texop_txl
||
1368 tex
->op
== nir_texop_txd
||
1369 tex
->op
== nir_texop_txf
||
1370 tex
->op
== nir_texop_txs
);
1371 assert(tex
->op
== nir_texop_txs
||
1372 nir_alu_type_get_base_type(tex
->dest_type
) == nir_type_float
);
1373 assert(tex
->texture_index
== tex
->sampler_index
);
1375 SpvId coord
= 0, proj
= 0, bias
= 0, lod
= 0, dref
= 0, dx
= 0, dy
= 0,
1377 unsigned coord_components
= 0;
1378 for (unsigned i
= 0; i
< tex
->num_srcs
; i
++) {
1379 switch (tex
->src
[i
].src_type
) {
1380 case nir_tex_src_coord
:
1381 if (tex
->op
== nir_texop_txf
)
1382 coord
= get_src_int(ctx
, &tex
->src
[i
].src
);
1384 coord
= get_src_float(ctx
, &tex
->src
[i
].src
);
1385 coord_components
= nir_src_num_components(tex
->src
[i
].src
);
1388 case nir_tex_src_projector
:
1389 assert(nir_src_num_components(tex
->src
[i
].src
) == 1);
1390 proj
= get_src_float(ctx
, &tex
->src
[i
].src
);
1394 case nir_tex_src_offset
:
1395 offset
= get_src_int(ctx
, &tex
->src
[i
].src
);
1398 case nir_tex_src_bias
:
1399 assert(tex
->op
== nir_texop_txb
);
1400 bias
= get_src_float(ctx
, &tex
->src
[i
].src
);
1404 case nir_tex_src_lod
:
1405 assert(nir_src_num_components(tex
->src
[i
].src
) == 1);
1406 if (tex
->op
== nir_texop_txf
||
1407 tex
->op
== nir_texop_txs
)
1408 lod
= get_src_int(ctx
, &tex
->src
[i
].src
);
1410 lod
= get_src_float(ctx
, &tex
->src
[i
].src
);
1414 case nir_tex_src_comparator
:
1415 assert(nir_src_num_components(tex
->src
[i
].src
) == 1);
1416 dref
= get_src_float(ctx
, &tex
->src
[i
].src
);
1420 case nir_tex_src_ddx
:
1421 dx
= get_src_float(ctx
, &tex
->src
[i
].src
);
1425 case nir_tex_src_ddy
:
1426 dy
= get_src_float(ctx
, &tex
->src
[i
].src
);
1431 fprintf(stderr
, "texture source: %d\n", tex
->src
[i
].src_type
);
1432 unreachable("unknown texture source");
1436 if (lod
== 0 && ctx
->stage
!= MESA_SHADER_FRAGMENT
) {
1437 lod
= emit_float_const(ctx
, 32, 0.0f
);
1442 SpvDim dimension
= type_to_dim(tex
->sampler_dim
, &is_ms
);
1443 SpvId float_type
= spirv_builder_type_float(&ctx
->builder
, 32);
1444 SpvId image_type
= spirv_builder_type_image(&ctx
->builder
, float_type
,
1445 dimension
, false, tex
->is_array
, is_ms
, 1,
1446 SpvImageFormatUnknown
);
1447 SpvId sampled_type
= spirv_builder_type_sampled_image(&ctx
->builder
,
1450 assert(tex
->texture_index
< ctx
->num_samplers
);
1451 SpvId load
= spirv_builder_emit_load(&ctx
->builder
, sampled_type
,
1452 ctx
->samplers
[tex
->texture_index
]);
1454 SpvId dest_type
= get_dest_type(ctx
, &tex
->dest
, tex
->dest_type
);
1456 if (tex
->op
== nir_texop_txs
) {
1457 SpvId image
= spirv_builder_emit_image(&ctx
->builder
, image_type
, load
);
1458 SpvId result
= spirv_builder_emit_image_query_size(&ctx
->builder
,
1461 store_dest(ctx
, &tex
->dest
, result
, tex
->dest_type
);
1466 SpvId constituents
[coord_components
+ 1];
1467 if (coord_components
== 1)
1468 constituents
[0] = coord
;
1470 assert(coord_components
> 1);
1471 SpvId float_type
= spirv_builder_type_float(&ctx
->builder
, 32);
1472 for (uint32_t i
= 0; i
< coord_components
; ++i
)
1473 constituents
[i
] = spirv_builder_emit_composite_extract(&ctx
->builder
,
1479 constituents
[coord_components
++] = proj
;
1481 SpvId vec_type
= get_fvec_type(ctx
, 32, coord_components
);
1482 coord
= spirv_builder_emit_composite_construct(&ctx
->builder
,
1488 SpvId actual_dest_type
= dest_type
;
1490 actual_dest_type
= float_type
;
1493 if (tex
->op
== nir_texop_txf
) {
1494 SpvId image
= spirv_builder_emit_image(&ctx
->builder
, image_type
, load
);
1495 result
= spirv_builder_emit_image_fetch(&ctx
->builder
, dest_type
,
1498 result
= spirv_builder_emit_image_sample(&ctx
->builder
,
1499 actual_dest_type
, load
,
1502 lod
, bias
, dref
, dx
, dy
,
1506 spirv_builder_emit_decoration(&ctx
->builder
, result
,
1507 SpvDecorationRelaxedPrecision
);
1510 SpvId components
[4] = { result
, result
, result
, result
};
1511 result
= spirv_builder_emit_composite_construct(&ctx
->builder
,
1517 store_dest(ctx
, &tex
->dest
, result
, tex
->dest_type
);
1521 start_block(struct ntv_context
*ctx
, SpvId label
)
1523 /* terminate previous block if needed */
1524 if (ctx
->block_started
)
1525 spirv_builder_emit_branch(&ctx
->builder
, label
);
1527 /* start new block */
1528 spirv_builder_label(&ctx
->builder
, label
);
1529 ctx
->block_started
= true;
1533 branch(struct ntv_context
*ctx
, SpvId label
)
1535 assert(ctx
->block_started
);
1536 spirv_builder_emit_branch(&ctx
->builder
, label
);
1537 ctx
->block_started
= false;
1541 branch_conditional(struct ntv_context
*ctx
, SpvId condition
, SpvId then_id
,
1544 assert(ctx
->block_started
);
1545 spirv_builder_emit_branch_conditional(&ctx
->builder
, condition
,
1547 ctx
->block_started
= false;
1551 emit_jump(struct ntv_context
*ctx
, nir_jump_instr
*jump
)
1553 switch (jump
->type
) {
1554 case nir_jump_break
:
1555 assert(ctx
->loop_break
);
1556 branch(ctx
, ctx
->loop_break
);
1559 case nir_jump_continue
:
1560 assert(ctx
->loop_cont
);
1561 branch(ctx
, ctx
->loop_cont
);
1565 unreachable("Unsupported jump type\n");
1570 emit_deref_var(struct ntv_context
*ctx
, nir_deref_instr
*deref
)
1572 assert(deref
->deref_type
== nir_deref_type_var
);
1574 struct hash_entry
*he
= _mesa_hash_table_search(ctx
->vars
, deref
->var
);
1576 SpvId result
= (SpvId
)(intptr_t)he
->data
;
1577 /* uint is a bit of a lie here, it's really just an opaque type */
1578 store_dest_uint(ctx
, &deref
->dest
, result
);
1582 emit_deref_array(struct ntv_context
*ctx
, nir_deref_instr
*deref
)
1584 assert(deref
->deref_type
== nir_deref_type_array
);
1585 nir_variable
*var
= nir_deref_instr_get_variable(deref
);
1587 SpvStorageClass storage_class
;
1588 switch (var
->data
.mode
) {
1589 case nir_var_shader_in
:
1590 storage_class
= SpvStorageClassInput
;
1593 case nir_var_shader_out
:
1594 storage_class
= SpvStorageClassOutput
;
1598 unreachable("Unsupported nir_variable_mode\n");
1601 SpvId index
= get_src_uint(ctx
, &deref
->arr
.index
);
1603 SpvId ptr_type
= spirv_builder_type_pointer(&ctx
->builder
,
1605 get_glsl_type(ctx
, deref
->type
));
1607 SpvId result
= spirv_builder_emit_access_chain(&ctx
->builder
,
1609 get_src_uint(ctx
, &deref
->parent
),
1611 /* uint is a bit of a lie here, it's really just an opaque type */
1612 store_dest_uint(ctx
, &deref
->dest
, result
);
1616 emit_deref(struct ntv_context
*ctx
, nir_deref_instr
*deref
)
1618 switch (deref
->deref_type
) {
1619 case nir_deref_type_var
:
1620 emit_deref_var(ctx
, deref
);
1623 case nir_deref_type_array
:
1624 emit_deref_array(ctx
, deref
);
1628 unreachable("unexpected deref_type");
1633 emit_block(struct ntv_context
*ctx
, struct nir_block
*block
)
1635 start_block(ctx
, block_label(ctx
, block
));
1636 nir_foreach_instr(instr
, block
) {
1637 switch (instr
->type
) {
1638 case nir_instr_type_alu
:
1639 emit_alu(ctx
, nir_instr_as_alu(instr
));
1641 case nir_instr_type_intrinsic
:
1642 emit_intrinsic(ctx
, nir_instr_as_intrinsic(instr
));
1644 case nir_instr_type_load_const
:
1645 emit_load_const(ctx
, nir_instr_as_load_const(instr
));
1647 case nir_instr_type_ssa_undef
:
1648 emit_undef(ctx
, nir_instr_as_ssa_undef(instr
));
1650 case nir_instr_type_tex
:
1651 emit_tex(ctx
, nir_instr_as_tex(instr
));
1653 case nir_instr_type_phi
:
1654 unreachable("nir_instr_type_phi not supported");
1656 case nir_instr_type_jump
:
1657 emit_jump(ctx
, nir_instr_as_jump(instr
));
1659 case nir_instr_type_call
:
1660 unreachable("nir_instr_type_call not supported");
1662 case nir_instr_type_parallel_copy
:
1663 unreachable("nir_instr_type_parallel_copy not supported");
1665 case nir_instr_type_deref
:
1666 emit_deref(ctx
, nir_instr_as_deref(instr
));
1673 emit_cf_list(struct ntv_context
*ctx
, struct exec_list
*list
);
1676 get_src_bool(struct ntv_context
*ctx
, nir_src
*src
)
1678 SpvId def
= get_src_uint(ctx
, src
);
1679 assert(nir_src_bit_size(*src
) == 1);
1680 unsigned num_components
= nir_src_num_components(*src
);
1681 return uvec_to_bvec(ctx
, def
, num_components
);
1685 emit_if(struct ntv_context
*ctx
, nir_if
*if_stmt
)
1687 SpvId condition
= get_src_bool(ctx
, &if_stmt
->condition
);
1689 SpvId header_id
= spirv_builder_new_id(&ctx
->builder
);
1690 SpvId then_id
= block_label(ctx
, nir_if_first_then_block(if_stmt
));
1691 SpvId endif_id
= spirv_builder_new_id(&ctx
->builder
);
1692 SpvId else_id
= endif_id
;
1694 bool has_else
= !exec_list_is_empty(&if_stmt
->else_list
);
1696 assert(nir_if_first_else_block(if_stmt
)->index
< ctx
->num_blocks
);
1697 else_id
= block_label(ctx
, nir_if_first_else_block(if_stmt
));
1700 /* create a header-block */
1701 start_block(ctx
, header_id
);
1702 spirv_builder_emit_selection_merge(&ctx
->builder
, endif_id
,
1703 SpvSelectionControlMaskNone
);
1704 branch_conditional(ctx
, condition
, then_id
, else_id
);
1706 emit_cf_list(ctx
, &if_stmt
->then_list
);
1709 if (ctx
->block_started
)
1710 branch(ctx
, endif_id
);
1712 emit_cf_list(ctx
, &if_stmt
->else_list
);
1715 start_block(ctx
, endif_id
);
1719 emit_loop(struct ntv_context
*ctx
, nir_loop
*loop
)
1721 SpvId header_id
= spirv_builder_new_id(&ctx
->builder
);
1722 SpvId begin_id
= block_label(ctx
, nir_loop_first_block(loop
));
1723 SpvId break_id
= spirv_builder_new_id(&ctx
->builder
);
1724 SpvId cont_id
= spirv_builder_new_id(&ctx
->builder
);
1726 /* create a header-block */
1727 start_block(ctx
, header_id
);
1728 spirv_builder_loop_merge(&ctx
->builder
, break_id
, cont_id
, SpvLoopControlMaskNone
);
1729 branch(ctx
, begin_id
);
1731 SpvId save_break
= ctx
->loop_break
;
1732 SpvId save_cont
= ctx
->loop_cont
;
1733 ctx
->loop_break
= break_id
;
1734 ctx
->loop_cont
= cont_id
;
1736 emit_cf_list(ctx
, &loop
->body
);
1738 ctx
->loop_break
= save_break
;
1739 ctx
->loop_cont
= save_cont
;
1741 branch(ctx
, cont_id
);
1742 start_block(ctx
, cont_id
);
1743 branch(ctx
, header_id
);
1745 start_block(ctx
, break_id
);
1749 emit_cf_list(struct ntv_context
*ctx
, struct exec_list
*list
)
1751 foreach_list_typed(nir_cf_node
, node
, node
, list
) {
1752 switch (node
->type
) {
1753 case nir_cf_node_block
:
1754 emit_block(ctx
, nir_cf_node_as_block(node
));
1757 case nir_cf_node_if
:
1758 emit_if(ctx
, nir_cf_node_as_if(node
));
1761 case nir_cf_node_loop
:
1762 emit_loop(ctx
, nir_cf_node_as_loop(node
));
1765 case nir_cf_node_function
:
1766 unreachable("nir_cf_node_function not supported");
1772 struct spirv_shader
*
1773 nir_to_spirv(struct nir_shader
*s
)
1775 struct spirv_shader
*ret
= NULL
;
1777 struct ntv_context ctx
= {};
1779 switch (s
->info
.stage
) {
1780 case MESA_SHADER_VERTEX
:
1781 case MESA_SHADER_FRAGMENT
:
1782 case MESA_SHADER_COMPUTE
:
1783 spirv_builder_emit_cap(&ctx
.builder
, SpvCapabilityShader
);
1786 case MESA_SHADER_TESS_CTRL
:
1787 case MESA_SHADER_TESS_EVAL
:
1788 spirv_builder_emit_cap(&ctx
.builder
, SpvCapabilityTessellation
);
1791 case MESA_SHADER_GEOMETRY
:
1792 spirv_builder_emit_cap(&ctx
.builder
, SpvCapabilityGeometry
);
1796 unreachable("invalid stage");
1799 // TODO: only enable when needed
1800 if (s
->info
.stage
== MESA_SHADER_FRAGMENT
) {
1801 spirv_builder_emit_cap(&ctx
.builder
, SpvCapabilitySampled1D
);
1802 spirv_builder_emit_cap(&ctx
.builder
, SpvCapabilityImageQuery
);
1805 ctx
.stage
= s
->info
.stage
;
1806 ctx
.GLSL_std_450
= spirv_builder_import(&ctx
.builder
, "GLSL.std.450");
1807 spirv_builder_emit_source(&ctx
.builder
, SpvSourceLanguageGLSL
, 450);
1809 spirv_builder_emit_mem_model(&ctx
.builder
, SpvAddressingModelLogical
,
1810 SpvMemoryModelGLSL450
);
1812 SpvExecutionModel exec_model
;
1813 switch (s
->info
.stage
) {
1814 case MESA_SHADER_VERTEX
:
1815 exec_model
= SpvExecutionModelVertex
;
1817 case MESA_SHADER_TESS_CTRL
:
1818 exec_model
= SpvExecutionModelTessellationControl
;
1820 case MESA_SHADER_TESS_EVAL
:
1821 exec_model
= SpvExecutionModelTessellationEvaluation
;
1823 case MESA_SHADER_GEOMETRY
:
1824 exec_model
= SpvExecutionModelGeometry
;
1826 case MESA_SHADER_FRAGMENT
:
1827 exec_model
= SpvExecutionModelFragment
;
1829 case MESA_SHADER_COMPUTE
:
1830 exec_model
= SpvExecutionModelGLCompute
;
1833 unreachable("invalid stage");
1836 SpvId type_void
= spirv_builder_type_void(&ctx
.builder
);
1837 SpvId type_main
= spirv_builder_type_function(&ctx
.builder
, type_void
,
1839 SpvId entry_point
= spirv_builder_new_id(&ctx
.builder
);
1840 spirv_builder_emit_name(&ctx
.builder
, entry_point
, "main");
1842 ctx
.vars
= _mesa_hash_table_create(NULL
, _mesa_hash_pointer
,
1843 _mesa_key_pointer_equal
);
1845 nir_foreach_variable(var
, &s
->inputs
)
1846 emit_input(&ctx
, var
);
1848 nir_foreach_variable(var
, &s
->outputs
)
1849 emit_output(&ctx
, var
);
1851 nir_foreach_variable(var
, &s
->uniforms
)
1852 emit_uniform(&ctx
, var
);
1854 if (s
->info
.stage
== MESA_SHADER_FRAGMENT
) {
1855 spirv_builder_emit_exec_mode(&ctx
.builder
, entry_point
,
1856 SpvExecutionModeOriginUpperLeft
);
1857 if (s
->info
.outputs_written
& BITFIELD64_BIT(FRAG_RESULT_DEPTH
))
1858 spirv_builder_emit_exec_mode(&ctx
.builder
, entry_point
,
1859 SpvExecutionModeDepthReplacing
);
1863 spirv_builder_function(&ctx
.builder
, entry_point
, type_void
,
1864 SpvFunctionControlMaskNone
,
1867 nir_function_impl
*entry
= nir_shader_get_entrypoint(s
);
1868 nir_metadata_require(entry
, nir_metadata_block_index
);
1870 ctx
.defs
= (SpvId
*)malloc(sizeof(SpvId
) * entry
->ssa_alloc
);
1873 ctx
.num_defs
= entry
->ssa_alloc
;
1875 nir_index_local_regs(entry
);
1876 ctx
.regs
= malloc(sizeof(SpvId
) * entry
->reg_alloc
);
1879 ctx
.num_regs
= entry
->reg_alloc
;
1881 SpvId
*block_ids
= (SpvId
*)malloc(sizeof(SpvId
) * entry
->num_blocks
);
1885 for (int i
= 0; i
< entry
->num_blocks
; ++i
)
1886 block_ids
[i
] = spirv_builder_new_id(&ctx
.builder
);
1888 ctx
.block_ids
= block_ids
;
1889 ctx
.num_blocks
= entry
->num_blocks
;
1891 /* emit a block only for the variable declarations */
1892 start_block(&ctx
, spirv_builder_new_id(&ctx
.builder
));
1893 foreach_list_typed(nir_register
, reg
, node
, &entry
->registers
) {
1894 SpvId type
= get_uvec_type(&ctx
, reg
->bit_size
, reg
->num_components
);
1895 SpvId pointer_type
= spirv_builder_type_pointer(&ctx
.builder
,
1896 SpvStorageClassFunction
,
1898 SpvId var
= spirv_builder_emit_var(&ctx
.builder
, pointer_type
,
1899 SpvStorageClassFunction
);
1901 ctx
.regs
[reg
->index
] = var
;
1904 emit_cf_list(&ctx
, &entry
->body
);
1908 spirv_builder_return(&ctx
.builder
); // doesn't belong here, but whatevz
1909 spirv_builder_function_end(&ctx
.builder
);
1911 spirv_builder_emit_entry_point(&ctx
.builder
, exec_model
, entry_point
,
1912 "main", ctx
.entry_ifaces
,
1913 ctx
.num_entry_ifaces
);
1915 size_t num_words
= spirv_builder_get_num_words(&ctx
.builder
);
1917 ret
= CALLOC_STRUCT(spirv_shader
);
1921 ret
->words
= MALLOC(sizeof(uint32_t) * num_words
);
1925 ret
->num_words
= spirv_builder_get_words(&ctx
.builder
, ret
->words
, num_words
);
1926 assert(ret
->num_words
== num_words
);
1933 spirv_shader_delete(ret
);
1936 _mesa_hash_table_destroy(ctx
.vars
, NULL
);
1942 spirv_shader_delete(struct spirv_shader
*s
)