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       SpvId type;
1062       if (bit_size == 1) {
1063          for (int i = 0; i < num_components; i++)
1064             components[i] = spirv_builder_const_bool(&ctx->builder,
1065                                                      load_const->value[i].b);
1066
1067          type = get_bvec_type(ctx, num_components);
1068       } else {
1069          for (int i = 0; i < num_components; i++)
1070             components[i] = emit_uint_const(ctx, bit_size,
1071                                             load_const->value[i].u32);
1072
1073          type = get_uvec_type(ctx, bit_size, num_components);
1074       }
1075       constant = spirv_builder_const_composite(&ctx->builder, type,
1076                                                components, num_components);
1077    } else {
1078       assert(num_components == 1);
1079       if (bit_size == 1)
1080          constant = spirv_builder_const_bool(&ctx->builder,
1081                                              load_const->value[0].b);
1082       else
1083          constant = emit_uint_const(ctx, bit_size, load_const->value[0].u32);
1084    }
1085
1086    if (bit_size == 1)
1087       constant = bvec_to_uvec(ctx, constant, num_components);
1088
1089    store_ssa_def_uint(ctx, &load_const->def, constant);
1090 }
1091
1092 static void
1093 emit_load_ubo(struct ntv_context *ctx, nir_intrinsic_instr *intr)
1094 {
1095    nir_const_value *const_block_index = nir_src_as_const_value(intr->src[0]);
1096    assert(const_block_index); // no dynamic indexing for now
1097    assert(const_block_index->u32 == 0); // we only support the default UBO for now
1098
1099    nir_const_value *const_offset = nir_src_as_const_value(intr->src[1]);
1100    if (const_offset) {
1101       SpvId uvec4_type = get_uvec_type(ctx, 32, 4);
1102       SpvId pointer_type = spirv_builder_type_pointer(&ctx->builder,
1103                                                       SpvStorageClassUniform,
1104                                                       uvec4_type);
1105
1106       unsigned idx = const_offset->u32;
1107       SpvId member = emit_uint_const(ctx, 32, 0);
1108       SpvId offset = emit_uint_const(ctx, 32, idx);
1109       SpvId offsets[] = { member, offset };
1110       SpvId ptr = spirv_builder_emit_access_chain(&ctx->builder, pointer_type,
1111                                                   ctx->ubos[0], offsets,
1112                                                   ARRAY_SIZE(offsets));
1113       SpvId result = spirv_builder_emit_load(&ctx->builder, uvec4_type, ptr);
1114
1115       SpvId type = get_dest_uvec_type(ctx, &intr->dest);
1116       unsigned num_components = nir_dest_num_components(intr->dest);
1117       if (num_components == 1) {
1118          uint32_t components[] = { 0 };
1119          result = spirv_builder_emit_composite_extract(&ctx->builder,
1120                                                        type,
1121                                                        result, components,
1122                                                        1);
1123       } else if (num_components < 4) {
1124          SpvId constituents[num_components];
1125          SpvId uint_type = spirv_builder_type_uint(&ctx->builder, 32);
1126          for (uint32_t i = 0; i < num_components; ++i)
1127             constituents[i] = spirv_builder_emit_composite_extract(&ctx->builder,
1128                                                                    uint_type,
1129                                                                    result, &i,
1130                                                                    1);
1131
1132          result = spirv_builder_emit_composite_construct(&ctx->builder,
1133                                                          type,
1134                                                          constituents,
1135                                                          num_components);
1136       }
1137
1138       store_dest_uint(ctx, &intr->dest, result);
1139    } else
1140       unreachable("uniform-addressing not yet supported");
1141 }
1142
1143 static void
1144 emit_discard(struct ntv_context *ctx, nir_intrinsic_instr *intr)
1145 {
1146    assert(ctx->block_started);
1147    spirv_builder_emit_kill(&ctx->builder);
1148    /* discard is weird in NIR, so let's just create an unreachable block after
1149       it and hope that the vulkan driver will DCE any instructinos in it. */
1150    spirv_builder_label(&ctx->builder, spirv_builder_new_id(&ctx->builder));
1151 }
1152
1153 static void
1154 emit_load_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);
1158
1159    nir_variable *var = nir_intrinsic_get_var(intr, 0);
1160    SpvId result = spirv_builder_emit_load(&ctx->builder,
1161                                           get_glsl_type(ctx, var->type),
1162                                           ptr);
1163    unsigned num_components = nir_dest_num_components(intr->dest);
1164    unsigned bit_size = nir_dest_bit_size(intr->dest);
1165    result = bitcast_to_uvec(ctx, result, bit_size, num_components);
1166    store_dest_uint(ctx, &intr->dest, result);
1167 }
1168
1169 static void
1170 emit_store_deref(struct ntv_context *ctx, nir_intrinsic_instr *intr)
1171 {
1172    /* uint is a bit of a lie here; it's really just a pointer */
1173    SpvId ptr = get_src_uint(ctx, &intr->src[0]);
1174    SpvId src = get_src_uint(ctx, &intr->src[1]);
1175
1176    nir_variable *var = nir_intrinsic_get_var(intr, 0);
1177    SpvId type = get_glsl_type(ctx, glsl_without_array(var->type));
1178    SpvId result = emit_bitcast(ctx, type, src);
1179    spirv_builder_emit_store(&ctx->builder, ptr, result);
1180 }
1181
1182 static void
1183 emit_load_front_face(struct ntv_context *ctx, nir_intrinsic_instr *intr)
1184 {
1185    SpvId var_type = get_glsl_type(ctx, glsl_bool_type());
1186    if (!ctx->front_face_var) {
1187       SpvId pointer_type = spirv_builder_type_pointer(&ctx->builder,
1188                                                       SpvStorageClassInput,
1189                                                       var_type);
1190       ctx->front_face_var = spirv_builder_emit_var(&ctx->builder,
1191                                                    pointer_type,
1192                                                    SpvStorageClassInput);
1193       spirv_builder_emit_name(&ctx->builder, ctx->front_face_var,
1194                               "gl_FrontFacing");
1195       spirv_builder_emit_builtin(&ctx->builder, ctx->front_face_var,
1196                                  SpvBuiltInFrontFacing);
1197
1198       assert(ctx->num_entry_ifaces < ARRAY_SIZE(ctx->entry_ifaces));
1199       ctx->entry_ifaces[ctx->num_entry_ifaces++] = ctx->front_face_var;
1200    }
1201
1202    SpvId result = spirv_builder_emit_load(&ctx->builder, var_type,
1203                                           ctx->front_face_var);
1204    assert(1 == nir_dest_num_components(intr->dest));
1205    result = bvec_to_uvec(ctx, result, 1);
1206    store_dest_uint(ctx, &intr->dest, result);
1207 }
1208
1209 static void
1210 emit_intrinsic(struct ntv_context *ctx, nir_intrinsic_instr *intr)
1211 {
1212    switch (intr->intrinsic) {
1213    case nir_intrinsic_load_ubo:
1214       emit_load_ubo(ctx, intr);
1215       break;
1216
1217    case nir_intrinsic_discard:
1218       emit_discard(ctx, intr);
1219       break;
1220
1221    case nir_intrinsic_load_deref:
1222       emit_load_deref(ctx, intr);
1223       break;
1224
1225    case nir_intrinsic_store_deref:
1226       emit_store_deref(ctx, intr);
1227       break;
1228
1229    case nir_intrinsic_load_front_face:
1230       emit_load_front_face(ctx, intr);
1231       break;
1232
1233    default:
1234       fprintf(stderr, "emit_intrinsic: not implemented (%s)\n",
1235               nir_intrinsic_infos[intr->intrinsic].name);
1236       unreachable("unsupported intrinsic");
1237    }
1238 }
1239
1240 static void
1241 emit_undef(struct ntv_context *ctx, nir_ssa_undef_instr *undef)
1242 {
1243    SpvId type = get_uvec_type(ctx, undef->def.bit_size,
1244                               undef->def.num_components);
1245
1246    store_ssa_def_uint(ctx, &undef->def,
1247                       spirv_builder_emit_undef(&ctx->builder, type));
1248 }
1249
1250 static SpvId
1251 get_src_float(struct ntv_context *ctx, nir_src *src)
1252 {
1253    SpvId def = get_src_uint(ctx, src);
1254    unsigned num_components = nir_src_num_components(*src);
1255    unsigned bit_size = nir_src_bit_size(*src);
1256    return bitcast_to_fvec(ctx, def, bit_size, num_components);
1257 }
1258
1259 static void
1260 emit_tex(struct ntv_context *ctx, nir_tex_instr *tex)
1261 {
1262    assert(tex->op == nir_texop_tex ||
1263           tex->op == nir_texop_txb ||
1264           tex->op == nir_texop_txl);
1265    assert(nir_alu_type_get_base_type(tex->dest_type) == nir_type_float);
1266    assert(tex->texture_index == tex->sampler_index);
1267
1268    SpvId coord = 0, proj = 0, bias = 0, lod = 0, dref = 0;
1269    unsigned coord_components;
1270    for (unsigned i = 0; i < tex->num_srcs; i++) {
1271       switch (tex->src[i].src_type) {
1272       case nir_tex_src_coord:
1273          coord = get_src_float(ctx, &tex->src[i].src);
1274          coord_components = nir_src_num_components(tex->src[i].src);
1275          break;
1276
1277       case nir_tex_src_projector:
1278          assert(nir_src_num_components(tex->src[i].src) == 1);
1279          proj = get_src_float(ctx, &tex->src[i].src);
1280          assert(proj != 0);
1281          break;
1282
1283       case nir_tex_src_bias:
1284          assert(tex->op == nir_texop_txb);
1285          bias = get_src_float(ctx, &tex->src[i].src);
1286          assert(bias != 0);
1287          break;
1288
1289       case nir_tex_src_lod:
1290          assert(nir_src_num_components(tex->src[i].src) == 1);
1291          lod = get_src_float(ctx, &tex->src[i].src);
1292          assert(lod != 0);
1293          break;
1294
1295       case nir_tex_src_comparator:
1296          assert(nir_src_num_components(tex->src[i].src) == 1);
1297          dref = get_src_float(ctx, &tex->src[i].src);
1298          assert(dref != 0);
1299          break;
1300
1301       default:
1302          fprintf(stderr, "texture source: %d\n", tex->src[i].src_type);
1303          unreachable("unknown texture source");
1304       }
1305    }
1306
1307    if (lod == 0 && ctx->stage != MESA_SHADER_FRAGMENT) {
1308       lod = emit_float_const(ctx, 32, 0.0f);
1309       assert(lod != 0);
1310    }
1311
1312    bool is_ms;
1313    SpvDim dimension = type_to_dim(tex->sampler_dim, &is_ms);
1314    SpvId float_type = spirv_builder_type_float(&ctx->builder, 32);
1315    SpvId image_type = spirv_builder_type_image(&ctx->builder, float_type,
1316                             dimension, false, tex->is_array, is_ms, 1,
1317                             SpvImageFormatUnknown);
1318    SpvId sampled_type = spirv_builder_type_sampled_image(&ctx->builder,
1319                                                          image_type);
1320
1321    assert(tex->texture_index < ctx->num_samplers);
1322    SpvId load = spirv_builder_emit_load(&ctx->builder, sampled_type,
1323                                         ctx->samplers[tex->texture_index]);
1324
1325    SpvId dest_type = get_dest_type(ctx, &tex->dest, tex->dest_type);
1326
1327    if (proj) {
1328       SpvId constituents[coord_components + 1];
1329       if (coord_components == 1)
1330          constituents[0] = coord;
1331       else {
1332          assert(coord_components > 1);
1333          SpvId float_type = spirv_builder_type_float(&ctx->builder, 32);
1334          for (uint32_t i = 0; i < coord_components; ++i)
1335             constituents[i] = spirv_builder_emit_composite_extract(&ctx->builder,
1336                                                  float_type,
1337                                                  coord,
1338                                                  &i, 1);
1339       }
1340
1341       constituents[coord_components++] = proj;
1342
1343       SpvId vec_type = get_fvec_type(ctx, 32, coord_components);
1344       coord = spirv_builder_emit_composite_construct(&ctx->builder,
1345                                                             vec_type,
1346                                                             constituents,
1347                                                             coord_components);
1348    }
1349
1350    SpvId actual_dest_type = dest_type;
1351    if (dref)
1352       actual_dest_type = float_type;
1353
1354    SpvId result = spirv_builder_emit_image_sample(&ctx->builder,
1355                                                   actual_dest_type, load,
1356                                                   coord,
1357                                                   proj != 0,
1358                                                   lod, bias, dref);
1359    spirv_builder_emit_decoration(&ctx->builder, result,
1360                                  SpvDecorationRelaxedPrecision);
1361
1362    if (dref) {
1363       SpvId components[4] = { result, result, result, result };
1364       result = spirv_builder_emit_composite_construct(&ctx->builder,
1365                                                       dest_type,
1366                                                       components,
1367                                                       4);
1368    }
1369
1370    store_dest(ctx, &tex->dest, result, tex->dest_type);
1371 }
1372
1373 static void
1374 start_block(struct ntv_context *ctx, SpvId label)
1375 {
1376    /* terminate previous block if needed */
1377    if (ctx->block_started)
1378       spirv_builder_emit_branch(&ctx->builder, label);
1379
1380    /* start new block */
1381    spirv_builder_label(&ctx->builder, label);
1382    ctx->block_started = true;
1383 }
1384
1385 static void
1386 branch(struct ntv_context *ctx, SpvId label)
1387 {
1388    assert(ctx->block_started);
1389    spirv_builder_emit_branch(&ctx->builder, label);
1390    ctx->block_started = false;
1391 }
1392
1393 static void
1394 branch_conditional(struct ntv_context *ctx, SpvId condition, SpvId then_id,
1395                    SpvId else_id)
1396 {
1397    assert(ctx->block_started);
1398    spirv_builder_emit_branch_conditional(&ctx->builder, condition,
1399                                          then_id, else_id);
1400    ctx->block_started = false;
1401 }
1402
1403 static void
1404 emit_jump(struct ntv_context *ctx, nir_jump_instr *jump)
1405 {
1406    switch (jump->type) {
1407    case nir_jump_break:
1408       assert(ctx->loop_break);
1409       branch(ctx, ctx->loop_break);
1410       break;
1411
1412    case nir_jump_continue:
1413       assert(ctx->loop_cont);
1414       branch(ctx, ctx->loop_cont);
1415       break;
1416
1417    default:
1418       unreachable("Unsupported jump type\n");
1419    }
1420 }
1421
1422 static void
1423 emit_deref_var(struct ntv_context *ctx, nir_deref_instr *deref)
1424 {
1425    assert(deref->deref_type == nir_deref_type_var);
1426
1427    struct hash_entry *he = _mesa_hash_table_search(ctx->vars, deref->var);
1428    assert(he);
1429    SpvId result = (SpvId)(intptr_t)he->data;
1430    /* uint is a bit of a lie here, it's really just an opaque type */
1431    store_dest_uint(ctx, &deref->dest, result);
1432 }
1433
1434 static void
1435 emit_deref_array(struct ntv_context *ctx, nir_deref_instr *deref)
1436 {
1437    assert(deref->deref_type == nir_deref_type_array);
1438    nir_variable *var = nir_deref_instr_get_variable(deref);
1439
1440    SpvStorageClass storage_class;
1441    switch (var->data.mode) {
1442    case nir_var_shader_in:
1443       storage_class = SpvStorageClassInput;
1444       break;
1445
1446    case nir_var_shader_out:
1447       storage_class = SpvStorageClassOutput;
1448       break;
1449
1450    default:
1451       unreachable("Unsupported nir_variable_mode\n");
1452    }
1453
1454    SpvId index = get_src_uint(ctx, &deref->arr.index);
1455
1456    SpvId ptr_type = spirv_builder_type_pointer(&ctx->builder,
1457                                                storage_class,
1458                                                get_glsl_type(ctx, deref->type));
1459
1460    SpvId result = spirv_builder_emit_access_chain(&ctx->builder,
1461                                                   ptr_type,
1462                                                   get_src_uint(ctx, &deref->parent),
1463                                                   &index, 1);
1464    /* uint is a bit of a lie here, it's really just an opaque type */
1465    store_dest_uint(ctx, &deref->dest, result);
1466 }
1467
1468 static void
1469 emit_deref(struct ntv_context *ctx, nir_deref_instr *deref)
1470 {
1471    switch (deref->deref_type) {
1472    case nir_deref_type_var:
1473       emit_deref_var(ctx, deref);
1474       break;
1475
1476    case nir_deref_type_array:
1477       emit_deref_array(ctx, deref);
1478       break;
1479
1480    default:
1481       unreachable("unexpected deref_type");
1482    }
1483 }
1484
1485 static void
1486 emit_block(struct ntv_context *ctx, struct nir_block *block)
1487 {
1488    start_block(ctx, block_label(ctx, block));
1489    nir_foreach_instr(instr, block) {
1490       switch (instr->type) {
1491       case nir_instr_type_alu:
1492          emit_alu(ctx, nir_instr_as_alu(instr));
1493          break;
1494       case nir_instr_type_intrinsic:
1495          emit_intrinsic(ctx, nir_instr_as_intrinsic(instr));
1496          break;
1497       case nir_instr_type_load_const:
1498          emit_load_const(ctx, nir_instr_as_load_const(instr));
1499          break;
1500       case nir_instr_type_ssa_undef:
1501          emit_undef(ctx, nir_instr_as_ssa_undef(instr));
1502          break;
1503       case nir_instr_type_tex:
1504          emit_tex(ctx, nir_instr_as_tex(instr));
1505          break;
1506       case nir_instr_type_phi:
1507          unreachable("nir_instr_type_phi not supported");
1508          break;
1509       case nir_instr_type_jump:
1510          emit_jump(ctx, nir_instr_as_jump(instr));
1511          break;
1512       case nir_instr_type_call:
1513          unreachable("nir_instr_type_call not supported");
1514          break;
1515       case nir_instr_type_parallel_copy:
1516          unreachable("nir_instr_type_parallel_copy not supported");
1517          break;
1518       case nir_instr_type_deref:
1519          emit_deref(ctx, nir_instr_as_deref(instr));
1520          break;
1521       }
1522    }
1523 }
1524
1525 static void
1526 emit_cf_list(struct ntv_context *ctx, struct exec_list *list);
1527
1528 static SpvId
1529 get_src_bool(struct ntv_context *ctx, nir_src *src)
1530 {
1531    SpvId def = get_src_uint(ctx, src);
1532    assert(nir_src_bit_size(*src) == 1);
1533    unsigned num_components = nir_src_num_components(*src);
1534    return uvec_to_bvec(ctx, def, num_components);
1535 }
1536
1537 static void
1538 emit_if(struct ntv_context *ctx, nir_if *if_stmt)
1539 {
1540    SpvId condition = get_src_bool(ctx, &if_stmt->condition);
1541
1542    SpvId header_id = spirv_builder_new_id(&ctx->builder);
1543    SpvId then_id = block_label(ctx, nir_if_first_then_block(if_stmt));
1544    SpvId endif_id = spirv_builder_new_id(&ctx->builder);
1545    SpvId else_id = endif_id;
1546
1547    bool has_else = !exec_list_is_empty(&if_stmt->else_list);
1548    if (has_else) {
1549       assert(nir_if_first_else_block(if_stmt)->index < ctx->num_blocks);
1550       else_id = block_label(ctx, nir_if_first_else_block(if_stmt));
1551    }
1552
1553    /* create a header-block */
1554    start_block(ctx, header_id);
1555    spirv_builder_emit_selection_merge(&ctx->builder, endif_id,
1556                                       SpvSelectionControlMaskNone);
1557    branch_conditional(ctx, condition, then_id, else_id);
1558
1559    emit_cf_list(ctx, &if_stmt->then_list);
1560
1561    if (has_else) {
1562       if (ctx->block_started)
1563          branch(ctx, endif_id);
1564
1565       emit_cf_list(ctx, &if_stmt->else_list);
1566    }
1567
1568    start_block(ctx, endif_id);
1569 }
1570
1571 static void
1572 emit_loop(struct ntv_context *ctx, nir_loop *loop)
1573 {
1574    SpvId header_id = spirv_builder_new_id(&ctx->builder);
1575    SpvId begin_id = block_label(ctx, nir_loop_first_block(loop));
1576    SpvId break_id = spirv_builder_new_id(&ctx->builder);
1577    SpvId cont_id = spirv_builder_new_id(&ctx->builder);
1578
1579    /* create a header-block */
1580    start_block(ctx, header_id);
1581    spirv_builder_loop_merge(&ctx->builder, break_id, cont_id, SpvLoopControlMaskNone);
1582    branch(ctx, begin_id);
1583
1584    SpvId save_break = ctx->loop_break;
1585    SpvId save_cont = ctx->loop_cont;
1586    ctx->loop_break = break_id;
1587    ctx->loop_cont = cont_id;
1588
1589    emit_cf_list(ctx, &loop->body);
1590
1591    ctx->loop_break = save_break;
1592    ctx->loop_cont = save_cont;
1593
1594    branch(ctx, cont_id);
1595    start_block(ctx, cont_id);
1596    branch(ctx, header_id);
1597
1598    start_block(ctx, break_id);
1599 }
1600
1601 static void
1602 emit_cf_list(struct ntv_context *ctx, struct exec_list *list)
1603 {
1604    foreach_list_typed(nir_cf_node, node, node, list) {
1605       switch (node->type) {
1606       case nir_cf_node_block:
1607          emit_block(ctx, nir_cf_node_as_block(node));
1608          break;
1609
1610       case nir_cf_node_if:
1611          emit_if(ctx, nir_cf_node_as_if(node));
1612          break;
1613
1614       case nir_cf_node_loop:
1615          emit_loop(ctx, nir_cf_node_as_loop(node));
1616          break;
1617
1618       case nir_cf_node_function:
1619          unreachable("nir_cf_node_function not supported");
1620          break;
1621       }
1622    }
1623 }
1624
1625 struct spirv_shader *
1626 nir_to_spirv(struct nir_shader *s)
1627 {
1628    struct spirv_shader *ret = NULL;
1629
1630    struct ntv_context ctx = {};
1631
1632    switch (s->info.stage) {
1633    case MESA_SHADER_VERTEX:
1634    case MESA_SHADER_FRAGMENT:
1635    case MESA_SHADER_COMPUTE:
1636       spirv_builder_emit_cap(&ctx.builder, SpvCapabilityShader);
1637       break;
1638
1639    case MESA_SHADER_TESS_CTRL:
1640    case MESA_SHADER_TESS_EVAL:
1641       spirv_builder_emit_cap(&ctx.builder, SpvCapabilityTessellation);
1642       break;
1643
1644    case MESA_SHADER_GEOMETRY:
1645       spirv_builder_emit_cap(&ctx.builder, SpvCapabilityGeometry);
1646       break;
1647
1648    default:
1649       unreachable("invalid stage");
1650    }
1651
1652    // TODO: only enable when needed
1653    if (s->info.stage == MESA_SHADER_FRAGMENT)
1654       spirv_builder_emit_cap(&ctx.builder, SpvCapabilitySampled1D);
1655
1656    ctx.stage = s->info.stage;
1657    ctx.GLSL_std_450 = spirv_builder_import(&ctx.builder, "GLSL.std.450");
1658    spirv_builder_emit_source(&ctx.builder, SpvSourceLanguageGLSL, 450);
1659
1660    spirv_builder_emit_mem_model(&ctx.builder, SpvAddressingModelLogical,
1661                                 SpvMemoryModelGLSL450);
1662
1663    SpvExecutionModel exec_model;
1664    switch (s->info.stage) {
1665    case MESA_SHADER_VERTEX:
1666       exec_model = SpvExecutionModelVertex;
1667       break;
1668    case MESA_SHADER_TESS_CTRL:
1669       exec_model = SpvExecutionModelTessellationControl;
1670       break;
1671    case MESA_SHADER_TESS_EVAL:
1672       exec_model = SpvExecutionModelTessellationEvaluation;
1673       break;
1674    case MESA_SHADER_GEOMETRY:
1675       exec_model = SpvExecutionModelGeometry;
1676       break;
1677    case MESA_SHADER_FRAGMENT:
1678       exec_model = SpvExecutionModelFragment;
1679       break;
1680    case MESA_SHADER_COMPUTE:
1681       exec_model = SpvExecutionModelGLCompute;
1682       break;
1683    default:
1684       unreachable("invalid stage");
1685    }
1686
1687    SpvId type_void = spirv_builder_type_void(&ctx.builder);
1688    SpvId type_main = spirv_builder_type_function(&ctx.builder, type_void,
1689                                                  NULL, 0);
1690    SpvId entry_point = spirv_builder_new_id(&ctx.builder);
1691    spirv_builder_emit_name(&ctx.builder, entry_point, "main");
1692
1693    ctx.vars = _mesa_hash_table_create(NULL, _mesa_hash_pointer,
1694                                       _mesa_key_pointer_equal);
1695
1696    nir_foreach_variable(var, &s->inputs)
1697       emit_input(&ctx, var);
1698
1699    nir_foreach_variable(var, &s->outputs)
1700       emit_output(&ctx, var);
1701
1702    nir_foreach_variable(var, &s->uniforms)
1703       emit_uniform(&ctx, var);
1704
1705    if (s->info.stage == MESA_SHADER_FRAGMENT) {
1706       spirv_builder_emit_exec_mode(&ctx.builder, entry_point,
1707                                    SpvExecutionModeOriginUpperLeft);
1708       if (s->info.outputs_written & BITFIELD64_BIT(FRAG_RESULT_DEPTH))
1709          spirv_builder_emit_exec_mode(&ctx.builder, entry_point,
1710                                       SpvExecutionModeDepthReplacing);
1711    }
1712
1713
1714    spirv_builder_function(&ctx.builder, entry_point, type_void,
1715                                             SpvFunctionControlMaskNone,
1716                                             type_main);
1717
1718    nir_function_impl *entry = nir_shader_get_entrypoint(s);
1719    nir_metadata_require(entry, nir_metadata_block_index);
1720
1721    ctx.defs = (SpvId *)malloc(sizeof(SpvId) * entry->ssa_alloc);
1722    if (!ctx.defs)
1723       goto fail;
1724    ctx.num_defs = entry->ssa_alloc;
1725
1726    nir_index_local_regs(entry);
1727    ctx.regs = malloc(sizeof(SpvId) * entry->reg_alloc);
1728    if (!ctx.regs)
1729       goto fail;
1730    ctx.num_regs = entry->reg_alloc;
1731
1732    SpvId *block_ids = (SpvId *)malloc(sizeof(SpvId) * entry->num_blocks);
1733    if (!block_ids)
1734       goto fail;
1735
1736    for (int i = 0; i < entry->num_blocks; ++i)
1737       block_ids[i] = spirv_builder_new_id(&ctx.builder);
1738
1739    ctx.block_ids = block_ids;
1740    ctx.num_blocks = entry->num_blocks;
1741
1742    /* emit a block only for the variable declarations */
1743    start_block(&ctx, spirv_builder_new_id(&ctx.builder));
1744    foreach_list_typed(nir_register, reg, node, &entry->registers) {
1745       SpvId type = get_uvec_type(&ctx, reg->bit_size, reg->num_components);
1746       SpvId pointer_type = spirv_builder_type_pointer(&ctx.builder,
1747                                                       SpvStorageClassFunction,
1748                                                       type);
1749       SpvId var = spirv_builder_emit_var(&ctx.builder, pointer_type,
1750                                          SpvStorageClassFunction);
1751
1752       ctx.regs[reg->index] = var;
1753    }
1754
1755    emit_cf_list(&ctx, &entry->body);
1756
1757    free(ctx.defs);
1758
1759    spirv_builder_return(&ctx.builder); // doesn't belong here, but whatevz
1760    spirv_builder_function_end(&ctx.builder);
1761
1762    spirv_builder_emit_entry_point(&ctx.builder, exec_model, entry_point,
1763                                   "main", ctx.entry_ifaces,
1764                                   ctx.num_entry_ifaces);
1765
1766    size_t num_words = spirv_builder_get_num_words(&ctx.builder);
1767
1768    ret = CALLOC_STRUCT(spirv_shader);
1769    if (!ret)
1770       goto fail;
1771
1772    ret->words = MALLOC(sizeof(uint32_t) * num_words);
1773    if (!ret->words)
1774       goto fail;
1775
1776    ret->num_words = spirv_builder_get_words(&ctx.builder, ret->words, num_words);
1777    assert(ret->num_words == num_words);
1778
1779    return ret;
1780
1781 fail:
1782
1783    if (ret)
1784       spirv_shader_delete(ret);
1785
1786    if (ctx.vars)
1787       _mesa_hash_table_destroy(ctx.vars, NULL);
1788
1789    return NULL;
1790 }
1791
1792 void
1793 spirv_shader_delete(struct spirv_shader *s)
1794 {
1795    FREE(s->words);
1796    FREE(s);
1797 }