From: Kenneth Graunke Date: Tue, 19 Oct 2021 05:35:33 +0000 (-0700) Subject: intel/genxml: Add an field option for nonzero="true" X-Git-Tag: upstream/22.3.5~16176 X-Git-Url: http://review.tizen.org/git/?a=commitdiff_plain;h=ebe2a2b5f6a461ec4644accb4e7b02c430bb8f16;p=platform%2Fupstream%2Fmesa.git 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 Part-of: --- diff --git a/src/intel/genxml/gen_pack_header.py b/src/intel/genxml/gen_pack_header.py index 7864156..fa9eae5 100644 --- 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))