projects / mesa.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
zink: set PIPE_CAP_VIEWPORT_TRANSFORM_LOWERED and remove POS special casing
[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 /* this consistently maps slots to a zero-indexed value to avoid wasting slots */
33 static unsigned slot_pack_map[] = {
34 /* Position is builtin */
35 [VARYING_SLOT_POS] = UINT_MAX,
36 [VARYING_SLOT_COL0] = 0, /* input/output */
37 [VARYING_SLOT_COL1] = 1, /* input/output */
38 [VARYING_SLOT_FOGC] = 2, /* input/output */
39 /* TEX0-7 are translated to VAR0-7 by nir, so we don't need to reserve */
40 [VARYING_SLOT_TEX0] = UINT_MAX, /* input/output */
41 [VARYING_SLOT_TEX1] = UINT_MAX,
42 [VARYING_SLOT_TEX2] = UINT_MAX,
43 [VARYING_SLOT_TEX3] = UINT_MAX,
44 [VARYING_SLOT_TEX4] = UINT_MAX,
45 [VARYING_SLOT_TEX5] = UINT_MAX,
46 [VARYING_SLOT_TEX6] = UINT_MAX,
47 [VARYING_SLOT_TEX7] = UINT_MAX,
48
49 /* PointSize is builtin */
50 [VARYING_SLOT_PSIZ] = UINT_MAX,
51
52 [VARYING_SLOT_BFC0] = 3, /* output only */
53 [VARYING_SLOT_BFC1] = 4, /* output only */
54 [VARYING_SLOT_EDGE] = 5, /* output only */
55 [VARYING_SLOT_CLIP_VERTEX] = 6, /* output only */
56
57 /* ClipDistance is builtin */
58 [VARYING_SLOT_CLIP_DIST0] = UINT_MAX,
59 [VARYING_SLOT_CLIP_DIST1] = UINT_MAX,
60
61 /* CullDistance is builtin */
62 [VARYING_SLOT_CULL_DIST0] = UINT_MAX, /* input/output */
63 [VARYING_SLOT_CULL_DIST1] = UINT_MAX, /* never actually used */
64
65 /* PrimitiveId is builtin */
66 [VARYING_SLOT_PRIMITIVE_ID] = UINT_MAX,
67
68 /* Layer is builtin */
69 [VARYING_SLOT_LAYER] = UINT_MAX, /* input/output */
70
71 /* ViewportIndex is builtin */
72 [VARYING_SLOT_VIEWPORT] = UINT_MAX, /* input/output */
73
74 /* FrontFacing is builtin */
75 [VARYING_SLOT_FACE] = UINT_MAX,
76
77 /* PointCoord is builtin */
78 [VARYING_SLOT_PNTC] = UINT_MAX, /* input only */
79
80 /* TessLevelOuter is builtin */
81 [VARYING_SLOT_TESS_LEVEL_OUTER] = UINT_MAX,
82 /* TessLevelInner is builtin */
83 [VARYING_SLOT_TESS_LEVEL_INNER] = UINT_MAX,
84
85 [VARYING_SLOT_BOUNDING_BOX0] = 7, /* Only appears as TCS output. */
86 [VARYING_SLOT_BOUNDING_BOX1] = 8, /* Only appears as TCS output. */
87 [VARYING_SLOT_VIEW_INDEX] = 9, /* input/output */
88 [VARYING_SLOT_VIEWPORT_MASK] = 10, /* output only */
89 };
90 #define NTV_MIN_RESERVED_SLOTS 10
91
92 struct ntv_context {
93 struct spirv_builder builder;
94
95 SpvId GLSL_std_450;
96
97 gl_shader_stage stage;
98
99 SpvId ubos[128];
100 size_t num_ubos;
101 SpvId image_types[PIPE_MAX_SAMPLERS];
102 SpvId samplers[PIPE_MAX_SAMPLERS];
103 unsigned samplers_used : PIPE_MAX_SAMPLERS;
104 SpvId entry_ifaces[PIPE_MAX_SHADER_INPUTS * 4 + PIPE_MAX_SHADER_OUTPUTS * 4];
105 size_t num_entry_ifaces;
106
107 SpvId *defs;
108 size_t num_defs;
109
110 SpvId *regs;
111 size_t num_regs;
112
113 struct hash_table *vars; /* nir_variable -> SpvId */
114 struct hash_table *so_outputs; /* pipe_stream_output -> SpvId */
115 unsigned outputs[VARYING_SLOT_MAX];
116 const struct glsl_type *so_output_gl_types[VARYING_SLOT_MAX];
117 SpvId so_output_types[VARYING_SLOT_MAX];
118
119 const SpvId *block_ids;
120 size_t num_blocks;
121 bool block_started;
122 SpvId loop_break, loop_cont;
123
124 SpvId front_face_var, instance_id_var, vertex_id_var;
125 };
126
127 static SpvId
128 get_fvec_constant(struct ntv_context *ctx, unsigned bit_size,
129 unsigned num_components, float value);
130
131 static SpvId
132 get_uvec_constant(struct ntv_context *ctx, unsigned bit_size,
133 unsigned num_components, uint32_t value);
134
135 static SpvId
136 get_ivec_constant(struct ntv_context *ctx, unsigned bit_size,
137 unsigned num_components, int32_t value);
138
139 static SpvId
140 emit_unop(struct ntv_context *ctx, SpvOp op, SpvId type, SpvId src);
141
142 static SpvId
143 emit_binop(struct ntv_context *ctx, SpvOp op, SpvId type,
144 SpvId src0, SpvId src1);
145
146 static SpvId
147 emit_triop(struct ntv_context *ctx, SpvOp op, SpvId type,
148 SpvId src0, SpvId src1, SpvId src2);
149
150 static SpvId
151 get_bvec_type(struct ntv_context *ctx, int num_components)
152 {
153 SpvId bool_type = spirv_builder_type_bool(&ctx->builder);
154 if (num_components > 1)
155 return spirv_builder_type_vector(&ctx->builder, bool_type,
156 num_components);
157
158 assert(num_components == 1);
159 return bool_type;
160 }
161
162 static SpvId
163 block_label(struct ntv_context *ctx, nir_block *block)
164 {
165 assert(block->index < ctx->num_blocks);
166 return ctx->block_ids[block->index];
167 }
168
169 static SpvId
170 emit_float_const(struct ntv_context *ctx, int bit_size, float value)
171 {
172 assert(bit_size == 32);
173 return spirv_builder_const_float(&ctx->builder, bit_size, value);
174 }
175
176 static SpvId
177 emit_uint_const(struct ntv_context *ctx, int bit_size, uint32_t value)
178 {
179 assert(bit_size == 32);
180 return spirv_builder_const_uint(&ctx->builder, bit_size, value);
181 }
182
183 static SpvId
184 emit_int_const(struct ntv_context *ctx, int bit_size, int32_t value)
185 {
186 assert(bit_size == 32);
187 return spirv_builder_const_int(&ctx->builder, bit_size, value);
188 }
189
190 static SpvId
191 get_fvec_type(struct ntv_context *ctx, unsigned bit_size, unsigned num_components)
192 {
193 assert(bit_size == 32); // only 32-bit floats supported so far
194
195 SpvId float_type = spirv_builder_type_float(&ctx->builder, bit_size);
196 if (num_components > 1)
197 return spirv_builder_type_vector(&ctx->builder, float_type,
198 num_components);
199
200 assert(num_components == 1);
201 return float_type;
202 }
203
204 static SpvId
205 get_ivec_type(struct ntv_context *ctx, unsigned bit_size, unsigned num_components)
206 {
207 assert(bit_size == 32); // only 32-bit ints supported so far
208
209 SpvId int_type = spirv_builder_type_int(&ctx->builder, bit_size);
210 if (num_components > 1)
211 return spirv_builder_type_vector(&ctx->builder, int_type,
212 num_components);
213
214 assert(num_components == 1);
215 return int_type;
216 }
217
218 static SpvId
219 get_uvec_type(struct ntv_context *ctx, unsigned bit_size, unsigned num_components)
220 {
221 assert(bit_size == 32); // only 32-bit uints supported so far
222
223 SpvId uint_type = spirv_builder_type_uint(&ctx->builder, bit_size);
224 if (num_components > 1)
225 return spirv_builder_type_vector(&ctx->builder, uint_type,
226 num_components);
227
228 assert(num_components == 1);
229 return uint_type;
230 }
231
232 static SpvId
233 get_dest_uvec_type(struct ntv_context *ctx, nir_dest *dest)
234 {
235 unsigned bit_size = MAX2(nir_dest_bit_size(*dest), 32);
236 return get_uvec_type(ctx, bit_size, nir_dest_num_components(*dest));
237 }
238
239 static SpvId
240 get_glsl_basetype(struct ntv_context *ctx, enum glsl_base_type type)
241 {
242 switch (type) {
243 case GLSL_TYPE_BOOL:
244 return spirv_builder_type_bool(&ctx->builder);
245
246 case GLSL_TYPE_FLOAT:
247 return spirv_builder_type_float(&ctx->builder, 32);
248
249 case GLSL_TYPE_INT:
250 return spirv_builder_type_int(&ctx->builder, 32);
251
252 case GLSL_TYPE_UINT:
253 return spirv_builder_type_uint(&ctx->builder, 32);
254 /* TODO: handle more types */
255
256 default:
257 unreachable("unknown GLSL type");
258 }
259 }
260
261 static SpvId
262 get_glsl_type(struct ntv_context *ctx, const struct glsl_type *type)
263 {
264 assert(type);
265 if (glsl_type_is_scalar(type))
266 return get_glsl_basetype(ctx, glsl_get_base_type(type));
267
268 if (glsl_type_is_vector(type))
269 return spirv_builder_type_vector(&ctx->builder,
270 get_glsl_basetype(ctx, glsl_get_base_type(type)),
271 glsl_get_vector_elements(type));
272
273 if (glsl_type_is_array(type)) {
274 SpvId ret = spirv_builder_type_array(&ctx->builder,
275 get_glsl_type(ctx, glsl_get_array_element(type)),
276 emit_uint_const(ctx, 32, glsl_get_length(type)));
277 uint32_t stride = glsl_get_explicit_stride(type);
278 if (stride)
279 spirv_builder_emit_array_stride(&ctx->builder, ret, stride);
280 return ret;
281 }
282
283
284 unreachable("we shouldn't get here, I think...");
285 }
286
287 #define HANDLE_EMIT_BUILTIN(SLOT, BUILTIN) \
288 case VARYING_SLOT_##SLOT: \
289 spirv_builder_emit_builtin(&ctx->builder, var_id, SpvBuiltIn##BUILTIN); \
290 break
291
292
293 static void
294 emit_input(struct ntv_context *ctx, struct nir_variable *var)
295 {
296 SpvId var_type = get_glsl_type(ctx, var->type);
297 SpvId pointer_type = spirv_builder_type_pointer(&ctx->builder,
298 SpvStorageClassInput,
299 var_type);
300 SpvId var_id = spirv_builder_emit_var(&ctx->builder, pointer_type,
301 SpvStorageClassInput);
302
303 if (var->name)
304 spirv_builder_emit_name(&ctx->builder, var_id, var->name);
305
306 if (ctx->stage == MESA_SHADER_FRAGMENT) {
307 unsigned slot = var->data.location;
308 switch (slot) {
309 HANDLE_EMIT_BUILTIN(POS, FragCoord);
310 HANDLE_EMIT_BUILTIN(PNTC, PointCoord);
311 HANDLE_EMIT_BUILTIN(LAYER, Layer);
312 HANDLE_EMIT_BUILTIN(PRIMITIVE_ID, PrimitiveId);
313 HANDLE_EMIT_BUILTIN(CLIP_DIST0, ClipDistance);
314 HANDLE_EMIT_BUILTIN(CULL_DIST0, CullDistance);
315 HANDLE_EMIT_BUILTIN(VIEWPORT, ViewportIndex);
316 HANDLE_EMIT_BUILTIN(FACE, FrontFacing);
317
318 default:
319 if (slot < VARYING_SLOT_VAR0) {
320 slot = slot_pack_map[slot];
321 if (slot == UINT_MAX)
322 debug_printf("unhandled varying slot: %s\n", gl_varying_slot_name(var->data.location));
323 } else
324 slot -= VARYING_SLOT_VAR0 - NTV_MIN_RESERVED_SLOTS;
325 assert(slot < VARYING_SLOT_VAR0);
326 spirv_builder_emit_location(&ctx->builder, var_id, slot);
327 }
328 } else {
329 spirv_builder_emit_location(&ctx->builder, var_id,
330 var->data.driver_location);
331 }
332
333 if (var->data.location_frac)
334 spirv_builder_emit_component(&ctx->builder, var_id,
335 var->data.location_frac);
336
337 if (var->data.interpolation == INTERP_MODE_FLAT)
338 spirv_builder_emit_decoration(&ctx->builder, var_id, SpvDecorationFlat);
339
340 _mesa_hash_table_insert(ctx->vars, var, (void *)(intptr_t)var_id);
341
342 assert(ctx->num_entry_ifaces < ARRAY_SIZE(ctx->entry_ifaces));
343 ctx->entry_ifaces[ctx->num_entry_ifaces++] = var_id;
344 }
345
346 static void
347 emit_output(struct ntv_context *ctx, struct nir_variable *var)
348 {
349 SpvId var_type = get_glsl_type(ctx, var->type);
350 SpvId pointer_type = spirv_builder_type_pointer(&ctx->builder,
351 SpvStorageClassOutput,
352 var_type);
353 SpvId var_id = spirv_builder_emit_var(&ctx->builder, pointer_type,
354 SpvStorageClassOutput);
355 if (var->name)
356 spirv_builder_emit_name(&ctx->builder, var_id, var->name);
357
358
359 if (ctx->stage == MESA_SHADER_VERTEX) {
360 unsigned slot = var->data.location;
361 switch (slot) {
362 HANDLE_EMIT_BUILTIN(POS, Position);
363 HANDLE_EMIT_BUILTIN(PSIZ, PointSize);
364 HANDLE_EMIT_BUILTIN(LAYER, Layer);
365 HANDLE_EMIT_BUILTIN(PRIMITIVE_ID, PrimitiveId);
366 HANDLE_EMIT_BUILTIN(CULL_DIST0, CullDistance);
367 HANDLE_EMIT_BUILTIN(VIEWPORT, ViewportIndex);
368 HANDLE_EMIT_BUILTIN(TESS_LEVEL_OUTER, TessLevelOuter);
369 HANDLE_EMIT_BUILTIN(TESS_LEVEL_INNER, TessLevelInner);
370
371 case VARYING_SLOT_CLIP_DIST0:
372 assert(glsl_type_is_array(var->type));
373 spirv_builder_emit_builtin(&ctx->builder, var_id, SpvBuiltInClipDistance);
374 /* this can be as large as 2x vec4, which requires 2 slots */
375 ctx->outputs[VARYING_SLOT_CLIP_DIST1] = var_id;
376 ctx->so_output_gl_types[VARYING_SLOT_CLIP_DIST1] = var->type;
377 ctx->so_output_types[VARYING_SLOT_CLIP_DIST1] = var_type;
378 break;
379
380 default:
381 if (slot < VARYING_SLOT_VAR0) {
382 slot = slot_pack_map[slot];
383 if (slot == UINT_MAX)
384 debug_printf("unhandled varying slot: %s\n", gl_varying_slot_name(var->data.location));
385 } else
386 slot -= VARYING_SLOT_VAR0 - NTV_MIN_RESERVED_SLOTS;
387 assert(slot < VARYING_SLOT_VAR0);
388 spirv_builder_emit_location(&ctx->builder, var_id, slot);
389 /* non-builtins get location incremented by VARYING_SLOT_VAR0 in vtn, so
390 * use driver_location for non-builtins with defined slots to avoid overlap
391 */
392 }
393 ctx->outputs[var->data.location] = var_id;
394 ctx->so_output_gl_types[var->data.location] = var->type;
395 ctx->so_output_types[var->data.location] = var_type;
396 } else if (ctx->stage == MESA_SHADER_FRAGMENT) {
397 if (var->data.location >= FRAG_RESULT_DATA0)
398 spirv_builder_emit_location(&ctx->builder, var_id,
399 var->data.location - FRAG_RESULT_DATA0);
400 else {
401 switch (var->data.location) {
402 case FRAG_RESULT_COLOR:
403 spirv_builder_emit_location(&ctx->builder, var_id, 0);
404 spirv_builder_emit_index(&ctx->builder, var_id, var->data.index);
405 break;
406
407 case FRAG_RESULT_DEPTH:
408 spirv_builder_emit_builtin(&ctx->builder, var_id, SpvBuiltInFragDepth);
409 break;
410
411 default:
412 spirv_builder_emit_location(&ctx->builder, var_id,
413 var->data.driver_location);
414 }
415 }
416 }
417
418 if (var->data.location_frac)
419 spirv_builder_emit_component(&ctx->builder, var_id,
420 var->data.location_frac);
421
422 switch (var->data.interpolation) {
423 case INTERP_MODE_NONE:
424 case INTERP_MODE_SMOOTH: /* XXX spirv doesn't seem to have anything for this */
425 break;
426 case INTERP_MODE_FLAT:
427 spirv_builder_emit_decoration(&ctx->builder, var_id, SpvDecorationFlat);
428 break;
429 case INTERP_MODE_EXPLICIT:
430 spirv_builder_emit_decoration(&ctx->builder, var_id, SpvDecorationExplicitInterpAMD);
431 break;
432 case INTERP_MODE_NOPERSPECTIVE:
433 spirv_builder_emit_decoration(&ctx->builder, var_id, SpvDecorationNoPerspective);
434 break;
435 default:
436 unreachable("unknown interpolation value");
437 }
438
439 _mesa_hash_table_insert(ctx->vars, var, (void *)(intptr_t)var_id);
440
441 assert(ctx->num_entry_ifaces < ARRAY_SIZE(ctx->entry_ifaces));
442 ctx->entry_ifaces[ctx->num_entry_ifaces++] = var_id;
443 }
444
445 static SpvDim
446 type_to_dim(enum glsl_sampler_dim gdim, bool *is_ms)
447 {
448 *is_ms = false;
449 switch (gdim) {
450 case GLSL_SAMPLER_DIM_1D:
451 return SpvDim1D;
452 case GLSL_SAMPLER_DIM_2D:
453 return SpvDim2D;
454 case GLSL_SAMPLER_DIM_3D:
455 return SpvDim3D;
456 case GLSL_SAMPLER_DIM_CUBE:
457 return SpvDimCube;
458 case GLSL_SAMPLER_DIM_RECT:
459 return SpvDim2D;
460 case GLSL_SAMPLER_DIM_BUF:
461 return SpvDimBuffer;
462 case GLSL_SAMPLER_DIM_EXTERNAL:
463 return SpvDim2D; /* seems dodgy... */
464 case GLSL_SAMPLER_DIM_MS:
465 *is_ms = true;
466 return SpvDim2D;
467 default:
468 fprintf(stderr, "unknown sampler type %d\n", gdim);
469 break;
470 }
471 return SpvDim2D;
472 }
473
474 uint32_t
475 zink_binding(gl_shader_stage stage, VkDescriptorType type, int index)
476 {
477 if (stage == MESA_SHADER_NONE ||
478 stage >= MESA_SHADER_COMPUTE) {
479 unreachable("not supported");
480 } else {
481 uint32_t stage_offset = (uint32_t)stage * (PIPE_MAX_CONSTANT_BUFFERS +
482 PIPE_MAX_SHADER_SAMPLER_VIEWS);
483
484 switch (type) {
485 case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER:
486 assert(index < PIPE_MAX_CONSTANT_BUFFERS);
487 return stage_offset + index;
488
489 case VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER:
490 assert(index < PIPE_MAX_SHADER_SAMPLER_VIEWS);
491 return stage_offset + PIPE_MAX_CONSTANT_BUFFERS + index;
492
493 default:
494 unreachable("unexpected type");
495 }
496 }
497 }
498
499 static void
500 emit_sampler(struct ntv_context *ctx, struct nir_variable *var)
501 {
502 const struct glsl_type *type = glsl_without_array(var->type);
503
504 bool is_ms;
505 SpvDim dimension = type_to_dim(glsl_get_sampler_dim(type), &is_ms);
506
507 SpvId result_type = get_glsl_basetype(ctx, glsl_get_sampler_result_type(type));
508 SpvId image_type = spirv_builder_type_image(&ctx->builder, result_type,
509 dimension, false,
510 glsl_sampler_type_is_array(type),
511 is_ms, 1,
512 SpvImageFormatUnknown);
513
514 SpvId sampled_type = spirv_builder_type_sampled_image(&ctx->builder,
515 image_type);
516 SpvId pointer_type = spirv_builder_type_pointer(&ctx->builder,
517 SpvStorageClassUniformConstant,
518 sampled_type);
519
520 if (glsl_type_is_array(var->type)) {
521 for (int i = 0; i < glsl_get_length(var->type); ++i) {
522 SpvId var_id = spirv_builder_emit_var(&ctx->builder, pointer_type,
523 SpvStorageClassUniformConstant);
524
525 if (var->name) {
526 char element_name[100];
527 snprintf(element_name, sizeof(element_name), "%s_%d", var->name, i);
528 spirv_builder_emit_name(&ctx->builder, var_id, var->name);
529 }
530
531 int index = var->data.binding + i;
532 assert(!(ctx->samplers_used & (1 << index)));
533 assert(!ctx->image_types[index]);
534 ctx->image_types[index] = image_type;
535 ctx->samplers[index] = var_id;
536 ctx->samplers_used |= 1 << index;
537
538 spirv_builder_emit_descriptor_set(&ctx->builder, var_id,
539 var->data.descriptor_set);
540 int binding = zink_binding(ctx->stage,
541 VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER,
542 var->data.binding + i);
543 spirv_builder_emit_binding(&ctx->builder, var_id, binding);
544 }
545 } else {
546 SpvId var_id = spirv_builder_emit_var(&ctx->builder, pointer_type,
547 SpvStorageClassUniformConstant);
548
549 if (var->name)
550 spirv_builder_emit_name(&ctx->builder, var_id, var->name);
551
552 int index = var->data.binding;
553 assert(!(ctx->samplers_used & (1 << index)));
554 assert(!ctx->image_types[index]);
555 ctx->image_types[index] = image_type;
556 ctx->samplers[index] = var_id;
557 ctx->samplers_used |= 1 << index;
558
559 spirv_builder_emit_descriptor_set(&ctx->builder, var_id,
560 var->data.descriptor_set);
561 int binding = zink_binding(ctx->stage,
562 VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER,
563 var->data.binding);
564 spirv_builder_emit_binding(&ctx->builder, var_id, binding);
565 }
566 }
567
568 static void
569 emit_ubo(struct ntv_context *ctx, struct nir_variable *var)
570 {
571 uint32_t size = glsl_count_attribute_slots(var->type, false);
572 SpvId vec4_type = get_uvec_type(ctx, 32, 4);
573 SpvId array_length = emit_uint_const(ctx, 32, size);
574 SpvId array_type = spirv_builder_type_array(&ctx->builder, vec4_type,
575 array_length);
576 spirv_builder_emit_array_stride(&ctx->builder, array_type, 16);
577
578 // wrap UBO-array in a struct
579 SpvId struct_type = spirv_builder_type_struct(&ctx->builder, &array_type, 1);
580 if (var->name) {
581 char struct_name[100];
582 snprintf(struct_name, sizeof(struct_name), "struct_%s", var->name);
583 spirv_builder_emit_name(&ctx->builder, struct_type, struct_name);
584 }
585
586 spirv_builder_emit_decoration(&ctx->builder, struct_type,
587 SpvDecorationBlock);
588 spirv_builder_emit_member_offset(&ctx->builder, struct_type, 0, 0);
589
590
591 SpvId pointer_type = spirv_builder_type_pointer(&ctx->builder,
592 SpvStorageClassUniform,
593 struct_type);
594
595 SpvId var_id = spirv_builder_emit_var(&ctx->builder, pointer_type,
596 SpvStorageClassUniform);
597 if (var->name)
598 spirv_builder_emit_name(&ctx->builder, var_id, var->name);
599
600 assert(ctx->num_ubos < ARRAY_SIZE(ctx->ubos));
601 ctx->ubos[ctx->num_ubos++] = var_id;
602
603 spirv_builder_emit_descriptor_set(&ctx->builder, var_id,
604 var->data.descriptor_set);
605 int binding = zink_binding(ctx->stage,
606 VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER,
607 var->data.binding);
608 spirv_builder_emit_binding(&ctx->builder, var_id, binding);
609 }
610
611 static void
612 emit_uniform(struct ntv_context *ctx, struct nir_variable *var)
613 {
614 if (var->data.mode == nir_var_mem_ubo)
615 emit_ubo(ctx, var);
616 else {
617 assert(var->data.mode == nir_var_uniform);
618 if (glsl_type_is_sampler(glsl_without_array(var->type)))
619 emit_sampler(ctx, var);
620 }
621 }
622
623 static SpvId
624 get_src_ssa(struct ntv_context *ctx, const nir_ssa_def *ssa)
625 {
626 assert(ssa->index < ctx->num_defs);
627 assert(ctx->defs[ssa->index] != 0);
628 return ctx->defs[ssa->index];
629 }
630
631 static SpvId
632 get_var_from_reg(struct ntv_context *ctx, nir_register *reg)
633 {
634 assert(reg->index < ctx->num_regs);
635 assert(ctx->regs[reg->index] != 0);
636 return ctx->regs[reg->index];
637 }
638
639 static SpvId
640 get_src_reg(struct ntv_context *ctx, const nir_reg_src *reg)
641 {
642 assert(reg->reg);
643 assert(!reg->indirect);
644 assert(!reg->base_offset);
645
646 SpvId var = get_var_from_reg(ctx, reg->reg);
647 SpvId type = get_uvec_type(ctx, reg->reg->bit_size, reg->reg->num_components);
648 return spirv_builder_emit_load(&ctx->builder, type, var);
649 }
650
651 static SpvId
652 get_src(struct ntv_context *ctx, nir_src *src)
653 {
654 if (src->is_ssa)
655 return get_src_ssa(ctx, src->ssa);
656 else
657 return get_src_reg(ctx, &src->reg);
658 }
659
660 static SpvId
661 get_alu_src_raw(struct ntv_context *ctx, nir_alu_instr *alu, unsigned src)
662 {
663 assert(!alu->src[src].negate);
664 assert(!alu->src[src].abs);
665
666 SpvId def = get_src(ctx, &alu->src[src].src);
667
668 unsigned used_channels = 0;
669 bool need_swizzle = false;
670 for (unsigned i = 0; i < NIR_MAX_VEC_COMPONENTS; i++) {
671 if (!nir_alu_instr_channel_used(alu, src, i))
672 continue;
673
674 used_channels++;
675
676 if (alu->src[src].swizzle[i] != i)
677 need_swizzle = true;
678 }
679 assert(used_channels != 0);
680
681 unsigned live_channels = nir_src_num_components(alu->src[src].src);
682 if (used_channels != live_channels)
683 need_swizzle = true;
684
685 if (!need_swizzle)
686 return def;
687
688 int bit_size = nir_src_bit_size(alu->src[src].src);
689 assert(bit_size == 1 || bit_size == 32);
690
691 SpvId raw_type = bit_size == 1 ? spirv_builder_type_bool(&ctx->builder) :
692 spirv_builder_type_uint(&ctx->builder, bit_size);
693
694 if (used_channels == 1) {
695 uint32_t indices[] = { alu->src[src].swizzle[0] };
696 return spirv_builder_emit_composite_extract(&ctx->builder, raw_type,
697 def, indices,
698 ARRAY_SIZE(indices));
699 } else if (live_channels == 1) {
700 SpvId raw_vec_type = spirv_builder_type_vector(&ctx->builder,
701 raw_type,
702 used_channels);
703
704 SpvId constituents[NIR_MAX_VEC_COMPONENTS] = {0};
705 for (unsigned i = 0; i < used_channels; ++i)
706 constituents[i] = def;
707
708 return spirv_builder_emit_composite_construct(&ctx->builder,
709 raw_vec_type,
710 constituents,
711 used_channels);
712 } else {
713 SpvId raw_vec_type = spirv_builder_type_vector(&ctx->builder,
714 raw_type,
715 used_channels);
716
717 uint32_t components[NIR_MAX_VEC_COMPONENTS] = {0};
718 size_t num_components = 0;
719 for (unsigned i = 0; i < NIR_MAX_VEC_COMPONENTS; i++) {
720 if (!nir_alu_instr_channel_used(alu, src, i))
721 continue;
722
723 components[num_components++] = alu->src[src].swizzle[i];
724 }
725
726 return spirv_builder_emit_vector_shuffle(&ctx->builder, raw_vec_type,
727 def, def, components,
728 num_components);
729 }
730 }
731
732 static void
733 store_ssa_def(struct ntv_context *ctx, nir_ssa_def *ssa, SpvId result)
734 {
735 assert(result != 0);
736 assert(ssa->index < ctx->num_defs);
737 ctx->defs[ssa->index] = result;
738 }
739
740 static SpvId
741 emit_select(struct ntv_context *ctx, SpvId type, SpvId cond,
742 SpvId if_true, SpvId if_false)
743 {
744 return emit_triop(ctx, SpvOpSelect, type, cond, if_true, if_false);
745 }
746
747 static SpvId
748 uvec_to_bvec(struct ntv_context *ctx, SpvId value, unsigned num_components)
749 {
750 SpvId type = get_bvec_type(ctx, num_components);
751 SpvId zero = get_uvec_constant(ctx, 32, num_components, 0);
752 return emit_binop(ctx, SpvOpINotEqual, type, value, zero);
753 }
754
755 static SpvId
756 emit_bitcast(struct ntv_context *ctx, SpvId type, SpvId value)
757 {
758 return emit_unop(ctx, SpvOpBitcast, type, value);
759 }
760
761 static SpvId
762 bitcast_to_uvec(struct ntv_context *ctx, SpvId value, unsigned bit_size,
763 unsigned num_components)
764 {
765 SpvId type = get_uvec_type(ctx, bit_size, num_components);
766 return emit_bitcast(ctx, type, value);
767 }
768
769 static SpvId
770 bitcast_to_ivec(struct ntv_context *ctx, SpvId value, unsigned bit_size,
771 unsigned num_components)
772 {
773 SpvId type = get_ivec_type(ctx, bit_size, num_components);
774 return emit_bitcast(ctx, type, value);
775 }
776
777 static SpvId
778 bitcast_to_fvec(struct ntv_context *ctx, SpvId value, unsigned bit_size,
779 unsigned num_components)
780 {
781 SpvId type = get_fvec_type(ctx, bit_size, num_components);
782 return emit_bitcast(ctx, type, value);
783 }
784
785 static void
786 store_reg_def(struct ntv_context *ctx, nir_reg_dest *reg, SpvId result)
787 {
788 SpvId var = get_var_from_reg(ctx, reg->reg);
789 assert(var);
790 spirv_builder_emit_store(&ctx->builder, var, result);
791 }
792
793 static void
794 store_dest_raw(struct ntv_context *ctx, nir_dest *dest, SpvId result)
795 {
796 if (dest->is_ssa)
797 store_ssa_def(ctx, &dest->ssa, result);
798 else
799 store_reg_def(ctx, &dest->reg, result);
800 }
801
802 static SpvId
803 store_dest(struct ntv_context *ctx, nir_dest *dest, SpvId result, nir_alu_type type)
804 {
805 unsigned num_components = nir_dest_num_components(*dest);
806 unsigned bit_size = nir_dest_bit_size(*dest);
807
808 if (bit_size != 1) {
809 switch (nir_alu_type_get_base_type(type)) {
810 case nir_type_bool:
811 assert("bool should have bit-size 1");
812
813 case nir_type_uint:
814 break; /* nothing to do! */
815
816 case nir_type_int:
817 case nir_type_float:
818 result = bitcast_to_uvec(ctx, result, bit_size, num_components);
819 break;
820
821 default:
822 unreachable("unsupported nir_alu_type");
823 }
824 }
825
826 store_dest_raw(ctx, dest, result);
827 return result;
828 }
829
830 static SpvId
831 emit_unop(struct ntv_context *ctx, SpvOp op, SpvId type, SpvId src)
832 {
833 return spirv_builder_emit_unop(&ctx->builder, op, type, src);
834 }
835
836 /* return the intended xfb output vec type based on base type and vector size */
837 static SpvId
838 get_output_type(struct ntv_context *ctx, unsigned register_index, unsigned num_components)
839 {
840 const struct glsl_type *out_type = ctx->so_output_gl_types[register_index];
841 enum glsl_base_type base_type = glsl_get_base_type(out_type);
842 if (base_type == GLSL_TYPE_ARRAY)
843 base_type = glsl_get_base_type(glsl_without_array(out_type));
844
845 switch (base_type) {
846 case GLSL_TYPE_BOOL:
847 return get_bvec_type(ctx, num_components);
848
849 case GLSL_TYPE_FLOAT:
850 return get_fvec_type(ctx, 32, num_components);
851
852 case GLSL_TYPE_INT:
853 return get_ivec_type(ctx, 32, num_components);
854
855 case GLSL_TYPE_UINT:
856 return get_uvec_type(ctx, 32, num_components);
857
858 default:
859 break;
860 }
861 unreachable("unknown type");
862 return 0;
863 }
864
865 /* for streamout create new outputs, as streamout can be done on individual components,
866 from complete outputs, so we just can't use the created packed outputs */
867 static void
868 emit_so_info(struct ntv_context *ctx, unsigned max_output_location,
869 const struct pipe_stream_output_info *so_info, struct pipe_stream_output_info *local_so_info)
870 {
871 for (unsigned i = 0; i < local_so_info->num_outputs; i++) {
872 struct pipe_stream_output so_output = local_so_info->output[i];
873 SpvId out_type = get_output_type(ctx, so_output.register_index, so_output.num_components);
874 SpvId pointer_type = spirv_builder_type_pointer(&ctx->builder,
875 SpvStorageClassOutput,
876 out_type);
877 SpvId var_id = spirv_builder_emit_var(&ctx->builder, pointer_type,
878 SpvStorageClassOutput);
879 char name[10];
880
881 snprintf(name, 10, "xfb%d", i);
882 spirv_builder_emit_name(&ctx->builder, var_id, name);
883 spirv_builder_emit_offset(&ctx->builder, var_id, (so_output.dst_offset * 4));
884 spirv_builder_emit_xfb_buffer(&ctx->builder, var_id, so_output.output_buffer);
885 spirv_builder_emit_xfb_stride(&ctx->builder, var_id, so_info->stride[so_output.output_buffer] * 4);
886
887 /* output location is incremented by VARYING_SLOT_VAR0 for non-builtins in vtn,
888 * so we need to ensure that the new xfb location slot doesn't conflict with any previously-emitted
889 * outputs.
890 *
891 * if there's no previous outputs that take up user slots (VAR0+) then we can start right after the
892 * glsl builtin reserved slots, otherwise we start just after the adjusted user output slot
893 */
894 uint32_t location = NTV_MIN_RESERVED_SLOTS + i;
895 if (max_output_location >= VARYING_SLOT_VAR0)
896 location = max_output_location - VARYING_SLOT_VAR0 + 1 + i;
897 assert(location < VARYING_SLOT_VAR0);
898 spirv_builder_emit_location(&ctx->builder, var_id, location);
899
900 /* note: gl_ClipDistance[4] can the 0-indexed member of VARYING_SLOT_CLIP_DIST1 here,
901 * so this is still the 0 component
902 */
903 if (so_output.start_component)
904 spirv_builder_emit_component(&ctx->builder, var_id, so_output.start_component);
905
906 uint32_t *key = ralloc_size(NULL, sizeof(uint32_t));
907 *key = (uint32_t)so_output.register_index << 2 | so_output.start_component;
908 _mesa_hash_table_insert(ctx->so_outputs, key, (void *)(intptr_t)var_id);
909
910 assert(ctx->num_entry_ifaces < ARRAY_SIZE(ctx->entry_ifaces));
911 ctx->entry_ifaces[ctx->num_entry_ifaces++] = var_id;
912 }
913 }
914
915 static void
916 emit_so_outputs(struct ntv_context *ctx,
917 const struct pipe_stream_output_info *so_info, struct pipe_stream_output_info *local_so_info)
918 {
919 SpvId loaded_outputs[VARYING_SLOT_MAX] = {};
920 for (unsigned i = 0; i < local_so_info->num_outputs; i++) {
921 uint32_t components[NIR_MAX_VEC_COMPONENTS];
922 struct pipe_stream_output so_output = local_so_info->output[i];
923 uint32_t so_key = (uint32_t) so_output.register_index << 2 | so_output.start_component;
924 struct hash_entry *he = _mesa_hash_table_search(ctx->so_outputs, &so_key);
925 assert(he);
926 SpvId so_output_var_id = (SpvId)(intptr_t)he->data;
927
928 SpvId type = get_output_type(ctx, so_output.register_index, so_output.num_components);
929 SpvId output = ctx->outputs[so_output.register_index];
930 SpvId output_type = ctx->so_output_types[so_output.register_index];
931 const struct glsl_type *out_type = ctx->so_output_gl_types[so_output.register_index];
932
933 if (!loaded_outputs[so_output.register_index])
934 loaded_outputs[so_output.register_index] = spirv_builder_emit_load(&ctx->builder, output_type, output);
935 SpvId src = loaded_outputs[so_output.register_index];
936
937 SpvId result;
938
939 for (unsigned c = 0; c < so_output.num_components; c++) {
940 components[c] = so_output.start_component + c;
941 /* this is the second half of a 2 * vec4 array */
942 if (ctx->stage == MESA_SHADER_VERTEX && so_output.register_index == VARYING_SLOT_CLIP_DIST1)
943 components[c] += 4;
944 }
945
946 /* if we're emitting a scalar or the type we're emitting matches the output's original type and we're
947 * emitting the same number of components, then we can skip any sort of conversion here
948 */
949 if (glsl_type_is_scalar(out_type) || (type == output_type && glsl_get_length(out_type) == so_output.num_components))
950 result = src;
951 else {
952 /* OpCompositeExtract can only extract scalars for our use here */
953 if (so_output.num_components == 1) {
954 result = spirv_builder_emit_composite_extract(&ctx->builder, type, src, components, so_output.num_components);
955 } else if (glsl_type_is_vector(out_type)) {
956 /* OpVectorShuffle can select vector members into a differently-sized vector */
957 result = spirv_builder_emit_vector_shuffle(&ctx->builder, type,
958 src, src,
959 components, so_output.num_components);
960 result = emit_unop(ctx, SpvOpBitcast, type, result);
961 } else {
962 /* for arrays, we need to manually extract each desired member
963 * and re-pack them into the desired output type
964 */
965 for (unsigned c = 0; c < so_output.num_components; c++) {
966 uint32_t member[] = { so_output.start_component + c };
967 SpvId base_type = get_glsl_type(ctx, glsl_without_array(out_type));
968
969 if (ctx->stage == MESA_SHADER_VERTEX && so_output.register_index == VARYING_SLOT_CLIP_DIST1)
970 member[0] += 4;
971 components[c] = spirv_builder_emit_composite_extract(&ctx->builder, base_type, src, member, 1);
972 }
973 result = spirv_builder_emit_composite_construct(&ctx->builder, type, components, so_output.num_components);
974 }
975 }
976
977 spirv_builder_emit_store(&ctx->builder, so_output_var_id, result);
978 }
979 }
980
981 static SpvId
982 emit_binop(struct ntv_context *ctx, SpvOp op, SpvId type,
983 SpvId src0, SpvId src1)
984 {
985 return spirv_builder_emit_binop(&ctx->builder, op, type, src0, src1);
986 }
987
988 static SpvId
989 emit_triop(struct ntv_context *ctx, SpvOp op, SpvId type,
990 SpvId src0, SpvId src1, SpvId src2)
991 {
992 return spirv_builder_emit_triop(&ctx->builder, op, type, src0, src1, src2);
993 }
994
995 static SpvId
996 emit_builtin_unop(struct ntv_context *ctx, enum GLSLstd450 op, SpvId type,
997 SpvId src)
998 {
999 SpvId args[] = { src };
1000 return spirv_builder_emit_ext_inst(&ctx->builder, type, ctx->GLSL_std_450,
1001 op, args, ARRAY_SIZE(args));
1002 }
1003
1004 static SpvId
1005 emit_builtin_binop(struct ntv_context *ctx, enum GLSLstd450 op, SpvId type,
1006 SpvId src0, SpvId src1)
1007 {
1008 SpvId args[] = { src0, src1 };
1009 return spirv_builder_emit_ext_inst(&ctx->builder, type, ctx->GLSL_std_450,
1010 op, args, ARRAY_SIZE(args));
1011 }
1012
1013 static SpvId
1014 emit_builtin_triop(struct ntv_context *ctx, enum GLSLstd450 op, SpvId type,
1015 SpvId src0, SpvId src1, SpvId src2)
1016 {
1017 SpvId args[] = { src0, src1, src2 };
1018 return spirv_builder_emit_ext_inst(&ctx->builder, type, ctx->GLSL_std_450,
1019 op, args, ARRAY_SIZE(args));
1020 }
1021
1022 static SpvId
1023 get_fvec_constant(struct ntv_context *ctx, unsigned bit_size,
1024 unsigned num_components, float value)
1025 {
1026 assert(bit_size == 32);
1027
1028 SpvId result = emit_float_const(ctx, bit_size, value);
1029 if (num_components == 1)
1030 return result;
1031
1032 assert(num_components > 1);
1033 SpvId components[num_components];
1034 for (int i = 0; i < num_components; i++)
1035 components[i] = result;
1036
1037 SpvId type = get_fvec_type(ctx, bit_size, num_components);
1038 return spirv_builder_const_composite(&ctx->builder, type, components,
1039 num_components);
1040 }
1041
1042 static SpvId
1043 get_uvec_constant(struct ntv_context *ctx, unsigned bit_size,
1044 unsigned num_components, uint32_t value)
1045 {
1046 assert(bit_size == 32);
1047
1048 SpvId result = emit_uint_const(ctx, bit_size, value);
1049 if (num_components == 1)
1050 return result;
1051
1052 assert(num_components > 1);
1053 SpvId components[num_components];
1054 for (int i = 0; i < num_components; i++)
1055 components[i] = result;
1056
1057 SpvId type = get_uvec_type(ctx, bit_size, num_components);
1058 return spirv_builder_const_composite(&ctx->builder, type, components,
1059 num_components);
1060 }
1061
1062 static SpvId
1063 get_ivec_constant(struct ntv_context *ctx, unsigned bit_size,
1064 unsigned num_components, int32_t value)
1065 {
1066 assert(bit_size == 32);
1067
1068 SpvId result = emit_int_const(ctx, bit_size, value);
1069 if (num_components == 1)
1070 return result;
1071
1072 assert(num_components > 1);
1073 SpvId components[num_components];
1074 for (int i = 0; i < num_components; i++)
1075 components[i] = result;
1076
1077 SpvId type = get_ivec_type(ctx, bit_size, num_components);
1078 return spirv_builder_const_composite(&ctx->builder, type, components,
1079 num_components);
1080 }
1081
1082 static inline unsigned
1083 alu_instr_src_components(const nir_alu_instr *instr, unsigned src)
1084 {
1085 if (nir_op_infos[instr->op].input_sizes[src] > 0)
1086 return nir_op_infos[instr->op].input_sizes[src];
1087
1088 if (instr->dest.dest.is_ssa)
1089 return instr->dest.dest.ssa.num_components;
1090 else
1091 return instr->dest.dest.reg.reg->num_components;
1092 }
1093
1094 static SpvId
1095 get_alu_src(struct ntv_context *ctx, nir_alu_instr *alu, unsigned src)
1096 {
1097 SpvId raw_value = get_alu_src_raw(ctx, alu, src);
1098
1099 unsigned num_components = alu_instr_src_components(alu, src);
1100 unsigned bit_size = nir_src_bit_size(alu->src[src].src);
1101 nir_alu_type type = nir_op_infos[alu->op].input_types[src];
1102
1103 if (bit_size == 1)
1104 return raw_value;
1105 else {
1106 switch (nir_alu_type_get_base_type(type)) {
1107 case nir_type_bool:
1108 unreachable("bool should have bit-size 1");
1109
1110 case nir_type_int:
1111 return bitcast_to_ivec(ctx, raw_value, bit_size, num_components);
1112
1113 case nir_type_uint:
1114 return raw_value;
1115
1116 case nir_type_float:
1117 return bitcast_to_fvec(ctx, raw_value, bit_size, num_components);
1118
1119 default:
1120 unreachable("unknown nir_alu_type");
1121 }
1122 }
1123 }
1124
1125 static SpvId
1126 store_alu_result(struct ntv_context *ctx, nir_alu_instr *alu, SpvId result)
1127 {
1128 assert(!alu->dest.saturate);
1129 return store_dest(ctx, &alu->dest.dest, result,
1130 nir_op_infos[alu->op].output_type);
1131 }
1132
1133 static SpvId
1134 get_dest_type(struct ntv_context *ctx, nir_dest *dest, nir_alu_type type)
1135 {
1136 unsigned num_components = nir_dest_num_components(*dest);
1137 unsigned bit_size = nir_dest_bit_size(*dest);
1138
1139 if (bit_size == 1)
1140 return get_bvec_type(ctx, num_components);
1141
1142 switch (nir_alu_type_get_base_type(type)) {
1143 case nir_type_bool:
1144 unreachable("bool should have bit-size 1");
1145
1146 case nir_type_int:
1147 return get_ivec_type(ctx, bit_size, num_components);
1148
1149 case nir_type_uint:
1150 return get_uvec_type(ctx, bit_size, num_components);
1151
1152 case nir_type_float:
1153 return get_fvec_type(ctx, bit_size, num_components);
1154
1155 default:
1156 unreachable("unsupported nir_alu_type");
1157 }
1158 }
1159
1160 static void
1161 emit_alu(struct ntv_context *ctx, nir_alu_instr *alu)
1162 {
1163 SpvId src[nir_op_infos[alu->op].num_inputs];
1164 unsigned in_bit_sizes[nir_op_infos[alu->op].num_inputs];
1165 for (unsigned i = 0; i < nir_op_infos[alu->op].num_inputs; i++) {
1166 src[i] = get_alu_src(ctx, alu, i);
1167 in_bit_sizes[i] = nir_src_bit_size(alu->src[i].src);
1168 }
1169
1170 SpvId dest_type = get_dest_type(ctx, &alu->dest.dest,
1171 nir_op_infos[alu->op].output_type);
1172 unsigned bit_size = nir_dest_bit_size(alu->dest.dest);
1173 unsigned num_components = nir_dest_num_components(alu->dest.dest);
1174
1175 SpvId result = 0;
1176 switch (alu->op) {
1177 case nir_op_mov:
1178 assert(nir_op_infos[alu->op].num_inputs == 1);
1179 result = src[0];
1180 break;
1181
1182 #define UNOP(nir_op, spirv_op) \
1183 case nir_op: \
1184 assert(nir_op_infos[alu->op].num_inputs == 1); \
1185 result = emit_unop(ctx, spirv_op, dest_type, src[0]); \
1186 break;
1187
1188 UNOP(nir_op_ineg, SpvOpSNegate)
1189 UNOP(nir_op_fneg, SpvOpFNegate)
1190 UNOP(nir_op_fddx, SpvOpDPdx)
1191 UNOP(nir_op_fddx_coarse, SpvOpDPdxCoarse)
1192 UNOP(nir_op_fddx_fine, SpvOpDPdxFine)
1193 UNOP(nir_op_fddy, SpvOpDPdy)
1194 UNOP(nir_op_fddy_coarse, SpvOpDPdyCoarse)
1195 UNOP(nir_op_fddy_fine, SpvOpDPdyFine)
1196 UNOP(nir_op_f2i32, SpvOpConvertFToS)
1197 UNOP(nir_op_f2u32, SpvOpConvertFToU)
1198 UNOP(nir_op_i2f32, SpvOpConvertSToF)
1199 UNOP(nir_op_u2f32, SpvOpConvertUToF)
1200 #undef UNOP
1201
1202 case nir_op_inot:
1203 if (bit_size == 1)
1204 result = emit_unop(ctx, SpvOpLogicalNot, dest_type, src[0]);
1205 else
1206 result = emit_unop(ctx, SpvOpNot, dest_type, src[0]);
1207 break;
1208
1209 case nir_op_b2i32:
1210 assert(nir_op_infos[alu->op].num_inputs == 1);
1211 result = emit_select(ctx, dest_type, src[0],
1212 get_ivec_constant(ctx, 32, num_components, 1),
1213 get_ivec_constant(ctx, 32, num_components, 0));
1214 break;
1215
1216 case nir_op_b2f32:
1217 assert(nir_op_infos[alu->op].num_inputs == 1);
1218 result = emit_select(ctx, dest_type, src[0],
1219 get_fvec_constant(ctx, 32, num_components, 1),
1220 get_fvec_constant(ctx, 32, num_components, 0));
1221 break;
1222
1223 #define BUILTIN_UNOP(nir_op, spirv_op) \
1224 case nir_op: \
1225 assert(nir_op_infos[alu->op].num_inputs == 1); \
1226 result = emit_builtin_unop(ctx, spirv_op, dest_type, src[0]); \
1227 break;
1228
1229 BUILTIN_UNOP(nir_op_iabs, GLSLstd450SAbs)
1230 BUILTIN_UNOP(nir_op_fabs, GLSLstd450FAbs)
1231 BUILTIN_UNOP(nir_op_fsqrt, GLSLstd450Sqrt)
1232 BUILTIN_UNOP(nir_op_frsq, GLSLstd450InverseSqrt)
1233 BUILTIN_UNOP(nir_op_flog2, GLSLstd450Log2)
1234 BUILTIN_UNOP(nir_op_fexp2, GLSLstd450Exp2)
1235 BUILTIN_UNOP(nir_op_ffract, GLSLstd450Fract)
1236 BUILTIN_UNOP(nir_op_ffloor, GLSLstd450Floor)
1237 BUILTIN_UNOP(nir_op_fceil, GLSLstd450Ceil)
1238 BUILTIN_UNOP(nir_op_ftrunc, GLSLstd450Trunc)
1239 BUILTIN_UNOP(nir_op_fround_even, GLSLstd450RoundEven)
1240 BUILTIN_UNOP(nir_op_fsign, GLSLstd450FSign)
1241 BUILTIN_UNOP(nir_op_fsin, GLSLstd450Sin)
1242 BUILTIN_UNOP(nir_op_fcos, GLSLstd450Cos)
1243 #undef BUILTIN_UNOP
1244
1245 case nir_op_frcp:
1246 assert(nir_op_infos[alu->op].num_inputs == 1);
1247 result = emit_binop(ctx, SpvOpFDiv, dest_type,
1248 get_fvec_constant(ctx, bit_size, num_components, 1),
1249 src[0]);
1250 break;
1251
1252 case nir_op_f2b1:
1253 assert(nir_op_infos[alu->op].num_inputs == 1);
1254 result = emit_binop(ctx, SpvOpFOrdNotEqual, dest_type, src[0],
1255 get_fvec_constant(ctx,
1256 nir_src_bit_size(alu->src[0].src),
1257 num_components, 0));
1258 break;
1259 case nir_op_i2b1:
1260 assert(nir_op_infos[alu->op].num_inputs == 1);
1261 result = emit_binop(ctx, SpvOpINotEqual, dest_type, src[0],
1262 get_ivec_constant(ctx,
1263 nir_src_bit_size(alu->src[0].src),
1264 num_components, 0));
1265 break;
1266
1267
1268 #define BINOP(nir_op, spirv_op) \
1269 case nir_op: \
1270 assert(nir_op_infos[alu->op].num_inputs == 2); \
1271 result = emit_binop(ctx, spirv_op, dest_type, src[0], src[1]); \
1272 break;
1273
1274 BINOP(nir_op_iadd, SpvOpIAdd)
1275 BINOP(nir_op_isub, SpvOpISub)
1276 BINOP(nir_op_imul, SpvOpIMul)
1277 BINOP(nir_op_idiv, SpvOpSDiv)
1278 BINOP(nir_op_udiv, SpvOpUDiv)
1279 BINOP(nir_op_umod, SpvOpUMod)
1280 BINOP(nir_op_fadd, SpvOpFAdd)
1281 BINOP(nir_op_fsub, SpvOpFSub)
1282 BINOP(nir_op_fmul, SpvOpFMul)
1283 BINOP(nir_op_fdiv, SpvOpFDiv)
1284 BINOP(nir_op_fmod, SpvOpFMod)
1285 BINOP(nir_op_ilt, SpvOpSLessThan)
1286 BINOP(nir_op_ige, SpvOpSGreaterThanEqual)
1287 BINOP(nir_op_uge, SpvOpUGreaterThanEqual)
1288 BINOP(nir_op_flt, SpvOpFOrdLessThan)
1289 BINOP(nir_op_fge, SpvOpFOrdGreaterThanEqual)
1290 BINOP(nir_op_feq, SpvOpFOrdEqual)
1291 BINOP(nir_op_fne, SpvOpFOrdNotEqual)
1292 BINOP(nir_op_ishl, SpvOpShiftLeftLogical)
1293 BINOP(nir_op_ishr, SpvOpShiftRightArithmetic)
1294 BINOP(nir_op_ushr, SpvOpShiftRightLogical)
1295 #undef BINOP
1296
1297 #define BINOP_LOG(nir_op, spv_op, spv_log_op) \
1298 case nir_op: \
1299 assert(nir_op_infos[alu->op].num_inputs == 2); \
1300 if (nir_src_bit_size(alu->src[0].src) == 1) \
1301 result = emit_binop(ctx, spv_log_op, dest_type, src[0], src[1]); \
1302 else \
1303 result = emit_binop(ctx, spv_op, dest_type, src[0], src[1]); \
1304 break;
1305
1306 BINOP_LOG(nir_op_iand, SpvOpBitwiseAnd, SpvOpLogicalAnd)
1307 BINOP_LOG(nir_op_ior, SpvOpBitwiseOr, SpvOpLogicalOr)
1308 BINOP_LOG(nir_op_ieq, SpvOpIEqual, SpvOpLogicalEqual)
1309 BINOP_LOG(nir_op_ine, SpvOpINotEqual, SpvOpLogicalNotEqual)
1310 #undef BINOP_LOG
1311
1312 #define BUILTIN_BINOP(nir_op, spirv_op) \
1313 case nir_op: \
1314 assert(nir_op_infos[alu->op].num_inputs == 2); \
1315 result = emit_builtin_binop(ctx, spirv_op, dest_type, src[0], src[1]); \
1316 break;
1317
1318 BUILTIN_BINOP(nir_op_fmin, GLSLstd450FMin)
1319 BUILTIN_BINOP(nir_op_fmax, GLSLstd450FMax)
1320 #undef BUILTIN_BINOP
1321
1322 case nir_op_fdot2:
1323 case nir_op_fdot3:
1324 case nir_op_fdot4:
1325 assert(nir_op_infos[alu->op].num_inputs == 2);
1326 result = emit_binop(ctx, SpvOpDot, dest_type, src[0], src[1]);
1327 break;
1328
1329 case nir_op_fdph:
1330 unreachable("should already be lowered away");
1331
1332 case nir_op_seq:
1333 case nir_op_sne:
1334 case nir_op_slt:
1335 case nir_op_sge: {
1336 assert(nir_op_infos[alu->op].num_inputs == 2);
1337 int num_components = nir_dest_num_components(alu->dest.dest);
1338 SpvId bool_type = get_bvec_type(ctx, num_components);
1339
1340 SpvId zero = emit_float_const(ctx, bit_size, 0.0f);
1341 SpvId one = emit_float_const(ctx, bit_size, 1.0f);
1342 if (num_components > 1) {
1343 SpvId zero_comps[num_components], one_comps[num_components];
1344 for (int i = 0; i < num_components; i++) {
1345 zero_comps[i] = zero;
1346 one_comps[i] = one;
1347 }
1348
1349 zero = spirv_builder_const_composite(&ctx->builder, dest_type,
1350 zero_comps, num_components);
1351 one = spirv_builder_const_composite(&ctx->builder, dest_type,
1352 one_comps, num_components);
1353 }
1354
1355 SpvOp op;
1356 switch (alu->op) {
1357 case nir_op_seq: op = SpvOpFOrdEqual; break;
1358 case nir_op_sne: op = SpvOpFOrdNotEqual; break;
1359 case nir_op_slt: op = SpvOpFOrdLessThan; break;
1360 case nir_op_sge: op = SpvOpFOrdGreaterThanEqual; break;
1361 default: unreachable("unexpected op");
1362 }
1363
1364 result = emit_binop(ctx, op, bool_type, src[0], src[1]);
1365 result = emit_select(ctx, dest_type, result, one, zero);
1366 }
1367 break;
1368
1369 case nir_op_flrp:
1370 assert(nir_op_infos[alu->op].num_inputs == 3);
1371 result = emit_builtin_triop(ctx, GLSLstd450FMix, dest_type,
1372 src[0], src[1], src[2]);
1373 break;
1374
1375 case nir_op_fcsel:
1376 result = emit_binop(ctx, SpvOpFOrdGreaterThan,
1377 get_bvec_type(ctx, num_components),
1378 src[0],
1379 get_fvec_constant(ctx,
1380 nir_src_bit_size(alu->src[0].src),
1381 num_components, 0));
1382 result = emit_select(ctx, dest_type, result, src[1], src[2]);
1383 break;
1384
1385 case nir_op_bcsel:
1386 assert(nir_op_infos[alu->op].num_inputs == 3);
1387 result = emit_select(ctx, dest_type, src[0], src[1], src[2]);
1388 break;
1389
1390 case nir_op_bany_fnequal2:
1391 case nir_op_bany_fnequal3:
1392 case nir_op_bany_fnequal4: {
1393 assert(nir_op_infos[alu->op].num_inputs == 2);
1394 assert(alu_instr_src_components(alu, 0) ==
1395 alu_instr_src_components(alu, 1));
1396 assert(in_bit_sizes[0] == in_bit_sizes[1]);
1397 /* The type of Operand 1 and Operand 2 must be a scalar or vector of floating-point type. */
1398 SpvOp op = in_bit_sizes[0] == 1 ? SpvOpLogicalNotEqual : SpvOpFOrdNotEqual;
1399 result = emit_binop(ctx, op,
1400 get_bvec_type(ctx, alu_instr_src_components(alu, 0)),
1401 src[0], src[1]);
1402 result = emit_unop(ctx, SpvOpAny, dest_type, result);
1403 break;
1404 }
1405
1406 case nir_op_ball_fequal2:
1407 case nir_op_ball_fequal3:
1408 case nir_op_ball_fequal4: {
1409 assert(nir_op_infos[alu->op].num_inputs == 2);
1410 assert(alu_instr_src_components(alu, 0) ==
1411 alu_instr_src_components(alu, 1));
1412 assert(in_bit_sizes[0] == in_bit_sizes[1]);
1413 /* The type of Operand 1 and Operand 2 must be a scalar or vector of floating-point type. */
1414 SpvOp op = in_bit_sizes[0] == 1 ? SpvOpLogicalEqual : SpvOpFOrdEqual;
1415 result = emit_binop(ctx, op,
1416 get_bvec_type(ctx, alu_instr_src_components(alu, 0)),
1417 src[0], src[1]);
1418 result = emit_unop(ctx, SpvOpAll, dest_type, result);
1419 break;
1420 }
1421
1422 case nir_op_bany_inequal2:
1423 case nir_op_bany_inequal3:
1424 case nir_op_bany_inequal4: {
1425 assert(nir_op_infos[alu->op].num_inputs == 2);
1426 assert(alu_instr_src_components(alu, 0) ==
1427 alu_instr_src_components(alu, 1));
1428 assert(in_bit_sizes[0] == in_bit_sizes[1]);
1429 /* The type of Operand 1 and Operand 2 must be a scalar or vector of integer type. */
1430 SpvOp op = in_bit_sizes[0] == 1 ? SpvOpLogicalNotEqual : SpvOpINotEqual;
1431 result = emit_binop(ctx, op,
1432 get_bvec_type(ctx, alu_instr_src_components(alu, 0)),
1433 src[0], src[1]);
1434 result = emit_unop(ctx, SpvOpAny, dest_type, result);
1435 break;
1436 }
1437
1438 case nir_op_ball_iequal2:
1439 case nir_op_ball_iequal3:
1440 case nir_op_ball_iequal4: {
1441 assert(nir_op_infos[alu->op].num_inputs == 2);
1442 assert(alu_instr_src_components(alu, 0) ==
1443 alu_instr_src_components(alu, 1));
1444 assert(in_bit_sizes[0] == in_bit_sizes[1]);
1445 /* The type of Operand 1 and Operand 2 must be a scalar or vector of integer type. */
1446 SpvOp op = in_bit_sizes[0] == 1 ? SpvOpLogicalEqual : SpvOpIEqual;
1447 result = emit_binop(ctx, op,
1448 get_bvec_type(ctx, alu_instr_src_components(alu, 0)),
1449 src[0], src[1]);
1450 result = emit_unop(ctx, SpvOpAll, dest_type, result);
1451 break;
1452 }
1453
1454 case nir_op_vec2:
1455 case nir_op_vec3:
1456 case nir_op_vec4: {
1457 int num_inputs = nir_op_infos[alu->op].num_inputs;
1458 assert(2 <= num_inputs && num_inputs <= 4);
1459 result = spirv_builder_emit_composite_construct(&ctx->builder, dest_type,
1460 src, num_inputs);
1461 }
1462 break;
1463
1464 default:
1465 fprintf(stderr, "emit_alu: not implemented (%s)\n",
1466 nir_op_infos[alu->op].name);
1467
1468 unreachable("unsupported opcode");
1469 return;
1470 }
1471
1472 store_alu_result(ctx, alu, result);
1473 }
1474
1475 static void
1476 emit_load_const(struct ntv_context *ctx, nir_load_const_instr *load_const)
1477 {
1478 unsigned bit_size = load_const->def.bit_size;
1479 unsigned num_components = load_const->def.num_components;
1480
1481 SpvId constant;
1482 if (num_components > 1) {
1483 SpvId components[num_components];
1484 SpvId type;
1485 if (bit_size == 1) {
1486 for (int i = 0; i < num_components; i++)
1487 components[i] = spirv_builder_const_bool(&ctx->builder,
1488 load_const->value[i].b);
1489
1490 type = get_bvec_type(ctx, num_components);
1491 } else {
1492 for (int i = 0; i < num_components; i++)
1493 components[i] = emit_uint_const(ctx, bit_size,
1494 load_const->value[i].u32);
1495
1496 type = get_uvec_type(ctx, bit_size, num_components);
1497 }
1498 constant = spirv_builder_const_composite(&ctx->builder, type,
1499 components, num_components);
1500 } else {
1501 assert(num_components == 1);
1502 if (bit_size == 1)
1503 constant = spirv_builder_const_bool(&ctx->builder,
1504 load_const->value[0].b);
1505 else
1506 constant = emit_uint_const(ctx, bit_size, load_const->value[0].u32);
1507 }
1508
1509 store_ssa_def(ctx, &load_const->def, constant);
1510 }
1511
1512 static void
1513 emit_load_ubo(struct ntv_context *ctx, nir_intrinsic_instr *intr)
1514 {
1515 nir_const_value *const_block_index = nir_src_as_const_value(intr->src[0]);
1516 assert(const_block_index); // no dynamic indexing for now
1517 assert(const_block_index->u32 == 0); // we only support the default UBO for now
1518
1519 nir_const_value *const_offset = nir_src_as_const_value(intr->src[1]);
1520 if (const_offset) {
1521 SpvId uvec4_type = get_uvec_type(ctx, 32, 4);
1522 SpvId pointer_type = spirv_builder_type_pointer(&ctx->builder,
1523 SpvStorageClassUniform,
1524 uvec4_type);
1525
1526 unsigned idx = const_offset->u32;
1527 SpvId member = emit_uint_const(ctx, 32, 0);
1528 SpvId offset = emit_uint_const(ctx, 32, idx);
1529 SpvId offsets[] = { member, offset };
1530 SpvId ptr = spirv_builder_emit_access_chain(&ctx->builder, pointer_type,
1531 ctx->ubos[0], offsets,
1532 ARRAY_SIZE(offsets));
1533 SpvId result = spirv_builder_emit_load(&ctx->builder, uvec4_type, ptr);
1534
1535 SpvId type = get_dest_uvec_type(ctx, &intr->dest);
1536 unsigned num_components = nir_dest_num_components(intr->dest);
1537 if (num_components == 1) {
1538 uint32_t components[] = { 0 };
1539 result = spirv_builder_emit_composite_extract(&ctx->builder,
1540 type,
1541 result, components,
1542 1);
1543 } else if (num_components < 4) {
1544 SpvId constituents[num_components];
1545 SpvId uint_type = spirv_builder_type_uint(&ctx->builder, 32);
1546 for (uint32_t i = 0; i < num_components; ++i)
1547 constituents[i] = spirv_builder_emit_composite_extract(&ctx->builder,
1548 uint_type,
1549 result, &i,
1550 1);
1551
1552 result = spirv_builder_emit_composite_construct(&ctx->builder,
1553 type,
1554 constituents,
1555 num_components);
1556 }
1557
1558 if (nir_dest_bit_size(intr->dest) == 1)
1559 result = uvec_to_bvec(ctx, result, num_components);
1560
1561 store_dest(ctx, &intr->dest, result, nir_type_uint);
1562 } else
1563 unreachable("uniform-addressing not yet supported");
1564 }
1565
1566 static void
1567 emit_discard(struct ntv_context *ctx, nir_intrinsic_instr *intr)
1568 {
1569 assert(ctx->block_started);
1570 spirv_builder_emit_kill(&ctx->builder);
1571 /* discard is weird in NIR, so let's just create an unreachable block after
1572 it and hope that the vulkan driver will DCE any instructinos in it. */
1573 spirv_builder_label(&ctx->builder, spirv_builder_new_id(&ctx->builder));
1574 }
1575
1576 static void
1577 emit_load_deref(struct ntv_context *ctx, nir_intrinsic_instr *intr)
1578 {
1579 SpvId ptr = get_src(ctx, intr->src);
1580
1581 nir_variable *var = nir_intrinsic_get_var(intr, 0);
1582 SpvId result = spirv_builder_emit_load(&ctx->builder,
1583 get_glsl_type(ctx, var->type),
1584 ptr);
1585 unsigned num_components = nir_dest_num_components(intr->dest);
1586 unsigned bit_size = nir_dest_bit_size(intr->dest);
1587 result = bitcast_to_uvec(ctx, result, bit_size, num_components);
1588 store_dest(ctx, &intr->dest, result, nir_type_uint);
1589 }
1590
1591 static void
1592 emit_store_deref(struct ntv_context *ctx, nir_intrinsic_instr *intr)
1593 {
1594 SpvId ptr = get_src(ctx, &intr->src[0]);
1595 SpvId src = get_src(ctx, &intr->src[1]);
1596
1597 nir_variable *var = nir_intrinsic_get_var(intr, 0);
1598 SpvId type = get_glsl_type(ctx, glsl_without_array(var->type));
1599 SpvId result = emit_bitcast(ctx, type, src);
1600 spirv_builder_emit_store(&ctx->builder, ptr, result);
1601 }
1602
1603 static SpvId
1604 create_builtin_var(struct ntv_context *ctx, SpvId var_type,
1605 SpvStorageClass storage_class,
1606 const char *name, SpvBuiltIn builtin)
1607 {
1608 SpvId pointer_type = spirv_builder_type_pointer(&ctx->builder,
1609 storage_class,
1610 var_type);
1611 SpvId var = spirv_builder_emit_var(&ctx->builder, pointer_type,
1612 storage_class);
1613 spirv_builder_emit_name(&ctx->builder, var, name);
1614 spirv_builder_emit_builtin(&ctx->builder, var, builtin);
1615
1616 assert(ctx->num_entry_ifaces < ARRAY_SIZE(ctx->entry_ifaces));
1617 ctx->entry_ifaces[ctx->num_entry_ifaces++] = var;
1618 return var;
1619 }
1620
1621 static void
1622 emit_load_front_face(struct ntv_context *ctx, nir_intrinsic_instr *intr)
1623 {
1624 SpvId var_type = spirv_builder_type_bool(&ctx->builder);
1625 if (!ctx->front_face_var)
1626 ctx->front_face_var = create_builtin_var(ctx, var_type,
1627 SpvStorageClassInput,
1628 "gl_FrontFacing",
1629 SpvBuiltInFrontFacing);
1630
1631 SpvId result = spirv_builder_emit_load(&ctx->builder, var_type,
1632 ctx->front_face_var);
1633 assert(1 == nir_dest_num_components(intr->dest));
1634 store_dest(ctx, &intr->dest, result, nir_type_bool);
1635 }
1636
1637 static void
1638 emit_load_instance_id(struct ntv_context *ctx, nir_intrinsic_instr *intr)
1639 {
1640 SpvId var_type = spirv_builder_type_uint(&ctx->builder, 32);
1641 if (!ctx->instance_id_var)
1642 ctx->instance_id_var = create_builtin_var(ctx, var_type,
1643 SpvStorageClassInput,
1644 "gl_InstanceId",
1645 SpvBuiltInInstanceIndex);
1646
1647 SpvId result = spirv_builder_emit_load(&ctx->builder, var_type,
1648 ctx->instance_id_var);
1649 assert(1 == nir_dest_num_components(intr->dest));
1650 store_dest(ctx, &intr->dest, result, nir_type_uint);
1651 }
1652
1653 static void
1654 emit_load_vertex_id(struct ntv_context *ctx, nir_intrinsic_instr *intr)
1655 {
1656 SpvId var_type = spirv_builder_type_uint(&ctx->builder, 32);
1657 if (!ctx->vertex_id_var)
1658 ctx->vertex_id_var = create_builtin_var(ctx, var_type,
1659 SpvStorageClassInput,
1660 "gl_VertexID",
1661 SpvBuiltInVertexIndex);
1662
1663 SpvId result = spirv_builder_emit_load(&ctx->builder, var_type,
1664 ctx->vertex_id_var);
1665 assert(1 == nir_dest_num_components(intr->dest));
1666 store_dest(ctx, &intr->dest, result, nir_type_uint);
1667 }
1668
1669 static void
1670 emit_intrinsic(struct ntv_context *ctx, nir_intrinsic_instr *intr)
1671 {
1672 switch (intr->intrinsic) {
1673 case nir_intrinsic_load_ubo:
1674 emit_load_ubo(ctx, intr);
1675 break;
1676
1677 case nir_intrinsic_discard:
1678 emit_discard(ctx, intr);
1679 break;
1680
1681 case nir_intrinsic_load_deref:
1682 emit_load_deref(ctx, intr);
1683 break;
1684
1685 case nir_intrinsic_store_deref:
1686 emit_store_deref(ctx, intr);
1687 break;
1688
1689 case nir_intrinsic_load_front_face:
1690 emit_load_front_face(ctx, intr);
1691 break;
1692
1693 case nir_intrinsic_load_instance_id:
1694 emit_load_instance_id(ctx, intr);
1695 break;
1696
1697 case nir_intrinsic_load_vertex_id:
1698 emit_load_vertex_id(ctx, intr);
1699 break;
1700
1701 default:
1702 fprintf(stderr, "emit_intrinsic: not implemented (%s)\n",
1703 nir_intrinsic_infos[intr->intrinsic].name);
1704 unreachable("unsupported intrinsic");
1705 }
1706 }
1707
1708 static void
1709 emit_undef(struct ntv_context *ctx, nir_ssa_undef_instr *undef)
1710 {
1711 SpvId type = get_uvec_type(ctx, undef->def.bit_size,
1712 undef->def.num_components);
1713
1714 store_ssa_def(ctx, &undef->def,
1715 spirv_builder_emit_undef(&ctx->builder, type));
1716 }
1717
1718 static SpvId
1719 get_src_float(struct ntv_context *ctx, nir_src *src)
1720 {
1721 SpvId def = get_src(ctx, src);
1722 unsigned num_components = nir_src_num_components(*src);
1723 unsigned bit_size = nir_src_bit_size(*src);
1724 return bitcast_to_fvec(ctx, def, bit_size, num_components);
1725 }
1726
1727 static SpvId
1728 get_src_int(struct ntv_context *ctx, nir_src *src)
1729 {
1730 SpvId def = get_src(ctx, src);
1731 unsigned num_components = nir_src_num_components(*src);
1732 unsigned bit_size = nir_src_bit_size(*src);
1733 return bitcast_to_ivec(ctx, def, bit_size, num_components);
1734 }
1735
1736 static void
1737 emit_tex(struct ntv_context *ctx, nir_tex_instr *tex)
1738 {
1739 assert(tex->op == nir_texop_tex ||
1740 tex->op == nir_texop_txb ||
1741 tex->op == nir_texop_txl ||
1742 tex->op == nir_texop_txd ||
1743 tex->op == nir_texop_txf ||
1744 tex->op == nir_texop_txf_ms ||
1745 tex->op == nir_texop_txs);
1746 assert(tex->texture_index == tex->sampler_index);
1747
1748 SpvId coord = 0, proj = 0, bias = 0, lod = 0, dref = 0, dx = 0, dy = 0,
1749 offset = 0, sample = 0;
1750 unsigned coord_components = 0;
1751 for (unsigned i = 0; i < tex->num_srcs; i++) {
1752 switch (tex->src[i].src_type) {
1753 case nir_tex_src_coord:
1754 if (tex->op == nir_texop_txf ||
1755 tex->op == nir_texop_txf_ms)
1756 coord = get_src_int(ctx, &tex->src[i].src);
1757 else
1758 coord = get_src_float(ctx, &tex->src[i].src);
1759 coord_components = nir_src_num_components(tex->src[i].src);
1760 break;
1761
1762 case nir_tex_src_projector:
1763 assert(nir_src_num_components(tex->src[i].src) == 1);
1764 proj = get_src_float(ctx, &tex->src[i].src);
1765 assert(proj != 0);
1766 break;
1767
1768 case nir_tex_src_offset:
1769 offset = get_src_int(ctx, &tex->src[i].src);
1770 break;
1771
1772 case nir_tex_src_bias:
1773 assert(tex->op == nir_texop_txb);
1774 bias = get_src_float(ctx, &tex->src[i].src);
1775 assert(bias != 0);
1776 break;
1777
1778 case nir_tex_src_lod:
1779 assert(nir_src_num_components(tex->src[i].src) == 1);
1780 if (tex->op == nir_texop_txf ||
1781 tex->op == nir_texop_txf_ms ||
1782 tex->op == nir_texop_txs)
1783 lod = get_src_int(ctx, &tex->src[i].src);
1784 else
1785 lod = get_src_float(ctx, &tex->src[i].src);
1786 assert(lod != 0);
1787 break;
1788
1789 case nir_tex_src_ms_index:
1790 assert(nir_src_num_components(tex->src[i].src) == 1);
1791 sample = get_src_int(ctx, &tex->src[i].src);
1792 break;
1793
1794 case nir_tex_src_comparator:
1795 assert(nir_src_num_components(tex->src[i].src) == 1);
1796 dref = get_src_float(ctx, &tex->src[i].src);
1797 assert(dref != 0);
1798 break;
1799
1800 case nir_tex_src_ddx:
1801 dx = get_src_float(ctx, &tex->src[i].src);
1802 assert(dx != 0);
1803 break;
1804
1805 case nir_tex_src_ddy:
1806 dy = get_src_float(ctx, &tex->src[i].src);
1807 assert(dy != 0);
1808 break;
1809
1810 default:
1811 fprintf(stderr, "texture source: %d\n", tex->src[i].src_type);
1812 unreachable("unknown texture source");
1813 }
1814 }
1815
1816 if (lod == 0 && ctx->stage != MESA_SHADER_FRAGMENT) {
1817 lod = emit_float_const(ctx, 32, 0.0f);
1818 assert(lod != 0);
1819 }
1820
1821 SpvId image_type = ctx->image_types[tex->texture_index];
1822 SpvId sampled_type = spirv_builder_type_sampled_image(&ctx->builder,
1823 image_type);
1824
1825 assert(ctx->samplers_used & (1u << tex->texture_index));
1826 SpvId load = spirv_builder_emit_load(&ctx->builder, sampled_type,
1827 ctx->samplers[tex->texture_index]);
1828
1829 SpvId dest_type = get_dest_type(ctx, &tex->dest, tex->dest_type);
1830
1831 if (tex->op == nir_texop_txs) {
1832 SpvId image = spirv_builder_emit_image(&ctx->builder, image_type, load);
1833 SpvId result = spirv_builder_emit_image_query_size(&ctx->builder,
1834 dest_type, image,
1835 lod);
1836 store_dest(ctx, &tex->dest, result, tex->dest_type);
1837 return;
1838 }
1839
1840 if (proj && coord_components > 0) {
1841 SpvId constituents[coord_components + 1];
1842 if (coord_components == 1)
1843 constituents[0] = coord;
1844 else {
1845 assert(coord_components > 1);
1846 SpvId float_type = spirv_builder_type_float(&ctx->builder, 32);
1847 for (uint32_t i = 0; i < coord_components; ++i)
1848 constituents[i] = spirv_builder_emit_composite_extract(&ctx->builder,
1849 float_type,
1850 coord,
1851 &i, 1);
1852 }
1853
1854 constituents[coord_components++] = proj;
1855
1856 SpvId vec_type = get_fvec_type(ctx, 32, coord_components);
1857 coord = spirv_builder_emit_composite_construct(&ctx->builder,
1858 vec_type,
1859 constituents,
1860 coord_components);
1861 }
1862
1863 SpvId actual_dest_type = dest_type;
1864 if (dref)
1865 actual_dest_type = spirv_builder_type_float(&ctx->builder, 32);
1866
1867 SpvId result;
1868 if (tex->op == nir_texop_txf ||
1869 tex->op == nir_texop_txf_ms) {
1870 SpvId image = spirv_builder_emit_image(&ctx->builder, image_type, load);
1871 result = spirv_builder_emit_image_fetch(&ctx->builder, dest_type,
1872 image, coord, lod, sample);
1873 } else {
1874 result = spirv_builder_emit_image_sample(&ctx->builder,
1875 actual_dest_type, load,
1876 coord,
1877 proj != 0,
1878 lod, bias, dref, dx, dy,
1879 offset);
1880 }
1881
1882 spirv_builder_emit_decoration(&ctx->builder, result,
1883 SpvDecorationRelaxedPrecision);
1884
1885 if (dref && nir_dest_num_components(tex->dest) > 1) {
1886 SpvId components[4] = { result, result, result, result };
1887 result = spirv_builder_emit_composite_construct(&ctx->builder,
1888 dest_type,
1889 components,
1890 4);
1891 }
1892
1893 store_dest(ctx, &tex->dest, result, tex->dest_type);
1894 }
1895
1896 static void
1897 start_block(struct ntv_context *ctx, SpvId label)
1898 {
1899 /* terminate previous block if needed */
1900 if (ctx->block_started)
1901 spirv_builder_emit_branch(&ctx->builder, label);
1902
1903 /* start new block */
1904 spirv_builder_label(&ctx->builder, label);
1905 ctx->block_started = true;
1906 }
1907
1908 static void
1909 branch(struct ntv_context *ctx, SpvId label)
1910 {
1911 assert(ctx->block_started);
1912 spirv_builder_emit_branch(&ctx->builder, label);
1913 ctx->block_started = false;
1914 }
1915
1916 static void
1917 branch_conditional(struct ntv_context *ctx, SpvId condition, SpvId then_id,
1918 SpvId else_id)
1919 {
1920 assert(ctx->block_started);
1921 spirv_builder_emit_branch_conditional(&ctx->builder, condition,
1922 then_id, else_id);
1923 ctx->block_started = false;
1924 }
1925
1926 static void
1927 emit_jump(struct ntv_context *ctx, nir_jump_instr *jump)
1928 {
1929 switch (jump->type) {
1930 case nir_jump_break:
1931 assert(ctx->loop_break);
1932 branch(ctx, ctx->loop_break);
1933 break;
1934
1935 case nir_jump_continue:
1936 assert(ctx->loop_cont);
1937 branch(ctx, ctx->loop_cont);
1938 break;
1939
1940 default:
1941 unreachable("Unsupported jump type\n");
1942 }
1943 }
1944
1945 static void
1946 emit_deref_var(struct ntv_context *ctx, nir_deref_instr *deref)
1947 {
1948 assert(deref->deref_type == nir_deref_type_var);
1949
1950 struct hash_entry *he = _mesa_hash_table_search(ctx->vars, deref->var);
1951 assert(he);
1952 SpvId result = (SpvId)(intptr_t)he->data;
1953 store_dest_raw(ctx, &deref->dest, result);
1954 }
1955
1956 static void
1957 emit_deref_array(struct ntv_context *ctx, nir_deref_instr *deref)
1958 {
1959 assert(deref->deref_type == nir_deref_type_array);
1960 nir_variable *var = nir_deref_instr_get_variable(deref);
1961
1962 SpvStorageClass storage_class;
1963 switch (var->data.mode) {
1964 case nir_var_shader_in:
1965 storage_class = SpvStorageClassInput;
1966 break;
1967
1968 case nir_var_shader_out:
1969 storage_class = SpvStorageClassOutput;
1970 break;
1971
1972 default:
1973 unreachable("Unsupported nir_variable_mode\n");
1974 }
1975
1976 SpvId index = get_src(ctx, &deref->arr.index);
1977
1978 SpvId ptr_type = spirv_builder_type_pointer(&ctx->builder,
1979 storage_class,
1980 get_glsl_type(ctx, deref->type));
1981
1982 SpvId result = spirv_builder_emit_access_chain(&ctx->builder,
1983 ptr_type,
1984 get_src(ctx, &deref->parent),
1985 &index, 1);
1986 /* uint is a bit of a lie here, it's really just an opaque type */
1987 store_dest(ctx, &deref->dest, result, nir_type_uint);
1988 }
1989
1990 static void
1991 emit_deref(struct ntv_context *ctx, nir_deref_instr *deref)
1992 {
1993 switch (deref->deref_type) {
1994 case nir_deref_type_var:
1995 emit_deref_var(ctx, deref);
1996 break;
1997
1998 case nir_deref_type_array:
1999 emit_deref_array(ctx, deref);
2000 break;
2001
2002 default:
2003 unreachable("unexpected deref_type");
2004 }
2005 }
2006
2007 static void
2008 emit_block(struct ntv_context *ctx, struct nir_block *block)
2009 {
2010 start_block(ctx, block_label(ctx, block));
2011 nir_foreach_instr(instr, block) {
2012 switch (instr->type) {
2013 case nir_instr_type_alu:
2014 emit_alu(ctx, nir_instr_as_alu(instr));
2015 break;
2016 case nir_instr_type_intrinsic:
2017 emit_intrinsic(ctx, nir_instr_as_intrinsic(instr));
2018 break;
2019 case nir_instr_type_load_const:
2020 emit_load_const(ctx, nir_instr_as_load_const(instr));
2021 break;
2022 case nir_instr_type_ssa_undef:
2023 emit_undef(ctx, nir_instr_as_ssa_undef(instr));
2024 break;
2025 case nir_instr_type_tex:
2026 emit_tex(ctx, nir_instr_as_tex(instr));
2027 break;
2028 case nir_instr_type_phi:
2029 unreachable("nir_instr_type_phi not supported");
2030 break;
2031 case nir_instr_type_jump:
2032 emit_jump(ctx, nir_instr_as_jump(instr));
2033 break;
2034 case nir_instr_type_call:
2035 unreachable("nir_instr_type_call not supported");
2036 break;
2037 case nir_instr_type_parallel_copy:
2038 unreachable("nir_instr_type_parallel_copy not supported");
2039 break;
2040 case nir_instr_type_deref:
2041 emit_deref(ctx, nir_instr_as_deref(instr));
2042 break;
2043 }
2044 }
2045 }
2046
2047 static void
2048 emit_cf_list(struct ntv_context *ctx, struct exec_list *list);
2049
2050 static SpvId
2051 get_src_bool(struct ntv_context *ctx, nir_src *src)
2052 {
2053 assert(nir_src_bit_size(*src) == 1);
2054 return get_src(ctx, src);
2055 }
2056
2057 static void
2058 emit_if(struct ntv_context *ctx, nir_if *if_stmt)
2059 {
2060 SpvId condition = get_src_bool(ctx, &if_stmt->condition);
2061
2062 SpvId header_id = spirv_builder_new_id(&ctx->builder);
2063 SpvId then_id = block_label(ctx, nir_if_first_then_block(if_stmt));
2064 SpvId endif_id = spirv_builder_new_id(&ctx->builder);
2065 SpvId else_id = endif_id;
2066
2067 bool has_else = !exec_list_is_empty(&if_stmt->else_list);
2068 if (has_else) {
2069 assert(nir_if_first_else_block(if_stmt)->index < ctx->num_blocks);
2070 else_id = block_label(ctx, nir_if_first_else_block(if_stmt));
2071 }
2072
2073 /* create a header-block */
2074 start_block(ctx, header_id);
2075 spirv_builder_emit_selection_merge(&ctx->builder, endif_id,
2076 SpvSelectionControlMaskNone);
2077 branch_conditional(ctx, condition, then_id, else_id);
2078
2079 emit_cf_list(ctx, &if_stmt->then_list);
2080
2081 if (has_else) {
2082 if (ctx->block_started)
2083 branch(ctx, endif_id);
2084
2085 emit_cf_list(ctx, &if_stmt->else_list);
2086 }
2087
2088 start_block(ctx, endif_id);
2089 }
2090
2091 static void
2092 emit_loop(struct ntv_context *ctx, nir_loop *loop)
2093 {
2094 SpvId header_id = spirv_builder_new_id(&ctx->builder);
2095 SpvId begin_id = block_label(ctx, nir_loop_first_block(loop));
2096 SpvId break_id = spirv_builder_new_id(&ctx->builder);
2097 SpvId cont_id = spirv_builder_new_id(&ctx->builder);
2098
2099 /* create a header-block */
2100 start_block(ctx, header_id);
2101 spirv_builder_loop_merge(&ctx->builder, break_id, cont_id, SpvLoopControlMaskNone);
2102 branch(ctx, begin_id);
2103
2104 SpvId save_break = ctx->loop_break;
2105 SpvId save_cont = ctx->loop_cont;
2106 ctx->loop_break = break_id;
2107 ctx->loop_cont = cont_id;
2108
2109 emit_cf_list(ctx, &loop->body);
2110
2111 ctx->loop_break = save_break;
2112 ctx->loop_cont = save_cont;
2113
2114 branch(ctx, cont_id);
2115 start_block(ctx, cont_id);
2116 branch(ctx, header_id);
2117
2118 start_block(ctx, break_id);
2119 }
2120
2121 static void
2122 emit_cf_list(struct ntv_context *ctx, struct exec_list *list)
2123 {
2124 foreach_list_typed(nir_cf_node, node, node, list) {
2125 switch (node->type) {
2126 case nir_cf_node_block:
2127 emit_block(ctx, nir_cf_node_as_block(node));
2128 break;
2129
2130 case nir_cf_node_if:
2131 emit_if(ctx, nir_cf_node_as_if(node));
2132 break;
2133
2134 case nir_cf_node_loop:
2135 emit_loop(ctx, nir_cf_node_as_loop(node));
2136 break;
2137
2138 case nir_cf_node_function:
2139 unreachable("nir_cf_node_function not supported");
2140 break;
2141 }
2142 }
2143 }
2144
2145 struct spirv_shader *
2146 nir_to_spirv(struct nir_shader *s, const struct pipe_stream_output_info *so_info, struct pipe_stream_output_info *local_so_info)
2147 {
2148 struct spirv_shader *ret = NULL;
2149
2150 struct ntv_context ctx = {};
2151
2152 switch (s->info.stage) {
2153 case MESA_SHADER_VERTEX:
2154 case MESA_SHADER_FRAGMENT:
2155 case MESA_SHADER_COMPUTE:
2156 spirv_builder_emit_cap(&ctx.builder, SpvCapabilityShader);
2157 break;
2158
2159 case MESA_SHADER_TESS_CTRL:
2160 case MESA_SHADER_TESS_EVAL:
2161 spirv_builder_emit_cap(&ctx.builder, SpvCapabilityTessellation);
2162 break;
2163
2164 case MESA_SHADER_GEOMETRY:
2165 spirv_builder_emit_cap(&ctx.builder, SpvCapabilityGeometry);
2166 break;
2167
2168 default:
2169 unreachable("invalid stage");
2170 }
2171
2172 // TODO: only enable when needed
2173 if (s->info.stage == MESA_SHADER_FRAGMENT) {
2174 spirv_builder_emit_cap(&ctx.builder, SpvCapabilitySampled1D);
2175 spirv_builder_emit_cap(&ctx.builder, SpvCapabilityImageQuery);
2176 spirv_builder_emit_cap(&ctx.builder, SpvCapabilityDerivativeControl);
2177 }
2178
2179 ctx.stage = s->info.stage;
2180 ctx.GLSL_std_450 = spirv_builder_import(&ctx.builder, "GLSL.std.450");
2181 spirv_builder_emit_source(&ctx.builder, SpvSourceLanguageGLSL, 450);
2182
2183 spirv_builder_emit_mem_model(&ctx.builder, SpvAddressingModelLogical,
2184 SpvMemoryModelGLSL450);
2185
2186 SpvExecutionModel exec_model;
2187 switch (s->info.stage) {
2188 case MESA_SHADER_VERTEX:
2189 exec_model = SpvExecutionModelVertex;
2190 break;
2191 case MESA_SHADER_TESS_CTRL:
2192 exec_model = SpvExecutionModelTessellationControl;
2193 break;
2194 case MESA_SHADER_TESS_EVAL:
2195 exec_model = SpvExecutionModelTessellationEvaluation;
2196 break;
2197 case MESA_SHADER_GEOMETRY:
2198 exec_model = SpvExecutionModelGeometry;
2199 break;
2200 case MESA_SHADER_FRAGMENT:
2201 exec_model = SpvExecutionModelFragment;
2202 break;
2203 case MESA_SHADER_COMPUTE:
2204 exec_model = SpvExecutionModelGLCompute;
2205 break;
2206 default:
2207 unreachable("invalid stage");
2208 }
2209
2210 SpvId type_void = spirv_builder_type_void(&ctx.builder);
2211 SpvId type_main = spirv_builder_type_function(&ctx.builder, type_void,
2212 NULL, 0);
2213 SpvId entry_point = spirv_builder_new_id(&ctx.builder);
2214 spirv_builder_emit_name(&ctx.builder, entry_point, "main");
2215
2216 ctx.vars = _mesa_hash_table_create(NULL, _mesa_hash_pointer,
2217 _mesa_key_pointer_equal);
2218
2219 ctx.so_outputs = _mesa_hash_table_create(NULL, _mesa_hash_u32,
2220 _mesa_key_u32_equal);
2221
2222 nir_foreach_variable(var, &s->inputs)
2223 emit_input(&ctx, var);
2224
2225 nir_foreach_variable(var, &s->outputs)
2226 emit_output(&ctx, var);
2227
2228 if (so_info)
2229 emit_so_info(&ctx, util_last_bit64(s->info.outputs_written), so_info, local_so_info);
2230 nir_foreach_variable(var, &s->uniforms)
2231 emit_uniform(&ctx, var);
2232
2233 if (s->info.stage == MESA_SHADER_FRAGMENT) {
2234 spirv_builder_emit_exec_mode(&ctx.builder, entry_point,
2235 SpvExecutionModeOriginUpperLeft);
2236 if (s->info.outputs_written & BITFIELD64_BIT(FRAG_RESULT_DEPTH))
2237 spirv_builder_emit_exec_mode(&ctx.builder, entry_point,
2238 SpvExecutionModeDepthReplacing);
2239 }
2240
2241 if (so_info && so_info->num_outputs) {
2242 spirv_builder_emit_cap(&ctx.builder, SpvCapabilityTransformFeedback);
2243 spirv_builder_emit_exec_mode(&ctx.builder, entry_point,
2244 SpvExecutionModeXfb);
2245 }
2246
2247 spirv_builder_function(&ctx.builder, entry_point, type_void,
2248 SpvFunctionControlMaskNone,
2249 type_main);
2250
2251 nir_function_impl *entry = nir_shader_get_entrypoint(s);
2252 nir_metadata_require(entry, nir_metadata_block_index);
2253
2254 ctx.defs = (SpvId *)malloc(sizeof(SpvId) * entry->ssa_alloc);
2255 if (!ctx.defs)
2256 goto fail;
2257 ctx.num_defs = entry->ssa_alloc;
2258
2259 nir_index_local_regs(entry);
2260 ctx.regs = malloc(sizeof(SpvId) * entry->reg_alloc);
2261 if (!ctx.regs)
2262 goto fail;
2263 ctx.num_regs = entry->reg_alloc;
2264
2265 SpvId *block_ids = (SpvId *)malloc(sizeof(SpvId) * entry->num_blocks);
2266 if (!block_ids)
2267 goto fail;
2268
2269 for (int i = 0; i < entry->num_blocks; ++i)
2270 block_ids[i] = spirv_builder_new_id(&ctx.builder);
2271
2272 ctx.block_ids = block_ids;
2273 ctx.num_blocks = entry->num_blocks;
2274
2275 /* emit a block only for the variable declarations */
2276 start_block(&ctx, spirv_builder_new_id(&ctx.builder));
2277 foreach_list_typed(nir_register, reg, node, &entry->registers) {
2278 SpvId type = get_uvec_type(&ctx, reg->bit_size, reg->num_components);
2279 SpvId pointer_type = spirv_builder_type_pointer(&ctx.builder,
2280 SpvStorageClassFunction,
2281 type);
2282 SpvId var = spirv_builder_emit_var(&ctx.builder, pointer_type,
2283 SpvStorageClassFunction);
2284
2285 ctx.regs[reg->index] = var;
2286 }
2287
2288 emit_cf_list(&ctx, &entry->body);
2289
2290 free(ctx.defs);
2291
2292 if (so_info)
2293 emit_so_outputs(&ctx, so_info, local_so_info);
2294
2295 spirv_builder_return(&ctx.builder); // doesn't belong here, but whatevz
2296 spirv_builder_function_end(&ctx.builder);
2297
2298 spirv_builder_emit_entry_point(&ctx.builder, exec_model, entry_point,
2299 "main", ctx.entry_ifaces,
2300 ctx.num_entry_ifaces);
2301
2302 size_t num_words = spirv_builder_get_num_words(&ctx.builder);
2303
2304 ret = CALLOC_STRUCT(spirv_shader);
2305 if (!ret)
2306 goto fail;
2307
2308 ret->words = MALLOC(sizeof(uint32_t) * num_words);
2309 if (!ret->words)
2310 goto fail;
2311
2312 ret->num_words = spirv_builder_get_words(&ctx.builder, ret->words, num_words);
2313 assert(ret->num_words == num_words);
2314
2315 return ret;
2316
2317 fail:
2318
2319 if (ret)
2320 spirv_shader_delete(ret);
2321
2322 if (ctx.vars)
2323 _mesa_hash_table_destroy(ctx.vars, NULL);
2324
2325 if (ctx.so_outputs)
2326 _mesa_hash_table_destroy(ctx.so_outputs, NULL);
2327
2328 return NULL;
2329 }
2330
2331 void
2332 spirv_shader_delete(struct spirv_shader *s)
2333 {
2334 FREE(s->words);
2335 FREE(s);
2336 }