Add storage images and support for querying image size

Author: btipling

src/backend/spirv/emit_spv_value.c

@@ -287,6 +287,14 @@ static SpvId emit_ext_op(Emitter* emitter, FnBuilder* fn_builder, BBBuilder bb_b
                 assert(operands.count == 1);
                 break;
             }
+			case SpvOpImageWrite: {
+				spvb_capability(emitter->file_builder, SpvCapabilityStorageImageWriteWithoutFormat);
+				break;
+			}
+			case SpvOpImageQuerySize: {
+				spvb_capability(emitter->file_builder, SpvCapabilityImageQuery);
+				break;
+			}
             default: break;
         }
         LARRAY(SpvId, ops, operands.count);

src/frontend/llvm/l2s_instr.c

@@ -627,9 +627,16 @@ const Node* l2s_convert_instruction(Parser* p, FnParseCtx* fn_ctx, Node* fn_or_b
                         ShdScope shd_scope = parse_scope(scope_str);
                         Nodes ops = convert_operands(p, num_args, instr);
                         uint32_t op = strtol(opcode_str, NULL, 10);
+						
+                        const Type* result_t = NULL;
+                        if (t && t->tag == TupleType_TAG && t->payload.tuple_type.members.count == 0) {
+                            result_t = NULL;
+                        } else if (t) {
+                            result_t = qualified_type_helper(a, shd_scope, t);
+                        }
 
                         free(duped);
-                        return shd_bld_add_instruction(b, ext_instr_helper(a, shd_bld_mem(b), qualified_type_helper(a, shd_scope, t), set, op, ops));
+                        return shd_bld_add_instruction(b, ext_instr_helper(a, shd_bld_mem(b), result_t, set, op, ops));
                     } else {
                         shd_error_print("Unrecognised shady intrinsic '%s'\n", keyword);
                         shd_error_die();

src/frontend/llvm/l2s_type.c

@@ -88,17 +88,22 @@ const Type* l2s_convert_type(Parser* p, LLVMTypeRef t) {
                     default: assert(false);
                 }
                 bool arrayed = (offset >> 6) & 1;
-
-                return sampled_image_type(a, (SampledImageType) {.image_type = image_type(a, (ImageType) {
+                bool is_storage = (offset >> 8) & 1;
+				
+                const Type* img_type = image_type(a, (ImageType) {
                         //.sampled_type = pack_type(a, (PackType) { .element_type = float_type(a, (Float) { .width = FloatTy32 }), .width = 4 }),
                         .sampled_type = sampled_type,
                         .dim = dim,
                         .depth = 0,
                         .arrayed = arrayed,
                         .ms = 0,
-                        .sampled = 1,
+                        .sampled = is_storage ? 2 : 1,
                         .imageformat = 0
-                })});
+                });
+                if (is_storage) {
+                    return img_type;
+                }
+                return sampled_image_type(a, (SampledImageType) {.image_type = img_type});
             }
             AddressSpace as = l2s_convert_llvm_address_space(llvm_as);
             const Type* pointee = NULL;

vcc/include/shady.h

@@ -48,11 +48,21 @@ typedef __attribute__((address_space(0x1001))) struct __shady_builtin_sampler2D*
 typedef __attribute__((address_space(0x1002))) struct __shady_builtin_sampler3D* sampler3D;
 typedef __attribute__((address_space(0x1003))) struct __shady_builtin_sampler3D* samplerCube;
 
+typedef __attribute__((address_space(0x1100))) struct __shady_builtin_image2D *image1D;
+typedef __attribute__((address_space(0x1101))) struct __shady_builtin_image2D *image2D;
+typedef __attribute__((address_space(0x1102))) struct __shady_builtin_image2D *image3D;
+typedef __attribute__((address_space(0x1103))) struct __shady_builtin_image2D *imageCube;
+
 native_vec4 texture1D(const sampler1D, float)           __asm__("shady::impure_op::spirv.core::87::Invocation");
 native_vec4 texture2D(const sampler2D, native_vec2)     __asm__("shady::impure_op::spirv.core::87::Invocation");
 native_vec4 texture3D(const sampler3D, native_vec3)     __asm__("shady::impure_op::spirv.core::87::Invocation");
 native_vec4 textureCube(const samplerCube, native_vec3) __asm__("shady::impure_op::spirv.core::87::Invocation");
 
+native_ivec2 imageSize(image2D img) __asm__("shady::pure_op::spirv.core::104::Invocation");
+void imageStore(image2D img,
+                native_ivec2 coord,
+                native_vec4 data) __asm__("shady::impure_op::spirv.core::99::Invocation");
+
 #if defined(__cplusplus)
 native_vec4 texture(const sampler1D, float)         __asm__("shady::impure_op::spirv.core::87::Invocation");
 native_vec4 texture(const sampler2D, native_vec2)   __asm__("shady::impure_op::spirv.core::87::Invocation");