From 58da316de7a7858eb96a18ee8c1f9d35bf0c2b99 Mon Sep 17 00:00:00 2001 From: Alyssa Rosenzweig Date: Mon, 14 Sep 2020 13:17:07 -0400 Subject: [PATCH] pan/bi: Add ISA parser This Python script parses the ISA.xml file to produce a normalized in-memory representation suitable for the disassembly and packing scripts to consume. In particular, it papers over details about duplicate encodings and default fields. Signed-off-by: Alyssa Rosenzweig Reviewed-by: Daniel Stone Part-of: --- src/panfrost/bifrost/isa_parse.py | 178 ++++++++++++++++++++++++++++++ 1 file changed, 178 insertions(+) create mode 100644 src/panfrost/bifrost/isa_parse.py diff --git a/src/panfrost/bifrost/isa_parse.py b/src/panfrost/bifrost/isa_parse.py new file mode 100644 index 00000000000..9b4e8a68583 --- /dev/null +++ b/src/panfrost/bifrost/isa_parse.py @@ -0,0 +1,178 @@ +# +# 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. + +# Parse instruction set XML into a normalized form for processing + +import xml.etree.ElementTree as ET +import copy + +def parse_cond(cond, aliased = False): + if cond.tag == 'reserved': + return None + + if cond.attrib.get('alias', False) and not aliased: + return ['alias', parse_cond(cond, True)] + + if 'left' in cond.attrib: + return [cond.tag, cond.attrib['left'], cond.attrib['right']] + else: + return [cond.tag] + [parse_cond(x) for x in cond.findall('*')] + +def parse_exact(obj): + return [int(obj.attrib['mask'], 0), int(obj.attrib['exact'], 0)] + +def parse_derived(obj): + out = [] + + for deriv in obj.findall('derived'): + loc = [int(deriv.attrib['start']), int(deriv.attrib['size'])] + count = 1 << loc[1] + + opts = [parse_cond(d) for d in deriv.findall('*')] + default = [None] * count + opts_fit = (opts + default)[0:count] + + out.append([loc, opts_fit]) + + return out + +def parse_modifiers(obj): + out = [] + + for mod in obj.findall('mod'): + name = mod.attrib['name'] + start = mod.attrib.get('start', None) + size = int(mod.attrib['size']) + + if start is not None: + start = int(start) + + opts = [x.text if x.tag == 'opt' else x.tag for x in mod.findall('*')] + + if len(opts) == 0: + assert('opt' in mod.attrib) + opts = ['none', mod.attrib['opt']] + + # Find suitable default + default = mod.attrib.get('default', 'none' if 'none' in opts else None) + + # Pad out as reserved + count = (1 << size) + opts = (opts + (['reserved'] * count))[0:count] + out.append([[name, start, size], default, opts]) + + return out + +def parse_copy(enc, existing): + for node in enc.findall('copy'): + name = node.get('name') + for ex in existing: + if ex[0][0] == name: + ex[0][1] = node.get('start') + +def parse_instruction(ins): + common = { + 'srcs': [], + 'modifiers': [], + 'immediates': [], + 'swaps': [], + 'derived': [], + 'staging': ins.attrib.get('staging', '') + } + + if 'exact' in ins.attrib: + common['exact'] = parse_exact(ins) + + for src in ins.findall('src'): + mask = int(src.attrib['mask'], 0) if ('mask' in src.attrib) else 0xFF + common['srcs'].append([int(src.attrib['start'], 0), mask]) + + for imm in ins.findall('immediate'): + common['immediates'].append([imm.attrib['name'], int(imm.attrib['start']), int(imm.attrib['size'])]) + + common['derived'] = parse_derived(ins) + common['modifiers'] = parse_modifiers(ins) + + for swap in ins.findall('swap'): + lr = [int(swap.get('left')), int(swap.get('right'))] + cond = parse_cond(swap.findall('*')[0]) + rewrites = {} + + for rw in swap.findall('rewrite'): + mp = {} + + for m in rw.findall('map'): + mp[m.attrib['from']] = m.attrib['to'] + + rewrites[rw.attrib['name']] = mp + + common['swaps'].append([lr, cond, rewrites]) + + encodings = ins.findall('encoding') + variants = [] + + if len(encodings) == 0: + variants = [[None, common]] + else: + for enc in encodings: + variant = copy.deepcopy(common) + assert(len(variant['derived']) == 0) + + variant['exact'] = parse_exact(enc) + variant['derived'] = parse_derived(enc) + parse_copy(enc, variant['modifiers']) + + cond = parse_cond(enc.findall('*')[0]) + variants.append([cond, variant]) + + return variants + +def parse_instructions(xml): + final = {} + instructions = ET.parse(xml).getroot().findall('ins') + + for ins in instructions: + final[ins.attrib['name']] = parse_instruction(ins) + + return final + +# Expand out an opcode name to something C-escaped + +def opname_to_c(name): + return name.lower().replace('*', 'fma_').replace('+', 'add_').replace('.', '_') + +# Expand out distinct states to distrinct instructions, with a placeholder +# condition for instructions with a single state + +def expand_states(instructions): + out = {} + + for ins in instructions: + c = instructions[ins] + + for ((test, desc), i) in zip(c, range(len(c))): + # Construct a name for the state + name = ins + (('.' + str(i)) if len(c) > 1 else '') + + out[name] = (ins, test if test is not None else [], desc) + + return out