spirv: Add initial subgroup support

[mesa.git] / src / compiler / spirv / vtn_private.h

diff --git a/src/compiler/spirv/vtn_private.h b/src/compiler/spirv/vtn_private.h
index d07f6a2beb29007da868ed4799c3c5d5c6ce0073..316def080273b1464271c73e7717045328d35463 100644 (file)
--- a/src/compiler/spirv/vtn_private.h
+++ b/src/compiler/spirv/vtn_private.h
@@ -265,6 +265,7 @@ enum vtn_base_type {
    vtn_base_type_pointer,
    vtn_base_type_image,
    vtn_base_type_sampler,
+   vtn_base_type_sampled_image,
    vtn_base_type_function,
 };
 
@@ -273,10 +274,13 @@ struct vtn_type {
 
    const struct glsl_type *type;
 
-   /* The value that declares this type.  Used for finding decorations */
-   struct vtn_value *val;
+   /* The SPIR-V id of the given type. */
+   uint32_t id;
 
-   /* Specifies the length of complex types. */
+   /* Specifies the length of complex types.
+    *
+    * For Workgroup pointers, this is the size of the referenced type.
+    */
    unsigned length;
 
    /* for arrays, matrices and pointers, the array stride */
@@ -327,6 +331,9 @@ struct vtn_type {
 
          /* Storage class for pointers */
          SpvStorageClass storage_class;
+
+         /* Required alignment for pointers */
+         uint32_t align;
       };
 
       /* Members for image types */
@@ -341,6 +348,12 @@ struct vtn_type {
          SpvAccessQualifier access_qualifier;
       };
 
+      /* Members for sampled image types */
+      struct {
+         /* For sampled images, the image type */
+         struct vtn_type *image;
+      };
+
       /* Members for function types */
       struct {
          /* For functions, the vtn_type for each parameter */
@@ -352,6 +365,9 @@ struct vtn_type {
    };
 };
 
+bool vtn_types_compatible(struct vtn_builder *b,
+                          struct vtn_type *t1, struct vtn_type *t2);
+
 struct vtn_variable;
 
 enum vtn_access_mode {
@@ -428,13 +444,6 @@ struct vtn_pointer {
    struct nir_ssa_def *offset;
 };
 
-static inline bool
-vtn_pointer_uses_ssa_offset(struct vtn_pointer *ptr)
-{
-   return ptr->mode == vtn_variable_mode_ubo ||
-          ptr->mode == vtn_variable_mode_ssbo;
-}
-
 struct vtn_variable {
    enum vtn_variable_mode mode;
 
@@ -448,6 +457,8 @@ struct vtn_variable {
    nir_variable *var;
    nir_variable **members;
 
+   int shared_location;
+
    /**
     * In some early released versions of GLSLang, it implemented all function
     * calls by making copies of all parameters into temporary variables and
@@ -479,14 +490,11 @@ struct vtn_value {
    enum vtn_value_type value_type;
    const char *name;
    struct vtn_decoration *decoration;
+   struct vtn_type *type;
    union {
       void *ptr;
       char *str;
-      struct vtn_type *type;
-      struct {
-         nir_constant *constant;
-         const struct glsl_type *const_type;
-      };
+      nir_constant *constant;
       struct vtn_pointer *pointer;
       struct vtn_image_pointer *image;
       struct vtn_sampled_image *sampled_image;
@@ -526,6 +534,7 @@ struct vtn_builder {
    jmp_buf fail_jump;
 
    const uint32_t *spirv;
+   size_t spirv_word_count;
 
    nir_shader *shader;
    const struct spirv_to_nir_options *options;
@@ -579,15 +588,25 @@ struct vtn_pointer *
 vtn_pointer_from_ssa(struct vtn_builder *b, nir_ssa_def *ssa,
                      struct vtn_type *ptr_type);
 
+static inline struct vtn_value *
+vtn_untyped_value(struct vtn_builder *b, uint32_t value_id)
+{
+   vtn_fail_if(value_id >= b->value_id_bound,
+               "SPIR-V id %u is out-of-bounds", value_id);
+   return &b->values[value_id];
+}
+
 static inline struct vtn_value *
 vtn_push_value(struct vtn_builder *b, uint32_t value_id,
                enum vtn_value_type value_type)
 {
-   assert(value_id < b->value_id_bound);
-   assert(b->values[value_id].value_type == vtn_value_type_invalid);
+   struct vtn_value *val = vtn_untyped_value(b, value_id);
 
-   b->values[value_id].value_type = value_type;
+   vtn_fail_if(val->value_type != vtn_value_type_invalid,
+               "SPIR-V id %u has already been written by another instruction",
+               value_id);
 
+   val->value_type = value_type;
    return &b->values[value_id];
 }
 
@@ -606,22 +625,26 @@ vtn_push_ssa(struct vtn_builder *b, uint32_t value_id,
    return val;
 }
 
-static inline struct vtn_value *
-vtn_untyped_value(struct vtn_builder *b, uint32_t value_id)
-{
-   assert(value_id < b->value_id_bound);
-   return &b->values[value_id];
-}
-
 static inline struct vtn_value *
 vtn_value(struct vtn_builder *b, uint32_t value_id,
           enum vtn_value_type value_type)
 {
    struct vtn_value *val = vtn_untyped_value(b, value_id);
-   assert(val->value_type == value_type);
+   vtn_fail_if(val->value_type != value_type,
+               "SPIR-V id %u is the wrong kind of value", value_id);
    return val;
 }
 
+bool
+vtn_set_instruction_result_type(struct vtn_builder *b, SpvOp opcode,
+                                const uint32_t *w, unsigned count);
+
+static inline nir_constant *
+vtn_constant_value(struct vtn_builder *b, uint32_t value_id)
+{
+   return vtn_value(b, value_id, vtn_value_type_constant)->constant;
+}
+
 struct vtn_ssa_value *vtn_ssa_value(struct vtn_builder *b, uint32_t value_id);
 
 struct vtn_ssa_value *vtn_create_ssa_value(struct vtn_builder *b,
@@ -683,15 +706,26 @@ typedef void (*vtn_execution_mode_foreach_cb)(struct vtn_builder *,
 void vtn_foreach_execution_mode(struct vtn_builder *b, struct vtn_value *value,
                                 vtn_execution_mode_foreach_cb cb, void *data);
 
-nir_op vtn_nir_alu_op_for_spirv_opcode(SpvOp opcode, bool *swap,
+nir_op vtn_nir_alu_op_for_spirv_opcode(struct vtn_builder *b,
+                                       SpvOp opcode, bool *swap,
                                        nir_alu_type src, nir_alu_type dst);
 
 void vtn_handle_alu(struct vtn_builder *b, SpvOp opcode,
                     const uint32_t *w, unsigned count);
 
+void vtn_handle_subgroup(struct vtn_builder *b, SpvOp opcode,
+                         const uint32_t *w, unsigned count);
+
 bool vtn_handle_glsl450_instruction(struct vtn_builder *b, uint32_t ext_opcode,
                                     const uint32_t *words, unsigned count);
 
+static inline uint32_t
+vtn_align_u32(uint32_t v, uint32_t a)
+{
+   assert(a != 0 && a == (a & -a));
+   return (v + a - 1) & ~(a - 1);
+}
+
 static inline uint64_t
 vtn_u64_literal(const uint32_t *w)
 {