fix a few more spirv issues

Author: Hugobros3

src/shady/emit/spirv/emit_spv_instructions.c

@@ -79,12 +79,12 @@ static const IselTableEntry isel_table[] = {
 
     [neg_op] = {Plain, FirstOp, Same, .fo = {SpvOpSNegate, SpvOpSNegate, SpvOpFNegate }},
 
-    [eq_op]  = {Plain, FirstOp, Bool, .fo = {SpvOpIEqual, SpvOpIEqual, SpvOpFOrdEqual, SpvOpLogicalEqual    }},
-    [neq_op] = {Plain, FirstOp, Bool, .fo = {SpvOpINotEqual, SpvOpINotEqual, SpvOpFOrdNotEqual, SpvOpLogicalNotEqual }},
-    [lt_op]  = {Plain, FirstOp, Bool, .fo = {SpvOpSLessThan, SpvOpULessThan, SpvOpFOrdLessThan, ISEL_IDENTITY        }},
-    [lte_op] = {Plain, FirstOp, Bool, .fo = {SpvOpSLessThanEqual, SpvOpULessThanEqual, SpvOpFOrdLessThanEqual, ISEL_IDENTITY        }},
-    [gt_op]  = {Plain, FirstOp, Bool, .fo = {SpvOpSGreaterThan, SpvOpUGreaterThan, SpvOpFOrdGreaterThan, ISEL_IDENTITY        }},
-    [gte_op] = {Plain, FirstOp, Bool, .fo = {SpvOpSGreaterThanEqual, SpvOpUGreaterThanEqual, SpvOpFOrdGreaterThanEqual, ISEL_IDENTITY        }},
+    [eq_op]  = {Plain, FirstOp, Bool, .fo = {SpvOpIEqual, SpvOpIEqual, SpvOpFOrdEqual, SpvOpLogicalEqual, SpvOpPtrEqual }},
+    [neq_op] = {Plain, FirstOp, Bool, .fo = {SpvOpINotEqual, SpvOpINotEqual, SpvOpFOrdNotEqual, SpvOpLogicalNotEqual, SpvOpPtrNotEqual }},
+    [lt_op]  = {Plain, FirstOp, Bool, .fo = {SpvOpSLessThan, SpvOpULessThan, SpvOpFOrdLessThan, ISEL_ILLEGAL, ISEL_ILLEGAL }},
+    [lte_op] = {Plain, FirstOp, Bool, .fo = {SpvOpSLessThanEqual, SpvOpULessThanEqual, SpvOpFOrdLessThanEqual, ISEL_ILLEGAL, ISEL_ILLEGAL}},
+    [gt_op]  = {Plain, FirstOp, Bool, .fo = {SpvOpSGreaterThan, SpvOpUGreaterThan, SpvOpFOrdGreaterThan, ISEL_ILLEGAL, ISEL_ILLEGAL}},
+    [gte_op] = {Plain, FirstOp, Bool, .fo = {SpvOpSGreaterThanEqual, SpvOpUGreaterThanEqual, SpvOpFOrdGreaterThanEqual, ISEL_ILLEGAL, ISEL_ILLEGAL }},
 
     [not_op] = {Plain, FirstOp, Same, .fo = {SpvOpNot, SpvOpNot, ISEL_ILLEGAL, SpvOpLogicalNot }},
 
@@ -109,7 +109,7 @@ static const IselTableEntry isel_table[] = {
         { SpvOpBitcast,       ISEL_ILLEGAL,      SpvOpBitcast,  ISEL_ILLEGAL,  SpvOpConvertUToPtr },
         { SpvOpBitcast,       SpvOpBitcast,       ISEL_IDENTITY, ISEL_ILLEGAL,  ISEL_ILLEGAL /* no fp-ptr casts */ },
         { ISEL_ILLEGAL,       ISEL_ILLEGAL,       ISEL_ILLEGAL,  ISEL_IDENTITY, ISEL_ILLEGAL /* no bool reinterpret */ },
-        { SpvOpConvertPtrToU, SpvOpConvertPtrToU, ISEL_ILLEGAL,  ISEL_ILLEGAL,  ISEL_IDENTITY }
+        { SpvOpConvertPtrToU, SpvOpConvertPtrToU, ISEL_ILLEGAL,  ISEL_ILLEGAL,  ISEL_CUSTOM }
     }},
 
     [sqrt_op] =     { Plain, Monomorphic, Same, .extended_set = "GLSL.std.450", .op = (SpvOp) GLSLstd450Sqrt },
