From b67f148db78d092ae1a385f82806dcb5545e70c4 Mon Sep 17 00:00:00 2001 From: Alyssa Rosenzweig Date: Sat, 24 Apr 2021 19:10:10 -0400 Subject: [PATCH] asahi: Add a GenXML fork Via Panfrost via v3d via Intel. Sour dough! Signed-off-by: Alyssa Rosenzweig Acked-by: Jason Ekstrand Acked-by: Bas Nieuwenhuizen Part-of: --- src/asahi/lib/gen_pack.py | 691 ++++++++++++++++++++++++++++++++++++++ src/asahi/lib/meson.build | 13 + 2 files changed, 704 insertions(+) create mode 100644 src/asahi/lib/gen_pack.py diff --git a/src/asahi/lib/gen_pack.py b/src/asahi/lib/gen_pack.py new file mode 100644 index 00000000000..0cca73f4367 --- /dev/null +++ b/src/asahi/lib/gen_pack.py @@ -0,0 +1,691 @@ +#encoding=utf-8 + +# Copyright (C) 2016 Intel Corporation +# Copyright (C) 2016 Broadcom +# Copyright (C) 2020 Collabora, Ltd. +# +# Permission is hereby granted, free of charge, to any person obtaining a +# copy of this software and associated documentation files (the "Software"), +# to deal in the Software without restriction, including without limitation +# the rights to use, copy, modify, merge, publish, distribute, sublicense, +# and/or sell copies of the Software, and to permit persons to whom the +# Software is furnished to do so, subject to the following conditions: +# +# The above copyright notice and this permission notice (including the next +# paragraph) shall be included in all copies or substantial portions of the +# Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL +# THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +# FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS +# IN THE SOFTWARE. + +import xml.parsers.expat +import sys +import operator +from functools import reduce + +global_prefix = "agx" + +pack_header = """ +/* Generated code, see midgard.xml and gen_pack_header.py + * + * Packets, enums and structures for Panfrost. + * + * This file has been generated, do not hand edit. + */ + +#ifndef AGX_PACK_H +#define AGX_PACK_H + +#include +#include +#include +#include +#include +#include +#include "util/macros.h" +#include "util/u_math.h" + +#define __gen_unpack_float(x, y, z) uif(__gen_unpack_uint(x, y, z)) + +static inline uint64_t +__gen_uint(uint64_t v, uint32_t start, uint32_t end) +{ +#ifndef NDEBUG + const int width = end - start + 1; + if (width < 64) { + const uint64_t max = (1ull << width) - 1; + assert(v <= max); + } +#endif + + return v << start; +} + +static inline uint32_t +__gen_sint(int32_t v, uint32_t start, uint32_t end) +{ +#ifndef NDEBUG + const int width = end - start + 1; + if (width < 64) { + const int64_t max = (1ll << (width - 1)) - 1; + const int64_t min = -(1ll << (width - 1)); + assert(min <= v && v <= max); + } +#endif + + return (((uint32_t) v) << start) & ((2ll << end) - 1); +} + +static inline uint64_t +__gen_unpack_uint(const uint8_t *restrict cl, uint32_t start, uint32_t end) +{ + uint64_t val = 0; + const int width = end - start + 1; + const uint64_t mask = (width == 64 ? ~0 : (1ull << width) - 1 ); + + for (unsigned byte = start / 8; byte <= end / 8; byte++) { + val |= ((uint64_t) cl[byte]) << ((byte - start / 8) * 8); + } + + return (val >> (start % 8)) & mask; +} + +static inline uint64_t +__gen_unpack_sint(const uint8_t *restrict cl, uint32_t start, uint32_t end) +{ + int size = end - start + 1; + int64_t val = __gen_unpack_uint(cl, start, end); + + /* Get the sign bit extended. */ + return (val << (64 - size)) >> (64 - size); +} + +#define agx_prepare(dst, T) \\ + *(dst) = (struct AGX_ ## T){ AGX_ ## T ## _header } + +#define agx_pack(dst, T, name) \\ + for (struct AGX_ ## T name = { AGX_ ## T ## _header }, \\ + *_loop_terminate = (void *) (dst); \\ + __builtin_expect(_loop_terminate != NULL, 1); \\ + ({ AGX_ ## T ## _pack((uint32_t *) (dst), &name); \\ + _loop_terminate = NULL; })) + +#define agx_unpack(fp, src, T, name) \\ + struct AGX_ ## T name; \\ + AGX_ ## T ## _unpack(fp, (uint8_t *)(src), &name) + +#define agx_print(fp, T, var, indent) \\ + AGX_ ## T ## _print(fp, &(var), indent) + +""" + +def to_alphanum(name): + substitutions = { + ' ': '_', + '/': '_', + '[': '', + ']': '', + '(': '', + ')': '', + '-': '_', + ':': '', + '.': '', + ',': '', + '=': '', + '>': '', + '#': '', + '&': '', + '*': '', + '"': '', + '+': '', + '\'': '', + } + + for i, j in substitutions.items(): + name = name.replace(i, j) + + return name + +def safe_name(name): + name = to_alphanum(name) + if not name[0].isalpha(): + name = '_' + name + + return name + +def prefixed_upper_name(prefix, name): + if prefix: + name = prefix + "_" + name + return safe_name(name).upper() + +def enum_name(name): + return "{}_{}".format(global_prefix, safe_name(name)).lower() + +def num_from_str(num_str): + if num_str.lower().startswith('0x'): + return int(num_str, base=16) + else: + assert(not num_str.startswith('0') and 'octals numbers not allowed') + return int(num_str) + +MODIFIERS = ["shr", "minus", "align", "log2"] + +def parse_modifier(modifier): + if modifier is None: + return None + + for mod in MODIFIERS: + if modifier[0:len(mod)] == mod: + if mod == "log2": + assert(len(mod) == len(modifier)) + return [mod] + + if modifier[len(mod)] == '(' and modifier[-1] == ')': + ret = [mod, int(modifier[(len(mod) + 1):-1])] + if ret[0] == 'align': + align = ret[1] + # Make sure the alignment is a power of 2 + assert(align > 0 and not(align & (align - 1))); + + return ret + + print("Invalid modifier") + assert(False) + +class Field(object): + def __init__(self, parser, attrs): + self.parser = parser + if "name" in attrs: + self.name = safe_name(attrs["name"]).lower() + self.human_name = attrs["name"] + + if ":" in str(attrs["start"]): + (word, bit) = attrs["start"].split(":") + self.start = (int(word) * 32) + int(bit) + else: + self.start = int(attrs["start"]) + + self.end = self.start + int(attrs["size"]) - 1 + self.type = attrs["type"] + + if self.type == 'bool' and self.start != self.end: + print("#error Field {} has bool type but more than one bit of size".format(self.name)); + + if "prefix" in attrs: + self.prefix = safe_name(attrs["prefix"]).upper() + else: + self.prefix = None + + if "exact" in attrs: + self.exact = int(attrs["exact"]) + else: + self.exact = None + + self.default = attrs.get("default") + + # Map enum values + if self.type in self.parser.enums and self.default is not None: + self.default = safe_name('{}_{}_{}'.format(global_prefix, self.type, self.default)).upper() + + self.modifier = parse_modifier(attrs.get("modifier")) + + def emit_template_struct(self, dim): + if self.type == 'address': + type = 'uint64_t' + elif self.type == 'bool': + type = 'bool' + elif self.type == 'float': + type = 'float' + elif self.type in ['uint', 'hex'] and self.end - self.start > 32: + type = 'uint64_t' + elif self.type == 'int': + type = 'int32_t' + elif self.type in ['uint', 'uint/float', 'hex']: + type = 'uint32_t' + elif self.type in self.parser.structs: + type = 'struct ' + self.parser.gen_prefix(safe_name(self.type.upper())) + elif self.type in self.parser.enums: + type = 'enum ' + enum_name(self.type) + else: + print("#error unhandled type: %s" % self.type) + type = "uint32_t" + + print(" %-36s %s%s;" % (type, self.name, dim)) + + for value in self.values: + name = prefixed_upper_name(self.prefix, value.name) + print("#define %-40s %d" % (name, value.value)) + + def overlaps(self, field): + return self != field and max(self.start, field.start) <= min(self.end, field.end) + +class Group(object): + def __init__(self, parser, parent, start, count, label): + self.parser = parser + self.parent = parent + self.start = start + self.count = count + self.label = label + self.size = 0 + self.length = 0 + self.fields = [] + + def get_length(self): + # Determine number of bytes in this group. + calculated = max(field.end // 8 for field in self.fields) + 1 if len(self.fields) > 0 else 0 + if self.length > 0: + assert(self.length >= calculated) + else: + self.length = calculated + return self.length + + + def emit_template_struct(self, dim): + if self.count == 0: + print(" /* variable length fields follow */") + else: + if self.count > 1: + dim = "%s[%d]" % (dim, self.count) + + if len(self.fields) == 0: + print(" int dummy;") + + for field in self.fields: + if field.exact is not None: + continue + + field.emit_template_struct(dim) + + class Word: + def __init__(self): + self.size = 32 + self.contributors = [] + + class FieldRef: + def __init__(self, field, path, start, end): + self.field = field + self.path = path + self.start = start + self.end = end + + def collect_fields(self, fields, offset, path, all_fields): + for field in fields: + field_path = '{}{}'.format(path, field.name) + field_offset = offset + field.start + + if field.type in self.parser.structs: + sub_struct = self.parser.structs[field.type] + self.collect_fields(sub_struct.fields, field_offset, field_path + '.', all_fields) + continue + + start = field_offset + end = offset + field.end + all_fields.append(self.FieldRef(field, field_path, start, end)) + + def collect_words(self, fields, offset, path, words): + for field in fields: + field_path = '{}{}'.format(path, field.name) + start = offset + field.start + + if field.type in self.parser.structs: + sub_fields = self.parser.structs[field.type].fields + self.collect_words(sub_fields, start, field_path + '.', words) + continue + + end = offset + field.end + contributor = self.FieldRef(field, field_path, start, end) + first_word = contributor.start // 32 + last_word = contributor.end // 32 + for b in range(first_word, last_word + 1): + if not b in words: + words[b] = self.Word() + words[b].contributors.append(contributor) + + def emit_pack_function(self): + self.get_length() + + words = {} + self.collect_words(self.fields, 0, '', words) + + # Validate the modifier is lossless + for field in self.fields: + if field.modifier is None: + continue + + assert(field.exact is None) + + if field.modifier[0] == "shr": + shift = field.modifier[1] + mask = hex((1 << shift) - 1) + print(" assert((values->{} & {}) == 0);".format(field.name, mask)) + elif field.modifier[0] == "minus": + print(" assert(values->{} >= {});".format(field.name, field.modifier[1])) + elif field.modifier[0] == "log2": + print(" assert(util_is_power_of_two_nonzero(values->{}));".format(field.name)) + + for index in range(self.length // 4): + # Handle MBZ words + if not index in words: + print(" cl[%2d] = 0;" % index) + continue + + word = words[index] + + word_start = index * 32 + + v = None + prefix = " cl[%2d] =" % index + + for contributor in word.contributors: + field = contributor.field + name = field.name + start = contributor.start + end = contributor.end + contrib_word_start = (start // 32) * 32 + start -= contrib_word_start + end -= contrib_word_start + + value = str(field.exact) if field.exact is not None else "values->{}".format(contributor.path) + if field.modifier is not None: + if field.modifier[0] == "shr": + value = "{} >> {}".format(value, field.modifier[1]) + elif field.modifier[0] == "minus": + value = "{} - {}".format(value, field.modifier[1]) + elif field.modifier[0] == "align": + value = "ALIGN_POT({}, {})".format(value, field.modifier[1]) + elif field.modifier[0] == "log2": + value = "util_logbase2({})".format(value) + + if field.type in ["uint", "hex", "address"]: + s = "__gen_uint(%s, %d, %d)" % \ + (value, start, end) + elif field.type in self.parser.enums: + s = "__gen_uint(%s, %d, %d)" % \ + (value, start, end) + elif field.type == "int": + s = "__gen_sint(%s, %d, %d)" % \ + (value, start, end) + elif field.type == "bool": + s = "__gen_uint(%s, %d, %d)" % \ + (value, start, end) + elif field.type == "float": + assert(start == 0 and end == 31) + s = "__gen_uint(fui({}), 0, 32)".format(value) + else: + s = "#error unhandled field {}, type {}".format(contributor.path, field.type) + + if not s == None: + shift = word_start - contrib_word_start + if shift: + s = "%s >> %d" % (s, shift) + + if contributor == word.contributors[-1]: + print("%s %s;" % (prefix, s)) + else: + print("%s %s |" % (prefix, s)) + prefix = " " + + continue + + # Given a field (start, end) contained in word `index`, generate the 32-bit + # mask of present bits relative to the word + def mask_for_word(self, index, start, end): + field_word_start = index * 32 + start -= field_word_start + end -= field_word_start + # Cap multiword at one word + start = max(start, 0) + end = min(end, 32 - 1) + count = (end - start + 1) + return (((1 << count) - 1) << start) + + def emit_unpack_function(self): + # First, verify there is no garbage in unused bits + words = {} + self.collect_words(self.fields, 0, '', words) + + for index in range(self.length // 4): + base = index * 32 + word = words.get(index, self.Word()) + masks = [self.mask_for_word(index, c.start, c.end) for c in word.contributors] + mask = reduce(lambda x,y: x | y, masks, 0) + + ALL_ONES = 0xffffffff + + if mask != ALL_ONES: + TMPL = ' if (((const uint32_t *) cl)[{}] & {}) fprintf(fp, "XXX: Unknown field of {} unpacked at word {}: got %X, bad mask %X\\n", ((const uint32_t *) cl)[{}], ((const uint32_t *) cl)[{}] & {});' + print(TMPL.format(index, hex(mask ^ ALL_ONES), self.label, index, index, index, hex(mask ^ ALL_ONES))) + + fieldrefs = [] + self.collect_fields(self.fields, 0, '', fieldrefs) + for fieldref in fieldrefs: + field = fieldref.field + convert = None + + args = [] + args.append('cl') + args.append(str(fieldref.start)) + args.append(str(fieldref.end)) + + if field.type in set(["uint", "uint/float", "address", "hex"]) | self.parser.enums: + convert = "__gen_unpack_uint" + elif field.type == "int": + convert = "__gen_unpack_sint" + elif field.type == "bool": + convert = "__gen_unpack_uint" + elif field.type == "float": + convert = "__gen_unpack_float" + else: + s = "/* unhandled field %s, type %s */\n" % (field.name, field.type) + + suffix = "" + prefix = "" + if field.modifier: + if field.modifier[0] == "minus": + suffix = " + {}".format(field.modifier[1]) + elif field.modifier[0] == "shr": + suffix = " << {}".format(field.modifier[1]) + if field.modifier[0] == "log2": + prefix = "1 << " + + decoded = '{}{}({}){}'.format(prefix, convert, ', '.join(args), suffix) + + print(' values->{} = {};'.format(fieldref.path, decoded)) + if field.modifier and field.modifier[0] == "align": + mask = hex(field.modifier[1] - 1) + print(' assert(!(values->{} & {}));'.format(fieldref.path, mask)) + + def emit_print_function(self): + for field in self.fields: + convert = None + name, val = field.human_name, 'values->{}'.format(field.name) + + if field.type in self.parser.structs: + pack_name = self.parser.gen_prefix(safe_name(field.type)).upper() + print(' fprintf(fp, "%*s{}:\\n", indent, "");'.format(field.human_name)) + print(" {}_print(fp, &values->{}, indent + 2);".format(pack_name, field.name)) + elif field.type == "address": + # TODO resolve to name + print(' fprintf(fp, "%*s{}: 0x%" PRIx64 "\\n", indent, "", {});'.format(name, val)) + elif field.type in self.parser.enums: + print(' fprintf(fp, "%*s{}: %s\\n", indent, "", {}_as_str({}));'.format(name, enum_name(field.type), val)) + elif field.type == "int": + print(' fprintf(fp, "%*s{}: %d\\n", indent, "", {});'.format(name, val)) + elif field.type == "bool": + print(' fprintf(fp, "%*s{}: %s\\n", indent, "", {} ? "true" : "false");'.format(name, val)) + elif field.type == "float": + print(' fprintf(fp, "%*s{}: %f\\n", indent, "", {});'.format(name, val)) + elif field.type in ["uint", "hex"] and (field.end - field.start) >= 32: + print(' fprintf(fp, "%*s{}: 0x%" PRIx64 "\\n", indent, "", {});'.format(name, val)) + elif field.type == "hex": + print(' fprintf(fp, "%*s{}: 0x%" PRIx32 "\\n", indent, "", {});'.format(name, val)) + elif field.type == "uint/float": + print(' fprintf(fp, "%*s{}: 0x%X (%f)\\n", indent, "", {}, uif({}));'.format(name, val, val)) + else: + print(' fprintf(fp, "%*s{}: %u\\n", indent, "", {});'.format(name, val)) + +class Value(object): + def __init__(self, attrs): + self.name = attrs["name"] + self.value = int(attrs["value"], 0) + +class Parser(object): + def __init__(self): + self.parser = xml.parsers.expat.ParserCreate() + self.parser.StartElementHandler = self.start_element + self.parser.EndElementHandler = self.end_element + + self.struct = None + self.structs = {} + # Set of enum names we've seen. + self.enums = set() + + def gen_prefix(self, name): + return '{}_{}'.format(global_prefix.upper(), name) + + def start_element(self, name, attrs): + if name == "agxml": + print(pack_header) + elif name == "struct": + name = attrs["name"] + self.no_direct_packing = attrs.get("no-direct-packing", False) + object_name = self.gen_prefix(safe_name(name.upper())) + self.struct = object_name + + self.group = Group(self, None, 0, 1, name) + if "size" in attrs: + self.group.length = int(attrs["size"]) + self.group.align = int(attrs["align"]) if "align" in attrs else None + self.structs[attrs["name"]] = self.group + elif name == "field": + self.group.fields.append(Field(self, attrs)) + self.values = [] + elif name == "enum": + self.values = [] + self.enum = safe_name(attrs["name"]) + self.enums.add(attrs["name"]) + if "prefix" in attrs: + self.prefix = attrs["prefix"] + else: + self.prefix= None + elif name == "value": + self.values.append(Value(attrs)) + + def end_element(self, name): + if name == "struct": + self.emit_struct() + self.struct = None + self.group = None + elif name == "field": + self.group.fields[-1].values = self.values + elif name == "enum": + self.emit_enum() + self.enum = None + elif name == "agxml": + print('#endif') + + def emit_header(self, name): + default_fields = [] + for field in self.group.fields: + if not type(field) is Field: + continue + if field.default is not None: + default_fields.append(" .{} = {}".format(field.name, field.default)) + elif field.type in self.structs: + default_fields.append(" .{} = {{ {}_header }}".format(field.name, self.gen_prefix(safe_name(field.type.upper())))) + + print('#define %-40s\\' % (name + '_header')) + if default_fields: + print(", \\\n".join(default_fields)) + else: + print(' 0') + print('') + + def emit_template_struct(self, name, group): + print("struct %s {" % name) + group.emit_template_struct("") + print("};\n") + + def emit_pack_function(self, name, group): + print("static inline void\n%s_pack(uint32_t * restrict cl,\n%sconst struct %s * restrict values)\n{" % + (name, ' ' * (len(name) + 6), name)) + + group.emit_pack_function() + + print("}\n\n") + + print('#define {} {}'.format (name + "_LENGTH", self.group.length)) + if self.group.align != None: + print('#define {} {}'.format (name + "_ALIGN", self.group.align)) + print('struct {}_packed {{ uint32_t opaque[{}]; }};'.format(name.lower(), self.group.length // 4)) + + def emit_unpack_function(self, name, group): + print("static inline void") + print("%s_unpack(FILE *fp, const uint8_t * restrict cl,\n%sstruct %s * restrict values)\n{" % + (name.upper(), ' ' * (len(name) + 8), name)) + + group.emit_unpack_function() + + print("}\n") + + def emit_print_function(self, name, group): + print("static inline void") + print("{}_print(FILE *fp, const struct {} * values, unsigned indent)\n{{".format(name.upper(), name)) + + group.emit_print_function() + + print("}\n") + + def emit_struct(self): + name = self.struct + + self.emit_template_struct(self.struct, self.group) + self.emit_header(name) + if self.no_direct_packing == False: + self.emit_pack_function(self.struct, self.group) + self.emit_unpack_function(self.struct, self.group) + self.emit_print_function(self.struct, self.group) + + def enum_prefix(self, name): + return + + def emit_enum(self): + e_name = enum_name(self.enum) + prefix = e_name if self.enum != 'Format' else global_prefix + print('enum {} {{'.format(e_name)) + + for value in self.values: + name = '{}_{}'.format(prefix, value.name) + name = safe_name(name).upper() + print(' % -36s = %6d,' % (name, value.value)) + print('};\n') + + print("static inline const char *") + print("{}_as_str(enum {} imm)\n{{".format(e_name.lower(), e_name)) + print(" switch (imm) {") + for value in self.values: + name = '{}_{}'.format(prefix, value.name) + name = safe_name(name).upper() + print(' case {}: return "{}";'.format(name, value.name)) + print(' default: return "XXX: INVALID";') + print(" }") + print("}\n") + + def parse(self, filename): + file = open(filename, "rb") + self.parser.ParseFile(file) + file.close() + +if len(sys.argv) < 2: + print("No input xml file specified") + sys.exit(1) + +input_file = sys.argv[1] + +p = Parser() +p.parse(input_file) diff --git a/src/asahi/lib/meson.build b/src/asahi/lib/meson.build index a2677d70227..7bde6afad84 100644 --- a/src/asahi/lib/meson.build +++ b/src/asahi/lib/meson.build @@ -18,3 +18,16 @@ # LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE # SOFTWARE. + +agx_pack = custom_target( + 'agx_pack.h', + input : ['gen_pack.py', 'cmdbuf.xml'], + output : 'agx_pack.h', + command : [prog_python, '@INPUT@'], + capture : true, +) + +idep_agx_pack = declare_dependency( + sources : [agx_pack], + include_directories : include_directories('.'), +)