projects / mesa.git / blob
? search:


d2001eb7de28aa0f003b390e0f316a2fcb4377f5
[mesa.git] / src / gallium / drivers / zink / nir_to_spirv / nir_to_spirv.c
1 /*
2 * Copyright 2018 Collabora Ltd.
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 * 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:
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 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.
22 */
23
24 #include "nir_to_spirv.h"
25 #include "spirv_builder.h"
26
27 #include "nir.h"
28 #include "pipe/p_state.h"
29 #include "util/u_memory.h"
30 #include "util/hash_table.h"
31
32 struct ntv_context {
33 struct spirv_builder builder;
34
35 SpvId GLSL_std_450;
36
37 gl_shader_stage stage;
38 int var_location;
39
40 SpvId ubos[128];
41 size_t num_ubos;
42 SpvId samplers[PIPE_MAX_SAMPLERS];
43 size_t num_samplers;
44 SpvId entry_ifaces[PIPE_MAX_SHADER_INPUTS * 4 + PIPE_MAX_SHADER_OUTPUTS * 4];
45 size_t num_entry_ifaces;
46
47 SpvId *defs;
48 size_t num_defs;
49
50 SpvId *regs;
51 size_t num_regs;
52
53 struct hash_table *vars; /* nir_variable -> SpvId */
54
55 const SpvId *block_ids;
56 size_t num_blocks;
57 bool block_started;
58 SpvId loop_break, loop_cont;
59 };
60
61 static SpvId
62 get_fvec_constant(struct ntv_context *ctx, int bit_size, int num_components,
63 const float values[]);
64
65 static SpvId
66 get_uvec_constant(struct ntv_context *ctx, int bit_size, int num_components,
67 const uint32_t values[]);
68
69 static SpvId
70 emit_unop(struct ntv_context *ctx, SpvOp op, SpvId type, SpvId src);
71
72 static SpvId
73 emit_binop(struct ntv_context *ctx, SpvOp op, SpvId type,
74 SpvId src0, SpvId src1);
75
76 static SpvId
77 emit_triop(struct ntv_context *ctx, SpvOp op, SpvId type,
78 SpvId src0, SpvId src1, SpvId src2);
79
80 static SpvId
81 get_bvec_type(struct ntv_context *ctx, int num_components)
82 {
83 SpvId bool_type = spirv_builder_type_bool(&ctx->builder);
84 if (num_components > 1)
85 return spirv_builder_type_vector(&ctx->builder, bool_type,
86 num_components);
87
88 assert(num_components == 1);
89 return bool_type;
90 }
91
92 static SpvId
93 block_label(struct ntv_context *ctx, nir_block *block)
94 {
95 assert(block->index < ctx->num_blocks);
96 return ctx->block_ids[block->index];
97 }
98
99 static SpvId
100 get_fvec_type(struct ntv_context *ctx, unsigned bit_size, unsigned num_components)
101 {
102 assert(bit_size == 32); // only 32-bit floats supported so far
103
104 SpvId float_type = spirv_builder_type_float(&ctx->builder, bit_size);
105 if (num_components > 1)
106 return spirv_builder_type_vector(&ctx->builder, float_type,
107 num_components);
108
109 assert(num_components == 1);
110 return float_type;
111 }
112
113 static SpvId
114 get_ivec_type(struct ntv_context *ctx, unsigned bit_size, unsigned num_components)
115 {
116 assert(bit_size == 32); // only 32-bit ints supported so far
117
118 SpvId int_type = spirv_builder_type_int(&ctx->builder, bit_size);
119 if (num_components > 1)
120 return spirv_builder_type_vector(&ctx->builder, int_type,
121 num_components);
122
123 assert(num_components == 1);
124 return int_type;
125 }
126
127 static SpvId
128 get_uvec_type(struct ntv_context *ctx, unsigned bit_size, unsigned num_components)
129 {
130 assert(bit_size == 32); // only 32-bit uints supported so far
131
132 SpvId uint_type = spirv_builder_type_uint(&ctx->builder, bit_size);
133 if (num_components > 1)
134 return spirv_builder_type_vector(&ctx->builder, uint_type,
135 num_components);
136
137 assert(num_components == 1);
138 return uint_type;
139 }
140
141 static SpvId
142 get_dest_uvec_type(struct ntv_context *ctx, nir_dest *dest)
143 {
144 return get_uvec_type(ctx, nir_dest_bit_size(*dest),
145 nir_dest_num_components(*dest));
146 }
147
148 static SpvId
149 get_glsl_basetype(struct ntv_context *ctx, enum glsl_base_type type)
150 {
151 switch (type) {
152 case GLSL_TYPE_FLOAT:
153 return spirv_builder_type_float(&ctx->builder, 32);
154
155 case GLSL_TYPE_INT:
156 return spirv_builder_type_int(&ctx->builder, 32);
157
158 case GLSL_TYPE_UINT:
159 return spirv_builder_type_uint(&ctx->builder, 32);
160 /* TODO: handle more types */
161
162 default:
163 unreachable("unknown GLSL type");
164 }
165 }
166
167 static SpvId
168 get_glsl_type(struct ntv_context *ctx, const struct glsl_type *type)
169 {
170 assert(type);
171 if (glsl_type_is_scalar(type))
172 return get_glsl_basetype(ctx, glsl_get_base_type(type));
173
174 if (glsl_type_is_vector(type))
175 return spirv_builder_type_vector(&ctx->builder,
176 get_glsl_basetype(ctx, glsl_get_base_type(type)),
177 glsl_get_vector_elements(type));
178
179 if (glsl_type_is_array(type)) {
180 SpvId ret = spirv_builder_type_array(&ctx->builder,
181 get_glsl_type(ctx, glsl_get_array_element(type)),
182 spirv_builder_const_uint(&ctx->builder, 32, glsl_get_length(type)));
183 uint32_t stride = glsl_get_explicit_stride(type);
184 if (stride)
185 spirv_builder_emit_array_stride(&ctx->builder, ret, stride);
186 return ret;
187 }
188
189
190 unreachable("we shouldn't get here, I think...");
191 }
192
193 static void
194 emit_input(struct ntv_context *ctx, struct nir_variable *var)
195 {
196 SpvId var_type = get_glsl_type(ctx, var->type);
197 SpvId pointer_type = spirv_builder_type_pointer(&ctx->builder,
198 SpvStorageClassInput,
199 var_type);
200 SpvId var_id = spirv_builder_emit_var(&ctx->builder, pointer_type,
201 SpvStorageClassInput);
202
203 if (var->name)
204 spirv_builder_emit_name(&ctx->builder, var_id, var->name);
205
206 if (ctx->stage == MESA_SHADER_FRAGMENT) {
207 if (var->data.location >= VARYING_SLOT_VAR0 ||
208 (var->data.location >= VARYING_SLOT_COL0 &&
209 var->data.location <= VARYING_SLOT_TEX7)) {
210 spirv_builder_emit_location(&ctx->builder, var_id,
211 ctx->var_location++);
212 } else {
213 switch (var->data.location) {
214 case VARYING_SLOT_POS:
215 spirv_builder_emit_builtin(&ctx->builder, var_id, SpvBuiltInFragCoord);
216 break;
217
218 case VARYING_SLOT_PNTC:
219 spirv_builder_emit_builtin(&ctx->builder, var_id, SpvBuiltInPointCoord);
220 break;
221
222 default:
223 debug_printf("unknown varying slot: %s\n", gl_varying_slot_name(var->data.location));
224 unreachable("unexpected varying slot");
225 }
226 }
227 } else {
228 spirv_builder_emit_location(&ctx->builder, var_id,
229 var->data.driver_location);
230 }
231
232 if (var->data.location_frac)
233 spirv_builder_emit_component(&ctx->builder, var_id,
234 var->data.location_frac);
235
236 if (var->data.interpolation == INTERP_MODE_FLAT)
237 spirv_builder_emit_decoration(&ctx->builder, var_id, SpvDecorationFlat);
238
239 _mesa_hash_table_insert(ctx->vars, var, (void *)(intptr_t)var_id);
240
241 assert(ctx->num_entry_ifaces < ARRAY_SIZE(ctx->entry_ifaces));
242 ctx->entry_ifaces[ctx->num_entry_ifaces++] = var_id;
243 }
244
245 static void
246 emit_output(struct ntv_context *ctx, struct nir_variable *var)
247 {
248 SpvId var_type = get_glsl_type(ctx, var->type);
249 SpvId pointer_type = spirv_builder_type_pointer(&ctx->builder,
250 SpvStorageClassOutput,
251 var_type);
252 SpvId var_id = spirv_builder_emit_var(&ctx->builder, pointer_type,
253 SpvStorageClassOutput);
254 if (var->name)
255 spirv_builder_emit_name(&ctx->builder, var_id, var->name);
256
257
258 if (ctx->stage == MESA_SHADER_VERTEX) {
259 if (var->data.location >= VARYING_SLOT_VAR0 ||
260 (var->data.location >= VARYING_SLOT_COL0 &&
261 var->data.location <= VARYING_SLOT_TEX7)) {
262 spirv_builder_emit_location(&ctx->builder, var_id,
263 ctx->var_location++);
264 } else {
265 switch (var->data.location) {
266 case VARYING_SLOT_POS:
267 spirv_builder_emit_builtin(&ctx->builder, var_id, SpvBuiltInPosition);
268 break;
269
270 case VARYING_SLOT_PSIZ:
271 spirv_builder_emit_builtin(&ctx->builder, var_id, SpvBuiltInPointSize);
272 break;
273
274 case VARYING_SLOT_CLIP_DIST0:
275 assert(glsl_type_is_array(var->type));
276 spirv_builder_emit_builtin(&ctx->builder, var_id, SpvBuiltInClipDistance);
277 break;
278
279 default:
280 debug_printf("unknown varying slot: %s\n", gl_varying_slot_name(var->data.location));
281 unreachable("unexpected varying slot");
282 }
283 }
284 } else if (ctx->stage == MESA_SHADER_FRAGMENT) {
285 if (var->data.location >= FRAG_RESULT_DATA0)
286 spirv_builder_emit_location(&ctx->builder, var_id,
287 var->data.location - FRAG_RESULT_DATA0);
288 else {
289 switch (var->data.location) {
290 case FRAG_RESULT_COLOR:
291 spirv_builder_emit_location(&ctx->builder, var_id, 0);
292 break;
293
294 case FRAG_RESULT_DEPTH:
295 spirv_builder_emit_builtin(&ctx->builder, var_id, SpvBuiltInFragDepth);
296 break;
297
298 default:
299 spirv_builder_emit_location(&ctx->builder, var_id,
300 var->data.driver_location);
301 }
302 }
303 }
304
305 if (var->data.location_frac)
306 spirv_builder_emit_component(&ctx->builder, var_id,
307 var->data.location_frac);
308
309 _mesa_hash_table_insert(ctx->vars, var, (void *)(intptr_t)var_id);
310
311 assert(ctx->num_entry_ifaces < ARRAY_SIZE(ctx->entry_ifaces));
312 ctx->entry_ifaces[ctx->num_entry_ifaces++] = var_id;
313 }
314
315 static SpvDim
316 type_to_dim(enum glsl_sampler_dim gdim, bool *is_ms)
317 {
318 *is_ms = false;
319 switch (gdim) {
320 case GLSL_SAMPLER_DIM_1D:
321 return SpvDim1D;
322 case GLSL_SAMPLER_DIM_2D:
323 return SpvDim2D;
324 case GLSL_SAMPLER_DIM_RECT:
325 return SpvDimRect;
326 case GLSL_SAMPLER_DIM_CUBE:
327 return SpvDimCube;
328 case GLSL_SAMPLER_DIM_3D:
329 return SpvDim3D;
330 case GLSL_SAMPLER_DIM_MS:
331 *is_ms = true;
332 return SpvDim2D;
333 default:
334 fprintf(stderr, "unknown sampler type %d\n", gdim);
335 break;
336 }
337 return SpvDim2D;
338 }
339
340 static void
341 emit_sampler(struct ntv_context *ctx, struct nir_variable *var)
342 {
343 bool is_ms;
344 SpvDim dimension = type_to_dim(glsl_get_sampler_dim(var->type), &is_ms);
345 SpvId float_type = spirv_builder_type_float(&ctx->builder, 32);
346 SpvId image_type = spirv_builder_type_image(&ctx->builder, float_type,
347 dimension, false, glsl_sampler_type_is_array(var->type), is_ms, 1,
348 SpvImageFormatUnknown);
349
350 SpvId sampled_type = spirv_builder_type_sampled_image(&ctx->builder,
351 image_type);
352 SpvId pointer_type = spirv_builder_type_pointer(&ctx->builder,
353 SpvStorageClassUniformConstant,
354 sampled_type);
355 SpvId var_id = spirv_builder_emit_var(&ctx->builder, pointer_type,
356 SpvStorageClassUniformConstant);
357
358 if (var->name)
359 spirv_builder_emit_name(&ctx->builder, var_id, var->name);
360
361 assert(ctx->num_samplers < ARRAY_SIZE(ctx->samplers));
362 ctx->samplers[ctx->num_samplers++] = var_id;
363
364 spirv_builder_emit_descriptor_set(&ctx->builder, var_id,
365 var->data.descriptor_set);
366 spirv_builder_emit_binding(&ctx->builder, var_id, var->data.binding);
367 }
368
369 static void
370 emit_ubo(struct ntv_context *ctx, struct nir_variable *var)
371 {
372 uint32_t size = glsl_count_attribute_slots(var->type, false);
373 SpvId vec4_type = get_uvec_type(ctx, 32, 4);
374 SpvId array_length = spirv_builder_const_uint(&ctx->builder, 32, size);
375 SpvId array_type = spirv_builder_type_array(&ctx->builder, vec4_type,
376 array_length);
377 spirv_builder_emit_array_stride(&ctx->builder, array_type, 16);
378
379 // wrap UBO-array in a struct
380 SpvId struct_type = spirv_builder_type_struct(&ctx->builder, &array_type, 1);
381 if (var->name) {
382 char struct_name[100];
383 snprintf(struct_name, sizeof(struct_name), "struct_%s", var->name);
384 spirv_builder_emit_name(&ctx->builder, struct_type, struct_name);
385 }
386
387 spirv_builder_emit_decoration(&ctx->builder, struct_type,
388 SpvDecorationBlock);
389 spirv_builder_emit_member_offset(&ctx->builder, struct_type, 0, 0);
390
391
392 SpvId pointer_type = spirv_builder_type_pointer(&ctx->builder,
393 SpvStorageClassUniform,
394 struct_type);
395
396 SpvId var_id = spirv_builder_emit_var(&ctx->builder, pointer_type,
397 SpvStorageClassUniform);
398 if (var->name)
399 spirv_builder_emit_name(&ctx->builder, var_id, var->name);
400
401 assert(ctx->num_ubos < ARRAY_SIZE(ctx->ubos));
402 ctx->ubos[ctx->num_ubos++] = var_id;
403
404 spirv_builder_emit_descriptor_set(&ctx->builder, var_id,
405 var->data.descriptor_set);
406 spirv_builder_emit_binding(&ctx->builder, var_id, var->data.binding);
407 }
408
409 static void
410 emit_uniform(struct ntv_context *ctx, struct nir_variable *var)
411 {
412 if (var->data.mode == nir_var_mem_ubo)
413 emit_ubo(ctx, var);
414 else {
415 assert(var->data.mode == nir_var_uniform);
416 if (glsl_type_is_sampler(var->type))
417 emit_sampler(ctx, var);
418 }
419 }
420
421 static SpvId
422 get_src_uint_ssa(struct ntv_context *ctx, const nir_ssa_def *ssa)
423 {
424 assert(ssa->index < ctx->num_defs);
425 assert(ctx->defs[ssa->index] != 0);
426 return ctx->defs[ssa->index];
427 }
428
429 static SpvId
430 get_var_from_reg(struct ntv_context *ctx, nir_register *reg)
431 {
432 assert(reg->index < ctx->num_regs);
433 assert(ctx->regs[reg->index] != 0);
434 return ctx->regs[reg->index];
435 }
436
437 static SpvId
438 get_src_uint_reg(struct ntv_context *ctx, const nir_reg_src *reg)
439 {
440 assert(reg->reg);
441 assert(!reg->indirect);
442 assert(!reg->base_offset);
443
444 SpvId var = get_var_from_reg(ctx, reg->reg);
445 SpvId type = get_uvec_type(ctx, reg->reg->bit_size, reg->reg->num_components);
446 return spirv_builder_emit_load(&ctx->builder, type, var);
447 }
448
449 static SpvId
450 get_src_uint(struct ntv_context *ctx, nir_src *src)
451 {
452 if (src->is_ssa)
453 return get_src_uint_ssa(ctx, src->ssa);
454 else
455 return get_src_uint_reg(ctx, &src->reg);
456 }
457
458 static SpvId
459 get_alu_src_uint(struct ntv_context *ctx, nir_alu_instr *alu, unsigned src)
460 {
461 assert(!alu->src[src].negate);
462 assert(!alu->src[src].abs);
463
464 SpvId def = get_src_uint(ctx, &alu->src[src].src);
465
466 unsigned used_channels = 0;
467 bool need_swizzle = false;
468 for (unsigned i = 0; i < NIR_MAX_VEC_COMPONENTS; i++) {
469 if (!nir_alu_instr_channel_used(alu, src, i))
470 continue;
471
472 used_channels++;
473
474 if (alu->src[src].swizzle[i] != i)
475 need_swizzle = true;
476 }
477 assert(used_channels != 0);
478
479 unsigned live_channels = nir_src_num_components(alu->src[src].src);
480 if (used_channels != live_channels)
481 need_swizzle = true;
482
483 if (!need_swizzle)
484 return def;
485
486 int bit_size = nir_src_bit_size(alu->src[src].src);
487 assert(bit_size == 32);
488
489 SpvId uint_type = spirv_builder_type_uint(&ctx->builder, bit_size);
490 if (used_channels == 1) {
491 uint32_t indices[] = { alu->src[src].swizzle[0] };
492 return spirv_builder_emit_composite_extract(&ctx->builder, uint_type,
493 def, indices,
494 ARRAY_SIZE(indices));
495 } else if (live_channels == 1) {
496 SpvId uvec_type = spirv_builder_type_vector(&ctx->builder, uint_type,
497 used_channels);
498
499 SpvId constituents[NIR_MAX_VEC_COMPONENTS];
500 for (unsigned i = 0; i < used_channels; ++i)
501 constituents[i] = def;
502
503 return spirv_builder_emit_composite_construct(&ctx->builder, uvec_type,
504 constituents,
505 used_channels);
506 } else {
507 SpvId uvec_type = spirv_builder_type_vector(&ctx->builder, uint_type,
508 used_channels);
509
510 uint32_t components[NIR_MAX_VEC_COMPONENTS];
511 size_t num_components = 0;
512 for (unsigned i = 0; i < NIR_MAX_VEC_COMPONENTS; i++) {
513 if (!nir_alu_instr_channel_used(alu, src, i))
514 continue;
515
516 components[num_components++] = alu->src[src].swizzle[i];
517 }
518
519 return spirv_builder_emit_vector_shuffle(&ctx->builder, uvec_type,
520 def, def, components, num_components);
521 }
522 }
523
524 static void
525 store_ssa_def_uint(struct ntv_context *ctx, nir_ssa_def *ssa, SpvId result)
526 {
527 assert(result != 0);
528 assert(ssa->index < ctx->num_defs);
529 ctx->defs[ssa->index] = result;
530 }
531
532 static SpvId
533 bvec_to_uvec(struct ntv_context *ctx, SpvId value, unsigned num_components)
534 {
535 SpvId otype = get_uvec_type(ctx, 32, num_components);
536 uint32_t zeros[4] = { 0, 0, 0, 0 };
537 uint32_t ones[4] = { 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff };
538 SpvId zero = get_uvec_constant(ctx, 32, num_components, zeros);
539 SpvId one = get_uvec_constant(ctx, 32, num_components, ones);
540 return emit_triop(ctx, SpvOpSelect, otype, value, one, zero);
541 }
542
543 static SpvId
544 uvec_to_bvec(struct ntv_context *ctx, SpvId value, unsigned num_components)
545 {
546 SpvId type = get_bvec_type(ctx, num_components);
547
548 uint32_t zeros[NIR_MAX_VEC_COMPONENTS] = { 0 };
549 SpvId zero = get_uvec_constant(ctx, 32, num_components, zeros);
550
551 return emit_binop(ctx, SpvOpINotEqual, type, value, zero);
552 }
553
554 static SpvId
555 bitcast_to_uvec(struct ntv_context *ctx, SpvId value, unsigned bit_size,
556 unsigned num_components)
557 {
558 SpvId type = get_uvec_type(ctx, bit_size, num_components);
559 return emit_unop(ctx, SpvOpBitcast, type, value);
560 }
561
562 static SpvId
563 bitcast_to_ivec(struct ntv_context *ctx, SpvId value, unsigned bit_size,
564 unsigned num_components)
565 {
566 SpvId type = get_ivec_type(ctx, bit_size, num_components);
567 return emit_unop(ctx, SpvOpBitcast, type, value);
568 }
569
570 static SpvId
571 bitcast_to_fvec(struct ntv_context *ctx, SpvId value, unsigned bit_size,
572 unsigned num_components)
573 {
574 SpvId type = get_fvec_type(ctx, bit_size, num_components);
575 return emit_unop(ctx, SpvOpBitcast, type, value);
576 }
577
578 static void
579 store_reg_def(struct ntv_context *ctx, nir_reg_dest *reg, SpvId result)
580 {
581 SpvId var = get_var_from_reg(ctx, reg->reg);
582 assert(var);
583 spirv_builder_emit_store(&ctx->builder, var, result);
584 }
585
586 static void
587 store_dest_uint(struct ntv_context *ctx, nir_dest *dest, SpvId result)
588 {
589 if (dest->is_ssa)
590 store_ssa_def_uint(ctx, &dest->ssa, result);
591 else
592 store_reg_def(ctx, &dest->reg, result);
593 }
594
595 static void
596 store_dest(struct ntv_context *ctx, nir_dest *dest, SpvId result, nir_alu_type type)
597 {
598 unsigned num_components = nir_dest_num_components(*dest);
599 unsigned bit_size = nir_dest_bit_size(*dest);
600
601 switch (nir_alu_type_get_base_type(type)) {
602 case nir_type_bool:
603 assert(bit_size == 1);
604 result = bvec_to_uvec(ctx, result, num_components);
605 break;
606
607 case nir_type_uint:
608 break; /* nothing to do! */
609
610 case nir_type_int:
611 case nir_type_float:
612 result = bitcast_to_uvec(ctx, result, bit_size, num_components);
613 break;
614
615 default:
616 unreachable("unsupported nir_alu_type");
617 }
618
619 store_dest_uint(ctx, dest, result);
620 }
621
622 static SpvId
623 emit_unop(struct ntv_context *ctx, SpvOp op, SpvId type, SpvId src)
624 {
625 return spirv_builder_emit_unop(&ctx->builder, op, type, src);
626 }
627
628 static SpvId
629 emit_binop(struct ntv_context *ctx, SpvOp op, SpvId type,
630 SpvId src0, SpvId src1)
631 {
632 return spirv_builder_emit_binop(&ctx->builder, op, type, src0, src1);
633 }
634
635 static SpvId
636 emit_triop(struct ntv_context *ctx, SpvOp op, SpvId type,
637 SpvId src0, SpvId src1, SpvId src2)
638 {
639 return spirv_builder_emit_triop(&ctx->builder, op, type, src0, src1, src2);
640 }
641
642 static SpvId
643 emit_builtin_unop(struct ntv_context *ctx, enum GLSLstd450 op, SpvId type,
644 SpvId src)
645 {
646 SpvId args[] = { src };
647 return spirv_builder_emit_ext_inst(&ctx->builder, type, ctx->GLSL_std_450,
648 op, args, ARRAY_SIZE(args));
649 }
650
651 static SpvId
652 emit_builtin_binop(struct ntv_context *ctx, enum GLSLstd450 op, SpvId type,
653 SpvId src0, SpvId src1)
654 {
655 SpvId args[] = { src0, src1 };
656 return spirv_builder_emit_ext_inst(&ctx->builder, type, ctx->GLSL_std_450,
657 op, args, ARRAY_SIZE(args));
658 }
659
660 static SpvId
661 get_fvec_constant(struct ntv_context *ctx, int bit_size, int num_components,
662 const float values[])
663 {
664 assert(bit_size == 32);
665
666 if (num_components > 1) {
667 SpvId components[num_components];
668 for (int i = 0; i < num_components; i++)
669 components[i] = spirv_builder_const_float(&ctx->builder, bit_size,
670 values[i]);
671
672 SpvId type = get_fvec_type(ctx, bit_size, num_components);
673 return spirv_builder_const_composite(&ctx->builder, type, components,
674 num_components);
675 }
676
677 assert(num_components == 1);
678 return spirv_builder_const_float(&ctx->builder, bit_size, values[0]);
679 }
680
681 static SpvId
682 get_uvec_constant(struct ntv_context *ctx, int bit_size, int num_components,
683 const uint32_t values[])
684 {
685 assert(bit_size == 32);
686
687 if (num_components > 1) {
688 SpvId components[num_components];
689 for (int i = 0; i < num_components; i++)
690 components[i] = spirv_builder_const_uint(&ctx->builder, bit_size,
691 values[i]);
692
693 SpvId type = get_uvec_type(ctx, bit_size, num_components);
694 return spirv_builder_const_composite(&ctx->builder, type, components,
695 num_components);
696 }
697
698 assert(num_components == 1);
699 return spirv_builder_const_uint(&ctx->builder, bit_size, values[0]);
700 }
701
702 static inline unsigned
703 alu_instr_src_components(const nir_alu_instr *instr, unsigned src)
704 {
705 if (nir_op_infos[instr->op].input_sizes[src] > 0)
706 return nir_op_infos[instr->op].input_sizes[src];
707
708 if (instr->dest.dest.is_ssa)
709 return instr->dest.dest.ssa.num_components;
710 else
711 return instr->dest.dest.reg.reg->num_components;
712 }
713
714 static SpvId
715 get_alu_src(struct ntv_context *ctx, nir_alu_instr *alu, unsigned src)
716 {
717 SpvId uint_value = get_alu_src_uint(ctx, alu, src);
718
719 unsigned num_components = alu_instr_src_components(alu, src);
720 unsigned bit_size = nir_src_bit_size(alu->src[src].src);
721 nir_alu_type type = nir_op_infos[alu->op].input_types[src];
722
723 switch (nir_alu_type_get_base_type(type)) {
724 case nir_type_bool:
725 assert(bit_size == 1);
726 return uvec_to_bvec(ctx, uint_value, num_components);
727
728 case nir_type_int:
729 return bitcast_to_ivec(ctx, uint_value, bit_size, num_components);
730
731 case nir_type_uint:
732 return uint_value;
733
734 case nir_type_float:
735 return bitcast_to_fvec(ctx, uint_value, bit_size, num_components);
736
737 default:
738 unreachable("unknown nir_alu_type");
739 }
740 }
741
742 static void
743 store_alu_result(struct ntv_context *ctx, nir_alu_instr *alu, SpvId result)
744 {
745 assert(!alu->dest.saturate);
746 return store_dest(ctx, &alu->dest.dest, result, nir_op_infos[alu->op].output_type);
747 }
748
749 static SpvId
750 get_dest_type(struct ntv_context *ctx, nir_dest *dest, nir_alu_type type)
751 {
752 unsigned num_components = nir_dest_num_components(*dest);
753 unsigned bit_size = nir_dest_bit_size(*dest);
754
755 switch (nir_alu_type_get_base_type(type)) {
756 case nir_type_bool:
757 return get_bvec_type(ctx, num_components);
758
759 case nir_type_int:
760 return get_ivec_type(ctx, bit_size, num_components);
761
762 case nir_type_uint:
763 return get_uvec_type(ctx, bit_size, num_components);
764
765 case nir_type_float:
766 return get_fvec_type(ctx, bit_size, num_components);
767
768 default:
769 unreachable("unsupported nir_alu_type");
770 }
771 }
772
773 static void
774 emit_alu(struct ntv_context *ctx, nir_alu_instr *alu)
775 {
776 SpvId src[nir_op_infos[alu->op].num_inputs];
777 for (unsigned i = 0; i < nir_op_infos[alu->op].num_inputs; i++)
778 src[i] = get_alu_src(ctx, alu, i);
779
780 SpvId dest_type = get_dest_type(ctx, &alu->dest.dest,
781 nir_op_infos[alu->op].output_type);
782 unsigned bit_size = nir_dest_bit_size(alu->dest.dest);
783 unsigned num_components = nir_dest_num_components(alu->dest.dest);
784
785 SpvId result = 0;
786 switch (alu->op) {
787 case nir_op_mov:
788 assert(nir_op_infos[alu->op].num_inputs == 1);
789 result = src[0];
790 break;
791
792 #define UNOP(nir_op, spirv_op) \
793 case nir_op: \
794 assert(nir_op_infos[alu->op].num_inputs == 1); \
795 result = emit_unop(ctx, spirv_op, dest_type, src[0]); \
796 break;
797
798 UNOP(nir_op_ineg, SpvOpSNegate)
799 UNOP(nir_op_fneg, SpvOpFNegate)
800 UNOP(nir_op_fddx, SpvOpDPdx)
801 UNOP(nir_op_fddy, SpvOpDPdy)
802 UNOP(nir_op_f2i32, SpvOpConvertFToS)
803 UNOP(nir_op_f2u32, SpvOpConvertFToU)
804 UNOP(nir_op_i2f32, SpvOpConvertSToF)
805 UNOP(nir_op_u2f32, SpvOpConvertUToF)
806 #undef UNOP
807
808 #define BUILTIN_UNOP(nir_op, spirv_op) \
809 case nir_op: \
810 assert(nir_op_infos[alu->op].num_inputs == 1); \
811 result = emit_builtin_unop(ctx, spirv_op, dest_type, src[0]); \
812 break;
813
814 BUILTIN_UNOP(nir_op_fabs, GLSLstd450FAbs)
815 BUILTIN_UNOP(nir_op_fsqrt, GLSLstd450Sqrt)
816 BUILTIN_UNOP(nir_op_frsq, GLSLstd450InverseSqrt)
817 BUILTIN_UNOP(nir_op_flog2, GLSLstd450Log2)
818 BUILTIN_UNOP(nir_op_fexp2, GLSLstd450Exp2)
819 BUILTIN_UNOP(nir_op_ffract, GLSLstd450Fract)
820 BUILTIN_UNOP(nir_op_ffloor, GLSLstd450Floor)
821 BUILTIN_UNOP(nir_op_fceil, GLSLstd450Ceil)
822 BUILTIN_UNOP(nir_op_ftrunc, GLSLstd450Trunc)
823 BUILTIN_UNOP(nir_op_fround_even, GLSLstd450RoundEven)
824 BUILTIN_UNOP(nir_op_fsign, GLSLstd450FSign)
825 BUILTIN_UNOP(nir_op_fsin, GLSLstd450Sin)
826 BUILTIN_UNOP(nir_op_fcos, GLSLstd450Cos)
827 #undef BUILTIN_UNOP
828
829 case nir_op_frcp: {
830 assert(nir_op_infos[alu->op].num_inputs == 1);
831 float one[4] = { 1, 1, 1, 1 };
832 src[1] = src[0];
833 src[0] = get_fvec_constant(ctx, bit_size, num_components, one);
834 result = emit_binop(ctx, SpvOpFDiv, dest_type, src[0], src[1]);
835 }
836 break;
837
838 case nir_op_f2b1: {
839 assert(nir_op_infos[alu->op].num_inputs == 1);
840 float values[NIR_MAX_VEC_COMPONENTS] = { 0 };
841 SpvId zero = get_fvec_constant(ctx, nir_src_bit_size(alu->src[0].src),
842 num_components, values);
843 result = emit_binop(ctx, SpvOpFOrdNotEqual, dest_type, src[0], zero);
844 } break;
845
846
847 #define BINOP(nir_op, spirv_op) \
848 case nir_op: \
849 assert(nir_op_infos[alu->op].num_inputs == 2); \
850 result = emit_binop(ctx, spirv_op, dest_type, src[0], src[1]); \
851 break;
852
853 BINOP(nir_op_iadd, SpvOpIAdd)
854 BINOP(nir_op_isub, SpvOpISub)
855 BINOP(nir_op_imul, SpvOpIMul)
856 BINOP(nir_op_idiv, SpvOpSDiv)
857 BINOP(nir_op_udiv, SpvOpUDiv)
858 BINOP(nir_op_fadd, SpvOpFAdd)
859 BINOP(nir_op_fsub, SpvOpFSub)
860 BINOP(nir_op_fmul, SpvOpFMul)
861 BINOP(nir_op_fdiv, SpvOpFDiv)
862 BINOP(nir_op_fmod, SpvOpFMod)
863 BINOP(nir_op_ilt, SpvOpSLessThan)
864 BINOP(nir_op_ige, SpvOpSGreaterThanEqual)
865 BINOP(nir_op_ieq, SpvOpIEqual)
866 BINOP(nir_op_ine, SpvOpINotEqual)
867 BINOP(nir_op_flt, SpvOpFOrdLessThan)
868 BINOP(nir_op_fge, SpvOpFOrdGreaterThanEqual)
869 BINOP(nir_op_feq, SpvOpFOrdEqual)
870 BINOP(nir_op_fne, SpvOpFOrdNotEqual)
871 BINOP(nir_op_ishl, SpvOpShiftLeftLogical)
872 BINOP(nir_op_ishr, SpvOpShiftRightArithmetic)
873 BINOP(nir_op_ushr, SpvOpShiftRightLogical)
874 #undef BINOP
875
876 #define BUILTIN_BINOP(nir_op, spirv_op) \
877 case nir_op: \
878 assert(nir_op_infos[alu->op].num_inputs == 2); \
879 result = emit_builtin_binop(ctx, spirv_op, dest_type, src[0], src[1]); \
880 break;
881
882 BUILTIN_BINOP(nir_op_fmin, GLSLstd450FMin)
883 BUILTIN_BINOP(nir_op_fmax, GLSLstd450FMax)
884 #undef BUILTIN_BINOP
885
886 case nir_op_fdot2:
887 case nir_op_fdot3:
888 case nir_op_fdot4:
889 assert(nir_op_infos[alu->op].num_inputs == 2);
890 result = emit_binop(ctx, SpvOpDot, dest_type, src[0], src[1]);
891 break;
892
893 case nir_op_seq:
894 case nir_op_sne:
895 case nir_op_slt:
896 case nir_op_sge: {
897 assert(nir_op_infos[alu->op].num_inputs == 2);
898 int num_components = nir_dest_num_components(alu->dest.dest);
899 SpvId bool_type = get_bvec_type(ctx, num_components);
900
901 SpvId zero = spirv_builder_const_float(&ctx->builder, 32, 0.0f);
902 SpvId one = spirv_builder_const_float(&ctx->builder, 32, 1.0f);
903 if (num_components > 1) {
904 SpvId zero_comps[num_components], one_comps[num_components];
905 for (int i = 0; i < num_components; i++) {
906 zero_comps[i] = zero;
907 one_comps[i] = one;
908 }
909
910 zero = spirv_builder_const_composite(&ctx->builder, dest_type,
911 zero_comps, num_components);
912 one = spirv_builder_const_composite(&ctx->builder, dest_type,
913 one_comps, num_components);
914 }
915
916 SpvOp op;
917 switch (alu->op) {
918 case nir_op_seq: op = SpvOpFOrdEqual; break;
919 case nir_op_sne: op = SpvOpFOrdNotEqual; break;
920 case nir_op_slt: op = SpvOpFOrdLessThan; break;
921 case nir_op_sge: op = SpvOpFOrdGreaterThanEqual; break;
922 default: unreachable("unexpected op");
923 }
924
925 result = emit_binop(ctx, op, bool_type, src[0], src[1]);
926 result = emit_triop(ctx, SpvOpSelect, dest_type, result, one, zero);
927 }
928 break;
929
930 case nir_op_fcsel: {
931 assert(nir_op_infos[alu->op].num_inputs == 3);
932 int num_components = nir_dest_num_components(alu->dest.dest);
933 SpvId bool_type = get_bvec_type(ctx, num_components);
934
935 float zero[4] = { 0, 0, 0, 0 };
936 SpvId cmp = get_fvec_constant(ctx, nir_src_bit_size(alu->src[0].src),
937 num_components, zero);
938
939 result = emit_binop(ctx, SpvOpFOrdGreaterThan, bool_type, src[0], cmp);
940 result = emit_triop(ctx, SpvOpSelect, dest_type, result, src[1], src[2]);
941 }
942 break;
943
944 case nir_op_vec2:
945 case nir_op_vec3:
946 case nir_op_vec4: {
947 int num_inputs = nir_op_infos[alu->op].num_inputs;
948 assert(2 <= num_inputs && num_inputs <= 4);
949 result = spirv_builder_emit_composite_construct(&ctx->builder, dest_type,
950 src, num_inputs);
951 }
952 break;
953
954 default:
955 fprintf(stderr, "emit_alu: not implemented (%s)\n",
956 nir_op_infos[alu->op].name);
957
958 unreachable("unsupported opcode");
959 return;
960 }
961
962 store_alu_result(ctx, alu, result);
963 }
964
965 static void
966 emit_load_const(struct ntv_context *ctx, nir_load_const_instr *load_const)
967 {
968 uint32_t values[NIR_MAX_VEC_COMPONENTS];
969 for (int i = 0; i < load_const->def.num_components; ++i)
970 values[i] = load_const->value[i].u32;
971
972 SpvId constant = get_uvec_constant(ctx, load_const->def.bit_size,
973 load_const->def.num_components,
974 values);
975 store_ssa_def_uint(ctx, &load_const->def, constant);
976 }
977
978 static void
979 emit_load_ubo(struct ntv_context *ctx, nir_intrinsic_instr *intr)
980 {
981 nir_const_value *const_block_index = nir_src_as_const_value(intr->src[0]);
982 assert(const_block_index); // no dynamic indexing for now
983 assert(const_block_index->u32 == 0); // we only support the default UBO for now
984
985 nir_const_value *const_offset = nir_src_as_const_value(intr->src[1]);
986 if (const_offset) {
987 SpvId uvec4_type = get_uvec_type(ctx, 32, 4);
988 SpvId pointer_type = spirv_builder_type_pointer(&ctx->builder,
989 SpvStorageClassUniform,
990 uvec4_type);
991
992 unsigned idx = const_offset->u32;
993 SpvId member = spirv_builder_const_uint(&ctx->builder, 32, 0);
994 SpvId offset = spirv_builder_const_uint(&ctx->builder, 32, idx);
995 SpvId offsets[] = { member, offset };
996 SpvId ptr = spirv_builder_emit_access_chain(&ctx->builder, pointer_type,
997 ctx->ubos[0], offsets,
998 ARRAY_SIZE(offsets));
999 SpvId result = spirv_builder_emit_load(&ctx->builder, uvec4_type, ptr);
1000
1001 SpvId type = get_dest_uvec_type(ctx, &intr->dest);
1002 unsigned num_components = nir_dest_num_components(intr->dest);
1003 if (num_components == 1) {
1004 uint32_t components[] = { 0 };
1005 result = spirv_builder_emit_composite_extract(&ctx->builder,
1006 type,
1007 result, components,
1008 1);
1009 } else if (num_components < 4) {
1010 SpvId constituents[num_components];
1011 SpvId uint_type = spirv_builder_type_uint(&ctx->builder, 32);
1012 for (uint32_t i = 0; i < num_components; ++i)
1013 constituents[i] = spirv_builder_emit_composite_extract(&ctx->builder,
1014 uint_type,
1015 result, &i,
1016 1);
1017
1018 result = spirv_builder_emit_composite_construct(&ctx->builder,
1019 type,
1020 constituents,
1021 num_components);
1022 }
1023
1024 store_dest_uint(ctx, &intr->dest, result);
1025 } else
1026 unreachable("uniform-addressing not yet supported");
1027 }
1028
1029 static void
1030 emit_discard(struct ntv_context *ctx, nir_intrinsic_instr *intr)
1031 {
1032 assert(ctx->block_started);
1033 spirv_builder_emit_kill(&ctx->builder);
1034 /* discard is weird in NIR, so let's just create an unreachable block after
1035 it and hope that the vulkan driver will DCE any instructinos in it. */
1036 spirv_builder_label(&ctx->builder, spirv_builder_new_id(&ctx->builder));
1037 }
1038
1039 static void
1040 emit_load_deref(struct ntv_context *ctx, nir_intrinsic_instr *intr)
1041 {
1042 /* uint is a bit of a lie here; it's really just a pointer */
1043 SpvId ptr = get_src_uint(ctx, intr->src);
1044
1045 nir_variable *var = nir_intrinsic_get_var(intr, 0);
1046 SpvId result = spirv_builder_emit_load(&ctx->builder,
1047 get_glsl_type(ctx, var->type),
1048 ptr);
1049 unsigned num_components = nir_dest_num_components(intr->dest);
1050 unsigned bit_size = nir_dest_bit_size(intr->dest);
1051 result = bitcast_to_uvec(ctx, result, bit_size, num_components);
1052 store_dest_uint(ctx, &intr->dest, result);
1053 }
1054
1055 static void
1056 emit_store_deref(struct ntv_context *ctx, nir_intrinsic_instr *intr)
1057 {
1058 /* uint is a bit of a lie here; it's really just a pointer */
1059 SpvId ptr = get_src_uint(ctx, &intr->src[0]);
1060 SpvId src = get_src_uint(ctx, &intr->src[1]);
1061
1062 nir_variable *var = nir_intrinsic_get_var(intr, 0);
1063 SpvId result = emit_unop(ctx, SpvOpBitcast,
1064 get_glsl_type(ctx, glsl_without_array(var->type)),
1065 src);
1066 spirv_builder_emit_store(&ctx->builder, ptr, result);
1067 }
1068
1069 static void
1070 emit_intrinsic(struct ntv_context *ctx, nir_intrinsic_instr *intr)
1071 {
1072 switch (intr->intrinsic) {
1073 case nir_intrinsic_load_ubo:
1074 emit_load_ubo(ctx, intr);
1075 break;
1076
1077 case nir_intrinsic_discard:
1078 emit_discard(ctx, intr);
1079 break;
1080
1081 case nir_intrinsic_load_deref:
1082 emit_load_deref(ctx, intr);
1083 break;
1084
1085 case nir_intrinsic_store_deref:
1086 emit_store_deref(ctx, intr);
1087 break;
1088
1089 default:
1090 fprintf(stderr, "emit_intrinsic: not implemented (%s)\n",
1091 nir_intrinsic_infos[intr->intrinsic].name);
1092 unreachable("unsupported intrinsic");
1093 }
1094 }
1095
1096 static void
1097 emit_undef(struct ntv_context *ctx, nir_ssa_undef_instr *undef)
1098 {
1099 SpvId type = get_uvec_type(ctx, undef->def.bit_size,
1100 undef->def.num_components);
1101
1102 store_ssa_def_uint(ctx, &undef->def,
1103 spirv_builder_emit_undef(&ctx->builder, type));
1104 }
1105
1106 static SpvId
1107 get_src_float(struct ntv_context *ctx, nir_src *src)
1108 {
1109 SpvId def = get_src_uint(ctx, src);
1110 unsigned num_components = nir_src_num_components(*src);
1111 unsigned bit_size = nir_src_bit_size(*src);
1112 return bitcast_to_fvec(ctx, def, bit_size, num_components);
1113 }
1114
1115 static void
1116 emit_tex(struct ntv_context *ctx, nir_tex_instr *tex)
1117 {
1118 assert(tex->op == nir_texop_tex ||
1119 tex->op == nir_texop_txb ||
1120 tex->op == nir_texop_txl);
1121 assert(nir_alu_type_get_base_type(tex->dest_type) == nir_type_float);
1122 assert(tex->texture_index == tex->sampler_index);
1123
1124 SpvId coord = 0, proj = 0, bias = 0, lod = 0, dref = 0;
1125 unsigned coord_components;
1126 for (unsigned i = 0; i < tex->num_srcs; i++) {
1127 switch (tex->src[i].src_type) {
1128 case nir_tex_src_coord:
1129 coord = get_src_float(ctx, &tex->src[i].src);
1130 coord_components = nir_src_num_components(tex->src[i].src);
1131 break;
1132
1133 case nir_tex_src_projector:
1134 assert(nir_src_num_components(tex->src[i].src) == 1);
1135 proj = get_src_float(ctx, &tex->src[i].src);
1136 assert(proj != 0);
1137 break;
1138
1139 case nir_tex_src_bias:
1140 assert(tex->op == nir_texop_txb);
1141 bias = get_src_float(ctx, &tex->src[i].src);
1142 assert(bias != 0);
1143 break;
1144
1145 case nir_tex_src_lod:
1146 assert(nir_src_num_components(tex->src[i].src) == 1);
1147 lod = get_src_float(ctx, &tex->src[i].src);
1148 assert(lod != 0);
1149 break;
1150
1151 case nir_tex_src_comparator:
1152 assert(nir_src_num_components(tex->src[i].src) == 1);
1153 dref = get_src_float(ctx, &tex->src[i].src);
1154 assert(dref != 0);
1155 break;
1156
1157 default:
1158 fprintf(stderr, "texture source: %d\n", tex->src[i].src_type);
1159 unreachable("unknown texture source");
1160 }
1161 }
1162
1163 if (lod == 0 && ctx->stage != MESA_SHADER_FRAGMENT) {
1164 lod = spirv_builder_const_float(&ctx->builder, 32, 0);
1165 assert(lod != 0);
1166 }
1167
1168 bool is_ms;
1169 SpvDim dimension = type_to_dim(tex->sampler_dim, &is_ms);
1170 SpvId float_type = spirv_builder_type_float(&ctx->builder, 32);
1171 SpvId image_type = spirv_builder_type_image(&ctx->builder, float_type,
1172 dimension, false, tex->is_array, is_ms, 1,
1173 SpvImageFormatUnknown);
1174 SpvId sampled_type = spirv_builder_type_sampled_image(&ctx->builder,
1175 image_type);
1176
1177 assert(tex->texture_index < ctx->num_samplers);
1178 SpvId load = spirv_builder_emit_load(&ctx->builder, sampled_type,
1179 ctx->samplers[tex->texture_index]);
1180
1181 SpvId dest_type = get_dest_type(ctx, &tex->dest, tex->dest_type);
1182
1183 if (proj) {
1184 SpvId constituents[coord_components + 1];
1185 if (coord_components == 1)
1186 constituents[0] = coord;
1187 else {
1188 assert(coord_components > 1);
1189 SpvId float_type = spirv_builder_type_float(&ctx->builder, 32);
1190 for (uint32_t i = 0; i < coord_components; ++i)
1191 constituents[i] = spirv_builder_emit_composite_extract(&ctx->builder,
1192 float_type,
1193 coord,
1194 &i, 1);
1195 }
1196
1197 constituents[coord_components++] = proj;
1198
1199 SpvId vec_type = get_fvec_type(ctx, 32, coord_components);
1200 coord = spirv_builder_emit_composite_construct(&ctx->builder,
1201 vec_type,
1202 constituents,
1203 coord_components);
1204 }
1205
1206 SpvId actual_dest_type = dest_type;
1207 if (dref)
1208 actual_dest_type = float_type;
1209
1210 SpvId result = spirv_builder_emit_image_sample(&ctx->builder,
1211 actual_dest_type, load,
1212 coord,
1213 proj != 0,
1214 lod, bias, dref);
1215 spirv_builder_emit_decoration(&ctx->builder, result,
1216 SpvDecorationRelaxedPrecision);
1217
1218 if (dref) {
1219 SpvId components[4] = { result, result, result, result };
1220 result = spirv_builder_emit_composite_construct(&ctx->builder,
1221 dest_type,
1222 components,
1223 4);
1224 }
1225
1226 store_dest(ctx, &tex->dest, result, tex->dest_type);
1227 }
1228
1229 static void
1230 start_block(struct ntv_context *ctx, SpvId label)
1231 {
1232 /* terminate previous block if needed */
1233 if (ctx->block_started)
1234 spirv_builder_emit_branch(&ctx->builder, label);
1235
1236 /* start new block */
1237 spirv_builder_label(&ctx->builder, label);
1238 ctx->block_started = true;
1239 }
1240
1241 static void
1242 branch(struct ntv_context *ctx, SpvId label)
1243 {
1244 assert(ctx->block_started);
1245 spirv_builder_emit_branch(&ctx->builder, label);
1246 ctx->block_started = false;
1247 }
1248
1249 static void
1250 branch_conditional(struct ntv_context *ctx, SpvId condition, SpvId then_id,
1251 SpvId else_id)
1252 {
1253 assert(ctx->block_started);
1254 spirv_builder_emit_branch_conditional(&ctx->builder, condition,
1255 then_id, else_id);
1256 ctx->block_started = false;
1257 }
1258
1259 static void
1260 emit_jump(struct ntv_context *ctx, nir_jump_instr *jump)
1261 {
1262 switch (jump->type) {
1263 case nir_jump_break:
1264 assert(ctx->loop_break);
1265 branch(ctx, ctx->loop_break);
1266 break;
1267
1268 case nir_jump_continue:
1269 assert(ctx->loop_cont);
1270 branch(ctx, ctx->loop_cont);
1271 break;
1272
1273 default:
1274 unreachable("Unsupported jump type\n");
1275 }
1276 }
1277
1278 static void
1279 emit_deref_var(struct ntv_context *ctx, nir_deref_instr *deref)
1280 {
1281 assert(deref->deref_type == nir_deref_type_var);
1282
1283 struct hash_entry *he = _mesa_hash_table_search(ctx->vars, deref->var);
1284 assert(he);
1285 SpvId result = (SpvId)(intptr_t)he->data;
1286 /* uint is a bit of a lie here, it's really just an opaque type */
1287 store_dest_uint(ctx, &deref->dest, result);
1288 }
1289
1290 static void
1291 emit_deref_array(struct ntv_context *ctx, nir_deref_instr *deref)
1292 {
1293 assert(deref->deref_type == nir_deref_type_array);
1294 nir_variable *var = nir_deref_instr_get_variable(deref);
1295
1296 SpvStorageClass storage_class;
1297 switch (var->data.mode) {
1298 case nir_var_shader_in:
1299 storage_class = SpvStorageClassInput;
1300 break;
1301
1302 case nir_var_shader_out:
1303 storage_class = SpvStorageClassOutput;
1304 break;
1305
1306 default:
1307 unreachable("Unsupported nir_variable_mode\n");
1308 }
1309
1310 SpvId index = get_src_uint(ctx, &deref->arr.index);
1311
1312 SpvId ptr_type = spirv_builder_type_pointer(&ctx->builder,
1313 storage_class,
1314 get_glsl_type(ctx, deref->type));
1315
1316 SpvId result = spirv_builder_emit_access_chain(&ctx->builder,
1317 ptr_type,
1318 get_src_uint(ctx, &deref->parent),
1319 &index, 1);
1320 /* uint is a bit of a lie here, it's really just an opaque type */
1321 store_dest_uint(ctx, &deref->dest, result);
1322 }
1323
1324 static void
1325 emit_deref(struct ntv_context *ctx, nir_deref_instr *deref)
1326 {
1327 switch (deref->deref_type) {
1328 case nir_deref_type_var:
1329 emit_deref_var(ctx, deref);
1330 break;
1331
1332 case nir_deref_type_array:
1333 emit_deref_array(ctx, deref);
1334 break;
1335
1336 default:
1337 unreachable("unexpected deref_type");
1338 }
1339 }
1340
1341 static void
1342 emit_block(struct ntv_context *ctx, struct nir_block *block)
1343 {
1344 start_block(ctx, block_label(ctx, block));
1345 nir_foreach_instr(instr, block) {
1346 switch (instr->type) {
1347 case nir_instr_type_alu:
1348 emit_alu(ctx, nir_instr_as_alu(instr));
1349 break;
1350 case nir_instr_type_intrinsic:
1351 emit_intrinsic(ctx, nir_instr_as_intrinsic(instr));
1352 break;
1353 case nir_instr_type_load_const:
1354 emit_load_const(ctx, nir_instr_as_load_const(instr));
1355 break;
1356 case nir_instr_type_ssa_undef:
1357 emit_undef(ctx, nir_instr_as_ssa_undef(instr));
1358 break;
1359 case nir_instr_type_tex:
1360 emit_tex(ctx, nir_instr_as_tex(instr));
1361 break;
1362 case nir_instr_type_phi:
1363 unreachable("nir_instr_type_phi not supported");
1364 break;
1365 case nir_instr_type_jump:
1366 emit_jump(ctx, nir_instr_as_jump(instr));
1367 break;
1368 case nir_instr_type_call:
1369 unreachable("nir_instr_type_call not supported");
1370 break;
1371 case nir_instr_type_parallel_copy:
1372 unreachable("nir_instr_type_parallel_copy not supported");
1373 break;
1374 case nir_instr_type_deref:
1375 emit_deref(ctx, nir_instr_as_deref(instr));
1376 break;
1377 }
1378 }
1379 }
1380
1381 static void
1382 emit_cf_list(struct ntv_context *ctx, struct exec_list *list);
1383
1384 static SpvId
1385 get_src_bool(struct ntv_context *ctx, nir_src *src)
1386 {
1387 SpvId def = get_src_uint(ctx, src);
1388 assert(nir_src_bit_size(*src) == 32);
1389 unsigned num_components = nir_src_num_components(*src);
1390 return uvec_to_bvec(ctx, def, num_components);
1391 }
1392
1393 static void
1394 emit_if(struct ntv_context *ctx, nir_if *if_stmt)
1395 {
1396 SpvId condition = get_src_bool(ctx, &if_stmt->condition);
1397
1398 SpvId header_id = spirv_builder_new_id(&ctx->builder);
1399 SpvId then_id = block_label(ctx, nir_if_first_then_block(if_stmt));
1400 SpvId endif_id = spirv_builder_new_id(&ctx->builder);
1401 SpvId else_id = endif_id;
1402
1403 bool has_else = !exec_list_is_empty(&if_stmt->else_list);
1404 if (has_else) {
1405 assert(nir_if_first_else_block(if_stmt)->index < ctx->num_blocks);
1406 else_id = block_label(ctx, nir_if_first_else_block(if_stmt));
1407 }
1408
1409 /* create a header-block */
1410 start_block(ctx, header_id);
1411 spirv_builder_emit_selection_merge(&ctx->builder, endif_id,
1412 SpvSelectionControlMaskNone);
1413 branch_conditional(ctx, condition, then_id, else_id);
1414
1415 emit_cf_list(ctx, &if_stmt->then_list);
1416
1417 if (has_else) {
1418 if (ctx->block_started)
1419 branch(ctx, endif_id);
1420
1421 emit_cf_list(ctx, &if_stmt->else_list);
1422 }
1423
1424 start_block(ctx, endif_id);
1425 }
1426
1427 static void
1428 emit_loop(struct ntv_context *ctx, nir_loop *loop)
1429 {
1430 SpvId header_id = spirv_builder_new_id(&ctx->builder);
1431 SpvId begin_id = block_label(ctx, nir_loop_first_block(loop));
1432 SpvId break_id = spirv_builder_new_id(&ctx->builder);
1433 SpvId cont_id = spirv_builder_new_id(&ctx->builder);
1434
1435 /* create a header-block */
1436 start_block(ctx, header_id);
1437 spirv_builder_loop_merge(&ctx->builder, break_id, cont_id, SpvLoopControlMaskNone);
1438 branch(ctx, begin_id);
1439
1440 SpvId save_break = ctx->loop_break;
1441 SpvId save_cont = ctx->loop_cont;
1442 ctx->loop_break = break_id;
1443 ctx->loop_cont = cont_id;
1444
1445 emit_cf_list(ctx, &loop->body);
1446
1447 ctx->loop_break = save_break;
1448 ctx->loop_cont = save_cont;
1449
1450 branch(ctx, cont_id);
1451 start_block(ctx, cont_id);
1452 branch(ctx, header_id);
1453
1454 start_block(ctx, break_id);
1455 }
1456
1457 static void
1458 emit_cf_list(struct ntv_context *ctx, struct exec_list *list)
1459 {
1460 foreach_list_typed(nir_cf_node, node, node, list) {
1461 switch (node->type) {
1462 case nir_cf_node_block:
1463 emit_block(ctx, nir_cf_node_as_block(node));
1464 break;
1465
1466 case nir_cf_node_if:
1467 emit_if(ctx, nir_cf_node_as_if(node));
1468 break;
1469
1470 case nir_cf_node_loop:
1471 emit_loop(ctx, nir_cf_node_as_loop(node));
1472 break;
1473
1474 case nir_cf_node_function:
1475 unreachable("nir_cf_node_function not supported");
1476 break;
1477 }
1478 }
1479 }
1480
1481 struct spirv_shader *
1482 nir_to_spirv(struct nir_shader *s)
1483 {
1484 struct spirv_shader *ret = NULL;
1485
1486 struct ntv_context ctx = {};
1487
1488 switch (s->info.stage) {
1489 case MESA_SHADER_VERTEX:
1490 case MESA_SHADER_FRAGMENT:
1491 case MESA_SHADER_COMPUTE:
1492 spirv_builder_emit_cap(&ctx.builder, SpvCapabilityShader);
1493 break;
1494
1495 case MESA_SHADER_TESS_CTRL:
1496 case MESA_SHADER_TESS_EVAL:
1497 spirv_builder_emit_cap(&ctx.builder, SpvCapabilityTessellation);
1498 break;
1499
1500 case MESA_SHADER_GEOMETRY:
1501 spirv_builder_emit_cap(&ctx.builder, SpvCapabilityGeometry);
1502 break;
1503
1504 default:
1505 unreachable("invalid stage");
1506 }
1507
1508 // TODO: only enable when needed
1509 if (s->info.stage == MESA_SHADER_FRAGMENT)
1510 spirv_builder_emit_cap(&ctx.builder, SpvCapabilitySampled1D);
1511
1512 ctx.stage = s->info.stage;
1513 ctx.GLSL_std_450 = spirv_builder_import(&ctx.builder, "GLSL.std.450");
1514 spirv_builder_emit_source(&ctx.builder, SpvSourceLanguageGLSL, 450);
1515
1516 spirv_builder_emit_mem_model(&ctx.builder, SpvAddressingModelLogical,
1517 SpvMemoryModelGLSL450);
1518
1519 SpvExecutionModel exec_model;
1520 switch (s->info.stage) {
1521 case MESA_SHADER_VERTEX:
1522 exec_model = SpvExecutionModelVertex;
1523 break;
1524 case MESA_SHADER_TESS_CTRL:
1525 exec_model = SpvExecutionModelTessellationControl;
1526 break;
1527 case MESA_SHADER_TESS_EVAL:
1528 exec_model = SpvExecutionModelTessellationEvaluation;
1529 break;
1530 case MESA_SHADER_GEOMETRY:
1531 exec_model = SpvExecutionModelGeometry;
1532 break;
1533 case MESA_SHADER_FRAGMENT:
1534 exec_model = SpvExecutionModelFragment;
1535 break;
1536 case MESA_SHADER_COMPUTE:
1537 exec_model = SpvExecutionModelGLCompute;
1538 break;
1539 default:
1540 unreachable("invalid stage");
1541 }
1542
1543 SpvId type_void = spirv_builder_type_void(&ctx.builder);
1544 SpvId type_main = spirv_builder_type_function(&ctx.builder, type_void,
1545 NULL, 0);
1546 SpvId entry_point = spirv_builder_new_id(&ctx.builder);
1547 spirv_builder_emit_name(&ctx.builder, entry_point, "main");
1548
1549 ctx.vars = _mesa_hash_table_create(NULL, _mesa_hash_pointer,
1550 _mesa_key_pointer_equal);
1551
1552 nir_foreach_variable(var, &s->inputs)
1553 emit_input(&ctx, var);
1554
1555 nir_foreach_variable(var, &s->outputs)
1556 emit_output(&ctx, var);
1557
1558 nir_foreach_variable(var, &s->uniforms)
1559 emit_uniform(&ctx, var);
1560
1561 spirv_builder_emit_entry_point(&ctx.builder, exec_model, entry_point,
1562 "main", ctx.entry_ifaces,
1563 ctx.num_entry_ifaces);
1564 if (s->info.stage == MESA_SHADER_FRAGMENT) {
1565 spirv_builder_emit_exec_mode(&ctx.builder, entry_point,
1566 SpvExecutionModeOriginUpperLeft);
1567 if (s->info.outputs_written & BITFIELD64_BIT(FRAG_RESULT_DEPTH))
1568 spirv_builder_emit_exec_mode(&ctx.builder, entry_point,
1569 SpvExecutionModeDepthReplacing);
1570 }
1571
1572
1573 spirv_builder_function(&ctx.builder, entry_point, type_void,
1574 SpvFunctionControlMaskNone,
1575 type_main);
1576
1577 nir_function_impl *entry = nir_shader_get_entrypoint(s);
1578 nir_metadata_require(entry, nir_metadata_block_index);
1579
1580 ctx.defs = (SpvId *)malloc(sizeof(SpvId) * entry->ssa_alloc);
1581 if (!ctx.defs)
1582 goto fail;
1583 ctx.num_defs = entry->ssa_alloc;
1584
1585 nir_index_local_regs(entry);
1586 ctx.regs = malloc(sizeof(SpvId) * entry->reg_alloc);
1587 if (!ctx.regs)
1588 goto fail;
1589 ctx.num_regs = entry->reg_alloc;
1590
1591 SpvId *block_ids = (SpvId *)malloc(sizeof(SpvId) * entry->num_blocks);
1592 if (!block_ids)
1593 goto fail;
1594
1595 for (int i = 0; i < entry->num_blocks; ++i)
1596 block_ids[i] = spirv_builder_new_id(&ctx.builder);
1597
1598 ctx.block_ids = block_ids;
1599 ctx.num_blocks = entry->num_blocks;
1600
1601 /* emit a block only for the variable declarations */
1602 start_block(&ctx, spirv_builder_new_id(&ctx.builder));
1603 foreach_list_typed(nir_register, reg, node, &entry->registers) {
1604 SpvId type = get_uvec_type(&ctx, reg->bit_size, reg->num_components);
1605 SpvId pointer_type = spirv_builder_type_pointer(&ctx.builder,
1606 SpvStorageClassFunction,
1607 type);
1608 SpvId var = spirv_builder_emit_var(&ctx.builder, pointer_type,
1609 SpvStorageClassFunction);
1610
1611 ctx.regs[reg->index] = var;
1612 }
1613
1614 emit_cf_list(&ctx, &entry->body);
1615
1616 free(ctx.defs);
1617
1618 spirv_builder_return(&ctx.builder); // doesn't belong here, but whatevz
1619 spirv_builder_function_end(&ctx.builder);
1620
1621 size_t num_words = spirv_builder_get_num_words(&ctx.builder);
1622
1623 ret = CALLOC_STRUCT(spirv_shader);
1624 if (!ret)
1625 goto fail;
1626
1627 ret->words = MALLOC(sizeof(uint32_t) * num_words);
1628 if (!ret->words)
1629 goto fail;
1630
1631 ret->num_words = spirv_builder_get_words(&ctx.builder, ret->words, num_words);
1632 assert(ret->num_words == num_words);
1633
1634 return ret;
1635
1636 fail:
1637
1638 if (ret)
1639 spirv_shader_delete(ret);
1640
1641 if (ctx.vars)
1642 _mesa_hash_table_destroy(ctx.vars, NULL);
1643
1644 return NULL;
1645 }
1646
1647 void
1648 spirv_shader_delete(struct spirv_shader *s)
1649 {
1650 FREE(s->words);
1651 FREE(s);
1652 }