src/gallium/drivers/zink/nir_to_spirv/nir_to_spirv.c

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