src/compiler/spirv/vtn_variables.c

   1 /*
   2  * Copyright © 2015 Intel Corporation
   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  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
   8  * and/or sell copies of the Software, and to permit persons to whom the
   9  * 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 NONINFRINGEMENT.  IN NO EVENT SHALL
  18  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  19  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
  20  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
  21  * IN THE SOFTWARE.
  22  *
  23  * Authors:
  24  *    Jason Ekstrand (jason@jlekstrand.net)
  25  *
  26  */
  27
  28 #include "vtn_private.h"
  29 #include "spirv_info.h"
  30
  31 static struct vtn_access_chain *
  32 vtn_access_chain_create(struct vtn_builder *b, unsigned length)
  33 {
  34    struct vtn_access_chain *chain;
  35
  36    /* Subtract 1 from the length since there's already one built in */
  37    size_t size = sizeof(*chain) +
  38                  (MAX2(length, 1) - 1) * sizeof(chain->link[0]);
  39    chain = rzalloc_size(b, size);
  40    chain->length = length;
  41
  42    return chain;
  43 }
  44
  45 static struct vtn_access_chain *
  46 vtn_access_chain_extend(struct vtn_builder *b, struct vtn_access_chain *old,
  47                         unsigned new_ids)
  48 {
  49    struct vtn_access_chain *chain;
  50
  51    unsigned old_len = old ? old->length : 0;
  52    chain = vtn_access_chain_create(b, old_len + new_ids);
  53
  54    for (unsigned i = 0; i < old_len; i++)
  55       chain->link[i] = old->link[i];
  56
  57    return chain;
  58 }
  59
  60 static bool
  61 vtn_pointer_uses_ssa_offset(struct vtn_builder *b,
  62                             struct vtn_pointer *ptr)
  63 {
  64    return ptr->mode == vtn_variable_mode_ubo ||
  65           ptr->mode == vtn_variable_mode_ssbo ||
  66           (ptr->mode == vtn_variable_mode_workgroup &&
  67            b->options->lower_workgroup_access_to_offsets);
  68 }
  69
  70 static bool
  71 vtn_pointer_is_external_block(struct vtn_builder *b,
  72                               struct vtn_pointer *ptr)
  73 {
  74    return ptr->mode == vtn_variable_mode_ssbo ||
  75           ptr->mode == vtn_variable_mode_ubo ||
  76           ptr->mode == vtn_variable_mode_push_constant ||
  77           (ptr->mode == vtn_variable_mode_workgroup &&
  78            b->options->lower_workgroup_access_to_offsets);
  79 }
  80
  81 /* Dereference the given base pointer by the access chain */
  82 static struct vtn_pointer *
  83 vtn_access_chain_pointer_dereference(struct vtn_builder *b,
  84                                      struct vtn_pointer *base,
  85                                      struct vtn_access_chain *deref_chain)
  86 {
  87    struct vtn_access_chain *chain =
  88       vtn_access_chain_extend(b, base->chain, deref_chain->length);
  89    struct vtn_type *type = base->type;
  90
  91    /* OpPtrAccessChain is only allowed on things which support variable
  92     * pointers.  For everything else, the client is expected to just pass us
  93     * the right access chain.
  94     */
  95    vtn_assert(!deref_chain->ptr_as_array);
  96
  97    unsigned start = base->chain ? base->chain->length : 0;
  98    for (unsigned i = 0; i < deref_chain->length; i++) {
  99       chain->link[start + i] = deref_chain->link[i];
 100
 101       if (glsl_type_is_struct(type->type)) {
 102          vtn_assert(deref_chain->link[i].mode == vtn_access_mode_literal);
 103          type = type->members[deref_chain->link[i].id];
 104       } else {
 105          type = type->array_element;
 106       }
 107    }
 108
 109    struct vtn_pointer *ptr = rzalloc(b, struct vtn_pointer);
 110    ptr->mode = base->mode;
 111    ptr->type = type;
 112    ptr->var = base->var;
 113    ptr->chain = chain;
 114
 115    return ptr;
 116 }
 117
 118 static nir_ssa_def *
 119 vtn_access_link_as_ssa(struct vtn_builder *b, struct vtn_access_link link,
 120                        unsigned stride)
 121 {
 122    vtn_assert(stride > 0);
 123    if (link.mode == vtn_access_mode_literal) {
 124       return nir_imm_int(&b->nb, link.id * stride);
 125    } else if (stride == 1) {
 126        nir_ssa_def *ssa = vtn_ssa_value(b, link.id)->def;
 127        if (ssa->bit_size != 32)
 128           ssa = nir_u2u32(&b->nb, ssa);
 129       return ssa;
 130    } else {
 131       nir_ssa_def *src0 = vtn_ssa_value(b, link.id)->def;
 132       if (src0->bit_size != 32)
 133          src0 = nir_u2u32(&b->nb, src0);
 134       return nir_imul(&b->nb, src0, nir_imm_int(&b->nb, stride));
 135    }
 136 }
 137
 138 static nir_ssa_def *
 139 vtn_variable_resource_index(struct vtn_builder *b, struct vtn_variable *var,
 140                             nir_ssa_def *desc_array_index)
 141 {
 142    if (!desc_array_index) {
 143       vtn_assert(glsl_type_is_struct(var->type->type));
 144       desc_array_index = nir_imm_int(&b->nb, 0);
 145    }
 146
 147    nir_intrinsic_instr *instr =
 148       nir_intrinsic_instr_create(b->nb.shader,
 149                                  nir_intrinsic_vulkan_resource_index);
 150    instr->src[0] = nir_src_for_ssa(desc_array_index);
 151    nir_intrinsic_set_desc_set(instr, var->descriptor_set);
 152    nir_intrinsic_set_binding(instr, var->binding);
 153
 154    nir_ssa_dest_init(&instr->instr, &instr->dest, 1, 32, NULL);
 155    nir_builder_instr_insert(&b->nb, &instr->instr);
 156
 157    return &instr->dest.ssa;
 158 }
 159
 160 static nir_ssa_def *
 161 vtn_resource_reindex(struct vtn_builder *b, nir_ssa_def *base_index,
 162                      nir_ssa_def *offset_index)
 163 {
 164    nir_intrinsic_instr *instr =
 165       nir_intrinsic_instr_create(b->nb.shader,
 166                                  nir_intrinsic_vulkan_resource_reindex);
 167    instr->src[0] = nir_src_for_ssa(base_index);
 168    instr->src[1] = nir_src_for_ssa(offset_index);
 169
 170    nir_ssa_dest_init(&instr->instr, &instr->dest, 1, 32, NULL);
 171    nir_builder_instr_insert(&b->nb, &instr->instr);
 172
 173    return &instr->dest.ssa;
 174 }
 175
 176 static struct vtn_pointer *
 177 vtn_ssa_offset_pointer_dereference(struct vtn_builder *b,
 178                                    struct vtn_pointer *base,
 179                                    struct vtn_access_chain *deref_chain)
 180 {
 181    nir_ssa_def *block_index = base->block_index;
 182    nir_ssa_def *offset = base->offset;
 183    struct vtn_type *type = base->type;
 184
 185    unsigned idx = 0;
 186    if (base->mode == vtn_variable_mode_ubo ||
 187        base->mode == vtn_variable_mode_ssbo) {
 188       if (!block_index) {
 189          vtn_assert(base->var && base->type);
 190          nir_ssa_def *desc_arr_idx;
 191          if (glsl_type_is_array(type->type)) {
 192             if (deref_chain->length >= 1) {
 193                desc_arr_idx =
 194                   vtn_access_link_as_ssa(b, deref_chain->link[0], 1);
 195                idx++;
 196                /* This consumes a level of type */
 197                type = type->array_element;
 198             } else {
 199                /* This is annoying.  We've been asked for a pointer to the
 200                 * array of UBOs/SSBOs and not a specifc buffer.  Return a
 201                 * pointer with a descriptor index of 0 and we'll have to do
 202                 * a reindex later to adjust it to the right thing.
 203                 */
 204                desc_arr_idx = nir_imm_int(&b->nb, 0);
 205             }
 206          } else if (deref_chain->ptr_as_array) {
 207             /* You can't have a zero-length OpPtrAccessChain */
 208             vtn_assert(deref_chain->length >= 1);
 209             desc_arr_idx = vtn_access_link_as_ssa(b, deref_chain->link[0], 1);
 210          } else {
 211             /* We have a regular non-array SSBO. */
 212             desc_arr_idx = NULL;
 213          }
 214          block_index = vtn_variable_resource_index(b, base->var, desc_arr_idx);
 215       } else if (deref_chain->ptr_as_array &&
 216                  type->base_type == vtn_base_type_struct && type->block) {
 217          /* We are doing an OpPtrAccessChain on a pointer to a struct that is
 218           * decorated block.  This is an interesting corner in the SPIR-V
 219           * spec.  One interpretation would be that they client is clearly
 220           * trying to treat that block as if it's an implicit array of blocks
 221           * repeated in the buffer.  However, the SPIR-V spec for the
 222           * OpPtrAccessChain says:
 223           *
 224           *    "Base is treated as the address of the first element of an
 225           *    array, and the Element element’s address is computed to be the
 226           *    base for the Indexes, as per OpAccessChain."
 227           *
 228           * Taken literally, that would mean that your struct type is supposed
 229           * to be treated as an array of such a struct and, since it's
 230           * decorated block, that means an array of blocks which corresponds
 231           * to an array descriptor.  Therefore, we need to do a reindex
 232           * operation to add the index from the first link in the access chain
 233           * to the index we recieved.
 234           *
 235           * The downside to this interpretation (there always is one) is that
 236           * this might be somewhat surprising behavior to apps if they expect
 237           * the implicit array behavior described above.
 238           */
 239          vtn_assert(deref_chain->length >= 1);
 240          nir_ssa_def *offset_index =
 241             vtn_access_link_as_ssa(b, deref_chain->link[0], 1);
 242          idx++;
 243
 244          block_index = vtn_resource_reindex(b, block_index, offset_index);
 245       }
 246    }
 247
 248    if (!offset) {
 249       if (base->mode == vtn_variable_mode_workgroup) {
 250          /* SLM doesn't need nor have a block index */
 251          vtn_assert(!block_index);
 252
 253          /* We need the variable for the base offset */
 254          vtn_assert(base->var);
 255
 256          /* We need ptr_type for size and alignment */
 257          vtn_assert(base->ptr_type);
 258
 259          /* Assign location on first use so that we don't end up bloating SLM
 260           * address space for variables which are never statically used.
 261           */
 262          if (base->var->shared_location < 0) {
 263             vtn_assert(base->ptr_type->length > 0 && base->ptr_type->align > 0);
 264             b->shader->num_shared = vtn_align_u32(b->shader->num_shared,
 265                                                   base->ptr_type->align);
 266             base->var->shared_location = b->shader->num_shared;
 267             b->shader->num_shared += base->ptr_type->length;
 268          }
 269
 270          offset = nir_imm_int(&b->nb, base->var->shared_location);
 271       } else {
 272          /* The code above should have ensured a block_index when needed. */
 273          vtn_assert(block_index);
 274
 275          /* Start off with at the start of the buffer. */
 276          offset = nir_imm_int(&b->nb, 0);
 277       }
 278    }
 279
 280    if (deref_chain->ptr_as_array && idx == 0) {
 281       /* We need ptr_type for the stride */
 282       vtn_assert(base->ptr_type);
 283
 284       /* We need at least one element in the chain */
 285       vtn_assert(deref_chain->length >= 1);
 286
 287       nir_ssa_def *elem_offset =
 288          vtn_access_link_as_ssa(b, deref_chain->link[idx],
 289                                 base->ptr_type->stride);
 290       offset = nir_iadd(&b->nb, offset, elem_offset);
 291       idx++;
 292    }
 293
 294    for (; idx < deref_chain->length; idx++) {
 295       switch (glsl_get_base_type(type->type)) {
 296       case GLSL_TYPE_UINT:
 297       case GLSL_TYPE_INT:
 298       case GLSL_TYPE_UINT16:
 299       case GLSL_TYPE_INT16:
 300       case GLSL_TYPE_UINT64:
 301       case GLSL_TYPE_INT64:
 302       case GLSL_TYPE_FLOAT:
 303       case GLSL_TYPE_FLOAT16:
 304       case GLSL_TYPE_DOUBLE:
 305       case GLSL_TYPE_BOOL:
 306       case GLSL_TYPE_ARRAY: {
 307          nir_ssa_def *elem_offset =
 308             vtn_access_link_as_ssa(b, deref_chain->link[idx], type->stride);
 309          offset = nir_iadd(&b->nb, offset, elem_offset);
 310          type = type->array_element;
 311          break;
 312       }
 313
 314       case GLSL_TYPE_STRUCT: {
 315          vtn_assert(deref_chain->link[idx].mode == vtn_access_mode_literal);
 316          unsigned member = deref_chain->link[idx].id;
 317          nir_ssa_def *mem_offset = nir_imm_int(&b->nb, type->offsets[member]);
 318          offset = nir_iadd(&b->nb, offset, mem_offset);
 319          type = type->members[member];
 320          break;
 321       }
 322
 323       default:
 324          vtn_fail("Invalid type for deref");
 325       }
 326    }
 327
 328    struct vtn_pointer *ptr = rzalloc(b, struct vtn_pointer);
 329    ptr->mode = base->mode;
 330    ptr->type = type;
 331    ptr->block_index = block_index;
 332    ptr->offset = offset;
 333
 334    return ptr;
 335 }
 336
 337 /* Dereference the given base pointer by the access chain */
 338 static struct vtn_pointer *
 339 vtn_pointer_dereference(struct vtn_builder *b,
 340                         struct vtn_pointer *base,
 341                         struct vtn_access_chain *deref_chain)
 342 {
 343    if (vtn_pointer_uses_ssa_offset(b, base)) {
 344       return vtn_ssa_offset_pointer_dereference(b, base, deref_chain);
 345    } else {
 346       return vtn_access_chain_pointer_dereference(b, base, deref_chain);
 347    }
 348 }
 349
 350 /* Crawls a chain of array derefs and rewrites the types so that the
 351  * lengths stay the same but the terminal type is the one given by
 352  * tail_type.  This is useful for split structures.
 353  */
 354 static void
 355 rewrite_deref_types(struct vtn_builder *b, nir_deref *deref,
 356                     const struct glsl_type *type)
 357 {
 358    deref->type = type;
 359    if (deref->child) {
 360       vtn_assert(deref->child->deref_type == nir_deref_type_array);
 361       vtn_assert(glsl_type_is_array(deref->type));
 362       rewrite_deref_types(b, deref->child, glsl_get_array_element(type));
 363    }
 364 }
 365
 366 struct vtn_pointer *
 367 vtn_pointer_for_variable(struct vtn_builder *b,
 368                          struct vtn_variable *var, struct vtn_type *ptr_type)
 369 {
 370    struct vtn_pointer *pointer = rzalloc(b, struct vtn_pointer);
 371
 372    pointer->mode = var->mode;
 373    pointer->type = var->type;
 374    vtn_assert(ptr_type->base_type == vtn_base_type_pointer);
 375    vtn_assert(ptr_type->deref->type == var->type->type);
 376    pointer->ptr_type = ptr_type;
 377    pointer->var = var;
 378
 379    return pointer;
 380 }
 381
 382 nir_deref_var *
 383 vtn_pointer_to_deref(struct vtn_builder *b, struct vtn_pointer *ptr)
 384 {
 385    /* Do on-the-fly copy propagation for samplers. */
 386    if (ptr->var->copy_prop_sampler)
 387       return vtn_pointer_to_deref(b, ptr->var->copy_prop_sampler);
 388
 389    nir_deref_var *deref_var;
 390    if (ptr->var->var) {
 391       deref_var = nir_deref_var_create(b, ptr->var->var);
 392       /* Raw variable access */
 393       if (!ptr->chain)
 394          return deref_var;
 395    } else {
 396       vtn_assert(ptr->var->members);
 397       /* Create the deref_var manually.  It will get filled out later. */
 398       deref_var = rzalloc(b, nir_deref_var);
 399       deref_var->deref.deref_type = nir_deref_type_var;
 400    }
 401
 402    struct vtn_access_chain *chain = ptr->chain;
 403    vtn_assert(chain);
 404
 405    struct vtn_type *deref_type = ptr->var->type;
 406    nir_deref *tail = &deref_var->deref;
 407    nir_variable **members = ptr->var->members;
 408
 409    for (unsigned i = 0; i < chain->length; i++) {
 410       enum glsl_base_type base_type = glsl_get_base_type(deref_type->type);
 411       switch (base_type) {
 412       case GLSL_TYPE_UINT:
 413       case GLSL_TYPE_INT:
 414       case GLSL_TYPE_UINT16:
 415       case GLSL_TYPE_INT16:
 416       case GLSL_TYPE_UINT64:
 417       case GLSL_TYPE_INT64:
 418       case GLSL_TYPE_FLOAT:
 419       case GLSL_TYPE_FLOAT16:
 420       case GLSL_TYPE_DOUBLE:
 421       case GLSL_TYPE_BOOL:
 422       case GLSL_TYPE_ARRAY: {
 423          deref_type = deref_type->array_element;
 424
 425          nir_deref_array *deref_arr = nir_deref_array_create(b);
 426          deref_arr->deref.type = deref_type->type;
 427
 428          if (chain->link[i].mode == vtn_access_mode_literal) {
 429             deref_arr->deref_array_type = nir_deref_array_type_direct;
 430             deref_arr->base_offset = chain->link[i].id;
 431          } else {
 432             vtn_assert(chain->link[i].mode == vtn_access_mode_id);
 433             deref_arr->deref_array_type = nir_deref_array_type_indirect;
 434             deref_arr->base_offset = 0;
 435             deref_arr->indirect =
 436                nir_src_for_ssa(vtn_ssa_value(b, chain->link[i].id)->def);
 437          }
 438          tail->child = &deref_arr->deref;
 439          tail = tail->child;
 440          break;
 441       }
 442
 443       case GLSL_TYPE_STRUCT: {
 444          vtn_assert(chain->link[i].mode == vtn_access_mode_literal);
 445          unsigned idx = chain->link[i].id;
 446          deref_type = deref_type->members[idx];
 447          if (members) {
 448             /* This is a pre-split structure. */
 449             deref_var->var = members[idx];
 450             rewrite_deref_types(b, &deref_var->deref, members[idx]->type);
 451             vtn_assert(tail->type == deref_type->type);
 452             members = NULL;
 453          } else {
 454             nir_deref_struct *deref_struct = nir_deref_struct_create(b, idx);
 455             deref_struct->deref.type = deref_type->type;
 456             tail->child = &deref_struct->deref;
 457             tail = tail->child;
 458          }
 459          break;
 460       }
 461       default:
 462          vtn_fail("Invalid type for deref");
 463       }
 464    }
 465
 466    vtn_assert(members == NULL);
 467    return deref_var;
 468 }
 469
 470 static void
 471 _vtn_local_load_store(struct vtn_builder *b, bool load, nir_deref_var *deref,
 472                       nir_deref *tail, struct vtn_ssa_value *inout)
 473 {
 474    /* The deref tail may contain a deref to select a component of a vector (in
 475     * other words, it might not be an actual tail) so we have to save it away
 476     * here since we overwrite it later.
 477     */
 478    nir_deref *old_child = tail->child;
 479
 480    if (glsl_type_is_vector_or_scalar(tail->type)) {
 481       /* Terminate the deref chain in case there is one more link to pick
 482        * off a component of the vector.
 483        */
 484       tail->child = NULL;
 485
 486       nir_intrinsic_op op = load ? nir_intrinsic_load_var :
 487                                    nir_intrinsic_store_var;
 488
 489       nir_intrinsic_instr *intrin = nir_intrinsic_instr_create(b->shader, op);
 490       intrin->variables[0] = nir_deref_var_clone(deref, intrin);
 491       intrin->num_components = glsl_get_vector_elements(tail->type);
 492
 493       if (load) {
 494          nir_ssa_dest_init(&intrin->instr, &intrin->dest,
 495                            intrin->num_components,
 496                            glsl_get_bit_size(tail->type),
 497                            NULL);
 498          inout->def = &intrin->dest.ssa;
 499       } else {
 500          nir_intrinsic_set_write_mask(intrin, (1 << intrin->num_components) - 1);
 501          intrin->src[0] = nir_src_for_ssa(inout->def);
 502       }
 503
 504       nir_builder_instr_insert(&b->nb, &intrin->instr);
 505    } else if (glsl_get_base_type(tail->type) == GLSL_TYPE_ARRAY ||
 506               glsl_type_is_matrix(tail->type)) {
 507       unsigned elems = glsl_get_length(tail->type);
 508       nir_deref_array *deref_arr = nir_deref_array_create(b);
 509       deref_arr->deref_array_type = nir_deref_array_type_direct;
 510       deref_arr->deref.type = glsl_get_array_element(tail->type);
 511       tail->child = &deref_arr->deref;
 512       for (unsigned i = 0; i < elems; i++) {
 513          deref_arr->base_offset = i;
 514          _vtn_local_load_store(b, load, deref, tail->child, inout->elems[i]);
 515       }
 516    } else {
 517       vtn_assert(glsl_get_base_type(tail->type) == GLSL_TYPE_STRUCT);
 518       unsigned elems = glsl_get_length(tail->type);
 519       nir_deref_struct *deref_struct = nir_deref_struct_create(b, 0);
 520       tail->child = &deref_struct->deref;
 521       for (unsigned i = 0; i < elems; i++) {
 522          deref_struct->index = i;
 523          deref_struct->deref.type = glsl_get_struct_field(tail->type, i);
 524          _vtn_local_load_store(b, load, deref, tail->child, inout->elems[i]);
 525       }
 526    }
 527
 528    tail->child = old_child;
 529 }
 530
 531 nir_deref_var *
 532 vtn_nir_deref(struct vtn_builder *b, uint32_t id)
 533 {
 534    struct vtn_pointer *ptr = vtn_value(b, id, vtn_value_type_pointer)->pointer;
 535    return vtn_pointer_to_deref(b, ptr);
 536 }
 537
 538 /*
 539  * Gets the NIR-level deref tail, which may have as a child an array deref
 540  * selecting which component due to OpAccessChain supporting per-component
 541  * indexing in SPIR-V.
 542  */
 543 static nir_deref *
 544 get_deref_tail(nir_deref_var *deref)
 545 {
 546    nir_deref *cur = &deref->deref;
 547    while (!glsl_type_is_vector_or_scalar(cur->type) && cur->child)
 548       cur = cur->child;
 549
 550    return cur;
 551 }
 552
 553 struct vtn_ssa_value *
 554 vtn_local_load(struct vtn_builder *b, nir_deref_var *src)
 555 {
 556    nir_deref *src_tail = get_deref_tail(src);
 557    struct vtn_ssa_value *val = vtn_create_ssa_value(b, src_tail->type);
 558    _vtn_local_load_store(b, true, src, src_tail, val);
 559
 560    if (src_tail->child) {
 561       nir_deref_array *vec_deref = nir_deref_as_array(src_tail->child);
 562       vtn_assert(vec_deref->deref.child == NULL);
 563       val->type = vec_deref->deref.type;
 564       if (vec_deref->deref_array_type == nir_deref_array_type_direct)
 565          val->def = vtn_vector_extract(b, val->def, vec_deref->base_offset);
 566       else
 567          val->def = vtn_vector_extract_dynamic(b, val->def,
 568                                                vec_deref->indirect.ssa);
 569    }
 570
 571    return val;
 572 }
 573
 574 void
 575 vtn_local_store(struct vtn_builder *b, struct vtn_ssa_value *src,
 576                 nir_deref_var *dest)
 577 {
 578    nir_deref *dest_tail = get_deref_tail(dest);
 579
 580    if (dest_tail->child) {
 581       struct vtn_ssa_value *val = vtn_create_ssa_value(b, dest_tail->type);
 582       _vtn_local_load_store(b, true, dest, dest_tail, val);
 583       nir_deref_array *deref = nir_deref_as_array(dest_tail->child);
 584       vtn_assert(deref->deref.child == NULL);
 585       if (deref->deref_array_type == nir_deref_array_type_direct)
 586          val->def = vtn_vector_insert(b, val->def, src->def,
 587                                       deref->base_offset);
 588       else
 589          val->def = vtn_vector_insert_dynamic(b, val->def, src->def,
 590                                               deref->indirect.ssa);
 591       _vtn_local_load_store(b, false, dest, dest_tail, val);
 592    } else {
 593       _vtn_local_load_store(b, false, dest, dest_tail, src);
 594    }
 595 }
 596
 597 nir_ssa_def *
 598 vtn_pointer_to_offset(struct vtn_builder *b, struct vtn_pointer *ptr,
 599                       nir_ssa_def **index_out, unsigned *end_idx_out)
 600 {
 601    if (vtn_pointer_uses_ssa_offset(b, ptr)) {
 602       if (!ptr->offset) {
 603          struct vtn_access_chain chain = {
 604             .length = 0,
 605          };
 606          ptr = vtn_ssa_offset_pointer_dereference(b, ptr, &chain);
 607       }
 608       *index_out = ptr->block_index;
 609       return ptr->offset;
 610    }
 611
 612    vtn_assert(ptr->mode == vtn_variable_mode_push_constant);
 613    *index_out = NULL;
 614
 615    unsigned idx = 0;
 616    struct vtn_type *type = ptr->var->type;
 617    nir_ssa_def *offset = nir_imm_int(&b->nb, 0);
 618
 619    if (ptr->chain) {
 620       for (; idx < ptr->chain->length; idx++) {
 621          enum glsl_base_type base_type = glsl_get_base_type(type->type);
 622          switch (base_type) {
 623          case GLSL_TYPE_UINT:
 624          case GLSL_TYPE_INT:
 625          case GLSL_TYPE_UINT16:
 626          case GLSL_TYPE_INT16:
 627          case GLSL_TYPE_UINT64:
 628          case GLSL_TYPE_INT64:
 629          case GLSL_TYPE_FLOAT:
 630          case GLSL_TYPE_FLOAT16:
 631          case GLSL_TYPE_DOUBLE:
 632          case GLSL_TYPE_BOOL:
 633          case GLSL_TYPE_ARRAY:
 634             offset = nir_iadd(&b->nb, offset,
 635                               vtn_access_link_as_ssa(b, ptr->chain->link[idx],
 636                                                      type->stride));
 637
 638             type = type->array_element;
 639             break;
 640
 641          case GLSL_TYPE_STRUCT: {
 642             vtn_assert(ptr->chain->link[idx].mode == vtn_access_mode_literal);
 643             unsigned member = ptr->chain->link[idx].id;
 644             offset = nir_iadd(&b->nb, offset,
 645                               nir_imm_int(&b->nb, type->offsets[member]));
 646             type = type->members[member];
 647             break;
 648          }
 649
 650          default:
 651             vtn_fail("Invalid type for deref");
 652          }
 653       }
 654    }
 655
 656    vtn_assert(type == ptr->type);
 657    if (end_idx_out)
 658       *end_idx_out = idx;
 659
 660    return offset;
 661 }
 662
 663 /* Tries to compute the size of an interface block based on the strides and
 664  * offsets that are provided to us in the SPIR-V source.
 665  */
 666 static unsigned
 667 vtn_type_block_size(struct vtn_builder *b, struct vtn_type *type)
 668 {
 669    enum glsl_base_type base_type = glsl_get_base_type(type->type);
 670    switch (base_type) {
 671    case GLSL_TYPE_UINT:
 672    case GLSL_TYPE_INT:
 673    case GLSL_TYPE_UINT16:
 674    case GLSL_TYPE_INT16:
 675    case GLSL_TYPE_UINT64:
 676    case GLSL_TYPE_INT64:
 677    case GLSL_TYPE_FLOAT:
 678    case GLSL_TYPE_FLOAT16:
 679    case GLSL_TYPE_BOOL:
 680    case GLSL_TYPE_DOUBLE: {
 681       unsigned cols = type->row_major ? glsl_get_vector_elements(type->type) :
 682                                         glsl_get_matrix_columns(type->type);
 683       if (cols > 1) {
 684          vtn_assert(type->stride > 0);
 685          return type->stride * cols;
 686       } else {
 687          unsigned type_size = glsl_get_bit_size(type->type) / 8;
 688          return glsl_get_vector_elements(type->type) * type_size;
 689       }
 690    }
 691
 692    case GLSL_TYPE_STRUCT:
 693    case GLSL_TYPE_INTERFACE: {
 694       unsigned size = 0;
 695       unsigned num_fields = glsl_get_length(type->type);
 696       for (unsigned f = 0; f < num_fields; f++) {
 697          unsigned field_end = type->offsets[f] +
 698                               vtn_type_block_size(b, type->members[f]);
 699          size = MAX2(size, field_end);
 700       }
 701       return size;
 702    }
 703
 704    case GLSL_TYPE_ARRAY:
 705       vtn_assert(type->stride > 0);
 706       vtn_assert(glsl_get_length(type->type) > 0);
 707       return type->stride * glsl_get_length(type->type);
 708
 709    default:
 710       vtn_fail("Invalid block type");
 711       return 0;
 712    }
 713 }
 714
 715 static void
 716 vtn_access_chain_get_offset_size(struct vtn_builder *b,
 717                                  struct vtn_access_chain *chain,
 718                                  struct vtn_type *type,
 719                                  unsigned *access_offset,
 720                                  unsigned *access_size)
 721 {
 722    *access_offset = 0;
 723
 724    for (unsigned i = 0; i < chain->length; i++) {
 725       if (chain->link[i].mode != vtn_access_mode_literal)
 726          break;
 727
 728       if (glsl_type_is_struct(type->type)) {
 729          *access_offset += type->offsets[chain->link[i].id];
 730          type = type->members[chain->link[i].id];
 731       } else {
 732          *access_offset += type->stride * chain->link[i].id;
 733          type = type->array_element;
 734       }
 735    }
 736
 737    *access_size = vtn_type_block_size(b, type);
 738 }
 739
 740 static void
 741 _vtn_load_store_tail(struct vtn_builder *b, nir_intrinsic_op op, bool load,
 742                      nir_ssa_def *index, nir_ssa_def *offset,
 743                      unsigned access_offset, unsigned access_size,
 744                      struct vtn_ssa_value **inout, const struct glsl_type *type)
 745 {
 746    nir_intrinsic_instr *instr = nir_intrinsic_instr_create(b->nb.shader, op);
 747    instr->num_components = glsl_get_vector_elements(type);
 748
 749    int src = 0;
 750    if (!load) {
 751       nir_intrinsic_set_write_mask(instr, (1 << instr->num_components) - 1);
 752       instr->src[src++] = nir_src_for_ssa((*inout)->def);
 753    }
 754
 755    if (op == nir_intrinsic_load_push_constant) {
 756       vtn_assert(access_offset % 4 == 0);
 757
 758       nir_intrinsic_set_base(instr, access_offset);
 759       nir_intrinsic_set_range(instr, access_size);
 760    }
 761
 762    if (index)
 763       instr->src[src++] = nir_src_for_ssa(index);
 764
 765    if (op == nir_intrinsic_load_push_constant) {
 766       /* We need to subtract the offset from where the intrinsic will load the
 767        * data. */
 768       instr->src[src++] =
 769          nir_src_for_ssa(nir_isub(&b->nb, offset,
 770                                   nir_imm_int(&b->nb, access_offset)));
 771    } else {
 772       instr->src[src++] = nir_src_for_ssa(offset);
 773    }
 774
 775    if (load) {
 776       nir_ssa_dest_init(&instr->instr, &instr->dest,
 777                         instr->num_components,
 778                         glsl_get_bit_size(type), NULL);
 779       (*inout)->def = &instr->dest.ssa;
 780    }
 781
 782    nir_builder_instr_insert(&b->nb, &instr->instr);
 783
 784    if (load && glsl_get_base_type(type) == GLSL_TYPE_BOOL)
 785       (*inout)->def = nir_ine(&b->nb, (*inout)->def, nir_imm_int(&b->nb, 0));
 786 }
 787
 788 static void
 789 _vtn_block_load_store(struct vtn_builder *b, nir_intrinsic_op op, bool load,
 790                       nir_ssa_def *index, nir_ssa_def *offset,
 791                       unsigned access_offset, unsigned access_size,
 792                       struct vtn_access_chain *chain, unsigned chain_idx,
 793                       struct vtn_type *type, struct vtn_ssa_value **inout)
 794 {
 795    if (chain && chain_idx >= chain->length)
 796       chain = NULL;
 797
 798    if (load && chain == NULL && *inout == NULL)
 799       *inout = vtn_create_ssa_value(b, type->type);
 800
 801    enum glsl_base_type base_type = glsl_get_base_type(type->type);
 802    switch (base_type) {
 803    case GLSL_TYPE_UINT:
 804    case GLSL_TYPE_INT:
 805    case GLSL_TYPE_UINT16:
 806    case GLSL_TYPE_INT16:
 807    case GLSL_TYPE_UINT64:
 808    case GLSL_TYPE_INT64:
 809    case GLSL_TYPE_FLOAT:
 810    case GLSL_TYPE_FLOAT16:
 811    case GLSL_TYPE_DOUBLE:
 812    case GLSL_TYPE_BOOL:
 813       /* This is where things get interesting.  At this point, we've hit
 814        * a vector, a scalar, or a matrix.
 815        */
 816       if (glsl_type_is_matrix(type->type)) {
 817          /* Loading the whole matrix */
 818          struct vtn_ssa_value *transpose;
 819          unsigned num_ops, vec_width, col_stride;
 820          if (type->row_major) {
 821             num_ops = glsl_get_vector_elements(type->type);
 822             vec_width = glsl_get_matrix_columns(type->type);
 823             col_stride = type->array_element->stride;
 824             if (load) {
 825                const struct glsl_type *transpose_type =
 826                   glsl_matrix_type(base_type, vec_width, num_ops);
 827                *inout = vtn_create_ssa_value(b, transpose_type);
 828             } else {
 829                transpose = vtn_ssa_transpose(b, *inout);
 830                inout = &transpose;
 831             }
 832          } else {
 833             num_ops = glsl_get_matrix_columns(type->type);
 834             vec_width = glsl_get_vector_elements(type->type);
 835             col_stride = type->stride;
 836          }
 837
 838          for (unsigned i = 0; i < num_ops; i++) {
 839             nir_ssa_def *elem_offset =
 840                nir_iadd(&b->nb, offset, nir_imm_int(&b->nb, i * col_stride));
 841             _vtn_load_store_tail(b, op, load, index, elem_offset,
 842                                  access_offset, access_size,
 843                                  &(*inout)->elems[i],
 844                                  glsl_vector_type(base_type, vec_width));
 845          }
 846
 847          if (load && type->row_major)
 848             *inout = vtn_ssa_transpose(b, *inout);
 849       } else {
 850          unsigned elems = glsl_get_vector_elements(type->type);
 851          unsigned type_size = glsl_get_bit_size(type->type) / 8;
 852          if (elems == 1 || type->stride == type_size) {
 853             /* This is a tightly-packed normal scalar or vector load */
 854             vtn_assert(glsl_type_is_vector_or_scalar(type->type));
 855             _vtn_load_store_tail(b, op, load, index, offset,
 856                                  access_offset, access_size,
 857                                  inout, type->type);
 858          } else {
 859             /* This is a strided load.  We have to load N things separately.
 860              * This is the single column of a row-major matrix case.
 861              */
 862             vtn_assert(type->stride > type_size);
 863             vtn_assert(type->stride % type_size == 0);
 864
 865             nir_ssa_def *per_comp[4];
 866             for (unsigned i = 0; i < elems; i++) {
 867                nir_ssa_def *elem_offset =
 868                   nir_iadd(&b->nb, offset,
 869                                    nir_imm_int(&b->nb, i * type->stride));
 870                struct vtn_ssa_value *comp, temp_val;
 871                if (!load) {
 872                   temp_val.def = nir_channel(&b->nb, (*inout)->def, i);
 873                   temp_val.type = glsl_scalar_type(base_type);
 874                }
 875                comp = &temp_val;
 876                _vtn_load_store_tail(b, op, load, index, elem_offset,
 877                                     access_offset, access_size,
 878                                     &comp, glsl_scalar_type(base_type));
 879                per_comp[i] = comp->def;
 880             }
 881
 882             if (load) {
 883                if (*inout == NULL)
 884                   *inout = vtn_create_ssa_value(b, type->type);
 885                (*inout)->def = nir_vec(&b->nb, per_comp, elems);
 886             }
 887          }
 888       }
 889       return;
 890
 891    case GLSL_TYPE_ARRAY: {
 892       unsigned elems = glsl_get_length(type->type);
 893       for (unsigned i = 0; i < elems; i++) {
 894          nir_ssa_def *elem_off =
 895             nir_iadd(&b->nb, offset, nir_imm_int(&b->nb, i * type->stride));
 896          _vtn_block_load_store(b, op, load, index, elem_off,
 897                                access_offset, access_size,
 898                                NULL, 0,
 899                                type->array_element, &(*inout)->elems[i]);
 900       }
 901       return;
 902    }
 903
 904    case GLSL_TYPE_STRUCT: {
 905       unsigned elems = glsl_get_length(type->type);
 906       for (unsigned i = 0; i < elems; i++) {
 907          nir_ssa_def *elem_off =
 908             nir_iadd(&b->nb, offset, nir_imm_int(&b->nb, type->offsets[i]));
 909          _vtn_block_load_store(b, op, load, index, elem_off,
 910                                access_offset, access_size,
 911                                NULL, 0,
 912                                type->members[i], &(*inout)->elems[i]);
 913       }
 914       return;
 915    }
 916
 917    default:
 918       vtn_fail("Invalid block member type");
 919    }
 920 }
 921
 922 static struct vtn_ssa_value *
 923 vtn_block_load(struct vtn_builder *b, struct vtn_pointer *src)
 924 {
 925    nir_intrinsic_op op;
 926    unsigned access_offset = 0, access_size = 0;
 927    switch (src->mode) {
 928    case vtn_variable_mode_ubo:
 929       op = nir_intrinsic_load_ubo;
 930       break;
 931    case vtn_variable_mode_ssbo:
 932       op = nir_intrinsic_load_ssbo;
 933       break;
 934    case vtn_variable_mode_push_constant:
 935       op = nir_intrinsic_load_push_constant;
 936       vtn_access_chain_get_offset_size(b, src->chain, src->var->type,
 937                                        &access_offset, &access_size);
 938       break;
 939    case vtn_variable_mode_workgroup:
 940       op = nir_intrinsic_load_shared;
 941       break;
 942    default:
 943       vtn_fail("Invalid block variable mode");
 944    }
 945
 946    nir_ssa_def *offset, *index = NULL;
 947    unsigned chain_idx;
 948    offset = vtn_pointer_to_offset(b, src, &index, &chain_idx);
 949
 950    struct vtn_ssa_value *value = NULL;
 951    _vtn_block_load_store(b, op, true, index, offset,
 952                          access_offset, access_size,
 953                          src->chain, chain_idx, src->type, &value);
 954    return value;
 955 }
 956
 957 static void
 958 vtn_block_store(struct vtn_builder *b, struct vtn_ssa_value *src,
 959                 struct vtn_pointer *dst)
 960 {
 961    nir_intrinsic_op op;
 962    switch (dst->mode) {
 963    case vtn_variable_mode_ssbo:
 964       op = nir_intrinsic_store_ssbo;
 965       break;
 966    case vtn_variable_mode_workgroup:
 967       op = nir_intrinsic_store_shared;
 968       break;
 969    default:
 970       vtn_fail("Invalid block variable mode");
 971    }
 972
 973    nir_ssa_def *offset, *index = NULL;
 974    unsigned chain_idx;
 975    offset = vtn_pointer_to_offset(b, dst, &index, &chain_idx);
 976
 977    _vtn_block_load_store(b, op, false, index, offset,
 978                          0, 0, dst->chain, chain_idx, dst->type, &src);
 979 }
 980
 981 static void
 982 _vtn_variable_load_store(struct vtn_builder *b, bool load,
 983                          struct vtn_pointer *ptr,
 984                          struct vtn_ssa_value **inout)
 985 {
 986    enum glsl_base_type base_type = glsl_get_base_type(ptr->type->type);
 987    switch (base_type) {
 988    case GLSL_TYPE_UINT:
 989    case GLSL_TYPE_INT:
 990    case GLSL_TYPE_UINT16:
 991    case GLSL_TYPE_INT16:
 992    case GLSL_TYPE_UINT64:
 993    case GLSL_TYPE_INT64:
 994    case GLSL_TYPE_FLOAT:
 995    case GLSL_TYPE_FLOAT16:
 996    case GLSL_TYPE_BOOL:
 997    case GLSL_TYPE_DOUBLE:
 998       /* At this point, we have a scalar, vector, or matrix so we know that
 999        * there cannot be any structure splitting still in the way.  By
1000        * stopping at the matrix level rather than the vector level, we
1001        * ensure that matrices get loaded in the optimal way even if they
1002        * are storred row-major in a UBO.
1003        */
1004       if (load) {
1005          *inout = vtn_local_load(b, vtn_pointer_to_deref(b, ptr));
1006       } else {
1007          vtn_local_store(b, *inout, vtn_pointer_to_deref(b, ptr));
1008       }
1009       return;
1010
1011    case GLSL_TYPE_ARRAY:
1012    case GLSL_TYPE_STRUCT: {
1013       unsigned elems = glsl_get_length(ptr->type->type);
1014       if (load) {
1015          vtn_assert(*inout == NULL);
1016          *inout = rzalloc(b, struct vtn_ssa_value);
1017          (*inout)->type = ptr->type->type;
1018          (*inout)->elems = rzalloc_array(b, struct vtn_ssa_value *, elems);
1019       }
1020
1021       struct vtn_access_chain chain = {
1022          .length = 1,
1023          .link = {
1024             { .mode = vtn_access_mode_literal, },
1025          }
1026       };
1027       for (unsigned i = 0; i < elems; i++) {
1028          chain.link[0].id = i;
1029          struct vtn_pointer *elem = vtn_pointer_dereference(b, ptr, &chain);
1030          _vtn_variable_load_store(b, load, elem, &(*inout)->elems[i]);
1031       }
1032       return;
1033    }
1034
1035    default:
1036       vtn_fail("Invalid access chain type");
1037    }
1038 }
1039
1040 struct vtn_ssa_value *
1041 vtn_variable_load(struct vtn_builder *b, struct vtn_pointer *src)
1042 {
1043    if (vtn_pointer_is_external_block(b, src)) {
1044       return vtn_block_load(b, src);
1045    } else {
1046       struct vtn_ssa_value *val = NULL;
1047       _vtn_variable_load_store(b, true, src, &val);
1048       return val;
1049    }
1050 }
1051
1052 void
1053 vtn_variable_store(struct vtn_builder *b, struct vtn_ssa_value *src,
1054                    struct vtn_pointer *dest)
1055 {
1056    if (vtn_pointer_is_external_block(b, dest)) {
1057       vtn_assert(dest->mode == vtn_variable_mode_ssbo ||
1058                  dest->mode == vtn_variable_mode_workgroup);
1059       vtn_block_store(b, src, dest);
1060    } else {
1061       _vtn_variable_load_store(b, false, dest, &src);
1062    }
1063 }
1064
1065 static void
1066 _vtn_variable_copy(struct vtn_builder *b, struct vtn_pointer *dest,
1067                    struct vtn_pointer *src)
1068 {
1069    vtn_assert(src->type->type == dest->type->type);
1070    enum glsl_base_type base_type = glsl_get_base_type(src->type->type);
1071    switch (base_type) {
1072    case GLSL_TYPE_UINT:
1073    case GLSL_TYPE_INT:
1074    case GLSL_TYPE_UINT16:
1075    case GLSL_TYPE_INT16:
1076    case GLSL_TYPE_UINT64:
1077    case GLSL_TYPE_INT64:
1078    case GLSL_TYPE_FLOAT:
1079    case GLSL_TYPE_FLOAT16:
1080    case GLSL_TYPE_DOUBLE:
1081    case GLSL_TYPE_BOOL:
1082       /* At this point, we have a scalar, vector, or matrix so we know that
1083        * there cannot be any structure splitting still in the way.  By
1084        * stopping at the matrix level rather than the vector level, we
1085        * ensure that matrices get loaded in the optimal way even if they
1086        * are storred row-major in a UBO.
1087        */
1088       vtn_variable_store(b, vtn_variable_load(b, src), dest);
1089       return;
1090
1091    case GLSL_TYPE_ARRAY:
1092    case GLSL_TYPE_STRUCT: {
1093       struct vtn_access_chain chain = {
1094          .length = 1,
1095          .link = {
1096             { .mode = vtn_access_mode_literal, },
1097          }
1098       };
1099       unsigned elems = glsl_get_length(src->type->type);
1100       for (unsigned i = 0; i < elems; i++) {
1101          chain.link[0].id = i;
1102          struct vtn_pointer *src_elem =
1103             vtn_pointer_dereference(b, src, &chain);
1104          struct vtn_pointer *dest_elem =
1105             vtn_pointer_dereference(b, dest, &chain);
1106
1107          _vtn_variable_copy(b, dest_elem, src_elem);
1108       }
1109       return;
1110    }
1111
1112    default:
1113       vtn_fail("Invalid access chain type");
1114    }
1115 }
1116
1117 static void
1118 vtn_variable_copy(struct vtn_builder *b, struct vtn_pointer *dest,
1119                   struct vtn_pointer *src)
1120 {
1121    /* TODO: At some point, we should add a special-case for when we can
1122     * just emit a copy_var intrinsic.
1123     */
1124    _vtn_variable_copy(b, dest, src);
1125 }
1126
1127 static void
1128 set_mode_system_value(struct vtn_builder *b, nir_variable_mode *mode)
1129 {
1130    vtn_assert(*mode == nir_var_system_value || *mode == nir_var_shader_in);
1131    *mode = nir_var_system_value;
1132 }
1133
1134 static void
1135 vtn_get_builtin_location(struct vtn_builder *b,
1136                          SpvBuiltIn builtin, int *location,
1137                          nir_variable_mode *mode)
1138 {
1139    switch (builtin) {
1140    case SpvBuiltInPosition:
1141       *location = VARYING_SLOT_POS;
1142       break;
1143    case SpvBuiltInPointSize:
1144       *location = VARYING_SLOT_PSIZ;
1145       break;
1146    case SpvBuiltInClipDistance:
1147       *location = VARYING_SLOT_CLIP_DIST0; /* XXX CLIP_DIST1? */
1148       break;
1149    case SpvBuiltInCullDistance:
1150       *location = VARYING_SLOT_CULL_DIST0;
1151       break;
1152    case SpvBuiltInVertexIndex:
1153       *location = SYSTEM_VALUE_VERTEX_ID;
1154       set_mode_system_value(b, mode);
1155       break;
1156    case SpvBuiltInVertexId:
1157       /* Vulkan defines VertexID to be zero-based and reserves the new
1158        * builtin keyword VertexIndex to indicate the non-zero-based value.
1159        */
1160       *location = SYSTEM_VALUE_VERTEX_ID_ZERO_BASE;
1161       set_mode_system_value(b, mode);
1162       break;
1163    case SpvBuiltInInstanceIndex:
1164       *location = SYSTEM_VALUE_INSTANCE_INDEX;
1165       set_mode_system_value(b, mode);
1166       break;
1167    case SpvBuiltInInstanceId:
1168       *location = SYSTEM_VALUE_INSTANCE_ID;
1169       set_mode_system_value(b, mode);
1170       break;
1171    case SpvBuiltInPrimitiveId:
1172       if (b->shader->info.stage == MESA_SHADER_FRAGMENT) {
1173          vtn_assert(*mode == nir_var_shader_in);
1174          *location = VARYING_SLOT_PRIMITIVE_ID;
1175       } else if (*mode == nir_var_shader_out) {
1176          *location = VARYING_SLOT_PRIMITIVE_ID;
1177       } else {
1178          *location = SYSTEM_VALUE_PRIMITIVE_ID;
1179          set_mode_system_value(b, mode);
1180       }
1181       break;
1182    case SpvBuiltInInvocationId:
1183       *location = SYSTEM_VALUE_INVOCATION_ID;
1184       set_mode_system_value(b, mode);
1185       break;
1186    case SpvBuiltInLayer:
1187       *location = VARYING_SLOT_LAYER;
1188       if (b->shader->info.stage == MESA_SHADER_FRAGMENT)
1189          *mode = nir_var_shader_in;
1190       else if (b->shader->info.stage == MESA_SHADER_GEOMETRY)
1191          *mode = nir_var_shader_out;
1192       else
1193          vtn_fail("invalid stage for SpvBuiltInLayer");
1194       break;
1195    case SpvBuiltInViewportIndex:
1196       *location = VARYING_SLOT_VIEWPORT;
1197       if (b->shader->info.stage == MESA_SHADER_GEOMETRY)
1198          *mode = nir_var_shader_out;
1199       else if (b->shader->info.stage == MESA_SHADER_FRAGMENT)
1200          *mode = nir_var_shader_in;
1201       else
1202          vtn_fail("invalid stage for SpvBuiltInViewportIndex");
1203       break;
1204    case SpvBuiltInTessLevelOuter:
1205       *location = VARYING_SLOT_TESS_LEVEL_OUTER;
1206       break;
1207    case SpvBuiltInTessLevelInner:
1208       *location = VARYING_SLOT_TESS_LEVEL_INNER;
1209       break;
1210    case SpvBuiltInTessCoord:
1211       *location = SYSTEM_VALUE_TESS_COORD;
1212       set_mode_system_value(b, mode);
1213       break;
1214    case SpvBuiltInPatchVertices:
1215       *location = SYSTEM_VALUE_VERTICES_IN;
1216       set_mode_system_value(b, mode);
1217       break;
1218    case SpvBuiltInFragCoord:
1219       *location = VARYING_SLOT_POS;
1220       vtn_assert(*mode == nir_var_shader_in);
1221       break;
1222    case SpvBuiltInPointCoord:
1223       *location = VARYING_SLOT_PNTC;
1224       vtn_assert(*mode == nir_var_shader_in);
1225       break;
1226    case SpvBuiltInFrontFacing:
1227       *location = SYSTEM_VALUE_FRONT_FACE;
1228       set_mode_system_value(b, mode);
1229       break;
1230    case SpvBuiltInSampleId:
1231       *location = SYSTEM_VALUE_SAMPLE_ID;
1232       set_mode_system_value(b, mode);
1233       break;
1234    case SpvBuiltInSamplePosition:
1235       *location = SYSTEM_VALUE_SAMPLE_POS;
1236       set_mode_system_value(b, mode);
1237       break;
1238    case SpvBuiltInSampleMask:
1239       if (*mode == nir_var_shader_out) {
1240          *location = FRAG_RESULT_SAMPLE_MASK;
1241       } else {
1242          *location = SYSTEM_VALUE_SAMPLE_MASK_IN;
1243          set_mode_system_value(b, mode);
1244       }
1245       break;
1246    case SpvBuiltInFragDepth:
1247       *location = FRAG_RESULT_DEPTH;
1248       vtn_assert(*mode == nir_var_shader_out);
1249       break;
1250    case SpvBuiltInHelperInvocation:
1251       *location = SYSTEM_VALUE_HELPER_INVOCATION;
1252       set_mode_system_value(b, mode);
1253       break;
1254    case SpvBuiltInNumWorkgroups:
1255       *location = SYSTEM_VALUE_NUM_WORK_GROUPS;
1256       set_mode_system_value(b, mode);
1257       break;
1258    case SpvBuiltInWorkgroupSize:
1259       /* This should already be handled */
1260       vtn_fail("unsupported builtin");
1261       break;
1262    case SpvBuiltInWorkgroupId:
1263       *location = SYSTEM_VALUE_WORK_GROUP_ID;
1264       set_mode_system_value(b, mode);
1265       break;
1266    case SpvBuiltInLocalInvocationId:
1267       *location = SYSTEM_VALUE_LOCAL_INVOCATION_ID;
1268       set_mode_system_value(b, mode);
1269       break;
1270    case SpvBuiltInLocalInvocationIndex:
1271       *location = SYSTEM_VALUE_LOCAL_INVOCATION_INDEX;
1272       set_mode_system_value(b, mode);
1273       break;
1274    case SpvBuiltInGlobalInvocationId:
1275       *location = SYSTEM_VALUE_GLOBAL_INVOCATION_ID;
1276       set_mode_system_value(b, mode);
1277       break;
1278    case SpvBuiltInBaseVertex:
1279       *location = SYSTEM_VALUE_BASE_VERTEX;
1280       set_mode_system_value(b, mode);
1281       break;
1282    case SpvBuiltInBaseInstance:
1283       *location = SYSTEM_VALUE_BASE_INSTANCE;
1284       set_mode_system_value(b, mode);
1285       break;
1286    case SpvBuiltInDrawIndex:
1287       *location = SYSTEM_VALUE_DRAW_ID;
1288       set_mode_system_value(b, mode);
1289       break;
1290    case SpvBuiltInViewIndex:
1291       *location = SYSTEM_VALUE_VIEW_INDEX;
1292       set_mode_system_value(b, mode);
1293       break;
1294    default:
1295       vtn_fail("unsupported builtin");
1296    }
1297 }
1298
1299 static void
1300 apply_var_decoration(struct vtn_builder *b, nir_variable *nir_var,
1301                      const struct vtn_decoration *dec)
1302 {
1303    switch (dec->decoration) {
1304    case SpvDecorationRelaxedPrecision:
1305       break; /* FIXME: Do nothing with this for now. */
1306    case SpvDecorationNoPerspective:
1307       nir_var->data.interpolation = INTERP_MODE_NOPERSPECTIVE;
1308       break;
1309    case SpvDecorationFlat:
1310       nir_var->data.interpolation = INTERP_MODE_FLAT;
1311       break;
1312    case SpvDecorationCentroid:
1313       nir_var->data.centroid = true;
1314       break;
1315    case SpvDecorationSample:
1316       nir_var->data.sample = true;
1317       break;
1318    case SpvDecorationInvariant:
1319       nir_var->data.invariant = true;
1320       break;
1321    case SpvDecorationConstant:
1322       vtn_assert(nir_var->constant_initializer != NULL);
1323       nir_var->data.read_only = true;
1324       break;
1325    case SpvDecorationNonReadable:
1326       nir_var->data.image.write_only = true;
1327       break;
1328    case SpvDecorationNonWritable:
1329       nir_var->data.read_only = true;
1330       nir_var->data.image.read_only = true;
1331       break;
1332    case SpvDecorationRestrict:
1333       nir_var->data.image.restrict_flag = true;
1334       break;
1335    case SpvDecorationVolatile:
1336       nir_var->data.image._volatile = true;
1337       break;
1338    case SpvDecorationCoherent:
1339       nir_var->data.image.coherent = true;
1340       break;
1341    case SpvDecorationComponent:
1342       nir_var->data.location_frac = dec->literals[0];
1343       break;
1344    case SpvDecorationIndex:
1345       nir_var->data.index = dec->literals[0];
1346       break;
1347    case SpvDecorationBuiltIn: {
1348       SpvBuiltIn builtin = dec->literals[0];
1349
1350       if (builtin == SpvBuiltInWorkgroupSize) {
1351          /* This shouldn't be a builtin.  It's actually a constant. */
1352          nir_var->data.mode = nir_var_global;
1353          nir_var->data.read_only = true;
1354
1355          nir_constant *c = rzalloc(nir_var, nir_constant);
1356          c->values[0].u32[0] = b->shader->info.cs.local_size[0];
1357          c->values[0].u32[1] = b->shader->info.cs.local_size[1];
1358          c->values[0].u32[2] = b->shader->info.cs.local_size[2];
1359          nir_var->constant_initializer = c;
1360          break;
1361       }
1362
1363       nir_variable_mode mode = nir_var->data.mode;
1364       vtn_get_builtin_location(b, builtin, &nir_var->data.location, &mode);
1365       nir_var->data.mode = mode;
1366
1367       switch (builtin) {
1368       case SpvBuiltInTessLevelOuter:
1369       case SpvBuiltInTessLevelInner:
1370          nir_var->data.compact = true;
1371          break;
1372       case SpvBuiltInSamplePosition:
1373          nir_var->data.origin_upper_left = b->origin_upper_left;
1374          /* fallthrough */
1375       case SpvBuiltInFragCoord:
1376          nir_var->data.pixel_center_integer = b->pixel_center_integer;
1377          break;
1378       default:
1379          break;
1380       }
1381    }
1382
1383    case SpvDecorationSpecId:
1384    case SpvDecorationRowMajor:
1385    case SpvDecorationColMajor:
1386    case SpvDecorationMatrixStride:
1387    case SpvDecorationAliased:
1388    case SpvDecorationUniform:
1389    case SpvDecorationStream:
1390    case SpvDecorationOffset:
1391    case SpvDecorationLinkageAttributes:
1392       break; /* Do nothing with these here */
1393
1394    case SpvDecorationPatch:
1395       nir_var->data.patch = true;
1396       break;
1397
1398    case SpvDecorationLocation:
1399       vtn_fail("Handled above");
1400
1401    case SpvDecorationBlock:
1402    case SpvDecorationBufferBlock:
1403    case SpvDecorationArrayStride:
1404    case SpvDecorationGLSLShared:
1405    case SpvDecorationGLSLPacked:
1406       break; /* These can apply to a type but we don't care about them */
1407
1408    case SpvDecorationBinding:
1409    case SpvDecorationDescriptorSet:
1410    case SpvDecorationNoContraction:
1411    case SpvDecorationInputAttachmentIndex:
1412       vtn_warn("Decoration not allowed for variable or structure member: %s",
1413                spirv_decoration_to_string(dec->decoration));
1414       break;
1415
1416    case SpvDecorationXfbBuffer:
1417    case SpvDecorationXfbStride:
1418       vtn_warn("Vulkan does not have transform feedback: %s",
1419                spirv_decoration_to_string(dec->decoration));
1420       break;
1421
1422    case SpvDecorationCPacked:
1423    case SpvDecorationSaturatedConversion:
1424    case SpvDecorationFuncParamAttr:
1425    case SpvDecorationFPRoundingMode:
1426    case SpvDecorationFPFastMathMode:
1427    case SpvDecorationAlignment:
1428       vtn_warn("Decoration only allowed for CL-style kernels: %s",
1429                spirv_decoration_to_string(dec->decoration));
1430       break;
1431
1432    default:
1433       vtn_fail("Unhandled decoration");
1434    }
1435 }
1436
1437 static void
1438 var_is_patch_cb(struct vtn_builder *b, struct vtn_value *val, int member,
1439                 const struct vtn_decoration *dec, void *out_is_patch)
1440 {
1441    if (dec->decoration == SpvDecorationPatch) {
1442       *((bool *) out_is_patch) = true;
1443    }
1444 }
1445
1446 static void
1447 var_decoration_cb(struct vtn_builder *b, struct vtn_value *val, int member,
1448                   const struct vtn_decoration *dec, void *void_var)
1449 {
1450    struct vtn_variable *vtn_var = void_var;
1451
1452    /* Handle decorations that apply to a vtn_variable as a whole */
1453    switch (dec->decoration) {
1454    case SpvDecorationBinding:
1455       vtn_var->binding = dec->literals[0];
1456       return;
1457    case SpvDecorationDescriptorSet:
1458       vtn_var->descriptor_set = dec->literals[0];
1459       return;
1460    case SpvDecorationInputAttachmentIndex:
1461       vtn_var->input_attachment_index = dec->literals[0];
1462       return;
1463    case SpvDecorationPatch:
1464       vtn_var->patch = true;
1465       break;
1466    default:
1467       break;
1468    }
1469
1470    if (val->value_type == vtn_value_type_pointer) {
1471       assert(val->pointer->var == void_var);
1472       assert(val->pointer->chain == NULL);
1473       assert(member == -1);
1474    } else {
1475       assert(val->value_type == vtn_value_type_type);
1476    }
1477
1478    /* Location is odd.  If applied to a split structure, we have to walk the
1479     * whole thing and accumulate the location.  It's easier to handle as a
1480     * special case.
1481     */
1482    if (dec->decoration == SpvDecorationLocation) {
1483       unsigned location = dec->literals[0];
1484       bool is_vertex_input;
1485       if (b->shader->info.stage == MESA_SHADER_FRAGMENT &&
1486           vtn_var->mode == vtn_variable_mode_output) {
1487          is_vertex_input = false;
1488          location += FRAG_RESULT_DATA0;
1489       } else if (b->shader->info.stage == MESA_SHADER_VERTEX &&
1490                  vtn_var->mode == vtn_variable_mode_input) {
1491          is_vertex_input = true;
1492          location += VERT_ATTRIB_GENERIC0;
1493       } else if (vtn_var->mode == vtn_variable_mode_input ||
1494                  vtn_var->mode == vtn_variable_mode_output) {
1495          is_vertex_input = false;
1496          location += vtn_var->patch ? VARYING_SLOT_PATCH0 : VARYING_SLOT_VAR0;
1497       } else {
1498          vtn_warn("Location must be on input or output variable");
1499          return;
1500       }
1501
1502       if (vtn_var->var) {
1503          /* This handles the member and lone variable cases */
1504          vtn_var->var->data.location = location;
1505       } else {
1506          /* This handles the structure member case */
1507          assert(vtn_var->members);
1508          unsigned length =
1509             glsl_get_length(glsl_without_array(vtn_var->type->type));
1510          for (unsigned i = 0; i < length; i++) {
1511             vtn_var->members[i]->data.location = location;
1512             location +=
1513                glsl_count_attribute_slots(vtn_var->members[i]->interface_type,
1514                                           is_vertex_input);
1515          }
1516       }
1517       return;
1518    } else {
1519       if (vtn_var->var) {
1520          assert(member == -1);
1521          apply_var_decoration(b, vtn_var->var, dec);
1522       } else if (vtn_var->members) {
1523          if (member >= 0) {
1524             /* Member decorations must come from a type */
1525             assert(val->value_type == vtn_value_type_type);
1526             apply_var_decoration(b, vtn_var->members[member], dec);
1527          } else {
1528             unsigned length =
1529                glsl_get_length(glsl_without_array(vtn_var->type->type));
1530             for (unsigned i = 0; i < length; i++)
1531                apply_var_decoration(b, vtn_var->members[i], dec);
1532          }
1533       } else {
1534          /* A few variables, those with external storage, have no actual
1535           * nir_variables associated with them.  Fortunately, all decorations
1536           * we care about for those variables are on the type only.
1537           */
1538          vtn_assert(vtn_var->mode == vtn_variable_mode_ubo ||
1539                     vtn_var->mode == vtn_variable_mode_ssbo ||
1540                     vtn_var->mode == vtn_variable_mode_push_constant ||
1541                     (vtn_var->mode == vtn_variable_mode_workgroup &&
1542                      b->options->lower_workgroup_access_to_offsets));
1543       }
1544    }
1545 }
1546
1547 static enum vtn_variable_mode
1548 vtn_storage_class_to_mode(struct vtn_builder *b,
1549                           SpvStorageClass class,
1550                           struct vtn_type *interface_type,
1551                           nir_variable_mode *nir_mode_out)
1552 {
1553    enum vtn_variable_mode mode;
1554    nir_variable_mode nir_mode;
1555    switch (class) {
1556    case SpvStorageClassUniform:
1557       if (interface_type->block) {
1558          mode = vtn_variable_mode_ubo;
1559          nir_mode = 0;
1560       } else if (interface_type->buffer_block) {
1561          mode = vtn_variable_mode_ssbo;
1562          nir_mode = 0;
1563       } else {
1564          vtn_fail("Invalid uniform variable type");
1565       }
1566       break;
1567    case SpvStorageClassStorageBuffer:
1568       mode = vtn_variable_mode_ssbo;
1569       nir_mode = 0;
1570       break;
1571    case SpvStorageClassUniformConstant:
1572       if (glsl_type_is_image(interface_type->type)) {
1573          mode = vtn_variable_mode_image;
1574          nir_mode = nir_var_uniform;
1575       } else if (glsl_type_is_sampler(interface_type->type)) {
1576          mode = vtn_variable_mode_sampler;
1577          nir_mode = nir_var_uniform;
1578       } else {
1579          vtn_fail("Invalid uniform constant variable type");
1580       }
1581       break;
1582    case SpvStorageClassPushConstant:
1583       mode = vtn_variable_mode_push_constant;
1584       nir_mode = nir_var_uniform;
1585       break;
1586    case SpvStorageClassInput:
1587       mode = vtn_variable_mode_input;
1588       nir_mode = nir_var_shader_in;
1589       break;
1590    case SpvStorageClassOutput:
1591       mode = vtn_variable_mode_output;
1592       nir_mode = nir_var_shader_out;
1593       break;
1594    case SpvStorageClassPrivate:
1595       mode = vtn_variable_mode_global;
1596       nir_mode = nir_var_global;
1597       break;
1598    case SpvStorageClassFunction:
1599       mode = vtn_variable_mode_local;
1600       nir_mode = nir_var_local;
1601       break;
1602    case SpvStorageClassWorkgroup:
1603       mode = vtn_variable_mode_workgroup;
1604       nir_mode = nir_var_shared;
1605       break;
1606    case SpvStorageClassCrossWorkgroup:
1607    case SpvStorageClassGeneric:
1608    case SpvStorageClassAtomicCounter:
1609    default:
1610       vtn_fail("Unhandled variable storage class");
1611    }
1612
1613    if (nir_mode_out)
1614       *nir_mode_out = nir_mode;
1615
1616    return mode;
1617 }
1618
1619 nir_ssa_def *
1620 vtn_pointer_to_ssa(struct vtn_builder *b, struct vtn_pointer *ptr)
1621 {
1622    /* This pointer needs to have a pointer type with actual storage */
1623    vtn_assert(ptr->ptr_type);
1624    vtn_assert(ptr->ptr_type->type);
1625
1626    if (!ptr->offset) {
1627       /* If we don't have an offset then we must be a pointer to the variable
1628        * itself.
1629        */
1630       vtn_assert(!ptr->offset && !ptr->block_index);
1631
1632       struct vtn_access_chain chain = {
1633          .length = 0,
1634       };
1635       ptr = vtn_ssa_offset_pointer_dereference(b, ptr, &chain);
1636    }
1637
1638    vtn_assert(ptr->offset);
1639    if (ptr->block_index) {
1640       vtn_assert(ptr->mode == vtn_variable_mode_ubo ||
1641                  ptr->mode == vtn_variable_mode_ssbo);
1642       return nir_vec2(&b->nb, ptr->block_index, ptr->offset);
1643    } else {
1644       vtn_assert(ptr->mode == vtn_variable_mode_workgroup);
1645       return ptr->offset;
1646    }
1647 }
1648
1649 struct vtn_pointer *
1650 vtn_pointer_from_ssa(struct vtn_builder *b, nir_ssa_def *ssa,
1651                      struct vtn_type *ptr_type)
1652 {
1653    vtn_assert(ssa->num_components <= 2 && ssa->bit_size == 32);
1654    vtn_assert(ptr_type->base_type == vtn_base_type_pointer);
1655    vtn_assert(ptr_type->deref->base_type != vtn_base_type_pointer);
1656    /* This pointer type needs to have actual storage */
1657    vtn_assert(ptr_type->type);
1658
1659    struct vtn_pointer *ptr = rzalloc(b, struct vtn_pointer);
1660    ptr->mode = vtn_storage_class_to_mode(b, ptr_type->storage_class,
1661                                          ptr_type, NULL);
1662    ptr->type = ptr_type->deref;
1663    ptr->ptr_type = ptr_type;
1664
1665    if (ssa->num_components > 1) {
1666       vtn_assert(ssa->num_components == 2);
1667       vtn_assert(ptr->mode == vtn_variable_mode_ubo ||
1668                  ptr->mode == vtn_variable_mode_ssbo);
1669       ptr->block_index = nir_channel(&b->nb, ssa, 0);
1670       ptr->offset = nir_channel(&b->nb, ssa, 1);
1671    } else {
1672       vtn_assert(ssa->num_components == 1);
1673       vtn_assert(ptr->mode == vtn_variable_mode_workgroup);
1674       ptr->block_index = NULL;
1675       ptr->offset = ssa;
1676    }
1677
1678    return ptr;
1679 }
1680
1681 static bool
1682 is_per_vertex_inout(const struct vtn_variable *var, gl_shader_stage stage)
1683 {
1684    if (var->patch || !glsl_type_is_array(var->type->type))
1685       return false;
1686
1687    if (var->mode == vtn_variable_mode_input) {
1688       return stage == MESA_SHADER_TESS_CTRL ||
1689              stage == MESA_SHADER_TESS_EVAL ||
1690              stage == MESA_SHADER_GEOMETRY;
1691    }
1692
1693    if (var->mode == vtn_variable_mode_output)
1694       return stage == MESA_SHADER_TESS_CTRL;
1695
1696    return false;
1697 }
1698
1699 static void
1700 vtn_create_variable(struct vtn_builder *b, struct vtn_value *val,
1701                     struct vtn_type *ptr_type, SpvStorageClass storage_class,
1702                     nir_constant *initializer)
1703 {
1704    vtn_assert(ptr_type->base_type == vtn_base_type_pointer);
1705    struct vtn_type *type = ptr_type->deref;
1706
1707    struct vtn_type *without_array = type;
1708    while(glsl_type_is_array(without_array->type))
1709       without_array = without_array->array_element;
1710
1711    enum vtn_variable_mode mode;
1712    nir_variable_mode nir_mode;
1713    mode = vtn_storage_class_to_mode(b, storage_class, without_array, &nir_mode);
1714
1715    switch (mode) {
1716    case vtn_variable_mode_ubo:
1717       b->shader->info.num_ubos++;
1718       break;
1719    case vtn_variable_mode_ssbo:
1720       b->shader->info.num_ssbos++;
1721       break;
1722    case vtn_variable_mode_image:
1723       b->shader->info.num_images++;
1724       break;
1725    case vtn_variable_mode_sampler:
1726       b->shader->info.num_textures++;
1727       break;
1728    case vtn_variable_mode_push_constant:
1729       b->shader->num_uniforms = vtn_type_block_size(b, type);
1730       break;
1731    default:
1732       /* No tallying is needed */
1733       break;
1734    }
1735
1736    struct vtn_variable *var = rzalloc(b, struct vtn_variable);
1737    var->type = type;
1738    var->mode = mode;
1739
1740    vtn_assert(val->value_type == vtn_value_type_pointer);
1741    val->pointer = vtn_pointer_for_variable(b, var, ptr_type);
1742
1743    switch (var->mode) {
1744    case vtn_variable_mode_local:
1745    case vtn_variable_mode_global:
1746    case vtn_variable_mode_image:
1747    case vtn_variable_mode_sampler:
1748       /* For these, we create the variable normally */
1749       var->var = rzalloc(b->shader, nir_variable);
1750       var->var->name = ralloc_strdup(var->var, val->name);
1751       var->var->type = var->type->type;
1752       var->var->data.mode = nir_mode;
1753
1754       switch (var->mode) {
1755       case vtn_variable_mode_image:
1756       case vtn_variable_mode_sampler:
1757          var->var->interface_type = without_array->type;
1758          break;
1759       default:
1760          var->var->interface_type = NULL;
1761          break;
1762       }
1763       break;
1764
1765    case vtn_variable_mode_workgroup:
1766       if (b->options->lower_workgroup_access_to_offsets) {
1767          var->shared_location = -1;
1768       } else {
1769          /* Create the variable normally */
1770          var->var = rzalloc(b->shader, nir_variable);
1771          var->var->name = ralloc_strdup(var->var, val->name);
1772          var->var->type = var->type->type;
1773          var->var->data.mode = nir_var_shared;
1774       }
1775       break;
1776
1777    case vtn_variable_mode_input:
1778    case vtn_variable_mode_output: {
1779       /* In order to know whether or not we're a per-vertex inout, we need
1780        * the patch qualifier.  This means walking the variable decorations
1781        * early before we actually create any variables.  Not a big deal.
1782        *
1783        * GLSLang really likes to place decorations in the most interior
1784        * thing it possibly can.  In particular, if you have a struct, it
1785        * will place the patch decorations on the struct members.  This
1786        * should be handled by the variable splitting below just fine.
1787        *
1788        * If you have an array-of-struct, things get even more weird as it
1789        * will place the patch decorations on the struct even though it's
1790        * inside an array and some of the members being patch and others not
1791        * makes no sense whatsoever.  Since the only sensible thing is for
1792        * it to be all or nothing, we'll call it patch if any of the members
1793        * are declared patch.
1794        */
1795       var->patch = false;
1796       vtn_foreach_decoration(b, val, var_is_patch_cb, &var->patch);
1797       if (glsl_type_is_array(var->type->type) &&
1798           glsl_type_is_struct(without_array->type)) {
1799          vtn_foreach_decoration(b, vtn_value(b, without_array->id,
1800                                              vtn_value_type_type),
1801                                 var_is_patch_cb, &var->patch);
1802       }
1803
1804       /* For inputs and outputs, we immediately split structures.  This
1805        * is for a couple of reasons.  For one, builtins may all come in
1806        * a struct and we really want those split out into separate
1807        * variables.  For another, interpolation qualifiers can be
1808        * applied to members of the top-level struct ane we need to be
1809        * able to preserve that information.
1810        */
1811
1812       int array_length = -1;
1813       struct vtn_type *interface_type = var->type;
1814       if (is_per_vertex_inout(var, b->shader->info.stage)) {
1815          /* In Geometry shaders (and some tessellation), inputs come
1816           * in per-vertex arrays.  However, some builtins come in
1817           * non-per-vertex, hence the need for the is_array check.  In
1818           * any case, there are no non-builtin arrays allowed so this
1819           * check should be sufficient.
1820           */
1821          interface_type = var->type->array_element;
1822          array_length = glsl_get_length(var->type->type);
1823       }
1824
1825       if (glsl_type_is_struct(interface_type->type)) {
1826          /* It's a struct.  Split it. */
1827          unsigned num_members = glsl_get_length(interface_type->type);
1828          var->members = ralloc_array(b, nir_variable *, num_members);
1829
1830          for (unsigned i = 0; i < num_members; i++) {
1831             const struct glsl_type *mtype = interface_type->members[i]->type;
1832             if (array_length >= 0)
1833                mtype = glsl_array_type(mtype, array_length);
1834
1835             var->members[i] = rzalloc(b->shader, nir_variable);
1836             var->members[i]->name =
1837                ralloc_asprintf(var->members[i], "%s.%d", val->name, i);
1838             var->members[i]->type = mtype;
1839             var->members[i]->interface_type =
1840                interface_type->members[i]->type;
1841             var->members[i]->data.mode = nir_mode;
1842             var->members[i]->data.patch = var->patch;
1843
1844             if (initializer) {
1845                assert(i < initializer->num_elements);
1846                var->members[i]->constant_initializer =
1847                   nir_constant_clone(initializer->elements[i], var->members[i]);
1848             }
1849          }
1850
1851          initializer = NULL;
1852       } else {
1853          var->var = rzalloc(b->shader, nir_variable);
1854          var->var->name = ralloc_strdup(var->var, val->name);
1855          var->var->type = var->type->type;
1856          var->var->interface_type = interface_type->type;
1857          var->var->data.mode = nir_mode;
1858          var->var->data.patch = var->patch;
1859       }
1860
1861       /* For inputs and outputs, we need to grab locations and builtin
1862        * information from the interface type.
1863        */
1864       vtn_foreach_decoration(b, vtn_value(b, interface_type->id,
1865                                           vtn_value_type_type),
1866                              var_decoration_cb, var);
1867       break;
1868    }
1869
1870    case vtn_variable_mode_param:
1871       vtn_fail("Not created through OpVariable");
1872
1873    case vtn_variable_mode_ubo:
1874    case vtn_variable_mode_ssbo:
1875    case vtn_variable_mode_push_constant:
1876       /* These don't need actual variables. */
1877       break;
1878    }
1879
1880    if (initializer) {
1881       var->var->constant_initializer =
1882          nir_constant_clone(initializer, var->var);
1883    }
1884
1885    vtn_foreach_decoration(b, val, var_decoration_cb, var);
1886
1887    if (var->mode == vtn_variable_mode_image ||
1888        var->mode == vtn_variable_mode_sampler) {
1889       /* XXX: We still need the binding information in the nir_variable
1890        * for these. We should fix that.
1891        */
1892       var->var->data.binding = var->binding;
1893       var->var->data.descriptor_set = var->descriptor_set;
1894       var->var->data.index = var->input_attachment_index;
1895
1896       if (var->mode == vtn_variable_mode_image)
1897          var->var->data.image.format = without_array->image_format;
1898    }
1899
1900    if (var->mode == vtn_variable_mode_local) {
1901       vtn_assert(var->members == NULL && var->var != NULL);
1902       nir_function_impl_add_variable(b->nb.impl, var->var);
1903    } else if (var->var) {
1904       nir_shader_add_variable(b->shader, var->var);
1905    } else if (var->members) {
1906       unsigned count = glsl_get_length(without_array->type);
1907       for (unsigned i = 0; i < count; i++) {
1908          vtn_assert(var->members[i]->data.mode != nir_var_local);
1909          nir_shader_add_variable(b->shader, var->members[i]);
1910       }
1911    } else {
1912       vtn_assert(vtn_pointer_is_external_block(b, val->pointer));
1913    }
1914 }
1915
1916 static void
1917 vtn_assert_types_equal(struct vtn_builder *b, SpvOp opcode,
1918                        struct vtn_type *dst_type,
1919                        struct vtn_type *src_type)
1920 {
1921    if (dst_type->id == src_type->id)
1922       return;
1923
1924    if (vtn_types_compatible(b, dst_type, src_type)) {
1925       /* Early versions of GLSLang would re-emit types unnecessarily and you
1926        * would end up with OpLoad, OpStore, or OpCopyMemory opcodes which have
1927        * mismatched source and destination types.
1928        *
1929        * https://github.com/KhronosGroup/glslang/issues/304
1930        * https://github.com/KhronosGroup/glslang/issues/307
1931        * https://bugs.freedesktop.org/show_bug.cgi?id=104338
1932        * https://bugs.freedesktop.org/show_bug.cgi?id=104424
1933        */
1934       vtn_warn("Source and destination types of %s do not have the same "
1935                "ID (but are compatible): %u vs %u",
1936                 spirv_op_to_string(opcode), dst_type->id, src_type->id);
1937       return;
1938    }
1939
1940    vtn_fail("Source and destination types of %s do not match: %s vs. %s",
1941             spirv_op_to_string(opcode),
1942             glsl_get_type_name(dst_type->type),
1943             glsl_get_type_name(src_type->type));
1944 }
1945
1946 void
1947 vtn_handle_variables(struct vtn_builder *b, SpvOp opcode,
1948                      const uint32_t *w, unsigned count)
1949 {
1950    switch (opcode) {
1951    case SpvOpUndef: {
1952       struct vtn_value *val = vtn_push_value(b, w[2], vtn_value_type_undef);
1953       val->type = vtn_value(b, w[1], vtn_value_type_type)->type;
1954       break;
1955    }
1956
1957    case SpvOpVariable: {
1958       struct vtn_type *ptr_type = vtn_value(b, w[1], vtn_value_type_type)->type;
1959
1960       struct vtn_value *val = vtn_push_value(b, w[2], vtn_value_type_pointer);
1961
1962       SpvStorageClass storage_class = w[3];
1963       nir_constant *initializer = NULL;
1964       if (count > 4)
1965          initializer = vtn_value(b, w[4], vtn_value_type_constant)->constant;
1966
1967       vtn_create_variable(b, val, ptr_type, storage_class, initializer);
1968       break;
1969    }
1970
1971    case SpvOpAccessChain:
1972    case SpvOpPtrAccessChain:
1973    case SpvOpInBoundsAccessChain: {
1974       struct vtn_access_chain *chain = vtn_access_chain_create(b, count - 4);
1975       chain->ptr_as_array = (opcode == SpvOpPtrAccessChain);
1976
1977       unsigned idx = 0;
1978       for (int i = 4; i < count; i++) {
1979          struct vtn_value *link_val = vtn_untyped_value(b, w[i]);
1980          if (link_val->value_type == vtn_value_type_constant) {
1981             chain->link[idx].mode = vtn_access_mode_literal;
1982             chain->link[idx].id = link_val->constant->values[0].u32[0];
1983          } else {
1984             chain->link[idx].mode = vtn_access_mode_id;
1985             chain->link[idx].id = w[i];
1986
1987          }
1988          idx++;
1989       }
1990
1991       struct vtn_type *ptr_type = vtn_value(b, w[1], vtn_value_type_type)->type;
1992       struct vtn_value *base_val = vtn_untyped_value(b, w[3]);
1993       if (base_val->value_type == vtn_value_type_sampled_image) {
1994          /* This is rather insane.  SPIR-V allows you to use OpSampledImage
1995           * to combine an array of images with a single sampler to get an
1996           * array of sampled images that all share the same sampler.
1997           * Fortunately, this means that we can more-or-less ignore the
1998           * sampler when crawling the access chain, but it does leave us
1999           * with this rather awkward little special-case.
2000           */
2001          struct vtn_value *val =
2002             vtn_push_value(b, w[2], vtn_value_type_sampled_image);
2003          val->sampled_image = ralloc(b, struct vtn_sampled_image);
2004          val->sampled_image->type = base_val->sampled_image->type;
2005          val->sampled_image->image =
2006             vtn_pointer_dereference(b, base_val->sampled_image->image, chain);
2007          val->sampled_image->sampler = base_val->sampled_image->sampler;
2008       } else {
2009          vtn_assert(base_val->value_type == vtn_value_type_pointer);
2010          struct vtn_value *val =
2011             vtn_push_value(b, w[2], vtn_value_type_pointer);
2012          val->pointer = vtn_pointer_dereference(b, base_val->pointer, chain);
2013          val->pointer->ptr_type = ptr_type;
2014       }
2015       break;
2016    }
2017
2018    case SpvOpCopyMemory: {
2019       struct vtn_value *dest = vtn_value(b, w[1], vtn_value_type_pointer);
2020       struct vtn_value *src = vtn_value(b, w[2], vtn_value_type_pointer);
2021
2022       vtn_assert_types_equal(b, opcode, dest->type->deref, src->type->deref);
2023
2024       vtn_variable_copy(b, dest->pointer, src->pointer);
2025       break;
2026    }
2027
2028    case SpvOpLoad: {
2029       struct vtn_type *res_type =
2030          vtn_value(b, w[1], vtn_value_type_type)->type;
2031       struct vtn_value *src_val = vtn_value(b, w[3], vtn_value_type_pointer);
2032       struct vtn_pointer *src = src_val->pointer;
2033
2034       vtn_assert_types_equal(b, opcode, res_type, src_val->type->deref);
2035
2036       if (src->mode == vtn_variable_mode_image ||
2037           src->mode == vtn_variable_mode_sampler) {
2038          vtn_push_value(b, w[2], vtn_value_type_pointer)->pointer = src;
2039          return;
2040       }
2041
2042       vtn_push_ssa(b, w[2], res_type, vtn_variable_load(b, src));
2043       break;
2044    }
2045
2046    case SpvOpStore: {
2047       struct vtn_value *dest_val = vtn_value(b, w[1], vtn_value_type_pointer);
2048       struct vtn_pointer *dest = dest_val->pointer;
2049       struct vtn_value *src_val = vtn_untyped_value(b, w[2]);
2050
2051       /* OpStore requires us to actually have a storage type */
2052       vtn_fail_if(dest->type->type == NULL,
2053                   "Invalid destination type for OpStore");
2054
2055       if (glsl_get_base_type(dest->type->type) == GLSL_TYPE_BOOL &&
2056           glsl_get_base_type(src_val->type->type) == GLSL_TYPE_UINT) {
2057          /* Early versions of GLSLang would use uint types for UBOs/SSBOs but
2058           * would then store them to a local variable as bool.  Work around
2059           * the issue by doing an implicit conversion.
2060           *
2061           * https://github.com/KhronosGroup/glslang/issues/170
2062           * https://bugs.freedesktop.org/show_bug.cgi?id=104424
2063           */
2064          vtn_warn("OpStore of value of type OpTypeInt to a pointer to type "
2065                   "OpTypeBool.  Doing an implicit conversion to work around "
2066                   "the problem.");
2067          struct vtn_ssa_value *bool_ssa =
2068             vtn_create_ssa_value(b, dest->type->type);
2069          bool_ssa->def = nir_i2b(&b->nb, vtn_ssa_value(b, w[2])->def);
2070          vtn_variable_store(b, bool_ssa, dest);
2071          break;
2072       }
2073
2074       vtn_assert_types_equal(b, opcode, dest_val->type->deref, src_val->type);
2075
2076       if (glsl_type_is_sampler(dest->type->type)) {
2077          vtn_warn("OpStore of a sampler detected.  Doing on-the-fly copy "
2078                   "propagation to workaround the problem.");
2079          vtn_assert(dest->var->copy_prop_sampler == NULL);
2080          dest->var->copy_prop_sampler =
2081             vtn_value(b, w[2], vtn_value_type_pointer)->pointer;
2082          break;
2083       }
2084
2085       struct vtn_ssa_value *src = vtn_ssa_value(b, w[2]);
2086       vtn_variable_store(b, src, dest);
2087       break;
2088    }
2089
2090    case SpvOpArrayLength: {
2091       struct vtn_pointer *ptr =
2092          vtn_value(b, w[3], vtn_value_type_pointer)->pointer;
2093
2094       const uint32_t offset = ptr->var->type->offsets[w[4]];
2095       const uint32_t stride = ptr->var->type->members[w[4]]->stride;
2096
2097       if (!ptr->block_index) {
2098          struct vtn_access_chain chain = {
2099             .length = 0,
2100          };
2101          ptr = vtn_ssa_offset_pointer_dereference(b, ptr, &chain);
2102          vtn_assert(ptr->block_index);
2103       }
2104
2105       nir_intrinsic_instr *instr =
2106          nir_intrinsic_instr_create(b->nb.shader,
2107                                     nir_intrinsic_get_buffer_size);
2108       instr->src[0] = nir_src_for_ssa(ptr->block_index);
2109       nir_ssa_dest_init(&instr->instr, &instr->dest, 1, 32, NULL);
2110       nir_builder_instr_insert(&b->nb, &instr->instr);
2111       nir_ssa_def *buf_size = &instr->dest.ssa;
2112
2113       /* array_length = max(buffer_size - offset, 0) / stride */
2114       nir_ssa_def *array_length =
2115          nir_idiv(&b->nb,
2116                   nir_imax(&b->nb,
2117                            nir_isub(&b->nb,
2118                                     buf_size,
2119                                     nir_imm_int(&b->nb, offset)),
2120                            nir_imm_int(&b->nb, 0u)),
2121                   nir_imm_int(&b->nb, stride));
2122
2123       struct vtn_value *val = vtn_push_value(b, w[2], vtn_value_type_ssa);
2124       val->ssa = vtn_create_ssa_value(b, glsl_uint_type());
2125       val->ssa->def = array_length;
2126       break;
2127    }
2128
2129    case SpvOpCopyMemorySized:
2130    default:
2131       vtn_fail("Unhandled opcode");
2132    }
2133 }