diff options
| -rw-r--r-- | src/compiler/spirv/vtn_alu.c | 67 |
1 files changed, 66 insertions, 1 deletions
diff --git a/src/compiler/spirv/vtn_alu.c b/src/compiler/spirv/vtn_alu.c index 9e4beedf926..ecf9cbc34d6 100644 --- a/src/compiler/spirv/vtn_alu.c +++ b/src/compiler/spirv/vtn_alu.c @@ -210,6 +210,68 @@ vtn_handle_matrix_alu(struct vtn_builder *b, SpvOp opcode, } } +static void +vtn_handle_bitcast(struct vtn_builder *b, struct vtn_ssa_value *dest, + struct nir_ssa_def *src) +{ + if (glsl_get_vector_elements(dest->type) == src->num_components) { + /* From the definition of OpBitcast in the SPIR-V 1.2 spec: + * + * "If Result Type has the same number of components as Operand, they + * must also have the same component width, and results are computed per + * component." + */ + dest->def = nir_imov(&b->nb, src); + return; + } + + /* From the definition of OpBitcast in the SPIR-V 1.2 spec: + * + * "If Result Type has a different number of components than Operand, the + * total number of bits in Result Type must equal the total number of bits + * in Operand. Let L be the type, either Result Type or Operand’s type, that + * has the larger number of components. Let S be the other type, with the + * smaller number of components. The number of components in L must be an + * integer multiple of the number of components in S. The first component + * (that is, the only or lowest-numbered component) of S maps to the first + * components of L, and so on, up to the last component of S mapping to the + * last components of L. Within this mapping, any single component of S + * (mapping to multiple components of L) maps its lower-ordered bits to the + * lower-numbered components of L." + */ + unsigned src_bit_size = src->bit_size; + unsigned dest_bit_size = glsl_get_bit_size(dest->type); + unsigned src_components = src->num_components; + unsigned dest_components = glsl_get_vector_elements(dest->type); + assert(src_bit_size * src_components == dest_bit_size * dest_components); + + nir_ssa_def *dest_chan[4]; + if (src_bit_size > dest_bit_size) { + assert(src_bit_size % dest_bit_size == 0); + unsigned divisor = src_bit_size / dest_bit_size; + for (unsigned comp = 0; comp < src_components; comp++) { + assert(src_bit_size == 64); + assert(dest_bit_size == 32); + nir_ssa_def *split = + nir_unpack_64_2x32(&b->nb, nir_channel(&b->nb, src, comp)); + for (unsigned i = 0; i < divisor; i++) + dest_chan[divisor * comp + i] = nir_channel(&b->nb, split, i); + } + } else { + assert(dest_bit_size % src_bit_size == 0); + unsigned divisor = dest_bit_size / src_bit_size; + for (unsigned comp = 0; comp < dest_components; comp++) { + unsigned channels = ((1 << divisor) - 1) << (comp * divisor); + nir_ssa_def *src_chan = + nir_channels(&b->nb, src, channels); + assert(dest_bit_size == 64); + assert(src_bit_size == 32); + dest_chan[comp] = nir_pack_64_2x32(&b->nb, src_chan); + } + } + dest->def = nir_vec(&b->nb, dest_chan, dest_components); +} + nir_op vtn_nir_alu_op_for_spirv_opcode(SpvOp opcode, bool *swap, nir_alu_type src, nir_alu_type dst) @@ -285,7 +347,6 @@ vtn_nir_alu_op_for_spirv_opcode(SpvOp opcode, bool *swap, case SpvOpFUnordGreaterThanEqual: return nir_op_fge; /* Conversions: */ - case SpvOpBitcast: return nir_op_imov; case SpvOpQuantizeToF16: return nir_op_fquantize2f16; case SpvOpUConvert: case SpvOpConvertFToU: @@ -503,6 +564,10 @@ vtn_handle_alu(struct vtn_builder *b, SpvOp opcode, break; } + case SpvOpBitcast: + vtn_handle_bitcast(b, val->ssa, src[0]); + break; + default: { bool swap; nir_alu_type src_alu_type = nir_get_nir_type_for_glsl_type(vtn_src[0]->type); |