intel/genxml: Add an field option for nonzero="true"

This asserts that the value supplied is non-zero.  Useful for things
like MOCS fields on modern platforms where we really want to avoid
setting it to 0 (uncached).

mbz types cannot be flagged as nonzero.

Reviewed-by: Jason Ekstrand <jason@jlekstrand.net>
Part-of: <https://gitlab.freedesktop.org/mesa/mesa/-/merge_requests/13480>

diff --git a/src/intel/genxml/gen_pack_header.py b/src/intel/genxml/gen_pack_header.py
index 7864156..fa9eae5 100644 (file)
--- a/src/intel/genxml/gen_pack_header.py
+++ b/src/intel/genxml/gen_pack_header.py
@@ -90,6 +90,13 @@ __gen_uint(uint64_t v, uint32_t start, NDEBUG_UNUSED uint32_t end)
 }
 
 static inline __attribute__((always_inline)) uint64_t
+__gen_uint_nonzero(uint64_t v, uint32_t start, uint32_t end)
+{
+   assert(v != 0ull);
+   return __gen_uint(v, start, end);
+}
+
+static inline __attribute__((always_inline)) uint64_t
 __gen_sint(int64_t v, uint32_t start, uint32_t end)
 {
    const int width = end - start + 1;
@@ -110,6 +117,13 @@ __gen_sint(int64_t v, uint32_t start, uint32_t end)
 }
 
 static inline __attribute__((always_inline)) uint64_t
+__gen_sint_nonzero(int64_t v, uint32_t start, uint32_t end)
+{
+   assert(v != 0ll);
+   return __gen_sint(v, start, end);
+}
+
+static inline __attribute__((always_inline)) uint64_t
 __gen_offset(uint64_t v, NDEBUG_UNUSED uint32_t start, NDEBUG_UNUSED uint32_t end)
 {
    __gen_validate_value(v);
@@ -123,6 +137,13 @@ __gen_offset(uint64_t v, NDEBUG_UNUSED uint32_t start, NDEBUG_UNUSED uint32_t en
 }
 
 static inline __attribute__((always_inline)) uint64_t
+__gen_offset_nonzero(uint64_t v, uint32_t start, uint32_t end)
+{
+   assert(v != 0ull);
+   return __gen_offset(v, start, end);
+}
+
+static inline __attribute__((always_inline)) uint64_t
 __gen_address(__gen_user_data *data, void *location,
               __gen_address_type address, uint32_t delta,
               __attribute__((unused)) uint32_t start, uint32_t end)
@@ -145,6 +166,13 @@ __gen_float(float v)
    return ((union __intel_value) { .f = (v) }).dw;
 }
 
+static inline __attribute__((always_inline)) uint32_t
+__gen_float_nonzero(float v)
+{
+   assert(v != 0.0f);
+   return __gen_float(v);
+}
+
 static inline __attribute__((always_inline)) uint64_t
 __gen_sfixed(float v, uint32_t start, uint32_t end, uint32_t fract_bits)
 {
@@ -165,6 +193,13 @@ __gen_sfixed(float v, uint32_t start, uint32_t end, uint32_t fract_bits)
 }
 
 static inline __attribute__((always_inline)) uint64_t
