nir/serialize: fix vec8 and vec16

[mesa.git] / src / compiler / glsl_types.cpp

diff --git a/src/compiler/glsl_types.cpp b/src/compiler/glsl_types.cpp
index 16cc79445e21e7b64fd5070f9b30d3fae6b1f0c6..4450b23a8c4ab781d4533bf1d0ad4bdb5f2e3499 100644 (file)
--- a/src/compiler/glsl_types.cpp
+++ b/src/compiler/glsl_types.cpp
@@ -2580,7 +2580,7 @@ union packed_type {
       unsigned interface_row_major:1;
       unsigned vector_elements:3;
       unsigned matrix_columns:3;
-      unsigned _pad:20;
+      unsigned explicit_stride:20;
    } basic;
    struct {
       unsigned base_type:5;
@@ -2590,6 +2590,17 @@ union packed_type {
       unsigned sampled_type:2;
       unsigned _pad:19;
    } sampler;
+   struct {
+      unsigned base_type:5;
+      unsigned length:13;
+      unsigned explicit_stride:14;
+   } array;
+   struct {
+      unsigned base_type:5;
+      unsigned interface_packing_or_packed:2;
+      unsigned interface_row_major:1;
+      unsigned length:24;
+   } strct;
 };
 
 void
@@ -2623,8 +2634,13 @@ encode_type_to_blob(struct blob *blob, const glsl_type *type)
       assert(type->matrix_columns < 8);
       encoded.basic.vector_elements = type->vector_elements;
       encoded.basic.matrix_columns = type->matrix_columns;
+      encoded.basic.explicit_stride = MIN2(type->explicit_stride, 0xfffff);
       blob_write_uint32(blob, encoded.u32);
-      blob_write_uint32(blob, type->explicit_stride);
+      /* If we don't have enough bits for explicit_stride, store it
+       * separately.
+       */
+      if (encoded.basic.explicit_stride == 0xfffff)
+         blob_write_uint32(blob, type->explicit_stride);
       return;
    case GLSL_TYPE_SAMPLER:
       encoded.sampler.dimensionality = type->sampler_dimensionality;
@@ -2644,16 +2660,33 @@ encode_type_to_blob(struct blob *blob, const glsl_type *type)
    case GLSL_TYPE_ATOMIC_UINT:
       break;
    case GLSL_TYPE_ARRAY:
+      encoded.array.length = MIN2(type->length, 0x1fff);
+      encoded.array.explicit_stride = MIN2(type->explicit_stride, 0x3fff);
       blob_write_uint32(blob, encoded.u32);
-      blob_write_uint32(blob, type->length);
-      blob_write_uint32(blob, type->explicit_stride);
+      /* If we don't have enough bits for length or explicit_stride, store it
+       * separately.
+       */
+      if (encoded.array.length == 0x1fff)
+         blob_write_uint32(blob, type->length);
+      if (encoded.array.explicit_stride == 0x3fff)
+         blob_write_uint32(blob, type->explicit_stride);
       encode_type_to_blob(blob, type->fields.array);
       return;
    case GLSL_TYPE_STRUCT:
    case GLSL_TYPE_INTERFACE:
+      encoded.strct.length = MIN2(type->length, 0xffffff);
+      if (type->is_interface()) {
+         encoded.strct.interface_packing_or_packed = type->interface_packing;
+         encoded.strct.interface_row_major = type->interface_row_major;
+      } else {
+         encoded.strct.interface_packing_or_packed = type->packed;
+      }
       blob_write_uint32(blob, encoded.u32);
       blob_write_string(blob, type->name);
-      blob_write_uint32(blob, type->length);
+
+      /* If we don't have enough bits for length, store it separately. */
+      if (encoded.strct.length == 0xffffff)
+         blob_write_uint32(blob, type->length);
 
       size_t s_field_size, s_field_ptrs;
       get_struct_type_field_and_pointer_sizes(&s_field_size, &s_field_ptrs);
@@ -2667,13 +2700,6 @@ encode_type_to_blob(struct blob *blob, const glsl_type *type)
                           ((char *)&type->fields.structure[i]) + s_field_ptrs,
                           s_field_size - s_field_ptrs);
       }
-
-      if (type->is_interface()) {
-         blob_write_uint32(blob, type->interface_packing);
-         blob_write_uint32(blob, type->interface_row_major);
-      } else {
-         blob_write_uint32(blob, type->packed);
-      }
       return;
    case GLSL_TYPE_VOID:
       break;
@@ -2712,7 +2738,9 @@ decode_type_from_blob(struct blob_reader *blob)
    case GLSL_TYPE_UINT64:
    case GLSL_TYPE_INT64:
    case GLSL_TYPE_BOOL: {
-      unsigned explicit_stride = blob_read_uint32(blob);
+      unsigned explicit_stride = encoded.basic.explicit_stride;
+      if (explicit_stride == 0xfffff)
+         explicit_stride = blob_read_uint32(blob);
       return glsl_type::get_instance(base_type, encoded.basic.vector_elements,
                                      encoded.basic.matrix_columns,
                                      explicit_stride,
@@ -2732,15 +2760,21 @@ decode_type_from_blob(struct blob_reader *blob)
    case GLSL_TYPE_ATOMIC_UINT:
       return glsl_type::atomic_uint_type;
    case GLSL_TYPE_ARRAY: {
-      unsigned length = blob_read_uint32(blob);
-      unsigned explicit_stride = blob_read_uint32(blob);
+      unsigned length = encoded.array.length;
+      if (length == 0x1fff)
+         length = blob_read_uint32(blob);
+      unsigned explicit_stride = encoded.array.explicit_stride;
+      if (explicit_stride == 0x3fff)
+         explicit_stride = blob_read_uint32(blob);
       return glsl_type::get_array_instance(decode_type_from_blob(blob),
                                            length, explicit_stride);
    }
    case GLSL_TYPE_STRUCT:
    case GLSL_TYPE_INTERFACE: {
       char *name = blob_read_string(blob);
-      unsigned num_fields = blob_read_uint32(blob);
+      unsigned num_fields = encoded.strct.length;
+      if (num_fields == 0xffffff)
+         num_fields = blob_read_uint32(blob);
 
       size_t s_field_size, s_field_ptrs;
       get_struct_type_field_and_pointer_sizes(&s_field_size, &s_field_ptrs);
@@ -2758,12 +2792,12 @@ decode_type_from_blob(struct blob_reader *blob)
       const glsl_type *t;
       if (base_type == GLSL_TYPE_INTERFACE) {
          enum glsl_interface_packing packing =
-            (glsl_interface_packing) blob_read_uint32(blob);
-         bool row_major = blob_read_uint32(blob);
+            (glsl_interface_packing) encoded.strct.interface_packing_or_packed;
+         bool row_major = encoded.strct.interface_row_major;
          t = glsl_type::get_interface_instance(fields, num_fields, packing,
                                                row_major, name);
       } else {
-         unsigned packed = blob_read_uint32(blob);
+         unsigned packed = encoded.strct.interface_packing_or_packed;
          t = glsl_type::get_struct_instance(fields, num_fields, name, packed);
       }