@@ -195,7 +195,8 @@ static void emit_primop(Emitter* emitter, FnBuilder fn_builder, BBBuilder bb_bui
                 Nodes results_ts = unwrap_multiple_yield_types(emitter->arena, instr->type);
                 SpvId result_t = results_ts.count >= 1 ? emit_type(emitter, instr->type) : emitter->void_t;
 
-                assert(opcode != SpvOpMax);
+                if (opcode == SpvOpMax)
+                    goto custom;
 
                 if (entry.extended_set) {
                     SpvId set_id = get_extended_instruction_set(emitter, entry.extended_set);
@@ -215,7 +216,17 @@ static void emit_primop(Emitter* emitter, FnBuilder fn_builder, BBBuilder bb_bui
 
         return;
     }
+
+    custom:
     switch (the_op.op) {
+        case reinterpret_op: {
+            const Type* dst = first(the_op.type_arguments);
+            const Type* src = get_unqualified_type(first(the_op.operands)->type);
+            assert(dst->tag == PtrType_TAG && src->tag == PtrType_TAG);
+            assert(src != dst);
+            results[0] = spvb_op(bb_builder, SpvOpBitcast, emit_type(emitter, dst), 1, (SpvId[]) {spv_emit_value(emitter, bb_builder, first(the_op.operands)) });
+            return;
+        }
         case subgroup_ballot_op: {
             const Type* i32x4 = pack_type(emitter->arena, (PackType) { .width = 4, .element_type = uint32_type(emitter->arena) });
             SpvId scope_subgroup = emit_value(emitter, bb_builder, int32_literal(emitter->arena, SpvScopeSubgroup));

src/shady/emit/spirv/emit_spv_type.c

@@ -144,9 +144,19 @@ SpvId emit_type(Emitter* emitter, const Type* type) {
             new = spvb_float_type(emitter->file_builder, width);
             break;
         } case PtrType_TAG: {
-            SpvId pointee = emit_type(emitter, type->payload.ptr_type.pointed_type);
             SpvStorageClass sc = emit_addr_space(emitter, type->payload.ptr_type.address_space);
+            const Type* pointed_type = type->payload.ptr_type.pointed_type;
+            if (get_maybe_nominal_type_decl(pointed_type) && sc == SpvStorageClassPhysicalStorageBuffer) {
+                new = spvb_forward_ptr_type(emitter->file_builder, sc);
+                insert_dict_and_get_result(struct Node*, SpvId, emitter->node_ids, type, new);
+                SpvId pointee = emit_type(emitter, pointed_type);
+                spvb_ptr_type_define(emitter->file_builder, new, sc, pointee);
+                return new;
+            }
+
+            SpvId pointee = emit_type(emitter, pointed_type);
             new = spvb_ptr_type(emitter->file_builder, sc, pointee);
+
             //if (is_physical_as(type->payload.ptr_type.address_space) && type->payload.ptr_type.pointed_type->tag == ArrType_TAG) {
             //    TypeMemLayout elem_mem_layout = get_mem_layout(emitter->arena, type->payload.ptr_type.pointed_type);
             //    spvb_decorate(emitter->file_builder, new, SpvDecorationArrayStride, 1, (uint32_t[]) {elem_mem_layout.size_in_bytes});
@@ -193,8 +203,9 @@ SpvId emit_type(Emitter* emitter, const Type* type) {
                 break;
             }
             new = spvb_fresh_id(emitter->file_builder);
+            insert_dict_and_get_result(struct Node*, SpvId, emitter->node_ids, type, new);
             emit_nominal_type_body(emitter, type, new);
-            break;
+            return new;
         }
         case Type_TypeDeclRef_TAG: {
             new = emit_decl(emitter, type->payload.type_decl_ref.decl);

src/shady/emit/spirv/spirv_builder.c

@@ -349,6 +349,21 @@ SpvId spvb_ptr_type(SpvbFileBuilder* file_builder, SpvStorageClass storage_class
     return id;
 }
 
+SpvId spvb_forward_ptr_type(SpvbFileBuilder* file_builder, SpvStorageClass storage_class) {
+    op(SpvOpTypeForwardPointer, 3);
+    SpvId id = spvb_fresh_id(file_builder);
+    ref_id(id);
+    literal_int(storage_class);
+    return id;
+}
+
+void spvb_ptr_type_define(SpvbFileBuilder* file_builder, SpvId id, SpvStorageClass storage_class, SpvId element_type) {
+    op(SpvOpTypePointer, 4);
+    ref_id(id);
+    literal_int(storage_class);
+    ref_id(element_type);
+}
+
 SpvId spvb_array_type(SpvbFileBuilder* file_builder, SpvId element_type, SpvId dim) {
     op(SpvOpTypeArray, 4);
     SpvId id = spvb_fresh_id(file_builder);

src/shady/emit/spirv/spirv_builder.h

@@ -44,6 +44,8 @@ SpvId spvb_void_type(SpvbFileBuilder*);
 SpvId spvb_bool_type(SpvbFileBuilder*);
 SpvId spvb_int_type(SpvbFileBuilder*, int width, bool signed_);
 SpvId spvb_float_type(SpvbFileBuilder*, int width);
+SpvId spvb_forward_ptr_type(SpvbFileBuilder*, SpvStorageClass storage_class);
+void spvb_ptr_type_define(SpvbFileBuilder*, SpvId id, SpvStorageClass storage_class, SpvId element_type);
 SpvId spvb_ptr_type(SpvbFileBuilder*, SpvStorageClass storage_class, SpvId element_type);
 SpvId spvb_array_type(SpvbFileBuilder*, SpvId element_type, SpvId dim);
 SpvId spvb_runtime_array_type(SpvbFileBuilder*, SpvId element_type);

src/shady/type.c

@@ -410,7 +410,7 @@ const Type* check_type_ptr_type(IrArena* arena, PtrType ptr_type) {
         const Node* maybe_record_type = ptr_type.pointed_type;
         if (maybe_record_type->tag == TypeDeclRef_TAG)
             maybe_record_type = get_nominal_type_body(maybe_record_type);
-        if (maybe_record_type->tag == RecordType_TAG && maybe_record_type->payload.record_type.special == DecorateBlock) {
+        if (maybe_record_type && maybe_record_type->tag == RecordType_TAG && maybe_record_type->payload.record_type.special == DecorateBlock) {
             return NULL;
         }
         assert(is_data_type(ptr_type.pointed_type));