+__gen_sfixed_nonzero(float v, uint32_t start, uint32_t end, uint32_t fract_bits)
+{
+   assert(v != 0.0f);
+   return __gen_sfixed(v, start, end, fract_bits);
+}
+
+static inline __attribute__((always_inline)) uint64_t
 __gen_ufixed(float v, uint32_t start, NDEBUG_UNUSED uint32_t end, uint32_t fract_bits)
 {
    __gen_validate_value(v);
@@ -182,6 +217,13 @@ __gen_ufixed(float v, uint32_t start, NDEBUG_UNUSED uint32_t end, uint32_t fract
    return uint_val << start;
 }
 
+static inline __attribute__((always_inline)) uint64_t
+__gen_ufixed_nonzero(float v, uint32_t start, uint32_t end, uint32_t fract_bits)
+{
+   assert(v != 0.0f);
+   return __gen_ufixed(v, start, end, fract_bits);
+}
+
 #ifndef __gen_address_type
 #error #define __gen_address_type before including this file
 #endif
@@ -203,6 +245,10 @@ def num_from_str(num_str):
     assert not num_str.startswith('0'), 'octals numbers not allowed'
     return int(num_str)
 
+def bool_from_str(bool_str):
+    options = { "true": True, "false": False }
+    return options[bool_str];
+
 class Field(object):
     ufixed_pattern = re.compile(r"u(\d+)\.(\d+)")
     sfixed_pattern = re.compile(r"s(\d+)\.(\d+)")
@@ -214,6 +260,7 @@ class Field(object):
         self.start = int(attrs["start"])
         self.end = int(attrs["end"])
         self.type = attrs["type"]
+        self.nonzero = bool_from_str(attrs.get("nonzero", "false"))
 
         assert self.start <= self.end, \
                'field {} has end ({}) < start ({})'.format(self.name, self.end,
@@ -435,36 +482,38 @@ class Group(object):
                 if field.type != "mbo" and field.type != "mbz":
                     name = field.name + field.dim
 
+                nz = "_nonzero" if field.nonzero else ""
+
                 if field.type == "mbo":
                     non_address_fields.append("__gen_mbo(%d, %d)" % \
                         (field.start - dword_start, field.end - dword_start))
                 elif field.type == "mbz":
-                    pass
+                    assert not field.nonzero
                 elif field.type == "address":
                     pass
                 elif field.type == "uint":
-                    non_address_fields.append("__gen_uint(values->%s, %d, %d)" % \
-                        (name, field.start - dword_start, field.end - dword_start))
+                    non_address_fields.append("__gen_uint%s(values->%s, %d, %d)" % \
+                        (nz, name, field.start - dword_start, field.end - dword_start))
                 elif field.is_enum_type():
-                    non_address_fields.append("__gen_uint(values->%s, %d, %d)" % \
-                        (name, field.start - dword_start, field.end - dword_start))
+                    non_address_fields.append("__gen_uint%s(values->%s, %d, %d)" % \
+                        (nz, name, field.start - dword_start, field.end - dword_start))
                 elif field.type == "int":
-                    non_address_fields.append("__gen_sint(values->%s, %d, %d)" % \
-                        (name, field.start - dword_start, field.end - dword_start))
+                    non_address_fields.append("__gen_sint%s(values->%s, %d, %d)" % \
+                        (nz, name, field.start - dword_start, field.end - dword_start))
                 elif field.type == "bool":
-                    non_address_fields.append("__gen_uint(values->%s, %d, %d)" % \
-                        (name, field.start - dword_start, field.end - dword_start))
+                    non_address_fields.append("__gen_uint%s(values->%s, %d, %d)" % \
+                        (nz, name, field.start - dword_start, field.end - dword_start))
                 elif field.type == "float":
-                    non_address_fields.append("__gen_float(values->%s)" % name)
+                    non_address_fields.append("__gen_float%s(values->%s)" % (nz, name))
                 elif field.type == "offset":
-                    non_address_fields.append("__gen_offset(values->%s, %d, %d)" % \
-                        (name, field.start - dword_start, field.end - dword_start))
+                    non_address_fields.append("__gen_offset%s(values->%s, %d, %d)" % \
+                        (nz, name, field.start - dword_start, field.end - dword_start))
                 elif field.type == 'ufixed':
-                    non_address_fields.append("__gen_ufixed(values->%s, %d, %d, %d)" % \
-                        (name, field.start - dword_start, field.end - dword_start, field.fractional_size))
+                    non_address_fields.append("__gen_ufixed%s(values->%s, %d, %d, %d)" % \
+                        (nz, name, field.start - dword_start, field.end - dword_start, field.fractional_size))
                 elif field.type == 'sfixed':
-                    non_address_fields.append("__gen_sfixed(values->%s, %d, %d, %d)" % \
-                        (name, field.start - dword_start, field.end - dword_start, field.fractional_size))
+                    non_address_fields.append("__gen_sfixed%s(values->%s, %d, %d, %d)" % \
+                        (nz, name, field.start - dword_start, field.end - dword_start, field.fractional_size))
                 elif field.is_struct_type():
                     non_address_fields.append("__gen_uint(v%d_%d, %d, %d)" % \
                         (index, field_index, field.start - dword_start, field.end - dword_start))