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