projects / mesa.git / blob
? search:


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