Edit
IABSD.fr/xenocara/lib/mesa/src/compiler/isaspec/encode.py
jsg
- lib/mesa/src/compiler/isaspec/encode.py
-
#!/usr/bin/env python3 # # Copyright © 2020 Google, Inc. # # 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. from mako.template import Template from isa import ISA, BitSetDerivedField, BitSetAssertField import argparse import sys import re # Encoding is driven by the display template that would be used # to decode any given instruction, essentially working backwards # from the decode case. (Or put another way, the decoded bitset # should contain enough information to re-encode it again.) # # In the xml, we can have multiple override cases per bitset, # which can override display template and/or fields. Iterating # all this from within the template is messy, so use helpers # outside of the template for this. # # The hierarchy of iterators for encoding is: # # // First level - Case() (s.bitset_cases() iterator) # if (caseA.expression()) { // maps to <override/> in xml # // Second level - DisplayField() (case.display_fields() iterator) # ... encode field A ... # ... encode field B ... # # // Third level - each display field can be potentially resolved # // by multiple different overrides, you can end up with # // an if/else ladder for an individual display field # if (field_c_case1.expression()) { # ... encode field C ... # } else if (field_c_case2.expression() { # ... encode field C ... # } else { # } # # } else if (caseB.expression())( # } else { // maps to the default case in bitset, ie. outside <override/> # } # Represents a concrete field, ie. a field can be overriden # by an override, so the exact choice to encode a given field # in a bitset may be conditional class FieldCase(object): def __init__(self, bitset, field, case): self.field = field self.expr = None if case.expr is not None: self.expr = bitset.isa.expressions[case.expr] def signed(self): if self.field.type in ['int', 'offset', 'branch']: return 'true' return 'false' class AssertField(object): def __init__(self, bitset, field, case): self.field = field self.expr = None if case.expr is not None: self.expr = bitset.isa.expressions[case.expr] def signed(self): return 'false' # Represents a field to be encoded: class DisplayField(object): def __init__(self, bitset, case, name): self.bitset = bitset # leaf bitset self.case = case self.name = name def fields(self, bitset=None): if bitset is None: bitset = self.bitset # resolving the various cases for encoding a given # field is similar to resolving the display template # string for case in bitset.cases: if case.expr is not None: expr = bitset.isa.expressions[case.expr] self.case.append_expr_fields(expr) if self.name in case.fields: field = case.fields[self.name] # For bitset fields, the bitset type could reference # fields in this (the containing) bitset, in addition # to the ones which are directly used to encode the # field itself. if field.get_c_typename() == 'TYPE_BITSET': for param in field.params: self.case.append_field(param[0]) # For derived fields, we want to consider any other # fields that are referenced by the expr if isinstance(field, BitSetDerivedField): expr = bitset.isa.expressions[field.expr] self.case.append_expr_fields(expr) elif not isinstance(field, BitSetAssertField): yield FieldCase(bitset, field, case) # if we've found an unconditional case specifying # the named field, we are done if case.expr is None: return if bitset.extends is not None: yield from self.fields(bitset.isa.bitsets[bitset.extends]) # Represents an if/else case in bitset encoding which has a display # template string: class Case(object): def __init__(self, bitset, case): self.bitset = bitset # leaf bitset self.case = case self.expr = None if case.expr is not None: self.expr = bitset.isa.expressions[case.expr] self.fieldnames = re.findall(r"{([a-zA-Z0-9_:=]+)}", case.display) self.append_forced(bitset) # remove special fieldname properties e.g. :align= self.fieldnames = list(map(lambda name: name.split(':')[0], self.fieldnames)) # Handle fields which don't appear in display template but have # force="true" def append_forced(self, bitset): if bitset.encode is not None: for name, val in bitset.encode.forced.items(): self.append_field(name) if bitset.extends is not None: self.append_forced(bitset.isa.bitsets[bitset.extends]) # In the process of resolving a field, we might discover additional # fields that need resolving: # # a) a derived field which maps to one or more other concrete fields # b) a bitset field, which may be "parameterized".. for example a # #multisrc field which refers back to SRC1_R/SRC2_R outside of # the range of bits covered by the #multisrc field itself def append_field(self, fieldname): if fieldname not in self.fieldnames: self.fieldnames.append(fieldname) def append_expr_fields(self, expr): for fieldname in expr.fieldnames: self.append_field(fieldname) def display_fields(self): for fieldname in self.fieldnames: yield DisplayField(self.bitset, self, fieldname) def assert_cases(self, bitset=None): if bitset is None: bitset = self.bitset for case in bitset.cases: for name, field in case.fields.items(): if field.get_c_typename() == 'TYPE_ASSERT': yield AssertField(bitset, field, case) if bitset.extends is not None: yield from self.assert_cases(bitset.isa.bitsets[bitset.extends]) # State and helpers used by the template: class State(object): def __init__(self, isa): self.isa = isa self.warned_missing_extractors = [] def bitset_cases(self, bitset, leaf_bitset=None): if leaf_bitset is None: leaf_bitset = bitset for case in bitset.cases: if case.display is None: # if this is the last case (ie. case.expr is None) # then we need to go up the inheritance chain: if case.expr is None and bitset.extends is not None: parent_bitset = bitset.isa.bitsets[bitset.extends] yield from self.bitset_cases(parent_bitset, leaf_bitset) continue yield Case(leaf_bitset, case) # Find unique bitset remap/parameter names, to generate a struct # used to pass "parameters" to bitset fields: def unique_param_names(self): unique_names = [] for root in self.encode_roots(): for leaf in self.encode_leafs(root): for case in self.bitset_cases(leaf): for df in case.display_fields(): for f in df.fields(): if f.field.get_c_typename() == 'TYPE_BITSET': for param in f.field.params: target_name = param[1] if target_name not in unique_names: yield target_name unique_names.append(target_name) def case_name(self, bitset, name): return bitset.encode.case_prefix + name.upper().replace('.', '_').replace('-', '_').replace('#', '') def encode_roots(self): for name, root in self.isa.roots.items(): if root.encode is None: continue yield root def encode_leafs(self, root): for name, leafs in self.isa.leafs.items(): for leaf in leafs: if leaf.get_root() != root: continue yield leaf def encode_leaf_groups(self, root): for name, leafs in self.isa.leafs.items(): if leafs[0].get_root() != root: continue yield leafs # expressions used in a bitset (case or field or recursively parent bitsets) def bitset_used_exprs(self, bitset): for case in bitset.cases: if case.expr: yield self.isa.expressions[case.expr] for name, field in case.fields.items(): if isinstance(field, BitSetDerivedField): yield self.isa.expressions[field.expr] if bitset.extends is not None: yield from self.bitset_used_exprs(self.isa.bitsets[bitset.extends]) def extractor_impl(self, bitset, name): if bitset.encode is not None: if name in bitset.encode.maps: return bitset.encode.maps[name] if bitset.extends is not None: return self.extractor_impl(self.isa.bitsets[bitset.extends], name) return None # Default fallback when no mapping is defined, simply to avoid # having to deal with encoding at the same time as r/e new # instruction decoding.. but we can at least print warnings: def extractor_fallback(self, bitset, name): extr_name = bitset.name + '.' + name if extr_name not in self.warned_missing_extractors: print('WARNING: no encode mapping for {}.{}'.format(bitset.name, name)) self.warned_missing_extractors.append(extr_name) return '0 /* XXX */' def extractor(self, bitset, name): extr = self.extractor_impl(bitset, name) if extr is not None: return extr return self.extractor_fallback(bitset, name) # In the special case of needing to access a field with bitset type # for an expr, we need to encode the field so we end up with an # integer, and not some pointer to a thing that will be encoded to # an integer def expr_extractor(self, bitset, name, p): extr = self.extractor_impl(bitset, name) field = self.resolve_simple_field(bitset, name) if isinstance(field, BitSetDerivedField): expr = self.isa.expressions[field.expr] return self.expr_name(bitset.get_root(), expr) + '(s, p, src)' if extr is None: if name in self.unique_param_names(): extr = 'p->' + name else: extr = self.extractor_fallback(bitset, name) if field and field.get_c_typename() == 'TYPE_BITSET': extr = 'encode' + self.isa.roots[field.type].get_c_name() + '(s, ' + p + ', ' + extr + ')' return extr # A limited resolver for field type which doesn't properly account for # overrides. In particular, if a field is defined differently in multiple # different cases, this just blindly picks the last one. # # TODO to do this properly, I don't think there is an alternative than # to emit code which evaluates the case.expr def resolve_simple_field(self, bitset, name): field = None for case in bitset.cases: if name in case.fields: field = case.fields[name] if field is not None: return field if bitset.extends is not None: return self.resolve_simple_field(bitset.isa.bitsets[bitset.extends], name) return None def encode_type(self, bitset): if bitset.encode is not None: if bitset.encode.type is not None: return bitset.encode.type if bitset.extends is not None: return self.encode_type(bitset.isa.bitsets[bitset.extends]) return None def expr_name(self, root, expr): return root.get_c_name() + '_' + expr.get_c_name() template = """\ /* Copyright (C) 2020 Google, Inc. * * 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. */ #include <assert.h> #include <stdbool.h> #include <stdint.h> #include <util/bitset.h> #include <util/log.h> <% isa = s.isa %> #define BITMASK_WORDS BITSET_WORDS(${isa.bitsize}) typedef struct { BITSET_WORD bitset[BITMASK_WORDS]; } bitmask_t; static inline uint64_t bitmask_to_uint64_t(bitmask_t mask) { % if isa.bitsize <= 32: return mask.bitset[0]; % else: return ((uint64_t)mask.bitset[1] << 32) | mask.bitset[0]; % endif } static inline bitmask_t uint64_t_to_bitmask(uint64_t val) { bitmask_t mask = { .bitset[0] = val & 0xffffffff, % if isa.bitsize > 32: .bitset[1] = (val >> 32) & 0xffffffff, % endif }; return mask; } static inline void store_instruction(BITSET_WORD *dst, bitmask_t instr) { % for i in range(0, int(isa.bitsize / 32)): *(dst + ${i}) = instr.bitset[${i}]; % endfor } /** * Opaque type from the PoV of generated code, but allows state to be passed * thru to the hand written helpers used by the generated code. */ struct encode_state; /** * Allows to use gpu_id in expr functions */ #define ISA_GPU_ID() s->gen struct bitset_params; static bitmask_t pack_field(unsigned low, unsigned high, int64_t val, bool is_signed) { bitmask_t field, mask; if (is_signed) { /* NOTE: Don't assume val is already sign-extended to 64b, * just check that the bits above the valid range are either * all zero or all one: */ assert(!(( val & ~BITFIELD64_MASK(1 + high - low)) && (~val & ~BITFIELD64_MASK(1 + high - low)))); } else { assert(!(val & ~BITFIELD64_MASK(1 + high - low))); } BITSET_ZERO(field.bitset); if (!val) return field; BITSET_ZERO(mask.bitset); BITSET_SET_RANGE(mask.bitset, 0, high - low); field = uint64_t_to_bitmask(val); BITSET_AND(field.bitset, field.bitset, mask.bitset); BITSET_SHL(field.bitset, low); return field; } /* * Forward-declarations (so we don't have to figure out which order to * emit various encoders when they have reference each other) */ %for root in s.encode_roots(): static bitmask_t encode${root.get_c_name()}(struct encode_state *s, const struct bitset_params *p, const ${root.encode.type} src); %endfor ## TODO before the expr evaluators, we should generate extract_FOO() for ## derived fields.. which probably also need to be in the context of the ## respective root so they take the correct src arg?? /* * Expression evaluators: */ struct bitset_params { %for name in s.unique_param_names(): int64_t ${name}; %endfor }; ## TODO can we share this def between the two templates somehow? <%def name="encode_params(leaf, field)"> struct bitset_params bp = { %for param in field.params: .${param[1]} = ${s.expr_extractor(leaf, param[0], 'p')}, /* ${param[0]} */ %endfor }; </%def> <%def name="render_expr(leaf, expr)"> static inline int64_t ${s.expr_name(leaf.get_root(), expr)}(struct encode_state *s, const struct bitset_params *p, const ${leaf.get_root().encode.type} src) { % for fieldname in expr.fieldnames: int64_t ${fieldname}; % endfor % for fieldname in expr.fieldnames: <% field = s.resolve_simple_field(leaf, fieldname) %> % if field is not None and field.get_c_typename() == 'TYPE_BITSET': { ${encode_params(leaf, field)} const bitmask_t tmp = ${s.expr_extractor(leaf, fieldname, '&bp')}; ${fieldname} = bitmask_to_uint64_t(tmp); } % else: ${fieldname} = ${s.expr_extractor(leaf, fieldname, 'p')}; % endif % endfor return ${expr.expr}; } </%def> ## note, we can't just iterate all the expressions, but we need to find ## the context in which they are used to know the correct src type %for root in s.encode_roots(): % for leaf in s.encode_leafs(root): % for expr in s.bitset_used_exprs(leaf): static inline int64_t ${s.expr_name(leaf.get_root(), expr)}(struct encode_state *s, const struct bitset_params *p, const ${leaf.get_root().encode.type} src); % endfor % endfor %endfor %for root in s.encode_roots(): <% rendered_exprs = [] %> % for leaf in s.encode_leafs(root): % for expr in s.bitset_used_exprs(leaf): <% if expr in rendered_exprs: continue rendered_exprs.append(expr) %> ${render_expr(leaf, expr)} % endfor % endfor %endfor /* * The actual encoder definitions */ %for root in s.encode_roots(): % for leaf in s.encode_leafs(root): <% snippet = encode_bitset.render(s=s, root=root, leaf=leaf) %> % if snippet not in root.snippets.keys(): <% snippet_name = "snippet" + root.get_c_name() + "_" + str(len(root.snippets)) %> static bitmask_t ${snippet_name}(struct encode_state *s, const struct bitset_params *p, const ${root.encode.type} src) { bitmask_t val = uint64_t_to_bitmask(0); ${snippet} return val; } <% root.snippets[snippet] = snippet_name %> % endif % endfor static bitmask_t encode${root.get_c_name()}(struct encode_state *s, const struct bitset_params *p, const ${root.encode.type} src) { % if root.encode.case_prefix is not None: switch (${root.get_c_name()}_case(s, src)) { % for leafs in s.encode_leaf_groups(root): case ${s.case_name(root, leafs[0].name)}: { % for leaf in leafs: % if leaf.has_gen_restriction(): if (s->gen >= ${leaf.gen_min} && s->gen <= ${leaf.gen_max}) { % endif <% snippet = encode_bitset.render(s=s, root=root, leaf=leaf) %> <% words = isa.split_bits((leaf.get_pattern().match), 64) %> bitmask_t val = uint64_t_to_bitmask(${words[-1]}); <% words.pop() %> % for x in reversed(range(len(words))): { bitmask_t word = uint64_t_to_bitmask(${words[x]}); BITSET_SHL(val.bitset, 64); BITSET_OR(val.bitset, val.bitset, word.bitset); } % endfor BITSET_OR(val.bitset, val.bitset, ${root.snippets[snippet]}(s, p, src).bitset); return val; % if leaf.has_gen_restriction(): } % endif % endfor % if leaf.has_gen_restriction(): break; % endif } % endfor default: /* Note that we need the default case, because there are * instructions which we never expect to be encoded, (ie. * meta/macro instructions) as they are removed/replace * in earlier stages of the compiler. */ break; } mesa_loge("Unhandled ${root.name} encode case: 0x%x\\n", ${root.get_c_name()}_case(s, src)); return uint64_t_to_bitmask(0); % else: # single case bitset, no switch % for leaf in s.encode_leafs(root): <% snippet = encode_bitset.render(s=s, root=root, leaf=leaf) %> bitmask_t val = uint64_t_to_bitmask(${hex(leaf.get_pattern().match)}); BITSET_OR(val.bitset, val.bitset, ${root.snippets[snippet]}(s, p, src).bitset); return val; % endfor % endif } %endfor """ encode_bitset_template = """ <% isa = s.isa %> <%def name="case_pre(root, expr)"> %if expr is not None: if (${s.expr_name(root, expr)}(s, p, src)) { %else: { %endif </%def> <%def name="case_post(root, expr)"> %if expr is not None: } else %else: } %endif </%def> <%def name="encode_params(leaf, field)"> struct bitset_params bp = { %for param in field.params: .${param[1]} = ${s.expr_extractor(leaf, param[0], 'p')}, /* ${param[0]} */ %endfor }; </%def> uint64_t fld; (void)fld; <% visited_exprs = [] %> %for case in s.bitset_cases(leaf): <% if case.expr is not None: visited_exprs.append(case.expr) # per-expression-case track display-field-names that we have # already emitted encoding for. It is possible that an # <override> case overrides a given field (for ex. #cat5-src3) # and we don't want to emit encoding for both the override and # the fallback seen_fields = {} %> ${case_pre(root, case.expr)} % for df in case.display_fields(): % for f in df.fields(): <% # simplify the control flow a bit to give the compiler a bit # less to clean up expr = f.expr if expr == case.expr: # Don't need to evaluate the same condition twice: expr = None elif expr in visited_exprs: # We are in an 'else'/'else-if' leg that we wouldn't # go down due to passing an earlier if() continue if not expr in seen_fields.keys(): seen_fields[expr] = [] if f.field.name in seen_fields[expr]: continue seen_fields[expr].append(f.field.name) %> ${case_pre(root, expr)} % if f.field.get_c_typename() == 'TYPE_BITSET': { ${encode_params(leaf, f.field)} bitmask_t tmp = encode${isa.roots[f.field.type].get_c_name()}(s, &bp, ${s.extractor(leaf, f.field.name)}); fld = bitmask_to_uint64_t(tmp); } % else: fld = ${s.extractor(leaf, f.field.name)}; % endif const bitmask_t packed = pack_field(${f.field.low}, ${f.field.high}, fld, ${f.signed()}); /* ${f.field.name} */ BITSET_OR(val.bitset, val.bitset, packed.bitset); ${case_post(root, expr)} % endfor % endfor % for f in case.assert_cases(): <% # simplify the control flow a bit to give the compiler a bit # less to clean up expr = f.expr if expr == case.expr: # Don't need to evaluate the same condition twice: expr = None elif expr in visited_exprs: # We are in an 'else'/'else-if' leg that we wouldn't # go down due to passing an earlier if() continue %> ${case_pre(root, expr)} const bitmask_t packed = pack_field(${f.field.low}, ${f.field.high}, ${f.field.val}, ${f.signed()}); BITSET_OR(val.bitset, val.bitset, packed.bitset); ${case_post(root, None)} % endfor {} /* in case no unconditional field to close out last '} else' */ ${case_post(root, case.expr)} %endfor """ def main(): parser = argparse.ArgumentParser() parser.add_argument('--xml', required=True, help='isaspec XML file.') parser.add_argument('--out-h', required=True, help='Output H file.') args = parser.parse_args() isa = ISA(args.xml) s = State(isa) try: with open(args.out_h, 'w', encoding='utf-8') as f: encode_bitset = Template(encode_bitset_template) f.write(Template(template).render(s=s, encode_bitset=encode_bitset)) except Exception: # In the event there's an error, this imports some helpers from mako # to print a useful stack trace and prints it, then exits with # status 1, if python is run with debug; otherwise it just raises # the exception import sys from mako import exceptions print(exceptions.text_error_template().render(), file=sys.stderr) sys.exit(1) if __name__ == '__main__': main()