diff --git a/src/intel/genxml/gen_pack_header.py b/src/intel/genxml/gen_pack_header.py index 7864156ec22..fa9eae51718 100644 --- a/src/intel/genxml/gen_pack_header.py +++ b/src/intel/genxml/gen_pack_header.py @@ -89,6 +89,13 @@ __gen_uint(uint64_t v, uint32_t start, NDEBUG_UNUSED uint32_t end) return v << start; } +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) { @@ -109,6 +116,13 @@ __gen_sint(int64_t v, uint32_t start, uint32_t end) return (v & mask) << start; } +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) { @@ -122,6 +136,13 @@ __gen_offset(uint64_t v, NDEBUG_UNUSED uint32_t start, NDEBUG_UNUSED uint32_t en return v; } +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, @@ -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) { @@ -164,6 +192,13 @@ __gen_sfixed(float v, uint32_t start, uint32_t end, uint32_t fract_bits) return (int_val & mask) << start; } +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) { @@ -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))